yarramate 1.20.0 → 1.21.0

package/dist/adapters/likec4-prepare.js

@@ -141,7 +141,7 @@ export function prepareLikeC4Export(input) {
             };
         }
     }
-    const projectionResult = evaluateProjection(compilation.graph, projection.projection, compilation.profileContext);
+    const projectionResult = evaluateProjection(compilation.graph, projection.projection, compilation.profileContext, compilation.patternMemberships);
     const comparison = input.comparison === undefined
         ? undefined
         : compareArchitectureStates(compilation.graph, input.comparison.from, input.comparison.to);

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

@@ -9,6 +9,7 @@
  * `node:path`, or the schema documents into its bundle.
  */
 import type { CanvasGraph } from "../../graph-projection.js";
+import type { NestingKind } from "../../nesting.js";
 import type { YarramateApplyResult, YarramateOperation } from "../../operations.js";
 import type { ProjectionDefinition, ProjectionExclusion, ProjectionQuery } from "../../projection.js";
 /**
@@ -163,6 +164,20 @@ export interface VisualKindOption {
 }
 export interface VisualFilterQueryPayload {
     readonly query: ProjectionQuery;
+    /**
+     * The nesting the canvas is drawing with, when the browser knows it (#473
+     * phase 2).
+     *
+     * Only `query.instances` reads it, and it must: the closure of an instance IS
+     * the containment tree, so evaluating it under a different nesting than the
+     * canvas answers a different question. On the ApertureX reference that is 15
+     * subjects against 2.
+     *
+     * Optional, so an older browser and every filter that names no instance keep
+     * working unchanged; absent, the evaluator falls back to the default nesting
+     * exactly as it did before.
+     */
+    readonly nesting?: readonly NestingKind[];
 }
 export interface VisualFilterResultPayload {
     readonly query: ProjectionQuery;

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

@@ -690,9 +690,15 @@ export const startVisualServer = async (options) => {
         if (!started.ok)
             standingDiagnostics = started.diagnostics;
     }
-    const filterMatchedIds = (query) => compiledWorkspace === undefined
+    const filterMatchedIds = (query, nesting) => compiledWorkspace === undefined
         ? []
-        : matchedIdsOf(compiledWorkspace.graph, query, compiledWorkspace.profileContext);
+        : matchedIdsOf(compiledWorkspace.graph, query, compiledWorkspace.profileContext, 
+        // A view's query can name `instances`, and the facet resolves to the
+        // instance alone without these (ADR 0144).
+        compiledWorkspace.patternMemberships, 
+        // And it resolves the WRONG closure without the nesting the canvas is
+        // drawing with, which is a wrong number rather than a missing one.
+        nesting);
     /**
      * Why a query dropped what it dropped, as the editor's "excluded, and why"
      * list reads it (#248).
@@ -704,9 +710,9 @@ export const startVisualServer = async (options) => {
      * the reason the editor shows and the set the canvas draws cannot come from
      * two readings of the same query.
      */
-    const filterExclusions = (query) => compiledWorkspace === undefined
+    const filterExclusions = (query, nesting) => compiledWorkspace === undefined
         ? []
-        : exclusionsOf(compiledWorkspace.graph, query, compiledWorkspace.profileContext);
+        : exclusionsOf(compiledWorkspace.graph, query, compiledWorkspace.profileContext, compiledWorkspace.patternMemberships, nesting);
     let listening = false;
     let bootstrapSpent = false;
     let agentAttached = false;
@@ -1243,8 +1249,8 @@ export const startVisualServer = async (options) => {
                     kind: "filter-result",
                     result: {
                         query: event.payload.query,
-                        matchedIds: filterMatchedIds(event.payload.query),
-                        excluded: filterExclusions(event.payload.query),
+                        matchedIds: filterMatchedIds(event.payload.query, event.payload.nesting),
+                        excluded: filterExclusions(event.payload.query, event.payload.nesting),
                     },
                 });
                 return;

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

@@ -2,7 +2,7 @@ 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 { ProjectionDefinition, ProjectionExclusion, ProjectionQuery } from "../../projection.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";
@@ -41,7 +41,7 @@ export declare const kindOptionsOf: (lineages: ReadonlyMap<string, readonly stri
  * subject count. A view over three components with two relationships between
  * them would read as five, and the reviewer counting boxes would find three.
  */
-export declare const conceptCountOf: (graph: SemanticGraph, query: ProjectionQuery, profileContext: ResolvedProfileContext) => number;
+export declare const conceptCountOf: (graph: SemanticGraph, query: ProjectionQuery, profileContext: ResolvedProfileContext, memberships?: readonly CataloguePatternMembership[], nesting?: readonly NestingKind[]) => number;
 /**
  * Folds one interrogation report into what the canvas draws (#292).
  *
@@ -109,9 +109,9 @@ export declare const renderedWorkspaceOf: (compiled: {
     readonly views: readonly VisualViewSummary[];
 };
 /** Every subject a query draws, concepts and relationships alike. */
-export declare const matchedIdsOf: (graph: SemanticGraph, query: ProjectionQuery, profileContext: ResolvedProfileContext) => readonly string[];
+export declare const matchedIdsOf: (graph: SemanticGraph, query: ProjectionQuery, profileContext: ResolvedProfileContext, memberships?: readonly CataloguePatternMembership[], nesting?: readonly NestingKind[]) => readonly string[];
 /** Every concept a query dropped, and the facet that dropped it (#248). */
-export declare const exclusionsOf: (graph: SemanticGraph, query: ProjectionQuery, profileContext: ResolvedProfileContext) => readonly ProjectionExclusion[];
+export declare const exclusionsOf: (graph: SemanticGraph, query: ProjectionQuery, profileContext: ResolvedProfileContext, memberships?: readonly CataloguePatternMembership[], nesting?: readonly NestingKind[]) => readonly ProjectionExclusion[];
 /**
  * One saved view, as the rail reads it. `subjectCount` is the caller's,
  * because counting needs a compiled graph and a session builds its first list

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

@@ -45,7 +45,7 @@ export const kindOptionsOf = (lineages) => [...lineages.keys()].map((id) => ({
  * subject count. A view over three components with two relationships between
  * 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 conceptCountOf = (graph, query, profileContext, memberships, nesting) => evaluateProjection(graph, adHoc(query, nesting), profileContext, memberships).subjects.filter(({ type }) => type === "concept").length;
 export const interrogationOverlayOf = (compiled, 
 /**
  * The catalogue, or the composed SET a workspace carries (#345, ADR 0129).
@@ -118,7 +118,14 @@ dismissed = []) => {
 export const renderedWorkspaceOf = (compiled, views, metadata, catalogue, dismissed) => {
     const refreshedViews = views.map((view) => ({
         ...view,
-        subjectCount: conceptCountOf(compiled.graph, view.query, compiled.profileContext),
+        subjectCount: conceptCountOf(compiled.graph, view.query, compiled.profileContext, 
+        // Without these an `instances` view counts 1 and the rail says so, which
+        // is a wrong number rather than a missing one (ADR 0144).
+        compiled.patternMemberships, 
+        // Each view's OWN nesting, because each view's closure is its own. A rail
+        // sitting beside the canvas must not count a different tree than the
+        // canvas draws.
+        view.presentation?.nesting),
     }));
     const interrogation = catalogue === undefined
         ? undefined
@@ -148,18 +155,23 @@ export const renderedWorkspaceOf = (compiled, views, metadata, catalogue, dismis
     };
 };
 /** Every subject a query draws, concepts and relationships alike. */
-export const matchedIdsOf = (graph, query, profileContext) => evaluateProjection(graph, adHoc(query), profileContext).subjects.map(({ id }) => id);
+export const matchedIdsOf = (graph, query, profileContext, memberships, nesting) => evaluateProjection(graph, adHoc(query, nesting), profileContext, memberships).subjects.map(({ id }) => id);
 /** Every concept a query dropped, and the facet that dropped it (#248). */
-export const exclusionsOf = (graph, query, profileContext) => explainProjection(graph, adHoc(query), profileContext);
+export const exclusionsOf = (graph, query, profileContext, memberships, nesting) => explainProjection(graph, adHoc(query, nesting), profileContext, memberships);
 /**
  * A query on its own is not a projection, and every evaluator here wants one.
  * The id is a placeholder that never reaches a document.
  */
-const adHoc = (query) => ({
+const adHoc = (query, nesting) => ({
     format: "yarramate/projection/v1",
     id: "ad-hoc",
     version: "0",
     query,
+    // `query.instances` resolves its closure through the view's nesting, so an
+    // ad-hoc projection that dropped the nesting would answer a DIFFERENT
+    // question than the canvas is drawing: 2 subjects against 15 on the
+    // ApertureX reference, with nothing to say it had (#473 phase 2).
+    ...(nesting === undefined ? {} : { presentation: { nesting } }),
 });
 /**
  * One saved view, as the rail reads it. `subjectCount` is the caller's,

package/dist/ask-command.js

@@ -784,7 +784,7 @@ export function runAskCommand(options, cwd) {
                 });
                 if (!loaded.ok)
                     continue;
-                const membership = evaluateProjection(graph, loaded.projection, compilation.profileContext);
+                const membership = evaluateProjection(graph, loaded.projection, compilation.profileContext, compilation.patternMemberships);
                 for (const subject of membership.subjects) {
                     covered.add(subject.id);
                 }
@@ -857,7 +857,7 @@ export function runAskCommand(options, cwd) {
             });
             if (!loaded.ok)
                 return failed(loaded.diagnostics);
-            const evaluated = evaluateProjection(graph, loaded.projection, compilation.profileContext);
+            const evaluated = evaluateProjection(graph, loaded.projection, compilation.profileContext, compilation.patternMemberships);
             const result = {
                 format: 'yarramate/ask-result/v1',
                 workspace: workspace.id,

package/dist/check-command.js

@@ -214,7 +214,18 @@ export function runCheckCommand(options, cwd) {
         // does not build would bury the real failure under its consequences.
         const referenceDiagnostics = result.ok
             ? loadedProjections.flatMap(({ source, loaded }) => loaded.ok
-                ? projectionReferenceDiagnostics(source, loaded.projection, result.graph, result.profileContext)
+                ? projectionReferenceDiagnostics(source, loaded.projection, result.graph, result.profileContext, 
+                // Instance-hood from BOTH lists. A membership row exists only
+                // for a BOUND slot, so an instance whose slots are all empty
+                // has none - and judging it by bindings alone would call a real
+                // instance "not an instance" on the day it was authored, before
+                // anything was wired into it. The honest question is not "did
+                // it bind anything" but "does the model know it as an
+                // instance" (rule 2).
+                new Set([
+                    ...(result.patternMemberships ?? []).map(({ instance }) => instance),
+                    ...(result.patternVacancies ?? []).map(({ instance }) => instance),
+                ]))
                 : [])
             : [];
         const optionalDiagnostics = sortDiagnostics([

package/dist/export-command.js

@@ -250,7 +250,10 @@ export function runExportCommand(options, cwd) {
             });
             if (!loadedProjection.ok)
                 return failed(loadedProjection.diagnostics);
-            result = evaluateProjection(compilation.graph, loadedProjection.projection, compilation.profileContext);
+            result = evaluateProjection(compilation.graph, loadedProjection.projection, compilation.profileContext, 
+            // An AUTHORED projection can name `instances`, and the facet resolves
+            // to the instance alone without these (ADR 0144).
+            compilation.patternMemberships);
         }
         if (kind === 'xlsx') {
             // A workbook an architect can work in (#355). It takes a PROJECTION,

package/dist/index.d.ts

@@ -11,7 +11,7 @@ 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 { canonicalProjection, evaluateProjection, explainProjection, loadProjection, renderProjectionMarkdown, type ConceptFacet, type ProjectionExclusion, } from './projection.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';
 export { createFileSystemStore, type PendingWrite, type SourceStore, type StoredSource, type WriteConflict, type WriteOutcome, } from './source-store.js';

package/dist/index.js

@@ -10,7 +10,7 @@ export { constraintExpectsPredicate, reconcileEvidenceReports, } from './reconci
 export { deriveAttestationStaleness } from './attestation-staleness.js';
 export { deriveArtifactCoverage, } from './artifact-coverage.js';
 export { buildRtm, renderRtmMarkdown, } from './rtm.js';
-export { canonicalProjection, evaluateProjection, explainProjection, loadProjection, renderProjectionMarkdown, } from './projection.js';
+export { canonicalProjection, evaluateProjection, explainProjection, instanceClosureOf, loadProjection, renderProjectionMarkdown, } from './projection.js';
 export { loadAdapterMapping, validateAdapterMapping, validateAdapterMappings, } from './adapter-mapping.js';
 export { createFileSystemStore, } from './source-store.js';
 export { applyOperations, landOperations, posixDirectoryOf, } from './apply-command.js';

package/dist/projection.d.ts

@@ -6,6 +6,25 @@ export interface ProjectionDefinition {
     readonly version: string;
     readonly query: {
         readonly subjects?: readonly string[];
+        /**
+         * Pattern instances whose CONTENTS this query wants (#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 the
+         * view's own `nesting`. A view that wanted the box wanted what is in it.
+         *
+         * This is the ONE facet that adds rather than narrows, and it is why
+         * `subjects` and this are read as a single identity facet whose values
+         * combine with OR (`docs/PROJECTIONS.md`). Every other field still ANDs
+         * over the union: `instances` says which subjects are in play, and `kinds`
+         * or `statuses` narrow that set the way they always did.
+         *
+         * Hand-listing the members instead is what this replaces, and the list goes
+         * stale the moment the pattern binds another slot. The names here are the
+         * instance, not its parts, so the view follows the model.
+         */
+        readonly instances?: readonly string[];
         /**
          * Subjects this query would otherwise select and the author has taken out
          * (#267, ADR 0122). A facet view states a rule, and every interesting rule
@@ -90,6 +109,7 @@ export { DEFAULT_NESTING, type NestingKind } from './nesting.js';
  */
 export { DEFAULT_FOLD, type FoldMode } from './fold-tree.js';
 import type { NestingKind } from './nesting.js';
+import { type FoldMembership } from './fold-tree.js';
 /**
  * Which way a view runs, and the default. Split out for the same reason as the
  * nesting vocabulary above, and re-exported here on the same terms (ADR 0121).
@@ -118,12 +138,40 @@ export declare function canonicalProjection(projection: ProjectionDefinition): P
  * A facet of a query, named the way the query names it. What
  * {@link explainProjection} reports as the reason a subject is not in a view.
  */
-export type ConceptFacet = 'exclude' | 'states' | 'subjects' | 'documents' | 'kinds' | 'layers' | 'statuses' | 'excludeStatuses' | 'owners' | 'constraints';
+export type ConceptFacet = 'exclude' | 'states' | 'subjects' | 'instances' | 'documents' | 'kinds' | 'layers' | 'statuses' | 'excludeStatuses' | 'owners' | 'constraints';
 /** One subject a query dropped, and the facet that dropped it. */
 export interface ProjectionExclusion {
     readonly id: string;
     readonly facet: ConceptFacet;
 }
+/**
+ * How a query decides about concepts, built once and shared by the two things
+ * that ask.
+ *
+ * `evaluateProjection` asks whether a subject is in; `explainProjection` asks
+ * why one is out. They must never be able to disagree, which is why there is
+ * one selector rather than a filter here and a reason-finder somewhere else.
+ */
+/**
+ * Which subjects each named pattern instance holds, transitively.
+ *
+ * The SAME tree the canvas folds, computed from the same module over the same
+ * inputs, because a view that names an instance must select exactly what the
+ * box would have contained. Two implementations of "what is inside this
+ * instance" would be two answers to one question, and the one the reader sees
+ * is whichever they happened to open (rule: a test must go through the seam it
+ * is testing - so must a second caller).
+ *
+ * Nesting comes from THIS view's `presentation.nesting`, not the default, for
+ * the reason folding reads it too: containment is a property of the view, and a
+ * view that nests on composition alone holds less than one that also nests on
+ * assignment.
+ *
+ * Without `memberships` the closure is the named instances ALONE. That is a
+ * degradation, not an answer, and it is why `check` refuses rather than
+ * quietly returning a smaller view (#447, #450).
+ */
+export declare function instanceClosureOf(graph: SemanticGraph, projection: ProjectionDefinition, profileContext?: ResolvedProfileContext, memberships?: readonly FoldMembership[]): ReadonlyMap<string, string>;
 /** A query facet naming something the model does not have. */
 export interface UnmatchedSelector {
     readonly facet: string;
@@ -170,7 +218,7 @@ export declare function unmatchedSelectors(graph: SemanticGraph, projection: Pro
  * caller so `check`, and anything that adopts this later, refuse in identical
  * words with an identical code.
  */
-export declare function projectionReferenceDiagnostics(source: WorkspaceSource, projection: ProjectionDefinition, graph: SemanticGraph, profileContext?: ResolvedProfileContext): readonly Diagnostic[];
+export declare function projectionReferenceDiagnostics(source: WorkspaceSource, projection: ProjectionDefinition, graph: SemanticGraph, profileContext?: ResolvedProfileContext, instances?: ReadonlySet<string>): readonly Diagnostic[];
 /**
  * Every concept a query leaves out, and the facet that left it out.
  *
@@ -186,7 +234,7 @@ export declare function projectionReferenceDiagnostics(source: WorkspaceSource,
  * `additionalProperties: false` and this is a question about a query rather
  * than part of what a projection IS.
  */
-export declare function explainProjection(graph: SemanticGraph, projection: ProjectionDefinition, profileContext?: ResolvedProfileContext): readonly ProjectionExclusion[];
-export declare function evaluateProjection(graph: SemanticGraph, projection: ProjectionDefinition, profileContext?: ResolvedProfileContext): ProjectionResult;
+export declare function explainProjection(graph: SemanticGraph, projection: ProjectionDefinition, profileContext?: ResolvedProfileContext, memberships?: readonly FoldMembership[]): readonly ProjectionExclusion[];
+export declare function evaluateProjection(graph: SemanticGraph, projection: ProjectionDefinition, profileContext?: ResolvedProfileContext, memberships?: readonly FoldMembership[]): ProjectionResult;
 export declare function renderProjectionMarkdown(result: ProjectionResult, profileContext?: ResolvedProfileContext): string;
 export declare function renderBudgetedContext(result: ProjectionResult, budgetTokens: number): string;

package/dist/projection.js

@@ -15,6 +15,9 @@ export { DEFAULT_NESTING } from './nesting.js';
  * vocabulary above (#473).
  */
 export { DEFAULT_FOLD } from './fold-tree.js';
+import { DEFAULT_NESTING as NESTING_DEFAULT } from './nesting.js';
+import { foldTree } from './fold-tree.js';
+import { kindLabelOf } from './kind-label.js';
 /**
  * Which way a view runs, and the default. Split out for the same reason as the
  * nesting vocabulary above, and re-exported here on the same terms (ADR 0121).
@@ -36,6 +39,7 @@ export function canonicalProjection(projection) {
         version: projection.version,
         query: {
             ...(query.subjects === undefined ? {} : { subjects: [...query.subjects].sort() }),
+            ...(query.instances === undefined ? {} : { instances: [...query.instances].sort() }),
             ...(query.documents === undefined ? {} : { documents: [...query.documents].sort() }),
             ...(query.kinds === undefined ? {} : { kinds: [...query.kinds].sort() }),
             ...(query.layers === undefined ? {} : { layers: [...query.layers].sort() }),
@@ -88,7 +92,106 @@ const claimReferences = (claims, subject, predicate) => claims.flatMap((claim) =
  * why one is out. They must never be able to disagree, which is why there is
  * one selector rather than a filter here and a reason-finder somewhere else.
  */
-const conceptSelector = (graph, projection, profileContext) => {
+/**
+ * Which subjects each named pattern instance holds, transitively.
+ *
+ * The SAME tree the canvas folds, computed from the same module over the same
+ * inputs, because a view that names an instance must select exactly what the
+ * box would have contained. Two implementations of "what is inside this
+ * instance" would be two answers to one question, and the one the reader sees
+ * is whichever they happened to open (rule: a test must go through the seam it
+ * is testing - so must a second caller).
+ *
+ * Nesting comes from THIS view's `presentation.nesting`, not the default, for
+ * the reason folding reads it too: containment is a property of the view, and a
+ * view that nests on composition alone holds less than one that also nests on
+ * assignment.
+ *
+ * Without `memberships` the closure is the named instances ALONE. That is a
+ * degradation, not an answer, and it is why `check` refuses rather than
+ * quietly returning a smaller view (#447, #450).
+ */
+export function instanceClosureOf(graph, projection, profileContext, memberships) {
+    const named = projection.query.instances;
+    const broughtInBy = new Map();
+    if (named === undefined || named.length === 0)
+        return broughtInBy;
+    // Sorted so that an instance nested inside another named instance resolves to
+    // a stable owner rather than to whichever the author typed first.
+    const roots = [...named].sort();
+    for (const root of roots)
+        broughtInBy.set(root, root);
+    if (memberships === undefined)
+        return broughtInBy;
+    const kindOf = new Map();
+    for (const claim of graph.claims) {
+        if (claim.predicate !== 'yarramate/concept/kind')
+            continue;
+        if ('value' in claim.object)
+            kindOf.set(claim.subject, claim.object.value);
+    }
+    const nodes = graph.subjects
+        .filter(({ type }) => type === 'concept')
+        .map(({ id }) => {
+        const kind = kindOf.get(id) ?? '';
+        return {
+            id,
+            kind,
+            // The same reading `projectGraphForCanvas` gives `coreKindLabel`: the
+            // nearest declared ancestor, labelled. Every rule in `foldTree` reads
+            // this and never the authored kind (#473).
+            coreKind: kindLabelOf(profileContext?.conceptKindLineages.get(kind)?.[0] ?? kind),
+        };
+    });
+    const edges = graph.subjects
+        .filter(({ type }) => type === 'relationship')
+        .flatMap(({ id }) => {
+        const claim = graph.claims.find((candidate) => candidate.id === id);
+        if (claim === undefined || !('ref' in claim.object))
+            return [];
+        return [
+            {
+                id,
+                kind: claim.predicate,
+                from: claim.subject,
+                to: claim.object.ref,
+            },
+        ];
+    });
+    const tree = foldTree({
+        nodes,
+        edges,
+        memberships,
+        nesting: projection.presentation?.nesting ?? NESTING_DEFAULT,
+    });
+    const childrenOf = new Map();
+    for (const [child, parent] of tree.parentOf) {
+        const siblings = childrenOf.get(parent);
+        if (siblings === undefined)
+            childrenOf.set(parent, [child]);
+        else
+            siblings.push(child);
+    }
+    // Transitive, because the box is: unfolding one reveals the folded rows
+    // inside it, and a view naming the outer instance wants those too.
+    for (const root of roots) {
+        const queue = [root];
+        while (queue.length > 0) {
+            const current = queue.pop();
+            for (const child of childrenOf.get(current) ?? []) {
+                if (broughtInBy.has(child))
+                    continue;
+                broughtInBy.set(child, root);
+                queue.push(child);
+            }
+        }
+    }
+    return broughtInBy;
+}
+const conceptSelector = (graph, projection, profileContext, memberships) => {
+    // Computed once for the whole query rather than per subject: the fold tree is
+    // a fact about the model and the view, not about the subject being judged.
+    const instanceClosure = instanceClosureOf(graph, projection, profileContext, memberships);
     const architectureStateIds = new Set(graph.claims
         .filter(({ predicate }) => predicate === 'yarramate/state/type')
         .map(({ subject }) => subject));
@@ -143,8 +246,22 @@ const conceptSelector = (graph, projection, profileContext) => {
                 (architectureStateIds.has(id) || !participatesInSelectedState(id))) {
                 return 'states';
             }
-            if (query.subjects !== undefined && !query.subjects.includes(id)) {
-                return 'subjects';
+            // `subjects` and `instances` are ONE identity facet spelled two ways,
+            // and values within a facet combine with OR - the rule
+            // `docs/PROJECTIONS.md` already states for the values inside a list,
+            // applied to the two lists that name the same thing. Naming a subject and
+            // naming the instance that holds it are the same act of selection, so a
+            // query carrying both selects the union and every other facet then ANDs
+            // over it, exactly as before.
+            //
+            // The reported facet keeps `subjects` whenever the author wrote one, so
+            // that no view which exists today changes the answer it gives the editor;
+            // `instances` is reported only where it is the sole identity facet.
+            if (query.subjects !== undefined || query.instances !== undefined) {
+                if (query.subjects?.includes(id) !== true &&
+                    !instanceClosure.has(id)) {
+                    return query.subjects === undefined ? 'instances' : 'subjects';
+                }
             }
             if (query.documents !== undefined &&
                 !query.documents.includes(documentId)) {
@@ -249,6 +366,11 @@ export function unmatchedSelectors(graph, projection, profileContext) {
     };
     const subjectIds = new Set(graph.subjects.map(({ id }) => id));
     check('subjects', query.subjects, subjectIds);
+    // Only whether the id names a subject at all. Whether that subject is a
+    // pattern INSTANCE is a second question with a different answer and its own
+    // diagnostic, because "you misspelled this" and "this is real but it is not
+    // an instance" send an author to two different places.
+    check('instances', query.instances, subjectIds);
     check('exclude', query.exclude, subjectIds);
     // Against the SUBJECT list rather than against owners currently in use: a
     // team that owns nothing yet is a real concept and selecting it is a real
@@ -296,8 +418,8 @@ const locate = (source, value) => {
  * caller so `check`, and anything that adopts this later, refuse in identical
  * words with an identical code.
  */
-export function projectionReferenceDiagnostics(source, projection, graph, profileContext) {
-    return unmatchedSelectors(graph, projection, profileContext).map(({ facet, value, nearest }) => ({
+export function projectionReferenceDiagnostics(source, projection, graph, profileContext, instances) {
+    const unmatched = unmatchedSelectors(graph, projection, profileContext).map(({ facet, value, nearest }) => ({
         severity: 'error',
         code: 'YM921',
         message: `Projection query \`${facet}\` names ${JSON.stringify(value)}, ` +
@@ -309,6 +431,50 @@ export function projectionReferenceDiagnostics(source, projection, graph, profil
         pointer: `/query/${facet}`,
         ...locate(source.source, value),
     }));
+    const named = projection.query.instances;
+    if (named === undefined)
+        return unmatched;
+    // The facet cannot be resolved without knowing which subjects are instances,
+    // and a caller that did not look is not the same as a workspace with none.
+    // Answering anyway would return the instances alone, which is a SMALLER view
+    // that reads exactly like a correct one - the failure #450 is about.
+    if (instances === undefined) {
+        return [
+            ...unmatched,
+            {
+                severity: 'error',
+                code: 'YM923',
+                message: 'Projection query `instances` cannot be resolved here, because this ' +
+                    'check was given no pattern instances to resolve it against. ' +
+                    'Without them the facet would select each named instance alone and ' +
+                    'silently drop everything it holds.',
+                path: source.path,
+                pointer: '/query/instances',
+                // The facet itself is what is wrong here, not any one name in it, so
+                // point at the word `instances` rather than at an arbitrary member.
+                ...locate(source.source, 'instances'),
+            },
+        ];
+    }
+    const knownIds = new Set(graph.subjects.map(({ id }) => id));
+    return [
+        ...unmatched,
+        ...named
+            // A name that resolves to nothing is already YM921's; saying it twice
+            // would send the author looking for a second fault.
+            .filter((value) => knownIds.has(value) && !instances.has(value))
+            .map((value) => ({
+            severity: 'error',
+            code: 'YM922',
+            message: `Projection query \`instances\` names ${JSON.stringify(value)}, ` +
+                'which this workspace has but which is not a pattern instance, so ' +
+                'it holds nothing for the facet to select. Name it under ' +
+                '`subjects` to select the subject itself.',
+            path: source.path,
+            pointer: '/query/instances',
+            ...locate(source.source, value),
+        })),
+    ];
 }
 /**
  * Every concept a query leaves out, and the facet that left it out.
@@ -325,8 +491,8 @@ export function projectionReferenceDiagnostics(source, projection, graph, profil
  * `additionalProperties: false` and this is a question about a query rather
  * than part of what a projection IS.
  */
-export function explainProjection(graph, projection, profileContext) {
-    const { droppedBy } = conceptSelector(graph, projection, profileContext);
+export function explainProjection(graph, projection, profileContext, memberships) {
+    const { droppedBy } = conceptSelector(graph, projection, profileContext, memberships);
     const exclusions = [];
     for (const subject of graph.subjects) {
         if (subject.type !== 'concept')
@@ -337,8 +503,8 @@ export function explainProjection(graph, projection, profileContext) {
     }
     return exclusions;
 }
-export function evaluateProjection(graph, projection, profileContext) {
-    const { droppedBy, architectureStateIds, participatesInSelectedState } = conceptSelector(graph, projection, profileContext);
+export function evaluateProjection(graph, projection, profileContext, memberships) {
+    const { droppedBy, architectureStateIds, participatesInSelectedState } = conceptSelector(graph, projection, profileContext, memberships);
     const endpointExcluded = (id) => {
         // An exclusion is final (#267, ADR 0122). Dropping the subject from the
         // initial selection alone would not be: `relationships: connected` adds