@astrale-os/kernel-dsl 0.2.0-beta.1 → 0.2.0-beta.10

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 { accept as acceptJsonValue, BoundaryError as JsonBoundaryError, } from '@astrale-os/kernel-dsl/value';
+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,41 +1,41 @@
-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 { 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 { 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;
 }
 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,25 +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);
         result.set(key, {
             identity: key,
             owner,
             name,
-            schema,
-            required: required.has(name),
-            visibility: declaration.propertyMetadata[name]?.visibility === 'private' ? 'private' : 'public',
+            schema: property.schema,
+            required: property.required,
+            visibility: property.visibility,
+            ...(property.auto === undefined ? {} : { auto: property.auto }),
         });
     }
     return result;
@@ -97,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,
     };
@@ -133,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.`));
@@ -144,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,
@@ -156,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.`));
@@ -185,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,193 +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 {
-        ...base,
-        endpoints: canonicalizeEndpoints(value.endpoints),
-        orientation: value.orientation,
-        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 {
-        ...base,
-        endpoints: canonicalizeEndpoints(value.endpoints),
-        orientation: value.orientation,
-        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')
-        .sort(([left], [right]) => compareUnicode(left, right)));
-}
-function canonicalizeEndpoints(value) {
-    return {
-        ...value,
-        source: { ...value.source, accepts: [...value.source.accepts].sort(compareSchemaRefs) },
-        target: { ...value.target, accepts: [...value.target.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

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

@@ -7,4 +7,3 @@ export function deepFreeze(value) {
     }
     return Object.freeze(value);
 }
-//# sourceMappingURL=freeze.js.map

package/dist/v1/schema/{domain.revision.d.ts → canonical/revision.d.ts}

@@ -1,5 +1,5 @@
-import type { Revision } from './reference.js';
-import { type DomainSchema, type DomainSchemaIR } from './domain.ir.js';
+import type { Revision } from '../../addressing/index.js';
+import { type DomainSchema, type DomainSchemaIR } from '../model/schema.js';
 export interface CanonicalDomainSchema {
     readonly schema: DomainSchema;
     readonly bytes: Uint8Array;
@@ -9,4 +9,3 @@ export declare function canonicalDomainSchema(value: DomainSchema): CanonicalDom
 /** Internal acceptance seam. The caller must establish whole-Domain validity first. */
 export declare function canonicalDomainSchemaAfterValidation(value: DomainSchemaIR): CanonicalDomainSchema;
 export declare function revisionOfDomainSchema(schema: DomainSchema): Revision;
-//# sourceMappingURL=domain.revision.d.ts.map

package/dist/v1/schema/{domain.revision.js → canonical/revision.js}

@@ -1,7 +1,7 @@
 import { json } from '@astrale-os/kernel-dsl/value';
-import { digestDomainSchemaBytes } from './canonical/domain.digest.js';
-import { canonicalizeDomainSchema } from './canonical/domain.js';
-import { asDomainSchema } from './domain.ir.js';
+import { asDomainSchema } from '../model/schema.js';
+import { digestDomainSchemaBytes } from './domain.digest.js';
+import { canonicalizeDomainSchema } from './domain.js';
 export function canonicalDomainSchema(value) {
     return canonicalDomainSchemaAfterValidation(value);
 }
@@ -15,4 +15,3 @@ export function canonicalDomainSchemaAfterValidation(value) {
 export function revisionOfDomainSchema(schema) {
     return canonicalDomainSchema(schema).revision;
 }
-//# sourceMappingURL=domain.revision.js.map

package/dist/v1/schema/codec/header.d.ts

@@ -0,0 +1,17 @@
+import type { Key } from '../../addressing/index.js';
+import type { DomainDependencyMap } from '../../addressing/index.js';
+/**
+ * Structurally trusted routing information used to discover an exact
+ * dependency closure before whole-Domain semantic acceptance is possible.
+ *
+ * This is deliberately not a DomainSchema: callers must still load the
+ * declared revisions and pass the original document to acceptDomainSchema.
+ */
+export interface DomainSchemaHeader {
+    readonly format: 'astrale.dsl';
+    readonly version: 'v1';
+    readonly origin: Key.Origin;
+    readonly dependencies: DomainDependencyMap;
+}
+/** Decode detached Schema bytes or text and retain only validated closure-routing identity. */
+export declare function header(input: string | Uint8Array): DomainSchemaHeader;

package/dist/v1/schema/codec/header.js

@@ -0,0 +1,26 @@
+import { json } from '@astrale-os/kernel-dsl/value';
+import { SchemaError, diagnostic } from '../diagnostic.js';
+import { routeDomainSchema } from '../validation/domain.route.js';
+/** Decode detached Schema bytes or text and retain only validated closure-routing identity. */
+export function header(input) {
+    let decoded;
+    try {
+        decoded = json.decode(input);
+    }
+    catch (error) {
+        if (error instanceof json.DecodeError) {
+            throw new SchemaError([diagnostic('DV_JSON_VALUE', '', error.message)]);
+        }
+        throw error;
+    }
+    const structured = routeDomainSchema(decoded);
+    return Object.freeze({
+        format: structured.format,
+        version: structured.version,
+        dependencies: Object.freeze(Object.fromEntries(Object.entries(structured.dependencies).map(([alias, dependency]) => [
+            alias,
+            Object.freeze({ ...dependency }),
+        ]))),
+        origin: structured.origin,
+    });
+}

package/dist/v1/schema/{domain.codec.d.ts → codec/schema.d.ts}

@@ -1,6 +1,5 @@
-import type { DomainSchema } from './domain.ir.js';
-import type { DomainSchemaLookup } from './domain.lookup.js';
+import type { DomainSchemaLookup } from '../dependency/lookup.js';
+import type { DomainSchema } from '../model/schema.js';
 export declare function decodeDomainSchema(input: string | Uint8Array, lookup?: DomainSchemaLookup): DomainSchema;
 export declare function serializeDomainSchema(schema: DomainSchema): string;
 export declare function encodeDomainSchema(schema: DomainSchema): Uint8Array;
-//# sourceMappingURL=domain.codec.d.ts.map