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

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/ordering.d.ts

@@ -14,6 +14,11 @@ export declare function classifyOrdering(contract: JsonSchema, registry: ValueSc
 /** Recompute the scalar ordering classification from one admitted portable value program. */
 export declare function classifyValueProgramOrdering(program: ValueProgram): OrderingKind | undefined;
 export declare function classifyPreparedOrdering(compiled: CompiledInstanceSchema): OrderingKind | undefined;
+/**
+ * Every value kind `classifyValueKind` returns, frozen, in the order `ValueKind` names them. A kind
+ * added to `ValueKind` does not compile until it is listed here.
+ */
+export declare const VALUE_KINDS: readonly ValueKind[];
 /**
  * The value kind of a property schema (page "Fondations Query v7", § Atoms et value kinds, Y4):
  * the one kind its non-null values admit, `null` being a point of every kind. An annotated

package/dist/v1/language/value/ordering.js

@@ -34,6 +34,20 @@ export function classifyPreparedOrdering(compiled) {
         ? kind
         : undefined;
 }
+const valueKinds = {
+    text: true,
+    number: true,
+    instant: true,
+    enum: true,
+    boolean: true,
+    set: true,
+    json: true,
+};
+/**
+ * Every value kind `classifyValueKind` returns, frozen, in the order `ValueKind` names them. A kind
+ * added to `ValueKind` does not compile until it is listed here.
+ */
+export const VALUE_KINDS = Object.freeze(Object.keys(valueKinds));
 /**
  * The value kind of a property schema (page "Fondations Query v7", § Atoms et value kinds, Y4):
  * the one kind its non-null values admit, `null` being a point of every kind. An annotated

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/language/value/reference/closure.js

@@ -36,10 +36,9 @@ export function collectResourceClosure(schema, context, index, pointer) {
             const target = result.resolved.resource;
             if (resources.has(target.key))
                 return;
-            const registered = {
-                ...target,
-                diagnosticPointer: `${pointer}/registry/graphNodePath`,
-            };
+            // The graph NodePath resource is no part of the schema: what it holds is reported at the
+            // $ref that names it.
+            const registered = { ...target, diagnosticPointer: refPointer };
             resources.set(target.key, registered);
             queue.push(registered);
         });

package/dist/v1/language/value/reference/registry.index.d.ts

@@ -5,6 +5,8 @@ export interface RegistryIndex {
     readonly registry: ValueSchemaRegistry;
     readonly domains: ReadonlyMap<string, ValueSchemaDomainRegistry>;
     readonly dependenciesByOwner: ReadonlyMap<string, ReadonlyMap<string, string>>;
+    /** The `definitionRefIndex` of each Node Definition its own Domain lists. */
+    readonly nodeDefinitions: ReadonlySet<string>;
 }
 export declare function indexRegistry(registry: ValueSchemaRegistry, pointer: string): {
     readonly index: RegistryIndex;

package/dist/v1/language/value/reference/registry.index.js

@@ -4,11 +4,21 @@ import { diagnostic } from '../../validation/diagnostic.js';
 import { isValueObject as isJsonObject } from '../model/object.js';
 import { JSON_SCHEMA_DIALECT } from '../model/schema.js';
 import { GRAPH_NODE_PATH_SCHEMA_ID } from '../syntax/node-path/schema.js';
+// A registry is an immutable value, and every value schema of a Domain is validated against the
+// same one: an index that admitted it without a diagnostic is reused, so the closure is indexed
+// once per registry rather than once per value schema.
+const admittedIndexes = new WeakMap();
 export function indexRegistry(registry, pointer) {
+    const admitted = admittedIndexes.get(registry);
+    if (admitted !== undefined)
+        return { index: admitted, diagnostics: [] };
     const diagnostics = [];
     const domains = new Map();
     domains.set(registry.current.origin, registry.current);
-    validateDomainRegistry(registry.current, `${pointer}/registry/current`, false, diagnostics);
+    // The registry is the closure the Kernel builds for the schema at `pointer`, not a document: a
+    // fault of one of its entries is a fault of the closure that schema is checked with, reported
+    // there, the entry named in the message.
+    validateDomainRegistry(registry.current, 'current', false, pointer, diagnostics);
     const dependencies = [
         ...registry.directDependencies.map((domain) => ({ domain, lane: 'directDependencies' })),
         ...registry.transitiveDependencies.map((domain) => ({
@@ -17,10 +27,9 @@ export function indexRegistry(registry, pointer) {
         })),
     ];
     dependencies.forEach(({ domain, lane }, index) => {
-        const domainPointer = `${pointer}/registry/${lane}/${index}`;
-        validateDomainRegistry(domain, domainPointer, true, diagnostics);
+        validateDomainRegistry(domain, `${lane}/${index}`, true, pointer, diagnostics);
         if (domain.origin === registry.current.origin || domains.has(domain.origin)) {
-            diagnostics.push(diagnostic('VS_REFERENCE_RESOLUTION', domainPointer, `Registry origin ${domain.origin} is duplicated in the exact closure.`));
+            diagnostics.push(diagnostic('VS_REFERENCE_RESOLUTION', pointer, `Registry origin ${domain.origin} is duplicated in the exact closure, at ${lane}/${index}.`));
             return;
         }
         domains.set(domain.origin, domain);
@@ -37,31 +46,38 @@ export function indexRegistry(registry, pointer) {
             }
         }
     }
-    validateGraphNodePathResource(registry.graphNodePath, `${pointer}/registry/graphNodePath`, diagnostics);
-    return { index: { registry, domains, dependenciesByOwner }, diagnostics };
+    const nodeDefinitions = new Set();
+    for (const domain of domains.values()) {
+        for (const ref of domain.nodeDefinitions) {
+            if (ref.origin === domain.origin)
+                nodeDefinitions.add(definitionRefIndex(ref));
+        }
+    }
+    validateGraphNodePathResource(registry.graphNodePath, pointer, diagnostics);
+    const index = { registry, domains, dependenciesByOwner, nodeDefinitions };
+    if (diagnostics.length === 0)
+        admittedIndexes.set(registry, index);
+    return { index, diagnostics };
 }
 export function isOriginVisibleFrom(index, ownerOrigin, targetOrigin) {
     return (ownerOrigin === targetOrigin ||
         index.dependenciesByOwner.get(ownerOrigin)?.has(targetOrigin) === true);
 }
 export function hasNodeDefinition(index, ref, ownerOrigin) {
-    if (!isOriginVisibleFrom(index, ownerOrigin, ref.origin))
-        return false;
-    return (index.domains
-        .get(ref.origin)
-        ?.nodeDefinitions.some((candidate) => definitionRefIndex(candidate) === definitionRefIndex(ref)) === true);
+    return (isOriginVisibleFrom(index, ownerOrigin, ref.origin) &&
+        index.nodeDefinitions.has(definitionRefIndex(ref)));
 }
-function validateDomainRegistry(domain, pointer, revisionRequired, diagnostics) {
+function validateDomainRegistry(domain, entry, revisionRequired, pointer, diagnostics) {
     if (!DOMAIN_ORIGIN_PATTERN.test(domain.origin)) {
-        diagnostics.push(diagnostic('VS_REFERENCE_RESOLUTION', `${pointer}/origin`, 'Registry origin is invalid.'));
+        diagnostics.push(diagnostic('VS_REFERENCE_RESOLUTION', pointer, `Registry origin is invalid, at ${entry}.`));
     }
     if ((revisionRequired && domain.revision === undefined) ||
         (domain.revision !== undefined && !DOMAIN_REVISION_PATTERN.test(domain.revision))) {
-        diagnostics.push(diagnostic('VS_REFERENCE_RESOLUTION', `${pointer}/revision`, 'A dependency-closure registry entry requires its exact sha256 revision.'));
+        diagnostics.push(diagnostic('VS_REFERENCE_RESOLUTION', pointer, `A dependency-closure registry entry requires its exact sha256 revision, at ${entry}.`));
     }
     for (const ref of domain.nodeDefinitions) {
         if (ref.origin !== domain.origin) {
-            diagnostics.push(diagnostic('VS_REFERENCE_RESOLUTION', `${pointer}/nodeDefinitions`, 'A registry domain can list only its own Node Definitions.'));
+            diagnostics.push(diagnostic('VS_REFERENCE_RESOLUTION', pointer, `A registry domain can list only its own Node Definitions, at ${entry}.`));
         }
     }
 }

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

@@ -46,7 +46,7 @@
             "code": "DV_VALUE_SCHEMA",
             "valueCode": "VS_PATH_EXTENSION",
             "stage": "rule",
-            "statement": "x-astrale-path annotates only a direct Property of a callable input object, beside exactly the $ref of the graph NodePath schema, and reads target node, cardinality one and a non-empty set of Node Class refs it accepts.",
+            "statement": "x-astrale-path annotates only a direct Property of a callable input object, beside exactly the $ref of the graph NodePath schema.",
             "positions": [
                 "#/$defs/value-location/anyOf/1/properties/x-astrale-path"
             ]
@@ -75,6 +75,7 @@
             "stage": "context",
             "statement": "A $ref resolves to a location of its own value schema, and x-astrale-path accepts Node Classes of the Domain or of a direct dependency.",
             "positions": [
+                "#/$defs/path-annotation/properties/accepts/items",
                 "#/$defs/value-location/anyOf/1/properties/$ref"
             ]
         },
@@ -322,17 +323,6 @@
                 }
             ]
         },
-        "class-policy": {
-            "anyOf": [
-                {
-                    "type": "boolean",
-                    "const": false
-                },
-                {
-                    "$ref": "#/$defs/policy-ref"
-                }
-            ]
-        },
         "class-ref": {
             "type": "object",
             "properties": {
@@ -586,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": {
@@ -779,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
@@ -1259,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
@@ -1292,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": {
@@ -1378,12 +1506,53 @@
                 "$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,
             "maxLength": 253,
             "pattern": "^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\\.)+[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$"
         },
+        "path-annotation": {
+            "type": "object",
+            "properties": {
+                "target": {
+                    "type": "string",
+                    "const": "node"
+                },
+                "cardinality": {
+                    "type": "string",
+                    "const": "one"
+                },
+                "accepts": {
+                    "type": "array",
+                    "minItems": 1,
+                    "uniqueItems": true,
+                    "items": {
+                        "$ref": "#/$defs/class-ref"
+                    }
+                }
+            },
+            "required": [
+                "target",
+                "cardinality",
+                "accepts"
+            ],
+            "additionalProperties": false
+        },
         "policy-check-expr": {
             "anyOf": [
                 {
@@ -2100,7 +2269,7 @@
                             "type": "string"
                         },
                         "x-astrale-path": {
-                            "type": "object"
+                            "$ref": "#/$defs/path-annotation"
                         },
                         "additionalProperties": {
                             "$ref": "#/$defs/value-subschema"
@@ -2331,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);
 }