@astrale-os/kernel-dsl 1.0.0-beta.14 → 1.0.0-beta.16

package/dist/v1/addressing/domain-dependency.d.ts

@@ -10,9 +10,3 @@ export type DomainDependency = JsonObject & {
 export type DependencyAlias = string;
 /** Exact direct dependency pins keyed by their authored aliases. */
 export type DomainDependencyMap = Readonly<Record<DependencyAlias, DomainDependency>>;
-/** Representation-neutral admission budgets shared by source and compiled closures. */
-export declare const dependencyLimits: Readonly<{
-    direct: 32;
-    closure: 256;
-    depth: 32;
-}>;

package/dist/v1/addressing/domain-dependency.js

@@ -1,6 +1 @@
-/** Representation-neutral admission budgets shared by source and compiled closures. */
-export const dependencyLimits = Object.freeze({
-    direct: 32,
-    closure: 256,
-    depth: 32,
-});
+export {};

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

@@ -1,5 +1,6 @@
 import type { Value as PortableValue } from '@astrale-os/kernel-dsl/value';
 import type { z } from 'zod';
+import type { ClassRef } from '../../addressing/index.js';
 import type { ResolvedClass, ResolvedProperty } from '../../language/class/resolved.js';
 import type { StateTopologyOf } from '../../language/state/topology.js';
 import type { BlobReceipt, BlobRef, BlobSchema } from '../../language/value/model/blob.js';
@@ -82,6 +83,44 @@ type ClassDepthOfInput<Input> = Input extends {
 } ? Parents extends readonly [] ? 0 : Increment<ClassDepthOf<Parents[number]>> : 0;
 type CompactReference<Value> = Value extends () => infer Resolved ? () => CompactReference<Resolved> : Value extends ResolvedClass ? ClassProjectionOfResolved<Value> : Value extends Class ? ClassReferenceProjectionOf<Value> : Value;
 type CompactReferences<Values extends readonly unknown[]> = Values extends readonly [] ? readonly [] : Values extends readonly [infer Value, ...infer Rest] ? readonly [CompactReference<Value>, ...CompactReferences<Rest>] : readonly CompactReference<Values[number]>[];
+/**
+ * A Class an endpoint accepts, as its projection keeps it: the exact ref of a resolved Class, the
+ * mark of an authored one, which the Schema names, or the ref as given. A lazy reference stays lazy.
+ */
+type CompactAccepted<Value> = Value extends () => infer Resolved ? () => CompactAccepted<Resolved> : Value extends ResolvedClass ? ExactClassRefOf<Value> : Value extends NodeClass<infer Config> ? AcceptedClassMark<Config> : Value;
+/**
+ * What tells an authored Node Class from the other Classes of its Schema in an endpoint's type:
+ * its abstractness, its depth and the names of its effective members. Names alone keep the Edge
+ * handle small enough to print in a declaration file; Classes alike in all of these are the same
+ * accepted Class to the types, never to the Schema. `schema/projection/class.ts` names the Classes
+ * of a Schema and of its direct dependencies that bear the mark, since either may own the handle.
+ */
+type AcceptedClassMark<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;
+};
+/** The ref of a resolved Class, exact while its key is. */
+type ExactClassRefOf<Value extends ResolvedClass> = Value['key'] extends `${infer Origin}:class.${infer Name}` ? string extends Origin ? ClassRef : string extends Name ? ClassRef : ClassRef<Name> & {
+    readonly origin: Origin;
+} : ClassRef;
+/** The Classes one endpoint accepts, in any order: the runtime list is canonically sorted. */
+type CompactAccepts<Values> = Values extends readonly (infer Value)[] ? readonly CompactAccepted<Value>[] : readonly never[];
 type CompactParentsOf<Input> = Input extends {
     readonly extends?: infer Values extends readonly unknown[];
 } ? 'extends' extends keyof Input ? CompactReferences<Values> : readonly [] : readonly [];
@@ -114,10 +153,12 @@ type CompactDirectedInput<Input extends Omit<DirectedEdgeInput, 'orientation'>>
     } ? NonNullable<Value> : never : never>;
     readonly source: {
         readonly as: Input['source']['as'];
+        readonly accepts: CompactAccepts<Input['source']['accepts']>;
         readonly outgoing: Input['source']['outgoing'];
     };
     readonly target: {
         readonly as: Input['target']['as'];
+        readonly accepts: CompactAccepts<Input['target']['accepts']>;
         readonly incoming: Input['target']['incoming'];
     };
     readonly constraints: Input extends {
@@ -137,10 +178,12 @@ type CompactUndirectedInput<Input extends Omit<UndirectedEdgeInput, 'orientation
     readonly endpoints: readonly [
         {
             readonly as: Input['endpoints'][0]['as'];
+            readonly accepts: CompactAccepts<Input['endpoints'][0]['accepts']>;
             readonly incident: Input['endpoints'][0]['incident'];
         },
         {
             readonly as: Input['endpoints'][1]['as'];
+            readonly accepts: CompactAccepts<Input['endpoints'][1]['accepts']>;
             readonly incident: Input['endpoints'][1]['incident'];
         }
     ];

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

@@ -19,7 +19,7 @@ export type { ClassReferenceInput as ClassReference, ClassRuleBuilder, ClassRule
 export type { AuthoredPropertyProjection, AuthoredMethodProjection, ClassIdentityProjection, ClassOwnerProjection, ClassReferenceProjection, } from './class/projection.js';
 export type { PathAuthoring } from './value/path.js';
 export type { Lazy } from './schema/lazy.js';
-export type { MatchPolicyInput, Policy, PolicyBuilder as PolicyFactory, PolicyEdgeInput, PolicyExistsContext, PolicyInput, PolicyNodeBinder, PolicyPatternContext, } from './policy/authoring.js';
+export type { EdgeRolesOf, MatchPolicyInput, Policy, PolicyBuilder as PolicyFactory, PolicyEdgeClassInput, PolicyEdgeEnds, PolicyEdgeInput, PolicyEdgeOptions, PolicyEdgeRepeat, PolicyExistsContext, PolicyInput, PolicyNodeBinder, PolicyPatternContext, } from './policy/authoring.js';
 export type { AutoOptions, AutoProperty, Property, PropertyFieldInput as PropertyField, PropertyOptions, ValueSchemaInput, } from './class/property.js';
 export type { CorePropertyInput } from './schema/projection.js';
 export type { ClassProjection, FunctionProjection, MethodProjection, PropertyProjection, } from './schema/projection.js';

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

@@ -24,6 +24,7 @@ export class V1PolicyCompiler {
         const match = input.match(createPatternContext({
             resolveObject: (member, refPointer) => this.context.resolvePolicyObject(member, refPointer),
             resolveEdgeClass: (definition, refPointer) => this.context.resolveEdgeClass(definition, refPointer),
+            edgeRoles: (ref) => this.context.edgeRoles(ref),
             resolveNodeClass: (definition, refPointer) => this.context.resolveNodeClass(definition, refPointer),
             pointer,
         }));

package/dist/v1/builder/lowering/schema/context.d.ts

@@ -34,6 +34,11 @@ export declare class BuilderContext {
     resolveParent(input: ClassReferenceInput, kind: ClassKind, pointer: string): ClassRef;
     resolveNodeClass(input: ClassReferenceInput, pointer: string): ClassRef;
     resolveEdgeClass(input: ClassReferenceInput, pointer: string): ClassRef;
+    /**
+     * The roles of a resolved Edge Class's source and target, or of an undirected Class's two
+     * endpoints in their stored order, which is the authored one.
+     */
+    edgeRoles(ref: ClassRef): readonly [source: string, target: string];
     resolvePolicy(input: Lazy<unknown>, pointer: string): PolicyRef;
     resolvePolicyObject(input: PolicyObjectInput | PolicyObjectRef, pointer: string): PolicyObjectRef;
     /** A Core fact belongs to the Domain that declares it, so a dependency endpoint never resolves. */

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

@@ -8,6 +8,7 @@ import { escapePointerToken } from '../../../language/value/syntax/pointer.js';
 import { revisionOfDomainSchema } from '../../../schema/canonical/revision.js';
 import { requireDomainClosure } from '../../../schema/resolution/closure.js';
 import { collectUsedForeignOrigins } from '../../../schema/resolution/origins.js';
+import { classConfiguration } from '../../class/authoring.js';
 import { fail } from '../../schema/diagnostic.js';
 import { resolveLazy } from '../../schema/lazy.js';
 import { OwnershipCapture } from './ownership.js';
@@ -16,6 +17,7 @@ export class BuilderContext {
     ownership = new OwnershipCapture();
     localDefinitions = new Map();
     localClassKinds = new Map();
+    #localClasses = new Map();
     policies = new Map();
     policyObjects = new Map();
     policyObjectRefs = new Set();
@@ -49,6 +51,7 @@ export class BuilderContext {
         }
         this.localDefinitions.set(key, ref);
         this.localClassKinds.set(key, value.kind);
+        this.#localClasses.set(key, value);
         this.ownership.captureDefinition(value, ref, pointer);
         this.capturePolicyObject(value, ref);
     }
@@ -109,6 +112,25 @@ export class BuilderContext {
     resolveEdgeClass(input, pointer) {
         return this.resolveClass(input, 'edge', pointer);
     }
+    /**
+     * The roles of a resolved Edge Class's source and target, or of an undirected Class's two
+     * endpoints in their stored order, which is the authored one.
+     */
+    edgeRoles(ref) {
+        if (ref.origin === this.origin) {
+            const value = this.#localClasses.get(definitionRefIndex(ref));
+            if (value.orientation === 'directed') {
+                const input = classConfiguration(value);
+                return [input.source.as, input.target.as];
+            }
+            const input = classConfiguration(value);
+            return [input.endpoints[0].as, input.endpoints[1].as];
+        }
+        const definition = this.#dependencies.get(ref.origin).schema.classes[ref.name];
+        return definition.orientation === 'directed'
+            ? [definition.endpoints.source.role, definition.endpoints.target.role]
+            : [definition.endpoints[0].role, definition.endpoints[1].role];
+    }
     resolvePolicy(input, pointer) {
         const value = resolveLazy(input, pointer);
         if (typeof value !== 'object' || value === null) {

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

@@ -1,18 +1,79 @@
 import type { ClassRef } from '../../addressing/index.js';
+import type { ResolvedClass } from '../../language/class/resolved.js';
 import type { PolicyCheckExpression, PolicyPatternExpression, PolicyPatternTerm as CanonicalPolicyPatternTerm, PolicyObjectRef } from '../../language/policy/model/policy.js';
 import type { PolicyObjectInput } from '../callable/authoring.js';
+import type { DirectedEdgeClass, EdgeClass, UndirectedEdgeClass } from '../class/handle.js';
 import type { EdgeClassReferenceInput, NodeClassReferenceInput } from '../class/input.js';
 import type { AuthoringValue } from '../schema/handle.js';
 import type { Lazy } from '../schema/lazy.js';
+import type { ResolveLazy } from '../schema/projection/identity.js';
+/**
+ * @deprecated Name the ends by their roles: `edge(classValue, { [role]: term }, { repeat })`
+ * lowers to this same pattern.
+ */
 export interface PolicyEdgeInput {
     readonly source: CanonicalPolicyPatternTerm;
     readonly class: EdgeClassReferenceInput;
     readonly target: CanonicalPolicyPatternTerm;
-    readonly repeat?: {
-        readonly min: number;
-        readonly max: number;
-    };
+    readonly repeat?: PolicyEdgeRepeat;
+}
+/** How many Edges of the Class a path between the two terms crosses, both bounds included. */
+export interface PolicyEdgeRepeat {
+    readonly min: number;
+    readonly max: number;
+}
+export interface PolicyEdgeOptions {
+    readonly repeat?: PolicyEdgeRepeat;
 }
+/** An Edge Class whose ends a Policy names by role: authored, resolved, or either lazily. */
+export type PolicyEdgeClassInput = Lazy<EdgeClass | ResolvedClass<'edge'>>;
+/**
+ * The roles of an Edge Class's two ends, as literal types: the `as` of an authored Class's ends,
+ * the `role` of a resolved Class's, read through a lazy reference.
+ */
+export type EdgeRolesOf<Value> = ResolveLazy<Value> extends infer Resolved ? Resolved extends DirectedEdgeClass<infer Config> ? Config extends {
+    readonly source: {
+        readonly as: infer Source;
+    };
+    readonly target: {
+        readonly as: infer Target;
+    };
+} ? Source | Target : never : Resolved extends UndirectedEdgeClass<infer Config> ? Config extends {
+    readonly endpoints: readonly [
+        {
+            readonly as: infer First;
+        },
+        {
+            readonly as: infer Second;
+        }
+    ];
+} ? First | Second : never : Resolved extends {
+    readonly kind: 'edge';
+    readonly definition: {
+        readonly endpoints: infer Endpoints;
+    };
+} ? Endpoints extends {
+    readonly source: {
+        readonly role: infer Source;
+    };
+    readonly target: {
+        readonly role: infer Target;
+    };
+} ? Source | Target : Endpoints extends readonly [
+    {
+        readonly role: infer First;
+    },
+    {
+        readonly role: infer Second;
+    }
+] ? First | Second : never : never : never;
+/**
+ * The two ends of an Edge, keyed by exactly the Class's two roles, both required. A Class whose
+ * roles the types do not know names no ends.
+ */
+export type PolicyEdgeEnds<Value> = [EdgeRolesOf<Value>] extends [never] ? never : string extends EdgeRolesOf<Value> ? never : {
+    readonly [Role in EdgeRolesOf<Value> & string]: CanonicalPolicyPatternTerm;
+};
 export interface PolicyNodeBinder {
     (): CanonicalPolicyPatternTerm;
     (definition: NodeClassReferenceInput): CanonicalPolicyPatternTerm;
@@ -36,6 +97,23 @@ export interface PolicyPatternContext {
     readonly object: CanonicalPolicyPatternTerm;
     readonly source: CanonicalPolicyPatternTerm;
     readonly target: CanonicalPolicyPatternTerm;
+    /**
+     * An Edge of `classValue` between two terms, each keyed by the role of its end: `{ [role]: term }`,
+     * the source's role written first by convention. It lowers to the pattern whose source is the
+     * term of the source's role and whose target is the term of the target's role. For an undirected
+     * Class, the first endpoint's role lowers to the source, and the roles only order the two terms:
+     * the pattern still matches an Edge between the two Nodes whichever end each Node holds.
+     *
+     * ```ts
+     * edge(project_owned_by, { owner: subject, project })
+     * edge(() => subtask_of, { child: a, parent: b }, { repeat: { min: 1, max: 3 } })
+     * ```
+     */
+    edge<ClassValue extends PolicyEdgeClassInput>(classValue: ClassValue, ends: PolicyEdgeEnds<ClassValue>, options?: PolicyEdgeOptions): PolicyPatternExpression;
+    /**
+     * @deprecated Name the ends by their roles: `edge(classValue, { [role]: term }, { repeat })`
+     * lowers to this same pattern.
+     */
     edge(input: PolicyEdgeInput): PolicyPatternExpression;
     exists(build: (context: PolicyExistsContext) => PolicyPatternExpression): PolicyPatternExpression;
     allOf(first: PolicyPatternExpression, ...rest: readonly PolicyPatternExpression[]): PolicyPatternExpression;
@@ -63,6 +141,8 @@ export declare const policy: PolicyBuilder;
 export declare function createPatternContext(options: {
     readonly resolveObject: (value: PolicyObjectInput, pointer: string) => PolicyObjectRef;
     readonly resolveEdgeClass: (value: EdgeClassReferenceInput, pointer: string) => ClassRef;
+    /** The roles of an Edge Class's source and target, or of an undirected Class's two endpoints. */
+    readonly edgeRoles: (ref: ClassRef) => readonly [source: string, target: string];
     readonly resolveNodeClass: (value: NodeClassReferenceInput, pointer: string) => ClassRef;
     readonly pointer: string;
 }): PolicyPatternContext;

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

@@ -1,4 +1,4 @@
-import { assertKnownKeys, fail } from '../schema/diagnostic.js';
+import { assertKnownKeys, escapeToken, fail } from '../schema/diagnostic.js';
 import { authoringValue } from '../schema/handle.js';
 const declarations = new WeakMap();
 const compositions = new WeakSet();
@@ -31,6 +31,7 @@ export function createPatternContext(options) {
     const object = Object.freeze({ kind: 'object' });
     const source = Object.freeze({ kind: 'source' });
     const target = Object.freeze({ kind: 'target' });
+    const classRef = (value) => options.resolveEdgeClass(value, `${options.pointer}/match/class`);
     const context = {
         ref: (member) => ({
             kind: 'ref',
@@ -41,17 +42,36 @@ export function createPatternContext(options) {
         object,
         source,
         target,
-        edge(input) {
-            assertKnownKeys(input, ['source', 'class', 'target', 'repeat']);
-            if (input.repeat !== undefined)
-                assertKnownKeys(input.repeat, ['min', 'max']);
-            return {
-                source: input.source,
-                class: options.resolveEdgeClass(input.class, `${options.pointer}/match/class`),
-                target: input.target,
-                ...(input.repeat === undefined ? {} : { repeat: { ...input.repeat } }),
-            };
-        },
+        edge: ((first, ends, edgeOptions) => {
+            const pointer = `${options.pointer}/match/edge`;
+            if (ends === undefined) {
+                if (typeof first === 'function' || first.kind === 'edge') {
+                    fail('BUILDER_POLICY', pointer, 'edge(classValue, ends) names both ends by their roles.');
+                }
+                const input = first;
+                assertKnownKeys(input, ['source', 'class', 'target', 'repeat']);
+                if (input.repeat !== undefined)
+                    assertKnownKeys(input.repeat, ['min', 'max']);
+                return edgePattern(input.source, classRef(input.class), input.target, input.repeat);
+            }
+            const ref = classRef(first);
+            const [sourceRole, targetRole] = options.edgeRoles(ref);
+            if (typeof ends !== 'object' || ends === null) {
+                fail('BUILDER_POLICY', pointer, 'edge(classValue, ends) names both ends by their roles.');
+            }
+            assertKnownKeys(ends, [sourceRole, targetRole], pointer);
+            for (const role of [sourceRole, targetRole]) {
+                if (!Object.hasOwn(ends, role)) {
+                    fail('BUILDER_POLICY', `${pointer}/${escapeToken(role)}`, `edge(...) names both ends of ${ref.origin}:class.${ref.name}: "${sourceRole}" and "${targetRole}".`);
+                }
+            }
+            if (edgeOptions !== undefined)
+                assertKnownKeys(edgeOptions, ['repeat'], pointer);
+            if (edgeOptions?.repeat !== undefined) {
+                assertKnownKeys(edgeOptions.repeat, ['min', 'max'], `${pointer}/repeat`);
+            }
+            return edgePattern(ends[sourceRole], ref, ends[targetRole], edgeOptions?.repeat);
+        }),
         exists(build) {
             const nodes = [];
             const bind = (selector, definition) => {
@@ -103,6 +123,15 @@ export function createPatternContext(options) {
     };
     return Object.freeze(context);
 }
+/** One Edge pattern, whichever form named its ends. */
+function edgePattern(source, classRef, target, repeat) {
+    return {
+        source,
+        class: classRef,
+        target,
+        ...(repeat === undefined ? {} : { repeat: { ...repeat } }),
+    };
+}
 function composition(operator, policies) {
     nonEmpty(policies, `/${operator}`);
     const value = {

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,6 +1,6 @@
 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';
@@ -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) {
@@ -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/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);