@astrale-os/kernel-dsl 1.0.0-beta.2 → 1.0.0-beta.20

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();
@@ -21,76 +21,24 @@ function createPolicy(input) {
     declarations.set(value, input);
     return value;
 }
-export const policy = Object.freeze(Object.assign(createPolicy, {
-    allOf: (first, ...rest) => createPolicy(composition('allOf', first === undefined ? [] : [first, ...rest])),
-    anyOf: (first, ...rest) => createPolicy(composition('anyOf', first === undefined ? [] : [first, ...rest])),
-}));
+export const policy = Object.freeze(Object.assign(createPolicy, { allOf: composer('allOf'), anyOf: composer('anyOf') }));
+function composer(operator) {
+    return (first, ...rest) => createPolicy(composition(operator, first === undefined ? [] : [first, ...rest]));
+}
 export function createPatternContext(options) {
-    let nextVariable = 0;
-    const subject = Object.freeze({ kind: 'subject' });
-    const object = Object.freeze({ kind: 'object' });
-    const source = Object.freeze({ kind: 'source' });
-    const target = Object.freeze({ kind: 'target' });
+    const nextVariable = variableIds();
     const context = {
         ref: (member) => ({
             kind: 'ref',
             ref: options.resolveObject(member, `${options.pointer}/match/ref`),
         }),
         sameNode: (left, right) => ({ sameNode: { left, right } }),
-        subject,
-        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 } }),
-            };
-        },
-        exists(build) {
-            const nodes = [];
-            const bind = (selector, definition) => {
-                const variable = Object.freeze({ kind: 'variable', id: nextVariable++ });
-                if (selector === 'any') {
-                    nodes.push({ variable, selector: Object.freeze({ kind: 'any' }) });
-                }
-                else {
-                    const classRef = options.resolveNodeClass(definition, `${options.pointer}/match/exists/nodes`);
-                    nodes.push(selector === 'exact'
-                        ? { variable, class: classRef }
-                        : { variable, selector: Object.freeze({ kind: 'satisfies', class: classRef }) });
-                }
-                return variable;
-            };
-            const node = function (...args) {
-                if (args.length > 1 || (args.length === 1 && args[0] === undefined)) {
-                    fail('BUILDER_POLICY', `${options.pointer}/match/exists/nodes`, 'node(...) accepts either no arguments or one Node Class.');
-                }
-                return args.length === 0
-                    ? bind('any')
-                    : bind('satisfies', args[0]);
-            };
-            Object.defineProperty(node, 'exact', {
-                enumerable: true,
-                value(definition) {
-                    if (arguments.length !== 1 || definition === undefined) {
-                        fail('BUILDER_POLICY', `${options.pointer}/match/exists/nodes`, 'node.exact(...) requires exactly one Node Class.');
-                    }
-                    return bind('exact', definition);
-                },
-            });
-            Object.freeze(node);
-            const where = build({ node });
-            if (nodes.length === 0) {
-                fail('BUILDER_POLICY_EMPTY_EXISTS', `${options.pointer}/match/exists/nodes`, 'exists(...) must declare at least one variable Node.');
-            }
-            return { exists: { nodes, where } };
-        },
+        subject: Object.freeze({ kind: 'subject' }),
+        object: Object.freeze({ kind: 'object' }),
+        source: Object.freeze({ kind: 'source' }),
+        target: Object.freeze({ kind: 'target' }),
+        edge: (...args) => edge(options, args),
+        exists: (build) => exists(options, nextVariable, build),
         allOf(...expressions) {
             nonEmpty(expressions, `${options.pointer}/match/allOf`);
             return { allOf: expressions };
@@ -102,12 +50,103 @@ export function createPatternContext(options) {
     };
     return Object.freeze(context);
 }
+/** Variable ids, unique across every `exists(...)` of one pattern. */
+function variableIds() {
+    let next = 0;
+    return () => next++;
+}
+function edge(options, args) {
+    const pointer = `${options.pointer}/match/edge`;
+    if (args[1] === undefined)
+        return legacyEdge(options, args[0], pointer);
+    const [classValue, ends, edgeOptions] = args;
+    const ref = options.resolveEdgeClass(classValue, `${options.pointer}/match/class`);
+    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);
+    const missing = `edge(...) names both ends of ${ref.origin}:class.${ref.name}: "${sourceRole}" and "${targetRole}".`;
+    const sourceTerm = endTerm(ends, sourceRole, pointer, missing);
+    const targetTerm = endTerm(ends, targetRole, pointer, missing);
+    if (edgeOptions !== undefined)
+        assertKnownKeys(edgeOptions, ['repeat'], pointer);
+    if (edgeOptions?.repeat !== undefined) {
+        assertKnownKeys(edgeOptions.repeat, ['min', 'max'], `${pointer}/repeat`);
+    }
+    return edgePattern(sourceTerm, ref, targetTerm, edgeOptions?.repeat);
+}
+function legacyEdge(options, input, pointer) {
+    // Typed callers cannot pass an Edge Class without ends; untyped ones can, and `kind` is read
+    // without `in` so a primitive still reaches `assertKnownKeys`.
+    if (typeof input === 'function' || input.kind === 'edge') {
+        fail('BUILDER_POLICY', pointer, 'edge(classValue, ends) names both ends by their roles.');
+    }
+    assertKnownKeys(input, ['source', 'class', 'target', 'repeat']);
+    if (input.repeat !== undefined)
+        assertKnownKeys(input.repeat, ['min', 'max']);
+    const ref = options.resolveEdgeClass(input.class, `${options.pointer}/match/class`);
+    return edgePattern(input.source, ref, input.target, input.repeat);
+}
+/** The term of one role. An own key holding `undefined` passes through, as it always has. */
+function endTerm(ends, role, pointer, missing) {
+    if (!Object.hasOwn(ends, role))
+        fail('BUILDER_POLICY', `${pointer}/${escapeToken(role)}`, missing);
+    return ends[role];
+}
+/** One Edge pattern, whichever form named its ends. */
+function edgePattern(source, classRef, target, repeat) {
+    return {
+        source,
+        class: classRef,
+        target,
+        ...(repeat === undefined ? {} : { repeat: { ...repeat } }),
+    };
+}
+function exists(options, nextVariable, build) {
+    const pointer = `${options.pointer}/match/exists/nodes`;
+    const nodes = [];
+    const bind = (selector) => {
+        const variable = Object.freeze({ kind: 'variable', id: nextVariable() });
+        nodes.push(nodeVariable(options, variable, selector, pointer));
+        return variable;
+    };
+    const where = build({ node: nodeBinder(bind, pointer) });
+    const [first, ...rest] = nodes;
+    if (first === undefined) {
+        fail('BUILDER_POLICY_EMPTY_EXISTS', pointer, 'exists(...) must declare at least one variable Node.');
+    }
+    return { exists: { nodes: [first, ...rest], where } };
+}
+function nodeVariable(options, variable, selector, pointer) {
+    if (selector.kind === 'any')
+        return { variable, selector: Object.freeze({ kind: 'any' }) };
+    const classRef = options.resolveNodeClass(selector.definition, pointer);
+    if (selector.kind === 'exact')
+        return { variable, class: classRef };
+    return { variable, selector: Object.freeze({ kind: 'satisfies', class: classRef }) };
+}
+function nodeBinder(bind, pointer) {
+    function node(...args) {
+        const definition = args[0];
+        if (args.length > 1 || (args.length === 1 && definition === undefined)) {
+            fail('BUILDER_POLICY', pointer, 'node(...) accepts either no arguments or one Node Class.');
+        }
+        return definition === undefined
+            ? bind({ kind: 'any' })
+            : bind({ kind: 'satisfies', definition });
+    }
+    function exact(definition) {
+        if (arguments.length !== 1 || definition === undefined) {
+            fail('BUILDER_POLICY', pointer, 'node.exact(...) requires exactly one Node Class.');
+        }
+        return bind({ kind: 'exact', definition });
+    }
+    return Object.freeze(Object.assign(node, { exact }));
+}
 function composition(operator, policies) {
     nonEmpty(policies, `/${operator}`);
-    const value = {
-        operator,
-        policies: [...policies],
-    };
+    const value = { operator, policies: [...policies] };
     compositions.add(value);
     return value;
 }

package/dist/v1/builder/schema/define.d.ts

@@ -2,7 +2,6 @@ import type { Domain } from '../../domain/model/domain.js';
 import type { DomainSchema } from '../../schema/model/schema.js';
 import type { DomainSchemaInput, EntrypointOf } from './input.js';
 import type { ResolvedDomainOfInput } from './projection.js';
-export type { DomainSchemaInput } from './input.js';
 /** Exact named Schema produced from one authored input. */
 export interface DefinedSchema<Origin extends string, Resolved extends Domain> extends DomainSchema<Origin, Resolved> {
 }

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

@@ -1,5 +1,7 @@
 import type { DiagnosticCode as LanguageDiagnosticCode } from '../../language/validation/diagnostic.js';
-export type BuilderDiagnosticCode = LanguageDiagnosticCode | 'BUILDER_ABSTRACT_POLICY' | 'BUILDER_AMBIGUOUS_OWNERSHIP' | 'BUILDER_AUTO_EVENT_INVALID' | 'BUILDER_AUTO_IMMUTABLE' | 'BUILDER_AUTO_NESTED' | 'BUILDER_AUTO_SET_INVALID' | 'BUILDER_CALLABLE_AUTH' | 'BUILDER_CALLABLE_PLACEMENT' | 'BUILDER_CALLABLE_POLICY_AUTH' | 'BUILDER_CORE_CLASS' | 'BUILDER_CORE_EDGE' | 'BUILDER_CORE_NODE' | 'BUILDER_CORE_PROPERTY' | 'BUILDER_CORE_REF' | 'BUILDER_DEFINITION' | 'BUILDER_DEPENDENCY_CONFLICT' | 'BUILDER_DEPENDENCY_ALIAS' | 'BUILDER_DEPENDENCY_DIRECT' | 'BUILDER_DUPLICATE_MEMBER' | 'BUILDER_FOREIGN_POLICY' | 'BUILDER_FULL_MATCH_INVALID' | 'BUILDER_FUNCTION' | 'BUILDER_METHOD' | 'BUILDER_PATH_DUPLICATE' | 'BUILDER_PATH_EMPTY' | 'BUILDER_POLICY' | 'BUILDER_POLICY_COMPOSITION' | 'BUILDER_POLICY_CYCLE' | 'BUILDER_POLICY_EMPTY_COMPOSITION' | 'BUILDER_POLICY_EMPTY_EXISTS' | 'BUILDER_POLICY_INPUT' | 'BUILDER_POLICY_REF' | 'BUILDER_POLICY_SELF' | 'BUILDER_PROPERTY_IMMUTABLE_INVALID' | 'BUILDER_REFERENCE_CYCLE' | 'BUILDER_REFERENCE_KIND' | 'BUILDER_REFERENCE_MISSING' | 'BUILDER_UNKNOWN_FIELD' | 'BUILDER_UNOWNED_REFERENCE' | 'BUILDER_VIEW' | 'ZOD_SCHEMA_NOT_LOSSLESS';
+import { escapePointerToken as escapeToken } from '../../language/value/syntax/pointer.js';
+export { escapeToken };
+export type BuilderDiagnosticCode = LanguageDiagnosticCode | 'BUILDER_ABSTRACT_POLICY' | 'BUILDER_AMBIGUOUS_OWNERSHIP' | 'BUILDER_AUTO_EVENT_INVALID' | 'BUILDER_AUTO_IMMUTABLE' | 'BUILDER_AUTO_NESTED' | 'BUILDER_AUTO_SET_INVALID' | 'BUILDER_CALLABLE_AUTH' | 'BUILDER_CALLABLE_PLACEMENT' | 'BUILDER_CALLABLE_POLICY_AUTH' | 'BUILDER_CLASS_INHERITANCE' | 'BUILDER_CORE_CLASS' | 'BUILDER_CORE_EDGE' | 'BUILDER_CORE_NODE' | 'BUILDER_CORE_PROPERTY' | 'BUILDER_CORE_REF' | 'BUILDER_DEFINITION' | 'BUILDER_DEPENDENCY_CONFLICT' | 'BUILDER_DEPENDENCY_ALIAS' | 'BUILDER_DEPENDENCY_DIRECT' | 'BUILDER_DUPLICATE_MEMBER' | 'BUILDER_EDGE_LIFETIME' | 'BUILDER_FOREIGN_POLICY' | 'BUILDER_FULL_MATCH_INVALID' | 'BUILDER_FUNCTION' | 'BUILDER_METHOD' | 'BUILDER_PATH_DUPLICATE' | 'BUILDER_PATH_EMPTY' | 'BUILDER_POLICY' | 'BUILDER_POLICY_COMPOSITION' | 'BUILDER_POLICY_CYCLE' | 'BUILDER_POLICY_EMPTY_COMPOSITION' | 'BUILDER_POLICY_EMPTY_EXISTS' | 'BUILDER_POLICY_INPUT' | 'BUILDER_POLICY_REF' | 'BUILDER_POLICY_SELF' | 'BUILDER_PROPERTY_IMMUTABLE_INVALID' | 'BUILDER_REFERENCE_CYCLE' | 'BUILDER_REFERENCE_KIND' | 'BUILDER_REFERENCE_MISSING' | 'BUILDER_UNIQUE_PROPERTY' | 'BUILDER_UNKNOWN_FIELD' | 'BUILDER_UNOWNED_REFERENCE' | 'BUILDER_VIEW' | 'ZOD_SCHEMA_NOT_LOSSLESS';
 export interface BuilderDiagnostic<out Code extends BuilderDiagnosticCode = BuilderDiagnosticCode> {
     readonly code: Code;
     readonly pointer: string;
@@ -13,4 +15,3 @@ export declare class BuilderError extends Error {
 }
 export declare function assertKnownKeys(value: object, allowed: readonly string[], pointer?: string): void;
 export declare function fail(code: BuilderDiagnosticCode, pointer: string, message: string): never;
-export declare function escapeToken(value: string): string;

package/dist/v1/builder/schema/diagnostic.js

@@ -1,16 +1,14 @@
-import { compareUnicode } from '../../addressing/ordering.js';
+import { formatDiagnostics, orderDiagnostics } from '../../language/validation/diagnostic.js';
+import { escapePointerToken as escapeToken } from '../../language/value/syntax/pointer.js';
+export { escapeToken };
 export function diagnostic(code, pointer, message, ref) {
     return Object.freeze({ code, pointer, message, ...(ref === undefined ? {} : { ref }) });
 }
 export class BuilderError extends Error {
     diagnostics;
     constructor(diagnostics) {
-        const ordered = [...diagnostics].sort((left, right) => compareUnicode(left.pointer, right.pointer) ||
-            compareUnicode(left.code, right.code) ||
-            compareUnicode(left.message, right.message));
-        super(ordered
-            .map(({ code, pointer, message }) => `${pointer || '/'} [${code}] ${message}`)
-            .join('\n'));
+        const ordered = orderDiagnostics(diagnostics);
+        super(formatDiagnostics(ordered));
         this.name = 'BuilderError';
         this.diagnostics = Object.freeze(ordered);
     }
@@ -26,6 +24,3 @@ export function assertKnownKeys(value, allowed, pointer = '') {
 export function fail(code, pointer, message) {
     throw new BuilderError([diagnostic(code, pointer, message)]);
 }
-export function escapeToken(value) {
-    return value.replaceAll('~', '~0').replaceAll('/', '~1');
-}

package/dist/v1/builder/schema/input.d.ts

@@ -1,6 +1,6 @@
 import type { DomainSchema } from '../../schema/model/schema.js';
 import type { Function } from '../callable/authoring.js';
-import type { Class } from '../class/authoring.js';
+import type { Class } from '../class/handle.js';
 import type { CoreInput } from '../core/authoring.js';
 import type { Policy } from '../policy/authoring.js';
 import type { View } from '../view/authoring.js';

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

@@ -18,6 +18,7 @@ type CallableConfig<Value> = Value extends Method<infer Config> ? Config extends
 type CallableInputValue<Value extends Method | Function> = CallableConfig<Value>['input'];
 type CallableOutputValue<Value extends Method | Function> = CallableConfig<Value>['output'];
 type CallableExecutionOf<Value extends Method | Function> = CallableConfig<Value>['execution'];
+type CallableAdmissionOf<Value extends Method | Function> = CallableConfig<Value>['admission'];
 type CallableStaticOf<Value extends Method> = CallableConfig<Value> extends {
     readonly static: true;
 } ? true : false;
@@ -25,11 +26,11 @@ type CallableAbstractOf<Value extends Method> = CallableConfig<Value> extends {
     readonly abstract: infer Abstract extends boolean;
 } ? Abstract : false;
 type CallableAuthOf<Value extends Method | Function> = CallableConfig<Value>['auth'];
-type MethodProjectionOfEntry<Origin extends string, OwnerName extends string, Entry> = Entry extends language.ResolvedMethod ? MethodProjectionOfResolved<Entry> : Entry extends AuthoredMethodEntry<infer Owner, infer Name, infer Value> ? MethodProjection<CallableInputValue<Value>, CallableOutputValue<Value>, CallableStaticOf<Value>, CallableAbstractOf<Value>, CallableAuthOf<Value>, Name, language.MethodKey<Origin, OwnerName, Name>, MethodExecutableOf<AbstractOf<ClassInputOf<Owner>>, CallableAbstractOf<Value>>, CallableExecutionOf<Value>> : never;
+type MethodProjectionOfEntry<Origin extends string, OwnerName extends string, Entry> = Entry extends language.ResolvedMethod ? MethodProjectionOfResolved<Entry> : Entry extends AuthoredMethodEntry<infer Owner, infer Name, infer Value> ? MethodProjection<CallableInputValue<Value>, CallableOutputValue<Value>, CallableStaticOf<Value>, CallableAbstractOf<Value>, CallableAuthOf<Value>, Name, language.MethodKey<Origin, OwnerName, Name>, MethodExecutableOf<AbstractOf<ClassInputOf<Owner>>, CallableAbstractOf<Value>>, CallableExecutionOf<Value>, CallableAdmissionOf<Value>> : never;
 type MethodProjectionOfEntries<Origin extends string, OwnerName extends string, Entries> = Entries extends unknown ? MethodProjectionOfEntry<Origin, OwnerName, Entries> : never;
 type MethodProjectionOfResolved<Value> = Value extends language.ResolvedMethod<infer Input, infer Output, infer Static, infer Abstract, infer Auth, infer _Policy, infer Key> & {
     readonly name: infer Name extends string;
-} ? MethodProjection<Input, Output, Static, Abstract, Auth, Name, Key, Value['executable'], Value['execution']> : never;
+} ? MethodProjection<Input, Output, Static, Abstract, Auth, Name, Key, Value['executable'], Value['execution'], Value['admission']> : never;
 /** Capture each Method through its qualified lookup key. */
 export type MethodsOfCollection<Value> = Value extends {
     readonly byKey: infer ByKey extends Readonly<Record<language.MethodKey, language.ResolvedMethod>>;
@@ -41,11 +42,12 @@ export type OwnStaticMethodProjectionsOf<Origin extends string, Name extends str
 /** Bind an authored Function to its exact Domain coordinates. */
 export type FunctionProjectionOfAuthoring<Origin extends string, Name extends string, Value> = Value extends Function ? FunctionProjection<CallableInputValue<Value>, CallableOutputValue<Value>, CallableAuthOf<Value>, language.FunctionRef<Name> & {
     readonly origin: Origin;
-}, language.DefinitionKey<Origin, 'function', Name>, CallableExecutionOf<Value>> : never;
-/** Restore a resolved Function while preserving its execution modifier. */
-export type ResolvedFunctionOfProjection<Value extends FunctionProjection> = Value extends FunctionProjection<infer Input, infer Output, infer Auth, infer Ref, infer Key, infer Execution> ? language.ResolvedFunction<Input, Output, Auth, language.CallablePolicy> & {
+}, language.DefinitionKey<Origin, 'function', Name>, CallableExecutionOf<Value>, CallableAdmissionOf<Value>> : never;
+/** Restore a resolved Function while preserving its execution modifier and admission age. */
+export type ResolvedFunctionOfProjection<Value extends FunctionProjection> = Value extends FunctionProjection<infer Input, infer Output, infer Auth, infer Ref, infer Key, infer Execution, infer Admission> ? language.ResolvedFunction<Input, Output, Auth, language.CallablePolicy> & {
     readonly ref: Ref;
     readonly key: Key;
     readonly execution: Execution;
+    readonly admission: Admission;
 } : never;
 export {};

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

@@ -1,12 +1,119 @@
 import type * as language from '../../../language/index.js';
-import type { NodeClass, DirectedEdgeClass, UndirectedEdgeClass, ClassReferenceProjection, Class, ProjectionOfClass } from '../../class/authoring.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;
     };
@@ -21,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;
     };
@@ -29,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'];
         };
     };
@@ -50,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;
     };
@@ -58,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'];
         }
     ];
@@ -81,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/builder/schema/projection/core-input.d.ts

@@ -1,6 +1,7 @@
 import type * as language from '../../../language/index.js';
 import type { BlobReceipt } from '../../../language/value/model/blob.js';
-import type { Class, AuthoredPropertyProjection } from '../../class/authoring.js';
+import type { Class } from '../../class/handle.js';
+import type { AuthoredPropertyProjection } from '../../class/projection.js';
 import type { ResolveLazy, IsMultiple } from './identity.js';
 import type { EffectivePropertyEntriesOfClass } from './property.js';
 /** Derive required, optional and forbidden Core Property inputs by name. */

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

@@ -1,4 +1,5 @@
-import type { NodeClass, DirectedEdgeClass, UndirectedEdgeClass, ClassReferenceProjection, ClassReferenceProjectionOf, Class, ClassIdentityProjectionOf, ClassOwnerProjectionOf, ClassOwnerProjection, ClassIdentityProjection } from '../../class/authoring.js';
+import type { NodeClass, DirectedEdgeClass, UndirectedEdgeClass, Class } from '../../class/handle.js';
+import type { ClassReferenceProjection, ClassReferenceProjectionOf, ClassIdentityProjectionOf, ClassOwnerProjectionOf, ClassOwnerProjection, ClassIdentityProjection } from '../../class/projection.js';
 import type { DomainSchemaInput } from '../input.js';
 /** Extract an authored abstract modifier with its default. */
 export type AbstractOf<Config> = Config extends {

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

@@ -10,7 +10,7 @@ export interface PropertyProjection<Value = unknown, Required extends boolean =
     readonly input: Input;
 }
 /** A Method’s exact callable, ownership and executable contracts. */
-export interface MethodProjection<Input = unknown, Output = unknown, Static extends boolean = boolean, Abstract extends boolean = boolean, Auth extends language.FunctionAuth = language.FunctionAuth, Name extends string = string, Key extends language.MethodKey = language.MethodKey, Executable extends boolean = boolean, Execution extends language.CallableExecution | undefined = language.CallableExecution | undefined> {
+export interface MethodProjection<Input = unknown, Output = unknown, Static extends boolean = boolean, Abstract extends boolean = boolean, Auth extends language.FunctionAuth = language.FunctionAuth, Name extends string = string, Key extends language.MethodKey = language.MethodKey, Executable extends boolean = boolean, Execution extends language.CallableExecution | undefined = language.CallableExecution | undefined, Admission extends language.CallableAdmission | undefined = language.CallableAdmission | undefined> {
     readonly input: Input;
     readonly output: Output;
     readonly static: Static;
@@ -20,15 +20,17 @@ export interface MethodProjection<Input = unknown, Output = unknown, Static exte
     readonly name: Name;
     readonly key: Key;
     readonly execution: Execution;
+    readonly admission: Admission;
 }
 /** A Function’s exact callable and declaration contracts. */
-export interface FunctionProjection<Input = unknown, Output = unknown, Auth extends language.FunctionAuth = language.FunctionAuth, Ref extends language.FunctionRef = language.FunctionRef, Key extends language.DefinitionKey<string, 'function'> = language.DefinitionKey<string, 'function'>, Execution extends language.CallableExecution | undefined = language.CallableExecution | undefined> {
+export interface FunctionProjection<Input = unknown, Output = unknown, Auth extends language.FunctionAuth = language.FunctionAuth, Ref extends language.FunctionRef = language.FunctionRef, Key extends language.DefinitionKey<string, 'function'> = language.DefinitionKey<string, 'function'>, Execution extends language.CallableExecution | undefined = language.CallableExecution | undefined, Admission extends language.CallableAdmission | undefined = language.CallableAdmission | undefined> {
     readonly input: Input;
     readonly output: Output;
     readonly auth: Auth;
     readonly ref: Ref;
     readonly key: Key;
     readonly execution: Execution;
+    readonly admission: Admission;
 }
 /** A compact Class witness with effective members and exact self facets. */
 export interface ClassProjection<Kind extends language.ClassKind = language.ClassKind, Definition extends Extract<language.ClassDefinition, {

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

@@ -1,5 +1,5 @@
 import type * as language from '../../../language/index.js';
-import type { AuthoredPropertyProjection } from '../../class/authoring.js';
+import type { AuthoredPropertyProjection } from '../../class/projection.js';
 import type { DomainSchemaInput } from '../input.js';
 import type { RecordField, ClassInputOf, OwnerNameOf } from './identity.js';
 import type { PropertyProjection } from './model.js';

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

@@ -56,10 +56,11 @@ type ProjectionPropertyByName<Entries extends PropertyProjection> = Readonly<{
 /** Restore qualified lookup and unambiguous named Property access. */
 type PropertyCollectionOfProjection<Entries extends PropertyProjection> = language.ResolvedPropertyCollection<ProjectionPropertyByKey<Entries>, ProjectionPropertyByName<Entries>>;
 type MethodCollectionOperation = 'byKey' | 'get';
-type ResolvedMethodOfProjection<Value> = Value extends MethodProjection<infer Input, infer Output, infer Static, infer Abstract, infer Auth, infer Name, infer Key, infer Executable, infer Execution> ? language.ResolvedMethod<Input, Output, Static, Abstract, Auth, language.CallablePolicy, Key> & {
+type ResolvedMethodOfProjection<Value> = Value extends MethodProjection<infer Input, infer Output, infer Static, infer Abstract, infer Auth, infer Name, infer Key, infer Executable, infer Execution, infer Admission> ? language.ResolvedMethod<Input, Output, Static, Abstract, Auth, language.CallablePolicy, Key> & {
     readonly name: Name;
     readonly executable: Executable;
     readonly execution: Execution;
+    readonly admission: Admission;
 } : never;
 type ProjectionMethodByKey<Entries extends MethodProjection> = Readonly<{
     [Key in Entries['key']]: ResolvedMethodOfProjection<Extract<Entries, {

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

@@ -1,4 +1,4 @@
-export type { PropertyProjection, MethodProjection, FunctionProjection, ClassProjection, DomainProjection, } from './projection/model.js';
+export type { PropertyProjection, MethodProjection, FunctionProjection, ClassProjection, } from './projection/model.js';
 export type { ResolvedDomainOfInput } from './projection/domain.js';
 export type { CoreNamedPropertyInput, CorePropertyInput } from './projection/core-input.js';
 export type { ClassProjectionOfResolved } from './projection/resolved-class.js';

package/dist/v1/builder/value/full-match.d.ts

@@ -1,4 +1,3 @@
 import { type FullMatch } from '../../language/value/syntax/full-match.js';
-export { fullMatchSource, type FullMatch } from '../../language/value/syntax/full-match.js';
 /** Authoring facade preserving the Builder-owned diagnostic for invalid source syntax. */
 export declare function fullMatch(source: string): FullMatch;

package/dist/v1/builder/value/full-match.js

@@ -1,7 +1,6 @@
 import { refuseIRegexp, stateBudgetMessage } from '../../language/value/regexp/syntax.js';
 import { fullMatch as languageFullMatch, } from '../../language/value/syntax/full-match.js';
 import { fail } from '../schema/diagnostic.js';
-export { fullMatchSource } from '../../language/value/syntax/full-match.js';
 /** Authoring facade preserving the Builder-owned diagnostic for invalid source syntax. */
 export function fullMatch(source) {
     const refusal = refuseIRegexp(source);

package/dist/v1/builder/value/path-metadata.d.ts

@@ -1,4 +1,4 @@
 import type { z } from 'zod';
-import type { NodeClassReferenceInput } from '../class/authoring.js';
+import type { NodeClassReferenceInput } from '../class/input.js';
 export declare function rememberPath(schema: z.ZodType, accepts: readonly NodeClassReferenceInput[]): void;
 export declare function pathAccepts(schema: z.ZodType): readonly NodeClassReferenceInput[] | undefined;

package/dist/v1/builder/value/path.d.ts

@@ -1,5 +1,5 @@
 import { type ZodString } from 'zod';
-import type { NodeClassReferenceInput } from '../class/authoring.js';
+import type { NodeClassReferenceInput } from '../class/input.js';
 declare const PATH_ACCEPTS: unique symbol;
 export type PathAuthoring<Accepts extends readonly NodeClassReferenceInput[] = readonly NodeClassReferenceInput[]> = ZodString & {
     readonly [PATH_ACCEPTS]: Accepts;