yarramate 1.23.2 → 1.24.0

package/dist/brief.js

@@ -1,4 +1,5 @@
 import { conceptKinds } from './profile.js';
+import { RELATIONSHIP_READING, humanizeKind } from './relationship-reading.js';
 const coreKindNames = new Map(conceptKinds.map(({ id, name }) => [id, name]));
 const motivationKindIds = new Set(conceptKinds
     .filter(({ layer }) => layer === 'motivation')
@@ -41,54 +42,32 @@ export const isDeclaredNonGoal = (kind, status, lineages) => {
     const core = coreLocalKind(kind, lineages);
     return core !== undefined && nonGoalKindIds.has(core);
 };
-const humanizeKind = (kind) => {
-    const local = kind.slice(kind.indexOf('#') + 1);
-    return local
-        .replaceAll(/([a-z0-9])([A-Z])/g, '$1 $2')
-        .replaceAll('-', ' ')
-        .toLowerCase();
-};
 const article = (reading) => /^[aeiou]/.test(reading) ? 'an' : 'a';
 const sentenceEnd = (text) => /[.!?]["')\]]*$/.test(text.trimEnd()) ? text.trimEnd() : `${text.trimEnd()}.`;
 const listPhrase = (items) => items.length <= 1
     ? (items[0] ?? '')
     : `${items.slice(0, -1).join(', ')} and ${items[items.length - 1]}`;
 // Phrase forms are the prose readings of each core relationship kind's
-// declared intent — the same table `next` reads for ordering, spoken
-// from the source's perspective.
+// declared intent - the same table `next` reads for ordering, spoken from
+// the source's perspective. The plain readings live in
+// `./relationship-reading.ts`, shared with the canvas's edge labels (ADR
+// 0147); only the two kinds whose reading depends on the relationship's own
+// fields are phrased here.
 const relationshipPhrase = (coreKind, fallbackKind, mode, content) => {
-    switch (coreKind) {
-        case 'serving':
-            return 'serves';
-        case 'access':
-            return mode === 'read'
-                ? 'reads'
-                : mode === 'write'
-                    ? 'writes'
-                    : mode === 'read-write'
-                        ? 'reads and writes'
-                        : 'accesses';
-        case 'realization':
-            return 'realizes';
-        case 'composition':
-            return 'comprises';
-        case 'aggregation':
-            return 'aggregates';
-        case 'assignment':
-            return 'is assigned to';
-        case 'triggering':
-            return 'triggers';
-        case 'flow':
-            return content === undefined ? 'flows to' : `sends ${content} to`;
-        case 'specialization':
-            return 'specializes';
-        case 'influence':
-            return 'influences';
-        case 'association':
-            return 'is associated with';
-        default:
-            return humanizeKind(fallbackKind);
+    if (coreKind === 'access') {
+        return mode === 'read'
+            ? 'reads'
+            : mode === 'write'
+                ? 'writes'
+                : mode === 'read-write'
+                    ? 'reads and writes'
+                    : 'accesses';
+    }
+    if (coreKind === 'flow') {
+        return content === undefined ? 'flows to' : `sends ${content} to`;
     }
+    const reading = coreKind === undefined ? undefined : RELATIONSHIP_READING[coreKind];
+    return reading ?? humanizeKind(fallbackKind);
 };
 const estimateTokens = (text) => Math.ceil(text.length / 4);
 export function renderBrief(result, profileContext, budgetTokens, 

package/dist/layout-mode.d.ts

@@ -0,0 +1,56 @@
+/**
+ * How a view arranges itself, kept in a module that imports nothing.
+ *
+ * Apart from `projection.ts` for the reason `./layout-direction.ts` gives: the
+ * browser needs the value and not only the type, and `projection.ts` drags Ajv
+ * and the projection schema in for one constant. `projection.ts` re-exports
+ * everything here.
+ *
+ * The four modes are a ladder; each keeps everything below it (ADR 0147).
+ *
+ * - `layered`: ELK places the nodes and cytoscape draws its own orthogonal
+ *   lines between them, through whatever happens to sit in the way. This is
+ *   what shipped before 1.24; measured on the ApertureX reference model, 127
+ *   of the Landscape's 206 drawn edges cut through a box that was not one of
+ *   their endpoints.
+ * - `routed`: ELK also routes every edge around the nodes and reserves room
+ *   for each label. Zero edges through boxes on every view measured.
+ * - `served-by`: routed, and serving, realization and specialization are
+ *   layered UPWARD, so the served, realized or general element sits above
+ *   what serves, realizes or specializes it, and the label reads down the
+ *   page as "served by". Only the layering turns; the arrowhead, which says
+ *   which end is which, keeps its ArchiMate form.
+ * - `bands`: served-by, and every element is pinned to its ArchiMate layer's
+ *   band, motivation at the top and physical at the bottom.
+ */
+export declare const LAYOUT_MODES: readonly ['layered', 'routed', 'served-by', 'bands'];
+export type LayoutMode = (typeof LAYOUT_MODES)[number];
+/**
+ * How a view lays out when it does not say. Served-by, because it is the
+ * mode that read correctly the first time anyone looked at real tiers: the
+ * plain top-down run put the system API above the experience API (ADR 0147).
+ * A view that wants the pre-1.24 picture declares `layout: layered`.
+ */
+export declare const DEFAULT_LAYOUT: LayoutMode;
+export declare const isLayoutMode: (value: unknown) => value is LayoutMode;
+/** Whether ELK's own routes are drawn, rather than cytoscape's straight lines. */
+export declare const routesEdges: (mode: LayoutMode) => boolean;
+/** Whether the upward kinds are layered target-above-source. */
+export declare const reversesForLayering: (mode: LayoutMode) => boolean;
+/** Whether every node is pinned to its ArchiMate layer's band. */
+export declare const partitionsByLayer: (mode: LayoutMode) => boolean;
+/**
+ * The kinds ArchiMate draws with the TARGET above the source: the served
+ * element above its server, the realized above its realizer, the general
+ * above its specialization. Reversed for layering only; the notation module
+ * still draws the arrowhead at the target.
+ */
+export declare const LAYERING_REVERSED_KINDS: ReadonlySet<string>;
+/**
+ * Each ArchiMate layer's band under `bands`, top to bottom. `composite` has no
+ * band of its own - a grouping holds members from any layer - and a subject
+ * with no layer floats free, so neither is listed: ELK partitions only what
+ * names a partition, and leaves the rest to the layering.
+ */
+export declare const LAYER_BAND: Readonly<Record<string, number>>;
+export declare const layerBandOf: (layer: string | null | undefined) => number | undefined;

package/dist/layout-mode.js

@@ -0,0 +1,67 @@
+/**
+ * How a view arranges itself, kept in a module that imports nothing.
+ *
+ * Apart from `projection.ts` for the reason `./layout-direction.ts` gives: the
+ * browser needs the value and not only the type, and `projection.ts` drags Ajv
+ * and the projection schema in for one constant. `projection.ts` re-exports
+ * everything here.
+ *
+ * The four modes are a ladder; each keeps everything below it (ADR 0147).
+ *
+ * - `layered`: ELK places the nodes and cytoscape draws its own orthogonal
+ *   lines between them, through whatever happens to sit in the way. This is
+ *   what shipped before 1.24; measured on the ApertureX reference model, 127
+ *   of the Landscape's 206 drawn edges cut through a box that was not one of
+ *   their endpoints.
+ * - `routed`: ELK also routes every edge around the nodes and reserves room
+ *   for each label. Zero edges through boxes on every view measured.
+ * - `served-by`: routed, and serving, realization and specialization are
+ *   layered UPWARD, so the served, realized or general element sits above
+ *   what serves, realizes or specializes it, and the label reads down the
+ *   page as "served by". Only the layering turns; the arrowhead, which says
+ *   which end is which, keeps its ArchiMate form.
+ * - `bands`: served-by, and every element is pinned to its ArchiMate layer's
+ *   band, motivation at the top and physical at the bottom.
+ */
+export const LAYOUT_MODES = ['layered', 'routed', 'served-by', 'bands'];
+/**
+ * How a view lays out when it does not say. Served-by, because it is the
+ * mode that read correctly the first time anyone looked at real tiers: the
+ * plain top-down run put the system API above the experience API (ADR 0147).
+ * A view that wants the pre-1.24 picture declares `layout: layered`.
+ */
+export const DEFAULT_LAYOUT = 'served-by';
+export const isLayoutMode = (value) => typeof value === 'string' && LAYOUT_MODES.includes(value);
+/** Whether ELK's own routes are drawn, rather than cytoscape's straight lines. */
+export const routesEdges = (mode) => mode !== 'layered';
+/** Whether the upward kinds are layered target-above-source. */
+export const reversesForLayering = (mode) => mode === 'served-by' || mode === 'bands';
+/** Whether every node is pinned to its ArchiMate layer's band. */
+export const partitionsByLayer = (mode) => mode === 'bands';
+/**
+ * The kinds ArchiMate draws with the TARGET above the source: the served
+ * element above its server, the realized above its realizer, the general
+ * above its specialization. Reversed for layering only; the notation module
+ * still draws the arrowhead at the target.
+ */
+export const LAYERING_REVERSED_KINDS = new Set([
+    'serving',
+    'realization',
+    'specialization',
+]);
+/**
+ * Each ArchiMate layer's band under `bands`, top to bottom. `composite` has no
+ * band of its own - a grouping holds members from any layer - and a subject
+ * with no layer floats free, so neither is listed: ELK partitions only what
+ * names a partition, and leaves the rest to the layering.
+ */
+export const LAYER_BAND = {
+    motivation: 0,
+    strategy: 1,
+    business: 2,
+    application: 3,
+    technology: 4,
+    physical: 5,
+    implementation: 6,
+};
+export const layerBandOf = (layer) => layer === null || layer === undefined ? undefined : LAYER_BAND[layer];

package/dist/projection.d.ts

@@ -51,7 +51,13 @@ export interface ProjectionDefinition {
     readonly presentation?: {
         readonly title?: string;
         readonly description?: string;
-        readonly layout?: 'layered';
+        /**
+         * How this view arranges itself: `layered`, `routed`, `served-by` or
+         * `bands`, a ladder where each keeps everything below it (ADR 0147). A
+         * view that says nothing lays out `served-by`. The canvas offers the
+         * choice on screen and a save writes what is in force.
+         */
+        readonly layout?: LayoutMode;
         /**
          * Which way this view runs its layers. Read by the LikeC4 export for its
          * `autoLayout` and by the canvas for ELK's `elk.direction` (ADR 0121); a
@@ -78,6 +84,13 @@ export interface ProjectionDefinition {
         readonly showLifecycle?: boolean;
         readonly showEvidence?: boolean;
         readonly showOwnership?: boolean;
+        /**
+         * Whether an unnamed relationship is labelled with its reading - "serves",
+         * "served by", "realizes" - or left to its line style and arrowhead
+         * (ADR 0147). A named relationship keeps its name either way. On when
+         * absent, which is what shipped.
+         */
+        readonly showKindLabels?: 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
@@ -116,6 +129,12 @@ import { type FoldMembership } from './fold-tree.js';
  */
 export { DEFAULT_DIRECTION, type LayoutDirection } from './layout-direction.js';
 import type { LayoutDirection } from './layout-direction.js';
+/**
+ * How a view arranges itself, and the default. Same split, same terms
+ * (ADR 0147).
+ */
+export { DEFAULT_LAYOUT, LAYOUT_MODES, type LayoutMode } from './layout-mode.js';
+import type { LayoutMode } from './layout-mode.js';
 export type ProjectionQuery = ProjectionDefinition['query'];
 export interface ProjectionResult {
     readonly format: 'yarramate/projection-result/v1';

package/dist/projection.js

@@ -23,6 +23,11 @@ import { kindLabelOf } from './kind-label.js';
  * nesting vocabulary above, and re-exported here on the same terms (ADR 0121).
  */
 export { DEFAULT_DIRECTION } from './layout-direction.js';
+/**
+ * How a view arranges itself, and the default. Same split, same terms
+ * (ADR 0147).
+ */
+export { DEFAULT_LAYOUT, LAYOUT_MODES } from './layout-mode.js';
 import { validateProjection } from './schema-validation.js';
 export function loadProjection(source) {
     const loaded = loadSourceDocument(source, validateProjection, 'Projection');
@@ -66,6 +71,7 @@ export function canonicalProjection(projection) {
                     ...(presentation.showLifecycle === undefined ? {} : { showLifecycle: presentation.showLifecycle }),
                     ...(presentation.showEvidence === undefined ? {} : { showEvidence: presentation.showEvidence }),
                     ...(presentation.showOwnership === undefined ? {} : { showOwnership: presentation.showOwnership }),
+                    ...(presentation.showKindLabels === undefined ? {} : { showKindLabels: presentation.showKindLabels }),
                     ...(presentation.notation === undefined ? {} : { notation: presentation.notation }),
                 },
             }),
@@ -631,6 +637,9 @@ export function evaluateProjection(graph, projection, profileContext, membership
                     ...(projection.presentation.showOwnership === undefined
                         ? {}
                         : { showOwnership: projection.presentation.showOwnership }),
+                    ...(projection.presentation.showKindLabels === undefined
+                        ? {}
+                        : { showKindLabels: projection.presentation.showKindLabels }),
                     ...(projection.presentation.notation === undefined
                         ? {}
                         : { notation: projection.presentation.notation }),

package/dist/relationship-reading.d.ts

@@ -0,0 +1,28 @@
+/**
+ * How a relationship reads as prose, kept in a module that imports nothing.
+ *
+ * One table for the brief and the canvas (ADR 0147). The brief has said
+ * "System API serves Process API" since it existed, and an edge label reading
+ * `serving` beside it was the same fact in a different voice. Every phrase
+ * here is spoken from the SOURCE: "a serves b".
+ *
+ * A canvas that layers the served element above what serves it reads the same
+ * edge from the other end, "b served by a", so the three kinds that turn for
+ * layering (`LAYERING_REVERSED_KINDS` in `./layout-mode.ts`) also carry a
+ * passive reading. Nothing else does: "b accessed by a" is not how anyone
+ * reads an access.
+ */
+export declare const RELATIONSHIP_READING: Readonly<Record<string, string>>;
+export declare const REVERSED_READING: Readonly<Record<string, string>>;
+/**
+ * `acme/p@1#applicationComponent` reads "application component" and
+ * `data-object` reads "data object": the last resort for a kind the table does
+ * not know, which is every extension kind.
+ */
+export declare const humanizeKind: (kind: string) => string;
+/**
+ * The reading of one relationship kind. `reversed` asks for the passive form
+ * and gets it only where one exists; a kind with no passive reading keeps its
+ * active one, so a caller can pass the layering's answer straight through.
+ */
+export declare const relationshipReading: (coreKind: string, reversed?: boolean) => string;

package/dist/relationship-reading.js

@@ -0,0 +1,52 @@
+/**
+ * How a relationship reads as prose, kept in a module that imports nothing.
+ *
+ * One table for the brief and the canvas (ADR 0147). The brief has said
+ * "System API serves Process API" since it existed, and an edge label reading
+ * `serving` beside it was the same fact in a different voice. Every phrase
+ * here is spoken from the SOURCE: "a serves b".
+ *
+ * A canvas that layers the served element above what serves it reads the same
+ * edge from the other end, "b served by a", so the three kinds that turn for
+ * layering (`LAYERING_REVERSED_KINDS` in `./layout-mode.ts`) also carry a
+ * passive reading. Nothing else does: "b accessed by a" is not how anyone
+ * reads an access.
+ */
+export const RELATIONSHIP_READING = {
+    serving: 'serves',
+    access: 'accesses',
+    realization: 'realizes',
+    composition: 'comprises',
+    aggregation: 'aggregates',
+    assignment: 'is assigned to',
+    triggering: 'triggers',
+    flow: 'flows to',
+    specialization: 'specializes',
+    influence: 'influences',
+    association: 'is associated with',
+};
+export const REVERSED_READING = {
+    serving: 'served by',
+    realization: 'realized by',
+    specialization: 'specialized by',
+};
+/**
+ * `acme/p@1#applicationComponent` reads "application component" and
+ * `data-object` reads "data object": the last resort for a kind the table does
+ * not know, which is every extension kind.
+ */
+export const humanizeKind = (kind) => {
+    const local = kind.slice(kind.indexOf('#') + 1);
+    return local
+        .replaceAll(/([a-z0-9])([A-Z])/g, '$1 $2')
+        .replaceAll('-', ' ')
+        .toLowerCase();
+};
+/**
+ * The reading of one relationship kind. `reversed` asks for the passive form
+ * and gets it only where one exists; a kind with no passive reading keeps its
+ * active one, so a caller can pass the layering's answer straight through.
+ */
+export const relationshipReading = (coreKind, reversed = false) => (reversed ? REVERSED_READING[coreKind] : undefined) ??
+    RELATIONSHIP_READING[coreKind] ??
+    humanizeKind(coreKind);

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: 047e27f42a2bbeaf186894dad22fea47af390a5f299667cca2e70b20873fbf05
 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": { "description": "How the view arranges itself (ADR 0147), a ladder where each mode keeps everything below it: \"layered\" places the nodes and lets the canvas draw straight lines between them; \"routed\" also routes every edge around the nodes and reserves room for its label; \"served-by\" also layers serving, realization and specialization upward, so the served element sits above what serves it and the label reads down the page; \"bands\" also pins every element to its ArchiMate layer's band. A view that says nothing lays out \"served-by\".", "enum": ["layered", "routed", "served-by", "bands"] }, "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" }, "showKindLabels": { "description": "Whether an unnamed relationship is labelled with its reading (\"serves\", \"served by\", \"realizes\"). Off, the line style and arrowhead alone say the kind; a named relationship keeps its name either way. On when absent.", "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": { "description": "How the view arranges itself (ADR 0147), a ladder where each mode keeps everything below it: \"layered\" places the nodes and lets the canvas draw straight lines between them; \"routed\" also routes every edge around the nodes and reserves room for its label; \"served-by\" also layers serving, realization and specialization upward, so the served element sits above what serves it and the label reads down the page; \"bands\" also pins every element to its ArchiMate layer's band. A view that says nothing lays out \"served-by\".", "enum": ["layered", "routed", "served-by", "bands"] }, "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" }, "showKindLabels": { "description": "Whether an unnamed relationship is labelled with its reading (\"serves\", \"served by\", \"realizes\"). Off, the line style and arrowhead alone say the kind; a named relationship keeps its name either way. On when absent.", "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;
@@ -5384,7 +5384,8 @@ function validate65(data, { instancePath = "", parentData, parentDataProperty, r
         }
     }
     if (data.layout !== undefined) {
-        if (!(data.layout === "layered")) {
+        let data2 = data.layout;
+        if (!((((data2 === "layered") || (data2 === "routed")) || (data2 === "served-by")) || (data2 === "bands"))) {
             const err5 = { instancePath: instancePath + "/layout", schemaPath: "#/properties/layout/enum", keyword: "enum", params: { allowedValues: schema126.properties.layout.enum }, message: "must be equal to one of the allowed values" };
             if (vErrors === null) {
                 vErrors = [err5];
@@ -5505,9 +5506,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.showKindLabels !== undefined) {
+        if (typeof data.showKindLabels !== "boolean") {
+            const err14 = { instancePath: instancePath + "/showKindLabels", schemaPath: "#/properties/showKindLabels/type", keyword: "type", params: { type: "boolean" }, message: "must be boolean" };
             if (vErrors === null) {
                 vErrors = [err14];
             }
@@ -5517,49 +5518,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; }