@_linked/core 2.8.0-next.20260620064950 → 2.8.0-next.20260624100616

package/lib/cjs/shapes/serializePathToNodeData.d.ts

@@ -0,0 +1,24 @@
+import type { PathExpr } from '../paths/PropertyPathExpr.js';
+import type { NodeReferenceValue } from '../utils/NodeReference.js';
+import { List } from './List.js';
+import { PathNode } from './PathNode.js';
+/**
+ * Node-data the create pipeline accepts for a `sh:path` value: an IRI reference (simple path),
+ * an `rdf:List` (sequence / alternative members), or a `PathNode` operator node.
+ */
+export type PathNodeData = NodeReferenceValue | {
+    shape: typeof List | typeof PathNode;
+    __id?: string;
+    [k: string]: unknown;
+};
+/**
+ * Translate a `PathExpr` into create-pipeline node-data for `sh:path`.
+ *
+ * - simple `PathRef` → `{id}` (a shared predicate IRI; NOT owned)
+ * - sequence → an `rdf:List` of segments (via {@link rdfList})
+ * - inverse / alternative / cardinality → a `PathNode` operator node (alt's operand is an `rdf:List`)
+ *
+ * `base` seeds deterministic ids for the minted owned nodes (`{base}/inv`, `{base}/seq/0`, …) so a
+ * re-sync overwrites them in place; the owned subtree is cleaned by the containment cascade.
+ */
+export declare function serializePathToNodeData(path: PathExpr, base: string): PathNodeData;

package/lib/cjs/shapes/serializePathToNodeData.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializePathToNodeData = serializePathToNodeData;
+const PropertyPathExpr_js_1 = require("../paths/PropertyPathExpr.js");
+const List_js_1 = require("./List.js");
+const PathNode_js_1 = require("./PathNode.js");
+/**
+ * Translate a `PathExpr` into create-pipeline node-data for `sh:path`.
+ *
+ * - simple `PathRef` → `{id}` (a shared predicate IRI; NOT owned)
+ * - sequence → an `rdf:List` of segments (via {@link rdfList})
+ * - inverse / alternative / cardinality → a `PathNode` operator node (alt's operand is an `rdf:List`)
+ *
+ * `base` seeds deterministic ids for the minted owned nodes (`{base}/inv`, `{base}/seq/0`, …) so a
+ * re-sync overwrites them in place; the owned subtree is cleaned by the containment cascade.
+ */
+function serializePathToNodeData(path, base) {
+    const serialize = (e, b) => {
+        if ((0, PropertyPathExpr_js_1.isPathRef)(e)) {
+            return { id: typeof e === 'string' ? e : e.id };
+        }
+        if ('seq' in e) {
+            return (0, List_js_1.rdfList)(e.seq.map((s, i) => serialize(s, `${b}/seq/${i}`)), { base: `${b}/seq` });
+        }
+        if ('inv' in e) {
+            return { shape: PathNode_js_1.PathNode, __id: `${b}/inv`, inversePath: serialize(e.inv, `${b}/inv`) };
+        }
+        if ('alt' in e) {
+            return {
+                shape: PathNode_js_1.PathNode,
+                __id: `${b}/alt`,
+                alternativePath: (0, List_js_1.rdfList)(e.alt.map((a, i) => serialize(a, `${b}/alt/${i}`)), { base: `${b}/alt` }),
+            };
+        }
+        if ('zeroOrMore' in e) {
+            return { shape: PathNode_js_1.PathNode, __id: `${b}/zom`, zeroOrMorePath: serialize(e.zeroOrMore, `${b}/zom`) };
+        }
+        if ('oneOrMore' in e) {
+            return { shape: PathNode_js_1.PathNode, __id: `${b}/oom`, oneOrMorePath: serialize(e.oneOrMore, `${b}/oom`) };
+        }
+        if ('zeroOrOne' in e) {
+            return { shape: PathNode_js_1.PathNode, __id: `${b}/zoo`, zeroOrOnePath: serialize(e.zeroOrOne, `${b}/zoo`) };
+        }
+        if ('negatedPropertySet' in e) {
+            throw new Error('negatedPropertySet cannot be serialized to SHACL sh:path — no SHACL representation.');
+        }
+        throw new Error(`Unknown PathExpr shape: ${JSON.stringify(e)}`);
+    };
+    return serialize(path, base);
+}
+//# sourceMappingURL=serializePathToNodeData.js.map

package/lib/cjs/shapes/serializePathToNodeData.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"serializePathToNodeData.js","sourceRoot":"","sources":["../../../src/shapes/serializePathToNodeData.ts"],"names":[],"mappings":";;AA6BA,0DAyCC;AAhED,sEAAuD;AAEvD,uCAAwC;AACxC,+CAAuC;AAUvC;;;;;;;;;GASG;AACH,SAAgB,uBAAuB,CAAC,IAAc,EAAE,IAAY;IAClE,MAAM,SAAS,GAAG,CAAC,CAAW,EAAE,CAAS,EAAgB,EAAE;QACzD,IAAI,IAAA,+BAAS,EAAC,CAAC,CAAC,EAAE,CAAC;YACjB,OAAO,EAAC,EAAE,EAAE,OAAO,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,EAAC,CAAC;QAChD,CAAC;QACD,IAAI,KAAK,IAAI,CAAC,EAAE,CAAC;YACf,OAAO,IAAA,iBAAO,EACZ,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,EAClD,EAAC,IAAI,EAAE,GAAG,CAAC,MAAM,EAAC,CACH,CAAC;QACpB,CAAC;QACD,IAAI,KAAK,IAAI,CAAC,EAAE,CAAC;YACf,OAAO,EAAC,KAAK,EAAE,sBAAQ,EAAE,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,EAAE,GAAG,CAAC,MAAM,CAAC,EAAC,CAAC;QACxF,CAAC;QACD,IAAI,KAAK,IAAI,CAAC,EAAE,CAAC;YACf,OAAO;gBACL,KAAK,EAAE,sBAAQ;gBACf,IAAI,EAAE,GAAG,CAAC,MAAM;gBAChB,eAAe,EAAE,IAAA,iBAAO,EACtB,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,EAClD,EAAC,IAAI,EAAE,GAAG,CAAC,MAAM,EAAC,CACnB;aACF,CAAC;QACJ,CAAC;QACD,IAAI,YAAY,IAAI,CAAC,EAAE,CAAC;YACtB,OAAO,EAAC,KAAK,EAAE,sBAAQ,EAAE,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,cAAc,EAAE,SAAS,CAAC,CAAC,CAAC,UAAU,EAAE,GAAG,CAAC,MAAM,CAAC,EAAC,CAAC;QAClG,CAAC;QACD,IAAI,WAAW,IAAI,CAAC,EAAE,CAAC;YACrB,OAAO,EAAC,KAAK,EAAE,sBAAQ,EAAE,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,EAAE,SAAS,CAAC,CAAC,CAAC,SAAS,EAAE,GAAG,CAAC,MAAM,CAAC,EAAC,CAAC;QAChG,CAAC;QACD,IAAI,WAAW,IAAI,CAAC,EAAE,CAAC;YACrB,OAAO,EAAC,KAAK,EAAE,sBAAQ,EAAE,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,EAAE,SAAS,CAAC,CAAC,CAAC,SAAS,EAAE,GAAG,CAAC,MAAM,CAAC,EAAC,CAAC;QAChG,CAAC;QACD,IAAI,oBAAoB,IAAI,CAAC,EAAE,CAAC;YAC9B,MAAM,IAAI,KAAK,CACb,qFAAqF,CACtF,CAAC;QACJ,CAAC;QACD,MAAM,IAAI,KAAK,CAAC,2BAA2B,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;IAClE,CAAC,CAAC;IACF,OAAO,SAAS,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;AAC/B,CAAC"}

package/lib/cjs/shapes/syncShapes.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Plan an idempotent sync of all code-registered (non-framework) NodeShapes into the store as
+ * SHACL data — the forward (code → graph) materialization of arch-05 "code is canonical".
+ *
+ * Returns built-but-unexecuted thunks; the caller controls execution and batching:
+ * ```ts
+ * await Promise.all((await syncShapes()).map((run) => run()));
+ * ```
+ * Each in-code shape's thunk runs `delete → create` in order (the delete cascade-cleans the old
+ * property shapes / list / path subtrees via the containment cascade, the create rebuilds them).
+ * Shapes present in the store but no longer in code are deleted as orphans (their owned subtree
+ * cascades too). Reads existing shape IRIs via the global query dispatch for orphan detection.
+ */
+export declare function syncShapes(): Promise<Array<() => Promise<void>>>;

package/lib/cjs/shapes/syncShapes.js

@@ -0,0 +1,141 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncShapes = syncShapes;
+/*
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+const ShapeClass_js_1 = require("../utils/ShapeClass.js");
+const SHACL_js_1 = require("./SHACL.js");
+const DeleteBuilder_js_1 = require("../queries/DeleteBuilder.js");
+const List_js_1 = require("./List.js");
+const serializePathToNodeData_js_1 = require("./serializePathToNodeData.js");
+/**
+ * The npm scope of framework shapes (NodeShape/PropertyShape/List/PathNode/Shape) that
+ * describe the meta-model itself and must never be synced as user data.
+ */
+const FRAMEWORK_PACKAGE = '@_linked/core';
+/** Build the create-pipeline data object for a single PropertyShape (flattened under shapeIri). */
+function buildPropertyShapeData(ps, shapeIri) {
+    const psIri = `${shapeIri}/${ps.label}`;
+    const d = {
+        __id: psIri,
+        path: (0, serializePathToNodeData_js_1.serializePathToNodeData)(ps.path, psIri),
+    };
+    if (ps.nodeKind)
+        d.nodeKind = ps.nodeKind;
+    if (ps.datatype)
+        d.datatype = ps.datatype;
+    if (typeof ps.minCount === 'number')
+        d.minCount = ps.minCount;
+    if (typeof ps.maxCount === 'number')
+        d.maxCount = ps.maxCount;
+    if (ps.name)
+        d.name = ps.name;
+    if (ps.description)
+        d.description = ps.description;
+    if (typeof ps.order === 'number')
+        d.order = ps.order;
+    if (ps.group)
+        d.group = ps.group;
+    if (ps.class)
+        d.class = ps.class;
+    if (ps.in)
+        d.in = (0, List_js_1.rdfList)(ps.in, { base: `${psIri}/in` });
+    if (ps.equalsConstraint)
+        d.equals = ps.equalsConstraint;
+    if (ps.disjoint)
+        d.disjoint = ps.disjoint;
+    if (ps.lessThan)
+        d.lessThan = ps.lessThan;
+    if (ps.lessThanOrEquals)
+        d.lessThanOrEquals = ps.lessThanOrEquals;
+    if (ps.hasValueConstraint !== undefined)
+        d.hasValue = ps.hasValueConstraint;
+    if (ps.valueShape)
+        d.valueShape = ps.valueShape;
+    if (ps.contains)
+        d.contains = true;
+    return d;
+}
+/** Build the create-pipeline data object for a NodeShape and its (flattened) property shapes. */
+function buildNodeShapeData(nodeShape, shapeIri) {
+    const d = {};
+    if (nodeShape.targetClass)
+        d.targetClass = nodeShape.targetClass;
+    if (nodeShape.description)
+        d.description = nodeShape.description;
+    if (nodeShape.extends)
+        d.extends = nodeShape.extends;
+    if (nodeShape.dependent)
+        d.dependent = true;
+    if (nodeShape.closed !== undefined)
+        d.closed = nodeShape.closed;
+    if (nodeShape.ignoredProperties && nodeShape.ignoredProperties.length) {
+        d.ignoredProperties = nodeShape.ignoredProperties;
+    }
+    // Flatten: emit own + inherited property shapes (deduped by label) under this shape.
+    d.properties = nodeShape
+        .getUniquePropertyShapes()
+        .map((ps) => buildPropertyShapeData(ps, shapeIri));
+    return d;
+}
+/**
+ * Plan an idempotent sync of all code-registered (non-framework) NodeShapes into the store as
+ * SHACL data — the forward (code → graph) materialization of arch-05 "code is canonical".
+ *
+ * Returns built-but-unexecuted thunks; the caller controls execution and batching:
+ * ```ts
+ * await Promise.all((await syncShapes()).map((run) => run()));
+ * ```
+ * Each in-code shape's thunk runs `delete → create` in order (the delete cascade-cleans the old
+ * property shapes / list / path subtrees via the containment cascade, the create rebuilds them).
+ * Shapes present in the store but no longer in code are deleted as orphans (their owned subtree
+ * cascades too). Reads existing shape IRIs via the global query dispatch for orphan detection.
+ */
+function syncShapes() {
+    return __awaiter(this, void 0, void 0, function* () {
+        // 1. Enumerate code-registered user shapes (exclude framework/meta shapes).
+        const userShapes = [];
+        for (const [iri, shapeClass] of (0, ShapeClass_js_1.getAllShapeClasses)()) {
+            if (!(shapeClass === null || shapeClass === void 0 ? void 0 : shapeClass.shape))
+                continue;
+            const pkg = shapeClass.packageName;
+            // Skip framework/meta shapes: the core package, and the base `Shape` which is registered
+            // directly (no applyLinkedShape) and therefore carries no packageName.
+            if (!pkg || pkg === FRAMEWORK_PACKAGE)
+                continue;
+            userShapes.push({ iri, nodeShape: shapeClass.shape });
+        }
+        const localShapeIris = new Set(userShapes.map((s) => s.iri));
+        // 2. Identity-read existing NodeShape IRIs (ids only) for orphan detection.
+        const existingRows = (yield SHACL_js_1.NodeShape.select());
+        const existingShapeIris = new Set(existingRows.map((r) => r.id));
+        const thunks = [];
+        // 3. Per in-code shape: delete (cascade) then recreate.
+        for (const { iri, nodeShape } of userShapes) {
+            const data = buildNodeShapeData(nodeShape, iri);
+            thunks.push(() => DeleteBuilder_js_1.DeleteBuilder.from(SHACL_js_1.NodeShape, { id: iri }).exec()
+                .then(() => (SHACL_js_1.NodeShape.create(data).withId(iri).exec()))
+                .then(() => undefined));
+        }
+        // 4. Orphan shapes (in store, not in code) → delete (cascade cleans their owned subtree).
+        for (const iri of existingShapeIris) {
+            if (!localShapeIris.has(iri)) {
+                thunks.push(() => DeleteBuilder_js_1.DeleteBuilder.from(SHACL_js_1.NodeShape, { id: iri }).exec().then(() => undefined));
+            }
+        }
+        return thunks;
+    });
+}
+//# sourceMappingURL=syncShapes.js.map

package/lib/cjs/shapes/syncShapes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"syncShapes.js","sourceRoot":"","sources":["../../../src/shapes/syncShapes.ts"],"names":[],"mappings":"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"}

package/lib/cjs/sparql/irToAlgebra.d.ts

@@ -1,5 +1,5 @@
 import type { IRSelectQuery, IRCreateMutation, IRUpdateMutation, IRDeleteMutation, IRDeleteAllMutation, IRDeleteWhereMutation, IRUpdateWhereMutation } from '../queries/IntermediateRepresentation.js';
-import type { SparqlSelectPlan, SparqlInsertDataPlan, SparqlDeleteInsertPlan } from './SparqlAlgebra.js';
+import type { SparqlSelectPlan, SparqlInsertDataPlan, SparqlDeleteInsertPlan, SparqlAlgebraNode, SparqlTriple, SparqlTerm } from './SparqlAlgebra.js';
 import { type SparqlOptions } from './sparqlUtils.js';
 /**
  * Converts an IRSelectQuery to a SparqlSelectPlan.
@@ -13,6 +13,15 @@ export declare function createToAlgebra(query: IRCreateMutation, options?: Sparq
  * Converts an IRUpdateMutation to a SparqlDeleteInsertPlan.
  */
 export declare function updateToAlgebra(query: IRUpdateMutation, options?: SparqlOptions): SparqlDeleteInsertPlan;
+/**
+ * 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.
+ */
+export declare function buildOwnedCascade(rootTerm: SparqlTerm, varPrefix: string): {
+    deletePatterns: SparqlTriple[];
+    whereOptionals: SparqlAlgebraNode[];
+};
 /**
  * Converts an IRDeleteMutation to a SparqlDeleteInsertPlan (DELETE + WHERE).
  */

package/lib/cjs/sparql/irToAlgebra.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.selectToAlgebra = selectToAlgebra;
 exports.createToAlgebra = createToAlgebra;
 exports.updateToAlgebra = updateToAlgebra;
+exports.buildOwnedCascade = buildOwnedCascade;
 exports.deleteToAlgebra = deleteToAlgebra;
 exports.deleteAllToAlgebra = deleteAllToAlgebra;
 exports.deleteWhereToAlgebra = deleteWhereToAlgebra;
@@ -487,10 +488,19 @@ function selectToAlgebra(query, _options) {
     const requiredTraversalAliases = collectRequiredTraversalAliases(query, traversePatternMap);
     const optionalTraversalAliases = new Set([...projectedTraversalAliases].filter((alias) => {
         const pattern = traversePatternMap.get(alias);
+        // Lower projection-only traversals into OPTIONAL subtrees regardless of
+        // cardinality, so a parent with an empty relationship is preserved (with
+        // an empty array / null child) instead of being inner-joined away. The
+        // result grouper already collects multiple child bindings into an array.
+        //
+        // Excluded:
+        //  - filtered traversals (`.where(...)`) — the filter makes the child required
+        //  - aliases otherwise required by the query (e.g. used in a top-level filter)
+        //  - paginated traversals — emitted separately as a sub-SELECT (section 5a),
+        //    so lowering them here too would double-emit the traverse triple
         return !!pattern &&
-            typeof pattern.maxCount === 'number' &&
-            pattern.maxCount <= 1 &&
             !pattern.filter &&
+            !subSelectAliases.has(alias) &&
             !requiredTraversalAliases.has(alias);
     }));
     const requiredTraverseTriples = traverseTriples.filter((triple) => !(triple.object.kind === 'variable' &&
@@ -1226,9 +1236,15 @@ function processUpdateFields(data, subjectTerm, options) {
     const insertPatterns = [];
     const oldValueTriples = [];
     const extends_ = [];
+    // Owned-subtree cascade: replacing a `contains` property must also
+    // delete the old object's owned subtree, not just the one-hop edge.
+    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);
         // Check for set modification ({add, remove})
         if (field.value &&
             typeof field.value === 'object' &&
@@ -1239,11 +1255,17 @@ function processUpdateFields(data, subjectTerm, options) {
             ('add' in field.value || 'remove' in field.value)) {
             const setMod = field.value;
             if (setMod.remove) {
-                for (const removeItem of setMod.remove) {
+                setMod.remove.forEach((removeItem, ri) => {
                     const removeTerm = iriTerm(removeItem.id);
                     deletePatterns.push(tripleOf(subjectTerm, propertyTerm, removeTerm));
                     oldValueTriples.push(tripleOf(subjectTerm, propertyTerm, removeTerm));
-                }
+                    // For a `contains` set, removing a value also removes its owned subtree.
+                    if (isContainsField) {
+                        const cascade = buildOwnedCascade(removeTerm, `ucr_${suffix}_${ri}_`);
+                        deletePatterns.push(...cascade.deletePatterns);
+                        cascadeOptionals.push(...cascade.whereOptionals);
+                    }
+                });
             }
             if (setMod.add) {
                 for (const addItem of setMod.add) {
@@ -1262,6 +1284,11 @@ function processUpdateFields(data, subjectTerm, options) {
             }
             continue;
         }
+        // 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) {
+            containsOldVars.push(`old_${suffix}`);
+        }
         // Unset (undefined/null) — delete only
         if (field.value === undefined || field.value === null) {
             const oldVar = varTerm(`old_${suffix}`);
@@ -1343,7 +1370,19 @@ function processUpdateFields(data, subjectTerm, options) {
             insertPatterns.push(tripleOf(subjectTerm, propertyTerm, term));
         }
     }
-    return { deletePatterns, insertPatterns, oldValueTriples, extends: extends_ };
+    // Append cascade for each replaced `contains` property's old value.
+    containsOldVars.forEach((oldVar, n) => {
+        const cascade = buildOwnedCascade(varTerm(oldVar), `uc${n}_`);
+        deletePatterns.push(...cascade.deletePatterns);
+        cascadeOptionals.push(...cascade.whereOptionals);
+    });
+    return {
+        deletePatterns,
+        insertPatterns,
+        oldValueTriples,
+        extends: extends_,
+        cascadeOptionals,
+    };
 }
 /**
  * Wraps old-value triples in OPTIONAL (LEFT JOIN) so UPDATE succeeds
@@ -1383,6 +1422,10 @@ function updateToAlgebra(query, options) {
             };
         }
     }
+    // Owned-subtree cascade OPTIONALs for replaced `contains` properties.
+    for (const optional of result.cascadeOptionals) {
+        whereAlgebra = { type: 'left_join', left: whereAlgebra, right: optional };
+    }
     // Add BIND expressions for computed fields
     for (const ext of result.extends) {
         whereAlgebra = {
@@ -1399,6 +1442,90 @@ function updateToAlgebra(query, options) {
         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 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.
+// ---------------------------------------------------------------------------
+/** True when the shape (or an ancestor) declares at least one `contains` property. */
+function shapeHasContainsProperty(shapeId) {
+    var _a;
+    const nodeShape = (_a = (0, ShapeClass_js_1.getShapeClass)(shapeId)) === null || _a === void 0 ? void 0 : _a.shape;
+    if (!nodeShape || typeof nodeShape.getPropertyShapes !== 'function')
+        return false;
+    return nodeShape
+        .getPropertyShapes(true)
+        .some((ps) => ps.contains);
+}
+/** Gather contains-predicate IRIs and dependent targetClass IRIs from the registry. */
+function collectContainment() {
+    var _a;
+    const containsPreds = new Set();
+    const dependentTypes = new Set();
+    for (const [, shapeClass] of (0, ShapeClass_js_1.getAllShapeClasses)()) {
+        const nodeShape = shapeClass === null || shapeClass === void 0 ? void 0 : shapeClass.shape;
+        if (!nodeShape)
+            continue;
+        if (nodeShape.dependent && ((_a = nodeShape.targetClass) === null || _a === void 0 ? void 0 : _a.id)) {
+            dependentTypes.add(nodeShape.targetClass.id);
+        }
+        const propertyShapes = typeof nodeShape.getPropertyShapes === 'function'
+            ? nodeShape.getPropertyShapes(false)
+            : [];
+        for (const ps of propertyShapes) {
+            if (ps.contains) {
+                const predId = (0, normalizePropertyPath_js_1.getSimplePathId)(ps.path);
+                if (predId)
+                    containsPreds.add(predId);
+            }
+        }
+    }
+    return { containsPreds: [...containsPreds], dependentTypes: [...dependentTypes] };
+}
+/**
+ * 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.
+ */
+function buildOwnedCascade(rootTerm, varPrefix) {
+    const { containsPreds, dependentTypes } = collectContainment();
+    if (containsPreds.length === 0 || dependentTypes.length === 0) {
+        return { deletePatterns: [], whereOptionals: [] };
+    }
+    // (c1|c2|…)+  — follow one-or-more contains edges from the root.
+    const pathExpr = containsPreds.length === 1
+        ? { oneOrMore: { id: containsPreds[0] } }
+        : { oneOrMore: { alt: containsPreds.map((id) => ({ id })) } };
+    const pathTerm = {
+        kind: 'path',
+        value: (0, pathExprToSparql_js_1.pathExprToSparql)(pathExpr),
+        uris: (0, pathExprToSparql_js_1.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({
+            type: 'bgp',
+            triples: [
+                tripleOf(rootTerm, pathTerm, owned),
+                tripleOf(owned, iriTerm(RDF_TYPE), iriTerm(typeId)),
+                tripleOf(owned, p, o),
+            ],
+        });
+    });
+    return { deletePatterns, whereOptionals };
+}
 /**
  * Converts an IRDeleteMutation to a SparqlDeleteInsertPlan (DELETE + WHERE).
  */
@@ -1406,6 +1533,7 @@ function deleteToAlgebra(query, _options) {
     const deletePatterns = [];
     const requiredTriples = [];
     const optionalTriples = [];
+    const cascadeOptionals = [];
     for (let i = 0; i < query.ids.length; i++) {
         const subjectTerm = iriTerm(query.ids[i].id);
         const idx = query.ids.length > 1 ? `_${i}` : '';
@@ -1418,8 +1546,15 @@ function deleteToAlgebra(query, _options) {
         // object-wildcard is OPTIONAL (entity may have no incoming references)
         requiredTriples.push(subjWild, typeGuard);
         optionalTriples.push(objWild);
+        // Cascade-delete the owned subtree — only for shapes that actually own something
+        // (have a `contains` property); a plain entity delete is left untouched.
+        if (shapeHasContainsProperty(query.shape)) {
+            const cascade = buildOwnedCascade(subjectTerm, `c${idx}_`);
+            deletePatterns.push(...cascade.deletePatterns);
+            cascadeOptionals.push(...cascade.whereOptionals);
+        }
     }
-    // Build WHERE algebra: required BGP + OPTIONAL for each object-wildcard
+    // Build WHERE algebra: required BGP + OPTIONAL for each object-wildcard + cascade OPTIONALs
     let whereAlgebra = { type: 'bgp', triples: requiredTriples };
     for (const triple of optionalTriples) {
         whereAlgebra = {
@@ -1428,6 +1563,9 @@ function deleteToAlgebra(query, _options) {
             right: { type: 'bgp', triples: [triple] },
         };
     }
+    for (const optional of cascadeOptionals) {
+        whereAlgebra = { type: 'left_join', left: whereAlgebra, right: optional };
+    }
     return {
         type: 'delete_insert',
         deletePatterns,
@@ -1629,6 +1767,10 @@ function updateWhereToAlgebra(query, options) {
             };
         }
     }
+    // Owned-subtree cascade OPTIONALs for replaced `contains` properties.
+    for (const optional of result.cascadeOptionals) {
+        whereAlgebra = { type: 'left_join', left: whereAlgebra, right: optional };
+    }
     // Add BIND expressions for computed fields
     for (const ext of result.extends) {
         whereAlgebra = {