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

package/dist/v1/compiled/loader/load.js

@@ -1,10 +1,11 @@
 import { Key, MethodKey, PropertyKey as PropertyKeyValue } from '../../addressing/index.js';
 import { compareUnicode } from '../../addressing/ordering.js';
 import { createDomain } from '../../domain/create.js';
-import { combineDomainValidation, createDomainValidation, unknownInputField, } from '../../domain/validation/create.js';
+import { createDomainValidation, unknownInputField } from '../../domain/validation/create.js';
 import { bindValueProgram } from '../../language/value/compile/load.js';
 import { validateValueProgram } from '../../language/value/evaluate/program.js';
 import { acceptCompiledSchema } from '../admission/accept.js';
+import { schemaOf, sourceFunction, sourceMethod } from '../admission/revision.js';
 export function load(input) {
     return realize(acceptCompiledSchema(input));
 }
@@ -14,13 +15,14 @@ export function load(input) {
  */
 export function realize(compiled) {
     const entries = new Map(compiled.closure.map((entry) => [entry.origin, loadEntry(entry)]));
+    const loaded = [...entries.values()];
     const root = entries.get(compiled.root.origin);
     if (root === undefined || root.entry.revision !== compiled.root.revision) {
         throw new TypeError('Compiled root is absent or has the wrong revision.');
     }
     return createDomain({
         root: compiled.root,
-        entries: Object.freeze([...entries.values()]
+        entries: Object.freeze(loaded
             .map(({ entry, definitions }) => Object.freeze({
             origin: entry.origin,
             revision: entry.revision,
@@ -29,7 +31,8 @@ export function realize(compiled) {
             coreEdges: entry.facts.core,
         }))
             .sort((left, right) => compareUnicode(left.origin, right.origin))),
-        validation: combineDomainValidation([...entries.values()].map(({ validation }) => validation)),
+        // Closure admission refuses a duplicate Definition, so no two entries share a key.
+        validation: createDomainValidation(new Map(loaded.flatMap(({ properties }) => [...properties])), new Map(loaded.flatMap(({ callables }) => [...callables]))),
     });
 }
 function loadEntry(entry) {
@@ -52,13 +55,13 @@ function loadEntry(entry) {
         const methods = Object.fromEntries(compiled.methods.map((method) => {
             const key = MethodKey.of(compiled.ref, method.name);
             callablePrograms.set(key, callableProgram(method));
-            return [method.name, loadMethod(entry, method)];
+            return [method.name, Object.freeze(sourceMethod(entry, method))];
         }));
         return Object.freeze({ ...definition, properties, methods });
     });
     const functions = entry.definitions.functions.map((compiled) => {
         callablePrograms.set(Key.of(compiled.ref), callableProgram(compiled));
-        return loadFunction(entry, compiled);
+        return Object.freeze(sourceFunction(entry, compiled));
     });
     return {
         entry,
@@ -69,46 +72,9 @@ function loadEntry(entry) {
             ...entry.definitions.views,
             ...entry.definitions.core,
         ]),
-        validation: programValidation(entry.values.map((value) => bindValueProgram(value, entry.patterns)), propertyPrograms, propertyOrdering, callablePrograms),
+        ...programValidation(entry.values.map((value) => bindValueProgram(value, entry.patterns)), propertyPrograms, propertyOrdering, callablePrograms),
     };
 }
-function loadMethod(entry, value) {
-    const { name: _, input, fields: __, output, ...definition } = value;
-    return Object.freeze({
-        ...definition,
-        input: schemaOf(entry, input),
-        output: loadOutput(entry, output),
-    });
-}
-function loadFunction(entry, value) {
-    const { input, fields: _, output, ...definition } = value;
-    return Object.freeze({
-        ...definition,
-        input: typeof input === 'number'
-            ? schemaOf(entry, input)
-            : {
-                mode: 'binary',
-                metadata: schemaOf(entry, input.metadata),
-                maximumBytes: input.maximumBytes,
-            },
-        output: loadOutput(entry, output),
-    });
-}
-function loadOutput(entry, output) {
-    if (output.mode === 'binary')
-        return output;
-    const schema = schemaOf(entry, output.value);
-    return output.mode === 'value'
-        ? { mode: 'value', schema }
-        : { mode: 'stream', item: schema };
-}
-function schemaOf(entry, index) {
-    const program = entry.values[index];
-    const root = program?.nodes[program.root];
-    if (root === undefined)
-        throw new TypeError(`Compiled Value program ${index} is absent.`);
-    return root.schema;
-}
 function callableProgram(value) {
     return {
         input: typeof value.input === 'number' ? value.input : value.input.metadata,
@@ -141,7 +107,7 @@ function programValidation(programs, properties, propertyOrdering, callables) {
             ...(callable.fields === undefined
                 ? {}
                 : { fields: Object.freeze(Object.keys(callable.fields)) }),
-            validateInput: (value) => validateValueProgram(input, value),
+            validateInput: (value, options) => validateValueProgram(input, value, [input.root], options),
             validateInputField(field, value) {
                 const nodes = callable.fields?.[field];
                 return nodes === undefined
@@ -151,5 +117,5 @@ function programValidation(programs, properties, propertyOrdering, callables) {
             validateOutput: (value) => output === undefined ? [] : validateValueProgram(output, value),
         }));
     }
-    return createDomainValidation(propertyValidation, callableValidation);
+    return { properties: propertyValidation, callables: callableValidation };
 }

package/dist/v1/domain/create.js

@@ -1,4 +1,5 @@
 import { Key, MethodKey } from '../addressing/index.js';
+import { compareCodeUnits } from '../addressing/ordering.js';
 import { frozenRecord } from './namespace/member-collection.js';
 import { createClasses } from './projection/classes.js';
 const admittedDomains = new WeakSet();
@@ -43,7 +44,7 @@ export function createDomain(input) {
         const visibleOrigins = new Set(visibleEntries.map(({ origin }) => origin));
         const local = [...definitionsByKey.values()]
             .filter(({ ref }) => ref.origin === entry.origin)
-            .sort((left, right) => compare(left.key, right.key));
+            .sort((left, right) => compareCodeUnits(left.key, right.key));
         const classes = namespace(local, 'class');
         const functions = namespace(local, 'function');
         const policies = namespace(local, 'policy');
@@ -86,7 +87,7 @@ export function createDomain(input) {
             revision: entry.revision,
             closure: Object.freeze(visibleEntries
                 .map(({ origin, revision }) => Object.freeze({ origin, revision }))
-                .sort((left, right) => compare(left.origin, right.origin))),
+                .sort((left, right) => compareCodeUnits(left.origin, right.origin))),
             dependencies,
             classes,
             functions,
@@ -130,11 +131,12 @@ function createDefinitions(declarations, classesByKey, input) {
                 input: definition.input,
                 output: definition.output,
                 ...(definition.execution === undefined ? {} : { execution: definition.execution }),
+                ...(definition.admission === undefined ? {} : { admission: definition.admission }),
                 auth: definition.auth,
                 policy: definition.policy,
                 ...(inputFields === undefined ? {} : { inputFields }),
                 definition,
-                validateInput: (value) => input.validation.callableInput(key, value),
+                validateInput: (value, options) => input.validation.callableInput(key, value, options),
                 validateInputField: (field, value) => input.validation.callableInputField(key, field, value),
                 validateOutput: (value) => input.validation.callableOutput(key, value),
             });
@@ -249,6 +251,3 @@ function isViewDefinition(value) {
 function isCoreDefinition(value) {
     return value.ref.kind === 'core';
 }
-function compare(left, right) {
-    return left < right ? -1 : left > right ? 1 : 0;
-}

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

@@ -1,11 +1,6 @@
 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';
+import type { AnyResolvedClass, MethodOwnerKeyOf, PropertyInputOf, ResolvedCallable, ResolvedCoreDefinition, ResolvedCoreEdge, ResolvedDefinition, ResolvedDefinitionOf, ResolvedFunction, ResolvedPolicy, ResolvedView } from '../../language/index.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>;
@@ -53,6 +48,6 @@ export type MethodOwnerOf<Work extends Domain, Method> = Extract<ClassesOf<Work>
 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 PropertyInputFor<Class extends AnyResolvedClass> = PropertyInputOf<Class>;
 export type PropertyValuesFor<Class extends AnyResolvedClass> = ReturnType<Class['properties']['from']>;
 export {};

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

@@ -1,3 +1,4 @@
+import type { Options } from '@astrale-os/kernel-dsl/value';
 import type { Key as AddressKey, PropertyKey, Revision } from '../../addressing/index.js';
 import type { DomainDependency, DomainDependencyMap } from '../../addressing/index.js';
 import type { CoreEdge } from '../../language/core/model/core.js';
@@ -27,7 +28,7 @@ export interface DomainValidation {
     propertyProgram(key: PropertyKey): ValueProgram;
     propertyOrdering(key: PropertyKey): OrderingKind | undefined;
     callableExists(key: AddressKey.Callable): boolean;
-    callableInput(key: AddressKey.Callable, input: unknown): readonly Diagnostic[];
+    callableInput(key: AddressKey.Callable, input: unknown, options?: Options): 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/namespace/member-collection.js

@@ -1,9 +1,10 @@
 import { PropertyKey as PropertyKeyValue } from '../../addressing/index.js';
+import { compareCodeUnits } from '../../addressing/ordering.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 ordered = [...values].sort((left, right) => compareCodeUnits(left.key, right.key));
     const byKey = frozenRecord(ordered.map((value) => [value.key, value]));
     const named = uniqueNames(ordered);
     const collection = {
@@ -39,7 +40,7 @@ export function createPropertyCollection(values) {
     return Object.freeze(collection);
 }
 export function createMethodCollection(values) {
-    const ordered = [...values].sort((left, right) => compare(left.key, right.key));
+    const ordered = [...values].sort((left, right) => compareCodeUnits(left.key, right.key));
     const byKey = frozenRecord(ordered.map((value) => [value.key, value]));
     const named = uniqueNames(ordered);
     const collection = {
@@ -71,11 +72,8 @@ function installShortcuts(target, named, reserved) {
 }
 export function frozenRecord(entries) {
     const output = Object.create(null);
-    for (const [key, value] of [...entries].sort(([left], [right]) => compare(left, right))) {
+    for (const [key, value] of [...entries].sort(([left], [right]) => compareCodeUnits(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.js

@@ -70,6 +70,9 @@ export function createClasses(definitions, validation) {
                     ...(methodDefinition.execution === undefined
                         ? {}
                         : { execution: methodDefinition.execution }),
+                    ...(methodDefinition.admission === undefined
+                        ? {}
+                        : { admission: methodDefinition.admission }),
                     auth: methodDefinition.auth,
                     policy: methodDefinition.policy,
                     static: methodDefinition.static,
@@ -77,7 +80,7 @@ export function createClasses(definitions, validation) {
                     executable: isMethodExecutable(definition, methodDefinition),
                     ...(inputFields === undefined ? {} : { inputFields }),
                     definition: methodDefinition,
-                    validateInput: (input) => validation.callableInput(methodKey, input),
+                    validateInput: (input, options) => validation.callableInput(methodKey, input, options),
                     validateInputField: (field, input) => validation.callableInputField(methodKey, field, input),
                     validateOutput: (output) => validation.callableOutput(methodKey, output),
                 });

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

@@ -1,3 +1,4 @@
+import type { Options } from '@astrale-os/kernel-dsl/value';
 import type { Key, PropertyKey } from '../../addressing/index.js';
 import type { Diagnostic } from '../../language/validation/diagnostic.js';
 import type { ValueProgram } from '../../language/value/compile/model.js';
@@ -10,11 +11,13 @@ export interface PropertyValidation {
 }
 export interface CallableValidation {
     readonly fields?: readonly string[];
-    validateInput(input: unknown): readonly Diagnostic[];
+    validateInput(input: unknown, options?: Options): 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. */
+/**
+ * Build the one Domain-level router shared by source resolution and compiled loading. The Domain
+ * built from the same entries asks only for the Properties and Callables they declare.
+ */
 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

@@ -1,69 +1,30 @@
-/** Build the one Domain-level router shared by source resolution and compiled loading. */
+/**
+ * Build the one Domain-level router shared by source resolution and compiled loading. The Domain
+ * built from the same entries asks only for the Properties and Callables they declare.
+ */
 export function createDomainValidation(properties, callables) {
+    const propertyOf = (key) => {
+        const target = properties.get(key);
+        if (target === undefined)
+            throw new TypeError(`Property ${key} is absent.`);
+        return target;
+    };
+    const callableOf = (key) => {
+        const target = callables.get(key);
+        if (target === undefined)
+            throw new TypeError(`Callable ${key} is absent.`);
+        return target;
+    };
     const validation = {
         propertyExists: (key) => properties.has(key),
-        property(key, input) {
-            const target = properties.get(key);
-            return target === undefined ? unknownTarget('Property', key) : target.validate(input);
-        },
-        propertyProgram(key) {
-            const target = properties.get(key);
-            if (target === undefined)
-                throw new TypeError(`Property ${key} is absent.`);
-            return target.program();
-        },
+        property: (key, input) => propertyOf(key).validate(input),
+        propertyProgram: (key) => propertyOf(key).program(),
         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);
-        },
+        callableInput: (key, input, options) => callableOf(key).validateInput(input, options),
         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);
-        },
-        propertyProgram(key) {
-            const owner = values.find((value) => value.propertyExists(key));
-            if (owner === undefined)
-                throw new TypeError(`Property ${key} is absent.`);
-            return owner.propertyProgram(key);
-        },
-        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);
-        },
+        callableInputField: (key, field, input) => callableOf(key).validateInputField(field, input),
+        callableOutput: (key, output) => callableOf(key).validateOutput(output),
     };
     return Object.freeze(validation);
 }
@@ -76,12 +37,3 @@ export function unknownInputField(field) {
         }),
     ];
 }
-function unknownTarget(kind, key) {
-    return [
-        Object.freeze({
-            code: 'DOMAIN_VALIDATION_TARGET_UNKNOWN',
-            pointer: '',
-            message: `${kind} ${key} is absent.`,
-        }),
-    ];
-}

package/dist/v1/index.d.ts

@@ -5,7 +5,7 @@ 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, CallablePolicy, ClassPolicy, ClassRuleChecks, ClassRuleObject, NodeClassPolicy, PolicyCheckExpression, PolicyDefinition, PropertyImmutability, 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 type { AnyResolvedClass, BoundMethodOf, BoundMethodShortcutsOf, CallableResultOf, CallableInputOf, CallableInputModeOf, CallableOutputOf, ClassSatisfactionKeysOf, ClassDefinition, CoreDefinition, CoreEdge, FunctionAuth, FunctionDefinition, Inheritance, BinaryInput, BinaryInputProjection, CallableInputContract, MethodDefinition, MethodOwnerKeyOf, CallablePolicy, ClassPolicy, ClassRuleChecks, ClassRuleObject, ClassWritePolicy, CreateRuleChecks, EdgeClassPolicy, EdgeClassWritePolicy, EdgeRuleChecks, NodeClassCreatePolicy, NodeClassPolicy, NodeClassWritePolicy, PolicyCheckExpression, PolicyDefinition, PropertyImmutability, 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';
@@ -14,6 +14,7 @@ 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 { BlobReceipt, BlobRef } from './language/value/model/blob.js';
 export type { CompiledSchema } from './compiled/index.js';
 export * as schema from './schema/index.js';
 export * as bundle from './bundle/index.js';