@astrale-os/kernel-dsl 0.2.0-beta.1 → 0.2.0-beta.11

package/dist/v1/builder/{policy.js → policy/authoring.js}

@@ -1,20 +1,30 @@
-import { authoringValue, isAuthoringValue } from './internal/authoring.js';
-import { assertKnownKeys, fail } from './internal/diagnostic.js';
-export function definePolicy(input) {
+import { assertKnownKeys, fail } from '../schema/diagnostic.js';
+import { authoringValue } from '../schema/handle.js';
+const declarations = new WeakMap();
+const compositions = new WeakSet();
+export function policyDeclaration(value) {
+    const declaration = declarations.get(value);
+    if (declaration === undefined)
+        fail('BUILDER_POLICY', '/', 'Policies are created by policy(...).');
+    return declaration;
+}
+function createPolicy(input) {
     if ('operator' in input) {
-        if (!isAuthoringValue(input, 'policy-composition')) {
+        if (!compositions.has(input)) {
             fail('BUILDER_POLICY_COMPOSITION', '/', 'Policy compositions are created by policy.allOf(...) or policy.anyOf(...).');
         }
     }
     else {
         assertKnownKeys(input, ['description', 'match']);
     }
-    return authoringValue('policy', { input });
+    const value = authoringValue('policy', {});
+    declarations.set(value, input);
+    return value;
 }
-export const policy = Object.freeze({
-    allOf: (...policies) => composition('allOf', policies),
-    anyOf: (...policies) => composition('anyOf', policies),
-});
+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 function createPatternContext(options) {
     let nextVariable = 0;
     const subject = Object.freeze({ kind: 'subject' });
@@ -67,13 +77,14 @@ export function createPatternContext(options) {
 }
 function composition(operator, policies) {
     nonEmpty(policies, `/${operator}`);
-    return authoringValue('policy-composition', {
+    const value = {
         operator,
         policies: [...policies],
-    });
+    };
+    compositions.add(value);
+    return value;
 }
 function nonEmpty(values, pointer) {
     if (values.length === 0)
         fail('BUILDER_POLICY_EMPTY_COMPOSITION', pointer, 'Policy composition must be non-empty.');
 }
-//# sourceMappingURL=policy.js.map

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

@@ -0,0 +1,11 @@
+import type { Domain } from '../../domain/model/domain.js';
+import type { DomainSchema } from '../../schema/model/schema.js';
+import type { DomainSchemaInput } 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> {
+}
+/** Build and semantically accept one immutable V1 DomainSchema. */
+export declare function defineSchema<const Origin extends string, const Input extends DomainSchemaInput>(origin: Origin, input: Input): DefinedSchema<Origin, ResolvedDomainOfInput<Origin, Input>>;
+export type { ResolvedDomainOfInput } from './projection.js';

package/dist/v1/builder/{schema.js → schema/define.js}

@@ -1,6 +1,5 @@
-import { compileSchema } from './compiler/schema.js';
+import { compileSchema } from '../lowering/schema/compile.js';
 /** Build and semantically accept one immutable V1 DomainSchema. */
 export function defineSchema(origin, input) {
     return compileSchema(origin, input);
 }
-//# sourceMappingURL=schema.js.map

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

@@ -0,0 +1,16 @@
+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_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_REFERENCE_CYCLE' | 'BUILDER_REFERENCE_KIND' | 'BUILDER_REFERENCE_MISSING' | '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;
+    readonly message: string;
+    readonly ref?: string;
+}
+export declare function diagnostic<const Code extends BuilderDiagnosticCode>(code: Code, pointer: string, message: string, ref?: string): BuilderDiagnostic<Code>;
+export declare class BuilderError extends Error {
+    readonly diagnostics: readonly BuilderDiagnostic[];
+    constructor(diagnostics: readonly BuilderDiagnostic[]);
+}
+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

@@ -0,0 +1,31 @@
+import { compareUnicode } from '../../addressing/ordering.js';
+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'));
+        this.name = 'BuilderError';
+        this.diagnostics = Object.freeze(ordered);
+    }
+}
+export function assertKnownKeys(value, allowed, pointer = '') {
+    const accepted = new Set(allowed);
+    for (const key of Object.keys(value)) {
+        if (!accepted.has(key)) {
+            fail('BUILDER_UNKNOWN_FIELD', `${pointer}/${escapeToken(key)}`, `Unknown builder field ${key}.`);
+        }
+    }
+}
+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/{internal/authoring.d.ts → schema/handle.d.ts}

@@ -1,8 +1,7 @@
 export declare const AUTHORING: unique symbol;
-export type AuthoringKind = 'definition' | 'function' | 'callable-output' | 'policy' | 'view' | 'core-node' | 'core-edge' | 'property' | 'policy-composition';
+export type AuthoringKind = 'definition' | 'function' | 'method' | 'callable-output' | 'policy' | 'view' | 'core-node' | 'core-edge' | 'property' | 'auto';
 export interface AuthoringValue<Kind extends AuthoringKind> {
     readonly [AUTHORING]: Kind;
 }
 export declare function authoringValue<Kind extends AuthoringKind, Value extends object>(kind: Kind, value: Value): Readonly<Value & AuthoringValue<Kind>>;
 export declare function isAuthoringValue<Kind extends AuthoringKind>(value: unknown, kind: Kind): value is AuthoringValue<Kind> & object;
-//# sourceMappingURL=authoring.d.ts.map

package/dist/v1/builder/{internal/authoring.js → schema/handle.js}

@@ -12,4 +12,3 @@ export function isAuthoringValue(value, kind) {
         value !== null &&
         value[AUTHORING] === kind);
 }
-//# sourceMappingURL=authoring.js.map

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

@@ -0,0 +1,15 @@
+import type { DomainSchema } from '../../schema/model/schema.js';
+import type { Function } from '../callable/authoring.js';
+import type { Class } from '../class/authoring.js';
+import type { CoreInput } from '../core/authoring.js';
+import type { Policy } from '../policy/authoring.js';
+import type { View } from '../view/authoring.js';
+/** Complete authoring input accepted by defineSchema. */
+export interface DomainSchemaInput {
+    readonly dependencies?: Readonly<Record<string, DomainSchema<string>>>;
+    readonly classes?: Readonly<Record<string, Class>>;
+    readonly functions?: Readonly<Record<string, Function>>;
+    readonly policies?: Readonly<Record<string, Policy>>;
+    readonly views?: Readonly<Record<string, View>>;
+    readonly core?: CoreInput;
+}

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

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

package/dist/v1/builder/{internal/authoring.lazy.d.ts → schema/lazy.d.ts}

@@ -1,3 +1,2 @@
 export type Lazy<T> = T | (() => T);
 export declare function resolveLazy<T>(value: Lazy<T>, pointer: string): T;
-//# sourceMappingURL=authoring.lazy.d.ts.map

package/dist/v1/builder/{internal/authoring.lazy.js → schema/lazy.js}

@@ -11,4 +11,3 @@ export function resolveLazy(value, pointer) {
     }
     return current;
 }
-//# sourceMappingURL=authoring.lazy.js.map

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

@@ -0,0 +1,364 @@
+import type { Revision } from '../../addressing/index.js';
+import type * as domain from '../../domain/model/domain.js';
+import type * as language from '../../language/index.js';
+import type { DomainOfSchema, DomainSchema } from '../../schema/model/schema.js';
+import type { CallableProjection, Function, Method } from '../callable/authoring.js';
+import type { AuthoredPropertyProjection, AuthoredMethodProjection, Class, ClassIdentityProjection, ClassIdentityProjectionOf, ClassOwnerProjection, ClassOwnerProjectionOf, ClassReferenceProjection, ClassReferenceProjectionOf, DirectedEdgeClass, NodeClass, ProjectionOfClass, UndirectedEdgeClass } from '../class/authoring.js';
+import type { DomainSchemaInput } from './input.js';
+export interface PropertyProjection<Value = unknown, Required extends boolean = boolean, Name extends string = string, Key extends language.PropertyKey = language.PropertyKey> {
+    readonly value: Value;
+    readonly required: Required;
+    readonly name: Name;
+    readonly key: Key;
+}
+export interface MethodProjection<Input = unknown, Output = unknown, Static extends boolean = boolean, Inheritance extends language.MethodInheritance = language.MethodInheritance, Auth extends language.FunctionAuth = language.FunctionAuth, Name extends string = string, Key extends language.MethodKey = language.MethodKey> {
+    readonly input: Input;
+    readonly output: Output;
+    readonly static: Static;
+    readonly inheritance: Inheritance;
+    readonly auth: Auth;
+    readonly name: Name;
+    readonly key: Key;
+}
+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'>> {
+    readonly input: Input;
+    readonly output: Output;
+    readonly auth: Auth;
+    readonly ref: Ref;
+    readonly key: Key;
+}
+export interface ClassProjection<Kind extends language.ClassKind = language.ClassKind, Definition extends Extract<language.ClassDefinition, {
+    readonly kind: Kind;
+}> = Extract<language.ClassDefinition, {
+    readonly kind: Kind;
+}>, Ref extends language.ClassRef = language.ClassRef, Key extends language.DefinitionKey<string, 'class'> = language.DefinitionKey<string, 'class'>, Parents extends readonly unknown[] = readonly unknown[], Properties extends PropertyProjection = PropertyProjection, InstanceMethods extends MethodProjection = MethodProjection, StaticMethods extends MethodProjection = MethodProjection, SelfProperties extends PropertyProjection = PropertyProjection, SelfInstanceMethods extends MethodProjection = MethodProjection, SelfStaticMethods extends MethodProjection = MethodProjection> {
+    readonly kind: Kind;
+    readonly definition: Definition;
+    readonly ref: Ref;
+    readonly key: Key;
+    readonly parents: Parents;
+    readonly properties: Properties;
+    readonly methods: InstanceMethods;
+    readonly staticMethods: StaticMethods;
+    readonly selfProperties: SelfProperties;
+    readonly selfMethods: SelfInstanceMethods;
+    readonly selfStaticMethods: SelfStaticMethods;
+}
+export interface DomainProjection<Classes extends Readonly<Record<string, unknown>> = Readonly<Record<string, unknown>>, Functions extends Readonly<Record<string, unknown>> = Readonly<Record<string, unknown>>, Policies extends Readonly<Record<string, unknown>> = Readonly<Record<string, unknown>>, Views extends Readonly<Record<string, unknown>> = Readonly<Record<string, unknown>>, CoreNodes extends Readonly<Record<string, unknown>> = Readonly<Record<string, unknown>>, Dependencies extends Readonly<Record<string, unknown>> = Readonly<Record<string, unknown>>> {
+    readonly classes: Classes;
+    readonly functions: Functions;
+    readonly policies: Policies;
+    readonly views: Views;
+    readonly core: CoreNodes;
+    readonly dependencies: Dependencies;
+}
+export type ProjectionOfInput<Origin extends string, Input extends DomainSchemaInput> = DomainProjection<{
+    readonly [Name in keyof ClassesInputOf<Input>]: ClassProjectionOfAuthoring<Origin, Extract<Name, string>, ClassesInputOf<Input>[Name], Input>;
+}, {
+    readonly [Name in keyof FunctionsInputOf<Input>]: FunctionProjectionOfAuthoring<Origin, Extract<Name, string>, FunctionsInputOf<Input>[Name]>;
+}, {
+    readonly [Name in keyof PoliciesInputOf<Input>]: language.ResolvedPolicy & {
+        readonly ref: language.PolicyRef<Extract<Name, string>> & {
+            readonly origin: Origin;
+        };
+        readonly key: language.DefinitionKey<Origin, 'policy', Extract<Name, string>>;
+    };
+}, {
+    readonly [Name in keyof ViewsInputOf<Input>]: language.ResolvedView & {
+        readonly ref: language.ViewRef<Extract<Name, string>> & {
+            readonly origin: Origin;
+        };
+        readonly key: language.DefinitionKey<Origin, 'view', Extract<Name, string>>;
+    };
+}, {
+    readonly [Name in keyof CoreNodesInputOf<Input>]: language.ResolvedCoreDefinition & {
+        readonly ref: language.CoreRef<Extract<Name, string>> & {
+            readonly origin: Origin;
+        };
+        readonly key: language.DefinitionKey<Origin, 'core', Extract<Name, string>>;
+    };
+}, DependencySchemasOf<Input>>;
+export interface DomainOfProjection<Projection extends DomainProjection> extends domain.Domain<{
+    readonly [Name in keyof Projection['classes']]: ResolvedClassOfProjection<Extract<Projection['classes'][Name], ClassProjection>>;
+}, {
+    readonly [Name in keyof Projection['functions']]: ResolvedFunctionOfProjection<Extract<Projection['functions'][Name], FunctionProjection>>;
+}, Extract<Projection['policies'], Readonly<Record<string, language.ResolvedPolicy>>>, Extract<Projection['views'], Readonly<Record<string, language.ResolvedView>>>, Extract<Projection['core'], Readonly<Record<string, language.ResolvedCoreDefinition>>>, Revision> {
+    readonly dependencies: domain.DependencyDomainNamespace<{
+        readonly [Alias in keyof Projection['dependencies']]: Projection['dependencies'][Alias] extends infer Dependency extends DomainSchema ? DomainOfSchema<Dependency> : never;
+    }>;
+}
+export type ResolvedDomainOfInput<Origin extends string, Input extends DomainSchemaInput> = DomainOfProjection<ProjectionOfInput<Origin, Input>>;
+type DependenciesInputOf<Input extends DomainSchemaInput> = RecordField<Input, 'dependencies'>;
+type DependencySchemasOf<Input extends DomainSchemaInput> = {
+    readonly [Alias in keyof DependenciesInputOf<Input>]: DependenciesInputOf<Input>[Alias];
+};
+type EmptyMethodCollection = language.ResolvedMethodCollection<Record<never, never>>;
+type AbstractOf<Config> = Config extends {
+    readonly abstract: infer Abstract extends boolean;
+} ? Abstract : false;
+type ConstraintsOf<Options> = Options extends {
+    readonly constraints?: infer Constraints;
+} ? NonNullable<Constraints> : Record<never, never>;
+type ProjectedClassDefinition<Origin extends string, Name extends string, Value> = Value extends NodeClass<infer Config> ? language.NodeClassDefinition & {
+    readonly ref: language.ClassRef<Name> & {
+        readonly origin: Origin;
+    };
+    readonly kind: 'node';
+    readonly abstract: AbstractOf<Config>;
+} : Value extends DirectedEdgeClass<infer Input> ? Input extends {
+    readonly source: infer Source extends {
+        readonly as: string;
+        readonly outgoing: language.EdgeCount;
+    };
+    readonly target: infer Target extends {
+        readonly as: string;
+        readonly incoming: language.EdgeCount;
+    };
+} ? language.EdgeClassDefinition & {
+    readonly ref: language.ClassRef<Name> & {
+        readonly origin: Origin;
+    };
+    readonly kind: 'edge';
+    readonly abstract: AbstractOf<Input>;
+    readonly orientation: 'directed';
+    readonly endpoints: {
+        readonly source: language.DirectedSourceEndpoint & {
+            readonly role: Source['as'];
+            readonly outgoing: Source['outgoing'];
+        };
+        readonly target: language.DirectedTargetEndpoint & {
+            readonly role: Target['as'];
+            readonly incoming: Target['incoming'];
+        };
+    };
+    readonly constraints: language.DirectedEdgeConstraints & ConstraintsOf<Input>;
+} : never : Value extends UndirectedEdgeClass<infer Input> ? Input extends {
+    readonly endpoints: readonly [
+        infer First extends {
+            readonly as: string;
+            readonly incident: language.EdgeCount;
+        },
+        infer Second extends {
+            readonly as: string;
+            readonly incident: language.EdgeCount;
+        }
+    ];
+} ? language.EdgeClassDefinition & {
+    readonly ref: language.ClassRef<Name> & {
+        readonly origin: Origin;
+    };
+    readonly kind: 'edge';
+    readonly abstract: AbstractOf<Input>;
+    readonly orientation: 'undirected';
+    readonly endpoints: readonly [
+        language.IncidentEndpoint & {
+            readonly role: First['as'];
+            readonly incident: First['incident'];
+        },
+        language.IncidentEndpoint & {
+            readonly role: Second['as'];
+            readonly incident: Second['incident'];
+        }
+    ];
+    readonly constraints: language.UndirectedEdgeConstraints & ConstraintsOf<Input>;
+} : never : never;
+type RecordField<Value, Key extends PropertyKey> = Key extends keyof Value ? NonNullable<Value[Key]> extends Readonly<Record<string, unknown>> ? NonNullable<Value[Key]> : Record<never, never> : Record<never, never>;
+type ClassesInputOf<Input extends DomainSchemaInput> = RecordField<Input, 'classes'>;
+type FunctionsInputOf<Input extends DomainSchemaInput> = RecordField<Input, 'functions'>;
+type PoliciesInputOf<Input extends DomainSchemaInput> = RecordField<Input, 'policies'>;
+type ViewsInputOf<Input extends DomainSchemaInput> = RecordField<Input, 'views'>;
+type CoreInputOf<Input extends DomainSchemaInput> = Input extends {
+    readonly core?: infer CoreValue;
+} ? NonNullable<CoreValue> : Record<never, never>;
+type CoreNodesInputOf<Input extends DomainSchemaInput> = RecordField<CoreInputOf<Input>, 'nodes'>;
+type ResolveLazy<Value, Depth extends readonly unknown[] = []> = Depth['length'] extends 32 ? Value : Value extends () => infer Resolved ? ResolveLazy<Resolved, readonly [...Depth, unknown]> : Value;
+type ClassInputOf<Value> = Value extends NodeClass<infer Input> ? Input : Value extends DirectedEdgeClass<infer Input> ? Input : Value extends UndirectedEdgeClass<infer Input> ? Input : never;
+type ParentInputsOfConfig<Config> = Config extends {
+    readonly extends?: infer Parents extends readonly unknown[];
+} ? Parents : readonly [];
+type ParentClassProjectionOf<Origin extends string, Parent, Root extends DomainSchemaInput, Seen> = ResolveLazy<Parent> extends infer Resolved ? Resolved extends ClassReferenceProjection<infer _Kind, infer _Identity, infer _Properties, infer _InstanceMethods, infer _StaticMethods> ? LocalNameOfReference<Root, Resolved> extends infer Name extends string ? Name extends keyof ClassesInputOf<Root> ? ShallowClassProjectionOfAuthoring<Origin, Name, Extract<ClassesInputOf<Root>[Name], Class>, Root> : never : never : Resolved extends ClassProjection ? Resolved : Resolved extends language.AnyResolvedClass ? ClassProjectionOfResolved<ExactClass<Resolved>> : LocalNameOf<Root, Resolved> extends infer Name extends string ? Resolved extends Seen ? never : ClassProjectionOfAuthoring<Origin, Name, Resolved, Root, Seen | Resolved> : never : never;
+type ParentClassProjectionTuple<Origin extends string, Parents extends readonly unknown[], Root extends DomainSchemaInput, Seen> = Parents extends readonly [] ? readonly [] : Parents extends readonly [infer Parent, ...infer Rest] ? readonly [
+    ParentClassProjectionOf<Origin, Parent, Root, Seen>,
+    ...ParentClassProjectionTuple<Origin, Rest, Root, Seen>
+] : readonly ParentClassProjectionOf<Origin, Parents[number], Root, Seen>[];
+type Same<Left, Right> = [Left] extends [Right] ? ([Right] extends [Left] ? true : false) : false;
+type LocalNameOf<Root extends DomainSchemaInput, Value> = {
+    [Name in keyof ClassesInputOf<Root>]: Same<ClassesInputOf<Root>[Name], Value> extends true ? Name : never;
+}[keyof ClassesInputOf<Root>];
+type LocalNameOfReference<Root extends DomainSchemaInput, Value> = {
+    [Name in keyof ClassesInputOf<Root>]: Value extends ClassReferenceProjection<'node' | 'edge', unknown, unknown, unknown, unknown> ? Same<ClassReferenceProjectionOf<Extract<ClassesInputOf<Root>[Name], Class>>, Value> extends true ? Name : never : never;
+}[keyof ClassesInputOf<Root>];
+type LocalNameOfIdentity<Root extends DomainSchemaInput, Value> = {
+    [Name in keyof ClassesInputOf<Root>]: Same<ClassIdentityProjectionOf<Extract<ClassesInputOf<Root>[Name], Class>>, Value> extends true ? Name : never;
+}[keyof ClassesInputOf<Root>];
+type LocalNameOfOwner<Root extends DomainSchemaInput, Value> = {
+    [Name in keyof ClassesInputOf<Root>]: Same<ClassOwnerProjectionOf<Extract<ClassesInputOf<Root>[Name], Class>>, Value> extends true ? Name : never;
+}[keyof ClassesInputOf<Root>];
+type PropertyFieldsOf<Value> = RecordField<ClassInputOf<Value>, 'properties'>;
+interface AuthoredPropertyEntry<Owner, Name extends string, Field> {
+    readonly owner: Owner;
+    readonly name: Name;
+    readonly field: Field;
+}
+type OwnPropertyEntries<Value> = {
+    [Name in keyof PropertyFieldsOf<Value>]: AuthoredPropertyEntry<Value, Extract<Name, string>, PropertyFieldsOf<Value>[Name]>;
+}[keyof PropertyFieldsOf<Value>];
+export type CoreNamedPropertyInput<ClassValue> = ResolveLazy<ClassValue> extends infer Resolved ? Resolved extends Class ? CorePropertyInputFromAuthoredProjections<EffectivePropertyProjectionsOfClass<Resolved>> : Resolved extends language.ResolvedClass ? language.PropertyInputOf<Resolved> : never : never;
+export type CorePropertyInput<ClassValue> = CoreNamedPropertyInput<ClassValue> | Readonly<Record<language.PropertyKey, language.PropertyValue>>;
+type EffectivePropertyProjectionsOfClass<Value extends Class> = ClassInputOf<Value> extends {
+    readonly effectiveProperties: infer Properties;
+} ? Properties : never;
+type AuthoredProjectionName<Entry> = Entry extends AuthoredPropertyProjection<unknown, unknown, boolean, infer Name> ? Name : never;
+type AuthoredProjectionInput<Entry> = Entry extends AuthoredPropertyProjection<infer Input, unknown, boolean, string> ? Input : never;
+type AuthoredProjectionRequired<Entry> = Entry extends AuthoredPropertyProjection<unknown, unknown, infer Required, string> ? Required : false;
+type UniqueAuthoredProjections<Entries> = Entries extends unknown ? IsMultiple<Extract<Entries, {
+    readonly name: AuthoredProjectionName<Entries>;
+}>> extends true ? never : Entries : never;
+type RequiredAuthoredPropertyNames<Entries> = UniqueAuthoredProjections<Entries> extends infer Entry ? Entry extends unknown ? AuthoredProjectionRequired<Entry> extends true ? AuthoredProjectionName<Entry> : never : never : never;
+type OptionalAuthoredPropertyNames<Entries> = Exclude<AuthoredProjectionName<UniqueAuthoredProjections<Entries>>, RequiredAuthoredPropertyNames<Entries>>;
+type CorePropertyInputFromAuthoredProjections<Entries> = Readonly<{
+    [Name in RequiredAuthoredPropertyNames<Entries>]: AuthoredProjectionInput<Extract<UniqueAuthoredProjections<Entries>, {
+        readonly name: Name;
+    }>>;
+} & {
+    [Name in OptionalAuthoredPropertyNames<Entries>]?: AuthoredProjectionInput<Extract<UniqueAuthoredProjections<Entries>, {
+        readonly name: Name;
+    }>>;
+}>;
+type UnionIsMultiple<Value, Whole = Value> = Value extends unknown ? [Whole] extends [Value] ? false : true : never;
+type IsMultiple<Value> = true extends UnionIsMultiple<Value> ? true : false;
+type PropertyCollectionOperation = 'byKey' | 'get' | 'from';
+type MethodFieldsOf<Value> = RecordField<ClassInputOf<Value>, 'methods'>;
+interface AuthoredMethodEntry<Owner, Name extends string, Value extends Method> {
+    readonly owner: Owner;
+    readonly name: Name;
+    readonly value: Value;
+}
+type OwnMethodEntries<Value, Static extends boolean> = {
+    [Name in keyof MethodFieldsOf<Value>]: MethodFieldsOf<Value>[Name] extends infer MethodValue extends Method ? CallableConfig<MethodValue> extends {
+        readonly static: true;
+    } ? Static extends true ? AuthoredMethodEntry<Value, Extract<Name, string>, MethodValue> : never : Static extends false ? AuthoredMethodEntry<Value, Extract<Name, string>, MethodValue> : never : never;
+}[keyof MethodFieldsOf<Value>];
+type CallableConfig<Value> = Value extends Method<infer Config> ? Config extends CallableProjection ? Config : never : Value extends Function<infer Config> ? Config extends CallableProjection ? Config : never : never;
+type CallableInputValue<Value extends Method | Function> = CallableConfig<Value>['input'];
+type CallableOutputValue<Value extends Method | Function> = CallableConfig<Value>['output'];
+type CallableStaticOf<Value extends Method> = CallableConfig<Value> extends {
+    readonly static: true;
+} ? true : false;
+type CallableInheritanceOf<Value extends Method> = CallableConfig<Value> extends {
+    readonly inheritance: infer Inheritance extends language.MethodInheritance;
+} ? Inheritance : 'default';
+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<unknown, infer Name, infer Value> ? MethodProjection<CallableInputValue<Value>, CallableOutputValue<Value>, CallableStaticOf<Value>, CallableInheritanceOf<Value>, CallableAuthOf<Value>, Name, language.MethodKey<Origin, OwnerName, Name>> : never;
+type MethodProjectionOfEntries<Origin extends string, OwnerName extends string, Entries> = Entries extends unknown ? MethodProjectionOfEntry<Origin, OwnerName, Entries> : never;
+type MethodCollectionOperation = 'byKey' | 'get';
+type PropertyProjectionOfResolved<Value> = Value extends language.ResolvedProperty<infer PropertyValue, infer Required> & {
+    readonly name: infer Name extends string;
+    readonly key: infer Key extends language.PropertyKey;
+} ? PropertyProjection<PropertyValue, Required, Name, Key> : never;
+type MethodProjectionOfResolved<Value> = Value extends language.ResolvedMethod<infer Input, infer Output, infer Static, infer Inheritance, infer Auth, infer _Policy, infer Key> & {
+    readonly name: infer Name extends string;
+} ? MethodProjection<Input, Output, Static, Inheritance, Auth, Name, Key> : never;
+type PropertiesOfCollection<Value> = Value extends {
+    readonly byKey: infer ByKey extends Readonly<Record<language.PropertyKey, language.ResolvedProperty<unknown, boolean>>>;
+} ? PropertyProjectionOfResolved<ByKey[keyof ByKey]> : never;
+type MethodsOfCollection<Value> = Value extends {
+    readonly byKey: infer ByKey extends Readonly<Record<language.MethodKey, language.ResolvedMethod>>;
+} ? MethodProjectionOfResolved<ByKey[keyof ByKey]> : never;
+export type ClassProjectionOfResolved<Value> = Value extends language.AnyResolvedClass & {
+    readonly ref: infer Ref extends language.ClassRef;
+    readonly key: infer Key extends language.DefinitionKey<string, 'class'>;
+} ? ClassProjection<Value['kind'], Extract<Value['definition'], Extract<language.ClassDefinition, {
+    readonly kind: Value['kind'];
+}>>, Ref, Key, ShallowClassProjectionTupleOfResolved<Value['extends']>, PropertiesOfCollection<Value['properties']>, MethodsOfCollection<Value['methods']>, MethodsOfCollection<Value['static']['methods']>, PropertiesOfCollection<Value['self']['properties']>, MethodsOfCollection<Value['self']['methods']>, MethodsOfCollection<Value['self']['static']['methods']>> : never;
+type ShallowClassProjectionOfResolved<Value> = Value extends language.AnyResolvedClass & {
+    readonly ref: infer Ref extends language.ClassRef;
+    readonly key: infer Key extends language.DefinitionKey<string, 'class'>;
+} ? ClassProjection<Value['kind'], Extract<Value['definition'], Extract<language.ClassDefinition, {
+    readonly kind: Value['kind'];
+}>>, Ref, Key, readonly language.AnyResolvedClass[], PropertiesOfCollection<Value['properties']>, MethodsOfCollection<Value['methods']>, MethodsOfCollection<Value['static']['methods']>, PropertiesOfCollection<Value['self']['properties']>, MethodsOfCollection<Value['self']['methods']>, MethodsOfCollection<Value['self']['static']['methods']>> : never;
+type ShallowClassProjectionTupleOfResolved<Parents extends readonly unknown[]> = Parents extends readonly [] ? readonly [] : Parents extends readonly [infer Parent, ...infer Rest] ? readonly [
+    ShallowClassProjectionOfResolved<ExactClass<Parent>>,
+    ...ShallowClassProjectionTupleOfResolved<Rest>
+] : readonly ShallowClassProjectionOfResolved<ExactClass<Parents[number]>>[];
+type ExactClass<Value> = Value extends {
+    readonly key: infer Key extends language.DefinitionKey<string, 'class'>;
+} ? Key extends `${infer Origin}:class.${infer Name}` ? string extends Origin ? never : string extends Name ? never : Value : never : never;
+type OwnPropertyProjectionsOf<Origin extends string, Name extends string, Value> = OwnPropertyEntries<Value> extends infer Entry ? Entry extends AuthoredPropertyEntry<unknown, infer PropertyName, infer Field> ? Field extends AuthoredPropertyProjection<unknown, infer Output, infer Required> ? PropertyProjection<Output, Required, PropertyName, language.PropertyKey<Origin, Name, PropertyName>> : never : never : never;
+type EffectivePropertyEntriesOfClass<Value> = ClassInputOf<Value> extends {
+    readonly effectiveProperties: infer Properties;
+} ? Properties : never;
+type OwnerNameOf<Root extends DomainSchemaInput, CurrentName extends string, Owner> = Owner extends 'self' ? CurrentName : Owner extends ClassOwnerProjection ? Extract<LocalNameOfOwner<Root, Owner>, string> : Owner extends ClassIdentityProjection ? Extract<LocalNameOfIdentity<Root, Owner>, string> : never;
+type EffectivePropertyProjectionOfEntry<Origin extends string, CurrentName extends string, Root extends DomainSchemaInput, Entry> = Entry extends language.ResolvedProperty ? PropertyProjectionOfResolved<Entry> : Entry extends AuthoredPropertyProjection<unknown, infer Output, infer Required, infer PropertyName, infer Owner> ? OwnerNameOf<Root, CurrentName, Owner> extends infer OwnerName extends string ? PropertyProjection<Output, Required, PropertyName, language.PropertyKey<Origin, OwnerName, PropertyName>> : never : never;
+type EffectivePropertyProjectionsOf<Origin extends string, Name extends string, Value, Root extends DomainSchemaInput> = EffectivePropertyEntriesOfClass<Value> extends infer Entry ? Entry extends unknown ? EffectivePropertyProjectionOfEntry<Origin, Name, Root, Entry> : never : never;
+type OwnInstanceMethodProjectionsOf<Origin extends string, Name extends string, Value> = MethodProjectionOfEntries<Origin, Name, OwnMethodEntries<Value, false>>;
+type OwnStaticMethodProjectionsOf<Origin extends string, Name extends string, Value> = MethodProjectionOfEntries<Origin, Name, OwnMethodEntries<Value, true>>;
+type EffectiveMethodEntriesOfClass<Value, Static extends boolean> = ClassInputOf<Value> extends {
+    readonly effectiveInstanceMethods: infer InstanceMethods;
+    readonly effectiveStaticMethods: infer StaticMethods;
+} ? Static extends true ? StaticMethods : InstanceMethods : never;
+type EffectiveMethodProjectionOfEntry<Origin extends string, CurrentName extends string, Root extends DomainSchemaInput, Entry> = Entry extends language.ResolvedMethod ? MethodProjectionOfResolved<Entry> : Entry extends AuthoredMethodProjection<infer Value, infer MethodName, infer Owner> ? OwnerNameOf<Root, CurrentName, Owner> extends infer OwnerName extends string ? MethodProjection<CallableInputValue<Value>, CallableOutputValue<Value>, CallableStaticOf<Value>, CallableInheritanceOf<Value>, CallableAuthOf<Value>, MethodName, language.MethodKey<Origin, OwnerName, MethodName>> : never : never;
+type EffectiveMethodProjectionsOf<Origin extends string, Name extends string, Value, Root extends DomainSchemaInput, Static extends boolean> = EffectiveMethodEntriesOfClass<Value, Static> extends infer Entry ? Entry extends unknown ? EffectiveMethodProjectionOfEntry<Origin, Name, Root, Entry> : never : never;
+type ShallowClassProjectionOfAuthoring<Origin extends string, Name extends string, Value, Root extends DomainSchemaInput> = Value extends NodeClass<infer _Config> ? ClassProjection<'node', Extract<ProjectedClassDefinition<Origin, Name, Value>, language.NodeClassDefinition>, language.ClassRef<Name> & {
+    readonly origin: Origin;
+}, language.DefinitionKey<Origin, 'class', Name>, readonly language.AnyResolvedClass[], EffectivePropertyProjectionsOf<Origin, Name, Value, Root>, EffectiveMethodProjectionsOf<Origin, Name, Value, Root, false>, EffectiveMethodProjectionsOf<Origin, Name, Value, Root, true>, 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> & {
+    readonly origin: Origin;
+}, language.DefinitionKey<Origin, 'class', Name>, readonly language.AnyResolvedClass[], EffectivePropertyProjectionsOf<Origin, Name, Value, Root>, never, never, OwnPropertyProjectionsOf<Origin, Name, Value>, never, never> : never;
+type ClassProjectionOfAuthoring<Origin extends string, Name extends string, Value, Root extends DomainSchemaInput, Seen = Value> = Value extends NodeClass ? ClassProjection<'node', Extract<ProjectedClassDefinition<Origin, Name, Value>, language.NodeClassDefinition>, language.ClassRef<Name> & {
+    readonly origin: Origin;
+}, language.DefinitionKey<Origin, 'class', Name>, ParentClassProjectionTuple<Origin, ParentInputsOfConfig<ProjectionOfClass<Extract<Value, Class>>>, Root, Seen>, EffectivePropertyProjectionsOf<Origin, Name, Value, Root>, EffectiveMethodProjectionsOf<Origin, Name, Value, Root, false>, EffectiveMethodProjectionsOf<Origin, Name, Value, Root, true>, 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> & {
+    readonly origin: Origin;
+}, language.DefinitionKey<Origin, 'class', Name>, ParentClassProjectionTuple<Origin, ParentInputsOfConfig<ProjectionOfClass<Extract<Value, Class>>>, Root, Seen>, EffectivePropertyProjectionsOf<Origin, Name, Value, Root>, never, never, OwnPropertyProjectionsOf<Origin, Name, Value>, never, never> : never;
+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>> : never;
+type ResolvedPropertyOfProjection<Value> = Value extends PropertyProjection<infer PropertyValue, infer Required, infer Name, infer Key> ? language.ResolvedProperty<PropertyValue, Required> & {
+    readonly name: Name;
+    readonly key: Key;
+} : never;
+type ProjectionPropertyByKey<Entries extends PropertyProjection> = Readonly<{
+    [Key in Entries['key']]: ResolvedPropertyOfProjection<Extract<Entries, {
+        readonly key: Key;
+    }>>;
+}>;
+type ProjectionPropertyByName<Entries extends PropertyProjection> = Readonly<{
+    [Name in Entries['name'] as IsMultiple<Extract<Entries, {
+        readonly name: Name;
+    }>> extends true ? never : Name extends PropertyCollectionOperation ? never : Name]: ResolvedPropertyOfProjection<Extract<Entries, {
+        readonly name: Name;
+    }>>;
+}>;
+type PropertyCollectionOfProjection<Entries extends PropertyProjection> = language.ResolvedPropertyCollection<ProjectionPropertyByKey<Entries>, ProjectionPropertyByName<Entries>>;
+type ResolvedMethodOfProjection<Value> = Value extends MethodProjection<infer Input, infer Output, infer Static, infer Inheritance, infer Auth, infer Name, infer Key> ? language.ResolvedMethod<Input, Output, Static, Inheritance, Auth, language.PolicyCheckExpression, Key> & {
+    readonly name: Name;
+} : never;
+type ProjectionMethodByKey<Entries extends MethodProjection> = Readonly<{
+    [Key in Entries['key']]: ResolvedMethodOfProjection<Extract<Entries, {
+        readonly key: Key;
+    }>>;
+}>;
+type ProjectionMethodByName<Entries extends MethodProjection> = Readonly<{
+    [Name in Entries['name'] as Name extends MethodCollectionOperation ? never : Name]: ResolvedMethodOfProjection<Extract<Entries, {
+        readonly name: Name;
+    }>>;
+}>;
+type MethodCollectionOfProjection<Entries extends MethodProjection> = language.ResolvedMethodCollection<ProjectionMethodByKey<Entries>, ProjectionMethodByName<Entries>>;
+type ResolvedParentTupleOfProjection<Parents extends readonly unknown[]> = Parents extends readonly [] ? readonly [] : Parents extends readonly [infer Parent, ...infer Rest] ? readonly [
+    Parent extends ClassProjection ? ResolvedClassOfProjection<Parent> : Extract<Parent, language.AnyResolvedClass>,
+    ...ResolvedParentTupleOfProjection<Rest>
+] : readonly (Parents[number] extends ClassProjection ? ResolvedClassOfProjection<Parents[number]> : Extract<Parents[number], language.AnyResolvedClass>)[];
+export type ResolvedClassOfProjection<Value extends ClassProjection> = Value extends ClassProjection<infer Kind, infer Definition, infer Ref, infer Key, infer Parents, infer Properties, infer InstanceMethods, infer StaticMethods, infer SelfProperties, infer SelfInstanceMethods, infer SelfStaticMethods> ? Key extends `${infer Origin}:class.${infer Name}` ? string extends Origin ? language.AnyResolvedClass : string extends Name ? language.AnyResolvedClass : ResolvedClassWithKind<Kind, Definition, Ref, Key, Parents, SelfProperties, SelfInstanceMethods, SelfStaticMethods, Properties, InstanceMethods, StaticMethods> : language.AnyResolvedClass : language.AnyResolvedClass;
+type ResolvedClassWithKind<Kind extends language.ClassKind, Definition extends Extract<language.ClassDefinition, {
+    readonly kind: Kind;
+}>, Ref extends language.ClassRef, Key extends language.DefinitionKey<string, 'class'>, Parents extends readonly unknown[], SelfProperties extends PropertyProjection, SelfInstanceMethods extends MethodProjection, SelfStaticMethods extends MethodProjection, Properties extends PropertyProjection, InstanceMethods extends MethodProjection, StaticMethods extends MethodProjection> = Kind extends 'node' ? language.ResolvedClass<'node', PropertyCollectionOfProjection<Properties>, MethodCollectionOfProjection<InstanceMethods>, MethodCollectionOfProjection<StaticMethods>, PropertyCollectionOfProjection<SelfProperties>, MethodCollectionOfProjection<SelfInstanceMethods>, MethodCollectionOfProjection<SelfStaticMethods>, Extract<Definition, language.NodeClassDefinition>, ResolvedParentTupleOfProjection<Parents>> & {
+    readonly ref: Ref;
+    readonly key: Key;
+} : Kind extends 'edge' ? language.ResolvedClass<'edge', PropertyCollectionOfProjection<Properties>, EmptyMethodCollection, EmptyMethodCollection, PropertyCollectionOfProjection<SelfProperties>, EmptyMethodCollection, EmptyMethodCollection, Extract<Definition, language.EdgeClassDefinition>, ResolvedParentTupleOfProjection<Parents>> & {
+    readonly ref: Ref;
+    readonly key: Key;
+} : never;
+type ResolvedFunctionOfProjection<Value extends FunctionProjection> = Value extends FunctionProjection<infer Input, infer Output, infer Auth, infer Ref, infer Key> ? language.ResolvedFunction<Input, Output, Auth, language.PolicyCheckExpression> & {
+    readonly ref: Ref;
+    readonly key: Key;
+} : never;
+export {};

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

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

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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,11 @@
+import { isIRegexp } 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) {
+    if (!isIRegexp(source)) {
+        fail('BUILDER_FULL_MATCH_INVALID', '/fullMatch', 'fullMatch(...) requires a complete RFC 9485 I-Regexp source.');
+    }
+    return languageFullMatch(source);
+}

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

@@ -0,0 +1,4 @@
+import type { z } from 'zod';
+import type { NodeClassReferenceInput } from '../class/authoring.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/{internal/path.metadata.js → value/path-metadata.js}

@@ -5,4 +5,3 @@ export function rememberPath(schema, accepts) {
 export function pathAccepts(schema) {
     return pathInputs.get(schema);
 }
-//# sourceMappingURL=path.metadata.js.map

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

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import type { NodeClassReferenceInput } from '../class/authoring.js';
+declare const PATH_ACCEPTS: unique symbol;
+export type PathAuthoring<Accepts extends readonly NodeClassReferenceInput[] = readonly NodeClassReferenceInput[]> = z.ZodString & {
+    readonly [PATH_ACCEPTS]: Accepts;
+};
+export declare function path<const Accepts extends readonly NodeClassReferenceInput[]>(...accepts: Accepts): PathAuthoring<Accepts>;
+export {};

package/dist/v1/builder/{path.js → value/path.js}

@@ -1,6 +1,6 @@
 import { z } from 'zod';
-import { fail } from './internal/diagnostic.js';
-import { rememberPath } from './internal/path.metadata.js';
+import { fail } from '../schema/diagnostic.js';
+import { rememberPath } from './path-metadata.js';
 export function path(...accepts) {
     if (accepts.length === 0) {
         fail('BUILDER_PATH_EMPTY', '', 'path(...) requires at least one Node Definition.');
@@ -9,4 +9,3 @@ export function path(...accepts) {
     rememberPath(schema, accepts);
     return schema;
 }
-//# sourceMappingURL=path.js.map