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

package/dist/v1/domain/model/domain.d.ts

@@ -0,0 +1,53 @@
+import type { DefinitionKey, DefinitionRef, Key, Revision } from '../../addressing/index.js';
+import type { DomainDependency } from '../../addressing/index.js';
+import type { MethodOwnerKeyOf, ResolvedCallable, ResolvedFunction } from '../../language/callable/resolved.js';
+import type { AnyResolvedClass } from '../../language/class/resolved.js';
+import type { ResolvedCoreDefinition, ResolvedCoreEdge } from '../../language/core/resolved.js';
+import type { ResolvedPolicy } from '../../language/policy/resolved.js';
+import type { ResolvedDefinition, ResolvedDefinitionOf } from '../../language/resolved.js';
+import type { ResolvedView } from '../../language/view/resolved.js';
+export type ClassNamespace<Classes extends Readonly<Record<string, unknown>> = Readonly<Record<string, AnyResolvedClass>>> = Readonly<Classes>;
+export type FunctionNamespace<Functions extends Readonly<Record<string, unknown>> = Readonly<Record<string, ResolvedFunction>>> = Readonly<Functions>;
+export type PolicyNamespace<Policies extends Readonly<Record<string, unknown>> = Readonly<Record<string, ResolvedPolicy>>> = Readonly<Policies>;
+export type ViewNamespace<Views extends Readonly<Record<string, unknown>> = Readonly<Record<string, ResolvedView>>> = Readonly<Views>;
+export interface CoreNamespace<Nodes extends Readonly<Record<string, unknown>> = Readonly<Record<string, ResolvedCoreDefinition>>> {
+    readonly nodes: Readonly<Nodes>;
+    readonly edges: readonly ResolvedCoreEdge[];
+}
+export interface Domain<Classes extends Readonly<Record<string, unknown>> = Readonly<Record<string, AnyResolvedClass>>, Functions extends Readonly<Record<string, unknown>> = Readonly<Record<string, ResolvedFunction>>, Policies extends Readonly<Record<string, unknown>> = Readonly<Record<string, ResolvedPolicy>>, Views extends Readonly<Record<string, unknown>> = Readonly<Record<string, ResolvedView>>, CoreNodes extends Readonly<Record<string, unknown>> = Readonly<Record<string, ResolvedCoreDefinition>>, RevisionValue extends Revision = Revision> {
+    readonly origin: Key.Origin;
+    readonly revision: RevisionValue;
+    /** Exact admitted root and transitive dependency revisions, ordered by origin. */
+    readonly closure: readonly DomainDependency[];
+    readonly dependencies: readonly DomainDependency[];
+    readonly classes: ClassNamespace<Classes>;
+    readonly functions: FunctionNamespace<Functions>;
+    readonly policies: PolicyNamespace<Policies>;
+    readonly views: ViewNamespace<Views>;
+    readonly core: CoreNamespace<CoreNodes>;
+    definition<const Ref extends DefinitionRef>(ref: Ref): ResolvedDefinitionOf<Ref['kind']> | undefined;
+    definition<const Origin extends Key.Origin, const Kind extends DefinitionRef['kind'], const Name extends string>(key: DefinitionKey<Origin, Kind, Name>): ResolvedDefinitionOf<Kind> | undefined;
+    callable(key: Key.Callable): ResolvedCallable | undefined;
+    definitions(): readonly ResolvedDefinition[];
+    definitions<const Kind extends DefinitionRef['kind']>(kind: Kind): readonly ResolvedDefinitionOf<Kind>[];
+    viewsFor(target: 'domain' | AnyResolvedClass): readonly Views[keyof Views][];
+}
+declare const DOMAIN_SOURCE_RESOLVED: unique symbol;
+/** Type-only witness carried by a source that retains its exact resolved Domain. */
+export interface DomainSource<Resolved extends Domain = Domain> {
+    readonly [DOMAIN_SOURCE_RESOLVED]: Resolved;
+}
+export type DomainOfSource<Source> = Source extends DomainSource<infer Resolved> ? Resolved : Domain;
+export type SourceDomain<Source, Resolved extends Domain = DomainOfSource<Source>> = Resolved & {
+    readonly source: Source;
+};
+export type ClassesOf<Value> = Value extends Domain<infer Classes> ? Classes : never;
+export type MethodOwnerOf<Work extends Domain, Method> = Extract<ClassesOf<Work>[keyof ClassesOf<Work>], {
+    readonly key: MethodOwnerKeyOf<Method>;
+}>;
+export type FunctionsOf<Value> = Value extends Domain<Readonly<Record<string, unknown>>, infer Functions> ? Functions : never;
+export type PoliciesOf<Value> = Value extends Domain<Readonly<Record<string, unknown>>, Readonly<Record<string, unknown>>, infer Policies> ? Policies : never;
+export type ViewsOf<Value> = Value extends Domain<Readonly<Record<string, unknown>>, Readonly<Record<string, unknown>>, Readonly<Record<string, unknown>>, infer Views> ? Views : never;
+export type PropertyInputFor<Class extends AnyResolvedClass> = import('../../language/class/resolved.js').PropertyInputOf<Class>;
+export type PropertyValuesFor<Class extends AnyResolvedClass> = ReturnType<Class['properties']['from']>;
+export {};

package/dist/v1/domain/model/domain.js

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

package/dist/v1/domain/model/input.d.ts

@@ -0,0 +1,27 @@
+import type { Key as AddressKey, PropertyKey, Revision } from '../../addressing/index.js';
+import type { DomainDependency } from '../../addressing/index.js';
+import type { CoreEdge } from '../../language/core/model/core.js';
+import type { Definition } from '../../language/definition.js';
+import type { Diagnostic } from '../../language/validation/diagnostic.js';
+import type { OrderingKind } from '../../language/value/ordering.js';
+/** Dependency-closed, representation-neutral input to the one Domain constructor. */
+export interface DomainInput {
+    readonly origin: AddressKey.Origin;
+    readonly revision: Revision;
+    readonly closure: readonly DomainDependency[];
+    readonly dependencies: readonly DomainDependency[];
+    readonly definitions: readonly Definition[];
+    readonly coreEdges: readonly CoreEdge[];
+    readonly validation: DomainValidation;
+}
+/** Already-bound validation semantics supplied by source compilation or compiled loading. */
+export interface DomainValidation {
+    propertyExists(key: PropertyKey): boolean;
+    property(key: PropertyKey, input: unknown): readonly Diagnostic[];
+    propertyOrdering(key: PropertyKey): OrderingKind | undefined;
+    callableExists(key: AddressKey.Callable): boolean;
+    callableInput(key: AddressKey.Callable, input: unknown): readonly Diagnostic[];
+    callableFields(key: AddressKey.Callable): readonly string[] | undefined;
+    callableInputField(key: AddressKey.Callable, field: string, input: unknown): readonly Diagnostic[];
+    callableOutput(key: AddressKey.Callable, output: unknown): readonly Diagnostic[];
+}

package/dist/v1/domain/model/input.js

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

package/dist/v1/domain/namespace/member-collection.d.ts

@@ -0,0 +1,5 @@
+import type { ResolvedMethod, ResolvedMethodCollection } from '../../language/callable/resolved.js';
+import type { ResolvedProperty, ResolvedPropertyCollection } from '../../language/class/resolved.js';
+export declare function createPropertyCollection(values: Iterable<ResolvedProperty>): ResolvedPropertyCollection;
+export declare function createMethodCollection(values: Iterable<ResolvedMethod>): ResolvedMethodCollection;
+export declare function frozenRecord<Value>(entries: Iterable<readonly [string, Value]>): Readonly<Record<string, Value>>;

package/dist/v1/domain/namespace/member-collection.js

@@ -0,0 +1,81 @@
+import { PropertyKey as PropertyKeyValue } from '../../addressing/index.js';
+import { createPropertyValues } from '../../language/class/property-values.js';
+const PROPERTY_OPERATIONS = new Set(['byKey', 'get', 'from']);
+const METHOD_OPERATIONS = new Set(['byKey', 'get']);
+export function createPropertyCollection(values) {
+    const ordered = [...values].sort((left, right) => compare(left.key, right.key));
+    const byKey = frozenRecord(ordered.map((value) => [value.key, value]));
+    const named = uniqueNames(ordered);
+    const collection = {
+        byKey,
+        get(key) {
+            return byKey[key];
+        },
+        from(input) {
+            const entries = new Map();
+            const source = new Map();
+            for (const [candidate, value] of Object.entries(input)) {
+                const property = PropertyKeyValue.is(candidate) ? byKey[candidate] : named[candidate];
+                if (property === undefined) {
+                    throw new TypeError(`Unknown or ambiguous Property ${JSON.stringify(candidate)}.`);
+                }
+                if (entries.has(property.key)) {
+                    throw new TypeError(`Property ${property.key} is supplied through both ${JSON.stringify(source.get(property.key))} and ${JSON.stringify(candidate)}.`);
+                }
+                const diagnostics = property.validate(value);
+                if (diagnostics.length > 0) {
+                    throw new TypeError(`Invalid value for Property ${property.key}: ${diagnostics.map(({ message }) => message).join('; ')}`);
+                }
+                source.set(property.key, candidate);
+                entries.set(property.key, value);
+            }
+            return createPropertyValues(entries);
+        },
+        *[Symbol.iterator]() {
+            yield* ordered;
+        },
+    };
+    installShortcuts(collection, named, PROPERTY_OPERATIONS);
+    return Object.freeze(collection);
+}
+export function createMethodCollection(values) {
+    const ordered = [...values].sort((left, right) => compare(left.key, right.key));
+    const byKey = frozenRecord(ordered.map((value) => [value.key, value]));
+    const named = uniqueNames(ordered);
+    const collection = {
+        byKey,
+        get(key) {
+            return byKey[key];
+        },
+        *[Symbol.iterator]() {
+            yield* ordered;
+        },
+    };
+    installShortcuts(collection, named, METHOD_OPERATIONS);
+    return Object.freeze(collection);
+}
+function uniqueNames(values) {
+    const candidates = new Map();
+    for (const value of values) {
+        const list = candidates.get(value.name) ?? [];
+        list.push(value);
+        candidates.set(value.name, list);
+    }
+    return frozenRecord([...candidates].flatMap(([name, list]) => list.length === 1 ? [[name, list[0]]] : []));
+}
+function installShortcuts(target, named, reserved) {
+    for (const [name, value] of Object.entries(named)) {
+        if (!reserved.has(name))
+            Object.defineProperty(target, name, { enumerable: true, value });
+    }
+}
+export function frozenRecord(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 });
+    }
+    return Object.freeze(output);
+}
+function compare(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}

package/dist/v1/domain/projection/classes.d.ts

@@ -0,0 +1,4 @@
+import type { AnyResolvedClass } from '../../language/class/resolved.js';
+import type { Definition } from '../../language/definition.js';
+import type { DomainValidation } from '../model/input.js';
+export declare function createClasses(definitions: readonly Definition[], validation: DomainValidation): ReadonlyMap<string, AnyResolvedClass>;

package/dist/v1/domain/projection/classes.js

@@ -0,0 +1,200 @@
+import { compareUnicode, Key, MethodKey as MethodKeyValue, PropertyKey as PropertyKeyValue, } from '../../addressing/index.js';
+import { acceptPropertyValues } from '../../language/class/property-values.js';
+import { appendPointer } from '../../language/value/syntax/pointer.js';
+import { createMethodCollection, createPropertyCollection } from '../namespace/member-collection.js';
+export function createClasses(definitions, validation) {
+    const declarations = new Map(definitions
+        .filter((value) => value.ref.kind === 'class')
+        .map((value) => [Key.of(value.ref), value]));
+    const resolved = new Map();
+    const visiting = new Set();
+    const resolve = (ref) => {
+        const key = Key.of(ref);
+        const cached = resolved.get(key);
+        if (cached !== undefined)
+            return cached;
+        if (visiting.has(key))
+            throw new TypeError(`Class inheritance cycle reaches ${key}.`);
+        const definition = declarations.get(key);
+        if (definition === undefined)
+            throw new TypeError(`Class ${key} is absent from Domain input.`);
+        visiting.add(key);
+        const parents = definition.extends.map(resolve);
+        if (parents.some((parent) => parent.kind !== definition.kind)) {
+            throw new TypeError(`Class ${key} extends a Class of another graph kind.`);
+        }
+        const shell = {};
+        const policies = Object.freeze({
+            read: Object.freeze(definition.kind === 'node'
+                ? uniquePolicyRefs([
+                    ...parents.flatMap((parent) => parent.kind === 'node' ? [...parent.policies.read] : []),
+                    ...(definition.policies.read === undefined ? [] : [definition.policies.read]),
+                ])
+                : []),
+            traverse: Object.freeze(uniquePolicyRefs([
+                ...parents.flatMap((parent) => [...parent.policies.traverse]),
+                ...(definition.policies.traverse === undefined ? [] : [definition.policies.traverse]),
+            ])),
+        });
+        const effectiveProperties = new Map();
+        const effectiveMethods = new Map();
+        let inheritedData;
+        for (const parent of parents) {
+            for (const property of parent.properties) {
+                effectiveProperties.set(property.key, property);
+            }
+            for (const method of [...parent.methods, ...parent.static.methods]) {
+                if (!effectiveMethods.has(method.name))
+                    effectiveMethods.set(method.name, method);
+            }
+            if (parent.kind === 'node' && inheritedData === undefined)
+                inheritedData = parent.data;
+        }
+        const ownProperties = [];
+        for (const [name, propertyDefinition] of Object.entries(definition.properties)) {
+            const propertyKey = PropertyKeyValue.of(ref, name);
+            const ordering = validation.propertyOrdering(propertyKey);
+            const property = Object.freeze({
+                owner: shell,
+                name,
+                key: propertyKey,
+                definition: propertyDefinition,
+                ...(ordering === undefined ? {} : { ordering }),
+                validate: (input) => validation.property(propertyKey, input),
+            });
+            ownProperties.push(property);
+            effectiveProperties.set(property.key, property);
+        }
+        const ownInstanceMethods = [];
+        const ownStaticMethods = [];
+        const ownData = definition.kind === 'node' && definition.data !== undefined
+            ? Object.freeze({ owner: shell, definition: definition.data })
+            : undefined;
+        if (definition.kind === 'node') {
+            for (const [name, methodDefinition] of Object.entries(definition.methods)) {
+                const methodKey = MethodKeyValue.of(ref, name);
+                const inputFields = validation.callableFields(methodKey);
+                const method = Object.freeze({
+                    owner: shell,
+                    name,
+                    key: methodKey,
+                    description: methodDefinition.description,
+                    input: methodDefinition.input,
+                    output: methodDefinition.output,
+                    auth: methodDefinition.auth,
+                    policy: methodDefinition.policy,
+                    static: methodDefinition.static,
+                    inheritance: methodDefinition.inheritance,
+                    ...(inputFields === undefined ? {} : { inputFields }),
+                    definition: methodDefinition,
+                    validateInput: (input) => validation.callableInput(methodKey, input),
+                    validateInputField: (field, input) => validation.callableInputField(methodKey, field, input),
+                    validateOutput: (output) => validation.callableOutput(methodKey, output),
+                });
+                effectiveMethods.set(name, method);
+                (methodDefinition.static ? ownStaticMethods : ownInstanceMethods).push(method);
+            }
+        }
+        const instanceMethods = [...effectiveMethods.values()].filter(({ definition }) => !definition.static);
+        const staticMethods = [...effectiveMethods.values()].filter(({ definition }) => definition.static);
+        Object.assign(shell, {
+            ref: definition.ref,
+            key,
+            kind: definition.kind,
+            abstract: definition.abstract,
+            definition,
+            extends: Object.freeze(parents),
+            policies,
+            data: definition.kind === 'node' ? (ownData ?? inheritedData) : undefined,
+            properties: createPropertyCollection(effectiveProperties.values()),
+            methods: createMethodCollection(instanceMethods),
+            static: Object.freeze({ methods: createMethodCollection(staticMethods) }),
+            self: Object.freeze({
+                data: definition.kind === 'node' ? ownData : undefined,
+                properties: createPropertyCollection(ownProperties),
+                policies: definition.policies,
+                methods: createMethodCollection(ownInstanceMethods),
+                static: Object.freeze({ methods: createMethodCollection(ownStaticMethods) }),
+            }),
+            satisfies(selected) {
+                if (key === selected.key)
+                    return true;
+                return parents.some((parent) => {
+                    if (parent.kind === 'node' && selected.kind === 'node')
+                        return parent.satisfies(selected);
+                    if (parent.kind === 'edge' && selected.kind === 'edge')
+                        return parent.satisfies(selected);
+                    return false;
+                });
+            },
+            validateProperties(input) {
+                return validateProperties(definition.abstract, effectiveProperties, input);
+            },
+        });
+        const value = Object.freeze(shell);
+        resolved.set(key, value);
+        visiting.delete(key);
+        return value;
+    };
+    for (const definition of declarations.values())
+        resolve(definition.ref);
+    return resolved;
+}
+function uniquePolicyRefs(values) {
+    const result = new Map();
+    for (const value of values)
+        result.set(Key.of(value), value);
+    return [...result.values()].sort((left, right) => compareUnicode(Key.of(left), Key.of(right)));
+}
+function validateProperties(abstract, properties, input) {
+    if (abstract) {
+        return [
+            {
+                code: 'DOMAIN_CLASS_ABSTRACT',
+                pointer: '/class',
+                message: 'An abstract Class cannot admit exact object Properties.',
+            },
+        ];
+    }
+    let values;
+    try {
+        values = acceptPropertyValues(input, '/properties');
+    }
+    catch (cause) {
+        return [
+            {
+                code: 'DOMAIN_PROPERTY_INPUT_INVALID',
+                pointer: '/properties',
+                message: cause instanceof Error ? cause.message : 'Properties are not canonical.',
+            },
+        ];
+    }
+    const diagnostics = [];
+    for (const key of Object.keys(values)) {
+        if (!properties.has(key)) {
+            diagnostics.push({
+                code: 'DOMAIN_PROPERTY_UNKNOWN',
+                pointer: appendPointer('/properties', key),
+                message: `Property ${key} is not effective on this Class.`,
+            });
+        }
+    }
+    for (const property of properties.values()) {
+        if (!Object.hasOwn(values, property.key)) {
+            if (property.definition.required) {
+                diagnostics.push({
+                    code: 'DOMAIN_PROPERTY_REQUIRED',
+                    pointer: appendPointer('/properties', property.key),
+                    message: `Required Property ${property.key} is absent.`,
+                });
+            }
+            continue;
+        }
+        const pointer = appendPointer('/properties', property.key);
+        diagnostics.push(...property.validate(values[property.key]).map((item) => ({
+            ...item,
+            pointer: `${pointer}${item.pointer}`,
+        })));
+    }
+    return Object.freeze(diagnostics);
+}

package/dist/v1/domain/validation/create.d.ts

@@ -0,0 +1,18 @@
+import type { Key, PropertyKey } from '../../addressing/index.js';
+import type { Diagnostic } from '../../language/validation/diagnostic.js';
+import type { OrderingKind } from '../../language/value/ordering.js';
+import type { DomainValidation } from '../model/input.js';
+export interface PropertyValidation {
+    readonly ordering?: OrderingKind;
+    validate(input: unknown): readonly Diagnostic[];
+}
+export interface CallableValidation {
+    readonly fields?: readonly string[];
+    validateInput(input: unknown): readonly Diagnostic[];
+    validateInputField(field: string, input: unknown): readonly Diagnostic[];
+    validateOutput(output: unknown): readonly Diagnostic[];
+}
+/** Build the one Domain-level router shared by source resolution and compiled loading. */
+export declare function createDomainValidation(properties: ReadonlyMap<PropertyKey, PropertyValidation>, callables: ReadonlyMap<Key.Callable, CallableValidation>): DomainValidation;
+export declare function combineDomainValidation(values: readonly DomainValidation[]): DomainValidation;
+export declare function unknownInputField(field: string): readonly Diagnostic[];

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,16 @@
 /** 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 } from './schema/index.js';
-export { Key, PropertyKey, Ref } from './addressing/index.js';
+export { auto, core, defineClass, defineSchema, edgeClass, func, fullMatch, method, nodeClass, output, path, policy, property, valueSchema, view, } from './builder/index.js';
+export { PropertyValues } from './language/index.js';
+export * as metadata from './language/definition/metadata.js';
+export type { AnyResolvedClass, BoundMethodOf, BoundMethodShortcutsOf, CallableResultOf, CallableInputOf, CallableOutputOf, ClassSatisfactionKeysOf, ClassDefinition, CoreDefinition, CoreEdge, FunctionAuth, FunctionDefinition, MethodDefinition, MethodInheritance, MethodOwnerKeyOf, PolicyCheckExpression, PolicyDefinition, PropertyInputOf, PropertyAccessOf, PropertyOutputOf, PropertyShortcutsOf, PropertyValuesOf, ResolvedClass, ResolvedCoreDefinition, ResolvedData, ResolvedFunction, 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,8 @@
 /** 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, method, nodeClass, output, path, policy, property, valueSchema, view, } from './builder/index.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/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,33 @@
+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 MethodInheritance = 'abstract' | 'default' | 'sealed';
+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'];
+export interface CallableDefinitionBase {
+    readonly description?: string;
+    readonly input: JsonSchema;
+    readonly output: CallableOutput;
+}
+export type CallableDefinition = CallableDefinitionBase & ({
+    readonly auth: 'anonymous' | 'authenticated';
+    readonly policy?: never;
+} | {
+    readonly auth: 'authorized';
+    readonly policy?: PolicyCheckExpression;
+});
+export type FunctionDefinition = DefinitionBase<FunctionRef> & CallableDefinition;
+export type MethodDefinition = CallableDefinition & {
+    readonly static: boolean;
+    readonly inheritance: MethodInheritance;
+};
+export type MethodRecord = Readonly<Record<string, MethodDefinition>>;

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

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

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

@@ -0,0 +1,68 @@
+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 { 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 Inheritance extends MethodDefinition['inheritance'] = MethodDefinition['inheritance'], 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 inheritance: Inheritance;
+    /** 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 inheritance: Inheritance;
+    };
+    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;
+export type CallableInputOf<Callable> = Callable extends ResolvedMethod<infer Input, unknown, boolean> ? Input : Callable extends ResolvedFunction<infer Input, unknown> ? Input : never;
+export type CallableOutputOf<Callable> = Callable extends ResolvedMethod<unknown, infer Output, boolean> ? Output : Callable extends ResolvedFunction<unknown, infer Output> ? Output : never;
+export {};

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

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