@astrale-os/kernel-dsl 0.2.0-beta.47 → 0.2.0-beta.48

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

@@ -0,0 +1,32 @@
+import type * as language from '../../../language/index.js';
+import type { AuthoredPropertyProjection } from '../../class/authoring.js';
+import type { DomainSchemaInput } from '../input.js';
+import type { RecordField, ClassInputOf, OwnerNameOf } from './identity.js';
+import type { PropertyProjection } from './model.js';
+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 PropertyProjectionOfResolved<Value> = Value extends language.ResolvedProperty<infer PropertyValue, infer Required, infer State, infer Input> & {
+    readonly name: infer Name extends string;
+    readonly key: infer Key extends language.PropertyKey;
+} ? PropertyProjection<PropertyValue, Required, Name, Key, State, Input> : never;
+/** Capture every Property by its unambiguous qualified key. */
+export type PropertiesOfCollection<Value> = Value extends {
+    readonly byKey: infer ByKey extends Readonly<Record<language.PropertyKey, language.ResolvedProperty<unknown, boolean>>>;
+} ? PropertyProjectionOfResolved<ByKey[keyof ByKey]> : never;
+/** Project Properties declared directly by one Class. */
+export type OwnPropertyProjectionsOf<Origin extends string, Name extends string, Value> = OwnPropertyEntries<Value> extends infer Entry ? Entry extends AuthoredPropertyEntry<unknown, infer PropertyName, infer Field> ? Field extends AuthoredPropertyProjection<infer Input, infer Output, infer Required, string, unknown, infer State> ? PropertyProjection<Output, Required, PropertyName, language.PropertyKey<Origin, Name, PropertyName>, State, Input> : never : never : never;
+/** Select the flat effective Property witnesses of a Class handle. */
+export type EffectivePropertyEntriesOfClass<Value> = ClassInputOf<Value> extends {
+    readonly effectiveProperties: infer Properties;
+} ? Properties : never;
+type EffectivePropertyProjectionOfEntry<Origin extends string, CurrentName extends string, Root extends DomainSchemaInput, Entry> = Entry extends language.ResolvedProperty ? PropertyProjectionOfResolved<Entry> : Entry extends AuthoredPropertyProjection<infer Input, infer Output, infer Required, infer PropertyName, infer Owner, infer State> ? OwnerNameOf<Root, CurrentName, Owner> extends infer OwnerName extends string ? PropertyProjection<Output, Required, PropertyName, language.PropertyKey<Origin, OwnerName, PropertyName>, State, Input> : never : never;
+/** Bind effective Property witnesses to their declaring Class coordinates. */
+export type EffectivePropertyProjectionsOf<Origin extends string, Name extends string, Value, Root extends DomainSchemaInput> = EffectivePropertyEntriesOfClass<Value> extends infer Entry ? Entry extends unknown ? EffectivePropertyProjectionOfEntry<Origin, Name, Root, Entry> : never : never;
+export {};

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

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

package/dist/v1/builder/schema/projection/resolved-class.d.ts

@@ -0,0 +1,76 @@
+import type * as language from '../../../language/index.js';
+import type { MethodsOfCollection } from './callable.js';
+import type { IsMultiple } from './identity.js';
+import type { ClassProjection, PropertyProjection, MethodProjection } from './model.js';
+import type { PropertiesOfCollection } from './property.js';
+type EmptyMethodCollection = language.ResolvedMethodCollection<Record<never, never>>;
+/** Retain exact dependency Class contracts with one shallow parent layer. */
+export type ClassProjectionOfResolved<Value> = Value extends language.AnyResolvedClass ? ResolvedClassProjection<Value, ShallowClassProjectionTupleOfResolved<Value['extends']>> : never;
+type ShallowClassProjectionOfResolved<Value> = ResolvedClassProjection<Value, readonly language.AnyResolvedClass[]>;
+type ResolvedClassProjection<Value, Parents extends readonly unknown[]> = Value extends language.AnyResolvedClass & {
+    readonly ref: infer Ref extends language.ClassRef;
+    readonly key: infer Key extends language.DefinitionKey<string, 'class'>;
+} ? ClassProjection<Value['kind'], Extract<Value['definition'], Extract<language.ClassDefinition, {
+    readonly kind: Value['kind'];
+}>>, Ref, Key, Parents, PropertiesOfCollection<Value['properties']>, MethodsOfCollection<Value['methods']>, MethodsOfCollection<Value['static']['methods']>, PropertiesOfCollection<Value['self']['properties']>, MethodsOfCollection<Value['self']['methods']>, MethodsOfCollection<Value['self']['static']['methods']>> : never;
+type ShallowClassProjectionTupleOfResolved<Parents extends readonly unknown[]> = Parents extends readonly [] ? readonly [] : Parents extends readonly [infer Parent, ...infer Rest] ? readonly [
+    ShallowClassProjectionOfResolved<ExactClass<Parent>>,
+    ...ShallowClassProjectionTupleOfResolved<Rest>
+] : readonly ShallowClassProjectionOfResolved<ExactClass<Parents[number]>>[];
+/** Keep only Classes whose origin and declaration name remain literal. */
+export type ExactClass<Value> = Value extends {
+    readonly key: infer Key extends language.DefinitionKey<string, 'class'>;
+} ? Key extends `${infer Origin}:class.${infer Name}` ? string extends Origin ? never : string extends Name ? never : Value : never : never;
+type ResolvedParentTupleOfProjection<Parents extends readonly unknown[]> = Parents extends readonly [] ? readonly [] : Parents extends readonly [infer Parent, ...infer Rest] ? readonly [
+    Parent extends ClassProjection ? ResolvedClassOfProjection<Parent> : Extract<Parent, language.AnyResolvedClass>,
+    ...ResolvedParentTupleOfProjection<Rest>
+] : readonly (Parents[number] extends ClassProjection ? ResolvedClassOfProjection<Parents[number]> : Extract<Parents[number], language.AnyResolvedClass>)[];
+/** Restore the resolved Class surface from its compact witness. */
+export type ResolvedClassOfProjection<Value extends ClassProjection> = Value extends ClassProjection<infer Kind, infer Definition, infer Ref, infer Key, infer Parents, infer Properties, infer InstanceMethods, infer StaticMethods, infer SelfProperties, infer SelfInstanceMethods, infer SelfStaticMethods> ? Key extends `${infer Origin}:class.${infer Name}` ? string extends Origin ? language.AnyResolvedClass : string extends Name ? language.AnyResolvedClass : ResolvedClassWithKind<Kind, Definition, Ref, Key, Parents, SelfProperties, SelfInstanceMethods, SelfStaticMethods, Properties, InstanceMethods, StaticMethods> : language.AnyResolvedClass : language.AnyResolvedClass;
+type ResolvedClassWithKind<Kind extends language.ClassKind, Definition extends Extract<language.ClassDefinition, {
+    readonly kind: Kind;
+}>, Ref extends language.ClassRef, Key extends language.DefinitionKey<string, 'class'>, Parents extends readonly unknown[], SelfProperties extends PropertyProjection, SelfInstanceMethods extends MethodProjection, SelfStaticMethods extends MethodProjection, Properties extends PropertyProjection, InstanceMethods extends MethodProjection, StaticMethods extends MethodProjection> = Kind extends 'node' ? language.ResolvedClass<'node', PropertyCollectionOfProjection<Properties>, MethodCollectionOfProjection<InstanceMethods>, MethodCollectionOfProjection<StaticMethods>, PropertyCollectionOfProjection<SelfProperties>, MethodCollectionOfProjection<SelfInstanceMethods>, MethodCollectionOfProjection<SelfStaticMethods>, Extract<Definition, language.NodeClassDefinition>, ResolvedParentTupleOfProjection<Parents>> & {
+    readonly ref: Ref;
+    readonly key: Key;
+} : Kind extends 'edge' ? language.ResolvedClass<'edge', PropertyCollectionOfProjection<Properties>, EmptyMethodCollection, EmptyMethodCollection, PropertyCollectionOfProjection<SelfProperties>, EmptyMethodCollection, EmptyMethodCollection, Extract<Definition, language.EdgeClassDefinition>, ResolvedParentTupleOfProjection<Parents>> & {
+    readonly ref: Ref;
+    readonly key: Key;
+} : never;
+type PropertyCollectionOperation = 'byKey' | 'get' | 'from';
+type ResolvedPropertyOfProjection<Value> = Value extends PropertyProjection<infer PropertyValue, infer Required, infer Name, infer Key, infer State, infer Input> ? language.ResolvedProperty<PropertyValue, Required, State, Input> & {
+    readonly name: Name;
+    readonly key: Key;
+} : never;
+type ProjectionPropertyByKey<Entries extends PropertyProjection> = Readonly<{
+    [Key in Entries['key']]: ResolvedPropertyOfProjection<Extract<Entries, {
+        readonly key: Key;
+    }>>;
+}>;
+type ProjectionPropertyByName<Entries extends PropertyProjection> = Readonly<{
+    [Name in Entries['name'] as IsMultiple<Extract<Entries, {
+        readonly name: Name;
+    }>> extends true ? never : Name extends PropertyCollectionOperation ? never : Name]: ResolvedPropertyOfProjection<Extract<Entries, {
+        readonly name: Name;
+    }>>;
+}>;
+/** Restore qualified lookup and unambiguous named Property access. */
+type PropertyCollectionOfProjection<Entries extends PropertyProjection> = language.ResolvedPropertyCollection<ProjectionPropertyByKey<Entries>, ProjectionPropertyByName<Entries>>;
+type MethodCollectionOperation = 'byKey' | 'get';
+type ResolvedMethodOfProjection<Value> = Value extends MethodProjection<infer Input, infer Output, infer Static, infer Abstract, infer Auth, infer Name, infer Key, infer Executable, infer Execution> ? language.ResolvedMethod<Input, Output, Static, Abstract, Auth, language.PolicyCheckExpression, Key> & {
+    readonly name: Name;
+    readonly executable: Executable;
+    readonly execution: Execution;
+} : never;
+type ProjectionMethodByKey<Entries extends MethodProjection> = Readonly<{
+    [Key in Entries['key']]: ResolvedMethodOfProjection<Extract<Entries, {
+        readonly key: Key;
+    }>>;
+}>;
+type ProjectionMethodByName<Entries extends MethodProjection> = Readonly<{
+    [Name in Entries['name'] as Name extends MethodCollectionOperation ? never : Name]: ResolvedMethodOfProjection<Extract<Entries, {
+        readonly name: Name;
+    }>>;
+}>;
+/** Restore qualified Method lookup and permitted named shortcuts. */
+type MethodCollectionOfProjection<Entries extends MethodProjection> = language.ResolvedMethodCollection<ProjectionMethodByKey<Entries>, ProjectionMethodByName<Entries>>;
+export {};

package/dist/v1/builder/schema/projection/resolved-class.js

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

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

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

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

@@ -1,7 +1,8 @@
 import type { Value as JsonValue } from '@astrale-os/kernel-dsl/value';
 import type { DomainSchemaIR } from '../schema/model/schema.js';
-export interface DomainSchemaBundleStructure {
+interface DomainSchemaBundleStructure {
     readonly root: DomainSchemaIR;
     readonly closure: readonly DomainSchemaIR[];
 }
 export declare function parseDomainSchemaBundleStructure(input: JsonValue): DomainSchemaBundleStructure;
+export {};

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

@@ -1,3 +1,3 @@
-import type { CompiledSchema } from '../model/schema.js';
+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;