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

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/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/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

@@ -198,6 +198,7 @@ function compiledProperty(input, values, node, path) {
     exact(value, ['name', 'required', 'value'], 'Compiled Property', path, [
         'auto',
         'description',
+        'immutable',
         'ordering',
         'state',
     ]);
@@ -206,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) {

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

@@ -162,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()) {

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/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/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/view/model/view.d.ts

@@ -1,4 +1,10 @@
 import type { ClassRef, DefinitionBase, ViewRef } from '../../../addressing/index.js';
+/**
+ * Document target of one View. Every View targets its owning Domain: authoring and compilation
+ * only produce `{ kind: 'domain' }`. The `definition` member is the legacy Class target of earlier
+ * V1 documents; admission still accepts it so already-persisted documents keep their exact revision
+ * and recover, but it carries no meaning and Runtime installation refuses it for a new revision.
+ */
 export type ViewTarget = {
     readonly kind: 'domain';
 } | {

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

@@ -1,9 +1,9 @@
 import type { DefinitionKey, ViewRef } from '../../addressing/index.js';
-import type { ViewDefinition, ViewTarget } from './model/view.js';
+import type { ViewDefinition } from './model/view.js';
+/** One resolved View of its owning Domain. A View has no Class or Node target. */
 export interface ResolvedView {
     readonly ref: ViewRef;
     readonly key: DefinitionKey<string, 'view'>;
-    readonly target: ViewTarget;
     readonly description?: ViewDefinition['description'];
     readonly definition: ViewDefinition;
 }

package/dist/v1/schema/analysis/class.d.ts

@@ -2,7 +2,7 @@ import type { ClassRef } from '../../addressing/index.js';
 import type { MethodDefinition } from '../../language/callable/model/callable.js';
 import type { ClassDefinition } from '../../language/class/model/class.js';
 import type { DataDefinition } from '../../language/class/model/data.js';
-import type { PropertyAuto } from '../../language/class/model/property.js';
+import type { PropertyAuto, PropertyImmutability } from '../../language/class/model/property.js';
 import type { StateTopology } from '../../language/state/index.js';
 import type { JsonSchema } from '../../language/value/model/schema.js';
 import type { SchemaDiagnostic } from '../diagnostic.js';
@@ -16,6 +16,7 @@ export interface EffectiveField {
     readonly schema: JsonSchema;
     readonly required: boolean;
     readonly auto?: PropertyAuto;
+    readonly immutable?: PropertyImmutability;
     readonly state?: StateTopology;
 }
 export interface EffectiveMethod {

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

@@ -63,6 +63,7 @@ function ownFields(owner, declaration) {
             schema: property.schema,
             required: property.required,
             ...(property.auto === undefined ? {} : { auto: property.auto }),
+            ...(property.immutable === undefined ? {} : { immutable: property.immutable }),
             ...(property.state === undefined ? {} : { state: property.state }),
         });
     }

package/dist/v1/schema/compatibility/context.d.ts

@@ -2,11 +2,15 @@ import type { ClassRef, DefinitionRef, Key as SemanticKey } from '../../addressi
 import type { DefinitionAnalysis, EffectiveMethod } from '../analysis/class.js';
 import type { DomainSchema } from '../model/schema.js';
 import { SchemaError } from '../diagnostic.js';
-/** One accepted root with its exact closure and a memoized semantic analysis per owner. */
+/** One accepted root with its exact closure and a memoized Definition analysis per owner. */
 export interface Context {
     readonly schemas: ReadonlyMap<string, DomainSchema>;
-    analysis(owner: DomainSchema): ReadonlyMap<string, DefinitionAnalysis> | undefined;
+    analysis(owner: DomainSchema): ReadonlyMap<string, DefinitionAnalysis>;
 }
+/**
+ * Every owner passed acceptance against the closure it retains, which is the only way a schema
+ * gets one, so its analysis is derived without validating it again.
+ */
 export declare function contextOf(root: DomainSchema): Context;
 export declare function effectiveDefinition(context: Context, owner: DomainSchema, ref: ClassRef): DefinitionAnalysis | undefined;
 /** Effective Methods are keyed by name; a coordinate names one by its exact Method Key. */

package/dist/v1/schema/compatibility/context.js

@@ -1,8 +1,13 @@
 import { MethodKey } from '../../addressing/index.js';
 import { definitionRefIndex } from '../../addressing/ordering.js';
+import { analyzeDefinitions } from '../analysis/class.js';
 import { SchemaError, diagnostic } from '../diagnostic.js';
 import { knownDomainClosure, lookupForDomainClosure } from '../resolution/closure.js';
-import { validateDomainSchemaSemantics } from '../validation/domain.js';
+import { buildDomainResolutionContext } from '../resolution/context.js';
+/**
+ * Every owner passed acceptance against the closure it retains, which is the only way a schema
+ * gets one, so its analysis is derived without validating it again.
+ */
 export function contextOf(root) {
     const schemas = new Map([
         [root.origin, root],
@@ -12,16 +17,17 @@ export function contextOf(root) {
     return {
         schemas,
         analysis(owner) {
-            if (!analyses.has(owner)) {
-                const validation = validateDomainSchemaSemantics(owner, lookupForDomainClosure(owner));
-                analyses.set(owner, validation.diagnostics.length > 0 ? undefined : validation.analysis.definitions);
+            let definitions = analyses.get(owner);
+            if (definitions === undefined) {
+                definitions = analyzeDefinitions(buildDomainResolutionContext(owner, lookupForDomainClosure(owner))).definitions;
+                analyses.set(owner, definitions);
             }
-            return analyses.get(owner);
+            return definitions;
         },
     };
 }
 export function effectiveDefinition(context, owner, ref) {
-    return context.analysis(owner)?.get(definitionRefIndex(ref));
+    return context.analysis(owner).get(definitionRefIndex(ref));
 }
 /** Effective Methods are keyed by name; a coordinate names one by its exact Method Key. */
 export function effectiveMethod(analysis, key) {

package/dist/v1/schema/compatibility/fields.d.ts

@@ -43,6 +43,7 @@ export declare const PROPERTY_FIELDS: Readonly<{
     schema: "always";
     required: "always";
     auto: "always";
+    immutable: "always";
     state: "always";
     description: Readonly<{
         excluded: 'annotation';
@@ -132,6 +133,7 @@ export declare const FIELD_ROLES: Readonly<{
         schema: "always";
         required: "always";
         auto: "always";
+        immutable: "always";
         state: "always";
         description: Readonly<{
             excluded: 'annotation';

package/dist/v1/schema/compatibility/fields.js

@@ -22,6 +22,7 @@ export const PROPERTY_FIELDS = Object.freeze({
     schema: 'always',
     required: 'always',
     auto: 'always',
+    immutable: 'always',
     state: 'always',
     description: ANNOTATION,
 });

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

@@ -1,4 +1,4 @@
-export type SchemaDiagnosticCode = 'DM_CAPABILITY_INVALID' | 'DM_MEMBER_ROOT_INVALID' | 'DM_DEPENDENCY_CONTEXT_INVALID' | 'DM_DEPENDENCY_NOT_RETAINED' | 'DM_MEANING_INCONSISTENT' | 'DM_MEMBER_ORIGIN_MISMATCH' | 'DV_ACCEPTANCE_CONTEXT' | 'DV_CALLABLE_AUTH' | 'DV_CALLABLE_IO' | 'DV_CALLABLE_POLICY_AUTH' | 'DV_CLASS_ABSTRACT' | 'DV_CLASS_ACYCLIC' | 'DV_CLASS_KIND' | 'DV_CORE_EDGE_CLASS' | 'DV_CORE_EDGE_CONSTRAINTS' | 'DV_CORE_EDGE_KEY' | 'DV_CORE_EDGE_PROPERTIES' | 'DV_CORE_NODE_CLASS' | 'DV_CORE_NODE_PROPERTIES' | 'DV_CORE_REF' | 'DV_DATA_COMPOSITION' | 'DV_DEPENDENCY_ACYCLIC' | 'DV_DEPENDENCY_DIRECT' | 'DV_DEPENDENCY_EXACT' | 'DV_DEPENDENCY_LIMITS' | 'DV_DEPENDENCY_REVISION_COHERENCE' | 'DV_DEPENDENCY_UNIQUE' | 'DV_EDGE_ACCEPTS' | 'DV_EDGE_CLASS_COMPOSITION' | 'DV_EDGE_CONSTRAINT' | 'DV_EDGE_ROLE' | 'DV_EDGE_UNDIRECTED' | 'DV_JSON_VALUE' | 'DV_METHOD_ABSTRACT' | 'DV_METHOD_COMPOSITION' | 'DV_PROPERTY_AUTO' | 'DV_PROPERTY_COMPOSITION' | 'DV_PROPERTY_STATE' | 'DV_REF_RESOLVES' | 'DV_VALUE_SCHEMA' | 'DV_VIEW_TARGET' | 'PL_BUDGET' | 'PL_COMPOSITION' | 'PL_CONNECTIVITY' | 'PL_REF' | 'PL_REPEAT' | 'PL_TARGET' | 'PL_TYPING' | 'PL_USE' | 'PL_VARIABLE_SCOPE' | 'STRUCTURE_ABSTRACT_POLICY' | 'STRUCTURE_CALLABLE_POLICY_AUTH' | 'STRUCTURE_DUPLICATE_ITEM' | 'STRUCTURE_EDGE_ORIENTATION' | 'STRUCTURE_FORMAT' | 'STRUCTURE_INVALID' | 'STRUCTURE_KEY' | 'STRUCTURE_MAXIMUM' | 'STRUCTURE_MINIMUM' | 'STRUCTURE_MULTIPLE' | 'STRUCTURE_REQUIRED' | 'STRUCTURE_TYPE' | 'STRUCTURE_UNION' | 'STRUCTURE_UNKNOWN_FIELD' | 'STRUCTURE_VALUE' | 'UNSUPPORTED_DOCUMENT_FORMAT' | 'UNSUPPORTED_DSL_VERSION';
+export type SchemaDiagnosticCode = 'DM_CAPABILITY_INVALID' | 'DM_MEMBER_ROOT_INVALID' | 'DM_DEPENDENCY_CONTEXT_INVALID' | 'DM_DEPENDENCY_NOT_RETAINED' | 'DM_MEANING_INCONSISTENT' | 'DM_MEMBER_ORIGIN_MISMATCH' | 'DV_ACCEPTANCE_CONTEXT' | 'DV_CALLABLE_AUTH' | 'DV_CALLABLE_IO' | 'DV_CALLABLE_POLICY_AUTH' | 'DV_CLASS_ABSTRACT' | 'DV_CLASS_ACYCLIC' | 'DV_CLASS_KIND' | 'DV_CORE_EDGE_CLASS' | 'DV_CORE_EDGE_CONSTRAINTS' | 'DV_CORE_EDGE_KEY' | 'DV_CORE_EDGE_PROPERTIES' | 'DV_CORE_NODE_CLASS' | 'DV_CORE_NODE_PROPERTIES' | 'DV_CORE_REF' | 'DV_DATA_COMPOSITION' | 'DV_DEPENDENCY_ACYCLIC' | 'DV_DEPENDENCY_DIRECT' | 'DV_DEPENDENCY_EXACT' | 'DV_DEPENDENCY_LIMITS' | 'DV_DEPENDENCY_REVISION_COHERENCE' | 'DV_DEPENDENCY_UNIQUE' | 'DV_EDGE_ACCEPTS' | 'DV_EDGE_CLASS_COMPOSITION' | 'DV_EDGE_CONSTRAINT' | 'DV_EDGE_ROLE' | 'DV_EDGE_UNDIRECTED' | 'DV_JSON_VALUE' | 'DV_METHOD_ABSTRACT' | 'DV_METHOD_COMPOSITION' | 'DV_PROPERTY_AUTO' | 'DV_PROPERTY_COMPOSITION' | 'DV_PROPERTY_IMMUTABLE' | 'DV_PROPERTY_STATE' | 'DV_REF_RESOLVES' | 'DV_VALUE_SCHEMA' | 'DV_VIEW_TARGET' | 'PL_BUDGET' | 'PL_COMPOSITION' | 'PL_CONNECTIVITY' | 'PL_REF' | 'PL_REPEAT' | 'PL_TARGET' | 'PL_TYPING' | 'PL_USE' | 'PL_VARIABLE_SCOPE' | 'STRUCTURE_ABSTRACT_POLICY' | 'STRUCTURE_CALLABLE_POLICY_AUTH' | 'STRUCTURE_DUPLICATE_ITEM' | 'STRUCTURE_EDGE_ORIENTATION' | 'STRUCTURE_FORMAT' | 'STRUCTURE_INVALID' | 'STRUCTURE_KEY' | 'STRUCTURE_MAXIMUM' | 'STRUCTURE_MINIMUM' | 'STRUCTURE_MULTIPLE' | 'STRUCTURE_REQUIRED' | 'STRUCTURE_TYPE' | 'STRUCTURE_UNION' | 'STRUCTURE_UNKNOWN_FIELD' | 'STRUCTURE_VALUE' | 'UNSUPPORTED_DOCUMENT_FORMAT' | 'UNSUPPORTED_DSL_VERSION';
 export interface SchemaDiagnostic<out Code extends SchemaDiagnosticCode = SchemaDiagnosticCode> {
     readonly code: Code;
     readonly pointer: string;

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

@@ -142,6 +142,7 @@ function canonicalizeProperty(value) {
                     set: value.auto.set,
                 },
             }),
+        ...(value.immutable === undefined ? {} : { immutable: value.immutable }),
         ...(value.description === undefined ? {} : { description: value.description }),
         ...(value.state === undefined
             ? {}

package/dist/v1/schema/resolution/domain.d.ts

@@ -1,4 +1,7 @@
 import type { SourceDomain } from '../../domain/model/domain.js';
 import type { DomainSchema } from '../model/schema.js';
-/** Resolve one accepted Schema through its exact retained source closure. */
+/**
+ * Resolve one accepted Schema through its exact retained source closure. Acceptance validated it
+ * against that closure, which is the only way a Schema retains one, so it is not validated again.
+ */
 export declare function resolve<const S extends DomainSchema>(schema: S): SourceDomain<S>;

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

@@ -9,12 +9,14 @@ import { validateValueProgram } from '../../language/value/evaluate/program.js';
 import { validateJsonInstance, validatePreparedInstance, } from '../../language/value/evaluate/validate.js';
 import { classifyPreparedOrdering } from '../../language/value/ordering.js';
 import { revisionOfDomainSchema } from '../canonical/revision.js';
-import { SchemaError } from '../diagnostic.js';
-import { validateDomainSchemaSemantics } from '../validation/domain.js';
 import { lookupForDomainClosure } from './closure.js';
+import { buildDomainResolutionContext } from './context.js';
 import { createDomainValueSchemaRegistry } from './value.registry.js';
 const resolvedSchemas = new WeakMap();
-/** Resolve one accepted Schema through its exact retained source closure. */
+/**
+ * Resolve one accepted Schema through its exact retained source closure. Acceptance validated it
+ * against that closure, which is the only way a Schema retains one, so it is not validated again.
+ */
 export function resolve(schema) {
     const cached = resolvedSchemas.get(schema);
     if (cached !== undefined)
@@ -24,10 +26,7 @@ export function resolve(schema) {
     return resolved;
 }
 function resolveWithLookup(schema, lookup) {
-    const validation = validateDomainSchemaSemantics(schema, lookup);
-    if (validation.diagnostics.length > 0)
-        throw new SchemaError(validation.diagnostics);
-    const closure = [schema, ...validation.context.dependencies.values()];
+    const closure = [schema, ...buildDomainResolutionContext(schema, lookup).dependencies.values()];
     const registries = new Map(closure.map((owner) => [owner.origin, createDomainValueSchemaRegistry(owner, lookup)]));
     const input = {
         root: Object.freeze({

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

@@ -62,6 +62,15 @@ function validateFacet(environment, declaration, pointer, diagnostics) {
                 diagnostics.push(diagnostic('DV_PROPERTY_STATE', `${propertyPointer}/state`, error instanceof Error ? error.message : 'Invalid State topology.'));
             }
         }
+        if (property.immutable !== undefined) {
+            const immutablePointer = `${propertyPointer}/immutable`;
+            if (property.auto !== undefined || property.state !== undefined) {
+                diagnostics.push(diagnostic('DV_PROPERTY_IMMUTABLE', immutablePointer, 'An immutable Property is neither automatic nor a State Property.'));
+            }
+            if (property.immutable === 'once' && property.required) {
+                diagnostics.push(diagnostic('DV_PROPERTY_IMMUTABLE', immutablePointer, 'A required immutable Property is written at creation: declare it create, not once.'));
+            }
+        }
         if (property.auto === undefined)
             continue;
         const autoPointer = `${propertyPointer}/auto`;

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

@@ -43,6 +43,7 @@ const propertyDefinitionSchema = strictObject({
         on: uniqueArray(enumeration(['create', 'update'])).min(1),
         set: literal('instant'),
     }).optional(),
+    immutable: enumeration(['create', 'once']).optional(),
     description: descriptionSchema.optional(),
     state: stateTopologySchema.optional(),
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/kernel-dsl",
-  "version": "0.2.0-beta.46",
+  "version": "0.2.0-beta.47",
   "description": "Astrale Kernel DSL - Schema authoring, inference, and IR serialization",
   "license": "Apache-2.0",
   "repository": {