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

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

@@ -0,0 +1,189 @@
+import { json } from '@astrale-os/kernel-dsl/value';
+import { Key } from '../../../addressing/index.js';
+import { normalizeClassRule } from '../../../language/policy/normalization/normalize.js';
+import { invalid, pointer } from '../diagnostic.js';
+import { definitionRef, policyObjectRef } from './reference.js';
+import { object, exact, description, array, unique, boundedInteger, integer, memberName, } from './value.js';
+/** Decode a named Policy and its expression grammar. */
+export function compiledPolicy(input, path) {
+    const value = object(input, 'Policy', path);
+    exact(value, ['ref', 'expression'], 'Policy', path, ['description']);
+    definitionRef(value.ref, 'policy', 'Policy ref', `${path}/ref`);
+    description(value.description, 'Policy description', `${path}/description`);
+    policyExpression(value.expression, 0, `${path}/expression`);
+    return value;
+}
+function policyExpression(input, depth, path) {
+    if (depth > 64)
+        invalid('Policy expression depth', undefined, path);
+    const value = object(input, 'Policy expression', path);
+    if (Object.hasOwn(value, 'match')) {
+        exact(value, ['match'], 'Policy expression', path);
+        policyPattern(value.match, depth + 1, `${path}/match`);
+        return;
+    }
+    const member = Object.hasOwn(value, 'allOf') ? 'allOf' : 'anyOf';
+    exact(value, [member], 'Policy expression', path);
+    const memberPath = pointer(path, member);
+    const refs = array(value[member], `Policy ${member}`, memberPath).map((item, index) => definitionRef(item, 'policy', `Policy ${member} ref`, `${memberPath}/${index}`));
+    if (refs.length === 0)
+        invalid(`Policy ${member}`, undefined, memberPath);
+    unique(refs.map(Key.of), `Policy ${member}`, memberPath);
+}
+function policyPattern(input, depth, path) {
+    if (depth > 64)
+        invalid('Policy pattern depth', undefined, path);
+    const value = object(input, 'Policy pattern', path);
+    if (Object.hasOwn(value, 'sameNode')) {
+        exact(value, ['sameNode'], 'Policy equality', path);
+        const pair = object(value.sameNode, 'Policy equality', `${path}/sameNode`);
+        exact(pair, ['left', 'right'], 'Policy equality operands', `${path}/sameNode`);
+        policyTerm(pair.left, false, `${path}/sameNode/left`);
+        policyTerm(pair.right, false, `${path}/sameNode/right`);
+        return;
+    }
+    if (Object.hasOwn(value, 'exists')) {
+        exact(value, ['exists'], 'Policy exists', path);
+        const existsPath = `${path}/exists`;
+        const exists = object(value.exists, 'Policy exists', existsPath);
+        exact(exists, ['nodes', 'where'], 'Policy exists', existsPath);
+        const nodesPath = `${existsPath}/nodes`;
+        const nodes = array(exists.nodes, 'Policy variables', nodesPath);
+        if (nodes.length < 1 || nodes.length > 4)
+            invalid('Policy variables', undefined, nodesPath);
+        for (const [index, node] of nodes.entries()) {
+            const variablePath = `${nodesPath}/${index}`;
+            const variable = object(node, 'Policy variable', variablePath);
+            policyTerm(variable.variable, true, `${variablePath}/variable`);
+            if (Object.hasOwn(variable, 'class')) {
+                exact(variable, ['variable', 'class'], 'Policy variable', variablePath);
+                definitionRef(variable.class, 'class', 'Policy variable Class', `${variablePath}/class`);
+            }
+            else {
+                exact(variable, ['variable', 'selector'], 'Policy variable', variablePath);
+                const selectorPath = `${variablePath}/selector`;
+                const selector = object(variable.selector, 'Policy variable selector', selectorPath);
+                if (selector.kind === 'any') {
+                    exact(selector, ['kind'], 'Policy variable selector', selectorPath);
+                }
+                else if (selector.kind === 'satisfies') {
+                    exact(selector, ['kind', 'class'], 'Policy variable selector', selectorPath);
+                    definitionRef(selector.class, 'class', 'Policy variable selector Class', `${selectorPath}/class`);
+                }
+                else {
+                    invalid('Policy variable selector kind', undefined, `${selectorPath}/kind`);
+                }
+            }
+        }
+        policyPattern(exists.where, depth + 1, `${existsPath}/where`);
+        return;
+    }
+    if (Object.hasOwn(value, 'allOf') || Object.hasOwn(value, 'anyOf')) {
+        const member = Object.hasOwn(value, 'allOf') ? 'allOf' : 'anyOf';
+        exact(value, [member], 'Policy pattern composition', path);
+        const memberPath = pointer(path, member);
+        const expressions = array(value[member], `Policy pattern ${member}`, memberPath);
+        if (expressions.length === 0)
+            invalid(`Policy pattern ${member}`, undefined, memberPath);
+        for (const [index, expression] of expressions.entries())
+            policyPattern(expression, depth + 1, `${memberPath}/${index}`);
+        return;
+    }
+    exact(value, ['source', 'class', 'target'], 'Policy Edge pattern', path, ['repeat']);
+    policyTerm(value.source, false, `${path}/source`);
+    definitionRef(value.class, 'class', 'Policy Edge Class', `${path}/class`);
+    policyTerm(value.target, false, `${path}/target`);
+    if (value.repeat !== undefined) {
+        const repeatPath = `${path}/repeat`;
+        const repeat = object(value.repeat, 'Policy repeat', repeatPath);
+        exact(repeat, ['min', 'max'], 'Policy repeat', repeatPath);
+        const minimum = boundedInteger(repeat.min, 0, 3, 'Policy repeat minimum', `${repeatPath}/min`);
+        const maximum = boundedInteger(repeat.max, 0, 3, 'Policy repeat maximum', `${repeatPath}/max`);
+        if (minimum > maximum)
+            invalid('Policy repeat order', undefined, repeatPath);
+    }
+}
+function policyTerm(input, variableOnly, path) {
+    const value = object(input, 'Policy pattern term', path);
+    if (!variableOnly && value.kind === 'ref') {
+        exact(value, ['kind', 'ref'], 'Policy reference term', path);
+        policyObjectRef(value.ref, `${path}/ref`);
+        return;
+    }
+    if (value.kind === 'variable') {
+        exact(value, ['kind', 'id'], 'Policy variable term', path);
+        integer(value.id, 'Policy variable id', `${path}/id`);
+        return;
+    }
+    if (variableOnly ||
+        (value.kind !== 'subject' &&
+            value.kind !== 'object' &&
+            value.kind !== 'source' &&
+            value.kind !== 'target')) {
+        invalid('Policy pattern term', undefined, `${path}/kind`);
+    }
+    exact(value, ['kind'], 'Policy pattern term', path);
+}
+/** Check one callable's caller rule: `true`, the rule every caller satisfies, or Policy checks. */
+export function callablePolicy(input, path) {
+    if (input !== true)
+        policyCheck(input, 0, path);
+}
+/**
+ * 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 function classRuleChecks(input, path) {
+    policyCheck(input, 0, path, 'class');
+    const rule = input;
+    if (json.serialize(normalizeClassRule(rule)) !== json.serialize(rule))
+        invalid('Class rule spelling', undefined, path);
+}
+/** What a site calls its checks in a refusal. */
+const SITE = { callable: 'Callable Policy', class: 'Class rule' };
+/** Check the recursive Policy check wire grammar of one use site. */
+function policyCheck(input, depth, path, site = 'callable') {
+    const name = SITE[site];
+    if (depth > 64)
+        invalid(`${name} depth`, undefined, path);
+    const value = object(input, name, path);
+    if (Object.hasOwn(value, 'sameNode')) {
+        const equality = site === 'class' ? 'Class rule equality' : 'Callable equality';
+        exact(value, ['sameNode'], equality, path);
+        const pair = object(value.sameNode, equality, `${path}/sameNode`);
+        exact(pair, ['left', 'right'], `${equality} operands`, `${path}/sameNode`);
+        policyCheckObject(pair.left, `${path}/sameNode/left`, site);
+        policyCheckObject(pair.right, `${path}/sameNode/right`, site);
+        return;
+    }
+    if (Object.hasOwn(value, 'check')) {
+        exact(value, ['check', 'object'], `${name} check`, path);
+        definitionRef(value.check, 'policy', `${name} ref`, `${path}/check`);
+        policyCheckObject(value.object, `${path}/object`, site);
+        return;
+    }
+    const member = Object.hasOwn(value, 'allOf') ? 'allOf' : 'anyOf';
+    exact(value, [member], `${name} composition`, path);
+    const memberPath = pointer(path, member);
+    const expressions = array(value[member], `${name} ${member}`, memberPath);
+    if (expressions.length === 0)
+        invalid(`${name} ${member}`, undefined, memberPath);
+    for (const [index, expression] of expressions.entries())
+        policyCheck(expression, depth + 1, `${memberPath}/${index}`, site);
+}
+function policyCheckObject(input, objectPath, site) {
+    const name = SITE[site];
+    const target = object(input, `${name} object`, objectPath);
+    if (target.kind === 'self')
+        exact(target, ['kind'], `${name} self`, objectPath);
+    else if (target.kind === 'input' && site === 'callable') {
+        exact(target, ['kind', 'field'], `${name} input`, objectPath);
+        memberName(target.field, `${name} input field`, `${objectPath}/field`);
+    }
+    else if (target.kind === 'ref') {
+        exact(target, ['kind', 'ref'], `${name} object ref`, objectPath);
+        policyObjectRef(target.ref, `${objectPath}/ref`);
+    }
+    else
+        invalid(`${name} object`, undefined, `${objectPath}/kind`);
+}

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

@@ -0,0 +1,4 @@
+import { type Value as JsonValue } from '@astrale-os/kernel-dsl/value';
+import { type Pattern, type RunPattern, type IndexedValueProgram } from '../../model/schema.js';
+/** Decode a value program and validate its local node and pattern indices. */
+export declare function program(input: JsonValue, programIndex: number, path: string, table: readonly (Pattern | RunPattern)[]): IndexedValueProgram;

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

@@ -0,0 +1,52 @@
+import {} from '@astrale-os/kernel-dsl/value';
+import { isValueObject } from '../../../language/value/model/object.js';
+import {} from '../../model/schema.js';
+import { invalid, pointer } from '../diagnostic.js';
+import { object, exact, array, index, unique, integer } from './value.js';
+/** Decode a value program and validate its local node and pattern indices. */
+export function program(input, programIndex, path, table) {
+    const value = object(input, `values[${programIndex}]`, path);
+    exact(value, ['root', 'nodes', 'patterns'], 'ValueProgram', path);
+    const nodesPath = `${path}/nodes`;
+    const nodes = array(value.nodes, 'ValueProgram nodes', nodesPath).map((node, index) => valueNode(node, index, `${nodesPath}/${index}`));
+    const root = index(value.root, nodes.length, 'ValueProgram root', `${path}/root`);
+    const patternsPath = `${path}/patterns`;
+    const patterns = array(value.patterns, 'ValueProgram patterns', patternsPath).map((item, position) => index(item, table.length, 'ValueProgram pattern', `${patternsPath}/${position}`));
+    const sources = patterns.map((index) => table[index].source);
+    unique(sources, 'patterns', patternsPath);
+    const available = new Set(sources);
+    for (const [nodeIndex, node] of nodes.entries()) {
+        if (isValueObject(node.schema)) {
+            const required = [node.schema.pattern, node.schema.fullMatch];
+            if (isValueObject(node.schema.patternProperties)) {
+                required.push(...Object.keys(node.schema.patternProperties));
+            }
+            for (const source of required) {
+                if (typeof source === 'string' && !available.has(source)) {
+                    invalid('ValueProgram pattern binding', undefined, patternsPath);
+                }
+            }
+        }
+        for (const [name, child] of Object.entries(node.children))
+            index(child, nodes.length, 'ValueNode child', pointer(`${nodesPath}/${nodeIndex}/children`, name));
+        if (node.reference !== undefined)
+            index(node.reference, nodes.length, 'ValueNode reference', `${nodesPath}/${nodeIndex}/reference`);
+    }
+    return { root, nodes, patterns };
+}
+function valueNode(input, nodeIndex, path) {
+    const value = object(input, `nodes[${nodeIndex}]`, path);
+    exact(value, ['schema', 'children'], 'ValueNode', path, ['reference']);
+    const children = {};
+    const childrenPath = `${path}/children`;
+    for (const [name, child] of Object.entries(object(value.children, 'ValueNode children', childrenPath))) {
+        children[name] = integer(child, 'ValueNode child', pointer(childrenPath, name));
+    }
+    return {
+        schema: value.schema,
+        children,
+        ...(value.reference === undefined
+            ? {}
+            : { reference: integer(value.reference, 'reference', `${path}/reference`) }),
+    };
+}

package/dist/v1/compiled/admission/wire/property.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 a Property and re-admit its State and ordering contracts. */
+export declare function compiledProperty(input: JsonValue, values: readonly ValueProgram[], node: boolean, path: string): CompiledClass['properties'][number];

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

@@ -0,0 +1,74 @@
+import {} from '@astrale-os/kernel-dsl/value';
+import {} from '../../../language/state/index.js';
+import { admitStateTopology } from '../../../language/state/topology.js';
+import { classifyValueProgramOrdering } from '../../../language/value/ordering.js';
+import {} from '../../model/schema.js';
+import { invalid } from '../diagnostic.js';
+import { object, exact, memberName, boolean, description, index, array, unique } from './value.js';
+/** Decode a Property and re-admit its State and ordering contracts. */
+export function compiledProperty(input, values, node, path) {
+    const value = object(input, 'Compiled Property', path);
+    exact(value, ['name', 'required', 'value'], 'Compiled Property', path, [
+        'auto',
+        'description',
+        'immutable',
+        'ordering',
+        'state',
+    ]);
+    memberName(value.name, 'Property name', `${path}/name`);
+    boolean(value.required, 'Property required', `${path}/required`);
+    description(value.description, 'Property description', `${path}/description`);
+    if (value.auto !== undefined)
+        propertyAuto(value.auto, `${path}/auto`);
+    if (value.immutable !== undefined && value.immutable !== 'create' && value.immutable !== 'once') {
+        invalid('Property immutability', undefined, `${path}/immutable`);
+    }
+    const valueIndex = index(value.value, values.length, 'Property value', `${path}/value`);
+    let state;
+    if (value.state !== undefined) {
+        if (!node)
+            invalid('Property state placement', 'COMPILED_SOURCE_INVALID', `${path}/state`);
+        let topology;
+        try {
+            topology = admitStateTopology(value.state);
+        }
+        catch {
+            invalid('Property state topology', 'COMPILED_SOURCE_INVALID', `${path}/state`);
+        }
+        const program = values[valueIndex];
+        const schema = program.nodes[program.root].schema;
+        const states = Object.keys(topology.transitions);
+        const schemaObject = schema;
+        const schemaMatches = schema !== null &&
+            typeof schema === 'object' &&
+            !Array.isArray(schema) &&
+            Object.keys(schemaObject).length === 2 &&
+            schemaObject.type === 'string' &&
+            Array.isArray(schemaObject.enum) &&
+            schemaObject.enum.length === states.length &&
+            schemaObject.enum.every((state, index) => state === states[index]);
+        if (!value.required || value.auto !== undefined || !schemaMatches) {
+            invalid('Property state contract', 'COMPILED_SOURCE_INVALID', `${path}/state`);
+        }
+        state = topology;
+    }
+    if (value.ordering !== classifyValueProgramOrdering(values[valueIndex])) {
+        invalid('Property ordering', 'COMPILED_CANONICAL_MISMATCH', `${path}/ordering`);
+    }
+    return {
+        ...value,
+        ...(state === undefined ? {} : { state }),
+    };
+}
+function propertyAuto(input, path) {
+    const value = object(input, 'Property auto', path);
+    exact(value, ['on', 'set'], 'Property auto', path);
+    const eventsPath = `${path}/on`;
+    const events = array(value.on, 'Property auto events', eventsPath);
+    if (events.length === 0 || events.some((event) => event !== 'create' && event !== 'update')) {
+        invalid('Property auto events', undefined, eventsPath);
+    }
+    unique(events.map(String), 'Property auto events', eventsPath);
+    if (value.set !== 'instant')
+        invalid('Property auto setter', undefined, `${path}/set`);
+}

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

@@ -0,0 +1,8 @@
+import { type Value as JsonValue } from '@astrale-os/kernel-dsl/value';
+import { type DefinitionRef } from '../../../addressing/index.js';
+/** Check a Domain or projected declaration endpoint. */
+export declare function coreEndpoint(input: JsonValue | undefined, label: string, path: string): void;
+/** Check a Policy reference to a projected declaration. */
+export declare function policyObjectRef(input: JsonValue | undefined, path: string): void;
+/** Require a canonical Definition coordinate of the expected kind. */
+export declare function definitionRef<Kind extends DefinitionRef['kind'] | undefined>(input: JsonValue | undefined, kind: Kind, label: string, path: string): DefinitionRef;

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

@@ -0,0 +1,33 @@
+import {} from '@astrale-os/kernel-dsl/value';
+import { isDefinitionRef } from '../../../addressing/index.js';
+import { MEMBER_NAME_PATTERN } from '../../../addressing/patterns.js';
+import { invalid } from '../diagnostic.js';
+import { object, exact } from './value.js';
+/** Check a Domain or projected declaration endpoint. */
+export function coreEndpoint(input, label, path) {
+    const value = object(input, label, path);
+    if (value.kind === 'domain')
+        exact(value, ['kind'], label, path);
+    else
+        projectedMemberRef(value, label, path);
+}
+/** Check a Policy reference to a projected declaration. */
+export function policyObjectRef(input, path) {
+    projectedMemberRef(object(input, 'Policy object ref', path), 'Policy object ref', path);
+}
+function projectedMemberRef(ref, label, path) {
+    if (ref.kind !== 'method') {
+        definitionRef(ref, undefined, label, path);
+        return;
+    }
+    exact(ref, ['kind', 'owner', 'name'], `${label} Method`, path);
+    definitionRef(ref.owner, 'class', `${label} Method owner`, `${path}/owner`);
+    if (typeof ref.name !== 'string' || !MEMBER_NAME_PATTERN.test(ref.name))
+        invalid(`${label} Method name`, undefined, `${path}/name`);
+}
+/** Require a canonical Definition coordinate of the expected kind. */
+export function definitionRef(input, kind, label, path) {
+    if (!isDefinitionRef(input) || (kind !== undefined && input.kind !== kind))
+        invalid(label, undefined, path);
+    return input;
+}

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

@@ -0,0 +1,29 @@
+import { type Value as JsonValue, type Object as JsonObject } from '@astrale-os/kernel-dsl/value';
+/** Require a portable Object at the named wire boundary. */
+export declare function object(input: JsonValue | undefined, label: string, path: string): JsonObject;
+/** Require a portable Array at the named wire boundary. */
+export declare function array(input: JsonValue | undefined, label: string, path: string): readonly JsonValue[];
+/** Reject unknown and missing members in deterministic diagnostic order. */
+export declare function exact(value: JsonObject, required: readonly string[], label: string, path: string, optional?: readonly string[]): void;
+/** Require a non-negative safe integer. */
+export declare function integer(input: JsonValue | undefined, label: string, path: string): number;
+/** Require an integer within an inclusive interval. */
+export declare function boundedInteger(input: JsonValue | undefined, minimum: number, maximum: number, label: string, path: string): number;
+/** Require a Boolean wire value. */
+export declare function boolean(input: JsonValue | undefined, label: string, path: string): boolean;
+/** Require a String wire value. */
+export declare function string(input: JsonValue | undefined, label: string, path: string): string;
+/** Require a canonical declaration member name. */
+export declare function memberName(input: JsonValue | undefined, label: string, path: string): string;
+/** Check the length of an optional String member. */
+export declare function boundedString(input: JsonValue | undefined, minimum: number, maximum: number, label: string, path: string): void;
+/** Check the optional declaration description budget. */
+export declare function description(input: JsonValue | undefined, label: string, path: string): void;
+/** Reject the first repeated value at its exact index. */
+export declare function unique(values: readonly string[], label: string, path: string): void;
+/** Require an index within the referenced table. */
+export declare function index(input: JsonValue | undefined, length: number, label: string, path: string): number;
+/** Require a Unicode scalar-range bound. */
+export declare function scalar(input: JsonValue | undefined, label: string, path: string): number;
+/** Order wire names independently of the host locale. */
+export declare function compare(left: string, right: string): number;

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

@@ -0,0 +1,98 @@
+import {} from '@astrale-os/kernel-dsl/value';
+import { MEMBER_NAME_PATTERN } from '../../../addressing/patterns.js';
+import { invalid, pointer } from '../diagnostic.js';
+/** Require a portable Object at the named wire boundary. */
+export function object(input, label, path) {
+    if (input === null || typeof input !== 'object' || Array.isArray(input))
+        invalid(label, undefined, path);
+    return input;
+}
+/** Require a portable Array at the named wire boundary. */
+export function array(input, label, path) {
+    if (!Array.isArray(input))
+        invalid(label, undefined, path);
+    return input;
+}
+/** Reject unknown and missing members in deterministic diagnostic order. */
+export function exact(value, required, label, path, optional = []) {
+    const allowed = new Set([...required, ...optional]);
+    const unknown = Object.keys(value)
+        .filter((key) => !allowed.has(key))
+        .sort(compare)[0];
+    if (unknown !== undefined)
+        invalid(label, undefined, pointer(path, unknown));
+    const missing = required.find((key) => !Object.hasOwn(value, key));
+    if (missing !== undefined)
+        invalid(label, undefined, pointer(path, missing));
+}
+/** Require a non-negative safe integer. */
+export function integer(input, label, path) {
+    if (!Number.isSafeInteger(input) || input < 0)
+        invalid(label, undefined, path);
+    return input;
+}
+/** Require an integer within an inclusive interval. */
+export function boundedInteger(input, minimum, maximum, label, path) {
+    const value = integer(input, label, path);
+    if (value < minimum || value > maximum)
+        invalid(label, undefined, path);
+    return value;
+}
+/** Require a Boolean wire value. */
+export function boolean(input, label, path) {
+    if (typeof input !== 'boolean')
+        invalid(label, undefined, path);
+    return input;
+}
+/** Require a String wire value. */
+export function string(input, label, path) {
+    if (typeof input !== 'string')
+        invalid(label, undefined, path);
+    return input;
+}
+/** Require a canonical declaration member name. */
+export function memberName(input, label, path) {
+    const value = string(input, label, path);
+    if (!MEMBER_NAME_PATTERN.test(value))
+        invalid(label, undefined, path);
+    return value;
+}
+/** Check the length of an optional String member. */
+export function boundedString(input, minimum, maximum, label, path) {
+    if (input === undefined)
+        return;
+    const value = string(input, label, path);
+    if (value.length < minimum || value.length > maximum)
+        invalid(label, undefined, path);
+}
+/** Check the optional declaration description budget. */
+export function description(input, label, path) {
+    boundedString(input, 1, 1000, label, path);
+}
+/** Reject the first repeated value at its exact index. */
+export function unique(values, label, path) {
+    const seen = new Set();
+    for (const [indexValue, value] of values.entries()) {
+        if (seen.has(value))
+            invalid(label, undefined, `${path}/${indexValue}`);
+        seen.add(value);
+    }
+}
+/** Require an index within the referenced table. */
+export function index(input, length, label, path) {
+    const value = integer(input, label, path);
+    if (value >= length)
+        invalid(label, undefined, path);
+    return value;
+}
+/** Require a Unicode scalar-range bound. */
+export function scalar(input, label, path) {
+    const value = integer(input, label, path);
+    if (value > 0x10ffff)
+        invalid(label, undefined, path);
+    return value;
+}
+/** Order wire names independently of the host locale. */
+export function compare(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}

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

@@ -0,0 +1,3 @@
+import { type Value as JsonValue } from '@astrale-os/kernel-dsl/value';
+/** Decode a View and its explicit target grammar. */
+export declare function compiledView(input: JsonValue, path: string): never;

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

@@ -0,0 +1,17 @@
+import {} from '@astrale-os/kernel-dsl/value';
+import { invalid } from '../diagnostic.js';
+import { definitionRef } from './reference.js';
+import { object, exact, description } from './value.js';
+/** Decode a View and its explicit target grammar. */
+export function compiledView(input, path) {
+    const value = object(input, 'View', path);
+    exact(value, ['ref', 'target'], 'View', path, ['description']);
+    definitionRef(value.ref, 'view', 'View ref', `${path}/ref`);
+    description(value.description, 'View description', `${path}/description`);
+    const targetPath = `${path}/target`;
+    const target = object(value.target, 'View target', targetPath);
+    exact(target, ['kind'], 'Domain View target', targetPath);
+    if (target.kind !== 'domain')
+        invalid('View target', undefined, targetPath);
+    return value;
+}

package/dist/v1/compiled/compiler/compile.js

@@ -1,6 +1,7 @@
+import { isBinaryInput } from '../../language/callable/model/callable.js';
 import { inputFieldNodes } from '../../language/value/compile/fields.js';
 import { prepareValueSchema } from '../../language/value/evaluate/preparation.js';
-import { classifyOrdering } from '../../language/value/ordering.js';
+import { classifyPreparedOrdering } from '../../language/value/ordering.js';
 import { revisionOfDomainSchema } from '../../schema/canonical/revision.js';
 import { lookupForDomainClosure, requireDomainClosure } from '../../schema/resolution/closure.js';
 import { createDomainValueSchemaRegistry } from '../../schema/resolution/value.registry.js';
@@ -16,7 +17,7 @@ export function compile(schema) {
     const closure = Object.freeze(sources.map((source) => compileEntry(source, lookup)));
     return Object.freeze({
         format: 'astrale.dsl.compiled-schema',
-        version: 1,
+        version: 2,
         root: Object.freeze({ origin: schema.origin, revision: revisionOfDomainSchema(schema) }),
         closure,
     });
@@ -24,24 +25,40 @@ export function compile(schema) {
 function compileEntry(schema, lookup) {
     const registry = createDomainValueSchemaRegistry(schema, lookup);
     const values = [];
-    const add = (contract, pointer) => {
-        const result = prepareValueSchema(contract, registry, pointer);
+    const pool = new Map();
+    const patternIndices = new Map();
+    const prepare = (contract, pointer) => {
+        const result = prepareValueSchema(contract, registry, pointer, pool);
         if (!result.compiled)
             throw new TypeError(`Cannot compile ValueSchema: ${result.message}`);
-        return values.push(result.value.program()) - 1;
+        return result.value;
     };
+    const addProgram = (program) => {
+        const patterns = program.patterns.map((pattern) => {
+            let index = patternIndices.get(pattern);
+            if (index === undefined) {
+                index = patternIndices.size;
+                patternIndices.set(pattern, index);
+            }
+            return index;
+        });
+        return values.push(Object.freeze({ ...program, patterns: Object.freeze(patterns) })) - 1;
+    };
+    const add = (contract, pointer) => addProgram(prepare(contract, pointer).program());
     const properties = (definition, pointer) => Object.entries(definition.properties)
         .sort(([left], [right]) => compare(left, right))
         .map(([name, property]) => {
-        const ordering = classifyOrdering(property.schema, registry);
+        const prepared = prepare(property.schema, `${pointer}/properties/${name}/schema`);
+        const ordering = classifyPreparedOrdering(prepared);
         return {
             name,
             required: property.required,
-            visibility: property.visibility,
             ...(property.auto === undefined ? {} : { auto: property.auto }),
+            ...(property.immutable === undefined ? {} : { immutable: property.immutable }),
             ...(property.description === undefined ? {} : { description: property.description }),
+            ...(property.state === undefined ? {} : { state: property.state }),
             ...(ordering === undefined ? {} : { ordering }),
-            value: add(property.schema, `${pointer}/properties/${name}/schema`),
+            value: addProgram(prepared.program()),
         };
     });
     const output = (value, pointer) => value.mode === 'binary'
@@ -70,7 +87,8 @@ function compileEntry(schema, lookup) {
                 ...(method.policy === undefined ? {} : { policy: method.policy }),
                 ...(method.description === undefined ? {} : { description: method.description }),
                 static: method.static,
-                inheritance: method.inheritance,
+                abstract: method.abstract,
+                ...(method.execution === undefined ? {} : { execution: method.execution }),
                 input,
                 ...(fields === undefined ? {} : { fields }),
                 output: output(method.output, `${pointer}/methods/${name}/output`),
@@ -81,13 +99,24 @@ function compileEntry(schema, lookup) {
     const functions = Object.values(schema.functions)
         .sort((left, right) => compare(left.ref.name, right.ref.name))
         .map((definition) => {
-        const input = add(definition.input, `/functions/${definition.ref.name}/input`);
-        const fields = inputFieldNodes(values[input]);
+        const binary = isBinaryInput(definition.input);
+        const inputIndex = add(binary ? definition.input.metadata : definition.input, binary
+            ? `/functions/${definition.ref.name}/input/metadata`
+            : `/functions/${definition.ref.name}/input`);
+        const input = binary
+            ? {
+                mode: 'binary',
+                metadata: inputIndex,
+                maximumBytes: definition.input.maximumBytes,
+            }
+            : inputIndex;
+        const fields = inputFieldNodes(values[inputIndex]);
         return {
             ref: definition.ref,
             auth: definition.auth,
             ...(definition.policy === undefined ? {} : { policy: definition.policy }),
             ...(definition.description === undefined ? {} : { description: definition.description }),
+            ...(definition.execution === undefined ? {} : { execution: definition.execution }),
             input,
             ...(fields === undefined ? {} : { fields }),
             output: output(definition.output, `/functions/${definition.ref.name}/output`),
@@ -96,6 +125,8 @@ function compileEntry(schema, lookup) {
     return Object.freeze({
         origin: schema.origin,
         revision: revisionOfDomainSchema(schema),
+        name: schema.name,
+        ...(schema.entrypoint === undefined ? {} : { entrypoint: schema.entrypoint }),
         dependencies: schema.dependencies,
         definitions: Object.freeze({
             classes: Object.freeze(classes),
@@ -106,6 +137,7 @@ function compileEntry(schema, lookup) {
         }),
         facts: Object.freeze({ core: schema.core.edges }),
         values: Object.freeze(values),
+        patterns: Object.freeze([...patternIndices.keys()]),
     });
 }
 function compare(left, right) {

package/dist/v1/compiled/generated.d.ts

@@ -0,0 +1,10 @@
+import type { Domain } from '../domain/model/domain.js';
+import type { CompiledSchema, DomainOfCompiled } from './model/schema.js';
+declare const GENERATED_COMPILED_SCHEMA: unique symbol;
+/** Exact compiled material embedded by an Astrale build generator. */
+export interface GeneratedCompiledSchema<Resolved = Domain> extends CompiledSchema<Resolved> {
+    readonly [GENERATED_COMPILED_SCHEMA]: 'generated-compiled-schema';
+}
+/** Realize immutable, build-owned compiled material without repeating external admission. */
+export declare function load<const Input extends GeneratedCompiledSchema>(input: Input): DomainOfCompiled<Input>;
+export {};