@astrale-os/sdk 0.5.0-beta.2 → 0.5.0-beta.21

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

@@ -0,0 +1,18 @@
+import type { Node, NodeId } from '@astrale-os/kernel-core/graph/node';
+import type { QueryEdgeItemFor, QueryEdgeProjection, QueryResult } from '@astrale-os/kernel-core/graph/query';
+declare function nodeValues(result: QueryResult, context: string): readonly Node[];
+declare function nodeIds(result: QueryResult, context: string): readonly NodeId[];
+declare function edgeItems(result: QueryResult, context: string): readonly QueryEdgeItemFor<QueryEdgeProjection>[];
+export declare const queryResult: Readonly<{
+    nodeValues: typeof nodeValues;
+    completeNodeValues: (results: readonly QueryResult[], context: string) => readonly Node[];
+    nodeIds: typeof nodeIds;
+    completeNodeIds: (results: readonly QueryResult[], context: string) => readonly NodeId[];
+    exactlyOneNode(result: QueryResult, context: string): Node;
+    optionalNode(result: QueryResult, context: string): Node | undefined;
+    edgeItems: typeof edgeItems;
+    optionalEdgeTarget(result: QueryResult, context: string): Node | undefined;
+    exactlyOneEdgeTarget(result: QueryResult, context: string): Node;
+    exactlyOneEdgeSource(result: QueryResult, context: string): Node;
+}>;
+export {};

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

@@ -0,0 +1,86 @@
+function nodeValues(result, context) {
+    if (result.kind === 'graph') {
+        if (result.selection.kind !== 'node')
+            invalid(`Expected a Node ${context} query result.`);
+        const byId = new Map(result.graph.nodes.map((node) => [node.id, node]));
+        return Object.freeze(result.selection.ids.map((id) => {
+            const node = byId.get(id);
+            if (node === undefined)
+                invalid(`${context} graph omits selected Node ${id}.`);
+            return node;
+        }));
+    }
+    if (result.kind !== 'nodes')
+        invalid(`Expected a Node ${context} query result.`);
+    return Object.freeze(result.nodes.map((projection) => {
+        if (projection.kind !== 'value')
+            invalid(`Expected ${context} query to project Node values.`);
+        return projection.value;
+    }));
+}
+function nodeIds(result, context) {
+    if (result.kind === 'graph') {
+        if (result.selection.kind !== 'node')
+            invalid(`Expected a Node ${context} query result.`);
+        return result.selection.ids;
+    }
+    if (result.kind !== 'nodes')
+        invalid(`Expected a Node ${context} query result.`);
+    return Object.freeze(result.nodes.map((projection) => projection.value.id));
+}
+function edgeItems(result, context) {
+    if (result.kind !== 'edges')
+        invalid(`Expected an Edge ${context} query result.`);
+    return result.edges;
+}
+export const queryResult = Object.freeze({
+    nodeValues,
+    completeNodeValues: (results, context) => Object.freeze(results.flatMap((result) => nodeValues(result, context))),
+    nodeIds,
+    completeNodeIds: (results, context) => Object.freeze(results.flatMap((result) => nodeIds(result, context))),
+    exactlyOneNode(result, context) {
+        const values = nodeValues(result, context);
+        if (values.length !== 1)
+            invalid(`${context} must resolve exactly one Node.`);
+        return values[0];
+    },
+    optionalNode(result, context) {
+        const values = nodeValues(result, context);
+        if (values.length > 1)
+            invalid(`${context} must resolve at most one Node.`);
+        return values[0];
+    },
+    edgeItems,
+    optionalEdgeTarget(result, context) {
+        const items = edgeItems(result, context);
+        if (items.length > 1)
+            invalid(`${context} must resolve at most one Edge.`);
+        const target = items[0]?.target;
+        if (target === undefined)
+            return undefined;
+        if (target.kind !== 'value')
+            invalid(`${context} must project its target value.`);
+        return target.value;
+    },
+    exactlyOneEdgeTarget(result, context) {
+        const items = edgeItems(result, context);
+        if (items.length !== 1)
+            invalid(`${context} must resolve exactly one Edge.`);
+        const target = items[0].target;
+        if (target.kind !== 'value')
+            invalid(`${context} must project its target value.`);
+        return target.value;
+    },
+    exactlyOneEdgeSource(result, context) {
+        const items = edgeItems(result, context);
+        if (items.length !== 1)
+            invalid(`${context} must resolve exactly one Edge.`);
+        const source = items[0].source;
+        if (source.kind !== 'value')
+            invalid(`${context} must project its source value.`);
+        return source.value;
+    },
+});
+function invalid(message) {
+    throw new TypeError(message);
+}

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

@@ -0,0 +1,9 @@
+import type { QueryPageRequest, QueryResponse } from '@astrale-os/kernel-client/graph';
+import type { QueryAST, QueryResultFor } from '@astrale-os/kernel-core/graph/query';
+import type { QueryPages, QueryPagination } from './query.js';
+export interface QueryPageExecutor {
+    <Query extends QueryAST>(ast: Query, options: {
+        readonly page: QueryPageRequest;
+    }): Promise<QueryResponse<QueryResultFor<Query>>>;
+}
+export declare function pages<Query extends QueryAST>(execute: QueryPageExecutor, ast: Query, page: Readonly<Pick<QueryPageRequest, 'size'>>, pagination: QueryPagination): Promise<QueryPages<Query>>;

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

@@ -0,0 +1,24 @@
+import { QueryPaginationError } from '../failure.js';
+export async function pages(execute, ast, page, pagination) {
+    const collected = [];
+    const cursors = new Set();
+    let response = await execute(ast, { page });
+    const kind = response.result.kind;
+    while (true) {
+        if (response.result.kind !== kind) {
+            throw new TypeError(`Paginated Query result kind changed from ${kind} to ${response.result.kind}.`);
+        }
+        collected.push(response.result);
+        const cursor = response.page.next;
+        if (cursor === undefined)
+            return Object.freeze(collected);
+        if (cursors.has(cursor)) {
+            throw new QueryPaginationError('QUERY_PAGINATION_CURSOR_REPEATED', 'Paginated Query returned a repeated continuation cursor.');
+        }
+        cursors.add(cursor);
+        if (collected.length >= pagination.maximumPages) {
+            throw new QueryPaginationError('QUERY_PAGINATION_LIMIT', `Paginated Query exceeded its ${pagination.maximumPages}-page bound.`);
+        }
+        response = await execute(ast, { page: { size: page.size, after: cursor } });
+    }
+}

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

@@ -0,0 +1,47 @@
+import type { QueryPageRequest } from '@astrale-os/kernel-client/graph';
+import type { QueryAST, QueryResult, QueryResultFor, QuerySelectionFor } from '@astrale-os/kernel-core/graph/query';
+import type { QueryFailure } from '../failure.js';
+declare const QUERY_INPUT: unique symbol;
+declare const QUERY_OUTPUT: unique symbol;
+export interface QueryLifecycle<Input, Output> {
+    readonly id: string;
+    readonly [QUERY_INPUT]?: Input;
+    readonly [QUERY_OUTPUT]?: Output;
+    prepare?(input: Input): Input;
+    reject?(failure: QueryFailure): Output;
+}
+export interface QueryProjectionContext<Query extends QueryAST> {
+    readonly ast: Query;
+}
+export interface CompleteQueryProjectionContext<Query extends QueryAST> extends QueryProjectionContext<Query> {
+    readonly complete: QuerySelectionFor<QueryResultFor<Query>>;
+}
+export interface QueryPagination {
+    readonly maximumPages: number;
+}
+export type QueryPages<Query extends QueryAST = QueryAST> = readonly [
+    QueryResultFor<Query>,
+    ...QueryResultFor<Query>[]
+];
+export interface SingleQueryBase<Input, Output, Query extends QueryAST> extends QueryLifecycle<Input, Output> {
+    readonly kind: 'single';
+    readonly page: Readonly<Pick<QueryPageRequest, 'size'>>;
+    build(input: Input): Query;
+}
+export interface RawQuery<Input, Query extends QueryAST = QueryAST> extends SingleQueryBase<Input, QueryResultFor<Query>, Query> {
+    readonly pagination?: undefined;
+    readonly project?: undefined;
+}
+export interface ProjectedQuery<Input, Output, Query extends QueryAST = QueryAST> extends SingleQueryBase<Input, Output, Query> {
+    readonly pagination?: undefined;
+    project(result: QueryResultFor<Query>, input: Input, context: QueryProjectionContext<Query>): Output;
+}
+export interface PaginatedQuery<Input, Output, Query extends QueryAST = QueryAST> extends SingleQueryBase<Input, Output, Query> {
+    readonly pagination: QueryPagination;
+    project(pages: QueryPages<Query>, input: Input, context: CompleteQueryProjectionContext<Query>): Output;
+}
+export type SingleQuery<Input, Output = QueryResult, Query extends QueryAST = QueryAST> = RawQuery<Input, Query> | ProjectedQuery<Input, Output, Query> | PaginatedQuery<Input, Output, Query>;
+export type AuthoredSingleQuery<Input, Output, Query extends QueryAST> = Omit<SingleQuery<Input, Output, Query>, 'kind' | 'page'> & {
+    readonly page?: Readonly<Pick<QueryPageRequest, 'size'>>;
+};
+export {};

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

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

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/administration.d.ts

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

package/dist/application/requirements/administration.js

@@ -0,0 +1,38 @@
+import { AuthorityOperationOrder } from '../../platform/schema/index.js';
+export function captureAdministration(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('Administration 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(`Administration ${kind} operations cannot be empty.`);
+    }
+    for (const operation of input) {
+        if (!AuthorityOperationOrder.includes(operation)) {
+            throw new TypeError(`Unknown administration ${kind} operation ${String(operation)}.`);
+        }
+    }
+    if (new Set(input).size !== input.length) {
+        throw new TypeError(`Administration ${kind} operations must be unique.`);
+    }
+    return Object.freeze([...input].sort((left, right) => AuthorityOperationOrder.indexOf(left) - AuthorityOperationOrder.indexOf(right)));
+}
+function invalid() {
+    throw new TypeError('Administration requirements may contain only grant and revoke.');
+}

package/dist/application/requirements/callables.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 CallableRequirementTarget = Pick<ResolvedFunction, 'key'> | Pick<ResolvedMethod, 'key'>;
+export declare function captureCallables(input: readonly CallableRequirementTarget[] | undefined): readonly SemanticKey.Callable[];

package/dist/application/requirements/callables.js

@@ -0,0 +1,30 @@
+import { callableAddress, Key } from '../../platform/schema/index.js';
+export function captureCallables(input) {
+    if (input === undefined)
+        return Object.freeze([]);
+    if (!Array.isArray(input))
+        throw new TypeError('Requirement callables must be an array.');
+    const keys = input.map((target) => {
+        if (target === null || typeof target !== 'object' || typeof target.key !== 'string') {
+            throw new TypeError('Callable requirement target is invalid.');
+        }
+        let key;
+        try {
+            key = Key(target.key);
+            callableAddress(key);
+        }
+        catch (cause) {
+            throw new TypeError('Callable requirement target is invalid.', { cause });
+        }
+        return key;
+    });
+    unique(keys, 'Callable 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/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/index.d.ts

@@ -0,0 +1,16 @@
+import type { AdministrationRequirementsInput } from './administration.js';
+import type { CallableRequirementTarget } from './callables.js';
+import type { ClassRequirementInput } from './classes.js';
+import type { Requirements } from './requirement.js';
+export type { AdministrationRequirements, ClassRequirement, Requirements } from './requirement.js';
+export type { CallableRequirementTarget } from './callables.js';
+export { ClassOperationOrder, type ClassOperation, type ClassRequirementInput } from './classes.js';
+export type { AdministrationRequirementsInput } from './administration.js';
+export interface RequirementsInput {
+    readonly callables?: readonly CallableRequirementTarget[];
+    readonly classes?: readonly ClassRequirementInput[];
+    readonly administration?: AdministrationRequirementsInput;
+}
+/** 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,29 @@
+import { captureAdministration } from './administration.js';
+import { captureCallables } from './callables.js';
+import { captureClasses } from './classes.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 !== 'callables' && key !== 'classes' && key !== 'administration')) {
+        invalid();
+    }
+    const callables = captureCallables(input.callables);
+    const classes = captureClasses(input.classes);
+    const administration = captureAdministration(input.administration);
+    const value = Object.freeze({
+        callables,
+        classes,
+        ...(administration === undefined ? {} : { administration }),
+    });
+    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 callables, classes, and administration.');
+}

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

@@ -0,0 +1,17 @@
+import type { AuthorityOperation } from '../../platform/schema/index.js';
+import type { ClassRef, 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 AdministrationRequirements {
+    readonly grant?: readonly [AuthorityOperation, ...AuthorityOperation[]];
+    readonly revoke?: readonly [AuthorityOperation, ...AuthorityOperation[]];
+}
+/** Canonical author intent; dependency-closure validation belongs to Build compilation. */
+export interface Requirements {
+    readonly callables: readonly Key.Callable[];
+    readonly classes: readonly ClassRequirement[];
+    readonly administration?: AdministrationRequirements;
+}

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,5 @@
+export { defineRuntime } from './define.js';
+export type { RuntimeInput } from './define.js';
+export type { RuntimeInitialization, RuntimeInitializer } from './initialize.js';
+export type { RuntimeIntegrations } from './integrations.js';
+export type { Runtime } from './runtime.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;