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

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

@@ -5,11 +5,11 @@ import type { CoreEndpointRef } from '../../../language/core/model/core.js';
 import type { PolicyObjectRef } from '../../../language/policy/model/policy.js';
 import type { ValueSchemaRegistry } from '../../../language/value/reference/registry.js';
 import type { DomainSchema, DomainSchemaIR } from '../../../schema/model/schema.js';
-import type { FunctionAuthoring, PolicyObjectInput } from '../../callable/authoring.js';
-import type { ClassAuthoring, ClassReferenceInput } from '../../class/authoring.js';
-import type { CoreNodeAuthoring } from '../../core/authoring.js';
+import type { Function, PolicyObjectInput } from '../../callable/authoring.js';
+import type { Class, ClassReferenceInput } from '../../class/authoring.js';
+import type { CoreNode } from '../../core/authoring.js';
 import type { Policy } from '../../policy/authoring.js';
-import type { ViewAuthoring } from '../../view/authoring.js';
+import type { View } from '../../view/authoring.js';
 import { type Lazy } from '../../schema/lazy.js';
 import { OwnershipCapture } from './ownership.js';
 export declare class BuilderContext {
@@ -19,24 +19,24 @@ export declare class BuilderContext {
     readonly localDefinitions: Map<string, DefinitionRef<import("../../../addressing/definition-ref.js").Definition.Kind, string>>;
     readonly localClassKinds: Map<string, ClassKind>;
     readonly policies: Map<object, PolicyRef>;
-    readonly coreNodes: Map<CoreNodeAuthoring<Lazy<import("../../class/authoring.js").NodeClassAuthoring<import("../../class/authoring.js").NodeClassInput>>, (Readonly<Record<`${string}:class.${string}.property.${string}`, import("../../../language/index.js").PropertyValue>> | Readonly<{} & {
+    readonly coreNodes: Map<CoreNode<Lazy<import("../../class/authoring.js").NodeClass<import("../../class/authoring.js").NodeClassInput>>, (Readonly<Record<`${string}:class.${string}.property.${string}`, import("../../../language/index.js").PropertyValue>> | Readonly<{} & {
         [x: string]: unknown;
     }>) & import("../../../../value/types.js").Object>, CoreRef>;
     readonly policyObjects: Map<object, PolicyObjectRef>;
     readonly policyObjectRefs: Set<string>;
     readonly usedForeignOrigins: Set<string>;
     constructor(origin: string, dependencies: readonly DomainSchema[]);
-    captureDefinition(value: ClassAuthoring, ref: ClassRef, pointer: string): void;
+    captureDefinition(value: Class, ref: ClassRef, pointer: string): void;
     capturePolicy(value: Policy, ref: PolicyRef, pointer: string): void;
-    captureCoreNode(value: CoreNodeAuthoring, slug: string, pointer: string): void;
-    captureFunction(value: FunctionAuthoring, ref: FunctionRef, pointer: string): void;
-    captureView(value: ViewAuthoring, ref: ViewRef, pointer: string): void;
+    captureCoreNode(value: CoreNode, slug: string, pointer: string): void;
+    captureFunction(value: Function, ref: FunctionRef, pointer: string): void;
+    captureView(value: View, ref: ViewRef, pointer: string): void;
     resolveClass(input: ClassReferenceInput, kind: ClassKind, pointer: string): ClassRef;
     resolveNodeClass(input: ClassReferenceInput, pointer: string): ClassRef;
     resolveEdgeClass(input: ClassReferenceInput, pointer: string): ClassRef;
     resolvePolicy(input: Lazy<unknown>, pointer: string): PolicyRef;
     resolvePolicyObject(input: PolicyObjectInput | PolicyObjectRef, pointer: string): PolicyObjectRef;
-    resolveCoreEndpoint(value: CoreNodeAuthoring | CoreEndpointRef, pointer: string): CoreEndpointRef;
+    resolveCoreEndpoint(value: CoreNode | CoreEndpointRef, pointer: string): CoreEndpointRef;
     dependencies(): readonly DomainDependency[];
     valueRegistry(): ValueSchemaRegistry;
     noteDomainEndpointReferences(schema: DomainSchemaIR): void;
@@ -44,4 +44,3 @@ export declare class BuilderContext {
     private classKind;
     private capturePolicyObject;
 }
-//# sourceMappingURL=context.d.ts.map

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

@@ -240,4 +240,3 @@ function definitionRefsOf(schema) {
     }
     return refs.sort(compareDefinitionRefs);
 }
-//# sourceMappingURL=context.js.map

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

@@ -6,4 +6,3 @@ export declare class OwnershipCapture {
     definition(value: object): DefinitionRef | undefined;
     commit(): void;
 }
-//# sourceMappingURL=ownership.d.ts.map

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

@@ -27,4 +27,3 @@ export class OwnershipCapture {
             definitionOwners.set(value, ref);
     }
 }
-//# sourceMappingURL=ownership.js.map

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

@@ -13,4 +13,3 @@ export declare class BuilderValueSchemas {
     private resolvePathAccepts;
     private assertValid;
 }
-//# sourceMappingURL=compile.d.ts.map

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

@@ -134,4 +134,3 @@ function isRequired(value) {
         return true;
     return !zodObjectPropertyIsOptional(value);
 }
-//# sourceMappingURL=compile.js.map

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

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

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

@@ -18,4 +18,3 @@ export function lowerPathSchema(context, resolveAccepts, pointer) {
 function escapeToken(value) {
     return value.replaceAll('~', '~0').replaceAll('/', '~1');
 }
-//# sourceMappingURL=path.js.map

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

@@ -30,4 +30,3 @@ export interface ZodValueSchemaOverrideContext {
 export declare function convertZodToValueSchema(zodSchema: z.ZodType, context: ValueSchemaContext, registry: ValueSchemaRegistry, pointer?: string, options?: ZodValueSchemaConversionOptions): ZodValueSchemaConversion;
 /** Whether explicit Zod optionality makes a containing object property absent-able. */
 export declare function zodObjectPropertyIsOptional(schema: z.ZodType): boolean;
-//# sourceMappingURL=zod.d.ts.map

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

@@ -340,4 +340,3 @@ const UNREPRESENTABLE_TYPES = new Set([
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
-//# sourceMappingURL=zod.js.map

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

@@ -1,12 +1,11 @@
 import type { ViewDefinition } from '../../language/view/model/view.js';
-import type { ViewAuthoring } from '../view/authoring.js';
+import type { View } from '../view/authoring.js';
 import type { BuilderContext } from './schema/context.js';
 export interface ViewCompiler {
-    compile(value: ViewAuthoring, name: string, pointer: string): ViewDefinition;
+    compile(value: View, name: string, pointer: string): ViewDefinition;
 }
 export declare class V1ViewCompiler implements ViewCompiler {
     readonly context: BuilderContext;
     constructor(context: BuilderContext);
-    compile(value: ViewAuthoring, name: string, pointer: string): ViewDefinition;
+    compile(value: View, name: string, pointer: string): ViewDefinition;
 }
-//# sourceMappingURL=view.d.ts.map

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

@@ -25,4 +25,3 @@ export class V1ViewCompiler {
 function isTargetList(input) {
     return Array.isArray(input);
 }
-//# sourceMappingURL=view.js.map

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

@@ -1,11 +1,11 @@
 import type { ClassRef } from '../../addressing/index.js';
 import type { PolicyCheckExpression, PolicyPatternExpression, PolicyPatternTerm as CanonicalPolicyPatternTerm } from '../../language/policy/model/policy.js';
-import type { EdgeClassAuthoring, NodeClassAuthoring } from '../class/authoring.js';
+import type { EdgeClass, NodeClass } from '../class/authoring.js';
 import type { AuthoringValue } from '../schema/handle.js';
 import type { Lazy } from '../schema/lazy.js';
 export interface PolicyEdgeInput {
     readonly source: CanonicalPolicyPatternTerm;
-    readonly class: Lazy<EdgeClassAuthoring>;
+    readonly class: Lazy<EdgeClass>;
     readonly target: CanonicalPolicyPatternTerm;
     readonly repeat?: {
         readonly min: number;
@@ -13,7 +13,7 @@ export interface PolicyEdgeInput {
     };
 }
 export interface PolicyExistsContext {
-    node(definition: Lazy<NodeClassAuthoring>): CanonicalPolicyPatternTerm;
+    node(definition: Lazy<NodeClass>): CanonicalPolicyPatternTerm;
 }
 export interface PolicyPatternContext {
     readonly subject: CanonicalPolicyPatternTerm;
@@ -45,9 +45,8 @@ export interface PolicyBuilder {
 export declare function policyDeclaration(value: Policy): PolicyDeclaration;
 export declare const policy: PolicyBuilder;
 export declare function createPatternContext(options: {
-    readonly resolveEdgeClass: (value: Lazy<EdgeClassAuthoring>, pointer: string) => ClassRef;
-    readonly resolveNodeClass: (value: Lazy<NodeClassAuthoring>, pointer: string) => ClassRef;
+    readonly resolveEdgeClass: (value: Lazy<EdgeClass>, pointer: string) => ClassRef;
+    readonly resolveNodeClass: (value: Lazy<NodeClass>, pointer: string) => ClassRef;
     readonly pointer: string;
 }): PolicyPatternContext;
 export type { PolicyCheckExpression };
-//# sourceMappingURL=authoring.d.ts.map

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

@@ -88,4 +88,3 @@ function nonEmpty(values, pointer) {
     if (values.length === 0)
         fail('BUILDER_POLICY_EMPTY_COMPOSITION', pointer, 'Policy composition must be non-empty.');
 }
-//# sourceMappingURL=authoring.js.map

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

@@ -2,7 +2,9 @@ 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): DomainSchema<Origin, Input, DomainOfInput<Origin, Input>>;
+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';
-//# sourceMappingURL=define.d.ts.map

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

@@ -3,4 +3,3 @@ import { compileSchema } from '../lowering/schema/compile.js';
 export function defineSchema(origin, input) {
     return compileSchema(origin, input);
 }
-//# sourceMappingURL=define.js.map

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

@@ -14,4 +14,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;
-//# sourceMappingURL=diagnostic.d.ts.map

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

@@ -29,4 +29,3 @@ export function fail(code, pointer, message) {
 export function escapeToken(value) {
     return value.replaceAll('~', '~0').replaceAll('/', '~1');
 }
-//# sourceMappingURL=diagnostic.js.map

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

@@ -5,4 +5,3 @@ export interface AuthoringValue<Kind extends AuthoringKind> {
 }
 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=handle.d.ts.map

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

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

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

@@ -1,16 +1,15 @@
 import type { DomainSchema } from '../../schema/model/schema.js';
-import type { FunctionAuthoring } from '../callable/authoring.js';
-import type { ClassAuthoring } from '../class/authoring.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 { ViewAuthoring } from '../view/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, ClassAuthoring>>;
-    readonly functions?: Readonly<Record<string, FunctionAuthoring>>;
+    readonly classes?: Readonly<Record<string, Class>>;
+    readonly functions?: Readonly<Record<string, Function>>;
     readonly policies?: Readonly<Record<string, Policy>>;
-    readonly views?: Readonly<Record<string, ViewAuthoring>>;
+    readonly views?: Readonly<Record<string, View>>;
     readonly core?: CoreInput;
 }
-//# sourceMappingURL=input.d.ts.map

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

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=input.js.map

package/dist/v1/builder/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=lazy.d.ts.map

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

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

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

@@ -3,9 +3,9 @@ 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 { FunctionAuthoring, MethodAuthoring, StreamOutput, BinaryOutput } from '../callable/authoring.js';
-import type { ClassAuthoring, DirectedEdgeClassAuthoring, NodeClassAuthoring, UndirectedEdgeClassAuthoring } from '../class/authoring.js';
-import type { AutoPropertyAuthoring, PropertyAuthoring, PropertyOptions, ValueSchemaInput } from '../class/property.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<{
@@ -34,12 +34,12 @@ export type DomainOfInput<Origin extends string, Input extends DomainSchemaInput
         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 NodeClassAuthoring ? 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>> & {
+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 DirectedEdgeClassAuthoring | UndirectedEdgeClassAuthoring ? 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>> & {
+} : 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;
     };
@@ -52,13 +52,13 @@ type AbstractOf<Config> = Config extends {
 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 NodeClassAuthoring<infer Config> ? language.NodeClassDefinition & {
+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 DirectedEdgeClassAuthoring<infer Input> ? language.EdgeClassDefinition & {
+} : Value extends DirectedEdgeClass<infer Input> ? language.EdgeClassDefinition & {
     readonly ref: language.ClassRef<Name> & {
         readonly origin: Origin;
     };
@@ -76,7 +76,7 @@ type ProjectedClassDefinition<Origin extends string, Name extends string, Value>
         };
     };
     readonly constraints: language.DirectedEdgeConstraints & ConstraintsOf<Input>;
-} : Value extends UndirectedEdgeClassAuthoring<infer Input> ? language.EdgeClassDefinition & {
+} : Value extends UndirectedEdgeClass<infer Input> ? language.EdgeClassDefinition & {
     readonly ref: language.ClassRef<Name> & {
         readonly origin: Origin;
     };
@@ -105,14 +105,14 @@ type CoreInputOf<Input extends DomainSchemaInput> = Input extends {
 } ? 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 NodeClassAuthoring<infer Input> ? Input : Value extends DirectedEdgeClassAuthoring<infer Input> ? Input : Value extends UndirectedEdgeClassAuthoring<infer Input> ? Input : never;
+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 NodeClassAuthoring ? language.ResolvedClass<'node'> & {
+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>;
@@ -135,16 +135,16 @@ interface AuthoredPropertyEntry<Owner, Name extends string, 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 ClassAuthoring ? EffectivePropertyEntries<Parent, Seen> : never;
+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 AutoPropertyAuthoring<infer Value> ? PropertySchemaOf<Value> : Field extends PropertyAuthoring<infer Schema, PropertyOptions> ? Schema : Field;
-type PropertyOptionsOf<Field> = Field extends AutoPropertyAuthoring<infer Value> ? PropertyOptionsOf<Value> : Field extends PropertyAuthoring<ValueSchemaInput, infer Options> ? Options : Record<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 ClassAuthoring ? CorePropertyInputFromEntries<EffectivePropertyEntries<Resolved>> : Resolved extends language.ResolvedClass ? language.PropertyInputOf<Resolved> : never : never;
+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;
@@ -186,26 +186,26 @@ type PropertyByName<Origin extends string, Entries, Root extends DomainSchemaInp
 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 MethodAuthoring> {
+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 MethodAuthoring ? CallableConfig<MethodValue> extends {
+    [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 NodeClassAuthoring ? EffectiveMethodEntries<Parent, Static, Seen> : never;
+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 MethodAuthoring<infer Config> ? Config : Value extends FunctionAuthoring<infer Config> ? Config : never;
-type CallableInputValue<Value extends MethodAuthoring | FunctionAuthoring> = ValueInputOf<CallableConfig<Value>['input']>;
-type CallableOutputValue<Value extends MethodAuthoring | FunctionAuthoring> = CallableConfig<Value>['output'] extends StreamOutput<infer Item> ? {
+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 ? {
@@ -217,14 +217,14 @@ type CallableOutputValue<Value extends MethodAuthoring | FunctionAuthoring> = Ca
 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 MethodAuthoring> = CallableConfig<Value> extends {
+type CallableStaticOf<Value extends Method> = CallableConfig<Value> extends {
     readonly static: true;
 } ? true : false;
-type CallableInheritanceOf<Value extends MethodAuthoring> = CallableConfig<Value> extends {
+type CallableInheritanceOf<Value extends Method> = CallableConfig<Value> extends {
     readonly inheritance: infer Inheritance extends language.MethodInheritance;
 } ? Inheritance : 'default';
-type CallableAuthOf<Value extends MethodAuthoring | FunctionAuthoring> = CallableConfig<Value>['auth'];
-type CallablePolicyOf<Value extends MethodAuthoring | FunctionAuthoring> = CallableAuthOf<Value> extends 'authorized' ? language.PolicyCheckExpression : never;
+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>, {
@@ -238,11 +238,10 @@ type MethodByName<Origin extends string, Entries, Root extends DomainSchemaInput
 }>;
 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 FunctionAuthoring ? language.ResolvedFunction<CallableInputValue<Value>, CallableOutputValue<Value>, CallableAuthOf<Value>, CallablePolicyOf<Value>> & {
+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 {};
-//# sourceMappingURL=projection.d.ts.map

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

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=projection.js.map

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

@@ -2,4 +2,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;
-//# sourceMappingURL=full-match.d.ts.map

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

@@ -9,4 +9,3 @@ export function fullMatch(source) {
     }
     return languageFullMatch(source);
 }
-//# sourceMappingURL=full-match.js.map

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

@@ -2,4 +2,3 @@ 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;
-//# sourceMappingURL=path-metadata.d.ts.map

package/dist/v1/builder/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

@@ -6,4 +6,3 @@ export type PathAuthoring<Accepts extends readonly NodeClassReferenceInput[] = r
 };
 export declare function path<const Accepts extends readonly NodeClassReferenceInput[]>(...accepts: Accepts): PathAuthoring<Accepts>;
 export {};
-//# sourceMappingURL=path.d.ts.map

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

@@ -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

@@ -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=schema.d.ts.map

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

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

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

@@ -10,13 +10,12 @@ export interface ViewInput {
     readonly description?: string;
     readonly target?: ViewTargetInput;
 }
-export interface ViewAuthoring<out Config extends ViewInput = ViewInput> {
+export interface View<out Config extends ViewInput = ViewInput> {
     readonly [AUTHORING]: 'view';
     readonly [VIEW_INPUT]: Config;
 }
-export type ViewAuthoringInput<Value extends ViewAuthoring> = Value extends ViewAuthoring<infer Config> ? Config : never;
+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 ViewAuthoring>(value: Value): ViewAuthoringInput<Value>;
-export declare function view<const Config extends ViewInput>(config: Config & Record<Exclude<keyof Config, keyof ViewInput>, never>): ViewAuthoring<Config>;
+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 {};
-//# sourceMappingURL=authoring.d.ts.map

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

@@ -9,4 +9,3 @@ export function view(config) {
     assertKnownKeys(config, ['description', 'target']);
     return authoringValue('view', { [VIEW_INPUT]: { ...config } });
 }
-//# sourceMappingURL=authoring.js.map

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

@@ -149,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

@@ -1,4 +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>;
-//# sourceMappingURL=create.d.ts.map

package/dist/v1/bundle/create.js

@@ -3,4 +3,3 @@ import { asDomainSchemaBundle } from './model.js';
 export function createDomainSchemaBundle(root) {
     return asDomainSchemaBundle(root, requireDomainClosure(root).map(({ schema }) => schema));
 }
-//# sourceMappingURL=create.js.map

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

@@ -8,4 +8,3 @@ export declare class BundleError extends Error {
     readonly diagnostics: readonly BundleDiagnostic[];
     constructor(diagnostics: readonly BundleDiagnostic[]);
 }
-//# sourceMappingURL=diagnostic.d.ts.map

package/dist/v1/bundle/diagnostic.js

@@ -15,4 +15,3 @@ export class BundleError extends Error {
         this.diagnostics = Object.freeze(ordered);
     }
 }
-//# sourceMappingURL=diagnostic.js.map

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

@@ -16,4 +16,3 @@ export declare function serialize(bundle: Bundle): string;
 export { DOMAIN_BUNDLE_FORMAT as FORMAT, DOMAIN_BUNDLE_VERSION as VERSION } from './model.js';
 export { BundleError as Error } from './diagnostic.js';
 export type { BundleDiagnostic as Diagnostic, BundleDiagnosticCode as DiagnosticCode, } from './diagnostic.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/v1/bundle/index.js

@@ -18,4 +18,3 @@ export function serialize(bundle) {
 }
 export { DOMAIN_BUNDLE_FORMAT as FORMAT, DOMAIN_BUNDLE_VERSION as VERSION } from './model.js';
 export { BundleError as Error } from './diagnostic.js';
-//# sourceMappingURL=index.js.map

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

@@ -14,4 +14,3 @@ export type DomainSchemaBundle<Root extends DomainSchema = DomainSchema> = Domai
 };
 export declare function asDomainSchemaBundle<Root extends DomainSchema>(root: Root, closure: readonly DomainSchema[]): DomainSchemaBundle<Root>;
 export {};
-//# sourceMappingURL=model.d.ts.map

package/dist/v1/bundle/model.js

@@ -9,4 +9,3 @@ export function asDomainSchemaBundle(root, closure) {
         closure: [...closure],
     });
 }
-//# sourceMappingURL=model.js.map

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

@@ -5,4 +5,3 @@ export interface DomainSchemaBundleStructure {
     readonly closure: readonly DomainSchemaIR[];
 }
 export declare function parseDomainSchemaBundleStructure(input: JsonValue): DomainSchemaBundleStructure;
-//# sourceMappingURL=structure.d.ts.map

package/dist/v1/bundle/structure.js

@@ -69,4 +69,3 @@ function describe(value) {
 function escapeToken(value) {
     return value.replaceAll('~', '~0').replaceAll('/', '~1');
 }
-//# sourceMappingURL=structure.js.map

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

@@ -6,4 +6,3 @@ export declare const encode: (bundle: Bundle) => Uint8Array;
 export declare const serialize: (bundle: Bundle) => string;
 export { DOMAIN_BUNDLE_FORMAT as FORMAT, DOMAIN_BUNDLE_VERSION as VERSION } from './model.js';
 export { BundleError as Error } from './diagnostic.js';
-//# sourceMappingURL=transport.d.ts.map

package/dist/v1/bundle/transport.js

@@ -5,4 +5,3 @@ export const encode = (bundle) => encodeDomainSchemaBundle(bundle);
 export const serialize = (bundle) => serializeDomainSchemaBundle(bundle);
 export { DOMAIN_BUNDLE_FORMAT as FORMAT, DOMAIN_BUNDLE_VERSION as VERSION } from './model.js';
 export { BundleError as Error } from './diagnostic.js';
-//# sourceMappingURL=transport.js.map

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

@@ -1,4 +1,3 @@
 import type { CompiledSchema } from '../model/schema.js';
 /** Admit one detached compiled closure before indices and declarations become executable. */
 export declare function acceptCompiledSchema(input: unknown): CompiledSchema;
-//# sourceMappingURL=accept.d.ts.map