@software-dlc/cli 0.157.2

package/dist/local/workspace-merge.js

@@ -0,0 +1,703 @@
+import { createHash } from 'node:crypto';
+import { findIntroducedDanglingUiInstanceReferences, mergeDocumentCompositions, mergeUiInstanceTrees } from '@software-dlc/graph/computation';
+import { c4NodeTypeIssuesOnChangedNodes, portable_graph_schema } from '@software-dlc/graph/schema';
+import { canonicalizePortableGraph, stringifyCanonicalGraph, stringifyCanonicalJson } from './canonical.js';
+import { validateProjectionGraph } from './projection.js';
+import { differsOnlyInSignFields, pickSignedReference } from '@software-dlc/graph/schema';
+import { entityObjectHash } from './workspace-evidence-status.js';
+import { packageUsesByKey } from './workspace-scope.js';
+const MISSING_VALUE = Symbol('missing');
+function isRecord(value) {
+    return (value !== MISSING_VALUE &&
+        value !== null &&
+        typeof value === 'object' &&
+        !Array.isArray(value));
+}
+function valuesEqual(left, right) {
+    if (left === MISSING_VALUE || right === MISSING_VALUE)
+        return left === right;
+    return stringifyCanonicalJson(left) === stringifyCanonicalJson(right);
+}
+function fieldPath(parent_path, key) {
+    const escaped_key = key.replaceAll('~', '~0').replaceAll('/', '~1');
+    return `${parent_path}/${escaped_key}`;
+}
+const UI_SURFACE_PATHS = new Set([
+    '/data/data/ui_frame',
+    '/data/data/ui_component_definition'
+]);
+/**
+ * Merges a UI surface whose authored instance tree both sides edited by
+ * stable instance id instead of as one atomic `children` array. Returns
+ * undefined to fall back to the generic merge (and its existing conflict
+ * coordinates) when the tree is template-backed, conflicts by instance id, or
+ * the merge would break a slot or binding reference.
+ */
+function mergeUiSurfaceByInstanceId(input) {
+    if (input.entity_kind !== 'node' ||
+        !UI_SURFACE_PATHS.has(input.field_path) ||
+        !isRecord(input.base) ||
+        !isRecord(input.ours) ||
+        !isRecord(input.theirs)) {
+        return undefined;
+    }
+    const { base, ours, theirs } = input;
+    // Template deltas can only be expanded against the app template catalog.
+    const deltas = (surface) => surface.authored_tree_changes ?? MISSING_VALUE;
+    if (!valuesEqual(deltas(base), deltas(ours)) ||
+        !valuesEqual(deltas(base), deltas(theirs))) {
+        return undefined;
+    }
+    const trees = [base, ours, theirs].map((surface) => surface.root_instance_tree);
+    if (!trees.every((tree) => isRecord(tree)))
+        return undefined;
+    const [base_tree, ours_tree, theirs_tree] = trees;
+    if (valuesEqual(base_tree, ours_tree) ||
+        valuesEqual(base_tree, theirs_tree)) {
+        return undefined;
+    }
+    const tree_merge = mergeUiInstanceTrees(base_tree, ours_tree, theirs_tree);
+    if (!tree_merge.tree)
+        return undefined;
+    const withoutTree = ({ root_instance_tree: _tree, ...rest }) => rest;
+    const conflict_count = input.conflicts.length;
+    const rest = mergeValue({
+        ...input,
+        base: withoutTree(base),
+        ours: withoutTree(ours),
+        theirs: withoutTree(theirs)
+    });
+    const introduced = findIntroducedDanglingUiInstanceReferences({
+        merged: { owner: rest, tree: tree_merge.tree },
+        target: { owner: ours, tree: ours_tree },
+        source: { owner: theirs, tree: theirs_tree }
+    });
+    if (introduced.length) {
+        input.conflicts.splice(conflict_count);
+        return undefined;
+    }
+    return { ...rest, root_instance_tree: tree_merge.tree };
+}
+/**
+ * Merges a Document whose composition both sides edited by block id instead of
+ * as one atomic `blocks` array. Returns undefined to fall back to the generic
+ * merge and its existing conflict coordinates when blocks conflict by id or
+ * the merged composition would be invalid.
+ */
+function mergeDocumentByBlockId(input) {
+    if (input.entity_kind !== 'node' ||
+        input.field_path !== '/data/data/document' ||
+        !isRecord(input.base) ||
+        !isRecord(input.ours) ||
+        !isRecord(input.theirs)) {
+        return undefined;
+    }
+    const { base, ours, theirs } = input;
+    const compositions = [base, ours, theirs].map((document) => document.composition);
+    if (!compositions.every((composition) => isRecord(composition))) {
+        return undefined;
+    }
+    const [base_composition, ours_composition, theirs_composition] = compositions;
+    if (valuesEqual(base_composition, ours_composition) ||
+        valuesEqual(base_composition, theirs_composition)) {
+        return undefined;
+    }
+    const merged = mergeDocumentCompositions(base_composition, ours_composition, theirs_composition);
+    if (!merged.composition)
+        return undefined;
+    const withoutComposition = ({ composition: _composition, ...rest }) => rest;
+    const rest = mergeValue({
+        ...input,
+        base: withoutComposition(base),
+        ours: withoutComposition(ours),
+        theirs: withoutComposition(theirs)
+    });
+    return { ...rest, composition: merged.composition };
+}
+const ACCEPTANCE_CRITERIA_PATH = '/data/data/acceptance_criteria';
+/** The criteria of one side by id, or undefined when they are not a list keyed by unique string ids. */
+function criteriaById(value) {
+    const list = value === MISSING_VALUE ? [] : value;
+    if (!Array.isArray(list) ||
+        !list.every((criterion) => isRecord(criterion) && typeof criterion.id === 'string')) {
+        return undefined;
+    }
+    const byId = new Map(list.map((criterion) => [
+        criterion.id,
+        criterion
+    ]));
+    return byId.size === list.length ? byId : undefined;
+}
+/**
+ * Merges a node's acceptance criteria that both sides changed by criterion
+ * id instead of as one atomic array, as Documents merge by block id: two plans
+ * that change different criteria of one story both land, and only the same
+ * criterion changed on both sides conflicts, at
+ * `/data/data/acceptance_criteria/<id>`. Kept criteria take the order of the
+ * side that reordered them; new ones follow, the coordinator's first. Returns
+ * undefined to fall back to the generic merge when a side is not a list keyed
+ * by unique ids, or both sides reordered differently.
+ */
+function mergeAcceptanceCriteriaById(input) {
+    if (input.entity_kind !== 'node' ||
+        input.field_path !== ACCEPTANCE_CRITERIA_PATH ||
+        input.ours === MISSING_VALUE ||
+        input.theirs === MISSING_VALUE) {
+        return undefined;
+    }
+    const base = criteriaById(input.base);
+    const ours = criteriaById(input.ours);
+    const theirs = criteriaById(input.theirs);
+    if (!base || !ours || !theirs)
+        return undefined;
+    const keptOrder = (side) => [...side.keys()].filter((id) => base.has(id));
+    const base_order = [...base.keys()];
+    const kept = base_order.filter((id) => ours.has(id) && theirs.has(id));
+    const relative = (order) => order.filter((id) => kept.includes(id));
+    const ours_order = relative(keptOrder(ours));
+    const theirs_order = relative(keptOrder(theirs));
+    const base_relative = relative(base_order);
+    const same = (a, b) => a.length === b.length && a.every((id, index) => id === b[index]);
+    let order;
+    if (same(ours_order, base_relative))
+        order = theirs_order;
+    else if (same(theirs_order, base_relative) || same(ours_order, theirs_order))
+        order = ours_order;
+    else
+        return undefined;
+    // Criteria one side removed are merged too, so a removal against an edit conflicts.
+    const removed = base_order.filter((id) => !kept.includes(id));
+    const added = [
+        ...[...ours.keys()].filter((id) => !base.has(id)),
+        ...[...theirs.keys()].filter((id) => !base.has(id) && !ours.has(id))
+    ];
+    const merged = [];
+    for (const id of [...order, ...removed, ...added]) {
+        const value = mergeValue({
+            ...input,
+            base: base.get(id) ?? MISSING_VALUE,
+            ours: ours.get(id) ?? MISSING_VALUE,
+            theirs: theirs.get(id) ?? MISSING_VALUE,
+            field_path: fieldPath(ACCEPTANCE_CRITERIA_PATH, id)
+        });
+        if (value !== MISSING_VALUE)
+            merged.push(value);
+    }
+    return merged;
+}
+const EVIDENCE_PATH = '/data/meta/evidence';
+/**
+ * Merges an evidence set both sides changed per reference, by reference_id
+ * (docs/specs/evidence-claim-freshness.md, Merging signed evidence). Two
+ * versions of a reference that differ only in the fields sign writes do not
+ * conflict; the side kept is chosen after the entity merges, from its merged
+ * hash. Any other difference on one reference conflicts at that reference.
+ * Returns undefined to fall back to the generic merge when a set is not a
+ * reference list keyed by unique ids.
+ */
+function mergeEvidenceByReference(input) {
+    if ((input.entity_kind !== 'node' && input.entity_kind !== 'edge') ||
+        input.field_path !== EVIDENCE_PATH ||
+        !isRecord(input.ours) ||
+        !isRecord(input.theirs) ||
+        !(isRecord(input.base) || input.base === MISSING_VALUE)) {
+        return undefined;
+    }
+    const sides = [
+        isRecord(input.base) ? input.base : { references: [] },
+        input.ours,
+        input.theirs
+    ];
+    const lists = sides.map((side) => side.references);
+    if (!lists.every((list) => Array.isArray(list) &&
+        list.every((reference) => isRecord(reference) && typeof reference.reference_id === 'string') &&
+        new Set(list.map((reference) => reference.reference_id)).size ===
+            list.length)) {
+        return undefined;
+    }
+    const [base, ours, theirs] = lists.map((list) => new Map(list.map((reference) => [reference.reference_id, reference])));
+    const withoutReferences = ({ references: _references, symbolic_ref: _symbolic_ref, ...rest }) => rest;
+    const rest = mergeValue({
+        ...input,
+        base: isRecord(input.base) ? withoutReferences(input.base) : MISSING_VALUE,
+        ours: withoutReferences(input.ours),
+        theirs: withoutReferences(input.theirs)
+    });
+    // The importer's identity is one value: keys from two sides never combine.
+    const symbolicRef = (side) => isRecord(side) && side.symbolic_ref !== undefined
+        ? side.symbolic_ref
+        : MISSING_VALUE;
+    const [symbolic_before, symbolic_ours, symbolic_theirs] = [
+        input.base,
+        input.ours,
+        input.theirs
+    ].map(symbolicRef);
+    let symbolic_ref;
+    if (valuesEqual(symbolic_ours, symbolic_theirs))
+        symbolic_ref = symbolic_ours;
+    else if (valuesEqual(symbolic_ours, symbolic_before))
+        symbolic_ref = symbolic_theirs;
+    else if (valuesEqual(symbolic_theirs, symbolic_before))
+        symbolic_ref = symbolic_ours;
+    else
+        symbolic_ref = recordConflict({
+            ...input,
+            base: symbolic_before,
+            ours: symbolic_ours,
+            theirs: symbolic_theirs,
+            field_path: `${EVIDENCE_PATH}/symbolic_ref`
+        });
+    // Base order first, then additions by id, so both merge directions order alike.
+    const order = [
+        ...base.keys(),
+        ...[...new Set([...ours.keys(), ...theirs.keys()])]
+            .filter((id) => !base.has(id))
+            .sort()
+    ];
+    const references = [];
+    for (const reference_id of order) {
+        const before = base.get(reference_id) ?? MISSING_VALUE;
+        const left = ours.get(reference_id) ?? MISSING_VALUE;
+        const right = theirs.get(reference_id) ?? MISSING_VALUE;
+        let merged;
+        if (valuesEqual(left, right))
+            merged = left;
+        else if (valuesEqual(left, before))
+            merged = right;
+        else if (valuesEqual(right, before))
+            merged = left;
+        else if (isRecord(left) &&
+            isRecord(right) &&
+            differsOnlyInSignFields(left, right)) {
+            merged = pickSignedReference(left, right, null);
+            input.sign_ties?.push({
+                entity_id: input.entity_id,
+                references,
+                index: references.length,
+                ours: left,
+                theirs: right
+            });
+        }
+        else {
+            merged = recordConflict({
+                ...input,
+                base: before,
+                ours: left,
+                theirs: right,
+                field_path: `${EVIDENCE_PATH}/references/${reference_id}`
+            });
+        }
+        if (merged !== MISSING_VALUE)
+            references.push(merged);
+    }
+    return {
+        ...(isRecord(rest) ? rest : {}),
+        ...(symbolic_ref === MISSING_VALUE ? {} : { symbolic_ref }),
+        references
+    };
+}
+function mergeValue(input) {
+    if (valuesEqual(input.ours, input.theirs))
+        return input.ours;
+    if (valuesEqual(input.ours, input.base))
+        return input.theirs;
+    if (valuesEqual(input.theirs, input.base))
+        return input.ours;
+    const ui_surface = mergeUiSurfaceByInstanceId(input);
+    if (ui_surface)
+        return ui_surface;
+    const document = mergeDocumentByBlockId(input);
+    if (document)
+        return document;
+    const evidence = mergeEvidenceByReference(input);
+    if (evidence)
+        return evidence;
+    const criteria = mergeAcceptanceCriteriaById(input);
+    if (criteria)
+        return criteria;
+    if (isRecord(input.ours) &&
+        isRecord(input.theirs) &&
+        (isRecord(input.base) || input.base === MISSING_VALUE)) {
+        const base = isRecord(input.base) ? input.base : {};
+        const keys = new Set([
+            ...Object.keys(base),
+            ...Object.keys(input.ours),
+            ...Object.keys(input.theirs)
+        ]);
+        const merged = {};
+        for (const key of [...keys].sort()) {
+            const value = mergeValue({
+                base: Object.hasOwn(base, key) ? base[key] : MISSING_VALUE,
+                ours: Object.hasOwn(input.ours, key) ? input.ours[key] : MISSING_VALUE,
+                theirs: Object.hasOwn(input.theirs, key)
+                    ? input.theirs[key]
+                    : MISSING_VALUE,
+                entity_kind: input.entity_kind,
+                entity_id: input.entity_id,
+                field_path: fieldPath(input.field_path, key),
+                conflicts: input.conflicts,
+                resolutions: input.resolutions,
+                used_resolution_keys: input.used_resolution_keys,
+                sign_ties: input.sign_ties
+            });
+            if (value !== MISSING_VALUE) {
+                Object.defineProperty(merged, key, {
+                    value,
+                    enumerable: true,
+                    configurable: true,
+                    writable: true
+                });
+            }
+        }
+        return merged;
+    }
+    return recordConflict(input);
+}
+/** Records a conflict at the input's coordinate, or applies the resolution given for it. */
+function recordConflict(input) {
+    const conflict = {
+        entity_kind: input.entity_kind,
+        entity_id: input.entity_id,
+        field_path: input.field_path || '/',
+        reason: input.ours === MISSING_VALUE || input.theirs === MISSING_VALUE
+            ? 'delete_edit'
+            : 'both_modified'
+    };
+    const resolution_key = conflictKey(conflict);
+    const resolution = input.resolutions?.get(resolution_key);
+    if (resolution) {
+        input.used_resolution_keys?.add(resolution_key);
+        if (resolution.action === 'use_base')
+            return input.base;
+        if (resolution.action === 'use_coordinator')
+            return input.ours;
+        if (resolution.action === 'use_child')
+            return input.theirs;
+        if (resolution.action === 'delete')
+            return MISSING_VALUE;
+        if (resolution.action === 'set')
+            return resolution.value;
+        throw new Error('Unsupported graph merge resolution action.');
+    }
+    input.conflicts.push(conflict);
+    return input.ours;
+}
+function pinOf(use) {
+    if (!isRecord(use))
+        return '';
+    return `${String(use.version)}\u0000${String(use.content_hash)}`;
+}
+/**
+ * Merges package uses by package (and governed project): each use merges
+ * field by field, so two sides that change different uses both land, and an
+ * ordered override list both sides changed is one conflict at
+ * /package_uses/<key>/overrides. Overrides are written against the pin, so a
+ * use one side moved to another version (an accepted upgrade proposal, which
+ * rebased its overrides) and the other side changed too is one conflict at
+ * /package_uses/<key>: merged field by field, the moved pin could meet
+ * overrides written for the old one. No uses left means no key at all.
+ */
+function mergePackageUses(input) {
+    const base = packageUsesByKey(input.base);
+    const ours = packageUsesByKey(input.ours);
+    const theirs = packageUsesByKey(input.theirs);
+    const keys = new Set([
+        ...Object.keys(base),
+        ...Object.keys(ours),
+        ...Object.keys(theirs)
+    ]);
+    const uses = [];
+    for (const key of [...keys].sort()) {
+        const side = {
+            base: Object.hasOwn(base, key) ? base[key] : MISSING_VALUE,
+            ours: Object.hasOwn(ours, key) ? ours[key] : MISSING_VALUE,
+            theirs: Object.hasOwn(theirs, key) ? theirs[key] : MISSING_VALUE,
+            entity_kind: 'graph_metadata',
+            entity_id: 'package_uses',
+            field_path: fieldPath('/package_uses', key),
+            conflicts: input.conflicts,
+            resolutions: input.resolutions,
+            used_resolution_keys: input.used_resolution_keys
+        };
+        const both_changed = side.base !== MISSING_VALUE &&
+            side.ours !== MISSING_VALUE &&
+            side.theirs !== MISSING_VALUE &&
+            !valuesEqual(side.ours, side.base) &&
+            !valuesEqual(side.theirs, side.base) &&
+            !valuesEqual(side.ours, side.theirs);
+        const pin_moved = pinOf(side.ours) !== pinOf(side.base) ||
+            pinOf(side.theirs) !== pinOf(side.base);
+        const merged = both_changed && pin_moved ? recordConflict(side) : mergeValue(side);
+        if (merged !== MISSING_VALUE)
+            uses.push(merged);
+    }
+    return uses.length > 0 ? { package_uses: uses } : {};
+}
+function mergeEntityCollection(input) {
+    const base = new Map(input.base.map((entity) => [entity.id, entity]));
+    const ours = new Map(input.ours.map((entity) => [entity.id, entity]));
+    const theirs = new Map(input.theirs.map((entity) => [entity.id, entity]));
+    const entity_ids = new Set([
+        ...base.keys(),
+        ...ours.keys(),
+        ...theirs.keys()
+    ]);
+    const merged = [];
+    for (const entity_id of [...entity_ids].sort()) {
+        const conflicts_before = input.conflicts.length;
+        const sign_ties = [];
+        const value = mergeValue({
+            base: base.get(entity_id) ?? MISSING_VALUE,
+            ours: ours.get(entity_id) ?? MISSING_VALUE,
+            theirs: theirs.get(entity_id) ?? MISSING_VALUE,
+            entity_kind: input.entity_kind,
+            entity_id,
+            field_path: '',
+            conflicts: input.conflicts,
+            resolutions: input.resolutions,
+            used_resolution_keys: input.used_resolution_keys,
+            sign_ties
+        });
+        // A signed reference is kept by the entity's merged hash, known only now;
+        // when the entity conflicts, the rule's first step is skipped.
+        if (sign_ties.length &&
+            value !== MISSING_VALUE &&
+            input.conflicts.length === conflicts_before &&
+            (input.entity_kind === 'node' || input.entity_kind === 'edge')) {
+            const merged_hash = entityObjectHash(input.entity_kind, value);
+            for (const tie of sign_ties) {
+                tie.references[tie.index] = pickSignedReference(tie.ours, tie.theirs, merged_hash);
+            }
+        }
+        if (value !== MISSING_VALUE)
+            merged.push(value);
+    }
+    return merged;
+}
+function graphRootHash(graph) {
+    return `sha256:${createHash('sha256')
+        .update(stringifyCanonicalGraph(graph))
+        .digest('hex')}`;
+}
+const NODE_PARENT_CODES = new Set([
+    'GRAPH_NODE_PARENT_NOT_FOUND',
+    'GRAPH_NODE_PARENT_TYPE_NOT_ALLOWED'
+]);
+/**
+ * The merged graph's broken issues, with node parents checked. A parent issue
+ * one side already had is left out: a graph from a hosted branch may hold
+ * older pairs on nodes the merge does not touch, which a hosted apply accepts.
+ */
+export function introducedBrokenIssues(graph, inputs, graph_issues = validateProjectionGraph(graph, { node_parents: true }).issues) {
+    const broken = graph_issues
+        .filter((issue) => issue.status === 'broken')
+        .map((issue) => ({ code: issue.code, message: issue.message }));
+    if (!broken.some((issue) => NODE_PARENT_CODES.has(issue.code))) {
+        return broken;
+    }
+    const known = new Set(inputs.flatMap((input) => validateProjectionGraph(input, { node_parents: true })
+        .issues.filter((issue) => NODE_PARENT_CODES.has(issue.code))
+        .map((issue) => `${issue.code}\u0000${issue.message}`)));
+    return broken.filter((issue) => !NODE_PARENT_CODES.has(issue.code) ||
+        !known.has(`${issue.code}\u0000${issue.message}`));
+}
+const INTRODUCED_WARNING_LIMIT = 20;
+/** The strings a warning's details hold: the ids of the entities it names. */
+function detailStrings(value, into = new Set()) {
+    if (typeof value === 'string')
+        into.add(value);
+    else if (Array.isArray(value))
+        value.forEach((item) => detailStrings(item, into));
+    else if (value && typeof value === 'object') {
+        Object.values(value).forEach((item) => detailStrings(item, into));
+    }
+    return into;
+}
+/**
+ * The validation warnings a hosted save of `graph` would report that `base`
+ * did not, as `CODE: message` lines: a commit lists what it introduces, not
+ * what its base already had. A base warning of the same code and path covers
+ * one whose details name only entities it named, so renaming a node or
+ * resolving part of a group does not list it again; a warning without
+ * details is matched by its message. Past the limit, one line counts the rest.
+ * `graph_issues` reuses a validation of `graph` the caller already ran.
+ */
+export function introducedValidationWarnings(graph, base, graph_issues) {
+    const warnings = (issues) => issues.filter((issue) => issue.status === 'warning');
+    const site = (issue) => `${issue.code}\u0000${issue.path ?? ''}`;
+    const known = new Map();
+    for (const issue of warnings(validateProjectionGraph(base, { node_parents: true }).issues)) {
+        known.set(site(issue), [...(known.get(site(issue)) ?? []), issue]);
+    }
+    const covered = (issue) => (known.get(site(issue)) ?? []).some((prior) => {
+        if (!issue.details || !prior.details)
+            return prior.message === issue.message;
+        const named = detailStrings(prior.details);
+        return [...detailStrings(issue.details)].every((value) => named.has(value));
+    });
+    const introduced = warnings(graph_issues ?? validateProjectionGraph(graph, { node_parents: true }).issues)
+        .filter((issue) => !covered(issue))
+        .map((issue) => `${issue.code}: ${issue.message}`);
+    if (introduced.length <= INTRODUCED_WARNING_LIMIT)
+        return introduced;
+    return [
+        ...introduced.slice(0, INTRODUCED_WARNING_LIMIT),
+        `and ${introduced.length - INTRODUCED_WARNING_LIMIT} more validation warnings this commit introduces.`
+    ];
+}
+export function mergeLocalPortableGraphs(input) {
+    return mergePortableGraphsInternal(input);
+}
+function conflictKey(conflict) {
+    return [
+        conflict.entity_kind,
+        conflict.entity_id,
+        conflict.field_path,
+        conflict.reason
+    ].join('\u0000');
+}
+function mergePortableGraphsInternal(input) {
+    const base_graph = canonicalizePortableGraph(portable_graph_schema.parse(input.base_graph));
+    const coordinator_graph = canonicalizePortableGraph(portable_graph_schema.parse(input.coordinator_graph));
+    const child_graph = canonicalizePortableGraph(portable_graph_schema.parse(input.child_graph));
+    const input_roots = {
+        base_root_hash: graphRootHash(base_graph),
+        coordinator_root_hash: graphRootHash(coordinator_graph),
+        child_root_hash: graphRootHash(child_graph)
+    };
+    const conflicts = [];
+    const resolutions = input.resolutions
+        ? new Map(input.resolutions.map((resolution) => [
+            conflictKey(resolution),
+            resolution
+        ]))
+        : undefined;
+    const used_resolution_keys = new Set();
+    const graph_input = {
+        nodes: mergeEntityCollection({
+            base: base_graph.nodes,
+            ours: coordinator_graph.nodes,
+            theirs: child_graph.nodes,
+            entity_kind: 'node',
+            conflicts,
+            resolutions,
+            used_resolution_keys
+        }),
+        edges: mergeEntityCollection({
+            base: base_graph.edges,
+            ours: coordinator_graph.edges,
+            theirs: child_graph.edges,
+            entity_kind: 'edge',
+            conflicts,
+            resolutions,
+            used_resolution_keys
+        }),
+        paths: mergeEntityCollection({
+            base: base_graph.paths ?? [],
+            ours: coordinator_graph.paths ?? [],
+            theirs: child_graph.paths ?? [],
+            entity_kind: 'path',
+            conflicts,
+            resolutions,
+            used_resolution_keys
+        }),
+        path_relations: mergeEntityCollection({
+            base: base_graph.path_relations ?? [],
+            ours: coordinator_graph.path_relations ?? [],
+            theirs: child_graph.path_relations ?? [],
+            entity_kind: 'path_relation',
+            conflicts,
+            resolutions,
+            used_resolution_keys
+        }),
+        tags: mergeValue({
+            base: base_graph.tags ?? [],
+            ours: coordinator_graph.tags ?? [],
+            theirs: child_graph.tags ?? [],
+            entity_kind: 'graph_metadata',
+            entity_id: 'tags',
+            field_path: '/tags',
+            conflicts,
+            resolutions,
+            used_resolution_keys
+        }),
+        ...mergePackageUses({
+            base: base_graph.package_uses,
+            ours: coordinator_graph.package_uses,
+            theirs: child_graph.package_uses,
+            conflicts,
+            resolutions,
+            used_resolution_keys
+        })
+    };
+    if (conflicts.length > 0) {
+        return {
+            version: 1,
+            status: 'blocked_conflict',
+            ...input_roots,
+            conflicts
+        };
+    }
+    if (resolutions && used_resolution_keys.size !== resolutions.size) {
+        throw new Error('Resolution output contains a non-conflict coordinate.');
+    }
+    const graph = canonicalizePortableGraph(portable_graph_schema.parse(graph_input));
+    const root_hash = graphRootHash(graph);
+    // A field-level merge can break the node-type rules with a node neither side
+    // holds, as a type from one and acceptance criteria from the other
+    // (iss-477). A node equal to either side's version is that side's history,
+    // which reconcile and upstream integrate take in as it stands.
+    const changed_from_child = new Set(c4NodeTypeIssuesOnChangedNodes({ previous: child_graph, next: graph }).map((issue) => issue.node_id));
+    const issues = [
+        ...introducedBrokenIssues(graph, [coordinator_graph, child_graph]),
+        ...c4NodeTypeIssuesOnChangedNodes({
+            previous: coordinator_graph,
+            next: graph
+        })
+            .filter((issue) => changed_from_child.has(issue.node_id))
+            .map((issue) => ({
+            code: 'node_type_rule',
+            message: `node ${issue.node_id} at ${issue.path}: ${issue.message}`
+        }))
+    ];
+    if (issues.length > 0) {
+        return {
+            version: 1,
+            status: 'blocked_validation',
+            ...input_roots,
+            graph,
+            root_hash,
+            issues
+        };
+    }
+    return {
+        version: 1,
+        status: 'clean',
+        ...input_roots,
+        graph,
+        root_hash
+    };
+}
+export function resolveLocalPortableGraphMerge(input) {
+    const initial = mergePortableGraphsInternal({
+        base_graph: input.base_graph,
+        coordinator_graph: input.coordinator_graph,
+        child_graph: input.child_graph
+    });
+    if (initial.status !== 'blocked_conflict') {
+        throw new Error('Graph merge has no conflicts to resolve.');
+    }
+    const expected_keys = new Set(initial.conflicts.map(conflictKey));
+    const received_keys = input.resolutions.map(conflictKey);
+    if (received_keys.length !== expected_keys.size ||
+        new Set(received_keys).size !== received_keys.length ||
+        received_keys.some((key) => !expected_keys.has(key))) {
+        throw new Error('Resolution output must contain exactly one decision for every conflict.');
+    }
+    const resolved = mergePortableGraphsInternal({ ...input });
+    if (resolved.status === 'blocked_conflict') {
+        throw new Error('Resolution output left conflicts unresolved.');
+    }
+    return resolved;
+}
+//# sourceMappingURL=workspace-merge.js.map