@cohesivesystems/processes-presentation 0.1.0-alpha.129

package/dist/process-presentation-graph.js

@@ -0,0 +1,847 @@
+import { canonicalProcessAwaitClauseKinds, canonicalProcessNodeKinds, } from '@cohesivesystems/processes';
+import { cloneWireValue, deepFreeze, isRecord, } from './process-presentation-values.js';
+export const canonicalProcessPresentationCompatibility = Object.freeze({
+    definitionKind: 'process',
+    projectionVersion: 'cohesive-process-presentation/v1',
+    schemaVersions: Object.freeze(['cohesive-execution/v4']),
+});
+export function processPresentationElementId(category, canonicalId, ownerId) {
+    const owner = ownerId ? `${encodeURIComponent(ownerId)}/` : '';
+    return `${category}/${owner}${encodeURIComponent(canonicalId)}`;
+}
+export function processPresentationDefinitionReferenceId(reference) {
+    return processPresentationElementId('definition-reference', definitionReferenceKey(reference));
+}
+export function projectCanonicalProcessDocument(document) {
+    const diagnostics = [];
+    if (!isRecord(document)) {
+        addDiagnostic(diagnostics, 'PROCESS_DEFINITION_INVALID', [], 'A canonical Process projection requires an execution-definition document object.');
+        return freezeProjectionResult(null, diagnostics);
+    }
+    const kind = readString(document.kind);
+    if (kind !== canonicalProcessPresentationCompatibility.definitionKind) {
+        addDiagnostic(diagnostics, 'PROCESS_DEFINITION_KIND_UNSUPPORTED', ['kind'], `Process presentation supports definition kind '${canonicalProcessPresentationCompatibility.definitionKind}', ` +
+            `but observed '${kind ?? '<missing>'}'.`, kind);
+        return freezeProjectionResult(null, diagnostics);
+    }
+    const metadata = isRecord(document.metadata) ? document.metadata : null;
+    const schemaVersion = readString(metadata?.schemaVersion);
+    if (!schemaVersion || !canonicalProcessPresentationCompatibility.schemaVersions.includes(schemaVersion)) {
+        addDiagnostic(diagnostics, 'PROCESS_DEFINITION_SCHEMA_UNSUPPORTED', ['metadata', 'schemaVersion'], `Process presentation does not support execution schema '${schemaVersion ?? '<missing>'}'.`, schemaVersion);
+        return freezeProjectionResult(null, diagnostics);
+    }
+    if (!metadata) {
+        addDiagnostic(diagnostics, 'PROCESS_DEFINITION_INVALID', ['metadata'], 'A canonical Process document requires definition metadata.');
+        return freezeProjectionResult(null, diagnostics);
+    }
+    const definition = isRecord(document.definition) ? document.definition : null;
+    if (!definition) {
+        addDiagnostic(diagnostics, 'PROCESS_DEFINITION_INVALID', ['definition'], 'A canonical Process document requires an object definition payload.');
+        return freezeProjectionResult(null, diagnostics);
+    }
+    const context = {
+        constructPaths: new Map(),
+        diagnostics,
+        document,
+        edgePaths: new Map(),
+        edges: [],
+        nodeIds: new Set(),
+        nodes: [],
+        pendingTargets: [],
+    };
+    verifyDispositionCompleteness(context);
+    projectProcessDefinition(definition, context);
+    resolvePendingTargets(context);
+    const definitionReference = readDefinitionReference(metadata);
+    if (!definitionReference) {
+        addDiagnostic(diagnostics, 'PROCESS_DEFINITION_REFERENCE_INVALID', ['metadata'], 'Process metadata must retain definition id, revision id, and a complete fingerprint.');
+    }
+    const entry = readString(definition.entry);
+    const entryNodeId = entry ? processPresentationElementId('process-node', entry) : null;
+    if (!entry || !context.nodeIds.has(entryNodeId)) {
+        addDiagnostic(diagnostics, 'PROCESS_ENTRY_UNRESOLVED', ['definition', 'entry'], 'The Process entry must identify a projected canonical Process node.', entry);
+    }
+    sortProjection(context);
+    const frozenDiagnostics = freezeDiagnostics(diagnostics);
+    const graph = deepFreeze({
+        diagnostics: frozenDiagnostics,
+        document: {
+            definition: definitionReference ?? missingDefinitionReference(metadata),
+            kind,
+            metadata: cloneWireValue(metadata),
+            schemaVersion,
+            typeDefinitions: Array.isArray(definition.$types) ? cloneWireValue(definition.$types) : [],
+        },
+        edges: context.edges.map(freezeEdge),
+        entryNodeId: entry && context.nodeIds.has(entryNodeId) ? entryNodeId : null,
+        nodes: context.nodes.map(freezeNode),
+        projectionVersion: canonicalProcessPresentationCompatibility.projectionVersion,
+    });
+    return deepFreeze({ graph, diagnostics: frozenDiagnostics });
+}
+function projectProcessDefinition(definition, context) {
+    const nodes = definition.nodes;
+    if (!Array.isArray(nodes)) {
+        addDiagnostic(context.diagnostics, 'PROCESS_NODE_TABLE_INVALID', ['definition', 'nodes'], 'A canonical Process definition requires a node array.');
+        return;
+    }
+    for (let index = 0; index < nodes.length; index += 1) {
+        const path = ['definition', 'nodes', String(index)];
+        const rawNode = nodes[index];
+        if (!isRecord(rawNode)) {
+            addDiagnostic(context.diagnostics, 'PROCESS_DEFINITION_INVALID', path, 'A Process node must be an object.');
+            continue;
+        }
+        const id = readString(rawNode.id);
+        if (!id) {
+            addDiagnostic(context.diagnostics, 'PROCESS_ELEMENT_ID_REQUIRED', [...path, 'id'], 'A Process node requires a stable canonical identity.');
+            continue;
+        }
+        const kind = readString(rawNode.$node);
+        if (!kind) {
+            const owner = addElementNode({
+                canonicalId: id,
+                category: 'process-node',
+                context,
+                label: 'Unknown Process node',
+                path,
+                processNodeKind: null,
+                source: rawNode,
+            });
+            addDiagnostic(context.diagnostics, 'PROCESS_NODE_KIND_REQUIRED', [...path, '$node'], 'A Process node requires its persisted wire discriminator.', owner?.canonicalId ?? id);
+            continue;
+        }
+        if (!isCanonicalProcessNodeKind(kind)) {
+            addElementNode({
+                canonicalId: id,
+                category: 'process-node',
+                context,
+                label: `Unsupported Process node (${kind})`,
+                path,
+                processNodeKind: kind,
+                source: rawNode,
+            });
+            addDiagnostic(context.diagnostics, 'PROCESS_NODE_KIND_UNSUPPORTED', [...path, '$node'], `Process node kind '${kind}' is outside the projector disposition inventory.`, id);
+            continue;
+        }
+        const disposition = processNodeDispositions[kind];
+        const owner = addElementNode({
+            canonicalId: id,
+            category: 'process-node',
+            context,
+            label: disposition.label,
+            path,
+            processNodeKind: kind,
+            source: rawNode,
+            terminal: disposition.terminal,
+        });
+        if (!owner) {
+            continue;
+        }
+        disposition.project(rawNode, owner, path, context);
+    }
+}
+const processNodeDispositions = {
+    invokeTransition: {
+        label: 'Invoke transition',
+        project(node, owner, path, context) {
+            addDefinitionReference(owner, 'transition', node.transition, [...path, 'transition'], context);
+            addContinuation(owner, node.continuation, 'continuation', [...path, 'continuation'], context);
+        },
+    },
+    evaluateRelation: {
+        label: 'Evaluate relation',
+        project(node, owner, path, context) {
+            addDefinitionReference(owner, 'relation', node.relation, [...path, 'relation'], context);
+            addContinuation(owner, node.continuation, 'continuation', [...path, 'continuation'], context);
+        },
+    },
+    request: {
+        label: 'Request',
+        project(node, owner, path, context) {
+            addContractReference(owner, 'request-contract', node.contract, [...path, 'contract'], context);
+            projectRequestOutcomes(owner, node.outcomes, [...path, 'outcomes'], context);
+        },
+    },
+    emitEvent: {
+        label: 'Emit event',
+        project(node, owner, path, context) {
+            addContractReference(owner, 'domain-event-contract', node.contract, [...path, 'contract'], context);
+            addControlEdge(owner, node.next, 'next', [...path, 'next'], context);
+        },
+    },
+    sendSignal: {
+        label: 'Send signal',
+        project(node, owner, path, context) {
+            addContractReference(owner, 'signal-contract', node.contract, [...path, 'contract'], context);
+            addControlEdge(owner, node.next, 'next', [...path, 'next'], context);
+        },
+    },
+    choice: {
+        label: 'Choice',
+        project(node, owner, path, context) {
+            projectChoiceCases(owner, node.cases, [...path, 'cases'], context);
+            projectFallback(owner, node.fallback, [...path, 'fallback'], context);
+        },
+    },
+    match: {
+        label: 'Match',
+        project(node, owner, path, context) {
+            addValueContract(owner, 'match-value', node.contract);
+            projectMatchCases(owner, node.cases, [...path, 'cases'], context);
+            projectFallback(owner, node.fallback, [...path, 'fallback'], context);
+        },
+    },
+    fork: {
+        label: 'Fork',
+        project(node, owner, path, context) {
+            projectForkBranches(owner, node.branches, [...path, 'branches'], context);
+            const join = readString(node.join);
+            if (join) {
+                addDerivedEdge(owner, processPresentationElementId('process-node', join), 'reciprocal', 'join', path, context);
+            }
+            else {
+                addDiagnostic(context.diagnostics, 'PROCESS_EDGE_TARGET_UNRESOLVED', [...path, 'join'], 'A Fork requires the stable identity of its reciprocal Join.', owner.canonicalId);
+            }
+        },
+    },
+    join: {
+        label: 'Join',
+        project(node, owner, path, context) {
+            addControlEdge(owner, node.next, 'next', [...path, 'next'], context);
+            projectJoinResults(owner, node.fork, node.result, [...path, 'result'], context);
+        },
+    },
+    awaitMatch: {
+        label: 'Await match',
+        project(node, owner, path, context) {
+            projectAwaitClauses(owner, node.clauses, [...path, 'clauses'], context);
+        },
+    },
+    timer: {
+        label: 'Timer',
+        project(node, owner, path, context) {
+            addControlEdge(owner, node.next, 'next', [...path, 'next'], context);
+        },
+    },
+    reply: {
+        label: 'Reply',
+        project(node, owner, path, context) {
+            addContractReference(owner, 'reply-contract', node.contract, [...path, 'contract'], context);
+            addControlEdge(owner, node.next, 'next', [...path, 'next'], context);
+        },
+    },
+    durableCut: {
+        label: 'Durable cut',
+        project(node, owner, path, context) {
+            addControlEdge(owner, node.resume, 'resume', [...path, 'resume'], context);
+        },
+    },
+    invokeProcess: {
+        label: 'Invoke process',
+        project(node, owner, path, context) {
+            addDefinitionReference(owner, 'child-process', node.process, [...path, 'process'], context);
+            addContractReference(owner, 'request-contract', node.contract, [...path, 'contract'], context);
+            projectRequestOutcomes(owner, node.outcomes, [...path, 'outcomes'], context);
+        },
+    },
+    forEachPartition: {
+        label: 'For each partition',
+        project(node, owner, path, context) {
+            addDefinitionReference(owner, 'child-process', node.process, [...path, 'process'], context);
+            addContractReference(owner, 'request-contract', node.contract, [...path, 'contract'], context);
+            addValueContract(owner, 'partition-output', node.partition?.contract);
+            addControlEdge(owner, node.completed, 'completed', [...path, 'completed'], context);
+            addControlEdge(owner, node.failed, 'failed', [...path, 'failed'], context);
+        },
+    },
+    repeatAcrossActivation: {
+        label: 'Repeat across activation',
+        project(node, owner, path, context) {
+            addValueContract(owner, 'progress', node.progressContract);
+            addValueContract(owner, 'state', node.stateContract);
+            addControlEdge(owner, node.repeat, 'repeat', [...path, 'repeat'], context);
+            addControlEdge(owner, node.completed, 'completed', [...path, 'completed'], context);
+            addControlEdge(owner, node.exhausted, 'exhausted', [...path, 'exhausted'], context);
+            addControlEdge(owner, node.stalled, 'stalled', [...path, 'stalled'], context);
+        },
+    },
+    cancellationFinalizer: {
+        label: 'Cancellation finalizer',
+        project(node, owner, path, context) {
+            addDefinitionReference(owner, 'cancellation-finalizer-process', node.process, [...path, 'process'], context);
+            addContractReference(owner, 'request-contract', node.contract, [...path, 'contract'], context);
+        },
+    },
+    return: {
+        label: 'Return',
+        terminal: true,
+        project() { },
+    },
+    fail: {
+        label: 'Fail',
+        terminal: true,
+        project() { },
+    },
+};
+const processAwaitClauseDispositions = {
+    interaction: {
+        label: 'Await interaction',
+        project(clause, owner, path, context) {
+            addContractReference(owner, 'interaction-contract', clause.contract, [...path, 'contract'], context);
+            addValueContract(owner, 'input', clause.input?.contract);
+        },
+    },
+    timer: {
+        label: 'Await timer',
+        project() { },
+    },
+};
+export const canonicalProcessPresentationDispositionKinds = Object.freeze(Object.keys(processNodeDispositions).sort());
+export const canonicalProcessAwaitClausePresentationDispositionKinds = Object.freeze(Object.keys(processAwaitClauseDispositions).sort());
+function projectRequestOutcomes(owner, rawOutcomes, path, context) {
+    forEachElement(rawOutcomes, path, context, (rawOutcome, outcomePath) => {
+        const id = readString(rawOutcome.id);
+        if (!id) {
+            missingElementId('Request outcome', outcomePath, owner, context);
+            return;
+        }
+        const role = readString(rawOutcome.outcome) ?? 'outcome';
+        const outcome = addElementNode({
+            canonicalId: id,
+            category: 'request-outcome',
+            context,
+            label: `Request outcome: ${role}`,
+            ownerId: owner.canonicalId,
+            path: outcomePath,
+            role,
+            source: rawOutcome,
+        });
+        if (!outcome) {
+            return;
+        }
+        addContainmentEdge(owner, outcome, 'outcome', outcomePath, context);
+        addContinuation(outcome, rawOutcome.continuation, role, [...outcomePath, 'continuation'], context);
+    });
+}
+function projectChoiceCases(owner, rawCases, path, context) {
+    forEachElement(rawCases, path, context, (rawCase, casePath) => {
+        const id = readString(rawCase.id);
+        if (!id) {
+            missingElementId('Choice case', casePath, owner, context);
+            return;
+        }
+        const choiceCase = addElementNode({
+            canonicalId: id,
+            category: 'choice-case',
+            context,
+            label: 'Choice case',
+            ownerId: owner.canonicalId,
+            path: casePath,
+            role: 'case',
+            source: rawCase,
+        });
+        if (!choiceCase) {
+            return;
+        }
+        addContainmentEdge(owner, choiceCase, 'case', casePath, context);
+        addControlEdge(choiceCase, rawCase.next, 'selected', [...casePath, 'next'], context);
+    });
+}
+function projectMatchCases(owner, rawCases, path, context) {
+    forEachElement(rawCases, path, context, (rawCase, casePath) => {
+        const id = readString(rawCase.id);
+        if (!id) {
+            missingElementId('Match case', casePath, owner, context);
+            return;
+        }
+        const matchCase = addElementNode({
+            canonicalId: id,
+            category: 'match-case',
+            context,
+            label: 'Match case',
+            ownerId: owner.canonicalId,
+            path: casePath,
+            role: 'case',
+            source: rawCase,
+        });
+        if (!matchCase) {
+            return;
+        }
+        const pattern = isRecord(rawCase.pattern) ? rawCase.pattern : null;
+        addValueContract(matchCase, 'pattern', pattern?.contract);
+        addContainmentEdge(owner, matchCase, 'case', casePath, context);
+        addControlEdge(matchCase, rawCase.next, 'selected', [...casePath, 'next'], context);
+    });
+}
+function projectFallback(owner, rawFallback, path, context) {
+    if (rawFallback === null || rawFallback === undefined) {
+        return;
+    }
+    if (!isRecord(rawFallback)) {
+        addDiagnostic(context.diagnostics, 'PROCESS_DEFINITION_INVALID', path, 'A Process fallback must be an object.', owner.canonicalId);
+        return;
+    }
+    const id = readString(rawFallback.id);
+    if (!id) {
+        missingElementId('Fallback', path, owner, context);
+        return;
+    }
+    const fallback = addElementNode({
+        canonicalId: id,
+        category: 'fallback',
+        context,
+        label: 'Fallback',
+        ownerId: owner.canonicalId,
+        path,
+        role: 'fallback',
+        source: rawFallback,
+    });
+    if (!fallback) {
+        return;
+    }
+    addContainmentEdge(owner, fallback, 'fallback', path, context);
+    addControlEdge(fallback, rawFallback.next, 'fallback', [...path, 'next'], context);
+}
+function projectForkBranches(owner, rawBranches, path, context) {
+    forEachElement(rawBranches, path, context, (rawBranch, branchPath) => {
+        const id = readString(rawBranch.id);
+        if (!id) {
+            missingElementId('Fork branch', branchPath, owner, context);
+            return;
+        }
+        const branch = addElementNode({
+            canonicalId: id,
+            category: 'fork-branch',
+            context,
+            label: 'Fork branch',
+            ownerId: owner.canonicalId,
+            path: branchPath,
+            role: readString(rawBranch.capacityDomain) ?? 'branch',
+            source: rawBranch,
+        });
+        if (!branch) {
+            return;
+        }
+        addContainmentEdge(owner, branch, 'branch', branchPath, context);
+        addControlEdge(branch, rawBranch.start, 'start', [...branchPath, 'start'], context);
+    });
+}
+function projectAwaitClauses(owner, rawClauses, path, context) {
+    forEachElement(rawClauses, path, context, (rawClause, clausePath) => {
+        const id = readString(rawClause.id);
+        if (!id) {
+            missingElementId('Await clause', clausePath, owner, context);
+            return;
+        }
+        const clauseKind = readString(rawClause.$clause);
+        const disposition = clauseKind && isCanonicalProcessAwaitClauseKind(clauseKind)
+            ? processAwaitClauseDispositions[clauseKind]
+            : null;
+        const clause = addElementNode({
+            canonicalId: id,
+            category: 'await-clause',
+            context,
+            label: disposition?.label ?? `Unsupported Await clause (${clauseKind ?? 'missing'})`,
+            ownerId: owner.canonicalId,
+            path: clausePath,
+            role: clauseKind ?? 'unknown',
+            source: rawClause,
+        });
+        if (!clause) {
+            return;
+        }
+        addContainmentEdge(owner, clause, 'clause', clausePath, context);
+        if (!disposition || !clauseKind) {
+            addDiagnostic(context.diagnostics, 'PROCESS_DEFINITION_INVALID', [...clausePath, '$clause'], `Await clause kind '${clauseKind ?? '<missing>'}' is unsupported.`, id);
+        }
+        else {
+            disposition.project(rawClause, clause, clausePath, context);
+        }
+        addContinuation(clause, rawClause.continuation, 'selected', [...clausePath, 'continuation'], context);
+    });
+}
+function projectJoinResults(owner, rawForkId, rawResult, path, context) {
+    if (rawResult === null || rawResult === undefined) {
+        return;
+    }
+    if (!isRecord(rawResult)) {
+        addDiagnostic(context.diagnostics, 'PROCESS_DEFINITION_INVALID', path, 'A Join result projection must be an object.', owner.canonicalId);
+        return;
+    }
+    const forkId = readString(rawForkId);
+    addValueContract(owner, 'join-result', rawResult.resultContract);
+    forEachElement(rawResult.branches, [...path, 'branches'], context, (rawBranch, branchPath) => {
+        const branchId = readString(rawBranch.branch);
+        if (!branchId) {
+            missingElementId('Join result branch', branchPath, owner, context);
+            return;
+        }
+        const result = addElementNode({
+            canonicalId: branchId,
+            category: 'join-result',
+            context,
+            label: 'Join branch result',
+            ownerId: owner.canonicalId,
+            path: branchPath,
+            registerConstruct: false,
+            role: 'result',
+            source: rawBranch,
+        });
+        if (!result) {
+            return;
+        }
+        addValueContract(result, 'join-result', rawResult.resultContract);
+        addContainmentEdge(owner, result, 'result', branchPath, context);
+        addDerivedEdge(result, processPresentationElementId('fork-branch', branchId, forkId), 'join-result', 'branch', branchPath, context);
+    });
+}
+function addElementNode({ canonicalId, category, context, label, ownerId = null, path, processNodeKind = null, registerConstruct = true, role = null, source, terminal = false, }) {
+    if (registerConstruct) {
+        const priorPath = context.constructPaths.get(canonicalId);
+        if (priorPath) {
+            addDiagnostic(context.diagnostics, 'PROCESS_ELEMENT_ID_DUPLICATED', path, `Canonical Process element identity '${canonicalId}' is duplicated; first observed at '${formatPath(priorPath)}'.`, canonicalId);
+            return null;
+        }
+        context.constructPaths.set(canonicalId, [...path]);
+    }
+    const id = processPresentationElementId(category, canonicalId, ownerId);
+    if (context.nodeIds.has(id)) {
+        return context.nodes.find((node) => node.id === id) ?? null;
+    }
+    const node = {
+        canonicalId,
+        category,
+        details: createDetails(source, path, context.document),
+        id,
+        label,
+        ownerId,
+        processNodeKind,
+        role,
+        terminal,
+    };
+    context.nodeIds.add(id);
+    context.nodes.push(node);
+    return node;
+}
+function addContainmentEdge(owner, child, role, path, context) {
+    addDerivedEdge(owner, child.id, 'contains', role, path, context);
+}
+function addDerivedEdge(owner, target, kind, role, path, context) {
+    const id = derivedEdgeId(kind, owner.id, target, role);
+    if (context.edges.some((edge) => edge.id === id)) {
+        return;
+    }
+    context.edges.push({
+        canonicalEdgeId: null,
+        details: createDetails(null, path, context.document),
+        id,
+        kind,
+        role,
+        source: owner.id,
+        target,
+    });
+    context.pendingTargets.push({ edge: context.edges.at(-1), path, targetCanonicalId: target });
+}
+function addControlEdge(owner, rawEdge, role, path, context) {
+    if (!isRecord(rawEdge)) {
+        addDiagnostic(context.diagnostics, 'PROCESS_EDGE_INVALID', path, `Process control edge '${role}' must be an object.`, owner.canonicalId);
+        return;
+    }
+    const edgeId = readString(rawEdge.id);
+    const targetCanonicalId = readString(rawEdge.target);
+    if (!edgeId || !targetCanonicalId) {
+        addDiagnostic(context.diagnostics, 'PROCESS_EDGE_INVALID', path, `Process control edge '${role}' requires stable edge and target identities.`, edgeId ?? owner.canonicalId);
+        return;
+    }
+    const priorPath = context.edgePaths.get(edgeId);
+    if (priorPath) {
+        addDiagnostic(context.diagnostics, 'PROCESS_ELEMENT_ID_DUPLICATED', path, `Canonical Process edge identity '${edgeId}' is duplicated; first observed at '${formatPath(priorPath)}'.`, edgeId);
+        return;
+    }
+    context.edgePaths.set(edgeId, [...path]);
+    const edge = {
+        canonicalEdgeId: edgeId,
+        details: createDetails(rawEdge, path, context.document),
+        id: `control/${encodeURIComponent(edgeId)}`,
+        kind: 'control',
+        role,
+        source: owner.id,
+        target: processPresentationElementId('process-node', targetCanonicalId),
+    };
+    context.edges.push(edge);
+    context.pendingTargets.push({ edge, path, targetCanonicalId });
+}
+function addContinuation(owner, rawContinuation, role, path, context) {
+    if (!isRecord(rawContinuation)) {
+        addDiagnostic(context.diagnostics, 'PROCESS_EDGE_INVALID', path, `Process continuation '${role}' must be an object.`, owner.canonicalId);
+        return;
+    }
+    const output = isRecord(rawContinuation.output) ? rawContinuation.output : null;
+    addValueContract(owner, `${role}-output`, output?.contract);
+    addControlEdge(owner, rawContinuation.edge, role, [...path, 'edge'], context);
+}
+function addContractReference(owner, role, rawContract, path, context) {
+    if (!isRecord(rawContract)) {
+        addDiagnostic(context.diagnostics, 'PROCESS_DEFINITION_REFERENCE_INVALID', path, `Interaction contract '${role}' must retain an exact definition reference.`, owner.canonicalId);
+        return;
+    }
+    addDefinitionReference(owner, role, rawContract.definition, [...path, 'definition'], context);
+}
+function addDefinitionReference(owner, role, rawReference, path, context) {
+    const reference = readDefinitionReference(rawReference);
+    if (!reference) {
+        addDiagnostic(context.diagnostics, 'PROCESS_DEFINITION_REFERENCE_INVALID', path, `Definition link '${role}' must retain definition id, revision id, and a complete fingerprint.`, owner.canonicalId);
+        return;
+    }
+    const frozenReference = cloneWireValue(reference);
+    owner.details.definitionReferences.push(deepFreeze({ reference: frozenReference, role }));
+    const key = definitionReferenceKey(reference);
+    const referenceNodeId = processPresentationDefinitionReferenceId(reference);
+    let referenceNode = context.nodes.find((node) => node.id === referenceNodeId);
+    if (!referenceNode) {
+        referenceNode = addElementNode({
+            canonicalId: key,
+            category: 'definition-reference',
+            context,
+            label: `Definition: ${reference.definitionId}`,
+            path,
+            registerConstruct: false,
+            role: 'definition',
+            source: reference,
+        }) ?? undefined;
+    }
+    if (!referenceNode) {
+        return;
+    }
+    const edgeId = derivedEdgeId('definition-reference', owner.id, referenceNode.id, role);
+    if (context.edges.some((edge) => edge.id === edgeId)) {
+        return;
+    }
+    context.edges.push({
+        canonicalEdgeId: null,
+        details: createDetails(reference, path, context.document),
+        id: edgeId,
+        kind: 'definition-reference',
+        role,
+        source: owner.id,
+        target: referenceNode.id,
+    });
+}
+function addValueContract(owner, role, rawContract) {
+    if (!isRecord(rawContract)) {
+        return;
+    }
+    owner.details.valueContracts.push(deepFreeze({
+        contract: cloneWireValue(rawContract),
+        role,
+    }));
+}
+function resolvePendingTargets(context) {
+    for (const pending of context.pendingTargets) {
+        if (context.nodeIds.has(pending.edge.target)) {
+            continue;
+        }
+        const targetCanonicalId = pending.edge.kind === 'control'
+            ? pending.targetCanonicalId
+            : pending.edge.target;
+        const unresolvedId = processPresentationElementId('unresolved-node', targetCanonicalId);
+        addElementNode({
+            canonicalId: targetCanonicalId,
+            category: 'unresolved-node',
+            context,
+            label: `Unresolved target: ${targetCanonicalId}`,
+            path: pending.path,
+            registerConstruct: false,
+            role: 'unresolved-target',
+            source: null,
+        });
+        pending.edge.target = unresolvedId;
+        addDiagnostic(context.diagnostics, 'PROCESS_EDGE_TARGET_UNRESOLVED', pending.path, `Projected edge '${pending.edge.id}' targets an unresolved semantic element.`, targetCanonicalId);
+    }
+}
+function verifyDispositionCompleteness(context) {
+    verifyInventoryDispositionCompleteness(canonicalProcessNodeKinds, Object.keys(processNodeDispositions), 'Process construct', context);
+    verifyInventoryDispositionCompleteness(canonicalProcessAwaitClauseKinds, Object.keys(processAwaitClauseDispositions), 'Process Await clause', context);
+}
+function verifyInventoryDispositionCompleteness(authoritativeValues, dispositionValues, label, context) {
+    const authoritative = new Set(authoritativeValues);
+    const dispositions = new Set(dispositionValues);
+    for (const kind of [...authoritative].sort()) {
+        if (!dispositions.has(kind)) {
+            addDiagnostic(context.diagnostics, 'PROCESS_CONSTRUCT_DISPOSITION_MISSING', [], `Canonical ${label} '${kind}' has no presentation disposition.`, kind);
+        }
+    }
+    for (const kind of [...dispositions].sort()) {
+        if (!authoritative.has(kind)) {
+            addDiagnostic(context.diagnostics, 'PROCESS_CONSTRUCT_DISPOSITION_STALE', [], `${label} presentation disposition '${kind}' is absent from the canonical inventory.`, kind);
+        }
+    }
+}
+function forEachElement(rawElements, path, context, project) {
+    if (!Array.isArray(rawElements)) {
+        addDiagnostic(context.diagnostics, 'PROCESS_DEFINITION_INVALID', path, 'A canonical Process element collection must be an array.');
+        return;
+    }
+    for (let index = 0; index < rawElements.length; index += 1) {
+        const elementPath = [...path, String(index)];
+        const element = rawElements[index];
+        if (!isRecord(element)) {
+            addDiagnostic(context.diagnostics, 'PROCESS_DEFINITION_INVALID', elementPath, 'A canonical Process element must be an object.');
+            continue;
+        }
+        project(element, elementPath);
+    }
+}
+function missingElementId(label, path, owner, context) {
+    addDiagnostic(context.diagnostics, 'PROCESS_ELEMENT_ID_REQUIRED', [...path, 'id'], `${label} requires a stable canonical identity.`, owner.canonicalId);
+}
+function createDetails(source, path, document) {
+    return {
+        definitionReferences: [],
+        source: cloneWireValue(source),
+        sourceMap: sourceMapForPath(document, path),
+        sourcePath: [...path],
+        valueContracts: [],
+    };
+}
+function sourceMapForPath(document, path) {
+    const entries = document.metadata?.sourceMap?.entries;
+    if (!Array.isArray(entries)) {
+        return [];
+    }
+    const definitionPath = path[0] === 'definition' ? path.slice(1) : path;
+    let deepest = -1;
+    const matches = [];
+    for (const entry of entries) {
+        const mapped = entry?.semanticPath?.segments;
+        if (!Array.isArray(mapped) ||
+            !isStringArray(mapped) ||
+            mapped.length < deepest ||
+            !isPrefix(mapped, definitionPath)) {
+            continue;
+        }
+        if (mapped.length > deepest) {
+            deepest = mapped.length;
+            matches.length = 0;
+        }
+        matches.push(entry);
+    }
+    return matches
+        .sort((left, right) => sourceMapKey(left).localeCompare(sourceMapKey(right)))
+        .map((entry) => cloneWireValue(entry));
+}
+function sortProjection(context) {
+    context.nodes.sort((left, right) => left.id.localeCompare(right.id));
+    context.edges.sort((left, right) => left.id.localeCompare(right.id));
+    context.diagnostics.sort((left, right) => left.id.localeCompare(right.id));
+}
+function freezeNode(node) {
+    return deepFreeze({
+        ...node,
+        details: freezeDetails(node.details),
+    });
+}
+function freezeEdge(edge) {
+    return deepFreeze({
+        ...edge,
+        details: freezeDetails(edge.details),
+    });
+}
+function freezeDetails(details) {
+    details.definitionReferences.sort((left, right) => `${left.role}:${definitionReferenceKey(left.reference)}`.localeCompare(`${right.role}:${definitionReferenceKey(right.reference)}`));
+    details.valueContracts.sort((left, right) => left.role.localeCompare(right.role));
+    return deepFreeze({
+        definitionReferences: details.definitionReferences,
+        source: details.source,
+        sourceMap: details.sourceMap,
+        sourcePath: details.sourcePath,
+        valueContracts: details.valueContracts,
+    });
+}
+function readDefinitionReference(raw) {
+    if (!isRecord(raw)) {
+        return null;
+    }
+    const definitionId = readString(raw.definitionId);
+    const revisionId = readString(raw.revisionId);
+    const fingerprint = readFingerprint(raw.fingerprint);
+    return definitionId && revisionId && fingerprint
+        ? { definitionId, fingerprint, revisionId }
+        : null;
+}
+function readFingerprint(raw) {
+    if (!isRecord(raw)) {
+        return null;
+    }
+    const algorithm = readString(raw.algorithm);
+    const canonicalization = readString(raw.canonicalization);
+    const value = readString(raw.value);
+    return algorithm && canonicalization && value
+        ? { algorithm, canonicalization, value }
+        : null;
+}
+function missingDefinitionReference(metadata) {
+    return deepFreeze({
+        definitionId: readString(metadata.definitionId) ?? '<missing>',
+        fingerprint: {
+            algorithm: '<missing>',
+            canonicalization: '<missing>',
+            value: '<missing>',
+        },
+        revisionId: readString(metadata.revisionId) ?? '<missing>',
+    });
+}
+function definitionReferenceKey(reference) {
+    return [
+        reference.definitionId,
+        reference.revisionId,
+        reference.fingerprint.algorithm,
+        reference.fingerprint.canonicalization,
+        reference.fingerprint.value,
+    ].join('|');
+}
+function addDiagnostic(diagnostics, code, path, message, subject = null, severity = 'error') {
+    diagnostics.push(deepFreeze({
+        code,
+        id: `diagnostic/${encodeURIComponent(code)}/${encodeURIComponent(formatPath(path))}/${encodeURIComponent(subject ?? '')}`,
+        message,
+        path: [...path],
+        severity,
+        subject,
+    }));
+}
+function freezeProjectionResult(graph, diagnostics) {
+    diagnostics.sort((left, right) => left.id.localeCompare(right.id));
+    return deepFreeze({ diagnostics: freezeDiagnostics(diagnostics), graph });
+}
+function freezeDiagnostics(diagnostics) {
+    return deepFreeze([...diagnostics]);
+}
+function derivedEdgeId(kind, source, target, role) {
+    return `derived/${encodeURIComponent(kind)}/${encodeURIComponent(source)}/${encodeURIComponent(role)}/${encodeURIComponent(target)}`;
+}
+function isCanonicalProcessNodeKind(value) {
+    return canonicalProcessNodeKinds.includes(value);
+}
+function isCanonicalProcessAwaitClauseKind(value) {
+    return canonicalProcessAwaitClauseKinds.includes(value);
+}
+function readString(value) {
+    return typeof value === 'string' && value.trim().length > 0 ? value : null;
+}
+function isStringArray(value) {
+    return value.every((item) => typeof item === 'string');
+}
+function isPrefix(prefix, value) {
+    return prefix.length <= value.length && prefix.every((segment, index) => segment === value[index]);
+}
+function sourceMapKey(source) {
+    return `${source.semanticPath?.segments.join('/') ?? ''}|${source.reference}|${source.description ?? ''}`;
+}
+function formatPath(path) {
+    return path.length === 0
+        ? '/'
+        : `/${path.map((segment) => segment.replaceAll('~', '~0').replaceAll('/', '~1')).join('/')}`;
+}
+//# sourceMappingURL=process-presentation-graph.js.map