yarramate 1.22.1 → 1.23.1

package/dist/adapters/visual/protocol-contract.d.ts

@@ -147,9 +147,63 @@ export interface VisualViewSummary {
      */
     readonly subjectCount: number;
 }
+/**
+ * One pattern a browser may offer, with everything a form needs to ask for its
+ * parts (#473 phase 4, ADR 0146).
+ *
+ * Built in `workspace-model.ts` so both hosts agree, for the reason the
+ * containment tree is: two derivations of what a pattern holds would be two
+ * answers to one question.
+ */
+export interface VisualPatternOption {
+    /** The concept kind that IS this pattern. */
+    readonly kind: string;
+    readonly label: string;
+    /** The core kind the pattern's own kind descends from. */
+    readonly coreLabel: string;
+    /** The pattern document that declared it, by path. */
+    readonly document: string;
+    /** The profile's display name for the kind, where it authored one. */
+    readonly name?: string;
+    readonly slots: readonly {
+        readonly name: string;
+        readonly required: boolean;
+        readonly wiring: "owned" | "context" | "unwired";
+        /**
+         * The kind LABELS this slot accepts, descendants already resolved.
+         *
+         * Resolved here rather than in the browser because it needs the lineage
+         * map: a slot declaring `kindMatching: descendants` admits a family, and a
+         * picker that offered only the declared kind would refuse subjects the
+         * compiler accepts.
+         */
+        readonly admits: readonly string[];
+    }[];
+    readonly wiring: readonly {
+        readonly from: string;
+        readonly kind: string;
+        readonly to: string;
+    }[];
+    readonly ports: readonly {
+        readonly kind: string;
+        readonly out: string;
+        readonly in: string;
+    }[];
+}
 export interface VisualKindOption {
     readonly id: string;
     readonly label: string;
+    /**
+     * The pattern this kind IS, which for a pattern kind is its own id (#473
+     * phase 4). Absent on a kind no pattern declares, which is most of them.
+     */
+    readonly pattern?: string;
+    /**
+     * The display name the profile authored, where it authored one. `label`
+     * stays the local id, because that is what a drag payload and an operation
+     * carry and the two must not drift.
+     */
+    readonly name?: string;
     /**
      * The nearest core-profile kind this one descends from, as a label — the
      * same resolution `CanvasNode.coreKindLabel` and `CanvasEdge.coreKindLabel`

package/dist/adapters/visual/wire.d.ts

@@ -1,6 +1,6 @@
 import type { CanvasGraph } from '../../graph-projection.js';
 import type { PatternMembership, PatternVacancy } from '../../compiler.js';
-import type { VISUAL_PROTOCOL_VERSION, VisualApplyResultPayload, VisualAuthority, VisualBrowserInput, VisualCapabilities, VisualChoicePresentPayload, VisualDiagnostic, VisualFilterResultPayload, VisualFreezeReason, VisualKindOption, VisualLayoutPositions, VisualLayoutSaveResultPayload, VisualResponse, VisualTerminationReason, VisualViewSummary } from './protocol-contract.js';
+import type { VISUAL_PROTOCOL_VERSION, VisualApplyResultPayload, VisualAuthority, VisualBrowserInput, VisualCapabilities, VisualChoicePresentPayload, VisualDiagnostic, VisualFilterResultPayload, VisualFreezeReason, VisualKindOption, VisualPatternOption, VisualLayoutPositions, VisualLayoutSaveResultPayload, VisualResponse, VisualTerminationReason, VisualViewSummary } from './protocol-contract.js';
 /**
  * Transport shapes the session server and the browser application both speak.
  *
@@ -51,6 +51,15 @@ export interface VisualRenderedModel {
     readonly vocabulary: {
         readonly conceptKinds: readonly VisualKindOption[];
         readonly relationshipKinds: readonly VisualKindOption[];
+        /**
+         * The patterns this workspace declares, with their slots resolved to what
+         * each admits (#473 phase 4, ADR 0146).
+         *
+         * Optional, and ABSENT rather than empty where the workspace declares none:
+         * an empty list is a workspace with no patterns, while absence is a host
+         * that never looked, and a palette should be able to tell those apart.
+         */
+        readonly patterns?: readonly VisualPatternOption[];
     };
     /** Every saved layout sidecar, keyed by projection id (Plan-level decision 1). */
     readonly layouts: {

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

@@ -2,10 +2,11 @@ import type { Diagnostic } from "../../compiler.js";
 import type { PendingWrite, SourceStore } from "../../source-store.js";
 import type { ResolvedWorkspace } from "../../workspace.js";
 import type { VisualDiagnostic, VisualViewOperation } from "./protocol-contract.js";
+import type { PatternShape } from "../../compiler.js";
 import type { NestingKind, ProjectionDefinition, ProjectionExclusion, ProjectionQuery } from "../../projection.js";
 import type { ResolvedProfileContext, SemanticGraph } from "../../compiler.js";
 import { type CataloguePatternMembership, type CataloguePatternVacancy } from "../../interrogate-command.js";
-import type { VisualKindOption, VisualViewSummary } from "./protocol-contract.js";
+import type { VisualKindOption, VisualPatternOption, VisualViewSummary } from "./protocol-contract.js";
 import type { VisualInterrogationOverlay, VisualRenderedModel } from "./wire.js";
 /**
  * What a workspace looks like to the editor, however the editor is being run
@@ -31,7 +32,22 @@ import type { VisualInterrogationOverlay, VisualRenderedModel } from "./wire.js"
  * keyed on core kinds, so offering an extension kind unchecked puts a `YM404`
  * one click away.
  */
-export declare const kindOptionsOf: (lineages: ReadonlyMap<string, readonly string[]>) => readonly VisualKindOption[];
+export declare const kindOptionsOf: (lineages: ReadonlyMap<string, readonly string[]>, 
+/** Which kinds ARE patterns, so a palette can group them (#473 phase 4). */
+patterns?: ReadonlyMap<string, PatternShape>, 
+/** The profile's display names, where it authored any. */
+names?: ReadonlyMap<string, string>) => readonly VisualKindOption[];
+/**
+ * Every pattern a browser may offer, with its slots resolved to what they
+ * admit.
+ *
+ * `admits` is the expensive part and the reason this lives here rather than in
+ * the browser: a slot declaring `kindMatching: descendants` accepts a whole
+ * family, and resolving that needs the lineage map the frame does not carry.
+ * A picker built from the declared kind alone would refuse subjects the
+ * compiler accepts.
+ */
+export declare const patternOptionsOf: (patterns: readonly PatternShape[], lineages: ReadonlyMap<string, readonly string[]>, names?: ReadonlyMap<string, string>) => readonly VisualPatternOption[];
 /**
  * How many SUBJECTS a query matches, which is not the size of its match set.
  *

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

@@ -31,11 +31,70 @@ import { evaluateCatalogue, composeCatalogues, } from "../../interrogate-command
  * keyed on core kinds, so offering an extension kind unchecked puts a `YM404`
  * one click away.
  */
-export const kindOptionsOf = (lineages) => [...lineages.keys()].map((id) => ({
+export const kindOptionsOf = (lineages, 
+/** Which kinds ARE patterns, so a palette can group them (#473 phase 4). */
+patterns = new Map(), 
+/** The profile's display names, where it authored any. */
+names = new Map()) => [...lineages.keys()].map((id) => ({
     id,
     label: kindLabelOf(id),
     coreLabel: kindLabelOf(lineages.get(id)?.[0] ?? id),
+    ...(patterns.has(id) ? { pattern: id } : {}),
+    ...(names.has(id) ? { name: names.get(id) } : {}),
 }));
+/**
+ * Every pattern a browser may offer, with its slots resolved to what they
+ * admit.
+ *
+ * `admits` is the expensive part and the reason this lives here rather than in
+ * the browser: a slot declaring `kindMatching: descendants` accepts a whole
+ * family, and resolving that needs the lineage map the frame does not carry.
+ * A picker built from the declared kind alone would refuse subjects the
+ * compiler accepts.
+ */
+export const patternOptionsOf = (patterns, lineages, names = new Map()) => patterns.map((pattern) => ({
+    kind: pattern.kindIdentity,
+    label: kindLabelOf(pattern.kindIdentity),
+    coreLabel: kindLabelOf(lineages.get(pattern.kindIdentity)?.[0] ?? pattern.kindIdentity),
+    document: pattern.declaredBy,
+    ...(names.has(pattern.kindIdentity)
+        ? { name: names.get(pattern.kindIdentity) }
+        : {}),
+    slots: pattern.slots.map((slot) => ({
+        name: slot.name,
+        required: slot.required,
+        wiring: wiringOf(pattern, slot.name),
+        admits: slot.kindMatching === "exact"
+            ? [kindLabelOf(slot.kindIdentity)]
+            : [...lineages]
+                .filter(([, lineage]) => lineage.includes(slot.kindIdentity))
+                .map(([id]) => kindLabelOf(id))
+                .sort(),
+    })),
+    wiring: pattern.wiring.map((wire) => ({
+        from: wire.from,
+        kind: kindLabelOf(wire.kindIdentity),
+        to: wire.to,
+    })),
+    ports: pattern.ports.map((port) => ({
+        kind: kindLabelOf(port.kindIdentity),
+        out: port.out,
+        in: port.in,
+    })),
+}));
+/**
+ * How a pattern's wiring relates a slot to the instance, by the same rule the
+ * compiler applies (ADR 0143): `self -> slot` is owned, `slot -> self` is
+ * context, neither is unwired, and BOTH is owned, because the instance holding
+ * something out is the stronger statement.
+ */
+const wiringOf = (pattern, slot) => {
+    const out = pattern.wiring.some((wire) => wire.from === "self" && wire.to === slot);
+    const back = pattern.wiring.some((wire) => wire.from === slot && wire.to === "self");
+    if (out)
+        return "owned";
+    return back ? "context" : "unwired";
+};
 /**
  * How many SUBJECTS a query matches, which is not the size of its match set.
  *
@@ -135,8 +194,19 @@ export const renderedWorkspaceOf = (compiled, views, metadata, catalogue, dismis
             ...metadata,
             graph: projectGraphForCanvas(compiled.graph, compiled.profileContext),
             vocabulary: {
-                conceptKinds: kindOptionsOf(compiled.profileContext.conceptKindLineages),
+                conceptKinds: kindOptionsOf(compiled.profileContext.conceptKindLineages, new Map((compiled.profileContext.patterns ?? []).map((pattern) => [
+                    pattern.kindIdentity,
+                    pattern,
+                ])), compiled.profileContext.conceptKindNames ?? new Map()),
                 relationshipKinds: kindOptionsOf(compiled.profileContext.relationshipKindLineages),
+                // Only where the workspace HAS patterns. An empty list would say the
+                // workspace declares none, which is a different claim from a host that
+                // never looked (rule 2), and the field is optional for exactly that.
+                ...((compiled.profileContext.patterns ?? []).length === 0
+                    ? {}
+                    : {
+                        patterns: patternOptionsOf(compiled.profileContext.patterns ?? [], compiled.profileContext.conceptKindLineages, compiled.profileContext.conceptKindNames ?? new Map()),
+                    }),
             },
             ...(interrogation === undefined ? {} : { interrogation }),
             // Containment context, forwarded rather than re-derived (#473). Both

package/dist/compiler.d.ts

@@ -29,6 +29,52 @@ export interface Diagnostic {
      */
     readonly subjects?: readonly string[];
 }
+/**
+ * One slot of a pattern, as a CONSUMER reads it (#473 phase 4, ADR 0146).
+ *
+ * The resolved shape rather than the authored one: `kindIdentity` is qualified
+ * and `kindMatching` is explicit, so a caller deciding what a slot admits does
+ * not have to re-resolve the document it came from.
+ */
+export interface PatternSlotShape {
+    readonly name: string;
+    readonly kindIdentity: string;
+    readonly required: boolean;
+    readonly kindMatching: 'exact' | 'descendants';
+}
+/** A wire the pattern declares, `self` naming the instance. */
+export interface PatternWireShape {
+    readonly from: string;
+    readonly to: string;
+    readonly kindIdentity: string;
+}
+/** Where a macro edge of one kind leaves and arrives (ADR 0124). */
+export interface PatternPortShape {
+    readonly kindIdentity: string;
+    readonly out: string;
+    readonly in: string;
+}
+/**
+ * A pattern as the workspace resolved it.
+ *
+ * The pattern DOCUMENT has had a JSON schema since ADR 0123 and never a public
+ * TypeScript type, so a host that wanted to offer patterns had to re-read the
+ * YAML or guess. Slots come as an ordered array rather than a map because the
+ * order a pattern DECLARES them is the order a form should ask for them, and a
+ * map's iteration order is not something a consumer should have to trust.
+ */
+export interface PatternShape {
+    readonly kindIdentity: string;
+    /**
+     * The PATH of the pattern document that declared it, not that document's id.
+     * It is the same string a duplicate-declaration diagnostic names, so a host
+     * grouping patterns by document groups them by the thing a reader can open.
+     */
+    readonly declaredBy: string;
+    readonly slots: readonly PatternSlotShape[];
+    readonly wiring: readonly PatternWireShape[];
+    readonly ports: readonly PatternPortShape[];
+}
 export interface GraphSource {
     readonly document: string;
     readonly path: string;
@@ -86,6 +132,23 @@ export interface ResolvedProfileContext {
      * else.
      */
     readonly patternPortKinds: ReadonlyMap<string, readonly RelationshipKind[]>;
+    /**
+     * Every pattern the workspace resolved, in kind order (#473 phase 4).
+     *
+     * Optional for the reason `patternMemberships` is: this shape is published
+     * and a required addition is free for readers and a break for CONSTRUCTORS.
+     * Read it as `?? []`. Absent, a host offers no patterns rather than offering
+     * an empty list of them.
+     */
+    readonly patterns?: readonly PatternShape[];
+    /**
+     * Kind identity -> the display name its PROFILE authored (#473 phase 4).
+     *
+     * Only profile-declared kinds appear: a core kind's name is the vocabulary's
+     * own and a consumer already has it. Optional for the reason `patterns` is,
+     * and read as `?? new Map()`.
+     */
+    readonly conceptKindNames?: ReadonlyMap<string, string>;
     /**
      * The core relationship kinds the ArchiMate table permits between two
      * concept kind identities, resolved through lineage; undefined when either

package/dist/compiler.js

@@ -296,6 +296,10 @@ function compileWorkspaceResolved(parsed) {
         }
     }
     const profiles = new Map();
+    // Kind identity -> the display name the profile authored for it (#473 phase
+    // 4). Resolution keeps identity, lineage, layer and aspect and drops the
+    // name, so a palette had nothing to show but the local id.
+    const conceptKindNames = new Map();
     const conceptKindByIdentity = new Map();
     const relationshipKindByIdentity = new Map();
     const coreConceptKinds = new Map();
@@ -509,6 +513,7 @@ function compileWorkspaceResolved(parsed) {
                     };
                     resolvedConceptKinds.set(kind.id, resolved);
                     conceptKindByIdentity.set(resolved.identity, resolved);
+                    conceptKindNames.set(resolved.identity, kind.name);
                 }
                 // No round can help what the last one could not.
                 if (deferred.length === 0 || deferred.length === pendingKinds.length) {
@@ -2578,6 +2583,31 @@ function compileWorkspaceResolved(parsed) {
             relationshipKindCoreAncestors: immutableMap([...relationshipKindByIdentity]
                 .sort(([left], [right]) => left.localeCompare(right))
                 .map(([identity, kind]) => [identity, kind.coreKind])),
+            // Ordered by kind, and each pattern's slots in the order the document
+            // DECLARED them, because that is the order a form should ask for them.
+            conceptKindNames: immutableMap([...conceptKindNames].sort(([left], [right]) => left.localeCompare(right))),
+            patterns: Object.freeze([...patternsByKind]
+                .sort(([left], [right]) => left.localeCompare(right))
+                .map(([identity, pattern]) => ({
+                kindIdentity: identity,
+                declaredBy: pattern.declaredBy,
+                slots: Object.freeze([...pattern.slots.values()].map((slot) => ({
+                    name: slot.name,
+                    kindIdentity: slot.kindIdentity,
+                    required: slot.required,
+                    kindMatching: slot.kindMatching,
+                }))),
+                wiring: Object.freeze(pattern.wiring.map((wire) => ({
+                    from: wire.from,
+                    to: wire.to,
+                    kindIdentity: wire.kindIdentity,
+                }))),
+                ports: Object.freeze([...pattern.ports].map(([kindIdentity, port]) => ({
+                    kindIdentity,
+                    out: port.out,
+                    in: port.in,
+                }))),
+            }))),
             patternPortKinds: immutableMap([...patternsByKind]
                 .sort(([left], [right]) => left.localeCompare(right))
                 .flatMap(([identity, pattern]) => pattern.ports.size === 0

package/dist/concept-drafting.d.ts

@@ -36,3 +36,73 @@ export declare const draftConcept: (graph: CanvasGraph, input: {
     readonly kind: string;
     readonly document: string;
 }, kinds: readonly string[], reserved?: Iterable<string>) => YarramateOperation | null;
+/**
+ * What a reviewer chose for one slot of a pattern instance (#473 phase 4).
+ *
+ * `null` is a slot left alone, which is legal for an optional slot and is what
+ * the interview later asks about (ADR 0140). A required slot left null is
+ * refused here rather than staged and refused by the compiler, because a
+ * changeset that cannot land is worse than a form that will not submit.
+ */
+export type SlotBinding = {
+    readonly mode: 'existing';
+    readonly subject: string;
+} | {
+    readonly mode: 'new';
+    readonly name: string;
+    readonly kind: string;
+} | null;
+export interface InstanceDraft {
+    readonly name: string;
+    readonly document: string;
+    /** The pattern's own kind, as a label, the same spelling an operation uses. */
+    readonly kind: string;
+    readonly slots: readonly {
+        readonly name: string;
+        readonly required: boolean;
+        /** Kind labels this slot accepts, descendants already resolved. */
+        readonly admits: readonly string[];
+    }[];
+}
+/**
+ * A pattern instance and every child it mints, as ONE batch.
+ *
+ * Children first and the instance last, though `apply` compiles the whole
+ * candidate workspace atomically and would take either order: item 4.1 proved
+ * both, and emitting the order a reader would write by hand costs nothing and
+ * makes the diff read forwards.
+ *
+ * Every minted id is reserved as it is proposed, so two slots filled with the
+ * same name do not both slug to `payload` and have the second silently replace
+ * the first (#315, the defect that made `reservedIds` required).
+ *
+ * `null` rather than a partial batch when anything is wrong: a form that stages
+ * half an instance leaves the reviewer to discover the rest from a compile
+ * error.
+ */
+export declare const draftInstance: (graph: CanvasGraph, input: InstanceDraft, bindings: ReadonlyMap<string, SlotBinding>, reserved?: Iterable<string>) => readonly YarramateOperation[] | null;
+/**
+ * Filling ONE slot of an instance that already exists (#473 phase 4).
+ *
+ * The other half of {@link draftInstance}: that one mints an instance and its
+ * parts together, this one answers a slot left open, which is what a
+ * `missing-part` card asks about (ADR 0140, #447). Both stage the same shape,
+ * so the model cannot tell which surface a binding came from.
+ *
+ * Merges BY SLOT, per ADR 0062's recorded convention: the operation names only
+ * the slot being filled, and the slots it does not mention are left alone
+ * (#448). There is no null idiom for retraction here, because retraction is
+ * coarse `remove: ['parts']` and is a different gesture from filling one.
+ *
+ * `null` rather than a partial batch: a child minted without the binding that
+ * uses it is a subject nobody asked for.
+ */
+export declare const draftSlotBinding: (graph: CanvasGraph, input: {
+    /** The instance whose slot is being filled. */
+    readonly instance: string;
+    readonly slot: string;
+    /** The document the operation writes to, and any minted child with it. */
+    readonly document: string;
+    /** Kind labels the slot accepts, descendants already resolved. */
+    readonly admits: readonly string[];
+}, binding: SlotBinding, reserved?: Iterable<string>) => readonly YarramateOperation[] | null;

package/dist/concept-drafting.js

@@ -85,3 +85,137 @@ export const draftConcept = (graph, input, kinds, reserved = []) => {
         concept: { id, kind: input.kind, name },
     };
 };
+/**
+ * A pattern instance and every child it mints, as ONE batch.
+ *
+ * Children first and the instance last, though `apply` compiles the whole
+ * candidate workspace atomically and would take either order: item 4.1 proved
+ * both, and emitting the order a reader would write by hand costs nothing and
+ * makes the diff read forwards.
+ *
+ * Every minted id is reserved as it is proposed, so two slots filled with the
+ * same name do not both slug to `payload` and have the second silently replace
+ * the first (#315, the defect that made `reservedIds` required).
+ *
+ * `null` rather than a partial batch when anything is wrong: a form that stages
+ * half an instance leaves the reviewer to discover the rest from a compile
+ * error.
+ */
+export const draftInstance = (graph, input, bindings, reserved = []) => {
+    if (input.document === '')
+        return null;
+    const name = input.name.trim();
+    if (name === '')
+        return null;
+    const claimed = new Set(reserved);
+    const children = [];
+    const parts = {};
+    for (const slot of input.slots) {
+        const binding = bindings.get(slot.name) ?? null;
+        if (binding === null) {
+            // The model does not stand up without it, so the form cannot stage it.
+            if (slot.required)
+                return null;
+            continue;
+        }
+        if (binding.mode === 'existing') {
+            if (binding.subject === '')
+                return null;
+            parts[slot.name] = binding.subject;
+            continue;
+        }
+        // A minted child: its kind has to be one the slot admits, or the compiler
+        // refuses the binding and the reviewer learns it from a diagnostic.
+        if (!slot.admits.includes(binding.kind))
+            return null;
+        const childName = binding.name.trim();
+        if (childName === '')
+            return null;
+        const childId = proposeConceptId(graph, childName, claimed);
+        if (childId === null)
+            return null;
+        claimed.add(childId);
+        children.push({
+            op: 'add-concept',
+            // The instance's document, not a choice: a part authored somewhere else
+            // is a part the reader has to go looking for.
+            document: input.document,
+            concept: { id: childId, kind: binding.kind, name: childName },
+        });
+        parts[slot.name] = childId;
+    }
+    const instanceId = proposeConceptId(graph, name, claimed);
+    if (instanceId === null)
+        return null;
+    return [
+        ...children,
+        {
+            op: 'add-concept',
+            document: input.document,
+            concept: {
+                id: instanceId,
+                kind: input.kind,
+                name,
+                // Omitted rather than empty where nothing was bound: an empty `parts`
+                // says the instance binds nothing, and the compiler reads the two the
+                // same way but a reader does not.
+                ...(Object.keys(parts).length === 0 ? {} : { parts }),
+            },
+        },
+    ];
+};
+/**
+ * Filling ONE slot of an instance that already exists (#473 phase 4).
+ *
+ * The other half of {@link draftInstance}: that one mints an instance and its
+ * parts together, this one answers a slot left open, which is what a
+ * `missing-part` card asks about (ADR 0140, #447). Both stage the same shape,
+ * so the model cannot tell which surface a binding came from.
+ *
+ * Merges BY SLOT, per ADR 0062's recorded convention: the operation names only
+ * the slot being filled, and the slots it does not mention are left alone
+ * (#448). There is no null idiom for retraction here, because retraction is
+ * coarse `remove: ['parts']` and is a different gesture from filling one.
+ *
+ * `null` rather than a partial batch: a child minted without the binding that
+ * uses it is a subject nobody asked for.
+ */
+export const draftSlotBinding = (graph, input, binding, reserved = []) => {
+    if (binding === null)
+        return null;
+    if (input.document === '')
+        return null;
+    if (input.slot === '')
+        return null;
+    if (binding.mode === 'existing') {
+        if (binding.subject === '')
+            return null;
+        return [
+            {
+                op: 'update-concept',
+                document: input.document,
+                concept: { id: input.instance, parts: { [input.slot]: binding.subject } },
+            },
+        ];
+    }
+    if (!input.admits.includes(binding.kind))
+        return null;
+    const childName = binding.name.trim();
+    if (childName === '')
+        return null;
+    const childId = proposeConceptId(graph, childName, reserved);
+    if (childId === null)
+        return null;
+    return [
+        {
+            op: 'add-concept',
+            document: input.document,
+            concept: { id: childId, kind: binding.kind, name: childName },
+        },
+        {
+            op: 'update-concept',
+            document: input.document,
+            concept: { id: input.instance, parts: { [input.slot]: childId } },
+        },
+    ];
+};

package/dist/index.d.ts

@@ -10,7 +10,7 @@ export { constraintExpectsPredicate, reconcileEvidenceReports, type AssertedRela
 export { deriveAttestationStaleness } from './attestation-staleness.js';
 export { deriveArtifactCoverage, type ArtifactCoverage, type CoverageScopePattern, } from './artifact-coverage.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 { CompilationCache, CompilationResult, ContextualCompilationResult, IncrementalCompilationResult, ParsedWorkspaceSource, PatternMembership, PatternVacancy, Diagnostic, GraphClaim, GraphSource, SemanticGraph, ResolvedProfileContext, WorkspaceSource, } from './compiler.js';
+export type { CompilationCache, CompilationResult, ContextualCompilationResult, IncrementalCompilationResult, ParsedWorkspaceSource, PatternMembership, PatternPortShape, PatternShape, PatternSlotShape, PatternVacancy, PatternWireShape, Diagnostic, GraphClaim, GraphSource, SemanticGraph, ResolvedProfileContext, WorkspaceSource, } from './compiler.js';
 export { canonicalProjection, evaluateProjection, explainProjection, instanceClosureOf, loadProjection, renderProjectionMarkdown, type ConceptFacet, type ProjectionExclusion, } 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';