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

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

@@ -0,0 +1,129 @@
+import type { ResolvedMethod } from '../../language/callable/resolved.js';
+import type { ResolvedProperty } from '../../language/class/resolved.js';
+import type { StateTopology } from '../../language/state/topology.js';
+import type { Method } from '../callable/authoring.js';
+import type { DirectedEdgeClass, NodeClass, UndirectedEdgeClass } from './handle.js';
+/** Compact type of one authored Property: values, requiredness, name, owner and state. */
+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;
+}
+/** Compact type of one authored Method with its name and owner. */
+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;
+}
+/** Give `Owner` to every Property projection still owned by `self`. */
+export 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;
+/** Give `Owner` to every Method projection still owned by `self`. */
+export type BindMethodOwners<Entries, Owner> = Entries extends AuthoredMethodProjection<infer Value, infer Name, infer ExistingOwner> ? AuthoredMethodProjection<Value, Name, ExistingOwner extends 'self' ? Owner : ExistingOwner> : Entries;
+/** Kind and structural identity of an authored Class. */
+export interface ClassIdentityProjection<out Kind extends 'node' | 'edge' = 'node' | 'edge', out Identity = unknown> {
+    readonly kind: Kind;
+    readonly identity: Identity;
+}
+/** An authored Class as the owner its Properties and Methods name. */
+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;
+}
+/** An authored Class as a reference, with its effective Properties and Methods. */
+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;
+/** Identity projection of a Class handle. */
+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;
+/** Owner projection of a Class handle. */
+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;
+/** Reference projection of a Class handle. */
+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;
+export {};

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

@@ -0,0 +1 @@
+export {};

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

@@ -1,7 +1,7 @@
 import type { Object as JsonObject } from '@astrale-os/kernel-dsl/value';
 import type { DomainEndpointRef } from '../../language/core/model/core.js';
 import type { PolicyObjectInput } from '../callable/authoring.js';
-import type { EdgeClass, NodeClass } from '../class/authoring.js';
+import type { EdgeClass, NodeClass } from '../class/handle.js';
 import type { AUTHORING } from '../schema/handle.js';
 import type { Lazy } from '../schema/lazy.js';
 import type { CoreNamedPropertyInput } from '../schema/projection.js';

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

@@ -14,7 +14,9 @@ export { BuilderError as Error } from './schema/diagnostic.js';
 export type { BuilderDiagnostic as Diagnostic, BuilderDiagnosticCode as DiagnosticCode, } from './schema/diagnostic.js';
 export type { CallableInputBase, CallableInput, BinaryInputAuthoring, CallableOutputInput, CallableProjection, CallablePolicyBuilder, CallablePolicyContext, PolicyCheckContext, BinaryOutput, Function, FunctionInput, Method, MethodInput, PolicyObjectInput, StreamOutput, } from './callable/authoring.js';
 export type { CoreEdge, CoreEndpoint, CoreInput, CoreNode } from './core/authoring.js';
-export type { AuthoredPropertyProjection, AuthoredMethodProjection, Class, ClassIdentityProjection, ClassOwnerProjection, ClassReferenceProjection, ClassReferenceInput as ClassReference, ClassRuleBuilder, ClassRuleContext, DirectedEdgeInput, DirectedEdgeClass, DirectedSourceInput, DirectedTargetInput, EdgeClassCommon, EdgeClassInput, EdgeClass, EdgeClassReferenceInput as EdgeClassReference, EdgeUniqueFieldInput, EdgeUniqueTupleInput, IncidentEndpointInput, NodeClass, NodeClassInput, NodeClassPoliciesInput, NodeClassPolicyInput, NodeClassReferenceInput as NodeClassReference, NodeUniqueTupleInput, UndirectedEdgeInput, UndirectedEdgeClass, } from './class/authoring.js';
+export type { Class, DirectedEdgeClass, EdgeClass, NodeClass, UndirectedEdgeClass, } from './class/handle.js';
+export type { ClassReferenceInput as ClassReference, ClassRuleBuilder, ClassRuleContext, DirectedEdgeInput, DirectedSourceInput, DirectedTargetInput, EdgeClassCommon, EdgeClassInput, EdgeClassReferenceInput as EdgeClassReference, EdgeUniqueFieldInput, EdgeUniqueTupleInput, IncidentEndpointInput, NodeClassInput, NodeClassPoliciesInput, NodeClassPolicyInput, NodeClassReferenceInput as NodeClassReference, NodeUniqueTupleInput, UndirectedEdgeInput, } from './class/input.js';
+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';

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

@@ -1,5 +1,5 @@
 import type { ClassDefinition } from '../../language/class/model/class.js';
-import type { Class } from '../class/authoring.js';
+import type { Class } from '../class/handle.js';
 import type { CallableCompiler } from './callable.js';
 import type { PolicyCompiler } from './policy.js';
 import type { BuilderContext } from './schema/context.js';

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

@@ -6,7 +6,8 @@ import type { PolicyObjectRef } from '../../../language/index.js';
 import type { ValueSchemaRegistry } from '../../../language/value/reference/registry.js';
 import type { DomainSchema, DomainSchemaIR } from '../../../schema/model/schema.js';
 import type { Function, PolicyObjectInput } from '../../callable/authoring.js';
-import type { Class, ClassReferenceInput } from '../../class/authoring.js';
+import type { Class } from '../../class/handle.js';
+import type { ClassReferenceInput } from '../../class/input.js';
 import type { CoreEndpoint, CoreNode } from '../../core/authoring.js';
 import type { Policy } from '../../policy/authoring.js';
 import type { View } from '../../view/authoring.js';

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

@@ -4,6 +4,7 @@ import { isMethodExecutable } from '../../../language/callable/executable.js';
 import { admitsForeignSubclass, inheritanceOf } from '../../../language/class/inheritance.js';
 import { policyObjectKey, policyObjectOrigin } from '../../../language/index.js';
 import { graphNodePathSchema } from '../../../language/value/syntax/node-path/schema.js';
+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';
@@ -23,7 +24,7 @@ export class BuilderContext {
     constructor(origin, dependencies) {
         this.origin = origin;
         for (const [alias, schema] of Object.entries(dependencies)) {
-            const pointer = `/dependencies/${escapePointer(alias)}`;
+            const pointer = `/dependencies/${escapePointerToken(alias)}`;
             if (!DEPENDENCY_ALIAS_PATTERN.test(alias)) {
                 fail('BUILDER_DEPENDENCY_ALIAS', pointer, `Dependency alias ${JSON.stringify(alias)} must be an ASCII lower-camel identifier.`);
             }
@@ -223,9 +224,6 @@ export class BuilderContext {
         this.policyObjectRefs.add(policyObjectKey(ref));
     }
 }
-function escapePointer(value) {
-    return value.replaceAll('~', '~0').replaceAll('/', '~1');
-}
 function isResolvedClass(value) {
     if (typeof value !== 'object' || value === null)
         return false;

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

@@ -1,3 +1,3 @@
-import type { NodeClassReferenceInput } from '../../class/authoring.js';
+import type { NodeClassReferenceInput } from '../../class/input.js';
 import type { ZodValueSchemaOverrideContext } from './zod.js';
 export declare function lowerPathSchema(context: ZodValueSchemaOverrideContext, resolveAccepts: (inputs: readonly NodeClassReferenceInput[], pointer: string) => readonly unknown[], pointer: string): void;

package/dist/v1/builder/lowering/value/path.js

@@ -1,9 +1,10 @@
+import { escapePointerToken } from '../../../language/value/syntax/pointer.js';
 import { pathAccepts } from '../../value/path-metadata.js';
 export function lowerPathSchema(context, resolveAccepts, pointer) {
     const inputs = pathAccepts(context.zodSchema);
     if (inputs === undefined)
         return;
-    const location = context.path.reduce((current, segment) => `${current}/${escapeToken(String(segment))}`, pointer);
+    const location = context.path.reduce((current, segment) => `${current}/${escapePointerToken(String(segment))}`, pointer);
     for (const key of Object.keys(context.jsonSchema))
         delete context.jsonSchema[key];
     Object.assign(context.jsonSchema, {
@@ -15,6 +16,3 @@ export function lowerPathSchema(context, resolveAccepts, pointer) {
         },
     });
 }
-function escapeToken(value) {
-    return value.replaceAll('~', '~0').replaceAll('/', '~1');
-}

package/dist/v1/builder/lowering/value/zod.js

@@ -4,6 +4,7 @@ import { canonicalizeValueSchema } from '../../../language/value/profile/canonic
 import { validateValueSchema } from '../../../language/value/profile/validate.js';
 import { isIRegexp } from '../../../language/value/regexp/syntax.js';
 import { fullMatchSource } from '../../../language/value/syntax/full-match.js';
+import { escapePointerToken } from '../../../language/value/syntax/pointer.js';
 import { diagnostic } from '../../schema/diagnostic.js';
 /**
  * Converts only Zod contracts whose JSON-value acceptance is represented
@@ -289,9 +290,6 @@ function getCheckDefinition(value) {
 function isZodType(value) {
     return value instanceof ZodType;
 }
-function escapePointerToken(value) {
-    return value.replaceAll('~', '~0').replaceAll('/', '~1');
-}
 function isPlainRecord(value) {
     return value !== null && typeof value === 'object' && !Array.isArray(value);
 }

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

@@ -1,7 +1,7 @@
 import type { ClassRef } from '../../addressing/index.js';
 import type { PolicyCheckExpression, PolicyPatternExpression, PolicyPatternTerm as CanonicalPolicyPatternTerm, PolicyObjectRef } from '../../language/policy/model/policy.js';
 import type { PolicyObjectInput } from '../callable/authoring.js';
-import type { EdgeClassReferenceInput, NodeClassReferenceInput } from '../class/authoring.js';
+import type { EdgeClassReferenceInput, NodeClassReferenceInput } from '../class/input.js';
 import type { AuthoringValue } from '../schema/handle.js';
 import type { Lazy } from '../schema/lazy.js';
 export interface PolicyEdgeInput {

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,4 +1,6 @@
 import type { DiagnosticCode as LanguageDiagnosticCode } from '../../language/validation/diagnostic.js';
+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;
@@ -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/class.d.ts

@@ -1,5 +1,6 @@
 import type * as language from '../../../language/index.js';
-import type { NodeClass, DirectedEdgeClass, UndirectedEdgeClass, ClassReferenceProjection, Class, ProjectionOfClass } from '../../class/authoring.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';

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/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.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;

package/dist/v1/bundle/codec.js

@@ -1,6 +1,7 @@
 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 { escapePointerToken } from '../language/value/syntax/pointer.js';
 import { acceptDomainSchema } from '../schema/admission/accept.js';
 import { canonicalDomainSchemaAfterValidation } from '../schema/canonical/revision.js';
 import { revisionOfDomainSchema } from '../schema/canonical/revision.js';
@@ -9,9 +10,6 @@ import { SchemaError } from '../schema/diagnostic.js';
 import { BundleError, diagnostic } from './diagnostic.js';
 import { asDomainSchemaBundle, } from './model.js';
 import { parseDomainSchemaBundleStructure } from './structure.js';
-function escapeToken(value) {
-    return value.replaceAll('~', '~0').replaceAll('/', '~1');
-}
 export function acceptDomainSchemaBundle(input) {
     let admitted;
     try {
@@ -136,7 +134,7 @@ function collectReachable(current, root, candidates, reachable, active, revision
         return;
     }
     for (const [alias, dependency] of Object.entries(current.schema.dependencies)) {
-        const pointer = `${current.pointer}/dependencies/${escapeToken(alias)}`;
+        const pointer = `${current.pointer}/dependencies/${escapePointerToken(alias)}`;
         const dependencyKey = keyOf(dependency.origin, dependency.revision);
         if (dependencyKey === root.key) {
             diagnostics.push(diagnostic('BUNDLE_CLOSURE_CYCLE', pointer, 'Bundle dependency closure returns to its root.'));

package/dist/v1/bundle/diagnostic.js

@@ -1,16 +1,12 @@
-import { compareUnicode } from '../addressing/ordering.js';
+import { formatDiagnostics, orderDiagnostics } from '../language/validation/diagnostic.js';
 export function diagnostic(code, pointer, message, ref) {
     return Object.freeze({ code, pointer, message, ...(ref === undefined ? {} : { ref }) });
 }
 export class BundleError 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 = 'BundleError';
         this.diagnostics = Object.freeze(ordered);
     }

package/dist/v1/bundle/structure.js

@@ -1,3 +1,4 @@
+import { escapePointerToken } from '../language/value/syntax/pointer.js';
 import { SchemaError } from '../schema/diagnostic.js';
 import { routeDomainSchema } from '../schema/validation/domain.route.js';
 import { BundleError, diagnostic } from './diagnostic.js';
@@ -12,7 +13,7 @@ export function parseDomainSchemaBundleStructure(input) {
     const expected = new Set(['format', 'version', 'root', 'closure']);
     for (const key of Object.keys(input)) {
         if (!expected.has(key)) {
-            diagnostics.push(diagnostic('BUNDLE_STRUCTURE', `/${escapeToken(key)}`, `Unknown bundle field ${key}.`));
+            diagnostics.push(diagnostic('BUNDLE_STRUCTURE', `/${escapePointerToken(key)}`, `Unknown bundle field ${key}.`));
         }
     }
     for (const key of expected) {
@@ -66,6 +67,3 @@ function isObject(value) {
 function describe(value) {
     return value === undefined ? '(missing)' : JSON.stringify(value);
 }
-function escapeToken(value) {
-    return value.replaceAll('~', '~0').replaceAll('/', '~1');
-}

package/dist/v1/compiled/admission/diagnostic.d.ts

@@ -1,6 +1,6 @@
 import { type CompiledDiagnosticCode } from '../diagnostic.js';
 /** Append one escaped JSON Pointer segment. */
-export declare function pointer(parent: string, member: string | number): string;
+export { appendPointer as pointer } from '../../language/value/syntax/pointer.js';
 /** Report a structural compiled-input violation with its stable diagnostic code. */
 export declare function invalid(label: string, code?: CompiledDiagnosticCode, path?: string): never;
 /** Report a contextual compiled-language violation at its original source pointer. */

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

@@ -1,8 +1,6 @@
 import { invalidCompiled } from '../diagnostic.js';
 /** Append one escaped JSON Pointer segment. */
-export function pointer(parent, member) {
-    return `${parent}/${String(member).replaceAll('~', '~0').replaceAll('/', '~1')}`;
-}
+export { appendPointer as pointer } from '../../language/value/syntax/pointer.js';
 /** Report a structural compiled-input violation with its stable diagnostic code. */
 export function invalid(label, code = 'COMPILED_STRUCTURE_INVALID', path = '') {
     return invalidCompiled(code, `Invalid compiled Schema ${label}.`, path);

package/dist/v1/compiled/admission/revision.d.ts

@@ -1,4 +1,12 @@
 import type { Revision } from '../../addressing/index.js';
-import type { CompiledSchemaEntry } from '../model/schema.js';
+import type { FunctionDefinition, MethodDefinition } from '../../language/callable/model/callable.js';
+import type { JsonSchema } from '../../language/value/model/schema.js';
+import type { CompiledFunction, CompiledMethod, CompiledSchemaEntry } from '../model/schema.js';
 /** Derive the exact canonical source-revision preimage without constructing an authored Schema. */
 export declare function revisionOfCompiledEntry(entry: CompiledSchemaEntry): Revision;
+/** The source definition of a compiled Method: its value programs back to their schemas. */
+export declare function sourceMethod(entry: CompiledSchemaEntry, method: CompiledMethod): MethodDefinition;
+/** The source definition of a compiled Function: its value programs back to their schemas. */
+export declare function sourceFunction(entry: CompiledSchemaEntry, definition: CompiledFunction): FunctionDefinition;
+/** The schema of the root node of the entry's value program `index`. */
+export declare function schemaOf(entry: CompiledSchemaEntry, index: number): JsonSchema;

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

@@ -44,7 +44,8 @@ function sourceClass(entry, definition) {
         methods: Object.fromEntries(methods.map((method) => [method.name, sourceMethod(entry, method)])),
     };
 }
-function sourceMethod(entry, method) {
+/** The source definition of a compiled Method: its value programs back to their schemas. */
+export function sourceMethod(entry, method) {
     const { name: _, input, fields: __, output, ...rest } = method;
     return {
         ...rest,
@@ -52,7 +53,8 @@ function sourceMethod(entry, method) {
         output: sourceOutput(entry, output),
     };
 }
-function sourceFunction(entry, definition) {
+/** The source definition of a compiled Function: its value programs back to their schemas. */
+export function sourceFunction(entry, definition) {
     const { input, fields: _, output, ...rest } = definition;
     return {
         ...rest,
@@ -72,7 +74,8 @@ function sourceOutput(entry, output) {
     const schema = schemaOf(entry, output.value);
     return output.mode === 'value' ? { mode: 'value', schema } : { mode: 'stream', item: schema };
 }
-function schemaOf(entry, index) {
+/** The schema of the root node of the entry's value program `index`. */
+export function schemaOf(entry, index) {
     const program = entry.values[index];
     const root = program?.nodes[program.root];
     if (root === undefined)

package/dist/v1/compiled/admission/semantics/class.d.ts

@@ -1,5 +1,8 @@
 import { type Located, type CompiledClass, type ClassAnalysis, type SemanticIndex } from './context.js';
-/** Compose inherited Properties, Methods and Data ownership once per Class. */
+/**
+ * Compose inherited Properties, Methods and Data ownership once per Class. The closure check has
+ * already proved every parent present and the inheritance graph acyclic.
+ */
 export declare function analyzeClasses(classes: ReadonlyMap<string, Located<CompiledClass>>): ReadonlyMap<string, ClassAnalysis>;
 /** Check automatic Properties, immutability and abstract Class obligations. */
 export declare function validateClassFacets(context: SemanticIndex): void;

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

@@ -7,22 +7,19 @@ import { bindValueProgram } from '../../../language/value/compile/load.js';
 import {} from '../../model/schema.js';
 import { fail } from '../diagnostic.js';
 import {} from './context.js';
-/** Compose inherited Properties, Methods and Data ownership once per Class. */
+/**
+ * Compose inherited Properties, Methods and Data ownership once per Class. The closure check has
+ * already proved every parent present and the inheritance graph acyclic.
+ */
 export function analyzeClasses(classes) {
     const analyses = new Map();
-    const visiting = new Set();
     const analyze = (located) => {
         const classKey = Key.of(located.value.ref);
         const cached = analyses.get(classKey);
         if (cached !== undefined)
             return cached;
-        if (visiting.has(classKey))
-            fail(`${located.pointer}/extends`, 'Class inheritance is cyclic.');
-        visiting.add(classKey);
         const parents = located.value.extends.map((ref, index) => {
             const parent = classes.get(Key.of(ref));
-            if (parent === undefined)
-                fail(`${located.pointer}/extends/${index}`, 'Parent Class is absent.');
             if (parent.value.inheritance === 'final')
                 fail(`${located.pointer}/extends/${index}`, 'A final Class has no subclass.');
             return analyze(parent);
@@ -71,7 +68,6 @@ export function analyzeClasses(classes) {
             ...(dataOwner === undefined ? {} : { dataOwner }),
         };
         analyses.set(classKey, analysis);
-        visiting.delete(classKey);
         return analysis;
     };
     for (const value of classes.values())

package/dist/v1/compiled/admission/semantics/core.d.ts

@@ -1,7 +1,5 @@
-import { type ClassRef } from '../../../addressing/index.js';
-import { type CoreEdge } from '../../../language/core/model/core.js';
 import { type CompiledSchemaEntry, type CompiledSchema } from '../../model/schema.js';
-import { type Located, type CompiledClass, type ClassAnalysis, type CompiledEdge, type SemanticIndex } from './context.js';
+import { type Located, type CompiledClass, type ClassAnalysis, type SemanticIndex } from './context.js';
 /** A local Core Node paired with its admitted Class analysis. */
 export interface CoreNode {
     readonly key: string;
@@ -10,26 +8,5 @@ export interface CoreNode {
     readonly analysis: ClassAnalysis;
     readonly pointer: string;
 }
-/**
- * A local Definition other than a Core Node, or a Class-owned Method. The Domain projects it as a
- * Kernel declaration Node, so `class` names that Kernel Class rather than an authored one.
- */
-interface CoreMemberEndpoint {
-    readonly key: string;
-    readonly class: ClassRef;
-    readonly pointer: string;
-}
-type CoreEndpoint = CoreNode | CoreMemberEndpoint | {
-    readonly key: 'domain';
-};
-/** A Core Edge paired with resolved endpoints and its exact Class. */
-export interface CoreEdgeValue {
-    readonly source: CoreEndpoint;
-    readonly target: CoreEndpoint;
-    readonly value: CoreEdge;
-    readonly class: Located<CompiledEdge>;
-    readonly pointer: string;
-}
 /** Admit local Core Nodes, Properties and Edge endpoint contracts. */
 export declare function validateCore(candidate: CompiledSchema, context: SemanticIndex): void;
-export {};