yarramate 1.17.0 → 1.19.0

package/dist/adapters/visual/session-server.js

@@ -624,6 +624,8 @@ export const startVisualServer = async (options) => {
                 // Threaded whole (ADR 0131): a narrow copy here is how a slot
                 // question would silently never fire in the embedded pane.
                 patternMemberships: compiled.patternMemberships,
+                // The vacant half, on the same rule (#447).
+                patternVacancies: compiled.patternVacancies,
             };
             const workspaceModel = renderedWorkspaceOf(compiledWorkspace, views, {
                 authority: rendered.authority,

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

@@ -4,7 +4,7 @@ import type { ResolvedWorkspace } from "../../workspace.js";
 import type { VisualDiagnostic, VisualViewOperation } from "./protocol-contract.js";
 import type { ProjectionDefinition, ProjectionExclusion, ProjectionQuery } from "../../projection.js";
 import type { ResolvedProfileContext, SemanticGraph } from "../../compiler.js";
-import { type CataloguePatternMembership } from "../../interrogate-command.js";
+import { type CataloguePatternMembership, type CataloguePatternVacancy } from "../../interrogate-command.js";
 import type { VisualKindOption, VisualViewSummary } from "./protocol-contract.js";
 import type { VisualInterrogationOverlay, VisualRenderedModel } from "./wire.js";
 /**
@@ -60,6 +60,8 @@ export declare const interrogationOverlayOf: (compiled: {
     readonly profileContext: ResolvedProfileContext;
     /** From the compilation (ADR 0131); absent, slot questions stay quiet. */
     readonly patternMemberships?: readonly CataloguePatternMembership[];
+    /** From the compilation (#447); absent, `missing-part` stays quiet. */
+    readonly patternVacancies?: readonly CataloguePatternVacancy[];
 }, 
 /**
  * The catalogue, or the composed SET a workspace carries (#345, ADR 0129).
@@ -94,6 +96,8 @@ export declare const renderedWorkspaceOf: (compiled: {
     readonly graph: SemanticGraph;
     readonly profileContext: ResolvedProfileContext;
     readonly patternMemberships?: readonly CataloguePatternMembership[];
+    /** Threaded on to the overlay (#447); absent, `missing-part` stays quiet. */
+    readonly patternVacancies?: readonly CataloguePatternVacancy[];
 }, views: readonly VisualViewSummary[], metadata: Omit<VisualRenderedModel, "graph" | "vocabulary" | "interrogation">, catalogue?: {
     readonly path: string;
     readonly source: string;

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

@@ -64,7 +64,7 @@ dismissed = []) => {
     const composed = composeCatalogues(Array.isArray(catalogue) ? catalogue : [catalogue]);
     if (!composed.ok)
         return undefined;
-    const report = evaluateCatalogue(composed.composed.catalogue, compiled.graph, compiled.profileContext, undefined, composed.composed.catalogues, compiled.patternMemberships);
+    const report = evaluateCatalogue(composed.composed.catalogue, compiled.graph, compiled.profileContext, undefined, composed.composed.catalogues, compiled.patternMemberships, compiled.patternVacancies);
     const dismissedEverywhere = new Set(dismissed
         .filter(({ subject }) => subject === undefined)
         .map(({ questionId }) => questionId));

package/dist/apply-command.js

@@ -27,6 +27,10 @@ import { validateOperations } from './schema-validation.js';
 // asserted — it never silently shrinks anything.
 const SCALAR_CONCEPT_FIELDS = ['kind', 'name', 'description', 'status', 'owner'];
 const LIST_CONCEPT_FIELDS = ['aka', 'constraints', 'references', 'presentIn', 'attestations', 'distinctFrom', 'supersedes'];
+// The third category (#448). `parts` is the first MAP-valued concept field:
+// it neither replaces like a scalar nor appends like a list, it merges by
+// slot. See `mergeMapField`.
+const MAP_CONCEPT_FIELDS = ['parts'];
 const SCALAR_RELATIONSHIP_FIELDS = ['kind', 'from', 'to', 'name', 'description', 'status', 'mode', 'content'];
 const LIST_RELATIONSHIP_FIELDS = ['references', 'presentIn'];
 // An overlay entry's address is the pair (target, key); everything else it
@@ -233,6 +237,66 @@ const appendListField = (source, map, key, additions) => {
     }
     return spliceValue(source, start, valueEnd, `\n${sequenceEntries(merged, indent + 2)}`);
 };
+// Merge a MAP-valued field by key (#448). A named slot rebinds, an unnamed one
+// is untouched: ADR 0062's convention, where a write enriches what is there and
+// never silently shrinks it. Replacing the whole map would unbind slots the
+// operation never mentioned, which is exactly the silent shrinking that rule
+// forbids.
+//
+// The per-slot work is `setScalarField` against the NESTED map, because
+// inserting or replacing one key of a mapping is what that already does. The
+// source is re-parsed between slots for the same reason the caller re-parses
+// between fields: every splice moves the offsets after it.
+const mergeMapField = (source, locateMap, key, additions) => {
+    const entries = Object.entries(additions);
+    if (entries.length === 0)
+        return source;
+    const map = locateMap(source);
+    if (map === undefined)
+        return source;
+    if (map.flow) {
+        return rewriteFlowItem(source, map, (fields) => ({
+            ...fields,
+            [key]: {
+                ...(fields[key] ?? {}),
+                ...additions,
+            },
+        }));
+    }
+    const existing = nestedMap(map, key);
+    if (existing === undefined) {
+        const pair = pairFor(map, key);
+        const indent = fieldIndentOf(source, map);
+        const rendered = entries
+            .map(([slot, value]) => `${' '.repeat(indent + 2)}${slot}: ${valueText(value)}`)
+            .join('\n');
+        // A `parts` that exists but is not a block mapping (flow, or empty) is
+        // replaced wholesale rather than merged into: there is nothing to preserve
+        // that the entries do not already carry.
+        if (pair !== undefined) {
+            const held = isMap(pair.value)
+                ? pair.value.toJSON()
+                : {};
+            const merged = { ...held, ...additions };
+            const [start, valueEnd] = nodeRange(pair.value);
+            return spliceValue(source, start, valueEnd, `\n${Object.entries(merged)
+                .map(([slot, value]) => `${' '.repeat(indent + 2)}${slot}: ${valueText(value)}`)
+                .join('\n')}`);
+        }
+        return insertBlock(source, itemFieldInsertAt(source, map), `${' '.repeat(indent)}${key}:\n${rendered}\n`);
+    }
+    let updated = source;
+    for (const [slot, value] of entries) {
+        const host = locateMap(updated);
+        if (host === undefined)
+            break;
+        const target = nestedMap(host, key);
+        if (target === undefined)
+            break;
+        updated = setScalarField(updated, target, slot, value);
+    }
+    return updated;
+};
 // Retraction (#115): delete the field's whole entry, from the start of its
 // key line through the end of its value's last line. A flow item is
 // rewritten instead — line-based deletion there would take the whole item
@@ -602,6 +666,14 @@ export const applyOperations = (input) => {
                     continue;
                 source = appendListField(source, itemMap(source, collection, id).map, key, additions);
             }
+            if (operation.op === 'update-concept') {
+                for (const key of MAP_CONCEPT_FIELDS) {
+                    const additions = payload[key];
+                    if (additions === undefined)
+                        continue;
+                    source = mergeMapField(source, (current) => itemMap(current, collection, id)?.map, key, additions);
+                }
+            }
             for (const key of removals) {
                 const removed = removeField(source, itemMap(source, collection, id).map, key);
                 if (removed === undefined) {

package/dist/ask-command.js

@@ -475,7 +475,7 @@ export function runAskCommand(options, cwd) {
             }, workspace, cwd), compilation.profileContext);
             if (!composed.ok)
                 return failed(composed.diagnostics);
-            const report = evaluateCatalogue(composed.composed.catalogue, compilation.graph, compilation.profileContext, evidenceDocuments.flatMap(({ observations }) => observations), composed.composed.catalogues, compilation.patternMemberships);
+            const report = evaluateCatalogue(composed.composed.catalogue, compilation.graph, compilation.profileContext, evidenceDocuments.flatMap(({ observations }) => observations), composed.composed.catalogues, compilation.patternMemberships, compilation.patternVacancies);
             const result = {
                 format: 'yarramate/ask-result/v1',
                 workspace: workspace.id,
@@ -719,7 +719,7 @@ export function runAskCommand(options, cwd) {
                 evidenceObservations.push(...loaded.evidence.observations);
             }
             const report = {
-                ...evaluateCatalogue(composed.composed.catalogue, graph, compilation.profileContext, evidenceObservations, composed.composed.catalogues, compilation.patternMemberships),
+                ...evaluateCatalogue(composed.composed.catalogue, graph, compilation.profileContext, evidenceObservations, composed.composed.catalogues, compilation.patternMemberships, compilation.patternVacancies),
                 workspace: workspace.id,
             };
             // Field by field, to fix key ORDER in the emitted JSON. Every optional
@@ -735,6 +735,7 @@ export function runAskCommand(options, cwd) {
                     ? {}
                     : { catalogues: report.catalogues }),
                 semantics: report.semantics,
+                inputs: report.inputs,
                 summary: report.summary,
                 waves: report.waves,
             };
@@ -1021,7 +1022,7 @@ export function runAskCommand(options, cwd) {
                 return failed(loaded.diagnostics);
             evidenceDocuments.push(loaded.evidence);
         }
-        const report = evaluateCatalogue(composed.composed.catalogue, graph, compilation.profileContext, evidenceDocuments.flatMap(({ observations }) => observations), composed.composed.catalogues, compilation.patternMemberships);
+        const report = evaluateCatalogue(composed.composed.catalogue, graph, compilation.profileContext, evidenceDocuments.flatMap(({ observations }) => observations), composed.composed.catalogues, compilation.patternMemberships, compilation.patternVacancies);
         const openQuestions = [];
         for (const wave of report.waves) {
             for (const question of wave.questions) {

package/dist/compiler.d.ts

@@ -109,6 +109,31 @@ export interface PatternMembership {
     readonly instance: string;
     readonly pattern: string;
 }
+/**
+ * One slot of one pattern instance that nothing is bound into (#447): the
+ * shape of a question a pattern already knows to ask. The mirror of
+ * {@link PatternMembership}, and it has to be a second array rather than a
+ * widening of that one, because a vacancy has no `member` and making that
+ * field optional would break every reader.
+ *
+ * `required` is here because a vacancy on a SUCCESSFUL compile can be a
+ * required slot after all. The first draft of this shape left the field out,
+ * reasoning that a required slot left unbound is `YM416` and so never reaches
+ * a result. That is true only of an instance that declares `parts`: a concept
+ * whose kind has a pattern but which declares no parts at all is not a
+ * `PatternInstance`, never reaches YM416, and compiles clean with every slot
+ * vacant. So the flag is load-bearing rather than permanently `false`, and it
+ * is the difference between "you have not decided this yet" and "this model
+ * does not stand up without it".
+ */
+export interface PatternVacancy {
+    readonly instance: string;
+    readonly pattern: string;
+    readonly slot: string;
+    readonly slotKind: string;
+    /** The pattern declares this part `required` (ADR 0123). */
+    readonly required: boolean;
+}
 export type CompilationResult = {
     readonly ok: true;
     readonly graph: SemanticGraph;
@@ -119,6 +144,8 @@ export type CompilationResult = {
      * to `evaluateCatalogue`, or `fills-pattern-slot` never fires.
      */
     readonly patternMemberships?: readonly PatternMembership[];
+    /** Same rule as `patternMemberships`, for the same reason (#447). */
+    readonly patternVacancies?: readonly PatternVacancy[];
 } | {
     readonly ok: false;
     readonly diagnostics: readonly Diagnostic[];
@@ -128,6 +155,7 @@ export type ContextualCompilationResult = {
     readonly graph: SemanticGraph;
     readonly profileContext: ResolvedProfileContext;
     readonly patternMemberships?: readonly PatternMembership[];
+    readonly patternVacancies?: readonly PatternVacancy[];
 } | {
     readonly ok: false;
     readonly diagnostics: readonly Diagnostic[];

package/dist/compiler.js

@@ -689,6 +689,7 @@ function compileWorkspaceResolved(parsed) {
                     name: slot,
                     kindIdentity: kind.identity,
                     required: part.required === true,
+                    kindMatching: part.kindMatching === 'descendants' ? 'descendants' : 'exact',
                 });
             }
             if (!slotsOk)
@@ -846,6 +847,18 @@ function compileWorkspaceResolved(parsed) {
         return diagnosticFailure(patternDiagnostics);
     }
     const patternInstances = [];
+    /**
+     * Concepts whose kind HAS a pattern but which declare no `parts` at all —
+     * the greenfield instance ADR 0123 named and left to a later phase, and the
+     * one an interview has the most to ask (#447).
+     *
+     * Deliberately NOT `patternInstances`. That list drives YM416, wiring
+     * expansion and membership, and adding these to it would start refusing
+     * workspaces that compile today. Instance-hood for the purpose of BEING
+     * ASKED is a wider question than instance-hood for the purpose of being
+     * expanded, so it gets its own list rather than a widened one.
+     */
+    const unbegunInstances = [];
     const documents = documentInputs.map(({ input, entry, fresh }) => {
         // Schema-checked by `parseWorkspaceSource`; the faults it found are the
         // `schemaDiagnostics` returned below, and they gate every later phase.
@@ -1562,9 +1575,17 @@ function compileWorkspaceResolved(parsed) {
             // A pattern instance is only COLLECTED here. What its slots bind may be
             // declared in any document, so the bindings cannot be checked until
             // every document has been read (#268, ADR 0123).
+            const conceptKindIdentity = selectedProfile.conceptKinds.get(concept.kind)?.identity ?? concept.kind;
+            if (concept.parts === undefined) {
+                // Nothing to bind and nothing to expand, but the kind still promises a
+                // shape, so the interview can still ask about it (#447).
+                const pattern = patternsByKind.get(conceptKindIdentity);
+                if (pattern !== undefined) {
+                    unbegunInstances.push({ instance: subject, pattern });
+                }
+            }
             if (concept.parts !== undefined) {
-                const kindIdentity = selectedProfile.conceptKinds.get(concept.kind)?.identity ??
-                    concept.kind;
+                const kindIdentity = conceptKindIdentity;
                 const pattern = patternsByKind.get(kindIdentity);
                 if (pattern === undefined) {
                     const where = location(['concepts', index, 'parts'], `/concepts/${index}/parts`);
@@ -2067,6 +2088,13 @@ function compileWorkspaceResolved(parsed) {
             else
                 group.push(entry);
         }
+        /**
+         * Every wire that wants to mint, keyed by the TRIPLE it names (#460).
+         * Collected across all instances before any is minted, because two wires
+         * belonging to different instances can name one triple and only one claim
+         * may survive.
+         */
+        const wireCandidates = new Map();
         for (const { instance, pattern, bindings, sourceOf } of patternInstances) {
             const boundTo = new Map();
             for (const [slot, target] of bindings) {
@@ -2103,13 +2131,27 @@ function compileWorkspaceResolved(parsed) {
                 }
                 boundTo.set(target, slot);
                 const actual = kindOfSubject.get(target);
-                if (actual !== slotShape.kindIdentity) {
+                // `descendants` admits any kind whose lineage includes the slot kind
+                // (#449), which is what the word already means on catalogue selectors
+                // and on `missing-relationship`. It fails safe: minted wiring is
+                // checked against the relationship table using the ACTUAL bound
+                // subjects' kinds, so a descendant that is not a legal endpoint is
+                // still refused by the ordinary relationship check rather than
+                // slipping through on the pattern's authority.
+                const admitted = actual === slotShape.kindIdentity ||
+                    (slotShape.kindMatching === 'descendants' &&
+                        actual !== undefined &&
+                        (conceptKindByIdentity.get(actual)?.lineage ?? []).includes(slotShape.kindIdentity));
+                if (!admitted) {
                     diagnostics.push({
                         severity: 'error',
                         code: 'YM417',
                         message: `Part "${slot}" of "${instance}" binds "${target}", which is ` +
                             `"${actual ?? 'not a concept'}"; the pattern declares this part ` +
-                            `"${slotShape.kindIdentity}"`,
+                            `"${slotShape.kindIdentity}"` +
+                            (slotShape.kindMatching === 'descendants'
+                                ? ' or a kind descending from it'
+                                : ''),
                         path: where.path,
                         pointer: where.pointer,
                         line: where.line,
@@ -2173,36 +2215,89 @@ function compileWorkspaceResolved(parsed) {
                 }
                 if (satisfied)
                     continue;
-                const wireId = [
+                // Collected rather than minted, because whether this wire mints
+                // depends on wires belonging to OTHER instances (#460). Two wires can
+                // name one triple, and before this they both minted: two relationship
+                // claims for one relationship.
+                const key = `${from}\u0000${wire.kindIdentity}\u0000${to}`;
+                const candidate = {
                     instance,
-                    ...(wire.from === 'self' ? [] : [wire.from]),
-                    wire.coreKind,
-                    wire.to,
-                ].join('-');
-                if (declaredIds.has(wireId)) {
-                    diagnostics.push({
-                        severity: 'error',
-                        code: 'YM420',
-                        message: `The pattern for "${pattern.kindIdentity}" derives the wiring id ` +
-                            `"${wireId}" for "${instance}", which is already a declared subject`,
-                        path: where.path,
-                        pointer: where.pointer,
-                        line: where.line,
-                        column: where.column,
-                    });
-                    continue;
-                }
-                declaredIds.add(wireId);
-                subjects.push({ id: wireId, type: 'relationship' });
-                claims.push({
-                    id: wireId,
-                    subject: from,
-                    predicate: wire.kindIdentity,
-                    object: { ref: to },
-                    origin: 'declared',
-                    source: where,
+                    pattern,
+                    wire,
+                    from,
+                    to,
+                    where,
+                    owner: wire.from === 'self',
+                    wireId: [
+                        instance,
+                        ...(wire.from === 'self' ? [] : [wire.from]),
+                        wire.coreKind,
+                        wire.to,
+                    ].join('-'),
+                };
+                const group = wireCandidates.get(key);
+                if (group === undefined)
+                    wireCandidates.set(key, [candidate]);
+                else
+                    group.push(candidate);
+            }
+        }
+        // One claim per triple, whichever wires named it (#460, ADR 0141).
+        //
+        // OWNERSHIP decides the id, not walk order. A wire whose `from` is `self`
+        // owns the edge, because the edge leaves that instance; a wire whose
+        // `from` is a slot is a guest naming somebody else's edge, and defers. So
+        // an edge with an owner keeps the ADR 0123 id it has always had, and
+        // nothing moves for a workspace that compiles today.
+        //
+        // Where every wire is a guest the owner's wire is absent — typically its
+        // instance is greenfield, and an unbound slot wires nothing — so there is
+        // no ADR 0123 id to prefer and the id comes from the TRIPLE instead. That
+        // is stable under adding or removing further guests, which sorting a
+        // winner out of the guests would not be.
+        for (const [, group] of [...wireCandidates].sort(([left], [right]) => left.localeCompare(right))) {
+            const owners = group
+                .filter(({ owner }) => owner)
+                // Two owners on one triple cannot happen: `self` differs per instance,
+                // and within one instance YM315 already refuses two slots naming one
+                // subject. Sorted anyway rather than trusting that from a distance.
+                .sort((left, right) => left.wireId.localeCompare(right.wireId));
+            const winner = owners[0] ?? group[0];
+            if (winner === undefined)
+                continue;
+            // A group of ONE is not a collision and keeps its ADR 0123 id, always.
+            // This is the case that matters most, because a wire between two SLOTS
+            // of one pattern (`component --composition--> interface`) has no `self`
+            // endpoint and so no owner, yet nothing is competing with it. Deriving
+            // its id from the triple would rename every such edge in every
+            // workspace, which is exactly the migration ownership exists to avoid;
+            // ADR 0123's own worked example is one of them.
+            const wireId = group.length === 1 || owners.length > 0
+                ? winner.wireId
+                : [winner.from, winner.wire.coreKind, winner.to].join('-');
+            if (declaredIds.has(wireId)) {
+                diagnostics.push({
+                    severity: 'error',
+                    code: 'YM420',
+                    message: `The pattern for "${winner.pattern.kindIdentity}" derives the wiring id ` +
+                        `"${wireId}" for "${winner.instance}", which is already a declared subject`,
+                    path: winner.where.path,
+                    pointer: winner.where.pointer,
+                    line: winner.where.line,
+                    column: winner.where.column,
                 });
+                continue;
             }
+            declaredIds.add(wireId);
+            subjects.push({ id: wireId, type: 'relationship' });
+            claims.push({
+                id: wireId,
+                subject: winner.from,
+                predicate: winner.wire.kindIdentity,
+                object: { ref: winner.to },
+                origin: 'declared',
+                source: winner.where,
+            });
         }
     }
     // ---- macro edges through ports (#268 phase 2, ADR 0124) ------------------
@@ -2349,9 +2444,44 @@ function compileWorkspaceResolved(parsed) {
         left.pattern.localeCompare(right.pattern) ||
         left.instance.localeCompare(right.instance) ||
         left.slot.localeCompare(right.slot));
+    // The mirror (#447): one entry per slot nothing was bound into. Always
+    // emitted, possibly empty — an empty array is a workspace whose instances
+    // are fully bound, while a missing array is a caller that never looked.
+    //
+    // Derived from BOTH lists, and that is the substance of the thing. An
+    // instance that declares some parts is asked about the rest; an instance
+    // that declares none is asked about all of them, because a template nobody
+    // has begun filling in is the one with the most blanks, not the one with
+    // none. Reading only `patternInstances` here would have reported `[]` for
+    // it, and `[]` means "fully bound".
+    const patternVacancies = [
+        ...patternInstances.map(({ instance, pattern, bindings }) => ({
+            instance,
+            pattern,
+            bound: bindings,
+        })),
+        ...unbegunInstances.map(({ instance, pattern }) => ({
+            instance,
+            pattern,
+            bound: new Map(),
+        })),
+    ]
+        .flatMap(({ instance, pattern, bound }) => [...pattern.slots.values()]
+        .filter((slot) => !bound.has(slot.name))
+        .map((slot) => ({
+        instance,
+        pattern: pattern.kindIdentity,
+        slot: slot.name,
+        slotKind: slot.kindIdentity,
+        required: slot.required === true,
+    })))
+        .sort((left, right) => left.instance.localeCompare(right.instance) ||
+        left.pattern.localeCompare(right.pattern) ||
+        left.slot.localeCompare(right.slot));
     return {
         ok: true,
         patternMemberships,
+        patternVacancies,
         profileContext: {
             conceptKindLineages: immutableMap([...conceptKindByIdentity]
                 .sort(([left], [right]) => left.localeCompare(right))
@@ -2441,6 +2571,7 @@ export function compileWorkspace(sources) {
             ok: true,
             graph: result.graph,
             patternMemberships: result.patternMemberships,
+            patternVacancies: result.patternVacancies,
         }
         : result;
 }

package/dist/design-command.js

@@ -294,7 +294,7 @@ export function runDesignCommand(options, cwd) {
                 };
             }
         }
-        const report = evaluateCatalogue(composed.composed.catalogue, compilation.graph, compilation.profileContext, evidenceObservations, composed.composed.catalogues, compilation.patternMemberships);
+        const report = evaluateCatalogue(composed.composed.catalogue, compilation.graph, compilation.profileContext, evidenceObservations, composed.composed.catalogues, compilation.patternMemberships, compilation.patternVacancies);
         // Keyed by the QUALIFIED id, matching what the report now carries.
         const askPlainById = new Map(composed.composed.catalogue.questions.flatMap((question) => question.askPlain === undefined
             ? []

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, Diagnostic, GraphClaim, GraphSource, SemanticGraph, ResolvedProfileContext, WorkspaceSource, } from './compiler.js';
+export type { CompilationCache, CompilationResult, ContextualCompilationResult, IncrementalCompilationResult, ParsedWorkspaceSource, PatternMembership, PatternVacancy, Diagnostic, GraphClaim, GraphSource, SemanticGraph, ResolvedProfileContext, WorkspaceSource, } from './compiler.js';
 export { canonicalProjection, evaluateProjection, explainProjection, 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';
@@ -19,4 +19,4 @@ export { applyOperations, landOperations, posixDirectoryOf, type ApplyInput, typ
 export { connectableKinds, draftRelationship, proposeRelationshipId, stagedSubjectIds, } from './relationship-drafting.js';
 export { draftConcept, proposeConceptId } from './concept-drafting.js';
 export { deletionBlockers, describeDeletion, draftDeletion, type DeletionBlocker, } from './deletion-drafting.js';
-export { INTERROGATION_SEMANTICS_VERSION, composeCatalogues, qualifiedQuestionId, evaluateCatalogue, loadQuestionCatalogue, renderInterrogationReport, renderQuestion, type CatalogueCondition, type CatalogueEvidenceObservation, type CataloguePatternMembership, type CatalogueLoadResult, type CatalogueQuestion, type CatalogueSelector, type InterrogationReport, type InterrogationSummary, type OpenSubject, type QuestionCatalogue, type ReportQuestion, type ReportWave, } from './interrogate-command.js';
+export { INTERROGATION_SEMANTICS_VERSION, composeCatalogues, qualifiedQuestionId, conditionInput, evaluateCatalogue, loadQuestionCatalogue, renderInterrogationReport, renderQuestion, type CatalogueCondition, type CatalogueEvidenceObservation, type CataloguePatternMembership, type CataloguePatternVacancy, type CatalogueInput, type CatalogueLoadResult, type CatalogueQuestion, type CatalogueSelector, type InterrogationReport, type InterrogationSummary, type OpenSubject, type QuestionCatalogue, type ReportQuestion, type ReportWave, } from './interrogate-command.js';

package/dist/index.js

@@ -17,4 +17,4 @@ export { applyOperations, landOperations, posixDirectoryOf, } from './apply-comm
 export { connectableKinds, draftRelationship, proposeRelationshipId, stagedSubjectIds, } from './relationship-drafting.js';
 export { draftConcept, proposeConceptId } from './concept-drafting.js';
 export { deletionBlockers, describeDeletion, draftDeletion, } from './deletion-drafting.js';
-export { INTERROGATION_SEMANTICS_VERSION, composeCatalogues, qualifiedQuestionId, evaluateCatalogue, loadQuestionCatalogue, renderInterrogationReport, renderQuestion, } from './interrogate-command.js';
+export { INTERROGATION_SEMANTICS_VERSION, composeCatalogues, qualifiedQuestionId, conditionInput, evaluateCatalogue, loadQuestionCatalogue, renderInterrogationReport, renderQuestion, } from './interrogate-command.js';