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

package/dist/v1/addressing/definition-ref.js

@@ -8,55 +8,39 @@ const DEFINITION_KINDS = new Set([
 ]);
 /** Admit and detach one canonical DefinitionRef from an untrusted value. */
 export function acceptDefinitionRef(input) {
-    if (input === null || typeof input !== 'object' || Array.isArray(input)) {
-        invalid(input);
-    }
+    return readDefinitionRef(input) ?? invalid(input);
+}
+/** Identify a canonical DefinitionRef-shaped value without retaining caller state. */
+export function isDefinitionRef(input) {
+    return readDefinitionRef(input) !== undefined;
+}
+/** Compare exact Definition coordinates, independent of object identity. */
+export function equalDefinitionRefs(left, right) {
+    return left.origin === right.origin && left.kind === right.kind && left.name === right.name;
+}
+function invalid(input) {
+    throw new TypeError(`Invalid DefinitionRef: ${JSON.stringify(input)}.`);
+}
+/** A detached copy of the canonical DefinitionRef `input` holds, reading each field once. */
+function readDefinitionRef(input) {
+    if (input === null || typeof input !== 'object' || Array.isArray(input))
+        return undefined;
     const value = input;
     const keys = Reflect.ownKeys(value);
     if (keys.length !== 3 ||
         !keys.every((key) => key === 'origin' || key === 'kind' || key === 'name')) {
-        invalid(input);
+        return undefined;
     }
-    const origin = value.origin;
-    const kind = value.kind;
-    const name = value.name;
+    const { origin, kind, name } = value;
     if (typeof origin !== 'string' ||
         !DOMAIN_ORIGIN_PATTERN.test(origin) ||
         typeof kind !== 'string' ||
         !DEFINITION_KINDS.has(kind) ||
         typeof name !== 'string' ||
         !definitionNameMatches(kind, name)) {
-        invalid(input);
+        return undefined;
     }
-    return Object.freeze({
-        origin,
-        kind: kind,
-        name,
-    });
-}
-/** Identify a canonical DefinitionRef-shaped value without retaining caller state. */
-export function isDefinitionRef(input) {
-    if (input === null || typeof input !== 'object' || Array.isArray(input))
-        return false;
-    const value = input;
-    const keys = Reflect.ownKeys(value);
-    if (keys.length !== 3 ||
-        !keys.every((key) => key === 'origin' || key === 'kind' || key === 'name')) {
-        return false;
-    }
-    return (typeof value.origin === 'string' &&
-        DOMAIN_ORIGIN_PATTERN.test(value.origin) &&
-        typeof value.kind === 'string' &&
-        DEFINITION_KINDS.has(value.kind) &&
-        typeof value.name === 'string' &&
-        definitionNameMatches(value.kind, value.name));
-}
-/** Compare exact Definition coordinates, independent of object identity. */
-export function equalDefinitionRefs(left, right) {
-    return left.origin === right.origin && left.kind === right.kind && left.name === right.name;
-}
-function invalid(input) {
-    throw new TypeError(`Invalid DefinitionRef: ${JSON.stringify(input)}.`);
+    return Object.freeze({ origin, kind: kind, name });
 }
 function definitionNameMatches(kind, name) {
     return kind === 'core' ? CORE_SLUG_PATTERN.test(name) : MEMBER_NAME_PATTERN.test(name);

package/dist/v1/addressing/ordering.d.ts

@@ -4,3 +4,5 @@ export declare function definitionRefIndex(ref: DefinitionRef): string;
 export declare function compareDefinitionRefs(left: DefinitionRef, right: DefinitionRef): number;
 /** Locale-independent Unicode code-point ordering for canonical DSL values. */
 export declare function compareUnicode(left: string, right: string): number;
+/** Order strings by UTF-16 code unit, the order `<` gives strings. */
+export declare function compareCodeUnits(left: string, right: string): number;

package/dist/v1/addressing/ordering.js

@@ -18,3 +18,7 @@ export function compareUnicode(left, right) {
     }
     return a.length - b.length;
 }
+/** Order strings by UTF-16 code unit, the order `<` gives strings. */
+export function compareCodeUnits(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}

package/dist/v1/addressing/patterns.d.ts

@@ -19,4 +19,3 @@ export declare const patterns: Readonly<{
     revision: RegExp;
     revisionFullMatch: "sha256:[0-9a-f]{64}";
 }>;
-export declare function assertMemberName(name: string): void;

package/dist/v1/addressing/patterns.js

@@ -22,8 +22,3 @@ export const patterns = Object.freeze({
     revision: DOMAIN_REVISION_PATTERN,
     revisionFullMatch: DOMAIN_REVISION_FULL_MATCH,
 });
-export function assertMemberName(name) {
-    if (!MEMBER_NAME_PATTERN.test(name)) {
-        throw new TypeError(`Invalid member name: ${JSON.stringify(name)}.`);
-    }
-}

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

@@ -3,7 +3,7 @@ import type { z } from 'zod';
 import type { PolicyRef } from '../../addressing/index.js';
 import type { BinaryInputProjection, CallableAdmission, CallableExecution, FunctionAuth } from '../../language/callable/model/callable.js';
 import type { PolicyCheckExpression, PolicyCheckObject, PolicyObjectRef } from '../../language/policy/model/policy.js';
-import type { Class } from '../class/authoring.js';
+import type { Class } from '../class/handle.js';
 import type { ValueSchemaInput } from '../class/property.js';
 import type { CoreNode } from '../core/authoring.js';
 import type { Policy, PolicyInput } from '../policy/authoring.js';

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

@@ -1,147 +1,16 @@
 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 { MethodRecord } from '../../language/callable/model/callable.js';
-import type { ResolvedMethod } from '../../language/callable/resolved.js';
-import type { Inheritance } from '../../language/class/model/class.js';
-import type { MediaType } from '../../language/class/model/data.js';
-import type { EdgeCount, EdgeLifetime } from '../../language/class/model/edge.js';
 import type { ResolvedClass, ResolvedProperty } from '../../language/class/resolved.js';
-import type { ClassRuleChecks, ClassRuleObject } from '../../language/policy/model/policy.js';
-import type { StateTopology, StateTopologyOf } from '../../language/state/topology.js';
+import type { StateTopologyOf } from '../../language/state/topology.js';
 import type { BlobReceipt, BlobRef, BlobSchema } from '../../language/value/model/blob.js';
-import type { Method, PolicyCheckContext, ProjectionOfCallable } from '../callable/authoring.js';
-import type { Policy } from '../policy/authoring.js';
-import type { Lazy } from '../schema/lazy.js';
+import type { Method, ProjectionOfCallable } from '../callable/authoring.js';
 import type { ClassProjectionOfResolved } from '../schema/projection.js';
 import type { TypedValueSchema } from '../value/schema.js';
+import type { Class, DirectedEdgeClass, EdgeClass, NodeClass, UndirectedEdgeClass } from './handle.js';
+import type { DirectedEdgeInput, DirectedSourceInput, DirectedTargetInput, IncidentEndpointInput, NodeClassInput, UndirectedEdgeInput } from './input.js';
+import type { AuthoredMethodProjection, AuthoredPropertyProjection, BindMethodOwners, BindPropertyOwners, ClassOwnerProjectionOf, ClassReferenceProjectionOf } from './projection.js';
 import type { AutoProperty, Property, PropertyOptions, PropertyStateMachineOf, ValueSchemaInput } from './property.js';
-import type { PropertyRecordInput } from './property.js';
-import { type AUTHORING } from '../schema/handle.js';
-declare const CLASS_TYPE: unique symbol;
-export type ClassReferenceInput = Lazy<Class | ClassRef | ResolvedClass<'node'> | ResolvedClass<'edge'>>;
-export type NodeClassReferenceInput = Lazy<NodeClass | ClassRef | ResolvedClass<'node'>>;
-export type EdgeClassReferenceInput = Lazy<EdgeClass | ClassRef | ResolvedClass<'edge'>>;
-export interface DirectedSourceInput {
-    readonly as: string;
-    readonly accepts: readonly NodeClassReferenceInput[];
-    readonly outgoing: EdgeCount;
-    /** What deleting a Node at this endpoint does to the Edge; derived when omitted. */
-    readonly onDelete?: EdgeLifetime;
-}
-export interface DirectedTargetInput {
-    readonly as: string;
-    readonly accepts: readonly NodeClassReferenceInput[];
-    readonly incoming: EdgeCount;
-    /** What deleting a Node at this endpoint does to the Edge; derived when omitted. */
-    readonly onDelete?: EdgeLifetime;
-}
-export interface IncidentEndpointInput {
-    readonly as: string;
-    readonly accepts: readonly NodeClassReferenceInput[];
-    readonly incident: EdgeCount;
-    /** What deleting a Node at this endpoint does to the Edge; derived when omitted. */
-    readonly onDelete?: EdgeLifetime;
-}
 type ExactEndpointInput<Input, Shape> = Input & Record<Exclude<keyof Input, keyof Shape>, never>;
-/** One observation slot: a local Policy, or its constant value. Absent means `true`. */
-export type ClassPolicyInput = Lazy<Policy> | boolean;
-export interface ClassPoliciesInput {
-    readonly read?: ClassPolicyInput;
-    readonly traverse?: ClassPolicyInput;
-}
-/**
- * Policy checks deciding one Node Class observation. `self` is the observed Node; `ref` names one
- * exact member, the same Node for every observed candidate.
- */
-export interface ClassRuleContext extends PolicyCheckContext<ClassRuleObject> {
-}
-export type ClassRuleBuilder = (context: ClassRuleContext) => ClassRuleChecks;
-/** One Node Class observation slot: a local Policy, a constant value, or Policy checks. */
-export type NodeClassPolicyInput = ClassPolicyInput | ClassRuleBuilder;
-export interface NodeClassPoliciesInput {
-    readonly read?: NodeClassPolicyInput;
-    readonly traverse?: NodeClassPolicyInput;
-}
-export interface NodeClassInput {
-    readonly abstract?: boolean;
-    /** Which Classes may extend this one; omitted, those of its own Domain only (`'internal'`). */
-    readonly inheritance?: Inheritance;
-    readonly description?: string;
-    readonly extends?: readonly NodeClassReferenceInput[];
-    readonly properties?: PropertyRecordInput;
-    readonly data?: MediaType;
-    readonly methods?: Readonly<Record<string, Method>>;
-    readonly icon?: string;
-    /** Local observation Policies; inherited by no descendant and forbidden on abstract Classes. */
-    readonly policies?: NodeClassPoliciesInput;
-    /**
-     * The tuples no two Nodes of this Class and of its active concrete descendants share while every
-     * Property is present; omitted, none. A descendant is covered without declaring them again.
-     */
-    readonly unique?: readonly NodeUniqueTupleInput[];
-}
-/**
- * The distinct Properties of one Node key, in any order, each a Property of the Class, own or
- * inherited, by its name or, when names collide, by its full key.
- */
-export type NodeUniqueTupleInput = readonly [string, ...string[]];
-export interface EdgeClassOptions {
-    readonly abstract?: boolean;
-    /** Which Classes may extend this one; omitted, those of its own Domain only (`'internal'`). */
-    readonly inheritance?: Inheritance;
-    readonly description?: string;
-    readonly extends?: readonly EdgeClassReferenceInput[];
-    readonly properties?: PropertyRecordInput;
-    /** Local observation Policies; inherited by no descendant and forbidden on abstract Classes. */
-    readonly policies?: ClassPoliciesInput;
-    readonly constraints?: {
-        readonly noSelf?: true;
-        readonly acyclic?: true;
-    };
-}
-/**
- * A key field as authored: an endpoint, the slug, or a Property of the Class, own or inherited, by
- * its name or, when names collide, by its full key.
- */
-export type EdgeUniqueFieldInput = 'source' | 'target' | 'slug' | {
-    readonly property: string;
-};
-/** The distinct fields of one key, in any order. */
-export type EdgeUniqueTupleInput = readonly [EdgeUniqueFieldInput, ...EdgeUniqueFieldInput[]];
-export interface DirectedEdgeInput extends EdgeClassOptions {
-    readonly orientation: 'directed';
-    readonly source: DirectedSourceInput;
-    readonly target: DirectedTargetInput;
-    /**
-     * The tuples no two Edges of this Class and of its active concrete descendants share while every
-     * field is present; omitted, none. A descendant is covered without declaring them again.
-     */
-    readonly unique?: readonly EdgeUniqueTupleInput[];
-}
-export interface UndirectedEdgeInput extends Omit<EdgeClassOptions, 'constraints'> {
-    readonly orientation: 'undirected';
-    readonly endpoints: readonly [IncidentEndpointInput, IncidentEndpointInput];
-    readonly constraints?: {
-        readonly noSelf?: true;
-    };
-}
-export type EdgeClassCommon = EdgeClassOptions;
-export type EdgeClassInput = DirectedEdgeInput | UndirectedEdgeInput;
-export type Class = NodeClass | EdgeClass;
-export interface AuthoredPropertyProjection<out Input = unknown, out Output = unknown, out Required extends boolean = boolean, out Name extends string = string, out Owner = 'self', out State extends StateTopology | undefined = StateTopology | undefined> {
-    readonly input: Input;
-    readonly output: Output;
-    readonly required: Required;
-    readonly name: Name;
-    readonly owner: Owner;
-    readonly state?: State;
-}
-export interface AuthoredMethodProjection<out Value extends Method = Method, out Name extends string = string, out Owner = 'self'> {
-    readonly value: Value;
-    readonly name: Name;
-    readonly owner: Owner;
-}
 type PropertySchemaOf<Field> = Field extends AutoProperty<infer Value> ? PropertySchemaOf<Value> : Field extends Property<infer Schema, PropertyOptions, unknown> ? Schema : Field;
 type PropertyOptionsOf<Field> = Field extends AutoProperty<infer Value> ? PropertyOptionsOf<Value> : Field extends Property<ValueSchemaInput, infer Options, unknown> ? Options : Record<never, never>;
 type ValueInputOf<Schema> = Schema extends BlobSchema ? BlobReceipt : Schema extends TypedValueSchema<infer Value> ? Value : Schema extends z.ZodType ? z.input<Schema> : PortableValue;
@@ -166,7 +35,6 @@ type ParentPropertyProjectionsOf<Input> = Input extends {
 type EffectivePropertyProjectionsOf<Input> = PropertyProjectionEntriesOf<'properties' extends keyof Input ? Input extends {
     readonly properties?: infer Value;
 } ? NonNullable<Value> : never : never> | ParentPropertyProjectionsOf<Input>;
-type BindPropertyOwners<Entries, Owner> = Entries extends AuthoredPropertyProjection<infer Input, infer Output, infer Required, infer Name, infer ExistingOwner, infer State> ? AuthoredPropertyProjection<Input, Output, Required, Name, ExistingOwner extends 'self' ? Owner : ExistingOwner, State> : Entries;
 type MethodFieldsOf<Input> = 'methods' extends keyof Input ? Input extends {
     readonly methods?: infer Methods extends Readonly<Record<string, Method>>;
 } ? NonNullable<Methods> : Readonly<Record<never, never>> : Readonly<Record<never, never>>;
@@ -176,7 +44,6 @@ type MethodIsStatic<Value extends Method> = ProjectionOfCallable<Value> extends
 type OwnMethodProjectionsOf<Input, Static extends boolean> = {
     [Name in keyof MethodFieldsOf<Input>]: MethodFieldsOf<Input>[Name] extends infer Value extends Method ? MethodIsStatic<Value> extends Static ? AuthoredMethodProjection<Value, Extract<Name, string>> : never : never;
 }[keyof MethodFieldsOf<Input>];
-type BindMethodOwners<Entries, Owner> = Entries extends AuthoredMethodProjection<infer Value, infer Name, infer ExistingOwner> ? AuthoredMethodProjection<Value, Name, ExistingOwner extends 'self' ? Owner : ExistingOwner> : Entries;
 type AbstractMethodEntries<Entry> = Entry extends AuthoredMethodProjection<infer Value> ? ProjectionOfCallable<Value> extends {
     readonly abstract: true;
 } ? Entry : never : Entry extends {
@@ -213,104 +80,6 @@ type Increment<Depth extends number> = number extends Depth ? number : [...Tuple
 type ClassDepthOfInput<Input> = Input extends {
     readonly extends?: infer Parents extends readonly unknown[];
 } ? Parents extends readonly [] ? 0 : Increment<ClassDepthOf<Parents[number]>> : 0;
-export interface ClassIdentityProjection<out Kind extends 'node' | 'edge' = 'node' | 'edge', out Identity = unknown> {
-    readonly kind: Kind;
-    readonly identity: Identity;
-}
-export interface ClassOwnerProjection<out Kind extends 'node' | 'edge' = 'node' | 'edge', out Identity = unknown, out Properties = unknown, out InstanceMethods = unknown, out StaticMethods = unknown> extends ClassIdentityProjection<Kind, Identity> {
-    readonly properties: Properties;
-    readonly instanceMethods: InstanceMethods;
-    readonly staticMethods: StaticMethods;
-}
-export interface ClassReferenceProjection<out Kind extends 'node' | 'edge' = 'node' | 'edge', out Identity = unknown, out EffectiveProperties = AuthoredPropertyProjection, out EffectiveInstanceMethods = unknown, out EffectiveStaticMethods = unknown> extends ClassIdentityProjection<Kind, Identity> {
-    readonly effectiveProperties: EffectiveProperties;
-    readonly effectiveInstanceMethods: EffectiveInstanceMethods;
-    readonly effectiveStaticMethods: EffectiveStaticMethods;
-}
-type NodeClassIdentity<Config> = Config extends {
-    readonly abstract: infer Abstract;
-    readonly depth: infer Depth;
-    readonly properties: infer Properties;
-    readonly methods: infer Methods;
-} ? {
-    readonly abstract: Abstract;
-    readonly depth: Depth;
-    readonly properties: Properties;
-    readonly methods: Methods;
-} : never;
-type DirectedEdgeClassIdentity<Config> = Config extends {
-    readonly abstract: infer Abstract;
-    readonly depth: infer Depth;
-    readonly properties: infer Properties;
-    readonly source: infer Source;
-    readonly target: infer Target;
-    readonly constraints: infer Constraints;
-} ? {
-    readonly abstract: Abstract;
-    readonly depth: Depth;
-    readonly properties: Properties;
-    readonly source: Source;
-    readonly target: Target;
-    readonly constraints: Constraints;
-} : never;
-type UndirectedEdgeClassIdentity<Config> = Config extends {
-    readonly abstract: infer Abstract;
-    readonly depth: infer Depth;
-    readonly properties: infer Properties;
-    readonly endpoints: infer Endpoints;
-    readonly constraints: infer Constraints;
-} ? {
-    readonly abstract: Abstract;
-    readonly depth: Depth;
-    readonly properties: Properties;
-    readonly endpoints: Endpoints;
-    readonly constraints: Constraints;
-} : never;
-type OwnerErasedPropertyProjection<Entry> = Entry extends AuthoredPropertyProjection<infer Input, infer Output, infer Required, infer Name, unknown, infer State> ? AuthoredPropertyProjection<Input, Output, Required, Name, unknown, State> : Entry extends ResolvedProperty<infer Value, infer Required, infer State, infer Input> & {
-    readonly name: infer Name;
-    readonly key: infer Key;
-} ? {
-    readonly value: Value;
-    readonly input: Input;
-    readonly required: Required;
-    readonly name: Name;
-    readonly key: Key;
-    readonly state?: State;
-} : never;
-type OwnerErasedMethodProjection<Entry> = Entry extends AuthoredMethodProjection<infer Value, infer Name, unknown> ? AuthoredMethodProjection<Value, Name, unknown> : Entry extends ResolvedMethod<infer Input, infer Output, infer Static, infer Abstract, infer Auth, infer _Policy, infer Key> & {
-    readonly name: infer Name;
-} ? {
-    readonly input: Input;
-    readonly output: Output;
-    readonly static: Static;
-    readonly abstract: Abstract;
-    readonly auth: Auth;
-    readonly name: Name;
-    readonly key: Key;
-} : never;
-export type ClassIdentityProjectionOf<Value> = Value extends NodeClass<infer Config> ? ClassIdentityProjection<'node', NodeClassIdentity<Config>> : Value extends DirectedEdgeClass<infer Config> ? ClassIdentityProjection<'edge', DirectedEdgeClassIdentity<Config>> : Value extends UndirectedEdgeClass<infer Config> ? ClassIdentityProjection<'edge', UndirectedEdgeClassIdentity<Config>> : never;
-export type ClassOwnerProjectionOf<Value> = Value extends NodeClass<infer Config> ? ClassOwnerProjection<'node', NodeClassIdentity<Config>, Config extends {
-    readonly effectiveProperties: infer Properties;
-} ? OwnerErasedPropertyProjection<Properties> : never, Config extends {
-    readonly effectiveInstanceMethods: infer Methods;
-} ? OwnerErasedMethodProjection<Methods> : never, Config extends {
-    readonly effectiveStaticMethods: infer Methods;
-} ? OwnerErasedMethodProjection<Methods> : never> : Value extends DirectedEdgeClass<infer Config> ? ClassOwnerProjection<'edge', DirectedEdgeClassIdentity<Config>, Config extends {
-    readonly effectiveProperties: infer Properties;
-} ? OwnerErasedPropertyProjection<Properties> : never, never, never> : Value extends UndirectedEdgeClass<infer Config> ? ClassOwnerProjection<'edge', UndirectedEdgeClassIdentity<Config>, Config extends {
-    readonly effectiveProperties: infer Properties;
-} ? OwnerErasedPropertyProjection<Properties> : never, never, never> : never;
-export type ClassReferenceProjectionOf<Value> = Value extends NodeClass<infer Config> ? ClassReferenceProjection<'node', NodeClassIdentity<Config>, Config extends {
-    readonly effectiveProperties: infer Properties;
-} ? BindPropertyOwners<Properties, ClassOwnerProjectionOf<NodeClass<Config>>> : never, Config extends {
-    readonly effectiveInstanceMethods: infer Methods;
-} ? BindMethodOwners<Methods, ClassOwnerProjectionOf<NodeClass<Config>>> : never, Config extends {
-    readonly effectiveStaticMethods: infer Methods;
-} ? BindMethodOwners<Methods, ClassOwnerProjectionOf<NodeClass<Config>>> : never> : Value extends DirectedEdgeClass<infer Config> ? ClassReferenceProjection<'edge', DirectedEdgeClassIdentity<Config>, Config extends {
-    readonly effectiveProperties: infer Properties;
-} ? BindPropertyOwners<Properties, ClassOwnerProjectionOf<DirectedEdgeClass<Config>>> : never, never, never> : Value extends UndirectedEdgeClass<infer Config> ? ClassReferenceProjection<'edge', UndirectedEdgeClassIdentity<Config>, Config extends {
-    readonly effectiveProperties: infer Properties;
-} ? BindPropertyOwners<Properties, ClassOwnerProjectionOf<UndirectedEdgeClass<Config>>> : never, never, never> : never;
 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]>[];
 type CompactParentsOf<Input> = Input extends {
@@ -380,24 +149,6 @@ type CompactUndirectedInput<Input extends Omit<UndirectedEdgeInput, 'orientation
     } ? NonNullable<Value> : Record<never, never>;
     readonly effectiveProperties: EffectivePropertyProjectionsOf<Input>;
 };
-export interface NodeClass<out Config = unknown> {
-    readonly [AUTHORING]: 'definition';
-    readonly kind: 'node';
-    readonly [CLASS_TYPE]: () => Config;
-}
-export interface DirectedEdgeClass<out Input = unknown> {
-    readonly [AUTHORING]: 'definition';
-    readonly kind: 'edge';
-    readonly orientation: 'directed';
-    readonly [CLASS_TYPE]: () => Input;
-}
-export interface UndirectedEdgeClass<out Input = unknown> {
-    readonly [AUTHORING]: 'definition';
-    readonly kind: 'edge';
-    readonly orientation: 'undirected';
-    readonly [CLASS_TYPE]: () => Input;
-}
-export type EdgeClass = DirectedEdgeClass | UndirectedEdgeClass;
 export declare function defineClass(config: {
     readonly kind: 'node';
     readonly abstract: boolean;
@@ -430,9 +181,8 @@ type WithoutStateProperties<Input> = Input extends {
         readonly [Name in keyof Properties]: Properties[Name] extends Property ? [PropertyStateMachineOf<Properties[Name]>] extends [never] ? Properties[Name] : never : Properties[Name];
     };
 } : unknown;
-export type ProjectionOfClass<Value extends Class> = Value extends NodeClass<infer Config> ? Config : Value extends DirectedEdgeClass<infer Input> ? Input : Value extends UndirectedEdgeClass<infer Input> ? Input : never;
 export declare function classConfiguration(value: NodeClass): NodeClassInput;
 export declare function classConfiguration(value: DirectedEdgeClass): Omit<DirectedEdgeInput, 'orientation'>;
 export declare function classConfiguration(value: UndirectedEdgeClass): Omit<UndirectedEdgeInput, 'orientation'>;
 export declare function classConfiguration(value: EdgeClass): Omit<DirectedEdgeInput, 'orientation'> | Omit<UndirectedEdgeInput, 'orientation'>;
-export type { MethodRecord };
+export {};

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

@@ -59,7 +59,7 @@ export const edgeClass = Object.freeze({
         validateDirectedSourceInput(input.source);
         validateDirectedTargetInput(input.target);
         const { source, target, unique, ...options } = input;
-        validateEdgeClassOptions(options);
+        validateEdgeClassOptions(options, ['noSelf', 'acyclic']);
         const value = authoringValue('definition', {
             kind: 'edge',
             orientation: 'directed',
@@ -94,7 +94,7 @@ export const edgeClass = Object.freeze({
         validateIncidentEndpointInput(input.endpoints[0]);
         validateIncidentEndpointInput(input.endpoints[1]);
         const { endpoints, ...options } = input;
-        validateUndirectedEdgeClassOptions(options);
+        validateEdgeClassOptions(options, ['noSelf']);
         const value = authoringValue('definition', {
             kind: 'edge',
             orientation: 'undirected',
@@ -122,33 +122,10 @@ function validateDirectedTargetInput(value) {
 function validateIncidentEndpointInput(value) {
     assertKnownKeys(value, ['as', 'accepts', 'incident', 'onDelete']);
 }
-function validateEdgeClassOptions(value) {
-    assertKnownKeys(value, [
-        'abstract',
-        'inheritance',
-        'description',
-        'extends',
-        'properties',
-        'policies',
-        'constraints',
-    ]);
-    if (value.policies !== undefined)
-        assertKnownKeys(value.policies, ['read', 'traverse']);
-    if (value.constraints !== undefined)
-        assertKnownKeys(value.constraints, ['noSelf', 'acyclic']);
-}
-function validateUndirectedEdgeClassOptions(value) {
-    assertKnownKeys(value, [
-        'abstract',
-        'inheritance',
-        'description',
-        'extends',
-        'properties',
-        'policies',
-        'constraints',
-    ]);
+/** Check the nested Edge Class options; the caller has checked the option keys themselves. */
+function validateEdgeClassOptions(value, constraints) {
     if (value.policies !== undefined)
         assertKnownKeys(value.policies, ['read', 'traverse']);
     if (value.constraints !== undefined)
-        assertKnownKeys(value.constraints, ['noSelf']);
+        assertKnownKeys(value.constraints, constraints);
 }

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

@@ -0,0 +1,27 @@
+import { type AUTHORING } from '../schema/handle.js';
+declare const CLASS_TYPE: unique symbol;
+/** Authored Node Class handle; its type carries the compact projection of its input. */
+export interface NodeClass<out Config = unknown> {
+    readonly [AUTHORING]: 'definition';
+    readonly kind: 'node';
+    readonly [CLASS_TYPE]: () => Config;
+}
+/** Authored directed Edge Class handle; its type carries the compact projection of its input. */
+export interface DirectedEdgeClass<out Input = unknown> {
+    readonly [AUTHORING]: 'definition';
+    readonly kind: 'edge';
+    readonly orientation: 'directed';
+    readonly [CLASS_TYPE]: () => Input;
+}
+/** Authored undirected Edge Class handle; its type carries the compact projection of its input. */
+export interface UndirectedEdgeClass<out Input = unknown> {
+    readonly [AUTHORING]: 'definition';
+    readonly kind: 'edge';
+    readonly orientation: 'undirected';
+    readonly [CLASS_TYPE]: () => Input;
+}
+export type EdgeClass = DirectedEdgeClass | UndirectedEdgeClass;
+export type Class = NodeClass | EdgeClass;
+/** The compact projection a Class handle carries. */
+export type ProjectionOfClass<Value extends Class> = Value extends NodeClass<infer Config> ? Config : Value extends DirectedEdgeClass<infer Input> ? Input : Value extends UndirectedEdgeClass<infer Input> ? Input : never;
+export {};

package/dist/v1/builder/class/handle.js

@@ -0,0 +1 @@
+import {} from '../schema/handle.js';

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

@@ -0,0 +1,129 @@
+import type { ClassRef } from '../../addressing/index.js';
+import type { Inheritance } from '../../language/class/model/class.js';
+import type { MediaType } from '../../language/class/model/data.js';
+import type { EdgeCount, EdgeLifetime } from '../../language/class/model/edge.js';
+import type { ResolvedClass } from '../../language/class/resolved.js';
+import type { ClassRuleChecks, ClassRuleObject } from '../../language/policy/model/policy.js';
+import type { Method, PolicyCheckContext } from '../callable/authoring.js';
+import type { Policy } from '../policy/authoring.js';
+import type { Lazy } from '../schema/lazy.js';
+import type { Class, EdgeClass, NodeClass } from './handle.js';
+import type { PropertyRecordInput } from './property.js';
+/** Reference to a Class: an authored handle, a ClassRef or a resolved Class, possibly lazy. */
+export type ClassReferenceInput = Lazy<Class | ClassRef | ResolvedClass<'node'> | ResolvedClass<'edge'>>;
+export type NodeClassReferenceInput = Lazy<NodeClass | ClassRef | ResolvedClass<'node'>>;
+export type EdgeClassReferenceInput = Lazy<EdgeClass | ClassRef | ResolvedClass<'edge'>>;
+/** Source side of a directed Edge Class. */
+export interface DirectedSourceInput {
+    readonly as: string;
+    readonly accepts: readonly NodeClassReferenceInput[];
+    readonly outgoing: EdgeCount;
+    /** What deleting a Node at this endpoint does to the Edge; derived when omitted. */
+    readonly onDelete?: EdgeLifetime;
+}
+/** Target side of a directed Edge Class. */
+export interface DirectedTargetInput {
+    readonly as: string;
+    readonly accepts: readonly NodeClassReferenceInput[];
+    readonly incoming: EdgeCount;
+    /** What deleting a Node at this endpoint does to the Edge; derived when omitted. */
+    readonly onDelete?: EdgeLifetime;
+}
+/** One endpoint of an undirected Edge Class. */
+export interface IncidentEndpointInput {
+    readonly as: string;
+    readonly accepts: readonly NodeClassReferenceInput[];
+    readonly incident: EdgeCount;
+    /** What deleting a Node at this endpoint does to the Edge; derived when omitted. */
+    readonly onDelete?: EdgeLifetime;
+}
+/** One observation slot: a local Policy, or its constant value. Absent means `true`. */
+export type ClassPolicyInput = Lazy<Policy> | boolean;
+/** Local observation Policies of a Class. */
+export interface ClassPoliciesInput {
+    readonly read?: ClassPolicyInput;
+    readonly traverse?: ClassPolicyInput;
+}
+/**
+ * Policy checks deciding one Node Class observation. `self` is the observed Node; `ref` names one
+ * exact member, the same Node for every observed candidate.
+ */
+export interface ClassRuleContext extends PolicyCheckContext<ClassRuleObject> {
+}
+export type ClassRuleBuilder = (context: ClassRuleContext) => ClassRuleChecks;
+/** One Node Class observation slot: a local Policy, a constant value, or Policy checks. */
+export type NodeClassPolicyInput = ClassPolicyInput | ClassRuleBuilder;
+/** Local observation Policies of a Node Class. */
+export interface NodeClassPoliciesInput {
+    readonly read?: NodeClassPolicyInput;
+    readonly traverse?: NodeClassPolicyInput;
+}
+/** Authored Node Class. */
+export interface NodeClassInput {
+    readonly abstract?: boolean;
+    /** Which Classes may extend this one; omitted, those of its own Domain only (`'internal'`). */
+    readonly inheritance?: Inheritance;
+    readonly description?: string;
+    readonly extends?: readonly NodeClassReferenceInput[];
+    readonly properties?: PropertyRecordInput;
+    readonly data?: MediaType;
+    readonly methods?: Readonly<Record<string, Method>>;
+    readonly icon?: string;
+    /** Local observation Policies; inherited by no descendant and forbidden on abstract Classes. */
+    readonly policies?: NodeClassPoliciesInput;
+    /**
+     * The tuples no two Nodes of this Class and of its active concrete descendants share while every
+     * Property is present; omitted, none. A descendant is covered without declaring them again.
+     */
+    readonly unique?: readonly NodeUniqueTupleInput[];
+}
+/**
+ * The distinct Properties of one Node key, in any order, each a Property of the Class, own or
+ * inherited, by its name or, when names collide, by its full key.
+ */
+export type NodeUniqueTupleInput = readonly [string, ...string[]];
+/** Members every authored Edge Class shares. */
+export interface EdgeClassOptions {
+    readonly abstract?: boolean;
+    /** Which Classes may extend this one; omitted, those of its own Domain only (`'internal'`). */
+    readonly inheritance?: Inheritance;
+    readonly description?: string;
+    readonly extends?: readonly EdgeClassReferenceInput[];
+    readonly properties?: PropertyRecordInput;
+    /** Local observation Policies; inherited by no descendant and forbidden on abstract Classes. */
+    readonly policies?: ClassPoliciesInput;
+    readonly constraints?: {
+        readonly noSelf?: true;
+        readonly acyclic?: true;
+    };
+}
+/**
+ * A key field as authored: an endpoint, the slug, or a Property of the Class, own or inherited, by
+ * its name or, when names collide, by its full key.
+ */
+export type EdgeUniqueFieldInput = 'source' | 'target' | 'slug' | {
+    readonly property: string;
+};
+/** The distinct fields of one key, in any order. */
+export type EdgeUniqueTupleInput = readonly [EdgeUniqueFieldInput, ...EdgeUniqueFieldInput[]];
+/** Authored directed Edge Class. */
+export interface DirectedEdgeInput extends EdgeClassOptions {
+    readonly orientation: 'directed';
+    readonly source: DirectedSourceInput;
+    readonly target: DirectedTargetInput;
+    /**
+     * The tuples no two Edges of this Class and of its active concrete descendants share while every
+     * field is present; omitted, none. A descendant is covered without declaring them again.
+     */
+    readonly unique?: readonly EdgeUniqueTupleInput[];
+}
+/** Authored undirected Edge Class. */
+export interface UndirectedEdgeInput extends Omit<EdgeClassOptions, 'constraints'> {
+    readonly orientation: 'undirected';
+    readonly endpoints: readonly [IncidentEndpointInput, IncidentEndpointInput];
+    readonly constraints?: {
+        readonly noSelf?: true;
+    };
+}
+export type EdgeClassCommon = EdgeClassOptions;
+export type EdgeClassInput = DirectedEdgeInput | UndirectedEdgeInput;