@_linked/core 2.30.1 → 2.32.0

package/lib/esm/sparql/irToAlgebra.js

@@ -6,12 +6,13 @@ import { rdf } from '../ontologies/rdf.js';
 import { shacl } from '../ontologies/shacl.js';
 import { xsd } from '../ontologies/xsd.js';
 import { getSimplePathId } from '../paths/normalizePropertyPath.js';
-import { getAllNodeShapes, getNodeShape, getRegistryVersion, getShapeClass, getSubShapes, getTargetClassId, } from '../utils/ShapeClass.js';
+import { getAllNodeShapes, getNodeShape, getRegistryVersion, getShapeClass, getSubShapes, getTargetClassId, isSubShapeOf, } from '../utils/ShapeClass.js';
 import { UnresolvedContextError } from '../queries/QueryContext.js';
 // ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------
 const RDF_TYPE = rdf.type.id;
+const RDF_NIL = rdf.nil.id;
 const XSD_DATETIME = xsd.dateTime.id;
 const XSD_DATE = xsd.date.id;
 const XSD_TIME = xsd.time.id;
@@ -21,7 +22,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 +1435,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 +1524,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 +1546,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 +1561,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',
@@ -1570,17 +1602,16 @@ function processUpdateFields(data, subjectTerm, options) {
     // Owned cleanup on `contains` replace/remove: dropping a `contains` edge must delete
     // the old object itself (its own triples) AND its owned subtree, not just unlink the
     // one-hop edge — otherwise the old node orphans (backlog 032).
-    const { containsPreds: updContainsPreds } = collectContainment();
     const containsOldVars = [];
     const cascadeOptionals = [];
     for (const field of data.fields) {
         const propertyTerm = resolvePropertyPredicateTerm(field.property);
         const suffix = propertySuffix(field.property);
-        const isContainsField = propertyTerm.kind === 'iri' && updContainsPreds.includes(propertyTerm.value);
-        // 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 fieldShape = findPropertyShapeById(field.property);
+        // Ownership is the property's own: a `contains` property with a value shape and a simple
+        // path (an IRI predicate term). A plain property on a predicate another shape declares
+        // `contains` owns nothing.
+        const valueShapeId = propertyTerm.kind === 'iri' && (fieldShape === null || fieldShape === void 0 ? void 0 : fieldShape.contains) ? (_a = fieldShape.valueShape) === null || _a === void 0 ? void 0 : _a.id : undefined;
         // Check for set modification ({add, remove})
         if (field.value &&
             typeof field.value === 'object' &&
@@ -1602,26 +1633,28 @@ function processUpdateFields(data, subjectTerm, options) {
                     oldValueTriples.push(edge);
                     // For a `contains` set, removing a value deletes the removed node itself
                     // (its own triples) and its owned subtree — exclusive ownership via the edge.
-                    if (isContainsField && !readdedIds.has(removeId)) {
-                        if (hasValueShape) {
-                            const self = buildOwnedSelfDelete(subjectTerm, propertyTerm, removeTerm, `ucr_${suffix}_${ri}_`);
-                            deletePatterns.push(...self.deletePatterns);
-                            cascadeOptionals.push(...self.whereOptionals);
+                    if (valueShapeId && !readdedIds.has(removeId)) {
+                        const prefix = `ucr_${suffix}_${ri}_`;
+                        const self = buildOwnedSelfDelete(subjectTerm, propertyTerm, removeTerm, prefix);
+                        deletePatterns.push(...self.deletePatterns);
+                        cascadeOptionals.push(...self.whereOptionals);
+                        const blank = subjectBlankCascade(valueShapeId, removeTerm, [edge], `${prefix}vb_`);
+                        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.
-                        const cascade = buildOwnedCascade(removeTerm, `ucr_${suffix}_${ri}_`, edge);
-                        deletePatterns.push(...cascade.deletePatterns);
-                        cascadeOptionals.push(...cascade.whereOptionals);
+                        // The edge leads every branch: the removed node's subtree may only be deleted
+                        // while the node is still owned here.
+                        const owned = ownedSubtreeBlocks(valueShapeId, removeTerm, [edge], prefix);
+                        deletePatterns.push(...owned.deletePatterns);
+                        cascadeOptionals.push(...owned.whereBlocks);
                     }
                 });
             }
             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,14 +1666,23 @@ 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).
+        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) {
+        if (valueShapeId) {
             containsOldVars.push({
                 oldVar: `old_${suffix}`,
                 propertyTerm,
                 keep: keptReferences(field.value),
-                hasValueShape,
+                valueShapeId,
             });
         }
         // Unset (undefined/null) — delete only
@@ -1657,9 +1699,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 +1715,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,19 +1766,24 @@ 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, 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);
-        }
-        // 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), keep);
-        deletePatterns.push(...cascade.deletePatterns);
-        cascadeOptionals.push(...cascade.whereOptionals);
+        const edge = tripleOf(subjectTerm, propertyTerm, oldTerm);
+        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 = subjectBlankCascade(valueShapeId, oldTerm, [edge], `uc${n}_vb_`);
+        if (blank) {
+            deletePatterns.push(...blank.deletePatterns);
+            cascadeOptionals.push(keepFilter(blank.whereBlock, oldTerm, keep));
+        }
+        // Every subtree branch binds `?old` itself through the owning edge, like the self-delete
+        // block does. Without it an absent old value leaves `?old` unbound and the branch matches
+        // the owned subtree of EVERY node in the graph.
+        const owned = ownedSubtreeBlocks(valueShapeId, oldTerm, [edge], `uc${n}_`, keep);
+        deletePatterns.push(...owned.deletePatterns);
+        cascadeOptionals.push(...owned.whereBlocks);
     });
     return {
         deletePatterns,
@@ -1934,249 +1977,549 @@ function buildUpdateWhere(base, result, traversalPatterns, subjectTerm) {
     return whereAlgebra;
 }
 // ---------------------------------------------------------------------------
-// Owned-subtree cascade
-//
-// Composition cleanup driven by two declarative flags:
-//   - a property marked `contains` → the cascade FOLLOWS that edge,
-//   - a shape marked `dependent`   → its instances may be DELETED when reached.
-// Both are read from the live registry, so no vocabulary is hardcoded. From a root
-// node we follow `(c1|c2|…)*` over all contains predicates (zero hops included, so a
-// dependent-typed root is itself a match) and, for each dependent targetClass,
-// wildcard-delete the reached typed nodes. Requiring an asserted `?owned a <dependentType>`
-// naturally excludes shared predicate IRIs (e.g. a simple `sh:path`) and `rdf:nil` (never
-// typed), so only owned structural nodes are removed.
-//
-// Whether a field owns its value is decided per predicate across the registry
-// (`collectContainment`): the replace and set-remove deletes, and the class check in
-// `ownedLinkCheck.ts`, apply that same rule. The subject deletes (by id and bulk) use the
-// deleted shape's own `contains` properties with a value shape for the immediate children.
+// Blank-node cascade: blank values are deleted through the blank-capable properties
+// (`isBlankCapable`) that hold them, never through `contains`.
 // ---------------------------------------------------------------------------
-/**
- * The simple-path predicates of the shape's own and inherited `contains` properties that
- * declare a value shape, deduplicated in declaration order. These are the properties
- * whose immediate values a subject delete removes.
- */
-function ownedValueShapePredicates(shapeId) {
-    var _a, _b;
-    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 predicates = new Set();
-    for (const ps of getPropertyShapes(nodeShape, true)) {
-        if (!ps.contains || !ps.valueShape)
+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];
 }
-/** True when the shape (or an ancestor) declares at least one `contains` property. */
-function shapeHasContainsProperty(shapeId) {
-    var _a, _b;
-    const nodeShape = (_b = (_a = getShapeClass(shapeId)) === null || _a === void 0 ? void 0 : _a.shape) !== null && _b !== void 0 ? _b : getNodeShape(shapeId);
-    if (!nodeShape)
-        return false;
-    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;
-    const version = getRegistryVersion();
-    if (containmentCache && version === containmentCacheSize) {
-        return containmentCache;
-    }
-    const containsPreds = new Set();
-    const dependentTypes = new Set();
-    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);
-        }
-        const propertyShapes = getPropertyShapes(nodeShape, false);
-        for (const ps of propertyShapes) {
-            if (ps.contains) {
-                const predId = getSimplePathId(ps.path);
-                if (predId)
-                    containsPreds.add(predId);
-            }
-        }
-    }
-    containmentCache = { containsPreds: [...containsPreds], dependentTypes: [...dependentTypes] };
-    containmentCacheSize = version;
-    return containmentCache;
-}
-let reachableCache = new Map();
-let reachableCacheVersion = -1;
+let blankWalkCache = new Map();
+let blankWalkCacheVersion = -1;
 /**
- * The dependent targetClasses a subject delete of `shapeId` can reach through `contains`
- * edges, in `collectContainment` order. A subject delete emits one cascade block per type it
- * returns, and each block is a property-path closure per subject, so a shape that owns only
- * non-dependent values (every `Thing.image` owner) pays for none.
- *
- * The walk starts at the shape and its registered sub-shapes and follows every flattened
- * property on a `contains` predicate (the registry-wide predicate rule the cascade path uses)
- * to its value shape and that shape's sub-shapes. A property on a `contains` predicate with no
- * value shape is polymorphic (`sh:path`) and may reach anything, so it yields every dependent
- * type; that keeps the shape-sync delete of a NodeShape exact.
+ * 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. Precision is not what
+ * keeps the walk safe:
+ * `buildBlankCascade` refuses any node reached through an IRI.
  */
-function reachableDependentTypes(shapeId) {
-    var _a, _b;
+function blankWalkPredicates(start) {
     const version = getRegistryVersion();
-    if (version !== reachableCacheVersion) {
-        reachableCache = new Map();
-        reachableCacheVersion = version;
+    if (version !== blankWalkCacheVersion) {
+        blankWalkCache = new Map();
+        blankWalkCacheVersion = version;
     }
-    const cached = reachableCache.get(shapeId);
+    const key = start.map((ps) => ps.id).join('|');
+    const cached = blankWalkCache.get(key);
     if (cached)
         return cached;
-    const { containsPreds, dependentTypes } = collectContainment();
-    const shapeOf = (id) => { var _a, _b; return (_b = (_a = getShapeClass(id)) === null || _a === void 0 ? void 0 : _a.shape) !== null && _b !== void 0 ? _b : getNodeShape(id); };
-    const reached = new Set();
-    // Shapes whose instances an owned edge can lead to. The start shapes join only when an
-    // edge leads back to them (a dependent shape that owns its own kind, like a list cell).
-    const owned = new Set();
+    let everything = false;
+    const predicates = [];
     const seen = new Set();
     const queue = [];
-    const visit = (id, viaEdge) => {
-        for (const sid of [id, ...getSubShapes(id).map((sub) => sub.id)]) {
-            if (viaEdge)
-                owned.add(sid);
-            if (seen.has(sid))
-                continue;
-            seen.add(sid);
-            queue.push(sid);
+    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);
         }
     };
-    visit(shapeId, false);
-    let everything = false;
+    start.forEach(follow);
     while (queue.length > 0 && !everything) {
-        const nodeShape = shapeOf(queue.shift());
-        if (!nodeShape)
-            continue;
-        for (const ps of getPropertyShapes(nodeShape, true)) {
-            const predicate = getSimplePathId(ps.path);
-            if (!predicate || !containsPreds.includes(predicate))
-                continue;
-            if (!((_a = ps.valueShape) === null || _a === void 0 ? void 0 : _a.id)) {
-                everything = true;
-                break;
-            }
-            visit(ps.valueShape.id, true);
+        for (const ps of blankCapableProperties(queue.shift())) {
+            predicates.push(ps);
+            follow(ps);
         }
     }
-    if (!everything) {
-        for (const id of owned) {
-            const nodeShape = shapeOf(id);
-            const dependent = nodeShape === null || nodeShape === void 0 ? void 0 : nodeShape.dependent;
-            if (dependent && ((_b = nodeShape === null || nodeShape === void 0 ? void 0 : nodeShape.targetClass) === null || _b === void 0 ? void 0 : _b.id)) {
-                reached.add(nodeShape.targetClass.id);
+    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 = everything ? dependentTypes : dependentTypes.filter((t) => reached.has(t));
-    reachableCache.set(shapeId, result);
+    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 }],
+});
 /**
- * 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.
+ * 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)) }
+ * }
+ * ```
  *
- * `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.
- * `onlyTypes`, when given, restricts the blocks to those dependent types (a subject delete
- * passes the types its shape can reach); by default every registered dependent type gets one.
+ * `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.
  */
-export function buildOwnedCascade(rootTerm, varPrefix, anchor, keep, onlyTypes) {
-    const containment = collectContainment();
-    const { containsPreds } = containment;
-    const dependentTypes = onlyTypes !== null && onlyTypes !== void 0 ? onlyTypes : containment.dependentTypes;
-    if (containsPreds.length === 0 || dependentTypes.length === 0) {
-        return { deletePatterns: [], whereOptionals: [] };
-    }
-    // (c1|c2|…)*  — zero or more contains edges, so the root itself is matched when it is
-    // dependent-typed. That is what cleans up the value of a `contains` property that has
-    // no value shape (a polymorphic slot like `sh:path`): it is deleted only when it is a
-    // dependent node, never when it is a shared IRI. On a subject delete `*` also matches
-    // the subject, which is being deleted anyway.
-    const pathExpr = containsPreds.length === 1
-        ? { zeroOrMore: { id: containsPreds[0] } }
-        : { zeroOrMore: { alt: containsPreds.map((id) => ({ id })) } };
-    const pathTerm = {
-        kind: 'path',
-        value: pathExprToSparql(pathExpr),
-        uris: collectPathUris(pathExpr),
-    };
-    const deletePatterns = [];
-    const whereOptionals = [];
-    dependentTypes.forEach((typeId, i) => {
-        const owned = varTerm(`${varPrefix}own${i}`);
-        const p = varTerm(`${varPrefix}op${i}`);
-        const o = varTerm(`${varPrefix}ov${i}`);
-        deletePatterns.push(tripleOf(owned, p, o));
-        whereOptionals.push(keepFilter({
-            type: 'bgp',
-            triples: [
-                ...(anchor ? [anchor] : []),
-                tripleOf(rootTerm, pathTerm, owned),
-                tripleOf(owned, iriTerm(RDF_TYPE), iriTerm(typeId)),
-                tripleOf(owned, p, o),
-            ],
-        }, 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),
+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 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 }],
-    });
-    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: {
+    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: [...(anchor ? [anchor] : []), tripleOf(rootTerm, pathTerm, ownedBlank)],
+                    triples: [tripleOf(bn0, predicatePathTerm(inner, 'zeroOrMore'), bn), own],
                 },
             },
-            right: {
-                type: 'bgp',
-                triples: [tripleOf(ownedBlank, insidePathTerm, blank), tripleOf(blank, bp, bo)],
-            },
         },
-    }, rootTerm, keep));
-    return { deletePatterns, whereOptionals };
+    };
+}
+/**
+ * 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);
+}
+// ---------------------------------------------------------------------------
+// Owned-subtree walk
+//
+// A `contains` property (with a value shape and a simple path) owns its value: replacing,
+// unsetting or set-removing the value, or deleting the subject, deletes the value node, then
+// the values that node's shape owns, and so on down. Ownership is decided per property: the
+// walk starts at the root's shape and follows only the `contains` properties the reached
+// shapes declare (own and inherited), so a plain property on a predicate that another shape
+// declares `contains` is never followed. A registered sub-shape that adds `contains`
+// properties contributes hops guarded by its concrete class (`?n a <SubClass>`). Every node
+// the walk reaches loses its own triples and its blank values; `dependent` plays no part.
+//
+// Recursion: a shape that owns itself through an unguarded edge (`List.rest`) is followed with
+// a closure (`rdf:rest*`), since every such edge from one of its nodes is its own. Any other
+// recursion (a cycle through several shapes, a sub-shape's edge back into the walk) is unrolled
+// into typed hops, up to `MAX_OWNED_RECURSION` repeated shapes per path; deeper values are left.
+// ---------------------------------------------------------------------------
+/**
+ * How many times one walk path may re-enter a shape it already passed through (a cycle through
+ * several shapes, or a sub-shape's edge back into its own kind). Values below are not deleted.
+ */
+export const MAX_OWNED_RECURSION = 4;
+/** Above this many branches for one root shape, lowering warns once (see backlog 055). */
+export const OWNED_BRANCH_WARNING = 64;
+/** The simple-path predicate through which a property owns its value, or null when it does not. */
+function ownedPredicate(ps) {
+    var _a, _b;
+    if (!ps.contains || !((_a = ps.valueShape) === null || _a === void 0 ? void 0 : _a.id))
+        return null;
+    return (_b = getSimplePathId(ps.path)) !== null && _b !== void 0 ? _b : null;
+}
+let classHoldersCache = new Map();
+let classHoldersVersion = -1;
+/** Every registered shape id per `targetClass` (memoized per registry version). */
+function classHolders(classId) {
+    var _a, _b, _c;
+    const version = getRegistryVersion();
+    if (version !== classHoldersVersion) {
+        classHoldersCache = new Map();
+        for (const nodeShape of getAllNodeShapes().values()) {
+            const cls = (_a = nodeShape === null || nodeShape === void 0 ? void 0 : nodeShape.targetClass) === null || _a === void 0 ? void 0 : _a.id;
+            if (!cls)
+                continue;
+            classHoldersCache.set(cls, [...((_b = classHoldersCache.get(cls)) !== null && _b !== void 0 ? _b : []), nodeShape.id]);
+        }
+        classHoldersVersion = version;
+    }
+    return (_c = classHoldersCache.get(classId)) !== null && _c !== void 0 ? _c : [];
+}
+/**
+ * Why the added `contains` property `ps` of the sub-shape `sub` cannot be followed from nodes of
+ * the sub-shape's class, or null when it can. The guard `?n a <C>` also matches the nodes of
+ * every other shape targeting `C`, so it is refused when one of them is a super-shape of `sub`
+ * (its own nodes would match) or declares the same predicate as a plain property (following it
+ * would delete that shape's references). A holder that does not declare the predicate, or owns
+ * it too, does not block it.
+ */
+function blockedGuard(sub, ps) {
+    var _a;
+    const cls = (_a = sub.targetClass) === null || _a === void 0 ? void 0 : _a.id;
+    if (!cls)
+        return 'has no targetClass';
+    const predicate = getSimplePathId(ps.path);
+    for (const id of classHolders(cls)) {
+        if (id === sub.id || isSubShapeOf(id, sub.id))
+            continue;
+        if (isSubShapeOf(sub.id, id))
+            return `shares its targetClass with its super-shape '${id}'`;
+        const holder = shapeById(id);
+        const plain = holder && getPropertyShapes(holder, true).some((q) => !q.contains && getSimplePathId(q.path) === predicate);
+        if (plain)
+            return `shares its targetClass with '${id}', which holds <${predicate}> as a plain property`;
+    }
+    return null;
+}
+const warnedUnguardable = new Set();
+/**
+ * The owned edges of a shape: its own and inherited `contains` properties, then, per registered
+ * sub-shape, the `contains` properties it adds, guarded by its `targetClass` (a node carries only
+ * its concrete class's `rdf:type`, so each sub-shape lists its full extra set). An added property
+ * whose guard cannot tell the sub-shape's nodes apart (`blockedGuard`) is not followed and is
+ * warned once, unless the sub-shape is a profile or data-only copy of its direct super-shape (same
+ * class or none, the property inherited from that super-shape), which is skipped silently: that
+ * super-shape's entry covers it.
+ */
+function ownedEdges(shapeId) {
+    var _a, _b, _c;
+    const nodeShape = shapeById(shapeId);
+    if (!nodeShape)
+        return [];
+    const edges = new Map();
+    const add = (ps, guard) => {
+        const predicate = ownedPredicate(ps);
+        if (!predicate)
+            return;
+        const target = ps.valueShape.id;
+        edges.set(`${guard !== null && guard !== void 0 ? guard : ''} ${predicate} ${target}`, { guard, predicate, target });
+    };
+    const own = getPropertyShapes(nodeShape, true);
+    own.forEach((ps) => add(ps));
+    const ownIds = new Set(own.map((ps) => ps.id));
+    for (const sub of getSubShapes(shapeId)) {
+        const extra = getPropertyShapes(sub, true).filter((ps) => !ownIds.has(ps.id) && ownedPredicate(ps));
+        if (extra.length === 0)
+            continue;
+        const parent = ((_a = sub.extends) === null || _a === void 0 ? void 0 : _a.id) ? shapeById(sub.extends.id) : undefined;
+        const inherited = new Set(parent ? getPropertyShapes(parent, true).map((ps) => ps.id) : []);
+        for (const ps of extra) {
+            const reason = blockedGuard(sub, ps);
+            if (!reason) {
+                add(ps, sub.targetClass.id);
+                continue;
+            }
+            // A profile or data-only copy of its direct super-shape (same class, or none) is that
+            // super-shape's node by type: the super-shape's own entry covers the property, unless
+            // that super-shape is this walk's shape itself (no other entry covers it, so warn).
+            const sameKind = !((_b = sub.targetClass) === null || _b === void 0 ? void 0 : _b.id) || sub.targetClass.id === ((_c = parent === null || parent === void 0 ? void 0 : parent.targetClass) === null || _c === void 0 ? void 0 : _c.id);
+            if (sameKind && inherited.has(ps.id) && (parent === null || parent === void 0 ? void 0 : parent.id) !== shapeId)
+                continue;
+            const key = `${sub.id} ${ps.id}`;
+            if (warnedUnguardable.has(key))
+                continue;
+            warnedUnguardable.add(key);
+            console.warn(`[linked] Shape '${sub.id}' adds the contains property "${ps.label}" to '${shapeId}', but ` +
+                `${reason}, so its nodes cannot be told apart by rdf:type: deleting through ` +
+                `'${shapeId}' does not follow it. Give the shape a targetClass of its own.`);
+        }
+    }
+    return [...edges.values()];
+}
+/** The classes a node of `shapeId` may carry: its targetClass and every registered sub-shape's. */
+function shapeClasses(shapeId) {
+    var _a;
+    const nodeShape = shapeById(shapeId);
+    const classes = new Set();
+    for (const shape of nodeShape ? [nodeShape, ...getSubShapes(shapeId)] : []) {
+        if ((_a = shape.targetClass) === null || _a === void 0 ? void 0 : _a.id)
+            classes.add(shape.targetClass.id);
+    }
+    return [...classes];
+}
+let ownedWalkCache = new Map();
+let ownedWalkCacheVersion = -1;
+const warnedBranches = new Set();
+/**
+ * The owned subtree of a root shape, as hops (memoized per registry version; read-only).
+ *
+ * One target per path from the root. A self-loop (`S` owns `S` through an unguarded edge) is a
+ * closure, exact because every such edge from an `S` node is `S`'s own. Every other edge is an
+ * explicit hop. A hop is typed when it is a sub-shape's (its class) or when it stays inside a
+ * cycle of several shapes (the declaring shape's classes), and a path stops after
+ * `MAX_OWNED_RECURSION` hops into a shape already on it.
+ */
+function ownedWalk(rootShapeId) {
+    const version = getRegistryVersion();
+    if (version !== ownedWalkCacheVersion) {
+        ownedWalkCache = new Map();
+        ownedWalkCacheVersion = version;
+    }
+    const cached = ownedWalkCache.get(rootShapeId);
+    if (cached)
+        return cached;
+    const edgesOf = new Map();
+    const pending = [rootShapeId];
+    while (pending.length > 0) {
+        const id = pending.pop();
+        if (edgesOf.has(id))
+            continue;
+        const edges = ownedEdges(id);
+        edgesOf.set(id, edges);
+        for (const edge of edges)
+            if (!edgesOf.has(edge.target))
+                pending.push(edge.target);
+    }
+    const isSelfLoop = (from, e) => !e.guard && e.target === from;
+    const closureOf = (id) => [
+        ...new Set(edgesOf.get(id).filter((e) => isSelfLoop(id, e)).map((e) => e.predicate)),
+    ];
+    // Tarjan's strongly connected components, over the edges that are not closures.
+    const index = new Map();
+    const low = new Map();
+    const onStack = new Set();
+    const stack = [];
+    const groupOf = new Map();
+    const groupSize = [];
+    const strong = (v) => {
+        index.set(v, index.size);
+        low.set(v, index.get(v));
+        stack.push(v);
+        onStack.add(v);
+        for (const e of edgesOf.get(v)) {
+            if (isSelfLoop(v, e))
+                continue;
+            const w = e.target;
+            if (!index.has(w)) {
+                strong(w);
+                low.set(v, Math.min(low.get(v), low.get(w)));
+            }
+            else if (onStack.has(w)) {
+                low.set(v, Math.min(low.get(v), index.get(w)));
+            }
+        }
+        if (low.get(v) !== index.get(v))
+            return;
+        let w;
+        let size = 0;
+        do {
+            w = stack.pop();
+            onStack.delete(w);
+            groupOf.set(w, groupSize.length);
+            size++;
+        } while (w !== v);
+        groupSize.push(size);
+    };
+    strong(rootShapeId);
+    // A non-closure edge back to its own shape (a sub-shape's guarded edge) counts as a cycle too.
+    const inCycle = (from, e) => e.target === from || (groupOf.get(from) === groupOf.get(e.target) && groupSize[groupOf.get(from)] > 1);
+    const targets = [];
+    const visit = (shape, hops, path, repeats) => {
+        for (const edge of edgesOf.get(shape)) {
+            if (isSelfLoop(shape, edge))
+                continue;
+            const repeat = path.includes(edge.target) ? 1 : 0;
+            if (repeats + repeat > MAX_OWNED_RECURSION)
+                continue;
+            const typeClasses = edge.guard
+                ? [edge.guard]
+                : inCycle(shape, edge)
+                    ? shapeClasses(shape)
+                    : undefined;
+            const hop = Object.assign(Object.assign({}, ((typeClasses === null || typeClasses === void 0 ? void 0 : typeClasses.length) ? { typeClasses } : {})), { predicate: edge.predicate, closure: closureOf(edge.target) });
+            const next = [...hops, hop];
+            targets.push({ hops: next, blankProps: blankCapableProperties(edge.target) });
+            visit(edge.target, next, [...path, edge.target], repeats + repeat);
+        }
+    };
+    visit(rootShapeId, [], [rootShapeId], 0);
+    if (targets.length > OWNED_BRANCH_WARNING && !warnedBranches.has(rootShapeId)) {
+        warnedBranches.add(rootShapeId);
+        console.warn(`[linked] Deleting a '${rootShapeId}' walks ${targets.length} owned paths (more than ` +
+            `${OWNED_BRANCH_WARNING}); each is one UNION branch of the delete.`);
+    }
+    const walk = {
+        rootClosure: closureOf(rootShapeId),
+        rootBlankProps: blankCapableProperties(rootShapeId),
+        targets,
+    };
+    ownedWalkCache.set(rootShapeId, walk);
+    return walk;
+}
+/** `FILTER(!sameTerm(?n, rdf:nil))`: the walk never deletes `rdf:nil`, which every list ends in. */
+function notNil(term) {
+    if (term.kind !== 'variable')
+        return null;
+    return {
+        kind: 'not_expr',
+        inner: {
+            kind: 'function_expr',
+            name: 'sameTerm',
+            args: [{ kind: 'variable_expr', name: term.name }, { kind: 'iri_expr', value: RDF_NIL }],
+        },
+    };
+}
+/** `inner` filtered by every expression in `filters` (unchanged when there are none). */
+function filtered(inner, filters) {
+    if (filters.length === 0)
+        return inner;
+    return {
+        type: 'filter',
+        expression: filters.length === 1 ? filters[0] : { kind: 'logical_expr', op: 'and', exprs: filters },
+        inner,
+    };
+}
+/**
+ * DELETE patterns and UNION branches that delete the owned subtree below `rootTerm`, a node of
+ * `rootShapeId` (see `ownedWalk`). The root itself is the caller's: the subject wildcard of a
+ * delete, or `buildOwnedSelfDelete` for a replaced value. Each branch deletes one node per
+ * solution, its own triples and its blank values. Schematically (variable names simplified):
+ *
+ * ```sparql
+ * …anchor…  <root> (r…)* ?w .                  # the root shape's self-loop, if any
+ * ?w a <SubClass> .                             # a typed hop only
+ * ?w <c1> ?x0e . ?x0e (s…)* ?x0 .               # closure only for a self-owning target shape
+ * ?x0 ?x0p ?x0o .  FILTER(!sameTerm(?x0, rdf:nil))
+ * ```
+ *
+ * `anchor` leads every branch: the owning edge that binds a variable root (`<s> <p> ?old`), or a
+ * bulk delete's type triple, so a branch evaluated on its own never runs with an unbound root.
+ * `keep` filters every branch on the root (`FILTER(?old NOT IN (…))`).
+ */
+function ownedSubtreeBlocks(rootShapeId, rootTerm, anchor, varPrefix, keep) {
+    const walk = ownedWalk(rootShapeId);
+    const deletePatterns = [];
+    const whereBlocks = [];
+    const emit = (reach, filters, node, blankProps, prefix) => {
+        const nil = notNil(node);
+        const all = nil ? [...filters, nil] : filters;
+        const own = tripleOf(node, varTerm(`${prefix}p`), varTerm(`${prefix}o`));
+        deletePatterns.push(own);
+        whereBlocks.push(keepFilter(filtered({ type: 'bgp', triples: [...anchor, ...reach, own] }, all), rootTerm, keep));
+        if (blankProps.length === 0)
+            return;
+        const blank = buildBlankCascade([...anchor, ...reach], node, simplePredicates(blankProps), blankWalkPredicates(blankProps), `${prefix}b_`);
+        if (!blank)
+            return;
+        deletePatterns.push(...blank.deletePatterns);
+        whereBlocks.push(keepFilter(filtered(blank.whereBlock, all), rootTerm, keep));
+    };
+    let base = rootTerm;
+    const baseReach = [];
+    if (walk.rootClosure.length > 0) {
+        // The other nodes of the root's own kind (the tail cells of a list).
+        const others = varTerm(`${varPrefix}r`);
+        emit([tripleOf(rootTerm, predicatePathTerm(walk.rootClosure, 'oneOrMore'), others)], [], others, walk.rootBlankProps, `${varPrefix}r`);
+        if (walk.targets.length > 0) {
+            base = varTerm(`${varPrefix}w`);
+            baseReach.push(tripleOf(rootTerm, predicatePathTerm(walk.rootClosure, 'zeroOrMore'), base));
+        }
+    }
+    walk.targets.forEach((target, t) => {
+        const reach = [...baseReach];
+        const filters = [];
+        let at = base;
+        target.hops.forEach((hop, h) => {
+            var _a;
+            const name = `${varPrefix}${t}_${h}`;
+            if (((_a = hop.typeClasses) === null || _a === void 0 ? void 0 : _a.length) === 1) {
+                reach.push(tripleOf(at, iriTerm(RDF_TYPE), iriTerm(hop.typeClasses[0])));
+            }
+            else if (hop.typeClasses) {
+                reach.push(tripleOf(at, iriTerm(RDF_TYPE), varTerm(`${name}t`)));
+                filters.push({
+                    kind: 'in_expr',
+                    negated: false,
+                    value: { kind: 'variable_expr', name: `${name}t` },
+                    list: hop.typeClasses.map((value) => ({ kind: 'iri_expr', value })),
+                });
+            }
+            const end = varTerm(hop.closure.length > 0 ? `${name}e` : name);
+            reach.push(tripleOf(at, iriTerm(hop.predicate), end));
+            if (hop.closure.length > 0) {
+                reach.push(tripleOf(end, predicatePathTerm(hop.closure, 'zeroOrMore'), varTerm(name)));
+            }
+            at = varTerm(name);
+        });
+        emit(reach, filters, at, target.blankProps, `${varPrefix}${t}_`);
+    });
+    return { deletePatterns, whereBlocks };
 }
 /**
  * Wrap an owned-cleanup block in `FILTER(?old NOT IN (<k1>, …))` so a value the mutation
@@ -2204,13 +2547,8 @@ function keepFilter(block, oldTerm, keep) {
  * Build DELETE + WHERE OPTIONAL that removes the *old node's own* one-hop triples when a
  * `contains` edge is replaced, unset, or set-removed. A `contains` edge asserts exclusive
  * ownership, so overwriting it must delete the previously owned child fully — not merely
- * unlink it — or the child orphans (backlog 032). This is `contains`-driven and deliberately
- * does NOT require the child shape to be `dependent`: ownership via the edge is sufficient.
- * Owned descendants *below* the old node are cascaded separately by `buildOwnedCascade`.
- *
- * Callers use it only for a property that declares a value shape. A shape-less `contains`
- * slot (like `sh:path`) may hold a shared IRI, so its old value is left to
- * `buildOwnedCascade`, which deletes it only when it is dependent-typed.
+ * unlink it — or the child orphans (backlog 032). Ownership via the edge is sufficient.
+ * Owned descendants *below* the old node are deleted separately (`ownedSubtreeBlocks`).
  *
  * The owning edge `<subject> <prop> ?old` is re-asserted INSIDE the WHERE group so `?old`
  * is bound there: when no old value exists the group matches nothing and the DELETE is a
@@ -2226,13 +2564,11 @@ export function buildOwnedSelfDelete(subjectTerm, propertyTerm, oldTerm, varPref
     const p = varTerm(`${varPrefix}sp`);
     const o = varTerm(`${varPrefix}so`);
     const wildcard = tripleOf(oldTerm, p, o);
+    const nil = notNil(oldTerm);
     return {
         deletePatterns: [wildcard],
         whereOptionals: [
-            keepFilter({
-                type: 'bgp',
-                triples: [tripleOf(subjectTerm, propertyTerm, oldTerm), wildcard],
-            }, oldTerm, keep),
+            keepFilter(filtered({ type: 'bgp', triples: [tripleOf(subjectTerm, propertyTerm, oldTerm), wildcard] }, nil ? [nil] : []), oldTerm, keep),
         ],
     };
 }
@@ -2240,19 +2576,18 @@ 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 immediately-owned child (`<s> <p> ?dN . ?dN ?dN_p ?dN_o`,
- * for each of the shape's own and inherited `contains` properties with a value shape and
- * a simple path) and one block per dependent type its owned subtree can reach
- * (`reachableDependentTypes`; none for a shape that owns only non-dependent values). The
+ * blocks: per id its own triples, its incoming references, its blank values and one branch
+ * per owned path, plus that node's blank values (`ownedSubtreeBlocks`: the shape's own and
+ * inherited `contains` properties, their value shapes' in turn, and the extra ones of
+ * registered sub-shapes behind a type guard; none for a shape that owns nothing). The
  * bulk deletes (`deleteAllToAlgebra`, `deleteWhereToAlgebra`) add the same owned blocks,
  * rooted at the subject variable (see `bulkDeleteUnion`).
  *
  * 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
+ * owned path. 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
+ * which re-evaluated the former registry-wide cascade 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.
@@ -2264,9 +2599,6 @@ export function deleteToAlgebra(query, _options) {
     const deletePatterns = [];
     const guards = [];
     const blocks = [];
-    const hasContains = shapeHasContainsProperty(query.shape);
-    const ownedChildPredicates = hasContains ? ownedValueShapePredicates(query.shape) : [];
-    const cascadeTypes = hasContains ? reachableDependentTypes(query.shape) : [];
     for (let i = 0; i < query.ids.length; i++) {
         const subjectTerm = iriTerm(query.ids[i].id);
         const idx = query.ids.length > 1 ? `_${i}` : '';
@@ -2279,25 +2611,17 @@ export function deleteToAlgebra(query, _options) {
         // incoming references (the entity may have none) are separate UNION blocks.
         guards.push(typeGuard);
         blocks.push({ type: 'bgp', triples: [subjWild] }, { type: 'bgp', triples: [objWild] });
-        // The immediately-owned children: for every `contains` property with a value shape,
-        // the child's own one-hop triples, as a replace or a set-remove deletes them. No type
-        // guard and no reference check: the `contains` edge alone asserts ownership.
-        ownedChildPredicates.forEach((predicate, n) => {
-            const child = varTerm(`d${n}${idx}`);
-            const childOwn = tripleOf(child, varTerm(`d${n}${idx}_p`), varTerm(`d${n}${idx}_o`));
-            deletePatterns.push(childOwn);
-            blocks.push({
-                type: 'bgp',
-                triples: [tripleOf(subjectTerm, iriTerm(predicate), child), childOwn],
-            });
-        });
-        // 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) {
-            const cascade = buildOwnedCascade(subjectTerm, `c${idx}_`, undefined, undefined, cascadeTypes);
-            deletePatterns.push(...cascade.deletePatterns);
-            blocks.push(...cascade.whereOptionals);
-        }
+        // 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);
+        }
+        // The owned subtree: every node the subject's `contains` properties reach (`ownedWalk`).
+        const owned = ownedSubtreeBlocks(query.shape, subjectTerm, [], `c${idx}_`);
+        deletePatterns.push(...owned.deletePatterns);
+        blocks.push(...owned.whereBlocks);
     }
     const whereAlgebra = {
         type: 'join',
@@ -2311,102 +2635,27 @@ 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.
- * - 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
- *   by the subject's type triple. With a linear join it is redundant; it keeps a branch that
- *   is evaluated on its own from running `?a0 (c…)* ?own` with both ends unbound, which
- *   matches every node in the graph.
+ * - The blank-node cascade of the shape's blank-capable properties (`subjectBlankCascade`).
+ * - The same owned subtree as a delete by id (`ownedSubtreeBlocks`), rooted at the subject
+ *   variable. Each owned block is led by the subject's type triple. With a linear join it is
+ *   redundant; it keeps a branch that is evaluated on its own from running `?a0 <c> ?x` with
+ *   both ends unbound, which matches every edge in the graph.
  */
 function bulkDeleteUnion(shapeId, subjectVar, rootWildcard, typeTriple, deletePatterns) {
     const blocks = [];
-    blankNodeBlocks(shapeId, subjectVar, { triples: [], bnVars: [] }, { next: 1 }, deletePatterns, blocks);
-    if (shapeHasContainsProperty(shapeId)) {
-        const subject = varTerm(subjectVar);
-        ownedValueShapePredicates(shapeId).forEach((predicate, n) => {
-            const child = varTerm(`d${n}`);
-            const childOwn = tripleOf(child, varTerm(`d${n}_p`), varTerm(`d${n}_o`));
-            deletePatterns.push(childOwn);
-            blocks.push({
-                type: 'bgp',
-                triples: [typeTriple, tripleOf(subject, iriTerm(predicate), child), childOwn],
-            });
-        });
-        const cascadeTypes = reachableDependentTypes(shapeId);
-        if (cascadeTypes.length > 0) {
-            const cascade = buildOwnedCascade(subject, 'c_', typeTriple, undefined, cascadeTypes);
-            deletePatterns.push(...cascade.deletePatterns);
-            blocks.push(...cascade.whereOptionals);
-        }
-    }
+    const blank = subjectBlankCascade(shapeId, varTerm(subjectVar), [typeTriple], 'b_');
+    if (blank) {
+        deletePatterns.push(...blank.deletePatterns);
+        blocks.push(blank.whereBlock);
+    }
+    const owned = ownedSubtreeBlocks(shapeId, varTerm(subjectVar), [typeTriple], 'c_');
+    deletePatterns.push(...owned.deletePatterns);
+    blocks.push(...owned.whereBlocks);
     if (blocks.length === 0)
         return null;
     return unionOf([{ type: 'bgp', triples: [rootWildcard] }, ...blocks]);
@@ -2416,7 +2665,7 @@ function bulkDeleteUnion(shapeId, subjectVar, rootWildcard, typeTriple, deletePa
  *
  * Generates DELETE { ?a0 ?p ?o . [blank-node and owned-cleanup wildcards] }
  *          WHERE  { ?a0 a <Shape> . { ?a0 ?p ?o } UNION [one block per blank node,
- *                   owned child and dependent type] }
+ *                   owned group] }
  * (see `bulkDeleteUnion`). Unlike a delete by id, incoming references are not deleted.
  */
 export function deleteAllToAlgebra(query, _options) {
@@ -2443,7 +2692,7 @@ export function deleteAllToAlgebra(query, _options) {
  * Converts an IRDeleteWhereMutation to a SparqlDeleteInsertPlan.
  *
  * Like deleteAllToAlgebra but adds filter conditions from the where clause. The cleanup
- * UNION (blank nodes, owned children, dependent cascade) is joined with the filtered match,
+ * UNION (blank nodes, owned subtree) is joined with the filtered match,
  * so only the matched subjects' children are deleted.
  */
 export function deleteWhereToAlgebra(query, _options) {