yarramate 1.3.0 → 1.4.0

package/catalogues/core-enrichment.yaml

@@ -1,6 +1,6 @@
 format: yarramate/question-catalogue/v1
 id: core-enrichment
-version: "1.2"
+version: "1.3"
 profile: yarramate/core@0.1
 presentation:
   title: Core enrichment interview
@@ -25,27 +25,39 @@ waves:
       Load-bearing hops: the behavior a component is assigned to or the
       interface it composes, the serving/triggering/flow mechanism,
       payload, trust, reliability, and capacity. Hygiene waits.
+    opensWhen:
+      - condition: has-any-subject
   - id: business
     name: Business
     description: Who acts, what is served, and what information matters.
+    opensWhen:
+      - condition: has-any-subject
   - id: application
     name: Application
     description: >-
       How declared services are realized, performed, and fed with
       information.
+    opensWhen:
+      - condition: has-any-subject
   - id: technology
     name: Technology
     description: >-
       Where the declared applications actually run and what materializes
       them.
+    opensWhen:
+      - condition: has-any-subject
   - id: implementation
     name: Implementation
     description: >-
       How the planned architecture becomes real: work, deliverables, and
       the plateaus between here and there.
+    opensWhen:
+      - condition: has-any-subject
   - id: hygiene
     name: Model hygiene
     description: Cross-cutting completeness that keeps every wave honest.
+    opensWhen:
+      - condition: has-any-subject
 
 questions:
   # ---- motivation ----------------------------------------------------------

package/dist/adapters/visual/workspace-model.d.ts

@@ -49,13 +49,25 @@ export declare const conceptCountOf: (graph: SemanticGraph, query: ProjectionQue
  * Subject ids come from the same compiled graph as `CanvasNode.id`, so the
  * join in the browser is a plain lookup.
  */
+export interface DismissedQuestion {
+    readonly questionId: string;
+    /** Absent dismisses the question wherever it appears. */
+    readonly subject?: string;
+}
 export declare const interrogationOverlayOf: (compiled: {
     readonly graph: SemanticGraph;
     readonly profileContext: ResolvedProfileContext;
 }, catalogue: {
     readonly path: string;
     readonly source: string;
-}) => VisualInterrogationOverlay | undefined;
+}, 
+/**
+ * What the host has already dealt with (#328). Evaluation is unchanged and
+ * the model is untouched: this decides only what the pane draws, because a
+ * question set aside in the host's own product should not be asked again by
+ * a pane embedded in it.
+ */
+dismissed?: readonly DismissedQuestion[]) => VisualInterrogationOverlay | undefined;
 /**
  * Rebuilds the shared editor workspace from one successful compile.
  *
@@ -71,7 +83,7 @@ export declare const renderedWorkspaceOf: (compiled: {
 }, views: readonly VisualViewSummary[], metadata: Omit<VisualRenderedModel, "graph" | "vocabulary" | "interrogation">, catalogue?: {
     readonly path: string;
     readonly source: string;
-}) => {
+}, dismissed?: readonly DismissedQuestion[]) => {
     readonly model: VisualRenderedModel;
     readonly views: readonly VisualViewSummary[];
 };

package/dist/adapters/visual/workspace-model.js

@@ -46,25 +46,32 @@ export const kindOptionsOf = (lineages) => [...lineages.keys()].map((id) => ({
  * them would read as five, and the reviewer counting boxes would find three.
  */
 export const conceptCountOf = (graph, query, profileContext) => evaluateProjection(graph, adHoc(query), profileContext).subjects.filter(({ type }) => type === "concept").length;
+export const interrogationOverlayOf = (compiled, catalogue, 
 /**
- * Folds one interrogation report into what the canvas draws (#292).
- *
- * Undefined — never a throw — when the catalogue does not load: the overlay
- * is a garnish on the model, and a model frame must not be blocked by it.
- * Subject ids come from the same compiled graph as `CanvasNode.id`, so the
- * join in the browser is a plain lookup.
+ * What the host has already dealt with (#328). Evaluation is unchanged and
+ * the model is untouched: this decides only what the pane draws, because a
+ * question set aside in the host's own product should not be asked again by
+ * a pane embedded in it.
  */
-export const interrogationOverlayOf = (compiled, catalogue) => {
+dismissed = []) => {
     const loaded = loadQuestionCatalogue(catalogue);
     if (!loaded.ok)
         return undefined;
     const report = evaluateCatalogue(loaded.catalogue, compiled.graph, compiled.profileContext);
+    const dismissedEverywhere = new Set(dismissed
+        .filter(({ subject }) => subject === undefined)
+        .map(({ questionId }) => questionId));
+    const dismissedForSubject = new Set(dismissed
+        .filter(({ subject }) => subject !== undefined)
+        .map(({ questionId, subject }) => `${questionId}\u0000${subject}`));
     const workspace = [];
     const subjects = {};
     for (const wave of report.waves) {
         for (const question of wave.questions) {
             if (!question.open)
                 continue;
+            if (dismissedEverywhere.has(question.id))
+                continue;
             const base = {
                 questionId: question.id,
                 authority: question.authority,
@@ -75,6 +82,9 @@ export const interrogationOverlayOf = (compiled, catalogue) => {
                 continue;
             }
             for (const subject of question.subjects) {
+                if (dismissedForSubject.has(`${question.id}\u0000${subject.id}`)) {
+                    continue;
+                }
                 (subjects[subject.id] ??= []).push({
                     ...base,
                     question: subject.question,
@@ -98,14 +108,14 @@ export const interrogationOverlayOf = (compiled, catalogue) => {
  * is the question catalogue's bytes — this module cannot read files, so
  * whoever can hands them over; omitting it ships a model with no overlay.
  */
-export const renderedWorkspaceOf = (compiled, views, metadata, catalogue) => {
+export const renderedWorkspaceOf = (compiled, views, metadata, catalogue, dismissed) => {
     const refreshedViews = views.map((view) => ({
         ...view,
         subjectCount: conceptCountOf(compiled.graph, view.query, compiled.profileContext),
     }));
     const interrogation = catalogue === undefined
         ? undefined
-        : interrogationOverlayOf(compiled, catalogue);
+        : interrogationOverlayOf(compiled, catalogue, dismissed);
     return {
         model: {
             ...metadata,

package/dist/ask-command.js

@@ -500,8 +500,15 @@ export function runAskCommand(options, cwd) {
             if (reconciliation !== undefined) {
                 lines.push(reconciliationLine(reconciliation));
             }
+            // Zero open has two causes and only one is complete (#334): a
+            // catalogue whose waves are all gated shut has asked nothing, and
+            // reporting that as a finished interview is the same empty-set
+            // flattery the wave rail carried.
+            const askedAnything = report.waves.some((wave) => wave.questions.length > 0);
             lines.push(report.summary.open === 0
-                ? `Design interview complete (catalogue ${report.catalogue}): no open questions.`
+                ? askedAnything
+                    ? `Design interview complete (catalogue ${report.catalogue}): no open questions.`
+                    : `Design interview not started (catalogue ${report.catalogue}): no wave has opened yet.`
                 : `Design interview: ${plural(report.summary.open, 'open question')} (catalogue ${report.catalogue}) — continue: yarramate design ${workspacePath}`, '', 'Backlog — planned, dependency order:', ...plannedLines(planned), '', `Current: ${plural(current.length, 'subject')} · Retired: ${retired.length} ` +
                 `(roster: yarramate ask ${workspacePath} --subjects)`);
             return emit(result, `${lines.join('\n')}\n`);

package/dist/compiler.d.ts

@@ -74,6 +74,18 @@ export interface ResolvedProfileContext {
     /** Kind identity -> the core kind it resolves to through lineage. */
     readonly conceptKindCoreAncestors: ReadonlyMap<string, CoreConceptKindId>;
     readonly relationshipKindCoreAncestors: ReadonlyMap<string, RelationshipKind>;
+    /**
+     * The core relationship kinds a pattern PORTS for a concept kind (#268
+     * phase 3, ADR 0124), keyed by kind identity. Only kinds that have a
+     * pattern with ports appear.
+     *
+     * A macro edge needs both ends to port its kind, so a consumer offering a
+     * palette between two instances intersects the two sets. Two raw groupings
+     * permit ten of the eleven kinds, which is no narrowing at all; the ports
+     * are what restore the guidance the relationship table gives everywhere
+     * else.
+     */
+    readonly patternPortKinds: ReadonlyMap<string, readonly RelationshipKind[]>;
     /**
      * The core relationship kinds the ArchiMate table permits between two
      * concept kind identities, resolved through lineage; undefined when either
@@ -104,7 +116,7 @@ export type ContextualCompilationResult = {
  */
 export interface ParsedWorkspaceSource {
     readonly source: string;
-    readonly kind: 'profile' | 'document';
+    readonly kind: 'profile' | 'document' | 'pattern';
     readonly value: unknown;
     readonly schemaDiagnostics: readonly Diagnostic[];
     /**