@astrale-os/kernel-dsl 1.0.0-beta.13 → 1.0.0-beta.15

package/dist/v1/builder/schema/projection/class.d.ts

@@ -1,13 +1,119 @@
 import type * as language from '../../../language/index.js';
+import type { DomainSchema, DomainOfSchema } from '../../../schema/model/schema.js';
 import type { NodeClass, DirectedEdgeClass, UndirectedEdgeClass, Class, ProjectionOfClass } from '../../class/handle.js';
 import type { ClassReferenceProjection } from '../../class/projection.js';
 import type { DomainSchemaInput } from '../input.js';
 import type { OwnInstanceMethodProjectionsOf, OwnStaticMethodProjectionsOf } from './callable.js';
-import type { AbstractOf, ConstraintsOf, ResolveLazy, LocalNameOfReference, ClassesInputOf, LocalNameOf } from './identity.js';
+import type { AbstractOf, ConstraintsOf, ResolveLazy, LocalNameOfReference, ClassesInputOf, LocalNameOf, RecordField } from './identity.js';
 import type { ClassProjection } from './model.js';
 import type { EffectivePropertyProjectionsOf, OwnPropertyProjectionsOf } from './property.js';
 import type { ClassProjectionOfResolved, ExactClass } from './resolved-class.js';
-type ProjectedClassDefinition<Origin extends string, Name extends string, Value> = Value extends NodeClass<infer Config> ? language.NodeClassDefinition & {
+/**
+ * A Class an endpoint accepts as the Schema names it: an authored Class by the ref of every Class
+ * that bears its mark, else the ref it carries.
+ */
+type AcceptedRefOf<Origin extends string, Reference, Root extends DomainSchemaInput> = Reference extends unknown ? ResolveLazy<Reference> extends infer Resolved ? Resolved extends {
+    readonly kind: 'node';
+} ? MarkedClassRefOf<Origin, Resolved, Root> : Resolved extends {
+    readonly origin: infer RefOrigin extends string;
+    readonly kind: 'class';
+    readonly name: infer RefName extends string;
+} ? language.ClassRef<RefName> & {
+    readonly origin: RefOrigin;
+} : language.ClassRef : never : never;
+/** The mark the class authoring module gives an accepted Node Class (`AcceptedClassMark`). */
+type ClassMarkOf<Value> = Value extends NodeClass<infer Config> ? {
+    readonly kind: 'node';
+    readonly abstract: Config extends {
+        readonly abstract: infer Abstract;
+    } ? Abstract : never;
+    readonly depth: Config extends {
+        readonly depth: infer Depth;
+    } ? Depth : never;
+    readonly properties: Config extends {
+        readonly effectiveProperties: infer Properties;
+    } ? Properties extends {
+        readonly name: infer Name;
+    } ? Name : never : never;
+    readonly methods: Config extends {
+        readonly effectiveInstanceMethods: infer Instance;
+        readonly effectiveStaticMethods: infer Static;
+    } ? Instance | Static extends infer Method ? Method extends {
+        readonly name: infer Name;
+    } ? Name : never : never : never;
+} : never;
+type Same<Left, Right> = [Left] extends [Right] ? ([Right] extends [Left] ? true : false) : false;
+/** Every local Class name whose mark is the accepted mark. */
+type LocalNameOfMark<Root extends DomainSchemaInput, Mark> = {
+    [Name in keyof ClassesInputOf<Root>]: Same<ClassMarkOf<ClassesInputOf<Root>[Name]>, Mark> extends true ? Name : never;
+}[keyof ClassesInputOf<Root>];
+/**
+ * Every Class an authored handle bearing the mark may be: the builder resolves the handle of a
+ * Class of the Schema or of a direct dependency, so either may bear it. The ref stays broad when no
+ * Class bears it or a dependency's Classes are not named in the types.
+ */
+type MarkedClassRefOf<Origin extends string, Mark, Root extends DomainSchemaInput> = LocalClassRefOf<Origin, LocalNameOfMark<Root, Mark>> | DependencyClassRefOfMark<Root, Mark> extends infer Refs ? [Refs] extends [never] ? language.ClassRef : Refs : never;
+type LocalClassRefOf<Origin extends string, Name> = Name extends string ? language.ClassRef<Name> & {
+    readonly origin: Origin;
+} : never;
+/** The names of the members of a resolved collection. */
+type MemberNamesOf<Collection> = Collection extends {
+    readonly byKey: infer ByKey;
+} ? ByKey[keyof ByKey] extends infer Member ? Member extends {
+    readonly name: infer Name;
+} ? Name : never : never : never;
+/**
+ * A dependency Class may bear a mark when it agrees with it in abstractness and the names of its
+ * effective Properties, and its own Methods are among the mark's. Its resolved type keeps neither
+ * its depth nor the abstract Methods it inherits, so neither is compared.
+ */
+type ResolvedBearsMark<Value, Mark> = Value extends {
+    readonly kind: 'node';
+    readonly definition: {
+        readonly abstract: infer Abstract;
+    };
+    readonly properties: infer Properties;
+    readonly methods: infer Methods;
+    readonly static: {
+        readonly methods: infer StaticMethods;
+    };
+} ? Mark extends {
+    readonly abstract: infer MarkAbstract;
+    readonly properties: infer MarkProperties;
+    readonly methods: infer MarkMethods;
+} ? Same<{
+    readonly abstract: Abstract;
+    readonly properties: MemberNamesOf<Properties>;
+}, {
+    readonly abstract: MarkAbstract;
+    readonly properties: MarkProperties;
+}> extends true ? [MemberNamesOf<Methods> | MemberNamesOf<StaticMethods>] extends [MarkMethods] ? true : false : false : false : false;
+/** Every Node Class of a direct dependency that may bear the mark. */
+type DependencyClassRefOfMark<Root extends DomainSchemaInput, Mark> = {
+    [Alias in keyof RecordField<Root, 'dependencies'>]: RecordField<Root, 'dependencies'>[Alias] extends infer Schema extends DomainSchema ? DomainOfSchema<Schema>['classes'] extends infer Classes ? string extends keyof Classes ? language.ClassRef : {
+        [Name in keyof Classes]: ResolvedBearsMark<Classes[Name], Mark> extends true ? Classes[Name] extends {
+            readonly ref: {
+                readonly origin: infer RefOrigin extends string;
+                readonly name: infer RefName extends string;
+            };
+        } ? language.ClassRef<RefName> & {
+            readonly origin: RefOrigin;
+        } : never : never;
+    }[keyof Classes] : never : never;
+}[keyof RecordField<Root, 'dependencies'>];
+/** Every Class an endpoint accepts, in any order: the runtime list is canonically sorted. */
+type AcceptedRefsOf<Origin extends string, Accepts, Root extends DomainSchemaInput> = Accepts extends readonly (infer Reference)[] ? readonly [AcceptedRefOf<Origin, Reference, Root>, ...AcceptedRefOf<Origin, Reference, Root>[]] : readonly [language.ClassRef, ...language.ClassRef[]];
+/** One endpoint as the Schema stores it: its role and its exact accepted Classes. */
+type ProjectedEndpoint<Origin extends string, Endpoint, Root extends DomainSchemaInput> = Endpoint extends {
+    readonly as: infer Role;
+    readonly accepts: infer Accepts;
+} ? {
+    readonly role: Role;
+    readonly accepts: AcceptedRefsOf<Origin, Accepts, Root>;
+    readonly onDelete?: language.EdgeLifetime;
+} : never;
+type EdgeDefinitionFields = 'ref' | 'kind' | 'abstract' | 'orientation' | 'endpoints' | 'constraints';
+type ProjectedClassDefinition<Origin extends string, Name extends string, Value, Root extends DomainSchemaInput> = Value extends NodeClass<infer Config> ? language.NodeClassDefinition & {
     readonly ref: language.ClassRef<Name> & {
         readonly origin: Origin;
     };
@@ -22,7 +128,7 @@ type ProjectedClassDefinition<Origin extends string, Name extends string, Value>
         readonly as: string;
         readonly incoming: language.EdgeCount;
     };
-} ? language.EdgeClassDefinition & {
+} ? Omit<language.DirectedEdgeDefinition, EdgeDefinitionFields> & {
     readonly ref: language.ClassRef<Name> & {
         readonly origin: Origin;
     };
@@ -30,12 +136,10 @@ type ProjectedClassDefinition<Origin extends string, Name extends string, Value>
     readonly abstract: AbstractOf<Input>;
     readonly orientation: 'directed';
     readonly endpoints: {
-        readonly source: language.DirectedSourceEndpoint & {
-            readonly role: Source['as'];
+        readonly source: ProjectedEndpoint<Origin, Source, Root> & {
             readonly outgoing: Source['outgoing'];
         };
-        readonly target: language.DirectedTargetEndpoint & {
-            readonly role: Target['as'];
+        readonly target: ProjectedEndpoint<Origin, Target, Root> & {
             readonly incoming: Target['incoming'];
         };
     };
@@ -51,7 +155,7 @@ type ProjectedClassDefinition<Origin extends string, Name extends string, Value>
             readonly incident: language.EdgeCount;
         }
     ];
-} ? language.EdgeClassDefinition & {
+} ? Omit<language.UndirectedEdgeDefinition, EdgeDefinitionFields> & {
     readonly ref: language.ClassRef<Name> & {
         readonly origin: Origin;
     };
@@ -59,12 +163,10 @@ type ProjectedClassDefinition<Origin extends string, Name extends string, Value>
     readonly abstract: AbstractOf<Input>;
     readonly orientation: 'undirected';
     readonly endpoints: readonly [
-        language.IncidentEndpoint & {
-            readonly role: First['as'];
+        ProjectedEndpoint<Origin, First, Root> & {
             readonly incident: First['incident'];
         },
-        language.IncidentEndpoint & {
-            readonly role: Second['as'];
+        ProjectedEndpoint<Origin, Second, Root> & {
             readonly incident: Second['incident'];
         }
     ];
@@ -82,9 +184,9 @@ type ParentClassProjectionTuple<Origin extends string, Parents extends readonly
 type ShallowClassProjectionOfAuthoring<Origin extends string, Name extends string, Value, Root extends DomainSchemaInput> = ClassProjectionWithParents<Origin, Name, Value, Root, readonly language.AnyResolvedClass[]>;
 /** Project each authored Class independently before computing its parent tuple. */
 export type ClassProjectionOfAuthoring<Origin extends string, Name extends string, Value, Root extends DomainSchemaInput, Seen = Value> = Value extends Class ? ClassProjectionWithParents<Origin, Name, Value, Root, ParentClassProjectionTuple<Origin, ParentInputsOfConfig<ProjectionOfClass<Extract<Value, Class>>>, Root, Seen>> : never;
-type ClassProjectionWithParents<Origin extends string, Name extends string, Value, Root extends DomainSchemaInput, Parents extends readonly unknown[]> = Value extends NodeClass<infer _Config> ? ClassProjection<'node', Extract<ProjectedClassDefinition<Origin, Name, Value>, language.NodeClassDefinition>, language.ClassRef<Name> & {
+type ClassProjectionWithParents<Origin extends string, Name extends string, Value, Root extends DomainSchemaInput, Parents extends readonly unknown[]> = Value extends NodeClass<infer _Config> ? ClassProjection<'node', Extract<ProjectedClassDefinition<Origin, Name, Value, Root>, language.NodeClassDefinition>, language.ClassRef<Name> & {
     readonly origin: Origin;
-}, language.DefinitionKey<Origin, 'class', Name>, Parents, EffectivePropertyProjectionsOf<Origin, Name, Value, Root>, OwnInstanceMethodProjectionsOf<Origin, Name, Value>, OwnStaticMethodProjectionsOf<Origin, Name, Value>, OwnPropertyProjectionsOf<Origin, Name, Value>, OwnInstanceMethodProjectionsOf<Origin, Name, Value>, OwnStaticMethodProjectionsOf<Origin, Name, Value>> : Value extends DirectedEdgeClass | UndirectedEdgeClass ? ClassProjection<'edge', Extract<ProjectedClassDefinition<Origin, Name, Value>, language.EdgeClassDefinition>, language.ClassRef<Name> & {
+}, language.DefinitionKey<Origin, 'class', Name>, Parents, EffectivePropertyProjectionsOf<Origin, Name, Value, Root>, OwnInstanceMethodProjectionsOf<Origin, Name, Value>, OwnStaticMethodProjectionsOf<Origin, Name, Value>, OwnPropertyProjectionsOf<Origin, Name, Value>, OwnInstanceMethodProjectionsOf<Origin, Name, Value>, OwnStaticMethodProjectionsOf<Origin, Name, Value>> : Value extends DirectedEdgeClass | UndirectedEdgeClass ? ClassProjection<'edge', Extract<ProjectedClassDefinition<Origin, Name, Value, Root>, language.EdgeClassDefinition>, language.ClassRef<Name> & {
     readonly origin: Origin;
 }, language.DefinitionKey<Origin, 'class', Name>, Parents, EffectivePropertyProjectionsOf<Origin, Name, Value, Root>, never, never, OwnPropertyProjectionsOf<Origin, Name, Value>, never, never> : never;
 export {};

package/dist/v1/bundle/codec.js

@@ -1,13 +1,13 @@
 import { accept as acceptJsonValue, BoundaryError as JsonBoundaryError, json, } from '@astrale-os/kernel-dsl/value';
-import { dependencyLimits } from '../addressing/domain-dependency.js';
 import { compareUnicode } from '../addressing/ordering.js';
+import { limits } from '../language/limits.js';
 import { escapePointerToken } from '../language/value/syntax/pointer.js';
 import { acceptDomainSchema } from '../schema/admission/accept.js';
 import { canonicalDomainSchemaAfterValidation } from '../schema/canonical/revision.js';
 import { revisionOfDomainSchema } from '../schema/canonical/revision.js';
 import { MemoryDomainSchemaLookup } from '../schema/dependency/lookup.js';
 import { SchemaError } from '../schema/diagnostic.js';
-import { BundleError, diagnostic } from './diagnostic.js';
+import { BundleError, diagnostic, schemaDiagnosticAt } from './diagnostic.js';
 import { asDomainSchemaBundle, } from './model.js';
 import { parseDomainSchemaBundleStructure } from './structure.js';
 export function acceptDomainSchemaBundle(input) {
@@ -46,12 +46,12 @@ function acceptBundleValue(input) {
     const closure = structure.closure.map((schema, index) => candidate(schema, `/closure/${index}`));
     const diagnostics = [];
     const candidates = new Map();
-    if (closure.length + 1 > dependencyLimits.closure) {
-        diagnostics.push(diagnostic('DV_DEPENDENCY_LIMITS', '/closure', `A dependency closure may contain at most ${dependencyLimits.closure} Domains.`));
+    if (closure.length + 1 > limits.dependency.closure) {
+        diagnostics.push(diagnostic('DV_DEPENDENCY_LIMITS', '/closure', `A dependency closure may contain at most ${limits.dependency.closure} Domains.`));
     }
     for (const entry of [root, ...closure]) {
-        if (Object.keys(entry.schema.dependencies).length > dependencyLimits.direct) {
-            diagnostics.push(diagnostic('DV_DEPENDENCY_LIMITS', `${entry.pointer}/dependencies`, `A Domain may declare at most ${dependencyLimits.direct} direct dependency aliases.`));
+        if (Object.keys(entry.schema.dependencies).length > limits.dependency.direct) {
+            diagnostics.push(diagnostic('DV_DEPENDENCY_LIMITS', `${entry.pointer}/dependencies`, `A Domain may declare at most ${limits.dependency.direct} direct dependency aliases.`));
         }
     }
     for (const entry of closure) {
@@ -99,7 +99,7 @@ function acceptBundleValue(input) {
         catch (error) {
             if (!(error instanceof SchemaError))
                 throw error;
-            throw new BundleError(error.diagnostics.map((item) => diagnostic(item.code, `${entry.pointer}${item.pointer}`, item.message, item.ref)));
+            throw new BundleError(error.diagnostics.map((item) => schemaDiagnosticAt(entry.pointer, item)));
         }
     };
     for (const entry of candidates.values()) {
@@ -128,8 +128,8 @@ function collectReachable(current, root, candidates, reachable, active, revision
         return;
     }
     active.add(current.key);
-    if (depth > dependencyLimits.depth) {
-        diagnostics.push(diagnostic('DV_DEPENDENCY_LIMITS', current.pointer, `Dependency depth ${depth} exceeds the maximum ${dependencyLimits.depth}.`));
+    if (depth > limits.dependency.depth) {
+        diagnostics.push(diagnostic('DV_DEPENDENCY_LIMITS', current.pointer, `Dependency depth ${depth} exceeds the maximum ${limits.dependency.depth}.`));
         active.delete(current.key);
         return;
     }

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

@@ -4,6 +4,8 @@ export type BundleDiagnostic<Code extends BundleDiagnosticCode = BundleDiagnosti
     readonly code: Code;
 };
 export declare function diagnostic<const Code extends BundleDiagnosticCode>(code: Code, pointer: string, message: string, ref?: string): BundleDiagnostic<Code>;
+/** A refusal of one bundled schema, its pointer rebased under the schema's place in the bundle. */
+export declare function schemaDiagnosticAt(pointer: string, refusal: SchemaDiagnostic): BundleDiagnostic;
 export declare class BundleError extends Error {
     readonly diagnostics: readonly BundleDiagnostic[];
     constructor(diagnostics: readonly BundleDiagnostic[]);

package/dist/v1/bundle/diagnostic.js

@@ -2,6 +2,12 @@ import { formatDiagnostics, orderDiagnostics } from '../language/validation/diag
 export function diagnostic(code, pointer, message, ref) {
     return Object.freeze({ code, pointer, message, ...(ref === undefined ? {} : { ref }) });
 }
+/** A refusal of one bundled schema, its pointer rebased under the schema's place in the bundle. */
+export function schemaDiagnosticAt(pointer, refusal) {
+    // Acceptance refuses a document with Schema codes only, never with comparison request codes.
+    const code = refusal.code;
+    return Object.freeze({ ...refusal, code, pointer: `${pointer}${refusal.pointer}` });
+}
 export class BundleError extends Error {
     diagnostics;
     constructor(diagnostics) {

package/dist/v1/bundle/structure.js

@@ -1,7 +1,7 @@
 import { escapePointerToken } from '../language/value/syntax/pointer.js';
 import { SchemaError } from '../schema/diagnostic.js';
 import { routeDomainSchema } from '../schema/validation/domain.route.js';
-import { BundleError, diagnostic } from './diagnostic.js';
+import { BundleError, diagnostic, schemaDiagnosticAt } from './diagnostic.js';
 import { DOMAIN_BUNDLE_FORMAT, DOMAIN_BUNDLE_VERSION } from './model.js';
 export function parseDomainSchemaBundleStructure(input) {
     if (!isObject(input)) {
@@ -57,7 +57,7 @@ function routeAt(value, pointer, diagnostics) {
     catch (error) {
         if (!(error instanceof SchemaError))
             throw error;
-        diagnostics.push(...error.diagnostics.map((entry) => diagnostic(entry.code, `${pointer}${entry.pointer}`, entry.message, entry.ref)));
+        diagnostics.push(...error.diagnostics.map((entry) => schemaDiagnosticAt(pointer, entry)));
         return undefined;
     }
 }

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

@@ -1,5 +1,5 @@
 import { accept as acceptPortable } from '@astrale-os/kernel-dsl/value';
-import { dependencyLimits } from '../../addressing/domain-dependency.js';
+import { limits } from '../../language/limits.js';
 import {} from '../model/schema.js';
 import { validateClosure } from './closure.js';
 import { invalid, pointer } from './diagnostic.js';
@@ -20,7 +20,7 @@ export function acceptCompiledSchema(input) {
     const rootPin = dependency(root.root, 'root', '/root');
     const machines = new Map();
     const closure = array(root.closure, 'closure', '/closure').map((value, index) => entry(value, index, `/closure/${index}`, machines));
-    if (closure.length > dependencyLimits.closure) {
+    if (closure.length > limits.dependency.closure) {
         invalid('dependency closure limit', 'COMPILED_DEPENDENCY_LIMITS', '/closure');
     }
     const closureOrigins = new Set();
@@ -34,7 +34,7 @@ export function acceptCompiledSchema(input) {
     if (rootEntry?.revision !== rootPin.revision)
         invalid('root pin', undefined, '/root');
     for (const [entryIndex, owner] of closure.entries()) {
-        if (Object.keys(owner.dependencies).length > dependencyLimits.direct) {
+        if (Object.keys(owner.dependencies).length > limits.dependency.direct) {
             invalid('direct dependency limit', 'COMPILED_DEPENDENCY_LIMITS', `/closure/${entryIndex}/dependencies`);
         }
         for (const [alias, pin] of Object.entries(owner.dependencies)) {

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

@@ -1,7 +1,7 @@
 import {} from '@astrale-os/kernel-dsl/value';
-import { dependencyLimits } from '../../addressing/domain-dependency.js';
 import { Key, isDefinitionRef } from '../../addressing/index.js';
 import {} from '../../language/class/model/edge.js';
+import { limits } from '../../language/limits.js';
 import {} from '../model/schema.js';
 import { invalid, pointer } from './diagnostic.js';
 /** Require closed direct references, acyclic inheritance and concrete Core Classes. */
@@ -128,7 +128,7 @@ function validateDependencyCycles(candidate) {
     const visited = new Set();
     const frames = [];
     const push = (origin, depth) => {
-        if (depth > dependencyLimits.depth) {
+        if (depth > limits.dependency.depth) {
             invalid('dependency depth limit', 'COMPILED_DEPENDENCY_LIMITS', `/closure/${byOrigin.get(origin)?.index ?? 0}/dependencies`);
         }
         active.add(origin);

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

@@ -1,7 +1,7 @@
 import { Key } from '../../../addressing/index.js';
 import { isMethodExecutable } from '../../../language/callable/executable.js';
 import { coveringEdgeUniqueTuples, coveringNodeUniqueTuples, edgeUniqueKeys, nodeUniqueKeys, } from '../../../language/class/unique.js';
-import { checkCoreEdgeSet, checkHeldKeys, coreEndpointsSatisfy, } from '../../../language/core/facts.js';
+import { checkCoreEdgeSet, checkHeldKeys, coreEndpointsSatisfy, DOMAIN_ENDPOINT_CLASS, } from '../../../language/core/facts.js';
 import {} from '../../../language/core/model/core.js';
 import { policyObjectOrigin, policyObjectKey, projectedMemberClass, } from '../../../language/index.js';
 import { bindValueProgram } from '../../../language/value/compile/load.js';
@@ -123,7 +123,7 @@ function validateCoreProperties(values, analysis, path) {
 }
 function resolveCoreEndpoint(context, entry, ref, nodes, path) {
     if (ref.kind === 'domain')
-        return { key: 'domain' };
+        return { key: 'domain', member: { class: DOMAIN_ENDPOINT_CLASS, pointer: path } };
     const undeclared = () => fail(path, 'Core endpoint does not name a declared local Definition.');
     if (policyObjectOrigin(ref) !== entry.origin)
         return undeclared();
@@ -151,9 +151,5 @@ function declaresProjectedMember(context, entry, ref) {
     return declarations.some((declaration) => declaration.ref.name === ref.name);
 }
 function endpointSatisfies(context, endpoint, accepts) {
-    if ('value' in endpoint)
-        return classSatisfiesAny(context, endpoint.value.class, accepts);
-    if ('member' in endpoint)
-        return classSatisfiesAny(context, endpoint.member.class, accepts);
-    return true;
+    return classSatisfiesAny(context, 'value' in endpoint ? endpoint.value.class : endpoint.member.class, accepts);
 }

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

@@ -1,6 +1,6 @@
 import {} from '../../../../addressing/index.js';
 import { branchesOf, targetMode, isConnected, } from '../../../../language/policy/analysis/branches.js';
-import { MAX_PATTERN_DEPTH, MAX_BRANCHES, MAX_EDGES, MAX_DOMAINS, measureChecks, MAX_CHECK_DEPTH, MAX_CHECK_LEAVES, policyMeasurer, } from '../../../../language/policy/analysis/budgets.js';
+import { exceededLimits, measureChecks, policyMeasurer, } from '../../../../language/policy/analysis/budgets.js';
 import { neverAdmittedClasses, } from '../../../../language/policy/analysis/checks.js';
 import {} from '../../../../language/policy/analysis/typing.js';
 import { checksNameTheCaller, isClassRuleChecks, } from '../../../../language/policy/model/policy.js';
@@ -28,11 +28,7 @@ export function validatePolicyParity(context, entry, entryIndex, policies, origi
             }
         }
         const measure = measurePolicy(name);
-        if (measure !== undefined &&
-            (measure.depth > MAX_PATTERN_DEPTH ||
-                measure.edgeCounts.length > MAX_BRANCHES ||
-                Math.max(0, ...measure.edgeCounts) > MAX_EDGES ||
-                measure.domains.size > MAX_DOMAINS)) {
+        if (measure !== undefined && exceededLimits(measure).length > 0) {
             fail(path, 'Policy expansion exceeds the V1 depth, branch, Edge, or Domain budget.');
         }
         const branches = typing.expandedBranches(name, `$${name}`);
@@ -98,10 +94,7 @@ function validatePolicyChecks(context, typing, entry, expression, input, receive
     if (!checksNameTheCaller(expression)) {
         fail(path, `${SITE[site].checks} must check a Policy on every branch: sameNode alone names no caller.`);
     }
-    const measure = measureChecks(expression);
-    if (measure.depth > MAX_CHECK_DEPTH ||
-        measure.branches > MAX_BRANCHES ||
-        measure.leaves > MAX_CHECK_LEAVES) {
+    if (exceededLimits(measureChecks(expression)).length > 0) {
         fail(path, `${SITE[site].checks} exceed the V1 depth, branch, or leaf budget.`);
     }
     const leaves = new Map();

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

@@ -14,6 +14,9 @@ export interface CallableValidation {
     validateInputField(field: string, input: unknown): readonly Diagnostic[];
     validateOutput(output: unknown): readonly Diagnostic[];
 }
-/** Build the one Domain-level router shared by source resolution and compiled loading. */
+/**
+ * Build the one Domain-level router shared by source resolution and compiled loading. The Domain
+ * built from the same entries asks only for the Properties and Callables they declare.
+ */
 export declare function createDomainValidation(properties: ReadonlyMap<PropertyKey, PropertyValidation>, callables: ReadonlyMap<Key.Callable, CallableValidation>): DomainValidation;
 export declare function unknownInputField(field: string): readonly Diagnostic[];

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

@@ -1,34 +1,30 @@
-/** Build the one Domain-level router shared by source resolution and compiled loading. */
+/**
+ * Build the one Domain-level router shared by source resolution and compiled loading. The Domain
+ * built from the same entries asks only for the Properties and Callables they declare.
+ */
 export function createDomainValidation(properties, callables) {
+    const propertyOf = (key) => {
+        const target = properties.get(key);
+        if (target === undefined)
+            throw new TypeError(`Property ${key} is absent.`);
+        return target;
+    };
+    const callableOf = (key) => {
+        const target = callables.get(key);
+        if (target === undefined)
+            throw new TypeError(`Callable ${key} is absent.`);
+        return target;
+    };
     const validation = {
         propertyExists: (key) => properties.has(key),
-        property(key, input) {
-            const target = properties.get(key);
-            return target === undefined ? unknownTarget('Property', key) : target.validate(input);
-        },
-        propertyProgram(key) {
-            const target = properties.get(key);
-            if (target === undefined)
-                throw new TypeError(`Property ${key} is absent.`);
-            return target.program();
-        },
+        property: (key, input) => propertyOf(key).validate(input),
+        propertyProgram: (key) => propertyOf(key).program(),
         propertyOrdering: (key) => properties.get(key)?.ordering,
         callableExists: (key) => callables.has(key),
-        callableInput(key, input) {
-            const target = callables.get(key);
-            return target === undefined ? unknownTarget('Callable', key) : target.validateInput(input);
-        },
+        callableInput: (key, input) => callableOf(key).validateInput(input),
         callableFields: (key) => callables.get(key)?.fields,
-        callableInputField(key, field, input) {
-            const target = callables.get(key);
-            return target === undefined
-                ? unknownTarget('Callable', key)
-                : target.validateInputField(field, input);
-        },
-        callableOutput(key, output) {
-            const target = callables.get(key);
-            return target === undefined ? unknownTarget('Callable', key) : target.validateOutput(output);
-        },
+        callableInputField: (key, field, input) => callableOf(key).validateInputField(field, input),
+        callableOutput: (key, output) => callableOf(key).validateOutput(output),
     };
     return Object.freeze(validation);
 }
@@ -41,12 +37,3 @@ export function unknownInputField(field) {
         }),
     ];
 }
-function unknownTarget(kind, key) {
-    return [
-        Object.freeze({
-            code: 'DOMAIN_VALIDATION_TARGET_UNKNOWN',
-            pointer: '',
-            message: `${kind} ${key} is absent.`,
-        }),
-    ];
-}

package/dist/v1/language/.spec/schemas/value-schema.schema.json

@@ -0,0 +1,22 @@
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "https://schemas.astrale.ai/dsl/v1/value-schema",
+    "$dynamicAnchor": "meta",
+    "$vocabulary": {
+        "https://json-schema.org/draft/2020-12/vocab/core": true,
+        "https://json-schema.org/draft/2020-12/vocab/applicator": true,
+        "https://json-schema.org/draft/2020-12/vocab/unevaluated": true,
+        "https://json-schema.org/draft/2020-12/vocab/validation": true,
+        "https://json-schema.org/draft/2020-12/vocab/meta-data": true,
+        "https://json-schema.org/draft/2020-12/vocab/format-annotation": true,
+        "https://json-schema.org/draft/2020-12/vocab/content": true,
+        "https://schemas.astrale.ai/dsl/v1/value-schema/vocabulary": true
+    },
+    "title": "Astrale V1 value schema",
+    "$comment": "The meta-schema of the V1 value-schema dialect: Draft 2020-12 and the required Astrale vocabulary (fullMatch, x-astrale-path, x-astrale-value-kind). Its $dynamicAnchor extends Draft 2020-12 at every subschema, not only the root. The rules of the profile beyond it are published as schema.values.RULES.",
+    "allOf": [{ "$ref": "https://json-schema.org/draft/2020-12/schema" }],
+    "properties": {
+        "fullMatch": { "type": "string" },
+        "x-astrale-path": { "type": "object" }
+    }
+}

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

@@ -3,7 +3,7 @@ import type { MethodRecord } from '../../callable/model/callable.js';
 import type { ClassPolicy, NodeClassPolicy } from '../../policy/model/policy.js';
 import type { DataFacet } from './data.js';
 import type { EdgeContract } from './edge.js';
-import type { PropertyFacet } from './property.js';
+import type { EdgePropertyDefinition, NodePropertyDefinition, PropertyFacet } from './property.js';
 export type ClassKind = 'node' | 'edge';
 /**
  * Which Classes may extend a Class: `'open'`, those of its Domain and of every Domain that depends
@@ -30,7 +30,7 @@ export type NodeUniqueTuple = readonly [PropertyKey, ...PropertyKey[]];
  * backend announces it to enforce Node keys, so a tuple is never ignored where it is not.
  */
 export type NodeUniqueForm = readonly ['property'];
-export interface NodeClassDefinition extends DefinitionBase<ClassRef>, PropertyFacet, DataFacet {
+export interface NodeClassDefinition extends DefinitionBase<ClassRef>, PropertyFacet<NodePropertyDefinition>, DataFacet {
     readonly kind: 'node';
     readonly abstract: boolean;
     /** Absent when `'internal'`, the default, so a Class that keeps the default keeps its revision. */
@@ -44,9 +44,9 @@ export interface NodeClassDefinition extends DefinitionBase<ClassRef>, PropertyF
      * The tuples no two Nodes of this Class and of its active concrete descendants share while every
      * Property is present; absent, none. A descendant is covered without declaring them again.
      */
-    readonly unique?: readonly NodeUniqueTuple[];
+    readonly unique?: readonly [NodeUniqueTuple, ...NodeUniqueTuple[]];
 }
-export type EdgeClassDefinition = DefinitionBase<ClassRef> & PropertyFacet & EdgeContract & {
+export type EdgeClassDefinition = DefinitionBase<ClassRef> & PropertyFacet<EdgePropertyDefinition> & EdgeContract & {
     readonly kind: 'edge';
     readonly abstract: boolean;
     /** Absent when `'internal'`, the default, so a Class that keeps the default keeps its revision. */

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

@@ -8,7 +8,7 @@ export type EdgeOrientation = 'directed' | 'undirected';
 export type EdgeLifetime = 'restrict' | 'detach';
 export interface EdgeEndpointBase {
     readonly role: string;
-    readonly accepts: readonly ClassRef[];
+    readonly accepts: readonly [ClassRef, ...ClassRef[]];
     /** Declared only when authored; otherwise derived (`edgeLifetimes`). */
     readonly onDelete?: EdgeLifetime;
 }
@@ -56,7 +56,7 @@ export interface DirectedEdgeContract {
      * The tuples no two Edges of this Class and of its active concrete descendants share. Absent
      * when the Class declares none, so a Class without one keeps its revision; never empty.
      */
-    readonly unique?: readonly EdgeUniqueTuple[];
+    readonly unique?: readonly [EdgeUniqueTuple, ...EdgeUniqueTuple[]];
 }
 export interface UndirectedEdgeContract {
     readonly orientation: 'undirected';

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

@@ -1,20 +1,29 @@
+import type { StateTopology } from '../../state/index.js';
+import type { JsonSchema } from '../../value/model/schema.js';
 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 on: readonly [AutoEvent, ...AutoEvent[]];
     readonly set: AutoSet;
 }
-export interface PropertyDefinition {
-    readonly schema: import('../../value/model/schema.js').JsonSchema;
+/** A Property of a Node Class, which may be a State Property. */
+export interface NodePropertyDefinition {
+    readonly schema: JsonSchema;
     readonly required: boolean;
     readonly auto?: PropertyAuto;
     readonly immutable?: PropertyImmutability;
     readonly description?: string;
-    readonly state?: import('../../state/index.js').StateTopology;
+    readonly state?: StateTopology;
 }
-export type PropertyRecord = Readonly<Record<string, PropertyDefinition>>;
-export interface PropertyFacet {
-    readonly properties: PropertyRecord;
+/** A Property of an Edge Class: an Edge has no State Property. */
+export interface EdgePropertyDefinition extends Omit<NodePropertyDefinition, 'state'> {
+    readonly state?: never;
+}
+/** A Property of a Class of either kind. */
+export type PropertyDefinition = NodePropertyDefinition | EdgePropertyDefinition;
+export type PropertyRecord<Definition extends PropertyDefinition = PropertyDefinition> = Readonly<Record<string, Definition>>;
+export interface PropertyFacet<Definition extends PropertyDefinition = PropertyDefinition> {
+    readonly properties: PropertyRecord<Definition>;
 }

package/dist/v1/language/core/facts.d.ts

@@ -1,9 +1,17 @@
 import type { ClassRef } from '../../addressing/index.js';
 import type { EdgeContract, EdgeCount, EdgeEndpointBase, IncidentEndpoint } from '../class/model/edge.js';
+/**
+ * The Class of the owning Domain's Node: every Domain principal is a Node of the final Kernel
+ * `Domain` Class, so a Core Edge that names the Domain must accept that Class at that endpoint.
+ */
+export declare const DOMAIN_ENDPOINT_CLASS: ClassRef;
 /** One endpoint of a Core Edge: a Core Node, a projected member or the owning Domain. */
 export interface CoreFactEndpoint {
     readonly key: string;
-    /** Set on a projected member: its Kernel Class, and where a breach of its degree is reported. */
+    /**
+     * Set on a projected member and on the owning Domain: the Kernel Class it is a Node of, and where
+     * a breach of its degree is reported.
+     */
     readonly member?: {
         readonly class: ClassRef;
         readonly pointer: string;
@@ -26,10 +34,12 @@ export interface CoreDegreeSubject {
 }
 export interface CoreEdgeSet<Edge> {
     readonly edges: readonly CoreFactEdge<Edge>[];
-    /** The local exact Edge Classes, in the order their slices are checked. */
+    /** The local Edge Classes, in the order their slices are checked. */
     readonly classes: readonly {
         readonly key: string;
-        readonly contract: EdgeContract;
+        readonly contract: EdgeContract & {
+            readonly abstract: boolean;
+        };
     }[];
     readonly nodes: readonly CoreDegreeSubject[];
     readonly satisfies: (ref: ClassRef, accepts: readonly ClassRef[]) => boolean;
@@ -68,5 +78,8 @@ export declare function coreEndpointsSatisfy<Endpoint>(contract: EdgeContract, s
  * DV-EDGE-UNIQUE); Activation checks them against stored data.
  */
 export declare function checkHeldKeys<Fact>(facts: Iterable<Fact>, keys: (fact: Fact) => readonly string[], report: (fact: Fact, previous: Fact) => void): void;
-/** Check normalized Edge identity, noSelf, keys, exact-Class acyclicity and Core degrees. */
+/**
+ * Check normalized Edge identity, noSelf, keys, and the acyclicity and Core degrees of each exact
+ * concrete Edge Class over its own Edges.
+ */
 export declare function checkCoreEdgeSet<Edge>(set: CoreEdgeSet<Edge>): void;