@astrale-os/sdk 0.5.0-beta.13 → 0.5.0-beta.130

package/dist/application/query/single/selection.d.ts

@@ -0,0 +1,2 @@
+import type { QueryResult, QuerySelectionFor } from '@astrale-os/kernel-core/graph/query';
+export declare function completeSelection<Result extends QueryResult>(pages: readonly [Result, ...Result[]]): QuerySelectionFor<Result>;

package/dist/application/query/single/selection.js

@@ -0,0 +1,23 @@
+import { QueryResult as QueryResultValue } from '@astrale-os/kernel-core/graph/query';
+export function completeSelection(pages) {
+    const first = QueryResultValue.selection(pages[0]);
+    if (first.kind === 'node') {
+        const ids = pages.flatMap((page) => {
+            const next = QueryResultValue.selection(page);
+            if (next.kind !== 'node')
+                changed(first, next);
+            return next.ids;
+        });
+        return Object.freeze({ kind: 'node', ids: Object.freeze(ids) });
+    }
+    const keys = pages.flatMap((page) => {
+        const next = QueryResultValue.selection(page);
+        if (next.kind !== 'edge')
+            changed(first, next);
+        return next.keys;
+    });
+    return Object.freeze({ kind: 'edge', keys: Object.freeze(keys) });
+}
+function changed(first, next) {
+    throw new TypeError(`Paginated Query selection changed from ${first.kind} to ${next.kind}.`);
+}

package/dist/application/requirements/authority.d.ts

@@ -0,0 +1,7 @@
+import type { AuthorityOperation } from '../../platform/schema/index.js';
+import type { AuthorityRequirements } from './requirement.js';
+export interface AuthorityRequirementsInput {
+    readonly grant?: readonly [AuthorityOperation, ...AuthorityOperation[]];
+    readonly revoke?: readonly [AuthorityOperation, ...AuthorityOperation[]];
+}
+export declare function captureAuthority(input: AuthorityRequirementsInput | undefined): AuthorityRequirements | undefined;

package/dist/application/requirements/authority.js

@@ -0,0 +1,38 @@
+import { AuthorityOperationOrder } from '../../platform/schema/index.js';
+export function captureAuthority(input) {
+    if (input === undefined)
+        return undefined;
+    if (input === null || typeof input !== 'object' || Array.isArray(input))
+        invalid();
+    const keys = Reflect.ownKeys(input);
+    if (keys.some((key) => key !== 'grant' && key !== 'revoke'))
+        invalid();
+    if (input.grant === undefined && input.revoke === undefined) {
+        throw new TypeError('Authority requirements cannot be empty.');
+    }
+    const grant = operations(input.grant, 'grant');
+    const revoke = operations(input.revoke, 'revoke');
+    return Object.freeze({
+        ...(grant === undefined ? {} : { grant }),
+        ...(revoke === undefined ? {} : { revoke }),
+    });
+}
+function operations(input, kind) {
+    if (input === undefined)
+        return undefined;
+    if (!Array.isArray(input) || input.length === 0) {
+        throw new TypeError(`Authority ${kind} operations cannot be empty.`);
+    }
+    for (const operation of input) {
+        if (!AuthorityOperationOrder.includes(operation)) {
+            throw new TypeError(`Unknown authority ${kind} operation ${String(operation)}.`);
+        }
+    }
+    if (new Set(input).size !== input.length) {
+        throw new TypeError(`Authority ${kind} operations must be unique.`);
+    }
+    return Object.freeze([...input].sort((left, right) => AuthorityOperationOrder.indexOf(left) - AuthorityOperationOrder.indexOf(right)));
+}
+function invalid() {
+    throw new TypeError('Authority requirements may contain only grant and revoke.');
+}

package/dist/application/requirements/classes.d.ts

@@ -0,0 +1,9 @@
+import type { AnyResolvedClass } from '../../platform/schema/index.js';
+import type { ClassRequirement } from './requirement.js';
+export declare const ClassOperationOrder: readonly ["create", "read", "traverse", "update", "delete"];
+export type ClassOperation = (typeof ClassOperationOrder)[number];
+export interface ClassRequirementInput {
+    readonly class: Pick<AnyResolvedClass, 'ref'>;
+    readonly operations: readonly [ClassOperation, ...ClassOperation[]];
+}
+export declare function captureClasses(input: readonly ClassRequirementInput[] | undefined): readonly ClassRequirement[];

package/dist/application/requirements/classes.js

@@ -0,0 +1,52 @@
+import { acceptDefinitionRef, Key } from '../../platform/schema/index.js';
+export const ClassOperationOrder = Object.freeze([
+    'create',
+    'read',
+    'traverse',
+    'update',
+    'delete',
+]);
+export function captureClasses(input) {
+    if (input === undefined)
+        return Object.freeze([]);
+    if (!Array.isArray(input))
+        throw new TypeError('Requirement classes must be an array.');
+    const classes = input.map((entry) => {
+        if (entry === null || typeof entry !== 'object' || !Array.isArray(entry.operations)) {
+            throw new TypeError('Class requirement is invalid.');
+        }
+        let ref;
+        try {
+            const admitted = acceptDefinitionRef(entry.class?.ref);
+            if (admitted.kind !== 'class')
+                throw new TypeError('Expected Class reference.');
+            ref = admitted;
+        }
+        catch (cause) {
+            throw new TypeError('Class requirement target is invalid.', { cause });
+        }
+        if (entry.operations.length === 0) {
+            throw new TypeError('Class requirement operations cannot be empty.');
+        }
+        const operations = entry.operations.map((operation) => {
+            if (!ClassOperationOrder.includes(operation)) {
+                throw new TypeError(`Unknown Class requirement operation ${String(operation)}.`);
+            }
+            return operation;
+        });
+        unique(operations, 'Class requirement operation');
+        return Object.freeze({
+            class: ref,
+            operations: Object.freeze([...operations].sort((left, right) => ClassOperationOrder.indexOf(left) - ClassOperationOrder.indexOf(right))),
+        });
+    });
+    unique(classes.map((entry) => Key.of(entry.class)), 'Class requirement');
+    return Object.freeze([...classes].sort((left, right) => compare(Key.of(left.class), Key.of(right.class))));
+}
+function unique(values, label) {
+    if (new Set(values).size !== values.length)
+        throw new TypeError(`${label}s must be unique.`);
+}
+function compare(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}

package/dist/application/requirements/core.d.ts

@@ -0,0 +1,14 @@
+import type { ResolvedCoreDefinition } from '../../platform/schema/index.js';
+import type { AuthorityRequirementsInput } from './authority.js';
+import type { ClassRequirementInput } from './classes.js';
+import type { FunctionRequirementTarget } from './functions.js';
+import type { CoreRequirement } from './requirement.js';
+/** Capabilities assigned to one installation-owned local Core Identity. */
+export interface CoreRequirementInput {
+    readonly subject: Pick<ResolvedCoreDefinition, 'ref'>;
+    /** Exact executable local callables or direct dependency callables; does not bypass Policies. */
+    readonly functions?: readonly FunctionRequirementTarget[];
+    readonly classes?: readonly ClassRequirementInput[];
+    readonly authority?: AuthorityRequirementsInput;
+}
+export declare function captureCore(input: readonly CoreRequirementInput[] | undefined): readonly CoreRequirement[];

package/dist/application/requirements/core.js

@@ -0,0 +1,41 @@
+import { acceptDefinitionRef, Key } from '../../platform/schema/index.js';
+import { captureAuthority } from './authority.js';
+import { captureClasses } from './classes.js';
+import { captureFunctions } from './functions.js';
+export function captureCore(input) {
+    if (input === undefined)
+        return Object.freeze([]);
+    if (!Array.isArray(input))
+        throw new TypeError('Core requirements must be an array.');
+    const core = input.map((entry) => {
+        if (entry === null || typeof entry !== 'object' || Array.isArray(entry))
+            invalid();
+        if (Reflect.ownKeys(entry).some((key) => key !== 'subject' && key !== 'functions' && key !== 'classes' && key !== 'authority')) {
+            invalid();
+        }
+        const admitted = acceptDefinitionRef(entry.subject?.ref);
+        if (admitted.kind !== 'core')
+            invalid();
+        const subject = admitted;
+        const functions = captureFunctions(entry.functions);
+        const classes = captureClasses(entry.classes);
+        const authority = captureAuthority(entry.authority);
+        if (functions.length === 0 && classes.length === 0 && authority === undefined)
+            invalid();
+        return Object.freeze({
+            subject,
+            functions,
+            classes,
+            ...(authority === undefined ? {} : { authority }),
+        });
+    });
+    if (new Set(core.map(({ subject }) => Key.of(subject))).size !== core.length)
+        invalid();
+    return Object.freeze([...core].sort((left, right) => compare(Key.of(left.subject), Key.of(right.subject))));
+}
+function invalid() {
+    throw new TypeError('Core capability requirement is invalid.');
+}
+function compare(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}

package/dist/application/requirements/functions.d.ts

@@ -0,0 +1,4 @@
+import type { ResolvedFunction, ResolvedMethod } from '../../platform/schema/index.js';
+import type { Key as SemanticKey } from '../../platform/schema/index.js';
+export type FunctionRequirementTarget = Pick<ResolvedFunction, 'key'> | Pick<ResolvedMethod, 'key'>;
+export declare function captureFunctions(input: readonly FunctionRequirementTarget[] | undefined): readonly SemanticKey.Callable[];

package/dist/application/requirements/functions.js

@@ -0,0 +1,30 @@
+import { callableAddress, Key } from '../../platform/schema/index.js';
+export function captureFunctions(input) {
+    if (input === undefined)
+        return Object.freeze([]);
+    if (!Array.isArray(input))
+        throw new TypeError('Requirement functions must be an array.');
+    const keys = input.map((target) => {
+        if (target === null || typeof target !== 'object' || typeof target.key !== 'string') {
+            throw new TypeError('Function requirement target is invalid.');
+        }
+        let key;
+        try {
+            key = Key(target.key);
+            callableAddress(key);
+        }
+        catch (cause) {
+            throw new TypeError('Function requirement target is invalid.', { cause });
+        }
+        return key;
+    });
+    unique(keys, 'Function requirement');
+    return Object.freeze([...keys].sort(compare));
+}
+function unique(values, label) {
+    if (new Set(values).size !== values.length)
+        throw new TypeError(`${label}s must be unique.`);
+}
+function compare(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}

package/dist/application/requirements/index.d.ts

@@ -0,0 +1,19 @@
+import type { AuthorityRequirementsInput } from './authority.js';
+import type { ClassRequirementInput } from './classes.js';
+import type { CoreRequirementInput } from './core.js';
+import type { FunctionRequirementTarget } from './functions.js';
+import type { Requirements } from './requirement.js';
+export type { AuthorityRequirements, CoreRequirement, ClassRequirement, Requirements, } from './requirement.js';
+export { ClassOperationOrder, type ClassOperation, type ClassRequirementInput } from './classes.js';
+export type { FunctionRequirementTarget } from './functions.js';
+export type { AuthorityRequirementsInput } from './authority.js';
+export type { CoreRequirementInput } from './core.js';
+export interface RequirementsInput {
+    readonly functions?: readonly FunctionRequirementTarget[];
+    readonly classes?: readonly ClassRequirementInput[];
+    readonly authority?: AuthorityRequirementsInput;
+    readonly core?: readonly CoreRequirementInput[];
+}
+/** Capture canonical dependency requirements; Build proves the pinned dependency closure. */
+export declare function requirements(input?: RequirementsInput): Requirements;
+export declare function isRequirements(input: unknown): input is Requirements;

package/dist/application/requirements/index.js

@@ -0,0 +1,32 @@
+import { captureAuthority } from './authority.js';
+import { captureClasses } from './classes.js';
+import { captureCore } from './core.js';
+import { captureFunctions } from './functions.js';
+export { ClassOperationOrder } from './classes.js';
+const admittedRequirements = new WeakSet();
+/** Capture canonical dependency requirements; Build proves the pinned dependency closure. */
+export function requirements(input = {}) {
+    if (input === null || typeof input !== 'object' || Array.isArray(input))
+        invalid();
+    if (Reflect.ownKeys(input).some((key) => key !== 'functions' && key !== 'classes' && key !== 'authority' && key !== 'core')) {
+        invalid();
+    }
+    const functions = captureFunctions(input.functions);
+    const classes = captureClasses(input.classes);
+    const authority = captureAuthority(input.authority);
+    const core = captureCore(input.core);
+    const value = Object.freeze({
+        functions,
+        classes,
+        core,
+        ...(authority === undefined ? {} : { authority }),
+    });
+    admittedRequirements.add(value);
+    return value;
+}
+export function isRequirements(input) {
+    return input !== null && typeof input === 'object' && admittedRequirements.has(input);
+}
+function invalid() {
+    throw new TypeError('Requirements definition may contain only functions, classes, authority, and core.');
+}

package/dist/application/requirements/requirement.d.ts

@@ -0,0 +1,25 @@
+import type { AuthorityOperation } from '../../platform/schema/index.js';
+import type { ClassRef, CoreRef, Key } from '../../platform/schema/index.js';
+import type { ClassOperation } from './classes.js';
+export interface ClassRequirement {
+    readonly class: ClassRef;
+    readonly operations: readonly [ClassOperation, ...ClassOperation[]];
+}
+export interface AuthorityRequirements {
+    readonly grant?: readonly [AuthorityOperation, ...AuthorityOperation[]];
+    readonly revoke?: readonly [AuthorityOperation, ...AuthorityOperation[]];
+}
+/** Canonical author intent; dependency-closure validation belongs to Build compilation. */
+export interface Requirements {
+    readonly functions: readonly Key.Callable[];
+    readonly classes: readonly ClassRequirement[];
+    readonly authority?: AuthorityRequirements;
+    readonly core: readonly CoreRequirement[];
+}
+/** Capabilities assigned at installation to one Identity declared in the local Core. */
+export interface CoreRequirement {
+    readonly subject: CoreRef;
+    readonly functions: readonly Key.Callable[];
+    readonly classes: readonly ClassRequirement[];
+    readonly authority?: AuthorityRequirements;
+}

package/dist/application/requirements/requirement.js

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

package/dist/application/routes/admission.d.ts

@@ -0,0 +1,5 @@
+import type { publication } from '@astrale-os/kernel-protocol';
+import type { RuntimeRegistry } from '../runtime/index.js';
+import type { Routes } from './collection.js';
+/** Lower recipe identities to canonical callable keys after Runtime admission. */
+export declare function admit(input: Routes | undefined, registry: RuntimeRegistry): readonly publication.HttpRouteDeclaration[];

package/dist/application/routes/admission.js

@@ -0,0 +1,15 @@
+import { isRoutes } from './collection.js';
+/** Lower recipe identities to canonical callable keys after Runtime admission. */
+export function admit(input, registry) {
+    if (input === undefined)
+        return Object.freeze([]);
+    if (!isRoutes(input))
+        throw new TypeError('Application routes are not admitted.');
+    return Object.freeze(input.entries.map(({ target, ...declaration }) => {
+        const implementation = registry.implementations.find(({ definition }) => definition === target);
+        if (implementation === undefined) {
+            throw new TypeError(`Route ${declaration.name} targets a recipe outside the Runtime.`);
+        }
+        return Object.freeze({ ...declaration, callable: implementation.callable.key });
+    }));
+}

package/dist/application/routes/collection.d.ts

@@ -0,0 +1,8 @@
+import type { Route } from './route.js';
+export interface Routes<Entries extends readonly Route[] = readonly Route[]> {
+    readonly entries: Entries;
+}
+export declare function routes<const Entries extends readonly Route[]>(entries: Entries): Routes<Entries>;
+export declare function isRoutes(input: unknown): input is Routes;
+export declare function captureRoute<RouteValue extends Route>(route: RouteValue): RouteValue;
+export declare function isRoute(input: unknown): input is Route;

package/dist/application/routes/collection.js

@@ -0,0 +1,23 @@
+const admittedCollections = new WeakSet();
+export function routes(entries) {
+    if (!Array.isArray(entries) || entries.some((entry) => !isRoute(entry))) {
+        throw new TypeError('Routes must contain only values created by route().');
+    }
+    const names = entries.map(({ name }) => name);
+    if (new Set(names).size !== names.length)
+        throw new TypeError('Route names must be unique.');
+    const collection = Object.freeze({ entries: Object.freeze([...entries]) });
+    admittedCollections.add(collection);
+    return collection;
+}
+export function isRoutes(input) {
+    return input !== null && typeof input === 'object' && admittedCollections.has(input);
+}
+const admittedRoutes = new WeakSet();
+export function captureRoute(route) {
+    admittedRoutes.add(route);
+    return route;
+}
+export function isRoute(input) {
+    return input !== null && typeof input === 'object' && admittedRoutes.has(input);
+}

package/dist/application/routes/index.d.ts

@@ -0,0 +1,9 @@
+import type { Route, RouteInput, RouteTarget } from './route.js';
+export { admit } from './admission.js';
+export { isRoute, isRoutes, routes, type Routes } from './collection.js';
+export type { Route, RouteInput, RouteTarget } from './route.js';
+type Recipe = RouteTarget & {
+    readonly run: (...input: never[]) => unknown;
+};
+/** Define one HTTP route without exposing DSL Function or Method topology. */
+export declare function route<const Target extends Recipe>(target: Target, input: RouteInput): Route<Target>;

package/dist/application/routes/index.js

@@ -0,0 +1,45 @@
+import { isAction } from '../action/index.js';
+import { isWorkflow } from '../workflow/index.js';
+import { captureRoute } from './collection.js';
+export { admit } from './admission.js';
+export { isRoute, isRoutes, routes } from './collection.js';
+/** Define one HTTP route without exposing DSL Function or Method topology. */
+export function route(target, input) {
+    if (!isAction(target) && !isWorkflow(target)) {
+        throw new TypeError('Route target must be an admitted Action or Workflow.');
+    }
+    if (input === null || typeof input !== 'object' || Array.isArray(input))
+        invalid();
+    const allowed = new Set([
+        'name',
+        'path',
+        'method',
+        'requestMethod',
+        'default',
+        'receiver',
+        'query',
+        'headers',
+        'body',
+        'credential',
+    ]);
+    if (Reflect.ownKeys(input).some((key) => !allowed.has(key)))
+        invalid();
+    return captureRoute(Object.freeze({
+        target,
+        ...detach(input),
+    }));
+}
+function detach(input) {
+    return deepFreeze(structuredClone(input));
+}
+function deepFreeze(input) {
+    if (input !== null && typeof input === 'object') {
+        for (const value of Object.values(input))
+            deepFreeze(value);
+        Object.freeze(input);
+    }
+    return input;
+}
+function invalid() {
+    throw new TypeError('Route input contains unsupported fields.');
+}

package/dist/application/routes/route.d.ts

@@ -0,0 +1,10 @@
+import type { publication } from '@astrale-os/kernel-protocol';
+export interface RouteTarget {
+    readonly kind: 'action' | 'workflow';
+    readonly address: string;
+}
+export type RouteInput = Omit<publication.HttpRouteDeclaration, 'callable'>;
+/** One provider-neutral HTTP route targeting an admitted Action or Workflow recipe. */
+export interface Route<Target extends RouteTarget = RouteTarget> extends RouteInput {
+    readonly target: Target;
+}

package/dist/application/routes/route.js

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

package/dist/application/runtime/actions.d.ts

@@ -0,0 +1,10 @@
+import type { ActionDefinition, ResolvedCallable } from '../action/index.js';
+import type { RuntimeCallable } from './callables.js';
+export interface RuntimeAction {
+    readonly kind: 'action';
+    readonly address: string;
+    readonly callable: ResolvedCallable;
+    readonly definition: ActionDefinition;
+}
+/** Associate admitted Actions with exact canonical root-local callable descriptors. */
+export declare function admitActions(callables: readonly RuntimeCallable[], input: unknown): readonly RuntimeAction[];

package/dist/application/runtime/actions.js

@@ -0,0 +1,27 @@
+import { isAction } from '../action/index.js';
+import { runtimeCallableAt } from './callables.js';
+/** Associate admitted Actions with exact canonical root-local callable descriptors. */
+export function admitActions(callables, input) {
+    if (!Array.isArray(input))
+        throw new TypeError('Runtime actions must be an array.');
+    const addresses = new Set();
+    const actions = input.map((definition) => {
+        if (!isAction(definition))
+            throw new TypeError('Runtime contains an unadmitted Action.');
+        if (addresses.has(definition.address)) {
+            throw new TypeError(`Runtime Action ${definition.address} occurs more than once.`);
+        }
+        addresses.add(definition.address);
+        const callable = runtimeCallableAt(callables, definition.address);
+        if (callable === undefined) {
+            throw new TypeError(`Runtime Action ${definition.address} is not root-local and executable.`);
+        }
+        return Object.freeze({
+            kind: 'action',
+            address: definition.address,
+            callable,
+            definition,
+        });
+    });
+    return Object.freeze(actions);
+}

package/dist/application/runtime/authoring.d.ts

@@ -0,0 +1,6 @@
+export { defineRuntime } from './define.js';
+export type { RuntimeInput } from './define.js';
+export type { RuntimeInitialization, RuntimeInitializationContext, RuntimeInitializer, } from './initialize.js';
+export type { RuntimeIntegrations } from './integrations.js';
+export type { Runtime } from './runtime.js';
+export type { AuthoredRuntime } from './declarations.js';

package/dist/application/runtime/authoring.js

@@ -0,0 +1 @@
+export { defineRuntime } from './define.js';

package/dist/application/runtime/callables.d.ts

@@ -0,0 +1,11 @@
+import type { Domain } from '@astrale-os/kernel-dsl/v1/domain';
+import type { ResolvedCallable } from '../action/context.js';
+import type { ActionAddressOf } from '../action/index.js';
+export interface RuntimeCallable<Callable extends ResolvedCallable = ResolvedCallable> {
+    readonly address: ActionAddressOf<Callable>;
+    readonly callable: Callable;
+}
+/** Enumerate only the exact executable callable set owned by the root Domain. */
+export declare function runtimeCallables(domain: Domain): readonly RuntimeCallable[];
+/** Resolve one SDK Action address through an already admitted root-local projection. */
+export declare function runtimeCallableAt(callables: readonly RuntimeCallable[], address: string): ResolvedCallable | undefined;

package/dist/application/runtime/callables.js

@@ -0,0 +1,40 @@
+import { callableAddress } from '@astrale-os/kernel-dsl/v1/addressing';
+import { isDomain } from '@astrale-os/kernel-dsl/v1/domain';
+/** Enumerate only the exact executable callable set owned by the root Domain. */
+export function runtimeCallables(domain) {
+    if (!isDomain(domain))
+        throw new TypeError('Runtime callables require an admitted Domain.');
+    const result = [];
+    const addresses = new Set();
+    for (const callable of Object.values(domain.functions))
+        append(callable);
+    for (const selected of Object.values(domain.classes)) {
+        if (selected.kind !== 'node')
+            continue;
+        for (const callable of selected.self.methods) {
+            if (!callable.abstract)
+                append(callable);
+        }
+        for (const callable of selected.self.static.methods) {
+            if (!callable.abstract)
+                append(callable);
+        }
+    }
+    return Object.freeze(result.sort((left, right) => left.address.localeCompare(right.address)));
+    function append(callable) {
+        const address = actionAddress(callable);
+        if (addresses.has(address)) {
+            throw new TypeError(`Runtime Action address ${address} is ambiguous.`);
+        }
+        addresses.add(address);
+        result.push(Object.freeze({ address, callable }));
+    }
+}
+/** Resolve one SDK Action address through an already admitted root-local projection. */
+export function runtimeCallableAt(callables, address) {
+    return callables.find((entry) => entry.address === address)?.callable;
+}
+function actionAddress(callable) {
+    const address = callableAddress(callable.key);
+    return address.kind === 'method' ? `${address.owner.name}.${address.name}` : address.name;
+}

package/dist/application/runtime/declarations.d.ts

@@ -0,0 +1,43 @@
+import type { schema } from '../../platform/schema/index.js';
+import type { ActionAddress, ActionDefinition } from '../action/index.js';
+import type { DeclaredErrors } from '../error/index.js';
+import type { Integrations } from '../integration/index.js';
+import type { WorkflowAddress, WorkflowDefinition } from '../workflow/index.js';
+import type { RuntimeInitialization, RuntimeInitializer } from './initialize.js';
+import type { RuntimeIntegrations } from './integrations.js';
+import type { Runtime } from './runtime.js';
+/** Retain each recipe's exact contract without repeating the owning Schema in every tuple slot. */
+type RuntimeFunctionSignature<Recipe> = Recipe extends ActionDefinition<infer Schema, infer Address, infer Definitions, infer Errors> ? readonly [
+    'action',
+    Address,
+    Definitions,
+    Errors,
+    {
+        [Key in keyof Recipe as Exclude<Key, keyof ActionDefinition<Schema, Address, Definitions, Errors>>]: Recipe[Key];
+    }
+] : Recipe extends WorkflowDefinition<infer Schema, infer Address, infer Definitions, infer Errors> ? readonly [
+    'workflow',
+    Address,
+    Definitions,
+    Errors,
+    {
+        [Key in keyof Recipe as Exclude<Key, keyof WorkflowDefinition<Schema, Address, Definitions, Errors>>]: Recipe[Key];
+    }
+] : never;
+export type RuntimeFunctionSignatures<Functions extends readonly unknown[]> = {
+    [Index in keyof Functions]: RuntimeFunctionSignature<Functions[Index]>;
+};
+type RuntimeFunction<Schema extends schema.DomainSchema, Signature> = Signature extends readonly [
+    infer Kind,
+    infer Address,
+    infer Definitions extends Integrations,
+    infer Errors extends DeclaredErrors,
+    infer Extra
+] ? Kind extends 'action' ? ActionDefinition<Schema, Extract<Address, ActionAddress<Schema>>, Definitions, Errors> & Extra : WorkflowDefinition<Schema, Extract<Address, WorkflowAddress<Schema>>, Definitions, Errors> & Extra : never;
+type RuntimeFunctions<Schema extends schema.DomainSchema, Signatures extends readonly unknown[]> = {
+    [Index in keyof Signatures]: RuntimeFunction<Schema, Signatures[Index]>;
+};
+/** A portable inferred Runtime keeps its Schema once while retaining the exact recipe tuple. */
+export interface AuthoredRuntime<Schema extends schema.DomainSchema, Integrations extends RuntimeIntegrations, Initialize extends RuntimeInitializer<never, RuntimeInitialization, Schema>, Signatures extends readonly unknown[]> extends Runtime<Schema, Integrations, Initialize, RuntimeFunctions<Schema, Signatures>> {
+}
+export {};

package/dist/application/runtime/declarations.js

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

package/dist/application/runtime/define.d.ts

@@ -0,0 +1,28 @@
+import type { schema } from '../../platform/schema/index.js';
+import type { ActionDefinition } from '../action/index.js';
+import type { Providers } from '../integration/index.js';
+import type { WorkflowDefinition } from '../workflow/index.js';
+import type { AuthoredRuntime, RuntimeFunctionSignatures } from './declarations.js';
+import type { RuntimeInitialization, RuntimeInitializer } from './initialize.js';
+import type { RuntimeIntegrations } from './integrations.js';
+import type { Runtime } from './runtime.js';
+type RuntimeInitializerValue = (...input: never[]) => RuntimeInitialization | Promise<RuntimeInitialization>;
+type AnyRuntimeInitializer<Schema extends schema.DomainSchema> = RuntimeInitializer<never, RuntimeInitialization, Schema>;
+type Same<Left, Right> = [Left] extends [Right] ? ([Right] extends [Left] ? true : false) : false;
+type ActionSchema<Value> = Value extends ActionDefinition<infer Schema, infer _Address, infer _Services> ? Schema : never;
+type WorkflowSchema<Value> = Value extends WorkflowDefinition<infer Schema, infer _Address, infer _Services> ? Schema : never;
+type RecipeIntegrations<Value> = Value extends ActionDefinition<infer _Schema, infer _Address, infer Definitions> ? Definitions : Value extends WorkflowDefinition<infer _Schema, infer _Address, infer Definitions> ? Definitions : never;
+type AdmitsRecipeSchema<Schema extends schema.DomainSchema, Functions extends readonly unknown[]> = [Functions[number]] extends [never] ? unknown : Same<ActionSchema<Functions[number]> | WorkflowSchema<Functions[number]>, Schema> extends true ? unknown : never;
+type InitializationOf<Initialize extends RuntimeInitializerValue> = Awaited<ReturnType<Initialize>>;
+type AdmitsRecipeIntegrations<Definitions extends RuntimeIntegrations, Recipe> = RecipeIntegrations<Recipe> extends infer Required extends RuntimeIntegrations ? Exclude<keyof Required, keyof Definitions> extends never ? Required extends Pick<Definitions, Extract<keyof Required, keyof Definitions>> ? true : false : false : false;
+type AdmitsIntegrations<Definitions extends RuntimeIntegrations, Functions extends readonly unknown[]> = [Functions[number]] extends [never] ? unknown : false extends AdmitsRecipeIntegrations<Definitions, Functions[number]> ? never : unknown;
+type AdmitsProviders<Integrations extends RuntimeIntegrations, Initialize extends RuntimeInitializerValue> = Same<InitializationOf<Initialize>['providers'], Providers<Integrations>> extends true ? unknown : never;
+export interface RuntimeInput<Integrations extends RuntimeIntegrations, Initialize extends RuntimeInitializerValue, Functions extends readonly unknown[]> {
+    readonly integrations: Integrations;
+    readonly initialize: Initialize;
+    readonly functions: Functions;
+}
+/** Define one inert Runtime declaration; realization requires an exact loaded DSL Domain. */
+export declare function defineRuntime<Schema extends schema.DomainSchema>(): <const Integrations extends RuntimeIntegrations, Initialize extends AnyRuntimeInitializer<Schema>, const Functions extends readonly unknown[]>(input: RuntimeInput<Integrations, Initialize, Functions> & AdmitsRecipeSchema<Schema, Functions> & AdmitsIntegrations<Integrations, Functions> & AdmitsProviders<Integrations, Initialize>) => AuthoredRuntime<Schema, Integrations, Initialize, RuntimeFunctionSignatures<Functions>>;
+export declare function isRuntime(input: unknown): input is Runtime;
+export {};