yarramate 1.15.0 → 1.15.2

package/dist/adapter-mapping.js

@@ -1,5 +1,6 @@
 import Ajv2020Module from 'ajv/dist/2020.js';
 import { diagnosticOrder, loadSourceDocument, locateSourcePath, } from './source-document.js';
+import { lazyValidator } from './schema-validation.js';
 import adapterMappingSchema from '../schema/yarramate-adapter-mapping.schema.json' with { type: 'json'
 };
 // `.default ?? module`, not a bare `.default`: NodeNext sees the raw CJS
@@ -8,10 +9,10 @@ import adapterMappingSchema from '../schema/yarramate-adapter-mapping.schema.jso
 // to keep track of (#252).
 const ajv2020Module = Ajv2020Module;
 const Ajv2020 = ajv2020Module.default ?? ajv2020Module;
-const validateSchema = new Ajv2020({ allErrors: true }).compile(adapterMappingSchema);
+const validateSchema = lazyValidator(() => new Ajv2020({ allErrors: true }).compile(adapterMappingSchema));
 const mappingLocations = new WeakMap();
 export function loadAdapterMapping(source) {
-    const loaded = loadSourceDocument(source, validateSchema, 'Adapter mapping');
+    const loaded = loadSourceDocument(source, validateSchema(), 'Adapter mapping');
     if (!loaded.ok)
         return loaded;
     const { value, yaml, lineCounter } = loaded.document;

package/dist/apply-command.js

@@ -22,6 +22,7 @@ export const posixDirectoryOf = (path) => {
 };
 import operationsSchema from '../schema/yarramate-operations.schema.json' with { type: 'json'
 };
+import { lazyValidator } from './schema-validation.js';
 // `.default ?? module`, not a bare `.default`: NodeNext sees the raw CJS
 // `module.exports` and a bundler sees the unwrapped class, and this file is
 // reachable from a browser through `./apply-operations.js` (#252).
@@ -29,10 +30,12 @@ const ajv2020Module = Ajv2020Module;
 const Ajv2020 = ajv2020Module.default ?? ajv2020Module;
 // `discriminator` routes a batch entry to the single branch its `op` names, so
 // one malformed operation reports one fault instead of ten near-misses.
-const validateOperations = new Ajv2020({
+// Keeps its own Ajv instance: `discriminator` changes how a schema compiles,
+// so it cannot share one with the nine that do not set it.
+const validateOperations = lazyValidator(() => new Ajv2020({
     allErrors: true,
     discriminator: true,
-}).compile(operationsSchema);
+}).compile(operationsSchema));
 // Scalar fields replace; list fields append; `remove` retracts (ADR 0062).
 // An answer enriches what is there and may explicitly take back what it
 // asserted — it never silently shrinks anything.
@@ -310,7 +313,7 @@ export const applyOperations = (input) => {
         ok: false,
         diagnostics,
     });
-    const loadedOperations = loadSourceDocument(operations, validateOperations, 'Operations');
+    const loadedOperations = loadSourceDocument(operations, validateOperations(), 'Operations');
     if (!loadedOperations.ok)
         return failed(loadedOperations.diagnostics);
     const operationList = loadedOperations.document.value.operations;

package/dist/compiler.js

@@ -11,12 +11,13 @@ import patternSchema from '../schema/yarramate-pattern.schema.json' with { type:
 };
 import { ATTESTATION_PREDICATE_PREFIX, attestationClaimValue } from './graph-claims.js';
 import { shippedPolicyIdentity, shippedPolicySource, } from './shipped-profile.js';
+import { lazyValidator } from './schema-validation.js';
 const coreProfile = 'yarramate/core@0.1';
 const ajv2020Module = Ajv2020Import;
 const Ajv2020 = ajv2020Module.default ?? ajv2020Module;
-const validateDocument = new Ajv2020({ allErrors: true }).compile(documentSchema);
-const validateProfile = new Ajv2020({ allErrors: true }).compile(profileSchema);
-const validatePattern = new Ajv2020({ allErrors: true }).compile(patternSchema);
+const validateDocument = lazyValidator(() => new Ajv2020({ allErrors: true }).compile(documentSchema));
+const validateProfile = lazyValidator(() => new Ajv2020({ allErrors: true }).compile(profileSchema));
+const validatePattern = lazyValidator(() => new Ajv2020({ allErrors: true }).compile(patternSchema));
 const immutableMap = (entries) => {
     const backing = new Map(entries);
     const facade = {
@@ -160,12 +161,12 @@ const parseWorkspaceSource = (input) => {
             fresh,
         };
     }
-    const valid = parseDiagnostics.length === 0 && validateDocument(value);
+    const valid = parseDiagnostics.length === 0 && validateDocument()(value);
     const schemaDiagnostics = parseDiagnostics.length > 0
         ? parseDiagnostics
         : valid
             ? []
-            : (validateDocument.errors ?? []).map((error) => {
+            : (validateDocument().errors ?? []).map((error) => {
                 const property = error.keyword === 'additionalProperties'
                     ? String(error.params.additionalProperty)
                     : undefined;
@@ -330,8 +331,8 @@ function compileWorkspaceResolved(parsed) {
             profileDiagnostics.push(...entry.schemaDiagnostics);
             continue;
         }
-        if (!validateProfile(value)) {
-            for (const error of validateProfile.errors ?? []) {
+        if (!validateProfile()(value)) {
+            for (const error of validateProfile().errors ?? []) {
                 const property = error.keyword === 'additionalProperties'
                     ? String(error.params.additionalProperty)
                     : undefined;
@@ -362,9 +363,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) {
@@ -377,8 +391,8 @@ function compileWorkspaceResolved(parsed) {
             if (entry.schemaDiagnostics.length > 0) {
                 profileDiagnostics.push(...entry.schemaDiagnostics);
             }
-            else if (!validateProfile(value)) {
-                for (const error of validateProfile.errors ?? []) {
+            else if (!validateProfile()(value)) {
+                for (const error of validateProfile().errors ?? []) {
                     profileDiagnostics.push({
                         severity: 'error',
                         code: 'YM201',
@@ -627,8 +641,8 @@ function compileWorkspaceResolved(parsed) {
             patternDiagnostics.push(...entry.schemaDiagnostics);
             continue;
         }
-        if (!validatePattern(value)) {
-            for (const error of validatePattern.errors ?? []) {
+        if (!validatePattern()(value)) {
+            for (const error of validatePattern().errors ?? []) {
                 const property = error.keyword === 'additionalProperties'
                     ? String(error.params.additionalProperty)
                     : undefined;

package/dist/core-contract.js

@@ -1,6 +1,7 @@
 import Ajv2020Module from 'ajv/dist/2020.js';
 import { LineCounter, parseDocument } from 'yaml';
 import { diagnosticOrder, loadSourceDocument, locateSourcePath, } from './source-document.js';
+import { lazyValidator } from './schema-validation.js';
 import coreContractSchema from '../schema/yarramate-core-contract.schema.json' with { type: 'json'
 };
 // `.default ?? module`, not a bare `.default`: NodeNext sees the raw CJS
@@ -9,9 +10,9 @@ import coreContractSchema from '../schema/yarramate-core-contract.schema.json' w
 // to keep track of (#252).
 const ajv2020Module = Ajv2020Module;
 const Ajv2020 = ajv2020Module.default ?? ajv2020Module;
-const validateCoreContract = new Ajv2020({ allErrors: true }).compile(coreContractSchema);
+const validateCoreContract = lazyValidator(() => new Ajv2020({ allErrors: true }).compile(coreContractSchema));
 export function loadCoreContract(source) {
-    const loaded = loadSourceDocument(source, validateCoreContract, 'Core contract');
+    const loaded = loadSourceDocument(source, validateCoreContract(), 'Core contract');
     if (!loaded.ok)
         return loaded;
     const { value, yaml, lineCounter } = loaded.document;

package/dist/evidence.js

@@ -8,11 +8,12 @@ import evidenceSchema from '../schema/yarramate-evidence.schema.json' with { typ
 // to keep track of (#252).
 const ajv2020Module = Ajv2020Module;
 const Ajv2020 = ajv2020Module.default ?? ajv2020Module;
-const validateEvidenceSchema = new Ajv2020({ allErrors: true }).compile(evidenceSchema);
+import { lazyValidator } from './schema-validation.js';
+const validateEvidenceSchema = lazyValidator(() => new Ajv2020({ allErrors: true }).compile(evidenceSchema));
 const evidenceLocations = new WeakMap();
 const observationTarget = (observation) => 'subject' in observation ? observation.subject : observation.claim;
 export function loadEvidence(source) {
-    const loaded = loadSourceDocument(source, validateEvidenceSchema, 'Evidence');
+    const loaded = loadSourceDocument(source, validateEvidenceSchema(), 'Evidence');
     if (!loaded.ok)
         return loaded;
     const { value, yaml, lineCounter } = loaded.document;

package/dist/interrogate-command.js

@@ -10,7 +10,8 @@ import catalogueSchema from '../schema/yarramate-question-catalogue.schema.json'
 // to keep track of (#252).
 const ajv2020Module = Ajv2020Module;
 const Ajv2020 = ajv2020Module.default ?? ajv2020Module;
-const validateCatalogue = new Ajv2020({ allErrors: true }).compile(catalogueSchema);
+import { lazyValidator } from './schema-validation.js';
+const validateCatalogue = lazyValidator(() => new Ajv2020({ allErrors: true }).compile(catalogueSchema));
 /**
  * The version of condition evaluation itself, not of the package.
  *
@@ -916,7 +917,7 @@ const unauthorableOffers = (catalogue, profileContext) => {
     return found;
 };
 const loadCatalogueDocument = (catalogueSource) => {
-    const loaded = loadSourceDocument(catalogueSource, validateCatalogue, 'Question catalogue');
+    const loaded = loadSourceDocument(catalogueSource, validateCatalogue(), 'Question catalogue');
     if (!loaded.ok)
         return { ok: false, diagnostics: loaded.diagnostics };
     return {

package/dist/projection.js

@@ -6,7 +6,7 @@ import projectionSchema from '../schema/yarramate-projection.schema.json' with {
 };
 const ajv2020Module = Ajv2020Import;
 const Ajv2020 = ajv2020Module.default ?? ajv2020Module;
-const validateProjection = new Ajv2020({ allErrors: true }).compile(projectionSchema);
+const validateProjection = lazyValidator(() => new Ajv2020({ allErrors: true }).compile(projectionSchema));
 /**
  * A relationship kind a view may draw as nesting, and the default. Defined in
  * `./nesting.js`, which imports nothing, and re-exported here so a consumer
@@ -20,8 +20,9 @@ export { DEFAULT_NESTING } from './nesting.js';
  * nesting vocabulary above, and re-exported here on the same terms (ADR 0121).
  */
 export { DEFAULT_DIRECTION } from './layout-direction.js';
+import { lazyValidator } from './schema-validation.js';
 export function loadProjection(source) {
-    const loaded = loadSourceDocument(source, validateProjection, 'Projection');
+    const loaded = loadSourceDocument(source, validateProjection(), 'Projection');
     return loaded.ok
         ? { ok: true, projection: loaded.document.value }
         : loaded;

package/dist/schema-validation.d.ts

@@ -0,0 +1,30 @@
+import type { ValidateFunction } from 'ajv';
+/**
+ * Defers compiling a JSON Schema until something actually validates against
+ * it, then reuses the compiled validator forever.
+ *
+ * Ten validators used to be constructed and compiled at MODULE SCOPE, so
+ * importing the package paid for every one of them whether or not a caller
+ * ever validated anything. Measured on the published 1.15.1 dist: ten
+ * `Ajv.compile` calls costing **123.7ms, 80% of the barrel's entire import
+ * time**, and one more on the `yarramate/interrogation` subpath, which is the
+ * entry we tell Workers consumers to prefer. That is not an abstract cost:
+ * Cloudflare Workers budget STARTUP CPU separately from request CPU and refuse
+ * a Worker that exceeds it, so an adopter's deploy was rejected outright
+ * (error 10021) by work no request had asked for.
+ *
+ * Deferring moves that cost to first use, where the budget is seconds rather
+ * than milliseconds, and a caller pays only for the schemas it actually
+ * touches - a consumer that compiles a workspace no longer pays for the
+ * evidence, adapter-mapping and core-contract validators it never calls.
+ *
+ * The accessor is a function rather than a getter so the deferral is visible
+ * at every call site: `validateDocument()(value)` reads as "get the validator,
+ * then use it", and `validateDocument().errors` cannot accidentally be read
+ * off a validator that was never run. Ajv attaches `errors` to the validator
+ * itself, so the two must come from the same object.
+ *
+ * `test/schema-validation-laziness.test.ts` asserts that importing the package
+ * compiles NOTHING, and fails on the next module-scope validator anyone adds.
+ */
+export declare const lazyValidator: <T = unknown>(compile: () => ValidateFunction<T>) => (() => ValidateFunction<T>);

package/dist/schema-validation.js

@@ -0,0 +1,32 @@
+/**
+ * Defers compiling a JSON Schema until something actually validates against
+ * it, then reuses the compiled validator forever.
+ *
+ * Ten validators used to be constructed and compiled at MODULE SCOPE, so
+ * importing the package paid for every one of them whether or not a caller
+ * ever validated anything. Measured on the published 1.15.1 dist: ten
+ * `Ajv.compile` calls costing **123.7ms, 80% of the barrel's entire import
+ * time**, and one more on the `yarramate/interrogation` subpath, which is the
+ * entry we tell Workers consumers to prefer. That is not an abstract cost:
+ * Cloudflare Workers budget STARTUP CPU separately from request CPU and refuse
+ * a Worker that exceeds it, so an adopter's deploy was rejected outright
+ * (error 10021) by work no request had asked for.
+ *
+ * Deferring moves that cost to first use, where the budget is seconds rather
+ * than milliseconds, and a caller pays only for the schemas it actually
+ * touches - a consumer that compiles a workspace no longer pays for the
+ * evidence, adapter-mapping and core-contract validators it never calls.
+ *
+ * The accessor is a function rather than a getter so the deferral is visible
+ * at every call site: `validateDocument()(value)` reads as "get the validator,
+ * then use it", and `validateDocument().errors` cannot accidentally be read
+ * off a validator that was never run. Ajv attaches `errors` to the validator
+ * itself, so the two must come from the same object.
+ *
+ * `test/schema-validation-laziness.test.ts` asserts that importing the package
+ * compiles NOTHING, and fails on the next module-scope validator anyone adds.
+ */
+export const lazyValidator = (compile) => {
+    let compiled;
+    return () => (compiled ??= compile());
+};

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;
     }