yarramate 1.14.1 → 1.15.1

package/dist/compiler.js

@@ -362,9 +362,22 @@ function compileWorkspaceResolved(parsed) {
     }
     const alreadyDeclaresPolicy = pendingProfiles.some(({ identity }) => identity === shippedPolicyIdentity);
     if (!alreadyDeclaresPolicy) {
+        // This probe runs BEFORE the document gate that rejects a source whose
+        // schema check failed, so it has to hold its own precondition: a source
+        // that composes to anything but a mapping - an empty file, a comment-only
+        // one, a bare scalar - selects no profile at all. It used to read
+        // `.profile` through an `as` cast, which is what hid the null from the
+        // typechecker, and an empty document crashed the whole compile with a
+        // `TypeError` instead of the `YM201 must be object` its schema already
+        // produces. Every other consumer of a parsed entry checks its diagnostics
+        // first (the profile walk above, the pattern walk below); this one could
+        // not, because it runs before that gate exists, so it narrows instead.
         const selected = documentInputs.some(({ entry }) => {
             const value = entry.value;
-            return value.profile === shippedPolicyIdentity;
+            return (typeof value === 'object' &&
+                value !== null &&
+                value.profile ===
+                    shippedPolicyIdentity);
         });
         const extended = pendingProfiles.some(({ value }) => value.extends === shippedPolicyIdentity);
         if (selected || extended) {

package/dist/design-command.js

@@ -81,6 +81,43 @@ const localKind = (qualified) => {
     const hash = qualified.lastIndexOf('#');
     return hash === -1 ? qualified : qualified.slice(hash + 1);
 };
+/**
+ * The `missing-claim` predicates that name a CONCEPT FIELD, and the field
+ * each one is written through (#430).
+ *
+ * `missing-claim` matches a raw predicate, and a predicate is not an
+ * authoring gesture: `yarramate/attestation/adequacy` is written by adding an
+ * attestation, `yarramate/reference/refers-to` by adding a reference, and a
+ * profile may mint predicates this engine has never heard of. So the
+ * condition cannot map to one operation in general, which is why an adopter
+ * wiring it up got a card with no affordance and filed #430.
+ *
+ * It maps for these three, and only these three, because each is a named
+ * field on a concept that `update-concept` writes directly. They are Core's
+ * own, closed, and they are every `missing-claim` the shipped catalogue uses
+ * — `owner-missing`, `information-unowned`, `concept-undescribed` and
+ * `status-missing`. Anything else returns no skeleton, which is ADR 0110's
+ * rule holding: a wrong skeleton is never offered.
+ *
+ * This is the "one new mapping case" ADR 0110 anticipated, not a remedy DSL.
+ * The engine still takes no position on which predicates a HOST should render
+ * as editable; the trigger carries the predicate and the host decides. This
+ * is the CLI rendering its own affordance, the same as the other two cases.
+ */
+const CONCEPT_FIELD_PREDICATES = {
+    'yarramate/ownership/owner': {
+        name: 'owner',
+        placeholder: '<owning-subject-id>',
+    },
+    'yarramate/concept/description': {
+        name: 'description',
+        placeholder: '<one line>',
+    },
+    'yarramate/lifecycle/status': {
+        name: 'status',
+        placeholder: '<planned|current|retired>',
+    },
+};
 const skeletonHeader = (documentAddress, op) => [
     '',
     'Prefilled skeleton (edit the <placeholders>, save as operations.yaml):',
@@ -125,6 +162,17 @@ const renderSkeleton = (step, documentAddress) => {
             `        to: ${to}`,
         ];
     }
+    if (condition.condition === 'missing-claim' && step.subject !== undefined) {
+        const field = CONCEPT_FIELD_PREDICATES[condition.predicate];
+        if (field === undefined)
+            return [];
+        return [
+            ...skeletonHeader(documentAddress, 'update-concept'),
+            '      concept:',
+            `        id: ${step.subject.id.split('#').pop()}`,
+            `        ${field.name}: ${field.placeholder}`,
+        ];
+    }
     return [];
 };
 export function runDesignCommand(options, cwd) {

package/dist/interrogate-command.d.ts

@@ -110,6 +110,35 @@ export type CatalogueCondition = {
     readonly direction: 'incoming' | 'outgoing' | 'either';
     readonly counterpartKinds: readonly string[];
     readonly kindMatching?: 'exact' | 'descendants';
+} | {
+    /**
+     * The negative twin of `exists-linkage`, workspace-scope like it
+     * (#436, ADR 0138). Fires while NO concept in the workspace satisfies
+     * the linkage, so a question can ask "nothing anywhere links this way".
+     *
+     * It exists because a **vocabulary question** was asking the wrong
+     * thing. `below-subject-count` measures a population, and a vocabulary
+     * question means "did anyone survey this" — a proxy that fails in both
+     * directions, measured on a live engagement: two throwaway values close
+     * it dishonestly, while a truthful single-value estate can never close
+     * it at all.
+     *
+     * `MODEL-FLOOR.md` prescribes the answer's home: a classification axis
+     * is a `grouping` that aggregates its members, so a scheme aggregating
+     * its classes IS the statement that these are the classes. Asking "no
+     * scheme aggregates any class" needs this condition; asking how many
+     * classes exist does not reach it.
+     *
+     * Deliberately NOT `!exists-linkage` in the evaluator, for the reason
+     * `has-subject-of-kind` is not `!no-subject-of-kind`: written as its own
+     * check, an empty workspace falls out right rather than by double
+     * negative.
+     */
+    readonly condition: 'no-linkage-exists';
+    readonly kinds: readonly string[];
+    readonly direction: 'incoming' | 'outgoing' | 'either';
+    readonly counterpartKinds: readonly string[];
+    readonly kindMatching?: 'exact' | 'descendants';
 } | {
     readonly condition: 'missing-constraint';
     readonly kinds: readonly string[];

package/dist/interrogate-command.js

@@ -207,6 +207,7 @@ const namedKinds = (question) => {
             case 'missing-linkage':
             case 'has-linkage':
             case 'exists-linkage':
+            case 'no-linkage-exists':
                 kinds.push(...condition.kinds, ...condition.counterpartKinds);
                 break;
             default:
@@ -267,6 +268,7 @@ const CONDITION_SCOPE = {
     'below-subject-count': 'workspace',
     'no-state-defined': 'workspace',
     'exists-linkage': 'workspace',
+    'no-linkage-exists': 'workspace',
     'missing-claim': 'subject',
     'missing-relationship': 'subject',
     isolated: 'subject',
@@ -413,6 +415,11 @@ const conditionHolds = (index, condition, subjectId, profileContext, evidence, m
                 linkageHits(index, condition, subjectId, profileContext));
         case 'exists-linkage':
             return [...index.concepts].some((id) => linkageHits(index, condition, id, profileContext));
+        case 'no-linkage-exists':
+            // Its own check rather than `!exists-linkage`, so an empty workspace
+            // falls out right: no concepts means no linkage, which is exactly the
+            // model a vocabulary question is loudest about.
+            return ![...index.concepts].some((id) => linkageHits(index, condition, id, profileContext));
         case 'missing-constraint': {
             const matching = condition.kindMatching ?? 'descendants';
             return !(index.claimsBySubject.get(subjectId) ?? []).some((claim) => claim.predicate === 'yarramate/constraint/requires' &&

package/dist/subject-references.d.ts

@@ -18,7 +18,13 @@ export type SubjectReferenceGroup = 'document' | 'projection' | 'evidence' | 'ad
 export type SubjectReferenceForm = 'declaration' | 'reference' | 'qualified';
 export interface SubjectReferencePosition {
     readonly group: SubjectReferenceGroup;
-    /** Key path from the document root; `*` matches every sequence index. */
+    /**
+     * Key path from the document root; `*` matches every element of a
+     * collection, which is every index of a sequence and every value of a
+     * mapping whose keys are open. Both spell `*` because the schema, not the
+     * position, is what decides which one a path lands on: `items` and
+     * `patternProperties` are the same shape of "and now, each of these".
+     */
     readonly path: readonly string[];
     readonly form: SubjectReferenceForm;
 }

package/dist/subject-references.js

@@ -25,6 +25,15 @@ export const SUBJECT_REFERENCE_POSITIONS = [
         path: ['concepts', '*', 'constraints', '*', 'ref'],
         form: 'reference',
     },
+    // The subjects bound into a pattern instance's slots (ADR 0123). Keyed by
+    // slot name rather than indexed, which is why it went missing: this is the
+    // only address in any of the four schemas that lives in a mapping, and the
+    // completeness walker below derived only sequences.
+    {
+        group: 'document',
+        path: ['concepts', '*', 'parts', '*'],
+        form: 'reference',
+    },
     {
         group: 'document',
         path: ['concepts', '*', 'references', '*', 'ref'],
@@ -150,10 +159,22 @@ const collect = (node, path, pointer, form, documentId, source, hits, aliases) =
     }
     const [segment, ...rest] = path;
     if (segment === '*') {
-        if (!isSeq(node))
+        if (isSeq(node)) {
+            for (const [index, item] of node.items.entries()) {
+                collect(item, rest, `${pointer}/${index}`, form, documentId, source, hits, aliases);
+            }
             return;
-        for (const [index, item] of node.items.entries()) {
-            collect(item, rest, `${pointer}/${index}`, form, documentId, source, hits, aliases);
+        }
+        // A mapping with open keys, which today is `parts` alone. The pointer
+        // segment is the authored key, so a diagnostic names the SLOT ("/parts/
+        // interface") rather than a position the reader would have to count out.
+        if (isMap(node)) {
+            for (const item of node.items) {
+                const key = isScalar(item.key) ? String(item.key.value) : undefined;
+                if (key === undefined)
+                    continue;
+                collect(item.value, rest, `${pointer}/${key}`, form, documentId, source, hits, aliases);
+            }
         }
         return;
     }