@astrale-os/kernel-dsl 0.2.0-beta.4 → 0.2.0-beta.40

package/dist/v1/domain/validation/create.js

@@ -0,0 +1,75 @@
+/** Build the one Domain-level router shared by source resolution and compiled loading. */
+export function createDomainValidation(properties, callables) {
+    const validation = {
+        propertyExists: (key) => properties.has(key),
+        property(key, input) {
+            const target = properties.get(key);
+            return target === undefined ? unknownTarget('Property', key) : target.validate(input);
+        },
+        propertyOrdering: (key) => properties.get(key)?.ordering,
+        callableExists: (key) => callables.has(key),
+        callableInput(key, input) {
+            const target = callables.get(key);
+            return target === undefined ? unknownTarget('Callable', key) : target.validateInput(input);
+        },
+        callableFields: (key) => callables.get(key)?.fields,
+        callableInputField(key, field, input) {
+            const target = callables.get(key);
+            return target === undefined
+                ? unknownTarget('Callable', key)
+                : target.validateInputField(field, input);
+        },
+        callableOutput(key, output) {
+            const target = callables.get(key);
+            return target === undefined ? unknownTarget('Callable', key) : target.validateOutput(output);
+        },
+    };
+    return Object.freeze(validation);
+}
+export function combineDomainValidation(values) {
+    const validation = {
+        propertyExists: (key) => values.some((value) => value.propertyExists(key)),
+        property(key, input) {
+            const owner = values.find((value) => value.propertyExists(key));
+            return owner === undefined ? unknownTarget('Property', key) : owner.property(key, input);
+        },
+        propertyOrdering: (key) => values.find((value) => value.propertyExists(key))?.propertyOrdering(key),
+        callableExists: (key) => values.some((value) => value.callableExists(key)),
+        callableInput(key, input) {
+            const owner = values.find((value) => value.callableExists(key));
+            return owner === undefined ? unknownTarget('Callable', key) : owner.callableInput(key, input);
+        },
+        callableFields: (key) => values.find((value) => value.callableExists(key))?.callableFields(key),
+        callableInputField(key, field, input) {
+            const owner = values.find((value) => value.callableExists(key));
+            return owner === undefined
+                ? unknownTarget('Callable', key)
+                : owner.callableInputField(key, field, input);
+        },
+        callableOutput(key, output) {
+            const owner = values.find((value) => value.callableExists(key));
+            return owner === undefined
+                ? unknownTarget('Callable', key)
+                : owner.callableOutput(key, output);
+        },
+    };
+    return Object.freeze(validation);
+}
+export function unknownInputField(field) {
+    return [
+        Object.freeze({
+            code: 'CALLABLE_INPUT_FIELD_UNKNOWN',
+            pointer: '',
+            message: `Input field ${field} is absent.`,
+        }),
+    ];
+}
+function unknownTarget(kind, key) {
+    return [
+        Object.freeze({
+            code: 'DOMAIN_VALIDATION_TARGET_UNKNOWN',
+            pointer: '',
+            message: `${kind} ${key} is absent.`,
+        }),
+    ];
+}

package/dist/v1/index.d.ts

@@ -1,9 +1,19 @@
 /** Stable aggregate facade for the V1 language. */
-export { auto, defineInterface, definePolicy, defineSchema, domain, edge, edgeClass, edgeInterface, fn, fullMatch, node, nodeClass, nodeInterface, output, path, policy, property, valueSchema, view, } from './builder/index.js';
-export type * from './builder/index.js';
-export type { FunctionAuth, MethodInheritance, PolicyCheckExpression, ViewAuth, } from './schema/index.js';
-export { Key, PropertyKey, Ref } from './addressing/index.js';
+export { auto, core, defineClass, defineSchema, edgeClass, func, fullMatch, input, method, nodeClass, output, path, policy, property, stateProperty, valueSchema, view, } from './builder/index.js';
+export { stateMachine } from './language/state/index.js';
+export { isBinaryInput } from './language/callable/model/callable.js';
+export type { EventOf, StateMachine, StateOf } from './language/state/index.js';
+export { PropertyValues } from './language/index.js';
+export * as metadata from './language/definition/metadata.js';
+export type { AnyResolvedClass, BoundMethodOf, BoundMethodShortcutsOf, CallableResultOf, CallableInputOf, CallableInputModeOf, CallableOutputOf, ClassSatisfactionKeysOf, ClassDefinition, CoreDefinition, CoreEdge, FunctionAuth, FunctionDefinition, BinaryInput, BinaryInputProjection, CallableInputContract, MethodDefinition, MethodOwnerKeyOf, PolicyCheckExpression, PolicyDefinition, PropertyInputOf, PropertyAccessOf, PropertyOutputOf, PropertyShortcutsOf, PropertyValuesOf, ResolvedClass, ResolvedCoreDefinition, ResolvedCoreEndpoint, ResolvedData, ResolvedFunction, ExecutableMethod, ResolvedMethod, ResolvedMethodCollection, ResolvedPolicy, ResolvedProperty, ResolvedView, MethodAccessOf, SelfMethodsOf, SelfPropertiesOf, SelfStaticMethodsOf, StaticMethodsOf, ViewDefinition, } from './language/index.js';
+export { acceptDefinitionRef, callableAddress, ClassKey, equalDefinitionRefs, isDefinitionRef, Key, MethodKey, PropertyKey, } from './addressing/index.js';
+export type { ClassRef, CoreRef, DefinitionBase, DefinitionKey, DefinitionRef, FunctionRef, MethodAddress, PolicyRef, Revision, ViewRef, } from './addressing/index.js';
+export type { Definition } from './language/index.js';
+export type { Domain, MethodOwnerOf, SourceDomain } from './domain/index.js';
+export { isDomain } from './domain/index.js';
 export type * as builder from './builder/index.js';
+export type { PathAuthoring, TypedValueSchema } from './builder/index.js';
+export type { PropertyValues as PropertyValuesValue } from './language/index.js';
+export type { CompiledSchema } from './compiled/index.js';
 export * as schema from './schema/index.js';
 export * as bundle from './bundle/index.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/v1/index.js

@@ -1,6 +1,10 @@
 /** Stable aggregate facade for the V1 language. */
-export { auto, defineInterface, definePolicy, defineSchema, domain, edge, edgeClass, edgeInterface, fn, fullMatch, node, nodeClass, nodeInterface, output, path, policy, property, valueSchema, view, } from './builder/index.js';
-export { Key, PropertyKey, Ref } from './addressing/index.js';
+export { auto, core, defineClass, defineSchema, edgeClass, func, fullMatch, input, method, nodeClass, output, path, policy, property, stateProperty, valueSchema, view, } from './builder/index.js';
+export { stateMachine } from './language/state/index.js';
+export { isBinaryInput } from './language/callable/model/callable.js';
+export { PropertyValues } from './language/index.js';
+export * as metadata from './language/definition/metadata.js';
+export { acceptDefinitionRef, callableAddress, ClassKey, equalDefinitionRefs, isDefinitionRef, Key, MethodKey, PropertyKey, } from './addressing/index.js';
+export { isDomain } from './domain/index.js';
 export * as schema from './schema/index.js';
 export * as bundle from './bundle/index.js';
-//# sourceMappingURL=index.js.map

package/dist/v1/language/callable/composition.d.ts

@@ -0,0 +1,27 @@
+interface MethodMember {
+    readonly key: string;
+    readonly name: string;
+    readonly declaration: {
+        readonly abstract: boolean;
+    };
+}
+export interface MethodComposition<Method> {
+    readonly requirements: ReadonlyMap<string, Method>;
+    readonly frontier: ReadonlyMap<string, Method>;
+    readonly methods: ReadonlyMap<string, Method>;
+}
+/** Structured failure facts; human diagnostic wording is not compatibility evidence. */
+export type MethodCompositionIssue = {
+    readonly kind: 'signature';
+    readonly local: string;
+    readonly required: string;
+} | {
+    readonly kind: 'ambiguous';
+    readonly methods: readonly [string, string];
+} | {
+    readonly kind: 'missing';
+    readonly required: string;
+};
+/** Concrete implementations never discharge a descendant's abstract obligations. */
+export declare function composeMethods<Method extends MethodMember>(parents: readonly MethodComposition<Method>[], own: ReadonlyMap<string, Method>, abstract: boolean, sameSignature: (left: Method, right: Method) => boolean, report: (message: string, issue: MethodCompositionIssue) => void): MethodComposition<Method>;
+export {};

package/dist/v1/language/callable/composition.js

@@ -0,0 +1,52 @@
+/** Concrete implementations never discharge a descendant's abstract obligations. */
+export function composeMethods(parents, own, abstract, sameSignature, report) {
+    const requirements = new Map(parents.flatMap((parent) => [...parent.requirements]));
+    const frontier = new Map(parents.flatMap((parent) => [...parent.frontier]));
+    for (const required of requirements.values()) {
+        const local = own.get(required.name);
+        if (local !== undefined && !sameSignature(local, required)) {
+            report(`Method ${local.key} does not exactly preserve abstract signature ${required.key}.`, {
+                kind: 'signature',
+                local: local.key,
+                required: required.key,
+            });
+        }
+    }
+    for (const local of own.values()) {
+        if (!local.declaration.abstract)
+            continue;
+        requirements.set(local.key, local);
+        for (const [key, inherited] of frontier) {
+            if (inherited.name === local.name)
+                frontier.delete(key);
+        }
+        frontier.set(local.key, local);
+    }
+    const methods = new Map();
+    for (const inherited of frontier.values()) {
+        const prior = methods.get(inherited.name);
+        if (prior !== undefined && !own.has(inherited.name)) {
+            report(`Inherited Method ${inherited.name} is ambiguous: ${prior.key}, ${inherited.key}.`, {
+                kind: 'ambiguous',
+                methods: [prior.key, inherited.key],
+            });
+        }
+        methods.set(inherited.name, inherited);
+    }
+    for (const [name, local] of own)
+        methods.set(name, local);
+    if (!abstract) {
+        const missing = new Set();
+        for (const required of requirements.values()) {
+            const local = own.get(required.name);
+            if (local === undefined && !missing.has(required.name)) {
+                missing.add(required.name);
+                report(`Concrete Class requires a local Method declaration of ${required.key}.`, {
+                    kind: 'missing',
+                    required: required.key,
+                });
+            }
+        }
+    }
+    return { requirements, frontier, methods };
+}

package/dist/v1/language/callable/executable.d.ts

@@ -0,0 +1,6 @@
+/** A local Method is executable unless both its contract and its owner are abstract. */
+export declare function isMethodExecutable(owner: {
+    readonly abstract: boolean;
+}, method: {
+    readonly abstract: boolean;
+}): boolean;

package/dist/v1/language/callable/executable.js

@@ -0,0 +1,4 @@
+/** A local Method is executable unless both its contract and its owner are abstract. */
+export function isMethodExecutable(owner, method) {
+    return !method.abstract || !owner.abstract;
+}

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

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

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

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

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

@@ -0,0 +1,46 @@
+import type { DefinitionBase, FunctionRef } from '../../../addressing/index.js';
+import type { PolicyCheckExpression } from '../../policy/model/policy.js';
+import type { JsonSchema } from '../../value/model/schema.js';
+export type FunctionAuth = 'anonymous' | 'authenticated' | 'authorized';
+export type CallableOutput = {
+    readonly mode: 'value';
+    readonly schema: JsonSchema;
+} | {
+    readonly mode: 'stream';
+    readonly item: JsonSchema;
+} | {
+    readonly mode: 'binary';
+};
+export type OutputMode = CallableOutput['mode'];
+/** A binary Function receives portable metadata and one required byte stream. */
+export interface BinaryInput {
+    readonly mode: 'binary';
+    readonly metadata: JsonSchema;
+    readonly maximumBytes: number;
+}
+export type CallableInputContract = JsonSchema | BinaryInput;
+declare const BINARY_INPUT_PROJECTION: unique symbol;
+/** Type-only witness retained by authored Functions; never serialized as an input Value. */
+export interface BinaryInputProjection<out Metadata = unknown> {
+    readonly [BINARY_INPUT_PROJECTION]: Metadata;
+}
+export declare function isBinaryInput(input: CallableInputContract): input is BinaryInput;
+export interface CallableDefinitionBase<Input extends CallableInputContract = CallableInputContract> {
+    readonly description?: string;
+    readonly input: Input;
+    readonly output: CallableOutput;
+}
+export type CallableDefinition<Input extends CallableInputContract = CallableInputContract> = CallableDefinitionBase<Input> & ({
+    readonly auth: 'anonymous' | 'authenticated';
+    readonly policy?: never;
+} | {
+    readonly auth: 'authorized';
+    readonly policy?: PolicyCheckExpression;
+});
+export type FunctionDefinition = DefinitionBase<FunctionRef> & CallableDefinition;
+export type MethodDefinition = CallableDefinition<JsonSchema> & {
+    readonly static: boolean;
+    readonly abstract: boolean;
+};
+export type MethodRecord = Readonly<Record<string, MethodDefinition>>;
+export {};

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

@@ -0,0 +1,3 @@
+export function isBinaryInput(input) {
+    return typeof input === 'object' && input !== null && input.mode === 'binary';
+}

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

@@ -0,0 +1,79 @@
+import type { DefinitionKey, FunctionRef, Key, MethodKey } from '../../addressing/index.js';
+import type { ResolvedClass } from '../class/resolved.js';
+import type { PolicyCheckExpression } from '../policy/model/policy.js';
+import type { Diagnostic } from '../validation/diagnostic.js';
+import type { BinaryInputProjection, FunctionDefinition, MethodDefinition } from './model/callable.js';
+import type { FunctionAuth } from './model/callable.js';
+type CallableDefinitionOf<Definition extends FunctionDefinition | MethodDefinition, Auth extends FunctionAuth, Policy extends PolicyCheckExpression> = Omit<Definition, 'auth' | 'policy'> & (Auth extends FunctionAuth ? {
+    readonly auth: Auth;
+} & (Auth extends 'authorized' ? {
+    readonly policy?: Policy;
+} : {
+    readonly policy?: never;
+}) : never);
+export interface ResolvedMethod<out Input = unknown, out Output = unknown, out Static extends boolean = boolean, out Abstract extends MethodDefinition['abstract'] = MethodDefinition['abstract'], out Auth extends FunctionAuth = FunctionAuth, out Policy extends PolicyCheckExpression = PolicyCheckExpression, out ExactKey extends MethodKey = MethodKey> {
+    readonly owner: ResolvedClass<'node'> & {
+        readonly key: MethodOwnerKeyOfKey<ExactKey>;
+    };
+    readonly name: string;
+    readonly key: ExactKey;
+    readonly description?: MethodDefinition['description'];
+    readonly input: MethodDefinition['input'];
+    readonly output: MethodDefinition['output'];
+    readonly auth: Auth;
+    readonly policy?: Auth extends 'authorized' ? Policy : never;
+    readonly static: Static;
+    readonly abstract: Abstract;
+    /** Whether this exact local declaration requires an implementation. */
+    readonly executable: Abstract extends false ? true : boolean;
+    /** Present only when the callable input is a safely enumerable closed object. */
+    readonly inputFields?: readonly string[];
+    readonly definition: CallableDefinitionOf<MethodDefinition, Auth, Policy> & {
+        readonly static: Static;
+        readonly abstract: Abstract;
+    };
+    validateInput(input: unknown): readonly Diagnostic[];
+    validateInputField(field: string, input: unknown): readonly Diagnostic[];
+    validateOutput(output: unknown): readonly Diagnostic[];
+    readonly __input?: Input;
+    readonly __output?: Output;
+}
+export type ResolvedMethodCollection<ByKey extends Readonly<Record<MethodKey, ResolvedMethod>> = Readonly<Record<MethodKey, ResolvedMethod>>, ByName extends Readonly<Record<string, ResolvedMethod>> = Readonly<Record<never, never>>> = Readonly<ByName> & Iterable<ByKey[keyof ByKey]> & {
+    readonly byKey: ByKey;
+    get<Key extends keyof ByKey>(key: Key): ByKey[Key];
+    get(key: MethodKey): ResolvedMethod | undefined;
+};
+export interface ResolvedFunction<out Input = unknown, out Output = unknown, out Auth extends FunctionAuth = FunctionAuth, out Policy extends PolicyCheckExpression = PolicyCheckExpression> {
+    readonly ref: FunctionRef;
+    readonly key: DefinitionKey<string, 'function'>;
+    readonly description?: FunctionDefinition['description'];
+    readonly input: FunctionDefinition['input'];
+    readonly output: FunctionDefinition['output'];
+    readonly auth: Auth;
+    readonly policy?: Auth extends 'authorized' ? Policy : never;
+    /** Present only when the callable input is a safely enumerable closed object. */
+    readonly inputFields?: readonly string[];
+    readonly definition: CallableDefinitionOf<FunctionDefinition, Auth, Policy>;
+    validateInput(input: unknown): readonly Diagnostic[];
+    validateInputField(field: string, input: unknown): readonly Diagnostic[];
+    validateOutput(output: unknown): readonly Diagnostic[];
+    readonly __input?: Input;
+    readonly __output?: Output;
+}
+export type ResolvedCallable = ResolvedFunction | ResolvedMethod;
+export type MethodOwnerKeyOf<Method> = Method extends {
+    readonly key: infer ExactKey extends MethodKey;
+} ? MethodOwnerKeyOfKey<ExactKey> : never;
+type MethodOwnerKeyOfKey<ExactKey extends MethodKey> = ExactKey extends `${infer Origin}:class.${infer Owner}.method.${string}` ? DefinitionKey<Extract<Origin, Key.Origin>, 'class', Owner> : never;
+type ProjectedCallableInputOf<Callable> = Callable extends ResolvedMethod<infer Input, unknown, boolean> ? Input : Callable extends ResolvedFunction<infer Input, unknown> ? Input : never;
+type InputValue<Input> = Input extends BinaryInputProjection<infer Metadata> ? Metadata : Input;
+/** Portable metadata for a binary Function, or the Value for an ordinary callable. */
+export type CallableInputOf<Callable> = InputValue<ProjectedCallableInputOf<Callable>>;
+type InputMode<Input> = Input extends BinaryInputProjection ? 'binary' : 'value';
+export type CallableInputModeOf<Callable> = InputMode<ProjectedCallableInputOf<Callable>>;
+export type CallableOutputOf<Callable> = Callable extends ResolvedMethod<unknown, infer Output, boolean> ? Output : Callable extends ResolvedFunction<unknown, infer Output> ? Output : never;
+/** An exact local Method whose Schema requires an implementation. */
+export type ExecutableMethod<Input = unknown, Output = unknown, Static extends boolean = boolean> = ResolvedMethod<Input, Output, Static> & {
+    readonly executable: true;
+};
+export {};

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

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

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

@@ -0,0 +1,61 @@
+import type { CallableInputOf, CallableOutputOf, ResolvedMethod, ResolvedMethodCollection } from '../callable/resolved.js';
+import type { StateTopology } from '../state/index.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, StateTopology | undefined, unknown> ? 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> & {
+    readonly executable: true;
+} ? 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,37 @@
+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 read?: PolicyRef;
+    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/language/class/model/data.d.ts

@@ -0,0 +1,11 @@
+import type { Object as JsonObject } from '@astrale-os/kernel-dsl/value';
+/** Canonical lowercase RFC 6838 media type without parameters. */
+export declare const MEDIA_TYPE_PATTERN: RegExp;
+export type MediaType = string;
+/** Schema-level contract for one externally stored Node payload. */
+export type DataDefinition = JsonObject & {
+    readonly mediaType: MediaType;
+};
+export interface DataFacet {
+    readonly data?: DataDefinition;
+}

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

@@ -0,0 +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;

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

@@ -0,0 +1,38 @@
+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 ClassRef[];
+}
+export interface DirectedSourceEndpoint extends EdgeEndpointBase {
+    readonly outgoing: EdgeCount;
+}
+export interface DirectedTargetEndpoint extends EdgeEndpointBase {
+    readonly incoming: EdgeCount;
+}
+export interface IncidentEndpoint extends EdgeEndpointBase {
+    readonly incident: EdgeCount;
+}
+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: DirectedEdgeConstraints;
+}
+export interface UndirectedEdgeContract {
+    readonly orientation: 'undirected';
+    readonly endpoints: readonly [IncidentEndpoint, IncidentEndpoint];
+    readonly constraints: UndirectedEdgeConstraints;
+}
+export type EdgeContract = DirectedEdgeContract | UndirectedEdgeContract;

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

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

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

@@ -0,0 +1,17 @@
+export type AutoEvent = 'create' | 'update';
+export type AutoSet = 'instant';
+export interface PropertyAuto {
+    readonly on: readonly AutoEvent[];
+    readonly set: AutoSet;
+}
+export interface PropertyDefinition {
+    readonly schema: import('../../value/model/schema.js').JsonSchema;
+    readonly required: boolean;
+    readonly auto?: PropertyAuto;
+    readonly description?: string;
+    readonly state?: import('../../state/index.js').StateTopology;
+}
+export type PropertyRecord = Readonly<Record<string, PropertyDefinition>>;
+export interface PropertyFacet {
+    readonly properties: PropertyRecord;
+}

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,33 @@
+import { acceptPropertyRoot } from '../../../value/accept.js';
+import { isImmutableSnapshot } from '../../../value/immutable.optimization.js';
+import { PropertyKey as admitPropertyKey } from '../../addressing/index.js';
+export function acceptPropertyValues(input, pointer = '') {
+    const admitted = acceptPropertyRoot(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;
+    if (isImmutableSnapshot(value))
+        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;
+}