@astrale-os/kernel-dsl 0.2.0-beta.5 → 0.2.0-beta.7

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,10 @@
+import type { DomainSchema } from '../../schema/model/schema.js';
+import type { DomainSchemaInput } from './input.js';
+import type { DomainOfInput } from './projection.js';
+export type { DomainSchemaInput } from './input.js';
+/** Exact named Schema produced from one authored input. */
+export interface DefinedSchema<Origin extends string, Input extends DomainSchemaInput> extends DomainSchema<Origin, Input, DomainOfInput<Origin, Input>> {
+}
+/** 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, Input>;
+export type { DomainOfInput } 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_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' | 'auto' | '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 DomainSchema<string, unknown>[];
+    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,247 @@
+import type { Value as PortableValue } from '@astrale-os/kernel-dsl/value';
+import type { z } from 'zod';
+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 { Function, Method, StreamOutput, BinaryOutput } from '../callable/authoring.js';
+import type { Class, DirectedEdgeClass, NodeClass, UndirectedEdgeClass } from '../class/authoring.js';
+import type { AutoProperty, Property, PropertyOptions, ValueSchemaInput } from '../class/property.js';
+import type { TypedValueSchema } from '../value/schema.js';
+import type { DomainSchemaInput } from './input.js';
+export type DomainOfInput<Origin extends string, Input extends DomainSchemaInput> = domain.Domain<{
+    readonly [Name in keyof ClassesInputOf<Input>]: ResolvedClassOfAuthoring<Origin, Extract<Name, string>, ClassesInputOf<Input>[Name], Input>;
+}, {
+    readonly [Name in keyof FunctionsInputOf<Input>]: ResolvedFunctionOfAuthoring<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>>;
+    };
+}, Revision>;
+export type ResolvedClassOfAuthoring<Origin extends string, Name extends string, Value, Root extends DomainSchemaInput, Seen = Value> = Value extends NodeClass ? language.ResolvedClass<'node', PropertyCollectionOf<Origin, EffectivePropertyEntries<Value>, Root>, MethodCollectionOf<Origin, EffectiveMethodEntries<Value, false>, Root>, MethodCollectionOf<Origin, EffectiveMethodEntries<Value, true>, Root>, PropertyCollectionOf<Origin, OwnPropertyEntries<Value>, Root>, MethodCollectionOf<Origin, OwnMethodEntries<Value, false>, Root>, MethodCollectionOf<Origin, OwnMethodEntries<Value, true>, Root>, Extract<ProjectedClassDefinition<Origin, Name, Value>, language.NodeClassDefinition>, ResolvedParentsOf<Origin, Value, Root, Seen>> & {
+    readonly ref: language.ClassRef<Name> & {
+        readonly origin: Origin;
+    };
+    readonly key: language.DefinitionKey<Origin, 'class', Name>;
+} : Value extends DirectedEdgeClass | UndirectedEdgeClass ? language.ResolvedClass<'edge', PropertyCollectionOf<Origin, EffectivePropertyEntries<Value>, Root>, EmptyMethodCollection, EmptyMethodCollection, PropertyCollectionOf<Origin, OwnPropertyEntries<Value>, Root>, EmptyMethodCollection, EmptyMethodCollection, Extract<ProjectedClassDefinition<Origin, Name, Value>, language.EdgeClassDefinition>, ResolvedParentsOf<Origin, Value, Root, Seen>> & {
+    readonly ref: language.ClassRef<Name> & {
+        readonly origin: Origin;
+    };
+    readonly key: language.DefinitionKey<Origin, 'class', Name>;
+} : never;
+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> ? 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: Input['source']['as'];
+            readonly outgoing: Input['source']['outgoing'];
+        };
+        readonly target: language.DirectedTargetEndpoint & {
+            readonly role: Input['target']['as'];
+            readonly incoming: Input['target']['incoming'];
+        };
+    };
+    readonly constraints: language.DirectedEdgeConstraints & ConstraintsOf<Input>;
+} : Value extends UndirectedEdgeClass<infer Input> ? 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: Input['endpoints'][0]['as'];
+            readonly incident: Input['endpoints'][0]['incident'];
+        },
+        language.IncidentEndpoint & {
+            readonly role: Input['endpoints'][1]['as'];
+            readonly incident: Input['endpoints'][1]['incident'];
+        }
+    ];
+    readonly constraints: language.UndirectedEdgeConstraints & ConstraintsOf<Input>;
+} : 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 ParentsOf<Value> = ClassInputOf<Value> extends {
+    readonly extends?: readonly (infer Parent)[];
+} ? ResolveLazy<Parent> : never;
+type ParentInputsOf<Value> = ClassInputOf<Value> extends {
+    readonly extends?: infer Parents extends readonly unknown[];
+} ? Parents : readonly [];
+type ResolvedParentOf<Origin extends string, Parent, Root extends DomainSchemaInput, Seen> = ResolveLazy<Parent> extends infer Resolved ? Resolved extends language.ResolvedClass ? Resolved : LocalNameOf<Root, Resolved> extends infer Name extends string ? Resolved extends Seen ? Resolved extends NodeClass ? language.ResolvedClass<'node'> & {
+    readonly key: language.DefinitionKey<Origin, 'class', Name>;
+} : language.ResolvedClass<'edge'> & {
+    readonly key: language.DefinitionKey<Origin, 'class', Name>;
+} : ResolvedClassOfAuthoring<Origin, Name, Resolved, Root, Seen | Resolved> : never : never;
+type ResolvedParentsOf<Origin extends string, Value, Root extends DomainSchemaInput, Seen> = ResolvedParentTuple<Origin, ParentInputsOf<Value>, Root, Seen>;
+type ResolvedParentTuple<Origin extends string, Parents extends readonly unknown[], Root extends DomainSchemaInput, Seen> = Parents extends readonly [] ? readonly [] : Parents extends readonly [infer Parent, ...infer Rest] ? readonly [
+    ResolvedParentOf<Origin, Parent, Root, Seen>,
+    ...ResolvedParentTuple<Origin, Rest, Root, Seen>
+] : readonly ResolvedParentOf<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 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>];
+type ParentPropertyEntries<Parent, Seen> = Parent extends language.ResolvedClass ? language.PropertiesOf<Parent>['byKey'][keyof language.PropertiesOf<Parent>['byKey']] : Parent extends Class ? EffectivePropertyEntries<Parent, Seen> : never;
+type EffectivePropertyEntries<Value, Seen = never> = Value extends Seen ? never : OwnPropertyEntries<Value> | (ParentsOf<Value> extends infer Parent ? Parent extends unknown ? ParentPropertyEntries<Parent, Seen | Value> : never : never);
+type PropertySchemaOf<Field> = Field extends AutoProperty<infer Value> ? PropertySchemaOf<Value> : Field extends Property<infer Schema, PropertyOptions> ? Schema : Field;
+type PropertyOptionsOf<Field> = Field extends AutoProperty<infer Value> ? PropertyOptionsOf<Value> : Field extends Property<ValueSchemaInput, infer Options> ? Options : Record<never, never>;
+type ValueOutputOf<Schema> = Schema extends TypedValueSchema<infer Value> ? Value : Schema extends z.ZodType ? z.output<Schema> : PortableValue;
+type ValueInputOf<Schema> = Schema extends TypedValueSchema<infer Value> ? Value : Schema extends z.ZodType ? z.input<Schema> : PortableValue;
+type PropertyRequiredOf<Field> = PropertyOptionsOf<Field> extends {
+    readonly required: infer Required extends boolean;
+} ? Required : undefined extends ValueInputOf<PropertySchemaOf<Field>> ? false : true;
+export type CorePropertyInput<ClassValue> = ResolveLazy<ClassValue> extends infer Resolved ? Resolved extends Class ? CorePropertyInputFromEntries<EffectivePropertyEntries<Resolved>> : Resolved extends language.ResolvedClass ? language.PropertyInputOf<Resolved> : never : never;
+type PropertyEntryName<Entry> = Entry extends {
+    readonly name: infer Name extends string;
+} ? Name : never;
+type PropertyEntryValue<Entry> = Entry extends language.ResolvedProperty<infer Value, boolean> ? Value : Entry extends AuthoredPropertyEntry<unknown, string, infer Field> ? ValueInputOf<PropertySchemaOf<Field>> : never;
+type PropertyEntryRequired<Entry> = Entry extends language.ResolvedProperty<unknown, infer Required> ? Required : Entry extends AuthoredPropertyEntry<unknown, string, infer Field> ? PropertyRequiredOf<Field> : false;
+type UniquePropertyEntries<Entries> = Entries extends unknown ? IsMultiple<Extract<Entries, {
+    readonly name: PropertyEntryName<Entries>;
+}>> extends true ? never : Entries : never;
+type RequiredPropertyNames<Entries> = UniquePropertyEntries<Entries> extends infer Entry ? Entry extends unknown ? PropertyEntryRequired<Entry> extends true ? PropertyEntryName<Entry> : never : never : never;
+type OptionalPropertyNames<Entries> = Exclude<PropertyEntryName<UniquePropertyEntries<Entries>>, RequiredPropertyNames<Entries>>;
+type CorePropertyInputFromEntries<Entries> = Readonly<({
+    [Name in RequiredPropertyNames<Entries>]: PropertyEntryValue<Extract<UniquePropertyEntries<Entries>, {
+        readonly name: Name;
+    }>>;
+} & {
+    [Name in OptionalPropertyNames<Entries>]?: PropertyEntryValue<Extract<UniquePropertyEntries<Entries>, {
+        readonly name: Name;
+    }>>;
+}) | Record<language.PropertyKey, language.PropertyValue>>;
+type ProjectedProperty<Origin extends string, Entry, Root extends DomainSchemaInput> = Entry extends language.ResolvedProperty ? Entry : Entry extends AuthoredPropertyEntry<infer Owner, infer Name, infer Field> ? LocalNameOf<Root, Owner> extends infer OwnerName extends string ? language.ResolvedProperty<ValueOutputOf<PropertySchemaOf<Field>>, PropertyRequiredOf<Field>> & {
+    readonly name: Name;
+    readonly key: language.PropertyKey<Origin, OwnerName, Name>;
+} : never : never;
+type ProjectedPropertyUnion<Origin extends string, Entries, Root extends DomainSchemaInput> = Entries extends unknown ? ProjectedProperty<Origin, Entries, Root> : never;
+type UnionIsMultiple<Value, Whole = Value> = Value extends unknown ? [Whole] extends [Value] ? false : true : never;
+type IsMultiple<Value> = true extends UnionIsMultiple<Value> ? true : false;
+type PropertyByKey<Origin extends string, Entries, Root extends DomainSchemaInput> = Readonly<{
+    [Key in ProjectedPropertyUnion<Origin, Entries, Root>['key']]: Extract<ProjectedPropertyUnion<Origin, Entries, Root>, {
+        readonly key: Key;
+    }>;
+}>;
+type PropertyByName<Origin extends string, Entries, Root extends DomainSchemaInput> = Readonly<{
+    [Name in ProjectedPropertyUnion<Origin, Entries, Root>['name'] as IsMultiple<Extract<ProjectedPropertyUnion<Origin, Entries, Root>, {
+        readonly name: Name;
+    }>> extends true ? never : Name extends PropertyCollectionOperation ? never : Name]: Extract<ProjectedPropertyUnion<Origin, Entries, Root>, {
+        readonly name: Name;
+    }>;
+}>;
+type PropertyCollectionOperation = 'byKey' | 'get' | 'from';
+type PropertyCollectionOf<Origin extends string, Entries, Root extends DomainSchemaInput> = language.ResolvedPropertyCollection<PropertyByKey<Origin, Entries, Root>, PropertyByName<Origin, Entries, Root>>;
+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 ParentMethodEntries<Parent, Static extends boolean, Seen> = Parent extends language.ResolvedClass<'node'> ? Static extends true ? language.StaticMethodsOf<Parent>['byKey'][keyof language.StaticMethodsOf<Parent>['byKey']] : language.MethodsOf<Parent>['byKey'][keyof language.MethodsOf<Parent>['byKey']] : Parent extends NodeClass ? EffectiveMethodEntries<Parent, Static, Seen> : never;
+type RemoveMethodNames<Entries, Names> = Entries extends {
+    readonly name: infer Name;
+} ? Name extends Names ? never : Entries : never;
+type EffectiveMethodEntries<Value, Static extends boolean, Seen = never> = Value extends Seen ? never : OwnMethodEntries<Value, Static> extends infer Own ? Own | RemoveMethodNames<ParentsOf<Value> extends infer Parent ? Parent extends unknown ? ParentMethodEntries<Parent, Static, Seen | Value> : never : never, Own extends {
+    readonly name: infer Name;
+} ? Name : never> : never;
+type CallableConfig<Value> = Value extends Method<infer Config> ? Config : Value extends Function<infer Config> ? Config : never;
+type CallableInputValue<Value extends Method | Function> = ValueInputOf<CallableConfig<Value>['input']>;
+type CallableOutputValue<Value extends Method | Function> = CallableConfig<Value>['output'] extends StreamOutput<infer Item> ? {
+    readonly mode: 'stream';
+    readonly item: ValueOutputOf<Item>;
+} : CallableConfig<Value>['output'] extends BinaryOutput ? {
+    readonly mode: 'binary';
+} : {
+    readonly mode: 'value';
+    readonly value: ValueOutputOf<CallableConfig<Value>['output']>;
+};
+type ProjectedMethod<Origin extends string, Entry, Root extends DomainSchemaInput> = Entry extends language.ResolvedMethod ? Entry : Entry extends AuthoredMethodEntry<infer Owner, infer Name, infer Value> ? LocalNameOf<Root, Owner> extends infer OwnerName extends string ? language.ResolvedMethod<CallableInputValue<Value>, CallableOutputValue<Value>, CallableStaticOf<Value>, CallableInheritanceOf<Value>, CallableAuthOf<Value>, CallablePolicyOf<Value>, language.MethodKey<Origin, OwnerName, Name>> & {
+    readonly name: Name;
+} : never : never;
+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 CallablePolicyOf<Value extends Method | Function> = CallableAuthOf<Value> extends 'authorized' ? language.PolicyCheckExpression : never;
+type ProjectedMethodUnion<Origin extends string, Entries, Root extends DomainSchemaInput> = Entries extends unknown ? ProjectedMethod<Origin, Entries, Root> : never;
+type MethodByKey<Origin extends string, Entries, Root extends DomainSchemaInput> = Readonly<{
+    [Key in ProjectedMethodUnion<Origin, Entries, Root>['key']]: Extract<ProjectedMethodUnion<Origin, Entries, Root>, {
+        readonly key: Key;
+    }>;
+}>;
+type MethodByName<Origin extends string, Entries, Root extends DomainSchemaInput> = Readonly<{
+    [Name in ProjectedMethodUnion<Origin, Entries, Root>['name'] as Name extends MethodCollectionOperation ? never : Name]: Extract<ProjectedMethodUnion<Origin, Entries, Root>, {
+        readonly name: Name;
+    }>;
+}>;
+type MethodCollectionOperation = 'byKey' | 'get';
+type MethodCollectionOf<Origin extends string, Entries, Root extends DomainSchemaInput> = language.ResolvedMethodCollection<MethodByKey<Origin, Entries, Root>, MethodByName<Origin, Entries, Root>>;
+type ResolvedFunctionOfAuthoring<Origin extends string, Name extends string, Value> = Value extends Function ? language.ResolvedFunction<CallableInputValue<Value>, CallableOutputValue<Value>, CallableAuthOf<Value>, CallablePolicyOf<Value>> & {
+    readonly ref: language.FunctionRef<Name> & {
+        readonly origin: Origin;
+    };
+    readonly key: language.DefinitionKey<Origin, 'function', Name>;
+} : 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

package/dist/v1/builder/{value-schema.d.ts → value/schema.d.ts}

@@ -1,5 +1,5 @@
-import type { JsonSchemaObject } from '../schema/value/schema.js';
-import type { ValueSchemaInput } from './property.js';
+import type { JsonSchemaObject } from '../../language/value/model/schema.js';
+import type { ValueSchemaInput } from '../class/property.js';
 declare const VALUE_SCHEMA_TYPE: unique symbol;
 /** Type-only value retained by one lossless Value Schema authored in TypeScript. */
 export interface TypedValueSchema<out Value = unknown> extends JsonSchemaObject {
@@ -14,4 +14,3 @@ export interface TypedValueSchema<out Value = unknown> extends JsonSchemaObject
  */
 export declare function valueSchema<Value>(): <const Schema extends ValueSchemaInput>(schema: Schema) => Schema & TypedValueSchema<Value>;
 export {};
-//# sourceMappingURL=value-schema.d.ts.map

package/dist/v1/builder/{value-schema.js → value/schema.js}

@@ -8,4 +8,3 @@
 export function valueSchema() {
     return (schema) => schema;
 }
-//# sourceMappingURL=value-schema.js.map

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

@@ -0,0 +1,21 @@
+import type { NodeClassReferenceInput } from '../class/authoring.js';
+import type { AUTHORING } from '../schema/handle.js';
+declare const VIEW_INPUT: unique symbol;
+export type ViewDefinitionTargetsInput = readonly [
+    NodeClassReferenceInput,
+    ...NodeClassReferenceInput[]
+];
+export type ViewTargetInput = 'domain' | NodeClassReferenceInput | ViewDefinitionTargetsInput;
+export interface ViewInput {
+    readonly description?: string;
+    readonly target?: ViewTargetInput;
+}
+export interface View<out Config extends ViewInput = ViewInput> {
+    readonly [AUTHORING]: 'view';
+    readonly [VIEW_INPUT]: Config;
+}
+export type ViewAuthoringInput<Value extends View> = Value extends View<infer Config> ? Config : never;
+/** Internal lowering access; View authoring handles expose no public configuration object. */
+export declare function viewAuthoringInput<const Value extends View>(value: Value): ViewAuthoringInput<Value>;
+export declare function view<const Config extends ViewInput>(config: Config & Record<Exclude<keyof Config, keyof ViewInput>, never>): View<Config>;
+export {};

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

@@ -0,0 +1,11 @@
+import { assertKnownKeys } from '../schema/diagnostic.js';
+import { authoringValue } from '../schema/handle.js';
+const VIEW_INPUT = Symbol('astrale.v1.view-input');
+/** Internal lowering access; View authoring handles expose no public configuration object. */
+export function viewAuthoringInput(value) {
+    return value[VIEW_INPUT];
+}
+export function view(config) {
+    assertKnownKeys(config, ['description', 'target']);
+    return authoringValue('view', { [VIEW_INPUT]: { ...config } });
+}

package/dist/v1/bundle/codec.d.ts

@@ -3,4 +3,3 @@ export declare function acceptDomainSchemaBundle(input: unknown): DomainSchemaBu
 export declare function decodeDomainSchemaBundle(input: string | Uint8Array): DomainSchemaBundle;
 export declare function serializeDomainSchemaBundle(bundle: DomainSchemaBundleValue): string;
 export declare function encodeDomainSchemaBundle(bundle: DomainSchemaBundleValue): Uint8Array;
-//# sourceMappingURL=codec.d.ts.map

package/dist/v1/bundle/codec.js

@@ -1,10 +1,11 @@
 import { accept as acceptJsonValue, BoundaryError as JsonBoundaryError, json, } from '@astrale-os/kernel-dsl/value';
-import { DomainSchemaError, diagnostic } from '../schema/diagnostic.js';
-import { acceptDomainSchema } from '../schema/domain.accept.js';
-import { MemoryDomainSchemaLookup } from '../schema/domain.lookup.js';
-import { canonicalDomainSchemaAfterValidation } from '../schema/domain.revision.js';
-import { revisionOfDomainSchema } from '../schema/domain.revision.js';
-import { compareUnicode } from '../schema/reference.js';
+import { compareUnicode } from '../addressing/ordering.js';
+import { acceptDomainSchema } from '../schema/admission/accept.js';
+import { canonicalDomainSchemaAfterValidation } from '../schema/canonical/revision.js';
+import { revisionOfDomainSchema } from '../schema/canonical/revision.js';
+import { MemoryDomainSchemaLookup } from '../schema/dependency/lookup.js';
+import { SchemaError } from '../schema/diagnostic.js';
+import { BundleError, diagnostic } from './diagnostic.js';
 import { asDomainSchemaBundle, } from './model.js';
 import { parseDomainSchemaBundleStructure } from './structure.js';
 export function acceptDomainSchemaBundle(input) {
@@ -14,7 +15,7 @@ export function acceptDomainSchemaBundle(input) {
     }
     catch (error) {
         if (error instanceof JsonBoundaryError) {
-            throw new DomainSchemaError([diagnostic('DV_JSON_VALUE', error.pointer, error.message)]);
+            throw new BundleError([diagnostic('DV_JSON_VALUE', error.pointer, error.message)]);
         }
         throw error;
     }
@@ -26,7 +27,7 @@ export function decodeDomainSchemaBundle(input) {
     }
     catch (error) {
         if (error instanceof json.DecodeError) {
-            throw new DomainSchemaError([diagnostic('DV_JSON_VALUE', '', error.message)]);
+            throw new BundleError([diagnostic('DV_JSON_VALUE', '', error.message)]);
         }
         throw error;
     }
@@ -63,7 +64,7 @@ function acceptBundleValue(input) {
         }
     }
     if (diagnostics.length > 0)
-        throw new DomainSchemaError(diagnostics);
+        throw new BundleError(diagnostics);
     const accepted = new Map();
     const acceptCandidate = (entry) => {
         const existing = accepted.get(entry.key);
@@ -78,7 +79,7 @@ function acceptBundleValue(input) {
             const schema = acceptDomainSchema(entry.schema, new MemoryDomainSchemaLookup([...accepted.values()]));
             const revision = revisionOfDomainSchema(schema);
             if (revision !== entry.revision) {
-                throw new DomainSchemaError([
+                throw new BundleError([
                     diagnostic('BUNDLE_SCHEMA_REVISION', '', `Accepted schema revision ${revision} differs from indexed revision ${entry.revision}.`),
                 ]);
             }
@@ -86,9 +87,9 @@ function acceptBundleValue(input) {
             return schema;
         }
         catch (error) {
-            if (!(error instanceof DomainSchemaError))
+            if (!(error instanceof SchemaError))
                 throw error;
-            throw new DomainSchemaError(error.diagnostics.map((item) => diagnostic(item.code, `${entry.pointer}${item.pointer}`, item.message, item.ref)));
+            throw new BundleError(error.diagnostics.map((item) => diagnostic(item.code, `${entry.pointer}${item.pointer}`, item.message, item.ref)));
         }
     };
     for (const entry of candidates.values()) {
@@ -148,4 +149,3 @@ function compareSchemas(left, right) {
 function keyOf(origin, revision) {
     return `${origin}\u0000${revision}`;
 }
-//# sourceMappingURL=codec.js.map

package/dist/v1/bundle/create.d.ts

@@ -0,0 +1,3 @@
+import type { DomainSchema } from '../schema/model/schema.js';
+import type { DomainSchemaBundle } from './model.js';
+export declare function createDomainSchemaBundle<const Root extends DomainSchema>(root: Root): DomainSchemaBundle<Root>;