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

package/dist/v1/language/value/regexp/matcher.js

@@ -0,0 +1,207 @@
+/**
+ * Load the portable counted-run or Thompson NFA executor for search and whole-string matching.
+ * Scratch belongs to one invocation: no match-result cache, shared mutable cursor or DFA expansion.
+ */
+export function loadPattern(pattern) {
+    if ('runs' in pattern)
+        return loadRuns(pattern);
+    const states = pattern.states;
+    const start = initialFrontier(pattern);
+    const run = (input, search) => {
+        if (input.length === 0)
+            return start.accepting;
+        if (search && start.accepting)
+            return true;
+        const resolve = executionStates(states);
+        // Initial frontier entries consume characters, so none can be a dead conduit cycle.
+        const initial = start.frontier.map((index) => resolve(index));
+        let active = [...initial];
+        let next = [];
+        const pending = [];
+        let activeCount = start.frontier.length;
+        let nextCount = 0;
+        let epoch = 0;
+        let accepting = false;
+        function add(destination) {
+            const seed = resolve(destination);
+            if (seed === null || seed.epoch === epoch)
+                return;
+            let count = 1;
+            pending[0] = seed;
+            seed.epoch = epoch;
+            while (count > 0) {
+                const entry = pending[--count];
+                const state = entry.state;
+                if (state.accepting === true)
+                    accepting = true;
+                if (state.transitions.length > 0)
+                    next[nextCount++] = entry;
+                for (const destination of state.epsilon) {
+                    const target = resolve(destination);
+                    if (target === null || target.epoch === epoch)
+                        continue;
+                    target.epoch = epoch;
+                    pending[count++] = target;
+                }
+            }
+        }
+        for (const character of input) {
+            if (!search && activeCount === 0)
+                return false;
+            epoch++;
+            nextCount = 0;
+            accepting = false;
+            const scalar = character.codePointAt(0);
+            for (let index = 0; index < activeCount; index++) {
+                for (const transition of active[index].state.transitions) {
+                    for (const range of transition.ranges) {
+                        if (scalar < range[0] || scalar > range[1])
+                            continue;
+                        add(transition.to);
+                        break;
+                    }
+                }
+            }
+            if (search) {
+                if (accepting)
+                    return true;
+                // The complete initial epsilon closure is already known; do not traverse it again.
+                for (const entry of initial) {
+                    if (entry.epoch === epoch)
+                        continue;
+                    entry.epoch = epoch;
+                    next[nextCount++] = entry;
+                }
+            }
+            const previous = active;
+            active = next;
+            next = previous;
+            activeCount = nextCount;
+        }
+        return accepting;
+    };
+    return Object.freeze({
+        test: (input) => run(input, true),
+        matches: (input) => run(input, false),
+    });
+}
+function loadRuns(pattern) {
+    const runs = pattern.runs;
+    const run = (input, search) => {
+        if (search && runs.length === 1) {
+            const scalarRun = runs[0];
+            if (scalarRun.minimum === 0)
+                return true;
+            let count = 0;
+            for (const character of input) {
+                count = includesScalar(scalarRun.ranges, character.codePointAt(0)) ? count + 1 : 0;
+                if (count >= scalarRun.minimum)
+                    return true;
+            }
+            return false;
+        }
+        let start = 0;
+        do {
+            let offset = start;
+            let accepted = true;
+            for (let index = 0; index < runs.length; index++) {
+                const scalarRun = runs[index];
+                const maximum = search && index === runs.length - 1 ? scalarRun.minimum : (scalarRun.maximum ?? Infinity);
+                let count = 0;
+                while (count < maximum && offset < input.length) {
+                    const scalar = input.codePointAt(offset);
+                    if (!includesScalar(scalarRun.ranges, scalar))
+                        break;
+                    offset += scalar > 0xffff ? 2 : 1;
+                    count++;
+                }
+                if (count < scalarRun.minimum) {
+                    accepted = false;
+                    break;
+                }
+            }
+            if (accepted && (search || offset === input.length))
+                return true;
+            if (!search || start === input.length)
+                return false;
+            start += input.codePointAt(start) > 0xffff ? 2 : 1;
+        } while (start <= input.length);
+        return false;
+    };
+    return Object.freeze({
+        test: (input) => run(input, true),
+        matches: (input) => run(input, false),
+    });
+}
+function includesScalar(ranges, scalar) {
+    if (ranges.length < 8) {
+        for (const range of ranges) {
+            if (scalar >= range[0] && scalar <= range[1])
+                return true;
+        }
+        return false;
+    }
+    let low = 0;
+    let high = ranges.length - 1;
+    while (low <= high) {
+        const middle = (low + high) >>> 1;
+        const range = ranges[middle];
+        if (scalar < range[0])
+            high = middle - 1;
+        else if (scalar > range[1])
+            low = middle + 1;
+        else
+            return true;
+    }
+    return false;
+}
+function initialFrontier(pattern) {
+    const start = pattern.start;
+    const seen = new Set([start]);
+    const pending = [start];
+    const frontier = [];
+    let accepting = false;
+    while (pending.length > 0) {
+        const index = pending.pop();
+        const state = pattern.states[index];
+        if (state.accepting === true)
+            accepting = true;
+        if (state.transitions.length > 0)
+            frontier.push(index);
+        for (const target of state.epsilon) {
+            if (seen.has(target))
+                continue;
+            seen.add(target);
+            pending.push(target);
+        }
+    }
+    return { frontier: Object.freeze(frontier), accepting };
+}
+/** Resolve only visited conduits, once within this invocation; never retain cross-call state. */
+function executionStates(states) {
+    const destinations = new Map();
+    return (index) => {
+        const known = destinations.get(index);
+        if (known !== undefined)
+            return known;
+        const path = [];
+        let current = index;
+        let destination = destinations.get(current);
+        while (destination === undefined) {
+            const state = states[current];
+            if (state.accepting === true || state.transitions.length > 0 || state.epsilon.length !== 1) {
+                destination = { state, epoch: 0 };
+                destinations.set(current, destination);
+                break;
+            }
+            // A revisit before resolving the path is a dead, epsilon-only cycle.
+            destinations.set(current, null);
+            path.push(current);
+            current = state.epsilon[0];
+            destination = destinations.get(current);
+        }
+        for (const member of path)
+            destinations.set(member, destination);
+        return destination;
+    };
+}

package/dist/v1/language/value/regexp/pattern.d.ts

@@ -0,0 +1,2 @@
+/** Lowers one admitted I-Regexp source into the pattern syntax used by the engine. */
+export declare function lowerIRegexpPattern(pattern: string): string;

package/dist/v1/language/value/regexp/pattern.js

@@ -0,0 +1,38 @@
+/** Lowers one admitted I-Regexp source into the pattern syntax used by the engine. */
+export function lowerIRegexpPattern(pattern) {
+    let result = '';
+    let escaped = false;
+    let characterClass = false;
+    for (const character of Array.from(pattern)) {
+        if (escaped) {
+            result += character;
+            escaped = false;
+            continue;
+        }
+        if (character === '\\') {
+            result += character;
+            escaped = true;
+            continue;
+        }
+        if (character === '[') {
+            characterClass = true;
+            result += character;
+            continue;
+        }
+        if (character === ']') {
+            characterClass = false;
+            result += character;
+            continue;
+        }
+        if (!characterClass && character === '.') {
+            result += '[^\\n\\r]';
+            continue;
+        }
+        if (!characterClass && (character === '^' || character === '$')) {
+            result += `\\${character}`;
+            continue;
+        }
+        result += character;
+    }
+    return result;
+}

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

@@ -0,0 +1,2 @@
+/** Complete RFC 9485 syntax admission through the same AST consumed by compilation. */
+export declare function isIRegexp(source: string): boolean;

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

@@ -0,0 +1,5 @@
+import { parseIRegexp } from './ast.js';
+/** Complete RFC 9485 syntax admission through the same AST consumed by compilation. */
+export function isIRegexp(source) {
+    return parseIRegexp(source) !== undefined;
+}

package/dist/v1/language/value/syntax/full-match.d.ts

@@ -0,0 +1,6 @@
+import type { $ZodCheck } from 'zod/v4/core';
+/** Zod check whose exact whole-string I-Regexp meaning is serialized by the V1 compiler. */
+export type FullMatch = $ZodCheck<string>;
+export declare function fullMatch(source: string): FullMatch;
+/** Compiler-private recognition of checks created by the Schema-owned fullMatch operation. */
+export declare function fullMatchSource(check: unknown): string | undefined;

package/dist/v1/language/value/syntax/full-match.js

@@ -0,0 +1,20 @@
+import { refine } from 'zod';
+import { compilePattern } from '../regexp/compile.js';
+import { loadPattern } from '../regexp/matcher.js';
+import { isIRegexp } from '../regexp/syntax.js';
+const sources = new WeakMap();
+export function fullMatch(source) {
+    if (!isIRegexp(source)) {
+        throw new TypeError('fullMatch(...) requires a complete RFC 9485 I-Regexp source.');
+    }
+    const matcher = loadPattern(compilePattern(source));
+    const check = refine((value) => matcher.matches(value), {
+        error: `String must fully match I-Regexp ${JSON.stringify(source)}.`,
+    });
+    sources.set(check, source);
+    return check;
+}
+/** Compiler-private recognition of checks created by the Schema-owned fullMatch operation. */
+export function fullMatchSource(check) {
+    return check !== null && typeof check === 'object' ? sources.get(check) : undefined;
+}

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

@@ -0,0 +1,3 @@
+export declare const SCHEMA_ARRAY_KEYWORDS: Set<string>;
+export declare const SCHEMA_MAP_KEYWORDS: Set<string>;
+export declare const SCHEMA_SINGLE_KEYWORDS: Set<string>;

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

@@ -0,0 +1,20 @@
+export const SCHEMA_ARRAY_KEYWORDS = new Set(['allOf', 'anyOf', 'oneOf', 'prefixItems']);
+export const SCHEMA_MAP_KEYWORDS = new Set([
+    '$defs',
+    'dependentSchemas',
+    'patternProperties',
+    'properties',
+]);
+export const SCHEMA_SINGLE_KEYWORDS = new Set([
+    'additionalProperties',
+    'contains',
+    'contentSchema',
+    'else',
+    'if',
+    'items',
+    'not',
+    'propertyNames',
+    'then',
+    'unevaluatedItems',
+    'unevaluatedProperties',
+]);

package/dist/v1/language/value/syntax/node-path/schema.d.ts

@@ -0,0 +1,5 @@
+import type { JsonSchema, JsonSchemaObject } from '../../model/schema.js';
+export declare const GRAPH_NODE_PATH_SCHEMA_ID: 'https://schemas.astrale.ai/graph/1/node-path';
+/** Exact locally bundled artifact owned by graph/path/language's governed JSON Schema. */
+export declare const graphNodePathSchema: JsonSchemaObject;
+export declare function hasNodePathAnnotation(schema: JsonSchema): boolean;

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

@@ -0,0 +1,18 @@
+import { isValueObject as isJsonObject } from '../../model/object.js';
+import { JSON_SCHEMA_DIALECT } from '../../model/schema.js';
+export const GRAPH_NODE_PATH_SCHEMA_ID = 'https://schemas.astrale.ai/graph/1/node-path';
+/** Exact locally bundled artifact owned by graph/path/language's governed JSON Schema. */
+export const graphNodePathSchema = Object.freeze({
+    $schema: JSON_SCHEMA_DIALECT,
+    $id: GRAPH_NODE_PATH_SCHEMA_ID,
+    title: 'Astrale graph NodePath',
+    description: 'Canonical serialized exact-one locator for one logical graph Node. Full admission requires the astrale-node-path-v1 graph codec; JSON Schema format remains an annotation.',
+    type: 'string',
+    minLength: 1,
+    format: 'astrale-node-path-v1',
+});
+export function hasNodePathAnnotation(schema) {
+    return (isJsonObject(schema) &&
+        schema.$ref === GRAPH_NODE_PATH_SCHEMA_ID &&
+        Object.hasOwn(schema, 'x-astrale-path'));
+}

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

@@ -0,0 +1,4 @@
+import type { ClassRef } from '../../../../addressing/index.js';
+import type { Diagnostic } from '../../../validation/diagnostic.js';
+import type { JsonSchema, ValueSchemaContext } from '../../model/schema.js';
+export declare function validateNodePathExtension(schema: JsonSchema, context: ValueSchemaContext, pointer: string, definitionExists: (ref: ClassRef) => boolean): readonly Diagnostic[];

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

@@ -0,0 +1,78 @@
+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 directField = context === 'callable-input' &&
+            root?.type === 'object' &&
+            location.depth === 1 &&
+            location.parentKeyword === 'properties' &&
+            fieldName !== undefined;
+        if (!directField) {
+            diagnostics.push(diagnostic('VS_PATH_EXTENSION', extensionPointer, 'x-astrale-path is allowed only on a direct property schema at a callable-input object root.'));
+        }
+        const schemaKeys = Object.keys(location.schema);
+        if (schemaKeys.length !== 2 ||
+            !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;
+}