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

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,15 +1,7 @@
-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.
- */
+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/schema/analysis/class.d.ts

@@ -25,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;
@@ -68,3 +68,4 @@ export declare function methodSignature(value: MethodDefinition): {
         durable: boolean;
     } | undefined;
 };
+export {};

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/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/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_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 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) {

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/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));
 }

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

@@ -1,6 +1,7 @@
 import { Key } from '../../addressing/key.js';
 import { definitionRefIndex } from '../../addressing/ordering.js';
 import { isMethodExecutable } from '../../language/callable/executable.js';
+import { classSatisfies as satisfiesClass, isGraphRoot } from '../../language/class/inheritance.js';
 import { admitStateTopology } from '../../language/state/topology.js';
 import { isBlobValueSchema } from '../../language/value/model/blob.js';
 import { classifyOrdering } from '../../language/value/ordering.js';
@@ -114,10 +115,6 @@ function validateEdgeContract(environment, owner, declaration, diagnostics) {
     validateEndpoint(environment, owner, endpoints[0], declaration.orientation === 'directed' ? 'source' : 'first endpoint', diagnostics);
     validateEndpoint(environment, owner, endpoints[1], declaration.orientation === 'directed' ? 'target' : 'second endpoint', diagnostics);
     if (declaration.orientation === 'undirected') {
-        if (!sameIncidentEndpointContract(declaration.endpoints[0], declaration.endpoints[1]) &&
-            undirectedEndpointsOverlap(environment, declaration.endpoints)) {
-            diagnostics.push(diagnostic('DV_EDGE_UNDIRECTED', '', `${formatDefinitionRef(owner)} has unequal undirected endpoint contracts whose accepted Node families overlap.`));
-        }
         if (declaration.constraints.acyclic === true) {
             diagnostics.push(diagnostic('DV_EDGE_CONSTRAINT', '', 'acyclic is valid only for directed Edge contracts.'));
         }
@@ -160,6 +157,8 @@ function validateEdgeClassComposition(environment, diagnostics) {
 }
 /** Whether `child` safely refines its parent Edge contract `parent`. */
 export function edgeContractRefines(environment, child, parent) {
+    if (isGraphRoot(parent))
+        return true;
     if (child.orientation !== parent.orientation)
         return false;
     if (parent.constraints.noSelf === true && child.constraints.noSelf !== true)
@@ -195,57 +194,18 @@ function countRefines(child, parent) {
     const [parentMinimum, parentMaximum] = bounds[parent];
     return childMinimum >= parentMinimum && childMaximum <= parentMaximum;
 }
-function sameIncidentEndpointContract(left, right) {
-    if (left.incident !== right.incident)
-        return false;
-    const a = [...left.accepts].map(definitionRefIndex).sort();
-    const b = [...right.accepts].map(definitionRefIndex).sort();
-    return a.length === b.length && a.every((value, index) => value === b[index]);
-}
-function undirectedEndpointsOverlap(environment, endpoints) {
-    for (const resolved of environment.definitions.values()) {
-        if (resolved.ref.kind !== 'class' ||
-            resolved.declaration.kind !== 'node' ||
-            resolved.declaration.abstract) {
-            continue;
-        }
-        const candidate = resolved.ref;
-        if (classSatisfies(environment, candidate, endpoints[0].accepts) &&
-            classSatisfies(environment, candidate, endpoints[1].accepts)) {
-            return true;
-        }
-    }
-    return false;
-}
 /** Whether `candidate` is, or is a Node Class extending, one of `accepts`. */
 export function classSatisfies(environment, candidate, accepts) {
     if (accepts.some((ref) => definitionRefIndex(ref) === definitionRefIndex(candidate)))
         return true;
-    const resolved = environment.resolveAny(candidate);
-    if (resolved === undefined ||
-        resolved.ref.kind !== 'class' ||
-        resolved.declaration.kind !== 'node') {
+    const resolve = (ref) => environment.resolveAny(ref)?.declaration;
+    const actual = resolve(candidate);
+    if (actual?.kind !== 'node')
         return false;
-    }
-    return extendsAny(environment, resolved.declaration.extends, accepts, new Set());
-}
-function extendsAny(environment, parents, accepts, visited) {
-    const accepted = new Set(accepts.map(definitionRefIndex));
-    for (const parent of parents) {
-        const key = definitionRefIndex(parent);
-        if (accepted.has(key))
-            return true;
-        if (visited.has(key))
-            continue;
-        visited.add(key);
-        const resolved = environment.resolveAny(parent);
-        if (resolved !== undefined &&
-            resolved.ref.kind === 'class' &&
-            extendsAny(environment, resolved.declaration.extends, accepts, visited)) {
-            return true;
-        }
-    }
-    return false;
+    return accepts.some((ref) => {
+        const required = resolve(ref);
+        return required !== undefined && satisfiesClass(actual, required, resolve);
+    });
 }
 function localRef(origin, name) {
     return { origin, kind: 'class', name };

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

@@ -4,6 +4,7 @@ import { isMethodExecutable } from '../../language/callable/executable.js';
 import { policyObjectKey, policyObjectOrigin, projectedMemberClass, } from '../../language/policy/model/policy.js';
 import { validateJsonInstance } from '../../language/value/evaluate/validate.js';
 import { diagnostic } from '../diagnostic.js';
+import { classSatisfies } from './class.js';
 const formatDefinitionRef = Key.of;
 export function validateCore(environment, analysis, registry) {
     const diagnostics = [];
@@ -286,33 +287,6 @@ function hasDirectedCycle(edges) {
     };
     return [...outgoing.keys()].some(visit);
 }
-function classSatisfies(environment, classRef, accepts) {
-    if (accepts.some((ref) => definitionRefIndex(ref) === definitionRefIndex(classRef)))
-        return true;
-    const resolved = environment.resolveAny(classRef);
-    if (resolved === undefined || resolved.ref.kind !== 'class' || resolved.kind !== 'node') {
-        return false;
-    }
-    return classExtendsAny(environment, resolved.declaration.extends, accepts, new Set());
-}
-function classExtendsAny(environment, parents, accepts, visited) {
-    const accepted = new Set(accepts.map(definitionRefIndex));
-    for (const parent of parents) {
-        const key = definitionRefIndex(parent);
-        if (accepted.has(key))
-            return true;
-        if (visited.has(key))
-            continue;
-        visited.add(key);
-        const resolved = environment.resolveAny(parent);
-        if (resolved !== undefined &&
-            resolved.ref.kind === 'class' &&
-            classExtendsAny(environment, resolved.declaration.extends, accepts, visited)) {
-            return true;
-        }
-    }
-    return false;
-}
 function escapePointer(value) {
     return value.replaceAll('~', '~0').replaceAll('/', '~1');
 }

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

@@ -3,9 +3,10 @@ import type { DomainSchemaLookup } from '../dependency/lookup.js';
 import type { SchemaDiagnostic } from '../diagnostic.js';
 import type { DomainSchemaIR } from '../model/schema.js';
 import type { DomainResolutionContext } from '../resolution/context.js';
-export interface DomainSchemaValidation {
+interface DomainSchemaValidation {
     readonly context: DomainResolutionContext;
     readonly analysis: DefinitionAnalysisResult;
     readonly diagnostics: readonly SchemaDiagnostic[];
 }
 export declare function validateDomainSchemaSemantics(schema: DomainSchemaIR, lookup: DomainSchemaLookup): DomainSchemaValidation;
+export {};

package/dist/v1/schema/validation/domain.structure.d.ts

@@ -1,4 +1,2 @@
-import { type ZodType } from 'zod';
 import type { DomainSchemaIR } from '../model/schema.js';
-export declare const domainSchemaStructuralSchema: ZodType<DomainSchemaIR>;
 export declare function parseDomainSchemaStructure(input: unknown): DomainSchemaIR;

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

@@ -17,6 +17,10 @@ const descriptionSchema = string()
     .min(metadata.description.minLength)
     .max(metadata.description.maxLength);
 const iconSchema = string().min(metadata.icon.minLength).max(metadata.icon.maxLength);
+const domainNameSchema = string()
+    .min(metadata.name.minLength)
+    .max(metadata.name.maxLength)
+    .refine(metadata.isDomainNameText, 'Expected one trimmed line of text.');
 const jsonValueSchema = lazy(() => union([
     nullSchema(),
     boolean(),
@@ -292,13 +296,7 @@ const policyDefinitionSchema = strictObject({
     expression: policyExpressionSchema,
     description: descriptionSchema.optional(),
 });
-const viewTargetSchema = discriminatedUnion('kind', [
-    strictObject({ kind: literal('domain') }),
-    strictObject({
-        kind: literal('definition'),
-        definitions: uniqueArray(classRefSchema).min(1),
-    }),
-]);
+const viewTargetSchema = strictObject({ kind: literal('domain') });
 const viewDefinitionSchema = strictObject({
     ref: viewRefSchema,
     description: descriptionSchema.optional(),
@@ -323,6 +321,8 @@ const structuralSchema = strictObject({
     format: literal(DOMAIN_FORMAT),
     version: literal(DOMAIN_VERSION),
     origin: originSchema,
+    name: domainNameSchema,
+    entrypoint: viewRefSchema.optional(),
     dependencies: record(dependencyAliasSchema, domainDependencySchema),
     classes: record(memberNameSchema, classDeclarationSchema),
     functions: record(memberNameSchema, functionDefinitionSchema),
@@ -330,7 +330,7 @@ const structuralSchema = strictObject({
     views: record(memberNameSchema, viewDefinitionSchema),
     core: coreSchema,
 });
-export const domainSchemaStructuralSchema = structuralSchema;
+const domainSchemaStructuralSchema = structuralSchema;
 export function parseDomainSchemaStructure(input) {
     const result = domainSchemaStructuralSchema.safeParse(input);
     if (result.success)

package/dist/v1/schema/validation/policy/context.js

@@ -1,5 +1,6 @@
 import { Key } from '../../../addressing/index.js';
 import { definitionRefIndex } from '../../../addressing/ordering.js';
+import { classSatisfies } from '../../../language/class/inheritance.js';
 import { diagnostic } from '../../diagnostic.js';
 const formatDefinitionRef = Key.of;
 export class PolicyValidationContext {
@@ -63,22 +64,10 @@ export class PolicyValidationContext {
     }
     /** Return true when candidate is the required Class or a same-kind descendant. */
     classExtends(candidate, required) {
-        if (definitionRefIndex(candidate) === definitionRefIndex(required))
-            return true;
-        const visited = new Set();
-        const visit = (ref) => {
-            const key = definitionRefIndex(ref);
-            if (key === definitionRefIndex(required))
-                return true;
-            if (visited.has(key))
-                return false;
-            visited.add(key);
-            const resolved = this.environment.resolveAny(ref);
-            if (resolved === undefined || resolved.ref.kind !== 'class')
-                return false;
-            return resolved.declaration.extends.some(visit);
-        };
-        return visit(candidate);
+        const resolve = (ref) => this.environment.resolveAny(ref)?.declaration;
+        const actual = resolve(candidate);
+        const target = resolve(required);
+        return actual !== undefined && target !== undefined && classSatisfies(actual, target, resolve);
     }
     add(code, pointer, message, ref) {
         this.diagnostics.push(diagnostic(code, pointer, message, ref));

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

@@ -9,21 +9,26 @@ export function validateViews(environment) {
         if (!sameRef(view.ref, ref)) {
             diagnostics.push(diagnostic('DV_REF_RESOLVES', `${pointer}/ref`, `View ref must be exactly ${formatDefinitionRef(ref)}.`, formatDefinitionRef(view.ref)));
         }
-        if (view.target.kind === 'definition') {
-            view.target.definitions.forEach((ref, index) => validateDefinitionTarget(environment, ref, `${pointer}/target/definitions/${index}`, diagnostics));
-        }
     }
+    validateEntrypoint(environment, diagnostics);
     return Object.freeze(diagnostics);
 }
+/** The entrypoint names one View this Domain declares for itself. */
+function validateEntrypoint(environment, diagnostics) {
+    const { entrypoint, origin, views } = environment.candidate;
+    if (entrypoint === undefined)
+        return;
+    // An own member only: a name such as `constructor` must not resolve on the prototype.
+    const view = entrypoint.origin === origin && Object.hasOwn(views, entrypoint.name)
+        ? views[entrypoint.name]
+        : undefined;
+    if (view === undefined) {
+        diagnostics.push(diagnostic('DV_ENTRYPOINT', '/entrypoint', `Entrypoint ${formatDefinitionRef(entrypoint)} is not a Domain-targeted View of ${origin}.`, formatDefinitionRef(entrypoint)));
+    }
+}
 function sameRef(left, right) {
     return left.origin === right.origin && left.kind === right.kind && left.name === right.name;
 }
-function validateDefinitionTarget(environment, ref, pointer, diagnostics) {
-    const target = environment.resolve(ref);
-    if (target === undefined || target.ref.kind !== 'class' || target.kind !== 'node') {
-        diagnostics.push(diagnostic('DV_VIEW_TARGET', pointer, `Definition target ${formatDefinitionRef(ref)} does not resolve to a Node Class.`, formatDefinitionRef(ref)));
-    }
-}
 function escapePointer(value) {
     return value.replaceAll('~', '~0').replaceAll('/', '~1');
 }