@andrew_l/app 0.3.7

package/dist/index.d.cts

@@ -0,0 +1,651 @@
+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';
+
+/**
+ * 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[];
+}
+/**
+ * @group Types
+ */
+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 PropConstructor<T = any> = {
+    new (...args: any[]): T & {};
+} | {
+    (): T;
+} | PropMethod<T>;
+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;
+}] ? any : [T] extends [ObjectConstructor | {
+    type: ObjectConstructor;
+}] ? Record<string, any> : [T] extends [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;
+/**
+ * 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]>;
+};
+
+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;
+    };
+}
+/**
+ * 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>;
+}
+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";
+};
+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];
+}
+/**
+ * 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;
+}
+/**
+ * Define an application with typed props and lifecycle hooks.
+ *
+ * When executed directly (`node app.ts`), the CLI is launched automatically.
+ * @group Main
+ * @example
+ * ```ts
+ * import { defineApp } from '@andrew_l/app';
+ *
+ * export default defineApp({
+ *   name: 'server',
+ *   props: {
+ *     port: { type: Number, default: () => 3000 },
+ *   },
+ *   setup() {
+ *     return { server: createServer() };
+ *   },
+ *   async entry(props) {
+ *     await this.server.listen(props.port);
+ *   },
+ *   async stop() {
+ *     await this.server.close();
+ *   },
+ * });
+ * ```
+ */
+declare function defineApp<P extends ObjectPropsOptions, S extends Record<string, any>, M extends Record<string, AnyFunction>>(definition: AppDefinition<P, S, M>): AppDefinition<P, S, M>;
+/**
+ * Create a new runtime instance from an app definition.
+ * @group App Lifecycle
+ * @example
+ * ```ts
+ * const instance = createAppInstance(myApp);
+ * await setupApp(instance, { port: 3000 });
+ * await runApp(instance);
+ * ```
+ */
+declare function createAppInstance<P extends ObjectPropsOptions, S extends Record<string, any>, M extends Record<string, AnyFunction>>(definition: AppDefinition<P, S, M>): AppInstance<P, S, M>;
+/**
+ * Returns true if the value was created by `defineApp`.
+ * @group Utils
+ */
+declare function isAppDefinition(value: unknown): value is AppDefinition;
+/**
+ * Run setup and entry in one call. Shuts down automatically if entry fails.
+ * @group App Lifecycle
+ * @example
+ * ```ts
+ * const result = await startApp(myApp, { port: 3000 });
+ * if (isSuccess(result)) {
+ *   await appWaitShutdown(result.app);
+ * }
+ * ```
+ */
+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>;
+}>>;
+/**
+ * Run the setup phase of an app instance.
+ * @group App Lifecycle
+ * @example
+ * ```ts
+ * const result = await setupApp(instance, { port: 3000 });
+ * if (isSuccess(result)) {
+ *   await runApp(instance);
+ * }
+ * ```
+ */
+declare function setupApp(instance: AppInstance, props: Data): Promise<ExecResult>;
+/**
+ * Run the entry phase of an app instance.
+ * @group App Lifecycle
+ * @example
+ * ```ts
+ * await setupApp(instance, props);
+ * await runApp(instance);
+ * ```
+ */
+declare function runApp$1(instance: AppInstance): Promise<ExecResult>;
+/**
+ * Stop a running app instance and call its `stop` hook.
+ * @group App Lifecycle
+ * @example
+ * ```ts
+ * process.on('SIGTERM', async () => {
+ *   await stopApp(instance);
+ *   await shutdownApp(instance);
+ * });
+ * ```
+ */
+declare function stopApp(instance: AppInstance): Promise<ExecResult>;
+/**
+ * Shut down an app instance, call its `shutdown` hook, and reset all state.
+ * @group App Lifecycle
+ * @example
+ * ```ts
+ * await stopApp(instance);
+ * await shutdownApp(instance);
+ * // instance can be set up and started again after this
+ * ```
+ */
+declare function shutdownApp(instance: AppInstance): Promise<ExecResult>;
+/**
+ * Returns a promise that resolves when the app emits its shutdown event.
+ * Resolves immediately if the app is not running.
+ * @group App Lifecycle
+ * @example
+ * ```ts
+ * await startApp(myApp, props);
+ * await appWaitShutdown(instance); // blocks until shutdown
+ * ```
+ */
+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.
+ * @group Utils
+ */
+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.
+ * @group Types
+ */
+declare function createAppThread(definition: AppDefinition): AppDefinition;
+interface CreateAppThreadInstanceParams {
+    definition: AppDefinition;
+    parentPort: ParentPortLike;
+    threadId: number;
+    onShutdown?: () => void;
+}
+/**
+ * A minimal port abstraction implemented by both IPC `MessagePort`
+ * and the `process`-based shim spawned by {@link initThread}.
+ * @group Types
+ */
+interface ParentPortLike {
+    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;
+
+interface RunAppOptions {
+    scriptFile?: string;
+    cliName?: string;
+    cliDescription?: string;
+    argv?: string[];
+}
+declare function runApp({ scriptFile, cliName, cliDescription, argv, }: RunAppOptions): Promise<void>;
+
+/**
+ * Programmatic access to the `vrun` CLI internals.
+ * @group Utils
+ */
+declare const cli: Readonly<{
+    readonly runApp: typeof runApp;
+}>;
+
+type LogEventFields = Record<string, any>;
+
+/**
+ * @group Types
+ */
+declare namespace ManagedThread {
+    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 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;
+        };
+    }
+}
+/**
+ * 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;
+}
+/**
+ * Wait for thread ready signal
+ * @group Threads
+ */
+declare function waitForThreadReady(w: ManagedThread): Promise<void>;
+/**
+ * Spawn a child process for `scriptFile` and return its {@link ManagedThread}
+ * immediately — synchronously, before the child signals readiness.
+ * @group Threads
+ */
+declare function initThread(threadId: number, scriptFile: string, threadProps: Record<string, unknown>): ManagedThread;
+/**
+ * Send the setup message; resolves when child replies setup_done.
+ * @group Threads
+ */
+declare function setupThreadApp(w: ManagedThread): Promise<void>;
+/**
+ * Send the start message; on reply, switch to running and arm heartbeat.
+ * @group Threads
+ */
+declare function startThreadApp(w: ManagedThread): Promise<void>;
+/**
+ * Send the stop message; child keeps running, app inside is stopped.
+ * @group Threads
+ */
+declare function stopThreadApp(w: ManagedThread): Promise<void>;
+/**
+ * Send shutdown and wait for the OS process to exit (SIGKILL fallback).
+ * @group Threads
+ */
+declare function shutdownThreadApp(w: ManagedThread): Promise<void>;
+/**
+ * Terminate the child and spawn a fresh one with the same script + props.
+ * @group Threads
+ */
+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;
+};
+type WorkerSkipData = {
+    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;
+    }
+}
+/**
+ * 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;
+}
+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;
+}
+/**
+ * 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;
+}
+/**
+ * Runtime state of a worker instance. Extends AppInstance with task queue and pool.
+ * Managed with the standard startApp / stopApp / shutdownApp lifecycle.
+ * @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;
+}
+/**
+ * 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>;
+/**
+ * Enqueue a task context on the worker. Fires backpressure signals at 80% capacity.
+ * @group Worker
+ */
+declare function addWorkerTask<C extends WorkerStrategy>(instance: WorkerInstance<C>, ctx: WorkerDefinition.TaskContext<C>): void;
+/**
+ * Define a background worker with a pluggable execution strategy.
+ * Returns a WorkerDefinition that can be run with createWorkerInstance + startApp.
+ *
+ * @example
+ * ```ts
+ * import { defineWorker, IntervalStrategy } from '@andrew_l/app';
+ *
+ * export default defineWorker({
+ *   name: 'clock',
+ *   executeStrategy: new IntervalStrategy({
+ *     intervalSeconds: 1,
+ *   }),
+ *   entry() {
+ *     this.log.info('tick=%d', this.timerSequence);
+ *   },
+ *   async shutdown() {
+ *     await delay(1000);
+ *   },
+ * });
+ * ```
+ *
+ * @group Main
+ */
+declare function defineWorker<P extends ObjectPropsOptions, S extends Record<string, any>, M extends Record<string, AnyFunction>, C extends WorkerStrategy = WorkerStrategy>(definition: WorkerDefinition<P, S, M, C>): WorkerDefinition<P, S, M, C>;
+/**
+ * Returns true if the value was created by defineWorker.
+ * @group Utils
+ */
+declare function isWorkerDefinition(value: unknown): value is WorkerDefinition;
+/**
+ * Returns true if the value is a WorkerInstance.
+ * @group Utils
+ */
+declare function isWorkerInstance(value: unknown): value is WorkerInstance;
+
+declare namespace IntervalStrategy {
+    /**
+     * Options for the built-in IntervalStrategy.
+     */
+    interface Options {
+        intervalSeconds: number;
+    }
+    /**
+     * Context emitted by IntervalStrategy on each tick.
+     */
+    interface Context extends WorkerStrategy.Context {
+        timerSequence: number;
+    }
+}
+/**
+ * Triggers a worker task on a fixed interval.
+ * Skips the tick with a warning if the worker is not idle.
+ * @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;
+}
+
+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 };