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

package/dist/v1/language/class/facets.d.ts

@@ -0,0 +1,58 @@
+import type { CallableInputOf, CallableOutputOf, ResolvedMethod, ResolvedMethodCollection } from '../callable/resolved.js';
+import type { ResolvedProperty, ResolvedPropertyCollection } from './resolved.js';
+type MemberName = string | number | symbol;
+type ValueAt<Collection, Key> = Key extends keyof Collection ? Collection[Key] : never;
+type PropertyCollectionOf<Class> = Class extends {
+    readonly properties: infer Properties;
+} ? Properties : never;
+type PropertyByKeyOf<Class> = PropertyCollectionOf<Class> extends {
+    readonly byKey: infer ByKey extends Readonly<Record<string, ResolvedProperty>>;
+} ? ByKey : Readonly<Record<never, never>>;
+type PropertyByNameOf<Class> = Pick<PropertyCollectionOf<Class>, Exclude<keyof PropertyCollectionOf<Class>, keyof ResolvedPropertyCollection>>;
+type MethodCollectionOf<Class> = Class extends {
+    readonly kind: 'node';
+    readonly methods: infer Methods extends ResolvedMethodCollection;
+} ? Methods : ResolvedMethodCollection<Record<never, never>>;
+type MethodByKeyOf<Class> = MethodCollectionOf<Class> extends {
+    readonly byKey: infer ByKey extends Readonly<Record<string, ResolvedMethod>>;
+} ? ByKey : Readonly<Record<never, never>>;
+type MethodByNameOf<Class> = Pick<MethodCollectionOf<Class>, Exclude<keyof MethodCollectionOf<Class>, keyof ResolvedMethodCollection>>;
+export type PropertyOutputOf<Property> = Property extends ResolvedProperty<infer Value, infer Required> ? Required extends true ? Value : Value | undefined : never;
+/** Collision-safe direct Property values. Client supplies graph/wrapper reserved names. */
+export type PropertyShortcutsOf<Class, Reserved extends MemberName = never> = Readonly<{
+    [Name in Exclude<keyof PropertyByNameOf<Class>, keyof MethodByNameOf<Class> | Reserved>]: PropertyOutputOf<ValueAt<PropertyByNameOf<Class>, Name>>;
+}>;
+type EffectiveProperty<Class> = PropertyByKeyOf<Class>[keyof PropertyByKeyOf<Class>];
+/** Exact and unambiguous Property access signatures, independent of graph values. */
+export type PropertyAccessOf<Class> = {
+    readonly property: {
+        <Property extends EffectiveProperty<Class>>(property: Property): PropertyOutputOf<Property>;
+        <Key extends keyof PropertyByKeyOf<Class>>(key: Key): PropertyOutputOf<PropertyByKeyOf<Class>[Key]>;
+        <Name extends keyof PropertyByNameOf<Class>>(name: Name): PropertyOutputOf<PropertyByNameOf<Class>[Name]>;
+    };
+};
+export type CallableResultOf<Callable, Binary = unknown> = CallableOutputOf<Callable> extends infer Output ? Output extends {
+    readonly mode: 'value';
+    readonly value: infer Value;
+} ? Value : Output extends {
+    readonly mode: 'stream';
+    readonly item: infer Item;
+} ? AsyncIterable<Item> : Output extends {
+    readonly mode: 'binary';
+} ? Binary : never : never;
+type ExecutableMethod<Method> = Method extends ResolvedMethod<unknown, unknown, false, infer Inheritance> ? Inheritance extends 'abstract' ? never : Method : never;
+export type BoundMethodOf<Method, Binary = unknown> = ExecutableMethod<Method> extends infer Callable ? [Callable] extends [never] ? never : (input: CallableInputOf<Callable>) => Promise<CallableResultOf<Callable, Binary>> : never;
+/** Collision-safe direct bound Methods. Client supplies graph/wrapper reserved names. */
+export type BoundMethodShortcutsOf<Class, Binary = unknown, Reserved extends MemberName = never> = Readonly<{
+    [Name in Exclude<keyof MethodByNameOf<Class>, keyof PropertyByNameOf<Class> | Reserved> as BoundMethodOf<ValueAt<MethodByNameOf<Class>, Name>, Binary> extends never ? never : Name]: BoundMethodOf<ValueAt<MethodByNameOf<Class>, Name>, Binary>;
+}>;
+type EffectiveMethod<Class> = MethodByKeyOf<Class>[keyof MethodByKeyOf<Class>];
+/** Exact and unambiguous bound Method access signatures, independent of Client provenance. */
+export type MethodAccessOf<Class, Binary = unknown> = {
+    readonly method: {
+        <Method extends EffectiveMethod<Class>>(method: Method): BoundMethodOf<Method, Binary>;
+        <Key extends keyof MethodByKeyOf<Class>>(key: Key): BoundMethodOf<MethodByKeyOf<Class>[Key], Binary>;
+        <Name extends keyof MethodByNameOf<Class>>(name: Name): BoundMethodOf<MethodByNameOf<Class>[Name], Binary>;
+    };
+};
+export {};

package/dist/v1/language/class/facets.js

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

package/dist/v1/language/class/index.d.ts

@@ -0,0 +1,8 @@
+export type * from './model/class.js';
+export type * from './model/data.js';
+export type * from './model/edge.js';
+export type * from './model/property.js';
+export { PropertyValues } from './property-values.js';
+export type { PropertyValuesOperations } from './property-values.js';
+export type * from './facets.js';
+export type * from './resolved.js';

package/dist/v1/language/class/index.js

@@ -0,0 +1 @@
+export { PropertyValues } from './property-values.js';

package/dist/v1/language/class/model/class.d.ts

@@ -0,0 +1,36 @@
+import type { ClassRef, DefinitionBase, PolicyRef } from '../../../addressing/index.js';
+import type { MethodRecord } from '../../callable/model/callable.js';
+import type { DataFacet } from './data.js';
+import type { EdgeContract } from './edge.js';
+import type { PropertyFacet } from './property.js';
+export type ClassKind = 'node' | 'edge';
+export interface NodeClassPolicies {
+    readonly read?: PolicyRef;
+    readonly traverse?: PolicyRef;
+}
+export interface EdgeClassPolicies {
+    readonly traverse?: PolicyRef;
+}
+export interface NodeClassDefinition extends DefinitionBase<ClassRef>, PropertyFacet, DataFacet {
+    readonly kind: 'node';
+    readonly abstract: boolean;
+    readonly description?: string;
+    readonly extends: readonly ClassRef[];
+    readonly methods: MethodRecord;
+    readonly icon?: string;
+    readonly policies: NodeClassPolicies;
+}
+export type EdgeClassDefinition = DefinitionBase<ClassRef> & PropertyFacet & EdgeContract & {
+    readonly kind: 'edge';
+    readonly abstract: boolean;
+    readonly description?: string;
+    readonly extends: readonly ClassRef[];
+    readonly policies: EdgeClassPolicies;
+};
+export type ClassDefinition = NodeClassDefinition | EdgeClassDefinition;
+export type DirectedEdgeDefinition = Extract<EdgeClassDefinition, {
+    readonly orientation: 'directed';
+}>;
+export type UndirectedEdgeDefinition = Extract<EdgeClassDefinition, {
+    readonly orientation: 'undirected';
+}>;

package/dist/v1/language/class/model/class.js

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

package/dist/v1/{schema/definition → language/class/model}/data.d.ts

@@ -3,10 +3,9 @@ import type { Object as JsonObject } from '@astrale-os/kernel-dsl/value';
 export declare const MEDIA_TYPE_PATTERN: RegExp;
 export type MediaType = string;
 /** Schema-level contract for one externally stored Node payload. */
-export type DataDeclaration = JsonObject & {
+export type DataDefinition = JsonObject & {
     readonly mediaType: MediaType;
 };
 export interface DataFacet {
-    readonly data?: DataDeclaration;
+    readonly data?: DataDefinition;
 }
-//# sourceMappingURL=data.d.ts.map

package/dist/v1/{schema/definition → language/class/model}/data.js

@@ -1,3 +1,2 @@
 /** Canonical lowercase RFC 6838 media type without parameters. */
 export const MEDIA_TYPE_PATTERN = /^[a-z0-9][a-z0-9!#$&^_.+-]{0,126}\/[a-z0-9][a-z0-9!#$&^_.+-]{0,126}$/u;
-//# sourceMappingURL=data.js.map

package/dist/v1/{schema/definition → language/class/model}/edge.d.ts

@@ -1,9 +1,9 @@
-import type { DefinitionRef } from '../reference.js';
+import type { ClassRef } from '../../../addressing/index.js';
 export type EdgeCount = '0..*' | '1..*' | '0..1' | '1';
 export type EdgeOrientation = 'directed' | 'undirected';
 export interface EdgeEndpointBase {
     readonly role: string;
-    readonly accepts: readonly DefinitionRef[];
+    readonly accepts: readonly ClassRef[];
 }
 export interface DirectedSourceEndpoint extends EdgeEndpointBase {
     readonly outgoing: EdgeCount;
@@ -14,22 +14,25 @@ export interface DirectedTargetEndpoint extends EdgeEndpointBase {
 export interface IncidentEndpoint extends EdgeEndpointBase {
     readonly incident: EdgeCount;
 }
-export interface EdgeConstraints {
+export interface DirectedEdgeConstraints {
     readonly noSelf?: true;
     readonly acyclic?: true;
 }
+export interface UndirectedEdgeConstraints {
+    readonly noSelf?: true;
+    readonly acyclic?: never;
+}
 export interface DirectedEdgeContract {
     readonly orientation: 'directed';
     readonly endpoints: {
         readonly source: DirectedSourceEndpoint;
         readonly target: DirectedTargetEndpoint;
     };
-    readonly constraints: EdgeConstraints;
+    readonly constraints: DirectedEdgeConstraints;
 }
 export interface UndirectedEdgeContract {
     readonly orientation: 'undirected';
     readonly endpoints: readonly [IncidentEndpoint, IncidentEndpoint];
-    readonly constraints: EdgeConstraints;
+    readonly constraints: UndirectedEdgeConstraints;
 }
 export type EdgeContract = DirectedEdgeContract | UndirectedEdgeContract;
-//# sourceMappingURL=edge.d.ts.map

package/dist/v1/language/class/model/edge.js

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

package/dist/v1/{schema/definition → language/class/model}/property.d.ts

@@ -1,4 +1,3 @@
-import type { PropertyObjectSchema } from '../value/schema.js';
 export type PropertyVisibility = 'public' | 'private';
 export type AutoEvent = 'create' | 'update';
 export type AutoSet = 'instant';
@@ -6,13 +5,14 @@ export interface PropertyAuto {
     readonly on: readonly AutoEvent[];
     readonly set: AutoSet;
 }
-export interface PropertyMetadata {
+export interface PropertyDefinition {
+    readonly schema: import('../../value/model/schema.js').JsonSchema;
+    readonly required: boolean;
     readonly visibility: PropertyVisibility;
     readonly auto?: PropertyAuto;
+    readonly description?: string;
 }
-export type PropertyMetadataRecord = Readonly<Record<string, PropertyMetadata>>;
+export type PropertyRecord = Readonly<Record<string, PropertyDefinition>>;
 export interface PropertyFacet {
-    readonly properties: PropertyObjectSchema;
-    readonly propertyMetadata: PropertyMetadataRecord;
+    readonly properties: PropertyRecord;
 }
-//# sourceMappingURL=property.d.ts.map

package/dist/v1/language/class/model/property.js

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

package/dist/v1/language/class/property-values.d.ts

@@ -0,0 +1,15 @@
+import type { Value as PortableValue } from '@astrale-os/kernel-dsl/value';
+import type { PropertyKey } from '../../addressing/index.js';
+declare const PROPERTY_VALUES: unique symbol;
+/** Detached, sorted, deeply frozen values keyed by exact declaring Property identity. */
+export type PropertyValues = Readonly<Record<PropertyKey, PortableValue>> & {
+    readonly [PROPERTY_VALUES]: true;
+};
+export interface PropertyValuesOperations {
+    accept(input: unknown, pointer?: string): PropertyValues;
+    create(entries: Iterable<readonly [PropertyKey, PortableValue]>): PropertyValues;
+}
+export declare function acceptPropertyValues(input: unknown, pointer?: string): PropertyValues;
+export declare function createPropertyValues(entries: Iterable<readonly [PropertyKey, PortableValue]>): PropertyValues;
+export declare const PropertyValues: PropertyValuesOperations;
+export {};

package/dist/v1/language/class/property-values.js

@@ -0,0 +1,30 @@
+import { accept as acceptPortable } from '@astrale-os/kernel-dsl/value';
+import { PropertyKey as admitPropertyKey } from '../../addressing/index.js';
+export function acceptPropertyValues(input, pointer = '') {
+    const admitted = acceptPortable(input);
+    if (admitted === null || typeof admitted !== 'object' || Array.isArray(admitted)) {
+        throw new TypeError(`Expected PropertyValues object at ${pointer || '/'}.`);
+    }
+    return createPropertyValues(Object.entries(admitted).map(([key, value]) => [admitPropertyKey(key), value]));
+}
+export function createPropertyValues(entries) {
+    const output = Object.create(null);
+    for (const [key, value] of [...entries].sort(([left], [right]) => compare(left, right))) {
+        Object.defineProperty(output, key, { enumerable: true, value: freeze(value) });
+    }
+    return Object.freeze(output);
+}
+export const PropertyValues = Object.freeze({
+    accept: acceptPropertyValues,
+    create: createPropertyValues,
+});
+function freeze(value) {
+    if (value === null || typeof value !== 'object')
+        return value;
+    for (const member of Object.values(value))
+        freeze(member);
+    return Object.freeze(value);
+}
+function compare(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}

package/dist/v1/language/class/resolved.d.ts

@@ -0,0 +1,123 @@
+import type { Value as PortableValue } from '@astrale-os/kernel-dsl/value';
+import type { ClassRef, DefinitionKey, Key, PolicyRef, PropertyKey } from '../../addressing/index.js';
+import type { ResolvedMethodCollection } from '../callable/resolved.js';
+import type { Diagnostic } from '../validation/diagnostic.js';
+import type { OrderingKind } from '../value/ordering.js';
+import type { ClassDefinition, ClassKind } from './model/class.js';
+import type { DataDefinition } from './model/data.js';
+import type { PropertyDefinition } from './model/property.js';
+import type { PropertyValues } from './property-values.js';
+export interface ResolvedProperty<out Value = PortableValue, out Required extends boolean = boolean> {
+    readonly owner: AnyResolvedClass;
+    readonly name: string;
+    readonly key: PropertyKey;
+    readonly definition: PropertyDefinition & {
+        readonly required: Required;
+    };
+    /** The one portable scalar ordering domain, when the Property is orderable. */
+    readonly ordering?: OrderingKind;
+    validate(input: unknown): readonly Diagnostic[];
+    readonly __value?: Value;
+}
+export interface ResolvedData {
+    readonly owner: ResolvedClass<'node'>;
+    readonly definition: DataDefinition;
+}
+export interface ResolvedClassPolicies<Kind extends ClassKind = ClassKind> {
+    readonly read: Kind extends 'node' ? readonly PolicyRef[] : readonly [];
+    readonly traverse: readonly PolicyRef[];
+}
+export type ResolvedPropertyCollection<ByKey extends Readonly<Record<PropertyKey, ResolvedProperty<unknown>>> = Readonly<Record<PropertyKey, ResolvedProperty<unknown>>>, ByName extends Readonly<Record<string, ResolvedProperty<unknown>>> = Readonly<Record<never, never>>> = Readonly<ByName> & Iterable<ByKey[keyof ByKey]> & {
+    readonly byKey: ByKey;
+    get<Key extends keyof ByKey>(key: Key): ByKey[Key];
+    get(key: PropertyKey): ResolvedProperty | undefined;
+    from(input: PropertyInput<ByKey, ByName>): PropertyValues;
+};
+export interface ResolvedClass<Kind extends ClassKind = ClassKind, Properties extends ResolvedPropertyCollection = ResolvedPropertyCollection, InstanceMethods extends ResolvedMethodCollection = ResolvedMethodCollection, StaticMethods extends ResolvedMethodCollection = ResolvedMethodCollection, SelfProperties extends ResolvedPropertyCollection = ResolvedPropertyCollection, SelfInstanceMethods extends ResolvedMethodCollection = ResolvedMethodCollection, SelfStaticMethods extends ResolvedMethodCollection = ResolvedMethodCollection, Definition extends Extract<ClassDefinition, {
+    readonly kind: Kind;
+}> = Extract<ClassDefinition, {
+    readonly kind: Kind;
+}>, Parents extends readonly unknown[] = readonly unknown[]> {
+    readonly ref: ClassRef;
+    readonly key: DefinitionKey<string, 'class'>;
+    readonly kind: Kind;
+    readonly abstract: boolean;
+    readonly definition: Definition;
+    readonly extends: Parents & readonly ResolvedClass<Kind>[];
+    /** Effective inherited Policy conjunction, deduplicated by exact Policy ref. */
+    readonly policies: ResolvedClassPolicies<Kind>;
+    readonly data: Kind extends 'node' ? ResolvedData | undefined : undefined;
+    readonly properties: Properties;
+    readonly methods: Kind extends 'node' ? InstanceMethods : ResolvedMethodCollection<Record<never, never>>;
+    readonly static: {
+        readonly methods: Kind extends 'node' ? StaticMethods : ResolvedMethodCollection<Record<never, never>>;
+    };
+    readonly self: {
+        readonly data: Kind extends 'node' ? ResolvedData | undefined : undefined;
+        readonly properties: SelfProperties;
+        /** Policies declared by this exact Class only. */
+        readonly policies: Definition['policies'];
+        readonly methods: Kind extends 'node' ? SelfInstanceMethods : ResolvedMethodCollection<Record<never, never>>;
+        readonly static: {
+            readonly methods: Kind extends 'node' ? SelfStaticMethods : ResolvedMethodCollection<Record<never, never>>;
+        };
+    };
+    satisfies(selected: ResolvedClass<Kind>): boolean;
+    validateProperties(input: unknown): readonly Diagnostic[];
+}
+/** One resolved Class with an exact graph kind, used at heterogeneous Domain boundaries. */
+export type AnyResolvedClass = ResolvedClass<'node'> | ResolvedClass<'edge'>;
+/** Exact Class keys satisfied by one resolved Class, including transitive parents. */
+export type ClassSatisfactionKeysOf<Class> = ClassSatisfactionKeys<Class, never>;
+type ClassSatisfactionKeys<Class, Seen> = Class extends Seen ? never : (Class extends {
+    readonly key: infer ExactKey extends DefinitionKey<Key.Origin, 'class'>;
+} ? ExactKey : never) | (Class extends ResolvedClass<ClassKind, ResolvedPropertyCollection, ResolvedMethodCollection, ResolvedMethodCollection, ResolvedPropertyCollection, ResolvedMethodCollection, ResolvedMethodCollection, ClassDefinition, infer Parents> ? ClassSatisfactionKeys<Extract<Parents[number], ResolvedClass>, Seen | Class> : never);
+export type PropertyValueOf<Property> = Property extends ResolvedProperty<infer Value> ? Value : never;
+export type PropertiesOf<Class> = Class extends {
+    readonly properties: infer Properties extends ResolvedPropertyCollection;
+} ? Properties : ResolvedPropertyCollection<Record<never, never>>;
+export type PropertyValuesOf<Class> = PropertyValues & Readonly<{
+    [Key in keyof PropertyByKeyOf<Class>]?: PropertyValueOf<PropertyByKeyOf<Class>[Key]>;
+}>;
+export type PropertyInputOf<Class> = PropertyInput<PropertyByKeyOf<Class>, PropertyByNameOf<Class>>;
+export type MethodsOf<Class> = Class extends {
+    readonly kind: 'node';
+    readonly methods: infer Methods extends ResolvedMethodCollection;
+} ? Methods : ResolvedMethodCollection<Record<never, never>>;
+export type StaticMethodsOf<Class> = Class extends {
+    readonly kind: 'node';
+    readonly static: {
+        readonly methods: infer Methods extends ResolvedMethodCollection;
+    };
+} ? Methods : ResolvedMethodCollection<Record<never, never>>;
+export type SelfPropertiesOf<Class> = Class extends {
+    readonly self: {
+        readonly properties: infer Properties extends ResolvedPropertyCollection;
+    };
+} ? Properties : ResolvedPropertyCollection<Record<never, never>>;
+export type SelfMethodsOf<Class> = Class extends {
+    readonly kind: 'node';
+    readonly self: {
+        readonly methods: infer Methods extends ResolvedMethodCollection;
+    };
+} ? Methods : ResolvedMethodCollection<Record<never, never>>;
+export type SelfStaticMethodsOf<Class> = Class extends {
+    readonly kind: 'node';
+    readonly self: {
+        readonly static: {
+            readonly methods: infer Methods extends ResolvedMethodCollection;
+        };
+    };
+} ? Methods : ResolvedMethodCollection<Record<never, never>>;
+type PropertyInput<ByKey extends Readonly<Record<PropertyKey, ResolvedProperty<unknown>>>, ByName extends Readonly<Record<string, ResolvedProperty<unknown>>>> = Readonly<{
+    [Key in keyof ByKey]?: PropertyValueOf<ByKey[Key]>;
+} & {
+    [Name in keyof ByName]?: PropertyValueOf<ByName[Name]>;
+}>;
+type PropertyByKeyOf<Class> = PropertiesOf<Class> extends {
+    readonly byKey: infer ByKey extends Readonly<Record<PropertyKey, ResolvedProperty<unknown>>>;
+} ? ByKey : Readonly<Record<never, never>>;
+type PropertyByNameOf<Class> = Readonly<{
+    [Name in Exclude<keyof PropertiesOf<Class>, keyof ResolvedPropertyCollection>]: Extract<PropertiesOf<Class>[Name], ResolvedProperty>;
+}>;
+export {};

package/dist/v1/language/class/resolved.js

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

package/dist/v1/language/core/index.d.ts

@@ -0,0 +1,2 @@
+export type * from './model/core.js';
+export type * from './resolved.js';

package/dist/v1/language/core/index.js

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

package/dist/v1/language/core/model/core.d.ts

@@ -0,0 +1,20 @@
+import type { ClassRef, CoreRef, DefinitionBase } from '../../../addressing/index.js';
+import type { PropertyValues } from '../../class/property-values.js';
+export interface DomainEndpointRef {
+    readonly kind: 'domain';
+}
+export type CoreEndpointRef = CoreRef | DomainEndpointRef;
+export interface CoreDefinition extends DefinitionBase<CoreRef> {
+    readonly class: ClassRef;
+    readonly properties: PropertyValues;
+}
+export interface CoreEdge {
+    readonly class: ClassRef;
+    readonly source: CoreEndpointRef;
+    readonly target: CoreEndpointRef;
+    readonly properties: PropertyValues;
+}
+export interface CoreContent {
+    readonly nodes: Readonly<Record<string, CoreDefinition>>;
+    readonly edges: readonly CoreEdge[];
+}

package/dist/v1/language/core/model/core.js

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

package/dist/v1/language/core/resolved.d.ts

@@ -0,0 +1,21 @@
+import type { DefinitionKey } from '../../addressing/index.js';
+import type { PropertyValues } from '../class/property-values.js';
+import type { ResolvedClass } from '../class/resolved.js';
+import type { CoreDefinition } from './model/core.js';
+export interface ResolvedCoreDefinition {
+    readonly ref: CoreDefinition['ref'];
+    readonly key: DefinitionKey<string, 'core'>;
+    readonly class: ResolvedClass<'node'>;
+    readonly properties: PropertyValues;
+    readonly definition: CoreDefinition;
+}
+export interface ResolvedDomainEndpoint {
+    readonly kind: 'domain';
+    readonly origin: string;
+}
+export interface ResolvedCoreEdge {
+    readonly class: ResolvedClass<'edge'>;
+    readonly source: ResolvedCoreDefinition | ResolvedDomainEndpoint;
+    readonly target: ResolvedCoreDefinition | ResolvedDomainEndpoint;
+    readonly properties: PropertyValues;
+}

package/dist/v1/language/core/resolved.js

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

package/dist/v1/{schema → language/definition}/metadata.d.ts

@@ -10,4 +10,3 @@ export declare const icon: Readonly<{
     readonly minLength: 1;
     readonly maxLength: 8000;
 }>;
-//# sourceMappingURL=metadata.d.ts.map

package/dist/v1/{schema → language/definition}/metadata.js

@@ -10,4 +10,3 @@ export const icon = Object.freeze({
     minLength: 1,
     maxLength: 8000,
 });
-//# sourceMappingURL=metadata.js.map

package/dist/v1/language/definition.d.ts

@@ -0,0 +1,7 @@
+import type { FunctionDefinition } from './callable/model/callable.js';
+import type { ClassDefinition } from './class/model/class.js';
+import type { CoreDefinition } from './core/model/core.js';
+import type { PolicyDefinition } from './policy/model/policy.js';
+import type { ViewDefinition } from './view/model/view.js';
+/** Every named V1 product Definition. Property and Method remain Class-owned members. */
+export type Definition = ClassDefinition | FunctionDefinition | PolicyDefinition | ViewDefinition | CoreDefinition;

package/dist/v1/language/definition.js

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

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

@@ -0,0 +1,23 @@
+export type { ClassRef, CoreRef, DefinitionBase, DefinitionKey, DefinitionRef, FunctionRef, MethodKey, PolicyRef, PropertyKey, ViewRef, } from '../addressing/index.js';
+export type { Value as PropertyValue } from '@astrale-os/kernel-dsl/value';
+export type { JsonSchema as ValueSchema, JsonSchemaObject as ValueSchemaObject, } from './value/model/schema.js';
+export type { OrderingKind } from './value/ordering.js';
+export type * from './callable/model/callable.js';
+export type * from './callable/resolved.js';
+export type * from './class/model/class.js';
+export type { DataDefinition, DataFacet, MediaType } from './class/model/data.js';
+export type * from './class/model/edge.js';
+export type * from './class/model/property.js';
+export type * from './class/resolved.js';
+export type * from './class/facets.js';
+export { PropertyValues } from './class/property-values.js';
+export type { PropertyValuesOperations } from './class/property-values.js';
+export type * from './core/model/core.js';
+export type * from './core/resolved.js';
+export type { Definition } from './definition.js';
+export type { ResolvedDefinition, ResolvedDefinitionOf } from './resolved.js';
+export type { Diagnostic, DiagnosticCode } from './validation/diagnostic.js';
+export type * from './policy/model/policy.js';
+export type * from './policy/resolved.js';
+export type * from './view/model/view.js';
+export type * from './view/resolved.js';

package/dist/v1/language/index.js

@@ -0,0 +1 @@
+export { PropertyValues } from './class/property-values.js';

package/dist/v1/{schema/policy/validation → language/policy/analysis}/branches.d.ts

@@ -1,5 +1,5 @@
-import type { ClassRef } from '../../reference.js';
-import type { PolicyEdgePattern, PolicyPatternExpression, PolicyPatternTerm } from '../ast.js';
+import type { ClassRef } from '../../../addressing/index.js';
+import type { PolicyEdgePattern, PolicyPatternExpression, PolicyPatternTerm } from '../model/policy.js';
 export interface PatternBranch {
     readonly edges: readonly PatternEdgeUse[];
     readonly variables: ReadonlyMap<string, ClassRef>;
@@ -15,7 +15,5 @@ export declare function branchesOf(pattern: PolicyPatternExpression, namespace:
 export declare function branchProduct(children: readonly (readonly PatternBranch[])[]): readonly PatternBranch[];
 export declare function capBranches(values: readonly PatternBranch[]): readonly PatternBranch[];
 export declare function isConnected(branch: PatternBranch): boolean;
-/** A normalized branch targets either one object or both authored Edge endpoints, never a mixture. */
 export declare function targetMode(branch: PatternBranch): PolicyTargetMode | undefined;
 export declare function termKey(term: PolicyPatternTerm, namespace: string): string;
-//# sourceMappingURL=branches.d.ts.map

package/dist/v1/{schema/policy/validation → language/policy/analysis}/branches.js

@@ -39,7 +39,6 @@ export function isConnected(branch) {
     const root = union.find('subject');
     return [...vertices].every((vertex) => union.find(vertex) === root);
 }
-/** A normalized branch targets either one object or both authored Edge endpoints, never a mixture. */
 export function targetMode(branch) {
     let object = false;
     let source = false;
@@ -61,15 +60,8 @@ export function termKey(term, namespace) {
     return term.kind === 'variable' ? variableKey(namespace, term.id) : term.kind;
 }
 function branchesForNode(pattern, namespace, variables) {
-    if (isEdge(pattern)) {
-        return [
-            {
-                edges: [{ pattern, namespace }],
-                variables,
-                requiredVariables: new Set(),
-                namespace,
-            },
-        ];
+    if ('source' in pattern) {
+        return [{ edges: [{ pattern, namespace }], variables, requiredVariables: new Set(), namespace }];
     }
     if ('exists' in pattern) {
         const direct = new Set(pattern.exists.nodes.map((node) => variableKey(namespace, node.variable.id)));
@@ -78,17 +70,11 @@ function branchesForNode(pattern, namespace, variables) {
             requiredVariables: new Set([...branch.requiredVariables, ...direct]),
         }));
     }
-    const { key, values } = patternOperands(pattern);
-    const children = values.map((child) => branchesForNode(child, namespace, variables));
-    return key === 'allOf' ? branchProduct(children) : capBranches(children.flat());
+    const children = ('allOf' in pattern ? pattern.allOf : pattern.anyOf).map((child) => branchesForNode(child, namespace, variables));
+    return 'allOf' in pattern ? branchProduct(children) : capBranches(children.flat());
 }
 function emptyBranch() {
-    return {
-        edges: [],
-        variables: new Map(),
-        requiredVariables: new Set(),
-        namespace: '$',
-    };
+    return { edges: [], variables: new Map(), requiredVariables: new Set(), namespace: '$' };
 }
 function mergeBranches(left, right) {
     return {
@@ -118,14 +104,6 @@ function collectVariableClasses(pattern, namespace) {
 function variableKey(namespace, id) {
     return `variable:${namespace}:${id}`;
 }
-function patternOperands(value) {
-    return 'allOf' in value
-        ? { key: 'allOf', values: value.allOf }
-        : { key: 'anyOf', values: value.anyOf };
-}
-function isEdge(value) {
-    return 'source' in value;
-}
 class UnionFind {
     #parents = new Map();
     constructor(values) {
@@ -152,4 +130,3 @@ class UnionFind {
             this.#parents.set(b, a);
     }
 }
-//# sourceMappingURL=branches.js.map

package/dist/v1/{schema/policy/validation → language/policy/analysis}/budgets.d.ts

@@ -1,5 +1,4 @@
-import type { PolicyCheckExpression } from '../ast.js';
-import type { PolicyValidationContext } from './context.js';
+import type { PolicyCheckExpression } from '../model/policy.js';
 export declare const MAX_PATTERN_DEPTH = 4;
 export declare const MAX_BRANCHES = 8;
 export declare const MAX_VARIABLES = 4;
@@ -14,6 +13,4 @@ export interface CheckMeasure {
     readonly branches: number;
     readonly leaves: number;
 }
-export declare function validatePolicyBudgets(context: PolicyValidationContext): void;
 export declare function measureChecks(expression: PolicyCheckExpression): CheckMeasure;
-//# sourceMappingURL=budgets.d.ts.map

package/dist/v1/language/policy/analysis/budgets.js

@@ -0,0 +1,25 @@
+export const MAX_PATTERN_DEPTH = 4;
+export const MAX_BRANCHES = 8;
+export const MAX_VARIABLES = 4;
+export const MAX_EDGES = 6;
+export const MAX_REPEAT = 3;
+export const MAX_DOMAINS = 4;
+export const MAX_CHECK_DEPTH = 4;
+export const MAX_CHECK_LEAVES = 8;
+export const BRANCH_OVERFLOW = MAX_BRANCHES + 1;
+export function measureChecks(expression) {
+    if ('check' in expression)
+        return { depth: 1, branches: 1, leaves: 1 };
+    const children = ('allOf' in expression ? expression.allOf : expression.anyOf).map(measureChecks);
+    const branches = 'allOf' in expression
+        ? children.reduce((value, child) => saturatingProduct(value, child.branches), 1)
+        : children.reduce((value, child) => Math.min(BRANCH_OVERFLOW, value + child.branches), 0);
+    return {
+        depth: 1 + Math.max(0, ...children.map((child) => child.depth)),
+        branches,
+        leaves: children.reduce((value, child) => value + child.leaves, 0),
+    };
+}
+function saturatingProduct(left, right) {
+    return Math.min(BRANCH_OVERFLOW, left * right);
+}

package/dist/v1/language/policy/index.d.ts

@@ -0,0 +1,3 @@
+export type * from './model/policy.js';
+export type * from './resolved.js';
+export * from './normalization/normalize.js';

package/dist/v1/language/policy/index.js

@@ -0,0 +1 @@
+export * from './normalization/normalize.js';