@memoarchitect/tools 0.13.0 → 0.15.0

package/packages/tools/lib/model/builder.js

@@ -1,2103 +0,0 @@
-// ─── Model Builder ────────────────────────────────────────────────────────────
-//
-// Walks Langium AST documents and produces a serializable MemoModel.
-// Maps SysML usages → MemoElements and ConnectionUsages → MemoRelationships.
-//
-// Key design decisions:
-//   - usage.type (e.g. "Hazard") is matched against config.kinds for layer info
-//   - ConnectionUsage.type (e.g. "Mitigates") → lowercase → matches config.relationshipTypes
-//   - PackageRegistry tracks cross-file packages and resolves imports
-//   - Connections are deferred until all elements are extracted (two-pass)
-//   - Doc comments are extracted from usage bodies
-//
-// Dual-mode resolution (M41):
-//   - If KindRegistry is provided, it takes precedence over config.kinds
-//   - If RelationshipRegistry is provided, it takes precedence for relationship validation
-//   - Falls back to config when registries are not provided or entry not found
-//   - Backward compatible: existing callers pass no registries, behavior unchanged
-//
-// Phase 5 additions:
-//   - ActionDefinition bodies extract parameters (in/out/inout)
-//   - ActionUsage supports composite actions with nested actions
-//   - FlowConnectionUsage → MemoRelationship of type "flow" with flowItem
-//   - SuccessionUsage → MemoRelationship pairs of type "succession"
-//   - ItemDefinition → MemoElement with construct "item"
-//
-// Language-native trace relations:
-//   - AllocateUsage              → MemoRelationship "allocatedTo"
-//   - SatisfyRequirementUsage    → MemoRelationship "satisfiedBy"
-//   - RequirementVerificationMember → MemoRelationship "verifiedBy"
-//   Each is the SAME edge the corresponding MEMO `connection def` produces —
-//   see LANGUAGE_NATIVE_RELATIONS. A model may use either spelling and the
-//   graph is identical, which is what makes the migration off the private
-//   connection defs reversible one file at a time.
-// ─────────────────────────────────────────────────────────────────────────────
-import { createHash } from 'node:crypto';
-import { AstUtils } from 'langium';
-import { isRequirementVerificationMember, isSatisfyRequirementUsage, isPerformActionUsage, isIncludeUseCaseUsage, isExhibitStateUsage, isFramedConcernMember, isSubjectMember, isDependency, isVariantMember, isActorMember, } from '../language/generated/ast.js';
-// Where an element sits comes from where it was AUTHORED, not from a literal
-// chosen here. See `authoredLayer` below.
-import { resolveLayerFromPath } from './layer-resolver.js';
-import { PackageRegistry } from './package-registry.js';
-import { assignSequentialShortIds, kindToPrefix } from './short-id.js';
-import { identityKey, priorShortIds } from './identity-registry.js';
-import { LANGUAGE_NATIVE_RELATIONS, REFINEMENT_METADATA, pascalToCamelCase } from './relationship-registry.js';
-import { indexKinds, kindConformsTo } from './relationship-legality.js';
-import { CONTROL_KIND_METACLASS } from './activity-notation.js';
-import { toModelType } from './naming.js';
-let relationshipCounter = 0;
-/**
- * Resolve a kind definition using registry-first, config-fallback strategy.
- * Returns the KindDefinition and the resolved kind name.
- */
-function resolveKindDef(typeName, config, registries) {
-    // Try registry first
-    if (registries?.kindRegistry) {
-        const entry = registries.kindRegistry.getKind(typeName);
-        if (entry) {
-            return {
-                kindDef: { label: entry.label, layer: entry.layer, sysmlConstruct: entry.sysmlConstruct },
-                resolvedKind: typeName,
-            };
-        }
-        // Try local part of qualified name
-        if (typeName.includes('::')) {
-            const localType = typeName.split('::').pop();
-            const localEntry = registries.kindRegistry.getKind(localType);
-            if (localEntry) {
-                return {
-                    kindDef: { label: localEntry.label, layer: localEntry.layer, sysmlConstruct: localEntry.sysmlConstruct },
-                    resolvedKind: localType,
-                };
-            }
-        }
-    }
-    // There is no config fallback. Kinds come from the ontology the project
-    // resolves; a YAML `kinds:` block used to be able to declare one, which
-    // meant a settings file could invent a type the ontology never defined.
-    const kinds = {};
-    const kindDef = kinds[typeName];
-    if (kindDef) {
-        return { kindDef, resolvedKind: typeName };
-    }
-    // Try local part of qualified name in config
-    if (typeName.includes('::')) {
-        const localType = typeName.split('::').pop();
-        if (kinds[localType]) {
-            return { kindDef: kinds[localType], resolvedKind: localType };
-        }
-    }
-    return { kindDef: undefined, resolvedKind: typeName };
-}
-/**
- * Build a MemoModel from parsed documents and config.
- * Optionally accepts registries for dual-mode resolution (registry-first, config-fallback).
- */
-export function buildMemoModel(documents, config, parseErrors = [], registries) {
-    relationshipCounter = 0;
-    const elements = new Map();
-    const relationships = [];
-    const errors = [...parseErrors];
-    const deferredConnections = [];
-    const deferredFlows = [];
-    const deferredSuccessions = [];
-    const deferredAllocates = [];
-    const deferredBindings = [];
-    // Phase 1: Build package registry from all documents
-    const registry = new PackageRegistry();
-    registry.buildFromDocuments(documents);
-    // Phase 2: Extract elements from all documents (populates registry)
-    for (const { document, filePath } of documents) {
-        const model = document.parseResult.value;
-        extractFromModel(model, filePath, config, elements, deferredConnections, deferredFlows, deferredSuccessions, deferredAllocates, deferredBindings, errors, registry, registries);
-    }
-    // Phase 3: Resolve connections using the registry (all elements now known)
-    const allElementIds = new Set(elements.keys());
-    for (const { conn, filePath, packageName } of deferredConnections) {
-        resolveConnection(conn, filePath, packageName, config, elements, relationships, registry, allElementIds);
-    }
-    // Phase 3b: Resolve flow connections
-    for (const { flow, filePath, packageName, parentActionId } of deferredFlows) {
-        resolveFlowConnection(flow, filePath, packageName, parentActionId, relationships, allElementIds, elements);
-    }
-    // Phase 3b2: Resolve port delegations
-    for (const { binding, filePath, packageName } of deferredBindings) {
-        resolveBinding(binding, filePath, packageName, relationships, allElementIds, elements);
-    }
-    // Phase 3c: Resolve successions
-    for (const { succession, filePath, packageName, parentActionId } of deferredSuccessions) {
-        resolveSuccession(succession, filePath, packageName, parentActionId, relationships, allElementIds);
-    }
-    // Phase 3d: Resolve allocations
-    for (const { allocate, filePath, packageName } of deferredAllocates) {
-        resolveAllocate(allocate, filePath, packageName, elements, relationships, registry, allElementIds, registries?.relationshipRegistry);
-    }
-    // Phase 3e: Resolve the native requirement relations. Unlike connections
-    // these are not package members — a `satisfy` sits in the body of the part
-    // that is the design context, and a `verify` in the body of the case that
-    // does the verifying — so they are found by walking containment rather than
-    // by the package-member switch, and their context comes from their owner.
-    for (const { document, filePath } of documents) {
-        resolveNativeTraceUsages(document.parseResult.value, filePath, relationships, registry, allElementIds);
-    }
-    // Phase 3f: Synthesize containment edges from native nesting. A natively
-    // nested part carries its parent in `owner` (set during extraction); MEMO's
-    // consumers read containment as a `composes` relationship (parent → child),
-    // so emit one per nesting. A model that nests natively then looks identical
-    // to one that wrote `Composes`, which is what lets R10-S7 delete the
-    // relationship without the containment vanishing. Ports carry `owner` too,
-    // so this covers part and item nesting. `state` joined them once nested
-    // StateUsage extraction existed to give it something to synthesize from —
-    // without a `composes` edge a composite state's substates were exposable
-    // (via `owner`) but never rendered nested, since the state-transition
-    // template builds its box-in-box layout from COMPOSITION_REL_TYPES, not
-    // from `owner` directly.
-    const CONTAINING_CONSTRUCTS = new Set(['part', 'item', 'state']);
-    for (const el of elements.values()) {
-        if (!CONTAINING_CONSTRUCTS.has(el.construct) || !el.owner)
-            continue;
-        const parent = elements.get(el.owner);
-        if (!parent || !CONTAINING_CONSTRUCTS.has(parent.construct))
-            continue;
-        relationships.push({
-            id: `rel-${++relationshipCounter}`,
-            type: 'composes',
-            sourceId: el.owner,
-            sourceEnd: 'parent',
-            targetId: el.id,
-            targetEnd: 'child',
-            file: el.file,
-            named: false,
-        });
-    }
-    // A nested action carries its parent in `parentAction` rather than
-    // `owner` (the two are set by separate extraction paths), and
-    // CR-ONT-065/066 already treat an action-typed end as a legitimate
-    // composes participant alongside parts — a functional decomposition
-    // (`action fnParent { action fnChild : SystemFunction { ... } }`) needs
-    // the same synthesis or a natively nested function tree loses the
-    // `composes` edges DSM and traceability consumers read, the exact
-    // silent-drop shape R10-S7 exists to close, not open. Every action
-    // usage nests some way — a flow step under its flow, a control node
-    // under its action — so this is not confined to decomposition the way
-    // the part path is; a nested action's owner IS its containing action
-    // for every shape the grammar produces, so there is no narrower
-    // predicate to gate this on without re-deriving one from AST shape
-    // that `parentAction` already erased.
-    for (const el of elements.values()) {
-        if (el.construct !== 'action' || !el.parentAction)
-            continue;
-        const parent = elements.get(el.parentAction);
-        if (!parent || parent.construct !== 'action')
-            continue;
-        relationships.push({
-            id: `rel-${++relationshipCounter}`,
-            type: 'composes',
-            sourceId: el.parentAction,
-            sourceEnd: 'parent',
-            targetId: el.id,
-            targetEnd: 'child',
-            file: el.file,
-            named: false,
-        });
-    }
-    // Keep ownership of a declaration separate from ownership of the type that
-    // classifies it.  A project usage of `Hazard` is editable project content;
-    // its classifier is a read-only ontology definition.
-    applySemanticProvenance(elements, relationships, registries);
-    // Build indexes
-    const elementsByKind = new Map();
-    const elementsByLayer = new Map();
-    for (const el of elements.values()) {
-        if (!elementsByKind.has(el.kind))
-            elementsByKind.set(el.kind, []);
-        elementsByKind.get(el.kind).push(el);
-        if (!elementsByLayer.has(el.layer))
-            elementsByLayer.set(el.layer, []);
-        elementsByLayer.get(el.layer).push(el);
-    }
-    // Assign each three-letter prefix one sequential display index. This is
-    // deliberately distinct from the technical UUID assigned below.
-    const elementsByPrefix = new Map();
-    for (const element of elements.values()) {
-        const prefix = kindToPrefix(element.kind);
-        const prefixElements = elementsByPrefix.get(prefix) ?? [];
-        prefixElements.push(element);
-        elementsByPrefix.set(prefix, prefixElements);
-    }
-    // Identities assigned on earlier builds win. Both of these are quoted
-    // outside the model, so recomputing them from current content — which is
-    // what happened before `memo.identity.yaml` — silently repointed every
-    // external reference whenever a file moved or an element was inserted.
-    const priorIdentities = config.priorIdentities ?? {};
-    const priorShortIdsByElement = priorShortIds(priorIdentities);
-    for (const [prefix, prefixElements] of elementsByPrefix) {
-        const idToShortId = assignSequentialShortIds(prefix, prefixElements.map(e => e.id), priorShortIdsByElement);
-        for (const el of prefixElements) {
-            el.shortId = idToShortId.get(el.id);
-            // `uuid` is part of the ontology's identification core, so a model
-            // may author it. An authored value wins: it is the whole point of
-            // writing one — the element keeps its identity across a file move
-            // or an id change, which the derived hash cannot survive.
-            // Precedence: an authored uuid, then the one this project already
-            // assigned, then a fresh derivation. The middle term is what makes a
-            // uuid survive a file move — the derivation hashes the file path, so
-            // without it the same element gets a new identity when it moves.
-            el.uuid = el.attributes.uuid?.trim()
-                || priorIdentities[identityKey(el)]?.uuid
-                || stableElementUuid(el);
-        }
-    }
-    // Phase 4: Validate relationship end types (warnings only).
-    // A kind conforms to an end type if it equals it or specializes it
-    // (transitively) — e.g. HardwareAssembly conforms to MemoPart.
-    if (registries?.relationshipRegistry) {
-        // Same resolver the authoring UI and the server persistence path use,
-        // so a link the panel offers is a link the builder accepts.
-        const kindIndex = indexKinds(registries.kindRegistry?.toDefinitionDTOs() ?? []);
-        // A project definition specializes an ontology kind, and the ontology
-        // registry has never heard of it: `AfferaStakeholder` is declared in
-        // this project, not in memo. So a chain like
-        // `AfferaHospitalEpLabStakeholder :> AfferaStakeholder :> MemoPart`
-        // broke at the first hop and fell through to guessing by name suffix,
-        // reporting a well-formed context diagram as malformed.
-        //
-        // A definition element records what it specializes in its own `kind`,
-        // so the model supplies the missing links. This is the same walk the
-        // explorer makes to file an element under its ontology kind.
-        const projectSuper = new Map();
-        for (const el of elements.values()) {
-            if (!el.isDefinition || !el.kind || el.kind === el.name)
-                continue;
-            if (!projectSuper.has(el.name))
-                projectSuper.set(el.name, el.kind);
-            if (el.id !== el.name && !projectSuper.has(el.id))
-                projectSuper.set(el.id, el.kind);
-        }
-        const conformsTo = (kind, expected) => {
-            let current = kind;
-            const seen = new Set();
-            while (current && !seen.has(current)) {
-                if (current === expected)
-                    return true;
-                if (kindConformsTo(current, expected, kindIndex))
-                    return true;
-                seen.add(current);
-                current = kindIndex.get(current)?.superType ?? projectSuper.get(current);
-            }
-            // Legacy fallback when neither the ontology nor the project knows
-            // this kind's hierarchy at all.
-            return !kindIndex.has(kind) && !projectSuper.has(kind) && kind.endsWith(expected);
-        };
-        for (const rel of relationships) {
-            const regEntry = registries.relationshipRegistry.getRelType(rel.type);
-            if (!regEntry || regEntry.ends.length === 0)
-                continue;
-            const sourceEl = elements.get(rel.sourceId);
-            const targetEl = elements.get(rel.targetId);
-            // Check if the source/target kinds match the typed ends
-            for (const end of regEntry.ends) {
-                if (!end.type)
-                    continue; // untyped ends allow any kind
-                // Match end to source or target by position (first end = source, second = target)
-                const endIndex = regEntry.ends.indexOf(end);
-                const el = endIndex === 0 ? sourceEl : targetEl;
-                if (!el)
-                    continue;
-                if (!conformsTo(el.kind, end.type)) {
-                    errors.push({
-                        message: `[well-formedness] Relationship "${rel.type}" expects ${end.name} to be ${end.type}, but found ${el.kind}`,
-                        file: rel.file ?? '',
-                    });
-                }
-            }
-        }
-    }
-    const relationshipsByType = new Map();
-    const outgoing = new Map();
-    const incoming = new Map();
-    for (const rel of relationships) {
-        if (!relationshipsByType.has(rel.type))
-            relationshipsByType.set(rel.type, []);
-        relationshipsByType.get(rel.type).push(rel);
-        if (!outgoing.has(rel.sourceId))
-            outgoing.set(rel.sourceId, []);
-        outgoing.get(rel.sourceId).push(rel);
-        if (!incoming.has(rel.targetId))
-            incoming.set(rel.targetId, []);
-        incoming.get(rel.targetId).push(rel);
-    }
-    // A local definition has already resolved its own ontology kind; usages
-    // typed by it inherit that kind, including through a local definition chain.
-    if (registries?.kindRegistry) {
-        const byName = new Map();
-        for (const [id, el] of elements) {
-            if (!byName.has(id))
-                byName.set(id, el);
-            if (el.name && !byName.has(el.name))
-                byName.set(el.name, el);
-        }
-        const known = (kind) => Boolean(registries.kindRegistry?.getKind(kind));
-        for (let pass = 0; pass < 16; pass++) {
-            let progressed = false;
-            for (const el of elements.values()) {
-                if (!el.kind || known(el.kind))
-                    continue;
-                const def = byName.get(el.kind.split('::').pop());
-                if (def && def !== el && def.kind && def.kind !== el.kind) {
-                    el.kind = def.kind;
-                    if (def.layer && (!el.layer || el.layer === 'unknown'))
-                        el.layer = def.layer;
-                    progressed = true;
-                }
-            }
-            if (!progressed)
-                break;
-        }
-    }
-    const unresolvedReferences = [];
-    const reachableCache = new Map();
-    const reachableNames = (packageName, seen = new Set()) => {
-        if (seen.has(packageName))
-            return new Set();
-        seen.add(packageName);
-        const pkg = registry.getPackage(packageName);
-        if (!pkg)
-            return new Set();
-        const names = new Set(pkg.elementIds);
-        for (const imported of pkg.imports) {
-            if (imported.isWildcard) {
-                for (const name of reachableNames(imported.packageName, seen))
-                    names.add(name);
-            }
-            else if (imported.namedImport)
-                names.add(imported.namedImport);
-        }
-        return names;
-    };
-    for (const [elementId, el] of elements) {
-        for (const [key, value] of Object.entries(el.attributes)) {
-            if (!key.endsWith('Type') || !value.includes('::'))
-                continue;
-            const parts = value.split('::');
-            const leaf = parts.pop().split('.')[0];
-            const packageName = parts.join('::');
-            if (!registry.getPackage(packageName))
-                continue;
-            const names = reachableCache.get(packageName) ?? reachableNames(packageName);
-            reachableCache.set(packageName, names);
-            if (!names.has(leaf)) {
-                unresolvedReferences.push({ elementId, elementName: el.name ?? elementId,
-                    elementKind: el.kind ?? 'Element', reference: value, packageName,
-                    missingName: leaf, file: el.file ?? '' });
-            }
-        }
-    }
-    return {
-        elements,
-        relationships,
-        errors,
-        packages: collectPackages(registry),
-        unresolvedReferences,
-        elementsByKind,
-        elementsByLayer,
-        relationshipsByType,
-        outgoing,
-        incoming,
-    };
-}
-/**
- * The declared packages, in the shape the model carries them.
- *
- * Read from the registry rather than from element membership so a package that
- * declares nothing is still reported: an explorer builds its containment tree
- * from this list, and a newly created package has no members yet by definition.
- */
-function collectPackages(registry) {
-    const packages = [];
-    for (const entry of registry.getPackages().values()) {
-        const separator = entry.qualifiedName.lastIndexOf('::');
-        packages.push({
-            qualifiedName: entry.qualifiedName,
-            name: separator === -1 ? entry.qualifiedName : entry.qualifiedName.slice(separator + 2),
-            ...(separator === -1 ? {} : { parent: entry.qualifiedName.slice(0, separator) }),
-            file: entry.file,
-        });
-    }
-    return packages.sort((a, b) => a.qualifiedName.localeCompare(b.qualifiedName));
-}
-function applySemanticProvenance(elements, relationships, registries) {
-    const table = registries?.provenance;
-    if (!table)
-        return;
-    const entryFor = (kind) => registries?.kindRegistry?.getKind(kind)
-        ?? registries?.kindRegistry?.getKind(kind.split('::').pop() ?? kind);
-    const classifierFor = (kind) => {
-        const entry = entryFor(kind);
-        if (!entry?.qualifiedName)
-            return undefined;
-        return {
-            qualifiedName: entry.qualifiedName,
-            shortName: entry.name,
-            provenance: entry.sourceFile ? table.lookup(entry.sourceFile) : undefined,
-        };
-    };
-    const classifierChainFor = (kind) => {
-        const chain = [];
-        const seen = new Set();
-        let entry = entryFor(kind);
-        while (entry?.qualifiedName && !seen.has(entry.qualifiedName)) {
-            seen.add(entry.qualifiedName);
-            chain.push({
-                qualifiedName: entry.qualifiedName,
-                shortName: entry.name,
-                provenance: entry.sourceFile ? table.lookup(entry.sourceFile) : undefined,
-            });
-            entry = entry.superType ? entryFor(entry.superType) : undefined;
-        }
-        return chain.length > 0 ? chain : undefined;
-    };
-    const declarationFor = (file, kind) => ({
-        declaration: table.lookupOrProject(file),
-        classifier: kind ? classifierFor(kind) : undefined,
-        classifierChain: kind ? classifierChainFor(kind) : undefined,
-    });
-    for (const element of elements.values()) {
-        element.provenance = declarationFor(element.file, element.kind);
-    }
-    for (const relationship of relationships) {
-        relationship.provenance = declarationFor(relationship.file, relationship.type);
-    }
-}
-/**
- * Derive a UUID from source identity, rather than allocating a random value on
- * every compilation. This is the machine identity; `shortId` is the compact
- * human-facing PREFIX-1, PREFIX-2, … label used in explorers.
- */
-function stableElementUuid(element) {
-    const bytes = createHash('sha256')
-        .update(`${element.file}\0${element.kind}\0${element.id}`)
-        .digest()
-        .subarray(0, 16);
-    bytes[6] = (bytes[6] & 0x0f) | 0x50; // UUID v5 shape
-    bytes[8] = (bytes[8] & 0x3f) | 0x80; // RFC 4122 variant
-    const hex = bytes.toString('hex');
-    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
-}
-// ─── AST Walking ────────────────────────────────────────────────────────────
-function extractFromModel(model, filePath, config, elements, deferredConnections, deferredFlows, deferredSuccessions, deferredAllocates, deferredBindings, errors, registry, registries) {
-    for (const member of model.members) {
-        if (member.$type === 'PackageDeclaration') {
-            extractFromPackage(member, filePath, '', config, elements, deferredConnections, deferredFlows, deferredSuccessions, deferredAllocates, deferredBindings, errors, registry, registries);
-        }
-    }
-}
-/**
- * Display label for a package rendered as a folder: an explicit `Matrix folder:`
- * line in the package's doc comment wins; otherwise the package name with a
- * `folder_` prefix stripped and underscores spaced.
- */
-function packageFolderDisplayName(pkg) {
-    const doc = extractDocComment(pkg.members);
-    if (doc) {
-        const match = doc.match(/Matrix folder:\s*(.+)/);
-        if (match)
-            return match[1].trim();
-    }
-    return pkg.name.replace(/^folder_/, '').replace(/_/g, ' ');
-}
-/** Tag a usage with the folder its owning package presents, so panels can group
- *  by nested SysML package folders. */
-function tagUsagePackageFolder(element, folderLabel) {
-    if (!element || !folderLabel)
-        return;
-    element.attributes['elementPackage'] = folderLabel;
-}
-function extractFromPackage(pkg, filePath, parentPackage, config, elements, deferredConnections, deferredFlows, deferredSuccessions, deferredAllocates, deferredBindings, errors, registry, registries) {
-    const packageName = parentPackage ? `${parentPackage}::${pkg.name}` : pkg.name;
-    // Only nested packages present as folders; a top-level package is the tree
-    // root, not a folder within it.
-    const folderLabel = parentPackage ? packageFolderDisplayName(pkg) : undefined;
-    for (const member of pkg.members) {
-        switch (member.$type) {
-            case 'PackageDeclaration':
-                extractFromPackage(member, filePath, packageName, config, elements, deferredConnections, deferredFlows, deferredSuccessions, deferredAllocates, deferredBindings, errors, registry, registries);
-                break;
-            case 'PartUsage':
-                extractUsage(member, 'part', filePath, packageName, config, elements, registry, registries);
-                tagUsagePackageFolder(elements.get(member.name), folderLabel);
-                break;
-            case 'RequirementUsage':
-                extractUsage(member, 'requirement', filePath, packageName, config, elements, registry, registries);
-                tagUsagePackageFolder(elements.get(member.name), folderLabel);
-                break;
-            case 'ItemUsage':
-                extractUsage(member, 'item', filePath, packageName, config, elements, registry, registries);
-                tagUsagePackageFolder(elements.get(member.name), folderLabel);
-                break;
-            case 'UseCaseDeclaration': {
-                const useCase = member;
-                if (useCase.isDefinition) {
-                    extractDefinitionElement({ name: useCase.name, specialization: useCase.specialization, body: useCase.body ?? useCase.usageBody }, 'use case', filePath, packageName, config, elements, registry, registries);
-                }
-                else {
-                    extractUsage({ name: useCase.name, type: useCase.type, body: useCase.usageBody }, 'use case', filePath, packageName, config, elements, registry, registries);
-                }
-                break;
-            }
-            case 'VerificationUsage':
-                extractUsage(member, 'verification', filePath, packageName, config, elements, registry, registries);
-                tagUsagePackageFolder(elements.get(member.name), folderLabel);
-                break;
-            case 'StateUsage':
-                extractUsage(member, 'state', filePath, packageName, config, elements, registry, registries);
-                break;
-            case 'InterfaceUsage':
-                extractUsage(member, 'interface', filePath, packageName, config, elements, registry, registries);
-                break;
-            case 'ActionUsage':
-                extractActionUsage(member, filePath, packageName, config, elements, deferredFlows, deferredSuccessions, registry, registries);
-                break;
-            case 'PortUsage':
-                extractUsage(member, 'port', filePath, packageName, config, elements, registry, registries);
-                break;
-            case 'ViewUsage':
-                extractUsage(member, 'view', filePath, packageName, config, elements, registry, registries);
-                break;
-            case 'ViewpointUsage':
-                extractViewpointUsage(member, filePath, packageName, config, elements, registry, registries);
-                break;
-            case 'ConnectionUsage':
-                // Defer connection resolution until all elements are extracted
-                deferredConnections.push({
-                    conn: member,
-                    filePath,
-                    packageName,
-                });
-                break;
-            case 'BindingUsage':
-                // Port delegation. Deferred for the same reason as flows: both
-                // ends are dotted paths that only resolve once every nested
-                // port is an element.
-                deferredBindings.push({
-                    binding: member,
-                    filePath,
-                    packageName,
-                });
-                break;
-            case 'FlowConnectionUsage':
-                // A flow between two action usages declared side by side in a
-                // package has no enclosing action, so parentActionId is unset
-                // and the endpoints resolve against the package scope.
-                deferredFlows.push({
-                    flow: member,
-                    filePath,
-                    packageName,
-                });
-                break;
-            case 'MessageUsage':
-                // `Message : FlowUsage`: native messages deliberately lower
-                // through the same path as MEMO's flow-shaped compatibility
-                // vocabulary, so consumers retain one trace-edge spelling.
-                deferredFlows.push({
-                    flow: member,
-                    filePath,
-                    packageName,
-                });
-                break;
-            case 'SuccessionUsage':
-                deferredSuccessions.push({
-                    succession: member,
-                    filePath,
-                    packageName,
-                });
-                break;
-            case 'AllocateUsage':
-                deferredAllocates.push({
-                    allocate: member,
-                    filePath,
-                    packageName,
-                });
-                break;
-            // ─── Native declarations (plan §8) ──────────────────────────
-            //
-            // `actor u : User;`, `stakeholder s : Stakeholder;` and
-            // `concern c : Concern;` declare the same elements `part u : User;`
-            // declares — same id, same kind, same attributes, same doc. Only
-            // the metaclass differs, and the metaclass is what makes them
-            // legible to a conforming tool. Routing them through extractUsage
-            // is what keeps the migration in step 3 a spelling change rather
-            // than a content change.
-            case 'ActorMember':
-                extractUsage(member, 'actor', filePath, packageName, config, elements, registry, registries);
-                break;
-            case 'StakeholderMember':
-                extractUsage(member, 'stakeholder', filePath, packageName, config, elements, registry, registries);
-                break;
-            case 'ConcernUsage':
-                extractUsage(member, 'concern', filePath, packageName, config, elements, registry, registries);
-                break;
-            case 'TransitionUsage':
-                extractTransition(member, filePath, packageName, config, elements, registry, registries);
-                break;
-            // ─── Definition members ─────────────────────────────────────
-            case 'ActionDefinition':
-                extractActionDefinition(member, filePath, packageName, config, elements, deferredFlows, deferredSuccessions, registry, registries);
-                break;
-            case 'ItemDefinition':
-                extractItemDefinition(member, filePath, packageName, config, elements, registry, registries);
-                break;
-            case 'PartDefinition':
-            case 'PortDefinition':
-            case 'InterfaceDefinition':
-            case 'ConnectionDefinition':
-                extractDefinitionElement(member, DEFINITION_CONSTRUCTS[member.$type], filePath, packageName, config, elements, registry, registries);
-                extractDefinitionPorts(member, filePath, packageName, config, elements, registry, registries);
-                // A definition's body is composition: `part def Pump { part
-                // motor : Motor; }` is what a BDD draws and what an IBD looks
-                // inside. Nested usages become elements owned by the
-                // definition, exactly as they do under a part usage.
-                extractNestedParts(member, filePath, packageName, config, elements, registry, registries);
-                break;
-            case 'RequirementDefinition':
-            case 'VerificationDefinition':
-            case 'StateDefinition':
-            case 'AttributeDefinition':
-            case 'EnumDefinition':
-                extractDefinitionElement(member, DEFINITION_CONSTRUCTS[member.$type], filePath, packageName, config, elements, registry, registries);
-                break;
-            // A `view def` / `viewpoint def` stays out: those are presentation
-            // apparatus, read through the viewpoint tree rather than as model
-            // content.
-        }
-    }
-}
-function extractUsage(usage, construct, filePath, packageName, config, elements, registry, registries) {
-    const id = usage.name;
-    const typeName = usage.type; // e.g. "Hazard", "Requirement"
-    // Dual-mode resolution: registry first, then config fallback
-    const { kindDef: finalKindDef, resolvedKind } = typeName
-        ? resolveKindDef(typeName, config, registries)
-        : { kindDef: undefined, resolvedKind: 'Unknown' };
-    const attributes = extractAttributes(usage.body);
-    if (typeName)
-        attributes.usageType = typeName;
-    const doc = extractDocComment(usage.body);
-    // A view's `expose <path>;` members declare its element membership
-    // natively — SysML v2's own visibility mechanism, in place of the MEMO
-    // `IncludedIn` relationship. Collected as a comma-separated attribute so
-    // `resolveViewElementIds` in view-deriver.ts can resolve each path
-    // against the model the same way it resolves `selectionQuery.*`.
-    if (construct === 'view') {
-        const exposePaths = (usage.body || [])
-            .filter(member => member.$type === 'ExposeMember')
-            .map(member => member.path);
-        if (exposePaths.length > 0) {
-            attributes['expose'] = exposePaths.join(',');
-        }
-    }
-    // Nested part/reference members that are view METADATA, not containment:
-    // bindings (`part/ref viewpoint :> vp;`) and the `:>>` redefinition of an
-    // inherited feature whose body is attributes (`part :>> selectionQuery
-    // { ... }`). These are flattened onto the owner as plain / prefixed
-    // attributes so SysML-modelled views expose their viewpoint binding and
-    // selection-query metadata to consumers. A typed nested part is NOT metadata
-    // — it is real containment and is extracted as its own element below.
-    for (const member of usage.body || []) {
-        if (member.$type !== 'PartMember' && member.$type !== 'RefMember')
-            continue;
-        const pm = member;
-        if (pm.boundRef && pm.name) {
-            // Two shapes land here. `part/ref viewpointDefinition :> vp;` names
-            // the feature in `name` and the value in `boundRef`. The subsetting
-            // form for a multi-valued feature —
-            // `part/ref vpLogical :> viewpointDefinition = someViewpoint;` — puts
-            // the FEATURE in `boundRef` and the value in `subsetValue`, and its
-            // member name is arbitrary. Attribute it to the feature it subsets,
-            // or a view governed by three viewpoints would surface as three
-            // unrelated attributes nothing reads.
-            const key = pm.subsetValue ? pm.boundRef : pm.name;
-            const value = pm.subsetValue ?? pm.boundRef;
-            // A feature with multiplicity may be rebound more than once. Keep
-            // every binding as a comma-separated value so view conformance can
-            // model one view against several viewpoints without cloning it.
-            const previous = attributes[key];
-            attributes[key] = previous ? `${previous},${value}` : value;
-        }
-        else if (!pm.type && pm.body && pm.name) {
-            // R10-S3 guard: an UNTYPED nested part with an attribute body is
-            // view metadata — the `part :>> selectionQuery { ... }` (or the
-            // un-redefined `part selectionQuery { ... }`) that view derivation
-            // reads as `selectionQuery.*` attributes. It carries no kind, so it
-            // is not a contained element. Flatten it; a TYPED nested part
-            // (`part valve : Valve`) is real containment and is extracted below.
-            const nested = extractAttributes(pm.body);
-            for (const [k, v] of Object.entries(nested)) {
-                attributes[`${pm.name}.${k}`] = v;
-            }
-        }
-    }
-    // Human-readable name: prefer "attribute redefines name" over usage name
-    const displayName = attributes['name'] || attributes['title'] || id;
-    const element = {
-        id,
-        name: displayName,
-        kind: resolvedKind,
-        construct,
-        layer: finalKindDef?.layer || 'unknown',
-        file: filePath,
-        package: packageName || undefined,
-        attributes,
-        doc,
-    };
-    // Port-specific fields
-    if (construct === 'port') {
-        const portNode = usage;
-        const directedItems = (usage.body || [])
-            .filter(member => member.$type === 'ItemUsage' && !!member.direction)
-            .map(member => member);
-        const itemDirections = new Set(directedItems.map(item => item.direction));
-        element.portSpec = {
-            type: portNode.type,
-            direction: (portNode.direction ?? (itemDirections.size === 1 ? directedItems[0]?.direction : undefined)),
-            isConjugated: portNode.isConjugated ?? false,
-        };
-        element.parameters = directedItems
-            .map(feature => {
-            return {
-                name: feature.name,
-                direction: feature.direction,
-                type: feature.type || 'Item',
-            };
-        });
-    }
-    elements.set(id, element);
-    registry.registerElement(id, packageName);
-    // A port's body may declare further ports. Recurse only after the parent is
-    // in the map, so the child's `owner` points at an element that exists.
-    if (construct === 'port') {
-        extractDefinitionPorts(usage, filePath, packageName, config, elements, registry, registries);
-    }
-    // A part's body may nest further parts. SysML v2 expresses containment by
-    // nesting; MEMO historically expressed it with a `Composes` connection, and
-    // the two must yield the same model. Extract each nested part as its own
-    // element with `owner` set — exactly as a nested port is — only after the
-    // parent is in the map. buildMemoModel synthesizes the `composes` edge from
-    // the resulting `owner` chain.
-    //
-    // A part usage may also declare its OWN boundary ports directly in its
-    // body (`part x : T { in port p : DataPort; }`), distinct from a nested
-    // part's ports and from any ports the type `T` declares at the def level
-    // (that path is `extractDefinitionPorts` at package scope, line ~668).
-    // Without this, an inline-authored port silently has no element: it
-    // parses, every relationship endpoint referencing it resolves to a
-    // dangling id, and nothing downstream reports why.
-    // Items nest too — a standard contains its clauses — so the nested-usage
-    // walk runs for both. Ports stay part-only: an item has no boundary.
-    if (construct === 'part' || construct === 'item') {
-        extractNestedParts(usage, filePath, packageName, config, elements, registry, registries);
-    }
-    if (construct === 'part') {
-        extractDefinitionPorts(usage, filePath, packageName, config, elements, registry, registries);
-    }
-    // A native `transition` lives inside the state machine that owns it, which
-    // is where the language puts it and where MEMO's `part def Transition`
-    // never could. Extract it from the state usage's body so the two spellings
-    // yield the same element set.
-    //
-    // A native `state` nests the same way — `state infusing { state priming;
-    // state delivering; }` is how a composite state declares its substates —
-    // but nothing walked a state usage's body for further StateUsage members
-    // at all. It parsed, `extractUsage` above created the ONE element for the
-    // state doing the nesting, and every substate silently became nothing: no
-    // element, so `expose pumpModes::**` (which walks `owner` chains) found
-    // only the state machine itself, and every state-transition view of a
-    // composite state rendered as a single unexpanded box. This is the
-    // `extractNestedParts` recursion for state usages, inlined here rather
-    // than as its own function because the transition loop it joins already
-    // walks the same body: `extractUsage(..., 'state', ...)` on a nested state
-    // re-enters this same function, so a third level (priming inside infusing
-    // inside pumpModes) reaches this loop again on its own.
-    for (const member of usage.body || []) {
-        const m = member;
-        if (m.$type === 'TransitionUsage') {
-            extractTransition(m, filePath, packageName, config, elements, registry, registries);
-            const transitionEl = elements.get(m.name);
-            if (transitionEl)
-                transitionEl.owner = id;
-        }
-        else if (construct === 'state' && m.$type === 'StateUsage') {
-            extractUsage(m, 'state', filePath, packageName, config, elements, registry, registries);
-            const childEl = elements.get(m.name);
-            if (childEl)
-                childEl.owner = id;
-        }
-    }
-}
-/**
- * Extract a native `transition` as a MemoElement.
- *
- * MEMO models a transition as `part def Transition` with `sourceState` and
- * `targetState` as **Strings** (§13.3) — and in the shipped content those
- * strings hold display names ("Idle"), not element ids, so nothing can follow
- * them to the states they name. The native form's source and target are real
- * references, so they are resolved to element ids here.
- *
- * Both are still written into the attribute map under the same keys the part
- * def declares. That is deliberate: it keeps every existing consumer of
- * `sourceState` / `targetState` working while the two spellings coexist, and it
- * is what makes the eventual migration a change of value (display name →
- * element id) that a diff can show, rather than a change of shape that it
- * cannot.
- *
- * An anonymous transition (`transition initial then off;`) declares no element.
- * It is a control statement, not a named thing the model traces to.
- */
-function extractTransition(transition, filePath, packageName, config, elements, registry, registries) {
-    if (!transition.name)
-        return;
-    const attributes = {
-        ...extractAttributes(transition.body),
-        sourceState: transition.source,
-        targetState: transition.target,
-    };
-    if (transition.trigger)
-        attributes.trigger = transition.trigger;
-    if (transition.effect)
-        attributes.effectSummary = transition.effect;
-    const guard = renderGuardExpression(transition.guard);
-    if (guard !== undefined)
-        attributes.guardSummary = guard;
-    const { kindDef, resolvedKind } = transition.type
-        ? resolveKindDef(transition.type, config, registries)
-        : { kindDef: undefined, resolvedKind: 'Unknown' };
-    elements.set(transition.name, {
-        id: transition.name,
-        name: attributes.name || transition.name,
-        kind: resolvedKind,
-        construct: 'transition',
-        layer: kindDef?.layer || 'unknown',
-        file: filePath,
-        package: packageName || undefined,
-        attributes,
-        doc: extractDocComment(transition.body),
-    });
-    registry.registerElement(transition.name, packageName);
-}
-/**
- * Extract an ActionDefinition as a MemoElement with parameters.
- */
-function extractActionDefinition(actionDef, filePath, packageName, config, elements, deferredFlows, deferredSuccessions, registry, registries) {
-    const id = actionDef.name;
-    // Extract parameters from body
-    const parameters = [];
-    const bodyMembers = actionDef.body || [];
-    for (const member of bodyMembers) {
-        if (member.$type === 'ActionParameterMember' || (member.$type === 'ItemUsage' && member.direction)) {
-            const param = member;
-            parameters.push({
-                name: param.name,
-                direction: param.direction,
-                type: param.type || 'Item',
-            });
-        }
-    }
-    const attributes = extractAttributes(bodyMembers);
-    const doc = extractDocComment(bodyMembers);
-    const behaviorKind = actionDef.behaviorKind ?? 'action';
-    // `action def AcquireSensorData :> FunctionalAction` defines a
-    // FunctionalAction. Stamping it `ActionDefinition` named the SysML
-    // METACLASS as though it were a MEMO kind — the ontology declares no such
-    // kind, so every project action def landed in the explorer's "not in
-    // ontology" bucket, and a validator had to look it up by that literal.
-    // The metaclass is what `construct` and `isDefinition` say; the kind is
-    // what the definition specializes.
-    const superType = actionDef.specialization?.superType;
-    const resolved = superType ? resolveKindDef(superType, config, registries) : undefined;
-    const ontologyKind = resolved?.kindDef && resolved.kindDef.layer && resolved.kindDef.layer !== 'unknown'
-        ? resolved
-        : undefined;
-    const element = {
-        id,
-        name: id,
-        // Only where nothing resolves does the metaclass stand in, and there it
-        // is the truthful answer: this is a SysML ActionDefinition and nothing
-        // more is known about it.
-        kind: ontologyKind?.resolvedKind
-            ?? (behaviorKind === 'operator' ? 'OperatorDefinition'
-                : behaviorKind === 'function' ? 'FunctionDefinition' : 'ActionDefinition'),
-        construct: 'action',
-        isDefinition: true,
-        layer: ontologyKind?.kindDef?.layer ?? authoredLayer(filePath),
-        file: filePath,
-        package: packageName || undefined,
-        attributes: { ...attributes, behaviorKind },
-        doc,
-        parameters: parameters.length > 0 ? parameters : undefined,
-    };
-    elements.set(id, element);
-    registry.registerElement(id, packageName);
-    // Standard SysML activity bodies may contain action/control usages directly
-    // (not wrapped in an ActionUsage). Preserve those declarations so a valid
-    // activity diagram cannot collapse to its enclosing action alone.
-    // `previousStep` carries the member a `then` refers back to: in standard
-    // SysML a body member written `then action x ...` succeeds the step declared
-    // before it, with no `succession` usage naming either end.
-    let previousStep;
-    let terminateCount = 0;
-    for (const member of bodyMembers) {
-        let step;
-        if (member.$type === 'ActionUsage') {
-            extractActionUsage(member, filePath, packageName, config, elements, deferredFlows, deferredSuccessions, registry, registries, id);
-            step = member.name;
-        }
-        else if (member.$type === 'ControlNodeUsage') {
-            extractControlNode(member, filePath, packageName, elements, registry, id);
-            step = member.name;
-        }
-        else if (['AcceptActionUsage', 'SendActionUsage', 'DecisionNodeUsage', 'MergeNodeUsage', 'TerminateUsage'].includes(member.$type)) {
-            const node = member;
-            // A terminate node has no name to be given one by, and an id keyed
-            // on `elements.size` moves whenever anything else in the file does.
-            // Key it on the action that owns it instead, so a view can name it
-            // and a saved layout keeps pointing at the same node.
-            const fallback = node.$type === 'TerminateUsage'
-                ? `${id}__terminate${terminateCount++ === 0 ? '' : terminateCount}`
-                : `${node.$type}-${elements.size}`;
-            const nodeId = node.name ?? fallback;
-            step = nodeId;
-            extractStandardActivityNode(node, filePath, packageName, elements, registry, id, nodeId);
-        }
-        else if (member.$type === 'SuccessionUsage') {
-            deferredSuccessions.push({ succession: member, filePath, packageName, parentActionId: id });
-        }
-        if (step && member.followsPrevious && previousStep) {
-            deferredSuccessions.push({
-                succession: { steps: [{ ref: previousStep }, { ref: step }] },
-                filePath,
-                packageName,
-                parentActionId: id,
-            });
-        }
-        if (step)
-            previousStep = step;
-    }
-}
-function extractStandardActivityNode(node, filePath, packageName, elements, registry, parentActionId, id) {
-    const typeToKind = {
-        AcceptActionUsage: 'AcceptActionUsage', SendActionUsage: 'SendActionUsage',
-        DecisionNodeUsage: 'DecisionNodeUsage', MergeNodeUsage: 'MergeNodeUsage', TerminateUsage: 'ActivityFinalNodeUsage',
-    };
-    const parameters = node.$type === 'AcceptActionUsage' && node.payloadName
-        ? [{ name: node.payloadName, direction: 'out', type: node.payloadType ?? 'Item' }]
-        : undefined;
-    elements.set(id, {
-        id, name: node.name ?? node.$type, kind: typeToKind[node.$type] ?? node.$type,
-        construct: 'action', layer: authoredLayer(filePath), file: filePath, package: packageName || undefined,
-        attributes: { ...(node.payloadName ? { payloadName: node.payloadName } : {}), ...(node.payloadType ? { payloadType: node.payloadType } : {}) }, parentAction: parentActionId, parameters,
-    });
-    registry.registerElement(id, packageName);
-}
-/**
- * Extract an ItemDefinition as a MemoElement.
- */
-function extractItemDefinition(itemDef, filePath, packageName, config, elements, registry, registries) {
-    const id = itemDef.name;
-    const attributes = extractAttributes(itemDef.body);
-    const doc = extractDocComment(itemDef.body);
-    const typeName = itemDef.specialization?.superType;
-    const { kindDef, resolvedKind } = typeName
-        ? resolveKindDef(typeName, config, registries)
-        : { kindDef: undefined, resolvedKind: 'ItemDefinition' };
-    const element = {
-        id,
-        name: id,
-        kind: kindDef?.layer && kindDef.layer !== 'unknown' ? resolvedKind : 'ItemDefinition',
-        construct: 'item',
-        isDefinition: true,
-        layer: kindDef?.layer && kindDef.layer !== 'unknown' ? kindDef.layer : authoredLayer(filePath),
-        file: filePath,
-        package: packageName || undefined,
-        attributes,
-        doc,
-    };
-    elements.set(id, element);
-    registry.registerElement(id, packageName);
-}
-/**
- * Walk an owner's body to extract port usages as owned port elements.
- * Sets owner on ports and ownedPorts on the owner.
- *
- * The owner may be a definition (`part def Board { port p : DataPort; }`) or a
- * USAGE — including another port. SysML v2 nests ports inside ports, which is
- * how a panel cluster says "this one boundary feature carries these three
- * connectors". Without the usage case a model that nests natively simply loses
- * the children: they are declared, they resolve, and they never become
- * elements, so they vanish from every diagram and every count. The only
- * alternative spelling is a `Composes` connection from a port to a port, which
- * CR-ONT-065 forbids — a whole in a decomposition has to be a part, an action
- * or a state. So the native form was the only correct one, and it was the one
- * that did not work.
- */
-/**
- * The SysML construct each definition declares, in the spelling its usages
- * carry — a `part def` and a `part` are the same construct, one defining and
- * one using.
- */
-const DEFINITION_CONSTRUCTS = {
-    PartDefinition: 'part',
-    PortDefinition: 'port',
-    InterfaceDefinition: 'interface',
-    ConnectionDefinition: 'connection',
-    RequirementDefinition: 'requirement',
-    VerificationDefinition: 'verification',
-    StateDefinition: 'state',
-    AttributeDefinition: 'attribute',
-    EnumDefinition: 'enumeration',
-};
-/**
- * A definition the PROJECT declares, as a model element.
- *
- * `part def Pump :> LogicalComponent` defines a Pump. It was registered as a
- * kind and nothing else, so no view could select it and no BDD or IBD could
- * draw it — which is most of what a definition is for. It is an element now,
- * and its usages read beneath it: a usage's `kind` is the definition's name,
- * which is the link every explorer already follows.
- *
- * The kind it carries is the ONTOLOGY kind it specializes, so a view, a
- * viewpoint filter and a palette that admit `LogicalComponent` admit the
- * definition of one without being edited. `isDefinition` is what tells the two
- * apart afterwards — a definition is a type, not an instance of one, and
- * anything counting instances must say so.
- *
- * This is only ever project content: the ontology's own definitions are read
- * by the kind registry and are never parsed into the model.
- */
-function extractDefinitionElement(definition, construct, filePath, packageName, config, elements, registry, registries) {
-    const id = definition.name;
-    if (!id || elements.has(id))
-        return;
-    // A `library package` is how a project writes ontology-style content: its
-    // definitions are types for other models to use, not this model's content.
-    // The user's distinction exactly — model definitions become elements,
-    // library ones stay kinds, which is what they already were.
-    if (registry.isLibraryPackage(packageName))
-        return;
-    const superType = definition.specialization?.superType;
-    const { kindDef, resolvedKind } = superType
-        ? resolveKindDef(superType, config, registries)
-        : { kindDef: undefined, resolvedKind: undefined };
-    const attributes = extractAttributes(definition.body ?? []);
-    const doc = extractDocComment(definition.body ?? []);
-    elements.set(id, {
-        id,
-        name: attributes['name'] || attributes['title'] || id,
-        // A definition that specializes nothing the ontology knows is still a
-        // definition; it says so rather than borrowing a kind it has not got.
-        kind: resolvedKind ?? `${construct.charAt(0).toUpperCase()}${construct.slice(1)}Definition`,
-        construct,
-        layer: kindDef?.layer || 'unknown',
-        file: filePath,
-        package: packageName || undefined,
-        attributes,
-        doc,
-        isDefinition: true,
-    });
-    registry.registerElement(id, packageName);
-}
-function extractDefinitionPorts(def, filePath, packageName, config, elements, registry, registries) {
-    const ownerId = def.name;
-    const body = def.body || [];
-    const ownedPortIds = [];
-    for (const member of body) {
-        if (member.$type === 'PortUsage') {
-            const portUsage = member;
-            extractUsage(portUsage, 'port', filePath, packageName, config, elements, registry, registries);
-            const portEl = elements.get(portUsage.name);
-            if (portEl) {
-                portEl.owner = ownerId;
-                ownedPortIds.push(portUsage.name);
-            }
-        }
-    }
-    if (ownedPortIds.length > 0) {
-        const ownerEl = elements.get(ownerId);
-        if (ownerEl) {
-            ownerEl.ownedPorts = ownedPortIds;
-        }
-    }
-}
-/**
- * Walk a usage's body to extract nested parts AND items as owned elements,
- * setting `owner` on each child.
- *
- * `extractUsage` flattens the `PartMember` shapes that are view metadata — a
- * reference binding (`part viewpoint :> vp;`) and an untyped body
- * (`part :>> selectionQuery { ... }`). A TYPED nested part
- * (`part valve : Valve { ... }`) is real containment: without this it is
- * declared, resolves, and never becomes an element — the same silent drop
- * nested ports had before `extractDefinitionPorts` walked port usages. The
- * `composes` edge that makes containment legible to consumers is synthesized
- * from the `owner` chain in buildMemoModel.
- */
-function extractNestedParts(owner, filePath, packageName, config, elements, registry, registries) {
-    const ownerId = owner.name;
-    for (const member of owner.body || []) {
-        const pm = member;
-        const isPart = pm.$type === 'PartMember';
-        // A nested ITEM is containment too — `item iec62304 { item clause4 …}`
-        // is how every standard declares its clauses. Without this branch the
-        // child parses cleanly in both parsers and never becomes an element at
-        // all: not a missing edge, a missing element. That is the
-        // BindingUsage / ExposeMember / untyped-flow shape again.
-        //
-        // A DIRECTED item is excluded: `in item payload : BubbleSignal;` is a
-        // port's payload parameter, not something the port contains. The same
-        // `direction` test already separates the two at the action-parameter
-        // and flow sites.
-        const isItem = pm.$type === 'ItemUsage' && !pm.direction;
-        if (!isPart && !isItem)
-            continue;
-        // Only a TYPED nested usage is containment. Untyped bodies (view
-        // selectionQuery) and reference bindings are view metadata, flattened
-        // to attributes in extractUsage — skip them here or a view's metadata
-        // becomes a phantom element and its selection query is lost.
-        if (!pm.type || pm.boundRef || !pm.name)
-            continue;
-        extractUsage({ name: pm.name, type: pm.type, body: pm.body }, isPart ? 'part' : 'item', filePath, packageName, config, elements, registry, registries);
-        const childEl = elements.get(pm.name);
-        if (childEl)
-            childEl.owner = ownerId;
-    }
-    extractNestedPackages(owner, filePath, packageName, config, elements, registry, registries);
-}
-/**
- * A `package` nested inside a usage body — `part scrHome : UIElement { package
- * grpHeader { part btnBack : UIElement; } }`.
- *
- * A package GROUPS; it does not decompose. So the group becomes an element (the
- * explorer needs a node to render, and the user asked to create these to
- * organise a screen or a leaf of the model), but the things inside it stay
- * contained by the OWNER — putting them under the package would assert a part
- * decomposition the author did not write, and would make the containment
- * family rules see a package "containing" software.
- *
- * Without this the package and everything in it parses in both parsers and
- * never becomes an element: the BindingUsage / ExposeMember / nested-item shape
- * for the fourth time.
- */
-function extractNestedPackages(owner, filePath, packageName, config, elements, registry, registries) {
-    for (const member of owner.body || []) {
-        const pm = member;
-        if (pm.$type !== 'PackageDeclaration' || !pm.name)
-            continue;
-        elements.set(pm.name, {
-            id: pm.name,
-            name: pm.name,
-            kind: ELEMENT_PACKAGE_KIND,
-            construct: 'package',
-            layer: elements.get(owner.name)?.layer ?? 'unknown',
-            file: filePath,
-            package: packageName,
-            attributes: {},
-            owner: owner.name,
-        });
-        for (const grouped of pm.members ?? []) {
-            const gm = grouped;
-            // `part btnBack : UIElement;` parses as a PartMember and
-            // `part btnBack : UIElement { … }` as a PartUsage — the same
-            // declaration with and without a body. Accepting only the first
-            // dropped every grouped element that declares anything, which is
-            // most of them.
-            const isPart = gm.$type === 'PartMember' || gm.$type === 'PartUsage';
-            const isItem = gm.$type === 'ItemUsage' && !gm.direction;
-            if (!isPart && !isItem)
-                continue;
-            if (!gm.type || gm.boundRef || !gm.name)
-                continue;
-            extractUsage({ name: gm.name, type: gm.type, body: gm.body }, isPart ? 'part' : 'item', filePath, packageName, config, elements, registry, registries);
-            const childEl = elements.get(gm.name);
-            if (childEl) {
-                // Contained by the OWNER; the package only labels the grouping.
-                childEl.owner = owner.name;
-                childEl.attributes['elementPackage'] = pm.name;
-            }
-        }
-    }
-}
-/** The kind a nested grouping package becomes, distinct from a namespace package. */
-export const ELEMENT_PACKAGE_KIND = 'ElementPackage';
-/**
- * A `viewpoint` usage, and any viewpoint declared inside it.
- *
- * A viewpoint nests for system-of-systems modelling: the viewpoint that frames
- * the whole system of systems declares one viewpoint per constituent system,
- * which is how ISO 42010 composes a description of a description. Native SysML
- * already permits it (`ViewpointUsage` is a `UsageBodyMember`) and the grammar
- * already parsed it — nothing extracted it, so a nested viewpoint became no
- * element at all and every consumer saw one flat list.
- *
- * The nested viewpoint carries its parent in `owner`, the same way a nested
- * part does. Unlike a part, no `composes` edge is synthesized: a viewpoint is
- * not a `part` construct, and framing is not containment of hardware.
- */
-function extractViewpointUsage(usage, filePath, packageName, config, elements, registry, registries, ownerId) {
-    if (!usage.name)
-        return;
-    extractUsage({ name: usage.name, type: usage.type, body: usage.body }, 'viewpoint', filePath, packageName, config, elements, registry, registries);
-    const element = elements.get(usage.name);
-    if (element && ownerId)
-        element.owner = ownerId;
-    for (const member of usage.body || []) {
-        const nested = member;
-        if (nested.$type !== 'ViewpointUsage')
-            continue;
-        extractViewpointUsage(nested, filePath, packageName, config, elements, registry, registries, usage.name);
-    }
-}
-/**
- * The layer an element belongs to when its type resolves to no ontology kind.
- *
- * This used to be the literal `'behavior'`, in five places. It was invented
- * here — the ontology has no behavior layer, and nothing checked the string
- * against the vocabulary the ontology produces — and it was wrong about the
- * model besides: all 440 of one project's `ItemDefinition`s are authored under
- * `architecture/implementation/` and were reported as behavior regardless.
- *
- * MEMO keeps namespace and folder path aligned, so the directory an element is
- * authored in already states where it belongs, and `resolveLayerFromPath` is
- * the same derivation used for the ontology's own kinds. A file the convention
- * does not cover still yields `unknown`, which is the honest answer and is
- * reported as one downstream rather than dressed as a layer.
- */
-function authoredLayer(filePath) {
-    return resolveLayerFromPath(filePath);
-}
-/**
- * Extract an ActionUsage, including nested actions, flows, and successions.
- * Supports both typed (action name : Type;) and composite (action name { ... }) forms.
- */
-function extractActionUsage(usage, filePath, packageName, config, elements, deferredFlows, deferredSuccessions, registry, registries, parentActionId) {
-    const id = usage.name;
-    const typeName = usage.type;
-    // Dual-mode resolution: registry first, then config fallback. A type
-    // that resolves without a real layer is a model-local action def, not an
-    // ontology kind — the usage stays an ActionUsage on the behavior layer
-    // (the def reference is kept in the actionType attribute below).
-    const behaviorKind = usage.behaviorKind ?? 'action';
-    let kind = behaviorKind === 'operator' ? 'OperatorUsage'
-        : behaviorKind === 'function' ? 'FunctionUsage' : 'ActionUsage';
-    let layer = authoredLayer(filePath);
-    if (typeName) {
-        const { kindDef, resolvedKind } = resolveKindDef(typeName, config, registries);
-        if (kindDef && kindDef.layer && kindDef.layer !== 'unknown') {
-            kind = resolvedKind;
-            layer = kindDef.layer;
-        }
-    }
-    const bodyMembers = usage.body || [];
-    const attributes = extractAttributes(bodyMembers);
-    attributes['behaviorKind'] = behaviorKind;
-    const doc = extractDocComment(bodyMembers);
-    const displayName = attributes['name'] || attributes['title'] || id;
-    // SysML types a usage the same way whatever the usage is — `part p : Board`
-    // and `action a : CoordinateWorkflows` are one mechanism — so the type goes
-    // in `usageType`, the field every other usage already uses. Recording it
-    // only under `actionType` meant anything reading typing generically saw
-    // parts typed and actions untyped, and a BDD of the function hierarchy
-    // resolved none of its definitions.
-    //
-    // `actionType` stays for flow type checking, which reads it by name.
-    if (typeName) {
-        attributes['actionType'] = typeName;
-        attributes['usageType'] = typeName;
-    }
-    const element = {
-        id,
-        name: displayName,
-        kind,
-        construct: 'action',
-        layer,
-        file: filePath,
-        package: packageName || undefined,
-        attributes,
-        doc,
-        parentAction: parentActionId,
-        parameters: bodyMembers
-            .filter(member => member.$type === 'ActionParameterMember')
-            .map(member => ({ name: member.name, direction: member.direction, type: member.type || 'Item' })),
-    };
-    elements.set(id, element);
-    registry.registerElement(id, packageName);
-    // Walk body for nested behavior members
-    for (const member of bodyMembers) {
-        switch (member.$type) {
-            case 'ActionUsage':
-                // Nested action usage — recursive extraction
-                extractActionUsage(member, filePath, packageName, config, elements, deferredFlows, deferredSuccessions, registry, registries, id);
-                break;
-            case 'FlowConnectionUsage':
-                deferredFlows.push({
-                    flow: member,
-                    filePath,
-                    packageName,
-                    parentActionId: id,
-                });
-                break;
-            case 'SuccessionUsage':
-                deferredSuccessions.push({
-                    succession: member,
-                    filePath,
-                    packageName,
-                    parentActionId: id,
-                });
-                break;
-            case 'ControlNodeUsage':
-                extractControlNode(member, filePath, packageName, elements, registry, id);
-                break;
-        }
-    }
-}
-/**
- * Extract a control node. Modeled as a behavior-layer element with
- * `construct: 'action'` so it participates in succession ordering and swimlane
- * layout like any other flow step, but carries the metaclass its `controlKind`
- * names and a `controlKind` attribute, so renderers draw the right symbol —
- * a bar for fork/join, a diamond for decide/merge.
- *
- * The kind comes from `CONTROL_KIND_METACLASS`, the same binding
- * `activityNodeType` classifies by; a second mapping here is how `decide` and
- * `merge` came to be stored as `JoinNode`.
- */
-function extractControlNode(node, filePath, packageName, elements, registry, parentActionId) {
-    const id = node.name;
-    const kind = CONTROL_KIND_METACLASS[node.controlKind];
-    elements.set(id, {
-        id,
-        name: node.name,
-        kind,
-        construct: 'action',
-        layer: authoredLayer(filePath),
-        file: filePath,
-        package: packageName || undefined,
-        attributes: { controlKind: node.controlKind },
-        parentAction: parentActionId,
-    });
-    registry.registerElement(id, packageName);
-}
-function resolveConnection(conn, filePath, packageName, config, elements, relationships, registry, allElementIds) {
-    const typeName = conn.type; // e.g. "Mitigates", "TraceTo"
-    if (!conn.source || !conn.target)
-        return;
-    // An untyped connection (`connection connect a to b;`, no `: SomeDef`) is
-    // the native binary connection with nothing further classifying it — the
-    // keyword IS the type, `connect`, the same as `flow`/`bind` (R10-S6,
-    // `ConnectsPhysically`'s migration). Before this it built to nothing at
-    // all: the same silent-drop shape as `BindingUsage`/`ExposeMember`.
-    // A typed connection normalizes its definition name: "Mitigates" → "mitigates".
-    const normalizedType = typeName ? normalizeRelType(typeName) : 'connect';
-    // Resolve source and target using registry for cross-file resolution
-    const sourceId = resolveEndpointId(conn.source.ref, packageName, registry, allElementIds);
-    const targetId = resolveEndpointId(conn.target.ref, packageName, registry, allElementIds);
-    if (!sourceId || !targetId)
-        return;
-    // A named connection usage carries its own stable ID; anonymous ones fall
-    // back to a positional counter that shifts whenever the file changes.
-    // `extractAttributes` lifts metadata applications itself now, so the
-    // connection path no longer needs its own second pass.
-    const attributes = extractAttributes(conn.body);
-    const rel = {
-        id: conn.name || `rel-${++relationshipCounter}`,
-        type: normalizedType,
-        sourceId,
-        // `connect a to b` omits the end names; the ends are then the inherited
-        // `source`/`target` participants. csv-io already defaults the same way.
-        sourceEnd: conn.source.endName ?? 'source',
-        targetId,
-        targetEnd: conn.target.endName ?? 'target',
-        file: filePath,
-        sourceRange: conn.$cstNode
-            ? { offset: conn.$cstNode.offset, length: conn.$cstNode.length }
-            : undefined,
-        named: conn.name ? true : undefined,
-        attributes,
-        flowItem: attributes.transportedItem || attributes.flowItem || undefined,
-    };
-    // Tag port IDs when endpoints reference port elements
-    const sourceEl = elements.get(sourceId);
-    if (sourceEl?.construct === 'port') {
-        rel.sourcePortId = sourceId;
-    }
-    const targetEl = elements.get(targetId);
-    if (targetEl?.construct === 'port') {
-        rel.targetPortId = targetId;
-    }
-    relationships.push(rel);
-}
-/**
- * Resolve a dotted endpoint path to the deepest element it names.
- *
- * A dotted endpoint has two shapes and they resolve differently.
- *
- * `receive.prescription` names an action and one of its PARAMETERS. The
- * parameter is not an element, so the endpoint is the action and the parameter
- * is the end label.
- *
- * `touchscreen.touchUsbIo` names a port and a port NESTED inside it, and
- * `coffeeMachine.serviceInterface.diagnostics` nests one level deeper again.
- * The nested port IS an element in its own right, so the endpoint is the child.
- * Reading it the first way silently retargets the edge at the parent, which is
- * not a resolution failure anyone sees: it produces a plausible relationship
- * pointing at the wrong feature, and it only surfaces later as a payload
- * mismatch on whichever edge happened to carry a different item from its
- * parent's.
- *
- * Walk the path through the parent link and take the deepest real element.
- *
- * A nested part or port records its parent in `owner`; a nested ACTION records
- * it in `parentAction`, because the two are set by separate extraction paths.
- * Reading only `owner` broke the walk at the first hop of every function path:
- * `flow from fnDeliverTherapy.fnMeterFluid.fnMeasureDelivered to …` became a
- * self-loop on `fnDeliverTherapy`, which is a plausible-looking edge pointing
- * at the wrong function — the exact failure the comment above describes, one
- * field away from where it was fixed for ports.
- */
-function resolveEndpoint(ref, elements) {
-    const parts = ref.split('.');
-    let id = parts[0];
-    let i = 1;
-    while (i < parts.length) {
-        const child = elements.get(parts[i]);
-        if (!child || (child.owner !== id && child.parentAction !== id))
-            break;
-        id = parts[i];
-        i++;
-    }
-    return { id, end: parts.slice(i).join('.') };
-}
-/**
- * Resolve a `bind outer = inner;` port delegation into a MemoRelationship.
- *
- * Unlike a flow this carries no item: delegation is identity, so there is
- * nothing travelling and nothing to label the edge with. Consumers that render
- * an itemless edge already suppress the label.
- */
-function resolveBinding(binding, filePath, _packageName, relationships, allElementIds, elements) {
-    const sourceRef = binding.source;
-    const targetRef = binding.target;
-    if (!sourceRef || !targetRef)
-        return;
-    const { id: sourceId, end: sourceEnd } = resolveEndpoint(sourceRef, elements);
-    const { id: targetId, end: targetEnd } = resolveEndpoint(targetRef, elements);
-    if (!allElementIds.has(sourceId) || !allElementIds.has(targetId))
-        return;
-    relationships.push({
-        id: `rel-${++relationshipCounter}`,
-        type: 'bind',
-        sourceId,
-        sourceEnd,
-        targetId,
-        targetEnd,
-        file: filePath,
-    });
-}
-/**
- * Resolve a flow connection usage into a MemoRelationship.
- * Flow endpoints use dot notation: "actionName.paramName"
- */
-function resolveFlowConnection(flow, filePath, packageName, parentActionId, relationships, allElementIds, elements) {
-    const sourceRef = flow.source?.ref;
-    const targetRef = flow.target?.ref;
-    if (!sourceRef || !targetRef)
-        return;
-    const { id: sourceActionId, end: sourcePort } = resolveEndpoint(sourceRef, elements);
-    const { id: targetActionId, end: targetPort } = resolveEndpoint(targetRef, elements);
-    // Only create relationship if both endpoints reference known elements
-    if (!allElementIds.has(sourceActionId) || !allElementIds.has(targetActionId))
-        return;
-    // A NAMED flow carries a stable ID that survives rebuilds; an anonymous one
-    // falls back to a positional counter that shifts whenever the file changes.
-    // Same rule `resolveConnection` applies to connection usages, and the same
-    // reason: authoring needs to inspect, delete, and deep-link a flow, and a
-    // positional id makes every one of those wrong after the next edit.
-    const rel = {
-        id: flow.name || `rel-${++relationshipCounter}`,
-        type: 'flow',
-        sourceId: sourceActionId,
-        sourceEnd: sourcePort,
-        targetId: targetActionId,
-        targetEnd: targetPort,
-        file: filePath,
-        sourceRange: flow.$cstNode
-            ? { offset: flow.$cstNode.offset, length: flow.$cstNode.length }
-            : undefined,
-        named: flow.name ? true : undefined,
-        attributes: extractAttributes(flow.body),
-        flowItem: flow.itemType || undefined,
-    };
-    relationships.push(rel);
-}
-/**
- * Resolve a succession usage into pairs of MemoRelationships.
- * "first A then B" → (A→B).
- *
- * The grammar admits exactly one `then` per statement, matching KerML
- * `SuccessionDeclaration` (:845), so `steps` is always a pair here. The loop
- * below is still written over the whole array: it costs nothing, and it keeps
- * this function correct for the chained input the deferred-succession path at
- * the call site synthesizes.
- */
-function resolveSuccession(succession, filePath, packageName, parentActionId, relationships, allElementIds) {
-    const steps = succession.steps || [];
-    if (steps.length < 2)
-        return;
-    for (let i = 0; i < steps.length - 1; i++) {
-        const fromRef = steps[i].ref;
-        const toRef = steps[i + 1].ref;
-        // "start" and "done" are pseudo-elements; use parent action as context
-        const sourceId = fromRef === 'start'
-            ? (parentActionId ? `${parentActionId}__start` : '__start')
-            : fromRef;
-        const targetId = toRef === 'done'
-            ? (parentActionId ? `${parentActionId}__done` : '__done')
-            : toRef;
-        // Skip if neither endpoint is a known element (allow start/done pseudo-elements)
-        const sourceKnown = fromRef === 'start' || allElementIds.has(sourceId);
-        const targetKnown = toRef === 'done' || allElementIds.has(targetId);
-        if (!sourceKnown || !targetKnown)
-            continue;
-        const guardLabel = renderGuardExpression(steps[i].guard);
-        const rel = {
-            id: `rel-${++relationshipCounter}`,
-            type: 'succession',
-            sourceId,
-            sourceEnd: guardLabel === undefined ? '' : `[${guardLabel}]`,
-            targetId,
-            targetEnd: '',
-            file: filePath,
-        };
-        relationships.push(rel);
-    }
-}
-/**
- * Preserve a SysML succession guard as readable diagram text.
- *
- * Guards use the same expression AST as constraints. Previously only literal
- * `true`/`false` nodes happened to carry one of the three fields inspected by
- * the builder, so a valid guard such as `validUser == true` silently vanished
- * during lowering even though SysIDE accepted it.
- */
-function renderGuardExpression(expr) {
-    if (!expr)
-        return undefined;
-    switch (expr.$type) {
-        case 'LiteralExpr':
-            return expr.boolValue ?? expr.intValue ?? expr.strValue;
-        case 'FeatureChain':
-            return Array.isArray(expr.segments) ? expr.segments.join('.') : undefined;
-        case 'UnaryExpr': {
-            const operand = renderGuardExpression(expr.operand);
-            return operand === undefined ? undefined : `${expr.op} ${operand}`;
-        }
-        case 'BinaryExpr': {
-            const left = renderGuardExpression(expr.left);
-            const right = renderGuardExpression(expr.right);
-            return left === undefined || right === undefined
-                ? undefined
-                : `${left} ${expr.op} ${right}`;
-        }
-        case 'CollectionOp': {
-            const target = renderGuardExpression(expr.target);
-            const argument = renderGuardExpression(expr.argument);
-            if (target === undefined)
-                return undefined;
-            return `${target}->${expr.op}(${argument ?? ''})`;
-        }
-        default:
-            return expr.text ?? expr.value;
-    }
-}
-/**
- * Resolve an allocate usage into a MemoRelationship and set allocatedTo on the element.
- */
-function resolveAllocate(allocate, filePath, packageName, elements, relationships, registry, allElementIds, relationshipRegistry) {
-    const sourceRef = allocate.source;
-    const targetRef = allocate.target;
-    if (!sourceRef || !targetRef)
-        return;
-    // Resolve references
-    const sourceId = resolveEndpointId(sourceRef, packageName, registry, allElementIds);
-    const targetId = resolveEndpointId(targetRef, packageName, registry, allElementIds);
-    if (!sourceId || !targetId)
-        return;
-    // Set allocatedTo on the source element
-    const sourceEl = elements.get(sourceId);
-    if (sourceEl) {
-        sourceEl.allocatedTo = targetId;
-    }
-    // `allocate a to b;` and `connection : AllocatedTo connect …` are the same
-    // statement, so they produce the same edge. They did not: the native form
-    // emitted `allocateTo` with invented ends while the connection emitted
-    // `allocatedTo` with the ontology's, and consumers keyed on one silently
-    // missed the other — the DHF allocation queries ask for `allocatedTo`.
-    //
-    // A TYPED allocation — `allocation d : DeploysTo allocate m to node;` —
-    // carries which allocation it is, and that distinction has to survive.
-    // `DeploysTo` and `BuildsInto` are not `AllocatedTo` under another name:
-    // they are separate edges the deployment views and the DHF read by name.
-    // The `allocation def` naming them is what the typed form points at, so the
-    // edge is its camelCase name whenever the registry knows it; an unknown or
-    // absent type falls back to the base allocation, which is what bare
-    // `allocate` has always meant.
-    const typed = allocate.type ? pascalToCamelCase(allocate.type.split('::').pop()) : undefined;
-    const edge = typed && relationshipRegistry?.has(typed) ? typed : 'allocatedTo';
-    relationships.push(edge === 'allocatedTo'
-        ? nativeTraceEdge('allocatedTo', sourceId, targetId, filePath)
-        : typedAllocationEdge(edge, sourceId, targetId, filePath, relationshipRegistry));
-}
-/**
- * The trace edge for an `allocation x : SomeAllocationDef allocate a to b;`.
- *
- * Ends come from the registry entry for the named definition, so a typed
- * allocation and the equivalent `connection : SomeAllocationDef connect …`
- * produce byte-identical links — the same guarantee the three
- * LANGUAGE_NATIVE_RELATIONS rows carry, extended to every allocation def the
- * ontology declares rather than to a fixed list of three.
- */
-function typedAllocationEdge(type, sourceId, targetId, filePath, relationshipRegistry) {
-    const ends = relationshipRegistry?.getRelType(type)?.ends ?? [];
-    return {
-        id: `rel-${++relationshipCounter}`,
-        type,
-        sourceId,
-        sourceEnd: ends[0]?.name ?? 'source',
-        targetId,
-        targetEnd: ends[1]?.name ?? 'target',
-        file: filePath,
-    };
-}
-/** Build the trace edge for a language-native relation, typed from the registry. */
-function nativeTraceEdge(name, sourceId, targetId, filePath) {
-    const [sourceEnd, targetEnd] = LANGUAGE_NATIVE_RELATIONS[name].ends;
-    return {
-        id: `rel-${++relationshipCounter}`,
-        type: name,
-        sourceId,
-        sourceEnd: sourceEnd.name,
-        targetId,
-        targetEnd: targetEnd.name,
-        file: filePath,
-    };
-}
-/**
- * The owner context of a native trace usage: the package it is declared in, and
- * the nearest enclosing named element.
- *
- * `verify` needs the second one — the case that does the verifying is the owner
- * of the member, never a written end — and `satisfy` needs the first to resolve
- * its references the way every other endpoint is resolved.
- */
-function nativeUsageContext(node) {
-    const packages = [];
-    let ownerId;
-    for (let current = node.$container; current; current = current.$container) {
-        if (current.$type === 'PackageDeclaration') {
-            if (current.name)
-                packages.unshift(current.name);
-            continue;
-        }
-        // An `objective` is a MEMBERSHIP, not the element that does the
-        // verifying — the standard writes `objective { verify r; }` inside the
-        // case, and the case is the verifier. A named objective would otherwise
-        // capture `ownerId` and the `verifiedBy` edge would point at a wrapper
-        // that is not an extracted element, silently dropping the link.
-        if (current.$type === 'ObjectiveMember')
-            continue;
-        if (ownerId === undefined && typeof current.name === 'string' && current.name) {
-            ownerId = current.name;
-        }
-    }
-    return { packageName: packages.join('::'), ownerId };
-}
-/**
- * Project a native usage that names ONE end and takes the other from its owner.
- *
- * `perform`, `include`, `exhibit` and `frame` all have this shape, and it is
- * `verify`'s shape with the ends swapped: `verify` names its source and owns
- * its target, these four own their source and name their target. Sharing the
- * resolution keeps the four from drifting apart, and keeps the rule that the
- * owner supplies the unwritten end stated in exactly one place.
- */
-function resolveOwnerRootedUsage(node, written, name, filePath, relationships, registry, allElementIds) {
-    if (!written)
-        return;
-    const { packageName, ownerId } = nativeUsageContext(node);
-    const sourceId = ownerId
-        ? resolveEndpointId(ownerId, packageName, registry, allElementIds)
-        : undefined;
-    const targetId = resolveEndpointId(written, packageName, registry, allElementIds);
-    if (!sourceId || !targetId)
-        return;
-    relationships.push(nativeTraceEdge(name, sourceId, targetId, filePath));
-}
-/**
- * Project a verification case's `subject` onto the `verifiedBy` edge.
- *
- * This is the standard's answer to verifying something that is not a
- * requirement: the verified element becomes the case's SUBJECT and the
- * requirement its `objective { verify … }`. 61 of MEMO's 99 `VerifiedBy` links
- * target a SystemFunction, a RiskControlMeasure, a SoftwareModule, a
- * BehaviorProperty or a TimingConstraint — none of which native `verify`
- * admits, because `verify` takes a RequirementUsage.
- *
- * The edge direction matches `VerifiedBy`: the subject is the source
- * (verificationTarget) and the owning case the target (verificationCase).
- *
- * A `subject` that declares a fresh feature rather than pointing at an existing
- * element — `subject testVehicle : Vehicle;` — binds nothing and contributes no
- * edge. Only the referring forms (`subject v :> vehicleTestConfig;`,
- * `subject v = vehicleTestConfig;`) name something already in the model. A
- * multi-valued subject is one parameter whose binding is a parenthesized list;
- * each bound element is one `verifiedBy` fact for the owning case.
- */
-function resolveSubject(subject, filePath, relationships, registry, allElementIds) {
-    if (!subject.boundRefs?.length)
-        return;
-    const { packageName, ownerId } = nativeUsageContext(subject);
-    const targetId = ownerId
-        ? resolveEndpointId(ownerId, packageName, registry, allElementIds)
-        : undefined;
-    if (!targetId)
-        return;
-    for (const boundRef of subject.boundRefs) {
-        const sourceId = resolveEndpointId(boundRef, packageName, registry, allElementIds);
-        if (sourceId)
-            relationships.push(nativeTraceEdge('verifiedBy', sourceId, targetId, filePath));
-    }
-}
-/**
- * Project a native `actor` onto the `participatesIn` edge (R10-S6).
- *
- * Same shape as `resolveSubject`: only the REFERRING form —
- * `actor driver = existingPart;` — names something already in the model, so
- * only that form produces an edge. A fresh declaration (`actor x : Person;`,
- * no `boundRef`) introduces a locally-scoped actor the model does not yet
- * have an element for; collapsing `MemoRelationship`'s `Initiates` and
- * `ParticipatesIn` onto the single native `actor` keyword means the
- * initiating/participating distinction is no longer a typed relationship —
- * it lives in how the actor is named, the same way `Composes` gave up its
- * whole/part distinction to plain nesting.
- *
- * The owner is the TARGET and the written reference the SOURCE — `verify`'s
- * shape, not `perform`'s: the use case is what the actor participates IN.
- */
-function resolveActorParticipation(actor, filePath, relationships, registry, allElementIds) {
-    if (!actor.boundRef)
-        return;
-    const { packageName, ownerId } = nativeUsageContext(actor);
-    const sourceId = resolveEndpointId(actor.boundRef, packageName, registry, allElementIds);
-    const targetId = ownerId ? resolveEndpointId(ownerId, packageName, registry, allElementIds) : undefined;
-    if (!sourceId || !targetId)
-        return;
-    relationships.push(nativeTraceEdge('participatesIn', sourceId, targetId, filePath));
-}
-/**
- * Project every `dependency a to b;` onto the generic `dependency` edge, and
- * additionally onto `realizes` when it carries `#refinement` (R10-S6).
- *
- * The only native relation here that is not a connection. A Dependency takes n
- * clients and n suppliers rather than a source and a target, so one written
- * dependency can produce several edges — `dependency Schemata from s to a, b;`
- * is two statements sharing a name, and it lowers to two links, which is what
- * `Realizes` would have needed two connection usages to say.
- *
- * A dependency WITHOUT `#refinement` is an unclassified dependency: it means
- * strictly less than `Realizes` does, so it contributes only the generic
- * `dependency` edge, never `realizes` — inferring realization from a bare
- * dependency would put a claim in the traceability matrix that the model
- * never made. `#refinement` adds `realizes` on top; it does not replace the
- * generic edge, because a refinement dependency IS a dependency.
- *
- * Before R10-S6 a bare (non-`#refinement`) dependency built to nothing at
- * all — the same silent-drop shape as `BindingUsage`/`ExposeMember` — which
- * is what `ModuleUses`/`MonitorsChannel`'s migration to plain `dependency`
- * would otherwise have hit. Both collapse onto this one generic edge; native
- * `dependency` does not distinguish "uses a module" from "monitors a
- * channel" any more than `actor` distinguished an initiating actor from a
- * participating one, so that distinction now lives in the dependency's own
- * name/doc, not in a relationship type.
- */
-function resolveDependency(dependency, filePath, relationships, registry, allElementIds) {
-    const prefixes = (dependency.prefixMetadata ?? [])
-        .map(annotation => annotation.type?.split('::').pop());
-    const isRefinement = prefixes.includes(REFINEMENT_METADATA);
-    const { packageName } = nativeUsageContext(dependency);
-    for (const client of dependency.clients ?? []) {
-        const sourceId = resolveEndpointId(client, packageName, registry, allElementIds);
-        if (!sourceId)
-            continue;
-        for (const supplier of dependency.suppliers ?? []) {
-            const targetId = resolveEndpointId(supplier, packageName, registry, allElementIds);
-            if (!targetId)
-                continue;
-            relationships.push(nativeTraceEdge('dependency', sourceId, targetId, filePath));
-            if (isRefinement)
-                relationships.push(nativeTraceEdge('realizes', sourceId, targetId, filePath));
-        }
-    }
-}
-/**
- * Project every `satisfy` and `verify` in a document onto the trace edge its
- * MEMO connection-def equivalent produces.
- */
-function resolveNativeTraceUsages(model, filePath, relationships, registry, allElementIds) {
-    for (const node of AstUtils.streamAllContents(model)) {
-        if (isSatisfyRequirementUsage(node)) {
-            resolveSatisfy(node, filePath, relationships, registry, allElementIds);
-        }
-        else if (isRequirementVerificationMember(node)) {
-            resolveVerify(node, filePath, relationships, registry, allElementIds);
-        }
-        else if (isPerformActionUsage(node)) {
-            resolveOwnerRootedUsage(node, node.performed, 'performs', filePath, relationships, registry, allElementIds);
-        }
-        else if (isIncludeUseCaseUsage(node)) {
-            resolveOwnerRootedUsage(node, node.included, 'includesStep', filePath, relationships, registry, allElementIds);
-        }
-        else if (isExhibitStateUsage(node)) {
-            resolveOwnerRootedUsage(node, node.exhibited, 'exhibitsMode', filePath, relationships, registry, allElementIds);
-        }
-        else if (isFramedConcernMember(node)) {
-            resolveOwnerRootedUsage(node, node.framed, 'framesConcern', filePath, relationships, registry, allElementIds);
-        }
-        else if (isSubjectMember(node)) {
-            resolveSubject(node, filePath, relationships, registry, allElementIds);
-        }
-        else if (isActorMember(node)) {
-            resolveActorParticipation(node, filePath, relationships, registry, allElementIds);
-        }
-        else if (isDependency(node)) {
-            resolveDependency(node, filePath, relationships, registry, allElementIds);
-        }
-        else if (isVariantMember(node)) {
-            resolveVariant(node, filePath, relationships, registry, allElementIds);
-        }
-    }
-}
-/**
- * Project `variant x;` onto a navigable choice-point edge.
- *
- * A variation's alternatives are memberships rather than connection usages,
- * so they would otherwise disappear from the consumer model entirely.  The
- * nearest owner is the variation point and the written member names the
- * selected configuration.  Keeping this as a first-class edge lets DSMs and
- * views distinguish a real choice from four unrelated parts.
- */
-function resolveVariant(variant, filePath, relationships, registry, allElementIds) {
-    const { packageName, ownerId } = nativeUsageContext(variant);
-    const sourceId = ownerId
-        ? resolveEndpointId(ownerId, packageName, registry, allElementIds)
-        : undefined;
-    const targetId = resolveEndpointId(variant.name, packageName, registry, allElementIds);
-    if (!sourceId || !targetId)
-        return;
-    relationships.push({
-        id: `rel-${++relationshipCounter}`,
-        type: 'variant',
-        sourceId,
-        sourceEnd: 'variationPoint',
-        targetId,
-        targetEnd: 'variant',
-        file: filePath,
-    });
-}
-function resolveSatisfy(satisfy, filePath, relationships, registry, allElementIds) {
-    // A negated claim — `assert not satisfy r by p;` — states that the
-    // requirement is NOT satisfied. There is no MEMO connection for it, and
-    // emitting a `satisfiedBy` edge would make a design review's rejection read
-    // as coverage in the traceability matrix. It parses; it contributes no
-    // trace edge until the model has somewhere honest to put it.
-    if (satisfy.isNegated)
-        return;
-    const { packageName } = nativeUsageContext(satisfy);
-    const sourceId = resolveEndpointId(satisfy.requirement, packageName, registry, allElementIds);
-    // Without `by`, the satisfying subject is inherited from the enclosing
-    // requirement rather than written. Nothing to bind, so no edge.
-    const targetId = satisfy.satisfyingFeature
-        ? resolveEndpointId(satisfy.satisfyingFeature, packageName, registry, allElementIds)
-        : undefined;
-    if (!sourceId || !targetId)
-        return;
-    relationships.push(nativeTraceEdge('satisfiedBy', sourceId, targetId, filePath));
-}
-function resolveVerify(verify, filePath, relationships, registry, allElementIds) {
-    const { packageName, ownerId } = nativeUsageContext(verify);
-    const sourceId = resolveEndpointId(verify.requirement, packageName, registry, allElementIds);
-    // The verifying case is the owner. A `verify` whose owner is not an
-    // extracted element — a bare `verification def`, say — has no second end
-    // to bind, so it stays a parse fact and not a graph fact.
-    const targetId = ownerId ? resolveEndpointId(ownerId, packageName, registry, allElementIds) : undefined;
-    if (!sourceId || !targetId)
-        return;
-    relationships.push(nativeTraceEdge('verifiedBy', sourceId, targetId, filePath));
-}
-// ─── Helpers ────────────────────────────────────────────────────────────────
-function extractAttributes(body) {
-    if (!body)
-        return {};
-    const attrs = {};
-    for (const member of body) {
-        if (member.$type === 'AttributeMember' || member.$type === 'RefMember' || member.$type === 'MetadataFeatureMember') {
-            const attr = member;
-            if (attr.value) {
-                attrs[attr.name] = extractAttributeValue(attr.value);
-            }
-            else if (attr.type) {
-                attrs[attr.name] = `<${attr.type}>`;
-            }
-            else if (attr.body?.length) {
-                // Structured value: the members of an `attribute def` assigned
-                // inline, e.g. `attribute :>> bounds { attribute :>> x = 0.1; }`.
-                // Flattened to dotted keys ("bounds.x") so the value lands in
-                // the same flat map every consumer already reads. Without this
-                // branch the whole assignment is dropped and the model carries
-                // no record of it.
-                for (const [key, value] of Object.entries(extractAttributes(attr.body))) {
-                    attrs[`${attr.name}.${key}`] = value;
-                }
-            }
-        }
-    }
-    // Metadata applications last, so an annotation overrides a directly declared
-    // attribute of the same name. That order is what R10-S5 established for
-    // connections and it is preserved here rather than re-litigated: while the
-    // identification core is migrating off the base defs, an element may carry
-    // both spellings, and the annotation is the newer statement of intent.
-    Object.assign(attrs, extractMetadataApplications(body));
-    return attrs;
-}
-/**
- * Standard metadata whose field name differs from the flat key MEMO reads.
- * Everything else lifts under its own field name, which is what makes one
- * `metadata def` usable as a carrier for any element.
- */
-const METADATA_KEY_ALIASES = {
-    Rationale: { text: 'rationale' },
-};
-/**
- * Lift every `@Foo { ... }` metadata application in a body into the flat
- * attribute map, under each field's own name.
- *
- * `extractAttributes`'s member walk covers `AttributeMember`/`RefMember`/
- * `MetadataFeatureMember`; a `MetadataApplication` is a different node type and
- * is invisible to it, so without this an annotation parses cleanly in both
- * parsers and then silently vanishes from the model — the BindingUsage /
- * ExposeMember / untyped-flow shape this codebase has already hit three times.
- *
- * This started (R10-S5, 2026-08-13) as a connection-only reader hardcoded to
- * `Rationale.text` and `StatusInfo.status`, because those were the two base-type
- * attributes being deleted at the time. It is general now for one reason: a
- * `metadata def` is the only carrier in SysML v2 that attaches to ANY metaclass,
- * so it is how MEMO can hold common fields (`id`, `uuid`, `sourceReference`, …)
- * without re-declaring them per metaclass. A carrier the builder cannot read is
- * not a carrier, so the reader has to be as general as the mechanism.
- *
- * Fields lift under their own names; `METADATA_KEY_ALIASES` covers the standard
- * definitions whose field name differs from the key MEMO reads.
- */
-function extractMetadataApplications(body) {
-    if (!body)
-        return {};
-    const attrs = {};
-    for (const member of body) {
-        if (member.$type !== 'MetadataApplication')
-            continue;
-        const metadataType = member.type?.split('::').pop() ?? '';
-        const aliases = METADATA_KEY_ALIASES[metadataType] ?? {};
-        for (const [field, value] of Object.entries(extractAttributes(member.body))) {
-            if (value === '')
-                continue;
-            attrs[aliases[field] ?? field] = value;
-        }
-    }
-    return attrs;
-}
-function extractAttributeValue(value) {
-    if (!value)
-        return '';
-    switch (value.$type) {
-        case 'StringValue':
-            return value.value.replace(/^"|"$/g, '');
-        case 'IntValue':
-            return String(value.value);
-        case 'RealValue':
-            return String(value.value);
-        case 'BooleanValue':
-            return value.value;
-        case 'EnumValue':
-            return value.enumRef;
-        case 'SetLiteral':
-            // { A, B, "c" } → "A, B, c" — keeps attributes flat and readable
-            return (value.elements ?? [])
-                .map(el => el.value ?? (el.stringValue ?? '').replace(/^"|"$/g, ''))
-                .filter((s) => s.length > 0)
-                .join(', ');
-        default:
-            return String(value);
-    }
-}
-function extractDocComment(body) {
-    if (!body)
-        return undefined;
-    const doc = body.find((m) => m.$type === 'DocComment');
-    if (!doc)
-        return undefined;
-    return doc.content
-        .replace(/^doc\s+\/\*\s*/, '')
-        .replace(/\s*\*\/$/, '')
-        .replace(/\n\s*\*\s?/g, ' ')
-        .trim();
-}
-/**
- * Resolve a QualifiedName reference to just the local name.
- * In SysML v2 usages: `control ::> rcFlowRateLimiter` — ref is "rcFlowRateLimiter"
- */
-function resolveRef(ref) {
-    if (!ref)
-        return undefined;
-    // Take the last segment of a qualified name
-    const parts = ref.split('::');
-    return parts[parts.length - 1] || undefined;
-}
-/**
- * Resolve a relationship endpoint reference to an element id, including
- * dotted feature chains (`sampleActionFlow.process.processStepB`): elements
- * are registered under their leaf name, so when the full reference is not a
- * known element id, resolve its last dot segment instead.
- */
-function resolveEndpointId(
-// An endpoint can parse without a reference — the Release examples contain
-// connection forms the MEMO grammar accepts structurally but cannot bind.
-// An unresolvable endpoint drops the relationship at the call site, which
-// is the same outcome as any other unresolved reference; crashing the whole
-// build over it is not (§1.1 — the compiler reports, it does not refuse).
-ref, packageName, registry, allElementIds) {
-    if (!ref)
-        return undefined;
-    const direct = registry.resolveElementId(ref, packageName, allElementIds) || resolveRef(ref);
-    if (direct && allElementIds.has(direct))
-        return direct;
-    if (ref.includes('.')) {
-        const leaf = ref.split('.').pop();
-        const resolved = registry.resolveElementId(leaf, packageName, allElementIds) || resolveRef(leaf);
-        if (resolved && allElementIds.has(resolved))
-            return resolved;
-    }
-    return direct;
-}
-/**
- * Relationship type names are normalized by the shared helper in `naming.ts`,
- * which is the single definition of the source-name → model-key rule.
- */
-const normalizeRelType = toModelType;
-//# sourceMappingURL=builder.js.map