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

package/dist/v1/language/policy/model/policy.js

@@ -33,6 +33,20 @@ export function projectedMemberClass(ref) {
 function kernelClassRef(name) {
     return Object.freeze({ origin: 'kernel.astrale.ai', kind: 'class', name });
 }
+/**
+ * Every Class slot: the observations, which admit every caller when absent, then the writes, which
+ * admit only the Domain that declares the Class when absent.
+ */
+export const CLASS_OPERATIONS = Object.freeze([
+    'read',
+    'traverse',
+    'create',
+    'update',
+    'delete',
+]);
+export function isClassObservation(operation) {
+    return operation === 'read' || operation === 'traverse';
+}
 export function isClassRuleChecks(value) {
     return (typeof value === 'object' &&
         ('check' in value || 'sameNode' in value || 'allOf' in value || 'anyOf' in value));

package/dist/v1/language/policy/normalization/normalize.d.ts

@@ -1,4 +1,4 @@
-import type { NodeClassPolicy, PolicyCheckExpression, PolicyExpression, PolicyPatternExpression } from '../model/policy.js';
+import type { ClassSlotPolicy, PolicyCheckExpression, PolicyExpression, PolicyPatternExpression } from '../model/policy.js';
 export declare function normalizePolicyExpression(value: PolicyExpression): PolicyExpression;
 /**
  * The fixed point of the single pass: a Pattern the single pass reproduces is returned unchanged,
@@ -6,10 +6,10 @@ export declare function normalizePolicyExpression(value: PolicyExpression): Poli
  */
 export declare function normalizePolicyPattern(value: PolicyPatternExpression): PolicyPatternExpression;
 /**
- * The one spelling of a Node Class observation rule: normalized Policy checks without a composition
- * of one operand, or the Policy that a lone check of `self` names, which is how a Class has always
- * declared one. Callable checks keep their compositions of one operand: their revisions predate
- * this rule.
+ * The one spelling of a Class rule: normalized Policy checks without a composition of one operand,
+ * or the Policy that a lone check of `self` names, which is how a Class has always declared one.
+ * Callable checks keep their compositions of one operand: their revisions predate this rule. A
+ * create rule checks no `self`, so it keeps its checks.
  */
-export declare function normalizeClassRule(value: NodeClassPolicy): NodeClassPolicy;
+export declare function normalizeClassRule<Slot extends ClassSlotPolicy>(value: Slot): Slot;
 export declare function normalizePolicyChecks(value: PolicyCheckExpression): PolicyCheckExpression;

package/dist/v1/language/policy/normalization/normalize.js

@@ -40,16 +40,16 @@ function normalizePatternOnce(value) {
     return normalizePatternNode(rewritten);
 }
 /**
- * The one spelling of a Node Class observation rule: normalized Policy checks without a composition
- * of one operand, or the Policy that a lone check of `self` names, which is how a Class has always
- * declared one. Callable checks keep their compositions of one operand: their revisions predate
- * this rule.
+ * The one spelling of a Class rule: normalized Policy checks without a composition of one operand,
+ * or the Policy that a lone check of `self` names, which is how a Class has always declared one.
+ * Callable checks keep their compositions of one operand: their revisions predate this rule. A
+ * create rule checks no `self`, so it keeps its checks.
  */
 export function normalizeClassRule(value) {
     if (!isClassRuleChecks(value))
         return value;
     const checks = unwrapSingleOperands(normalizePolicyChecks(value));
-    return 'check' in checks && checks.object.kind === 'self' ? checks.check : checks;
+    return ('check' in checks && checks.object.kind === 'self' ? checks.check : checks);
 }
 /** Replace each composition of one operand by that operand, merging what it then nests. */
 function unwrapSingleOperands(value) {

package/dist/v1/language/validation/rule.d.ts

@@ -8,13 +8,15 @@ import type { DiagnosticCode } from './diagnostic.js';
  * `warning`: a value schema, which the rule reports without refusing it.
  */
 export type ValueRuleStage = 'schema' | 'context' | 'value' | 'warning';
-/** The rule one value diagnostic code reports. */
-export interface ValueRule {
-    readonly stage: ValueRuleStage;
+/**
+ * The rule one diagnostic code reports, whatever it checks: what `schema.RULES` and `VALUE_RULES`
+ * say of every code, each with the stages of its own checks.
+ */
+export interface DiagnosticRule {
     /**
-     * The positions the rule constrains, which its diagnostics point at, relative to the value
-     * schema, the value or the Domain input it checks: JSON Pointer templates in which a `{name}`
-     * token stands for one token of the kind it names and `{/path*}` for any number of tokens.
+     * The positions the rule constrains, which its diagnostics point at: JSON Pointer templates in
+     * which a `{name}` token stands for one token of the kind it names and `{/path*}` for any number
+     * of tokens.
      */
     readonly positions: readonly [string, ...string[]];
     /** The rule, in one plain sentence. */
@@ -23,11 +25,19 @@ export interface ValueRule {
     readonly limits?: readonly [LimitKey, ...LimitKey[]];
     /**
      * The conditions of the published JSON Schema of the document that state the rule, where some
-     * do: the URI fragment of each `if` or `not` subschema whose failure refuses a value schema of
-     * the document with `DV_VALUE_SCHEMA` and this rule's code as its `valueCode`.
+     * do: the URI fragment of each `if` or `not` subschema whose failure refuses the document with
+     * this rule's code.
      */
     readonly conditions?: readonly [string, ...string[]];
 }
+/**
+ * The rule one value diagnostic code reports. Its positions are relative to the value schema, the
+ * value or the Domain input it checks. A condition refuses a value schema of the document with
+ * `DV_VALUE_SCHEMA` and this rule's code as its `valueCode`.
+ */
+export interface ValueRule extends DiagnosticRule {
+    readonly stage: ValueRuleStage;
+}
 /**
  * Every value diagnostic code with the rule it reports. A code added to the language does not
  * compile until it is described here.

package/dist/v1/language/validation/rule.js

@@ -1,8 +1,9 @@
+import { deepFreeze } from '../freeze.js';
 /**
  * Every value diagnostic code with the rule it reports. A code added to the language does not
  * compile until it is described here.
  */
-export const VALUE_RULES = frozen({
+export const VALUE_RULES = deepFreeze({
     CALLABLE_INPUT_FIELD_UNKNOWN: {
         stage: 'value',
         positions: [''],
@@ -106,13 +107,3 @@ export const VALUE_RULES = frozen({
         statement: 'A Property of value kind json is filtered by equality only, so its author is warned.',
     },
 });
-function frozen(rules) {
-    for (const rule of Object.values(rules)) {
-        Object.freeze(Object.freeze(rule).positions);
-        if (rule.limits !== undefined)
-            Object.freeze(rule.limits);
-        if (rule.conditions !== undefined)
-            Object.freeze(rule.conditions);
-    }
-    return Object.freeze(rules);
-}

package/dist/v1/language/value/evaluate/program.d.ts

@@ -1,3 +1,4 @@
+import type { Options } from '@astrale-os/kernel-dsl/value';
 import type { Diagnostic } from '../../validation/diagnostic.js';
 import type { ValueProgram } from '../compile/model.js';
-export declare function validateValueProgram(program: ValueProgram, input: unknown, roots?: readonly number[]): readonly Diagnostic[];
+export declare function validateValueProgram(program: ValueProgram, input: unknown, roots?: readonly number[], options?: Options): readonly Diagnostic[];

package/dist/v1/language/value/evaluate/program.js

@@ -1,8 +1,8 @@
 import { loadValueProgram } from '../compile/load.js';
 import { validateCanonicalJsonDomain } from '../profile/json.validate.js';
 import { evaluateInstance } from './evaluator.js';
-export function validateValueProgram(program, input, roots = [program.root]) {
-    const canonical = validateCanonicalJsonDomain(input, '');
+export function validateValueProgram(program, input, roots = [program.root], options) {
+    const canonical = validateCanonicalJsonDomain(input, '', options);
     if (canonical.length > 0)
         return canonical;
     return roots.flatMap((root) => {

package/dist/v1/language/value/evaluate/validate.d.ts

@@ -1,4 +1,4 @@
-import type { Value as JsonValue } from '@astrale-os/kernel-dsl/value';
+import type { Value as JsonValue, Options } from '@astrale-os/kernel-dsl/value';
 import type { Diagnostic } from '../../validation/diagnostic.js';
 import type { JsonSchema } from '../model/schema.js';
 import type { ValueSchemaRegistry } from '../reference/registry.js';
@@ -13,4 +13,4 @@ import { type PatternPool } from './preparation.js';
  */
 export declare function validateJsonInstance(schema: JsonSchema, value: JsonValue, registry: ValueSchemaRegistry, pointer?: string, patterns?: PatternPool): Diagnostic[];
 /** Validate with the exact preparation already retained by a source-resolved Property or Callable. */
-export declare function validatePreparedInstance(compiled: CompiledInstanceSchema, value: unknown): Diagnostic[];
+export declare function validatePreparedInstance(compiled: CompiledInstanceSchema, value: unknown, options?: Options): Diagnostic[];

package/dist/v1/language/value/evaluate/validate.js

@@ -24,8 +24,8 @@ export function validateJsonInstance(schema, value, registry, pointer = '', patt
     return instanceDiagnostics(prepared.value, value, pointer);
 }
 /** Validate with the exact preparation already retained by a source-resolved Property or Callable. */
-export function validatePreparedInstance(compiled, value) {
-    const diagnostics = [...validateCanonicalJsonDomain(value, '')];
+export function validatePreparedInstance(compiled, value, options) {
+    const diagnostics = [...validateCanonicalJsonDomain(value, '', options)];
     return diagnostics.length > 0
         ? diagnostics
         : instanceDiagnostics(compiled, value, '');

package/dist/v1/language/value/profile/json.validate.d.ts

@@ -1,2 +1,4 @@
+import { type Options } from '@astrale-os/kernel-dsl/value';
 import type { Diagnostic } from '../../validation/diagnostic.js';
-export declare function validateCanonicalJsonDomain(value: unknown, pointer: string): readonly Diagnostic[];
+/** Whether `value` is a portable JSON Value, within the portable limits `options` overrides. */
+export declare function validateCanonicalJsonDomain(value: unknown, pointer: string, options?: Options): readonly Diagnostic[];

package/dist/v1/language/value/profile/json.validate.js

@@ -1,8 +1,9 @@
 import { acceptForRead as acceptJsonValue, BoundaryError as JsonBoundaryError, } from '@astrale-os/kernel-dsl/value';
 import { diagnostic } from '../../validation/diagnostic.js';
-export function validateCanonicalJsonDomain(value, pointer) {
+/** Whether `value` is a portable JSON Value, within the portable limits `options` overrides. */
+export function validateCanonicalJsonDomain(value, pointer, options) {
     try {
-        acceptJsonValue(value);
+        acceptJsonValue(value, options);
         return [];
     }
     catch (error) {

package/dist/v1/schema/.spec/schemas/domain-schema.schema.json

@@ -323,17 +323,6 @@
                 }
             ]
         },
-        "class-policy": {
-            "anyOf": [
-                {
-                    "type": "boolean",
-                    "const": false
-                },
-                {
-                    "$ref": "#/$defs/policy-ref"
-                }
-            ]
-        },
         "class-ref": {
             "type": "object",
             "properties": {
@@ -587,6 +576,136 @@
             "maxLength": 100,
             "pattern": "^(?=.{1,100}$)[a-z][a-z0-9-]*(?:\\.[a-z][a-z0-9-]*)*$"
         },
+        "create-policy": {
+            "anyOf": [
+                {
+                    "type": "boolean",
+                    "const": true
+                },
+                {
+                    "$ref": "#/$defs/create-rule-check-expr"
+                }
+            ]
+        },
+        "create-rule-check-expr": {
+            "anyOf": [
+                {
+                    "type": "object",
+                    "properties": {
+                        "sameNode": {
+                            "type": "object",
+                            "properties": {
+                                "left": {
+                                    "type": "object",
+                                    "properties": {
+                                        "kind": {
+                                            "type": "string",
+                                            "const": "ref"
+                                        },
+                                        "ref": {
+                                            "$ref": "#/$defs/projected-member-ref"
+                                        }
+                                    },
+                                    "required": [
+                                        "kind",
+                                        "ref"
+                                    ],
+                                    "additionalProperties": false
+                                },
+                                "right": {
+                                    "type": "object",
+                                    "properties": {
+                                        "kind": {
+                                            "type": "string",
+                                            "const": "ref"
+                                        },
+                                        "ref": {
+                                            "$ref": "#/$defs/projected-member-ref"
+                                        }
+                                    },
+                                    "required": [
+                                        "kind",
+                                        "ref"
+                                    ],
+                                    "additionalProperties": false
+                                }
+                            },
+                            "required": [
+                                "left",
+                                "right"
+                            ],
+                            "additionalProperties": false
+                        }
+                    },
+                    "required": [
+                        "sameNode"
+                    ],
+                    "additionalProperties": false
+                },
+                {
+                    "type": "object",
+                    "properties": {
+                        "check": {
+                            "$ref": "#/$defs/policy-ref"
+                        },
+                        "object": {
+                            "type": "object",
+                            "properties": {
+                                "kind": {
+                                    "type": "string",
+                                    "const": "ref"
+                                },
+                                "ref": {
+                                    "$ref": "#/$defs/projected-member-ref"
+                                }
+                            },
+                            "required": [
+                                "kind",
+                                "ref"
+                            ],
+                            "additionalProperties": false
+                        }
+                    },
+                    "required": [
+                        "check",
+                        "object"
+                    ],
+                    "additionalProperties": false
+                },
+                {
+                    "type": "object",
+                    "properties": {
+                        "allOf": {
+                            "minItems": 1,
+                            "type": "array",
+                            "items": {
+                                "$ref": "#/$defs/create-rule-check-expr"
+                            }
+                        }
+                    },
+                    "required": [
+                        "allOf"
+                    ],
+                    "additionalProperties": false
+                },
+                {
+                    "type": "object",
+                    "properties": {
+                        "anyOf": {
+                            "minItems": 1,
+                            "type": "array",
+                            "items": {
+                                "$ref": "#/$defs/create-rule-check-expr"
+                            }
+                        }
+                    },
+                    "required": [
+                        "anyOf"
+                    ],
+                    "additionalProperties": false
+                }
+            ]
+        },
         "dependency": {
             "type": "object",
             "properties": {
@@ -780,10 +899,19 @@
                     "type": "object",
                     "properties": {
                         "read": {
-                            "$ref": "#/$defs/class-policy"
+                            "$ref": "#/$defs/observation-policy"
                         },
                         "traverse": {
-                            "$ref": "#/$defs/class-policy"
+                            "$ref": "#/$defs/observation-policy"
+                        },
+                        "create": {
+                            "$ref": "#/$defs/write-policy"
+                        },
+                        "update": {
+                            "$ref": "#/$defs/write-policy"
+                        },
+                        "delete": {
+                            "$ref": "#/$defs/write-policy"
                         }
                     },
                     "additionalProperties": false
@@ -1260,10 +1388,19 @@
                     "type": "object",
                     "properties": {
                         "read": {
-                            "$ref": "#/$defs/node-class-policy"
+                            "$ref": "#/$defs/observation-policy"
                         },
                         "traverse": {
-                            "$ref": "#/$defs/node-class-policy"
+                            "$ref": "#/$defs/observation-policy"
+                        },
+                        "create": {
+                            "$ref": "#/$defs/create-policy"
+                        },
+                        "update": {
+                            "$ref": "#/$defs/write-policy"
+                        },
+                        "delete": {
+                            "$ref": "#/$defs/write-policy"
                         }
                     },
                     "additionalProperties": false
@@ -1293,16 +1430,6 @@
             ],
             "additionalProperties": false
         },
-        "node-class-policy": {
-            "anyOf": [
-                {
-                    "$ref": "#/$defs/class-policy"
-                },
-                {
-                    "$ref": "#/$defs/class-rule-check-expr"
-                }
-            ]
-        },
         "node-property-definition": {
             "type": "object",
             "properties": {
@@ -1379,6 +1506,20 @@
                 "$ref": "#/$defs/node-property-definition"
             }
         },
+        "observation-policy": {
+            "anyOf": [
+                {
+                    "type": "boolean",
+                    "const": false
+                },
+                {
+                    "$ref": "#/$defs/policy-ref"
+                },
+                {
+                    "$ref": "#/$defs/class-rule-check-expr"
+                }
+            ]
+        },
         "origin": {
             "type": "string",
             "minLength": 3,
@@ -2359,6 +2500,20 @@
             ],
             "additionalProperties": false,
             "description": "Every View targets its owning Domain."
+        },
+        "write-policy": {
+            "anyOf": [
+                {
+                    "type": "boolean",
+                    "const": true
+                },
+                {
+                    "$ref": "#/$defs/policy-ref"
+                },
+                {
+                    "$ref": "#/$defs/class-rule-check-expr"
+                }
+            ]
         }
     }
 }

package/dist/v1/schema/admission/callable.js

@@ -1,12 +1,12 @@
 import { accept as acceptJsonValue, BoundaryError as JsonBoundaryError, } from '@astrale-os/kernel-dsl/value';
 import { definitionRefIndex } from '../../addressing/ordering.js';
 import { isBinaryInput } from '../../language/callable/model/callable.js';
+import { deepFreeze } from '../../language/freeze.js';
 import { measureChecks } from '../../language/policy/analysis/budgets.js';
 import { PolicyTyping } from '../../language/policy/analysis/typing.js';
 import { normalizePolicyChecks } from '../../language/policy/normalization/normalize.js';
 import {} from '../../language/value/evaluate/preparation.js';
 import { analyzeDefinitions } from '../analysis/class.js';
-import { deepFreeze } from '../canonical/freeze.js';
 import { SchemaError, diagnostic } from '../diagnostic.js';
 import { canonicalizeCallable } from '../normalization/domain.js';
 import { lookupForDomainClosure } from '../resolution/closure.js';

package/dist/v1/schema/canonical/revision.js

@@ -1,7 +1,7 @@
 import { json } from '@astrale-os/kernel-dsl/value';
+import { digestRevisionBytes } from '../../addressing/revision.js';
 import { asDomainSchema } from '../model/schema.js';
-import { digestDomainSchemaBytes } from './domain.digest.js';
-import { canonicalizeDomainSchema } from './domain.js';
+import { normalizeDomainSchema } from '../normalization/domain.js';
 // Only canonical schemas created here own a retained revision, never caller-owned input.
 const revisions = new WeakMap();
 export function canonicalDomainSchema(value) {
@@ -9,9 +9,9 @@ export function canonicalDomainSchema(value) {
 }
 /** Internal acceptance seam. The caller must establish whole-Domain validity first. */
 export function canonicalDomainSchemaAfterValidation(value) {
-    const schema = asDomainSchema(canonicalizeDomainSchema(value));
+    const schema = asDomainSchema(normalizeDomainSchema(value));
     const bytes = json.encode(schema);
-    const revision = digestDomainSchemaBytes(bytes);
+    const revision = digestRevisionBytes(bytes);
     revisions.set(schema, revision);
     return Object.freeze({ schema, bytes, revision });
 }

package/dist/v1/schema/compatibility/comparators/callables.js

@@ -1,7 +1,7 @@
 import { isMethodExecutable } from '../../../language/callable/executable.js';
 import { isBinaryInput } from '../../../language/callable/model/callable.js';
+import { deepFreeze } from '../../../language/freeze.js';
 import { methodSignature as inheritedSignature } from '../../analysis/class.js';
-import { deepFreeze } from '../../canonical/freeze.js';
 import { keyForDefinitionRef } from '../coordinate.js';
 import { CALLABLE_FIELDS, fieldsOf } from '../fields.js';
 import { fingerprintMeaning, semanticValueSchema } from './values.js';

package/dist/v1/schema/compatibility/comparators/classes.js

@@ -1,7 +1,7 @@
 import { compareUnicode } from '../../../addressing/ordering.js';
 import { compareEdgeUniqueTuples, coveringEdgeUniqueTuples, } from '../../../language/class/unique.js';
+import { deepFreeze } from '../../../language/freeze.js';
 import { isClassRuleChecks } from '../../../language/policy/model/policy.js';
-import { deepFreeze } from '../../canonical/freeze.js';
 import { effectiveDefinition } from '../context.js';
 import { propertyCoordinate } from '../coordinate.js';
 import { keyForDefinitionRef } from '../coordinate.js';
@@ -56,12 +56,12 @@ export function classMeaning(context, coordinate, level, onto) {
     return { meaning: deepFreeze(meaning), requirement };
 }
 /**
- * A named Policy compares by its key; `false` or Policy checks by their value, as a callable's
+ * A named Policy compares by its key; a constant or Policy checks by their value, as a callable's
  * Policy does.
  */
 function classPolicyMeaning(policy) {
-    if (policy === false)
-        return false;
+    if (typeof policy === 'boolean')
+        return policy;
     return isClassRuleChecks(policy) ? policy : keyForDefinitionRef(policy);
 }
 /**

package/dist/v1/schema/compatibility/comparators/members.js

@@ -1,4 +1,4 @@
-import { deepFreeze } from '../../canonical/freeze.js';
+import { deepFreeze } from '../../../language/freeze.js';
 import { CORE_FIELDS, POLICY_FIELDS, VIEW_FIELDS, fieldsOf } from '../fields.js';
 import { functionSignature } from './callables.js';
 export function memberMeaning(owner, ref) {

package/dist/v1/schema/compatibility/comparators/values.js

@@ -1,7 +1,7 @@
 import { json } from '@astrale-os/kernel-dsl/value';
+import { digestRevisionBytes } from '../../../addressing/revision.js';
 import { isValueObject as isJsonObject } from '../../../language/value/model/object.js';
 import { SCHEMA_ARRAY_KEYWORDS, SCHEMA_MAP_KEYWORDS, SCHEMA_SINGLE_KEYWORDS, } from '../../../language/value/syntax/keywords.js';
-import { digestDomainSchemaBytes } from '../../canonical/domain.digest.js';
 import { ANNOTATION_KEYWORDS } from '../fields.js';
 /** Drop annotation keywords wherever a schema keyword nests a schema; never inside data. */
 export function semanticValueSchema(value) {
@@ -30,7 +30,7 @@ export function semanticValueSchema(value) {
     return semantic;
 }
 export function fingerprintMeaning(value) {
-    return digestDomainSchemaBytes(json.encode(value));
+    return digestRevisionBytes(json.encode(value));
 }
 function isJsonSchema(value) {
     return typeof value === 'boolean' || isJsonObject(value);

package/dist/v1/schema/compatibility/report.js

@@ -1,6 +1,6 @@
 import { json } from '@astrale-os/kernel-dsl/value';
 import { compareUnicode } from '../../addressing/ordering.js';
-import { deepFreeze } from '../canonical/freeze.js';
+import { deepFreeze } from '../../language/freeze.js';
 import { fingerprintMeaning } from './comparators/values.js';
 import { differences } from './diff.js';
 import { schemaIdentity } from './references.js';

package/dist/v1/schema/compatibility/versioning/index.js

@@ -1,4 +1,4 @@
-import { deepFreeze } from '../../canonical/freeze.js';
+import { deepFreeze } from '../../../language/freeze.js';
 import { SchemaError, diagnostic } from '../../diagnostic.js';
 import { compareFootprint } from '../meaning/footprint.js';
 import { schemaIdentity } from '../references.js';

package/dist/v1/schema/model/schema.js

@@ -1,4 +1,4 @@
-import { deepFreeze } from '../canonical/freeze.js';
+import { deepFreeze } from '../../language/freeze.js';
 export function asDomainSchema(value) {
     return deepFreeze(value);
 }

package/dist/v1/schema/normalization/domain.js

@@ -2,6 +2,7 @@ import { json } from '@astrale-os/kernel-dsl/value';
 import { compareDefinitionRefs, compareUnicode } from '../../addressing/ordering.js';
 import { isBinaryInput } from '../../language/callable/model/callable.js';
 import { compareEdgeUniqueFields, compareEdgeUniqueTuples, compareNodeUniqueTuples, } from '../../language/class/unique.js';
+import { CLASS_OPERATIONS } from '../../language/policy/model/policy.js';
 import { normalizeClassRule, normalizePolicyChecks, normalizePolicyExpression, } from '../../language/policy/normalization/normalize.js';
 import { admitStateTopology } from '../../language/state/topology.js';
 import { canonicalizeValueSchema } from '../../language/value/profile/canonicalize.js';
@@ -72,7 +73,7 @@ function canonicalizeClass(value) {
             methods: mapRecord(value.methods, canonicalizeMethod),
             ...(value.data === undefined ? {} : { data: { mediaType: value.data.mediaType } }),
             ...(value.icon === undefined ? {} : { icon: value.icon }),
-            policies: canonicalizeNodePolicies(value.policies),
+            policies: canonicalizeClassPolicies(value.policies),
             ...(value.unique === undefined ? {} : { unique: canonicalizeNodeUnique(value.unique) }),
         };
     }
@@ -81,7 +82,7 @@ function canonicalizeClass(value) {
             ...base,
             orientation: 'directed',
             endpoints: canonicalizeDirectedEndpoints(value.endpoints),
-            policies: value.policies,
+            policies: canonicalizeClassPolicies(value.policies),
             constraints: value.constraints,
             ...(value.unique === undefined ? {} : { unique: canonicalizeUnique(value.unique) }),
         }
@@ -89,7 +90,7 @@ function canonicalizeClass(value) {
             ...base,
             orientation: 'undirected',
             endpoints: canonicalizeIncidentEndpoints(value.endpoints),
-            policies: value.policies,
+            policies: canonicalizeClassPolicies(value.policies),
             constraints: value.constraints,
         };
 }
@@ -106,11 +107,11 @@ function canonicalizeUnique(tuples) {
         .sort(compareEdgeUniqueTuples);
 }
 /** A rule keeps one spelling: normalized checks, or the Policy a lone `self` check names. */
-function canonicalizeNodePolicies(value) {
-    return {
-        ...(value.read === undefined ? {} : { read: normalizeClassRule(value.read) }),
-        ...(value.traverse === undefined ? {} : { traverse: normalizeClassRule(value.traverse) }),
-    };
+function canonicalizeClassPolicies(value) {
+    return Object.fromEntries(CLASS_OPERATIONS.flatMap((operation) => {
+        const policy = value[operation];
+        return policy === undefined ? [] : [[operation, normalizeClassRule(policy)]];
+    }));
 }
 function canonicalizeFunction(value) {
     return {

package/dist/v1/schema/resolution/domain.js

@@ -97,7 +97,7 @@ export function callableValidation(input, output, registry, patterns) {
     const fields = inputFieldNodes(inputProgram);
     return Object.freeze({
         ...(fields === undefined ? {} : { fields: Object.freeze(Object.keys(fields)) }),
-        validateInput: (value) => validatePreparedInstance(prepared.value, value),
+        validateInput: (value, options) => validatePreparedInstance(prepared.value, value, options),
         validateInputField(field, value) {
             const nodes = fields?.[field];
             return nodes === undefined