@astrale-os/kernel-dsl 0.2.0-beta.9 → 1.0.0-beta.2

package/dist/v1/compiled/admission/wire/callable.d.ts

@@ -0,0 +1,6 @@
+import { type Value as JsonValue, type Object as JsonObject } from '@astrale-os/kernel-dsl/value';
+import { type ValueProgram, type CompiledFunction } from '../../model/schema.js';
+/** Decode one Function declaration and its callable contract. */
+export declare function compiledFunction(input: JsonValue, values: readonly ValueProgram[], path: string): CompiledFunction;
+/** Check the shared Function and Method wire grammar. */
+export declare function compiledCallable(input: JsonValue | JsonObject, values: readonly ValueProgram[], method: boolean, path: string): void;

package/dist/v1/compiled/admission/wire/callable.js

@@ -0,0 +1,90 @@
+import {} from '@astrale-os/kernel-dsl/value';
+import {} from '../../model/schema.js';
+import { invalid, pointer } from '../diagnostic.js';
+import { callablePolicy } from './policy.js';
+import { definitionRef } from './reference.js';
+import { object, exact, memberName, boolean, description, index, integer, array } from './value.js';
+/** Decode one Function declaration and its callable contract. */
+export function compiledFunction(input, values, path) {
+    const value = object(input, 'Compiled Function', path);
+    compiledCallable(value, values, false, path);
+    definitionRef(value.ref, 'function', 'Function ref', `${path}/ref`);
+    return value;
+}
+/** Check the shared Function and Method wire grammar. */
+export function compiledCallable(input, values, method, path) {
+    const value = object(input, 'Compiled Callable', path);
+    exact(value, method
+        ? ['name', 'auth', 'static', 'abstract', 'input', 'output']
+        : ['ref', 'auth', 'input', 'output'], 'Compiled Callable', path, ['policy', 'description', 'execution', 'fields']);
+    if (method) {
+        memberName(value.name, 'Method name', `${path}/name`);
+        boolean(value.static, 'Method static', `${path}/static`);
+        boolean(value.abstract, 'Method abstract', `${path}/abstract`);
+    }
+    if (value.auth !== 'anonymous' && value.auth !== 'authenticated' && value.auth !== 'authorized') {
+        invalid('Callable auth', undefined, `${path}/auth`);
+    }
+    description(value.description, 'Callable description', `${path}/description`);
+    if (value.policy !== undefined) {
+        if (value.auth !== 'authorized') {
+            invalid('Callable Policy placement', undefined, `${path}/policy`);
+        }
+        callablePolicy(value.policy, `${path}/policy`);
+    }
+    let inputIndex;
+    if (!method && typeof value.input === 'object' && value.input !== null) {
+        const inputPath = `${path}/input`;
+        const binary = object(value.input, 'Binary input', inputPath);
+        exact(binary, ['mode', 'metadata', 'maximumBytes'], 'Binary input', inputPath);
+        if (binary.mode !== 'binary')
+            invalid('Binary input mode', undefined, `${inputPath}/mode`);
+        inputIndex = index(binary.metadata, values.length, 'Binary input metadata', `${inputPath}/metadata`);
+        const maximumBytes = integer(binary.maximumBytes, 'Binary input maximumBytes', `${inputPath}/maximumBytes`);
+        if (maximumBytes < 1)
+            invalid('Binary input maximumBytes', undefined, `${inputPath}/maximumBytes`);
+    }
+    else {
+        inputIndex = index(value.input, values.length, 'Callable input', `${path}/input`);
+    }
+    if (value.fields !== undefined) {
+        const fieldsPath = `${path}/fields`;
+        for (const [field, nodes] of Object.entries(object(value.fields, 'Callable fields', fieldsPath))) {
+            const fieldPath = pointer(fieldsPath, field);
+            const fieldNodes = array(nodes, 'Callable field nodes', fieldPath);
+            if (fieldNodes.length === 0)
+                invalid('Callable field nodes', undefined, fieldPath);
+            for (const [indexValue, node] of fieldNodes.entries()) {
+                index(node, values[inputIndex].nodes.length, 'Callable field', `${fieldPath}/${indexValue}`);
+            }
+        }
+    }
+    const outputPath = `${path}/output`;
+    const output = object(value.output, 'Callable output', outputPath);
+    if (output.mode === 'binary')
+        exact(output, ['mode'], 'binary output', outputPath);
+    else {
+        if (output.mode !== 'value' && output.mode !== 'stream')
+            invalid('Callable output mode', undefined, `${outputPath}/mode`);
+        exact(output, ['mode', 'value'], 'Callable output', outputPath);
+        index(output.value, values.length, 'Callable output value', `${outputPath}/value`);
+    }
+    if (value.execution !== undefined) {
+        const executionPath = `${path}/execution`;
+        const execution = object(value.execution, 'Callable execution', executionPath);
+        exact(execution, ['durable'], 'Callable execution', executionPath);
+        // Ordinary execution is canonically absent; only the durable modifier is retained.
+        if (!boolean(execution.durable, 'Callable execution durable', `${executionPath}/durable`)) {
+            invalid('Callable execution', 'COMPILED_CANONICAL_MISMATCH', `${executionPath}/durable`);
+        }
+        if (value.auth === 'anonymous') {
+            invalid('durable Callable auth', 'COMPILED_SOURCE_INVALID', `${path}/auth`);
+        }
+        if (typeof value.input === 'object' && value.input !== null) {
+            invalid('durable Callable input', 'COMPILED_SOURCE_INVALID', `${path}/input`);
+        }
+        if (output.mode !== 'value') {
+            invalid('durable Callable output', 'COMPILED_SOURCE_INVALID', `${outputPath}/mode`);
+        }
+    }
+}

package/dist/v1/compiled/admission/wire/class.d.ts

@@ -0,0 +1,4 @@
+import { type Value as JsonValue } from '@astrale-os/kernel-dsl/value';
+import { type ValueProgram, type CompiledClass } from '../../model/schema.js';
+/** Decode one Node or Edge Class with its declared members. */
+export declare function compiledClass(input: JsonValue, values: readonly ValueProgram[], path: string): CompiledClass;

package/dist/v1/compiled/admission/wire/class.js

@@ -0,0 +1,133 @@
+import {} from '@astrale-os/kernel-dsl/value';
+import { Key } from '../../../addressing/index.js';
+import { MEDIA_TYPE_PATTERN } from '../../../language/class/model/data.js';
+import {} from '../../model/schema.js';
+import { invalid } from '../diagnostic.js';
+import { compiledCallable } from './callable.js';
+import { classRuleChecks } from './policy.js';
+import { compiledProperty } from './property.js';
+import { definitionRef } from './reference.js';
+import { object, exact, boolean, description, array, unique, boundedString, string, memberName, } from './value.js';
+/** Decode one Node or Edge Class with its declared members. */
+export function compiledClass(input, values, path) {
+    const value = object(input, 'Compiled Class', path);
+    if (value.kind !== 'node' && value.kind !== 'edge')
+        invalid('Class kind', undefined, `${path}/kind`);
+    exact(value, value.kind === 'node'
+        ? ['ref', 'kind', 'abstract', 'extends', 'properties', 'methods', 'policies']
+        : [
+            'ref',
+            'kind',
+            'abstract',
+            'extends',
+            'orientation',
+            'endpoints',
+            'constraints',
+            'properties',
+            'policies',
+        ], 'Compiled Class', path, value.kind === 'node' ? ['data', 'description', 'icon'] : ['description']);
+    definitionRef(value.ref, 'class', 'Class ref', `${path}/ref`);
+    boolean(value.abstract, 'Class abstract', `${path}/abstract`);
+    description(value.description, 'Class description', `${path}/description`);
+    const extendsPath = `${path}/extends`;
+    const parents = array(value.extends, 'Class extends', extendsPath).map((parent, index) => definitionRef(parent, 'class', 'Class parent', `${extendsPath}/${index}`));
+    unique(parents.map(Key.of), 'Class parents', extendsPath);
+    const propertiesPath = `${path}/properties`;
+    const properties = array(value.properties, 'Class properties', propertiesPath).map((property, index) => compiledProperty(property, values, value.kind === 'node', `${propertiesPath}/${index}`));
+    unique(properties.map((property) => property.name), 'Class Properties', propertiesPath);
+    if (value.kind === 'node') {
+        if (value.data !== undefined)
+            dataDefinition(value.data, `${path}/data`);
+        boundedString(value.icon, 1, 8000, 'Class icon', `${path}/icon`);
+        classPolicies(value.policies, 'node', `${path}/policies`);
+        const methodsPath = `${path}/methods`;
+        const methods = array(value.methods, 'Class methods', methodsPath);
+        for (const [index, method] of methods.entries())
+            compiledCallable(method, values, true, `${methodsPath}/${index}`);
+        unique(methods.map((method, index) => string(object(method, 'Compiled Method', `${methodsPath}/${index}`).name, 'Method name', `${methodsPath}/${index}/name`)), 'Class Methods', methodsPath);
+    }
+    else {
+        classPolicies(value.policies, 'edge', `${path}/policies`);
+        edgeContract(value, path);
+    }
+    return { ...value, properties };
+}
+function classPolicies(input, kind, path) {
+    const value = object(input, 'Class Policies', path);
+    exact(value, [], 'Class Policies', path, ['read', 'traverse']);
+    if (value.read !== undefined)
+        classPolicy(value.read, kind, 'Class read Policy', `${path}/read`);
+    if (value.traverse !== undefined)
+        classPolicy(value.traverse, kind, 'Class traverse Policy', `${path}/traverse`);
+}
+/**
+ * Check one observation slot: `false`, the rule no caller satisfies, a named Policy, or, on a Node
+ * Class only, Policy checks over the observed Node.
+ */
+function classPolicy(input, kind, label, path) {
+    if (kind === 'node' &&
+        input !== null &&
+        typeof input === 'object' &&
+        ['check', 'sameNode', 'allOf', 'anyOf'].some((key) => Object.hasOwn(input, key))) {
+        classRuleChecks(input, path);
+        return;
+    }
+    if (input !== false)
+        definitionRef(input, 'policy', label, path);
+}
+function edgeContract(value, path) {
+    const constraintsPath = `${path}/constraints`;
+    const constraints = object(value.constraints, 'Edge constraints', constraintsPath);
+    exact(constraints, [], 'Edge constraints', constraintsPath, ['noSelf', 'acyclic']);
+    if (constraints.noSelf !== undefined && constraints.noSelf !== true)
+        invalid('Edge noSelf constraint', undefined, `${constraintsPath}/noSelf`);
+    if (constraints.acyclic !== undefined && constraints.acyclic !== true)
+        invalid('Edge acyclic constraint', undefined, `${constraintsPath}/acyclic`);
+    if (value.orientation === 'directed') {
+        const endpointsPath = `${path}/endpoints`;
+        const endpoints = object(value.endpoints, 'directed Edge endpoints', endpointsPath);
+        exact(endpoints, ['source', 'target'], 'directed Edge endpoints', endpointsPath);
+        edgeEndpoint(endpoints.source, 'outgoing', 'directed Edge source', `${endpointsPath}/source`);
+        edgeEndpoint(endpoints.target, 'incoming', 'directed Edge target', `${endpointsPath}/target`);
+        if (object(endpoints.source, 'directed Edge source', `${endpointsPath}/source`).role ===
+            object(endpoints.target, 'directed Edge target', `${endpointsPath}/target`).role) {
+            invalid('Edge endpoint roles', undefined, endpointsPath);
+        }
+        return;
+    }
+    if (value.orientation !== 'undirected' || constraints.acyclic !== undefined) {
+        invalid('Edge orientation', undefined, `${path}/orientation`);
+    }
+    const endpointsPath = `${path}/endpoints`;
+    const endpoints = array(value.endpoints, 'undirected Edge endpoints', endpointsPath);
+    if (endpoints.length !== 2)
+        invalid('undirected Edge endpoints', undefined, endpointsPath);
+    edgeEndpoint(endpoints[0], 'incident', 'undirected first endpoint', `${endpointsPath}/0`);
+    edgeEndpoint(endpoints[1], 'incident', 'undirected second endpoint', `${endpointsPath}/1`);
+    if (object(endpoints[0], 'undirected first endpoint', `${endpointsPath}/0`).role ===
+        object(endpoints[1], 'undirected second endpoint', `${endpointsPath}/1`).role) {
+        invalid('Edge endpoint roles', undefined, endpointsPath);
+    }
+}
+function edgeEndpoint(input, count, label, path) {
+    const value = object(input, label, path);
+    exact(value, ['role', 'accepts', count], label, path);
+    memberName(value.role, `${label} role`, `${path}/role`);
+    const acceptsPath = `${path}/accepts`;
+    const accepts = array(value.accepts, `${label} accepts`, acceptsPath).map((item, index) => definitionRef(item, 'class', `${label} accepted Class`, `${acceptsPath}/${index}`));
+    if (accepts.length === 0)
+        invalid(`${label} accepts`, undefined, acceptsPath);
+    unique(accepts.map(Key.of), `${label} accepts`, acceptsPath);
+    if (value[count] !== '0..*' &&
+        value[count] !== '1..*' &&
+        value[count] !== '0..1' &&
+        value[count] !== '1') {
+        invalid(`${label} ${count}`, undefined, `${path}/${count}`);
+    }
+}
+function dataDefinition(input, path) {
+    const value = object(input, 'Class data', path);
+    exact(value, ['mediaType'], 'Class data', path);
+    if (typeof value.mediaType !== 'string' || !MEDIA_TYPE_PATTERN.test(value.mediaType))
+        invalid('Class data mediaType', undefined, `${path}/mediaType`);
+}

package/dist/v1/compiled/admission/wire/core.d.ts

@@ -0,0 +1,5 @@
+import { type Value as JsonValue } from '@astrale-os/kernel-dsl/value';
+/** Decode a Core Node declaration and its Property values. */
+export declare function compiledCoreDefinition(input: JsonValue, path: string): never;
+/** Decode a Core Edge fact and its endpoints. */
+export declare function compiledCoreEdge(input: JsonValue, path: string): never;

package/dist/v1/compiled/admission/wire/core.js

@@ -0,0 +1,32 @@
+import {} from '@astrale-os/kernel-dsl/value';
+import { PropertyValues } from '../../../language/class/property-values.js';
+import { invalid } from '../diagnostic.js';
+import { definitionRef, coreEndpoint } from './reference.js';
+import { object, exact } from './value.js';
+/** Decode a Core Node declaration and its Property values. */
+export function compiledCoreDefinition(input, path) {
+    const value = object(input, 'Core Definition', path);
+    exact(value, ['ref', 'class', 'properties'], 'Core Definition', path);
+    definitionRef(value.ref, 'core', 'Core ref', `${path}/ref`);
+    definitionRef(value.class, 'class', 'Core Class', `${path}/class`);
+    propertyValues(value.properties, 'Core Properties', `${path}/properties`);
+    return value;
+}
+/** Decode a Core Edge fact and its endpoints. */
+export function compiledCoreEdge(input, path) {
+    const value = object(input, 'Core Edge', path);
+    exact(value, ['class', 'source', 'target', 'properties'], 'Core Edge', path);
+    definitionRef(value.class, 'class', 'Core Edge Class', `${path}/class`);
+    coreEndpoint(value.source, 'Core Edge source', `${path}/source`);
+    coreEndpoint(value.target, 'Core Edge target', `${path}/target`);
+    propertyValues(value.properties, 'Core Edge Properties', `${path}/properties`);
+    return value;
+}
+function propertyValues(input, label, path) {
+    try {
+        PropertyValues.accept(input, path);
+    }
+    catch {
+        invalid(label, undefined, path);
+    }
+}

package/dist/v1/compiled/admission/wire/dependency.d.ts

@@ -0,0 +1,14 @@
+import { type Value as JsonValue } from '@astrale-os/kernel-dsl/value';
+import { type Revision } from '../../../addressing/index.js';
+import { type CompiledSchemaEntry } from '../../model/schema.js';
+/** Decode one exact Domain revision pin. */
+export declare function dependency(input: JsonValue | undefined, label: string, path: string): {
+    origin: string;
+    revision: Revision;
+};
+/** Decode and canonically order direct dependency aliases. */
+export declare function dependencyMap(input: JsonValue | undefined, path: string): CompiledSchemaEntry['dependencies'];
+/** Require a canonical Domain origin. */
+export declare function originValue(input: JsonValue | undefined, label: string, path: string): string;
+/** Require a canonical content-addressed revision. */
+export declare function revisionValue(input: JsonValue | undefined, label: string, path: string): Revision;

package/dist/v1/compiled/admission/wire/dependency.js

@@ -0,0 +1,43 @@
+import {} from '@astrale-os/kernel-dsl/value';
+import {} from '../../../addressing/index.js';
+import { DEPENDENCY_ALIAS_PATTERN, DOMAIN_ORIGIN_PATTERN, DOMAIN_REVISION_PATTERN, } from '../../../addressing/patterns.js';
+import {} from '../../model/schema.js';
+import { pointer, invalid } from '../diagnostic.js';
+import { object, exact, compare } from './value.js';
+/** Decode one exact Domain revision pin. */
+export function dependency(input, label, path) {
+    const value = object(input, label, path);
+    exact(value, ['origin', 'revision'], label, path);
+    return {
+        origin: originValue(value.origin, label, `${path}/origin`),
+        revision: revisionValue(value.revision, label, `${path}/revision`),
+    };
+}
+/** Decode and canonically order direct dependency aliases. */
+export function dependencyMap(input, path) {
+    const value = object(input, 'dependencies', path);
+    const accepted = Object.create(null);
+    for (const [alias, inputDependency] of Object.entries(value).sort(([left], [right]) => compare(left, right))) {
+        const aliasPath = pointer(path, alias);
+        if (!DEPENDENCY_ALIAS_PATTERN.test(alias) ||
+            alias === '__proto__' ||
+            alias === 'prototype' ||
+            alias === 'constructor') {
+            invalid('dependency alias', undefined, aliasPath);
+        }
+        accepted[alias] = dependency(inputDependency, `dependency ${alias}`, aliasPath);
+    }
+    return accepted;
+}
+/** Require a canonical Domain origin. */
+export function originValue(input, label, path) {
+    if (typeof input !== 'string' || !DOMAIN_ORIGIN_PATTERN.test(input))
+        invalid(label, undefined, path);
+    return input;
+}
+/** Require a canonical content-addressed revision. */
+export function revisionValue(input, label, path) {
+    if (typeof input !== 'string' || !DOMAIN_REVISION_PATTERN.test(input))
+        invalid(label, undefined, path);
+    return input;
+}

package/dist/v1/compiled/admission/wire/entry.d.ts

@@ -0,0 +1,5 @@
+import { type Value as JsonValue } from '@astrale-os/kernel-dsl/value';
+import { type CompiledSchemaEntry } from '../../model/schema.js';
+import { type Machines } from './pattern.js';
+/** Decode one closure entry and verify its exact semantic revision. */
+export declare function entry(input: JsonValue, entryIndex: number, path: string, machines: Machines): CompiledSchemaEntry;

package/dist/v1/compiled/admission/wire/entry.js

@@ -0,0 +1,100 @@
+import {} from '@astrale-os/kernel-dsl/value';
+import {} from '../../../addressing/index.js';
+import * as metadata from '../../../language/definition/metadata.js';
+import { bindValueProgram } from '../../../language/value/compile/load.js';
+import {} from '../../model/schema.js';
+import { invalid, pointer } from '../diagnostic.js';
+import { revisionOfCompiledEntry } from '../revision.js';
+import { compiledFunction } from './callable.js';
+import { compiledClass } from './class.js';
+import { compiledCoreDefinition, compiledCoreEdge } from './core.js';
+import { originValue, revisionValue, dependencyMap } from './dependency.js';
+import { pattern } from './pattern.js';
+import { compiledPolicy } from './policy.js';
+import { program } from './program.js';
+import { definitionRef } from './reference.js';
+import { object, exact, string, array } from './value.js';
+import { compiledView } from './view.js';
+/** Decode one closure entry and verify its exact semantic revision. */
+export function entry(input, entryIndex, path, machines) {
+    const value = object(input, `closure[${entryIndex}]`, path);
+    exact(value, ['origin', 'revision', 'name', 'dependencies', 'definitions', 'facts', 'values', 'patterns'], 'entry', path, ['entrypoint']);
+    const origin = originValue(value.origin, 'entry origin', `${path}/origin`);
+    const name = string(value.name, 'entry name', `${path}/name`);
+    if (name.length < metadata.name.minLength ||
+        name.length > metadata.name.maxLength ||
+        !metadata.isDomainNameText(name))
+        invalid('entry name', undefined, `${path}/name`);
+    const entrypoint = value.entrypoint === undefined
+        ? undefined
+        : definitionRef(value.entrypoint, 'view', 'entry entrypoint', `${path}/entrypoint`);
+    const revision = revisionValue(value.revision, 'entry revision', `${path}/revision`);
+    const dependenciesPath = `${path}/dependencies`;
+    const dependencies = dependencyMap(value.dependencies, dependenciesPath);
+    const dependencyOrigins = new Set();
+    for (const [alias, dependency] of Object.entries(dependencies)) {
+        if (dependencyOrigins.has(dependency.origin))
+            invalid('duplicate dependency', undefined, `${pointer(dependenciesPath, alias)}/origin`);
+        dependencyOrigins.add(dependency.origin);
+    }
+    const valuesPath = `${path}/values`;
+    const patternsPath = `${path}/patterns`;
+    const patterns = array(value.patterns, 'entry patterns', patternsPath).map((item, index) => pattern(item, index, `${patternsPath}/${index}`, machines));
+    const values = array(value.values, 'values', valuesPath).map((item, index) => program(item, index, `${valuesPath}/${index}`, patterns));
+    const bound = values.map((value) => bindValueProgram(value, patterns));
+    const definitionsPath = `${path}/definitions`;
+    const definitions = object(value.definitions, 'definitions', definitionsPath);
+    exact(definitions, ['classes', 'functions', 'policies', 'views', 'core'], 'definitions', definitionsPath);
+    const classesPath = `${definitionsPath}/classes`;
+    const classes = array(definitions.classes, 'classes', classesPath).map((item, index) => compiledClass(item, bound, `${classesPath}/${index}`));
+    const functionsPath = `${definitionsPath}/functions`;
+    const functions = array(definitions.functions, 'functions', functionsPath).map((item, index) => compiledFunction(item, bound, `${functionsPath}/${index}`));
+    const factsPath = `${path}/facts`;
+    const facts = object(value.facts, 'facts', factsPath);
+    exact(facts, ['core'], 'facts', factsPath);
+    const policiesPath = `${definitionsPath}/policies`;
+    const viewsPath = `${definitionsPath}/views`;
+    const coreDefinitionsPath = `${definitionsPath}/core`;
+    const coreFactsPath = `${factsPath}/core`;
+    const accepted = {
+        origin,
+        revision,
+        name,
+        ...(entrypoint === undefined ? {} : { entrypoint }),
+        dependencies,
+        definitions: {
+            classes,
+            functions,
+            policies: array(definitions.policies, 'policies', policiesPath).map((item, index) => compiledPolicy(item, `${policiesPath}/${index}`)),
+            views: array(definitions.views, 'views', viewsPath).map((item, index) => compiledView(item, `${viewsPath}/${index}`)),
+            core: array(definitions.core, 'core definitions', coreDefinitionsPath).map((item, index) => compiledCoreDefinition(item, `${coreDefinitionsPath}/${index}`)),
+        },
+        facts: {
+            core: array(facts.core, 'core facts', coreFactsPath).map((item, index) => compiledCoreEdge(item, `${coreFactsPath}/${index}`)),
+        },
+        values,
+        patterns,
+    };
+    const collections = [
+        ['classes', accepted.definitions.classes],
+        ['functions', accepted.definitions.functions],
+        ['policies', accepted.definitions.policies],
+        ['views', accepted.definitions.views],
+        ['core', accepted.definitions.core],
+    ];
+    for (const [collection, definitions] of collections) {
+        for (const [index, definition] of definitions.entries()) {
+            if (definition.ref.origin !== origin)
+                invalid('Definition owner origin', undefined, `${definitionsPath}/${collection}/${index}/ref/origin`);
+        }
+    }
+    if (entrypoint !== undefined &&
+        (entrypoint.origin !== origin ||
+            !accepted.definitions.views.some(({ ref, target }) => ref.name === entrypoint.name && target.kind === 'domain'))) {
+        invalid('entry entrypoint', undefined, `${path}/entrypoint`);
+    }
+    if (revisionOfCompiledEntry(accepted) !== revision) {
+        invalid('entry revision', 'COMPILED_CANONICAL_MISMATCH', `${path}/revision`);
+    }
+    return accepted;
+}

package/dist/v1/compiled/admission/wire/pattern.d.ts

@@ -0,0 +1,12 @@
+import { type Value as JsonValue } from '@astrale-os/kernel-dsl/value';
+import { type Pattern, type RunPattern } from '../../model/schema.js';
+/** The machine compiled from each admitted I-Regexp source, shared by its occurrences. */
+export type Machines = Map<string, Pattern | RunPattern>;
+/**
+ * Admit one received pattern as data and return the machine compiled from its source. A received
+ * machine never decides membership: it may come from another compiler, from a host with other
+ * Unicode data, or from a forger, and the artifact carries no compiler version that could tell a
+ * current machine from those, so it is ignored rather than compared. Its source decides, through
+ * the same bounded `isIRegexp` and `compilePattern` that source resolution uses.
+ */
+export declare function pattern(input: JsonValue, patternIndex: number, path: string, machines: Machines): Pattern | RunPattern;

package/dist/v1/compiled/admission/wire/pattern.js

@@ -0,0 +1,111 @@
+import {} from '@astrale-os/kernel-dsl/value';
+import { compilePattern } from '../../../language/value/regexp/compile.js';
+import { isIRegexp } from '../../../language/value/regexp/syntax.js';
+import {} from '../../model/schema.js';
+import { invalid } from '../diagnostic.js';
+import { object, exact, array, integer, scalar, index, boundedInteger } from './value.js';
+/**
+ * Admit one received pattern as data and return the machine compiled from its source. A received
+ * machine never decides membership: it may come from another compiler, from a host with other
+ * Unicode data, or from a forger, and the artifact carries no compiler version that could tell a
+ * current machine from those, so it is ignored rather than compared. Its source decides, through
+ * the same bounded `isIRegexp` and `compilePattern` that source resolution uses.
+ */
+export function pattern(input, patternIndex, path, machines) {
+    const value = object(input, `patterns[${patternIndex}]`, path);
+    const { source } = Object.hasOwn(value, 'runs')
+        ? runPattern(value, path)
+        : nfaPattern(value, path);
+    let machine = machines.get(source);
+    if (machine === undefined) {
+        if (!isIRegexp(source))
+            invalid('Pattern source', 'COMPILED_SOURCE_INVALID', `${path}/source`);
+        machine = compilePattern(source);
+        machines.set(source, machine);
+    }
+    return machine;
+}
+function nfaPattern(value, path) {
+    exact(value, ['source', 'start', 'states'], 'Pattern', path);
+    if (typeof value.source !== 'string')
+        invalid('Pattern source', undefined, `${path}/source`);
+    const statesPath = `${path}/states`;
+    const states = array(value.states, 'Pattern states', statesPath).map((item, stateIndex) => {
+        const statePath = `${statesPath}/${stateIndex}`;
+        const state = object(item, 'Pattern state', statePath);
+        exact(state, ['epsilon', 'transitions'], 'Pattern state', statePath, ['accepting']);
+        if (state.accepting !== undefined && state.accepting !== true)
+            invalid('accepting', undefined, `${statePath}/accepting`);
+        const epsilonPath = `${statePath}/epsilon`;
+        const transitionsPath = `${statePath}/transitions`;
+        return {
+            epsilon: array(state.epsilon, 'epsilon', epsilonPath).map((target, index) => integer(target, 'epsilon', `${epsilonPath}/${index}`)),
+            transitions: array(state.transitions, 'transitions', transitionsPath).map((transitionValue, transitionIndex) => {
+                const transitionPath = `${transitionsPath}/${transitionIndex}`;
+                const transition = object(transitionValue, 'transition', transitionPath);
+                exact(transition, ['to', 'ranges'], 'transition', transitionPath);
+                const rangesPath = `${transitionPath}/ranges`;
+                return {
+                    to: integer(transition.to, 'transition target', `${transitionPath}/to`),
+                    ranges: array(transition.ranges, 'ranges', rangesPath).map((rangeValue, rangeIndex) => {
+                        const rangePath = `${rangesPath}/${rangeIndex}`;
+                        const range = array(rangeValue, 'range', rangePath);
+                        if (range.length !== 2)
+                            invalid('range', undefined, rangePath);
+                        const minimum = scalar(range[0], 'range minimum', `${rangePath}/0`);
+                        const maximum = scalar(range[1], 'range maximum', `${rangePath}/1`);
+                        if (minimum > maximum)
+                            invalid('range order', undefined, rangePath);
+                        return [minimum, maximum];
+                    }),
+                };
+            }),
+            ...(state.accepting === true ? { accepting: true } : {}),
+        };
+    });
+    const start = index(value.start, states.length, 'Pattern start', `${path}/start`);
+    for (const [stateIndex, state] of states.entries()) {
+        state.epsilon.forEach((target, indexValue) => index(target, states.length, 'epsilon', `${statesPath}/${stateIndex}/epsilon/${indexValue}`));
+        state.transitions.forEach(({ to }, transitionIndex) => index(to, states.length, 'transition', `${statesPath}/${stateIndex}/transitions/${transitionIndex}/to`));
+    }
+    return { source: value.source, start, states };
+}
+function runPattern(value, path) {
+    exact(value, ['source', 'runs'], 'RunPattern', path);
+    if (typeof value.source !== 'string')
+        invalid('Pattern source', undefined, `${path}/source`);
+    const entries = array(value.runs, 'scalar runs', `${path}/runs`);
+    if (entries.length === 0 || entries.length > 4096) {
+        invalid('scalar run count', undefined, `${path}/runs`);
+    }
+    const runs = entries.map((entry, position) => {
+        const runPath = `${path}/runs/${position}`;
+        const run = object(entry, 'scalar run', runPath);
+        exact(run, ['ranges', 'minimum'], 'scalar run', runPath, ['maximum']);
+        const minimum = boundedInteger(run.minimum, 0, 1000, 'run minimum', `${runPath}/minimum`);
+        const maximum = run.maximum === undefined
+            ? undefined
+            : boundedInteger(run.maximum, minimum, 1000, 'run maximum', `${runPath}/maximum`);
+        if (position !== entries.length - 1 && minimum !== maximum) {
+            invalid('exact scalar prefix', undefined, `${runPath}/maximum`);
+        }
+        let previous = -1;
+        const ranges = array(run.ranges, 'scalar ranges', `${runPath}/ranges`).map((entry, index) => {
+            const rangePath = `${runPath}/ranges/${index}`;
+            const range = array(entry, 'scalar range', rangePath);
+            if (range.length !== 2)
+                invalid('scalar range', undefined, rangePath);
+            const minimum = scalar(range[0], 'range minimum', `${rangePath}/0`);
+            const maximum = scalar(range[1], 'range maximum', `${rangePath}/1`);
+            if (minimum > maximum ||
+                minimum <= previous ||
+                (minimum >= 0xd800 && minimum <= 0xdfff) ||
+                (maximum >= 0xd800 && maximum <= 0xdfff))
+                invalid('ordered scalar range', undefined, rangePath);
+            previous = maximum;
+            return [minimum, maximum];
+        });
+        return { ranges, minimum, ...(maximum === undefined ? {} : { maximum }) };
+    });
+    return { source: value.source, runs };
+}

package/dist/v1/compiled/admission/wire/policy.d.ts

@@ -0,0 +1,10 @@
+import { type Value as JsonValue } from '@astrale-os/kernel-dsl/value';
+/** Decode a named Policy and its expression grammar. */
+export declare function compiledPolicy(input: JsonValue, path: string): never;
+/** Check one callable's caller rule: `true`, the rule every caller satisfies, or Policy checks. */
+export declare function callablePolicy(input: JsonValue | undefined, path: string): void;
+/**
+ * Check one Node Class rule: Policy checks over `self` and `ref` objects only, in their one
+ * spelling. A lone check of `self` is spelled as the Policy reference itself.
+ */
+export declare function classRuleChecks(input: JsonValue, path: string): void;