@microfox/ai-worker 1.0.1 → 1.0.3

package/dist/client-BqSJQ9mZ.d.mts

@@ -0,0 +1,183 @@
+import { ZodType, z } from 'zod';
+
+/**
+ * Queue definition and context types for worker queues.
+ *
+ * These types are used at code-time by .queue.ts files and at runtime
+ * by the client and generated registry/queue wrappers.
+ */
+interface WorkerQueueStep {
+    /** Worker ID for this step. Must match an existing worker id. */
+    workerId: string;
+    /**
+     * Optional delay (in seconds) before this step is executed.
+     * Implemented via SQS DelaySeconds (0–900).
+     */
+    delaySeconds?: number;
+    /**
+     * Optional name of a mapping function exported from the .queue.ts file.
+     * The function is called with (initialInput, previousOutputs):
+     * - initialInput: original input passed to dispatchQueue (always first, for best DX).
+     * - previousOutputs: array of { stepIndex, workerId, output } for steps 0..current-1.
+     *   Use any prior step's output; the immediate previous step is previousOutputs[previousOutputs.length - 1]?.output.
+     */
+    mapInputFromPrev?: string;
+}
+interface WorkerQueueConfig<InitialInput = any, StepOutput = any> {
+    /** Stable queue identifier, e.g. "cost-usage". */
+    id: string;
+    /** Ordered list of workers forming the queue. */
+    steps: WorkerQueueStep[];
+    /**
+     * Optional schedule for the queue (cron or rate).
+     * When set, the CLI generates a queue-starter Lambda triggered by this schedule.
+     * Example: 'cron(0 3 * * ? *)' for daily at 03:00 UTC.
+     */
+    schedule?: string | {
+        rate: string;
+        enabled?: boolean;
+        input?: Record<string, any>;
+    };
+    _initialInputType?: InitialInput;
+    _stepOutputType?: StepOutput;
+}
+/**
+ * Queue execution context that is embedded into job input/metadata so
+ * queue-aware wrappers can determine where they are in the queue.
+ */
+interface WorkerQueueContext<InitialInput = any> {
+    id: string;
+    stepIndex: number;
+    initialInput: InitialInput;
+    /** Queue job ID (same as first worker's jobId) for tracking progress. */
+    queueJobId?: string;
+}
+/**
+ * Identity helper for defining worker queues in .queue.ts files.
+ * This is primarily for type safety and CLI discovery.
+ */
+declare function defineWorkerQueue<T extends WorkerQueueConfig>(config: T): T;
+
+/**
+ * Client for dispatching background worker jobs.
+ *
+ * In production, dispatching happens via the workers HTTP API:
+ *   POST /workers/trigger  -> enqueues message to SQS on the workers service side
+ *
+ * This avoids requiring AWS credentials in your Next.js app.
+ */
+
+interface WorkerQueueRegistry {
+    getQueueById(queueId: string): WorkerQueueConfig | undefined;
+    /** (initialInput, previousOutputs) for best DX: derive next input from original request and all prior step outputs. */
+    invokeMapInput?: (queueId: string, stepIndex: number, initialInput: unknown, previousOutputs: Array<{
+        stepIndex: number;
+        workerId: string;
+        output: unknown;
+    }>) => Promise<unknown> | unknown;
+}
+interface DispatchOptions {
+    /**
+     * Optional webhook callback URL to notify when the job finishes.
+     * Only called when provided. Default: no webhook (use job store / MongoDB only).
+     */
+    webhookUrl?: string;
+    /**
+     * Controls how dispatch executes.
+     * - "auto" (default): local inline execution in development unless WORKERS_LOCAL_MODE=false.
+     * - "local": force inline execution (no SQS).
+     * - "remote": force SQS/Lambda dispatch even in development.
+     */
+    mode?: 'auto' | 'local' | 'remote';
+    jobId?: string;
+    metadata?: Record<string, any>;
+    /**
+     * In-memory queue registry for dispatchQueue. Required when using dispatchQueue.
+     * Pass a registry that imports from your .queue.ts definitions (works on Vercel/serverless).
+     */
+    registry?: WorkerQueueRegistry;
+    /**
+     * Optional callback to create a queue job record before dispatching.
+     * Called with queueJobId (= first worker's jobId), queueId, and firstStep.
+     */
+    onCreateQueueJob?: (params: {
+        queueJobId: string;
+        queueId: string;
+        firstStep: {
+            workerId: string;
+            workerJobId: string;
+        };
+        metadata?: Record<string, unknown>;
+    }) => Promise<void>;
+}
+interface DispatchResult {
+    messageId: string;
+    status: 'queued';
+    jobId: string;
+}
+interface DispatchQueueResult extends DispatchResult {
+    queueId: string;
+}
+interface SerializedContext {
+    requestId?: string;
+    userId?: string;
+    traceId?: string;
+    [key: string]: any;
+}
+/**
+ * Derives the full /workers/trigger URL from env.
+ * Exported for use by local dispatchWorker (worker-to-worker in dev).
+ * Server-side only; clients should use useWorkflowJob with your app's /api/workflows routes.
+ *
+ * Env vars:
+ * - WORKER_BASE_URL: base URL of the workers service (e.g. https://.../prod)
+ * - WORKERS_TRIGGER_API_URL / WORKERS_CONFIG_API_URL: legacy, still supported
+ */
+declare function getWorkersTriggerUrl(): string;
+/**
+ * URL for the queue start endpoint (dispatch proxy). Use this so queue starts
+ * go through the queue handler Lambda for easier debugging (one log stream per queue).
+ */
+declare function getQueueStartUrl(queueId: string): string;
+/**
+ * Dispatches a background worker job to SQS.
+ *
+ * @param workerId - The ID of the worker to dispatch
+ * @param input - The input data for the worker (will be validated against inputSchema)
+ * @param inputSchema - Zod schema for input validation
+ * @param options - Dispatch options including webhook URL
+ * @param ctx - Optional context object (only serializable parts will be sent)
+ * @returns Promise resolving to dispatch result with messageId and jobId
+ */
+declare function dispatch<INPUT_SCHEMA extends ZodType<any>>(workerId: string, input: z.input<INPUT_SCHEMA>, inputSchema: INPUT_SCHEMA, options: DispatchOptions, ctx?: any): Promise<DispatchResult>;
+/**
+ * Dispatch a worker by ID without importing the worker module.
+ * Sends to the workers trigger API (WORKER_BASE_URL). No input schema validation at call site.
+ *
+ * @param workerId - The worker ID (e.g. 'echo', 'data-processor')
+ * @param input - Input payload (object or undefined)
+ * @param options - Optional jobId, webhookUrl, metadata
+ * @param ctx - Optional context (serializable parts sent in the request)
+ * @returns Promise resolving to { messageId, status: 'queued', jobId }
+ */
+declare function dispatchWorker(workerId: string, input?: Record<string, unknown>, options?: DispatchOptions, ctx?: any): Promise<DispatchResult>;
+/**
+ * Local development mode: runs the handler immediately in the same process.
+ * This bypasses SQS and Lambda for faster iteration during development.
+ *
+ * @param handler - The worker handler function
+ * @param input - The input data
+ * @param ctx - The context object
+ * @returns The handler result
+ */
+declare function dispatchLocal<INPUT, OUTPUT>(handler: (params: {
+    input: INPUT;
+    ctx: any;
+}) => Promise<OUTPUT>, input: INPUT, ctx?: any): Promise<OUTPUT>;
+/**
+ * Dispatches a queue by ID. POSTs to the queue-start API; the queue-start handler creates the queue job.
+ * Pass the first worker's input directly (no registry required).
+ */
+declare function dispatchQueue<InitialInput = any>(queueId: string, initialInput?: InitialInput, options?: DispatchOptions, _ctx?: any): Promise<DispatchQueueResult>;
+
+export { type DispatchOptions as D, type SerializedContext as S, type WorkerQueueRegistry as W, type DispatchResult as a, type DispatchQueueResult as b, getQueueStartUrl as c, dispatch as d, dispatchWorker as e, dispatchLocal as f, getWorkersTriggerUrl as g, dispatchQueue as h, type WorkerQueueStep as i, type WorkerQueueConfig as j, type WorkerQueueContext as k, defineWorkerQueue as l };

package/dist/client-BqSJQ9mZ.d.ts

@@ -0,0 +1,183 @@
+import { ZodType, z } from 'zod';
+
+/**
+ * Queue definition and context types for worker queues.
+ *
+ * These types are used at code-time by .queue.ts files and at runtime
+ * by the client and generated registry/queue wrappers.
+ */
+interface WorkerQueueStep {
+    /** Worker ID for this step. Must match an existing worker id. */
+    workerId: string;
+    /**
+     * Optional delay (in seconds) before this step is executed.
+     * Implemented via SQS DelaySeconds (0–900).
+     */
+    delaySeconds?: number;
+    /**
+     * Optional name of a mapping function exported from the .queue.ts file.
+     * The function is called with (initialInput, previousOutputs):
+     * - initialInput: original input passed to dispatchQueue (always first, for best DX).
+     * - previousOutputs: array of { stepIndex, workerId, output } for steps 0..current-1.
+     *   Use any prior step's output; the immediate previous step is previousOutputs[previousOutputs.length - 1]?.output.
+     */
+    mapInputFromPrev?: string;
+}
+interface WorkerQueueConfig<InitialInput = any, StepOutput = any> {
+    /** Stable queue identifier, e.g. "cost-usage". */
+    id: string;
+    /** Ordered list of workers forming the queue. */
+    steps: WorkerQueueStep[];
+    /**
+     * Optional schedule for the queue (cron or rate).
+     * When set, the CLI generates a queue-starter Lambda triggered by this schedule.
+     * Example: 'cron(0 3 * * ? *)' for daily at 03:00 UTC.
+     */
+    schedule?: string | {
+        rate: string;
+        enabled?: boolean;
+        input?: Record<string, any>;
+    };
+    _initialInputType?: InitialInput;
+    _stepOutputType?: StepOutput;
+}
+/**
+ * Queue execution context that is embedded into job input/metadata so
+ * queue-aware wrappers can determine where they are in the queue.
+ */
+interface WorkerQueueContext<InitialInput = any> {
+    id: string;
+    stepIndex: number;
+    initialInput: InitialInput;
+    /** Queue job ID (same as first worker's jobId) for tracking progress. */
+    queueJobId?: string;
+}
+/**
+ * Identity helper for defining worker queues in .queue.ts files.
+ * This is primarily for type safety and CLI discovery.
+ */
+declare function defineWorkerQueue<T extends WorkerQueueConfig>(config: T): T;
+
+/**
+ * Client for dispatching background worker jobs.
+ *
+ * In production, dispatching happens via the workers HTTP API:
+ *   POST /workers/trigger  -> enqueues message to SQS on the workers service side
+ *
+ * This avoids requiring AWS credentials in your Next.js app.
+ */
+
+interface WorkerQueueRegistry {
+    getQueueById(queueId: string): WorkerQueueConfig | undefined;
+    /** (initialInput, previousOutputs) for best DX: derive next input from original request and all prior step outputs. */
+    invokeMapInput?: (queueId: string, stepIndex: number, initialInput: unknown, previousOutputs: Array<{
+        stepIndex: number;
+        workerId: string;
+        output: unknown;
+    }>) => Promise<unknown> | unknown;
+}
+interface DispatchOptions {
+    /**
+     * Optional webhook callback URL to notify when the job finishes.
+     * Only called when provided. Default: no webhook (use job store / MongoDB only).
+     */
+    webhookUrl?: string;
+    /**
+     * Controls how dispatch executes.
+     * - "auto" (default): local inline execution in development unless WORKERS_LOCAL_MODE=false.
+     * - "local": force inline execution (no SQS).
+     * - "remote": force SQS/Lambda dispatch even in development.
+     */
+    mode?: 'auto' | 'local' | 'remote';
+    jobId?: string;
+    metadata?: Record<string, any>;
+    /**
+     * In-memory queue registry for dispatchQueue. Required when using dispatchQueue.
+     * Pass a registry that imports from your .queue.ts definitions (works on Vercel/serverless).
+     */
+    registry?: WorkerQueueRegistry;
+    /**
+     * Optional callback to create a queue job record before dispatching.
+     * Called with queueJobId (= first worker's jobId), queueId, and firstStep.
+     */
+    onCreateQueueJob?: (params: {
+        queueJobId: string;
+        queueId: string;
+        firstStep: {
+            workerId: string;
+            workerJobId: string;
+        };
+        metadata?: Record<string, unknown>;
+    }) => Promise<void>;
+}
+interface DispatchResult {
+    messageId: string;
+    status: 'queued';
+    jobId: string;
+}
+interface DispatchQueueResult extends DispatchResult {
+    queueId: string;
+}
+interface SerializedContext {
+    requestId?: string;
+    userId?: string;
+    traceId?: string;
+    [key: string]: any;
+}
+/**
+ * Derives the full /workers/trigger URL from env.
+ * Exported for use by local dispatchWorker (worker-to-worker in dev).
+ * Server-side only; clients should use useWorkflowJob with your app's /api/workflows routes.
+ *
+ * Env vars:
+ * - WORKER_BASE_URL: base URL of the workers service (e.g. https://.../prod)
+ * - WORKERS_TRIGGER_API_URL / WORKERS_CONFIG_API_URL: legacy, still supported
+ */
+declare function getWorkersTriggerUrl(): string;
+/**
+ * URL for the queue start endpoint (dispatch proxy). Use this so queue starts
+ * go through the queue handler Lambda for easier debugging (one log stream per queue).
+ */
+declare function getQueueStartUrl(queueId: string): string;
+/**
+ * Dispatches a background worker job to SQS.
+ *
+ * @param workerId - The ID of the worker to dispatch
+ * @param input - The input data for the worker (will be validated against inputSchema)
+ * @param inputSchema - Zod schema for input validation
+ * @param options - Dispatch options including webhook URL
+ * @param ctx - Optional context object (only serializable parts will be sent)
+ * @returns Promise resolving to dispatch result with messageId and jobId
+ */
+declare function dispatch<INPUT_SCHEMA extends ZodType<any>>(workerId: string, input: z.input<INPUT_SCHEMA>, inputSchema: INPUT_SCHEMA, options: DispatchOptions, ctx?: any): Promise<DispatchResult>;
+/**
+ * Dispatch a worker by ID without importing the worker module.
+ * Sends to the workers trigger API (WORKER_BASE_URL). No input schema validation at call site.
+ *
+ * @param workerId - The worker ID (e.g. 'echo', 'data-processor')
+ * @param input - Input payload (object or undefined)
+ * @param options - Optional jobId, webhookUrl, metadata
+ * @param ctx - Optional context (serializable parts sent in the request)
+ * @returns Promise resolving to { messageId, status: 'queued', jobId }
+ */
+declare function dispatchWorker(workerId: string, input?: Record<string, unknown>, options?: DispatchOptions, ctx?: any): Promise<DispatchResult>;
+/**
+ * Local development mode: runs the handler immediately in the same process.
+ * This bypasses SQS and Lambda for faster iteration during development.
+ *
+ * @param handler - The worker handler function
+ * @param input - The input data
+ * @param ctx - The context object
+ * @returns The handler result
+ */
+declare function dispatchLocal<INPUT, OUTPUT>(handler: (params: {
+    input: INPUT;
+    ctx: any;
+}) => Promise<OUTPUT>, input: INPUT, ctx?: any): Promise<OUTPUT>;
+/**
+ * Dispatches a queue by ID. POSTs to the queue-start API; the queue-start handler creates the queue job.
+ * Pass the first worker's input directly (no registry required).
+ */
+declare function dispatchQueue<InitialInput = any>(queueId: string, initialInput?: InitialInput, options?: DispatchOptions, _ctx?: any): Promise<DispatchQueueResult>;
+
+export { type DispatchOptions as D, type SerializedContext as S, type WorkerQueueRegistry as W, type DispatchResult as a, type DispatchQueueResult as b, getQueueStartUrl as c, dispatch as d, dispatchWorker as e, dispatchLocal as f, getWorkersTriggerUrl as g, dispatchQueue as h, type WorkerQueueStep as i, type WorkerQueueConfig as j, type WorkerQueueContext as k, defineWorkerQueue as l };

package/dist/client.d.mts

@@ -1,64 +1,2 @@
-import { ZodType, z } from 'zod';
-
-/**
- * Client for dispatching background worker jobs.
- *
- * In production, dispatching happens via the workers HTTP API:
- *   POST /workers/trigger  -> enqueues message to SQS on the workers service side
- *
- * This avoids requiring AWS credentials in your Next.js app.
- */
-
-interface DispatchOptions {
-    /**
-     * Optional webhook callback URL to notify when the job finishes.
-     * Only called when provided. Default: no webhook (use job store / MongoDB only).
-     */
-    webhookUrl?: string;
-    /**
-     * Controls how dispatch executes.
-     * - "auto" (default): local inline execution in development unless WORKERS_LOCAL_MODE=false.
-     * - "local": force inline execution (no SQS).
-     * - "remote": force SQS/Lambda dispatch even in development.
-     */
-    mode?: 'auto' | 'local' | 'remote';
-    jobId?: string;
-    metadata?: Record<string, any>;
-}
-interface DispatchResult {
-    messageId: string;
-    status: 'queued';
-    jobId: string;
-}
-interface SerializedContext {
-    requestId?: string;
-    userId?: string;
-    traceId?: string;
-    [key: string]: any;
-}
-/**
- * Dispatches a background worker job to SQS.
- *
- * @param workerId - The ID of the worker to dispatch
- * @param input - The input data for the worker (will be validated against inputSchema)
- * @param inputSchema - Zod schema for input validation
- * @param options - Dispatch options including webhook URL
- * @param ctx - Optional context object (only serializable parts will be sent)
- * @returns Promise resolving to dispatch result with messageId and jobId
- */
-declare function dispatch<INPUT_SCHEMA extends ZodType<any>>(workerId: string, input: z.input<INPUT_SCHEMA>, inputSchema: INPUT_SCHEMA, options: DispatchOptions, ctx?: any): Promise<DispatchResult>;
-/**
- * Local development mode: runs the handler immediately in the same process.
- * This bypasses SQS and Lambda for faster iteration during development.
- *
- * @param handler - The worker handler function
- * @param input - The input data
- * @param ctx - The context object
- * @returns The handler result
- */
-declare function dispatchLocal<INPUT, OUTPUT>(handler: (params: {
-    input: INPUT;
-    ctx: any;
-}) => Promise<OUTPUT>, input: INPUT, ctx?: any): Promise<OUTPUT>;
-
-export { type DispatchOptions, type DispatchResult, type SerializedContext, dispatch, dispatchLocal };
+import 'zod';
+export { D as DispatchOptions, b as DispatchQueueResult, a as DispatchResult, S as SerializedContext, W as WorkerQueueRegistry, d as dispatch, f as dispatchLocal, h as dispatchQueue, e as dispatchWorker, c as getQueueStartUrl, g as getWorkersTriggerUrl } from './client-BqSJQ9mZ.mjs';

package/dist/client.d.ts

@@ -1,64 +1,2 @@
-import { ZodType, z } from 'zod';
-
-/**
- * Client for dispatching background worker jobs.
- *
- * In production, dispatching happens via the workers HTTP API:
- *   POST /workers/trigger  -> enqueues message to SQS on the workers service side
- *
- * This avoids requiring AWS credentials in your Next.js app.
- */
-
-interface DispatchOptions {
-    /**
-     * Optional webhook callback URL to notify when the job finishes.
-     * Only called when provided. Default: no webhook (use job store / MongoDB only).
-     */
-    webhookUrl?: string;
-    /**
-     * Controls how dispatch executes.
-     * - "auto" (default): local inline execution in development unless WORKERS_LOCAL_MODE=false.
-     * - "local": force inline execution (no SQS).
-     * - "remote": force SQS/Lambda dispatch even in development.
-     */
-    mode?: 'auto' | 'local' | 'remote';
-    jobId?: string;
-    metadata?: Record<string, any>;
-}
-interface DispatchResult {
-    messageId: string;
-    status: 'queued';
-    jobId: string;
-}
-interface SerializedContext {
-    requestId?: string;
-    userId?: string;
-    traceId?: string;
-    [key: string]: any;
-}
-/**
- * Dispatches a background worker job to SQS.
- *
- * @param workerId - The ID of the worker to dispatch
- * @param input - The input data for the worker (will be validated against inputSchema)
- * @param inputSchema - Zod schema for input validation
- * @param options - Dispatch options including webhook URL
- * @param ctx - Optional context object (only serializable parts will be sent)
- * @returns Promise resolving to dispatch result with messageId and jobId
- */
-declare function dispatch<INPUT_SCHEMA extends ZodType<any>>(workerId: string, input: z.input<INPUT_SCHEMA>, inputSchema: INPUT_SCHEMA, options: DispatchOptions, ctx?: any): Promise<DispatchResult>;
-/**
- * Local development mode: runs the handler immediately in the same process.
- * This bypasses SQS and Lambda for faster iteration during development.
- *
- * @param handler - The worker handler function
- * @param input - The input data
- * @param ctx - The context object
- * @returns The handler result
- */
-declare function dispatchLocal<INPUT, OUTPUT>(handler: (params: {
-    input: INPUT;
-    ctx: any;
-}) => Promise<OUTPUT>, input: INPUT, ctx?: any): Promise<OUTPUT>;
-
-export { type DispatchOptions, type DispatchResult, type SerializedContext, dispatch, dispatchLocal };
+import 'zod';
+export { D as DispatchOptions, b as DispatchQueueResult, a as DispatchResult, S as SerializedContext, W as WorkerQueueRegistry, d as dispatch, f as dispatchLocal, h as dispatchQueue, e as dispatchWorker, c as getQueueStartUrl, g as getWorkersTriggerUrl } from './client-BqSJQ9mZ.js';

package/dist/client.js

@@ -21,14 +21,18 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var client_exports = {};
 __export(client_exports, {
   dispatch: () => dispatch,
-  dispatchLocal: () => dispatchLocal
+  dispatchLocal: () => dispatchLocal,
+  dispatchQueue: () => dispatchQueue,
+  dispatchWorker: () => dispatchWorker,
+  getQueueStartUrl: () => getQueueStartUrl,
+  getWorkersTriggerUrl: () => getWorkersTriggerUrl
 });
 module.exports = __toCommonJS(client_exports);
 function getWorkersTriggerUrl() {
-  const raw = process.env.WORKER_BASE_URL || process.env.NEXT_PUBLIC_WORKER_BASE_URL || process.env.WORKERS_TRIGGER_API_URL || process.env.NEXT_PUBLIC_WORKERS_TRIGGER_API_URL || process.env.WORKERS_CONFIG_API_URL || process.env.NEXT_PUBLIC_WORKERS_CONFIG_API_URL;
+  const raw = process.env.WORKER_BASE_URL || process.env.WORKERS_TRIGGER_API_URL || process.env.WORKERS_CONFIG_API_URL;
   if (!raw) {
     throw new Error(
-      "WORKER_BASE_URL (preferred) or NEXT_PUBLIC_WORKER_BASE_URL is required for background workers"
+      "WORKER_BASE_URL is required for background workers. Set it server-side only."
     );
   }
   const url = new URL(raw);
@@ -40,6 +44,23 @@ function getWorkersTriggerUrl() {
   url.pathname = `${basePath}/workers/trigger`.replace(/\/+$/, "");
   return url.toString();
 }
+function getQueueStartUrl(queueId) {
+  const raw = process.env.WORKER_BASE_URL || process.env.WORKERS_TRIGGER_API_URL || process.env.WORKERS_CONFIG_API_URL;
+  if (!raw) {
+    throw new Error(
+      "WORKER_BASE_URL is required for background workers. Set it server-side only."
+    );
+  }
+  const url = new URL(raw);
+  url.search = "";
+  url.hash = "";
+  const path = url.pathname || "";
+  url.pathname = path.replace(/\/?workers\/(trigger|config)\/?$/, "");
+  const basePath = url.pathname.replace(/\/+$/, "");
+  const safeSegment = encodeURIComponent(queueId);
+  url.pathname = `${basePath}/queues/${safeSegment}/start`.replace(/\/+$/, "");
+  return url.toString();
+}
 function serializeContext(ctx) {
   const serialized = {};
   if (ctx.requestId) {
@@ -97,12 +118,75 @@ async function dispatch(workerId, input, inputSchema, options, ctx) {
     jobId
   };
 }
+async function dispatchWorker(workerId, input, options = {}, ctx) {
+  const jobId = options.jobId || `job-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  const triggerUrl = getWorkersTriggerUrl();
+  const serializedContext = ctx ? serializeContext(ctx) : {};
+  const messageBody = {
+    workerId,
+    jobId,
+    input: input ?? {},
+    context: serializedContext,
+    webhookUrl: options.webhookUrl,
+    metadata: options.metadata || {},
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const headers = { "Content-Type": "application/json" };
+  const triggerKey = process.env.WORKERS_TRIGGER_API_KEY;
+  if (triggerKey) headers["x-workers-trigger-key"] = triggerKey;
+  const response = await fetch(triggerUrl, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({ workerId, body: messageBody })
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(
+      `Failed to trigger worker "${workerId}": ${response.status} ${response.statusText}${text ? ` - ${text}` : ""}`
+    );
+  }
+  const data = await response.json().catch(() => ({}));
+  const messageId = data?.messageId ? String(data.messageId) : `trigger-${jobId}`;
+  return { messageId, status: "queued", jobId };
+}
 async function dispatchLocal(handler, input, ctx) {
   return handler({ input, ctx: ctx || {} });
 }
+async function dispatchQueue(queueId, initialInput, options = {}, _ctx) {
+  const jobId = options.jobId || `job-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  const queueStartUrl = getQueueStartUrl(queueId);
+  const normalizedInput = initialInput !== null && typeof initialInput === "object" ? initialInput : { value: initialInput };
+  const headers = { "Content-Type": "application/json" };
+  const triggerKey = process.env.WORKERS_TRIGGER_API_KEY;
+  if (triggerKey) headers["x-workers-trigger-key"] = triggerKey;
+  const response = await fetch(queueStartUrl, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({
+      input: normalizedInput,
+      initialInput: normalizedInput,
+      metadata: options.metadata ?? {},
+      jobId,
+      ...options.webhookUrl ? { webhookUrl: options.webhookUrl } : {}
+    })
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(
+      `Failed to start queue "${queueId}": ${response.status} ${response.statusText}${text ? ` - ${text}` : ""}`
+    );
+  }
+  const data = await response.json().catch(() => ({}));
+  const messageId = data?.messageId ?? data?.jobId ?? `queue-${jobId}`;
+  return { queueId, messageId, status: "queued", jobId };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   dispatch,
-  dispatchLocal
+  dispatchLocal,
+  dispatchQueue,
+  dispatchWorker,
+  getQueueStartUrl,
+  getWorkersTriggerUrl
 });
 //# sourceMappingURL=client.js.map