yarramate 1.15.0 → 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/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;
     }