@andrew_l/app 0.3.8 → 0.4.0

package/dist/index.d.mts

@@ -1,21 +1,25 @@
-import { IfAny, Data, Logger, AnyFunction, Awaitable, SimpleEventEmitter, ExecResult, LogLevel, Scheduler, AsyncIterableQueue, ResourcePool, CancellablePromise } from '@andrew_l/toolkit';
-import * as cp from 'node:child_process';
-import { EventEmitter } from 'node:events';
-
+import { AnyFunction, AsyncIterableQueue, Awaitable, CancellablePromise, Data, ExecResult, LogLevel, Logger, ResourcePool, Scheduler, SimpleEventEmitter } from "@andrew_l/toolkit";
+import * as cp from "node:child_process";
+import { EventEmitter } from "node:events";
+import { Option } from "commander";
 /**
  * Declaration for a single typed app prop.
  * @group Types
  */
 interface PropOptions<T = any> {
-    type: PropType<T> | null;
-    description?: string;
-    alias?: string;
-    required?: boolean;
-    env?: string | string[];
-    default?: () => InferPropType<T>;
-    parser?: (value: string) => InferPropType<T>;
-    enum?: string[];
+  type: PropType<T> | null;
+  description?: string;
+  alias?: string;
+  required?: boolean;
+  env?: string | string[];
+  default?: () => InferPropType<T>;
+  parser?: (value: string) => InferPropType<T>;
+  enum?: string[];
 }
+/**
+ * @group Types
+ */
+type Prop<T> = PropOptions<T> | PropType<T>;
 /**
  * @group Types
  */
@@ -24,146 +28,129 @@ type PropType<T> = PropConstructor<T> | PropConstructor<T>[];
  * Map of prop declarations keyed by name — passed as `props` in `defineApp`.
  * @group Types
  */
-type ObjectPropsOptions<P = Data> = {
-    [K in keyof P]: PropOptions<P[K]>;
-};
+type ObjectPropsOptions<P = Data> = { [K in keyof P]: PropOptions<P[K]> };
 type PropConstructor<T = any> = {
-    new (...args: any[]): T & {};
+  new (...args: any[]): T & {};
 } | {
-    (): T;
+  (): T;
 } | PropMethod<T>;
-type PropMethod<T, TConstructor = any> = [T] extends [
-    ((...args: any) => any) | undefined
-] ? {
-    new (): TConstructor;
-    (): T;
-    readonly prototype: TConstructor;
+type PropMethod<T, TConstructor = any> = [T] extends [((...args: any) => any) | undefined] ? {
+  new (): TConstructor;
+  (): T;
+  readonly prototype: TConstructor;
 } : never;
 type OptionalKeys<T> = Exclude<keyof T, RequiredKeys<T>>;
-type RequiredKeys<T> = {
-    [K in keyof T]: T[K] extends {
-        required: true;
-    } ? K : never;
-}[keyof T];
-type InferPropType<T> = [T] extends [null] ? any : [T] extends [{
-    type: null;
+type RequiredKeys<T> = { [K in keyof T]: T[K] extends {
+  required: true;
+} ? K : never }[keyof T];
+type InferPropType<T, NullAsAny = true> = [T] extends [null] ? NullAsAny extends true ? any : null : [T] extends [{
+  type: null | true;
 }] ? any : [T] extends [ObjectConstructor | {
-    type: ObjectConstructor;
+  type: ObjectConstructor;
 }] ? Record<string, any> : [T] extends [BooleanConstructor | {
-    type: BooleanConstructor;
+  type: BooleanConstructor;
 }] ? boolean : [T] extends [DateConstructor | {
-    type: DateConstructor;
-}] ? Date : [T] extends [DateConstructor | {
-    type: DateConstructor;
-}] ? Date : [T] extends [StringConstructor | {
-    type: StringConstructor;
-}] ? string : [T] extends [(infer U)[] | {
-    type: (infer U)[];
-}] ? U extends DateConstructor ? Date | InferPropType<U> : InferPropType<U> : [T] extends [PropOptions<infer V>] ? unknown extends V ? IfAny<V, V, V> : V : T;
+  type: DateConstructor;
+}] ? Date : [T] extends [(infer U)[] | {
+  type: (infer U)[];
+}] ? U extends DateConstructor ? Date | InferPropType<U, false> : InferPropType<U, false> : [T] extends [Prop<infer V>] ? V : T;
 /**
  * Resolve the concrete prop value types from an `ObjectPropsOptions` declaration.
  * @group Types
  */
-type ExtractPropTypes<O> = {
-    [K in keyof Pick<O, RequiredKeys<O>>]: InferPropType<O[K]>;
-} & {
-    [K in keyof Pick<O, OptionalKeys<O>>]?: InferPropType<O[K]>;
-};
-
+type ExtractPropTypes<O> = { [K in keyof Pick<O, RequiredKeys<O>>]: InferPropType<O[K]> } & { [K in keyof Pick<O, OptionalKeys<O>>]?: InferPropType<O[K]> };
 declare namespace AppDefinition {
-    type EntryContext<T extends Data = Data> = T & {
-        log: Logger;
-    };
-    type SetupContext<T extends Data = Data> = T & {
-        log: Logger;
-    };
-    type RuntimeContext<T extends Data = Data> = T & {
-        log: Logger;
-    };
+  type EntryContext<T extends Data = Data> = T & {
+    log: Logger;
+  };
+  type SetupContext<T extends Data = Data> = T & {
+    log: Logger;
+  };
+  type RuntimeContext<T extends Data = Data> = T & {
+    log: Logger;
+  };
 }
 /**
  * Shape of an application — name, typed props, lifecycle hooks, and optional methods.
  * @group Types
  */
 interface AppDefinition<P extends ObjectPropsOptions = {}, S extends Record<string, any> = {}, M extends Record<string, AnyFunction> = {}, RuntimeContext extends AppDefinition.RuntimeContext = AppDefinition.RuntimeContext<S & M>, EntryContext extends AppDefinition.EntryContext = AppDefinition.EntryContext<S & M>, SetupContext extends AppDefinition.SetupContext = AppDefinition.SetupContext<M>> {
-    /**
-     * Name of your awesome application
-     */
-    name: string;
-    /**
-     * Describe what your application does
-     */
-    description?: string;
-    /**
-     * Props options to be parsed from cli arguments of env variables
-     */
-    props?: P;
-    /**
-     * Path to the file where this definition exports default
-     * Usually you should not use this option, because it tracks automatically
-     */
-    filePath?: string | null;
-    /**
-     * Logger instance or constructor function
-     */
-    logger?: false | Logger | ((definition: AppDefinition) => Logger);
-    /**
-     * Setup function to initialize application. Will be called once
-     */
-    setup?(this: SetupContext, props: ExtractPropTypes<P>): Awaitable<S>;
-    /**
-     * Custom methods which will be available under `this` context
-     */
-    methods?: M & ThisType<RuntimeContext>;
-    /**
-     * Entry function that will be called each time when application starts
-     */
-    entry?(this: EntryContext, props: ExtractPropTypes<P>): Awaitable<any>;
-    /**
-     * Stop function that will be called each time when application stops
-     */
-    stop?(this: RuntimeContext, props: ExtractPropTypes<P>): Awaitable<void>;
-    /**
-     * Shutdown function that will be called before application/process graceful shutdown
-     */
-    shutdown?(this: RuntimeContext, props: ExtractPropTypes<P>): Awaitable<void>;
+  /**
+   * Name of your awesome application
+   */
+  name: string;
+  /**
+   * Describe what your application does
+   */
+  description?: string;
+  /**
+   * Props options to be parsed from cli arguments of env variables
+   */
+  props?: P;
+  /**
+   * Path to the file where this definition exports default
+   * Usually you should not use this option, because it tracks automatically
+   */
+  filePath?: string | null;
+  /**
+   * Logger instance or constructor function
+   */
+  logger?: false | Logger | ((definition: AppDefinition) => Logger);
+  /**
+   * Setup function to initialize application. Will be called once
+   */
+  setup?(this: SetupContext, props: ExtractPropTypes<P>): Awaitable<S>;
+  /**
+   * Custom methods which will be available under `this` context
+   */
+  methods?: M & ThisType<RuntimeContext>;
+  /**
+   * Entry function that will be called each time when application starts
+   */
+  entry?(this: EntryContext, props: ExtractPropTypes<P>, ...args: any[]): Awaitable<any>;
+  /**
+   * Stop function that will be called each time when application stops
+   */
+  stop?(this: RuntimeContext, props: ExtractPropTypes<P>): Awaitable<void>;
+  /**
+   * Shutdown function that will be called before application/process graceful shutdown
+   */
+  shutdown?(this: RuntimeContext, props: ExtractPropTypes<P>): Awaitable<void>;
 }
 declare const APP_INSTANCE_STATE: {
-    readonly INIT: "init";
-    readonly IN_SETUP: "in-setup";
-    readonly SETUP: "setup";
-    readonly IN_STOP: "in-stop";
-    readonly IN_RUN: "in-run";
-    readonly RUN: "run";
-    readonly STOP: "stop";
-    readonly IN_SHUTDOWN: "in-shutdown";
-    readonly SHUTDOWN: "shutdown";
-    readonly ERROR: "error";
+  readonly INIT: "init";
+  readonly IN_SETUP: "in-setup";
+  readonly SETUP: "setup";
+  readonly IN_STOP: "in-stop";
+  readonly IN_RUN: "in-run";
+  readonly RUN: "run";
+  readonly STOP: "stop";
+  readonly IN_SHUTDOWN: "in-shutdown";
+  readonly SHUTDOWN: "shutdown";
+  readonly ERROR: "error";
 };
 declare namespace AppInstance {
-    type EventMap = {
-        state: [newState: State, oldState: State];
-        error: [err: Error];
-    } & {
-        [K in State as `state:${K}`]: [];
-    };
-    type State = (typeof APP_INSTANCE_STATE)[keyof typeof APP_INSTANCE_STATE];
+  type EventMap = {
+    state: [newState: State, oldState: State];
+    error: [err: Error];
+  } & { [K in State as `state:${K}`]: [] };
+  type State = (typeof APP_INSTANCE_STATE)[keyof typeof APP_INSTANCE_STATE];
 }
 /**
  * Runtime state of a created app instance.
  * @group Types
  */
 interface AppInstance<P extends ObjectPropsOptions = {}, S extends Record<string, any> = {}, M extends Record<string, AnyFunction> = {}> {
-    definition: AppDefinition<P, S, M>;
-    props: ExtractPropTypes<P> | null;
-    setupState: AppDefinition.SetupContext<Data>;
-    eventBus: SimpleEventEmitter<AppInstance.EventMap>;
-    /** @internal */
-    mutexName: string | null;
-    /** @internal */
-    mutexQueue: Promise<void>;
-    readonly state: AppInstance.State;
-    logger: Logger;
+  definition: AppDefinition<P, S, M>;
+  props: ExtractPropTypes<P> | null;
+  setupState: AppDefinition.SetupContext<Data>;
+  eventBus: SimpleEventEmitter<AppInstance.EventMap>;
+  /** @internal */
+  mutexName: string | null;
+  /** @internal */
+  mutexQueue: Promise<void>;
+  readonly state: AppInstance.State;
+  logger: Logger;
 }
 /**
  * Define an application with typed props and lifecycle hooks.
@@ -220,7 +207,7 @@ declare function isAppDefinition(value: unknown): value is AppDefinition;
  * ```
  */
 declare function startApp<P extends ObjectPropsOptions, S extends Record<string, any>>(app: AppDefinition<P, S> | AppInstance<P, S>, props: ExtractPropTypes<P>): Promise<ExecResult<{
-    app: AppInstance<P, S>;
+  app: AppInstance<P, S>;
 }>>;
 /**
  * Run the setup phase of an app instance.
@@ -243,7 +230,7 @@ declare function setupApp(instance: AppInstance, props: Data): Promise<ExecResul
  * await runApp(instance);
  * ```
  */
-declare function runApp$1(instance: AppInstance): Promise<ExecResult>;
+declare function runApp(instance: AppInstance): Promise<ExecResult>;
 /**
  * Stop a running app instance and call its `stop` hook.
  * @group App Lifecycle
@@ -278,7 +265,6 @@ declare function shutdownApp(instance: AppInstance): Promise<ExecResult>;
  * ```
  */
 declare function appWaitShutdown(instance: AppInstance): Promise<void>;
-
 /**
  * Combine multiple app definitions into a single orchestrated app.
  * Props from each definition are namespaced by their app name.
@@ -287,7 +273,6 @@ declare function appWaitShutdown(instance: AppInstance): Promise<void>;
 declare function createAppHub(definitions: AppDefinition[]): AppDefinition;
 declare function getPrefixedProps(definition: AppDefinition, props: Data): Data;
 declare function prefixifyProps(definitions: AppDefinition[]): ObjectPropsOptions;
-
 /**
  * Wrap an app definition to run across N child processes. Adds a
  * `threads` prop and manages the full lifecycle of each child.
@@ -295,10 +280,10 @@ declare function prefixifyProps(definitions: AppDefinition[]): ObjectPropsOption
  */
 declare function createAppThread(definition: AppDefinition): AppDefinition;
 interface CreateAppThreadInstanceParams {
-    definition: AppDefinition;
-    parentPort: ParentPortLike;
-    threadId: number;
-    onShutdown?: () => void;
+  definition: AppDefinition;
+  parentPort: ParentPortLike;
+  threadId: number;
+  onShutdown?: () => void;
 }
 /**
  * A minimal port abstraction implemented by both IPC `MessagePort`
@@ -306,110 +291,114 @@ interface CreateAppThreadInstanceParams {
  * @group Types
  */
 interface ParentPortLike {
-    on(event: 'message', cb: (msg: unknown) => void): unknown;
-    postMessage(msg: unknown, cb?: () => void): unknown;
-    close?(): unknown;
+  on(event: 'message', cb: (msg: unknown) => void): unknown;
+  postMessage(msg: unknown, cb?: () => void): unknown;
+  close?(): unknown;
 }
 /**
  * Create app instance with IPC fully managed lifecycle
  * @group Threads
  */
-declare function createAppThreadInstance({ definition, parentPort, threadId, onShutdown, }: CreateAppThreadInstanceParams): AppInstance;
-
+declare function createAppThreadInstance({
+  definition,
+  parentPort,
+  threadId,
+  onShutdown
+}: CreateAppThreadInstanceParams): AppInstance;
 interface RunAppOptions {
-    scriptFile?: string;
-    cliName?: string;
-    cliDescription?: string;
-    argv?: string[];
+  scriptFile?: string;
+  cliName?: string;
+  cliDescription?: string;
+  argv?: string[];
 }
-declare function runApp({ scriptFile, cliName, cliDescription, argv, }: RunAppOptions): Promise<void>;
-
+declare function runApp$1({
+  scriptFile,
+  cliName,
+  cliDescription,
+  argv
+}: RunAppOptions): Promise<void>;
 /**
  * Programmatic access to the `vrun` CLI internals.
  * @group Utils
  */
 declare const cli: Readonly<{
-    readonly runApp: typeof runApp;
+  readonly runApp: typeof runApp$1;
 }>;
-
 type LogEventFields = Record<string, any>;
-
 /**
  * @group Types
  */
 declare namespace ManagedThread {
-    type State = AppInstance.State | 'ready';
-    interface LogEntry {
-        ts: number;
-        level: LogLevel;
-        text: string;
+  type State = AppInstance.State | 'ready';
+  interface LogEntry {
+    ts: number;
+    level: LogLevel;
+    text: string;
+  }
+  type EventMap = {
+    ready: [];
+    state: [newState: State, oldState: State];
+    log: [entry: LogEntry];
+    pid: [pid: number];
+    exit: [code: number | null, signal: NodeJS.Signals | null];
+    message: [message: ManagedThread.ThreadMessage];
+    error: [err: Error];
+  } & { [K in ManagedThread.ThreadMessage as `msg:${K['type']}`]: [msg: K] };
+  type ThreadMessage = ThreadMessage.AppState | ThreadMessage.Ping | ThreadMessage.Pong | ThreadMessage.Ready | ThreadMessage.Shutdown | ThreadMessage.ShutdownDone | ThreadMessage.Start | ThreadMessage.StartDone | ThreadMessage.Setup | ThreadMessage.SetupDone | ThreadMessage.Stop | ThreadMessage.StopDone;
+  type ThreadMessageMap = { [K in ManagedThread.ThreadMessage as K['type']]: K };
+  type ThreadMessageDone<T extends string> = `${T}_done` extends keyof ThreadMessageMap ? `${T}_done` : never;
+  namespace ThreadMessage {
+    interface Base<T extends string> {
+      type: T;
+      vrun_app_thread_message: true;
     }
-    type EventMap = {
-        ready: [];
-        state: [newState: State, oldState: State];
-        log: [entry: LogEntry];
-        pid: [pid: number];
-        exit: [code: number | null, signal: NodeJS.Signals | null];
-        message: [message: ManagedThread.ThreadMessage];
-        error: [err: Error];
-    } & {
-        [K in ManagedThread.ThreadMessage as `msg:${K['type']}`]: [msg: K];
+    type AppState = Base<'app-state'> & {
+      state: AppInstance.State;
     };
-    type ThreadMessage = ThreadMessage.AppState | ThreadMessage.Ping | ThreadMessage.Pong | ThreadMessage.Ready | ThreadMessage.Shutdown | ThreadMessage.ShutdownDone | ThreadMessage.Start | ThreadMessage.StartDone | ThreadMessage.Setup | ThreadMessage.SetupDone | ThreadMessage.Stop | ThreadMessage.StopDone;
-    type ThreadMessageMap = {
-        [K in ManagedThread.ThreadMessage as K['type']]: K;
+    type Start = Base<'start'>;
+    type StartDone = Base<'start_done'> & {
+      result: ExecResult;
     };
-    type ThreadMessageDone<T extends string> = `${T}_done` extends keyof ThreadMessageMap ? `${T}_done` : never;
-    namespace ThreadMessage {
-        interface Base<T extends string> {
-            type: T;
-            vrun_app_thread_message: true;
-        }
-        type AppState = Base<'app-state'> & {
-            state: AppInstance.State;
-        };
-        type Start = Base<'start'>;
-        type StartDone = Base<'start_done'> & {
-            result: ExecResult;
-        };
-        type Setup = Base<'setup'> & {
-            props: Data;
-        };
-        type SetupDone = Base<'setup_done'> & {
-            result: ExecResult;
-        };
-        type Stop = Base<'stop'>;
-        type StopDone = Base<'stop_done'> & {
-            result: ExecResult;
-        };
-        type Shutdown = Base<'shutdown'>;
-        type ShutdownDone = Base<'shutdown_done'> & {
-            result: ExecResult;
-        };
-        type Ping = Base<'ping'>;
-        type Pong = Base<'pong'>;
-        type Ready = Base<'ready'> & {
-            pid: number;
-        };
-    }
+    type Setup = Base<'setup'> & {
+      props: Data;
+    };
+    type SetupDone = Base<'setup_done'> & {
+      result: ExecResult;
+    };
+    type Stop = Base<'stop'>;
+    type StopDone = Base<'stop_done'> & {
+      result: ExecResult;
+    };
+    type Shutdown = Base<'shutdown'>;
+    type ShutdownDone = Base<'shutdown_done'> & {
+      result: ExecResult;
+    };
+    type Ping = Base<'ping'>;
+    type Pong = Base<'pong'>;
+    type Ready = Base<'ready'> & {
+      pid: number;
+    };
+  }
 }
 /**
  * A child process managed by the parent.
  * @group Types
  */
 interface ManagedThread {
-    child: cp.ChildProcess;
-    threadId: number;
-    pid: number;
-    state: ManagedThread.State;
-    restartCount: number;
-    scriptFile: string;
-    threadProps: Record<string, unknown>;
-    eventBus: EventEmitter<ManagedThread.EventMap>;
-    scheduler: Scheduler;
-    writeLog(level: LogLevel, event: string, fields?: LogEventFields): void;
-    /** @internal */ heartbeatTimer?: NodeJS.Timeout;
-    /** @internal */ lastPong: number;
+  child: cp.ChildProcess;
+  threadId: number;
+  pid: number;
+  state: ManagedThread.State;
+  restartCount: number;
+  scriptFile: string;
+  threadProps: Record<string, unknown>;
+  eventBus: EventEmitter<ManagedThread.EventMap>;
+  scheduler: Scheduler;
+  writeLog(level: LogLevel, event: string, fields?: LogEventFields): void;
+  /** @internal */
+  heartbeatTimer?: NodeJS.Timeout;
+  /** @internal */
+  lastPong: number;
 }
 /**
  * Wait for thread ready signal
@@ -450,91 +439,90 @@ declare function restartThreadApp(w: ManagedThread): Promise<void>;
 declare function isThreadMessage(value: unknown): value is ManagedThread.ThreadMessage;
 declare function createThreadMessage<T extends keyof ManagedThread.ThreadMessageMap>(type: T, msg: Omit<ManagedThread.ThreadMessageMap[T], 'type' | 'vrun_app_thread_message'>): ManagedThread.ThreadMessageMap[T];
 declare function isThreadExit(w: ManagedThread): boolean;
-
 type WorkerSuccessData = {
-    [x: string]: unknown;
+  [x: string]: unknown;
 };
 type WorkerSkipData = {
-    error?: boolean;
-    [x: string]: unknown;
+  error?: boolean;
+  [x: string]: unknown;
 };
 type WorkerResult = ExecResult<WorkerSuccessData, WorkerSkipData>;
 /**
  * @group Types
  */
 declare namespace WorkerStrategy {
-    /**
-     * Base context bag emitted by strategies per task. Strategies extend this with typed fields.
-     * @group Types
-     */
-    interface Context {
-        [key: string]: unknown;
-    }
+  /**
+   * Base context bag emitted by strategies per task. Strategies extend this with typed fields.
+   * @group Types
+   */
+  interface Context {
+    [key: string]: unknown;
+  }
 }
 /**
  * Pluggable trigger source. Drives when tasks are enqueued.
  * @group Types
  */
 interface WorkerStrategy<C extends WorkerStrategy.Context = WorkerStrategy.Context> {
-    doSetup(opts: {
-        worker: WorkerInstance;
-    }): Awaitable<void>;
-    startSignal(): void;
-    stopSignal(done: () => void): void;
-    doShutdown(): Awaitable<void>;
-    createTask(...args: any[]): C;
-    executeSignal?(ctx: WorkerDefinition.EntryContext<WorkerStrategy<C>>): Awaitable<ExecResult>;
-    completeSignal?(ctx: WorkerDefinition.EntryContext<WorkerStrategy<C>>, result: WorkerResult | WorkerResult[]): Awaitable<void>;
-    overloadedSignal?(): void;
-    availableSignal?(): void;
-    handleEntryError?(err: Error): WorkerResult;
+  doSetup(opts: {
+    worker: WorkerInstance;
+  }): Awaitable<void>;
+  startSignal(): void;
+  stopSignal(done: () => void): void;
+  doShutdown(): Awaitable<void>;
+  createTask(...args: any[]): C;
+  executeSignal?(ctx: WorkerDefinition.EntryContext<WorkerStrategy<C>>): Awaitable<ExecResult>;
+  completeSignal?(ctx: WorkerDefinition.EntryContext<WorkerStrategy<C>>, result: WorkerResult | WorkerResult[]): Awaitable<void>;
+  overloadedSignal?(): void;
+  availableSignal?(): void;
+  handleEntryError?(err: Error): WorkerResult;
 }
 declare namespace WorkerDefinition {
-    /**
-     * Entry function that will be called each time when worker handle a job
-     */
-    type EntryFn<Context extends Data, Props extends Data> = (this: Context, props: Props) => Awaitable<WorkerResult | WorkerResult[] | void>;
-    type SetupFn<Context extends Data, Props extends Data, Result> = (this: Context, props: Props) => Awaitable<Result>;
-    type EntryContext<T extends WorkerStrategy = WorkerStrategy> = AppDefinition.EntryContext<{
-        worker: WorkerInstance<T>;
-    } & TaskContext<T>>;
-    type SetupContext<T extends Data = Data> = AppDefinition.SetupContext<T & {
-        worker: WorkerInstance;
-    }>;
-    type RuntimeContext<T extends Data = Data> = AppDefinition.RuntimeContext<T & {
-        worker: WorkerInstance;
-    }>;
-    type TaskContext<T extends WorkerStrategy> = T extends WorkerStrategy<infer X> ? X : never;
+  /**
+   * Entry function that will be called each time when worker handle a job
+   */
+  type EntryFn<Context extends Data, Props extends Data> = (this: Context, props: Props) => Awaitable<WorkerResult | WorkerResult[] | void>;
+  type SetupFn<Context extends Data, Props extends Data, Result> = (this: Context, props: Props) => Awaitable<Result>;
+  type EntryContext<T extends WorkerStrategy = WorkerStrategy> = AppDefinition.EntryContext<{
+    worker: WorkerInstance<T>;
+  } & TaskContext<T>>;
+  type SetupContext<T extends Data = Data> = AppDefinition.SetupContext<T & {
+    worker: WorkerInstance;
+  }>;
+  type RuntimeContext<T extends Data = Data> = AppDefinition.RuntimeContext<T & {
+    worker: WorkerInstance;
+  }>;
+  type TaskContext<T extends WorkerStrategy> = T extends WorkerStrategy<infer X> ? X : never;
 }
 /**
  * Worker definition — extends AppDefinition with strategy, per-task entry, and concurrency config.
  * @group Types
  */
 interface WorkerDefinition<P extends ObjectPropsOptions = {}, S extends Record<string, any> = {}, M extends Record<string, AnyFunction> = {}, C extends WorkerStrategy = WorkerStrategy, RuntimeContext extends WorkerDefinition.RuntimeContext = WorkerDefinition.RuntimeContext<S & M>, EntryContext extends WorkerDefinition.EntryContext = WorkerDefinition.EntryContext<C> & S & M, SetupContext extends WorkerDefinition.SetupContext = WorkerDefinition.SetupContext<M>> extends AppDefinition<P, S, M, RuntimeContext, EntryContext, SetupContext> {
-    /**
-     * Entry function that will be called each time when worker handle a job
-     */
-    entry?(this: EntryContext, props: ExtractPropTypes<P>): Awaitable<WorkerResult | WorkerResult[] | void>;
-    /**
-     * Setup function will be called once while worker setup.
-     */
-    setup?(this: SetupContext, props: ExtractPropTypes<P>): Awaitable<S>;
-    executeStrategy: C;
-    /**
-     * Maximum limit of queued tasks
-     * @default 50
-     */
-    taskLimit?: number;
-    /**
-     * Amount of task to be executed in parallel
-     * @default 2
-     */
-    taskParallel?: number;
-    /**
-     * Disable worker
-     * @default false
-     */
-    disabled?: boolean;
+  /**
+   * Entry function that will be called each time when worker handle a job
+   */
+  entry?(this: EntryContext, props: ExtractPropTypes<P>, abortSignal: AbortSignal): Awaitable<WorkerResult | WorkerResult[] | void>;
+  /**
+   * Setup function will be called once while worker setup.
+   */
+  setup?(this: SetupContext, props: ExtractPropTypes<P>): Awaitable<S>;
+  executeStrategy: C | ((props: ExtractPropTypes<P>) => C);
+  /**
+   * Maximum limit of queued tasks
+   * @default 50
+   */
+  taskLimit?: number;
+  /**
+   * Amount of task to be executed in parallel
+   * @default 2
+   */
+  taskParallel?: number;
+  /**
+   * Disable worker
+   * @default false
+   */
+  disabled?: boolean;
 }
 /**
  * Runtime state of a worker instance. Extends AppInstance with task queue and pool.
@@ -542,37 +530,38 @@ interface WorkerDefinition<P extends ObjectPropsOptions = {}, S extends Record<s
  * @group Types
  */
 interface WorkerInstance<C extends WorkerStrategy = WorkerStrategy> {
-    definition: WorkerDefinition<{}, {}, {}, C>;
-    queue: AsyncIterableQueue<WorkerDefinition.TaskContext<C>>;
-    pool: ResourcePool<symbol>;
-    runTask: CancellablePromise<void> | null;
-    overloadedSignaled: boolean;
-    log: Logger;
-    readonly queueMaxSize: number;
-    readonly taskParallel: number;
-    /**
-     * Tasks queue size
-     */
-    readonly queueSize: number;
-    /**
-     * Check if the worker is overloaded (e.g., queue length is high)
-     */
-    readonly isOverloaded: boolean;
-    /**
-     * Returns true when worker do nothing
-     */
-    readonly isIdle: boolean;
-    /**
-     * Add task into execution queue
-     */
-    addTask(ctx: WorkerDefinition.TaskContext<C>): void;
+  definition: WorkerDefinition<{}, {}, {}, C>;
+  queue: AsyncIterableQueue<WorkerDefinition.TaskContext<C>>;
+  pool: ResourcePool<symbol>;
+  runTask: CancellablePromise<void> | null;
+  executeStrategy: C | null;
+  overloadedSignaled: boolean;
+  log: Logger;
+  readonly queueMaxSize: number;
+  readonly taskParallel: number;
+  /**
+   * Tasks queue size
+   */
+  readonly queueSize: number;
+  /**
+   * Check if the worker is overloaded (e.g., queue length is high)
+   */
+  readonly isOverloaded: boolean;
+  /**
+   * Returns true when worker do nothing
+   */
+  readonly isIdle: boolean;
+  /**
+   * Add task into execution queue
+   */
+  addTask(ctx: WorkerDefinition.TaskContext<C>): void;
 }
 /**
  * Create a runtime WorkerInstance from a WorkerDefinition.
  * Use with startApp / stopApp / shutdownApp.
  * @group Worker
  */
-declare function createWorkerInstance<C extends WorkerStrategy>(definition: WorkerDefinition<{}, {}, {}, C>, logger: Logger): WorkerInstance<C>;
+declare function createWorkerInstance<C extends WorkerStrategy>(definition: WorkerDefinition<any, {}, {}, C>, logger: Logger): WorkerInstance<C>;
 /**
  * Enqueue a task context on the worker. Fires backpressure signals at 80% capacity.
  * @group Worker
@@ -613,20 +602,23 @@ declare function isWorkerDefinition(value: unknown): value is WorkerDefinition;
  * @group Utils
  */
 declare function isWorkerInstance(value: unknown): value is WorkerInstance;
-
 declare namespace IntervalStrategy {
+  /**
+   * Options for the built-in IntervalStrategy.
+   */
+  interface Options {
+    intervalSeconds: number;
     /**
-     * Options for the built-in IntervalStrategy.
+     * @default true
      */
-    interface Options {
-        intervalSeconds: number;
-    }
-    /**
-     * Context emitted by IntervalStrategy on each tick.
-     */
-    interface Context extends WorkerStrategy.Context {
-        timerSequence: number;
-    }
+    warnOnBusy?: boolean;
+  }
+  /**
+   * Context emitted by IntervalStrategy on each tick.
+   */
+  interface Context extends WorkerStrategy.Context {
+    timerSequence: number;
+  }
 }
 /**
  * Triggers a worker task on a fixed interval.
@@ -634,18 +626,21 @@ declare namespace IntervalStrategy {
  * @group Worker Strategies
  */
 declare class IntervalStrategy implements WorkerStrategy<IntervalStrategy.Context> {
-    private readonly options;
-    private timerSequence;
-    private timer;
-    private worker;
-    constructor(options: IntervalStrategy.Options);
-    doSetup({ worker }: {
-        worker: WorkerInstance;
-    }): void;
-    startSignal(): void;
-    stopSignal(done: () => void): void;
-    doShutdown(): void;
-    createTask(): IntervalStrategy.Context;
+  private readonly options;
+  private timerSequence;
+  private timer;
+  private worker;
+  private warnOnBusy;
+  constructor(options: IntervalStrategy.Options);
+  doSetup({
+    worker
+  }: {
+    worker: WorkerInstance;
+  }): void;
+  startSignal(): void;
+  stopSignal(done: () => void): void;
+  doShutdown(): void;
+  createTask(): IntervalStrategy.Context;
 }
-
-export { APP_INSTANCE_STATE, AppDefinition, AppInstance, type CreateAppThreadInstanceParams, type ExtractPropTypes, IntervalStrategy, ManagedThread, type ObjectPropsOptions, type ParentPortLike, type PropOptions, WorkerDefinition, type WorkerInstance, type WorkerResult, type WorkerSkipData, WorkerStrategy, type WorkerSuccessData, addWorkerTask, appWaitShutdown, cli, createAppHub, createAppInstance, createAppThread, createAppThreadInstance, createThreadMessage, createWorkerInstance, defineApp, defineWorker, getPrefixedProps, initThread, isAppDefinition, isThreadExit, isThreadMessage, isWorkerDefinition, isWorkerInstance, prefixifyProps, restartThreadApp, runApp$1 as runApp, setupApp, setupThreadApp, shutdownApp, shutdownThreadApp, startApp, startThreadApp, stopApp, stopThreadApp, waitForThreadReady };
+export { APP_INSTANCE_STATE, AppDefinition, AppInstance, CreateAppThreadInstanceParams, type ExtractPropTypes, IntervalStrategy, ManagedThread, type ObjectPropsOptions, ParentPortLike, type PropOptions, type PropType, WorkerDefinition, WorkerInstance, WorkerResult, WorkerSkipData, WorkerStrategy, WorkerSuccessData, addWorkerTask, appWaitShutdown, cli, createAppHub, createAppInstance, createAppThread, createAppThreadInstance, createThreadMessage, createWorkerInstance, defineApp, defineWorker, getPrefixedProps, initThread, isAppDefinition, isThreadExit, isThreadMessage, isWorkerDefinition, isWorkerInstance, prefixifyProps, restartThreadApp, runApp, setupApp, setupThreadApp, shutdownApp, shutdownThreadApp, startApp, startThreadApp, stopApp, stopThreadApp, waitForThreadReady };
+//# sourceMappingURL=index.d.mts.map