@astrale-os/kernel-dsl 0.2.0-beta.9 → 1.0.0-beta.2

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

@@ -1,258 +1,4 @@
-import type { Value as PortableValue } from '@astrale-os/kernel-dsl/value';
-import type { z } from 'zod';
-import type { Revision } from '../../addressing/index.js';
-import type * as domain from '../../domain/model/domain.js';
-import type * as language from '../../language/index.js';
-import type { DomainOfSchema, DomainSchema } from '../../schema/model/schema.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> = Omit<domain.Domain<{
-    readonly [Name in keyof ClassesInputOf<Input>]: ResolvedClassOfAuthoring<Origin, Extract<Name, string>, ClassesInputOf<Input>[Name], Input>;
-}, {
-    readonly [Name in keyof FunctionsInputOf<Input>]: ResolvedFunctionOfAuthoring<Origin, Extract<Name, string>, FunctionsInputOf<Input>[Name]>;
-}, {
-    readonly [Name in keyof PoliciesInputOf<Input>]: language.ResolvedPolicy & {
-        readonly ref: language.PolicyRef<Extract<Name, string>> & {
-            readonly origin: Origin;
-        };
-        readonly key: language.DefinitionKey<Origin, 'policy', Extract<Name, string>>;
-    };
-}, {
-    readonly [Name in keyof ViewsInputOf<Input>]: language.ResolvedView & {
-        readonly ref: language.ViewRef<Extract<Name, string>> & {
-            readonly origin: Origin;
-        };
-        readonly key: language.DefinitionKey<Origin, 'view', Extract<Name, string>>;
-    };
-}, {
-    readonly [Name in keyof CoreNodesInputOf<Input>]: language.ResolvedCoreDefinition & {
-        readonly ref: language.CoreRef<Extract<Name, string>> & {
-            readonly origin: Origin;
-        };
-        readonly key: language.DefinitionKey<Origin, 'core', Extract<Name, string>>;
-    };
-}, Revision>, 'dependencies'> & {
-    readonly dependencies: domain.DependencyDomainNamespace<DirectDependenciesOf<Input>>;
-};
-type DependenciesInputOf<Input extends DomainSchemaInput> = RecordField<Input, 'dependencies'>;
-/**
- * Project exact direct witnesses already carried by dependency Schemas.
- * This intentionally never reopens their authored inputs or computes a typed closure.
- */
-export type DirectDependenciesOf<Input extends DomainSchemaInput> = {
-    readonly [Alias in keyof DependenciesInputOf<Input>]: DependenciesInputOf<Input>[Alias] extends infer Dependency extends DomainSchema ? DomainOfSchema<Dependency> : never;
-};
-export type ResolvedClassOfAuthoring<Origin extends string, Name extends string, Value, Root extends DomainSchemaInput, Seen = Value> = Value extends NodeClass ? language.ResolvedClass<'node', PropertyCollectionOf<Origin, EffectivePropertyEntries<Value>, Root>, MethodCollectionOf<Origin, EffectiveMethodEntries<Value, false>, Root>, MethodCollectionOf<Origin, EffectiveMethodEntries<Value, true>, Root>, PropertyCollectionOf<Origin, OwnPropertyEntries<Value>, Root>, MethodCollectionOf<Origin, OwnMethodEntries<Value, false>, Root>, MethodCollectionOf<Origin, OwnMethodEntries<Value, true>, Root>, Extract<ProjectedClassDefinition<Origin, Name, Value>, language.NodeClassDefinition>, ResolvedParentsOf<Origin, Value, Root, Seen>> & {
-    readonly ref: language.ClassRef<Name> & {
-        readonly origin: Origin;
-    };
-    readonly key: language.DefinitionKey<Origin, 'class', Name>;
-} : Value extends DirectedEdgeClass | UndirectedEdgeClass ? language.ResolvedClass<'edge', PropertyCollectionOf<Origin, EffectivePropertyEntries<Value>, Root>, EmptyMethodCollection, EmptyMethodCollection, PropertyCollectionOf<Origin, OwnPropertyEntries<Value>, Root>, EmptyMethodCollection, EmptyMethodCollection, Extract<ProjectedClassDefinition<Origin, Name, Value>, language.EdgeClassDefinition>, ResolvedParentsOf<Origin, Value, Root, Seen>> & {
-    readonly ref: language.ClassRef<Name> & {
-        readonly origin: Origin;
-    };
-    readonly key: language.DefinitionKey<Origin, 'class', Name>;
-} : never;
-type EmptyMethodCollection = language.ResolvedMethodCollection<Record<never, never>>;
-type AbstractOf<Config> = Config extends {
-    readonly abstract: infer Abstract extends boolean;
-} ? Abstract : false;
-type ConstraintsOf<Options> = Options extends {
-    readonly constraints?: infer Constraints;
-} ? NonNullable<Constraints> : Record<never, never>;
-type ProjectedClassDefinition<Origin extends string, Name extends string, Value> = Value extends NodeClass<infer Config> ? language.NodeClassDefinition & {
-    readonly ref: language.ClassRef<Name> & {
-        readonly origin: Origin;
-    };
-    readonly kind: 'node';
-    readonly abstract: AbstractOf<Config>;
-} : Value extends DirectedEdgeClass<infer Input> ? language.EdgeClassDefinition & {
-    readonly ref: language.ClassRef<Name> & {
-        readonly origin: Origin;
-    };
-    readonly kind: 'edge';
-    readonly abstract: AbstractOf<Input>;
-    readonly orientation: 'directed';
-    readonly endpoints: {
-        readonly source: language.DirectedSourceEndpoint & {
-            readonly role: Input['source']['as'];
-            readonly outgoing: Input['source']['outgoing'];
-        };
-        readonly target: language.DirectedTargetEndpoint & {
-            readonly role: Input['target']['as'];
-            readonly incoming: Input['target']['incoming'];
-        };
-    };
-    readonly constraints: language.DirectedEdgeConstraints & ConstraintsOf<Input>;
-} : Value extends UndirectedEdgeClass<infer Input> ? language.EdgeClassDefinition & {
-    readonly ref: language.ClassRef<Name> & {
-        readonly origin: Origin;
-    };
-    readonly kind: 'edge';
-    readonly abstract: AbstractOf<Input>;
-    readonly orientation: 'undirected';
-    readonly endpoints: readonly [
-        language.IncidentEndpoint & {
-            readonly role: Input['endpoints'][0]['as'];
-            readonly incident: Input['endpoints'][0]['incident'];
-        },
-        language.IncidentEndpoint & {
-            readonly role: Input['endpoints'][1]['as'];
-            readonly incident: Input['endpoints'][1]['incident'];
-        }
-    ];
-    readonly constraints: language.UndirectedEdgeConstraints & ConstraintsOf<Input>;
-} : never;
-type RecordField<Value, Key extends PropertyKey> = Key extends keyof Value ? NonNullable<Value[Key]> extends Readonly<Record<string, unknown>> ? NonNullable<Value[Key]> : Record<never, never> : Record<never, never>;
-type ClassesInputOf<Input extends DomainSchemaInput> = RecordField<Input, 'classes'>;
-type FunctionsInputOf<Input extends DomainSchemaInput> = RecordField<Input, 'functions'>;
-type PoliciesInputOf<Input extends DomainSchemaInput> = RecordField<Input, 'policies'>;
-type ViewsInputOf<Input extends DomainSchemaInput> = RecordField<Input, 'views'>;
-type CoreInputOf<Input extends DomainSchemaInput> = Input extends {
-    readonly core?: infer CoreValue;
-} ? NonNullable<CoreValue> : Record<never, never>;
-type CoreNodesInputOf<Input extends DomainSchemaInput> = RecordField<CoreInputOf<Input>, 'nodes'>;
-type ResolveLazy<Value, Depth extends readonly unknown[] = []> = Depth['length'] extends 32 ? Value : Value extends () => infer Resolved ? ResolveLazy<Resolved, readonly [...Depth, unknown]> : Value;
-type ClassInputOf<Value> = Value extends NodeClass<infer Input> ? Input : Value extends DirectedEdgeClass<infer Input> ? Input : Value extends UndirectedEdgeClass<infer Input> ? Input : never;
-type ParentsOf<Value> = ClassInputOf<Value> extends {
-    readonly extends?: readonly (infer Parent)[];
-} ? ResolveLazy<Parent> : never;
-type ParentInputsOf<Value> = ClassInputOf<Value> extends {
-    readonly extends?: infer Parents extends readonly unknown[];
-} ? Parents : readonly [];
-type ResolvedParentOf<Origin extends string, Parent, Root extends DomainSchemaInput, Seen> = ResolveLazy<Parent> extends infer Resolved ? Resolved extends language.ResolvedClass ? Resolved : LocalNameOf<Root, Resolved> extends infer Name extends string ? Resolved extends Seen ? Resolved extends NodeClass ? language.ResolvedClass<'node'> & {
-    readonly key: language.DefinitionKey<Origin, 'class', Name>;
-} : language.ResolvedClass<'edge'> & {
-    readonly key: language.DefinitionKey<Origin, 'class', Name>;
-} : ResolvedClassOfAuthoring<Origin, Name, Resolved, Root, Seen | Resolved> : never : never;
-type ResolvedParentsOf<Origin extends string, Value, Root extends DomainSchemaInput, Seen> = ResolvedParentTuple<Origin, ParentInputsOf<Value>, Root, Seen>;
-type ResolvedParentTuple<Origin extends string, Parents extends readonly unknown[], Root extends DomainSchemaInput, Seen> = Parents extends readonly [] ? readonly [] : Parents extends readonly [infer Parent, ...infer Rest] ? readonly [
-    ResolvedParentOf<Origin, Parent, Root, Seen>,
-    ...ResolvedParentTuple<Origin, Rest, Root, Seen>
-] : readonly ResolvedParentOf<Origin, Parents[number], Root, Seen>[];
-type Same<Left, Right> = [Left] extends [Right] ? ([Right] extends [Left] ? true : false) : false;
-type LocalNameOf<Root extends DomainSchemaInput, Value> = {
-    [Name in keyof ClassesInputOf<Root>]: Same<ClassesInputOf<Root>[Name], Value> extends true ? Name : never;
-}[keyof ClassesInputOf<Root>];
-type PropertyFieldsOf<Value> = RecordField<ClassInputOf<Value>, 'properties'>;
-interface AuthoredPropertyEntry<Owner, Name extends string, Field> {
-    readonly owner: Owner;
-    readonly name: Name;
-    readonly field: Field;
-}
-type OwnPropertyEntries<Value> = {
-    [Name in keyof PropertyFieldsOf<Value>]: AuthoredPropertyEntry<Value, Extract<Name, string>, PropertyFieldsOf<Value>[Name]>;
-}[keyof PropertyFieldsOf<Value>];
-type ParentPropertyEntries<Parent, Seen> = Parent extends language.ResolvedClass ? language.PropertiesOf<Parent>['byKey'][keyof language.PropertiesOf<Parent>['byKey']] : Parent extends Class ? EffectivePropertyEntries<Parent, Seen> : never;
-type EffectivePropertyEntries<Value, Seen = never> = Value extends Seen ? never : OwnPropertyEntries<Value> | (ParentsOf<Value> extends infer Parent ? Parent extends unknown ? ParentPropertyEntries<Parent, Seen | Value> : never : never);
-type PropertySchemaOf<Field> = Field extends AutoProperty<infer Value> ? PropertySchemaOf<Value> : Field extends Property<infer Schema, PropertyOptions> ? Schema : Field;
-type PropertyOptionsOf<Field> = Field extends AutoProperty<infer Value> ? PropertyOptionsOf<Value> : Field extends Property<ValueSchemaInput, infer Options> ? Options : Record<never, never>;
-type ValueOutputOf<Schema> = Schema extends TypedValueSchema<infer Value> ? Value : Schema extends z.ZodType ? z.output<Schema> : PortableValue;
-type ValueInputOf<Schema> = Schema extends TypedValueSchema<infer Value> ? Value : Schema extends z.ZodType ? z.input<Schema> : PortableValue;
-type PropertyRequiredOf<Field> = PropertyOptionsOf<Field> extends {
-    readonly required: infer Required extends boolean;
-} ? Required : undefined extends ValueInputOf<PropertySchemaOf<Field>> ? false : true;
-export type CorePropertyInput<ClassValue> = ResolveLazy<ClassValue> extends infer Resolved ? Resolved extends Class ? CorePropertyInputFromEntries<EffectivePropertyEntries<Resolved>> : Resolved extends language.ResolvedClass ? language.PropertyInputOf<Resolved> : never : never;
-type PropertyEntryName<Entry> = Entry extends {
-    readonly name: infer Name extends string;
-} ? Name : never;
-type PropertyEntryValue<Entry> = Entry extends language.ResolvedProperty<infer Value, boolean> ? Value : Entry extends AuthoredPropertyEntry<unknown, string, infer Field> ? ValueInputOf<PropertySchemaOf<Field>> : never;
-type PropertyEntryRequired<Entry> = Entry extends language.ResolvedProperty<unknown, infer Required> ? Required : Entry extends AuthoredPropertyEntry<unknown, string, infer Field> ? PropertyRequiredOf<Field> : false;
-type UniquePropertyEntries<Entries> = Entries extends unknown ? IsMultiple<Extract<Entries, {
-    readonly name: PropertyEntryName<Entries>;
-}>> extends true ? never : Entries : never;
-type RequiredPropertyNames<Entries> = UniquePropertyEntries<Entries> extends infer Entry ? Entry extends unknown ? PropertyEntryRequired<Entry> extends true ? PropertyEntryName<Entry> : never : never : never;
-type OptionalPropertyNames<Entries> = Exclude<PropertyEntryName<UniquePropertyEntries<Entries>>, RequiredPropertyNames<Entries>>;
-type CorePropertyInputFromEntries<Entries> = Readonly<({
-    [Name in RequiredPropertyNames<Entries>]: PropertyEntryValue<Extract<UniquePropertyEntries<Entries>, {
-        readonly name: Name;
-    }>>;
-} & {
-    [Name in OptionalPropertyNames<Entries>]?: PropertyEntryValue<Extract<UniquePropertyEntries<Entries>, {
-        readonly name: Name;
-    }>>;
-}) | Record<language.PropertyKey, language.PropertyValue>>;
-type ProjectedProperty<Origin extends string, Entry, Root extends DomainSchemaInput> = Entry extends language.ResolvedProperty ? Entry : Entry extends AuthoredPropertyEntry<infer Owner, infer Name, infer Field> ? LocalNameOf<Root, Owner> extends infer OwnerName extends string ? language.ResolvedProperty<ValueOutputOf<PropertySchemaOf<Field>>, PropertyRequiredOf<Field>> & {
-    readonly name: Name;
-    readonly key: language.PropertyKey<Origin, OwnerName, Name>;
-} : never : never;
-type ProjectedPropertyUnion<Origin extends string, Entries, Root extends DomainSchemaInput> = Entries extends unknown ? ProjectedProperty<Origin, Entries, Root> : never;
-type UnionIsMultiple<Value, Whole = Value> = Value extends unknown ? [Whole] extends [Value] ? false : true : never;
-type IsMultiple<Value> = true extends UnionIsMultiple<Value> ? true : false;
-type PropertyByKey<Origin extends string, Entries, Root extends DomainSchemaInput> = Readonly<{
-    [Key in ProjectedPropertyUnion<Origin, Entries, Root>['key']]: Extract<ProjectedPropertyUnion<Origin, Entries, Root>, {
-        readonly key: Key;
-    }>;
-}>;
-type PropertyByName<Origin extends string, Entries, Root extends DomainSchemaInput> = Readonly<{
-    [Name in ProjectedPropertyUnion<Origin, Entries, Root>['name'] as IsMultiple<Extract<ProjectedPropertyUnion<Origin, Entries, Root>, {
-        readonly name: Name;
-    }>> extends true ? never : Name extends PropertyCollectionOperation ? never : Name]: Extract<ProjectedPropertyUnion<Origin, Entries, Root>, {
-        readonly name: Name;
-    }>;
-}>;
-type PropertyCollectionOperation = 'byKey' | 'get' | 'from';
-type PropertyCollectionOf<Origin extends string, Entries, Root extends DomainSchemaInput> = language.ResolvedPropertyCollection<PropertyByKey<Origin, Entries, Root>, PropertyByName<Origin, Entries, Root>>;
-type MethodFieldsOf<Value> = RecordField<ClassInputOf<Value>, 'methods'>;
-interface AuthoredMethodEntry<Owner, Name extends string, Value extends Method> {
-    readonly owner: Owner;
-    readonly name: Name;
-    readonly value: Value;
-}
-type OwnMethodEntries<Value, Static extends boolean> = {
-    [Name in keyof MethodFieldsOf<Value>]: MethodFieldsOf<Value>[Name] extends infer MethodValue extends Method ? CallableConfig<MethodValue> extends {
-        readonly static: true;
-    } ? Static extends true ? AuthoredMethodEntry<Value, Extract<Name, string>, MethodValue> : never : Static extends false ? AuthoredMethodEntry<Value, Extract<Name, string>, MethodValue> : never : never;
-}[keyof MethodFieldsOf<Value>];
-type ParentMethodEntries<Parent, Static extends boolean, Seen> = Parent extends language.ResolvedClass<'node'> ? Static extends true ? language.StaticMethodsOf<Parent>['byKey'][keyof language.StaticMethodsOf<Parent>['byKey']] : language.MethodsOf<Parent>['byKey'][keyof language.MethodsOf<Parent>['byKey']] : Parent extends NodeClass ? EffectiveMethodEntries<Parent, Static, Seen> : never;
-type RemoveMethodNames<Entries, Names> = Entries extends {
-    readonly name: infer Name;
-} ? Name extends Names ? never : Entries : never;
-type EffectiveMethodEntries<Value, Static extends boolean, Seen = never> = Value extends Seen ? never : OwnMethodEntries<Value, Static> extends infer Own ? Own | RemoveMethodNames<ParentsOf<Value> extends infer Parent ? Parent extends unknown ? ParentMethodEntries<Parent, Static, Seen | Value> : never : never, Own extends {
-    readonly name: infer Name;
-} ? Name : never> : never;
-type CallableConfig<Value> = Value extends Method<infer Config> ? Config : Value extends Function<infer Config> ? Config : never;
-type CallableInputValue<Value extends Method | Function> = ValueInputOf<CallableConfig<Value>['input']>;
-type CallableOutputValue<Value extends Method | Function> = CallableConfig<Value>['output'] extends StreamOutput<infer Item> ? {
-    readonly mode: 'stream';
-    readonly item: ValueOutputOf<Item>;
-} : CallableConfig<Value>['output'] extends BinaryOutput ? {
-    readonly mode: 'binary';
-} : {
-    readonly mode: 'value';
-    readonly value: ValueOutputOf<CallableConfig<Value>['output']>;
-};
-type ProjectedMethod<Origin extends string, Entry, Root extends DomainSchemaInput> = Entry extends language.ResolvedMethod ? Entry : Entry extends AuthoredMethodEntry<infer Owner, infer Name, infer Value> ? LocalNameOf<Root, Owner> extends infer OwnerName extends string ? language.ResolvedMethod<CallableInputValue<Value>, CallableOutputValue<Value>, CallableStaticOf<Value>, CallableInheritanceOf<Value>, CallableAuthOf<Value>, CallablePolicyOf<Value>, language.MethodKey<Origin, OwnerName, Name>> & {
-    readonly name: Name;
-} : never : never;
-type CallableStaticOf<Value extends Method> = CallableConfig<Value> extends {
-    readonly static: true;
-} ? true : false;
-type CallableInheritanceOf<Value extends Method> = CallableConfig<Value> extends {
-    readonly inheritance: infer Inheritance extends language.MethodInheritance;
-} ? Inheritance : 'default';
-type CallableAuthOf<Value extends Method | Function> = CallableConfig<Value>['auth'];
-type CallablePolicyOf<Value extends Method | Function> = CallableAuthOf<Value> extends 'authorized' ? language.PolicyCheckExpression : never;
-type ProjectedMethodUnion<Origin extends string, Entries, Root extends DomainSchemaInput> = Entries extends unknown ? ProjectedMethod<Origin, Entries, Root> : never;
-type MethodByKey<Origin extends string, Entries, Root extends DomainSchemaInput> = Readonly<{
-    [Key in ProjectedMethodUnion<Origin, Entries, Root>['key']]: Extract<ProjectedMethodUnion<Origin, Entries, Root>, {
-        readonly key: Key;
-    }>;
-}>;
-type MethodByName<Origin extends string, Entries, Root extends DomainSchemaInput> = Readonly<{
-    [Name in ProjectedMethodUnion<Origin, Entries, Root>['name'] as Name extends MethodCollectionOperation ? never : Name]: Extract<ProjectedMethodUnion<Origin, Entries, Root>, {
-        readonly name: Name;
-    }>;
-}>;
-type MethodCollectionOperation = 'byKey' | 'get';
-type MethodCollectionOf<Origin extends string, Entries, Root extends DomainSchemaInput> = language.ResolvedMethodCollection<MethodByKey<Origin, Entries, Root>, MethodByName<Origin, Entries, Root>>;
-type ResolvedFunctionOfAuthoring<Origin extends string, Name extends string, Value> = Value extends Function ? language.ResolvedFunction<CallableInputValue<Value>, CallableOutputValue<Value>, CallableAuthOf<Value>, CallablePolicyOf<Value>> & {
-    readonly ref: language.FunctionRef<Name> & {
-        readonly origin: Origin;
-    };
-    readonly key: language.DefinitionKey<Origin, 'function', Name>;
-} : never;
-export {};
+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/builder/value/full-match.js

@@ -1,11 +1,14 @@
-import { isIRegexp } from '../../language/value/regexp/syntax.js';
+import { refuseIRegexp, stateBudgetMessage } from '../../language/value/regexp/syntax.js';
 import { fullMatch as languageFullMatch, } from '../../language/value/syntax/full-match.js';
 import { fail } from '../schema/diagnostic.js';
 export { fullMatchSource } from '../../language/value/syntax/full-match.js';
 /** Authoring facade preserving the Builder-owned diagnostic for invalid source syntax. */
 export function fullMatch(source) {
-    if (!isIRegexp(source)) {
-        fail('BUILDER_FULL_MATCH_INVALID', '/fullMatch', 'fullMatch(...) requires a complete RFC 9485 I-Regexp source.');
+    const refusal = refuseIRegexp(source);
+    if (refusal !== undefined) {
+        fail('BUILDER_FULL_MATCH_INVALID', '/fullMatch', refusal === 'syntax'
+            ? 'fullMatch(...) requires a complete RFC 9485 I-Regexp source.'
+            : stateBudgetMessage('fullMatch(...)'));
     }
     return languageFullMatch(source);
 }

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

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

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

@@ -1,11 +1,11 @@
-import { z } from 'zod';
+import { string } from 'zod';
 import { fail } from '../schema/diagnostic.js';
 import { rememberPath } from './path-metadata.js';
 export function path(...accepts) {
     if (accepts.length === 0) {
         fail('BUILDER_PATH_EMPTY', '', 'path(...) requires at least one Node Definition.');
     }
-    const schema = z.string();
+    const schema = string();
     rememberPath(schema, accepts);
     return schema;
 }

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

@@ -1,21 +1,13 @@
-import type { NodeClassReferenceInput } from '../class/authoring.js';
 import type { AUTHORING } from '../schema/handle.js';
-declare const VIEW_INPUT: unique symbol;
-export type ViewDefinitionTargetsInput = readonly [
-    NodeClassReferenceInput,
-    ...NodeClassReferenceInput[]
-];
-export type ViewTargetInput = 'domain' | NodeClassReferenceInput | ViewDefinitionTargetsInput;
+/** A View always targets its owning Domain; it declares no Class or Node target. */
 export interface ViewInput {
     readonly description?: string;
-    readonly target?: ViewTargetInput;
+    /** Removed: every View targets its owning Domain. Refused at compile time and at runtime. */
+    readonly target?: never;
 }
-export interface View<out Config extends ViewInput = ViewInput> {
+export interface View {
     readonly [AUTHORING]: 'view';
-    readonly [VIEW_INPUT]: Config;
 }
-export type ViewAuthoringInput<Value extends View> = Value extends View<infer Config> ? Config : never;
 /** Internal lowering access; View authoring handles expose no public configuration object. */
-export declare function viewAuthoringInput<const Value extends View>(value: Value): ViewAuthoringInput<Value>;
-export declare function view<const Config extends ViewInput>(config: Config & Record<Exclude<keyof Config, keyof ViewInput>, never>): View<Config>;
-export {};
+export declare function viewAuthoringInput(value: View): ViewInput;
+export declare function view<const Config extends ViewInput>(config: Config & Record<Exclude<keyof Config, keyof ViewInput>, never>): View;

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

@@ -1,11 +1,19 @@
-import { assertKnownKeys } from '../schema/diagnostic.js';
+import { assertKnownKeys, fail } from '../schema/diagnostic.js';
 import { authoringValue } from '../schema/handle.js';
-const VIEW_INPUT = Symbol('astrale.v1.view-input');
+const viewInputs = new WeakMap();
 /** Internal lowering access; View authoring handles expose no public configuration object. */
 export function viewAuthoringInput(value) {
-    return value[VIEW_INPUT];
+    const input = viewInputs.get(value);
+    if (input === undefined)
+        throw new TypeError('Unknown View authoring handle.');
+    return input;
 }
 export function view(config) {
-    assertKnownKeys(config, ['description', 'target']);
-    return authoringValue('view', { [VIEW_INPUT]: { ...config } });
+    if (Object.hasOwn(config, 'target')) {
+        fail('BUILDER_VIEW', '/target', 'View target is removed: every View targets its owning Domain. Select a Node inside the View frontend instead.');
+    }
+    assertKnownKeys(config, ['description']);
+    const value = authoringValue('view', {});
+    viewInputs.set(value, { ...config });
+    return value;
 }

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;