@astrale-os/kernel-dsl 0.2.0-beta.45 → 0.2.0-beta.47

package/dist/v1/addressing/class-key.js

@@ -20,10 +20,11 @@ export function ClassKey(input) {
     function is(input) {
         if (typeof input !== 'string' || !Key.is(input))
             return false;
-        const separator = input.indexOf(':');
-        return (input.slice(separator + 1).startsWith('class.') &&
-            !input.includes('.property.') &&
-            !input.includes('.method.'));
+        // Only the coordinate is tested: an origin label may itself be `property` or `method`.
+        const coordinate = input.slice(input.indexOf(':') + 1);
+        return (coordinate.startsWith('class.') &&
+            !coordinate.includes('.property.') &&
+            !coordinate.includes('.method.'));
     }
     ClassKey.is = is;
     function ref(input) {

package/dist/v1/addressing/method-key.js

@@ -21,8 +21,9 @@ export function MethodKey(input) {
     function is(input) {
         if (typeof input !== 'string' || !Key.is(input))
             return false;
-        const coordinate = input.slice(input.indexOf(':') + 1);
-        return coordinate.startsWith('class.') && coordinate.includes('.method.');
+        // The member kind is the third segment: the owner Class may itself be named `method`.
+        const [kind, , member] = input.slice(input.indexOf(':') + 1).split('.');
+        return kind === 'class' && member === 'method';
     }
     MethodKey.is = is;
     function address(input) {

package/dist/v1/builder/class/property.d.ts

@@ -1,5 +1,5 @@
 import type { z } from 'zod';
-import type { AutoEvent, AutoSet } from '../../language/class/model/property.js';
+import type { AutoEvent, AutoSet, PropertyImmutability } from '../../language/class/model/property.js';
 import type { StateMachine } from '../../language/state/index.js';
 import type { JsonSchema } from '../../language/value/model/schema.js';
 import type { AUTHORING } from '../schema/handle.js';
@@ -9,6 +9,8 @@ export type ValueSchemaInput = z.ZodType | JsonSchema;
 export interface PropertyOptions {
     readonly required?: boolean;
     readonly description?: string;
+    /** `create` freezes the value at creation; `once` admits one write while absent. */
+    readonly immutable?: PropertyImmutability;
 }
 export interface AutoOptions {
     readonly on: AutoEvent | readonly AutoEvent[];

package/dist/v1/builder/class/property.js

@@ -10,7 +10,12 @@ export function autoPropertyAuthoringInput(value) {
 }
 export function property(schema, options) {
     const admitted = options ?? {};
-    assertKnownKeys(admitted, ['required', 'description']);
+    assertKnownKeys(admitted, ['required', 'description', 'immutable']);
+    if (admitted.immutable !== undefined &&
+        admitted.immutable !== 'create' &&
+        admitted.immutable !== 'once') {
+        fail('BUILDER_PROPERTY_IMMUTABLE_INVALID', '/immutable', 'immutable is create or once.');
+    }
     return authoringValue('property', {
         [PROPERTY_INPUT]: {
             schema,
@@ -34,6 +39,9 @@ export function auto(property, options) {
         fail('BUILDER_AUTO_NESTED', '', 'auto(...) cannot wrap another auto Property.');
     }
     assertKnownKeys(options, ['on', 'set']);
+    if (propertyAuthoringInput(property).options.immutable !== undefined) {
+        fail('BUILDER_AUTO_IMMUTABLE', '', 'An auto Property cannot be immutable.');
+    }
     const authored = Array.isArray(options.on) ? options.on : [options.on];
     if (authored.length === 0)
         fail('BUILDER_AUTO_EVENT_INVALID', '/on', 'auto(...) requires an event.');

package/dist/v1/builder/lowering/schema/compile.js

@@ -47,7 +47,7 @@ function assembleDomainSchema(origin, input, lookup) {
     }));
     const policies = mapRecord(input.policies ?? {}, (value, name) => policyCompiler.compile(value, name, `/policies/${escapeToken(name)}`));
     assertPolicyCompositionAcyclic(policies, origin);
-    const views = mapRecord(input.views ?? {}, (value, name) => viewCompiler.compile(value, name, `/views/${escapeToken(name)}`));
+    const views = mapRecord(input.views ?? {}, (value, name) => viewCompiler.compile(value, name));
     const core = compileCore(input.core, context);
     const semanticContent = {
         format: 'astrale.dsl',

package/dist/v1/builder/lowering/value/compile.js

@@ -37,6 +37,9 @@ export class BuilderValueSchemas {
                 schema: canonicalizeValueSchema(schema, 'property-facet', this.registry),
                 required: authoredInput?.options.required ?? isRequired(schemaInput),
                 ...(autoInput === undefined ? {} : { auto: autoInput.options }),
+                ...(authoredInput?.options.immutable === undefined
+                    ? {}
+                    : { immutable: authoredInput.options.immutable }),
                 ...(authoredInput?.options.description === undefined
                     ? {}
                     : { description: authoredInput.options.description }),

package/dist/v1/builder/lowering/value/zod.js

@@ -161,7 +161,10 @@ function inspectCheck(def, pointer, diagnostics) {
         return;
     }
     if (def.check === 'string_format' && def.format === 'regex' && def.pattern instanceof RegExp) {
-        if (!isLosslessRegexp(def.pattern)) {
+        if (def.pattern.flags === '') {
+            diagnostics.push(diagnostic('ZOD_SCHEMA_NOT_LOSSLESS', pointer, 'Zod RegExp without the u flag reads \\p{...} as literal text, and classes and quantifiers by UTF-16 code unit, unlike the V1 I-Regexp it would lower to; add the u flag.'));
+        }
+        else if (!isLosslessRegexp(def.pattern)) {
             diagnostics.push(diagnostic('ZOD_SCHEMA_NOT_LOSSLESS', pointer, 'Zod RegExp flags, anchors, dot semantics, or syntax cannot be preserved as a V1 I-Regexp substring pattern.'));
         }
     }
@@ -292,8 +295,14 @@ function escapePointerToken(value) {
 function isPlainRecord(value) {
     return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
+/**
+ * Whether a Zod RegExp search means its source read as an I-Regexp. Only the u flag qualifies:
+ * without it, `\p{L}` matches the text `p{L}`, and classes and quantifiers apply to UTF-16 code
+ * units rather than scalars; `v` reads class syntax differently, and every other flag changes the
+ * match itself.
+ */
 function isLosslessRegexp(pattern) {
-    if (pattern.flags !== '' && pattern.flags !== 'u')
+    if (pattern.flags !== 'u')
         return false;
     if (!isIRegexp(pattern.source))
         return false;

package/dist/v1/builder/lowering/view.d.ts

@@ -2,10 +2,10 @@ import type { ViewDefinition } from '../../language/view/model/view.js';
 import type { View } from '../view/authoring.js';
 import type { BuilderContext } from './schema/context.js';
 export interface ViewCompiler {
-    compile(value: View, name: string, pointer: string): ViewDefinition;
+    compile(value: View, name: string): ViewDefinition;
 }
 export declare class V1ViewCompiler implements ViewCompiler {
     readonly context: BuilderContext;
     constructor(context: BuilderContext);
-    compile(value: View, name: string, pointer: string): ViewDefinition;
+    compile(value: View, name: string): ViewDefinition;
 }

package/dist/v1/builder/lowering/view.js

@@ -1,27 +1,15 @@
-import { compareDefinitionRefs } from '../../addressing/ordering.js';
 import { viewAuthoringInput } from '../view/authoring.js';
 export class V1ViewCompiler {
     context;
     constructor(context) {
         this.context = context;
     }
-    compile(value, name, pointer) {
+    compile(value, name) {
         const config = viewAuthoringInput(value);
-        const target = config.target;
         return {
             ref: { origin: this.context.origin, kind: 'view', name },
             ...(config.description === undefined ? {} : { description: config.description }),
-            target: target === undefined || target === 'domain'
-                ? { kind: 'domain' }
-                : {
-                    kind: 'definition',
-                    definitions: (isTargetList(target) ? target : [target])
-                        .map((entry, index) => this.context.resolveNodeClass(entry, `${pointer}/target/definitions/${index}`))
-                        .sort(compareDefinitionRefs),
-                },
+            target: { kind: 'domain' },
         };
     }
 }
-function isTargetList(input) {
-    return Array.isArray(input);
-}

package/dist/v1/builder/schema/diagnostic.d.ts

@@ -1,5 +1,5 @@
 import type { DiagnosticCode as LanguageDiagnosticCode } from '../../language/validation/diagnostic.js';
-export type BuilderDiagnosticCode = LanguageDiagnosticCode | 'BUILDER_ABSTRACT_POLICY' | 'BUILDER_AMBIGUOUS_OWNERSHIP' | 'BUILDER_AUTO_EVENT_INVALID' | 'BUILDER_AUTO_NESTED' | 'BUILDER_AUTO_SET_INVALID' | 'BUILDER_CALLABLE_AUTH' | 'BUILDER_CALLABLE_PLACEMENT' | 'BUILDER_CALLABLE_POLICY_AUTH' | 'BUILDER_CORE_CLASS' | 'BUILDER_CORE_EDGE' | 'BUILDER_CORE_NODE' | 'BUILDER_CORE_PROPERTY' | 'BUILDER_CORE_REF' | 'BUILDER_DEFINITION' | 'BUILDER_DEPENDENCY_CONFLICT' | 'BUILDER_DEPENDENCY_ALIAS' | 'BUILDER_DEPENDENCY_DIRECT' | 'BUILDER_DUPLICATE_MEMBER' | 'BUILDER_FOREIGN_POLICY' | 'BUILDER_FULL_MATCH_INVALID' | 'BUILDER_FUNCTION' | 'BUILDER_METHOD' | 'BUILDER_PATH_DUPLICATE' | 'BUILDER_PATH_EMPTY' | 'BUILDER_POLICY' | 'BUILDER_POLICY_COMPOSITION' | 'BUILDER_POLICY_CYCLE' | 'BUILDER_POLICY_EMPTY_COMPOSITION' | 'BUILDER_POLICY_EMPTY_EXISTS' | 'BUILDER_POLICY_INPUT' | 'BUILDER_POLICY_REF' | 'BUILDER_POLICY_SELF' | 'BUILDER_REFERENCE_CYCLE' | 'BUILDER_REFERENCE_KIND' | 'BUILDER_REFERENCE_MISSING' | 'BUILDER_UNKNOWN_FIELD' | 'BUILDER_UNOWNED_REFERENCE' | 'BUILDER_VIEW' | 'ZOD_SCHEMA_NOT_LOSSLESS';
+export type BuilderDiagnosticCode = LanguageDiagnosticCode | 'BUILDER_ABSTRACT_POLICY' | 'BUILDER_AMBIGUOUS_OWNERSHIP' | 'BUILDER_AUTO_EVENT_INVALID' | 'BUILDER_AUTO_IMMUTABLE' | 'BUILDER_AUTO_NESTED' | 'BUILDER_AUTO_SET_INVALID' | 'BUILDER_CALLABLE_AUTH' | 'BUILDER_CALLABLE_PLACEMENT' | 'BUILDER_CALLABLE_POLICY_AUTH' | 'BUILDER_CORE_CLASS' | 'BUILDER_CORE_EDGE' | 'BUILDER_CORE_NODE' | 'BUILDER_CORE_PROPERTY' | 'BUILDER_CORE_REF' | 'BUILDER_DEFINITION' | 'BUILDER_DEPENDENCY_CONFLICT' | 'BUILDER_DEPENDENCY_ALIAS' | 'BUILDER_DEPENDENCY_DIRECT' | 'BUILDER_DUPLICATE_MEMBER' | 'BUILDER_FOREIGN_POLICY' | 'BUILDER_FULL_MATCH_INVALID' | 'BUILDER_FUNCTION' | 'BUILDER_METHOD' | 'BUILDER_PATH_DUPLICATE' | 'BUILDER_PATH_EMPTY' | 'BUILDER_POLICY' | 'BUILDER_POLICY_COMPOSITION' | 'BUILDER_POLICY_CYCLE' | 'BUILDER_POLICY_EMPTY_COMPOSITION' | 'BUILDER_POLICY_EMPTY_EXISTS' | 'BUILDER_POLICY_INPUT' | 'BUILDER_POLICY_REF' | 'BUILDER_POLICY_SELF' | 'BUILDER_PROPERTY_IMMUTABLE_INVALID' | 'BUILDER_REFERENCE_CYCLE' | 'BUILDER_REFERENCE_KIND' | 'BUILDER_REFERENCE_MISSING' | 'BUILDER_UNKNOWN_FIELD' | 'BUILDER_UNOWNED_REFERENCE' | 'BUILDER_VIEW' | 'ZOD_SCHEMA_NOT_LOSSLESS';
 export interface BuilderDiagnostic<out Code extends BuilderDiagnosticCode = BuilderDiagnosticCode> {
     readonly code: Code;
     readonly pointer: string;

package/dist/v1/builder/value/full-match.js

@@ -1,11 +1,14 @@
-import { isIRegexp } from '../../language/value/regexp/syntax.js';
+import { refuseIRegexp, stateBudgetMessage } from '../../language/value/regexp/syntax.js';
 import { fullMatch as languageFullMatch, } from '../../language/value/syntax/full-match.js';
 import { fail } from '../schema/diagnostic.js';
 export { fullMatchSource } from '../../language/value/syntax/full-match.js';
 /** Authoring facade preserving the Builder-owned diagnostic for invalid source syntax. */
 export function fullMatch(source) {
-    if (!isIRegexp(source)) {
-        fail('BUILDER_FULL_MATCH_INVALID', '/fullMatch', 'fullMatch(...) requires a complete RFC 9485 I-Regexp source.');
+    const refusal = refuseIRegexp(source);
+    if (refusal !== undefined) {
+        fail('BUILDER_FULL_MATCH_INVALID', '/fullMatch', refusal === 'syntax'
+            ? 'fullMatch(...) requires a complete RFC 9485 I-Regexp source.'
+            : stateBudgetMessage('fullMatch(...)'));
     }
     return languageFullMatch(source);
 }

package/dist/v1/builder/view/authoring.d.ts

@@ -1,13 +1,9 @@
-import type { NodeClassReferenceInput } from '../class/authoring.js';
 import type { AUTHORING } from '../schema/handle.js';
-export type ViewDefinitionTargetsInput = readonly [
-    NodeClassReferenceInput,
-    ...NodeClassReferenceInput[]
-];
-export type ViewTargetInput = 'domain' | NodeClassReferenceInput | ViewDefinitionTargetsInput;
+/** A View always targets its owning Domain; it declares no Class or Node target. */
 export interface ViewInput {
     readonly description?: string;
-    readonly target?: ViewTargetInput;
+    /** Removed: every View targets its owning Domain. Refused at compile time and at runtime. */
+    readonly target?: never;
 }
 export interface View {
     readonly [AUTHORING]: 'view';

package/dist/v1/builder/view/authoring.js

@@ -1,4 +1,4 @@
-import { assertKnownKeys } from '../schema/diagnostic.js';
+import { assertKnownKeys, fail } from '../schema/diagnostic.js';
 import { authoringValue } from '../schema/handle.js';
 const viewInputs = new WeakMap();
 /** Internal lowering access; View authoring handles expose no public configuration object. */
@@ -9,7 +9,10 @@ export function viewAuthoringInput(value) {
     return input;
 }
 export function view(config) {
-    assertKnownKeys(config, ['description', 'target']);
+    if (Object.hasOwn(config, 'target')) {
+        fail('BUILDER_VIEW', '/target', 'View target is removed: every View targets its owning Domain. Select a Node inside the View frontend instead.');
+    }
+    assertKnownKeys(config, ['description']);
     const value = authoringValue('view', {});
     viewInputs.set(value, { ...config });
     return value;

package/dist/v1/compiled/admission/accept.js

@@ -8,6 +8,8 @@ import { admitStateTopology } from '../../language/state/topology.js';
 import { bindValueProgram } from '../../language/value/compile/load.js';
 import { isValueObject } from '../../language/value/model/object.js';
 import { classifyValueProgramOrdering } from '../../language/value/ordering.js';
+import { compilePattern } from '../../language/value/regexp/compile.js';
+import { isIRegexp } from '../../language/value/regexp/syntax.js';
 import { invalidCompiled } from '../diagnostic.js';
 import { revisionOfCompiledEntry } from './revision.js';
 import { validateCompiledSemantics } from './semantics.js';
@@ -24,7 +26,8 @@ export function acceptCompiledSchema(input) {
     if (root.version !== 2)
         invalid('version', undefined, '/version');
     const rootPin = dependency(root.root, 'root', '/root');
-    const closure = array(root.closure, 'closure', '/closure').map((value, index) => entry(value, index, `/closure/${index}`));
+    const machines = new Map();
+    const closure = array(root.closure, 'closure', '/closure').map((value, index) => entry(value, index, `/closure/${index}`, machines));
     if (closure.length > dependencyLimits.closure) {
         invalid('dependency closure limit', 'COMPILED_DEPENDENCY_LIMITS', '/closure');
     }
@@ -74,7 +77,7 @@ export function acceptCompiledSchema(input) {
     validateCompiledSemantics(candidate);
     return deepFreeze(candidate);
 }
-function entry(input, entryIndex, path) {
+function entry(input, entryIndex, path, machines) {
     const value = object(input, `closure[${entryIndex}]`, path);
     exact(value, ['origin', 'revision', 'dependencies', 'definitions', 'facts', 'values', 'patterns'], 'entry', path);
     const origin = originValue(value.origin, 'entry origin', `${path}/origin`);
@@ -89,7 +92,7 @@ function entry(input, entryIndex, path) {
     }
     const valuesPath = `${path}/values`;
     const patternsPath = `${path}/patterns`;
-    const patterns = array(value.patterns, 'entry patterns', patternsPath).map((item, index) => pattern(item, index, `${patternsPath}/${index}`));
+    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`;
@@ -195,6 +198,7 @@ function compiledProperty(input, values, node, path) {
     exact(value, ['name', 'required', 'value'], 'Compiled Property', path, [
         'auto',
         'description',
+        'immutable',
         'ordering',
         'state',
     ]);
@@ -203,6 +207,9 @@ function compiledProperty(input, values, node, path) {
     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) {
@@ -838,10 +845,28 @@ function valueNode(input, nodeIndex, path) {
             : { reference: integer(value.reference, 'reference', `${path}/reference`) }),
     };
 }
-function pattern(input, patternIndex, path) {
+/**
+ * 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.
+ */
+function pattern(input, patternIndex, path, machines) {
     const value = object(input, `patterns[${patternIndex}]`, path);
-    if (Object.hasOwn(value, 'runs'))
-        return runPattern(value, 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`);

package/dist/v1/compiled/admission/semantics.js

@@ -21,10 +21,11 @@ export function validateCompiledSemantics(candidate) {
     const partial = index(candidate);
     const analyses = analyzeClasses(partial.classes);
     const context = { ...partial, analyses };
+    const admitted = admittedOrigins(candidate);
     validateClassFacets(context);
-    validateEdges(context);
+    validateEdges(context, admitted);
     validateViews(candidate, context);
-    validatePolicies(candidate, context);
+    validatePolicies(candidate, context, admitted);
     validateCore(candidate, context);
 }
 function index(candidate) {
@@ -161,6 +162,14 @@ function validateClassFacets(context) {
                     fail(`${path}/auto/set`, 'The instant setter requires an Instant value program.');
                 }
             }
+            if (property.immutable !== undefined) {
+                if (property.auto !== undefined || property.state !== undefined) {
+                    fail(`${path}/immutable`, 'An immutable Property is neither automatic nor a State Property.');
+                }
+                if (property.immutable === 'once' && property.required) {
+                    fail(`${path}/immutable`, 'A required immutable Property is declared create, not once.');
+                }
+            }
         }
         if (located.value.kind === 'node') {
             for (const [index, method] of located.value.methods.entries()) {
@@ -171,7 +180,30 @@ function validateClassFacets(context) {
         }
     }
 }
-function validateEdges(context) {
+/**
+ * The origins each closure entry was admitted against: itself and its transitive dependencies.
+ * Source admission decides undirected overlap and types Policies within that closure alone, so a
+ * dependent's Class extending a dependency's Classes never reaches the dependency's own decisions.
+ */
+function admittedOrigins(candidate) {
+    const entries = new Map(candidate.closure.map((entry) => [entry.origin, entry]));
+    const scopes = new Map();
+    const scope = (origin) => {
+        const known = scopes.get(origin);
+        if (known !== undefined)
+            return known;
+        const origins = new Set([origin]);
+        for (const dependency of Object.values(entries.get(origin)?.dependencies ?? {}))
+            for (const reached of scope(dependency.origin))
+                origins.add(reached);
+        scopes.set(origin, origins);
+        return origins;
+    };
+    for (const entry of candidate.closure)
+        scope(entry.origin);
+    return scopes;
+}
+function validateEdges(context, admitted) {
     for (const located of context.classes.values()) {
         if (!isCompiledEdge(located.value))
             continue;
@@ -194,7 +226,7 @@ function validateEdges(context) {
         }
         if (edge.orientation === 'undirected' &&
             !sameIncidentEndpoint(edge.endpoints[0], edge.endpoints[1]) &&
-            undirectedOverlap(context, edge.endpoints)) {
+            undirectedOverlap(context, edge.endpoints, admitted.get(located.entry.origin))) {
             fail(`${located.pointer}/endpoints`, 'Unequal undirected endpoint contracts overlap.');
         }
         for (const [parentIndex, parentRef] of edge.extends.entries()) {
@@ -242,8 +274,9 @@ function sameIncidentEndpoint(left, right) {
         a.length === b.length &&
         a.every((value, index) => value === b[index]));
 }
-function undirectedOverlap(context, endpoints) {
-    return [...context.classes.values()].some(({ value }) => value.kind === 'node' &&
+function undirectedOverlap(context, endpoints, origins) {
+    return [...context.classes.values()].some(({ value }) => origins.has(value.ref.origin) &&
+        value.kind === 'node' &&
         !value.abstract &&
         classSatisfiesAny(context, value.ref, endpoints[0].accepts) &&
         classSatisfiesAny(context, value.ref, endpoints[1].accepts));
@@ -274,14 +307,14 @@ function validateViews(candidate, context) {
         }
     }
 }
-function validatePolicies(candidate, context) {
+function validatePolicies(candidate, context, admitted) {
     for (const [entryIndex, entry] of candidate.closure.entries()) {
         const localPolicies = new Map(entry.definitions.policies.map((value) => [value.ref.name, value]));
         for (const [policyIndex, policy] of entry.definitions.policies.entries()) {
             validatePolicyExpression(context, entry, policy.expression, `/closure/${entryIndex}/definitions/policies/${policyIndex}/expression`, localPolicies);
         }
         validatePolicyCycles(entry, localPolicies, entryIndex);
-        validatePolicyParity(context, entry, entryIndex, localPolicies);
+        validatePolicyParity(context, entry, entryIndex, localPolicies, admitted.get(entry.origin));
         for (const [functionIndex, callable] of entry.definitions.functions.entries()) {
             if (callable.policy !== undefined)
                 validateCallablePolicy(context, entry, callable.policy, typeof callable.input === 'number' ? callable.input : callable.input.metadata, callable.fields, false, `/closure/${entryIndex}/definitions/functions/${functionIndex}/policy`);
@@ -455,9 +488,9 @@ function isNodeClassRef(context, value) {
     }
     return context.classes.get(Key.of(ref))?.value.kind === 'node';
 }
-function validatePolicyParity(context, entry, entryIndex, policies) {
+function validatePolicyParity(context, entry, entryIndex, policies, origins) {
     const normalized = new Map([...policies].map(([name, policy]) => [name, normalizePolicyExpression(policy.expression)]));
-    const typing = new CompiledPolicyTyping(context, entry, normalized);
+    const typing = new CompiledPolicyTyping(context, entry, normalized, origins);
     for (const [name, declaration] of policies) {
         const path = `/closure/${entryIndex}/definitions/policies/${declarationIndex(entry, 'policies', name)}`;
         if ('match' in declaration.expression) {
@@ -602,21 +635,21 @@ function nodePathAccepts(entry, input, field) {
         ? annotation.accepts
         : [];
 }
+/** Types one entry's Policies against the Node Classes of its own closure, as source admission. */
 class CompiledPolicyTyping {
     context;
     entry;
     normalized;
     allNodeClasses;
     concreteNodeClasses;
-    constructor(context, entry, normalized) {
+    constructor(context, entry, normalized, origins) {
         this.context = context;
         this.entry = entry;
         this.normalized = normalized;
-        this.allNodeClasses = [...context.classes.values()]
-            .filter(({ value }) => value.kind === 'node')
-            .map(({ value }) => value.ref);
-        this.concreteNodeClasses = [...context.classes.values()]
-            .filter(({ value }) => value.kind === 'node' && !value.abstract)
+        const nodeClasses = [...context.classes.values()].filter(({ value }) => value.kind === 'node' && origins.has(value.ref.origin));
+        this.allNodeClasses = nodeClasses.map(({ value }) => value.ref);
+        this.concreteNodeClasses = nodeClasses
+            .filter(({ value }) => !value.abstract)
             .map(({ value }) => value.ref);
     }
     expandedBranches(name, visiting, namespace) {

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

@@ -54,6 +54,7 @@ function compileEntry(schema, lookup) {
             name,
             required: property.required,
             ...(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 }),

package/dist/v1/compiled/loader/load.js

@@ -125,6 +125,7 @@ function programValidation(programs, properties, propertyOrdering, callables) {
         propertyValidation.set(key, Object.freeze({
             ordering: propertyOrdering.get(key),
             validate: (value) => validateValueProgram(program, value),
+            program: () => program,
         }));
     }
     const callableValidation = new Map();

package/dist/v1/domain/create.js

@@ -104,24 +104,6 @@ export function createDomain(input) {
             definitions(kind) {
                 return kind === undefined ? local : local.filter(({ ref }) => ref.kind === kind);
             },
-            viewsFor(target) {
-                return Object.freeze(Object.values(views).filter((view) => {
-                    if (view.target.kind === 'domain')
-                        return target === 'domain';
-                    if (target === 'domain')
-                        return false;
-                    return view.target.definitions.some((ref) => {
-                        const selected = classesByKey.get(Key.of(ref));
-                        if (target.kind === 'node' && selected?.kind === 'node') {
-                            return target.satisfies(selected);
-                        }
-                        if (target.kind === 'edge' && selected?.kind === 'edge') {
-                            return target.satisfies(selected);
-                        }
-                        return false;
-                    });
-                }));
-            },
         };
         const admitted = Object.freeze(domain);
         facades.set(entry.origin, admitted);
@@ -175,7 +157,6 @@ function createDefinitions(declarations, classesByKey, input) {
             definitionsByKey.set(key, Object.freeze({
                 ref: definition.ref,
                 key,
-                target: definition.target,
                 description: definition.description,
                 definition,
             }));

package/dist/v1/domain/model/domain.d.ts

@@ -36,7 +36,6 @@ export interface Domain<Classes extends Readonly<Record<string, unknown>> = Read
     callable(key: Key.Callable): ResolvedCallable | undefined;
     definitions(): readonly ResolvedDefinition[];
     definitions<const Kind extends DefinitionRef['kind']>(kind: Kind): readonly ResolvedDefinitionOf<Kind>[];
-    viewsFor(target: 'domain' | AnyResolvedClass): readonly Views[keyof Views][];
 }
 declare const DOMAIN_SOURCE_RESOLVED: unique symbol;
 /** Type-only witness carried by a source that retains its exact resolved Domain. */

package/dist/v1/domain/model/input.d.ts

@@ -3,6 +3,7 @@ import type { DomainDependency, DomainDependencyMap } from '../../addressing/ind
 import type { CoreEdge } from '../../language/core/model/core.js';
 import type { Definition } from '../../language/definition.js';
 import type { Diagnostic } from '../../language/validation/diagnostic.js';
+import type { ValueProgram } from '../../language/value/compile/model.js';
 import type { OrderingKind } from '../../language/value/ordering.js';
 /** One admitted Schema entry in a dependency-closed Domain universe. */
 export interface DomainEntryInput {
@@ -22,6 +23,8 @@ export interface DomainInput {
 export interface DomainValidation {
     propertyExists(key: PropertyKey): boolean;
     property(key: PropertyKey, input: unknown): readonly Diagnostic[];
+    /** The admitted program `property` evaluates. */
+    propertyProgram(key: PropertyKey): ValueProgram;
     propertyOrdering(key: PropertyKey): OrderingKind | undefined;
     callableExists(key: AddressKey.Callable): boolean;
     callableInput(key: AddressKey.Callable, input: unknown): readonly Diagnostic[];

package/dist/v1/domain/projection/classes.js

@@ -45,6 +45,7 @@ export function createClasses(definitions, validation) {
                 definition: propertyDefinition,
                 ...(ordering === undefined ? {} : { ordering }),
                 validate: (input) => validation.property(propertyKey, input),
+                program: () => validation.propertyProgram(propertyKey),
             });
             ownProperties.push(property);
             effectiveProperties.set(property.key, property);

package/dist/v1/domain/validation/create.d.ts

@@ -1,10 +1,12 @@
 import type { Key, PropertyKey } from '../../addressing/index.js';
 import type { Diagnostic } from '../../language/validation/diagnostic.js';
+import type { ValueProgram } from '../../language/value/compile/model.js';
 import type { OrderingKind } from '../../language/value/ordering.js';
 import type { DomainValidation } from '../model/input.js';
 export interface PropertyValidation {
     readonly ordering?: OrderingKind;
     validate(input: unknown): readonly Diagnostic[];
+    program(): ValueProgram;
 }
 export interface CallableValidation {
     readonly fields?: readonly string[];

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

@@ -6,6 +6,12 @@ export function createDomainValidation(properties, callables) {
             const target = properties.get(key);
             return target === undefined ? unknownTarget('Property', key) : target.validate(input);
         },
+        propertyProgram(key) {
+            const target = properties.get(key);
+            if (target === undefined)
+                throw new TypeError(`Property ${key} is absent.`);
+            return target.program();
+        },
         propertyOrdering: (key) => properties.get(key)?.ordering,
         callableExists: (key) => callables.has(key),
         callableInput(key, input) {
@@ -33,6 +39,12 @@ export function combineDomainValidation(values) {
             const owner = values.find((value) => value.propertyExists(key));
             return owner === undefined ? unknownTarget('Property', key) : owner.property(key, input);
         },
+        propertyProgram(key) {
+            const owner = values.find((value) => value.propertyExists(key));
+            if (owner === undefined)
+                throw new TypeError(`Property ${key} is absent.`);
+            return owner.propertyProgram(key);
+        },
         propertyOrdering: (key) => values.find((value) => value.propertyExists(key))?.propertyOrdering(key),
         callableExists: (key) => values.some((value) => value.callableExists(key)),
         callableInput(key, input) {

package/dist/v1/language/class/model/property.d.ts

@@ -1,5 +1,7 @@
 export type AutoEvent = 'create' | 'update';
 export type AutoSet = 'instant';
+/** `create`: written only by node or edge creation. `once`: written while absent, never unset. */
+export type PropertyImmutability = 'create' | 'once';
 export interface PropertyAuto {
     readonly on: readonly AutoEvent[];
     readonly set: AutoSet;
@@ -8,6 +10,7 @@ export interface PropertyDefinition {
     readonly schema: import('../../value/model/schema.js').JsonSchema;
     readonly required: boolean;
     readonly auto?: PropertyAuto;
+    readonly immutable?: PropertyImmutability;
     readonly description?: string;
     readonly state?: import('../../state/index.js').StateTopology;
 }

package/dist/v1/language/class/resolved.d.ts

@@ -3,6 +3,7 @@ import type { ClassRef, DefinitionKey, Key, PropertyKey } from '../../addressing
 import type { ResolvedMethodCollection } from '../callable/resolved.js';
 import type { StateTopology } from '../state/index.js';
 import type { Diagnostic } from '../validation/diagnostic.js';
+import type { ValueProgram } from '../value/compile/model.js';
 import type { OrderingKind } from '../value/ordering.js';
 import type { ClassDefinition, ClassKind } from './model/class.js';
 import type { DataDefinition } from './model/data.js';
@@ -19,6 +20,8 @@ export interface ResolvedProperty<out Value = PortableValue, out Required extend
     /** The one portable scalar ordering domain, when the Property is orderable. */
     readonly ordering?: OrderingKind;
     validate(input: unknown): readonly Diagnostic[];
+    /** The admitted program `validate` evaluates. */
+    program(): ValueProgram;
     readonly __value?: Value;
     readonly __input?: Input;
 }

package/dist/v1/language/index.d.ts

@@ -4,6 +4,8 @@ export type { ClassRef, CoreRef, DefinitionBase, DefinitionKey, DefinitionRef, F
 export type { Value as PropertyValue } from '@astrale-os/kernel-dsl/value';
 export type { JsonSchema as ValueSchema, JsonSchemaObject as ValueSchemaObject, } from './value/model/schema.js';
 export type { OrderingKind } from './value/ordering.js';
+export type { ValueProgram } from './value/compile/model.js';
+export { valueProgramIncludes } from './value/inclusion/includes.js';
 export { stateMachine } from './state/index.js';
 export type { EventOf, StateMachine, StateOf, StateTopology } from './state/index.js';
 export type * from './callable/model/callable.js';