yarramate 1.15.1 → 1.15.3

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 { compileValidator } 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,7 +9,7 @@ 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 = compileValidator(adapterMappingSchema);
 const mappingLocations = new WeakMap();
 export function loadAdapterMapping(source) {
     const loaded = loadSourceDocument(source, validateSchema, 'Adapter mapping');

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 { compileValidatorWith } 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,9 @@ 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({
-    allErrors: true,
-    discriminator: true,
-}).compile(operationsSchema);
+// 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 = compileValidatorWith({ allErrors: true, discriminator: true }, 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.

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 { compileValidator } 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 = compileValidator(documentSchema);
+const validateProfile = compileValidator(profileSchema);
+const validatePattern = compileValidator(patternSchema);
 const immutableMap = (entries) => {
     const backing = new Map(entries);
     const facade = {

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 { compileValidator } 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,7 +10,7 @@ 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 = compileValidator(coreContractSchema);
 export function loadCoreContract(source) {
     const loaded = loadSourceDocument(source, validateCoreContract, 'Core contract');
     if (!loaded.ok)

package/dist/evidence.js

@@ -8,7 +8,8 @@ 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 { compileValidator } from './schema-validation.js';
+const validateEvidenceSchema = compileValidator(evidenceSchema);
 const evidenceLocations = new WeakMap();
 const observationTarget = (observation) => 'subject' in observation ? observation.subject : observation.claim;
 export function loadEvidence(source) {

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 { compileValidator } from './schema-validation.js';
+const validateCatalogue = compileValidator(catalogueSchema);
 /**
  * The version of condition evaluation itself, not of the package.
  *

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 = compileValidator(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,6 +20,7 @@ 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 { compileValidator } from './schema-validation.js';
 export function loadProjection(source) {
     const loaded = loadSourceDocument(source, validateProjection, 'Projection');
     return loaded.ok

package/dist/schema-validation.d.ts

@@ -0,0 +1,12 @@
+import Ajv2020Module from 'ajv/dist/2020.js';
+import type { ValidateFunction } from 'ajv';
+declare const Ajv2020: typeof Ajv2020Module & typeof Ajv2020Module.Ajv2020;
+/** Compiles on the shared `allErrors` instance. */
+export declare const compileValidator: <T = unknown>(schema: object) => ValidateFunction<T>;
+/**
+ * For a schema needing options the shared instance does not carry. Only
+ * `apply-command` uses it: `discriminator` changes how a schema compiles, so
+ * it cannot ride on an instance that does not set it.
+ */
+export declare const compileValidatorWith: <T = unknown>(options: ConstructorParameters<typeof Ajv2020>[0], schema: object) => ValidateFunction<T>;
+export {};

package/dist/schema-validation.js

@@ -0,0 +1,46 @@
+import Ajv2020Module from 'ajv/dist/2020.js';
+// The published dual-export dance every other module here does; see the
+// comment in `compiler.ts` for why (#252).
+const ajv2020Module = Ajv2020Module;
+const Ajv2020 = ajv2020Module.default ?? ajv2020Module;
+/**
+ * Compiles a JSON Schema AT MODULE SCOPE, on an instance shared with every
+ * other schema that wants the same options.
+ *
+ * **Compilation must happen at import, and this is not a preference.** Ajv
+ * compiles a schema by generating source and calling `new Function`.
+ * Cloudflare's `workerd` permits code generation during module evaluation and
+ * FORBIDS it at request time - measured on the real runtime binary:
+ *
+ * ```
+ * {"atStartup":"ALLOWED",
+ *  "atRequest":"EvalError: Code generation from strings disallowed for this context"}
+ * ```
+ *
+ * 1.15.2 deferred these compiles to first use to keep startup CPU down, which
+ * moved them into the one context that cannot run them: every request that
+ * validated anything threw. The startup budget was real, but a package that
+ * cannot serve a request is not a fix for it. Deferral is therefore not an
+ * option here, and `test/schema-validation-eagerness.test.ts` asserts the
+ * opposite of what its predecessor did - that importing the package compiles
+ * every validator, so no request has to.
+ *
+ * The cost is paid down by SHARING one Ajv instance rather than building ten.
+ * Each instance compiles the 2020-12 meta-schema again, and that dominates:
+ * ten instances cost 81.6ms against 35.0ms for one, a 57% reduction with no
+ * change to when anything runs. Sharing is safe here because no schema
+ * registers formats and all 39 ship distinct `$id`s, so nothing collides.
+ *
+ * The real ceiling-lifter is precompiled standalone validators (Ajv's
+ * `code: { source: true }`), which remove Ajv from the runtime altogether and
+ * satisfy both constraints at once. This is the shape that is correct today.
+ */
+const sharedAjv = new Ajv2020({ allErrors: true });
+/** Compiles on the shared `allErrors` instance. */
+export const compileValidator = (schema) => sharedAjv.compile(schema);
+/**
+ * For a schema needing options the shared instance does not carry. Only
+ * `apply-command` uses it: `discriminator` changes how a schema compiles, so
+ * it cannot ride on an instance that does not set it.
+ */
+export const compileValidatorWith = (options, schema) => new Ajv2020(options).compile(schema);