yarramate 1.15.3 → 1.16.0

package/dist/adapter-mapping.js

@@ -1,15 +1,5 @@
-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
-// `module.exports` and a bundler the unwrapped class. One shape for all of
-// them, so which modules a browser happens to reach is not a thing anyone has
-// to keep track of (#252).
-const ajv2020Module = Ajv2020Module;
-const Ajv2020 = ajv2020Module.default ?? ajv2020Module;
-const validateSchema = compileValidator(adapterMappingSchema);
+import { validateAdapterMapping as validateSchema } from './schema-validation.js';
 const mappingLocations = new WeakMap();
 export function loadAdapterMapping(source) {
     const loaded = loadSourceDocument(source, validateSchema, 'Adapter mapping');

package/dist/apply-command.js

@@ -1,5 +1,4 @@
 import { isMap, isScalar, isSeq, parseDocument, } from 'yaml';
-import Ajv2020Module from 'ajv/dist/2020.js';
 import { loadAdapterMapping } from './adapter-mapping.js';
 import { compileWorkspace, withDiagnosticSubjects, } from './compiler.js';
 import { evaluateEvidence, loadEvidence } from './evidence.js';
@@ -20,19 +19,9 @@ export const posixDirectoryOf = (path) => {
     const cut = normalised.lastIndexOf('/');
     return cut === -1 ? '' : normalised.slice(0, cut);
 };
-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).
-const ajv2020Module = Ajv2020Module;
-const Ajv2020 = ajv2020Module.default ?? ajv2020Module;
+import { validateOperations } from './schema-validation.js';
 // `discriminator` routes a batch entry to the single branch its `op` names, so
 // one malformed operation reports one fault instead of ten near-misses.
-// 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

@@ -1,23 +1,11 @@
-import Ajv2020Import from 'ajv/dist/2020.js';
 import { LineCounter, parse, parseDocument } from 'yaml';
 import { conceptKinds, relationshipPolicies, } from './profile.js';
 import { isCoreConceptKindId, matrixEndpointAspects, permittedRelationshipKinds as tablePermittedKinds, } from './relationship-matrix.js';
 import { closestCandidate, describeSchemaViolation, } from './source-document.js';
-import documentSchema from '../schema/yarramate-document.schema.json' with { type: 'json'
-};
-import profileSchema from '../schema/yarramate-profile.schema.json' with { type: 'json'
-};
-import patternSchema from '../schema/yarramate-pattern.schema.json' with { type: 'json'
-};
 import { ATTESTATION_PREDICATE_PREFIX, attestationClaimValue } from './graph-claims.js';
 import { shippedPolicyIdentity, shippedPolicySource, } from './shipped-profile.js';
-import { compileValidator } from './schema-validation.js';
+import { validateDocument, validateProfile, validatePattern } from './schema-validation.js';
 const coreProfile = 'yarramate/core@0.1';
-const ajv2020Module = Ajv2020Import;
-const Ajv2020 = ajv2020Module.default ?? ajv2020Module;
-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,16 +1,6 @@
-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
-// `module.exports` and a bundler the unwrapped class. One shape for all of
-// them, so which modules a browser happens to reach is not a thing anyone has
-// to keep track of (#252).
-const ajv2020Module = Ajv2020Module;
-const Ajv2020 = ajv2020Module.default ?? ajv2020Module;
-const validateCoreContract = compileValidator(coreContractSchema);
+import { validateCoreContract } from './schema-validation.js';
 export function loadCoreContract(source) {
     const loaded = loadSourceDocument(source, validateCoreContract, 'Core contract');
     if (!loaded.ok)

package/dist/evidence.js

@@ -1,15 +1,5 @@
-import Ajv2020Module from 'ajv/dist/2020.js';
 import { diagnosticOrder, loadSourceDocument, locateSourcePath, } from './source-document.js';
-import evidenceSchema from '../schema/yarramate-evidence.schema.json' with { type: 'json'
-};
-// `.default ?? module`, not a bare `.default`: NodeNext sees the raw CJS
-// `module.exports` and a bundler the unwrapped class. One shape for all of
-// them, so which modules a browser happens to reach is not a thing anyone has
-// to keep track of (#252).
-const ajv2020Module = Ajv2020Module;
-const Ajv2020 = ajv2020Module.default ?? ajv2020Module;
-import { compileValidator } from './schema-validation.js';
-const validateEvidenceSchema = compileValidator(evidenceSchema);
+import { validateEvidence as validateEvidenceSchema } from './schema-validation.js';
 const evidenceLocations = new WeakMap();
 const observationTarget = (observation) => 'subject' in observation ? observation.subject : observation.claim;
 export function loadEvidence(source) {

package/dist/interrogate-command.js

@@ -1,17 +1,7 @@
-import Ajv2020Module from 'ajv/dist/2020.js';
 import { loadSourceDocument, locateSourcePath, } from './source-document.js';
 import { nearDuplicateIndex } from './subject-identity.js';
 import { sourceKindsPermitting, tableKnowsConceptKind, tableKnowsRelationshipKind, targetKindsPermitting, } from './relationship-matrix.js';
-import catalogueSchema from '../schema/yarramate-question-catalogue.schema.json' with { type: 'json'
-};
-// `.default ?? module`, not a bare `.default`: NodeNext sees the raw CJS
-// `module.exports` and a bundler the unwrapped class. One shape for all of
-// them, so which modules a browser happens to reach is not a thing anyone has
-// to keep track of (#252).
-const ajv2020Module = Ajv2020Module;
-const Ajv2020 = ajv2020Module.default ?? ajv2020Module;
-import { compileValidator } from './schema-validation.js';
-const validateCatalogue = compileValidator(catalogueSchema);
+import { validateCatalogue } from './schema-validation.js';
 /**
  * The version of condition evaluation itself, not of the package.
  *

package/dist/projection.js

@@ -1,12 +1,6 @@
-import Ajv2020Import from 'ajv/dist/2020.js';
 import { isDeclaredNonGoal } from './brief.js';
 import { loadSourceDocument } from './source-document.js';
 import { similarity } from './subject-identity.js';
-import projectionSchema from '../schema/yarramate-projection.schema.json' with { type: 'json'
-};
-const ajv2020Module = Ajv2020Import;
-const Ajv2020 = ajv2020Module.default ?? ajv2020Module;
-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,7 +14,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';
+import { validateProjection } from './schema-validation.js';
 export function loadProjection(source) {
     const loaded = loadSourceDocument(source, validateProjection, 'Projection');
     return loaded.ok

package/dist/schema-validation.d.ts

@@ -1,12 +1,42 @@
-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.
+ * The package's JSON Schema validators, precompiled at BUILD time.
+ *
+ * Ajv normally compiles a schema by generating source and calling
+ * `new Function`, and where that happens decided two releases:
+ *
+ * - Cloudflare's `workerd` **permits** code generation during module
+ *   evaluation and **forbids** it at request time. 1.15.2 deferred compilation
+ *   to first use to save startup CPU, which put it inside a request, and every
+ *   request that validated anything threw `EvalError`.
+ * - 1.15.3 moved compilation back to import, where it is allowed, but that
+ *   only avoids the forbidden context. The codegen still ran, and Workers
+ *   budget startup CPU separately (400ms) and refuse a Worker that exceeds it.
+ *   An adopter's deploy came back at 439ms against that line.
+ *
+ * Precompiling removes the question instead of answering it: there is no
+ * compile step left to put in the wrong place, and no amount of future
+ * refactoring can move one back. `schema-validators.generated.js` is committed
+ * and regenerated by `pnpm generate:validators`;
+ * `test/generated-validators.test.ts` regenerates and compares byte for byte,
+ * so a schema edited without regenerating fails there rather than shipping a
+ * validator that checks the old shape.
+ *
+ * Behaviour is unchanged: same `allErrors` collection, same messages, same
+ * `errors` property on each validator. `validateOperations` is emitted from an
+ * instance with `discriminator` enabled, which is compiled into it.
+ *
+ * Ajv's COMPILER is a build dependency now rather than a runtime one. Two pure
+ * helpers - a deep-equal and a UCS-2 string length - are still imported from
+ * `ajv/dist/runtime` by the generated module, which is the accurate claim.
  */
-export declare const compileValidatorWith: <T = unknown>(options: ConstructorParameters<typeof Ajv2020>[0], schema: object) => ValidateFunction<T>;
-export {};
+export declare const validateDocument: ValidateFunction;
+export declare const validateProfile: ValidateFunction;
+export declare const validatePattern: ValidateFunction;
+export declare const validateWorkspace: ValidateFunction;
+export declare const validateProjection: ValidateFunction;
+export declare const validateEvidence: ValidateFunction;
+export declare const validateCoreContract: ValidateFunction;
+export declare const validateAdapterMapping: ValidateFunction;
+export declare const validateCatalogue: ValidateFunction;
+export declare const validateOperations: ValidateFunction;

package/dist/schema-validation.js

@@ -1,46 +1,43 @@
-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;
+import * as generatedOperations from './schema-validators-operations.generated.js';
+import * as generated from './schema-validators.generated.js';
 /**
- * Compiles a JSON Schema AT MODULE SCOPE, on an instance shared with every
- * other schema that wants the same options.
+ * The package's JSON Schema validators, precompiled at BUILD time.
  *
- * **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:
+ * Ajv normally compiles a schema by generating source and calling
+ * `new Function`, and where that happens decided two releases:
  *
- * ```
- * {"atStartup":"ALLOWED",
- *  "atRequest":"EvalError: Code generation from strings disallowed for this context"}
- * ```
+ * - Cloudflare's `workerd` **permits** code generation during module
+ *   evaluation and **forbids** it at request time. 1.15.2 deferred compilation
+ *   to first use to save startup CPU, which put it inside a request, and every
+ *   request that validated anything threw `EvalError`.
+ * - 1.15.3 moved compilation back to import, where it is allowed, but that
+ *   only avoids the forbidden context. The codegen still ran, and Workers
+ *   budget startup CPU separately (400ms) and refuse a Worker that exceeds it.
+ *   An adopter's deploy came back at 439ms against that line.
  *
- * 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.
+ * Precompiling removes the question instead of answering it: there is no
+ * compile step left to put in the wrong place, and no amount of future
+ * refactoring can move one back. `schema-validators.generated.js` is committed
+ * and regenerated by `pnpm generate:validators`;
+ * `test/generated-validators.test.ts` regenerates and compares byte for byte,
+ * so a schema edited without regenerating fails there rather than shipping a
+ * validator that checks the old shape.
  *
- * 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.
+ * Behaviour is unchanged: same `allErrors` collection, same messages, same
+ * `errors` property on each validator. `validateOperations` is emitted from an
+ * instance with `discriminator` enabled, which is compiled into it.
  *
- * 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.
+ * Ajv's COMPILER is a build dependency now rather than a runtime one. Two pure
+ * helpers - a deep-equal and a UCS-2 string length - are still imported from
+ * `ajv/dist/runtime` by the generated module, which is the accurate claim.
  */
-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);
+export const validateDocument = generated.validateDocument;
+export const validateProfile = generated.validateProfile;
+export const validatePattern = generated.validatePattern;
+export const validateWorkspace = generated.validateWorkspace;
+export const validateProjection = generated.validateProjection;
+export const validateEvidence = generated.validateEvidence;
+export const validateCoreContract = generated.validateCoreContract;
+export const validateAdapterMapping = generated.validateAdapterMapping;
+export const validateCatalogue = generated.validateCatalogue;
+export const validateOperations = generatedOperations.validateOperations;

package/dist/schema-validators-operations.generated.d.ts

@@ -0,0 +1,7 @@
+export declare const validateOperations: typeof validate20;
+declare function validate20(data: any, { instancePath, parentData, parentDataProperty, rootData, dynamicAnchors }?: {
+    dynamicAnchors?: {} | undefined;
+    instancePath?: string | undefined;
+    rootData?: any;
+}): boolean;
+export {};