@bluelibs/runner 5.2.1 → 5.4.0

package/dist/types/node/durable/core/interfaces/service.d.ts

@@ -1,20 +1,17 @@
 import type { IEventDefinition } from "../../../../types/event";
+import type { ITask } from "../../../../types/task";
 import type { IDurableStore } from "./store";
 import type { IDurableQueue } from "./queue";
 import type { IEventBus } from "./bus";
 import type { IDurableContext } from "./context";
 import type { Schedule } from "../types";
 import type { DurableAuditEmitter } from "../audit";
-export interface DurableTask<TInput = unknown, TResult = unknown> {
-    id: string;
-    run(input: TInput, ...args: any[]): Promise<TResult>;
-}
 export interface ITaskExecutor {
-    run<TInput, TResult>(task: DurableTask<TInput, TResult>, input?: TInput): Promise<TResult>;
+    run<TInput, TResult>(task: ITask<TInput, Promise<TResult>, any, any, any, any>, input?: TInput): Promise<TResult>;
 }
 export interface ScheduleConfig<TInput = unknown> {
     id: string;
-    task: DurableTask<TInput, unknown>;
+    task: ITask<TInput, Promise<any>, any, any, any, any> | string;
     cron?: string;
     interval?: number;
     input: TInput;
@@ -51,7 +48,7 @@ export interface DurableServiceConfig {
      * Resolves tasks by id for resuming/recovering executions.
      * Useful in Runner environments where tasks are registered in the Store registry.
      */
-    taskResolver?: (taskId: string) => DurableTask<any, any> | undefined;
+    taskResolver?: (taskId: string) => ITask<any, Promise<any>, any, any, any, any> | undefined;
     audit?: {
         enabled?: boolean;
         emitter?: DurableAuditEmitter;
@@ -66,7 +63,7 @@ export interface DurableServiceConfig {
         maxAttempts?: number;
         timeout?: number;
         /**
-         * When a queue is configured, `startExecution()` persists the execution and then enqueues it.
+         * When a queue is configured, `start()` persists the execution and then enqueues it.
          * If enqueue fails (eg. broker outage), the execution would otherwise remain "pending" forever.
          *
          * This delay arms a small store-backed timer as a failsafe so workers can retry resuming it
@@ -75,7 +72,7 @@ export interface DurableServiceConfig {
         kickoffFailsafeDelayMs?: number;
     };
     schedules?: ScheduleConfig[];
-    tasks?: Array<DurableTask<any, any>>;
+    tasks?: Array<ITask<any, Promise<any>, any, any, any, any>>;
 }
 export interface ExecuteOptions {
     timeout?: number;
@@ -94,8 +91,15 @@ export interface ScheduleOptions {
     cron?: string;
     interval?: number;
 }
+export interface DurableStartAndWaitResult<TResult = unknown> {
+    durable: {
+        executionId: string;
+    };
+    data: TResult;
+}
 export interface IDurableService {
-    startExecution<TInput>(task: DurableTask<TInput, unknown>, input?: TInput, options?: ExecuteOptions): Promise<string>;
+    start<TInput, TResult>(task: ITask<TInput, Promise<TResult>, any, any, any, any>, input?: TInput, options?: ExecuteOptions): Promise<string>;
+    start(task: string, input?: unknown, options?: ExecuteOptions): Promise<string>;
     /**
      * Request cancellation for an execution.
      * Cancellation is cooperative: it marks the execution as cancelled and unblocks waiters,
@@ -106,24 +110,28 @@ export interface IDurableService {
         timeout?: number;
         waitPollIntervalMs?: number;
     }): Promise<TResult>;
-    execute<TInput, TResult>(task: DurableTask<TInput, TResult>, input?: TInput, options?: ExecuteOptions): Promise<TResult>;
     /**
-     * A stricter alternative to `execute()` that rejects tasks whose result type
-     * includes `undefined` (including `void`, `unknown`, and `any`).
-     *
-     * This mirrors the runtime contract where `wait()`/`execute()` treat
-     * "completed without result" as an error.
+     * Starts a workflow and waits for completion.
+     * Returns the started execution id together with the workflow result payload.
      */
-    executeStrict<TInput, TResult>(task: undefined extends TResult ? never : DurableTask<TInput, TResult>, input?: TInput, options?: ExecuteOptions): Promise<TResult>;
-    schedule<TInput>(task: DurableTask<TInput, unknown>, input: TInput | undefined, options: ScheduleOptions): Promise<string>;
+    startAndWait<TInput, TResult>(task: ITask<TInput, Promise<TResult>, any, any, any, any>, input?: TInput, options?: ExecuteOptions): Promise<DurableStartAndWaitResult<TResult>>;
+    startAndWait<TResult = unknown>(task: string, input?: unknown, options?: ExecuteOptions): Promise<DurableStartAndWaitResult<TResult>>;
+    schedule<TInput, TResult>(task: ITask<TInput, Promise<TResult>, any, any, any, any>, input: TInput | undefined, options: ScheduleOptions): Promise<string>;
+    schedule(task: string, input: unknown, options: ScheduleOptions): Promise<string>;
     /**
      * Idempotently create (or update) a recurring schedule (cron/interval) with a stable id.
      * Safe to call concurrently from multiple processes.
      */
-    ensureSchedule<TInput>(task: DurableTask<TInput, unknown>, input: TInput | undefined, options: ScheduleOptions & {
+    ensureSchedule<TInput, TResult>(task: ITask<TInput, Promise<TResult>, any, any, any, any>, input: TInput | undefined, options: ScheduleOptions & {
+        id: string;
+    }): Promise<string>;
+    ensureSchedule(task: string, input: unknown, options: ScheduleOptions & {
         id: string;
     }): Promise<string>;
     recover(): Promise<void>;
+    /**
+     * Starts the durable polling loop (timers/schedules processing).
+     */
     start(): void;
     stop(): Promise<void>;
     pauseSchedule(scheduleId: string): Promise<void>;

package/dist/types/node/durable/core/interfaces/store.d.ts

@@ -13,7 +13,7 @@ export interface IDurableStore {
     listIncompleteExecutions(): Promise<Execution[]>;
     /**
      * Optional execution-level idempotency mapping.
-     * If supported, allows `startExecution(..., { idempotencyKey })` to dedupe workflow starts.
+     * If supported, allows `start(..., { idempotencyKey })` to dedupe workflow starts.
      */
     getExecutionIdByIdempotencyKey?(params: {
         taskId: string;

package/dist/types/node/durable/core/managers/ExecutionManager.d.ts

@@ -1,7 +1,8 @@
 import type { IDurableStore } from "../interfaces/store";
 import type { IDurableQueue } from "../interfaces/queue";
 import type { IEventBus } from "../interfaces/bus";
-import type { DurableServiceConfig, DurableTask, ExecuteOptions, ITaskExecutor } from "../interfaces/service";
+import type { DurableStartAndWaitResult, DurableServiceConfig, ExecuteOptions, ITaskExecutor } from "../interfaces/service";
+import type { ITask } from "../../../../types/task";
 import { type Execution } from "../types";
 import type { TaskRegistry } from "./TaskRegistry";
 import type { AuditLogger } from "./AuditLogger";
@@ -37,12 +38,41 @@ export declare class ExecutionManager {
     private readonly auditLogger;
     private readonly waitManager;
     constructor(config: ExecutionManagerConfig, taskRegistry: TaskRegistry, auditLogger: AuditLogger, waitManager: WaitManager);
-    startExecution<TInput>(task: DurableTask<TInput, unknown>, input?: TInput, options?: ExecuteOptions): Promise<string>;
+    start(taskRef: string | ITask<any, Promise<any>, any, any, any, any>, input?: unknown, options?: ExecuteOptions): Promise<string>;
+    /**
+     * Start a workflow with deduplication: if the same (taskId, idempotencyKey)
+     * was already started, returns the existing executionId instead of creating
+     * a duplicate. Uses a distributed lock to prevent concurrent races.
+     */
+    private startWithIdempotencyKey;
+    private assertCanExecute;
+    private assertStoreSupportsIdempotency;
+    /**
+     * Acquires a distributed lock around the idempotency check-and-set,
+     * falling back to lock-free operation when the store has no locking support.
+     */
+    private withIdempotencyLock;
+    /**
+     * Recovery path: `setExecutionIdByIdempotencyKey` returned false (another
+     * writer won the race), so we re-read the mapping to get their executionId.
+     */
+    private resolveRacedIdempotencyKey;
+    /**
+     * Creates a new execution record, persists it to the store, and logs an
+     * audit entry. Returns the executionId.
+     */
+    private persistNewExecution;
+    /**
+     * Kicks off an execution with a failsafe timer for queue mode.
+     * If the queue enqueue succeeds, the timer is cleaned up immediately.
+     * If enqueue fails, the timer remains so the polling loop can retry later.
+     */
+    private kickoffWithFailsafe;
     cancelExecution(executionId: string, reason?: string): Promise<void>;
-    execute<TInput, TResult>(task: DurableTask<TInput, TResult>, input?: TInput, options?: ExecuteOptions): Promise<TResult>;
-    executeStrict<TInput, TResult>(task: undefined extends TResult ? never : DurableTask<TInput, TResult>, input?: TInput, options?: ExecuteOptions): Promise<TResult>;
+    startAndWait(taskRef: string | ITask<any, Promise<any>, any, any, any, any>, input?: unknown, options?: ExecuteOptions): Promise<DurableStartAndWaitResult<unknown>>;
     processExecution(executionId: string): Promise<void>;
     kickoffExecution(executionId: string): Promise<void>;
     notifyExecutionFinished(execution: Execution): Promise<void>;
     private runExecutionAttempt;
+    private resolveTaskReference;
 }

package/dist/types/node/durable/core/managers/ScheduleManager.d.ts

@@ -1,7 +1,8 @@
 import type { IDurableStore } from "../interfaces/store";
-import type { DurableTask, ScheduleOptions } from "../interfaces/service";
+import type { ScheduleOptions } from "../interfaces/service";
 import { type Schedule } from "../types";
 import type { TaskRegistry } from "./TaskRegistry";
+import type { ITask } from "../../../../types/task";
 /**
  * Creates and maintains durable schedules.
  *
@@ -13,10 +14,10 @@ export declare class ScheduleManager {
     private readonly store;
     private readonly taskRegistry;
     constructor(store: IDurableStore, taskRegistry: TaskRegistry);
-    ensureSchedule<TInput>(task: DurableTask<TInput, unknown>, input: TInput | undefined, options: ScheduleOptions & {
+    ensureSchedule(taskRef: string | ITask<any, Promise<any>, any, any, any, any>, input: unknown, options: ScheduleOptions & {
         id: string;
     }): Promise<string>;
-    schedule<TInput>(task: DurableTask<TInput, unknown>, input: TInput | undefined, options: ScheduleOptions): Promise<string>;
+    schedule(taskRef: string | ITask<any, Promise<any>, any, any, any, any>, input: unknown, options: ScheduleOptions): Promise<string>;
     reschedule(schedule: Schedule, options?: {
         lastRunAt?: Date;
     }): Promise<void>;
@@ -30,4 +31,5 @@ export declare class ScheduleManager {
         input?: unknown;
     }): Promise<void>;
     remove(id: string): Promise<void>;
+    private resolveTaskReference;
 }

package/dist/types/node/durable/core/managers/TaskRegistry.d.ts

@@ -1,16 +1,16 @@
-import type { DurableTask } from "../interfaces/service";
+import type { ITask } from "../../../../types/task";
 /**
  * In-memory durable task registry.
  *
  * Durable executions persist only a `taskId` in the store, so the runtime needs a way
- * to resolve `taskId -> DurableTask` when resuming. This registry holds tasks that
+ * to resolve `taskId -> ITask` when resuming. This registry holds tasks that
  * were registered on the current process and optionally delegates to an external
  * resolver for tasks defined elsewhere (useful for modular apps).
  */
 export declare class TaskRegistry {
     private readonly externalResolver?;
     private readonly tasks;
-    constructor(externalResolver?: ((taskId: string) => DurableTask<any, any> | undefined) | undefined);
-    register<TInput, TResult>(task: DurableTask<TInput, TResult>): void;
-    find(taskId: string): DurableTask<any, any> | undefined;
+    constructor(externalResolver?: ((taskId: string) => ITask<any, Promise<any>, any, any, any, any> | undefined) | undefined);
+    register<TInput, TResult>(task: ITask<TInput, Promise<TResult>, any, any, any, any>): void;
+    find(taskId: string): ITask<any, Promise<any>, any, any, any, any> | undefined;
 }

package/dist/types/node/durable/core/managers/WaitManager.d.ts

@@ -12,7 +12,7 @@ export interface WaitConfig {
  * - otherwise (or on bus issues) fall back to polling the store
  *
  * The durable store remains the source of truth; this manager is purely a convenience layer
- * for callers that want `await durable.wait(...)` / `await durable.execute(...)`.
+ * for callers that want `await durable.wait(...)` / `await durable.startAndWait(...)`.
  */
 export declare class WaitManager {
     private readonly store;

package/dist/types/node/durable/core/resource.d.ts

@@ -7,8 +7,8 @@ export type DurableResourceRuntimeConfig = RunnerDurableRuntimeConfig;
  * - `const durable = durableResource.fork("app.durable");`
  * - Register it via `durable.with({ store, queue, eventBus, ... })`
  */
-export declare const durableResource: import("../..").IResource<RunnerDurableRuntimeConfig, Promise<import("./DurableResource").DurableResource>, {
-    taskRunner: import("../..").IResource<void, Promise<import("../..").TaskRunner>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
-    eventManager: import("../..").IResource<void, Promise<import("../..").EventManager>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
-    runnerStore: import("../..").IResource<void, Promise<import("../..").Store>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
-}, any, import("../..").IResourceMeta, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
+export declare const durableResource: import("../../../defs").IResource<RunnerDurableRuntimeConfig, Promise<import("./DurableResource").DurableResource>, {
+    taskRunner: import("../../../defs").IResource<void, Promise<import("../../../models").TaskRunner>, {}, any, any, import("../../../defs").TagType[], import("../../../defs").ResourceMiddlewareAttachmentType[]>;
+    eventManager: import("../../../defs").IResource<void, Promise<import("../../../models").EventManager>, {}, any, any, import("../../../defs").TagType[], import("../../../defs").ResourceMiddlewareAttachmentType[]>;
+    runnerStore: import("../../../defs").IResource<void, Promise<import("../../../models").Store>, {}, any, any, import("../../../defs").TagType[], import("../../../defs").ResourceMiddlewareAttachmentType[]>;
+}, any, import("../../../defs").IResourceMeta, import("../../../defs").TagType[], import("../../../defs").ResourceMiddlewareAttachmentType[]>;

package/dist/types/node/durable/index.d.ts

@@ -28,6 +28,7 @@ export { NoopEventBus } from "./bus/NoopEventBus";
 export { RedisEventBus } from "./bus/RedisEventBus";
 export { createDurableTestSetup, waitUntil } from "./test-utils";
 export type { DurableTestSetup, DurableTestSetupOptions } from "./test-utils";
+export { durableWorkflowTag, type DurableWorkflowTagConfig, } from "./tags/durableWorkflow.tag";
 export { memoryDurableResource } from "./resources/memoryDurableResource";
 export type { MemoryDurableResourceConfig } from "./resources/memoryDurableResource";
 export { redisDurableResource } from "./resources/redisDurableResource";

package/dist/types/node/durable/resources/memoryDurableResource.d.ts

@@ -13,9 +13,9 @@ export type MemoryDurableResourceConfig = Omit<RunnerDurableRuntimeConfig, "stor
 interface MemoryDurableResourceContext {
     runtimeConfig: RunnerDurableRuntimeConfig | null;
 }
-export declare const memoryDurableResource: import("../..").IResource<MemoryDurableResourceConfig, Promise<DurableResource>, {
-    taskRunner: import("../..").IResource<void, Promise<import("../..").TaskRunner>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
-    eventManager: import("../..").IResource<void, Promise<import("../..").EventManager>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
-    runnerStore: import("../..").IResource<void, Promise<import("../..").Store>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
-}, MemoryDurableResourceContext, import("../..").IResourceMeta, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
+export declare const memoryDurableResource: import("../../../defs").IResource<MemoryDurableResourceConfig, Promise<DurableResource>, {
+    taskRunner: import("../../../defs").IResource<void, Promise<import("../../../models").TaskRunner>, {}, any, any, import("../../../defs").TagType[], import("../../../defs").ResourceMiddlewareAttachmentType[]>;
+    eventManager: import("../../../defs").IResource<void, Promise<import("../../../models").EventManager>, {}, any, any, import("../../../defs").TagType[], import("../../../defs").ResourceMiddlewareAttachmentType[]>;
+    runnerStore: import("../../../defs").IResource<void, Promise<import("../../../models").Store>, {}, any, any, import("../../../defs").TagType[], import("../../../defs").ResourceMiddlewareAttachmentType[]>;
+}, MemoryDurableResourceContext, import("../../../defs").IResourceMeta, import("../../../defs").TagType[], import("../../../defs").ResourceMiddlewareAttachmentType[]>;
 export {};

package/dist/types/node/durable/resources/redisDurableResource.d.ts

@@ -27,9 +27,9 @@ export type RedisDurableResourceConfig = Omit<RunnerDurableRuntimeConfig, "store
 interface RedisDurableResourceContext {
     runtimeConfig: RunnerDurableRuntimeConfig | null;
 }
-export declare const redisDurableResource: import("../..").IResource<RedisDurableResourceConfig, Promise<DurableResource>, {
-    taskRunner: import("../..").IResource<void, Promise<import("../..").TaskRunner>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
-    eventManager: import("../..").IResource<void, Promise<import("../..").EventManager>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
-    runnerStore: import("../..").IResource<void, Promise<import("../..").Store>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
-}, RedisDurableResourceContext, import("../..").IResourceMeta, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
+export declare const redisDurableResource: import("../../../defs").IResource<RedisDurableResourceConfig, Promise<DurableResource>, {
+    taskRunner: import("../../../defs").IResource<void, Promise<import("../../../models").TaskRunner>, {}, any, any, import("../../../defs").TagType[], import("../../../defs").ResourceMiddlewareAttachmentType[]>;
+    eventManager: import("../../../defs").IResource<void, Promise<import("../../../models").EventManager>, {}, any, any, import("../../../defs").TagType[], import("../../../defs").ResourceMiddlewareAttachmentType[]>;
+    runnerStore: import("../../../defs").IResource<void, Promise<import("../../../models").Store>, {}, any, any, import("../../../defs").TagType[], import("../../../defs").ResourceMiddlewareAttachmentType[]>;
+}, RedisDurableResourceContext, import("../../../defs").IResourceMeta, import("../../../defs").TagType[], import("../../../defs").ResourceMiddlewareAttachmentType[]>;
 export {};

package/dist/types/node/durable/tags/durableWorkflow.tag.d.ts

@@ -0,0 +1,19 @@
+export interface DurableWorkflowTagConfig {
+    /**
+     * Optional domain/category to group workflows (eg. "orders", "billing").
+     */
+    category?: string;
+    /**
+     * Optional default input used by `durable.describe(task)` when no explicit
+     * input argument is provided.
+     */
+    defaults?: Record<string, unknown>;
+    /**
+     * Optional metadata for dashboards/tooling.
+     */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Marks a task as a durable workflow for runtime discovery.
+ */
+export declare const durableWorkflowTag: import("../../..").ITag<DurableWorkflowTagConfig, void, void>;

package/dist/types/node/exposure/requestContext.d.ts

@@ -8,7 +8,7 @@ export interface ExposureRequestContextValue {
     method?: string;
     signal: AbortSignal;
 }
-export declare const ExposureRequestContext: import("..").IAsyncContext<ExposureRequestContextValue>;
+export declare const ExposureRequestContext: import("../..").IAsyncContext<ExposureRequestContextValue>;
 export declare function useExposureContext(): ExposureRequestContextValue;
 /**
  * Checks if the exposure request context is currently available without throwing an error.

package/dist/types/node/exposure/resource.d.ts

@@ -1,12 +1,12 @@
 import type { NodeExposureConfig } from "./resourceTypes";
 export type { NodeExposureHttpAuthConfig } from "./authenticator";
-export declare const nodeExposure: import("..").IResource<NodeExposureConfig, Promise<import("./resourceTypes").NodeExposureHandlers>, {
-    store: import("..").IResource<void, Promise<import("..").Store>, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
-    taskRunner: import("..").IResource<void, Promise<import("..").TaskRunner>, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
-    eventManager: import("..").IResource<void, Promise<import("..").EventManager>, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
-    logger: import("..").IResource<void, Promise<import("..").Logger>, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
-    serializer: import("..").IResource<void, Promise<import("..").SerializerLike>, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
+export declare const nodeExposure: import("../..").IResource<NodeExposureConfig, Promise<import("./resourceTypes").NodeExposureHandlers>, {
+    store: import("../..").IResource<void, Promise<import("../..").Store>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
+    taskRunner: import("../..").IResource<void, Promise<import("../..").TaskRunner>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
+    eventManager: import("../..").IResource<void, Promise<import("../..").EventManager>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
+    logger: import("../..").IResource<void, Promise<import("../..").Logger>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
+    serializer: import("../..").IResource<void, Promise<import("../..").SerializerLike>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
 }, any, {
     title: string;
     description: string;
-}, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
+}, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;

package/dist/types/node/http/http-mixed-client.factory.resource.d.ts

@@ -13,5 +13,5 @@ export interface HttpMixedClientFactoryConfig {
     }) => void | Promise<void>;
 }
 export type HttpMixedClientFactory = (config: HttpMixedClientFactoryConfig) => MixedHttpClient;
-export declare const httpMixedClientFactory: import("..").IResource<void, Promise<HttpMixedClientFactory>, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
+export declare const httpMixedClientFactory: import("../..").IResource<void, Promise<HttpMixedClientFactory>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
 export type { MixedHttpClient };

package/dist/types/node/http/http-smart-client.factory.resource.d.ts

@@ -12,5 +12,5 @@ export interface HttpSmartClientFactoryConfig {
     }) => void | Promise<void>;
 }
 export type HttpSmartClientFactory = (config: HttpSmartClientFactoryConfig) => HttpSmartClient;
-export declare const httpSmartClientFactory: import("..").IResource<void, Promise<HttpSmartClientFactory>, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
+export declare const httpSmartClientFactory: import("../..").IResource<void, Promise<HttpSmartClientFactory>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
 export type { HttpSmartClient };

package/dist/types/node/node.d.ts

@@ -1,6 +1,4 @@
-export * from "../index";
-import type { RunResult } from "../models/RunResult";
-import type { SerializerLike } from "../serializer";
+export { run, globals } from "../public";
 export { nodeExposure } from "./exposure";
 export { hasExposureContext, useExposureContext, } from "./exposure/requestContext";
 export type * from "./exposure/resourceTypes";
@@ -10,184 +8,3 @@ export { readInputFileToBuffer, writeInputFileToPath } from "./files";
 export { createHttpSmartClient, createHttpMixedClient } from "./http";
 export type { HttpSmartClient, HttpSmartClientAuthConfig, HttpSmartClientConfig, MixedHttpClient, MixedHttpClientAuthConfig, MixedHttpClientConfig, Readable, } from "./http";
 export * from "./durable";
-export declare const globals: {
-    resources: {
-        httpSmartClientFactory: import("./node").IResource<void, Promise<import("./http").HttpSmartClientFactory>, {}, any, any, import("./node").TagType[], import("./node").ResourceMiddlewareAttachmentType[]>;
-        httpMixedClientFactory: import("./node").IResource<void, Promise<import("./http").HttpMixedClientFactory>, {}, any, any, import("./node").TagType[], import("./node").ResourceMiddlewareAttachmentType[]>;
-        store: import("./node").IResource<void, Promise<import("./node").Store>, {}, any, any, import("./node").TagType[], import("./node").ResourceMiddlewareAttachmentType[]>;
-        middlewareManager: import("./node").IResource<void, Promise<import("./node").MiddlewareManager>, {}, any, any, import("./node").TagType[], import("./node").ResourceMiddlewareAttachmentType[]>;
-        eventManager: import("./node").IResource<void, Promise<import("./node").EventManager>, {}, any, any, import("./node").TagType[], import("./node").ResourceMiddlewareAttachmentType[]>;
-        taskRunner: import("./node").IResource<void, Promise<import("./node").TaskRunner>, {}, any, any, import("./node").TagType[], import("./node").ResourceMiddlewareAttachmentType[]>;
-        logger: import("./node").IResource<void, Promise<import("./node").Logger>, {}, any, any, import("./node").TagType[], import("./node").ResourceMiddlewareAttachmentType[]>;
-        serializer: import("./node").IResource<void, Promise<SerializerLike>, {}, any, any, import("./node").TagType[], import("./node").ResourceMiddlewareAttachmentType[]>;
-        cache: import("./node").IResource<import("./node").CacheResourceConfig, Promise<{
-            map: Map<string, import("./node").ICacheInstance>;
-            cacheFactoryTask: import("./node").TaskDependencyWithIntercept<import("lru-cache").LRUCache.Options<any, any, any>, Promise<import("./node").ICacheInstance>>;
-            defaultOptions: any;
-        }>, {
-            cacheFactoryTask: import("./node").ITask<import("lru-cache").LRUCache.Options<any, any, any>, Promise<import("./node").ICacheInstance>, any, any, import("./node").TagType[], import("./node").TaskMiddlewareAttachmentType[]>;
-        }, any, any, import("./node").TagType[], import("./node").ResourceMiddlewareAttachmentType[]>;
-        queue: import("./node").IResource<void, Promise<{
-            map: Map<string, import("./node").Queue>;
-            run: <T>(id: string, task: (signal: AbortSignal) => Promise<T>) => Promise<T>;
-        }>, {}, {
-            map: Map<string, import("./node").Queue>;
-        }, {
-            title: string;
-            description: string;
-        }, import("./node").TagType[], import("./node").ResourceMiddlewareAttachmentType[]>;
-        httpClientFactory: import("./node").IResource<void, Promise<import("./node").HttpClientFactory>, {
-            serializer: import("./node").IResource<void, Promise<SerializerLike>, {}, any, any, import("./node").TagType[], import("./node").ResourceMiddlewareAttachmentType[]>;
-            store: import("./node").IResource<void, Promise<import("./node").Store>, {}, any, any, import("./node").TagType[], import("./node").ResourceMiddlewareAttachmentType[]>;
-        }, any, {
-            title: string;
-            description: string;
-        }, import("./node").TagType[], import("./node").ResourceMiddlewareAttachmentType[]>;
-        rateLimit: import("./node").IResource<void, Promise<{
-            states: WeakMap<import("./node").RateLimitMiddlewareConfig, import("./node").RateLimitState>;
-        }>, {}, any, any, import("./node").ITag<{
-            metadata?: Record<string, any>;
-        }, void, void>[], import("./node").ResourceMiddlewareAttachmentType[]>;
-        circuitBreaker: import("./node").IResource<void, Promise<{
-            statusMap: Map<string, import("./node").CircuitBreakerStatus>;
-        }>, {}, any, any, import("./node").ITag<{
-            metadata?: Record<string, any>;
-        }, void, void>[], import("./node").ResourceMiddlewareAttachmentType[]>;
-        temporal: import("./node").IResource<void, Promise<{
-            debounceStates: WeakMap<import("./node").TemporalMiddlewareConfig, import("./node").DebounceState>;
-            throttleStates: WeakMap<import("./node").TemporalMiddlewareConfig, import("./node").ThrottleState>;
-        }>, {}, any, any, import("./node").ITag<{
-            metadata?: Record<string, any>;
-        }, void, void>[], import("./node").ResourceMiddlewareAttachmentType[]>;
-        concurrency: import("./node").IResource<void, Promise<{
-            semaphoresByConfig: WeakMap<import("./node").ConcurrencyMiddlewareConfig, import("./node").Semaphore>;
-            semaphoresByKey: Map<string, {
-                semaphore: import("./node").Semaphore;
-                limit: number;
-            }>;
-        }>, {}, any, any, import("./node").ITag<{
-            metadata?: Record<string, any>;
-        }, void, void>[], import("./node").ResourceMiddlewareAttachmentType[]>;
-    };
-    events: {
-        readonly ready: import("./node").IEvent<void>;
-    };
-    middleware: {
-        requireContext: import("./node").ITaskMiddleware<import("./node").RequireContextMiddlewareConfig, void, void, any>;
-        task: {
-            requireContext: import("./node").ITaskMiddleware<import("./node").RequireContextMiddlewareConfig, void, void, any>;
-            cache: import("./node").ITaskMiddleware<any, void, void, {
-                cache: import("./node").IResource<import("./node").CacheResourceConfig, Promise<{
-                    map: Map<string, import("./node").ICacheInstance>;
-                    cacheFactoryTask: import("./node").TaskDependencyWithIntercept<import("lru-cache").LRUCache.Options<any, any, any>, Promise<import("./node").ICacheInstance>>;
-                    defaultOptions: any;
-                }>, {
-                    cacheFactoryTask: import("./node").ITask<import("lru-cache").LRUCache.Options<any, any, any>, Promise<import("./node").ICacheInstance>, any, any, import("./node").TagType[], import("./node").TaskMiddlewareAttachmentType[]>;
-                }, any, any, import("./node").TagType[], import("./node").ResourceMiddlewareAttachmentType[]>;
-            }> & {
-                journalKeys: {
-                    readonly hit: import("./node").JournalKey<boolean>;
-                };
-            };
-            concurrency: import("./node").ITaskMiddleware<import("./node").ConcurrencyMiddlewareConfig, void, void, {
-                state: import("./node").IResource<void, Promise<{
-                    semaphoresByConfig: WeakMap<import("./node").ConcurrencyMiddlewareConfig, import("./node").Semaphore>;
-                    semaphoresByKey: Map<string, {
-                        semaphore: import("./node").Semaphore;
-                        limit: number;
-                    }>;
-                }>, {}, any, any, import("./node").ITag<{
-                    metadata?: Record<string, any>;
-                }, void, void>[], import("./node").ResourceMiddlewareAttachmentType[]>;
-            }>;
-            debounce: import("./node").ITaskMiddleware<import("./node").TemporalMiddlewareConfig, void, void, {
-                state: import("./node").IResource<void, Promise<{
-                    debounceStates: WeakMap<import("./node").TemporalMiddlewareConfig, import("./node").DebounceState>;
-                    throttleStates: WeakMap<import("./node").TemporalMiddlewareConfig, import("./node").ThrottleState>;
-                }>, {}, any, any, import("./node").ITag<{
-                    metadata?: Record<string, any>;
-                }, void, void>[], import("./node").ResourceMiddlewareAttachmentType[]>;
-            }>;
-            throttle: import("./node").ITaskMiddleware<import("./node").TemporalMiddlewareConfig, void, void, {
-                state: import("./node").IResource<void, Promise<{
-                    debounceStates: WeakMap<import("./node").TemporalMiddlewareConfig, import("./node").DebounceState>;
-                    throttleStates: WeakMap<import("./node").TemporalMiddlewareConfig, import("./node").ThrottleState>;
-                }>, {}, any, any, import("./node").ITag<{
-                    metadata?: Record<string, any>;
-                }, void, void>[], import("./node").ResourceMiddlewareAttachmentType[]>;
-            }>;
-            fallback: import("./node").ITaskMiddleware<import("./node").FallbackMiddlewareConfig, void, void, {
-                taskRunner: import("./node").IResource<void, Promise<import("./node").TaskRunner>, {}, any, any, import("./node").TagType[], import("./node").ResourceMiddlewareAttachmentType[]>;
-            }> & {
-                journalKeys: {
-                    readonly active: import("./node").JournalKey<boolean>;
-                    readonly error: import("./node").JournalKey<Error>;
-                };
-            };
-            rateLimit: import("./node").ITaskMiddleware<import("./node").RateLimitMiddlewareConfig, void, void, {
-                state: import("./node").IResource<void, Promise<{
-                    states: WeakMap<import("./node").RateLimitMiddlewareConfig, import("./node").RateLimitState>;
-                }>, {}, any, any, import("./node").ITag<{
-                    metadata?: Record<string, any>;
-                }, void, void>[], import("./node").ResourceMiddlewareAttachmentType[]>;
-            }> & {
-                journalKeys: {
-                    readonly remaining: import("./node").JournalKey<number>;
-                    readonly resetTime: import("./node").JournalKey<number>;
-                    readonly limit: import("./node").JournalKey<number>;
-                };
-            };
-            retry: import("./node").ITaskMiddleware<import("./node").RetryMiddlewareConfig, void, void, any> & {
-                journalKeys: {
-                    readonly attempt: import("./node").JournalKey<number>;
-                    readonly lastError: import("./node").JournalKey<Error>;
-                };
-            };
-            timeout: import("./node").ITaskMiddleware<import("./node").TimeoutMiddlewareConfig, void, void, any> & {
-                journalKeys: {
-                    readonly abortController: import("./node").JournalKey<AbortController>;
-                };
-            };
-            circuitBreaker: import("./node").ITaskMiddleware<import("./node").CircuitBreakerMiddlewareConfig, void, void, {
-                state: import("./node").IResource<void, Promise<{
-                    statusMap: Map<string, import("./node").CircuitBreakerStatus>;
-                }>, {}, any, any, import("./node").ITag<{
-                    metadata?: Record<string, any>;
-                }, void, void>[], import("./node").ResourceMiddlewareAttachmentType[]>;
-            }> & {
-                journalKeys: {
-                    readonly state: import("./node").JournalKey<import("./node").CircuitBreakerState>;
-                    readonly failures: import("./node").JournalKey<number>;
-                };
-            };
-        };
-        resource: {
-            retry: import("./node").IResourceMiddleware<import("./node").RetryMiddlewareConfig, void, void, any>;
-            timeout: import("./node").IResourceMiddleware<import("./node").TimeoutMiddlewareConfig, void, void, any>;
-        };
-    };
-    tags: {
-        system: import("./node").ITag<{
-            metadata?: Record<string, any>;
-        }, void, void>;
-        excludeFromGlobalHooks: import("./node").ITag<{
-            metadata?: Record<string, any>;
-        }, void, void>;
-        debug: import("./node").ITag<import("./node").DebugFriendlyConfig, void, void>;
-        tunnel: import("./node").ITag<void, void, import("./node").TunnelRunner>;
-        tunnelPolicy: import("./node").ITag<import("./node").TunnelTaskMiddlewarePolicyConfig, void, void>;
-        authValidator: import("./node").ITag<void, void, void>;
-    };
-    tunnels: Readonly<{
-        http: Readonly<{
-            createClient(cfg: import("./node").HttpCreateClientConfig): import("./node").ExposureFetchClient;
-        }>;
-    }>;
-    debug: {
-        levels: {
-            normal: import("./node").DebugConfig;
-            verbose: import("./node").DebugConfig;
-        };
-    };
-};
-export declare function run(root: any, config?: any): Promise<RunResult<any>>;

package/dist/types/platform/adapters/edge.d.ts

@@ -1,5 +1,22 @@
+import type { IAsyncLocalStorage } from "../types";
 import { BrowserPlatformAdapter } from "./browser";
+/**
+ * Edge runtimes (workers) are closer to browsers but may support
+ * AsyncLocalStorage via the `node:async_hooks` compat layer
+ * (e.g. Cloudflare Workers, Vercel Edge).
+ */
 export declare class EdgePlatformAdapter extends BrowserPlatformAdapter {
     readonly id: "edge";
+    private alsClass;
+    private alsProbed;
+    init(): Promise<void>;
+    /**
+     * Attempt to discover AsyncLocalStorage from the runtime.
+     * Checks globalThis first, then tries `import("node:async_hooks")`.
+     */
+    private probeGlobalAsyncLocalStorage;
+    private probeAsyncLocalStorage;
     onShutdownSignal(_handler: () => void): () => void;
+    hasAsyncLocalStorage(): boolean;
+    createAsyncLocalStorage<T>(): IAsyncLocalStorage<T>;
 }

package/dist/types/platform/adapters/universal-generic.d.ts

@@ -1,7 +1,10 @@
 import type { IAsyncLocalStorage, IPlatformAdapter } from "../types";
 export declare class GenericUniversalPlatformAdapter implements IPlatformAdapter {
     readonly id: "universal";
+    private alsClass;
+    private alsProbed;
     init(): Promise<void>;
+    private probeAsyncLocalStorage;
     onUncaughtException(handler: (error: any) => void): () => any;
     onUnhandledRejection(handler: (reason: any) => void): () => any;
     onShutdownSignal(handler: () => void): () => void;

package/dist/types/platform/index.d.ts

@@ -8,6 +8,7 @@ export declare function getDetectedEnvironment(): PlatformId;
 export declare function isNode(): boolean;
 export declare function isBrowser(): boolean;
 export declare function isUniversal(): boolean;
+export declare function isEdge(): boolean;
 export type { IPlatformAdapter, IAsyncLocalStorage, PlatformId, PlatformSetTimeout, PlatformClearTimeout, } from "./types";
 export declare class PlatformAdapter implements IPlatformAdapter {
     private inner;