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

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

@@ -30,27 +30,25 @@ export function validateDefinitions(environment, analysis) {
         validateFacet(environment, declaration, pointer, diagnostics);
         validateParents(environment, ref, declaration.kind, declaration.extends, diagnostics);
         if (declaration.kind === 'edge') {
-            validateEdgeContract(environment, ref, declaration, diagnostics);
+            validateEdgeContract(environment, ref, declaration, pointer, diagnostics);
             scope ??= lifetimeScope([...environment.definitions.values()].map(({ declaration }) => declaration));
             validateEdgeLifetimes(scope, ref, declaration, pointer, diagnostics);
+            validateEdgeClassComposition(environment, ref, declaration, pointer, diagnostics);
         }
         validateUniqueProperties(environment, analysis, ref, declaration, pointer, diagnostics);
     }
-    validateEdgeClassComposition(environment, diagnostics);
     return Object.freeze(diagnostics);
 }
 function validateFacet(environment, declaration, pointer, diagnostics) {
     const valueRegistry = createValueSchemaRegistry(environment);
     for (const [name, property] of Object.entries(declaration.properties)) {
         const propertyPointer = `${pointer}/properties/${escapePointerToken(name)}`;
+        // The structure refuses a blob on an Edge Property and a State Property on an Edge Class.
         if (isBlobValueSchema(property.schema) &&
-            (declaration.kind !== 'node' || property.auto !== undefined || property.state !== undefined)) {
+            (property.auto !== undefined || property.state !== undefined)) {
             diagnostics.push(diagnostic('DV_VALUE_SCHEMA', `${propertyPointer}/schema/x-astrale-value-kind`, 'Blob values are allowed only on non-automatic, non-state Node properties.'));
         }
         if (property.state !== undefined) {
-            if (declaration.kind !== 'node') {
-                diagnostics.push(diagnostic('DV_PROPERTY_STATE', `${propertyPointer}/state`, 'A State Property may be declared only on a Node Class.'));
-            }
             try {
                 const topology = admitStateTopology(property.state);
                 const expected = Object.keys(topology.transitions).sort();
@@ -122,23 +120,26 @@ function validateParents(environment, owner, ownerKind, parents, diagnostics) {
         }
     }
 }
-function validateEdgeContract(environment, owner, declaration, diagnostics) {
-    const endpoints = declaration.orientation === 'directed'
+function validateEdgeContract(environment, owner, declaration, pointer, diagnostics) {
+    const directed = declaration.orientation === 'directed';
+    const endpoints = directed
         ? [declaration.endpoints.source, declaration.endpoints.target]
         : declaration.endpoints;
+    const keys = directed ? ['source', 'target'] : ['0', '1'];
     if (endpoints[0].role === endpoints[1].role) {
-        diagnostics.push(diagnostic('DV_EDGE_ROLE', '', `${formatDefinitionRef(owner)} has equal endpoint roles.`));
-    }
-    const counts = declaration.orientation === 'directed'
-        ? [declaration.endpoints.source.outgoing, declaration.endpoints.target.incoming]
-        : [declaration.endpoints[0].incident, declaration.endpoints[1].incident];
-    validateEndpoint(environment, owner, endpoints[0], counts[0], declaration.orientation === 'directed' ? 'source' : 'first endpoint', diagnostics);
-    validateEndpoint(environment, owner, endpoints[1], counts[1], declaration.orientation === 'directed' ? 'target' : 'second endpoint', diagnostics);
-    if (declaration.orientation === 'undirected') {
-        if (declaration.constraints.acyclic === true) {
-            diagnostics.push(diagnostic('DV_EDGE_CONSTRAINT', '', 'acyclic is valid only for directed Edge contracts.'));
-        }
+        diagnostics.push(diagnostic('DV_EDGE_ROLE', `${pointer}/endpoints/${keys[1]}/role`, `${formatDefinitionRef(owner)} has equal endpoint roles.`));
     }
+    const counts = directed
+        ? [
+            ['outgoing', declaration.endpoints.source.outgoing],
+            ['incoming', declaration.endpoints.target.incoming],
+        ]
+        : [
+            ['incident', declaration.endpoints[0].incident],
+            ['incident', declaration.endpoints[1].incident],
+        ];
+    validateEndpoint(environment, owner, endpoints[0], counts[0], directed ? 'source' : 'first endpoint', `${pointer}/endpoints/${keys[0]}`, diagnostics);
+    validateEndpoint(environment, owner, endpoints[1], counts[1], directed ? 'target' : 'second endpoint', `${pointer}/endpoints/${keys[1]}`, diagnostics);
 }
 /**
  * Each Property a key tuple names is one of the Class's own or inherited Properties, and keyable:
@@ -190,25 +191,20 @@ function validateUniqueProperties(environment, analysis, owner, declaration, poi
             check(field.property, `${pointer}/unique/${t}/${f}/property`);
     }));
 }
-function validateEndpoint(environment, owner, endpoint, count, side, diagnostics) {
+// The structure refuses a repeated accepted Class before semantics: `accepts` is a set.
+function validateEndpoint(environment, owner, endpoint, [countField, count], side, pointer, diagnostics) {
     // An Edge Class binds only the Nodes of its Domain and its dependents: it cannot oblige the
     // Nodes of a Class another Domain owns to carry its Edges.
     const foreign = endpoint.accepts.find((ref) => ref.origin !== owner.origin);
     if (foreign !== undefined && (count === '1' || count === '1..*')) {
-        diagnostics.push(diagnostic('DV_EDGE_FOREIGN_MINIMUM', '', `${formatDefinitionRef(owner)} ${side} accepts ${formatDefinitionRef(foreign)} of another Domain and cannot require ${count} Edges.`));
+        diagnostics.push(diagnostic('DV_EDGE_FOREIGN_MINIMUM', `${pointer}/${countField}`, `${formatDefinitionRef(owner)} ${side} accepts ${formatDefinitionRef(foreign)} of another Domain and cannot require ${count} Edges.`));
     }
-    const seen = new Set();
-    for (const ref of endpoint.accepts) {
-        const key = definitionRefIndex(ref);
-        if (seen.has(key)) {
-            diagnostics.push(diagnostic('DV_EDGE_ACCEPTS', '', `${formatDefinitionRef(owner)} ${side} repeats ${formatDefinitionRef(ref)}.`));
-        }
-        seen.add(key);
+    for (const [index, ref] of endpoint.accepts.entries()) {
         const resolved = environment.resolve(ref);
         if (resolved === undefined ||
             resolved.ref.kind !== 'class' ||
             resolved.declaration.kind !== 'node') {
-            diagnostics.push(diagnostic('DV_EDGE_ACCEPTS', '', `${formatDefinitionRef(owner)} ${side} ref ${formatDefinitionRef(ref)} does not resolve to a Node Class.`));
+            diagnostics.push(diagnostic('DV_EDGE_ACCEPTS', `${pointer}/accepts/${index}`, `${formatDefinitionRef(owner)} ${side} ref ${formatDefinitionRef(ref)} does not resolve to a Node Class.`));
         }
     }
 }
@@ -225,22 +221,18 @@ function validateEdgeLifetimes(scope, owner, declaration, pointer, diagnostics)
         diagnostics.push(diagnostic('DV_EDGE_LIFETIME', `${pointer}/endpoints/${keys[index]}/onDelete`, `${formatDefinitionRef(owner)} ${sides[index]} ${reason}`));
     }
 }
-/** Edge inheritance is refinement, not a second interface composition mechanism. */
-function validateEdgeClassComposition(environment, diagnostics) {
-    for (const resolved of environment.definitions.values()) {
-        if (resolved.ref.kind !== 'class' || resolved.declaration.kind !== 'edge')
+/**
+ * Edge inheritance is refinement, not a second interface composition mechanism. A dependency
+ * Edge Class was judged against this same exact closure when it was accepted.
+ */
+function validateEdgeClassComposition(environment, owner, child, pointer, diagnostics) {
+    for (const [index, parentRef] of child.extends.entries()) {
+        const parent = environment.resolveAny(parentRef);
+        if (parent === undefined || parent.ref.kind !== 'class' || parent.declaration.kind !== 'edge') {
             continue;
-        const child = resolved.declaration;
-        for (const parentRef of child.extends) {
-            const parent = environment.resolveAny(parentRef);
-            if (parent === undefined ||
-                parent.ref.kind !== 'class' ||
-                parent.declaration.kind !== 'edge') {
-                continue;
-            }
-            if (!edgeContractRefines(environment, child, parent.declaration)) {
-                diagnostics.push(diagnostic('DV_EDGE_CLASS_COMPOSITION', '', `${formatDefinitionRef(resolved.ref)} does not safely refine ${formatDefinitionRef(parentRef)}.`));
-            }
+        }
+        if (!edgeContractRefines(environment, child, parent.declaration)) {
+            diagnostics.push(diagnostic('DV_EDGE_CLASS_COMPOSITION', `${pointer}/extends/${index}`, `${formatDefinitionRef(owner)} does not safely refine ${formatDefinitionRef(parentRef)}.`));
         }
     }
 }

package/dist/v1/schema/validation/core.js

@@ -3,11 +3,11 @@ import { Key } from '../../addressing/key.js';
 import { compareUnicode, definitionRefIndex } from '../../addressing/ordering.js';
 import { isMethodExecutable } from '../../language/callable/executable.js';
 import { coveringEdgeUniqueTuples, coveringNodeUniqueTuples, edgeUniqueKeys, nodeUniqueKeys, } from '../../language/class/unique.js';
-import { checkCoreEdgeSet, checkHeldKeys, coreEndpointsSatisfy, } from '../../language/core/facts.js';
+import { checkCoreEdgeSet, checkHeldKeys, coreEndpointsSatisfy, DOMAIN_ENDPOINT_CLASS, } from '../../language/core/facts.js';
 import { policyObjectKey, policyObjectOrigin, projectedMemberClass, } from '../../language/policy/model/policy.js';
 import { validateJsonInstance } from '../../language/value/evaluate/validate.js';
 import { escapePointerToken } from '../../language/value/syntax/pointer.js';
-import { diagnostic } from '../diagnostic.js';
+import { diagnostic, valueDiagnostic } from '../diagnostic.js';
 import { classSatisfies } from './class.js';
 const formatDefinitionRef = Key.of;
 export function validateCore(environment, analysis, registry) {
@@ -83,7 +83,9 @@ function resolveCoreEdges(environment, analysis, registry, nodesByRef, diagnosti
             continue;
         const endpointsSatisfy = coreEndpointsSatisfy(declaration, source, target, (endpoint, accepts) => endpointSatisfies(environment, endpoint, accepts));
         if (!endpointsSatisfy) {
-            diagnostics.push(diagnostic('DV_CORE_EDGE_CLASS', pointer, `Core Edge endpoints do not satisfy ${formatDefinitionRef(edge.class)}.`, formatDefinitionRef(edge.class)));
+            diagnostics.push(diagnostic('DV_CORE_EDGE_CLASS', pointer, `Core Edge endpoints do not satisfy ${formatDefinitionRef(edge.class)}.${source.kind === 'domain' || target.kind === 'domain'
+                ? ` The owning Domain is a ${formatDefinitionRef(DOMAIN_ENDPOINT_CLASS)} Node: the endpoint that names it must accept that Class or one it extends.`
+                : ''}`, formatDefinitionRef(edge.class)));
             continue;
         }
         edges.push({ source, target, declaration, value: edge, pointer });
@@ -92,7 +94,7 @@ function resolveCoreEdges(environment, analysis, registry, nodesByRef, diagnosti
 }
 function resolveCoreEndpoint(environment, ref, pointer, nodesByRef, diagnostics) {
     if (ref.kind === 'domain')
-        return { kind: 'domain', ref, key: 'domain' };
+        return { kind: 'domain', ref, key: 'domain', classRef: DOMAIN_ENDPOINT_CLASS };
     const undeclared = () => {
         const key = policyObjectKey(ref);
         diagnostics.push(diagnostic('DV_CORE_REF', pointer, `Core endpoint ${key} does not name a declared local Definition.`, key));
@@ -122,10 +124,14 @@ function declaresProjectedMember(environment, ref) {
         return Object.hasOwn(candidate.policies, ref.name);
     return Object.hasOwn(candidate.views, ref.name);
 }
+/**
+ * A Core Node is admitted by its own authored Class, a projected member by the Kernel declaration
+ * Class it projects as, and the owning Domain by the Kernel `Domain` Class of its Node: the write
+ * that projects the Edge binds exactly that Node, so an Edge Class that does not accept it can
+ * never be installed (DV-CORE-EDGE-CLASS).
+ */
 function endpointSatisfies(environment, endpoint, accepts) {
-    // The owning Domain is a graph-projection identity, not a Definition declared by this DSL.
-    // Its concrete Class contract is therefore admitted by the projection compiler.
-    return endpoint.kind === 'domain' || classSatisfies(environment, endpoint.classRef, accepts);
+    return classSatisfies(environment, endpoint.classRef, accepts);
 }
 function validateCreationProperties(definition, properties, registry, code, pointer, diagnostics) {
     const schema = {
@@ -139,8 +145,8 @@ function validateCreationProperties(definition, properties, registry, code, poin
             .sort(compareUnicode),
         additionalProperties: false,
     };
-    for (const failure of validateJsonInstance(schema, properties, registry, pointer)) {
-        diagnostics.push(diagnostic(code, failure.pointer, failure.message, failure.ref));
+    for (const refusal of validateJsonInstance(schema, properties, registry, pointer)) {
+        diagnostics.push(valueDiagnostic(code, refusal));
     }
 }
 function validateCoreEdgeSet(environment, edges, nodesByRef, diagnostics) {
@@ -181,11 +187,11 @@ function validateCoreEdgeSet(environment, edges, nodesByRef, diagnostics) {
         report: (issue) => diagnostics.push(coreEdgeDiagnostic(issue)),
     });
 }
-/** A projected member's degree is reported at the Edge that names it. */
+/** A projected member's degree, and the owning Domain's, is reported at the Edge that names it. */
 function factEndpoint(endpoint, pointer) {
-    return endpoint.kind === 'member'
-        ? { key: endpoint.key, member: { class: endpoint.classRef, pointer } }
-        : endpoint;
+    return endpoint.kind === 'core'
+        ? endpoint
+        : { key: endpoint.key, member: { class: endpoint.classRef, pointer } };
 }
 function coreEdgeDiagnostic(issue) {
     switch (issue.kind) {

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

@@ -2,7 +2,7 @@ import { orderAndDeduplicate } from '../../language/validation/diagnostic.js';
 import { analyzeDefinitions } from '../analysis/class.js';
 import { buildDomainResolutionContext } from '../resolution/context.js';
 import { createValueSchemaRegistry } from '../resolution/value.registry.js';
-import { validateCallables } from './callable.js';
+import { validateContracts } from './callable.js';
 import { validateDefinitions } from './class.js';
 import { validateCore } from './core.js';
 import { validatePolicies } from './policy/validate.js';
@@ -16,7 +16,7 @@ export function validateDomainSchemaSemantics(schema, lookup) {
         ...context.diagnostics,
         ...validateEmbeddedValueSchemas(schema, registry),
         ...validateDefinitions(context, analysis),
-        ...validateCallables(schema),
+        ...validateContracts(schema, registry),
         ...validatePolicies(context, analysis),
         ...validateViews(context),
         ...validateCore(context, analysis, registry),

package/dist/v1/schema/validation/domain.json-schema.d.ts

@@ -0,0 +1,15 @@
+import { type core as zodCore } from 'zod';
+export type JsonSchemaDocument = zodCore.JSONSchema.JSONSchema;
+/**
+ * The JSON Schema of an authored Domain schema document, rendered from the structure the Kernel
+ * enforces. Zod derives what it reads; `documentJsonSchema` states each refinement it cannot read,
+ * or names the rule JSON Schema cannot state. A refinement neither stated nor named fails the
+ * rendering, so that no check of the structure is dropped silently. Every value schema is in the
+ * published dialect and states the profile rules JSON Schema can state; the others are named.
+ */
+export declare function domainSchemaJsonSchema(): JsonSchemaDocument;
+/**
+ * Every refinement and custom part of the structure carries its statement in `documentJsonSchema`:
+ * the keywords that state it, or its named rule. Only parts zod renders take part.
+ */
+export declare function assertChecksStated(schema: zodCore.$ZodType, visited?: Set<zodCore.$ZodType<unknown, unknown, zodCore.$ZodTypeInternals<unknown, unknown>>>): void;

package/dist/v1/schema/validation/domain.json-schema.js

@@ -0,0 +1,183 @@
+import { toJSONSchema } from 'zod';
+import { VALUE_RULES } from '../../language/validation/rule.js';
+import { escapePointerToken } from '../../language/value/syntax/pointer.js';
+import { RULES } from '../rule.js';
+import { domainSchemaStructure, documentJsonSchema, structureRules, } from './domain.structure.js';
+import { jsonValueJsonSchema, jsonValueRules } from './json.json-schema.js';
+import { valueSchemaJsonSchema, valueSchemaRules, } from './value.json-schema.js';
+/** The checks the published document names, each with its stage and the positions it constrains. */
+const namedRules = { ...structureRules, ...jsonValueRules, ...valueSchemaRules };
+/**
+ * The JSON Schema of an authored Domain schema document, rendered from the structure the Kernel
+ * enforces. Zod derives what it reads; `documentJsonSchema` states each refinement it cannot read,
+ * or names the rule JSON Schema cannot state. A refinement neither stated nor named fails the
+ * rendering, so that no check of the structure is dropped silently. Every value schema is in the
+ * published dialect and states the profile rules JSON Schema can state; the others are named.
+ */
+export function domainSchemaJsonSchema() {
+    assertChecksStated(domainSchemaStructure);
+    const { $schema, $defs = {}, ...root } = toJSONSchema(domainSchemaStructure, {
+        metadata: documentJsonSchema,
+        io: 'input',
+        // Every opaque part is stated or named, as `assertChecksStated` proved.
+        unrepresentable: 'any',
+        override: ({ zodSchema, jsonSchema: rendered }) => {
+            // Zod states the items of a tuple but not its length.
+            const def = zodSchema._zod.def;
+            if (def.type !== 'tuple')
+                return;
+            if (def.rest !== null || def.items.some((item) => item._zod.optin === 'optional')) {
+                throw new Error('A tuple of the structure has a fixed length.');
+            }
+            rendered.minItems = def.items.length;
+            rendered.maxItems = def.items.length;
+        },
+    });
+    const unnamed = Object.keys($defs).filter((name) => name.startsWith('__schema'));
+    if (unnamed.length > 0) {
+        throw new Error(`Every shared part of the structure is named: ${unnamed.join(', ')} is not.`);
+    }
+    const json = jsonValueJsonSchema();
+    const values = valueSchemaJsonSchema();
+    const valueSchema = $defs['value-schema'];
+    const nodeProperty = $defs['node-property-definition'];
+    if (root.allOf !== undefined ||
+        valueSchema === undefined ||
+        nodeProperty === undefined ||
+        valueSchema.allOf !== undefined ||
+        nodeProperty.allOf !== undefined ||
+        [...Object.keys(json.definitions), ...Object.keys(values.definitions)].some((name) => name in $defs)) {
+        throw new Error('Portable JSON extends the root, and the value language the value-schema and Node Property definitions.');
+    }
+    const definitions = Object.fromEntries(Object.entries({
+        ...$defs,
+        'value-schema': { ...valueSchema, allOf: [...values.root] },
+        'node-property-definition': { ...nodeProperty, allOf: [values.nodeProperty] },
+        ...json.definitions,
+        ...values.definitions,
+    }).sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0)));
+    const document = { ...root, allOf: [json.root] };
+    const positions = rulePositions({ ...document, $defs: definitions });
+    return {
+        $schema,
+        $id: 'https://schemas.astrale.ai/dsl/v1/domain-schema',
+        title: 'V1 DomainSchema',
+        $comment: 'Generated from the structure the Kernel enforces; value schemas are in the dialect https://schemas.astrale.ai/dsl/v1/value-schema. Each check JSON Schema cannot state is named under x-astrale-rules, with its stage and the positions it constrains.',
+        'x-astrale-rules': Object.fromEntries(Object.keys(namedRules).sort().map((name) => {
+            const { statement, ...rule } = namedRules[name];
+            const named = { ...rule, stage: stageOf(rule), statement };
+            return [name, { ...named, positions: positions.get(name) ?? [] }];
+        })),
+        ...document,
+        $defs: definitions,
+    };
+}
+/**
+ * What a named rule reads, in the stages of `schema.RULES`: its code's, or for a value code the
+ * value rule's own, which reads the document alone unless it reads the context.
+ */
+function stageOf(rule) {
+    if (rule.valueCode === undefined)
+        return RULES[rule.code].stage;
+    return VALUE_RULES[rule.valueCode].stage === 'context' ? 'context' : 'rule';
+}
+/**
+ * Every refinement and custom part of the structure carries its statement in `documentJsonSchema`:
+ * the keywords that state it, or its named rule. Only parts zod renders take part.
+ */
+export function assertChecksStated(schema, visited = new Set()) {
+    if (visited.has(schema))
+        return;
+    visited.add(schema);
+    const part = schema;
+    const def = part._zod.def;
+    for (const check of def.checks ?? []) {
+        if (check._zod.def.check === 'custom' && !isStated(schema, check)) {
+            throw new Error('A refinement of the structure is neither stated nor named.');
+        }
+    }
+    switch (def.type) {
+        case 'boolean':
+        case 'enum':
+        case 'literal':
+        case 'null':
+        case 'number':
+        case 'string':
+            return;
+        case 'custom':
+            if (statementOf(schema) === undefined) {
+                throw new Error('A custom part of the structure is neither stated nor named.');
+            }
+            return;
+        case 'array':
+            return assertChecksStated(def.element, visited);
+        case 'lazy':
+            return assertChecksStated(part._zod.innerType, visited);
+        case 'object':
+            for (const field of Object.values(def.shape))
+                assertChecksStated(field, visited);
+            return;
+        case 'optional':
+            return assertChecksStated(def.innerType, visited);
+        case 'record':
+            assertChecksStated(def.keyType, visited);
+            return assertChecksStated(def.valueType, visited);
+        case 'tuple':
+            for (const item of def.items)
+                assertChecksStated(item, visited);
+            return;
+        case 'union':
+            for (const option of def.options)
+                assertChecksStated(option, visited);
+            return;
+        default:
+            throw new Error(`The structure has a ${def.type} part, which this rendering does not read.`);
+    }
+}
+/** A check is stated where it was added, or on a refinement of that schema. */
+function isStated(schema, check) {
+    for (let current = schema; current !== undefined;) {
+        if (statementOf(current) !== undefined)
+            return true;
+        const parent = current._zod.parent;
+        if (parent?._zod.def.checks?.includes(check) !== true)
+            return false;
+        current = parent;
+    }
+    return false;
+}
+/** The keywords or rule registered on this very schema, which `get` would inherit from a parent. */
+function statementOf(schema) {
+    const { id: _id, description: _description, ...statement } = documentJsonSchema._map.get(schema) ?? {};
+    return Object.keys(statement).length > 0 ? statement : undefined;
+}
+/**
+ * Where each rule applies, as JSON Pointers into the document. The marker a named check leaves is
+ * removed; every `maxLength` counts UTF-16 code units, the length the structure measures.
+ */
+function rulePositions(document) {
+    const positions = new Map();
+    const note = (rule, pointer) => positions.set(rule, [...(positions.get(rule) ?? []), `#${pointer}`]);
+    const visit = (value, pointer) => {
+        if (Array.isArray(value)) {
+            value.forEach((item, index) => visit(item, `${pointer}/${index}`));
+            return;
+        }
+        if (value === null || typeof value !== 'object')
+            return;
+        const schema = value;
+        const rules = schema['x-astrale-rule'];
+        if (rules !== undefined) {
+            for (const rule of [rules].flat())
+                note(rule, pointer);
+            delete schema['x-astrale-rule'];
+        }
+        if (typeof schema.maxLength === 'number')
+            note('length-in-utf16-code-units', pointer);
+        for (const [key, entry] of Object.entries(schema)) {
+            visit(entry, `${pointer}/${escapePointerToken(key)}`);
+        }
+    };
+    visit(document, '');
+    return positions;
+}

package/dist/v1/schema/validation/domain.route.d.ts

@@ -1,4 +1,9 @@
-import type { Value as JsonValue } from '@astrale-os/kernel-dsl/value';
+import { type Value as JsonValue } from '@astrale-os/kernel-dsl/value';
 import type { DomainSchemaIR } from '../model/schema.js';
+/**
+ * Read an unknown value as a Domain Schema document of its exact language contract: portable JSON
+ * (`DV_JSON_VALUE`), then the structure of its format and version. Throws `SchemaError`.
+ */
+export declare function structureDomainSchema(input: unknown): DomainSchemaIR;
 /** Select the exact Domain language contract before entering its structural grammar. */
 export declare function routeDomainSchema(input: JsonValue): DomainSchemaIR;

package/dist/v1/schema/validation/domain.route.js

@@ -1,9 +1,27 @@
+import { accept as acceptJsonValue, BoundaryError as JsonBoundaryError, } from '@astrale-os/kernel-dsl/value';
 import { SchemaError, diagnostic } from '../diagnostic.js';
 import { DOMAIN_FORMAT, DOMAIN_VERSION } from '../model/format.js';
 import { parseDomainSchemaStructure } from './domain.structure.js';
 const decoders = new Map([
     [DOMAIN_FORMAT, new Map([[DOMAIN_VERSION, parseDomainSchemaStructure]])],
 ]);
+/**
+ * Read an unknown value as a Domain Schema document of its exact language contract: portable JSON
+ * (`DV_JSON_VALUE`), then the structure of its format and version. Throws `SchemaError`.
+ */
+export function structureDomainSchema(input) {
+    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;
+    }
+    return routeDomainSchema(admitted);
+}
 /** Select the exact Domain language contract before entering its structural grammar. */
 export function routeDomainSchema(input) {
     if (!isJsonObject(input))