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

package/dist/v1/language/value/syntax/node-path/validate.js

@@ -0,0 +1,80 @@
+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 = [];
+    walkSchema(schema, (location) => {
+        if (!isJsonObject(location.schema) || !Object.hasOwn(location.schema, 'x-astrale-path')) {
+            return;
+        }
+        const extensionPointer = `${pointer}${location.pointer}/x-astrale-path`;
+        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' &&
+            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.'));
+        }
+        const schemaKeys = Object.keys(location.schema);
+        if (schemaKeys.length !== 2 ||
+            !Object.hasOwn(location.schema, '$ref') ||
+            location.schema.$ref !== GRAPH_NODE_PATH_SCHEMA_ID) {
+            diagnostics.push(diagnostic('VS_PATH_EXTENSION', `${pointer}${location.pointer}`, `A Path field schema contains exactly $ref ${GRAPH_NODE_PATH_SCHEMA_ID} and x-astrale-path.`, GRAPH_NODE_PATH_SCHEMA_ID));
+        }
+        const annotation = location.schema['x-astrale-path'];
+        if (!isJsonObject(annotation)) {
+            diagnostics.push(diagnostic('VS_PATH_EXTENSION', extensionPointer, 'x-astrale-path must be a closed annotation object.'));
+            return;
+        }
+        if (!hasExactKeys(annotation, ['target', 'cardinality', 'accepts'])) {
+            diagnostics.push(diagnostic('VS_PATH_EXTENSION', extensionPointer, 'x-astrale-path contains exactly target, cardinality, and accepts.'));
+        }
+        if (annotation.target !== 'node' || annotation.cardinality !== 'one') {
+            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 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 Class refs.'));
+                return;
+            }
+            const key = Key.of(candidate);
+            if (seen.has(key)) {
+                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 Class is absent from the current/direct exact registry.'));
+            }
+        });
+    });
+    return diagnostics;
+}
+function isNodeDefinitionRef(value) {
+    return (isJsonObject(value) &&
+        hasExactKeys(value, ['origin', 'kind', 'name']) &&
+        typeof value.origin === 'string' &&
+        DOMAIN_ORIGIN_PATTERN.test(value.origin) &&
+        value.kind === 'class' &&
+        typeof value.name === 'string' &&
+        MEMBER_NAME_PATTERN.test(value.name));
+}
+function hasExactKeys(value, expected) {
+    const actual = Object.keys(value);
+    return actual.length === expected.length && expected.every((key) => Object.hasOwn(value, key));
+}

package/dist/v1/language/value/syntax/pointer.d.ts

@@ -0,0 +1,4 @@
+export declare function appendPointer(pointer: string, token: string | number): string;
+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;

package/dist/v1/language/value/syntax/pointer.js

@@ -0,0 +1,49 @@
+export function appendPointer(pointer, token) {
+    const encoded = String(token).replaceAll('~', '~0').replaceAll('/', '~1');
+    return `${pointer}/${encoded}`;
+}
+export function parseJsonPointerFragment(fragment) {
+    if (!fragment.startsWith('#'))
+        return undefined;
+    let decoded;
+    try {
+        decoded = decodeURIComponent(fragment.slice(1));
+    }
+    catch {
+        return undefined;
+    }
+    if (decoded === '')
+        return [];
+    if (!decoded.startsWith('/'))
+        return undefined;
+    const tokens = [];
+    for (const encoded of decoded.slice(1).split('/')) {
+        if (/~(?:[^01]|$)/u.test(encoded))
+            return undefined;
+        tokens.push(encoded.replaceAll('~1', '/').replaceAll('~0', '~'));
+    }
+    return tokens;
+}
+export function tokensToPointer(tokens) {
+    return tokens.reduce((pointer, token) => appendPointer(pointer, token), '');
+}
+export function resolvePointer(root, tokens) {
+    let value = root;
+    for (const token of tokens) {
+        if (Array.isArray(value)) {
+            if (!/^(?:0|[1-9][0-9]*)$/u.test(token))
+                return undefined;
+            const index = Number(token);
+            if (!Number.isSafeInteger(index) || index >= value.length || !(index in value)) {
+                return undefined;
+            }
+            value = value[index];
+            continue;
+        }
+        if (!isJsonObject(value) || !Object.hasOwn(value, token))
+            return undefined;
+        value = value[token];
+    }
+    return value;
+}
+import { isValueObject as isJsonObject } from '../model/object.js';

package/dist/v1/language/value/syntax/walk.d.ts

@@ -0,0 +1,10 @@
+import type { JsonSchema } from '../model/schema.js';
+export interface SchemaLocation {
+    readonly schema: JsonSchema;
+    readonly pointer: string;
+    readonly depth: number;
+    readonly parentKeyword?: string;
+}
+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;

package/dist/v1/language/value/syntax/walk.js

@@ -0,0 +1,53 @@
+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 = '') {
+    const active = new Set();
+    function walk(current, currentPointer, depth, parentKeyword) {
+        if (typeof current === 'object' && current !== null) {
+            if (active.has(current))
+                return;
+            active.add(current);
+        }
+        try {
+            visit({ schema: current, pointer: currentPointer, depth, parentKeyword });
+            if (!isJsonObject(current))
+                return;
+            for (const [keyword, value] of Object.entries(current)) {
+                const keywordPointer = appendPointer(currentPointer, keyword);
+                if (SCHEMA_SINGLE_KEYWORDS.has(keyword) && isJsonSchema(value)) {
+                    walk(value, keywordPointer, depth + 1, keyword);
+                    continue;
+                }
+                if (SCHEMA_ARRAY_KEYWORDS.has(keyword) && Array.isArray(value)) {
+                    value.forEach((entry, index) => {
+                        if (isJsonSchema(entry)) {
+                            walk(entry, appendPointer(keywordPointer, index), depth + 1, keyword);
+                        }
+                    });
+                    continue;
+                }
+                if (SCHEMA_MAP_KEYWORDS.has(keyword) && isJsonObject(value)) {
+                    for (const [name, entry] of Object.entries(value)) {
+                        if (isJsonSchema(entry)) {
+                            walk(entry, appendPointer(keywordPointer, name), depth + 1, keyword);
+                        }
+                    }
+                }
+            }
+        }
+        finally {
+            if (typeof current === 'object' && current !== null)
+                active.delete(current);
+        }
+    }
+    walk(schema, pointer, 0);
+}
+export function collectSchemaPointers(schema) {
+    const pointers = new Set();
+    walkSchema(schema, ({ pointer }) => pointers.add(pointer));
+    return pointers;
+}
+export function isJsonSchema(value) {
+    return typeof value === 'boolean' || isJsonObject(value);
+}

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/admission/accept.js

@@ -0,0 +1,26 @@
+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 {
+        admitted = acceptJsonValue(input);
+    }
+    catch (error) {
+        if (error instanceof JsonBoundaryError) {
+            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 SchemaError(validation.diagnostics);
+    const accepted = canonicalDomainSchemaAfterValidation(structured).schema;
+    rememberDomainClosure(accepted, validation.context.dependencies.values());
+    return accepted;
+}

package/dist/v1/schema/analysis/class.d.ts

@@ -0,0 +1,41 @@
+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 { PropertyKey } from '../../addressing/index.js';
+export interface EffectiveField {
+    readonly identity: PropertyKey;
+    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: ClassRef;
+    readonly name: string;
+    readonly declaration: MethodDefinition;
+}
+export interface EffectiveData {
+    readonly identity: string;
+    readonly owner: ClassRef;
+    readonly declaration: DataDefinition;
+}
+export interface DefinitionAnalysis {
+    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 SchemaDiagnostic[];
+}
+export declare function analyzeDefinitions(environment: DomainResolutionContext): DefinitionAnalysisResult;

package/dist/v1/schema/analysis/class.js

@@ -0,0 +1,181 @@
+import { json } from '@astrale-os/kernel-dsl/value';
+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';
+const formatDefinitionRef = Key.of;
+export function analyzeDefinitions(environment) {
+    const diagnostics = [];
+    const result = new Map();
+    const visiting = new Set();
+    const analyze = (ref) => {
+        const key = definitionRefIndex(ref);
+        const cached = result.get(key);
+        if (cached !== undefined)
+            return cached;
+        if (visiting.has(key)) {
+            diagnostics.push(diagnostic('DV_CLASS_ACYCLIC', '', `Inheritance cycle reaches ${formatDefinitionRef(ref)}.`, formatDefinitionRef(ref)));
+            return undefined;
+        }
+        const resolved = environment.resolveAny(ref);
+        if (resolved === undefined)
+            return undefined;
+        visiting.add(key);
+        const declaration = resolved.declaration;
+        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 ${formatDefinitionRef(parent)} does not resolve.`, formatDefinitionRef(parent)));
+                return [];
+            }
+            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));
+        const data = mergeData(ref, declaration, parentAnalyses, diagnostics);
+        const methods = mergeMethods(ref, declaration, parentAnalyses, diagnostics);
+        const analysis = {
+            ref,
+            declaration,
+            properties,
+            ...(data === undefined ? {} : { data }),
+            methods,
+        };
+        result.set(key, analysis);
+        visiting.delete(key);
+        return analysis;
+    };
+    for (const resolved of environment.definitions.values()) {
+        analyze(resolved.ref);
+    }
+    return Object.freeze({ definitions: result, diagnostics: Object.freeze(diagnostics) });
+}
+function ownFields(owner, declaration) {
+    const result = new Map();
+    for (const [name, property] of Object.entries(declaration.properties)) {
+        const key = PropertyKey.of(owner, name);
+        result.set(key, {
+            identity: key,
+            owner,
+            name,
+            schema: property.schema,
+            required: property.required,
+            visibility: property.visibility,
+            ...(property.auto === undefined ? {} : { auto: property.auto }),
+        });
+    }
+    return result;
+}
+function mergeFields(inherited, own) {
+    const result = new Map();
+    for (const fields of inherited) {
+        for (const [key, field] of fields) {
+            if (!result.has(key))
+                result.set(key, field);
+        }
+    }
+    for (const [key, field] of own) {
+        result.set(key, field);
+    }
+    return result;
+}
+function mergeData(owner, declaration, parents, diagnostics) {
+    let effective;
+    for (const parent of parents) {
+        if (parent.data === undefined)
+            continue;
+        if (effective === undefined) {
+            effective = parent.data;
+            continue;
+        }
+        if (effective.identity !== parent.data.identity) {
+            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 ${formatDefinitionRef(effective.owner)}.`));
+    }
+    return {
+        identity: `${definitionRefIndex(owner)}\u0000data`,
+        owner,
+        declaration: own,
+    };
+}
+function mergeMethods(owner, declaration, parents, diagnostics) {
+    if (!('methods' in declaration))
+        return new Map();
+    const inherited = new Map();
+    for (const parent of parents) {
+        for (const [name, method] of parent.methods) {
+            const entries = inherited.get(name) ?? [];
+            if (!entries.some((entry) => entry.identity === method.identity))
+                entries.push(method);
+            inherited.set(name, entries);
+        }
+    }
+    const result = new Map();
+    for (const [name, entries] of inherited) {
+        if (entries.length === 1)
+            result.set(name, entries[0]);
+    }
+    for (const [name, ownMethod] of Object.entries(declaration.methods)) {
+        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 ${formatDefinitionRef(parent.owner)}.${name}.`));
+            }
+            if (!sameMethodSignature(ownMethod, parent.declaration)) {
+                diagnostics.push(diagnostic('DV_METHOD_COMPOSITION', '', `Method ${name} does not exactly preserve its inherited signature.`));
+            }
+            if (parent.declaration.inheritance !== 'abstract' &&
+                canonicalPolicy(parent.declaration.policy) !== canonicalPolicy(ownMethod.policy)) {
+                diagnostics.push(diagnostic('DV_METHOD_COMPOSITION', '', `Method ${name} changes an executable inherited Policy.`));
+            }
+        }
+        result.set(name, {
+            identity: `${definitionRefIndex(owner)}\u0000method\u0000${name}`,
+            owner,
+            name,
+            declaration: ownMethod,
+        });
+        inherited.delete(name);
+    }
+    for (const [name, entries] of inherited) {
+        if (entries.length > 1) {
+            diagnostics.push(diagnostic('DV_METHOD_COMPOSITION', '', `Inherited method ${name} is ambiguous and has no local override.`));
+        }
+    }
+    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.`));
+            }
+        }
+    }
+    return result;
+}
+function sameMethodSignature(left, right) {
+    return (json.serialize(canonicalizeValueSchema(left.input, 'callable-input')) ===
+        json.serialize(canonicalizeValueSchema(right.input, 'callable-input')) &&
+        canonicalMethodOutput(left) === canonicalMethodOutput(right) &&
+        left.auth === right.auth &&
+        left.static === right.static);
+}
+function canonicalMethodOutput(value) {
+    switch (value.output.mode) {
+        case 'value':
+            return `value:${json.serialize(canonicalizeValueSchema(value.output.schema, 'callable-output'))}`;
+        case 'stream':
+            return `stream:${json.serialize(canonicalizeValueSchema(value.output.item, 'callable-output'))}`;
+        case 'binary':
+            return 'binary';
+    }
+}
+function canonicalPolicy(value) {
+    return json.serialize(value === undefined ? null : normalizePolicyChecks(value));
+}

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

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

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

@@ -0,0 +1,3 @@
+import type { Revision } from '../../addressing/index.js';
+/** Content-address canonical DomainSchema bytes with the V1 revision algorithm. */
+export declare function digestDomainSchemaBytes(bytes: Uint8Array): Revision;

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

@@ -0,0 +1,5 @@
+import { digestRevisionBytes } from '../../addressing/revision.js';
+/** Content-address canonical DomainSchema bytes with the V1 revision algorithm. */
+export function digestDomainSchemaBytes(bytes) {
+    return digestRevisionBytes(bytes);
+}

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

@@ -0,0 +1,5 @@
+import { normalizeDomainSchema } from '../normalization/domain.js';
+/** Produce the deterministic semantic document consumed by canonical JSON serialization. */
+export function canonicalizeDomainSchema(schema) {
+    return normalizeDomainSchema(schema);
+}

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

@@ -0,0 +1 @@
+export declare function deepFreeze<T>(value: T): Readonly<T>;

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

@@ -0,0 +1,9 @@
+export function deepFreeze(value) {
+    if (value === null || typeof value !== 'object' || Object.isFrozen(value)) {
+        return value;
+    }
+    for (const nested of Object.values(value)) {
+        deepFreeze(nested);
+    }
+    return Object.freeze(value);
+}

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

@@ -0,0 +1,11 @@
+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;
+    readonly revision: Revision;
+}
+export declare function canonicalDomainSchema(value: DomainSchema): CanonicalDomainSchema;
+/** 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;

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

@@ -0,0 +1,17 @@
+import { json } from '@astrale-os/kernel-dsl/value';
+import { asDomainSchema } from '../model/schema.js';
+import { digestDomainSchemaBytes } from './domain.digest.js';
+import { canonicalizeDomainSchema } from './domain.js';
+export function canonicalDomainSchema(value) {
+    return canonicalDomainSchemaAfterValidation(value);
+}
+/** Internal acceptance seam. The caller must establish whole-Domain validity first. */
+export function canonicalDomainSchemaAfterValidation(value) {
+    const schema = asDomainSchema(canonicalizeDomainSchema(value));
+    const bytes = json.encode(schema);
+    const revision = digestDomainSchemaBytes(bytes);
+    return Object.freeze({ schema, bytes, revision });
+}
+export function revisionOfDomainSchema(schema) {
+    return canonicalDomainSchema(schema).revision;
+}

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

@@ -0,0 +1,5 @@
+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;

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

@@ -0,0 +1,21 @@
+import { json } from '@astrale-os/kernel-dsl/value';
+import { acceptDomainSchema } from '../admission/accept.js';
+import { emptyDomainSchemaLookup } from '../dependency/lookup.js';
+import { SchemaError, diagnostic } from '../diagnostic.js';
+export function decodeDomainSchema(input, lookup = emptyDomainSchemaLookup()) {
+    try {
+        return acceptDomainSchema(json.decode(input), lookup);
+    }
+    catch (error) {
+        if (error instanceof json.DecodeError) {
+            throw new SchemaError([diagnostic('DV_JSON_VALUE', '', error.message)]);
+        }
+        throw error;
+    }
+}
+export function serializeDomainSchema(schema) {
+    return json.serialize(schema);
+}
+export function encodeDomainSchema(schema) {
+    return json.encode(schema);
+}