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

package/dist/v1/language/class/inheritance.js

@@ -0,0 +1,25 @@
+/** Kernel graph roots are intrinsic supertypes, not authored structural Edge contracts. */
+export function isGraphRoot(value) {
+    return (value.ref.origin === 'kernel.astrale.ai' &&
+        value.ref.name === (value.kind === 'node' ? 'Node' : 'Edge'));
+}
+/** Same-kind satisfaction includes the intrinsic root and the declared parent closure. */
+export function classSatisfies(candidate, required, resolve) {
+    if (candidate.kind !== required.kind)
+        return false;
+    if (isGraphRoot(required))
+        return true;
+    const seen = new Set();
+    const visit = (value) => {
+        if (value.ref.origin === required.ref.origin && value.ref.name === required.ref.name)
+            return true;
+        if (seen.has(value))
+            return false;
+        seen.add(value);
+        return value.extends.some((ref) => {
+            const parent = resolve(ref);
+            return parent !== undefined && parent.kind === required.kind && visit(parent);
+        });
+    };
+    return visit(candidate);
+}

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

@@ -45,6 +45,7 @@ export interface ResolvedClass<Kind extends ClassKind = ClassKind, Properties ex
     readonly kind: Kind;
     readonly abstract: boolean;
     readonly definition: Definition;
+    /** Explicitly authored parents; intrinsic graph roots do not alter schema bytes. */
     readonly extends: Parents & readonly ResolvedClass<Kind>[];
     /** Local observation Policies; Class inheritance never contributes an attachment. */
     readonly policies: Definition['policies'];
@@ -62,14 +63,17 @@ export interface ResolvedClass<Kind extends ClassKind = ClassKind, Properties ex
             readonly methods: Kind extends 'node' ? SelfStaticMethods : ResolvedMethodCollection<Record<never, never>>;
         };
     };
+    /** Same-kind nominal inheritance, including the universal Kernel Node or Edge root. */
     satisfies(selected: ResolvedClass<Kind>): boolean;
     validateProperties(input: unknown): readonly Diagnostic[];
 }
 /** One resolved Class with an exact graph kind, used at heterogeneous Domain boundaries. */
 export type AnyResolvedClass = ResolvedClass<'node'> | ResolvedClass<'edge'>;
-/** Exact Class keys satisfied by one resolved Class, including transitive parents. */
+/** Class keys satisfied by one resolved Class, including its graph root and transitive parents. */
 export type ClassSatisfactionKeysOf<Class> = ClassSatisfactionKeys<Class, never>;
 type ClassSatisfactionKeys<Class, Seen> = Class extends Seen ? never : (Class extends {
+    readonly kind: infer Kind extends ClassKind;
+} ? DefinitionKey<'kernel.astrale.ai', 'class', Kind extends 'node' ? 'Node' : 'Edge'> : never) | (Class extends {
     readonly key: infer ExactKey extends DefinitionKey<Key.Origin, 'class'>;
 } ? ExactKey : never) | (Class extends ResolvedClass<ClassKind, ResolvedPropertyCollection, ResolvedMethodCollection, ResolvedMethodCollection, ResolvedPropertyCollection, ResolvedMethodCollection, ResolvedMethodCollection, ClassDefinition, infer Parents> ? ClassSatisfactionKeys<Extract<Parents[number], ResolvedClass>, Seen | Class> : never);
 export type PropertyValueOf<Property> = Property extends ResolvedProperty<infer Value, boolean, StateTopology | undefined, unknown> ? Value : never;

package/dist/v1/language/definition/metadata.d.ts

@@ -10,3 +10,11 @@ export declare const icon: Readonly<{
     readonly minLength: 1;
     readonly maxLength: 8000;
 }>;
+/** Exact V1 bound for the required human-facing display name a new Domain revision declares. */
+export declare const name: Readonly<{
+    readonly type: 'string';
+    readonly minLength: 1;
+    readonly maxLength: 100;
+}>;
+/** The common source and compiled grammar for a name displayed exactly as authored. */
+export declare function isDomainNameText(value: string): boolean;

package/dist/v1/language/definition/metadata.js

@@ -10,3 +10,15 @@ export const icon = Object.freeze({
     minLength: 1,
     maxLength: 8000,
 });
+/** Exact V1 bound for the required human-facing display name a new Domain revision declares. */
+export const name = Object.freeze({
+    type: 'string',
+    minLength: 1,
+    maxLength: 100,
+});
+// oxlint-disable-next-line no-control-regex
+const DOMAIN_NAME_CONTROL = /[\u0000-\u001f\u007f-\u009f\u2028\u2029]/u;
+/** The common source and compiled grammar for a name displayed exactly as authored. */
+export function isDomainNameText(value) {
+    return value.trim() === value && !DOMAIN_NAME_CONTROL.test(value);
+}

package/dist/v1/language/value/model/blob.d.ts

@@ -21,8 +21,6 @@ export interface BlobOptions {
     readonly mediaTypes?: readonly string[];
 }
 export declare const BLOB_VALUE_KIND: 'blob';
-export declare const BLOB_DIGEST_PATTERN = "sha256:[0-9a-f]{64}";
-export declare const BLOB_MEDIA_TYPE_PATTERN = "[a-z0-9!#$%&'*+.^_`|~-]+/[a-z0-9!#$%&'*+.^_`|~-]+(;[a-z0-9!#$%&'*+.^_`|~-]+=[!#$%&'*+.^_`|~0-9A-Za-z-]+)*";
 /** Build the one canonical V1 schema shape for a blob-valued Node property. */
 export declare function blob(options: BlobOptions): BlobSchema;
 /** Marker recognition on an already admitted V1 value schema. */

package/dist/v1/language/value/model/blob.js

@@ -1,6 +1,6 @@
 export const BLOB_VALUE_KIND = 'blob';
-export const BLOB_DIGEST_PATTERN = 'sha256:[0-9a-f]{64}';
-export const BLOB_MEDIA_TYPE_PATTERN = "[a-z0-9!#$%&'*+.^_`|~-]+/[a-z0-9!#$%&'*+.^_`|~-]+(;[a-z0-9!#$%&'*+.^_`|~-]+=[!#$%&'*+.^_`|~0-9A-Za-z-]+)*";
+const BLOB_DIGEST_PATTERN = 'sha256:[0-9a-f]{64}';
+const BLOB_MEDIA_TYPE_PATTERN = "[a-z0-9!#$%&'*+.^_`|~-]+/[a-z0-9!#$%&'*+.^_`|~-]+(;[a-z0-9!#$%&'*+.^_`|~-]+=[!#$%&'*+.^_`|~0-9A-Za-z-]+)*";
 const TOKEN = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/u;
 const DIGEST = /^sha256:[0-9a-f]{64}$/u;
 /** Build the one canonical V1 schema shape for a blob-valued Node property. */

package/dist/v1/language/value/model/instant.d.ts

@@ -1,6 +1,4 @@
 /** Exact portable UTC millisecond Instant used by the V1 value-schema dialect. */
-/** Canonical value-language annotation for an Instant string. */
-export declare const INSTANT_VALUE_KIND: 'instant';
 export declare const instant: Readonly<{
     readonly type: 'string';
     readonly 'x-astrale-value-kind': 'instant';

package/dist/v1/language/value/model/instant.js

@@ -1,6 +1,6 @@
 /** Exact portable UTC millisecond Instant used by the V1 value-schema dialect. */
 /** Canonical value-language annotation for an Instant string. */
-export const INSTANT_VALUE_KIND = 'instant';
+const INSTANT_VALUE_KIND = 'instant';
 export const instant = Object.freeze({
     type: 'string',
     'x-astrale-value-kind': INSTANT_VALUE_KIND,

package/dist/v1/language/value/model/schema.d.ts

@@ -21,5 +21,6 @@ export interface PathAnnotation {
     readonly cardinality: 'one';
     readonly accepts: readonly ClassRef[];
 }
-export declare const VALUE_SCHEMA_CONTEXTS: readonly ['property-facet', 'callable-input', 'callable-output'];
+declare const VALUE_SCHEMA_CONTEXTS: readonly ['property-facet', 'callable-input', 'callable-output'];
 export type ValueSchemaContext = (typeof VALUE_SCHEMA_CONTEXTS)[number];
+export {};

package/dist/v1/language/value/model/schema.js

@@ -4,8 +4,4 @@ export const JSON_SCHEMA_DIALECT = 'https://json-schema.org/draft/2020-12/schema
 export const VALUE_SCHEMA_DIALECT = 'https://schemas.astrale.ai/dsl/v1/value-schema';
 /** Required vocabulary carried by the V1 value-schema dialect. */
 export const VALUE_SCHEMA_VOCABULARY = 'https://schemas.astrale.ai/dsl/v1/value-schema/vocabulary';
-export const VALUE_SCHEMA_CONTEXTS = [
-    'property-facet',
-    'callable-input',
-    'callable-output',
-];
+const VALUE_SCHEMA_CONTEXTS = ['property-facet', 'callable-input', 'callable-output'];

package/dist/v1/language/value/reference/registry.d.ts

@@ -1,6 +1,6 @@
 import type { ClassRef } from '../../../addressing/index.js';
 import type { JsonSchema } from '../model/schema.js';
-export interface ValueSchemaDependency {
+interface ValueSchemaDependency {
     readonly origin: string;
     readonly revision: `sha256:${string}`;
 }
@@ -22,3 +22,4 @@ export interface ValueSchemaRegistry {
     readonly transitiveDependencies: readonly ValueSchemaDomainRegistry[];
     readonly graphNodePath: JsonSchema;
 }
+export {};

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

@@ -3,10 +3,11 @@
  * parser's bounds on length, nesting and counts; `states` when its machine would exceed the state
  * budget.
  */
-export type IRegexpRefusal = 'syntax' | 'states';
+type IRegexpRefusal = 'syntax' | 'states';
 /** The refusal of one source, through the same AST and state count as compilation. */
 export declare function refuseIRegexp(source: string): IRegexpRefusal | undefined;
 /** Complete RFC 9485 syntax admission, within the implementation limits RFC 9485 §8 allows. */
 export declare function isIRegexp(source: string): boolean;
 /** The authoring explanation of a `states` refusal of `subject` (`pattern`, `fullMatch`, ...). */
 export declare function stateBudgetMessage(subject: string): string;
+export {};

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

@@ -1,9 +1,7 @@
-import type { ClassRef, DefinitionBase, ViewRef } from '../../../addressing/index.js';
+import type { DefinitionBase, ViewRef } from '../../../addressing/index.js';
+/** Every View targets its owning Domain. */
 export type ViewTarget = {
     readonly kind: 'domain';
-} | {
-    readonly kind: 'definition';
-    readonly definitions: readonly [ClassRef, ...ClassRef[]];
 };
 export interface ViewDefinition extends DefinitionBase<ViewRef> {
     readonly description?: string;

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 {
@@ -24,7 +25,7 @@ export interface EffectiveMethod {
     readonly name: string;
     readonly declaration: MethodDefinition;
 }
-export interface EffectiveData {
+interface EffectiveData {
     readonly identity: string;
     readonly owner: ClassRef;
     readonly declaration: DataDefinition;
@@ -67,3 +68,4 @@ export declare function methodSignature(value: MethodDefinition): {
         durable: boolean;
     } | undefined;
 };
+export {};

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/canonical/revision.d.ts

@@ -1,6 +1,6 @@
 import type { Revision } from '../../addressing/index.js';
 import { type DomainSchema, type DomainSchemaIR } from '../model/schema.js';
-export interface CanonicalDomainSchema {
+interface CanonicalDomainSchema {
     readonly schema: DomainSchema;
     readonly bytes: Uint8Array;
     readonly revision: Revision;
@@ -9,3 +9,4 @@ export declare function canonicalDomainSchema(value: DomainSchema): CanonicalDom
 /** Internal acceptance seam. The caller must establish whole-Domain validity first. */
 export declare function canonicalDomainSchemaAfterValidation(value: DomainSchemaIR): CanonicalDomainSchema;
 export declare function revisionOfDomainSchema(schema: DomainSchema): Revision;
+export {};

package/dist/v1/schema/compatibility/comparators/classes.d.ts

@@ -6,7 +6,7 @@ import type { ClassCoordinate } from '../coordinate.js';
 import type { DependencyMeaningLevel } from '../fields.js';
 import type { Report } from '../report.js';
 import type { ComparisonContext, SubjectPair } from '../scope.js';
-export interface ClassRequirement {
+interface ClassRequirement {
     readonly ancestors: readonly SemanticKey[];
 }
 /**
@@ -44,3 +44,4 @@ export declare function compareAddedProperties({ context, pair, report, }: {
     readonly pair: SubjectPair;
     readonly report: Report;
 }): void;
+export {};

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

@@ -29,7 +29,7 @@ export declare function memberCoordinate(ref: MemberRef): MemberCoordinate;
 export declare function propertyCoordinate(owner: ClassRef, name: string): PropertyCoordinate;
 export declare function methodCoordinate(owner: ClassRef, name: string): MethodCoordinate;
 export declare function keyForDefinitionRef(ref: DefinitionRef): SemanticKey;
-export interface ParsedKeyReference {
+interface ParsedKeyReference {
     readonly kind: Definition.Kind;
     readonly name: string;
     readonly member?: 'property' | 'method';
@@ -37,3 +37,4 @@ export interface ParsedKeyReference {
 }
 /** Interpret one canonical V1 Key as a Definition or a Class member location. */
 export declare function keyReference(key: SemanticKey): ParsedKeyReference;
+export {};

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/compatibility/references.js

@@ -46,11 +46,6 @@ export function rootReferences(schema) {
         collectCallableRefs(declaration, collector(schema, result, keyForDefinitionRef(declaration.ref)));
     for (const declaration of Object.values(schema.policies))
         collectPolicyDefinitionRefs(declaration, collector(schema, result, keyForDefinitionRef(declaration.ref)));
-    for (const declaration of Object.values(schema.views))
-        if (declaration.target.kind === 'definition') {
-            const add = collector(schema, result, keyForDefinitionRef(declaration.ref));
-            declaration.target.definitions.forEach((ref) => add(ref, 'view'));
-        }
     collectCoreRefs(schema, collector(schema, result));
     return result;
 }
@@ -127,12 +122,8 @@ export function memberReferences(subject) {
         case 'policy':
             collectPolicyDefinitionRefs(schema.policies[ref.name], add);
             break;
-        case 'view': {
-            const view = schema.views[ref.name];
-            if (view.target.kind === 'definition')
-                view.target.definitions.forEach((ref) => add(ref, 'view'));
+        case 'view':
             break;
-        }
         case 'core': {
             add(schema.core.nodes[ref.name].class, 'endpoint');
             for (const edge of schema.core.edges) {

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

@@ -2,7 +2,7 @@ import type { Value } from '@astrale-os/kernel-dsl/value';
 import type { Assessment, ComparisonEntry, Facet } from './model.js';
 import type { Reference } from './references.js';
 import type { SubjectPair } from './scope.js';
-export interface ComparisonFact {
+interface ComparisonFact {
     readonly pair: SubjectPair;
     readonly facet: Facet;
     readonly before?: Value;
@@ -24,3 +24,4 @@ export declare function createReport(): {
 export type Report = ReturnType<typeof createReport>;
 /** Full comparison merges facts; it never reclassifies the two analyses' conclusions. */
 export declare function mergeEntries(...groups: readonly (readonly ComparisonEntry[])[]): readonly ComparisonEntry[];
+export {};

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

@@ -34,7 +34,3 @@ export declare function prepare(request: ComparisonRequest): ComparisonContext;
  * of a version that may declare none.
  */
 export declare function selectMembers(source: DomainSchema, target: DomainSchema, keys: readonly Key[]): ComparisonContext;
-export declare function retainedContext(dependent: DomainSchema, origin: Key.Origin, path: '/target/origin' | '/origin'): {
-    source: DomainSchema;
-    context: Context;
-};

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

@@ -99,7 +99,7 @@ function comparisonContext({ kind, source, target, dependent, before, roots, cap
         },
     };
 }
-export function retainedContext(dependent, origin, path) {
+function retainedContext(dependent, origin, path) {
     resolve(dependent);
     const source = (knownDomainClosure(dependent) ?? []).find((entry) => entry.schema.origin === origin)?.schema;
     if (source === undefined)

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_ENTRYPOINT' | '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' | '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/model/schema.d.ts

@@ -1,5 +1,5 @@
 import type { Key } from '../../addressing/index.js';
-import type { DomainDependencyMap } from '../../addressing/index.js';
+import type { DomainDependencyMap, ViewRef } from '../../addressing/index.js';
 import type { Domain, DomainOfSource, DomainSource } from '../../domain/model/domain.js';
 import type { FunctionDefinition } from '../../language/callable/model/callable.js';
 import type { ClassDefinition } from '../../language/class/model/class.js';
@@ -10,6 +10,10 @@ export interface DomainSchemaIR {
     readonly format: 'astrale.dsl';
     readonly version: 'v1';
     readonly origin: Key.Origin;
+    /** Human-facing display name of the Domain, projected as its Domain Node `name`. */
+    readonly name: string;
+    /** The one View this Domain opens by default, projected as its `entrypoint` Edge. */
+    readonly entrypoint?: ViewRef;
     readonly dependencies: DomainDependencyMap;
     readonly classes: Readonly<Record<string, ClassDefinition>>;
     readonly functions: Readonly<Record<string, FunctionDefinition>>;

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

@@ -13,6 +13,16 @@ export function normalizeDomainSchema(schema) {
         format: 'astrale.dsl',
         version: 'v1',
         origin: schema.origin,
+        name: schema.name,
+        ...(schema.entrypoint === undefined
+            ? {}
+            : {
+                entrypoint: {
+                    origin: schema.entrypoint.origin,
+                    kind: 'view',
+                    name: schema.entrypoint.name,
+                },
+            }),
         dependencies: mapRecord(schema.dependencies, (dependency) => ({ ...dependency })),
         classes,
         functions: mapRecord(schema.functions, canonicalizeFunction),
@@ -42,12 +52,7 @@ function canonicalizeView(value) {
     return {
         ref: value.ref,
         ...withDescription(value),
-        target: value.target.kind === 'domain'
-            ? { kind: 'domain' }
-            : {
-                kind: 'definition',
-                definitions: [...value.target.definitions].sort(compareDefinitionRefs),
-            },
+        target: { kind: 'domain' },
     };
 }
 function canonicalizeClass(value) {
@@ -142,6 +147,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/definition.index.d.ts

@@ -1,4 +1,4 @@
-import type { ClassRef, DefinitionRef } from '../../addressing/index.js';
+import type { ClassRef } from '../../addressing/index.js';
 import type { ClassDefinition } from '../../language/class/model/class.js';
 import type { DomainSchemaIR } from '../model/schema.js';
 /** One exact Class declaration resolved within the retained Domain closure. */
@@ -18,4 +18,3 @@ export type IndexedClassDefinition = {
     }>;
 };
 export declare function indexSchemaDefinitions(schema: DomainSchemaIR): ReadonlyMap<string, IndexedClassDefinition>;
-export declare function resolveIndexedReference(indexes: ReadonlyMap<string, IndexedClassDefinition>, ref: DefinitionRef): IndexedClassDefinition | undefined;

package/dist/v1/schema/resolution/definition.index.js

@@ -12,6 +12,3 @@ export function indexSchemaDefinitions(schema) {
     }
     return result;
 }
-export function resolveIndexedReference(indexes, ref) {
-    return ref.kind === 'class' ? indexes.get(definitionRefIndex(ref)) : 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/resolution/origins.d.ts

@@ -10,7 +10,7 @@ import type { DomainSchemaIR } from '../model/schema.js';
  * instantiates the Definition; every other site only refers to it. `pattern` is the Edge Class a
  * Policy pattern matches, whose orientation and accepted endpoint Classes Policy typing reads.
  */
-export type ReferenceSite = 'extends' | 'endpoint' | 'value' | 'policy' | 'pattern' | 'view' | 'core';
+export type ReferenceSite = 'extends' | 'endpoint' | 'value' | 'policy' | 'pattern' | 'core';
 /**
  * What a site names: a Definition, or the Class-owned Method a Policy object term names. A Policy
  * keeps the Method itself, since it resolves that Method's own executable declaration; a collector

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

@@ -25,11 +25,6 @@ export function collectDomainDefinitionRefs(schema) {
     for (const declaration of Object.values(schema.policies)) {
         collectPolicyDefinitionRefs(declaration, add);
     }
-    for (const declaration of Object.values(schema.views)) {
-        if (declaration.target.kind === 'definition') {
-            declaration.target.definitions.forEach((ref) => add(ref, 'view'));
-        }
-    }
     collectCoreRefs(schema, add);
     return Object.freeze([...result.values()].sort(compareDefinitionRefs));
 }