yarramate 1.21.0 → 1.22.0

package/dist/fold-tree.d.ts

@@ -110,15 +110,28 @@ export declare function nestingTree(edges: readonly FoldEdge[], nesting: readonl
 /**
  * The containment tree: what a view nests, plus what a pattern owns.
  *
- * A slot member joins the tree only when all three hold, and each condition is
- * a different way of getting the answer wrong:
+ * A slot member joins the tree only when all of these hold, and each condition
+ * is a different way of getting the answer wrong:
  *
- * - **Exclusive.** A subject bound into two instances has two owners, and a
- *   single-parent tree would silently pick one. Shared subjects stay outside.
- * - **`owned` or `unwired`, never `context`.** A context slot names something
- *   the instance USES and does not contain — the upstream API it calls, the
- *   plane it runs on. Folding those would swallow half the landscape into
- *   whichever box happened to reference it.
+ * - **Held inside one box.** A member's HOLDERS are every instance whose slots
+ *   name it. One holder puts the member in that holder. Several put it in their
+ *   lowest common ancestor, which is the level at which the holders diverge and
+ *   therefore the innermost box that contains all of them. Holders with no
+ *   common ancestor leave the member outside, because there is no one box it
+ *   sits within and a single-parent tree would have to pick.
+ *
+ *   This AMENDS ADR 0143's "Exclusive" rule, which kept every shared subject
+ *   outside (#473 phase 3, ADR 0145, Nabeel's decision of 2026-09-05). The
+ *   original reasoning was that two owners force a silent choice; it is only
+ *   true when the owners sit in different boxes. Where both already sit under
+ *   one box there is nothing to choose, and the old rule left 14 of the
+ *   reference Landscape's 30 data objects outside the single application whose
+ *   own parts were the things binding them.
+ * - **`owned` or `unwired`, never `context` alone.** A context slot names
+ *   something the instance USES and does not contain — the upstream API it
+ *   calls, the plane it runs on. Folding those would swallow half the landscape
+ *   into whichever box happened to reference it. At least one binding must be
+ *   `owned` or `unwired` for the member to fold at all.
  * - **Not a ruling.** See {@link RULING_CORE_KINDS}.
  *
  * A view's own nesting wins where both apply: the view is the more specific

package/dist/fold-tree.js

@@ -127,6 +127,18 @@ export function nestingTree(edges, nesting, coreKindOf) {
  * a straight-line ancestor of a cycle is still validly nested under its own
  * non-cyclic parent. Mutates `parentOf` and returns what it removed.
  */
+/** Whether `id` sits anywhere inside `ancestor` in the tree built so far. */
+const isDescendantOf = (id, ancestor, parentOf) => {
+    const seen = new Set([id]);
+    let current = parentOf.get(id);
+    while (current !== undefined && !seen.has(current)) {
+        if (current === ancestor)
+            return true;
+        seen.add(current);
+        current = parentOf.get(current);
+    }
+    return false;
+};
 function unnestCycles(parentOf) {
     const cycleMembers = new Set();
     for (const start of parentOf.keys()) {
@@ -149,18 +161,59 @@ function unnestCycles(parentOf) {
         parentOf.delete(id);
     return [...cycleMembers];
 }
+/**
+ * The lowest node that contains every one of `ids`, counting each id as an
+ * ancestor of itself, or `undefined` when they do not share one.
+ *
+ * "Counting each id as an ancestor of itself" is the part that matters: where
+ * one holder already sits inside another, the answer is the outer holder rather
+ * than something above them both.
+ */
+const lowestCommonAncestor = (ids, parentOf) => {
+    const chainOf = (id) => {
+        const chain = [];
+        const seen = new Set();
+        let current = id;
+        while (current !== undefined && !seen.has(current)) {
+            seen.add(current);
+            chain.push(current);
+            current = parentOf.get(current);
+        }
+        return chain;
+    };
+    const [first, ...rest] = ids;
+    if (first === undefined)
+        return undefined;
+    const others = rest.map((id) => new Set(chainOf(id)));
+    // Walking the first chain from the node OUTWARDS makes the first hit the
+    // lowest by construction.
+    return chainOf(first).find((candidate) => others.every((chain) => chain.has(candidate)));
+};
 /**
  * The containment tree: what a view nests, plus what a pattern owns.
  *
- * A slot member joins the tree only when all three hold, and each condition is
- * a different way of getting the answer wrong:
+ * A slot member joins the tree only when all of these hold, and each condition
+ * is a different way of getting the answer wrong:
  *
- * - **Exclusive.** A subject bound into two instances has two owners, and a
- *   single-parent tree would silently pick one. Shared subjects stay outside.
- * - **`owned` or `unwired`, never `context`.** A context slot names something
- *   the instance USES and does not contain — the upstream API it calls, the
- *   plane it runs on. Folding those would swallow half the landscape into
- *   whichever box happened to reference it.
+ * - **Held inside one box.** A member's HOLDERS are every instance whose slots
+ *   name it. One holder puts the member in that holder. Several put it in their
+ *   lowest common ancestor, which is the level at which the holders diverge and
+ *   therefore the innermost box that contains all of them. Holders with no
+ *   common ancestor leave the member outside, because there is no one box it
+ *   sits within and a single-parent tree would have to pick.
+ *
+ *   This AMENDS ADR 0143's "Exclusive" rule, which kept every shared subject
+ *   outside (#473 phase 3, ADR 0145, Nabeel's decision of 2026-09-05). The
+ *   original reasoning was that two owners force a silent choice; it is only
+ *   true when the owners sit in different boxes. Where both already sit under
+ *   one box there is nothing to choose, and the old rule left 14 of the
+ *   reference Landscape's 30 data objects outside the single application whose
+ *   own parts were the things binding them.
+ * - **`owned` or `unwired`, never `context` alone.** A context slot names
+ *   something the instance USES and does not contain — the upstream API it
+ *   calls, the plane it runs on. Folding those would swallow half the landscape
+ *   into whichever box happened to reference it. At least one binding must be
+ *   `owned` or `unwired` for the member to fold at all.
  * - **Not a ruling.** See {@link RULING_CORE_KINDS}.
  *
  * A view's own nesting wins where both apply: the view is the more specific
@@ -178,22 +231,64 @@ export function foldTree(input) {
         else
             instances.add(membership.instance);
     }
-    const parentOf = new Map(fromNesting.parentOf);
+    // Whether ANY of a member's bindings is one the instance holds it out by. A
+    // member bound only through context slots never folds, however many hold it.
+    const heldOutSomewhere = new Set();
     for (const membership of input.memberships) {
-        if (parentOf.has(membership.member))
-            continue;
-        if ((instancesOf.get(membership.member)?.size ?? 0) !== 1)
-            continue;
-        if (membership.wiring === 'context')
-            continue;
-        if (RULING_CORE_KINDS.has(coreKindOf(membership.member)))
-            continue;
-        // A node the input does not carry cannot be drawn inside anything.
-        if (!coreKindById.has(membership.member))
-            continue;
-        if (membership.member === membership.instance)
-            continue;
-        parentOf.set(membership.member, membership.instance);
+        if (membership.wiring !== 'context')
+            heldOutSomewhere.add(membership.member);
+    }
+    const parentOf = new Map(fromNesting.parentOf);
+    const candidates = [
+        ...new Set(input.memberships
+            .map(({ member }) => member)
+            .filter((member) => 
+        // A view's own nesting already placed it, and the view wins.
+        !parentOf.has(member) &&
+            heldOutSomewhere.has(member) &&
+            !RULING_CORE_KINDS.has(coreKindOf(member)) &&
+            // A node the input does not carry cannot be drawn inside anything.
+            coreKindById.has(member) &&
+            // Something that holds itself is not held by anything.
+            instancesOf.get(member)?.has(member) !== true)),
+    ];
+    // Resolved in ROUNDS rather than one pass, because a member's holders may
+    // themselves be members whose own parents are decided here. Placing a member
+    // before its holders are settled would measure the lowest common ancestor
+    // against a tree that is still missing the levels that separate them, and the
+    // reference has five-deep chains (spec, mapping, call, client, application),
+    // so this is exercised rather than theoretical.
+    //
+    // A member is settled once it is placed or once it is known to stay outside.
+    // Whatever a round cannot decide it hands to the next; when a round decides
+    // nothing, what is left is a mutual dependency and stays outside, which is the
+    // same answer the cycle guard below would reach for it anyway.
+    let pending = candidates;
+    while (pending.length > 0) {
+        const deferred = [];
+        let decided = false;
+        for (const member of pending) {
+            const holders = [...(instancesOf.get(member) ?? [])];
+            if (holders.some((holder) => pending.includes(holder) && holder !== member)) {
+                deferred.push(member);
+                continue;
+            }
+            decided = true;
+            const parent = holders.length === 1
+                ? holders[0]
+                : lowestCommonAncestor(holders, parentOf);
+            if (parent === undefined || parent === member)
+                continue;
+            // A member that already contains one of its holders cannot also sit
+            // inside it. The cycle guard below is the backstop, not the rule.
+            if (holders.some((holder) => isDescendantOf(holder, member, parentOf))) {
+                continue;
+            }
+            parentOf.set(member, parent);
+        }
+        if (!decided)
+            break;
+        pending = deferred;
     }
     // Slot membership can close a loop the view's nesting alone did not, so the
     // guard runs again over the combined tree rather than trusting the first.

package/dist/projection.d.ts

@@ -78,6 +78,17 @@ export interface ProjectionDefinition {
         readonly showLifecycle?: boolean;
         readonly showEvidence?: boolean;
         readonly showOwnership?: boolean;
+        /**
+         * Whether a bound RULING draws as a row inside its holder rather than as a
+         * node of its own (#473 phase 3, ADR 0145).
+         *
+         * On the reference this takes the whole model from 173 boxes to 91, because
+         * 82 of its rulings are bound into slots and every one of them was drawing
+         * as a box with a single association edge. Presentation only: the model,
+         * the query and the selected set do not move, and turning it off restores
+         * the boxes.
+         */
+        readonly showConstraints?: boolean;
         /**
          * The folder this view files itself under in an editor's rail: a label the
          * author declares, nested with `/`, never the directory the projection

package/dist/projection.js

@@ -66,6 +66,7 @@ export function canonicalProjection(projection) {
                     ...(presentation.showLifecycle === undefined ? {} : { showLifecycle: presentation.showLifecycle }),
                     ...(presentation.showEvidence === undefined ? {} : { showEvidence: presentation.showEvidence }),
                     ...(presentation.showOwnership === undefined ? {} : { showOwnership: presentation.showOwnership }),
+                    ...(presentation.showConstraints === undefined ? {} : { showConstraints: presentation.showConstraints }),
                     ...(presentation.notation === undefined ? {} : { notation: presentation.notation }),
                 },
             }),
@@ -631,6 +632,9 @@ export function evaluateProjection(graph, projection, profileContext, membership
                     ...(projection.presentation.showOwnership === undefined
                         ? {}
                         : { showOwnership: projection.presentation.showOwnership }),
+                    ...(projection.presentation.showConstraints === undefined
+                        ? {}
+                        : { showConstraints: projection.presentation.showConstraints }),
                     ...(projection.presentation.notation === undefined
                         ? {}
                         : { notation: projection.presentation.notation }),

package/dist/schema-validators.generated.js

@@ -9,7 +9,7 @@
 // file and not a runtime one; the two pure helpers imported below are
 // all the runtime still takes from ajv.
 //
-// schema/ sha256: 71358391c82518d840a0bc538999ea67063aa97e7093f7ca099155f57c44abba
+// schema/ sha256: cc9263e2df972b9fbeb51dd1e2572396c633aaa2b7eb74f0a70e82f7063ce0d4
 import ajvRuntime0Module from 'ajv/dist/runtime/ucs2length.js';
 const ajvRuntime0 = ajvRuntime0Module.default ?? ajvRuntime0Module;
 import ajvRuntime1Module from 'ajv/dist/runtime/equal.js';
@@ -4476,7 +4476,7 @@ else {
 } validate61.errors = vErrors; return errors === 0; }
 validate61.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
 export const validateProjection = validate62;
-const schema113 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://yarramate.org/schema/projection/v1", "title": "YarraMate semantic projection", "type": "object", "additionalProperties": false, "required": ["format", "id", "version", "query"], "properties": { "format": { "const": "yarramate/projection/v1" }, "id": { "$ref": "#/$defs/id" }, "version": { "type": "string", "pattern": "^[0-9]+\\.[0-9]+$" }, "query": { "$ref": "#/$defs/query" }, "presentation": { "$ref": "#/$defs/presentation" } }, "$defs": { "query": { "type": "object", "additionalProperties": false, "properties": { "subjects": { "type": "array", "minItems": 1, "uniqueItems": true, "items": { "$ref": "#/$defs/subjectIdentity" } }, "instances": { "description": "Pattern instances whose CONTENTS this query selects (#473, ADR 0144). Each id names an instance, and the facet selects that instance together with everything the fold tree would draw inside it: the same closure `presentation.fold: \"instances\"` collapses into one box, read through this view's own `nesting`. This is the one facet that ADDS rather than narrows. `subjects` and `instances` are a single identity facet spelled two ways and their values combine with OR, while every other field still ANDs over the union. Naming the instance rather than hand-listing its members is what keeps a view from going stale the next time the pattern binds a slot. An id that names nothing is refused (YM921); one that names a subject which is not a pattern instance is refused separately (YM922), because a typo and a category error send an author to different places.", "type": "array", "minItems": 1, "uniqueItems": true, "items": { "$ref": "#/$defs/subjectIdentity" } }, "exclude": { "description": "Subjects this query would otherwise select and the author has taken out: the exception a rule cannot state (#267, ADR 0122). Applied after every other facet and after relationship expansion, so an excluded subject is out whichever way it would have come back in. Naming a subject no facet selects is allowed and inert until the model grows into the rule.", "type": "array", "minItems": 1, "uniqueItems": true, "items": { "$ref": "#/$defs/subjectIdentity" } }, "documents": { "type": "array", "uniqueItems": true, "items": { "$ref": "#/$defs/id" } }, "kinds": { "type": "array", "uniqueItems": true, "items": { "$ref": "#/$defs/qualifiedKind" } }, "layers": { "type": "array", "minItems": 1, "uniqueItems": true, "items": { "$ref": "#/$defs/layer" } }, "statuses": { "type": "array", "uniqueItems": true, "items": { "enum": ["planned", "current", "retired"] } }, "excludeStatuses": { "description": "Drop concepts carrying one of these lifecycle statuses while keeping concepts that declare no status at all - 'everything except retired' for viewpoint projections, where a bare statuses filter would wrongly drop unstatused actors and motivation elements.", "type": "array", "uniqueItems": true, "items": { "enum": ["planned", "current", "retired"] } }, "states": { "type": "array", "minItems": 1, "uniqueItems": true, "items": { "$ref": "#/$defs/subjectIdentity" } }, "owners": { "type": "array", "minItems": 1, "uniqueItems": true, "items": { "$ref": "#/$defs/subjectIdentity" } }, "constraints": { "type": "array", "minItems": 1, "uniqueItems": true, "items": { "$ref": "#/$defs/subjectIdentity" } }, "relationshipKinds": { "type": "array", "minItems": 1, "uniqueItems": true, "items": { "$ref": "#/$defs/qualifiedKind" } }, "kindMatching": { "enum": ["exact", "descendants"] }, "relationships": { "enum": ["between", "connected", "none"] }, "isolatedConcepts": { "enum": ["include", "exclude"] } } }, "presentation": { "type": "object", "additionalProperties": false, "properties": { "title": { "$ref": "#/$defs/nonEmptyText" }, "description": { "$ref": "#/$defs/nonEmptyText" }, "layout": { "enum": ["layered"] }, "direction": { "enum": ["top-down", "left-right"] }, "nesting": { "type": "array", "uniqueItems": true, "items": { "enum": ["composition", "assignment"] } }, "fold": { "description": "Whether this view draws pattern instances FOLDED by default (#473). \"instances\" collapses every instance to a single node carrying its members, with the edges into and out of them lifted onto the box; \"none\", the default, draws everything. A reader opens what they want, so this says where to START rather than what may be seen. Folding reads the same containment tree nesting does, so a view declaring fold without \"assignment\" in nesting collapses less than its author probably expects; the editor says so rather than the loader refusing it, because a diagnostic has no warning severity and this is not an error.", "enum": ["instances", "none"] }, "showLifecycle": { "type": "boolean" }, "showEvidence": { "type": "boolean" }, "showOwnership": { "type": "boolean" }, "notation": { "enum": ["archimate"] }, "folder": { "type": "string", "description": "The folder this view files itself under in an editor's rail. A LABEL the author declares, never the directory the projection sits in: nest with '/' separators, and the filesystem is never consulted (ADR 0104).", "pattern": "^[^/]+(?:/[^/]+)*$", "minLength": 1 } } }, "id": { "type": "string", "pattern": "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$" }, "qualifiedKind": { "type": "string", "pattern": "^[a-z][a-z0-9-]*(?:/[a-z][a-z0-9-]*)+@[0-9]+\\.[0-9]+#[a-z][A-Za-z0-9-]*$" }, "subjectIdentity": { "type": "string", "pattern": "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$" }, "nonEmptyText": { "type": "string", "minLength": 1 }, "layer": { "enum": ["motivation", "strategy", "business", "application", "technology", "physical", "implementation", "composite"] } } };
+const schema113 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://yarramate.org/schema/projection/v1", "title": "YarraMate semantic projection", "type": "object", "additionalProperties": false, "required": ["format", "id", "version", "query"], "properties": { "format": { "const": "yarramate/projection/v1" }, "id": { "$ref": "#/$defs/id" }, "version": { "type": "string", "pattern": "^[0-9]+\\.[0-9]+$" }, "query": { "$ref": "#/$defs/query" }, "presentation": { "$ref": "#/$defs/presentation" } }, "$defs": { "query": { "type": "object", "additionalProperties": false, "properties": { "subjects": { "type": "array", "minItems": 1, "uniqueItems": true, "items": { "$ref": "#/$defs/subjectIdentity" } }, "instances": { "description": "Pattern instances whose CONTENTS this query selects (#473, ADR 0144). Each id names an instance, and the facet selects that instance together with everything the fold tree would draw inside it: the same closure `presentation.fold: \"instances\"` collapses into one box, read through this view's own `nesting`. This is the one facet that ADDS rather than narrows. `subjects` and `instances` are a single identity facet spelled two ways and their values combine with OR, while every other field still ANDs over the union. Naming the instance rather than hand-listing its members is what keeps a view from going stale the next time the pattern binds a slot. An id that names nothing is refused (YM921); one that names a subject which is not a pattern instance is refused separately (YM922), because a typo and a category error send an author to different places.", "type": "array", "minItems": 1, "uniqueItems": true, "items": { "$ref": "#/$defs/subjectIdentity" } }, "exclude": { "description": "Subjects this query would otherwise select and the author has taken out: the exception a rule cannot state (#267, ADR 0122). Applied after every other facet and after relationship expansion, so an excluded subject is out whichever way it would have come back in. Naming a subject no facet selects is allowed and inert until the model grows into the rule.", "type": "array", "minItems": 1, "uniqueItems": true, "items": { "$ref": "#/$defs/subjectIdentity" } }, "documents": { "type": "array", "uniqueItems": true, "items": { "$ref": "#/$defs/id" } }, "kinds": { "type": "array", "uniqueItems": true, "items": { "$ref": "#/$defs/qualifiedKind" } }, "layers": { "type": "array", "minItems": 1, "uniqueItems": true, "items": { "$ref": "#/$defs/layer" } }, "statuses": { "type": "array", "uniqueItems": true, "items": { "enum": ["planned", "current", "retired"] } }, "excludeStatuses": { "description": "Drop concepts carrying one of these lifecycle statuses while keeping concepts that declare no status at all - 'everything except retired' for viewpoint projections, where a bare statuses filter would wrongly drop unstatused actors and motivation elements.", "type": "array", "uniqueItems": true, "items": { "enum": ["planned", "current", "retired"] } }, "states": { "type": "array", "minItems": 1, "uniqueItems": true, "items": { "$ref": "#/$defs/subjectIdentity" } }, "owners": { "type": "array", "minItems": 1, "uniqueItems": true, "items": { "$ref": "#/$defs/subjectIdentity" } }, "constraints": { "type": "array", "minItems": 1, "uniqueItems": true, "items": { "$ref": "#/$defs/subjectIdentity" } }, "relationshipKinds": { "type": "array", "minItems": 1, "uniqueItems": true, "items": { "$ref": "#/$defs/qualifiedKind" } }, "kindMatching": { "enum": ["exact", "descendants"] }, "relationships": { "enum": ["between", "connected", "none"] }, "isolatedConcepts": { "enum": ["include", "exclude"] } } }, "presentation": { "type": "object", "additionalProperties": false, "properties": { "title": { "$ref": "#/$defs/nonEmptyText" }, "description": { "$ref": "#/$defs/nonEmptyText" }, "layout": { "enum": ["layered"] }, "direction": { "enum": ["top-down", "left-right"] }, "nesting": { "type": "array", "uniqueItems": true, "items": { "enum": ["composition", "assignment"] } }, "fold": { "description": "Whether this view draws pattern instances FOLDED by default (#473). \"instances\" collapses every instance to a single node carrying its members, with the edges into and out of them lifted onto the box; \"none\", the default, draws everything. A reader opens what they want, so this says where to START rather than what may be seen. Folding reads the same containment tree nesting does, so a view declaring fold without \"assignment\" in nesting collapses less than its author probably expects; the editor says so rather than the loader refusing it, because a diagnostic has no warning severity and this is not an error.", "enum": ["instances", "none"] }, "showLifecycle": { "type": "boolean" }, "showEvidence": { "type": "boolean" }, "showOwnership": { "type": "boolean" }, "showConstraints": { "description": "Whether this view draws a bound RULING as a row inside the instance that holds it rather than as a node of its own (#473 phase 3, ADR 0145). A constraint filling an unwired slot of a visible instance becomes a line in that instance's label block, carrying its slot, its name and its RULER, and its association edge to the owner is hidden with it. Constraints nothing binds stay nodes: a requirement with no holder has no box to sit in. Presentation only, exactly like the three toggles above it: the model, the query and the selected set are identical either way, and a reader turns it off to get the boxes back.", "type": "boolean" }, "notation": { "enum": ["archimate"] }, "folder": { "type": "string", "description": "The folder this view files itself under in an editor's rail. A LABEL the author declares, never the directory the projection sits in: nest with '/' separators, and the filesystem is never consulted (ADR 0104).", "pattern": "^[^/]+(?:/[^/]+)*$", "minLength": 1 } } }, "id": { "type": "string", "pattern": "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$" }, "qualifiedKind": { "type": "string", "pattern": "^[a-z][a-z0-9-]*(?:/[a-z][a-z0-9-]*)+@[0-9]+\\.[0-9]+#[a-z][A-Za-z0-9-]*$" }, "subjectIdentity": { "type": "string", "pattern": "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$" }, "nonEmptyText": { "type": "string", "minLength": 1 }, "layer": { "enum": ["motivation", "strategy", "business", "application", "technology", "physical", "implementation", "composite"] } } };
 const schema114 = { "type": "string", "pattern": "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$" };
 const schema115 = { "type": "object", "additionalProperties": false, "properties": { "subjects": { "type": "array", "minItems": 1, "uniqueItems": true, "items": { "$ref": "#/$defs/subjectIdentity" } }, "instances": { "description": "Pattern instances whose CONTENTS this query selects (#473, ADR 0144). Each id names an instance, and the facet selects that instance together with everything the fold tree would draw inside it: the same closure `presentation.fold: \"instances\"` collapses into one box, read through this view's own `nesting`. This is the one facet that ADDS rather than narrows. `subjects` and `instances` are a single identity facet spelled two ways and their values combine with OR, while every other field still ANDs over the union. Naming the instance rather than hand-listing its members is what keeps a view from going stale the next time the pattern binds a slot. An id that names nothing is refused (YM921); one that names a subject which is not a pattern instance is refused separately (YM922), because a typo and a category error send an author to different places.", "type": "array", "minItems": 1, "uniqueItems": true, "items": { "$ref": "#/$defs/subjectIdentity" } }, "exclude": { "description": "Subjects this query would otherwise select and the author has taken out: the exception a rule cannot state (#267, ADR 0122). Applied after every other facet and after relationship expansion, so an excluded subject is out whichever way it would have come back in. Naming a subject no facet selects is allowed and inert until the model grows into the rule.", "type": "array", "minItems": 1, "uniqueItems": true, "items": { "$ref": "#/$defs/subjectIdentity" } }, "documents": { "type": "array", "uniqueItems": true, "items": { "$ref": "#/$defs/id" } }, "kinds": { "type": "array", "uniqueItems": true, "items": { "$ref": "#/$defs/qualifiedKind" } }, "layers": { "type": "array", "minItems": 1, "uniqueItems": true, "items": { "$ref": "#/$defs/layer" } }, "statuses": { "type": "array", "uniqueItems": true, "items": { "enum": ["planned", "current", "retired"] } }, "excludeStatuses": { "description": "Drop concepts carrying one of these lifecycle statuses while keeping concepts that declare no status at all - 'everything except retired' for viewpoint projections, where a bare statuses filter would wrongly drop unstatused actors and motivation elements.", "type": "array", "uniqueItems": true, "items": { "enum": ["planned", "current", "retired"] } }, "states": { "type": "array", "minItems": 1, "uniqueItems": true, "items": { "$ref": "#/$defs/subjectIdentity" } }, "owners": { "type": "array", "minItems": 1, "uniqueItems": true, "items": { "$ref": "#/$defs/subjectIdentity" } }, "constraints": { "type": "array", "minItems": 1, "uniqueItems": true, "items": { "$ref": "#/$defs/subjectIdentity" } }, "relationshipKinds": { "type": "array", "minItems": 1, "uniqueItems": true, "items": { "$ref": "#/$defs/qualifiedKind" } }, "kindMatching": { "enum": ["exact", "descendants"] }, "relationships": { "enum": ["between", "connected", "none"] }, "isolatedConcepts": { "enum": ["include", "exclude"] } } };
 const schema116 = { "type": "string", "pattern": "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$" };
@@ -5314,7 +5314,7 @@ else {
     errors++;
 } validate63.errors = vErrors; return errors === 0; }
 validate63.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
-const schema126 = { "type": "object", "additionalProperties": false, "properties": { "title": { "$ref": "#/$defs/nonEmptyText" }, "description": { "$ref": "#/$defs/nonEmptyText" }, "layout": { "enum": ["layered"] }, "direction": { "enum": ["top-down", "left-right"] }, "nesting": { "type": "array", "uniqueItems": true, "items": { "enum": ["composition", "assignment"] } }, "fold": { "description": "Whether this view draws pattern instances FOLDED by default (#473). \"instances\" collapses every instance to a single node carrying its members, with the edges into and out of them lifted onto the box; \"none\", the default, draws everything. A reader opens what they want, so this says where to START rather than what may be seen. Folding reads the same containment tree nesting does, so a view declaring fold without \"assignment\" in nesting collapses less than its author probably expects; the editor says so rather than the loader refusing it, because a diagnostic has no warning severity and this is not an error.", "enum": ["instances", "none"] }, "showLifecycle": { "type": "boolean" }, "showEvidence": { "type": "boolean" }, "showOwnership": { "type": "boolean" }, "notation": { "enum": ["archimate"] }, "folder": { "type": "string", "description": "The folder this view files itself under in an editor's rail. A LABEL the author declares, never the directory the projection sits in: nest with '/' separators, and the filesystem is never consulted (ADR 0104).", "pattern": "^[^/]+(?:/[^/]+)*$", "minLength": 1 } } };
+const schema126 = { "type": "object", "additionalProperties": false, "properties": { "title": { "$ref": "#/$defs/nonEmptyText" }, "description": { "$ref": "#/$defs/nonEmptyText" }, "layout": { "enum": ["layered"] }, "direction": { "enum": ["top-down", "left-right"] }, "nesting": { "type": "array", "uniqueItems": true, "items": { "enum": ["composition", "assignment"] } }, "fold": { "description": "Whether this view draws pattern instances FOLDED by default (#473). \"instances\" collapses every instance to a single node carrying its members, with the edges into and out of them lifted onto the box; \"none\", the default, draws everything. A reader opens what they want, so this says where to START rather than what may be seen. Folding reads the same containment tree nesting does, so a view declaring fold without \"assignment\" in nesting collapses less than its author probably expects; the editor says so rather than the loader refusing it, because a diagnostic has no warning severity and this is not an error.", "enum": ["instances", "none"] }, "showLifecycle": { "type": "boolean" }, "showEvidence": { "type": "boolean" }, "showOwnership": { "type": "boolean" }, "showConstraints": { "description": "Whether this view draws a bound RULING as a row inside the instance that holds it rather than as a node of its own (#473 phase 3, ADR 0145). A constraint filling an unwired slot of a visible instance becomes a line in that instance's label block, carrying its slot, its name and its RULER, and its association edge to the owner is hidden with it. Constraints nothing binds stay nodes: a requirement with no holder has no box to sit in. Presentation only, exactly like the three toggles above it: the model, the query and the selected set are identical either way, and a reader turns it off to get the boxes back.", "type": "boolean" }, "notation": { "enum": ["archimate"] }, "folder": { "type": "string", "description": "The folder this view files itself under in an editor's rail. A LABEL the author declares, never the directory the projection sits in: nest with '/' separators, and the filesystem is never consulted (ADR 0104).", "pattern": "^[^/]+(?:/[^/]+)*$", "minLength": 1 } } };
 const schema127 = { "type": "string", "minLength": 1 };
 function validate65(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { let vErrors = null; let errors = 0; const evaluated0 = validate65.evaluated; if (evaluated0.dynamicProps) {
     evaluated0.props = undefined;
@@ -5505,9 +5505,9 @@ function validate65(data, { instancePath = "", parentData, parentDataProperty, r
             errors++;
         }
     }
-    if (data.notation !== undefined) {
-        if (!(data.notation === "archimate")) {
-            const err14 = { instancePath: instancePath + "/notation", schemaPath: "#/properties/notation/enum", keyword: "enum", params: { allowedValues: schema126.properties.notation.enum }, message: "must be equal to one of the allowed values" };
+    if (data.showConstraints !== undefined) {
+        if (typeof data.showConstraints !== "boolean") {
+            const err14 = { instancePath: instancePath + "/showConstraints", schemaPath: "#/properties/showConstraints/type", keyword: "type", params: { type: "boolean" }, message: "must be boolean" };
             if (vErrors === null) {
                 vErrors = [err14];
             }
@@ -5517,49 +5517,61 @@ function validate65(data, { instancePath = "", parentData, parentDataProperty, r
             errors++;
         }
     }
+    if (data.notation !== undefined) {
+        if (!(data.notation === "archimate")) {
+            const err15 = { instancePath: instancePath + "/notation", schemaPath: "#/properties/notation/enum", keyword: "enum", params: { allowedValues: schema126.properties.notation.enum }, message: "must be equal to one of the allowed values" };
+            if (vErrors === null) {
+                vErrors = [err15];
+            }
+            else {
+                vErrors.push(err15);
+            }
+            errors++;
+        }
+    }
     if (data.folder !== undefined) {
-        let data11 = data.folder;
-        if (typeof data11 === "string") {
-            if (func2(data11) < 1) {
-                const err15 = { instancePath: instancePath + "/folder", schemaPath: "#/properties/folder/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" };
+        let data12 = data.folder;
+        if (typeof data12 === "string") {
+            if (func2(data12) < 1) {
+                const err16 = { instancePath: instancePath + "/folder", schemaPath: "#/properties/folder/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters" };
                 if (vErrors === null) {
-                    vErrors = [err15];
+                    vErrors = [err16];
                 }
                 else {
-                    vErrors.push(err15);
+                    vErrors.push(err16);
                 }
                 errors++;
             }
-            if (!pattern15.test(data11)) {
-                const err16 = { instancePath: instancePath + "/folder", schemaPath: "#/properties/folder/pattern", keyword: "pattern", params: { pattern: "^[^/]+(?:/[^/]+)*$" }, message: "must match pattern \"" + "^[^/]+(?:/[^/]+)*$" + "\"" };
+            if (!pattern15.test(data12)) {
+                const err17 = { instancePath: instancePath + "/folder", schemaPath: "#/properties/folder/pattern", keyword: "pattern", params: { pattern: "^[^/]+(?:/[^/]+)*$" }, message: "must match pattern \"" + "^[^/]+(?:/[^/]+)*$" + "\"" };
                 if (vErrors === null) {
-                    vErrors = [err16];
+                    vErrors = [err17];
                 }
                 else {
-                    vErrors.push(err16);
+                    vErrors.push(err17);
                 }
                 errors++;
             }
         }
         else {
-            const err17 = { instancePath: instancePath + "/folder", schemaPath: "#/properties/folder/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+            const err18 = { instancePath: instancePath + "/folder", schemaPath: "#/properties/folder/type", keyword: "type", params: { type: "string" }, message: "must be string" };
             if (vErrors === null) {
-                vErrors = [err17];
+                vErrors = [err18];
             }
             else {
-                vErrors.push(err17);
+                vErrors.push(err18);
             }
             errors++;
         }
     }
 }
 else {
-    const err18 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    const err19 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
     if (vErrors === null) {
-        vErrors = [err18];
+        vErrors = [err19];
     }
     else {
-        vErrors.push(err18);
+        vErrors.push(err19);
     }
     errors++;
 } validate65.errors = vErrors; return errors === 0; }