yarramate 0.15.0 → 0.16.0

package/dist/adapters/graphify-entry.d.ts

@@ -1 +1 @@
-export { observeGraphify, type GraphifyGraph, type GraphifyObservationIssue, type GraphifyObservationResult, } from './graphify.js';
+export { observeGraphify, type GraphifyObservationIssue, type GraphifyGraph, type GraphifyObservationResult, } from './graphify.js';

package/dist/adapters/graphify.d.ts

@@ -4,6 +4,11 @@ export interface GraphifyGraph {
     readonly nodes: readonly {
         readonly id: string;
     }[];
+    readonly edges?: readonly {
+        readonly id: string;
+        readonly source: string;
+        readonly target: string;
+    }[];
 }
 export interface GraphifyObservationIssue {
     readonly code: 'YMG101' | 'YMG102';

package/dist/adapters/likec4-export.js

@@ -233,6 +233,6 @@ export function exportLikeC4(projection, mapping, kindMapping, options = {}) {
                 return [`    style ${external} { color amber }`];
             }
             return [];
-        })), '    autoLayout LeftRight', '  }', '}', '');
+        })), `    autoLayout ${projection.presentation?.direction === 'top-down' ? 'TopBottom' : 'LeftRight'}`, '  }', '}', '');
     return { ok: true, source: lines.join('\n') };
 }

package/dist/compiler.d.ts

@@ -46,6 +46,7 @@ export interface SemanticGraph {
 export interface ResolvedProfileContext {
     readonly conceptKindLineages: ReadonlyMap<string, readonly string[]>;
     readonly relationshipKindLineages: ReadonlyMap<string, readonly string[]>;
+    readonly conceptKindLayers: ReadonlyMap<string, string>;
 }
 export type CompilationResult = {
     readonly ok: true;

package/dist/compiler.js

@@ -10,6 +10,24 @@ const coreProfile = 'yarramate/core@0.1';
 const Ajv2020 = Ajv2020Module.default;
 const validateDocument = new Ajv2020({ allErrors: true }).compile(documentSchema);
 const validateProfile = new Ajv2020({ allErrors: true }).compile(profileSchema);
+const immutableMap = (entries) => {
+    const backing = new Map(entries);
+    const facade = {
+        get: backing.get.bind(backing),
+        has: backing.has.bind(backing),
+        forEach(callback, thisArg) {
+            backing.forEach((value, key) => callback.call(thisArg, value, key, facade));
+        },
+        entries: backing.entries.bind(backing),
+        keys: backing.keys.bind(backing),
+        values: backing.values.bind(backing),
+        [Symbol.iterator]: backing[Symbol.iterator].bind(backing),
+        get size() {
+            return backing.size;
+        },
+    };
+    return Object.freeze(facade);
+};
 const compareById = (left, right) => left.id.localeCompare(right.id);
 const presenceClaimId = (subject, state) => `${subject}~present-in-${Buffer.from(state, 'utf8').toString('hex')}`;
 // Alternative labels and distinctness records are unordered sets, not
@@ -64,6 +82,7 @@ function compileWorkspaceResolved(sources) {
         const resolved = {
             identity: `${coreProfile}#${kind.id}`,
             aspect: kind.aspect,
+            layer: kind.layer,
             lineage: [`${coreProfile}#${kind.id}`],
             ...(kind.rigidity === undefined ? {} : { rigidity: kind.rigidity }),
         };
@@ -226,6 +245,7 @@ function compileWorkspaceResolved(sources) {
                 const resolved = {
                     identity: `${identity}#${kind.id}`,
                     aspect: parent.aspect,
+                    layer: kind.layer ?? parent.layer,
                     lineage: [...parent.lineage, `${identity}#${kind.id}`],
                     ...(kind.rigidity === undefined ? {} : { rigidity: kind.rigidity }),
                 };
@@ -1267,12 +1287,21 @@ function compileWorkspaceResolved(sources) {
     return {
         ok: true,
         profileContext: {
-            conceptKindLineages: new Map([...conceptKindByIdentity]
+            conceptKindLineages: immutableMap([...conceptKindByIdentity]
                 .sort(([left], [right]) => left.localeCompare(right))
-                .map(([identity, kind]) => [identity, kind.lineage])),
-            relationshipKindLineages: new Map([...relationshipKindByIdentity]
+                .map(([identity, kind]) => [
+                identity,
+                Object.freeze([...kind.lineage]),
+            ])),
+            relationshipKindLineages: immutableMap([...relationshipKindByIdentity]
+                .sort(([left], [right]) => left.localeCompare(right))
+                .map(([identity, kind]) => [
+                identity,
+                Object.freeze([...kind.lineage]),
+            ])),
+            conceptKindLayers: immutableMap([...conceptKindByIdentity]
                 .sort(([left], [right]) => left.localeCompare(right))
-                .map(([identity, kind]) => [identity, kind.lineage])),
+                .map(([identity, kind]) => [identity, kind.layer])),
         },
         graph: {
             format: 'yarramate/graph/v2',

package/dist/index.d.ts

@@ -8,6 +8,6 @@ export { constraintExpectsPredicate, reconcileEvidenceReports, type AssertedRela
 export { deriveAttestationStaleness } from './attestation-staleness.js';
 export { buildRtm, renderRtmMarkdown, type RequirementsTraceabilityMatrix, type RtmAttestation, type RtmContextEntry, type RtmDescopedEntry, type RtmEvidenceVerdict, type RtmLineageEntry, type RtmRealizer, type RtmRow, type RtmSource, } from './rtm.js';
 export type { CompilationResult, ContextualCompilationResult, Diagnostic, GraphClaim, GraphSource, SemanticGraph, ResolvedProfileContext, WorkspaceSource, } from './compiler.js';
-export { evaluateProjection, loadProjection, renderProjectionMarkdown, } from './projection.js';
+export { canonicalProjection, evaluateProjection, loadProjection, renderProjectionMarkdown, } from './projection.js';
 export { loadAdapterMapping, validateAdapterMapping, validateAdapterMappings, type AdapterMapping, type AdapterMappingLoadResult, type AdapterMappingValidationResult, type AdapterMappingsValidationResult, type AdapterSubjectMapping, } from './adapter-mapping.js';
 export type { LifecycleStatus, ProjectionDefinition, ProjectionLoadResult, ProjectionResult, } from './projection.js';

package/dist/index.js

@@ -7,5 +7,5 @@ export { evaluateEvidence, evaluateEvidenceWorkspace, loadEvidence, } from './ev
 export { constraintExpectsPredicate, reconcileEvidenceReports, } from './reconciliation.js';
 export { deriveAttestationStaleness } from './attestation-staleness.js';
 export { buildRtm, renderRtmMarkdown, } from './rtm.js';
-export { evaluateProjection, loadProjection, renderProjectionMarkdown, } from './projection.js';
+export { canonicalProjection, evaluateProjection, loadProjection, renderProjectionMarkdown, } from './projection.js';
 export { loadAdapterMapping, validateAdapterMapping, validateAdapterMappings, } from './adapter-mapping.js';

package/dist/projection.d.ts

@@ -8,6 +8,7 @@ export interface ProjectionDefinition {
         readonly subjects?: readonly string[];
         readonly documents?: readonly string[];
         readonly kinds?: readonly string[];
+        readonly layers?: readonly string[];
         readonly statuses?: readonly LifecycleStatus[];
         readonly excludeStatuses?: readonly LifecycleStatus[];
         readonly states?: readonly string[];
@@ -21,6 +22,12 @@ export interface ProjectionDefinition {
     readonly presentation?: {
         readonly title?: string;
         readonly description?: string;
+        readonly layout?: 'layered' | 'radial' | 'force';
+        readonly direction?: 'top-down' | 'left-right';
+        readonly seed?: string;
+        readonly showLifecycle?: boolean;
+        readonly showEvidence?: boolean;
+        readonly showOwnership?: boolean;
     };
 }
 export interface ProjectionResult {
@@ -39,6 +46,7 @@ export type ProjectionLoadResult = {
     readonly diagnostics: readonly Diagnostic[];
 };
 export declare function loadProjection(source: WorkspaceSource): ProjectionLoadResult;
+export declare function canonicalProjection(projection: ProjectionDefinition): ProjectionDefinition;
 export declare function evaluateProjection(graph: SemanticGraph, projection: ProjectionDefinition, profileContext?: ResolvedProfileContext): ProjectionResult;
 export declare function renderProjectionMarkdown(result: ProjectionResult, profileContext?: ResolvedProfileContext): string;
 export declare function renderBudgetedContext(result: ProjectionResult, budgetTokens: number): string;

package/dist/projection.js

@@ -11,6 +11,44 @@ export function loadProjection(source) {
         ? { ok: true, projection: loaded.document.value }
         : loaded;
 }
+export function canonicalProjection(projection) {
+    const query = projection.query;
+    const presentation = projection.presentation;
+    return {
+        format: projection.format,
+        id: projection.id,
+        version: projection.version,
+        query: {
+            ...(query.subjects === undefined ? {} : { subjects: [...query.subjects].sort() }),
+            ...(query.documents === undefined ? {} : { documents: [...query.documents].sort() }),
+            ...(query.kinds === undefined ? {} : { kinds: [...query.kinds].sort() }),
+            ...(query.layers === undefined ? {} : { layers: [...query.layers].sort() }),
+            ...(query.statuses === undefined ? {} : { statuses: [...query.statuses].sort() }),
+            ...(query.excludeStatuses === undefined ? {} : { excludeStatuses: [...query.excludeStatuses].sort() }),
+            ...(query.states === undefined ? {} : { states: [...query.states].sort() }),
+            ...(query.owners === undefined ? {} : { owners: [...query.owners].sort() }),
+            ...(query.constraints === undefined ? {} : { constraints: [...query.constraints].sort() }),
+            ...(query.relationshipKinds === undefined ? {} : { relationshipKinds: [...query.relationshipKinds].sort() }),
+            ...(query.kindMatching === undefined ? {} : { kindMatching: query.kindMatching }),
+            ...(query.relationships === undefined ? {} : { relationships: query.relationships }),
+            ...(query.isolatedConcepts === undefined ? {} : { isolatedConcepts: query.isolatedConcepts }),
+        },
+        ...(presentation === undefined
+            ? {}
+            : {
+                presentation: {
+                    ...(presentation.title === undefined ? {} : { title: presentation.title }),
+                    ...(presentation.description === undefined ? {} : { description: presentation.description }),
+                    ...(presentation.layout === undefined ? {} : { layout: presentation.layout }),
+                    ...(presentation.direction === undefined ? {} : { direction: presentation.direction }),
+                    ...(presentation.seed === undefined ? {} : { seed: presentation.seed }),
+                    ...(presentation.showLifecycle === undefined ? {} : { showLifecycle: presentation.showLifecycle }),
+                    ...(presentation.showEvidence === undefined ? {} : { showEvidence: presentation.showEvidence }),
+                    ...(presentation.showOwnership === undefined ? {} : { showOwnership: presentation.showOwnership }),
+                },
+            }),
+    };
+}
 const claimValue = (claims, subject, predicate) => {
     const object = claims.find((claim) => claim.subject === subject && claim.predicate === predicate)?.object;
     return object !== undefined && 'value' in object ? object.value : undefined;
@@ -40,6 +78,14 @@ export function evaluateProjection(graph, projection, profileContext) {
         return (presence.length === 0 ||
             presence.some((state) => selectedStateIds.includes(state)));
     };
+    const endpointExcluded = (id) => {
+        if (!participatesInSelectedState(id))
+            return true;
+        const status = claimValue(graph.claims, id, 'yarramate/lifecycle/status');
+        return (status !== undefined &&
+            projection.query.excludeStatuses?.includes(status) ===
+                true);
+    };
     const initiallySelectedConceptIds = new Set(graph.subjects
         .filter(({ type }) => type === 'concept')
         .filter(({ id }) => {
@@ -62,6 +108,10 @@ export function evaluateProjection(graph, projection, profileContext) {
                             profileContext?.conceptKindLineages
                                 .get(kind)
                                 ?.includes(selectedKind) === true)))) &&
+            (projection.query.layers === undefined ||
+                (kind !== undefined &&
+                    profileContext?.conceptKindLayers.get(kind) !== undefined &&
+                    projection.query.layers.includes(profileContext.conceptKindLayers.get(kind)))) &&
             (projection.query.statuses === undefined ||
                 (status !== undefined &&
                     projection.query.statuses.includes(status))) &&
@@ -100,16 +150,6 @@ export function evaluateProjection(graph, projection, profileContext) {
             }
             const sourceSelected = initiallySelectedConceptIds.has(relationship.subject);
             const targetSelected = initiallySelectedConceptIds.has(relationship.object.ref);
-            // excludeStatuses also vetoes connected expansion: an excluded
-            // concept is never pulled in as a neighbour, and edges touching
-            // one are dropped rather than left dangling.
-            const endpointExcluded = (id) => {
-                if (projection.query.excludeStatuses === undefined)
-                    return false;
-                const endpointStatus = claimValue(graph.claims, id, 'yarramate/lifecycle/status');
-                return (endpointStatus !== undefined &&
-                    projection.query.excludeStatuses.includes(endpointStatus));
-            };
             if (endpointExcluded(relationship.subject) ||
                 endpointExcluded(relationship.object.ref)) {
                 continue;
@@ -168,6 +208,24 @@ export function evaluateProjection(graph, projection, profileContext) {
                     ...(projection.presentation.description === undefined
                         ? {}
                         : { description: projection.presentation.description }),
+                    ...(projection.presentation.layout === undefined
+                        ? {}
+                        : { layout: projection.presentation.layout }),
+                    ...(projection.presentation.direction === undefined
+                        ? {}
+                        : { direction: projection.presentation.direction }),
+                    ...(projection.presentation.seed === undefined
+                        ? {}
+                        : { seed: projection.presentation.seed }),
+                    ...(projection.presentation.showLifecycle === undefined
+                        ? {}
+                        : { showLifecycle: projection.presentation.showLifecycle }),
+                    ...(projection.presentation.showEvidence === undefined
+                        ? {}
+                        : { showEvidence: projection.presentation.showEvidence }),
+                    ...(projection.presentation.showOwnership === undefined
+                        ? {}
+                        : { showOwnership: projection.presentation.showOwnership }),
                 },
             }),
         documents: graph.documents.filter(({ id }) => selectedDocuments.has(id)),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yarramate",
-  "version": "0.15.0",
+  "version": "0.16.0",
   "description": "Tool-neutral semantic architecture engine and guided methodology",
   "license": "MIT",
   "repository": {

package/schema/yarramate-profile.schema.json

@@ -80,6 +80,9 @@
         },
         "rigidity": {
           "$ref": "#/$defs/rigidity"
+        },
+        "layer": {
+          "$ref": "#/$defs/layer"
         }
       }
     },
@@ -115,6 +118,18 @@
           }
         }
       }
-    }
+    },
+    "layer": {
+      "enum": [
+        "motivation",
+        "strategy",
+        "business",
+        "application",
+        "technology",
+        "physical",
+        "implementation",
+        "composite"
+      ]
+  }
   }
 }

package/schema/yarramate-projection-result.schema.json

@@ -24,6 +24,25 @@
         "description": {
           "type": "string",
           "minLength": 1
+        },
+        "layout": {
+          "enum": ["layered", "radial", "force"]
+        },
+        "direction": {
+          "enum": ["top-down", "left-right"]
+        },
+        "seed": {
+          "type": "string",
+          "minLength": 1
+        },
+        "showLifecycle": {
+          "type": "boolean"
+        },
+        "showEvidence": {
+          "type": "boolean"
+        },
+        "showOwnership": {
+          "type": "boolean"
         }
       }
     },

package/schema/yarramate-projection.schema.json

@@ -42,6 +42,14 @@
             "$ref": "#/$defs/qualifiedKind"
           }
         },
+        "layers": {
+          "type": "array",
+          "minItems": 1,
+          "uniqueItems": true,
+          "items": {
+            "$ref": "#/$defs/layer"
+          }
+        },
         "statuses": {
           "type": "array",
           "uniqueItems": true,
@@ -109,8 +117,36 @@
         },
         "description": {
           "$ref": "#/$defs/nonEmptyText"
+        },
+        "layout": {
+          "enum": ["layered", "radial", "force"]
+        },
+        "direction": {
+          "enum": ["top-down", "left-right"]
+        },
+        "seed": {
+          "$ref": "#/$defs/nonEmptyText"
+        },
+        "showLifecycle": {
+          "type": "boolean"
+        },
+        "showEvidence": {
+          "type": "boolean"
+        },
+        "showOwnership": {
+          "type": "boolean"
         }
-      }
+      },
+      "allOf": [
+        {
+          "if": {
+            "required": ["layout"]
+          },
+          "then": {
+            "required": ["seed"]
+          }
+        }
+      ]
     }
   },
   "$defs": {
@@ -129,6 +165,18 @@
     "nonEmptyText": {
       "type": "string",
       "minLength": 1
-    }
+    },
+    "layer": {
+      "enum": [
+        "motivation",
+        "strategy",
+        "business",
+        "application",
+        "technology",
+        "physical",
+        "implementation",
+        "composite"
+      ]
+  }
   }
 }