@astrale-os/kernel-dsl 0.2.0-beta.4 → 0.2.0-beta.41

package/dist/v1/schema/compatibility/subjects.d.ts

@@ -0,0 +1,34 @@
+import type { Key as SemanticKey } from '../../addressing/index.js';
+import type { DefinitionAnalysis, EffectiveField, EffectiveMethod } from '../analysis/class.js';
+import type { DomainSchema } from '../model/schema.js';
+import type { Context } from './context.js';
+import type { ClassCoordinate, Coordinate, MemberCoordinate, MethodCoordinate, PropertyCoordinate } from './coordinate.js';
+import type { Subject } from './model.js';
+export type ResolvedSubject = {
+    readonly kind: 'class';
+    readonly coordinate: ClassCoordinate;
+    readonly schema: DomainSchema;
+    readonly analysis: DefinitionAnalysis;
+} | {
+    readonly kind: 'property';
+    readonly coordinate: PropertyCoordinate;
+    readonly schema: DomainSchema;
+    readonly field: EffectiveField;
+} | {
+    readonly kind: 'method';
+    readonly coordinate: MethodCoordinate;
+    readonly schema: DomainSchema;
+    readonly method: EffectiveMethod;
+} | {
+    readonly kind: 'member';
+    readonly coordinate: MemberCoordinate;
+    readonly schema: DomainSchema;
+};
+/** Resolve a trusted coordinate within one exact accepted closure. */
+export declare function resolveSubject({ context, coordinate, }: {
+    readonly context: Context;
+    readonly coordinate: Coordinate;
+}): ResolvedSubject | undefined;
+export declare function identityOf(coordinate: Coordinate): Subject;
+/** Resolve one caller-supplied Key of the source into an exact coordinate that exists there. */
+export declare function coordinateForKey(context: Context, source: DomainSchema, input: SemanticKey, index: number): Coordinate;

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

@@ -0,0 +1,86 @@
+import { Key } from '../../addressing/index.js';
+import { SchemaError, diagnostic } from '../diagnostic.js';
+import { effectiveDefinition, effectiveMethod } from './context.js';
+import { classCoordinate, keyReference, memberCoordinate, methodCoordinate, propertyCoordinate, } from './coordinate.js';
+/** Resolve a trusted coordinate within one exact accepted closure. */
+export function resolveSubject({ context, coordinate, }) {
+    const schema = context.schemas.get(Key.origin(coordinate.key));
+    if (schema === undefined)
+        return undefined;
+    if (coordinate.kind === 'member') {
+        const { ref } = coordinate;
+        const declaration = ref.kind === 'function'
+            ? schema.functions[ref.name]
+            : ref.kind === 'policy'
+                ? schema.policies[ref.name]
+                : ref.kind === 'view'
+                    ? schema.views[ref.name]
+                    : schema.core.nodes[ref.name];
+        return declaration === undefined ? undefined : { kind: 'member', coordinate, schema };
+    }
+    const analysis = effectiveDefinition(context, schema, coordinate.kind === 'class' ? coordinate.ref : coordinate.owner);
+    if (analysis === undefined)
+        return undefined;
+    if (coordinate.kind === 'class')
+        return { kind: 'class', coordinate, schema, analysis };
+    if (coordinate.kind === 'property') {
+        const field = analysis.properties.get(coordinate.key);
+        return field === undefined ? undefined : { kind: 'property', coordinate, schema, field };
+    }
+    const method = effectiveMethod(analysis, coordinate.key);
+    return method === undefined ? undefined : { kind: 'method', coordinate, schema, method };
+}
+export function identityOf(coordinate) {
+    return Object.freeze({
+        key: coordinate.key,
+        kind: coordinate.kind === 'member' ? coordinate.ref.kind : coordinate.kind,
+    });
+}
+/** Resolve one caller-supplied Key of the source into an exact coordinate that exists there. */
+export function coordinateForKey(context, source, input, index) {
+    let key;
+    try {
+        key = Key(input);
+    }
+    catch {
+        return invalidMemberRoot(input, index, 'is not a canonical semantic Key');
+    }
+    if (Key.origin(key) !== source.origin) {
+        return invalidMemberRoot(key, index, `belongs to ${Key.origin(key)}, not source ${source.origin}`);
+    }
+    const reference = keyReference(key);
+    let coordinate;
+    if (reference.member !== undefined && reference.ownerName !== undefined) {
+        if (source.classes[reference.ownerName] === undefined) {
+            return invalidMemberRoot(key, index, 'has no exact owning Definition');
+        }
+        const owner = { origin: source.origin, kind: 'class', name: reference.ownerName };
+        coordinate =
+            reference.member === 'property'
+                ? propertyCoordinate(owner, reference.name)
+                : methodCoordinate(owner, reference.name);
+    }
+    else if (reference.kind === 'class') {
+        if (source.classes[reference.name] === undefined) {
+            return invalidMemberRoot(key, index, 'does not exist in the source');
+        }
+        // Explicit Class selection compares its surface without inferring inheritance.
+        coordinate = classCoordinate({ origin: source.origin, kind: 'class', name: reference.name });
+    }
+    else {
+        coordinate = memberCoordinate({
+            origin: source.origin,
+            kind: reference.kind,
+            name: reference.name,
+        });
+    }
+    if (resolveSubject({ context, coordinate }) === undefined) {
+        return invalidMemberRoot(key, index, 'does not exist in the source');
+    }
+    return coordinate;
+}
+function invalidMemberRoot(key, index, reason) {
+    throw new SchemaError([
+        diagnostic('DM_MEMBER_ROOT_INVALID', `/roots/${index}`, `Key ${JSON.stringify(key)} ${reason}.`, typeof key === 'string' ? key : undefined),
+    ]);
+}

package/dist/v1/schema/dependency/lookup.d.ts

@@ -0,0 +1,18 @@
+import type { Key } from '../../addressing/index.js';
+import type { Revision } from '../../addressing/index.js';
+import type { DomainSchema } from '../model/schema.js';
+/** Exact revision-addressed lookup used while accepting a dependency closure. */
+export interface DomainSchemaLookup {
+    get(origin: Key.Origin, revision: Revision): DomainSchema | undefined;
+}
+export interface DomainSchemaEntry {
+    readonly revision: Revision;
+    readonly schema: DomainSchema;
+}
+export declare class MemoryDomainSchemaLookup implements DomainSchemaLookup {
+    #private;
+    constructor(entries?: readonly DomainSchemaEntry[]);
+    get(origin: Key.Origin, revision: Revision): DomainSchema | undefined;
+    set(entry: DomainSchemaEntry): this;
+}
+export declare function emptyDomainSchemaLookup(): DomainSchemaLookup;

package/dist/v1/schema/dependency/lookup.js

@@ -0,0 +1,31 @@
+import { revisionOfDomainSchema } from '../canonical/revision.js';
+export class MemoryDomainSchemaLookup {
+    #entries = new Map();
+    constructor(entries = []) {
+        for (const entry of entries)
+            this.set(entry);
+    }
+    get(origin, revision) {
+        return this.#entries.get(lookupKey(origin, revision));
+    }
+    set(entry) {
+        const { revision, schema } = entry;
+        const actualRevision = revisionOfDomainSchema(schema);
+        if (revision !== actualRevision) {
+            throw new Error(`Schema lookup revision ${revision} disagrees with ${schema.origin}@${actualRevision}`);
+        }
+        const key = lookupKey(schema.origin, revision);
+        const existing = this.#entries.get(key);
+        if (existing !== undefined && existing !== schema) {
+            throw new Error(`Schema lookup entry ${schema.origin}@${revision} is already bound`);
+        }
+        this.#entries.set(key, schema);
+        return this;
+    }
+}
+export function emptyDomainSchemaLookup() {
+    return { get: () => undefined };
+}
+function lookupKey(origin, revision) {
+    return `${origin}\u0000${revision}`;
+}

package/dist/v1/schema/diagnostic.d.ts

@@ -1,12 +1,12 @@
-export interface DomainDiagnostic {
-    readonly code: string;
+export type SchemaDiagnosticCode = 'DM_MEMBER_ROOT_INVALID' | 'DM_DEPENDENCY_CONTEXT_INVALID' | 'DM_DEPENDENCY_NOT_RETAINED' | 'DM_MEANING_INCONSISTENT' | 'DM_MEMBER_ORIGIN_MISMATCH' | 'DV_ACCEPTANCE_CONTEXT' | 'DV_CALLABLE_AUTH' | 'DV_CALLABLE_IO' | 'DV_CALLABLE_POLICY_AUTH' | 'DV_CLASS_ABSTRACT' | 'DV_CLASS_ACYCLIC' | 'DV_CLASS_KIND' | 'DV_CORE_EDGE_CLASS' | 'DV_CORE_EDGE_CONSTRAINTS' | 'DV_CORE_EDGE_KEY' | 'DV_CORE_EDGE_PROPERTIES' | 'DV_CORE_NODE_CLASS' | 'DV_CORE_NODE_PROPERTIES' | 'DV_CORE_REF' | 'DV_DATA_COMPOSITION' | 'DV_DEPENDENCY_ACYCLIC' | 'DV_DEPENDENCY_DIRECT' | 'DV_DEPENDENCY_EXACT' | 'DV_DEPENDENCY_LIMITS' | 'DV_DEPENDENCY_REVISION_COHERENCE' | 'DV_DEPENDENCY_UNIQUE' | 'DV_EDGE_ACCEPTS' | 'DV_EDGE_CLASS_COMPOSITION' | 'DV_EDGE_CONSTRAINT' | 'DV_EDGE_ROLE' | 'DV_EDGE_UNDIRECTED' | 'DV_JSON_VALUE' | 'DV_METHOD_ABSTRACT' | 'DV_METHOD_COMPOSITION' | 'DV_PROPERTY_AUTO' | 'DV_PROPERTY_COMPOSITION' | 'DV_PROPERTY_STATE' | 'DV_REF_RESOLVES' | 'DV_VALUE_SCHEMA' | 'DV_VIEW_TARGET' | 'PL_BUDGET' | 'PL_COMPOSITION' | 'PL_CONNECTIVITY' | 'PL_REF' | 'PL_REPEAT' | 'PL_TARGET' | 'PL_TYPING' | 'PL_USE' | 'PL_VARIABLE_SCOPE' | 'STRUCTURE_ABSTRACT_POLICY' | 'STRUCTURE_CALLABLE_POLICY_AUTH' | 'STRUCTURE_DUPLICATE_ITEM' | 'STRUCTURE_EDGE_ORIENTATION' | 'STRUCTURE_FORMAT' | 'STRUCTURE_INVALID' | 'STRUCTURE_KEY' | 'STRUCTURE_MAXIMUM' | 'STRUCTURE_MINIMUM' | 'STRUCTURE_MULTIPLE' | 'STRUCTURE_REQUIRED' | 'STRUCTURE_TYPE' | 'STRUCTURE_UNION' | 'STRUCTURE_UNKNOWN_FIELD' | 'STRUCTURE_VALUE' | 'UNSUPPORTED_DOCUMENT_FORMAT' | 'UNSUPPORTED_DSL_VERSION';
+export interface SchemaDiagnostic<out Code extends SchemaDiagnosticCode = SchemaDiagnosticCode> {
+    readonly code: Code;
     readonly pointer: string;
     readonly message: string;
     readonly ref?: string;
 }
-export declare class DomainSchemaError extends Error {
-    readonly diagnostics: readonly DomainDiagnostic[];
-    constructor(diagnostics: readonly DomainDiagnostic[]);
+export declare function diagnostic<const Code extends SchemaDiagnosticCode>(code: Code, pointer: string, message: string, ref?: string): SchemaDiagnostic<Code>;
+export declare class SchemaError extends Error {
+    readonly diagnostics: readonly SchemaDiagnostic[];
+    constructor(diagnostics: readonly SchemaDiagnostic[]);
 }
-export declare function diagnostic(code: string, pointer: string, message: string, ref?: string): DomainDiagnostic;
-//# sourceMappingURL=diagnostic.d.ts.map

package/dist/v1/schema/diagnostic.js

@@ -1,21 +1,21 @@
-export class DomainSchemaError extends Error {
+import { compareUnicode } from '../addressing/ordering.js';
+export function diagnostic(code, pointer, message, ref) {
+    return Object.freeze({ code, pointer, message, ...(ref === undefined ? {} : { ref }) });
+}
+export class SchemaError extends Error {
     diagnostics;
     constructor(diagnostics) {
         const ordered = [...diagnostics].sort(compareDiagnostic);
         super(ordered.map(formatDiagnostic).join('\n'));
-        this.name = 'DomainSchemaError';
+        this.name = 'SchemaError';
         this.diagnostics = Object.freeze(ordered);
     }
 }
-export function diagnostic(code, pointer, message, ref) {
-    return Object.freeze({ code, pointer, message, ...(ref === undefined ? {} : { ref }) });
-}
 function compareDiagnostic(left, right) {
-    return (left.pointer.localeCompare(right.pointer) ||
-        left.code.localeCompare(right.code) ||
-        left.message.localeCompare(right.message));
+    return (compareUnicode(left.pointer, right.pointer) ||
+        compareUnicode(left.code, right.code) ||
+        compareUnicode(left.message, right.message));
 }
 function formatDiagnostic(value) {
     return `${value.pointer || '/'} [${value.code}] ${value.message}`;
 }
-//# sourceMappingURL=diagnostic.js.map

package/dist/v1/schema/fingerprint.d.ts

@@ -0,0 +1,2 @@
+export { callableFingerprint } from './compatibility/comparators/callables.js';
+export type { Fingerprint as MeaningFingerprint } from './compatibility/model.js';

package/dist/v1/schema/fingerprint.js

@@ -0,0 +1 @@
+export { callableFingerprint } from './compatibility/comparators/callables.js';

package/dist/v1/schema/index.d.ts

@@ -1,42 +1,29 @@
 /** Admit, encode, inspect, and semantically resolve canonical V1 DomainSchemas. */
-export type { DomainSchema, DomainSchemaIR, DomainSchemaInputOf as InputOf } from './domain.ir.js';
-export { acceptDomainSchema as accept } from './domain.accept.js';
-export { decodeDomainSchema as decode, encodeDomainSchema as encode, serializeDomainSchema as serialize, } from './domain.codec.js';
-export { revisionOfDomainSchema as revision } from './domain.revision.js';
-export { resolveDomainSchema as resolve } from './domain.resolve.js';
-export { compareDependencyMeaning, compareMemberMeaning } from './dependency.meaning.js';
-export type { DependencyMeaningChange, DependencyMeaningChangeKind, DependencyMeaningComparison, } from './dependency.meaning.js';
-export { readDomainSchemaHeader as readHeader } from './domain.header.js';
-export { DOMAIN_FORMAT as FORMAT, DOMAIN_VERSION as VERSION } from './reference.js';
-export { namedTypeUri as typeUri } from './reference.js';
-export { patterns } from '../addressing/index.js';
-export { compile } from './compiled/compiler.js';
-export { validator } from './compiled/authored-validator.js';
-export { load } from './compiled/validator.js';
-export type { Bundle, CallableTarget, CompiledSchema, Pattern, PatternState, PatternTransition, ScalarRange, ValueNode, ValueProgram, } from './compiled/model.js';
-export type { CallableMeaning, Validator } from './compiled/validator.js';
-export { DomainSchemaError as Error } from './diagnostic.js';
-export type { DomainDiagnostic as Diagnostic } from './diagnostic.js';
-export type { DomainSchemaLookup as Lookup } from './domain.lookup.js';
-export type { DomainSchemaHeader as Header } from './domain.header.js';
-/** Exact structured identities retained only by schema lifecycle and resolution. */
-export type { CoreEndpointRef, CoreRef, ClassFamily, ClassRef, DefinitionKind, DefinitionRef, DomainDependency, DomainMemberKind, DomainRef, Revision, Family, FunctionRef, MemberKind, InterfaceFamily, InterfaceRef, PolicyRef, SchemaRef, ValueTypeRef, ViewRef, } from './reference.js';
-export type { ClassDeclaration, NodeClassDeclaration, EdgeClassDeclaration, EdgeClassPolicies, NodeClassPolicies, } from './definition/class.js';
-export type { InterfaceDeclaration, NodeInterfaceDeclaration, EdgeInterfaceDeclaration, } from './definition/interface.js';
-export type { DefinitionAnalysis } from './definition/analysis.js';
-export type { AutoEvent, AutoSet, PropertyFacet, PropertyAuto, PropertyMetadata, PropertyMetadataRecord, PropertyVisibility, } from './definition/property.js';
-export type { PropertyObjectSchema } from './value/schema.js';
-export type { DirectedEdgeContract, DirectedSourceEndpoint, DirectedTargetEndpoint, EdgeConstraints, EdgeContract, EdgeCount, EdgeEndpointBase, EdgeOrientation, IncidentEndpoint, UndirectedEdgeContract, } from './definition/edge.js';
-export type { CallableContract, CallableOutput, FunctionAuth, FunctionDeclaration, MethodDeclaration, MethodInheritance, MethodRecord, OutputMode, } from './callable.js';
-export { fullMatch, fullMatchSource, type FullMatch } from './value/full-match.js';
-export type { DataDeclaration, DataFacet, MediaType } from './definition/data.js';
-export type { ViewAuth, ViewDeclaration, ViewTarget } from './view/declaration.js';
-export type { PolicyCheckExpression, PolicyCheckObject, PolicyObjectRef, PolicyDeclaration, PolicyEdgePattern, PolicyVariable, PolicyPatternExpression, PolicyPatternTerm, PolicyRepeat, } from './policy/ast.js';
-export type { CoreDeclaration, CoreEdgeDeclaration, CoreNodeDeclaration, } from './core/declaration.js';
-export type { ResolvedDomainSchema as Resolution, ResolvedDomainSchemaReferences as ResolutionReferences, } from './domain.resolve.js';
-export type { ResolvedDefinition } from './resolution/definition.index.js';
+import type { SourceDomain } from '../domain/index.js';
+import type { DomainSchema } from './model/schema.js';
+export type { DomainSchema, DomainSchemaIR, DomainOfSchema as DomainOf } from './model/schema.js';
+export type ResolvedDomainOf<Schema extends DomainSchema> = SourceDomain<Schema>;
+export interface Resolve {
+    <const Schema extends DomainSchema>(schema: Schema): ResolvedDomainOf<Schema>;
+}
+export declare const resolve: Resolve;
+export type { SchemaDiagnosticCode as DiagnosticCode } from './diagnostic.js';
+export { acceptDomainSchema as accept } from './admission/accept.js';
+export { decodeDomainSchema as decode, encodeDomainSchema as encode, serializeDomainSchema as serialize, } from './codec/schema.js';
+export { revisionOfDomainSchema as revision } from './canonical/revision.js';
+export { ANNOTATION_KEYWORDS, FIELD_ROLES, callableFingerprint, compareDependencyMeaning, compareMemberMeaning, describeMeaningChange, footprintOf, meaningOf, } from './compatibility/index.js';
+export type { DependencyMeaningChange, DependencyMeaningChangeKind, DependencyMeaningComparison, DependencyMeaningLevel, FieldRole, FootprintEntry, MeaningDifference, MeaningFingerprint, } from './compatibility/index.js';
+export * as compatibility from './compatibility/api.js';
+export { header } from './codec/header.js';
+export { DOMAIN_FORMAT as FORMAT, DOMAIN_VERSION as VERSION } from './model/format.js';
+export { compile, load } from '../compiled/index.js';
+export type { CompiledSchema, DomainOfCompiled } from '../compiled/index.js';
+export { SchemaError as Error } from './diagnostic.js';
+export type { SchemaDiagnostic as Diagnostic } from './diagnostic.js';
+export type { DomainSchemaLookup as Lookup } from './dependency/lookup.js';
+export type { DomainSchemaHeader as Header } from './codec/header.js';
+export type { DomainDependency } from '../addressing/index.js';
 /** The versioned value-schema grammar embedded in declarations. */
-export * as values from './value/index.js';
-/** Shared exact value bounds for declaration metadata. */
-export * as metadata from './metadata.js';
-//# sourceMappingURL=index.d.ts.map
+export * as values from './validation/value-api.js';
+export { compareDependencyStructure } from './compatibility/index.js';
+export type { DependencyStructureComparison } from './compatibility/index.js';

package/dist/v1/schema/index.js

@@ -1,20 +1,15 @@
 /** Admit, encode, inspect, and semantically resolve canonical V1 DomainSchemas. */
-export { acceptDomainSchema as accept } from './domain.accept.js';
-export { decodeDomainSchema as decode, encodeDomainSchema as encode, serializeDomainSchema as serialize, } from './domain.codec.js';
-export { revisionOfDomainSchema as revision } from './domain.revision.js';
-export { resolveDomainSchema as resolve } from './domain.resolve.js';
-export { compareDependencyMeaning, compareMemberMeaning } from './dependency.meaning.js';
-export { readDomainSchemaHeader as readHeader } from './domain.header.js';
-export { DOMAIN_FORMAT as FORMAT, DOMAIN_VERSION as VERSION } from './reference.js';
-export { namedTypeUri as typeUri } from './reference.js';
-export { patterns } from '../addressing/index.js';
-export { compile } from './compiled/compiler.js';
-export { validator } from './compiled/authored-validator.js';
-export { load } from './compiled/validator.js';
-export { DomainSchemaError as Error } from './diagnostic.js';
-export { fullMatch, fullMatchSource } from './value/full-match.js';
+import { resolve as resolveDomainSchema } from './resolution/domain.js';
+export const resolve = resolveDomainSchema;
+export { acceptDomainSchema as accept } from './admission/accept.js';
+export { decodeDomainSchema as decode, encodeDomainSchema as encode, serializeDomainSchema as serialize, } from './codec/schema.js';
+export { revisionOfDomainSchema as revision } from './canonical/revision.js';
+export { ANNOTATION_KEYWORDS, FIELD_ROLES, callableFingerprint, compareDependencyMeaning, compareMemberMeaning, describeMeaningChange, footprintOf, meaningOf, } from './compatibility/index.js';
+export * as compatibility from './compatibility/api.js';
+export { header } from './codec/header.js';
+export { DOMAIN_FORMAT as FORMAT, DOMAIN_VERSION as VERSION } from './model/format.js';
+export { compile, load } from '../compiled/index.js';
+export { SchemaError as Error } from './diagnostic.js';
 /** The versioned value-schema grammar embedded in declarations. */
-export * as values from './value/index.js';
-/** Shared exact value bounds for declaration metadata. */
-export * as metadata from './metadata.js';
-//# sourceMappingURL=index.js.map
+export * as values from './validation/value-api.js';
+export { compareDependencyStructure } from './compatibility/index.js';

package/dist/v1/schema/model/format.d.ts

@@ -0,0 +1,2 @@
+export declare const DOMAIN_FORMAT: 'astrale.dsl';
+export declare const DOMAIN_VERSION: 'v1';

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

@@ -0,0 +1,2 @@
+export const DOMAIN_FORMAT = 'astrale.dsl';
+export const DOMAIN_VERSION = 'v1';

package/dist/v1/schema/model/schema.d.ts

@@ -0,0 +1,30 @@
+import type { Key } from '../../addressing/index.js';
+import type { DomainDependencyMap } from '../../addressing/index.js';
+import type { Domain, DomainOfSource, DomainSource } from '../../domain/model/domain.js';
+import type { FunctionDefinition } from '../../language/callable/model/callable.js';
+import type { ClassDefinition } from '../../language/class/model/class.js';
+import type { CoreContent } from '../../language/core/model/core.js';
+import type { PolicyDefinition } from '../../language/policy/model/policy.js';
+import type { ViewDefinition } from '../../language/view/model/view.js';
+export interface DomainSchemaIR {
+    readonly format: 'astrale.dsl';
+    readonly version: 'v1';
+    readonly origin: Key.Origin;
+    readonly dependencies: DomainDependencyMap;
+    readonly classes: Readonly<Record<string, ClassDefinition>>;
+    readonly functions: Readonly<Record<string, FunctionDefinition>>;
+    readonly policies: Readonly<Record<string, PolicyDefinition>>;
+    readonly views: Readonly<Record<string, ViewDefinition>>;
+    readonly core: CoreContent;
+}
+declare const DOMAIN_SCHEMA_BRAND: unique symbol;
+/**
+ * Accepted canonical schema carrying its exact resolved Domain projection.
+ */
+export type DomainSchema<Origin extends string = string, Resolved extends Domain = Domain> = DomainSchemaIR & DomainSource<Resolved> & {
+    readonly origin: Origin;
+    readonly [DOMAIN_SCHEMA_BRAND]: true;
+};
+export type DomainOfSchema<Schema extends DomainSchema> = DomainOfSource<Schema>;
+export declare function asDomainSchema<Origin extends string = string, Resolved extends Domain = Domain>(value: DomainSchemaIR): DomainSchema<Origin, Resolved>;
+export {};

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

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

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

@@ -0,0 +1,2 @@
+import type { DomainSchemaIR } from '../model/schema.js';
+export declare function normalizeDomainSchema(schema: DomainSchemaIR): DomainSchemaIR;

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

@@ -0,0 +1,234 @@
+import { json } from '@astrale-os/kernel-dsl/value';
+import { compareDefinitionRefs, compareUnicode } from '../../addressing/ordering.js';
+import { isBinaryInput } from '../../language/callable/model/callable.js';
+import { normalizePolicyChecks, normalizePolicyExpression, } from '../../language/policy/normalization/normalize.js';
+import { admitStateTopology } from '../../language/state/topology.js';
+import { canonicalizeValueSchema } from '../../language/value/profile/canonicalize.js';
+export function normalizeDomainSchema(schema) {
+    const classes = mapRecord(schema.classes, canonicalizeClass);
+    const orientationByClass = new Map(Object.entries(classes)
+        .filter((entry) => entry[1].kind === 'edge')
+        .map(([name, declaration]) => [name, declaration.orientation]));
+    const normalized = {
+        format: 'astrale.dsl',
+        version: 'v1',
+        origin: schema.origin,
+        dependencies: mapRecord(schema.dependencies, (dependency) => ({ ...dependency })),
+        classes,
+        functions: mapRecord(schema.functions, canonicalizeFunction),
+        policies: mapRecord(schema.policies, canonicalizePolicy),
+        views: mapRecord(schema.views, canonicalizeView),
+        core: {
+            nodes: mapRecord(schema.core.nodes, (node) => ({
+                ref: node.ref,
+                class: node.class,
+                properties: copyJsonValue(node.properties),
+            })),
+            edges: schema.core.edges
+                .map((edge) => canonicalizeCoreEdge(edge, schema.origin, orientationByClass))
+                .sort(compareCoreEdges),
+        },
+    };
+    return copyJsonValue(normalized);
+}
+function canonicalizePolicy(value) {
+    return {
+        ref: value.ref,
+        ...withDescription(value),
+        expression: normalizePolicyExpression(value.expression),
+    };
+}
+function canonicalizeView(value) {
+    return {
+        ref: value.ref,
+        ...withDescription(value),
+        target: value.target.kind === 'domain'
+            ? { kind: 'domain' }
+            : {
+                kind: 'definition',
+                definitions: [...value.target.definitions].sort(compareDefinitionRefs),
+            },
+    };
+}
+function canonicalizeClass(value) {
+    const base = {
+        ...withDescription(value),
+        ref: value.ref,
+        kind: value.kind,
+        abstract: value.abstract,
+        extends: [...value.extends].sort(compareDefinitionRefs),
+        properties: mapRecord(value.properties, canonicalizeProperty),
+    };
+    if (value.kind === '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 {
+        ref: value.ref,
+        ...canonicalizeCallable(value),
+    };
+}
+function canonicalizeCallable(value) {
+    const base = {
+        ...withDescription(value),
+        input: isBinaryInput(value.input)
+            ? {
+                mode: 'binary',
+                metadata: canonicalizeValueSchema(value.input.metadata, 'callable-input'),
+                maximumBytes: value.input.maximumBytes,
+            }
+            : canonicalizeValueSchema(value.input, 'callable-input'),
+        output: canonicalizeCallableOutput(value.output),
+        // Ordinary execution has one canonical form, so existing revisions never move.
+        ...(value.execution?.durable === true ? { execution: { durable: true } } : {}),
+    };
+    return value.auth === 'authorized'
+        ? {
+            ...base,
+            auth: value.auth,
+            ...(value.policy === undefined ? {} : { policy: normalizePolicyChecks(value.policy) }),
+        }
+        : { ...base, auth: value.auth };
+}
+function canonicalizeMethod(value) {
+    return {
+        ...canonicalizeCallable(value),
+        input: canonicalizeValueSchema(value.input, 'callable-input'),
+        static: value.static,
+        abstract: value.abstract,
+    };
+}
+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 canonicalizeProperty(value) {
+    return {
+        schema: canonicalizeValueSchema(value.schema, 'property-facet'),
+        required: value.required,
+        ...(value.auto === undefined
+            ? {}
+            : {
+                auto: {
+                    on: [...new Set(value.auto.on)].sort(compareUnicode),
+                    set: value.auto.set,
+                },
+            }),
+        ...(value.description === undefined ? {} : { description: value.description }),
+        ...(value.state === undefined
+            ? {}
+            : { state: admitStateTopology(value.state) }),
+    };
+}
+function canonicalizeDirectedEndpoints(value) {
+    return {
+        ...value,
+        source: { ...value.source, accepts: [...value.source.accepts].sort(compareDefinitionRefs) },
+        target: { ...value.target, accepts: [...value.target.accepts].sort(compareDefinitionRefs) },
+    };
+}
+function canonicalizeIncidentEndpoints(value) {
+    return [
+        { ...value[0], accepts: [...value[0].accepts].sort(compareDefinitionRefs) },
+        { ...value[1], accepts: [...value[1].accepts].sort(compareDefinitionRefs) },
+    ];
+}
+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 (compareDefinitionRefs(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;
+    const [a, b] = [coreEndpointOrder(left), coreEndpointOrder(right)];
+    return (compareUnicode(a.origin, b.origin) ||
+        compareUnicode(a.kind, b.kind) ||
+        compareUnicode(a.name, b.name) ||
+        compareUnicode(a.member, b.member));
+}
+/**
+ * A Method orders under its owner Class through the synthetic kind `method`; every other endpoint
+ * keeps the exact `compareDefinitionRefs` tuple with an empty member, so the canonical order of
+ * already-authored Core Edges — and therefore their revisions — never moves.
+ */
+function coreEndpointOrder(ref) {
+    return ref.kind === 'method'
+        ? { origin: ref.owner.origin, kind: ref.kind, name: ref.owner.name, member: ref.name }
+        : { origin: ref.origin, kind: ref.kind, name: ref.name, member: '' };
+}
+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)]));
+}