Variable rConst

r: Readonly<
    {
        asyncContext: <T = unknown>(id: string) => AsyncContextFluentBuilder<T>;
        error: <TData extends DefaultErrorType = DefaultErrorType>(
            id: string,
        ) => ErrorFluentBuilder<TData> & {
            is: {
                (error: unknown): error is RunnerError<DefaultErrorType>;
                (
                    error: unknown,
                    partialData: Partial<DefaultErrorType>,
                ): error is RunnerError<DefaultErrorType>;
            };
        };
        event: <TPayload = void>(
            id: string,
        ) => EventFluentBuilder<TPayload, undefined>;
        eventLane: EventLaneBuilderWithTopology;
        hook: (id: string) => HookFluentBuilderWithoutOn<{}, ITaskMeta>;
        isSameDefinition: (left: unknown, right: unknown) => boolean;
        middleware: Readonly<
            {
                resource: {
                    <C = void>(
                        id: string,
                    ): ResourceMiddlewareFluentBuilderBeforeRun<C, void, void, {}>;
                    <C, In, Out = void, D extends DependencyMapType = {}>(
                        id: string,
                    ): ResourceMiddlewareFluentBuilderBeforeRun<C, In, Out, D>;
                };
                task: {
                    <C = void>(
                        id: string,
                    ): TaskMiddlewareFluentBuilderBeforeRun<C, void, void, {}>;
                    <C, In, Out = void, D extends DependencyMapType = {}>(
                        id: string,
                    ): TaskMiddlewareFluentBuilderBeforeRun<C, In, Out, D>;
                };
            },
        >;
        override: {
            <
                TInput,
                TOutput extends Promise<any>,
                TDeps extends DependencyMapType,
                TMeta extends ITaskMeta,
                TTags extends TaskTagType[],
                TMiddleware extends TaskMiddlewareAttachmentType[],
            >(
                base: ITask<TInput, TOutput, TDeps, TMeta, TTags, TMiddleware>,
                run: (
                    input: HasInputContracts<[...TTags[], ...TMiddleware[]]> extends true
                        ? [TInput] extends [undefined]
                            ? InferInputOrViolationFromContracts<
                                [...TTags[], ...TMiddleware[]],
                            >
                            : EnsureInputSatisfiesContracts<
                                [...TTags[], ...TMiddleware[]],
                                TInput,
                            >
                        : TInput,
                    dependencies: DependencyValuesType<TDependencies>,
                    context?: TaskRunContext,
                ) => HasOutputContracts<[...TTags[], ...TMiddleware[]]> extends true
                    ? EnsureOutputSatisfiesContracts<
                        [...TTags[], ...TMiddleware[]],
                        TOutput,
                    >
                    : TOutput,
            ): ITask<TInput, TOutput, TDeps, TMeta, TTags, TMiddleware> & OverrideDefinitionBrand;
            <
                TConfig,
                TResolved,
                TDeps extends DependencyMapType,
                TContext,
                TMeta extends IResourceMeta,
                TTags extends ResourceTagType[],
                TMiddleware extends ResourceMiddlewareAttachmentType[],
            >(
                base: IResource<
                    TConfig,
                    Promise<TResolved>,
                    TDeps,
                    TContext,
                    TMeta,
                    TTags,
                    TMiddleware,
                >,
                init: (
                    config: TConfig,
                    dependencies: ResourceDependencyValuesType<TDeps>,
                    context: TContext,
                ) => Promise<TResolved>,
            ): IResource<
                TConfig,
                Promise<TResolved>,
                TDeps,
                TContext,
                TMeta,
                TTags,
                TMiddleware,
            > & OverrideDefinitionBrand;
            <
                TConfig,
                TValue extends Promise<any>,
                TDeps extends DependencyMapType,
                TContext,
                TMeta extends IResourceMeta,
                TTags extends ResourceTagType[],
                TMiddleware extends ResourceMiddlewareAttachmentType[],
            >(
                base: IResource<
                    TConfig,
                    TValue,
                    TDeps,
                    TContext,
                    TMeta,
                    TTags,
                    TMiddleware,
                >,
                patch: ResourceOverridePatch<
                    TConfig,
                    TValue,
                    TDeps,
                    TContext,
                    TMeta,
                    TTags,
                    TMiddleware,
                >,
            ): IResource<TConfig, TValue, TDeps, TContext, TMeta, TTags, TMiddleware> & OverrideDefinitionBrand;
            <
                TDeps extends DependencyMapType,
                TOn extends OnType,
                TMeta extends ITaskMeta,
            >(
                base: IHook<TDeps, TOn, TMeta>,
                run: (
                    event: IEventEmission<
                        HasSelectorEntry<TOn> extends true
                            ? any
                            : TOn extends "*"
                                ? any
                                : TOn extends readonly IEventDefinition<any>[]
                                    ? CommonPayload<TOn>
                                    : ExtractEventPayload<TOn>,
                    >,
                    dependencies: DependencyValuesType<TDependencies>,
                ) => Promise<HookRunResult<TOn>>,
            ): IHook<TDeps, TOn, TMeta> & OverrideDefinitionBrand;
            <C, In, Out, D extends DependencyMapType>(
                base: ITaskMiddleware<C, In, Out, D>,
                run: (
                    input: ITaskMiddlewareExecutionInput<
                        In extends void ? any : In,
                        Out extends void ? any : Out,
                    >,
                    dependencies: DependencyValuesType<TDependencies>,
                    config: C,
                ) => Promise<any>,
            ): ITaskMiddleware<C, In, Out, D, TaskMiddlewareTagType[]> & OverrideDefinitionBrand;
            <C, In, Out, D extends DependencyMapType>(
                base: IResourceMiddleware<C, In, Out, D>,
                run: (
                    input: IResourceMiddlewareExecutionInput<
                        In extends void ? any : In,
                        Out extends void ? any : Out,
                    >,
                    dependencies: DependencyValuesType<TDependencies>,
                    config: C,
                ) => Promise<any>,
            ): IResourceMiddleware<C, In, Out, D, ResourceMiddlewareTagType[]> & OverrideDefinitionBrand;
        };
        resource: <TConfig = void>(
            id: string,
            options?: ResourceBuilderOptions,
        ) => ResourceFluentBuilderBeforeInit<
            TConfig,
            Promise<any>,
            {},
            any,
            IResourceMeta,
            ResourceTagType[],
            ResourceMiddlewareAttachmentType[],
        >;
        rpcLane: RpcLaneBuilderWithTopology;
        scope: (
            target: IsolationScopeTarget | readonly IsolationScopeTarget[],
            channels?: IsolationChannels,
        ) => IsolationScope;
        subtreeOf: (
            resource: AnyResource,
            options?: { types?: readonly ItemType[] },
        ) => IsolationSubtreeFilter;
        tag: <
            TConfig = void,
            TEnforceIn = void,
            TEnforceOut = void,
            TAllowedTargets extends void | TagTarget = void,
        >(
            id: string,
        ) => TagFluentBuilder<TConfig, TEnforceIn, TEnforceOut, TAllowedTargets>;
        task: <TInput = undefined>(
            id: string,
        ) => TaskFluentBuilder<
            TInput,
            Promise<any>,
            {},
            ITaskMeta,
            TaskTagType[],
            TaskMiddlewareAttachmentType[],
        >;
    },
> = ...

import { r, run } from "@bluelibs/runner";

const greet = r.task("app.tasks.greet")
  .inputSchema({ name: String })
  .run(async (input) => `Hello, ${input.name}!`)
  .build();

const app = r.resource("app").register([greet]).build();
const runtime = await run(app);
const msg = await runtime.runTask(greet, { name: "Ada" });
await runtime.dispose();
Copy