@memoarchitect/tools 0.6.7 → 0.7.2

package/packages/tools/lib/model/activity-notation.js

@@ -0,0 +1,208 @@
+// ─── Activity notation roles ─────────────────────────────────────────────────
+//
+// Which activity symbol an element draws as. Same standard as
+// `relationship-legality.ts`: pure, dependency-free, and derived from declared
+// data rather than from a table of names in TypeScript.
+//
+// What this replaces. Architect's `actionflow-view.ts` classified nodes by
+// comparing a normalised `kind` string against a ladder of spellings —
+// `'decisionnode' || 'decisionnodeusage'`, `'acceptactionusage' ||
+// 'acceptaction'`, and so on. Three problems with that, in increasing order of
+// seriousness: it lived in the view rather than in the toolchain (§1.2.2); the
+// spellings were a hardcoded kind list, which is exactly what the engine is not
+// supposed to contain; and it could not answer a question the metamodel answers
+// for free — that a `ForkNode` *is* a `ControlNode` *is* an `ActionUsage`.
+//
+// How it works instead. Three declared sources decide, and none of them is a
+// list of names maintained here:
+//
+//   1. **The normative metamodel.** `SYSML_METACLASSES` is generated from
+//      `SysML.ecore` (Track B B2), so the generalization graph — `ForkNode` →
+//      `ControlNode` → `ActionUsage` — is data. A role is anchored on one
+//      metaclass and matched with `conformsTo`, so every present and future
+//      subtype of that anchor classifies correctly without being named.
+//   2. **The metamodel again, for precedence.** Roles are tried most-specific
+//      first, and "most specific" is computed from each anchor's supertype
+//      depth rather than written down in an order someone has to maintain.
+//   3. **The ontology.** An element whose `kind` is a MEMO ontology kind is
+//      resolved by walking that kind's declared `superType` chain, so binding a
+//      new kind to a notation role is an ontology edit and not a code change.
+//
+// What remains hardcoded, stated plainly rather than hidden. Two things, both
+// irreducible today:
+//
+//   - **The role → anchor binding.** Notation is a mapping from semantics to
+//      symbols; something has to state it. The normative graphical grammar
+//      (`bnf/SysML-graphical-bnf.kgbnf`, vendored) names the productions —
+//      `fork-node`, `decision-node`, `accept-action-node` — but binds them to
+//      SVG images, not to metaclasses, so it cannot supply the anchor. Each
+//      binding cites its production, and Session 5's notation work is where the
+//      kgbnf becomes the source rather than the citation.
+//   - **The two final-node roles.** SysML v2 has no `ActivityFinalNode` or
+//      `FlowFinalNode` metaclass; they are UML and SysML v1 names that
+//      importers still emit. They cannot come from the v2 metamodel because the
+//      v2 metamodel does not have them, so they are declared as what they are —
+//      legacy input spellings — instead of sitting in the same ladder as
+//      metaclasses that do exist.
+// ─────────────────────────────────────────────────────────────────────────────
+import { SYSML_METACLASSES, allSuperTypes, conformsTo } from '../sysml-ir/index.js';
+/**
+ * Role bindings, unordered.
+ *
+ * Deliberately not written in precedence order — `activityRolesBySpecificity()`
+ * derives that from the metamodel, so adding a binding cannot put it in the
+ * wrong place.
+ */
+export const ACTIVITY_NOTATION_ROLES = [
+    { role: 'fork', metaclass: 'ForkNode', bnfProduction: 'fork-node' },
+    { role: 'join', metaclass: 'JoinNode', bnfProduction: 'join-node' },
+    { role: 'decision', metaclass: 'DecisionNode', bnfProduction: 'decision-node' },
+    { role: 'merge', metaclass: 'MergeNode', bnfProduction: 'merge-node' },
+    { role: 'send', metaclass: 'SendActionUsage', bnfProduction: 'send-action-node' },
+    { role: 'accept', metaclass: 'AcceptActionUsage', bnfProduction: 'accept-action-node' },
+    { role: 'activityFinal', metaclass: 'TerminateActionUsage' },
+    { role: 'action', metaclass: 'ActionUsage', bnfProduction: 'action-node' },
+    // Definitions draw as actions too, and `ActionDefinition` is not a subtype
+    // of `ActionUsage` — the metamodel puts it under `OccurrenceDefinition` and
+    // `Behavior` — so it needs its own anchor rather than being reached through
+    // the usage one. A role with two anchors is exactly what the list shape is
+    // for.
+    { role: 'action', metaclass: 'ActionDefinition', bnfProduction: 'action-node' },
+];
+/**
+ * Input spellings SysML v2 has no metaclass for.
+ *
+ * UML and SysML v1 final nodes. Kept because importers emit them and a diagram
+ * that silently drops a final node is worse than one drawn from a legacy name;
+ * kept *here*, apart from the metamodel-driven path, because pretending they
+ * are metaclasses is how the old ladder became unreadable.
+ */
+const LEGACY_NODE_SPELLINGS = {
+    activityfinalnode: 'activityFinal',
+    activityfinalnodeusage: 'activityFinal',
+    flowfinalnode: 'flowFinal',
+    flowfinalnodeusage: 'flowFinal',
+};
+/**
+ * MEMO grammar literals for `ControlNodeUsage.controlKind`, bound to the
+ * metaclasses they name.
+ *
+ * The four values come from MEMO's own Langium grammar, so they are not
+ * derivable from `SysML.ecore` — but their targets are, and
+ * `controlKindMetaclassesAreControlNodes()` asserts that these four are exactly
+ * the metamodel's `ControlNode` subtypes. A fifth control node upstream fails
+ * that check rather than silently going unclassified.
+ */
+export const CONTROL_KIND_METACLASS = {
+    fork: 'ForkNode',
+    join: 'JoinNode',
+    decide: 'DecisionNode',
+    merge: 'MergeNode',
+};
+/** True when the bindings above still match the metamodel's control nodes. */
+export function controlKindMetaclassesAreControlNodes() {
+    const declared = new Set(Object.values(CONTROL_KIND_METACLASS));
+    const actual = Object.keys(SYSML_METACLASSES)
+        .filter(name => name !== 'ControlNode' && conformsTo(name, 'ControlNode'));
+    return actual.length === declared.size && actual.every(name => declared.has(name));
+}
+/**
+ * Roles most-specific first, by supertype depth.
+ *
+ * `ForkNode` sits three levels below `ActionUsage`, so it is tried first and an
+ * `ActionUsage` anchor never swallows a control node. Computed rather than
+ * declared, because the metamodel already knows the answer.
+ */
+export function activityRolesBySpecificity() {
+    return [...ACTIVITY_NOTATION_ROLES].sort((a, b) => allSuperTypes(b.metaclass).length - allSuperTypes(a.metaclass).length);
+}
+/**
+ * Spellings of `token` to try against the metamodel.
+ *
+ * The suffix rules exist because the same concept is written several ways
+ * across importers and MEMO's own construct keywords — `DecisionNodeUsage`,
+ * `decision`, `AcceptAction`. What makes this different from the ladder it
+ * replaces is that *the metamodel decides* which candidate is real: a spelling
+ * that does not name a metaclass simply does not match, and no spelling has to
+ * be enumerated here.
+ */
+function metaclassCandidates(token) {
+    if (!token)
+        return [];
+    const base = token.replace(/[ _-]/g, '');
+    const capitalized = base.charAt(0).toUpperCase() + base.slice(1);
+    return [
+        capitalized,
+        `${capitalized}Usage`,
+        `${capitalized}Node`,
+        `${capitalized}ActionUsage`,
+        capitalized.replace(/Usage$/, ''),
+        capitalized.replace(/Definition$/, ''),
+    ];
+}
+/** The metaclass a token names, if the metamodel has one. */
+function resolveMetaclass(token) {
+    for (const candidate of metaclassCandidates(token ?? '')) {
+        if (candidate in SYSML_METACLASSES)
+            return candidate;
+    }
+    return undefined;
+}
+/** An ontology kind and everything it specializes, nearest first. */
+function ontologyChain(kind, kinds) {
+    const byName = new Map((kinds ?? []).map(definition => [definition.name, definition]));
+    const chain = [];
+    let current = kind;
+    while (current && !chain.includes(current)) {
+        chain.push(current);
+        current = byName.get(current)?.superType;
+    }
+    return chain;
+}
+/**
+ * The activity symbol this element draws as, or `undefined` if it is not an
+ * activity node at all.
+ *
+ * `registries` is optional: without it, classification uses the metamodel
+ * alone, which is what a caller holding a bare element can do. With it, an
+ * ontology kind reaches its role through its declared specialization chain —
+ * which is the path a project extends.
+ */
+export function activityNodeType(element, registries) {
+    // The metamodel's own discriminator first: a control node says what it is.
+    const controlKind = element.attributes?.controlKind?.toLowerCase();
+    const fromControlKind = controlKind ? CONTROL_KIND_METACLASS[controlKind] : undefined;
+    const tokens = [
+        ...(fromControlKind ? [fromControlKind] : []),
+        ...ontologyChain(element.kind, registries?.kinds),
+        // Native SysML nodes (AcceptActionUsage, DecisionNodeUsage, etc.) are
+        // already represented by their metaclass name in `kind`; do not rely
+        // on the generic `construct: action`, which would erase their symbol.
+        element.kind,
+        element.construct,
+    ];
+    const roles = activityRolesBySpecificity();
+    for (const token of tokens) {
+        const legacy = LEGACY_NODE_SPELLINGS[(token ?? '').replace(/[ _-]/g, '').toLowerCase()];
+        if (legacy)
+            return legacy;
+        const metaclass = resolveMetaclass(token);
+        if (!metaclass)
+            continue;
+        const match = roles.find(role => conformsTo(metaclass, role.metaclass));
+        if (match)
+            return match.role;
+    }
+    return undefined;
+}
+/** Control nodes flow through the graph but own no responsibility lane. */
+export function isControlNode(element, registries) {
+    const role = activityNodeType(element, registries);
+    if (role === 'activityFinal' || role === 'flowFinal')
+        return true;
+    const binding = ACTIVITY_NOTATION_ROLES.find(candidate => candidate.role === role);
+    // "Is it a control node" is the metamodel's question, not a list of four
+    // role names: `ControlNode` is a metaclass, and the anchors sit under it.
+    return binding !== undefined && conformsTo(binding.metaclass, 'ControlNode');
+}
+//# sourceMappingURL=activity-notation.js.map

package/packages/tools/lib/model/activity-notation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"activity-notation.js","sourceRoot":"","sources":["../../src/model/activity-notation.ts"],"names":[],"mappings":"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"}

package/packages/tools/lib/model/builder.d.ts

@@ -3,6 +3,7 @@ import type { MemoModel, ParseError } from './semantic.js';
 import type { ParsedDocument } from './parser-utils.js';
 import type { KindRegistry } from './kind-registry.js';
 import type { RelationshipRegistry } from './relationship-registry.js';
+import type { ProvenanceTable } from './source-provenance.js';
 /**
  * Optional registries for dual-mode resolution.
  * When provided, registries take precedence over config lookups.
@@ -13,6 +14,8 @@ export interface BuilderRegistries {
     kindRegistry?: KindRegistry;
     /** RelationshipRegistry populated from ontology SysML files */
     relationshipRegistry?: RelationshipRegistry;
+    /** Resolved source ownership; never infer this from a client-side path. */
+    provenance?: ProvenanceTable;
 }
 /**
  * Build a MemoModel from parsed documents and config.

package/packages/tools/lib/model/builder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../../src/model/builder.ts"],"names":[],"mappings":"AA4DA,OAAO,KAAK,EAAE,UAAU,EAAkB,MAAM,aAAa,CAAC;AAC9D,OAAO,KAAK,EAGR,SAAS,EACT,UAAU,EAGb,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAGxD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAGvE;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IAC9B,uDAAuD;IACvD,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,+DAA+D;IAC/D,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;CAC/C;AAmFD;;;GAGG;AACH,wBAAgB,cAAc,CAC1B,SAAS,EAAE,cAAc,EAAE,EAC3B,MAAM,EAAE,UAAU,EAClB,WAAW,GAAE,UAAU,EAAO,EAC9B,UAAU,CAAC,EAAE,iBAAiB,GAC/B,SAAS,CAiIX"}
+{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../../src/model/builder.ts"],"names":[],"mappings":"AA4DA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C,OAAO,KAAK,EAGR,SAAS,EACT,UAAU,EAGb,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAGxD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAGvE,OAAO,KAAK,EAAE,eAAe,EAA6B,MAAM,wBAAwB,CAAC;AAEzF;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IAC9B,uDAAuD;IACvD,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,+DAA+D;IAC/D,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;IAC5C,2EAA2E;IAC3E,UAAU,CAAC,EAAE,eAAe,CAAC;CAChC;AAqFD;;;GAGG;AACH,wBAAgB,cAAc,CAC1B,SAAS,EAAE,cAAc,EAAE,EAC3B,MAAM,EAAE,UAAU,EAClB,WAAW,GAAE,UAAU,EAAO,EAC9B,UAAU,CAAC,EAAE,iBAAiB,GAC/B,SAAS,CAsIX"}

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

@@ -28,6 +28,7 @@ import { createHash } from 'node:crypto';
 import { PackageRegistry } from './package-registry.js';
 import { assignSequentialShortIds, kindToPrefix } from './short-id.js';
 import { indexKinds, kindConformsTo } from './relationship-legality.js';
+import { CONTROL_KIND_METACLASS } from './activity-notation.js';
 let relationshipCounter = 0;
 /**
  * Resolve a kind definition using registry-first, config-fallback strategy.
@@ -55,8 +56,10 @@ function resolveKindDef(typeName, config, registries) {
             }
         }
     }
-    // Fall back to config (if kinds are present)
-    const kinds = config.kinds ?? {};
+    // 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 };
@@ -108,6 +111,10 @@ export function buildMemoModel(documents, config, parseErrors = [], registries)
     for (const { allocate, filePath, packageName } of deferredAllocates) {
         resolveAllocate(allocate, filePath, packageName, elements, relationships, registry, allElementIds);
     }
+    // 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();
@@ -197,6 +204,49 @@ export function buildMemoModel(documents, config, parseErrors = [], registries)
         incoming,
     };
 }
+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
@@ -269,6 +319,23 @@ function extractFromPackage(pkg, filePath, parentPackage, config, elements, defe
                     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 'SuccessionUsage':
+                deferredSuccessions.push({
+                    succession: member,
+                    filePath,
+                    packageName,
+                });
+                break;
             case 'AllocateUsage':
                 deferredAllocates.push({
                     allocate: member,
@@ -278,7 +345,7 @@ function extractFromPackage(pkg, filePath, parentPackage, config, elements, defe
                 break;
             // ─── Definition members ─────────────────────────────────────
             case 'ActionDefinition':
-                extractActionDefinition(member, filePath, packageName, config, elements, registry);
+                extractActionDefinition(member, filePath, packageName, config, elements, deferredFlows, deferredSuccessions, registry, registries);
                 break;
             case 'ItemDefinition':
                 extractItemDefinition(member, filePath, packageName, config, elements, registry, registries);
@@ -312,13 +379,21 @@ function extractUsage(usage, construct, filePath, packageName, config, elements,
             continue;
         const pm = member;
         if (pm.boundRef && pm.name) {
+            // Two shapes land here. `part viewpointDefinition :> vp;` names the
+            // feature in `name` and the value in `boundRef`. The subsetting
+            // form for a multi-valued feature —
+            // `part 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[pm.name];
-            attributes[pm.name] = previous
-                ? `${previous},${pm.boundRef}`
-                : pm.boundRef;
+            const previous = attributes[key];
+            attributes[key] = previous ? `${previous},${value}` : value;
         }
         else if (pm.body && pm.name) {
             const nested = extractAttributes(pm.body);
@@ -343,11 +418,23 @@ function extractUsage(usage, construct, filePath, packageName, config, elements,
     // 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,
+            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);
@@ -355,18 +442,18 @@ function extractUsage(usage, construct, filePath, packageName, config, elements,
 /**
  * Extract an ActionDefinition as a MemoElement with parameters.
  */
-function extractActionDefinition(actionDef, filePath, packageName, config, elements, registry) {
+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') {
+        if (member.$type === 'ActionParameterMember' || (member.$type === 'ItemUsage' && member.direction)) {
             const param = member;
             parameters.push({
                 name: param.name,
                 direction: param.direction,
-                type: param.type,
+                type: param.type || 'Item',
             });
         }
     }
@@ -388,6 +475,66 @@ function extractActionDefinition(actionDef, filePath, packageName, config, eleme
     };
     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: 'behavior', 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.
@@ -482,6 +629,9 @@ function extractActionUsage(usage, filePath, packageName, config, elements, defe
         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);
@@ -515,18 +665,22 @@ function extractActionUsage(usage, filePath, packageName, config, elements, defe
     }
 }
 /**
- * Extract a fork/join control node. Modeled as a behavior-layer element with
+ * 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 a distinct kind
- * (`ForkNode` / `JoinNode`) and a `controlKind` attribute so renderers draw it
- * as a synchronization bar rather than an action card.
+ * 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 = node.controlKind === 'fork' ? 'ForkNode' : 'JoinNode';
+    const kind = CONTROL_KIND_METACLASS[node.controlKind];
     elements.set(id, {
         id,
-        name: node.controlKind,
+        name: node.name,
         kind,
         construct: 'action',
         layer: 'behavior',
@@ -630,11 +784,12 @@ function resolveSuccession(succession, filePath, packageName, parentActionId, re
         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: '',
+            sourceEnd: guardLabel === undefined ? '' : `[${guardLabel}]`,
             targetId,
             targetEnd: '',
             file: filePath,
@@ -642,6 +797,44 @@ function resolveSuccession(succession, filePath, packageName, parentActionId, re
         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.
  */
@@ -685,6 +878,17 @@ function extractAttributes(body) {
             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;
+                }
+            }
         }
     }
     return attrs;
@@ -742,7 +946,15 @@ function resolveRef(ref) {
  * 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(ref, packageName, registry, allElementIds) {
+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;