@_linked/core 2.30.0 → 2.31.0

package/lib/esm/sparql/irToAlgebra.js

@@ -21,7 +21,19 @@ const XSD_DOUBLE = xsd.double.id;
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
+/**
+ * The IRI terms of triples (subjects, objects, ids of mutations and `.for()` targets) are built
+ * here, so this is where a blank-node label used as an id is refused: `_:b0` is SPARQL /
+ * N-Triples blank-node syntax, never an IRI (an IRI scheme starts with a letter). Filter
+ * expressions build their IRIs separately (`iri_expr`) and are not checked.
+ */
 function iriTerm(value) {
+    if (typeof value === 'string' && value.startsWith('_:')) {
+        throw new Error(`${JSON.stringify(value)} is a blank-node label, not an IRI. A blank node has no id to ` +
+            `address it by: it cannot be linked, updated with update().for() or deleted by id. ` +
+            `Change it through the property that holds it (replace or unset that property, or ` +
+            `delete its owner).`);
+    }
     return { kind: 'iri', value };
 }
 function varTerm(name) {
@@ -1422,55 +1434,84 @@ function fieldValueToTerms(value, options, datatype) {
     return [];
 }
 /**
- * The RDF-collection and SHACL-path predicates the cascade's blank-node block walks inside a
- * blank structure: the syntax core writes as blank nodes (`serializePathToNodeData`).
+ * True when the property's `sh:nodeKind` allows blank-node values (`sh:BlankNode`,
+ * `sh:BlankNodeOrIRI`, `sh:BlankNodeOrLiteral`). A nested create under such a property may be
+ * minted as a blank node, and a delete / replace through it removes its blank value.
  */
-const BLANK_SYNTAX_PREDICATES = [
-    rdf.first.id,
-    rdf.rest.id,
-    shacl.inversePath.id,
-    shacl.alternativePath.id,
-    shacl.zeroOrMorePath.id,
-    shacl.oneOrMorePath.id,
-    shacl.zeroOrOnePath.id,
-];
+function isBlankCapable(ps) {
+    var _a;
+    const nk = (_a = ps === null || ps === void 0 ? void 0 : ps.nodeKind) === null || _a === void 0 ? void 0 : _a.id;
+    return nk === shacl.BlankNode.id || nk === shacl.BlankNodeOrIRI.id || nk === shacl.BlankNodeOrLiteral.id;
+}
+/** `label` (shape) of a property shape, for error messages. */
+function describeProperty(propertyId) {
+    const ps = findPropertyShapeById(propertyId);
+    return (ps === null || ps === void 0 ? void 0 : ps.label) ? `'${ps.label}' (${propertyId})` : propertyId;
+}
 /**
- * A blank node is removed only by the cascade's blank-node block, which reaches it through a
- * `contains` edge, or, inside a blank structure, through a list / path syntax predicate
- * (`rdf:first` of a blank list cell). A blank node held any other way could never be deleted:
- * refuse to write one.
+ * How a nested create under `propertyId` is written, from the property's `sh:nodeKind`:
+ *
+ * | nodeKind | without id | with id |
+ * |---|---|---|
+ * | unset, `sh:IRI`, `sh:IRIOrLiteral` | IRI (minted) | IRI |
+ * | `sh:BlankNode` | blank node | error: a blank node has no id |
+ * | `sh:BlankNodeOrIRI` | blank node | IRI |
+ * | `sh:BlankNodeOrLiteral` | blank node | error: an IRI is not allowed |
+ * | `sh:Literal` | error | error |
+ *
+ * The rule is read from the receiving side's registry, so nothing about it travels on the wire.
  */
-function assertBlankIsOwned(data, propertyId, propertyTerm, parentIsBlank) {
-    var _a;
-    if (!data.blank || ((_a = findPropertyShapeById(propertyId)) === null || _a === void 0 ? void 0 : _a.contains))
-        return;
-    const syntaxEdge = parentIsBlank && propertyTerm.kind === 'iri' && BLANK_SYNTAX_PREDICATES.includes(propertyTerm.value);
-    if (syntaxEdge)
-        return;
-    throw new Error(`A blank nested node (__blank) must be the value of a \`contains\` property, or of a list / ` +
-        `path syntax predicate inside a blank node; ${propertyId} is neither, so nothing would ` +
-        `ever delete it.`);
+function nestedNodeKind(propertyId, data) {
+    var _a, _b;
+    const nk = (_b = (_a = findPropertyShapeById(propertyId)) === null || _a === void 0 ? void 0 : _a.nodeKind) === null || _b === void 0 ? void 0 : _b.id;
+    switch (nk) {
+        case shacl.BlankNodeOrIRI.id:
+            return data.id ? 'iri' : 'blank';
+        case shacl.BlankNode.id:
+        case shacl.BlankNodeOrLiteral.id:
+            if (data.id) {
+                throw new Error(`Property ${describeProperty(propertyId)} is ${nk === shacl.BlankNode.id ? 'sh:BlankNode' : 'sh:BlankNodeOrLiteral'}: ` +
+                    `its nested value is written as a blank node, which has no id, but the value carries ` +
+                    `the id ${data.id}.`);
+            }
+            return 'blank';
+        case shacl.Literal.id:
+            throw new Error(`Property ${describeProperty(propertyId)} is sh:Literal and cannot hold a nested node.`);
+        default:
+            return 'iri';
+    }
+}
+/**
+ * The triples of a nested create held by `subjectTerm` through `propertyId`: the edge, then the
+ * nested node's own triples. `blanks` is the create's label minter; without one (the update
+ * paths) a value that would be minted blank throws, see `generateNodeDataTriples`.
+ */
+function nestedCreateTriples(subjectTerm, propertyId, propertyTerm, data, options, blanks) {
+    var _a, _b;
+    const kind = nestedNodeKind(propertyId, data);
+    if (kind === 'blank' && !blanks) {
+        throw new Error(`Cannot write a blank node in an update: property ${describeProperty(propertyId)} allows ` +
+            `blank nodes and its nested value has no id. An update writes its INSERT once per WHERE ` +
+            `solution, which would duplicate the blank node. Write the value with the create of its ` +
+            `parent${((_b = (_a = findPropertyShapeById(propertyId)) === null || _a === void 0 ? void 0 : _a.nodeKind) === null || _b === void 0 ? void 0 : _b.id) === shacl.BlankNodeOrIRI.id ? ', or give it an id to write it as an IRI' : ''}.`);
+    }
+    const nested = generateNodeDataTriples(data, options, blanks, kind);
+    return [tripleOf(subjectTerm, propertyTerm, nested.term), ...nested.triples];
 }
 /**
  * Recursively generate triples for an IRNodeData (used in create and nested creates).
  * Returns the term used for this node and all generated triples.
  *
- * A node marked `blank` (nested only, see `NodeDescriptionValue.__blank`) becomes a fresh
- * blank node with its field triples and NO `rdf:type`: it is RDF syntax, like a SHACL path
- * operator, which the spec defines as a blank node that is the subject of exactly one triple.
- * Without a `blanks` minter (the update paths) a blank node throws.
+ * `kind` is decided by the caller from the property that holds the node (`nestedNodeKind`);
+ * the root of a create is always an IRI. A blank node gets a fresh label and only its field
+ * triples, no `rdf:type`: its shape is known from the property, and a SHACL path operator, the
+ * case blank nodes exist for here, must be the subject of exactly one triple.
  */
-function generateNodeDataTriples(data, options, blanks) {
+function generateNodeDataTriples(data, options, blanks, kind = 'iri') {
     const triples = [];
     let subjectTerm;
-    if (data.blank) {
-        if (data.id) {
-            throw new Error(`A blank nested node (__blank) cannot carry an id (${data.id}).`);
-        }
-        if (!blanks) {
-            throw new Error('A blank nested node (__blank) can only be written by a create. An update writes its ' +
-                'INSERT once per WHERE solution, which would duplicate the blank node.');
-        }
+    if (kind === 'blank') {
+        // Callers only pass 'blank' with a minter (`nestedCreateTriples` checks).
         subjectTerm = { kind: 'blank', label: `b${blanks.next++}` };
     }
     else {
@@ -1482,20 +1523,16 @@ function generateNodeDataTriples(data, options, blanks) {
     }
     // Field triples
     for (const field of data.fields) {
-        // Resolve the SHACL PropertyShapeData id to its declared `path` URI.
         const propertyTerm = resolvePropertyPredicateTerm(field.property);
-        if (field.value === null || field.value === undefined) {
+        // Skip undefined/null values in create
+        if (field.value === undefined || field.value === null) {
             continue;
         }
-        // Handle arrays (including mixed arrays of references and nested creates)
+        // Handle arrays (multi-value fields)
         if (Array.isArray(field.value)) {
             for (const item of field.value) {
                 if (item && typeof item === 'object' && 'shape' in item && 'fields' in item) {
-                    // Nested create
-                    assertBlankIsOwned(item, field.property, propertyTerm, !!data.blank);
-                    const nested = generateNodeDataTriples(item, options, blanks);
-                    triples.push(tripleOf(subjectTerm, propertyTerm, nested.term));
-                    triples.push(...nested.triples);
+                    triples.push(...nestedCreateTriples(subjectTerm, field.property, propertyTerm, item, options, blanks));
                 }
                 else {
                     const terms = fieldValueToTerms(item, options, resolvePropertyDatatype(field.property));
@@ -1508,13 +1545,10 @@ function generateNodeDataTriples(data, options, blanks) {
         }
         // Handle nested IRNodeData
         if (typeof field.value === 'object' && 'shape' in field.value && 'fields' in field.value) {
-            assertBlankIsOwned(field.value, field.property, propertyTerm, !!data.blank);
-            const nested = generateNodeDataTriples(field.value, options, blanks);
-            triples.push(tripleOf(subjectTerm, propertyTerm, nested.term));
-            triples.push(...nested.triples);
+            triples.push(...nestedCreateTriples(subjectTerm, field.property, propertyTerm, field.value, options, blanks));
             continue;
         }
-        // Simple values
+        // Simple value
         const terms = fieldValueToTerms(field.value, options, resolvePropertyDatatype(field.property));
         for (const term of terms) {
             triples.push(tripleOf(subjectTerm, propertyTerm, term));
@@ -1526,9 +1560,6 @@ function generateNodeDataTriples(data, options, blanks) {
  * Converts an IRCreateMutation to a SparqlInsertDataPlan.
  */
 export function createToAlgebra(query, options) {
-    if (query.data.blank) {
-        throw new Error('The root node of a create cannot be blank (__blank): it must be addressable.');
-    }
     const { triples } = generateNodeDataTriples(query.data, options, { next: 0 });
     return {
         type: 'insert_data',
@@ -1562,7 +1593,7 @@ function keptReferences(value) {
  * Shared between updateToAlgebra (IRI subject) and updateWhereToAlgebra (variable subject).
  */
 function processUpdateFields(data, subjectTerm, options) {
-    var _a, _b;
+    var _a, _b, _c;
     const deletePatterns = [];
     const insertPatterns = [];
     const oldValueTriples = [];
@@ -1580,7 +1611,8 @@ function processUpdateFields(data, subjectTerm, options) {
         // Only a `contains` property that declares a value shape deletes the old value's own
         // triples. Without one (a polymorphic slot like `sh:path`) the value may be a shared
         // IRI, so it is left to the cascade, which deletes it only when it is dependent-typed.
-        const hasValueShape = isContainsField && !!((_a = findPropertyShapeById(field.property)) === null || _a === void 0 ? void 0 : _a.valueShape);
+        const valueShapeId = isContainsField ? (_b = (_a = findPropertyShapeById(field.property)) === null || _a === void 0 ? void 0 : _a.valueShape) === null || _b === void 0 ? void 0 : _b.id : undefined;
+        const hasValueShape = !!valueShapeId;
         // Check for set modification ({add, remove})
         if (field.value &&
             typeof field.value === 'object' &&
@@ -1593,7 +1625,7 @@ function processUpdateFields(data, subjectTerm, options) {
             if (setMod.remove) {
                 // A value that is removed and added back in the same modification stays: its edge
                 // is deleted and re-inserted (a no-op), and the node itself is not touched.
-                const readdedIds = new Set(((_b = setMod.add) !== null && _b !== void 0 ? _b : []).filter(isBareNodeReference).map((ref) => ref.id));
+                const readdedIds = new Set(((_c = setMod.add) !== null && _c !== void 0 ? _c : []).filter(isBareNodeReference).map((ref) => ref.id));
                 setMod.remove.forEach((removeItem, ri) => {
                     const removeId = removeItem.id;
                     const removeTerm = iriTerm(removeId);
@@ -1607,6 +1639,13 @@ function processUpdateFields(data, subjectTerm, options) {
                             const self = buildOwnedSelfDelete(subjectTerm, propertyTerm, removeTerm, `ucr_${suffix}_${ri}_`);
                             deletePatterns.push(...self.deletePatterns);
                             cascadeOptionals.push(...self.whereOptionals);
+                            const blank = valueShapeId
+                                ? subjectBlankCascade(valueShapeId, removeTerm, [edge], `ucr_${suffix}_${ri}_vb_`)
+                                : null;
+                            if (blank) {
+                                deletePatterns.push(...blank.deletePatterns);
+                                cascadeOptionals.push(blank.whereBlock);
+                            }
                         }
                         // The edge leads the cascade too: with a zero-or-more path the removed node is
                         // itself a match, and it may only be deleted while it is still owned here.
@@ -1619,9 +1658,7 @@ function processUpdateFields(data, subjectTerm, options) {
             if (setMod.add) {
                 for (const addItem of setMod.add) {
                     if (addItem && typeof addItem === 'object' && 'shape' in addItem && 'fields' in addItem) {
-                        const nested = generateNodeDataTriples(addItem, options);
-                        insertPatterns.push(tripleOf(subjectTerm, propertyTerm, nested.term));
-                        insertPatterns.push(...nested.triples);
+                        insertPatterns.push(...nestedCreateTriples(subjectTerm, field.property, propertyTerm, addItem, options));
                     }
                     else {
                         const terms = fieldValueToTerms(addItem, options, resolvePropertyDatatype(field.property));
@@ -1633,6 +1670,16 @@ function processUpdateFields(data, subjectTerm, options) {
             }
             continue;
         }
+        // Replace / unset / overwrite of a blank-capable property: its old blank value and the
+        // blank nodes below it go (the branch binds `old_${suffix}` through the edge itself).
+        const fieldShape = findPropertyShapeById(field.property);
+        if (isBlankCapable(fieldShape)) {
+            const blank = buildBlankCascade([tripleOf(subjectTerm, propertyTerm, varTerm(`old_${suffix}`))], varTerm(`old_${suffix}`), null, blankWalkPredicates([fieldShape]), `ub_${suffix}_`);
+            if (blank) {
+                deletePatterns.push(...blank.deletePatterns);
+                cascadeOptionals.push(blank.whereBlock);
+            }
+        }
         // Non-set-modification replace of a `contains` property: cascade the old value's
         // subtree (every branch below binds `old_${suffix}` in the WHERE).
         if (isContainsField) {
@@ -1641,6 +1688,7 @@ function processUpdateFields(data, subjectTerm, options) {
                 propertyTerm,
                 keep: keptReferences(field.value),
                 hasValueShape,
+                valueShapeId,
             });
         }
         // Unset (undefined/null) — delete only
@@ -1657,9 +1705,7 @@ function processUpdateFields(data, subjectTerm, options) {
             oldValueTriples.push(tripleOf(subjectTerm, propertyTerm, oldVar));
             for (const item of field.value) {
                 if (item && typeof item === 'object' && 'shape' in item && 'fields' in item) {
-                    const nested = generateNodeDataTriples(item, options);
-                    insertPatterns.push(tripleOf(subjectTerm, propertyTerm, nested.term));
-                    insertPatterns.push(...nested.triples);
+                    insertPatterns.push(...nestedCreateTriples(subjectTerm, field.property, propertyTerm, item, options));
                 }
                 else {
                     const terms = fieldValueToTerms(item, options, resolvePropertyDatatype(field.property));
@@ -1675,9 +1721,7 @@ function processUpdateFields(data, subjectTerm, options) {
             const oldVar = varTerm(`old_${suffix}`);
             deletePatterns.push(tripleOf(subjectTerm, propertyTerm, oldVar));
             oldValueTriples.push(tripleOf(subjectTerm, propertyTerm, oldVar));
-            const nested = generateNodeDataTriples(field.value, options);
-            insertPatterns.push(tripleOf(subjectTerm, propertyTerm, nested.term));
-            insertPatterns.push(...nested.triples);
+            insertPatterns.push(...nestedCreateTriples(subjectTerm, field.property, propertyTerm, field.value, options));
             continue;
         }
         // IRExpression — computed value update (e.g. p.age.plus(1))
@@ -1728,12 +1772,20 @@ function processUpdateFields(data, subjectTerm, options) {
     // (exclusive ownership via the edge — backlog 032) then cascade any owned descendants.
     // Values re-sent as a bare `{id}` are kept: their blocks are filtered, so re-sending the
     // current value is a no-op (the edge is deleted and re-inserted).
-    containsOldVars.forEach(({ oldVar, propertyTerm, keep, hasValueShape }, n) => {
+    containsOldVars.forEach(({ oldVar, propertyTerm, keep, hasValueShape, valueShapeId }, n) => {
         const oldTerm = varTerm(oldVar);
         if (hasValueShape) {
             const self = buildOwnedSelfDelete(subjectTerm, propertyTerm, oldTerm, `uc${n}_`, keep);
             deletePatterns.push(...self.deletePatterns);
             cascadeOptionals.push(...self.whereOptionals);
+            // The old value's own blank values go with it.
+            const blank = valueShapeId
+                ? subjectBlankCascade(valueShapeId, oldTerm, [tripleOf(subjectTerm, propertyTerm, oldTerm)], `uc${n}_vb_`)
+                : null;
+            if (blank) {
+                deletePatterns.push(...blank.deletePatterns);
+                cascadeOptionals.push(keepFilter(blank.whereBlock, oldTerm, keep));
+            }
         }
         // 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
@@ -1971,6 +2023,27 @@ function ownedValueShapePredicates(shapeId) {
     }
     return [...predicates];
 }
+/**
+ * The blank-node cascade of the immediately-owned children of `shapeId` on `predicate` (see
+ * `ownedValueShapePredicates`): the blank values of every value shape its `contains` properties
+ * on that predicate declare. `ownerTriples` bind the child.
+ */
+function ownedChildBlankCascade(shapeId, predicate, childTerm, ownerTriples, varPrefix) {
+    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 [];
+    const valueShapes = new Set();
+    for (const ps of getPropertyShapes(nodeShape, true)) {
+        if (ps.contains && ((_c = ps.valueShape) === null || _c === void 0 ? void 0 : _c.id) && getSimplePathId(ps.path) === predicate) {
+            valueShapes.add(ps.valueShape.id);
+        }
+    }
+    return [...valueShapes].flatMap((valueShapeId, i) => {
+        const cascade = subjectBlankCascade(valueShapeId, childTerm, ownerTriples, `${varPrefix}${i}_`);
+        return cascade ? [cascade] : [];
+    });
+}
 /** True when the shape (or an ancestor) declares at least one `contains` property. */
 function shapeHasContainsProperty(shapeId) {
     var _a, _b;
@@ -1980,25 +2053,41 @@ function shapeHasContainsProperty(shapeId) {
     return getPropertyShapes(nodeShape, true)
         .some((ps) => ps.contains);
 }
-// Memoized registry scan for cascade lowering — called once per update/delete and
-// again per owned-cascade item inside loops. Guarded by registry size (same rationale
-// as predicateTermCache). Callers treat the result as read-only.
 let containmentCache = null;
 let containmentCacheSize = -1;
 /** Gather contains-predicate IRIs and dependent targetClass IRIs from the registry. */
 export function collectContainment() {
-    var _a;
+    var _a, _b, _c;
     const version = getRegistryVersion();
     if (containmentCache && version === containmentCacheSize) {
         return containmentCache;
     }
     const containsPreds = new Set();
     const dependentTypes = new Set();
+    const dependentBlankProps = new Map();
+    // Per targetClass, the predicates some shape targeting it declares NOT blank-capable.
+    const plainPredsByType = new Map();
     for (const nodeShape of getAllNodeShapes().values()) {
         if (!nodeShape)
             continue;
-        if (nodeShape.dependent && ((_a = nodeShape.targetClass) === null || _a === void 0 ? void 0 : _a.id)) {
-            dependentTypes.add(nodeShape.targetClass.id);
+        if ((_a = nodeShape.targetClass) === null || _a === void 0 ? void 0 : _a.id) {
+            const typeId = nodeShape.targetClass.id;
+            for (const ps of getPropertyShapes(nodeShape, true)) {
+                const predicate = getSimplePathId(ps.path);
+                if (!predicate || isBlankCapable(ps))
+                    continue;
+                if (!plainPredsByType.has(typeId))
+                    plainPredsByType.set(typeId, new Set());
+                plainPredsByType.get(typeId).add(predicate);
+            }
+        }
+        if (nodeShape.dependent && ((_b = nodeShape.targetClass) === null || _b === void 0 ? void 0 : _b.id)) {
+            const typeId = nodeShape.targetClass.id;
+            dependentTypes.add(typeId);
+            const blank = getPropertyShapes(nodeShape, true).filter(isBlankCapable);
+            if (blank.length > 0) {
+                dependentBlankProps.set(typeId, [...((_c = dependentBlankProps.get(typeId)) !== null && _c !== void 0 ? _c : []), ...blank]);
+            }
         }
         const propertyShapes = getPropertyShapes(nodeShape, false);
         for (const ps of propertyShapes) {
@@ -2009,7 +2098,24 @@ export function collectContainment() {
             }
         }
     }
-    containmentCache = { containsPreds: [...containsPreds], dependentTypes: [...dependentTypes] };
+    // A typed node only says its class, not which of the shapes targeting it wrote it. When the
+    // shapes disagree on a predicate (`PathList.first` is blank-capable, `List.first` is not, both
+    // target `rdf:List`), the cascade does not follow it: a user list's blank `rdf:first` member
+    // is content the list does not own.
+    for (const [typeId, props] of dependentBlankProps) {
+        const plain = plainPredsByType.get(typeId);
+        if (!plain)
+            continue;
+        const kept = props.filter((ps) => {
+            const predicate = getSimplePathId(ps.path);
+            return !!predicate && !plain.has(predicate);
+        });
+        if (kept.length > 0)
+            dependentBlankProps.set(typeId, kept);
+        else
+            dependentBlankProps.delete(typeId);
+    }
+    containmentCache = { containsPreds: [...containsPreds], dependentTypes: [...dependentTypes], dependentBlankProps };
     containmentCacheSize = version;
     return containmentCache;
 }
@@ -2085,6 +2191,202 @@ function reachableDependentTypes(shapeId) {
     reachableCache.set(shapeId, result);
     return result;
 }
+// ---------------------------------------------------------------------------
+// Blank-node cascade: blank values are deleted through the blank-capable properties
+// (`isBlankCapable`) that hold them, never through `contains`.
+// ---------------------------------------------------------------------------
+const shapeById = (id) => { var _a, _b; return (_b = (_a = getShapeClass(id)) === null || _a === void 0 ? void 0 : _a.shape) !== null && _b !== void 0 ? _b : getNodeShape(id); };
+/** The blank-capable property shapes of a shape (own and inherited) and of its sub-shapes. */
+function blankCapableProperties(shapeId) {
+    const out = [];
+    for (const sid of [shapeId, ...getSubShapes(shapeId).map((sub) => sub.id)]) {
+        const nodeShape = shapeById(sid);
+        if (!nodeShape)
+            continue;
+        for (const ps of getPropertyShapes(nodeShape, true)) {
+            if (isBlankCapable(ps))
+                out.push(ps);
+        }
+    }
+    return out;
+}
+/** The simple-path predicates of property shapes, deduplicated in order. */
+function simplePredicates(props) {
+    const predicates = new Set();
+    for (const ps of props) {
+        const predicate = getSimplePathId(ps.path);
+        if (predicate)
+            predicates.add(predicate);
+    }
+    return [...predicates];
+}
+let blankWalkCache = new Map();
+let blankWalkCacheVersion = -1;
+/**
+ * The predicates the blank-node cascade follows *below* a blank value held by one of `start`:
+ * the blank-capable properties of every shape the value (and, transitively, its blank values)
+ * can have — a property's value shape and its sub-shapes. A blank-capable property without a
+ * value shape is polymorphic (`sh:path`, the `PathNode` slots, `PathList.first`) and may hold
+ * any shape, so it yields every blank-capable predicate in the registry, the same rule
+ * `reachableDependentTypes` applies to `contains`. Precision is not what keeps the walk safe:
+ * `buildBlankCascade` refuses any node reached through an IRI.
+ */
+function blankWalkPredicates(start) {
+    const version = getRegistryVersion();
+    if (version !== blankWalkCacheVersion) {
+        blankWalkCache = new Map();
+        blankWalkCacheVersion = version;
+    }
+    const key = start.map((ps) => ps.id).join('|');
+    const cached = blankWalkCache.get(key);
+    if (cached)
+        return cached;
+    let everything = false;
+    const predicates = [];
+    const seen = new Set();
+    const queue = [];
+    const follow = (ps) => {
+        var _a;
+        if (!((_a = ps.valueShape) === null || _a === void 0 ? void 0 : _a.id)) {
+            everything = true;
+            return;
+        }
+        if (!seen.has(ps.valueShape.id)) {
+            seen.add(ps.valueShape.id);
+            queue.push(ps.valueShape.id);
+        }
+    };
+    start.forEach(follow);
+    while (queue.length > 0 && !everything) {
+        for (const ps of blankCapableProperties(queue.shift())) {
+            predicates.push(ps);
+            follow(ps);
+        }
+    }
+    if (everything) {
+        predicates.length = 0;
+        for (const nodeShape of getAllNodeShapes().values()) {
+            if (!nodeShape)
+                continue;
+            for (const ps of getPropertyShapes(nodeShape, false)) {
+                if (isBlankCapable(ps))
+                    predicates.push(ps);
+            }
+        }
+    }
+    const result = simplePredicates(predicates);
+    blankWalkCache.set(key, result);
+    return result;
+}
+/** A SPARQL property-path term over `predicates`: `(p1|…|pn)`, then `*` / `+` when given. */
+function predicatePathTerm(predicates, repeat) {
+    const step = predicates.length === 1 ? { id: predicates[0] } : { alt: predicates.map((id) => ({ id })) };
+    const expr = repeat === 'zeroOrMore' ? { zeroOrMore: step } : repeat === 'oneOrMore' ? { oneOrMore: step } : step;
+    return { kind: 'path', value: pathExprToSparql(expr), uris: collectPathUris(expr) };
+}
+const isBlankExpr = (name) => ({
+    kind: 'function_expr',
+    name: 'isBlank',
+    args: [{ kind: 'variable_expr', name }],
+});
+/**
+ * One UNION branch that deletes the blank values `owner` holds through `first`, and every blank
+ * node below them through `inner`:
+ *
+ * ```sparql
+ * DELETE { ?bn ?bnp ?bno }
+ * WHERE {
+ *   …ownerTriples…  <owner> (first…) ?bn0 . FILTER(isBlank(?bn0))
+ *   ?bn0 (inner…)* ?bn . ?bn ?bnp ?bno . FILTER(isBlank(?bn))
+ *   FILTER NOT EXISTS { ?bn0 (inner…)* ?mid . ?mid (inner…)+ ?bn . FILTER(!isBlank(?mid)) }
+ * }
+ * ```
+ *
+ * `first: null` means the owner term *is* the blank value (the old value of a replaced
+ * blank-capable property, bound by `ownerTriples`). Every deleted node is a blank node, so no IRI
+ * — a predicate such as `schema:image`, an entity a list merely lists — is ever deleted. The
+ * `NOT EXISTS` refuses a blank node reached *through* an IRI: a property path cannot constrain
+ * the nodes between its ends, and the walk may include every blank-capable predicate
+ * (`blankWalkPredicates`), so without it a blank list's `rdf:first` could lead into a listed
+ * entity and delete that entity's blank values. Blank structures core writes are trees, so the
+ * guard removes nothing they own. Returns null when there is nothing to follow.
+ */
+function buildBlankCascade(ownerTriples, ownerTerm, first, inner, varPrefix) {
+    if (first !== null && first.length === 0)
+        return null;
+    let bn0Name;
+    const reach = [...ownerTriples];
+    if (first === null) {
+        if (ownerTerm.kind !== 'variable')
+            return null;
+        bn0Name = ownerTerm.name;
+    }
+    else {
+        bn0Name = `${varPrefix}bn0`;
+        reach.push(tripleOf(ownerTerm, predicatePathTerm(first), varTerm(bn0Name)));
+    }
+    const bn0 = varTerm(bn0Name);
+    const reached = {
+        type: 'filter',
+        expression: isBlankExpr(bn0Name),
+        inner: { type: 'bgp', triples: reach },
+    };
+    const bp = varTerm(`${varPrefix}bnp`);
+    const bo = varTerm(`${varPrefix}bno`);
+    if (inner.length === 0) {
+        const own = tripleOf(bn0, bp, bo);
+        return {
+            deletePatterns: [own],
+            whereBlock: { type: 'join', left: reached, right: { type: 'bgp', triples: [own] } },
+        };
+    }
+    const bnName = `${varPrefix}bn`;
+    const bn = varTerm(bnName);
+    const mid = varTerm(`${varPrefix}bnm`);
+    const own = tripleOf(bn, bp, bo);
+    const throughIri = {
+        kind: 'exists_expr',
+        negated: true,
+        pattern: {
+            type: 'filter',
+            expression: { kind: 'not_expr', inner: isBlankExpr(`${varPrefix}bnm`) },
+            inner: {
+                type: 'bgp',
+                triples: [
+                    tripleOf(bn0, predicatePathTerm(inner, 'zeroOrMore'), mid),
+                    tripleOf(mid, predicatePathTerm(inner, 'oneOrMore'), bn),
+                ],
+            },
+        },
+    };
+    return {
+        deletePatterns: [own],
+        whereBlock: {
+            type: 'filter',
+            expression: { kind: 'logical_expr', op: 'and', exprs: [isBlankExpr(bnName), throughIri] },
+            inner: {
+                type: 'join',
+                // Filter the blank values before the inner walk runs from each of them.
+                left: reached,
+                right: {
+                    type: 'bgp',
+                    triples: [tripleOf(bn0, predicatePathTerm(inner, 'zeroOrMore'), bn), own],
+                },
+            },
+        },
+    };
+}
+/**
+ * The blank-node cascade of a subject: its blank values through the blank-capable properties of
+ * its shape, and their blank descendants. `ownerTriples` anchors a variable subject (the bulk
+ * deletes pass its type triple).
+ */
+function subjectBlankCascade(shapeId, subjectTerm, ownerTriples, varPrefix) {
+    const props = blankCapableProperties(shapeId);
+    if (props.length === 0)
+        return null;
+    return buildBlankCascade(ownerTriples, subjectTerm, simplePredicates(props), blankWalkPredicates(props), varPrefix);
+}
 /**
  * Build DELETE patterns + WHERE OPTIONAL blocks that cascade-delete the owned subtree
  * reachable from `rootTerm` via `contains` edges. `varPrefix` keeps generated variables
@@ -2132,50 +2434,24 @@ export function buildOwnedCascade(rootTerm, varPrefix, anchor, keep, onlyTypes)
             ],
         }, rootTerm, keep));
     });
-    // Blank nodes carry no type (a SHACL path operator must be the subject of exactly one
-    // triple), so the typed blocks above cannot see them. Every blank node owned through
-    // `contains` edges (`?b0`) is deleted, together with the RDF-list / SHACL-path syntax below it
-    // (`?bn`). That inner walk follows `rdf:first` too, because a sequence member that is itself a
-    // path operator is held by `rdf:first`, which is not a `contains` edge. It is restricted to the
-    // syntax predicates on purpose: SPARQL cannot require the nodes *between* `?b0` and `?bn` to be
-    // blank, so following every `contains` edge there would let a list's `rdf:first` lead into an
-    // entity it merely lists and delete that entity's blank children.
-    const insidePathExpr = { zeroOrMore: { alt: BLANK_SYNTAX_PREDICATES.map((id) => ({ id })) } };
-    const insidePathTerm = {
-        kind: 'path',
-        value: pathExprToSparql(insidePathExpr),
-        uris: collectPathUris(insidePathExpr),
-    };
-    const ownedBlank = varTerm(`${varPrefix}bn0`);
-    const blank = varTerm(`${varPrefix}bn`);
-    const bp = varTerm(`${varPrefix}bnp`);
-    const bo = varTerm(`${varPrefix}bno`);
-    const isBlank = (name) => ({
-        kind: 'function_expr',
-        name: 'isBlank',
-        args: [{ kind: 'variable_expr', name }],
+    // The blank values of every dependent node deleted above, through the blank-capable
+    // properties of its type's shapes (a property shape's `sh:path`). Blank nodes carry no type,
+    // so the typed blocks cannot see them; see `buildBlankCascade`.
+    dependentTypes.forEach((typeId, i) => {
+        const props = containment.dependentBlankProps.get(typeId);
+        if (!props)
+            return;
+        const owner = varTerm(`${varPrefix}bo${i}`);
+        const cascade = buildBlankCascade([
+            ...(anchor ? [anchor] : []),
+            tripleOf(rootTerm, pathTerm, owner),
+            tripleOf(owner, iriTerm(RDF_TYPE), iriTerm(typeId)),
+        ], owner, simplePredicates(props), blankWalkPredicates(props), `${varPrefix}b${i}_`);
+        if (!cascade)
+            return;
+        deletePatterns.push(...cascade.deletePatterns);
+        whereOptionals.push(keepFilter(cascade.whereBlock, rootTerm, keep));
     });
-    deletePatterns.push(tripleOf(blank, bp, bo));
-    whereOptionals.push(keepFilter({
-        type: 'filter',
-        expression: isBlank(`${varPrefix}bn`),
-        inner: {
-            type: 'join',
-            // Filter the owned blank nodes before the inner walk runs from each of them.
-            left: {
-                type: 'filter',
-                expression: isBlank(`${varPrefix}bn0`),
-                inner: {
-                    type: 'bgp',
-                    triples: [...(anchor ? [anchor] : []), tripleOf(rootTerm, pathTerm, ownedBlank)],
-                },
-            },
-            right: {
-                type: 'bgp',
-                triples: [tripleOf(ownedBlank, insidePathTerm, blank), tripleOf(blank, bp, bo)],
-            },
-        },
-    }, rootTerm, keep));
     return { deletePatterns, whereOptionals };
 }
 /**
@@ -2290,7 +2566,19 @@ export function deleteToAlgebra(query, _options) {
                 type: 'bgp',
                 triples: [tripleOf(subjectTerm, iriTerm(predicate), child), childOwn],
             });
+            // …and the child's own blank values.
+            for (const blank of ownedChildBlankCascade(query.shape, predicate, child, [tripleOf(subjectTerm, iriTerm(predicate), child)], `d${n}${idx}_b`)) {
+                deletePatterns.push(...blank.deletePatterns);
+                blocks.push(blank.whereBlock);
+            }
         });
+        // The subject's own blank values (through its blank-capable properties) and the blank
+        // nodes below them.
+        const blank = subjectBlankCascade(query.shape, subjectTerm, [], `b${idx}_`);
+        if (blank) {
+            deletePatterns.push(...blank.deletePatterns);
+            blocks.push(blank.whereBlock);
+        }
         // Cascade-delete the owned subtree — only for shapes that actually own something
         // (have a `contains` property); a plain entity delete is left untouched.
         if (hasContains && cascadeTypes.length > 0) {
@@ -2311,74 +2599,12 @@ export function deleteToAlgebra(query, _options) {
         whereAlgebra,
     };
 }
-// ---------------------------------------------------------------------------
-// Blank node tree walking for schema-aware delete cleanup
-// ---------------------------------------------------------------------------
-/**
- * Checks whether a PropertyShapeData points to blank nodes (sh:BlankNode or
- * sh:BlankNodeOrIRI). Returns true when the property's range *may* include
- * blank node values that should be cleaned up on delete.
- */
-function isBlankNodeProperty(prop) {
-    var _a;
-    const nk = (_a = prop.nodeKind) === null || _a === void 0 ? void 0 : _a.id;
-    if (!nk)
-        return false;
-    return nk === shacl.BlankNode.id || nk === shacl.BlankNodeOrIRI.id;
-}
-/**
- * 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)).
- *
- * - 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.
- *
- * 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 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;
-    const props = getPropertyShapes(nodeShape, true);
-    for (const prop of props) {
-        if (!isBlankNodeProperty(prop))
-            continue;
-        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],
-        };
-        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,
-            };
-        }
-        blocks.push(block);
-        if ((_c = prop.valueShape) === null || _c === void 0 ? void 0 : _c.id) {
-            blankNodeBlocks(prop.valueShape.id, bnVar, here, counter, deletePatterns, blocks);
-        }
-    }
-}
 /**
  * The 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 there is nothing to
  * clean up (the root wildcard then stays in the required BGP).
  *
- * - The blank-node blocks of the shape's blank-node properties.
+ * - The blank-node cascade of the shape's blank-capable properties (`subjectBlankCascade`).
  * - For a shape that owns something (a `contains` property), the same owned cleanup as a
  *   delete by id: the immediately-owned children of every `contains` property with a value
  *   shape, and the dependent cascade, rooted at the subject variable. Each owned block is led
@@ -2388,7 +2614,11 @@ function blankNodeBlocks(shapeId, parentVar, path, counter, deletePatterns, bloc
  */
 function bulkDeleteUnion(shapeId, subjectVar, rootWildcard, typeTriple, deletePatterns) {
     const blocks = [];
-    blankNodeBlocks(shapeId, subjectVar, { triples: [], bnVars: [] }, { next: 1 }, deletePatterns, blocks);
+    const blank = subjectBlankCascade(shapeId, varTerm(subjectVar), [typeTriple], 'b_');
+    if (blank) {
+        deletePatterns.push(...blank.deletePatterns);
+        blocks.push(blank.whereBlock);
+    }
     if (shapeHasContainsProperty(shapeId)) {
         const subject = varTerm(subjectVar);
         ownedValueShapePredicates(shapeId).forEach((predicate, n) => {
@@ -2399,6 +2629,10 @@ function bulkDeleteUnion(shapeId, subjectVar, rootWildcard, typeTriple, deletePa
                 type: 'bgp',
                 triples: [typeTriple, tripleOf(subject, iriTerm(predicate), child), childOwn],
             });
+            for (const blank of ownedChildBlankCascade(shapeId, predicate, child, [typeTriple, tripleOf(subject, iriTerm(predicate), child)], `d${n}_b`)) {
+                deletePatterns.push(...blank.deletePatterns);
+                blocks.push(blank.whereBlock);
+            }
         });
         const cascadeTypes = reachableDependentTypes(shapeId);
         if (cascadeTypes.length > 0) {