@_linked/core 2.28.1 → 2.28.3

package/lib/esm/sparql/irToAlgebra.js

@@ -1641,7 +1641,10 @@ function processUpdateFields(data, subjectTerm, options) {
         const self = buildOwnedSelfDelete(subjectTerm, propertyTerm, oldTerm, `uc${n}_`);
         deletePatterns.push(...self.deletePatterns);
         cascadeOptionals.push(...self.whereOptionals);
-        const cascade = buildOwnedCascade(oldTerm, `uc${n}_`);
+        // Every cascade block binds `?old` itself through the owning edge, like the
+        // self-delete block does. Without it an absent old value leaves `?old` unbound and
+        // the block matches the owned subtree of EVERY node in the graph.
+        const cascade = buildOwnedCascade(oldTerm, `uc${n}_`, tripleOf(subjectTerm, propertyTerm, oldTerm));
         deletePatterns.push(...cascade.deletePatterns);
         cascadeOptionals.push(...cascade.whereOptionals);
     });
@@ -1699,21 +1702,80 @@ export function upsertToAlgebra(query, options) {
  * update path has always emitted.
  */
 function buildDeleteInsertPlan(query, options, opts) {
-    var _a, _b, _c;
     const subjectTerm = iriTerm(query.id);
     const result = processUpdateFields(query.data, subjectTerm, options);
+    const whereAlgebra = buildUpdateWhere({ type: 'bgp', triples: [] }, result, query.traversalPatterns, subjectTerm);
+    // The type triple leads the INSERT, mirroring `create`'s triple order.
+    const insertPatterns = (opts === null || opts === void 0 ? void 0 : opts.ensureType)
+        ? [
+            tripleOf(subjectTerm, iriTerm(RDF_TYPE), iriTerm(opts.ensureType)),
+            ...result.insertPatterns,
+        ]
+        : result.insertPatterns;
+    return {
+        type: 'delete_insert',
+        deletePatterns: result.deletePatterns,
+        insertPatterns,
+        whereAlgebra,
+    };
+}
+/** Left-nested UNION of `blocks` (at least one). */
+function unionOf(blocks) {
+    let union = blocks[0];
+    for (let i = 1; i < blocks.length; i++) {
+        union = { type: 'union', left: union, right: blocks[i] };
+    }
+    return union;
+}
+/** Every variable name an expression mentions, including inside EXISTS patterns. */
+function collectVariableNames(value, into) {
+    if (Array.isArray(value)) {
+        for (const item of value)
+            collectVariableNames(item, into);
+    }
+    else if (value && typeof value === 'object') {
+        const node = value;
+        if ((node.kind === 'variable_expr' || node.kind === 'variable') && typeof node.name === 'string') {
+            into.add(node.name);
+        }
+        if (node.kind === 'bound_expr' && typeof node.variable === 'string') {
+            into.add(node.variable);
+        }
+        for (const child of Object.values(value))
+            collectVariableNames(child, into);
+    }
+    return into;
+}
+/**
+ * The WHERE shared by `update`, `upsert` and `updateWhere`, on top of `base` (empty for
+ * an id-targeted update; the type guard and filter for an update-where).
+ *
+ * The old values and owned-cleanup blocks are independent of each other, so they are
+ * joined as ONE OPTIONAL over a UNION, never as a chain of OPTIONALs. A chain is a join:
+ * the old values of two multi-valued properties, or an owned node's own triples and its
+ * owned subtree, multiply into one solution per combination. A UNION yields each block's
+ * matches once, so the solutions add up, and the DELETE removes exactly the same triples
+ * (a template triple a solution leaves unbound is skipped). The OPTIONAL keeps one
+ * solution when nothing matches, so the INSERT still happens.
+ *
+ * Old values that a computed field's BIND reads stay in `base` as before, together with
+ * the traversals they need, because the BIND needs them bound in the same solution. With
+ * a single independent block the output is the one OPTIONAL it always was.
+ */
+function buildUpdateWhere(base, result, traversalPatterns, subjectTerm) {
+    var _a, _b;
     // Partition old-value/optional triples into subject-anchored ones and those
     // anchored on a traversal target variable (e.g. `?a1 <name> ?a1_name` from a
     // `p.bestFriend.name.ucase()` expression). Traversal-anchored triples MUST be
     // nested inside the same OPTIONAL group as their traversal edge — otherwise,
     // when the subject has no such edge, the leaf variable is unbound and the
     // property triple matches every entity in the graph (data-corruption bug).
-    const travTos = new Set(((_a = query.traversalPatterns) !== null && _a !== void 0 ? _a : []).map((t) => t.to));
+    const travTos = new Set((traversalPatterns !== null && traversalPatterns !== void 0 ? traversalPatterns : []).map((t) => t.to));
     const travAnchoredByTo = new Map();
     const subjectAnchored = [];
     for (const triple of result.oldValueTriples) {
         if (triple.subject.kind === 'variable' && travTos.has(triple.subject.name)) {
-            const list = (_b = travAnchoredByTo.get(triple.subject.name)) !== null && _b !== void 0 ? _b : [];
+            const list = (_a = travAnchoredByTo.get(triple.subject.name)) !== null && _a !== void 0 ? _a : [];
             list.push(triple);
             travAnchoredByTo.set(triple.subject.name, list);
         }
@@ -1721,36 +1783,50 @@ function buildDeleteInsertPlan(query, options, opts) {
             subjectAnchored.push(triple);
         }
     }
-    let whereAlgebra = wrapOldValueOptionals({ type: 'bgp', triples: [] }, subjectAnchored);
+    // Old values a BIND reads must share its solution; the rest are independent blocks.
+    const readByBinds = new Set();
+    for (const ext of result.extends)
+        collectVariableNames(ext.expression, readByBinds);
+    const correlated = [];
+    const independent = [];
+    for (const triple of subjectAnchored) {
+        const vars = collectVariableNames([triple.subject, triple.predicate, triple.object], new Set());
+        if ([...vars].some((v) => readByBinds.has(v))) {
+            correlated.push(triple);
+        }
+        else {
+            independent.push({ type: 'bgp', triples: [triple] });
+        }
+    }
+    let whereAlgebra = wrapOldValueOptionals(base, correlated);
     // Add traversal OPTIONAL patterns (for multi-segment expression refs). The
     // traversal edge and its dependent leaf property triples share one OPTIONAL
     // group so the leaf variable is scoped to the traversal target. These come
     // BEFORE expression BINDs since the BINDs reference the traversal variables.
-    if (query.traversalPatterns) {
-        for (const trav of query.traversalPatterns) {
-            const fromTerm = trav.from === '__mutation_subject__' ? subjectTerm : varTerm(trav.from);
-            const traversalTriple = tripleOf(fromTerm, 
-            // The declared `sh:path`, like every other predicate — not the property
-            // shape's own IRI, which identifies the description of the property.
-            resolvePropertyPredicateTerm(trav.property), varTerm(trav.to));
-            // The traversal edge binds the target var; each dependent leaf property is
-            // a nested OPTIONAL *within* that scope, so a missing optional property
-            // (e.g. a bestFriend with no hobby) doesn't drop the whole group, while an
-            // absent edge still leaves every leaf var unbound (no cross-entity match).
-            let travNode = { type: 'bgp', triples: [traversalTriple] };
-            for (const leaf of (_c = travAnchoredByTo.get(trav.to)) !== null && _c !== void 0 ? _c : []) {
-                travNode = {
-                    type: 'left_join',
-                    left: travNode,
-                    right: { type: 'bgp', triples: [leaf] },
-                };
-            }
-            whereAlgebra = { type: 'left_join', left: whereAlgebra, right: travNode };
+    for (const trav of traversalPatterns !== null && traversalPatterns !== void 0 ? traversalPatterns : []) {
+        const fromTerm = trav.from === '__mutation_subject__' ? subjectTerm : varTerm(trav.from);
+        const traversalTriple = tripleOf(fromTerm, 
+        // The declared `sh:path`, like every other predicate — not the property
+        // shape's own IRI, which identifies the description of the property.
+        resolvePropertyPredicateTerm(trav.property), varTerm(trav.to));
+        // The traversal edge binds the target var; each dependent leaf property is
+        // a nested OPTIONAL *within* that scope, so a missing optional property
+        // (e.g. a bestFriend with no hobby) doesn't drop the whole group, while an
+        // absent edge still leaves every leaf var unbound (no cross-entity match).
+        let travNode = { type: 'bgp', triples: [traversalTriple] };
+        for (const leaf of (_b = travAnchoredByTo.get(trav.to)) !== null && _b !== void 0 ? _b : []) {
+            travNode = {
+                type: 'left_join',
+                left: travNode,
+                right: { type: 'bgp', triples: [leaf] },
+            };
         }
+        whereAlgebra = { type: 'left_join', left: whereAlgebra, right: travNode };
     }
-    // Owned-subtree cascade OPTIONALs for replaced `contains` properties.
-    for (const optional of result.cascadeOptionals) {
-        whereAlgebra = { type: 'left_join', left: whereAlgebra, right: optional };
+    // Independent old values + owned-subtree cleanup for `contains` replace/remove.
+    const blocks = [...independent, ...result.cascadeOptionals];
+    if (blocks.length > 0) {
+        whereAlgebra = { type: 'left_join', left: whereAlgebra, right: unionOf(blocks) };
     }
     // Add BIND expressions for computed fields
     for (const ext of result.extends) {
@@ -1761,19 +1837,7 @@ function buildDeleteInsertPlan(query, options, opts) {
             expression: ext.expression,
         };
     }
-    // The type triple leads the INSERT, mirroring `create`'s triple order.
-    const insertPatterns = (opts === null || opts === void 0 ? void 0 : opts.ensureType)
-        ? [
-            tripleOf(subjectTerm, iriTerm(RDF_TYPE), iriTerm(opts.ensureType)),
-            ...result.insertPatterns,
-        ]
-        : result.insertPatterns;
-    return {
-        type: 'delete_insert',
-        deletePatterns: result.deletePatterns,
-        insertPatterns,
-        whereAlgebra,
-    };
+    return whereAlgebra;
 }
 // ---------------------------------------------------------------------------
 // Owned-subtree cascade
@@ -1833,8 +1897,11 @@ function collectContainment() {
  * Build DELETE patterns + WHERE OPTIONAL blocks that cascade-delete the owned subtree
  * reachable from `rootTerm` via `contains` edges. `varPrefix` keeps generated variables
  * unique across multiple roots in one query. Returns empty when nothing is owned.
+ *
+ * `anchor`, when given, leads every block: the triple that binds a variable root, so
+ * each block stays correct on its own (as a UNION branch) when no such root exists.
  */
-export function buildOwnedCascade(rootTerm, varPrefix) {
+export function buildOwnedCascade(rootTerm, varPrefix, anchor) {
     const { containsPreds, dependentTypes } = collectContainment();
     if (containsPreds.length === 0 || dependentTypes.length === 0) {
         return { deletePatterns: [], whereOptionals: [] };
@@ -1858,6 +1925,7 @@ export function buildOwnedCascade(rootTerm, varPrefix) {
         whereOptionals.push({
             type: 'bgp',
             triples: [
+                ...(anchor ? [anchor] : []),
                 tripleOf(rootTerm, pathTerm, owned),
                 tripleOf(owned, iriTerm(RDF_TYPE), iriTerm(typeId)),
                 tripleOf(owned, p, o),
@@ -1895,12 +1963,27 @@ export function buildOwnedSelfDelete(subjectTerm, propertyTerm, oldTerm, varPref
 }
 /**
  * Converts an IRDeleteMutation to a SparqlDeleteInsertPlan (DELETE + WHERE).
+ *
+ * The WHERE is the type guard of every id, joined with ONE UNION of independent
+ * blocks: per id its own triples, its incoming references and, for a shape that
+ * owns something, one block per dependent type of its owned subtree.
+ *
+ * The blocks must not be chained as OPTIONALs. A chain of OPTIONALs is a join, so
+ * the solutions multiply: own triples x incoming references x owned triples of each
+ * dependent type. Deleting one shape description with the shape sync's cascade
+ * produced ~27,000 solutions for ~130 triples and took over 30 seconds on Fuseki,
+ * which re-evaluates the cascade property path for every left-hand row. A UNION
+ * yields each block's matches once, so the solutions add up instead, and it deletes
+ * exactly the same triples: a DELETE template triple whose variables a solution
+ * leaves unbound is skipped, as it was for an OPTIONAL that did not match.
+ *
+ * The guards stay required for every id, as before: when any id is not of the
+ * shape, the WHERE has no solution and nothing is deleted.
  */
 export function deleteToAlgebra(query, _options) {
     const deletePatterns = [];
-    const requiredTriples = [];
-    const optionalTriples = [];
-    const cascadeOptionals = [];
+    const guards = [];
+    const blocks = [];
     for (let i = 0; i < query.ids.length; i++) {
         const subjectTerm = iriTerm(query.ids[i].id);
         const idx = query.ids.length > 1 ? `_${i}` : '';
@@ -1909,30 +1992,23 @@ export function deleteToAlgebra(query, _options) {
         const typeGuard = tripleOf(subjectTerm, iriTerm(RDF_TYPE), iriTerm(resolveShapeScanIri(query.shape)));
         // DELETE block: all patterns (subject-wildcard, object-wildcard, type)
         deletePatterns.push(subjWild, objWild, typeGuard);
-        // WHERE block: subject-wildcard and type guard are required;
-        // object-wildcard is OPTIONAL (entity may have no incoming references)
-        requiredTriples.push(subjWild, typeGuard);
-        optionalTriples.push(objWild);
+        // WHERE: the type guard is required; the subject's own triples and its
+        // incoming references (the entity may have none) are separate UNION blocks.
+        guards.push(typeGuard);
+        blocks.push({ type: 'bgp', triples: [subjWild] }, { type: 'bgp', triples: [objWild] });
         // Cascade-delete the owned subtree — only for shapes that actually own something
         // (have a `contains` property); a plain entity delete is left untouched.
         if (shapeHasContainsProperty(query.shape)) {
             const cascade = buildOwnedCascade(subjectTerm, `c${idx}_`);
             deletePatterns.push(...cascade.deletePatterns);
-            cascadeOptionals.push(...cascade.whereOptionals);
+            blocks.push(...cascade.whereOptionals);
         }
     }
-    // Build WHERE algebra: required BGP + OPTIONAL for each object-wildcard + cascade OPTIONALs
-    let whereAlgebra = { type: 'bgp', triples: requiredTriples };
-    for (const triple of optionalTriples) {
-        whereAlgebra = {
-            type: 'left_join',
-            left: whereAlgebra,
-            right: { type: 'bgp', triples: [triple] },
-        };
-    }
-    for (const optional of cascadeOptionals) {
-        whereAlgebra = { type: 'left_join', left: whereAlgebra, right: optional };
-    }
+    const whereAlgebra = {
+        type: 'join',
+        left: { type: 'bgp', triples: guards },
+        right: unionOf(blocks),
+    };
     return {
         type: 'delete_insert',
         deletePatterns,
@@ -1956,63 +2032,63 @@ function isBlankNodeProperty(prop) {
     return nk === shacl.BlankNode.id || nk === shacl.BlankNodeOrIRI.id;
 }
 /**
- * Recursively builds DELETE + WHERE patterns for blank-node-typed properties.
+ * Builds DELETE patterns + one WHERE block per blank node reachable from `parentVar`
+ * through blank-node-typed properties, recursing into each property's valueShape for
+ * nested blank nodes (e.g. Person → Address (blank) → GeoPoint (blank)).
  *
- * For each blank-node property on the shape:
- * - DELETE: `?bnVar ?pN ?oN .`  (wildcard all triples on the blank node)
- * - WHERE: `OPTIONAL { ?parent <property> ?bnVar . FILTER(isBlank(?bnVar)) . ?bnVar ?pN ?oN . }`
+ * - DELETE: `?bnN ?pN ?oN .` (wildcard all triples on the blank node)
+ * - WHERE block: the path of edges from the root down to `?bnN`, `?bnN ?pN ?oN`, and
+ *   `FILTER(isBlank(…))` for every blank node on that path.
  *
- * Recurses into the property's valueShape to handle nested blank nodes
- * (e.g. Person → Address (blank) → GeoPoint (blank)).
+ * Each block carries its own path from the root, so the blocks are independent of one
+ * another and are joined with a UNION by the caller. Nested as OPTIONALs, a node's
+ * triples multiplied with every blank node below and beside it.
  */
-function walkBlankNodeTree(shapeId, parentVar, depth, deletePatterns) {
+function blankNodeBlocks(shapeId, parentVar, path, counter, deletePatterns, blocks) {
     var _a, _b, _c;
     const nodeShape = (_b = (_a = getShapeClass(shapeId)) === null || _a === void 0 ? void 0 : _a.shape) !== null && _b !== void 0 ? _b : getNodeShape(shapeId);
     if (!nodeShape)
-        return null;
-    let optionals = null;
+        return;
     const props = getPropertyShapes(nodeShape, true);
     for (const prop of props) {
         if (!isBlankNodeProperty(prop))
             continue;
-        const bnVar = `bn${depth}`;
-        const pVar = `p${depth}`;
-        const oVar = `o${depth}`;
-        // DELETE pattern: wildcard all triples on the blank node
-        deletePatterns.push(tripleOf(varTerm(bnVar), varTerm(pVar), varTerm(oVar)));
-        // WHERE: parent --<property>--> ?bnVar
-        const traverseTriple = tripleOf(varTerm(parentVar), resolvePropertyPredicateTerm(prop.id), varTerm(bnVar));
-        // FILTER(isBlank(?bnVar))
-        const isBlankFilter = {
-            kind: 'function_expr',
-            name: 'isBlank',
-            args: [{ kind: 'variable_expr', name: bnVar }],
-        };
-        // ?bnVar ?pN ?oN
-        const wildcardTriple = tripleOf(varTerm(bnVar), varTerm(pVar), varTerm(oVar));
-        // Build inner pattern: traverse + filter + wildcard
-        let innerPattern = {
-            type: 'bgp',
-            triples: [traverseTriple, wildcardTriple],
+        const n = counter.next++;
+        const bnVar = `bn${n}`;
+        const wildcardTriple = tripleOf(varTerm(bnVar), varTerm(`p${n}`), varTerm(`o${n}`));
+        deletePatterns.push(wildcardTriple);
+        const here = {
+            triples: [
+                ...path.triples,
+                tripleOf(varTerm(parentVar), resolvePropertyPredicateTerm(prop.id), varTerm(bnVar)),
+            ],
+            bnVars: [...path.bnVars, bnVar],
         };
-        innerPattern = { type: 'filter', expression: isBlankFilter, inner: innerPattern };
-        // Recurse into valueShape for nested blank nodes
-        if ((_c = prop.valueShape) === null || _c === void 0 ? void 0 : _c.id) {
-            const nestedOptional = walkBlankNodeTree(prop.valueShape.id, bnVar, depth + 1, deletePatterns);
-            if (nestedOptional) {
-                innerPattern = { type: 'left_join', left: innerPattern, right: nestedOptional };
-            }
-        }
-        // Wrap in OPTIONAL (left_join)
-        if (optionals) {
-            optionals = { type: 'left_join', left: optionals, right: innerPattern };
+        let block = { type: 'bgp', triples: [...here.triples, wildcardTriple] };
+        for (const v of here.bnVars) {
+            block = {
+                type: 'filter',
+                expression: { kind: 'function_expr', name: 'isBlank', args: [{ kind: 'variable_expr', name: v }] },
+                inner: block,
+            };
         }
-        else {
-            optionals = innerPattern;
+        blocks.push(block);
+        if ((_c = prop.valueShape) === null || _c === void 0 ? void 0 : _c.id) {
+            blankNodeBlocks(prop.valueShape.id, bnVar, here, counter, deletePatterns, blocks);
         }
-        depth++;
     }
-    return optionals;
+}
+/**
+ * The blank-node cleanup blocks of a bulk delete, already joined with the root's own
+ * triples as ONE UNION so their matches add up instead of multiplying; `null` when the
+ * shape has no blank-node property (the root wildcard then stays in the required BGP).
+ */
+function bulkDeleteUnion(shapeId, subjectVar, rootWildcard, deletePatterns) {
+    const blocks = [];
+    blankNodeBlocks(shapeId, subjectVar, { triples: [], bnVars: [] }, { next: 1 }, deletePatterns, blocks);
+    if (blocks.length === 0)
+        return null;
+    return unionOf([{ type: 'bgp', triples: [rootWildcard] }, ...blocks]);
 }
 /**
  * Converts an IRDeleteAllMutation to a SparqlDeleteInsertPlan.
@@ -2026,15 +2102,13 @@ export function deleteAllToAlgebra(query, _options) {
     const deletePatterns = [
         tripleOf(varTerm(subjectVar), varTerm('p'), varTerm('o')),
     ];
-    // WHERE: type triple + root wildcard
+    // WHERE: type triple, then the root wildcard and the blank-node cleanup
     const typeTriple = tripleOf(varTerm(subjectVar), iriTerm(RDF_TYPE), iriTerm(resolveShapeScanIri(query.shape)));
     const rootWildcard = tripleOf(varTerm(subjectVar), varTerm('p'), varTerm('o'));
-    let whereAlgebra = { type: 'bgp', triples: [typeTriple, rootWildcard] };
-    // Walk blank node tree for cleanup
-    const blankNodeOptional = walkBlankNodeTree(query.shape, subjectVar, 1, deletePatterns);
-    if (blankNodeOptional) {
-        whereAlgebra = { type: 'left_join', left: whereAlgebra, right: blankNodeOptional };
-    }
+    const union = bulkDeleteUnion(query.shape, subjectVar, rootWildcard, deletePatterns);
+    const whereAlgebra = union
+        ? { type: 'join', left: { type: 'bgp', triples: [typeTriple] }, right: union }
+        : { type: 'bgp', triples: [typeTriple, rootWildcard] };
     return {
         type: 'delete_insert',
         deletePatterns,
@@ -2054,10 +2128,14 @@ export function deleteWhereToAlgebra(query, _options) {
     const deletePatterns = [
         tripleOf(varTerm(subjectVar), varTerm('p'), varTerm('o')),
     ];
-    // WHERE: type triple + root wildcard
+    // WHERE: type triple + the where clause; the root wildcard and blank-node cleanup follow
     const typeTriple = tripleOf(varTerm(subjectVar), iriTerm(RDF_TYPE), iriTerm(resolveShapeScanIri(query.shape)));
     const rootWildcard = tripleOf(varTerm(subjectVar), varTerm('p'), varTerm('o'));
-    let whereAlgebra = { type: 'bgp', triples: [typeTriple, rootWildcard] };
+    const union = bulkDeleteUnion(query.shape, subjectVar, rootWildcard, deletePatterns);
+    let whereAlgebra = {
+        type: 'bgp',
+        triples: union ? [typeTriple] : [typeTriple, rootWildcard],
+    };
     // Process where patterns (traversals from the where clause)
     const traverseTriples = [];
     const optionalPropertyTriples = [];
@@ -2077,10 +2155,8 @@ export function deleteWhereToAlgebra(query, _options) {
     // Convert and add filter expression
     const filterExpr = convertExpression(query.where, registry, []);
     whereAlgebra = { type: 'filter', expression: filterExpr, inner: whereAlgebra };
-    // Walk blank node tree for cleanup
-    const blankNodeOptional = walkBlankNodeTree(query.shape, subjectVar, 1, deletePatterns);
-    if (blankNodeOptional) {
-        whereAlgebra = { type: 'left_join', left: whereAlgebra, right: blankNodeOptional };
+    if (union) {
+        whereAlgebra = { type: 'join', left: whereAlgebra, right: union };
     }
     return {
         type: 'delete_insert',
@@ -2097,7 +2173,6 @@ export function deleteWhereToAlgebra(query, _options) {
  * filter conditions from the where clause.
  */
 export function updateWhereToAlgebra(query, options) {
-    var _a, _b, _c;
     const subjectTerm = varTerm('a0');
     const result = processUpdateFields(query.data, subjectTerm, options);
     // WHERE: type triple is always required
@@ -2122,62 +2197,11 @@ export function updateWhereToAlgebra(query, options) {
         whereAlgebra = { type: 'filter', expression: filterExpr, inner: whereAlgebra };
     }
     // Old-value triples anchored on a traversal *target* belong INSIDE that
-    // traversal's OPTIONAL group, not beside it. Emitted beside it, the leaf's
-    // subject variable is introduced by an OPTIONAL that shares no variable with
-    // anything to its left — a left join with no join condition, i.e. a cartesian
-    // product over every node in the store carrying that predicate. The following
-    // OPTIONAL cannot repair it: the variable is already bound, and OPTIONAL never
-    // removes rows. `updateToAlgebra` performs the same split; this path did not.
-    const travTos = new Set(((_a = query.traversalPatterns) !== null && _a !== void 0 ? _a : []).map((t) => t.to));
-    const travAnchoredByTo = new Map();
-    const subjectAnchored = [];
-    for (const triple of result.oldValueTriples) {
-        if (triple.subject.kind === 'variable' && travTos.has(triple.subject.name)) {
-            const list = (_b = travAnchoredByTo.get(triple.subject.name)) !== null && _b !== void 0 ? _b : [];
-            list.push(triple);
-            travAnchoredByTo.set(triple.subject.name, list);
-        }
-        else {
-            subjectAnchored.push(triple);
-        }
-    }
-    whereAlgebra = wrapOldValueOptionals(whereAlgebra, subjectAnchored);
-    // Add traversal OPTIONAL patterns (for multi-segment expression refs)
-    // These must come BEFORE expression BINDs since the BINDs reference traversal variables.
-    if (query.traversalPatterns) {
-        for (const trav of query.traversalPatterns) {
-            const fromTerm = trav.from === '__mutation_subject__' ? varTerm('a0') : varTerm(trav.from);
-            const traversalTriple = tripleOf(fromTerm, 
-            // The declared `sh:path`, like every other predicate — not the property
-            // shape's own IRI, which identifies the description of the property.
-            resolvePropertyPredicateTerm(trav.property), varTerm(trav.to));
-            // The edge binds the target variable; each dependent leaf property is a
-            // nested OPTIONAL within that scope, so a missing leaf does not drop the
-            // group while an absent edge leaves every leaf variable unbound.
-            let travNode = { type: 'bgp', triples: [traversalTriple] };
-            for (const leaf of (_c = travAnchoredByTo.get(trav.to)) !== null && _c !== void 0 ? _c : []) {
-                travNode = {
-                    type: 'left_join',
-                    left: travNode,
-                    right: { type: 'bgp', triples: [leaf] },
-                };
-            }
-            whereAlgebra = { type: 'left_join', left: whereAlgebra, right: travNode };
-        }
-    }
-    // Owned-subtree cascade OPTIONALs for replaced `contains` properties.
-    for (const optional of result.cascadeOptionals) {
-        whereAlgebra = { type: 'left_join', left: whereAlgebra, right: optional };
-    }
-    // Add BIND expressions for computed fields
-    for (const ext of result.extends) {
-        whereAlgebra = {
-            type: 'extend',
-            inner: whereAlgebra,
-            variable: ext.variable,
-            expression: ext.expression,
-        };
-    }
+    // traversal's OPTIONAL group, not beside it: beside it, the leaf's subject variable
+    // is introduced by an OPTIONAL that shares no variable with anything to its left — a
+    // cartesian product over every node carrying that predicate. `buildUpdateWhere` does
+    // that split for both update paths.
+    whereAlgebra = buildUpdateWhere(whereAlgebra, result, query.traversalPatterns, subjectTerm);
     return {
         type: 'delete_insert',
         deletePatterns: result.deletePatterns,