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

package/dist/v1/addressing/class-key.js

@@ -20,10 +20,11 @@ export function ClassKey(input) {
     function is(input) {
         if (typeof input !== 'string' || !Key.is(input))
             return false;
-        const separator = input.indexOf(':');
-        return (input.slice(separator + 1).startsWith('class.') &&
-            !input.includes('.property.') &&
-            !input.includes('.method.'));
+        // Only the coordinate is tested: an origin label may itself be `property` or `method`.
+        const coordinate = input.slice(input.indexOf(':') + 1);
+        return (coordinate.startsWith('class.') &&
+            !coordinate.includes('.property.') &&
+            !coordinate.includes('.method.'));
     }
     ClassKey.is = is;
     function ref(input) {

package/dist/v1/addressing/method-key.js

@@ -21,8 +21,9 @@ export function MethodKey(input) {
     function is(input) {
         if (typeof input !== 'string' || !Key.is(input))
             return false;
-        const coordinate = input.slice(input.indexOf(':') + 1);
-        return coordinate.startsWith('class.') && coordinate.includes('.method.');
+        // The member kind is the third segment: the owner Class may itself be named `method`.
+        const [kind, , member] = input.slice(input.indexOf(':') + 1).split('.');
+        return kind === 'class' && member === 'method';
     }
     MethodKey.is = is;
     function address(input) {

package/dist/v1/addressing/patterns.d.ts

@@ -5,11 +5,6 @@ export declare const MEMBER_NAME_PATTERN: RegExp;
 export declare const DEPENDENCY_ALIAS_PATTERN: RegExp;
 export declare const CORE_SLUG_PATTERN: RegExp;
 export declare const DOMAIN_REVISION_PATTERN: RegExp;
-export declare const DOMAIN_REVISION_FULL_MATCH = "sha256:[0-9a-f]{64}";
-export declare const DOMAIN_ORIGIN_FULL_MATCH = "([a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?\\.)+[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?";
-export declare const MEMBER_NAME_FULL_MATCH = "[A-Za-z][A-Za-z0-9_]*";
-export declare const DEPENDENCY_ALIAS_FULL_MATCH = "[a-z][A-Za-z0-9]*";
-export declare const PROPERTY_KEY_FULL_MATCH = "([a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?\\.)+[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?:class\\.[A-Za-z][A-Za-z0-9_]*\\.property\\.[A-Za-z][A-Za-z0-9_]*";
 export declare const PROPERTY_KEY_PATTERN: RegExp;
 export declare const patterns: Readonly<{
     coreSlug: RegExp;

package/dist/v1/addressing/patterns.js

@@ -3,11 +3,11 @@ export const MEMBER_NAME_PATTERN = /^[A-Za-z][A-Za-z0-9_]*$/u;
 export const DEPENDENCY_ALIAS_PATTERN = /^[a-z][A-Za-z0-9]*$/u;
 export const CORE_SLUG_PATTERN = /^[a-z][a-z0-9-]{0,99}$/u;
 export const DOMAIN_REVISION_PATTERN = /^sha256:[0-9a-f]{64}$/u;
-export const DOMAIN_REVISION_FULL_MATCH = 'sha256:[0-9a-f]{64}';
-export const DOMAIN_ORIGIN_FULL_MATCH = '([a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?\\.)+[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?';
-export const MEMBER_NAME_FULL_MATCH = '[A-Za-z][A-Za-z0-9_]*';
-export const DEPENDENCY_ALIAS_FULL_MATCH = '[a-z][A-Za-z0-9]*';
-export const PROPERTY_KEY_FULL_MATCH = '([a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?\\.)+[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?:class\\.[A-Za-z][A-Za-z0-9_]*\\.property\\.[A-Za-z][A-Za-z0-9_]*';
+const DOMAIN_REVISION_FULL_MATCH = 'sha256:[0-9a-f]{64}';
+const DOMAIN_ORIGIN_FULL_MATCH = '([a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?\\.)+[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?';
+const MEMBER_NAME_FULL_MATCH = '[A-Za-z][A-Za-z0-9_]*';
+const DEPENDENCY_ALIAS_FULL_MATCH = '[a-z][A-Za-z0-9]*';
+const PROPERTY_KEY_FULL_MATCH = '([a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?\\.)+[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?:class\\.[A-Za-z][A-Za-z0-9_]*\\.property\\.[A-Za-z][A-Za-z0-9_]*';
 export const PROPERTY_KEY_PATTERN = new RegExp(`^(?:${PROPERTY_KEY_FULL_MATCH})$`, 'u');
 export const patterns = Object.freeze({
     coreSlug: CORE_SLUG_PATTERN,

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

@@ -1,29 +1,44 @@
-import type { FunctionAuth, MethodInheritance } from '../../language/callable/model/callable.js';
+import type { Value as PortableValue } from '@astrale-os/kernel-dsl/value';
+import type { z } from 'zod';
+import type { PolicyRef } from '../../addressing/index.js';
+import type { BinaryInputProjection, CallableExecution, FunctionAuth } from '../../language/callable/model/callable.js';
 import type { PolicyCheckExpression, PolicyCheckObject, PolicyObjectRef } from '../../language/policy/model/policy.js';
 import type { Class } from '../class/authoring.js';
 import type { ValueSchemaInput } from '../class/property.js';
 import type { CoreNode } from '../core/authoring.js';
 import type { Policy, PolicyInput } from '../policy/authoring.js';
 import type { Lazy } from '../schema/lazy.js';
+import type { TypedValueSchema } from '../value/schema.js';
 import type { View } from '../view/authoring.js';
 import { type AUTHORING } from '../schema/handle.js';
 declare const CALLABLE_OUTPUT: unique symbol;
 declare const CALLABLE_INPUT: unique symbol;
-export interface CallablePolicyContext {
-    readonly input: Readonly<Record<string, Extract<PolicyCheckObject, {
-        readonly kind: 'input';
-    }>>>;
-    readonly self: Extract<PolicyCheckObject, {
+declare const CALLABLE_PROJECTION: unique symbol;
+declare const CALLABLE_PROJECTION_VALUE: unique symbol;
+/**
+ * The check vocabulary of a rule site whose checks name `Object`s: an authorized callable's Policy
+ * and a Node Class rule write their checks with it.
+ */
+export interface PolicyCheckContext<Object extends PolicyCheckObject = PolicyCheckObject> {
+    readonly self: Extract<Object, {
         readonly kind: 'self';
     }>;
-    ref(member: PolicyObjectInput): Extract<PolicyCheckObject, {
+    ref(member: PolicyObjectInput): Extract<Object, {
         readonly kind: 'ref';
     }>;
-    check(policy: PolicyInput, object: PolicyCheckObject): PolicyCheckExpression;
-    allOf(first: PolicyCheckExpression, ...rest: readonly PolicyCheckExpression[]): PolicyCheckExpression;
-    anyOf(first: PolicyCheckExpression, ...rest: readonly PolicyCheckExpression[]): PolicyCheckExpression;
+    check(policy: PolicyInput, object: Object): PolicyCheckExpression<PolicyRef, Object>;
+    sameNode(left: Object, right: Object): PolicyCheckExpression<PolicyRef, Object>;
+    allOf(first: PolicyCheckExpression<PolicyRef, Object>, ...rest: readonly PolicyCheckExpression<PolicyRef, Object>[]): PolicyCheckExpression<PolicyRef, Object>;
+    anyOf(first: PolicyCheckExpression<PolicyRef, Object>, ...rest: readonly PolicyCheckExpression<PolicyRef, Object>[]): PolicyCheckExpression<PolicyRef, Object>;
+}
+export interface CallablePolicyContext extends PolicyCheckContext {
+    readonly input: Readonly<Record<string, Extract<PolicyCheckObject, {
+        readonly kind: 'input';
+    }>>>;
 }
 export type CallablePolicyBuilder = (context: CallablePolicyContext) => PolicyCheckExpression;
+/** The caller rule: Policy checks, or its constant value. Absent means `false`. */
+export type CallablePolicyInput = CallablePolicyBuilder | boolean;
 export interface StreamOutput<out Item extends ValueSchemaInput = ValueSchemaInput> {
     readonly mode: 'stream';
     readonly item: Item;
@@ -34,14 +49,21 @@ export interface BinaryOutput {
     readonly [CALLABLE_OUTPUT]: true;
 }
 export type CallableOutputInput = ValueSchemaInput | StreamOutput | BinaryOutput;
-export interface CallableInputBase {
+export interface BinaryInputAuthoring<out Metadata extends ValueSchemaInput = ValueSchemaInput> {
+    readonly mode: 'binary';
+    readonly metadata: Metadata;
+    readonly maximumBytes: number;
+    readonly [CALLABLE_INPUT]: true;
+}
+export type FunctionInputSchema = ValueSchemaInput | BinaryInputAuthoring;
+export interface CallableInputBase<Input extends FunctionInputSchema = ValueSchemaInput> {
     readonly description?: string;
-    readonly input: ValueSchemaInput;
+    readonly input: Input;
     readonly output: CallableOutputInput;
-    readonly static?: boolean;
-    readonly inheritance?: MethodInheritance;
+    /** `{ durable: true }` makes an invocation return an Execution reference. */
+    readonly execution?: CallableExecution;
 }
-export type CallableInput = CallableInputBase & ({
+type ConcreteCallableInput<Input extends FunctionInputSchema = ValueSchemaInput> = CallableInputBase<Input> & ({
     readonly auth: 'anonymous';
     readonly policy?: never;
 } | {
@@ -49,43 +71,61 @@ export type CallableInput = CallableInputBase & ({
     readonly policy?: never;
 } | {
     readonly auth: 'authorized';
-    readonly policy?: CallablePolicyBuilder;
+    readonly policy?: CallablePolicyInput;
 });
-export type FunctionInput = CallableInput & {
+export type FunctionInput = ConcreteCallableInput<FunctionInputSchema> & {
     readonly static?: never;
-    readonly inheritance?: never;
+    readonly abstract?: never;
 };
-export type MethodInput = CallableInput;
-/** Exact public callable coordinates derived from an authored config. */
-export type AuthoredCallableInput<Input extends ValueSchemaInput, Output extends CallableOutputInput, Auth extends FunctionAuth, Static extends boolean = never, Inheritance extends MethodInheritance = never> = {
-    readonly description?: string;
+export type MethodInput = ConcreteCallableInput & {
+    readonly static?: boolean;
+    /** Require every concrete descendant to declare this contract locally. */
+    readonly abstract?: boolean;
+};
+export type CallableInput = FunctionInput | MethodInput;
+export interface CallableProjection<out Input = unknown, out Output = unknown, out Auth extends FunctionAuth = FunctionAuth, out Static extends boolean = boolean, out Abstract extends boolean = boolean, out Execution extends CallableExecution | undefined = CallableExecution | undefined> {
+    readonly [CALLABLE_PROJECTION_VALUE]: true;
     readonly input: Input;
     readonly output: Output;
     readonly auth: Auth;
-} & (Auth extends 'authorized' ? {
-    readonly policy?: CallablePolicyBuilder;
-} : {
-    readonly policy?: never;
-}) & ([Static] extends [never] ? {} : {
     readonly static: Static;
-}) & ([Inheritance] extends [never] ? {} : {
-    readonly inheritance: Inheritance;
-});
-export interface Function<out Config extends CallableInput = CallableInput> {
+    readonly abstract: Abstract;
+    readonly execution: Execution;
+}
+type ValueInputOf<Schema> = Schema extends TypedValueSchema<infer Value> ? Value : Schema extends z.ZodType ? z.input<Schema> : PortableValue;
+type FunctionInputOf<Schema> = Schema extends BinaryInputAuthoring<infer Metadata> ? BinaryInputProjection<ValueInputOf<Metadata>> : ValueInputOf<Schema>;
+type ValueOutputOf<Schema> = Schema extends TypedValueSchema<infer Value> ? Value : Schema extends z.ZodType ? z.output<Schema> : PortableValue;
+type ExecutionOfConfig<Config extends CallableInput> = Config extends {
+    readonly execution: infer Execution extends CallableExecution;
+} ? Execution : undefined;
+type CallableOutputOf<Input extends CallableOutputInput> = Input extends StreamOutput<infer Item> ? {
+    readonly mode: 'stream';
+    readonly item: ValueOutputOf<Item>;
+} : Input extends BinaryOutput ? {
+    readonly mode: 'binary';
+} : {
+    readonly mode: 'value';
+    readonly value: ValueOutputOf<Input>;
+};
+export interface Function<out Projection = unknown> {
     readonly [AUTHORING]: 'function';
-    readonly [CALLABLE_INPUT]: Config;
+    readonly [CALLABLE_PROJECTION]?: () => Projection;
 }
-export interface Method<out Config extends MethodInput = MethodInput> {
+export interface Method<out Projection = unknown> {
     readonly [AUTHORING]: 'method';
-    readonly [CALLABLE_INPUT]: Config;
+    readonly [CALLABLE_PROJECTION]?: () => Projection;
 }
-export type CallableAuthoringInput<Value extends Function | Method> = Value extends Function<infer Config> ? Config : Value extends Method<infer Config> ? Config : never;
+export type ProjectionOfCallable<Value extends Function | Method> = Value extends Function<infer Projection> ? Projection : Value extends Method<infer Projection> ? Projection : never;
 /** Internal lowering access; Callable authoring handles expose no public configuration object. */
-export declare function callableAuthoringInput<const Value extends Function | Method>(value: Value): CallableAuthoringInput<Value>;
-export type PolicyObjectAuthoring = Class | Function | Policy | View | CoreNode;
-export type PolicyObjectInput = Lazy<PolicyObjectAuthoring>;
-export declare function func<const Config extends FunctionInput>(config: Config): Function<Config>;
-export declare function method<const Config extends MethodInput>(config: Config): Method<Config>;
+export declare function callableConfiguration(value: Function | Method): CallableInput;
+type PolicyObjectAuthoring = Class | Function | Method | Policy | View | CoreNode;
+export type PolicyObjectInput = Lazy<PolicyObjectAuthoring | PolicyObjectRef>;
+export declare function func<const Config extends FunctionInput, Input = FunctionInputOf<Config['input']>, Output = CallableOutputOf<Config['output']>, Auth extends FunctionAuth = Config['auth'], Execution extends CallableExecution | undefined = ExecutionOfConfig<Config>>(config: Config): Function<CallableProjection<Input, Output, Auth, false, false, Execution>>;
+export declare function method<const Config extends MethodInput, Input = ValueInputOf<Config['input']>, Output = CallableOutputOf<Config['output']>, Auth extends FunctionAuth = Config['auth'], Static extends boolean = Config extends {
+    readonly static: true;
+} ? true : false, Abstract extends boolean = Config extends {
+    readonly abstract: infer Value extends boolean;
+} ? Value : false, Execution extends CallableExecution | undefined = ExecutionOfConfig<Config>>(config: Config): Method<CallableProjection<Input, Output, Auth, Static, Abstract, Execution>>;
 export declare function callableInputField(name: string): Extract<PolicyCheckObject, {
     readonly kind: 'input';
 }>;
@@ -95,11 +135,17 @@ export declare function callableSelf(): Extract<PolicyCheckObject, {
 export declare function callableRef(ref: PolicyObjectRef): Extract<PolicyCheckObject, {
     readonly kind: 'ref';
 }>;
-export declare function callablePolicyObject(value: PolicyCheckObject): PolicyCheckObject;
 /** Explicit non-value output contracts. Plain schemas remain value outputs. */
 export declare const output: {
     readonly stream: <const Item extends ValueSchemaInput>(item: Item) => StreamOutput<Item>;
     readonly binary: () => BinaryOutput;
 };
+/** Explicit binary Function input. Plain schemas remain value inputs. */
+export declare const input: {
+    readonly binary: <const Metadata extends ValueSchemaInput>(metadata: Metadata, options: {
+        readonly maximumBytes: number;
+    }) => BinaryInputAuthoring<Metadata>;
+};
+export declare function isBinaryInputAuthoring(value: FunctionInputSchema): value is BinaryInputAuthoring;
 export declare function isCallableOutputAuthoring(value: CallableOutputInput): value is StreamOutput | BinaryOutput;
 export {};

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

@@ -1,9 +1,12 @@
 import { assertKnownKeys } from '../schema/diagnostic.js';
 import { authoringValue, isAuthoringValue } from '../schema/handle.js';
-const CALLABLE_INPUT = Symbol('astrale.v1.callable-input');
+const callableInputs = new WeakMap();
 /** Internal lowering access; Callable authoring handles expose no public configuration object. */
-export function callableAuthoringInput(value) {
-    return value[CALLABLE_INPUT];
+export function callableConfiguration(value) {
+    const input = callableInputs.get(value);
+    if (input === undefined)
+        throw new TypeError('Unknown Callable authoring handle.');
+    return input;
 }
 export function func(config) {
     assertKnownKeys(config, [
@@ -13,11 +16,12 @@ export function func(config) {
         'auth',
         'policy',
         'static',
-        'inheritance',
+        'abstract',
+        'execution',
     ]);
-    return authoringValue('function', {
-        [CALLABLE_INPUT]: { ...config },
-    });
+    const value = authoringValue('function', {});
+    callableInputs.set(value, { ...config });
+    return value;
 }
 export function method(config) {
     assertKnownKeys(config, [
@@ -27,11 +31,12 @@ export function method(config) {
         'auth',
         'policy',
         'static',
-        'inheritance',
+        'abstract',
+        'execution',
     ]);
-    return authoringValue('method', {
-        [CALLABLE_INPUT]: { ...config },
-    });
+    const value = authoringValue('method', {});
+    callableInputs.set(value, { ...config });
+    return value;
 }
 export function callableInputField(name) {
     return Object.freeze({ kind: 'input', field: name });
@@ -42,9 +47,6 @@ export function callableSelf() {
 export function callableRef(ref) {
     return Object.freeze({ kind: 'ref', ref: Object.freeze({ ...ref }) });
 }
-export function callablePolicyObject(value) {
-    return value;
-}
 /** Explicit non-value output contracts. Plain schemas remain value outputs. */
 export const output = Object.freeze({
     stream(item) {
@@ -59,6 +61,19 @@ export const output = Object.freeze({
         });
     },
 });
+/** Explicit binary Function input. Plain schemas remain value inputs. */
+export const input = Object.freeze({
+    binary(metadata, options) {
+        return authoringValue('callable-input', {
+            mode: 'binary',
+            metadata,
+            maximumBytes: options.maximumBytes,
+        });
+    },
+});
+export function isBinaryInputAuthoring(value) {
+    return isAuthoringValue(value, 'callable-input');
+}
 export function isCallableOutputAuthoring(value) {
     return isAuthoringValue(value, 'callable-output');
 }