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

package/dist/index.d.ts

@@ -1,2 +1 @@
 export * from './v1/index.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,2 +1 @@
 export * from './v1/index.js';
-//# sourceMappingURL=index.js.map

package/dist/upgrade/contract.d.ts

@@ -29,4 +29,3 @@ export interface BundleUpgrade<Source extends VersionedBundle, Target extends Ve
     readonly to: LanguageVersionOf<Target>;
     readonly upgrade: (bundle: Source) => BundleUpgradeResult<Target>;
 }
-//# sourceMappingURL=contract.d.ts.map

package/dist/upgrade/contract.js

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

package/dist/upgrade/index.d.ts

@@ -1,2 +1 @@
 export type { BundleUpgrade, BundleUpgradeResult, UpgradeIssue, VersionedBundle, } from './contract.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/upgrade/index.js

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

package/dist/v1/addressing/class-key.d.ts

@@ -10,4 +10,3 @@ export declare namespace ClassKey {
     function is(input: unknown): input is ClassKey;
     function ref(input: ClassKey): ClassRef;
 }
-//# sourceMappingURL=class-key.d.ts.map

package/dist/v1/addressing/class-key.js

@@ -37,4 +37,3 @@ export function ClassKey(input) {
     }
     ClassKey.ref = ref;
 })(ClassKey || (ClassKey = {}));
-//# sourceMappingURL=class-key.js.map

package/dist/v1/addressing/definition-ref.d.ts

@@ -26,4 +26,3 @@ export declare function acceptDefinitionRef(input: unknown): DefinitionRef;
 export declare function isDefinitionRef(input: unknown): input is DefinitionRef;
 /** Compare exact Definition coordinates, independent of object identity. */
 export declare function equalDefinitionRefs(left: DefinitionRef, right: DefinitionRef): boolean;
-//# sourceMappingURL=definition-ref.d.ts.map

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

@@ -61,4 +61,3 @@ function invalid(input) {
 function definitionNameMatches(kind, name) {
     return kind === 'core' ? CORE_SLUG_PATTERN.test(name) : MEMBER_NAME_PATTERN.test(name);
 }
-//# sourceMappingURL=definition-ref.js.map

package/dist/v1/addressing/domain-dependency.d.ts

@@ -6,4 +6,13 @@ export type DomainDependency = JsonObject & {
     readonly origin: Key.Origin;
     readonly revision: Revision;
 };
-//# sourceMappingURL=domain-dependency.d.ts.map
+/** Canonical authored name of one exact direct dependency. */
+export type DependencyAlias = string;
+/** Exact direct dependency pins keyed by their authored aliases. */
+export type DomainDependencyMap = Readonly<Record<DependencyAlias, DomainDependency>>;
+/** Representation-neutral admission budgets shared by source and compiled closures. */
+export declare const dependencyLimits: Readonly<{
+    direct: 32;
+    closure: 256;
+    depth: 32;
+}>;

package/dist/v1/addressing/domain-dependency.js

@@ -1,2 +1,6 @@
-export {};
-//# sourceMappingURL=domain-dependency.js.map
+/** Representation-neutral admission budgets shared by source and compiled closures. */
+export const dependencyLimits = Object.freeze({
+    direct: 32,
+    closure: 256,
+    depth: 32,
+});

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

@@ -9,5 +9,4 @@ export { Key } from './key.js';
 export { compareUnicode } from './ordering.js';
 export { PropertyKey } from './property-key.js';
 export type { Revision } from './revision.js';
-export type { DomainDependency } from './domain-dependency.js';
-//# sourceMappingURL=index.d.ts.map
+export type { DependencyAlias, DomainDependency, DomainDependencyMap } from './domain-dependency.js';

package/dist/v1/addressing/index.js

@@ -5,4 +5,3 @@ export { patterns } from './patterns.js';
 export { Key } from './key.js';
 export { compareUnicode } from './ordering.js';
 export { PropertyKey } from './property-key.js';
-//# sourceMappingURL=index.js.map

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

@@ -17,4 +17,3 @@ export declare namespace Key {
     function origin(input: Key): Key.Origin;
     function is(input: unknown): input is Key;
 }
-//# sourceMappingURL=key.d.ts.map

package/dist/v1/addressing/key.js

@@ -37,4 +37,3 @@ function isCanonicalKey(input) {
 function isCanonicalCoordinate(input) {
     return DEFINITION_KEY.test(input) || CORE_KEY.test(input) || MEMBER_KEY.test(input);
 }
-//# sourceMappingURL=key.js.map

package/dist/v1/addressing/method-address.d.ts

@@ -7,4 +7,3 @@ export interface MethodAddress<out Owner extends ClassRef = ClassRef, out Name e
     readonly owner: Owner;
     readonly name: Name;
 }
-//# sourceMappingURL=method-address.d.ts.map

package/dist/v1/addressing/method-address.js

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

package/dist/v1/addressing/method-key.d.ts

@@ -13,4 +13,3 @@ export declare namespace MethodKey {
 }
 /** Decompose one admitted callable key into its semantic Function or Method address. */
 export declare function callableAddress(input: Key.Callable): FunctionRef | MethodAddress;
-//# sourceMappingURL=method-key.d.ts.map

package/dist/v1/addressing/method-key.js

@@ -58,4 +58,3 @@ export function callableAddress(input) {
         name: coordinate.slice('function.'.length),
     });
 }
-//# sourceMappingURL=method-key.js.map

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

@@ -4,4 +4,3 @@ export declare function definitionRefIndex(ref: DefinitionRef): string;
 export declare function compareDefinitionRefs(left: DefinitionRef, right: DefinitionRef): number;
 /** Locale-independent Unicode code-point ordering for canonical DSL values. */
 export declare function compareUnicode(left: string, right: string): number;
-//# sourceMappingURL=ordering.d.ts.map

package/dist/v1/addressing/ordering.js

@@ -18,4 +18,3 @@ export function compareUnicode(left, right) {
     }
     return a.length - b.length;
 }
-//# sourceMappingURL=ordering.js.map

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

@@ -2,15 +2,19 @@
 export type DomainOrigin = string;
 export declare const DOMAIN_ORIGIN_PATTERN: RegExp;
 export declare const MEMBER_NAME_PATTERN: RegExp;
+export declare const DEPENDENCY_ALIAS_PATTERN: RegExp;
 export declare const CORE_SLUG_PATTERN: RegExp;
 export declare const DOMAIN_REVISION_PATTERN: RegExp;
 export declare const DOMAIN_REVISION_FULL_MATCH = "sha256:[0-9a-f]{64}";
 export declare const DOMAIN_ORIGIN_FULL_MATCH = "([a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?\\.)+[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?";
 export declare const MEMBER_NAME_FULL_MATCH = "[A-Za-z][A-Za-z0-9_]*";
+export declare const DEPENDENCY_ALIAS_FULL_MATCH = "[a-z][A-Za-z0-9]*";
 export declare const PROPERTY_KEY_FULL_MATCH = "([a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?\\.)+[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?:class\\.[A-Za-z][A-Za-z0-9_]*\\.property\\.[A-Za-z][A-Za-z0-9_]*";
 export declare const PROPERTY_KEY_PATTERN: RegExp;
 export declare const patterns: Readonly<{
     coreSlug: RegExp;
+    dependencyAlias: RegExp;
+    dependencyAliasFullMatch: "[a-z][A-Za-z0-9]*";
     memberName: RegExp;
     memberNameFullMatch: "[A-Za-z][A-Za-z0-9_]*";
     origin: RegExp;
@@ -21,4 +25,3 @@ export declare const patterns: Readonly<{
     revisionFullMatch: "sha256:[0-9a-f]{64}";
 }>;
 export declare function assertMemberName(name: string): void;
-//# sourceMappingURL=patterns.d.ts.map

package/dist/v1/addressing/patterns.js

@@ -1,14 +1,18 @@
 export const DOMAIN_ORIGIN_PATTERN = /^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/u;
 export const MEMBER_NAME_PATTERN = /^[A-Za-z][A-Za-z0-9_]*$/u;
+export const DEPENDENCY_ALIAS_PATTERN = /^[a-z][A-Za-z0-9]*$/u;
 export const CORE_SLUG_PATTERN = /^[a-z][a-z0-9-]{0,99}$/u;
 export const DOMAIN_REVISION_PATTERN = /^sha256:[0-9a-f]{64}$/u;
 export const DOMAIN_REVISION_FULL_MATCH = 'sha256:[0-9a-f]{64}';
 export const DOMAIN_ORIGIN_FULL_MATCH = '([a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?\\.)+[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?';
 export const MEMBER_NAME_FULL_MATCH = '[A-Za-z][A-Za-z0-9_]*';
+export const DEPENDENCY_ALIAS_FULL_MATCH = '[a-z][A-Za-z0-9]*';
 export const PROPERTY_KEY_FULL_MATCH = '([a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?\\.)+[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?:class\\.[A-Za-z][A-Za-z0-9_]*\\.property\\.[A-Za-z][A-Za-z0-9_]*';
 export const PROPERTY_KEY_PATTERN = new RegExp(`^(?:${PROPERTY_KEY_FULL_MATCH})$`, 'u');
 export const patterns = Object.freeze({
     coreSlug: CORE_SLUG_PATTERN,
+    dependencyAlias: DEPENDENCY_ALIAS_PATTERN,
+    dependencyAliasFullMatch: DEPENDENCY_ALIAS_FULL_MATCH,
     memberName: MEMBER_NAME_PATTERN,
     memberNameFullMatch: MEMBER_NAME_FULL_MATCH,
     origin: DOMAIN_ORIGIN_PATTERN,
@@ -23,4 +27,3 @@ export function assertMemberName(name) {
         throw new TypeError(`Invalid member name: ${JSON.stringify(name)}.`);
     }
 }
-//# sourceMappingURL=patterns.js.map

package/dist/v1/addressing/property-key.d.ts

@@ -11,4 +11,3 @@ export declare namespace PropertyKey {
         readonly name: string;
     };
 }
-//# sourceMappingURL=property-key.d.ts.map

package/dist/v1/addressing/property-key.js

@@ -37,4 +37,3 @@ export function PropertyKey(input) {
     }
     PropertyKey.address = address;
 })(PropertyKey || (PropertyKey = {}));
-//# sourceMappingURL=property-key.js.map

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

@@ -6,4 +6,3 @@ export type Revision = `sha256:${string}` & {
 /** Content-address canonical Domain bytes with the one V1 revision algorithm. */
 export declare function digestRevisionBytes(bytes: Uint8Array): Revision;
 export {};
-//# sourceMappingURL=revision.d.ts.map

package/dist/v1/addressing/revision.js

@@ -6,4 +6,3 @@ export function digestRevisionBytes(bytes) {
     return `sha256:${hexadecimal}`;
 }
 import { sha256 } from '@noble/hashes/sha2.js';
-//# sourceMappingURL=revision.js.map

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

@@ -1,11 +1,11 @@
 import type { FunctionAuth, MethodInheritance } from '../../language/callable/model/callable.js';
 import type { PolicyCheckExpression, PolicyCheckObject, PolicyObjectRef } from '../../language/policy/model/policy.js';
-import type { ClassAuthoring } from '../class/authoring.js';
+import type { Class } from '../class/authoring.js';
 import type { ValueSchemaInput } from '../class/property.js';
-import type { CoreNodeAuthoring } from '../core/authoring.js';
+import type { CoreNode } from '../core/authoring.js';
 import type { Policy, PolicyInput } from '../policy/authoring.js';
 import type { Lazy } from '../schema/lazy.js';
-import type { ViewAuthoring } from '../view/authoring.js';
+import type { View } from '../view/authoring.js';
 import { type AUTHORING } from '../schema/handle.js';
 declare const CALLABLE_OUTPUT: unique symbol;
 declare const CALLABLE_INPUT: unique symbol;
@@ -71,21 +71,21 @@ export type AuthoredCallableInput<Input extends ValueSchemaInput, Output extends
 }) & ([Inheritance] extends [never] ? {} : {
     readonly inheritance: Inheritance;
 });
-export interface FunctionAuthoring<out Config extends CallableInput = CallableInput> {
+export interface Function<out Config extends CallableInput = CallableInput> {
     readonly [AUTHORING]: 'function';
     readonly [CALLABLE_INPUT]: Config;
 }
-export interface MethodAuthoring<out Config extends MethodInput = MethodInput> {
+export interface Method<out Config extends MethodInput = MethodInput> {
     readonly [AUTHORING]: 'method';
     readonly [CALLABLE_INPUT]: Config;
 }
-export type CallableAuthoringInput<Value extends FunctionAuthoring | MethodAuthoring> = Value extends FunctionAuthoring<infer Config> ? Config : Value extends MethodAuthoring<infer Config> ? Config : never;
+export type CallableAuthoringInput<Value extends Function | Method> = Value extends Function<infer Config> ? Config : Value extends Method<infer Config> ? Config : never;
 /** Internal lowering access; Callable authoring handles expose no public configuration object. */
-export declare function callableAuthoringInput<const Value extends FunctionAuthoring | MethodAuthoring>(value: Value): CallableAuthoringInput<Value>;
-export type PolicyObjectAuthoring = ClassAuthoring | FunctionAuthoring | Policy | ViewAuthoring | CoreNodeAuthoring;
+export declare function callableAuthoringInput<const Value extends Function | Method>(value: Value): CallableAuthoringInput<Value>;
+export type PolicyObjectAuthoring = Class | Function | Policy | View | CoreNode;
 export type PolicyObjectInput = Lazy<PolicyObjectAuthoring>;
-export declare function func<const Config extends FunctionInput>(config: Config): FunctionAuthoring<Config>;
-export declare function method<const Config extends MethodInput>(config: Config): MethodAuthoring<Config>;
+export declare function func<const Config extends FunctionInput>(config: Config): Function<Config>;
+export declare function method<const Config extends MethodInput>(config: Config): Method<Config>;
 export declare function callableInputField(name: string): Extract<PolicyCheckObject, {
     readonly kind: 'input';
 }>;
@@ -103,4 +103,3 @@ export declare const output: {
 };
 export declare function isCallableOutputAuthoring(value: CallableOutputInput): value is StreamOutput | BinaryOutput;
 export {};
-//# sourceMappingURL=authoring.d.ts.map

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

@@ -62,4 +62,3 @@ export const output = Object.freeze({
 export function isCallableOutputAuthoring(value) {
     return isAuthoringValue(value, 'callable-output');
 }
-//# sourceMappingURL=authoring.js.map

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

@@ -2,15 +2,15 @@ import type { ClassRef } from '../../addressing/index.js';
 import type { MethodRecord } from '../../language/callable/model/callable.js';
 import type { MediaType } from '../../language/class/model/data.js';
 import type { ResolvedClass } from '../../language/class/resolved.js';
-import type { MethodAuthoring } from '../callable/authoring.js';
+import type { Method } from '../callable/authoring.js';
 import type { Policy } from '../policy/authoring.js';
 import type { Lazy } from '../schema/lazy.js';
 import type { PropertyRecordInput } from './property.js';
 import { type AUTHORING } from '../schema/handle.js';
 declare const CLASS_TYPE: unique symbol;
-export type ClassReferenceInput = Lazy<ClassAuthoring | ClassRef | ResolvedClass<'node'> | ResolvedClass<'edge'>>;
-export type NodeClassReferenceInput = Lazy<NodeClassAuthoring | ClassRef | ResolvedClass<'node'>>;
-export type EdgeClassReferenceInput = Lazy<EdgeClassAuthoring | ClassRef | ResolvedClass<'edge'>>;
+export type ClassReferenceInput = Lazy<Class | ClassRef | ResolvedClass<'node'> | ResolvedClass<'edge'>>;
+export type NodeClassReferenceInput = Lazy<NodeClass | ClassRef | ResolvedClass<'node'>>;
+export type EdgeClassReferenceInput = Lazy<EdgeClass | ClassRef | ResolvedClass<'edge'>>;
 export interface DirectedSourceInput {
     readonly as: string;
     readonly accepts: readonly NodeClassReferenceInput[];
@@ -33,7 +33,7 @@ export interface NodeClassInput {
     readonly extends?: readonly NodeClassReferenceInput[];
     readonly properties?: PropertyRecordInput;
     readonly data?: MediaType;
-    readonly methods?: Readonly<Record<string, MethodAuthoring>>;
+    readonly methods?: Readonly<Record<string, Method>>;
     readonly icon?: string;
     readonly policies?: {
         readonly read?: Lazy<Policy>;
@@ -79,51 +79,50 @@ export type ClassInput = ({
     readonly orientation: 'undirected';
     readonly abstract: boolean;
 } & Omit<UndirectedEdgeInput, 'orientation'>);
-export type ClassAuthoring = NodeClassAuthoring | EdgeClassAuthoring;
-export interface NodeClassAuthoring<out Config extends NodeClassInput = NodeClassInput> {
+export type Class = NodeClass | EdgeClass;
+export interface NodeClass<out Config extends NodeClassInput = NodeClassInput> {
     readonly [AUTHORING]: 'definition';
     readonly kind: 'node';
     readonly [CLASS_TYPE]?: () => Config;
 }
-export interface DirectedEdgeClassAuthoring<out Input extends Omit<DirectedEdgeInput, 'orientation'> = Omit<DirectedEdgeInput, 'orientation'>> {
+export interface DirectedEdgeClass<out Input extends Omit<DirectedEdgeInput, 'orientation'> = Omit<DirectedEdgeInput, 'orientation'>> {
     readonly [AUTHORING]: 'definition';
     readonly kind: 'edge';
     readonly orientation: 'directed';
     readonly [CLASS_TYPE]?: () => Input;
 }
-export interface UndirectedEdgeClassAuthoring<out Input extends Omit<UndirectedEdgeInput, 'orientation'> = Omit<UndirectedEdgeInput, 'orientation'>> {
+export interface UndirectedEdgeClass<out Input extends Omit<UndirectedEdgeInput, 'orientation'> = Omit<UndirectedEdgeInput, 'orientation'>> {
     readonly [AUTHORING]: 'definition';
     readonly kind: 'edge';
     readonly orientation: 'undirected';
     readonly [CLASS_TYPE]?: () => Input;
 }
-export type EdgeClassAuthoring = DirectedEdgeClassAuthoring | UndirectedEdgeClassAuthoring;
+export type EdgeClass = DirectedEdgeClass | UndirectedEdgeClass;
 export declare function defineClass(config: {
     readonly kind: 'node';
     readonly abstract: boolean;
-} & NodeClassInput): NodeClassAuthoring;
+} & NodeClassInput): NodeClass;
 export declare function defineClass(config: {
     readonly kind: 'edge';
     readonly orientation: 'directed';
     readonly abstract: boolean;
-} & Omit<DirectedEdgeInput, 'orientation'>): DirectedEdgeClassAuthoring;
+} & Omit<DirectedEdgeInput, 'orientation'>): DirectedEdgeClass;
 export declare function defineClass(config: {
     readonly kind: 'edge';
     readonly orientation: 'undirected';
     readonly abstract: boolean;
-} & Omit<UndirectedEdgeInput, 'orientation'>): UndirectedEdgeClassAuthoring;
-export declare function nodeClass<const Config extends NodeClassInput = Record<never, never>>(config?: Config & Record<Exclude<keyof Config, keyof NodeClassInput>, never>): NodeClassAuthoring<Config>;
+} & Omit<UndirectedEdgeInput, 'orientation'>): UndirectedEdgeClass;
+export declare function nodeClass<const Config extends NodeClassInput = Record<never, never>>(config?: Config & Record<Exclude<keyof Config, keyof NodeClassInput>, never>): NodeClass<Config>;
 export declare const edgeClass: Readonly<{
     directed<const Input extends Omit<DirectedEdgeInput, 'orientation'>>(input: Input & {
         readonly source: ExactEndpointInput<Input['source'], DirectedSourceInput>;
         readonly target: ExactEndpointInput<Input['target'], DirectedTargetInput>;
-    }): DirectedEdgeClassAuthoring<Input>;
+    }): DirectedEdgeClass<Input>;
     undirected<const Input extends Omit<UndirectedEdgeInput, 'orientation'>>(input: Input & {
         readonly endpoints: readonly [ExactEndpointInput<Input['endpoints'][0], IncidentEndpointInput>, ExactEndpointInput<Input['endpoints'][1], IncidentEndpointInput>];
-    }): UndirectedEdgeClassAuthoring<Input>;
+    }): UndirectedEdgeClass<Input>;
 }>;
-export type ClassAuthoringInput<Value extends ClassAuthoring> = Value extends NodeClassAuthoring<infer Config> ? Config : Value extends DirectedEdgeClassAuthoring<infer Input> ? Input : Value extends UndirectedEdgeClassAuthoring<infer Input> ? Input : never;
+export type ClassAuthoringInput<Value extends Class> = Value extends NodeClass<infer Config> ? Config : Value extends DirectedEdgeClass<infer Input> ? Input : Value extends UndirectedEdgeClass<infer Input> ? Input : never;
 /** Internal lowering access; Class authoring handles expose no public configuration object. */
-export declare function classAuthoringInput<const Value extends ClassAuthoring>(value: Value): ClassAuthoringInput<Value>;
+export declare function classAuthoringInput<const Value extends Class>(value: Value): ClassAuthoringInput<Value>;
 export type { MethodRecord };
-//# sourceMappingURL=authoring.d.ts.map

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

@@ -133,4 +133,3 @@ function validateUndirectedEdgeClassOptions(value) {
     if (value.constraints !== undefined)
         assertKnownKeys(value.constraints, ['noSelf']);
 }
-//# sourceMappingURL=authoring.js.map

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

@@ -14,40 +14,39 @@ export interface AutoOptions {
     readonly on: AutoEvent | readonly AutoEvent[];
     readonly set: AutoSet;
 }
-export interface PropertyAuthoring<out Schema extends ValueSchemaInput = ValueSchemaInput, out Options extends PropertyOptions = PropertyOptions> {
+export interface Property<out Schema extends ValueSchemaInput = ValueSchemaInput, out Options extends PropertyOptions = PropertyOptions> {
     readonly [AUTHORING]: 'property';
     readonly [PROPERTY_INPUT]: {
         readonly schema: Schema;
         readonly options: Options;
     };
 }
-export type PropertySchemaOf<Value extends PropertyAuthoring> = Value extends PropertyAuthoring<infer Schema, PropertyOptions> ? Schema : never;
-export type PropertyOptionsOf<Value extends PropertyAuthoring> = Value extends PropertyAuthoring<ValueSchemaInput, infer Options> ? Options : never;
-export interface AutoPropertyAuthoring<out Property extends PropertyAuthoring = PropertyAuthoring> {
+export type PropertySchemaOf<Value extends Property> = Value extends Property<infer Schema, PropertyOptions> ? Schema : never;
+export type PropertyOptionsOf<Value extends Property> = Value extends Property<ValueSchemaInput, infer Options> ? Options : never;
+export interface AutoProperty<out PropertyValue extends Property = Property> {
     readonly [AUTHORING]: 'auto';
     readonly [AUTO_INPUT]: {
-        readonly property: Property;
+        readonly property: PropertyValue;
         readonly options: {
             readonly on: readonly AutoEvent[];
             readonly set: AutoSet;
         };
     };
 }
-export type PropertyAuthoringInput<Value extends PropertyAuthoring> = Value extends PropertyAuthoring<infer Schema, infer Options> ? {
+export type PropertyAuthoringInput<Value extends Property> = Value extends Property<infer Schema, infer Options> ? {
     readonly schema: Schema;
     readonly options: Options;
 } : never;
-export declare function propertyAuthoringInput<const Value extends PropertyAuthoring>(value: Value): PropertyAuthoringInput<Value>;
-export declare function autoPropertyAuthoringInput<const Value extends AutoPropertyAuthoring>(value: Value): Value extends AutoPropertyAuthoring<infer Property> ? {
+export declare function propertyAuthoringInput<const Value extends Property>(value: Value): PropertyAuthoringInput<Value>;
+export declare function autoPropertyAuthoringInput<const Value extends AutoProperty>(value: Value): Value extends AutoProperty<infer Property> ? {
     readonly property: Property;
     readonly options: {
         readonly on: readonly AutoEvent[];
         readonly set: AutoSet;
     };
 } : never;
-export type PropertyFieldInput = ValueSchemaInput | PropertyAuthoring | AutoPropertyAuthoring;
+export type PropertyFieldInput = ValueSchemaInput | Property | AutoProperty;
 export type PropertyRecordInput = Readonly<Record<string, PropertyFieldInput>>;
-export declare function property<const Schema extends ValueSchemaInput, const Options extends PropertyOptions = Record<never, never>>(schema: Schema, options?: Options): PropertyAuthoring<Schema, Options>;
-export declare function auto<const Property extends PropertyAuthoring>(property: Property, options: AutoOptions): AutoPropertyAuthoring<Property>;
+export declare function property<const Schema extends ValueSchemaInput, const Options extends PropertyOptions = Record<never, never>>(schema: Schema, options?: Options): Property<Schema, Options>;
+export declare function auto<const PropertyValue extends Property>(property: PropertyValue, options: AutoOptions): AutoProperty<PropertyValue>;
 export {};
-//# sourceMappingURL=property.d.ts.map

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

@@ -47,4 +47,3 @@ export function auto(property, options) {
         },
     });
 }
-//# sourceMappingURL=property.js.map

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

@@ -1,17 +1,17 @@
 import type { Object as JsonObject } from '@astrale-os/kernel-dsl/value';
 import type { CoreRef } from '../../addressing/index.js';
 import type { DomainEndpointRef } from '../../language/core/model/core.js';
-import type { EdgeClassAuthoring, NodeClassAuthoring } from '../class/authoring.js';
+import type { EdgeClass, NodeClass } from '../class/authoring.js';
 import type { AUTHORING } from '../schema/handle.js';
 import type { Lazy } from '../schema/lazy.js';
 import type { CorePropertyInput } from '../schema/projection.js';
-export interface CoreNodeAuthoring<out Definition extends Lazy<NodeClassAuthoring> = Lazy<NodeClassAuthoring>, out Properties extends JsonObject = CorePropertyInput<Definition> & JsonObject> {
+export interface CoreNode<out Definition extends Lazy<NodeClass> = Lazy<NodeClass>, out Properties extends JsonObject = CorePropertyInput<Definition> & JsonObject> {
     readonly [AUTHORING]: 'core-node';
     readonly class: Definition;
     readonly properties: Properties;
 }
-export type CoreEndpointAuthoring = CoreNodeAuthoring | CoreRef | DomainEndpointRef;
-export interface CoreEdgeAuthoring<out Source extends CoreEndpointAuthoring = CoreEndpointAuthoring, out Definition extends Lazy<EdgeClassAuthoring> = Lazy<EdgeClassAuthoring>, out Target extends CoreEndpointAuthoring = CoreEndpointAuthoring, out Properties extends JsonObject = CorePropertyInput<Definition> & JsonObject> {
+export type CoreEndpoint = CoreNode | CoreRef | DomainEndpointRef;
+export interface CoreEdge<out Source extends CoreEndpoint = CoreEndpoint, out Definition extends Lazy<EdgeClass> = Lazy<EdgeClass>, out Target extends CoreEndpoint = CoreEndpoint, out Properties extends JsonObject = CorePropertyInput<Definition> & JsonObject> {
     readonly [AUTHORING]: 'core-edge';
     readonly source: Source;
     readonly class: Definition;
@@ -19,15 +19,14 @@ export interface CoreEdgeAuthoring<out Source extends CoreEndpointAuthoring = Co
     readonly properties: Properties;
 }
 export interface CoreInput {
-    readonly nodes?: Readonly<Record<string, CoreNodeAuthoring>>;
-    readonly edges?: readonly CoreEdgeAuthoring[];
+    readonly nodes?: Readonly<Record<string, CoreNode>>;
+    readonly edges?: readonly CoreEdge[];
 }
-declare function node<const Definition extends Lazy<NodeClassAuthoring>, const Properties extends CorePropertyInput<Definition> & JsonObject>(definition: Definition, properties: Properties): CoreNodeAuthoring<Definition, Properties>;
-declare function edge<const Source extends CoreEndpointAuthoring, const Definition extends Lazy<EdgeClassAuthoring>, const Target extends CoreEndpointAuthoring, const Properties extends CorePropertyInput<Definition> & JsonObject>(source: Source, definition: Definition, target: Target, properties: Properties): CoreEdgeAuthoring<Source, Definition, Target, Properties>;
+declare function node<const Definition extends Lazy<NodeClass>, const Properties extends CorePropertyInput<Definition> & JsonObject>(definition: Definition, properties: Properties): CoreNode<Definition, Properties>;
+declare function edge<const Source extends CoreEndpoint, const Definition extends Lazy<EdgeClass>, const Target extends CoreEndpoint, const Properties extends CorePropertyInput<Definition> & JsonObject>(source: Source, definition: Definition, target: Target, properties: Properties): CoreEdge<Source, Definition, Target, Properties>;
 export declare const core: Readonly<{
     node: typeof node;
     edge: typeof edge;
     domain: DomainEndpointRef;
 }>;
 export {};
-//# sourceMappingURL=authoring.d.ts.map

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

@@ -17,4 +17,3 @@ function edge(source, definition, target, properties) {
     });
 }
 export const core = Object.freeze({ node, edge, domain });
-//# sourceMappingURL=authoring.js.map

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

@@ -6,20 +6,20 @@ export { path } from './value/path.js';
 export { policy } from './policy/authoring.js';
 export { auto, property } from './class/property.js';
 export { defineSchema } from './schema/define.js';
-export type { DomainOfInput } from './schema/projection.js';
+export type { DefinedSchema } from './schema/define.js';
+export type { DirectDependenciesOf, DomainOfInput } from './schema/projection.js';
 export { valueSchema } from './value/schema.js';
 export { view } from './view/authoring.js';
 export { BuilderError as Error } from './schema/diagnostic.js';
 export type { BuilderDiagnostic as Diagnostic, BuilderDiagnosticCode as DiagnosticCode, } from './schema/diagnostic.js';
-export type { CallableInputBase, CallableInput, CallableOutputInput, CallablePolicyBuilder, CallablePolicyContext, BinaryOutput, FunctionAuthoring as Function, FunctionInput, MethodAuthoring as Method, MethodInput, PolicyObjectInput, StreamOutput, } from './callable/authoring.js';
-export type { CoreEdgeAuthoring as CoreEdge, CoreEndpointAuthoring as CoreEndpoint, CoreInput, CoreNodeAuthoring as CoreNode, } from './core/authoring.js';
-export type { ClassAuthoring as Class, ClassReferenceInput as ClassReference, DirectedEdgeInput, DirectedEdgeClassAuthoring as DirectedEdgeClass, DirectedSourceInput, DirectedTargetInput, EdgeClassCommon, EdgeClassInput, EdgeClassAuthoring as EdgeClass, EdgeClassReferenceInput as EdgeClassReference, IncidentEndpointInput, NodeClassAuthoring as NodeClass, NodeClassInput, NodeClassReferenceInput as NodeClassReference, UndirectedEdgeInput, UndirectedEdgeClassAuthoring as UndirectedEdgeClass, } from './class/authoring.js';
+export type { CallableInputBase, CallableInput, CallableOutputInput, CallablePolicyBuilder, CallablePolicyContext, BinaryOutput, Function, FunctionInput, Method, MethodInput, PolicyObjectInput, StreamOutput, } from './callable/authoring.js';
+export type { CoreEdge, CoreEndpoint, CoreInput, CoreNode } from './core/authoring.js';
+export type { Class, ClassReferenceInput as ClassReference, DirectedEdgeInput, DirectedEdgeClass, DirectedSourceInput, DirectedTargetInput, EdgeClassCommon, EdgeClassInput, EdgeClass, EdgeClassReferenceInput as EdgeClassReference, IncidentEndpointInput, NodeClass, NodeClassInput, NodeClassReferenceInput as NodeClassReference, UndirectedEdgeInput, UndirectedEdgeClass, } from './class/authoring.js';
 export type { PathAuthoring } from './value/path.js';
 export type { Lazy } from './schema/lazy.js';
 export type { MatchPolicyInput, Policy, PolicyBuilder as PolicyFactory, PolicyEdgeInput, PolicyExistsContext, PolicyInput, PolicyPatternContext, } from './policy/authoring.js';
-export type { AutoOptions, AutoPropertyAuthoring as AutoProperty, PropertyAuthoring as Property, PropertyFieldInput as PropertyField, PropertyOptions, ValueSchemaInput, } from './class/property.js';
+export type { AutoOptions, AutoProperty, Property, PropertyFieldInput as PropertyField, PropertyOptions, ValueSchemaInput, } from './class/property.js';
 export type { CorePropertyInput, ResolvedClassOfAuthoring } from './schema/projection.js';
 export type { DomainSchemaInput as SchemaInput } from './schema/input.js';
 export type { TypedValueSchema } from './value/schema.js';
-export type { ViewAuthoring as View, ViewInput } from './view/authoring.js';
-//# sourceMappingURL=index.d.ts.map
+export type { View, ViewInput } from './view/authoring.js';

package/dist/v1/builder/index.js

@@ -9,4 +9,3 @@ export { defineSchema } from './schema/define.js';
 export { valueSchema } from './value/schema.js';
 export { view } from './view/authoring.js';
 export { BuilderError as Error } from './schema/diagnostic.js';
-//# sourceMappingURL=index.js.map

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

@@ -1,6 +1,6 @@
 import type { FunctionRef } from '../../addressing/index.js';
 import type { FunctionDefinition, MethodDefinition } from '../../language/callable/model/callable.js';
-import type { FunctionAuthoring, MethodAuthoring } from '../callable/authoring.js';
+import type { Function, Method } from '../callable/authoring.js';
 import type { BuilderContext } from './schema/context.js';
 import type { BuilderValueSchemas } from './value/compile.js';
 export type CallablePlacement = {
@@ -12,14 +12,13 @@ export type CallablePlacement = {
     readonly pointer: string;
 };
 export interface CallableCompiler {
-    compile(value: FunctionAuthoring | MethodAuthoring, placement: CallablePlacement): FunctionDefinition | MethodDefinition;
+    compile(value: Function | Method, placement: CallablePlacement): FunctionDefinition | MethodDefinition;
 }
 export declare class V1CallableCompiler implements CallableCompiler {
     readonly context: BuilderContext;
     readonly values: BuilderValueSchemas;
     constructor(context: BuilderContext, values: BuilderValueSchemas);
-    compile(value: FunctionAuthoring | MethodAuthoring, placement: CallablePlacement): FunctionDefinition | MethodDefinition;
+    compile(value: Function | Method, placement: CallablePlacement): FunctionDefinition | MethodDefinition;
     private compileOutput;
     private policyContext;
 }
-//# sourceMappingURL=callable.d.ts.map

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

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

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

@@ -1,5 +1,5 @@
 import type { ClassDefinition } from '../../language/class/model/class.js';
-import type { ClassAuthoring } from '../class/authoring.js';
+import type { Class } from '../class/authoring.js';
 import type { CallableCompiler } from './callable.js';
 import type { PolicyCompiler } from './policy.js';
 import type { BuilderContext } from './schema/context.js';
@@ -10,7 +10,7 @@ export declare class V1DefinitionCompiler {
     readonly callables: CallableCompiler;
     readonly policies: PolicyCompiler;
     constructor(context: BuilderContext, values: BuilderValueSchemas, callables: CallableCompiler, policies: PolicyCompiler);
-    compileClass(value: ClassAuthoring, name: string, pointer: string): ClassDefinition;
+    compileClass(value: Class, name: string, pointer: string): ClassDefinition;
     private nodeClass;
     private edgeClass;
     private endpointBase;
@@ -20,4 +20,3 @@ export declare class V1DefinitionCompiler {
     private parents;
     private methods;
 }
-//# sourceMappingURL=class.d.ts.map

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

@@ -127,4 +127,3 @@ function directedConstraints(options) {
 function undirectedConstraints(options) {
     return options.constraints?.noSelf === true ? { noSelf: true } : {};
 }
-//# sourceMappingURL=class.js.map

package/dist/v1/builder/lowering/core-properties.d.ts

@@ -8,4 +8,3 @@ type UnqualifiedDomainSchema = Omit<DomainSchemaIR, 'core'> & {
 /** Lower rich builder shorthand to the canonical full-key Core representation. */
 export declare function canonicalizeCorePropertyKeys(candidate: UnqualifiedDomainSchema, lookup: DomainSchemaLookup): CoreContent;
 export {};
-//# sourceMappingURL=core-properties.d.ts.map

package/dist/v1/builder/lowering/core-properties.js

@@ -74,4 +74,3 @@ function resolveInputKey(input, definition, byName, pointer) {
     }
     fail('BUILDER_CORE_PROPERTY', pointer, `Property ${JSON.stringify(input)} is ambiguous; use one of: ${candidates.join(', ')}.`);
 }
-//# sourceMappingURL=core-properties.js.map

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

@@ -20,4 +20,3 @@ export interface UnqualifiedCoreContent {
     readonly edges: readonly UnqualifiedCoreEdge[];
 }
 export declare function compileCore(input: CoreInput | undefined, context: BuilderContext): UnqualifiedCoreContent;
-//# sourceMappingURL=core.d.ts.map

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

@@ -45,4 +45,3 @@ function compileEdge(value, context, pointer) {
 function resolveEndpoint(value, context, pointer) {
     return context.resolveCoreEndpoint(value, pointer);
 }
-//# sourceMappingURL=core.js.map