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

package/dist/execution/invocation/integration/authentication.js

@@ -0,0 +1,53 @@
+import { credential as credentials } from '../../../platform/auth/index.js';
+import { active } from '../lifecycle/index.js';
+import { protocolError } from '../result/index.js';
+// Match the callback resolver's reserve; a child credential cannot outlive its source.
+const TRANSPORT_RESERVE_SECONDS = 5;
+/** Capture only self mint, bounded by this invocation's verified credential horizon. */
+export function bindIntegrationAuthentication(context, self, expiresAt) {
+    if (expiresAt !== undefined && !Number.isFinite(expiresAt)) {
+        throw new TypeError('Invalid Integration authentication expiry.');
+    }
+    const mint = self.auth.mint.bind(self.auth);
+    return Object.freeze({
+        async mint(input) {
+            active(context);
+            if (input === null || typeof input !== 'object' || Array.isArray(input))
+                invalidInput();
+            const keys = Reflect.ownKeys(input);
+            const { audience, ttlSeconds } = input;
+            if (keys.length !== 2 ||
+                !keys.every((key) => key === 'audience' || key === 'ttlSeconds') ||
+                typeof audience !== 'string' ||
+                audience.length === 0 ||
+                audience.trim() !== audience ||
+                !Number.isInteger(ttlSeconds) ||
+                ttlSeconds < 1 ||
+                ttlSeconds > 60)
+                invalidInput();
+            const horizon = Math.min(context.execution.deadline / 1000, expiresAt ?? Infinity);
+            const remaining = Math.floor(horizon) - Math.floor(Date.now() / 1000) - TRANSPORT_RESERVE_SECONDS;
+            if (remaining < 1) {
+                throw protocolError('DEADLINE_EXCEEDED', 'Insufficient lifetime for Integration credential.');
+            }
+            const credential = await mint({ audience, ttlSeconds: Math.min(ttlSeconds, remaining) }, {
+                signal: context.execution.signal,
+                timeoutMs: Math.max(1, context.execution.deadline - Date.now()),
+            });
+            active(context);
+            // Inspect only the result of the trusted Kernel call, not a Provider-supplied token.
+            // The reserve is an optimization; this absolute check is the lifetime boundary.
+            const expiry = credentials.inspect(credential).claims.exp;
+            if (typeof expiry !== 'number' ||
+                !Number.isSafeInteger(expiry) ||
+                expiry <= Math.floor(Date.now() / 1000) ||
+                expiry > Math.floor(horizon)) {
+                throw protocolError('DEADLINE_EXCEEDED', 'Integration credential exceeds its lifetime.');
+            }
+            return credential;
+        },
+    });
+}
+function invalidInput() {
+    throw new TypeError('Invalid Integration mint input.');
+}

package/dist/execution/invocation/integration/call.d.ts

@@ -0,0 +1,11 @@
+import type { InvocationContext } from '@astrale-os/kernel-server';
+import type { IntegrationInvocationOwner } from '../../../application/integration/index.js';
+import type { BoundClientSession } from '../../../platform/client/session/index.js';
+export interface IntegrationInvocationSessions {
+    readonly caller: BoundClientSession;
+    readonly self: BoundClientSession;
+    /** Verified incoming carrier expiry, in Unix seconds. */
+    readonly expiresAt?: number;
+}
+/** One invocation-owned logical Integration call sequence. */
+export declare function calls(context: InvocationContext, sessions?: IntegrationInvocationSessions | null): IntegrationInvocationOwner;

package/dist/execution/invocation/integration/call.js

@@ -0,0 +1,24 @@
+import { active } from '../lifecycle/index.js';
+import { bindIntegrationAuthentication } from './authentication.js';
+/** One invocation-owned logical Integration call sequence. */
+export function calls(context, sessions = null) {
+    const prefix = context.idempotencyKey ?? JSON.stringify([context.invocation.source, context.invocation.id]);
+    const invoke = sessions?.caller.invoke.bind(sessions.caller);
+    const auth = sessions === null
+        ? undefined
+        : bindIntegrationAuthentication(context, sessions.self, sessions.expiresAt);
+    let sequence = 0;
+    return Object.freeze({
+        invoke(call) {
+            active(context);
+            sequence += 1;
+            return call.attempt({
+                callId: `${prefix}:${sequence}`,
+                signal: context.execution.signal,
+                deadline: context.execution.deadline,
+                ...(invoke === undefined ? {} : { invoke }),
+                ...(auth === undefined ? {} : { auth }),
+            });
+        },
+    });
+}

package/dist/execution/invocation/integration/clients.d.ts

@@ -0,0 +1,5 @@
+import type { InvocationContext } from '@astrale-os/kernel-server';
+import type { IntegrationClients, Integrations } from '../../../application/integration/index.js';
+import type { InitializedRuntime } from '../../runtime/index.js';
+import type { IntegrationInvocationSessions } from './call.js';
+export declare function clients(runtime: InitializedRuntime, context: InvocationContext, sessions: IntegrationInvocationSessions | null): IntegrationClients<Integrations>;

package/dist/execution/invocation/integration/clients.js

@@ -0,0 +1,4 @@
+import { calls } from './call.js';
+export function clients(runtime, context, sessions) {
+    return runtime.clients(calls(context, sessions));
+}

package/dist/execution/invocation/integration/index.d.ts

@@ -0,0 +1,2 @@
+export { calls } from './call.js';
+export { clients } from './clients.js';

package/dist/execution/invocation/integration/index.js

@@ -0,0 +1,2 @@
+export { calls } from './call.js';
+export { clients } from './clients.js';

package/dist/execution/invocation/invocation.d.ts

@@ -0,0 +1,10 @@
+import type { HandlerRequest, HandlerResult } from '@astrale-os/kernel-server';
+import type { WorkflowRunner } from '../../application/workflow/runner/index.js';
+import type { InitializedRuntime } from '../runtime/index.js';
+import type { InvocationAuthority } from './admission/index.js';
+export interface InvocationInput {
+    readonly runtime: InitializedRuntime;
+    readonly authority: InvocationAuthority;
+    readonly workflows: WorkflowRunner;
+}
+export declare function invoke(request: HandlerRequest, inputConfig: InvocationInput): Promise<HandlerResult>;

package/dist/execution/invocation/invocation.js

@@ -0,0 +1,53 @@
+import * as publication from '@astrale-os/kernel-protocol/publication';
+import { authentication, input, requireVia, target } from './admission/index.js';
+import { action, context, select, workflow } from './dispatch/index.js';
+import { active, settle } from './lifecycle/index.js';
+import { project, protocolError } from './result/index.js';
+export async function invoke(request, inputConfig) {
+    active(request.context);
+    const release = inputConfig.runtime.loaded.release;
+    const snapshot = request.publication;
+    if (snapshot === undefined ||
+        !publication.matchesReference(snapshot.publication, publication.reference(release.publication))) {
+        throw protocolError('CONFLICT', 'Invocation Publication differs from the running Release.');
+    }
+    if (request.credential !== undefined && typeof request.credential !== 'string') {
+        throw protocolError('AUTH_INVALID', 'Credential is invalid.');
+    }
+    const via = requireVia(request);
+    const selectedTarget = target(await inputConfig.authority.admit({
+        call: request.call,
+        ...(request.credential === undefined ? {} : { credential: request.credential }),
+        via,
+        publication: release.publication,
+        domain: inputConfig.runtime.loaded.domain,
+        context: request.context,
+    }));
+    const selected = select(inputConfig.runtime.loaded.registry, selectedTarget);
+    if (selected === undefined)
+        return Object.freeze({ kind: 'miss' });
+    input(selected.implementation.callable, request.call.input);
+    const admittedAuthentication = await authentication(selected.implementation.callable, request, release, inputConfig.runtime.loaded.domain, inputConfig.authority);
+    const close = once(admittedAuthentication.close);
+    active(request.context);
+    try {
+        const dispatchContext = context(request, inputConfig.runtime, admittedAuthentication, selected.self);
+        const output = selected.implementation.kind === 'action'
+            ? await action(selected.implementation, dispatchContext)
+            : await workflow(selected.implementation, dispatchContext, inputConfig.workflows);
+        return settle(project(selected.implementation.callable, output), close);
+    }
+    catch (cause) {
+        close();
+        throw cause;
+    }
+}
+function once(operation) {
+    let called = false;
+    return () => {
+        if (called)
+            return;
+        called = true;
+        operation();
+    };
+}

package/dist/execution/invocation/lifecycle/active.d.ts

@@ -0,0 +1,4 @@
+import type { HandlerResult, InvocationContext } from '@astrale-os/kernel-server';
+export declare function active(context: InvocationContext): void;
+/** Close authenticated resources after finite results or stream settlement. */
+export declare function settle(result: HandlerResult, close: () => void): HandlerResult;

package/dist/execution/invocation/lifecycle/active.js

@@ -0,0 +1,86 @@
+import { protocolError } from '../result/index.js';
+export function active(context) {
+    if (context.execution.signal.aborted) {
+        throw protocolError('CANCELLED', 'Invocation was cancelled.');
+    }
+    if (Date.now() >= context.execution.deadline) {
+        throw protocolError('DEADLINE_EXCEEDED', 'Invocation deadline was exceeded.');
+    }
+}
+/** Close authenticated resources after finite results or stream settlement. */
+export function settle(result, close) {
+    if (result.kind === 'stream') {
+        return Object.freeze({ kind: 'stream', stream: settledStream(result.stream, close) });
+    }
+    if (result.kind === 'binary' && !(result.value.body instanceof Uint8Array)) {
+        return Object.freeze({
+            kind: 'binary',
+            value: Object.freeze({ ...result.value, body: settledIterable(result.value.body, close) }),
+        });
+    }
+    close();
+    return result;
+}
+function settledStream(stream, close) {
+    let settled = false;
+    const finish = () => {
+        if (settled)
+            return;
+        settled = true;
+        close();
+    };
+    return Object.freeze({
+        ...settledIterable(stream, finish),
+        async cancel(reason) {
+            try {
+                await stream.cancel(reason);
+            }
+            finally {
+                finish();
+            }
+        },
+    });
+}
+function settledIterable(stream, close) {
+    let settled = false;
+    const finish = () => {
+        if (settled)
+            return;
+        settled = true;
+        close();
+    };
+    return Object.freeze({
+        [Symbol.asyncIterator]() {
+            let iterator;
+            try {
+                iterator = stream[Symbol.asyncIterator]();
+            }
+            catch (cause) {
+                finish();
+                throw cause;
+            }
+            return Object.freeze({
+                async next() {
+                    try {
+                        const value = await iterator.next();
+                        if (value.done === true)
+                            finish();
+                        return value;
+                    }
+                    catch (cause) {
+                        finish();
+                        throw cause;
+                    }
+                },
+                async return() {
+                    try {
+                        return (await iterator.return?.()) ?? { done: true, value: undefined };
+                    }
+                    finally {
+                        finish();
+                    }
+                },
+            });
+        },
+    });
+}

package/dist/execution/invocation/lifecycle/index.d.ts

@@ -0,0 +1 @@
+export { active, settle } from './active.js';

package/dist/execution/invocation/lifecycle/index.js

@@ -0,0 +1 @@
+export { active, settle } from './active.js';

package/dist/execution/invocation/result/errors.d.ts

@@ -0,0 +1,23 @@
+import * as errors from '@astrale-os/kernel-protocol/errors';
+import type { ResolvedCallable } from '../../../application/action/index.js';
+import type { Key } from '../../../platform/schema/index.js';
+import type { Value } from '../../../platform/value/index.js';
+export type InvocationErrorCode = Extract<keyof typeof errors.CODES, 'VALIDATION_ERROR' | 'ACCESS_DENIED' | 'NOT_FOUND' | 'CONFLICT' | 'UNSUPPORTED' | 'LIMIT_EXCEEDED' | 'BACKEND_UNAVAILABLE'>;
+/** @deprecated Declare expected failures on defineAction or defineWorkflow instead. */
+export declare class InvocationError extends Error {
+    readonly code: InvocationErrorCode;
+    readonly name = "InvocationError";
+    readonly reason?: errors.ErrorReason;
+    constructor(code: InvocationErrorCode, message: string, options?: ErrorOptions & {
+        readonly reason?: errors.ErrorReason;
+    });
+}
+export type InvocationDefectCode = 'INVOCATION_TARGET_INVALID' | 'INVOCATION_HANDLER_INVALID' | 'INVOCATION_OUTPUT_INVALID' | 'INVOCATION_RESULT_CONTRACT_VIOLATION';
+export declare class InvocationDefect extends Error {
+    readonly code: InvocationDefectCode;
+    readonly name = "InvocationDefect";
+    constructor(code: InvocationDefectCode, message: string, options?: ErrorOptions);
+}
+export declare function protocolError(code: keyof typeof errors.CODES, message: string, data?: Value): errors.ProtocolError;
+export declare function inputError(callable: Key.Callable, diagnostics: ReturnType<ResolvedCallable['validateInput']>): errors.ProtocolError;
+export declare function projectError(input: unknown): errors.ProtocolError;

package/dist/execution/invocation/result/errors.js

@@ -0,0 +1,97 @@
+import * as errors from '@astrale-os/kernel-protocol/errors';
+import { ClientError, MissError, ProtocolError as ClientProtocolError, ResponseError, SessionError, StaleRouteError, TransportError, } from '../../../platform/client/index.js';
+const PUBLIC_DIAGNOSTICS = new Set(['VALUE_SCHEMA_INSTANCE_INVALID', 'VS_NUMBER_DOMAIN']);
+const PUBLIC_ERROR_CODES = new Set(Object.values(errors.CODES));
+const PUBLIC_ERROR_NAMES = new Map(Object.entries(errors.CODES).map(([name, code]) => [code, name]));
+const MAXIMUM_DIAGNOSTICS = 32;
+const admittedProtocolErrors = new WeakSet();
+/** @deprecated Declare expected failures on defineAction or defineWorkflow instead. */
+export class InvocationError extends Error {
+    code;
+    name = 'InvocationError';
+    reason;
+    constructor(code, message, options = {}) {
+        super(message, options);
+        this.code = code;
+        this.reason =
+            options.reason === undefined
+                ? undefined
+                : errors.acceptReason(options.reason, 'InvocationError reason');
+    }
+}
+export class InvocationDefect extends Error {
+    code;
+    name = 'InvocationDefect';
+    constructor(code, message, options) {
+        super(message, options);
+        this.code = code;
+    }
+}
+export function protocolError(code, message, data) {
+    const error = new errors.ProtocolError({
+        code: errors.CODES[code],
+        message,
+        ...(data === undefined ? {} : { data }),
+    });
+    admittedProtocolErrors.add(error);
+    return error;
+}
+export function inputError(callable, diagnostics) {
+    if (diagnostics.length === 0 ||
+        diagnostics.some((diagnostic) => !PUBLIC_DIAGNOSTICS.has(diagnostic.code))) {
+        throw new InvocationDefect('INVOCATION_RESULT_CONTRACT_VIOLATION', 'Callable input validation returned inadmissible diagnostics.');
+    }
+    const projected = diagnostics.slice(0, MAXIMUM_DIAGNOSTICS).map((diagnostic) => Object.freeze({
+        code: diagnostic.code,
+        path: diagnostic.pointer,
+        message: diagnostic.message,
+    }));
+    const reason = Object.freeze({
+        code: 'CALLABLE_INPUT_INVALID',
+        details: Object.freeze({
+            callable,
+            diagnostics: Object.freeze(projected),
+            truncated: diagnostics.length > projected.length,
+        }),
+    });
+    return protocolError('VALIDATION_ERROR', 'Callable input is invalid.', reason);
+}
+export function projectError(input) {
+    if (input instanceof errors.ProtocolError) {
+        return admittedProtocolErrors.has(input)
+            ? input
+            : protocolError('INTERNAL_ERROR', 'Internal application error.');
+    }
+    if (input instanceof InvocationError) {
+        return protocolError('INTERNAL_ERROR', 'Internal application error.');
+    }
+    if (input instanceof ResponseError) {
+        if (!PUBLIC_ERROR_CODES.has(input.code)) {
+            return protocolError('BACKEND_UNAVAILABLE', 'Dependency Kernel returned invalid error evidence.');
+        }
+        return protocolError(PUBLIC_ERROR_NAMES.get(input.code), input.message, input.data);
+    }
+    if (input instanceof TransportError) {
+        return protocolError(input.phase === 'timeout' ? 'DEADLINE_EXCEEDED' : 'BACKEND_UNAVAILABLE', input.phase === 'timeout'
+            ? 'Dependency invocation deadline was exceeded.'
+            : 'Dependency Kernel is unavailable.');
+    }
+    if (input instanceof ClientProtocolError) {
+        return protocolError('BACKEND_UNAVAILABLE', 'Dependency Kernel is unavailable.');
+    }
+    if (input instanceof SessionError) {
+        if (input.failure === 'timeout') {
+            return protocolError('DEADLINE_EXCEEDED', 'Dependency invocation deadline was exceeded.');
+        }
+        if (input.failure === 'cancelled') {
+            return protocolError('CANCELLED', 'Dependency invocation was cancelled.');
+        }
+        return protocolError('BACKEND_UNAVAILABLE', 'Dependency Kernel is unavailable.');
+    }
+    if (input instanceof MissError || input instanceof StaleRouteError) {
+        return protocolError('BACKEND_UNAVAILABLE', 'Dependency routing is unavailable.');
+    }
+    if (input instanceof ClientError)
+        throw input;
+    throw input;
+}

package/dist/execution/invocation/result/index.d.ts

@@ -0,0 +1,4 @@
+export { inputError, InvocationDefect, InvocationError, projectError, protocolError, } from './errors.js';
+export type { InvocationDefectCode, InvocationErrorCode } from './errors.js';
+export { project } from './project.js';
+export { validateInput, validateOutput } from './validate.js';

package/dist/execution/invocation/result/index.js

@@ -0,0 +1,3 @@
+export { inputError, InvocationDefect, InvocationError, projectError, protocolError, } from './errors.js';
+export { project } from './project.js';
+export { validateInput, validateOutput } from './validate.js';

package/dist/execution/invocation/result/project.d.ts

@@ -0,0 +1,3 @@
+import type { HandlerResult } from '@astrale-os/kernel-server';
+import type { ResolvedCallable } from '../../../application/action/index.js';
+export declare function project(callable: ResolvedCallable, output: unknown): HandlerResult;

package/dist/execution/invocation/result/project.js

@@ -0,0 +1,186 @@
+import { InvocationDefect } from './errors.js';
+import { validateOutput } from './validate.js';
+const MEDIA_TYPE = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+\/[!#$%&'*+.^_`|~0-9A-Za-z-]+$/u;
+const HEADER_NAME = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/u;
+export function project(callable, output) {
+    switch (callable.output.mode) {
+        case 'value':
+            return Object.freeze({ kind: 'value', value: validateOutput(callable, output) });
+        case 'stream':
+            return Object.freeze({ kind: 'stream', stream: stream(callable, output) });
+        case 'binary':
+            return projectBinary(output);
+    }
+}
+function stream(callable, input) {
+    if (input === null ||
+        (typeof input !== 'object' && typeof input !== 'function') ||
+        typeof input[Symbol.asyncIterator] !==
+            'function') {
+        throw new InvocationDefect('INVOCATION_OUTPUT_INVALID', 'Streaming Callable output must be an AsyncIterable.');
+    }
+    return new InvocationStream(input[Symbol.asyncIterator](), (value) => validateOutput(callable, value));
+}
+class InvocationStream {
+    source;
+    admit;
+    consumed = false;
+    terminal = false;
+    stopping;
+    constructor(source, admit) {
+        this.source = source;
+        this.admit = admit;
+    }
+    [Symbol.asyncIterator]() {
+        if (this.consumed) {
+            throw new InvocationDefect('INVOCATION_RESULT_CONTRACT_VIOLATION', 'Callable stream supports exactly one consumer.');
+        }
+        this.consumed = true;
+        return Object.freeze({ next: () => this.next(), return: () => this.return() });
+    }
+    async cancel() {
+        await this.stop();
+    }
+    async next() {
+        if (this.terminal)
+            return { done: true, value: undefined };
+        const next = await this.source.next();
+        if (next.done === true) {
+            this.terminal = true;
+            return { done: true, value: undefined };
+        }
+        return { done: false, value: this.admit(next.value) };
+    }
+    async return() {
+        await this.stop();
+        return { done: true, value: undefined };
+    }
+    stop() {
+        return (this.stopping ??= this.close());
+    }
+    async close() {
+        if (this.terminal)
+            return;
+        this.terminal = true;
+        await this.source.return?.();
+    }
+}
+function projectBinary(input) {
+    return Object.freeze({ kind: 'binary', value: binary(input) });
+}
+function binary(input) {
+    if (input === null || typeof input !== 'object' || Array.isArray(input))
+        invalidBinary();
+    const value = input;
+    if (Reflect.ownKeys(input).some((key) => key !== 'body' && key !== 'mediaType' && key !== 'status' && key !== 'headers') ||
+        (!isBytes(value.body) && !isAsyncBytes(value.body)) ||
+        typeof value.mediaType !== 'string' ||
+        !MEDIA_TYPE.test(value.mediaType) ||
+        (value.status !== undefined &&
+            (!Number.isInteger(value.status) || value.status < 200 || value.status > 599))) {
+        invalidBinary();
+    }
+    const headers = binaryHeaders(value.headers);
+    if (isBytes(value.body)) {
+        return Object.freeze({
+            body: new Uint8Array(value.body),
+            mediaType: value.mediaType,
+            ...(value.status === undefined ? {} : { status: value.status }),
+            ...(headers === undefined ? {} : { headers }),
+        });
+    }
+    return Object.freeze({
+        body: new InvocationByteStream(value.body),
+        mediaType: value.mediaType,
+        ...(value.status === undefined ? {} : { status: value.status }),
+        ...(headers === undefined ? {} : { headers }),
+    });
+}
+class InvocationByteStream {
+    source;
+    consumed = false;
+    constructor(source) {
+        this.source = source;
+    }
+    [Symbol.asyncIterator]() {
+        if (this.consumed) {
+            throw new InvocationDefect('INVOCATION_RESULT_CONTRACT_VIOLATION', 'Streaming binary output supports exactly one consumer.');
+        }
+        this.consumed = true;
+        const iterator = this.source[Symbol.asyncIterator]();
+        let terminal = false;
+        let stopping;
+        const stop = () => {
+            stopping ??= (async () => {
+                if (terminal)
+                    return;
+                terminal = true;
+                await iterator.return?.();
+            })();
+            return stopping;
+        };
+        return Object.freeze({
+            next: async () => {
+                if (terminal)
+                    return { done: true, value: undefined };
+                let next;
+                try {
+                    next = await iterator.next();
+                }
+                catch (cause) {
+                    await stop().catch(() => undefined);
+                    throw cause;
+                }
+                if (next.done) {
+                    terminal = true;
+                    return { done: true, value: undefined };
+                }
+                if (!(next.value instanceof Uint8Array)) {
+                    await stop().catch(() => undefined);
+                    invalidBinary();
+                }
+                return { done: false, value: new Uint8Array(next.value) };
+            },
+            return: async () => {
+                await stop();
+                return { done: true, value: undefined };
+            },
+        });
+    }
+}
+function isBytes(input) {
+    return input instanceof Uint8Array;
+}
+function isAsyncBytes(input) {
+    return (input !== null &&
+        (typeof input === 'object' || typeof input === 'function') &&
+        typeof input[Symbol.asyncIterator] ===
+            'function');
+}
+function binaryHeaders(input) {
+    if (input === undefined)
+        return undefined;
+    if (input === null || typeof input !== 'object' || Array.isArray(input))
+        invalidBinary();
+    const headers = {};
+    for (const name of Reflect.ownKeys(input)) {
+        if (typeof name !== 'string')
+            invalidBinary();
+        const value = input[name];
+        const lower = name.toLowerCase();
+        if (typeof value !== 'string' ||
+            !HEADER_NAME.test(name) ||
+            /[\r\n]/u.test(value) ||
+            Object.hasOwn(headers, lower) ||
+            lower === 'content-length' ||
+            lower === 'transfer-encoding' ||
+            lower === 'connection') {
+            invalidBinary();
+        }
+        headers[lower] = value;
+    }
+    return Object.keys(headers).length === 0 ? undefined : Object.freeze(headers);
+}
+function invalidBinary() {
+    throw new InvocationDefect('INVOCATION_OUTPUT_INVALID', 'Binary Callable output is invalid.');
+}

package/dist/execution/invocation/result/validate.d.ts

@@ -0,0 +1,4 @@
+import type { ResolvedCallable } from '../../../application/action/index.js';
+import type { Value } from '../../../platform/value/index.js';
+export declare function validateInput(callable: ResolvedCallable, input: unknown): void;
+export declare function validateOutput(callable: ResolvedCallable, input: unknown): Value;

package/dist/execution/invocation/result/validate.js

@@ -0,0 +1,25 @@
+import * as portable from '../../../platform/value/index.js';
+import { inputError, InvocationDefect } from './errors.js';
+export function validateInput(callable, input) {
+    const diagnostics = callable.validateInput(input);
+    if (diagnostics.length > 0)
+        throw inputError(callable.key, diagnostics);
+}
+export function validateOutput(callable, input) {
+    let value;
+    try {
+        value = portable.accept(input);
+    }
+    catch (cause) {
+        if (cause instanceof portable.BoundaryError) {
+            throw new InvocationDefect('INVOCATION_OUTPUT_INVALID', 'Callable output is not portable.', {
+                cause,
+            });
+        }
+        throw cause;
+    }
+    if (callable.validateOutput(value).length > 0) {
+        throw new InvocationDefect('INVOCATION_OUTPUT_INVALID', 'Callable output is invalid.');
+    }
+    return value;
+}

package/dist/execution/node/index.d.ts

@@ -0,0 +1,2 @@
+export { listen, type NodeOptions } from './serve.js';
+export type { NodeListener } from './listener.js';

package/dist/execution/node/index.js

@@ -0,0 +1 @@
+export { listen } from './serve.js';

package/dist/execution/node/listener.d.ts

@@ -0,0 +1,10 @@
+import type { ServerCloseOptions } from '@astrale-os/kernel-server';
+import type { ServerType } from '@hono/node-server';
+export interface NodeListener {
+    readonly port: number;
+    close(options: ServerCloseOptions): Promise<void>;
+}
+export declare function listener(server: ServerType, port: number, lifecycle: {
+    drain(): void;
+    close(options: ServerCloseOptions): Promise<void>;
+}): NodeListener;