@astrale-os/kernel-dsl 1.0.0-beta.15 → 1.0.0-beta.17

package/dist/v1/compiled/admission/wire/class.js

@@ -2,6 +2,7 @@ import {} from '@astrale-os/kernel-dsl/value';
 import { Key } from '../../../addressing/index.js';
 import { MEDIA_TYPE_PATTERN } from '../../../language/class/model/data.js';
 import { compareEdgeUniqueTuples, compareNodeUniqueTuples, edgeUniqueTuple, nodeUniqueTuple, } from '../../../language/class/unique.js';
+import { CLASS_OPERATIONS, isClassObservation } from '../../../language/policy/model/policy.js';
 import {} from '../../model/schema.js';
 import { invalid } from '../diagnostic.js';
 import { compiledCallable } from './callable.js';
@@ -63,26 +64,30 @@ export function compiledClass(input, values, path) {
 }
 function classPolicies(input, kind, path) {
     const value = object(input, 'Class Policies', path);
-    exact(value, [], 'Class Policies', path, ['read', 'traverse']);
-    if (value.read !== undefined)
-        classPolicy(value.read, kind, 'Class read Policy', `${path}/read`);
-    if (value.traverse !== undefined)
-        classPolicy(value.traverse, kind, 'Class traverse Policy', `${path}/traverse`);
+    exact(value, [], 'Class Policies', path, CLASS_OPERATIONS);
+    for (const operation of CLASS_OPERATIONS) {
+        const policy = value[operation];
+        if (policy === undefined)
+            continue;
+        const label = `Class ${operation} Policy`;
+        const slot = `${path}/${operation}`;
+        if (isRuleChecks(policy)) {
+            classRuleChecks(policy, slot, kind === 'node' && operation === 'create' ? 'create' : 'class');
+            continue;
+        }
+        // Each slot spells one constant, and a Node create rule has no Node for a named Policy alone.
+        if (policy === !isClassObservation(operation))
+            continue;
+        if (kind === 'node' && operation === 'create')
+            invalid(label, undefined, slot);
+        definitionRef(policy, 'policy', label, slot);
+    }
 }
-/**
- * Check one observation slot: `false`, the rule no caller satisfies, a named Policy, or, on a Node
- * Class only, Policy checks over the observed Node.
- */
-function classPolicy(input, kind, label, path) {
-    if (kind === 'node' &&
-        input !== null &&
+/** Policy checks, as opposed to a constant or a named Policy. */
+function isRuleChecks(input) {
+    return (input !== null &&
         typeof input === 'object' &&
-        ['check', 'sameNode', 'allOf', 'anyOf'].some((key) => Object.hasOwn(input, key))) {
-        classRuleChecks(input, path);
-        return;
-    }
-    if (input !== false)
-        definitionRef(input, 'policy', label, path);
+        ['check', 'sameNode', 'allOf', 'anyOf'].some((key) => Object.hasOwn(input, key)));
 }
 function edgeContract(value, path) {
     const constraintsPath = `${path}/constraints`;

package/dist/v1/compiled/admission/wire/policy.d.ts

@@ -4,7 +4,8 @@ export declare function compiledPolicy(input: JsonValue, path: string): never;
 /** Check one callable's caller rule: `true`, the rule every caller satisfies, or Policy checks. */
 export declare function callablePolicy(input: JsonValue | undefined, path: string): void;
 /**
- * Check one Node Class rule: Policy checks over `self` and `ref` objects only, in their one
- * spelling. A lone check of `self` is spelled as the Policy reference itself.
+ * Check one Class rule: Policy checks over `self` and `ref` objects only, or, in a Node create
+ * rule, `ref` objects only, in their one spelling. A lone check of `self` is spelled as the Policy
+ * reference itself.
  */
-export declare function classRuleChecks(input: JsonValue, path: string): void;
+export declare function classRuleChecks(input: JsonValue, path: string, site: 'class' | 'create'): void;

package/dist/v1/compiled/admission/wire/policy.js

@@ -130,17 +130,18 @@ export function callablePolicy(input, path) {
         policyCheck(input, 0, path);
 }
 /**
- * Check one Node Class rule: Policy checks over `self` and `ref` objects only, in their one
- * spelling. A lone check of `self` is spelled as the Policy reference itself.
+ * Check one Class rule: Policy checks over `self` and `ref` objects only, or, in a Node create
+ * rule, `ref` objects only, in their one spelling. A lone check of `self` is spelled as the Policy
+ * reference itself.
  */
-export function classRuleChecks(input, path) {
-    policyCheck(input, 0, path, 'class');
+export function classRuleChecks(input, path, site) {
+    policyCheck(input, 0, path, site);
     const rule = input;
     if (json.serialize(normalizeClassRule(rule)) !== json.serialize(rule))
         invalid('Class rule spelling', undefined, path);
 }
 /** What a site calls its checks in a refusal. */
-const SITE = { callable: 'Callable Policy', class: 'Class rule' };
+const SITE = { callable: 'Callable Policy', class: 'Class rule', create: 'Create rule' };
 /** Check the recursive Policy check wire grammar of one use site. */
 function policyCheck(input, depth, path, site = 'callable') {
     const name = SITE[site];
@@ -148,7 +149,7 @@ function policyCheck(input, depth, path, site = 'callable') {
         invalid(`${name} depth`, undefined, path);
     const value = object(input, name, path);
     if (Object.hasOwn(value, 'sameNode')) {
-        const equality = site === 'class' ? 'Class rule equality' : 'Callable equality';
+        const equality = site === 'callable' ? 'Callable equality' : `${name} equality`;
         exact(value, ['sameNode'], equality, path);
         const pair = object(value.sameNode, equality, `${path}/sameNode`);
         exact(pair, ['left', 'right'], `${equality} operands`, `${path}/sameNode`);
@@ -174,7 +175,7 @@ function policyCheck(input, depth, path, site = 'callable') {
 function policyCheckObject(input, objectPath, site) {
     const name = SITE[site];
     const target = object(input, `${name} object`, objectPath);
-    if (target.kind === 'self')
+    if (target.kind === 'self' && site !== 'create')
         exact(target, ['kind'], `${name} self`, objectPath);
     else if (target.kind === 'input' && site === 'callable') {
         exact(target, ['kind', 'field'], `${name} input`, objectPath);

package/dist/v1/compiled/loader/load.js

@@ -107,7 +107,7 @@ function programValidation(programs, properties, propertyOrdering, callables) {
             ...(callable.fields === undefined
                 ? {}
                 : { fields: Object.freeze(Object.keys(callable.fields)) }),
-            validateInput: (value) => validateValueProgram(input, value),
+            validateInput: (value, options) => validateValueProgram(input, value, [input.root], options),
             validateInputField(field, value) {
                 const nodes = callable.fields?.[field];
                 return nodes === undefined

package/dist/v1/domain/create.js

@@ -136,7 +136,7 @@ function createDefinitions(declarations, classesByKey, input) {
                 policy: definition.policy,
                 ...(inputFields === undefined ? {} : { inputFields }),
                 definition,
-                validateInput: (value) => input.validation.callableInput(key, value),
+                validateInput: (value, options) => input.validation.callableInput(key, value, options),
                 validateInputField: (field, value) => input.validation.callableInputField(key, field, value),
                 validateOutput: (value) => input.validation.callableOutput(key, value),
             });

package/dist/v1/domain/model/input.d.ts

@@ -1,3 +1,4 @@
+import type { Options } from '@astrale-os/kernel-dsl/value';
 import type { Key as AddressKey, PropertyKey, Revision } from '../../addressing/index.js';
 import type { DomainDependency, DomainDependencyMap } from '../../addressing/index.js';
 import type { CoreEdge } from '../../language/core/model/core.js';
@@ -27,7 +28,7 @@ export interface DomainValidation {
     propertyProgram(key: PropertyKey): ValueProgram;
     propertyOrdering(key: PropertyKey): OrderingKind | undefined;
     callableExists(key: AddressKey.Callable): boolean;
-    callableInput(key: AddressKey.Callable, input: unknown): readonly Diagnostic[];
+    callableInput(key: AddressKey.Callable, input: unknown, options?: Options): readonly Diagnostic[];
     callableFields(key: AddressKey.Callable): readonly string[] | undefined;
     callableInputField(key: AddressKey.Callable, field: string, input: unknown): readonly Diagnostic[];
     callableOutput(key: AddressKey.Callable, output: unknown): readonly Diagnostic[];

package/dist/v1/domain/projection/classes.js

@@ -80,7 +80,7 @@ export function createClasses(definitions, validation) {
                     executable: isMethodExecutable(definition, methodDefinition),
                     ...(inputFields === undefined ? {} : { inputFields }),
                     definition: methodDefinition,
-                    validateInput: (input) => validation.callableInput(methodKey, input),
+                    validateInput: (input, options) => validation.callableInput(methodKey, input, options),
                     validateInputField: (field, input) => validation.callableInputField(methodKey, field, input),
                     validateOutput: (output) => validation.callableOutput(methodKey, output),
                 });

package/dist/v1/domain/validation/create.d.ts

@@ -1,3 +1,4 @@
+import type { Options } from '@astrale-os/kernel-dsl/value';
 import type { Key, PropertyKey } from '../../addressing/index.js';
 import type { Diagnostic } from '../../language/validation/diagnostic.js';
 import type { ValueProgram } from '../../language/value/compile/model.js';
@@ -10,7 +11,7 @@ export interface PropertyValidation {
 }
 export interface CallableValidation {
     readonly fields?: readonly string[];
-    validateInput(input: unknown): readonly Diagnostic[];
+    validateInput(input: unknown, options?: Options): readonly Diagnostic[];
     validateInputField(field: string, input: unknown): readonly Diagnostic[];
     validateOutput(output: unknown): readonly Diagnostic[];
 }

package/dist/v1/domain/validation/create.js

@@ -21,7 +21,7 @@ export function createDomainValidation(properties, callables) {
         propertyProgram: (key) => propertyOf(key).program(),
         propertyOrdering: (key) => properties.get(key)?.ordering,
         callableExists: (key) => callables.has(key),
-        callableInput: (key, input) => callableOf(key).validateInput(input),
+        callableInput: (key, input, options) => callableOf(key).validateInput(input, options),
         callableFields: (key) => callables.get(key)?.fields,
         callableInputField: (key, field, input) => callableOf(key).validateInputField(field, input),
         callableOutput: (key, output) => callableOf(key).validateOutput(output),

package/dist/v1/index.d.ts

@@ -5,7 +5,7 @@ export { isBinaryInput } from './language/callable/model/callable.js';
 export type { EventOf, StateMachine, StateOf } from './language/state/index.js';
 export { PropertyValues } from './language/index.js';
 export * as metadata from './language/definition/metadata.js';
-export type { AnyResolvedClass, BoundMethodOf, BoundMethodShortcutsOf, CallableResultOf, CallableInputOf, CallableInputModeOf, CallableOutputOf, ClassSatisfactionKeysOf, ClassDefinition, CoreDefinition, CoreEdge, FunctionAuth, FunctionDefinition, Inheritance, BinaryInput, BinaryInputProjection, CallableInputContract, MethodDefinition, MethodOwnerKeyOf, CallablePolicy, ClassPolicy, ClassRuleChecks, ClassRuleObject, NodeClassPolicy, PolicyCheckExpression, PolicyDefinition, PropertyImmutability, PropertyInputOf, PropertyAccessOf, PropertyOutputOf, PropertyShortcutsOf, PropertyValuesOf, ResolvedClass, ResolvedCoreDefinition, ResolvedCoreEndpoint, ResolvedData, ResolvedFunction, ExecutableMethod, ResolvedMethod, ResolvedMethodCollection, ResolvedPolicy, ResolvedProperty, ResolvedView, MethodAccessOf, SelfMethodsOf, SelfPropertiesOf, SelfStaticMethodsOf, StaticMethodsOf, ViewDefinition, } from './language/index.js';
+export type { AnyResolvedClass, BoundMethodOf, BoundMethodShortcutsOf, CallableResultOf, CallableInputOf, CallableInputModeOf, CallableOutputOf, ClassSatisfactionKeysOf, ClassDefinition, CoreDefinition, CoreEdge, FunctionAuth, FunctionDefinition, Inheritance, BinaryInput, BinaryInputProjection, CallableInputContract, MethodDefinition, MethodOwnerKeyOf, CallablePolicy, ClassPolicy, ClassRuleChecks, ClassRuleObject, ClassWritePolicy, CreateRuleChecks, EdgeClassPolicy, EdgeClassWritePolicy, EdgeRuleChecks, NodeClassCreatePolicy, NodeClassPolicy, NodeClassWritePolicy, PolicyCheckExpression, PolicyDefinition, PropertyImmutability, PropertyInputOf, PropertyAccessOf, PropertyOutputOf, PropertyShortcutsOf, PropertyValuesOf, ResolvedClass, ResolvedCoreDefinition, ResolvedCoreEndpoint, ResolvedData, ResolvedFunction, ExecutableMethod, ResolvedMethod, ResolvedMethodCollection, ResolvedPolicy, ResolvedProperty, ResolvedView, MethodAccessOf, SelfMethodsOf, SelfPropertiesOf, SelfStaticMethodsOf, StaticMethodsOf, ViewDefinition, } from './language/index.js';
 export { acceptDefinitionRef, callableAddress, ClassKey, equalDefinitionRefs, isDefinitionRef, Key, MethodKey, PropertyKey, } from './addressing/index.js';
 export type { ClassRef, CoreRef, DefinitionBase, DefinitionKey, DefinitionRef, FunctionRef, MethodAddress, PolicyRef, Revision, ViewRef, } from './addressing/index.js';
 export type { Definition } from './language/index.js';

package/dist/v1/language/.spec/schemas/draft-2020-12.schema.json

@@ -0,0 +1,462 @@
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "https://schemas.astrale.ai/dsl/v1/draft-2020-12",
+    "title": "JSON Schema Draft 2020-12",
+    "$comment": "The Draft 2020-12 meta-schemas the V1 value-schema dialect composes, each under its own $id, exactly as the validator of the dialect embeds them. With value-schema.schema.json, they resolve the dialect without a network fetch.",
+    "$defs": {
+        "schema": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$id": "https://json-schema.org/draft/2020-12/schema",
+            "$vocabulary": {
+                "https://json-schema.org/draft/2020-12/vocab/core": true,
+                "https://json-schema.org/draft/2020-12/vocab/applicator": true,
+                "https://json-schema.org/draft/2020-12/vocab/unevaluated": true,
+                "https://json-schema.org/draft/2020-12/vocab/validation": true,
+                "https://json-schema.org/draft/2020-12/vocab/meta-data": true,
+                "https://json-schema.org/draft/2020-12/vocab/format-annotation": true,
+                "https://json-schema.org/draft/2020-12/vocab/content": true
+            },
+            "$dynamicAnchor": "meta",
+            "title": "Core and Validation specifications meta-schema",
+            "allOf": [
+                {
+                    "$ref": "meta/core"
+                },
+                {
+                    "$ref": "meta/applicator"
+                },
+                {
+                    "$ref": "meta/unevaluated"
+                },
+                {
+                    "$ref": "meta/validation"
+                },
+                {
+                    "$ref": "meta/meta-data"
+                },
+                {
+                    "$ref": "meta/format-annotation"
+                },
+                {
+                    "$ref": "meta/content"
+                }
+            ],
+            "type": [
+                "object",
+                "boolean"
+            ],
+            "$comment": "This meta-schema also defines keywords that have appeared in previous drafts in order to prevent incompatible extensions as they remain in common use.",
+            "properties": {
+                "definitions": {
+                    "$comment": "\"definitions\" has been replaced by \"$defs\".",
+                    "type": "object",
+                    "additionalProperties": {
+                        "$dynamicRef": "#meta"
+                    },
+                    "deprecated": true,
+                    "default": {}
+                },
+                "dependencies": {
+                    "$comment": "\"dependencies\" has been split and replaced by \"dependentSchemas\" and \"dependentRequired\" in order to serve their differing semantics.",
+                    "type": "object",
+                    "additionalProperties": {
+                        "anyOf": [
+                            {
+                                "$dynamicRef": "#meta"
+                            },
+                            {
+                                "$ref": "meta/validation#/$defs/stringArray"
+                            }
+                        ]
+                    },
+                    "deprecated": true,
+                    "default": {}
+                },
+                "$recursiveAnchor": {
+                    "$comment": "\"$recursiveAnchor\" has been replaced by \"$dynamicAnchor\".",
+                    "$ref": "meta/core#/$defs/anchorString",
+                    "deprecated": true
+                },
+                "$recursiveRef": {
+                    "$comment": "\"$recursiveRef\" has been replaced by \"$dynamicRef\".",
+                    "$ref": "meta/core#/$defs/uriReferenceString",
+                    "deprecated": true
+                }
+            }
+        },
+        "core": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$id": "https://json-schema.org/draft/2020-12/meta/core",
+            "$vocabulary": {
+                "https://json-schema.org/draft/2020-12/vocab/core": true
+            },
+            "$dynamicAnchor": "meta",
+            "title": "Core vocabulary meta-schema",
+            "type": [
+                "object",
+                "boolean"
+            ],
+            "properties": {
+                "$id": {
+                    "$ref": "#/$defs/uriReferenceString",
+                    "$comment": "Non-empty fragments not allowed.",
+                    "pattern": "^[^#]*#?$"
+                },
+                "$schema": {
+                    "$ref": "#/$defs/uriString"
+                },
+                "$ref": {
+                    "$ref": "#/$defs/uriReferenceString"
+                },
+                "$anchor": {
+                    "$ref": "#/$defs/anchorString"
+                },
+                "$dynamicRef": {
+                    "$ref": "#/$defs/uriReferenceString"
+                },
+                "$dynamicAnchor": {
+                    "$ref": "#/$defs/anchorString"
+                },
+                "$vocabulary": {
+                    "type": "object",
+                    "propertyNames": {
+                        "$ref": "#/$defs/uriString"
+                    },
+                    "additionalProperties": {
+                        "type": "boolean"
+                    }
+                },
+                "$comment": {
+                    "type": "string"
+                },
+                "$defs": {
+                    "type": "object",
+                    "additionalProperties": {
+                        "$dynamicRef": "#meta"
+                    }
+                }
+            },
+            "$defs": {
+                "anchorString": {
+                    "type": "string",
+                    "pattern": "^[A-Za-z_][-A-Za-z0-9._]*$"
+                },
+                "uriString": {
+                    "type": "string",
+                    "format": "uri"
+                },
+                "uriReferenceString": {
+                    "type": "string",
+                    "format": "uri-reference"
+                }
+            }
+        },
+        "applicator": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$id": "https://json-schema.org/draft/2020-12/meta/applicator",
+            "$vocabulary": {
+                "https://json-schema.org/draft/2020-12/vocab/applicator": true
+            },
+            "$dynamicAnchor": "meta",
+            "title": "Applicator vocabulary meta-schema",
+            "type": [
+                "object",
+                "boolean"
+            ],
+            "properties": {
+                "prefixItems": {
+                    "$ref": "#/$defs/schemaArray"
+                },
+                "items": {
+                    "$dynamicRef": "#meta"
+                },
+                "contains": {
+                    "$dynamicRef": "#meta"
+                },
+                "additionalProperties": {
+                    "$dynamicRef": "#meta"
+                },
+                "properties": {
+                    "type": "object",
+                    "additionalProperties": {
+                        "$dynamicRef": "#meta"
+                    },
+                    "default": {}
+                },
+                "patternProperties": {
+                    "type": "object",
+                    "additionalProperties": {
+                        "$dynamicRef": "#meta"
+                    },
+                    "propertyNames": {
+                        "format": "regex"
+                    },
+                    "default": {}
+                },
+                "dependentSchemas": {
+                    "type": "object",
+                    "additionalProperties": {
+                        "$dynamicRef": "#meta"
+                    },
+                    "default": {}
+                },
+                "propertyNames": {
+                    "$dynamicRef": "#meta"
+                },
+                "if": {
+                    "$dynamicRef": "#meta"
+                },
+                "then": {
+                    "$dynamicRef": "#meta"
+                },
+                "else": {
+                    "$dynamicRef": "#meta"
+                },
+                "allOf": {
+                    "$ref": "#/$defs/schemaArray"
+                },
+                "anyOf": {
+                    "$ref": "#/$defs/schemaArray"
+                },
+                "oneOf": {
+                    "$ref": "#/$defs/schemaArray"
+                },
+                "not": {
+                    "$dynamicRef": "#meta"
+                }
+            },
+            "$defs": {
+                "schemaArray": {
+                    "type": "array",
+                    "minItems": 1,
+                    "items": {
+                        "$dynamicRef": "#meta"
+                    }
+                }
+            }
+        },
+        "unevaluated": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$id": "https://json-schema.org/draft/2020-12/meta/unevaluated",
+            "$vocabulary": {
+                "https://json-schema.org/draft/2020-12/vocab/unevaluated": true
+            },
+            "$dynamicAnchor": "meta",
+            "title": "Unevaluated applicator vocabulary meta-schema",
+            "type": [
+                "object",
+                "boolean"
+            ],
+            "properties": {
+                "unevaluatedItems": {
+                    "$dynamicRef": "#meta"
+                },
+                "unevaluatedProperties": {
+                    "$dynamicRef": "#meta"
+                }
+            }
+        },
+        "validation": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$id": "https://json-schema.org/draft/2020-12/meta/validation",
+            "$vocabulary": {
+                "https://json-schema.org/draft/2020-12/vocab/validation": true
+            },
+            "$dynamicAnchor": "meta",
+            "title": "Validation vocabulary meta-schema",
+            "type": [
+                "object",
+                "boolean"
+            ],
+            "properties": {
+                "type": {
+                    "anyOf": [
+                        {
+                            "$ref": "#/$defs/simpleTypes"
+                        },
+                        {
+                            "type": "array",
+                            "items": {
+                                "$ref": "#/$defs/simpleTypes"
+                            },
+                            "minItems": 1,
+                            "uniqueItems": true
+                        }
+                    ]
+                },
+                "const": true,
+                "enum": {
+                    "type": "array",
+                    "items": true
+                },
+                "multipleOf": {
+                    "type": "number",
+                    "exclusiveMinimum": 0
+                },
+                "maximum": {
+                    "type": "number"
+                },
+                "exclusiveMaximum": {
+                    "type": "number"
+                },
+                "minimum": {
+                    "type": "number"
+                },
+                "exclusiveMinimum": {
+                    "type": "number"
+                },
+                "maxLength": {
+                    "$ref": "#/$defs/nonNegativeInteger"
+                },
+                "minLength": {
+                    "$ref": "#/$defs/nonNegativeIntegerDefault0"
+                },
+                "pattern": {
+                    "type": "string",
+                    "format": "regex"
+                },
+                "maxItems": {
+                    "$ref": "#/$defs/nonNegativeInteger"
+                },
+                "minItems": {
+                    "$ref": "#/$defs/nonNegativeIntegerDefault0"
+                },
+                "uniqueItems": {
+                    "type": "boolean",
+                    "default": false
+                },
+                "maxContains": {
+                    "$ref": "#/$defs/nonNegativeInteger"
+                },
+                "minContains": {
+                    "$ref": "#/$defs/nonNegativeInteger",
+                    "default": 1
+                },
+                "maxProperties": {
+                    "$ref": "#/$defs/nonNegativeInteger"
+                },
+                "minProperties": {
+                    "$ref": "#/$defs/nonNegativeIntegerDefault0"
+                },
+                "required": {
+                    "$ref": "#/$defs/stringArray"
+                },
+                "dependentRequired": {
+                    "type": "object",
+                    "additionalProperties": {
+                        "$ref": "#/$defs/stringArray"
+                    }
+                }
+            },
+            "$defs": {
+                "nonNegativeInteger": {
+                    "type": "integer",
+                    "minimum": 0
+                },
+                "nonNegativeIntegerDefault0": {
+                    "$ref": "#/$defs/nonNegativeInteger",
+                    "default": 0
+                },
+                "simpleTypes": {
+                    "enum": [
+                        "array",
+                        "boolean",
+                        "integer",
+                        "null",
+                        "number",
+                        "object",
+                        "string"
+                    ]
+                },
+                "stringArray": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    },
+                    "uniqueItems": true,
+                    "default": []
+                }
+            }
+        },
+        "meta-data": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$id": "https://json-schema.org/draft/2020-12/meta/meta-data",
+            "$vocabulary": {
+                "https://json-schema.org/draft/2020-12/vocab/meta-data": true
+            },
+            "$dynamicAnchor": "meta",
+            "title": "Meta-data vocabulary meta-schema",
+            "type": [
+                "object",
+                "boolean"
+            ],
+            "properties": {
+                "title": {
+                    "type": "string"
+                },
+                "description": {
+                    "type": "string"
+                },
+                "default": true,
+                "deprecated": {
+                    "type": "boolean",
+                    "default": false
+                },
+                "readOnly": {
+                    "type": "boolean",
+                    "default": false
+                },
+                "writeOnly": {
+                    "type": "boolean",
+                    "default": false
+                },
+                "examples": {
+                    "type": "array",
+                    "items": true
+                }
+            }
+        },
+        "format-annotation": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$id": "https://json-schema.org/draft/2020-12/meta/format-annotation",
+            "$vocabulary": {
+                "https://json-schema.org/draft/2020-12/vocab/format-annotation": true
+            },
+            "$dynamicAnchor": "meta",
+            "title": "Format vocabulary meta-schema for annotation results",
+            "type": [
+                "object",
+                "boolean"
+            ],
+            "properties": {
+                "format": {
+                    "type": "string"
+                }
+            }
+        },
+        "content": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$id": "https://json-schema.org/draft/2020-12/meta/content",
+            "$vocabulary": {
+                "https://json-schema.org/draft/2020-12/vocab/content": true
+            },
+            "$dynamicAnchor": "meta",
+            "title": "Content vocabulary meta-schema",
+            "type": [
+                "object",
+                "boolean"
+            ],
+            "properties": {
+                "contentEncoding": {
+                    "type": "string"
+                },
+                "contentMediaType": {
+                    "type": "string"
+                },
+                "contentSchema": {
+                    "$dynamicRef": "#meta"
+                }
+            }
+        }
+    }
+}