@bluelibs/runner 4.5.9 → 4.5.10

package/AI.md

@@ -184,9 +184,7 @@ import { globals, task } from "@bluelibs/runner";
 
 const critical = task({
   id: "app.tasks.critical",
-  tags: [
-    globals.tags.debug.with({ logTaskInput: true, logTaskOutput: true }),
-  ],
+  tags: [globals.tags.debug.with({ logTaskInput: true, logTaskOutput: true })],
   run: async () => "ok",
 });
 ```
@@ -203,7 +201,7 @@ const logsExtension = resource({
     logger.info("test", { example: 123 }); // "trace", "debug", "info", "warn", "error", "critical"
     const sublogger = logger.with({
       source: "app.logs",
-      context: {},
+      additionalContext: {},
     });
     logger.onLog((log) => {
       // ship or transform
@@ -238,7 +236,8 @@ export async function getRunner() {
 // handler.ts
 export const handler = async (event: any, context: any) => {
   const rr: any = await getRunner();
-  const method = event?.requestContext?.http?.method ?? event?.httpMethod ?? "GET";
+  const method =
+    event?.requestContext?.http?.method ?? event?.httpMethod ?? "GET";
   const path = event?.rawPath || event?.path || "/";
   const rawBody = event?.body
     ? event.isBase64Encoded
@@ -247,9 +246,12 @@ export const handler = async (event: any, context: any) => {
     : undefined;
   const body = rawBody ? JSON.parse(rawBody) : undefined;
 
-  return RequestCtx.provide({ requestId: context?.awsRequestId ?? "local", method, path }, async () => {
-    // route and call rr.runTask(...)
-  });
+  return RequestCtx.provide(
+    { requestId: context?.awsRequestId ?? "local", method, path },
+    async () => {
+      // route and call rr.runTask(...)
+    },
+  );
 };
 ```
 
@@ -396,6 +398,21 @@ const { dispose } = await run(app, {
 });
 ```
 
+## Type Helpers
+
+Extract generics from tasks, resources, and events without re-declaring their shapes and avoid use of 'any'.
+
+```ts
+import { task, resource, event } from "@bluelibs/runner";
+import type {
+  ExtractTaskInput, // ExtractTaskInput(typeof myTask)
+  ExtractTaskOutput,
+  ExtractResourceConfig,
+  ExtractResourceValue,
+  ExtractEventPayload,
+} from "@bluelibs/runner";
+```
+
 ## Run Options (high‑level)
 
 - debug: "normal" | "verbose" | DebugConfig
@@ -521,115 +538,40 @@ Coverage tip: the script name is `npm run coverage`.
 
 ## Metadata & Tags
 
+Tags and meta can be applied to all elements.
+
 ```ts
 import { tag, globals, task, resource } from "@bluelibs/runner";
 
-// Simple tags and debug/system globals
-const perf = tag<{ warnAboveMs: number }>({ id: "perf" });
 const contractTag = tag<void, void, { result: string }>({ id: "contract" });
-
-const processPayment = task({
-  id: "app.tasks.pay",
-  tags: [perf.with({ warnAboveMs: 1000 })],
-  meta: {
-    title: "Process Payment",
-    description: "Detailed",
-  },
-  run: async () => {
-    /* ... */
-  },
-});
-
-const internalSvc = resource({
-  id: "app.resources.internal",
-  register: [perf],
-  tags: [globals.tags.system],
-  init: async () => ({}),
-});
-```
-
-### Tag Contracts (type‑enforced returns)
-
-```ts
-// Contract enforces the awaited return type (Config, Input, Output)
-const userContract = tag<void, void, { name: string }>({ id: "contract.user" });
-
-const getProfile = task({
-  id: "app.tasks.getProfile",
-  tags: [userContract],
-  run: async () => ({ name: "Ada" }), // must contain { name: string }
+const httpRouteTag = tag<{ method: "GET" | "POST"; path: string }>({
+  id: "httpRoute",
 });
 
-const profileService = resource({
-  id: "app.resources.profile",
-  tags: [userContract],
-  init: async () => ({ name: "Ada" }),
-});
-```
-
-### Tag Extraction (behavior flags)
-
-```ts
-const perf = tag<{ warnAboveMs: number }>({ id: "perf" });
-
-const perfMiddleware = taskMiddleware({
-  id: "app.middleware.perf",
-  run: async ({ task, next }) => {
-    const cfg = perf.extract(task.definition);
-    // use perf.exists(task.definition) to check for existence
-    if (!cfg) return next(task.input);
-    // performance hooks here ...
+const task = task({
+  id: "app.tasks.myTask",
+  tags: [contractTag, httpRouteTag.with({ method: "POST", path: "/do" })],
+  run: async () => ({ result: "ok" }), // must return { result: string }
+  meta: {
+    title: "My Task",
+    description: "Does something important", // multi-line description, markdown
   },
 });
 ```
 
-### Intercept Tasks via Tags (programmatic wiring)
-
-Use a hook on `globals.events.ready` to discover and intercept tasks by tag:
+Usage:
 
 ```ts
-import { hook, globals, tag } from "@bluelibs/runner";
-
-const apiTag = tag<void>({ id: "api" });
-
-const addTracingToApiTasks = hook({
-  id: "app.hooks.traceApis",
+const onReady = hook({
+  id: "app.hooks.onReady",
   on: globals.events.ready,
   dependencies: { store: globals.resources.store },
   run: async (_, { store }) => {
-    const apiTasks = store.getTasksWithTag(apiTag); // tag object or string id
-    apiTasks.forEach((taskDef) => {
-      taskDef.intercept(async (next, input) => {
-        // ...
-      });
-    });
-    // Apply same concept to routing like fastify, express routes based on tag config to your fastify instance.
-  },
-});
-```
-
-### Route registration via tags (ready hook)
-
-```ts
-import { hook, globals } from "@bluelibs/runner";
-import { httpTag } from "./http.tag"; // your structured tag (method, path, schemas, etc.)
-import { expressServer } from "./expressServer"; // resource that returns { app, port }
-
-const registerRoutes = hook({
-  id: "app.hooks.registerRoutes",
-  on: globals.events.ready,
-  dependencies: { store: globals.resources.store, server: expressServer },
-  run: async (_, { store, server }) => {
-    const tasks = store.getTasksWithTag(httpTag);
+    // Same concept for resources
+    const tasks = store.getTasksWithTag(httpRouteTag); // uses httpRouteTag.exists(component);
     tasks.forEach((t) => {
-      const cfg = httpTag.extract(t.meta?.tags || []);
-      if (!cfg?.config) return;
-      const { method, path } = cfg.config;
-      if (!method || !path) return;
-      (server.app as any)[method.toLowerCase()](path, async (req, res) => {
-        const result = await t({ ...req.body, ...req.query, ...req.params });
-        res.json(result);
-      });
+      const cfg = httpRouteTag.extract(tasks); // { method, path }
+      // you can even do t
     });
   },
 });
@@ -704,7 +646,7 @@ interface IValidationSchema<T> {
 }
 ```
 
-Works out of the box with Zod (`z.object(...).parse`), and can be adapted for Yup/Joi with small wrappers.
+Works out of the box with Zod (`z.object(...).parse`), and can be adapted for Yup/Joi with small wrappers. As it only needs a parse() method.
 
 ```ts
 import { z } from "zod";
@@ -728,6 +670,10 @@ event({
   payloadSchema, // Runs on event emission
 });
 
+tag({
+  configSchema, // Tag config validation (runs on .with())
+});
+
 // Middleware config validation (runs on .with())
 middleware({
   // ...

package/README.md

@@ -958,6 +958,43 @@ const handleRequest = resource({
 });
 ```
 
+## Type Helpers
+
+These utility types help you extract the generics from tasks, resources, and events without re-declaring them. Import them from `@bluelibs/runner`.
+
+```ts
+import { task, resource, event } from "@bluelibs/runner";
+import type {
+  ExtractTaskInput,
+  ExtractTaskOutput,
+  ExtractResourceConfig,
+  ExtractResourceValue,
+  ExtractEventPayload,
+} from "@bluelibs/runner";
+
+// Task example
+const add = task({
+  id: "calc.add",
+  run: async (input: { a: number; b: number }) => input.a + input.b,
+});
+
+type AddInput = ExtractTaskInput<typeof add>; // { a: number; b: number }
+type AddOutput = ExtractTaskOutput<typeof add>; // number
+
+// Resource example
+const config = resource({
+  id: "app.config",
+  init: async (cfg: { baseUrl: string }) => ({ baseUrl: cfg.baseUrl }),
+});
+
+type ConfigInput = ExtractResourceConfig<typeof config>; // { baseUrl: string }
+type ConfigValue = ExtractResourceValue<typeof config>; // { baseUrl: string }
+
+// Event example
+const userRegistered = event<{ userId: string; email: string }>({ id: "app.events.userRegistered" });
+type UserRegisteredPayload = ExtractEventPayload<typeof userRegistered>; // { userId: string; email: string }
+```
+
 ### Context with Middleware
 
 Context shines when combined with middleware for request-scoped data:
@@ -1328,7 +1365,7 @@ BlueLibs Runner achieves high performance while providing enterprise features:
 | Event System         | ~0.013ms             | Loose coupling, observability |
 | Middleware Chain     | ~0.0003ms/middleware | Cross-cutting concerns        |
 | Resource Management  | One-time init        | Singleton pattern, lifecycle  |
-| Built-in Caching     | 1.8x speedup         | Automatic optimization        |
+| Built-in Caching     | Variable speedup     | Automatic optimization        |
 
 **Bottom line**: The framework adds minimal overhead (~0.005ms per task) while providing significant architectural benefits.
 
@@ -1552,10 +1589,12 @@ const requestHandler = task({
     const request = RequestContext.use();
 
     // Create a contextual logger with bound metadata with source and context
-    const requestLogger = logger.with("api.handler", {
+    const requestLogger = logger.with({
       source: requestHandler.id,
-      requestId: request.requestId,
-      userId: request.userId,
+      additionalContext: {
+        requestId: request.requestId,
+        userId: request.userId,
+      },
     });
 
     // All logs from this logger will include the bound context

package/dist/index.d.ts

@@ -395,7 +395,7 @@ interface IHookDefinition<TDependencies extends DependencyMapType = {}, TOn exte
     /** Listener execution order. Lower numbers run first. */
     order?: number;
     meta?: TMeta;
-    run: (event: IEventEmission<TOn extends "*" ? any : TOn extends readonly IEventDefinition<any>[] ? CommonPayload<TOn> : ExtractEventParams<TOn>>, dependencies: DependencyValuesType<TDependencies>) => Promise<any>;
+    run: (event: IEventEmission<TOn extends "*" ? any : TOn extends readonly IEventDefinition<any>[] ? CommonPayload<TOn> : ExtractEventPayload<TOn>>, dependencies: DependencyValuesType<TDependencies>) => Promise<any>;
     tags?: TagType[];
 }
 interface IHook<TDependencies extends DependencyMapType = {}, TOn extends OnType = any, TMeta extends ITaskMeta = any> extends IHookDefinition<TDependencies, TOn, TMeta> {
@@ -529,12 +529,13 @@ interface IOptionalDependency<T> {
 }
 type ExtractTaskInput<T> = T extends ITask<infer I, any, infer D> ? I : never;
 type ExtractTaskOutput<T> = T extends ITask<any, infer O, infer D> ? O : never;
+type ExtractResourceConfig<T> = T extends IResource<infer C, any, any> ? C : never;
 type ExtractResourceValue<T> = T extends IResource<any, infer V, infer D> ? V extends Promise<infer U> ? U : V : never;
-type ExtractEventParams<T> = T extends IEventDefinition<infer P> ? P : T extends IEvent<infer P> ? P : never;
+type ExtractEventPayload<T> = T extends IEventDefinition<infer P> ? P : T extends IEvent<infer P> ? P : never;
 type UnionToIntersection<U> = (U extends any ? (x: U) => any : never) extends (x: infer I) => any ? I : never;
 type CommonPayload<T extends readonly IEventDefinition<any>[] | IEventDefinition<any>> = T extends readonly IEventDefinition<any>[] ? {
-    [K in keyof ExtractEventParams<T[number]>]: UnionToIntersection<ExtractEventParams<T[number]> extends any ? ExtractEventParams<T[number]>[K] : never>;
-} : ExtractEventParams<T>;
+    [K in keyof ExtractEventPayload<T[number]>]: UnionToIntersection<ExtractEventPayload<T[number]> extends any ? ExtractEventPayload<T[number]>[K] : never>;
+} : ExtractEventPayload<T>;
 /**
  * Task dependencies transform into callable functions: call with the task input
  * and you receive the task output.
@@ -555,7 +556,7 @@ type EventDependency<P> = P extends void ? (() => Promise<void>) & ((input?: Rec
  * - Resource -> resolved value
  * - Event -> emit function
  */
-type DependencyValueType<T> = T extends ITask<any, any, any> ? TaskDependency<ExtractTaskInput<T>, ExtractTaskOutput<T>> : T extends IResource<any, any> ? ResourceDependency<ExtractResourceValue<T>> : T extends IEventDefinition<any> ? EventDependency<ExtractEventParams<T>> : T extends IOptionalDependency<infer U> ? DependencyValueType<U> | undefined : never;
+type DependencyValueType<T> = T extends ITask<any, any, any> ? TaskDependency<ExtractTaskInput<T>, ExtractTaskOutput<T>> : T extends IResource<any, any> ? ResourceDependency<ExtractResourceValue<T>> : T extends IEventDefinition<any> ? EventDependency<ExtractEventPayload<T>> : T extends IOptionalDependency<infer U> ? DependencyValueType<U> | undefined : never;
 type DependencyValuesType<T extends DependencyMapType> = {
     [K in keyof T]: DependencyValueType<T[K]>;
 };
@@ -564,7 +565,7 @@ type TaskDependencyWithIntercept<TInput, TOutput> = TaskDependency<TInput, TOutp
     intercept: (middleware: TaskLocalInterceptor<TInput, TOutput>) => void;
 };
 /** Resource-context dependency typing where tasks expose intercept() */
-type ResourceDependencyValueType<T> = T extends ITask<any, any, any> ? TaskDependencyWithIntercept<ExtractTaskInput<T>, ExtractTaskOutput<T>> : T extends IResource<any, any> ? ResourceDependency<ExtractResourceValue<T>> : T extends IEventDefinition<any> ? EventDependency<ExtractEventParams<T>> : T extends IOptionalDependency<infer U> ? ResourceDependencyValueType<U> | undefined : never;
+type ResourceDependencyValueType<T> = T extends ITask<any, any, any> ? TaskDependencyWithIntercept<ExtractTaskInput<T>, ExtractTaskOutput<T>> : T extends IResource<any, any> ? ResourceDependency<ExtractResourceValue<T>> : T extends IEventDefinition<any> ? EventDependency<ExtractEventPayload<T>> : T extends IOptionalDependency<infer U> ? ResourceDependencyValueType<U> | undefined : never;
 type ResourceDependencyValuesType<T extends DependencyMapType> = {
     [K in keyof T]: ResourceDependencyValueType<T[K]>;
 };
@@ -870,7 +871,11 @@ type defs_DependencyValueType<T> = DependencyValueType<T>;
 type defs_DependencyValuesType<T extends DependencyMapType> = DependencyValuesType<T>;
 type defs_EventHandlerType<T = any> = EventHandlerType<T>;
 type defs_EventStoreElementType = EventStoreElementType;
-type defs_ExtractEventParams<T> = ExtractEventParams<T>;
+type defs_ExtractEventPayload<T> = ExtractEventPayload<T>;
+type defs_ExtractResourceConfig<T> = ExtractResourceConfig<T>;
+type defs_ExtractResourceValue<T> = ExtractResourceValue<T>;
+type defs_ExtractTaskInput<T> = ExtractTaskInput<T>;
+type defs_ExtractTaskOutput<T> = ExtractTaskOutput<T>;
 type defs_HookStoreElementType<D extends DependencyMapType = any, TOn extends "*" | IEventDefinition = any> = HookStoreElementType<D, TOn>;
 type defs_ICacheInstance = ICacheInstance;
 type defs_IEvent<TPayload = any> = IEvent<TPayload>;
@@ -938,7 +943,7 @@ declare const defs_symbolTagConfigured: typeof symbolTagConfigured;
 declare const defs_symbolTask: typeof symbolTask;
 declare const defs_symbolTaskMiddleware: typeof symbolTaskMiddleware;
 declare namespace defs {
-  export { type defs_CommonPayload as CommonPayload, type defs_DependencyMapType as DependencyMapType, type defs_DependencyValueType as DependencyValueType, type defs_DependencyValuesType as DependencyValuesType, type defs_EventHandlerType as EventHandlerType, type defs_EventStoreElementType as EventStoreElementType, type defs_ExtractEventParams as ExtractEventParams, type defs_HookStoreElementType as HookStoreElementType, type defs_ICacheInstance as ICacheInstance, type defs_IEvent as IEvent, type defs_IEventDefinition as IEventDefinition, type defs_IEventEmission as IEventEmission, type defs_IEventMeta as IEventMeta, type defs_IHook as IHook, type defs_IHookDefinition as IHookDefinition, type defs_IMeta as IMeta, type defs_IMiddlewareMeta as IMiddlewareMeta, type defs_IOptionalDependency as IOptionalDependency, type defs_IResource as IResource, type defs_IResourceDefinition as IResourceDefinition, type defs_IResourceMeta as IResourceMeta, type defs_IResourceMiddleware as IResourceMiddleware, type defs_IResourceMiddlewareConfigured as IResourceMiddlewareConfigured, type defs_IResourceMiddlewareDefinition as IResourceMiddlewareDefinition, type defs_IResourceMiddlewareExecutionInput as IResourceMiddlewareExecutionInput, type defs_IResourceWithConfig as IResourceWithConfig, type defs_ITag as ITag, type defs_ITagConfigured as ITagConfigured, type defs_ITagDefinition as ITagDefinition, type defs_ITagMeta as ITagMeta, type defs_ITaggable as ITaggable, type defs_ITask as ITask, type defs_ITaskDefinition as ITaskDefinition, type defs_ITaskMeta as ITaskMeta, type defs_ITaskMiddleware as ITaskMiddleware, type defs_ITaskMiddlewareConfigured as ITaskMiddlewareConfigured, type defs_ITaskMiddlewareDefinition as ITaskMiddlewareDefinition, type defs_ITaskMiddlewareExecutionInput as ITaskMiddlewareExecutionInput, type defs_IValidationSchema as IValidationSchema, type defs_OverridableElements as OverridableElements, type defs_RegisterableItems as RegisterableItems, type defs_RequiredKeys as RequiredKeys, type defs_ResourceDependencyValueType as ResourceDependencyValueType, type defs_ResourceDependencyValuesType as ResourceDependencyValuesType, type defs_ResourceMiddlewareAttachmentType as ResourceMiddlewareAttachmentType, type defs_ResourceMiddlewareStoreElementType as ResourceMiddlewareStoreElementType, type defs_ResourceStoreElementType as ResourceStoreElementType, type defs_RunOptions as RunOptions, type defs_TagType as TagType, type defs_TaskDependencyWithIntercept as TaskDependencyWithIntercept, type defs_TaskLocalInterceptor as TaskLocalInterceptor, type defs_TaskMiddlewareAttachmentType as TaskMiddlewareAttachmentType, type defs_TaskMiddlewareStoreElementType as TaskMiddlewareStoreElementType, type defs_TaskStoreElementType as TaskStoreElementType, type defs_UnionToIntersection as UnionToIntersection, defs_isOneOf as isOneOf, defs_onAnyOf as onAnyOf, defs_symbolDispose as symbolDispose, defs_symbolEvent as symbolEvent, defs_symbolFilePath as symbolFilePath, defs_symbolHook as symbolHook, defs_symbolIndexResource as symbolIndexResource, defs_symbolMiddleware as symbolMiddleware, defs_symbolMiddlewareConfigured as symbolMiddlewareConfigured, defs_symbolOptionalDependency as symbolOptionalDependency, defs_symbolResource as symbolResource, defs_symbolResourceMiddleware as symbolResourceMiddleware, defs_symbolResourceWithConfig as symbolResourceWithConfig, defs_symbolStore as symbolStore, defs_symbolTag as symbolTag, defs_symbolTagConfigured as symbolTagConfigured, defs_symbolTask as symbolTask, defs_symbolTaskMiddleware as symbolTaskMiddleware };
+  export { type defs_CommonPayload as CommonPayload, type defs_DependencyMapType as DependencyMapType, type defs_DependencyValueType as DependencyValueType, type defs_DependencyValuesType as DependencyValuesType, type defs_EventHandlerType as EventHandlerType, type defs_EventStoreElementType as EventStoreElementType, type defs_ExtractEventPayload as ExtractEventPayload, type defs_ExtractResourceConfig as ExtractResourceConfig, type defs_ExtractResourceValue as ExtractResourceValue, type defs_ExtractTaskInput as ExtractTaskInput, type defs_ExtractTaskOutput as ExtractTaskOutput, type defs_HookStoreElementType as HookStoreElementType, type defs_ICacheInstance as ICacheInstance, type defs_IEvent as IEvent, type defs_IEventDefinition as IEventDefinition, type defs_IEventEmission as IEventEmission, type defs_IEventMeta as IEventMeta, type defs_IHook as IHook, type defs_IHookDefinition as IHookDefinition, type defs_IMeta as IMeta, type defs_IMiddlewareMeta as IMiddlewareMeta, type defs_IOptionalDependency as IOptionalDependency, type defs_IResource as IResource, type defs_IResourceDefinition as IResourceDefinition, type defs_IResourceMeta as IResourceMeta, type defs_IResourceMiddleware as IResourceMiddleware, type defs_IResourceMiddlewareConfigured as IResourceMiddlewareConfigured, type defs_IResourceMiddlewareDefinition as IResourceMiddlewareDefinition, type defs_IResourceMiddlewareExecutionInput as IResourceMiddlewareExecutionInput, type defs_IResourceWithConfig as IResourceWithConfig, type defs_ITag as ITag, type defs_ITagConfigured as ITagConfigured, type defs_ITagDefinition as ITagDefinition, type defs_ITagMeta as ITagMeta, type defs_ITaggable as ITaggable, type defs_ITask as ITask, type defs_ITaskDefinition as ITaskDefinition, type defs_ITaskMeta as ITaskMeta, type defs_ITaskMiddleware as ITaskMiddleware, type defs_ITaskMiddlewareConfigured as ITaskMiddlewareConfigured, type defs_ITaskMiddlewareDefinition as ITaskMiddlewareDefinition, type defs_ITaskMiddlewareExecutionInput as ITaskMiddlewareExecutionInput, type defs_IValidationSchema as IValidationSchema, type defs_OverridableElements as OverridableElements, type defs_RegisterableItems as RegisterableItems, type defs_RequiredKeys as RequiredKeys, type defs_ResourceDependencyValueType as ResourceDependencyValueType, type defs_ResourceDependencyValuesType as ResourceDependencyValuesType, type defs_ResourceMiddlewareAttachmentType as ResourceMiddlewareAttachmentType, type defs_ResourceMiddlewareStoreElementType as ResourceMiddlewareStoreElementType, type defs_ResourceStoreElementType as ResourceStoreElementType, type defs_RunOptions as RunOptions, type defs_TagType as TagType, type defs_TaskDependencyWithIntercept as TaskDependencyWithIntercept, type defs_TaskLocalInterceptor as TaskLocalInterceptor, type defs_TaskMiddlewareAttachmentType as TaskMiddlewareAttachmentType, type defs_TaskMiddlewareStoreElementType as TaskMiddlewareStoreElementType, type defs_TaskStoreElementType as TaskStoreElementType, type defs_UnionToIntersection as UnionToIntersection, defs_isOneOf as isOneOf, defs_onAnyOf as onAnyOf, defs_symbolDispose as symbolDispose, defs_symbolEvent as symbolEvent, defs_symbolFilePath as symbolFilePath, defs_symbolHook as symbolHook, defs_symbolIndexResource as symbolIndexResource, defs_symbolMiddleware as symbolMiddleware, defs_symbolMiddlewareConfigured as symbolMiddlewareConfigured, defs_symbolOptionalDependency as symbolOptionalDependency, defs_symbolResource as symbolResource, defs_symbolResourceMiddleware as symbolResourceMiddleware, defs_symbolResourceWithConfig as symbolResourceWithConfig, defs_symbolStore as symbolStore, defs_symbolTag as symbolTag, defs_symbolTagConfigured as symbolTagConfigured, defs_symbolTask as symbolTask, defs_symbolTaskMiddleware as symbolTaskMiddleware };
 }
 
 /**
@@ -1756,4 +1761,4 @@ declare const globals: {
     };
 };
 
-export { type CommonPayload, type Context, type DebugConfig, type DebugFriendlyConfig, type DependencyMapType, DependencyProcessor, type DependencyValueType, type DependencyValuesType, errors as Errors, type EventEmissionInterceptor, type EventHandlerType, EventManager, type EventStoreElementType, type ExtractEventParams, type HookExecutionInterceptor, type HookStoreElementType, type ICacheInstance, type IEvent, type IEventDefinition, type IEventEmission, type IEventHandlerOptions, type IEventMeta, type IHook, type IHookDefinition, type ILog, type ILogInfo, type IMeta, type IMiddlewareMeta, type IOptionalDependency, type IResource, type IResourceDefinition, type IResourceMeta, type IResourceMiddleware, type IResourceMiddlewareConfigured, type IResourceMiddlewareDefinition, type IResourceMiddlewareExecutionInput, type IResourceWithConfig, type ITag, type ITagConfigured, type ITagDefinition, type ITagMeta, type ITaggable, type ITask, type ITaskDefinition, type ITaskMeta, type ITaskMiddleware, type ITaskMiddlewareConfigured, type ITaskMiddlewareDefinition, type ITaskMiddlewareExecutionInput, type IValidationSchema, type LogLevels, Logger, MiddlewareManager, type OnUnhandledError, type OnUnhandledErrorInfo, type OverridableElements, type PrintStrategy, Queue, type RegisterableItems, type RequiredKeys, type ResourceDependencyValueType, type ResourceDependencyValuesType, ResourceInitializer, type ResourceMiddlewareAttachmentType, type ResourceMiddlewareInterceptor, type ResourceMiddlewareStoreElementType, type ResourceStoreElementType, type RunOptions, RunResult, Semaphore, Store, type TagType, type TaskDependencyWithIntercept, type TaskLocalInterceptor, type TaskMiddlewareAttachmentType, type TaskMiddlewareInterceptor, type TaskMiddlewareStoreElementType, TaskRunner, type TaskStoreElementType, type UnhandledErrorKind, type UnionToIntersection, allFalse, bindProcessErrorHandler, createContext, createDefaultUnhandledError, createTestResource, defs as definitions, defineEvent as event, getConfig, globals, defineHook as hook, isOneOf, levelNormal, levelVerbose, onAnyOf, defineOverride as override, defineResource as resource, defineResourceMiddleware as resourceMiddleware, run, safeReportUnhandledError, symbolDispose, symbolEvent, symbolFilePath, symbolHook, symbolIndexResource, symbolMiddleware, symbolMiddlewareConfigured, symbolOptionalDependency, symbolResource, symbolResourceMiddleware, symbolResourceWithConfig, symbolStore, symbolTag, symbolTagConfigured, symbolTask, symbolTaskMiddleware, defineTag as tag, defineTask as task, defineTaskMiddleware as taskMiddleware };
+export { type CommonPayload, type Context, type DebugConfig, type DebugFriendlyConfig, type DependencyMapType, DependencyProcessor, type DependencyValueType, type DependencyValuesType, errors as Errors, type EventEmissionInterceptor, type EventHandlerType, EventManager, type EventStoreElementType, type ExtractEventPayload, type ExtractResourceConfig, type ExtractResourceValue, type ExtractTaskInput, type ExtractTaskOutput, type HookExecutionInterceptor, type HookStoreElementType, type ICacheInstance, type IEvent, type IEventDefinition, type IEventEmission, type IEventHandlerOptions, type IEventMeta, type IHook, type IHookDefinition, type ILog, type ILogInfo, type IMeta, type IMiddlewareMeta, type IOptionalDependency, type IResource, type IResourceDefinition, type IResourceMeta, type IResourceMiddleware, type IResourceMiddlewareConfigured, type IResourceMiddlewareDefinition, type IResourceMiddlewareExecutionInput, type IResourceWithConfig, type ITag, type ITagConfigured, type ITagDefinition, type ITagMeta, type ITaggable, type ITask, type ITaskDefinition, type ITaskMeta, type ITaskMiddleware, type ITaskMiddlewareConfigured, type ITaskMiddlewareDefinition, type ITaskMiddlewareExecutionInput, type IValidationSchema, type LogLevels, Logger, MiddlewareManager, type OnUnhandledError, type OnUnhandledErrorInfo, type OverridableElements, type PrintStrategy, Queue, type RegisterableItems, type RequiredKeys, type ResourceDependencyValueType, type ResourceDependencyValuesType, ResourceInitializer, type ResourceMiddlewareAttachmentType, type ResourceMiddlewareInterceptor, type ResourceMiddlewareStoreElementType, type ResourceStoreElementType, type RunOptions, RunResult, Semaphore, Store, type TagType, type TaskDependencyWithIntercept, type TaskLocalInterceptor, type TaskMiddlewareAttachmentType, type TaskMiddlewareInterceptor, type TaskMiddlewareStoreElementType, TaskRunner, type TaskStoreElementType, type UnhandledErrorKind, type UnionToIntersection, allFalse, bindProcessErrorHandler, createContext, createDefaultUnhandledError, createTestResource, defs as definitions, defineEvent as event, getConfig, globals, defineHook as hook, isOneOf, levelNormal, levelVerbose, onAnyOf, defineOverride as override, defineResource as resource, defineResourceMiddleware as resourceMiddleware, run, safeReportUnhandledError, symbolDispose, symbolEvent, symbolFilePath, symbolHook, symbolIndexResource, symbolMiddleware, symbolMiddlewareConfigured, symbolOptionalDependency, symbolResource, symbolResourceMiddleware, symbolResourceWithConfig, symbolStore, symbolTag, symbolTagConfigured, symbolTask, symbolTaskMiddleware, defineTag as tag, defineTask as task, defineTaskMiddleware as taskMiddleware };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bluelibs/runner",
-  "version": "4.5.9",
+  "version": "4.5.10",
   "description": "BlueLibs Runner",
   "sideEffects": false,
   "main": "dist/index.cjs",