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

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

@@ -0,0 +1,8 @@
+import type { NodePath } from '../../../platform/graph/path/index.js';
+import type { Key as SemanticKey } from '../../../platform/schema/index.js';
+export interface InvocationTarget {
+    readonly callable: SemanticKey.Callable;
+    readonly receiver?: NodePath;
+}
+/** Admit the portable target selected by the execution Identity owner. */
+export declare function target(input: unknown): InvocationTarget;

package/dist/execution/invocation/admission/target.js

@@ -0,0 +1,30 @@
+import { callableAddress, Key } from '@astrale-os/kernel-dsl/v1/addressing';
+import { NodePath as acceptNodePath } from '../../../platform/graph/path/index.js';
+import { InvocationDefect } from '../result/index.js';
+/** Admit the portable target selected by the execution Identity owner. */
+export function target(input) {
+    if (input === null || typeof input !== 'object' || Array.isArray(input))
+        invalid();
+    const value = input;
+    if (!Object.hasOwn(value, 'callable') ||
+        Reflect.ownKeys(value).some((key) => key !== 'callable' && key !== 'receiver') ||
+        typeof value.callable !== 'string') {
+        invalid();
+    }
+    let callable;
+    let receiver;
+    try {
+        callable = Key(value.callable);
+        callableAddress(callable);
+        receiver = value.receiver === undefined ? undefined : acceptNodePath(value.receiver);
+    }
+    catch (cause) {
+        throw new InvocationDefect('INVOCATION_TARGET_INVALID', 'Invocation target is invalid.', {
+            cause,
+        });
+    }
+    return Object.freeze({ callable, ...(receiver === undefined ? {} : { receiver }) });
+}
+function invalid() {
+    throw new InvocationDefect('INVOCATION_TARGET_INVALID', 'Invocation target is invalid.');
+}

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

@@ -0,0 +1,3 @@
+import type { RuntimeAction } from '../../../application/runtime/actions.js';
+import type { DispatchContext } from './context.js';
+export declare function action(selected: RuntimeAction, context: DispatchContext): Promise<unknown>;

package/dist/execution/invocation/dispatch/action.js

@@ -0,0 +1,3 @@
+export function action(selected, context) {
+    return selected.definition.run(context);
+}

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

@@ -0,0 +1,21 @@
+import type { HandlerRequest } from '@astrale-os/kernel-server';
+import type { ActionExecution, Caller } from '../../../application/action/index.js';
+import type { MutationExecutor } from '../../../application/mutation/index.js';
+import type { QueryExecutor } from '../../../application/query/index.js';
+import type { BoundClientSession } from '../../../platform/client/session/index.js';
+import type { NodeId } from '../../../platform/graph/node/index.js';
+import type { Domain } from '../../../platform/schema/index.js';
+import type { InitializedRuntime } from '../../runtime/index.js';
+import type { InvocationAuthentication } from '../admission/index.js';
+export interface DispatchContext {
+    readonly domain: Domain;
+    readonly input: unknown;
+    readonly caller: Caller;
+    readonly client: BoundClientSession | null;
+    readonly query?: QueryExecutor;
+    readonly mutate?: MutationExecutor;
+    readonly integrations: Readonly<Record<string, unknown>>;
+    readonly execution: ActionExecution;
+    readonly self?: NodeId;
+}
+export declare function context(request: HandlerRequest, runtime: InitializedRuntime, authentication: InvocationAuthentication, self: NodeId | undefined): DispatchContext;

package/dist/execution/invocation/dispatch/context.js

@@ -0,0 +1,31 @@
+import { bindMutation } from '../../../application/mutation/execution/executor.js';
+import { bindQuery } from '../../../application/query/execution/executor.js';
+import { clients } from '../integration/index.js';
+export function context(request, runtime, authentication, self) {
+    const client = authentication.client;
+    const execution = Object.freeze({
+        signal: request.context.execution.signal,
+        deadline: request.context.execution.deadline,
+        ...(request.context.idempotencyKey === undefined
+            ? {}
+            : { idempotencyKey: request.context.idempotencyKey }),
+        background: request.context.background,
+        sleep: request.context.sleep,
+        ...(request.context.request === undefined ? {} : { request: request.context.request }),
+    });
+    return Object.freeze({
+        domain: runtime.loaded.domain,
+        input: request.call.input,
+        caller: authentication.caller,
+        client,
+        ...(client === null
+            ? {}
+            : {
+                query: bindQuery(client),
+                mutate: bindMutation(client),
+            }),
+        integrations: clients(runtime, request.context),
+        execution,
+        ...(self === undefined ? {} : { self }),
+    });
+}

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

@@ -0,0 +1,5 @@
+export { action } from './action.js';
+export { context, type DispatchContext } from './context.js';
+export { receiver } from './receiver.js';
+export { requireSelected, select, type SelectedInvocation } from './select.js';
+export { workflow } from './workflow.js';

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

@@ -0,0 +1,5 @@
+export { action } from './action.js';
+export { context } from './context.js';
+export { receiver } from './receiver.js';
+export { requireSelected, select } from './select.js';
+export { workflow } from './workflow.js';

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

@@ -0,0 +1,4 @@
+import type { ResolvedCallable } from '../../../application/action/index.js';
+import type { NodeId } from '../../../platform/graph/node/index.js';
+import type { InvocationTarget } from '../admission/target.js';
+export declare function receiver(callable: ResolvedCallable, target: InvocationTarget): NodeId | undefined;

package/dist/execution/invocation/dispatch/receiver.js

@@ -0,0 +1,18 @@
+import { NodeId as acceptNodeId } from '../../../platform/graph/node/index.js';
+import { Path } from '../../../platform/graph/path/index.js';
+import { InvocationDefect } from '../result/index.js';
+export function receiver(callable, target) {
+    const instance = 'owner' in callable && callable.static === false;
+    if (instance !== (target.receiver !== undefined)) {
+        throw new InvocationDefect('INVOCATION_TARGET_INVALID', instance
+            ? 'Instance Action or Workflow requires a receiver.'
+            : 'Receiver-free Action or Workflow forbids a receiver.');
+    }
+    if (target.receiver === undefined)
+        return undefined;
+    const path = Path.from(target.receiver);
+    if (!('id' in path)) {
+        throw new InvocationDefect('INVOCATION_TARGET_INVALID', 'Instance Action or Workflow receiver must be one canonical Node id.');
+    }
+    return acceptNodeId(path.id);
+}

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

@@ -0,0 +1,10 @@
+import type { RuntimeImplementation, RuntimeRegistry } from '../../../application/runtime/index.js';
+import type { NodeId } from '../../../platform/graph/node/index.js';
+import type { InvocationTarget } from '../admission/target.js';
+export interface SelectedInvocation {
+    readonly target: InvocationTarget;
+    readonly implementation: RuntimeImplementation;
+    readonly self?: NodeId;
+}
+export declare function select(registry: RuntimeRegistry, target: InvocationTarget): SelectedInvocation | undefined;
+export declare function requireSelected(registry: RuntimeRegistry, target: InvocationTarget): SelectedInvocation;

package/dist/execution/invocation/dispatch/select.js

@@ -0,0 +1,20 @@
+import { InvocationDefect } from '../result/index.js';
+import { receiver } from './receiver.js';
+export function select(registry, target) {
+    const implementation = registry.implementations.find(({ callable }) => callable.key === target.callable);
+    if (implementation === undefined)
+        return undefined;
+    const self = receiver(implementation.callable, target);
+    return Object.freeze({
+        target,
+        implementation,
+        ...(self === undefined ? {} : { self }),
+    });
+}
+export function requireSelected(registry, target) {
+    const selected = select(registry, target);
+    if (selected === undefined) {
+        throw new InvocationDefect('INVOCATION_HANDLER_INVALID', 'Invocation target has no local Action or Workflow implementation.');
+    }
+    return selected;
+}

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

@@ -0,0 +1,4 @@
+import type { RuntimeWorkflow } from '../../../application/runtime/workflows.js';
+import type { WorkflowRunner } from '../../../application/workflow/runner/index.js';
+import type { DispatchContext } from './context.js';
+export declare function workflow(selected: RuntimeWorkflow, context: DispatchContext, runner: WorkflowRunner): Promise<unknown>;

package/dist/execution/invocation/dispatch/workflow.js

@@ -0,0 +1,11 @@
+import { protocolError } from '../result/index.js';
+export function workflow(selected, context, runner) {
+    if (context.caller.kind !== 'authenticated' || context.client === null) {
+        throw protocolError('AUTH_MISSING', 'Workflow authentication is required.');
+    }
+    return runner.run(selected.definition, {
+        ...context,
+        caller: context.caller,
+        client: context.client,
+    });
+}

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

@@ -0,0 +1,7 @@
+import type { Handler } from '@astrale-os/kernel-server';
+import type { InvocationInput } from './invocation.js';
+export type HandlerInput = Omit<InvocationInput, 'workflows'> & {
+    readonly workflows?: InvocationInput['workflows'];
+};
+/** Compose one ready semantic Handler below Kernel Server transport ownership. */
+export declare function createHandler(input: HandlerInput): Handler;

package/dist/execution/invocation/handler.js

@@ -0,0 +1,37 @@
+import { createInlineWorkflowRunner } from '../../application/workflow/runner/index.js';
+import { authority } from './admission/index.js';
+import { invoke } from './invocation.js';
+import { projectError } from './result/index.js';
+/** Compose one ready semantic Handler below Kernel Server transport ownership. */
+export function createHandler(input) {
+    if (input === null || typeof input !== 'object' || Array.isArray(input))
+        invalid();
+    if (!Object.hasOwn(input, 'runtime') ||
+        !Object.hasOwn(input, 'authority') ||
+        Reflect.ownKeys(input).some((key) => key !== 'runtime' && key !== 'authority' && key !== 'workflows')) {
+        invalid();
+    }
+    const capturedAuthority = authority(input.authority);
+    const workflows = input.workflows ?? createInlineWorkflowRunner();
+    if (workflows === null || typeof workflows !== 'object' || typeof workflows.run !== 'function') {
+        invalid();
+    }
+    const capturedWorkflows = Object.freeze({ run: workflows.run.bind(workflows) });
+    return Object.freeze({
+        async dispatch(request) {
+            try {
+                return await invoke(request, {
+                    runtime: input.runtime,
+                    authority: capturedAuthority,
+                    workflows: capturedWorkflows,
+                });
+            }
+            catch (cause) {
+                throw projectError(cause);
+            }
+        },
+    });
+}
+function invalid() {
+    throw new TypeError('Invocation Handler input is invalid.');
+}

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

@@ -0,0 +1,5 @@
+export { createHandler, type HandlerInput } from './handler.js';
+export { invoke, type InvocationInput } from './invocation.js';
+export type * from './admission/index.js';
+export { InvocationDefect, InvocationError } from './result/index.js';
+export type { InvocationDefectCode, InvocationErrorCode } from './result/index.js';

package/dist/execution/invocation/index.js

@@ -0,0 +1,3 @@
+export { createHandler } from './handler.js';
+export { invoke } from './invocation.js';
+export { InvocationDefect, InvocationError } from './result/index.js';

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

@@ -0,0 +1,4 @@
+import type { InvocationContext } from '@astrale-os/kernel-server';
+import type { IntegrationInvocationOwner } from '../../../application/integration/index.js';
+/** One invocation-owned logical Integration call sequence. */
+export declare function calls(context: InvocationContext): IntegrationInvocationOwner;

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

@@ -0,0 +1,17 @@
+import { active } from '../lifecycle/index.js';
+/** One invocation-owned logical Integration call sequence. */
+export function calls(context) {
+    const prefix = context.idempotencyKey ?? context.invocation;
+    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,
+            });
+        },
+    });
+}

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

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

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

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

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,61 @@
+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') {
+        close();
+        return result;
+    }
+    return Object.freeze({ kind: 'stream', stream: settledStream(result.stream, close) });
+}
+function settledStream(stream, close) {
+    let settled = false;
+    const finish = () => {
+        if (settled)
+            return;
+        settled = true;
+        close();
+    };
+    return Object.freeze({
+        async cancel(reason) {
+            try {
+                await stream.cancel(reason);
+            }
+            finally {
+                finish();
+            }
+        },
+        [Symbol.asyncIterator]() {
+            const iterator = stream[Symbol.asyncIterator]();
+            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,22 @@
+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'>;
+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,88 @@
+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 MAXIMUM_DIAGNOSTICS = 32;
+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) {
+    return new errors.ProtocolError({
+        code: errors.CODES[code],
+        message,
+        ...(data === undefined ? {} : { data }),
+    });
+}
+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 input;
+    if (input instanceof InvocationError)
+        return protocolError(input.code, input.message, input.reason);
+    if (input instanceof ResponseError) {
+        return new errors.ProtocolError({
+            code: input.code,
+            message: input.message,
+            ...(input.data === undefined ? {} : { data: 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;