@astrale-os/kernel-dsl 0.2.0-beta.2 → 0.2.0-beta.20

package/dist/v1/{schema/value/extensions → language/value/syntax}/node-path/validate.js

@@ -1,8 +1,9 @@
-import { diagnostic } from '../../../diagnostic.js';
-import { schemaRefIndex, DOMAIN_ORIGIN_PATTERN, MEMBER_NAME_PATTERN } from '../../../reference.js';
-import { parseJsonPointerFragment } from '../../location/pointer.js';
-import { walkSchema } from '../../location/walk.js';
-import { isValueObject as isJsonObject } from '../../object.js';
+import { Key } from '../../../../addressing/index.js';
+import { DOMAIN_ORIGIN_PATTERN, MEMBER_NAME_PATTERN } from '../../../../addressing/patterns.js';
+import { diagnostic } from '../../../validation/diagnostic.js';
+import { isValueObject as isJsonObject } from '../../model/object.js';
+import { parseJsonPointerFragment } from '../pointer.js';
+import { walkSchema } from '../walk.js';
 import { GRAPH_NODE_PATH_SCHEMA_ID } from './schema.js';
 export function validateNodePathExtension(schema, context, pointer, definitionExists) {
     const diagnostics = [];
@@ -14,15 +15,13 @@ export function validateNodePathExtension(schema, context, pointer, definitionEx
         const tokens = parseJsonPointerFragment(`#${location.pointer}`);
         const fieldName = tokens?.length === 2 && tokens[0] === 'properties' ? tokens[1] : undefined;
         const root = isJsonObject(schema) ? schema : undefined;
-        const directRequiredField = context === 'callable-input' &&
+        const directField = context === 'callable-input' &&
             root?.type === 'object' &&
             location.depth === 1 &&
             location.parentKeyword === 'properties' &&
-            fieldName !== undefined &&
-            Array.isArray(root?.required) &&
-            root.required.includes(fieldName);
-        if (!directRequiredField) {
-            diagnostics.push(diagnostic('VS_PATH_EXTENSION', extensionPointer, 'x-astrale-path is allowed only on a direct required property schema at a callable-input object root.'));
+            fieldName !== undefined;
+        if (!directField) {
+            diagnostics.push(diagnostic('VS_PATH_EXTENSION', extensionPointer, 'x-astrale-path is allowed only on a direct property schema at a callable-input object root.'));
         }
         const schemaKeys = Object.keys(location.schema);
         if (schemaKeys.length !== 2 ||
@@ -42,23 +41,23 @@ export function validateNodePathExtension(schema, context, pointer, definitionEx
             diagnostics.push(diagnostic('VS_PATH_EXTENSION', extensionPointer, 'A V1 Path field resolves exactly one Node.'));
         }
         if (!Array.isArray(annotation.accepts) || annotation.accepts.length === 0) {
-            diagnostics.push(diagnostic('VS_PATH_EXTENSION', `${extensionPointer}/accepts`, 'x-astrale-path.accepts must be a non-empty Node Definition ref set.'));
+            diagnostics.push(diagnostic('VS_PATH_EXTENSION', `${extensionPointer}/accepts`, 'x-astrale-path.accepts must be a non-empty Node Class ref set.'));
             return;
         }
         const seen = new Set();
         annotation.accepts.forEach((candidate, candidateIndex) => {
             const candidatePointer = `${extensionPointer}/accepts/${candidateIndex}`;
             if (!isNodeDefinitionRef(candidate)) {
-                diagnostics.push(diagnostic('VS_PATH_EXTENSION', candidatePointer, 'Path acceptance entries are exact node-family class or interface refs.'));
+                diagnostics.push(diagnostic('VS_PATH_EXTENSION', candidatePointer, 'Path acceptance entries are exact Node Class refs.'));
                 return;
             }
-            const key = schemaRefIndex(candidate);
+            const key = Key.of(candidate);
             if (seen.has(key)) {
-                diagnostics.push(diagnostic('VS_PATH_EXTENSION', candidatePointer, 'x-astrale-path.accepts rejects duplicate Definition refs.'));
+                diagnostics.push(diagnostic('VS_PATH_EXTENSION', candidatePointer, 'x-astrale-path.accepts rejects duplicate Class refs.'));
             }
             seen.add(key);
             if (!definitionExists(candidate)) {
-                diagnostics.push(diagnostic('VS_REFERENCE_RESOLUTION', candidatePointer, 'Path acceptance Definition is absent from the current/direct exact registry.'));
+                diagnostics.push(diagnostic('VS_REFERENCE_RESOLUTION', candidatePointer, 'Path acceptance Class is absent from the current/direct exact registry.'));
             }
         });
     });
@@ -69,7 +68,7 @@ function isNodeDefinitionRef(value) {
         hasExactKeys(value, ['origin', 'kind', 'name']) &&
         typeof value.origin === 'string' &&
         DOMAIN_ORIGIN_PATTERN.test(value.origin) &&
-        (value.kind === 'interface' || value.kind === 'class') &&
+        value.kind === 'class' &&
         typeof value.name === 'string' &&
         MEMBER_NAME_PATTERN.test(value.name));
 }
@@ -77,4 +76,3 @@ function hasExactKeys(value, expected) {
     const actual = Object.keys(value);
     return actual.length === expected.length && expected.every((key) => Object.hasOwn(value, key));
 }
-//# sourceMappingURL=validate.js.map

package/dist/v1/{schema/value/location → language/value/syntax}/pointer.d.ts

@@ -2,4 +2,3 @@ export declare function appendPointer(pointer: string, token: string | number):
 export declare function parseJsonPointerFragment(fragment: string): readonly string[] | undefined;
 export declare function tokensToPointer(tokens: readonly string[]): string;
 export declare function resolvePointer(root: unknown, tokens: readonly string[]): unknown;
-//# sourceMappingURL=pointer.d.ts.map

package/dist/v1/{schema/value/location → language/value/syntax}/pointer.js

@@ -46,5 +46,4 @@ export function resolvePointer(root, tokens) {
     }
     return value;
 }
-import { isValueObject as isJsonObject } from '../object.js';
-//# sourceMappingURL=pointer.js.map
+import { isValueObject as isJsonObject } from '../model/object.js';

package/dist/v1/{schema/value/location → language/value/syntax}/walk.d.ts

@@ -1,4 +1,4 @@
-import type { JsonSchema } from '../schema.js';
+import type { JsonSchema } from '../model/schema.js';
 export interface SchemaLocation {
     readonly schema: JsonSchema;
     readonly pointer: string;
@@ -8,4 +8,3 @@ export interface SchemaLocation {
 export declare function walkSchema(schema: JsonSchema, visit: (location: SchemaLocation) => void, pointer?: string): void;
 export declare function collectSchemaPointers(schema: JsonSchema): ReadonlySet<string>;
 export declare function isJsonSchema(value: unknown): value is JsonSchema;
-//# sourceMappingURL=walk.d.ts.map

package/dist/v1/{schema/value/location → language/value/syntax}/walk.js

@@ -1,4 +1,4 @@
-import { isValueObject as isJsonObject } from '../object.js';
+import { isValueObject as isJsonObject } from '../model/object.js';
 import { SCHEMA_ARRAY_KEYWORDS, SCHEMA_MAP_KEYWORDS, SCHEMA_SINGLE_KEYWORDS } from './keywords.js';
 import { appendPointer } from './pointer.js';
 export function walkSchema(schema, visit, pointer = '') {
@@ -51,4 +51,3 @@ export function collectSchemaPointers(schema) {
 export function isJsonSchema(value) {
     return typeof value === 'boolean' || isJsonObject(value);
 }
-//# sourceMappingURL=walk.js.map

package/dist/v1/language/view/index.d.ts

@@ -0,0 +1,2 @@
+export type * from './model/view.js';
+export type * from './resolved.js';

package/dist/v1/language/view/index.js

@@ -0,0 +1 @@
+export {};

package/dist/v1/language/view/model/view.d.ts

@@ -0,0 +1,11 @@
+import type { ClassRef, DefinitionBase, ViewRef } from '../../../addressing/index.js';
+export type ViewTarget = {
+    readonly kind: 'domain';
+} | {
+    readonly kind: 'definition';
+    readonly definitions: readonly [ClassRef, ...ClassRef[]];
+};
+export interface ViewDefinition extends DefinitionBase<ViewRef> {
+    readonly description?: string;
+    readonly target: ViewTarget;
+}

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

@@ -0,0 +1 @@
+export {};

package/dist/v1/language/view/resolved.d.ts

@@ -0,0 +1,9 @@
+import type { DefinitionKey, ViewRef } from '../../addressing/index.js';
+import type { ViewDefinition, ViewTarget } from './model/view.js';
+export interface ResolvedView {
+    readonly ref: ViewRef;
+    readonly key: DefinitionKey<string, 'view'>;
+    readonly target: ViewTarget;
+    readonly description?: ViewDefinition['description'];
+    readonly definition: ViewDefinition;
+}

package/dist/v1/language/view/resolved.js

@@ -0,0 +1 @@
+export {};

package/dist/v1/schema/admission/accept.d.ts

@@ -0,0 +1,3 @@
+import type { DomainSchemaLookup } from '../dependency/lookup.js';
+import type { DomainSchema } from '../model/schema.js';
+export declare function acceptDomainSchema(input: unknown, lookup?: DomainSchemaLookup): DomainSchema;

package/dist/v1/schema/{domain.accept.js → admission/accept.js}

@@ -1,10 +1,10 @@
 import { accept as acceptJsonValue, BoundaryError as JsonBoundaryError, } from '@astrale-os/kernel-dsl/value';
-import { DomainSchemaError, diagnostic } from './diagnostic.js';
-import { emptyDomainSchemaLookup } from './domain.lookup.js';
-import { canonicalDomainSchemaAfterValidation } from './domain.revision.js';
-import { validateDomainSchemaSemantics } from './domain.validate.js';
-import { rememberDomainClosure } from './resolution/closure.js';
-import { routeDomainSchema } from './validation/domain.route.js';
+import { canonicalDomainSchemaAfterValidation } from '../canonical/revision.js';
+import { emptyDomainSchemaLookup } from '../dependency/lookup.js';
+import { SchemaError, diagnostic } from '../diagnostic.js';
+import { rememberDomainClosure } from '../resolution/closure.js';
+import { validateDomainSchemaSemantics } from '../validation/domain.js';
+import { routeDomainSchema } from '../validation/domain.route.js';
 export function acceptDomainSchema(input, lookup = emptyDomainSchemaLookup()) {
     let admitted;
     try {
@@ -12,16 +12,15 @@ export function acceptDomainSchema(input, lookup = emptyDomainSchemaLookup()) {
     }
     catch (error) {
         if (error instanceof JsonBoundaryError) {
-            throw new DomainSchemaError([diagnostic('DV_JSON_VALUE', error.pointer, error.message)]);
+            throw new SchemaError([diagnostic('DV_JSON_VALUE', error.pointer, error.message)]);
         }
         throw error;
     }
     const structured = routeDomainSchema(admitted);
     const validation = validateDomainSchemaSemantics(structured, lookup);
     if (validation.diagnostics.length > 0)
-        throw new DomainSchemaError(validation.diagnostics);
+        throw new SchemaError(validation.diagnostics);
     const accepted = canonicalDomainSchemaAfterValidation(structured).schema;
     rememberDomainClosure(accepted, validation.context.dependencies.values());
     return accepted;
 }
-//# sourceMappingURL=domain.accept.js.map

package/dist/v1/schema/{definition/analysis.d.ts → analysis/class.d.ts}

@@ -1,43 +1,42 @@
-import type { MethodDeclaration } from '../callable.js';
-import type { DomainDiagnostic } from '../diagnostic.js';
-import type { DefinitionRef } from '../reference.js';
+import type { ClassRef } from '../../addressing/index.js';
+import type { MethodDefinition } from '../../language/callable/model/callable.js';
+import type { ClassDefinition } from '../../language/class/model/class.js';
+import type { DataDefinition } from '../../language/class/model/data.js';
+import type { PropertyAuto } from '../../language/class/model/property.js';
+import type { StateTopology } from '../../language/state/index.js';
+import type { JsonSchema } from '../../language/value/model/schema.js';
+import type { SchemaDiagnostic } from '../diagnostic.js';
 import type { DomainResolutionContext } from '../resolution/context.js';
-import type { JsonSchema } from '../value/schema.js';
-import type { ClassDeclaration } from './class.js';
-import type { DataDeclaration } from './data.js';
-import type { InterfaceDeclaration } from './interface.js';
-import type { PropertyAuto } from './property.js';
 import { PropertyKey } from '../../addressing/index.js';
 export interface EffectiveField {
     readonly identity: PropertyKey;
-    readonly owner: DefinitionRef;
+    readonly owner: ClassRef;
     readonly name: string;
     readonly schema: JsonSchema;
     readonly required: boolean;
-    readonly visibility: 'public' | 'private';
     readonly auto?: PropertyAuto;
+    readonly state?: StateTopology;
 }
 export interface EffectiveMethod {
     readonly identity: string;
-    readonly owner: DefinitionRef;
+    readonly owner: ClassRef;
     readonly name: string;
-    readonly declaration: MethodDeclaration;
+    readonly declaration: MethodDefinition;
 }
 export interface EffectiveData {
     readonly identity: string;
-    readonly owner: DefinitionRef;
-    readonly declaration: DataDeclaration;
+    readonly owner: ClassRef;
+    readonly declaration: DataDefinition;
 }
 export interface DefinitionAnalysis {
-    readonly ref: DefinitionRef;
-    readonly declaration: InterfaceDeclaration | ClassDeclaration;
+    readonly ref: ClassRef;
+    readonly declaration: ClassDefinition;
     readonly properties: ReadonlyMap<PropertyKey, EffectiveField>;
     readonly data?: EffectiveData;
     readonly methods: ReadonlyMap<string, EffectiveMethod>;
 }
 export interface DefinitionAnalysisResult {
     readonly definitions: ReadonlyMap<string, DefinitionAnalysis>;
-    readonly diagnostics: readonly DomainDiagnostic[];
+    readonly diagnostics: readonly SchemaDiagnostic[];
 }
 export declare function analyzeDefinitions(environment: DomainResolutionContext): DefinitionAnalysisResult;
-//# sourceMappingURL=analysis.d.ts.map

package/dist/v1/schema/{definition/analysis.js → analysis/class.js}

@@ -1,20 +1,21 @@
 import { json } from '@astrale-os/kernel-dsl/value';
-import { PropertyKey } from '../../addressing/index.js';
+import { Key, PropertyKey } from '../../addressing/index.js';
+import { definitionRefIndex } from '../../addressing/ordering.js';
+import { normalizePolicyChecks } from '../../language/policy/normalization/normalize.js';
+import { canonicalizeValueSchema } from '../../language/value/profile/canonicalize.js';
 import { diagnostic } from '../diagnostic.js';
-import { normalizePolicyChecks } from '../policy/normalize.js';
-import { schemaRefIndex, formatSchemaRef } from '../reference.js';
-import { canonicalizeValueSchema } from '../value/profile/canonicalize.js';
+const formatDefinitionRef = Key.of;
 export function analyzeDefinitions(environment) {
     const diagnostics = [];
     const result = new Map();
     const visiting = new Set();
     const analyze = (ref) => {
-        const key = schemaRefIndex(ref);
+        const key = definitionRefIndex(ref);
         const cached = result.get(key);
         if (cached !== undefined)
             return cached;
         if (visiting.has(key)) {
-            diagnostics.push(diagnostic('DV_INTERFACE_ACYCLIC', '', `Inheritance cycle reaches ${formatSchemaRef(ref)}.`, formatSchemaRef(ref)));
+            diagnostics.push(diagnostic('DV_CLASS_ACYCLIC', '', `Inheritance cycle reaches ${formatDefinitionRef(ref)}.`, formatDefinitionRef(ref)));
             return undefined;
         }
         const resolved = environment.resolveAny(ref);
@@ -22,14 +23,14 @@ export function analyzeDefinitions(environment) {
             return undefined;
         visiting.add(key);
         const declaration = resolved.declaration;
-        const parents = parentRefs(declaration, ref.kind);
+        const parents = declaration.extends;
         const parentAnalyses = parents.flatMap((parent) => {
             const target = environment.resolveAny(parent);
             if (target === undefined) {
-                diagnostics.push(diagnostic('DV_REF_RESOLVES', '', `Inheritance ref ${formatSchemaRef(parent)} does not resolve.`, formatSchemaRef(parent)));
+                diagnostics.push(diagnostic('DV_REF_RESOLVES', '', `Inheritance ref ${formatDefinitionRef(parent)} does not resolve.`, formatDefinitionRef(parent)));
                 return [];
             }
-            const analysis = analyze(target.ref);
+            const analysis = target.ref.kind === 'class' ? analyze(target.ref) : undefined;
             return analysis === undefined ? [] : [analysis];
         });
         const properties = mergeFields(parentAnalyses.map((parent) => parent.properties), ownFields(ref, declaration));
@@ -51,27 +52,18 @@ export function analyzeDefinitions(environment) {
     }
     return Object.freeze({ definitions: result, diagnostics: Object.freeze(diagnostics) });
 }
-function parentRefs(declaration, kind) {
-    if (kind === 'interface') {
-        return declaration.extends;
-    }
-    return declaration.implements;
-}
 function ownFields(owner, declaration) {
-    const root = declaration.properties;
-    const required = new Set(root.required);
     const result = new Map();
-    for (const [name, schema] of Object.entries(root.properties)) {
+    for (const [name, property] of Object.entries(declaration.properties)) {
         const key = PropertyKey.of(owner, name);
-        const metadata = declaration.propertyMetadata[name];
         result.set(key, {
             identity: key,
             owner,
             name,
-            schema,
-            required: required.has(name),
-            visibility: metadata?.visibility === 'private' ? 'private' : 'public',
-            ...(metadata?.auto === undefined ? {} : { auto: metadata.auto }),
+            schema: property.schema,
+            required: property.required,
+            ...(property.auto === undefined ? {} : { auto: property.auto }),
+            ...(property.state === undefined ? {} : { state: property.state }),
         });
     }
     return result;
@@ -99,17 +91,17 @@ function mergeData(owner, declaration, parents, diagnostics) {
             continue;
         }
         if (effective.identity !== parent.data.identity) {
-            diagnostics.push(diagnostic('DV_DATA_COMPOSITION', '', `Data has distinct declaring owners ${formatSchemaRef(effective.owner)} and ${formatSchemaRef(parent.data.owner)}.`));
+            diagnostics.push(diagnostic('DV_DATA_COMPOSITION', '', `Data has distinct declaring owners ${formatDefinitionRef(effective.owner)} and ${formatDefinitionRef(parent.data.owner)}.`));
         }
     }
     const own = 'data' in declaration ? declaration.data : undefined;
     if (own === undefined)
         return effective;
     if (effective !== undefined) {
-        diagnostics.push(diagnostic('DV_DATA_COMPOSITION', '', `Data redeclares the inherited contract from ${formatSchemaRef(effective.owner)}.`));
+        diagnostics.push(diagnostic('DV_DATA_COMPOSITION', '', `Data redeclares the inherited contract from ${formatDefinitionRef(effective.owner)}.`));
     }
     return {
-        identity: `${schemaRefIndex(owner)}\u0000data`,
+        identity: `${definitionRefIndex(owner)}\u0000data`,
         owner,
         declaration: own,
     };
@@ -135,7 +127,7 @@ function mergeMethods(owner, declaration, parents, diagnostics) {
         const parentsForName = inherited.get(name) ?? [];
         for (const parent of parentsForName) {
             if (parent.declaration.inheritance === 'sealed') {
-                diagnostics.push(diagnostic('DV_METHOD_COMPOSITION', '', `Method ${name} cannot override sealed ${formatSchemaRef(parent.owner)}.${name}.`));
+                diagnostics.push(diagnostic('DV_METHOD_COMPOSITION', '', `Method ${name} cannot override sealed ${formatDefinitionRef(parent.owner)}.${name}.`));
             }
             if (!sameMethodSignature(ownMethod, parent.declaration)) {
                 diagnostics.push(diagnostic('DV_METHOD_COMPOSITION', '', `Method ${name} does not exactly preserve its inherited signature.`));
@@ -146,7 +138,7 @@ function mergeMethods(owner, declaration, parents, diagnostics) {
             }
         }
         result.set(name, {
-            identity: `${schemaRefIndex(owner)}\u0000method\u0000${name}`,
+            identity: `${definitionRefIndex(owner)}\u0000method\u0000${name}`,
             owner,
             name,
             declaration: ownMethod,
@@ -158,7 +150,7 @@ function mergeMethods(owner, declaration, parents, diagnostics) {
             diagnostics.push(diagnostic('DV_METHOD_COMPOSITION', '', `Inherited method ${name} is ambiguous and has no local override.`));
         }
     }
-    if (owner.kind === 'class' && declaration.family === 'node') {
+    if (declaration.kind === 'node' && !declaration.abstract) {
         for (const [name, method] of result) {
             if (method.declaration.inheritance === 'abstract') {
                 diagnostics.push(diagnostic('DV_METHOD_COMPOSITION', '', `Concrete Class ${owner.name} leaves method ${name} abstract.`));
@@ -187,4 +179,3 @@ function canonicalMethodOutput(value) {
 function canonicalPolicy(value) {
     return json.serialize(value === undefined ? null : normalizePolicyChecks(value));
 }
-//# sourceMappingURL=analysis.js.map

package/dist/v1/schema/canonical/domain.d.ts

@@ -1,3 +1,3 @@
-import type { DomainSchemaIR } from '../domain.ir.js';
+import type { DomainSchemaIR } from '../model/schema.js';
+/** Produce the deterministic semantic document consumed by canonical JSON serialization. */
 export declare function canonicalizeDomainSchema(schema: DomainSchemaIR): DomainSchemaIR;
-//# sourceMappingURL=domain.d.ts.map

package/dist/v1/schema/canonical/domain.digest.d.ts

@@ -1,4 +1,3 @@
-import type { Revision } from '../reference.js';
+import type { Revision } from '../../addressing/index.js';
 /** Content-address canonical DomainSchema bytes with the V1 revision algorithm. */
 export declare function digestDomainSchemaBytes(bytes: Uint8Array): Revision;
-//# sourceMappingURL=domain.digest.d.ts.map

package/dist/v1/schema/canonical/domain.digest.js

@@ -1,9 +1,5 @@
-import { sha256 } from '@noble/hashes/sha2.js';
+import { digestRevisionBytes } from '../../addressing/revision.js';
 /** Content-address canonical DomainSchema bytes with the V1 revision algorithm. */
 export function digestDomainSchemaBytes(bytes) {
-    let hexadecimal = '';
-    for (const byte of sha256(bytes))
-        hexadecimal += byte.toString(16).padStart(2, '0');
-    return `sha256:${hexadecimal}`;
+    return digestRevisionBytes(bytes);
 }
-//# sourceMappingURL=domain.digest.js.map

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

@@ -1,226 +1,5 @@
-import { json } from '@astrale-os/kernel-dsl/value';
-import { normalizePolicyChecks, normalizePolicyDeclaration } from '../policy/normalize.js';
-import { compareSchemaRefs, compareUnicode, } from '../reference.js';
-import { canonicalizeValueSchema } from '../value/profile/canonicalize.js';
+import { normalizeDomainSchema } from '../normalization/domain.js';
+/** Produce the deterministic semantic document consumed by canonical JSON serialization. */
 export function canonicalizeDomainSchema(schema) {
-    const classes = mapRecord(schema.classes, canonicalizeClass);
-    const orientationByClass = new Map(Object.entries(classes)
-        .filter((entry) => entry[1].family === 'edge')
-        .map(([name, declaration]) => [name, declaration.orientation]));
-    const canonical = {
-        format: 'astrale.dsl',
-        version: 'v1',
-        origin: schema.origin,
-        dependencies: [...schema.dependencies].sort((left, right) => compareUnicode(left.origin, right.origin)),
-        types: mapRecord(schema.types, (value) => canonicalizeValueSchema(value, 'named-type')),
-        interfaces: mapRecord(schema.interfaces, canonicalizeInterface),
-        classes,
-        functions: mapRecord(schema.functions, canonicalizeFunction),
-        policies: mapRecord(schema.policies, normalizePolicyDeclaration),
-        views: mapRecord(schema.views, canonicalizeView),
-        core: {
-            nodes: mapRecord(schema.core.nodes, (node) => ({
-                class: node.class,
-                properties: copyJsonValue(node.properties),
-            })),
-            edges: schema.core.edges
-                .map((edge) => canonicalizeCoreEdge(edge, schema.origin, orientationByClass))
-                .sort(compareCoreEdges),
-        },
-    };
-    return copyJsonValue(canonical);
+    return normalizeDomainSchema(schema);
 }
-function canonicalizeView(value) {
-    return {
-        ...withDescription(value),
-        target: value.target.kind === 'domain'
-            ? { kind: 'domain' }
-            : {
-                kind: 'definition',
-                definitions: [...value.target.definitions].sort(compareSchemaRefs),
-            },
-        auth: value.auth,
-    };
-}
-function canonicalizeInterface(value) {
-    const base = {
-        ...withDescription(value),
-        family: value.family,
-        extends: [...value.extends].sort(compareSchemaRefs),
-        properties: canonicalizePropertyFacet(value.properties),
-        propertyMetadata: canonicalizePropertyMetadata(value.propertyMetadata),
-    };
-    if (value.family === 'both')
-        return base;
-    if (value.family === 'node') {
-        return {
-            ...base,
-            methods: mapRecord(value.methods, canonicalizeMethod),
-            ...(value.data === undefined ? {} : { data: { mediaType: value.data.mediaType } }),
-        };
-    }
-    return value.orientation === 'directed'
-        ? {
-            ...base,
-            orientation: 'directed',
-            endpoints: canonicalizeDirectedEndpoints(value.endpoints),
-            constraints: value.constraints,
-        }
-        : {
-            ...base,
-            orientation: 'undirected',
-            endpoints: canonicalizeIncidentEndpoints(value.endpoints),
-            constraints: value.constraints,
-        };
-}
-function canonicalizeClass(value) {
-    const base = {
-        ...withDescription(value),
-        family: value.family,
-        implements: [...value.implements].sort(compareSchemaRefs),
-        properties: canonicalizePropertyFacet(value.properties),
-        propertyMetadata: canonicalizePropertyMetadata(value.propertyMetadata),
-    };
-    if (value.family === 'node') {
-        return {
-            ...base,
-            methods: mapRecord(value.methods, canonicalizeMethod),
-            ...(value.data === undefined ? {} : { data: { mediaType: value.data.mediaType } }),
-            ...(value.icon === undefined ? {} : { icon: value.icon }),
-            policies: value.policies,
-        };
-    }
-    return value.orientation === 'directed'
-        ? {
-            ...base,
-            orientation: 'directed',
-            endpoints: canonicalizeDirectedEndpoints(value.endpoints),
-            policies: value.policies,
-            constraints: value.constraints,
-        }
-        : {
-            ...base,
-            orientation: 'undirected',
-            endpoints: canonicalizeIncidentEndpoints(value.endpoints),
-            policies: value.policies,
-            constraints: value.constraints,
-        };
-}
-function canonicalizeFunction(value) {
-    return {
-        ...withDescription(value),
-        input: canonicalizeValueSchema(value.input, 'callable-input'),
-        output: canonicalizeCallableOutput(value.output),
-        auth: value.auth,
-        ...(value.policy === undefined ? {} : { policy: normalizePolicyChecks(value.policy) }),
-    };
-}
-function canonicalizeMethod(value) {
-    return {
-        ...canonicalizeFunction(value),
-        static: value.static,
-        inheritance: value.inheritance,
-    };
-}
-function canonicalizeCallableOutput(value) {
-    switch (value.mode) {
-        case 'value':
-            return { mode: 'value', schema: canonicalizeValueSchema(value.schema, 'callable-output') };
-        case 'stream':
-            return { mode: 'stream', item: canonicalizeValueSchema(value.item, 'callable-output') };
-        case 'binary':
-            return { mode: 'binary' };
-    }
-}
-function canonicalizePropertyFacet(value) {
-    const canonical = canonicalizeValueSchema(value, 'property-facet');
-    return canonical;
-}
-function canonicalizePropertyMetadata(value) {
-    return Object.fromEntries(Object.entries(value)
-        .filter(([, metadata]) => metadata.visibility === 'private' || metadata.auto !== undefined)
-        .map(([name, metadata]) => [
-        name,
-        metadata.auto === undefined
-            ? { visibility: metadata.visibility }
-            : {
-                visibility: metadata.visibility,
-                auto: {
-                    on: [...new Set(metadata.auto.on)].sort(compareUnicode),
-                    set: metadata.auto.set,
-                },
-            },
-    ])
-        .sort(([left], [right]) => compareUnicode(left, right)));
-}
-function canonicalizeDirectedEndpoints(value) {
-    return {
-        ...value,
-        source: { ...value.source, accepts: [...value.source.accepts].sort(compareSchemaRefs) },
-        target: { ...value.target, accepts: [...value.target.accepts].sort(compareSchemaRefs) },
-    };
-}
-function canonicalizeIncidentEndpoints(value) {
-    return [
-        { ...value[0], accepts: [...value[0].accepts].sort(compareSchemaRefs) },
-        { ...value[1], accepts: [...value[1].accepts].sort(compareSchemaRefs) },
-    ];
-}
-function canonicalizeCoreEdge(edge, origin, orientationByClass) {
-    const isLocal = edge.class.origin === origin;
-    const isUndirected = isLocal && orientationByClass.get(edge.class.name) === 'undirected';
-    const [source, target] = isUndirected && compareCoreEndpoints(edge.source, edge.target) > 0
-        ? [edge.target, edge.source]
-        : [edge.source, edge.target];
-    return {
-        class: edge.class,
-        source,
-        target,
-        properties: copyJsonValue(edge.properties),
-    };
-}
-function compareCoreEdges(left, right) {
-    return (compareSchemaRefs(left.class, right.class) ||
-        compareCoreEndpoints(left.source, right.source) ||
-        compareCoreEndpoints(left.target, right.target) ||
-        compareBytes(json.serialize(left.properties), json.serialize(right.properties)));
-}
-function compareCoreEndpoints(left, right) {
-    if (left.kind === 'domain')
-        return right.kind === 'domain' ? 0 : -1;
-    if (right.kind === 'domain')
-        return 1;
-    return compareSchemaRefs(left, right);
-}
-function compareBytes(left, right) {
-    const encoder = new TextEncoder();
-    const a = encoder.encode(left);
-    const b = encoder.encode(right);
-    const length = Math.min(a.length, b.length);
-    for (let index = 0; index < length; index++) {
-        if (a[index] !== b[index])
-            return (a[index] ?? 0) - (b[index] ?? 0);
-    }
-    return a.length - b.length;
-}
-function mapRecord(value, map) {
-    return Object.fromEntries(Object.entries(value)
-        .sort(([left], [right]) => compareUnicode(left, right))
-        .map(([name, entry]) => [name, map(entry, name)]));
-}
-function withDescription(value) {
-    return value.description === undefined ? {} : { description: value.description };
-}
-function copyJsonValue(value) {
-    if (typeof value === 'number') {
-        if (Object.is(value, -0))
-            throw new TypeError('Cannot canonicalize negative zero.');
-        return value;
-    }
-    if (value === null || typeof value !== 'object')
-        return value;
-    if (Array.isArray(value))
-        return value.map((entry) => copyJsonValue(entry));
-    return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, copyJsonValue(entry)]));
-}
-//# sourceMappingURL=domain.js.map

package/dist/v1/schema/canonical/freeze.d.ts

@@ -1,2 +1 @@
 export declare function deepFreeze<T>(value: T): Readonly<T>;
-//# sourceMappingURL=freeze.d.ts.map