@lotiai/composer 0.2.0 → 0.2.2

package/dist/internal/async/register/workflow-worker.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Temporal Workflow Worker
+ *
+ * Registers and executes workflow orchestration logic in a deterministic sandbox.
+ * Accepts workflow definitions declaratively, generates workflow plans, writes a
+ * temporary source file, and lets Temporal's internal Webpack bundle it for the
+ * V8 sandbox.
+ *
+ * ## Workflow Worker Responsibilities:
+ * - Connect to Temporal Server
+ * - Generate WorkflowPlan objects from provided workflow definitions
+ * - Write a temp CJS file exporting workflow functions via createWorkflowFunction
+ * - Pass the temp file to Temporal's Webpack via workflowsPath
+ * - Execute workflow coordination (batch sequencing, parallel execution)
+ * - Schedule activities to appropriate task queues
+ *
+ * ## What Workflows CANNOT Do:
+ * - Access Node.js APIs (fs, http, process, etc.)
+ * - Use non-deterministic functions (Date.now(), Math.random(), crypto.randomBytes())
+ * - Make external API calls or database queries
+ * - Import business logic (all business logic runs in activities)
+ *
+ * @module workflow-worker
+ */
+import { NativeConnection, Worker } from "@temporalio/worker";
+import type { Workflow } from "../../dag-sync-workflow";
+import type { ComposerLogger } from "../../types";
+/**
+ * Configuration for the Workflow Worker.
+ */
+export interface WorkflowWorkerConfig {
+    /**
+     * Temporal Server address (e.g., "localhost:7233" for local dev)
+     * @default "localhost:7233"
+     */
+    serverAddress?: string;
+    /**
+     * Temporal namespace to connect to
+     * @default "default"
+     */
+    namespace?: string;
+    /**
+     * Task queue(s) to listen on for workflow tasks.
+     * All workflows are registered to the same queue(s).
+     * @default ["workflow-tasks"]
+     */
+    taskQueues?: string[];
+    /**
+     * Workflow definitions to register.
+     * Plans are generated from these at startup.
+     */
+    workflows: Workflow<any, any, any>[];
+    /**
+     * Maximum number of concurrent workflow executions
+     * @default 100
+     */
+    maxConcurrentWorkflowTaskExecutions?: number;
+    /**
+     * Deployment series name for Worker Versioning (e.g., "orders-service-workflows").
+     * Derived from the service name via getDeploymentSeriesNames().
+     */
+    deploymentSeriesName: string;
+    /**
+     * Build identifier for Worker Versioning (typically git commit SHA).
+     * When set, workers register with this buildId for version-aware routing.
+     * When unset, Worker Versioning is disabled.
+     */
+    buildId?: string;
+    /**
+     * Logger for worker lifecycle messages.
+     * If not provided, defaults to the console-based defaultLogger.
+     */
+    logger?: ComposerLogger;
+}
+/**
+ * Creates Temporal Workflow Workers with automatic connection management.
+ *
+ * At startup:
+ * 1. Generates WorkflowPlan objects from provided workflow definitions
+ * 2. Writes a temp CJS file with createWorkflowFunction calls
+ * 3. Passes the temp file to Temporal's Webpack via workflowsPath
+ * 4. Creates worker instances for the specified task queues
+ *
+ * @param config - Worker configuration
+ * @returns Object containing workers array and the created connection
+ *
+ * @example
+ * ```typescript
+ * const { workers, connection } = await createWorkflowWorkers({
+ *   workflows: [myWorkflow],
+ *   taskQueues: ["workflow-tasks"],
+ * });
+ *
+ * // Run workers
+ * await Promise.all(workers.map(w => w.run()));
+ *
+ * // Cleanup
+ * await Promise.all(workers.map(w => w.shutdown()));
+ * await connection.close();
+ * ```
+ */
+export declare function createWorkflowWorkers(config: WorkflowWorkerConfig): Promise<{
+    workers: Worker[];
+    connection: NativeConnection;
+}>;
+/**
+ * Starts Workflow Workers and runs them until interrupted.
+ *
+ * Creates a Temporal connection, initializes workers from provided workflows, and
+ * handles graceful shutdown on SIGINT/SIGTERM. The connection is automatically
+ * managed and closed on shutdown.
+ *
+ * @param config - Worker configuration
+ *
+ * @example
+ * ```typescript
+ * // Run workflow workers (blocks until interrupted)
+ * await runWorkflowWorkers({
+ *   workflows: [myWorkflow],
+ *   taskQueues: ["workflow-tasks"],
+ * });
+ * ```
+ */
+export declare function runWorkflowWorkers(config: WorkflowWorkerConfig): Promise<void>;
+//# sourceMappingURL=workflow-worker.d.ts.map

package/dist/internal/async/register/workflow-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-worker.d.ts","sourceRoot":"","sources":["../../../../src/internal/async/register/workflow-worker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAIH,OAAO,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAExD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAqBlD;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IAEvB;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IAEtB;;;OAGG;IACH,SAAS,EAAE,QAAQ,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC;IAErC;;;OAGG;IACH,mCAAmC,CAAC,EAAE,MAAM,CAAC;IAE7C;;;OAGG;IACH,oBAAoB,EAAE,MAAM,CAAC;IAE7B;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;;OAGG;IACH,MAAM,CAAC,EAAE,cAAc,CAAC;CACzB;AAYD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,oBAAoB,GAC3B,OAAO,CAAC;IAAE,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,UAAU,EAAE,gBAAgB,CAAA;CAAE,CAAC,CAsF9D;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,kBAAkB,CAAC,MAAM,EAAE,oBAAoB,GAAG,OAAO,CAAC,IAAI,CAAC,CAqCpF"}

package/dist/internal/async/register/workflow-worker.js

@@ -0,0 +1,215 @@
+"use strict";
+/**
+ * Temporal Workflow Worker
+ *
+ * Registers and executes workflow orchestration logic in a deterministic sandbox.
+ * Accepts workflow definitions declaratively, generates workflow plans, writes a
+ * temporary source file, and lets Temporal's internal Webpack bundle it for the
+ * V8 sandbox.
+ *
+ * ## Workflow Worker Responsibilities:
+ * - Connect to Temporal Server
+ * - Generate WorkflowPlan objects from provided workflow definitions
+ * - Write a temp CJS file exporting workflow functions via createWorkflowFunction
+ * - Pass the temp file to Temporal's Webpack via workflowsPath
+ * - Execute workflow coordination (batch sequencing, parallel execution)
+ * - Schedule activities to appropriate task queues
+ *
+ * ## What Workflows CANNOT Do:
+ * - Access Node.js APIs (fs, http, process, etc.)
+ * - Use non-deterministic functions (Date.now(), Math.random(), crypto.randomBytes())
+ * - Make external API calls or database queries
+ * - Import business logic (all business logic runs in activities)
+ *
+ * @module workflow-worker
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWorkflowWorkers = createWorkflowWorkers;
+exports.runWorkflowWorkers = runWorkflowWorkers;
+const node_path_1 = require("node:path");
+const common_1 = require("@temporalio/common");
+const worker_1 = require("@temporalio/worker");
+const defaults_1 = require("../../defaults");
+const generate_workflow_source_1 = require("./generate-workflow-source");
+/**
+ * Resolve the node_modules directory containing @temporalio/workflow.
+ *
+ * Temporal's workflow Worker uses webpack internally to bundle workflow code
+ * into a deterministic sandbox. Webpack needs to resolve `@temporalio/workflow`
+ * at bundle time, but pnpm's strict node_modules structure may not hoist it
+ * to the consumer's top-level node_modules. Since @lotiai/composer lists
+ * @temporalio/workflow as a direct dependency, require.resolve finds it from
+ * here. We pass this directory to webpack via bundlerOptions so it can resolve
+ * the package regardless of the consumer's package manager layout.
+ */
+function getTemporalWorkflowNodeModulesDir() {
+    const temporalWorkflowPkg = require.resolve("@temporalio/workflow/package.json");
+    // Go up from .../node_modules/@temporalio/workflow/package.json
+    // to .../node_modules (scoped package = 2 levels above the package dir)
+    return (0, node_path_1.resolve)((0, node_path_1.dirname)(temporalWorkflowPkg), "..", "..");
+}
+/**
+ * Default configuration for local development.
+ */
+const DEFAULT_CONFIG = {
+    serverAddress: "localhost:7233",
+    namespace: "default",
+    taskQueues: ["workflow-tasks"],
+    maxConcurrentWorkflowTaskExecutions: 100,
+};
+/**
+ * Creates Temporal Workflow Workers with automatic connection management.
+ *
+ * At startup:
+ * 1. Generates WorkflowPlan objects from provided workflow definitions
+ * 2. Writes a temp CJS file with createWorkflowFunction calls
+ * 3. Passes the temp file to Temporal's Webpack via workflowsPath
+ * 4. Creates worker instances for the specified task queues
+ *
+ * @param config - Worker configuration
+ * @returns Object containing workers array and the created connection
+ *
+ * @example
+ * ```typescript
+ * const { workers, connection } = await createWorkflowWorkers({
+ *   workflows: [myWorkflow],
+ *   taskQueues: ["workflow-tasks"],
+ * });
+ *
+ * // Run workers
+ * await Promise.all(workers.map(w => w.run()));
+ *
+ * // Cleanup
+ * await Promise.all(workers.map(w => w.shutdown()));
+ * await connection.close();
+ * ```
+ */
+async function createWorkflowWorkers(config) {
+    const logger = config.logger ?? defaults_1.defaultLogger;
+    const finalConfig = { ...DEFAULT_CONFIG, ...config };
+    const workflowCount = config.workflows.length;
+    logger.info("Creating Workflow Workers", {
+        server: finalConfig.serverAddress,
+        namespace: finalConfig.namespace,
+        taskQueues: finalConfig.taskQueues,
+        workflowCount,
+    });
+    const workflowsPath = await (0, generate_workflow_source_1.writeWorkflowSourceFile)(config.workflows);
+    logger.info("Workflow source file generated", { workflowsPath });
+    const connection = await worker_1.NativeConnection.connect({
+        address: finalConfig.serverAddress,
+    });
+    // TODO: This webpackConfigHook may no longer be necessary. It was added when
+    // the esbuild bundle lived in the consumer's dist/ and webpack resolved
+    // @temporalio/workflow from there (where it's not a direct dep). Now that
+    // workflow-factory.js is loaded via absolute path from @lotiai/composer (which
+    // has @temporalio/workflow as a direct dep), webpack should resolve it
+    // normally. Try removing the hook + getTemporalWorkflowNodeModulesDir and
+    // verify the workflow worker still starts.
+    const temporalNodeModulesDir = getTemporalWorkflowNodeModulesDir();
+    // Create workers for each task queue
+    // Note: Temporal requires one Worker per task queue, but they all load the same workflows
+    const workers = await Promise.all(finalConfig.taskQueues.map(async (taskQueue) => {
+        const worker = await worker_1.Worker.create({
+            connection,
+            namespace: finalConfig.namespace,
+            taskQueue,
+            workflowsPath,
+            maxConcurrentWorkflowTaskExecutions: finalConfig.maxConcurrentWorkflowTaskExecutions,
+            // Enable Build ID versioning for safe rainbow deploys when a git hash is available.
+            // PINNED ensures workflows started on a specific version continue using that version.
+            ...(config.buildId
+                ? {
+                    workerDeploymentOptions: {
+                        useWorkerVersioning: true,
+                        version: {
+                            deploymentName: config.deploymentSeriesName,
+                            buildId: config.buildId,
+                        },
+                        defaultVersioningBehavior: common_1.VersioningBehavior.PINNED,
+                    },
+                }
+                : {}),
+            bundlerOptions: {
+                // Tell webpack where to find @temporalio/workflow. Without this, pnpm's
+                // strict node_modules layout prevents webpack from resolving it when the
+                // workflow source file lives in the consumer's dist/ directory.
+                webpackConfigHook: (config) => {
+                    config.resolve = config.resolve ?? {};
+                    const modules = config.resolve.modules ?? [];
+                    if (!modules.includes(temporalNodeModulesDir)) {
+                        modules.push(temporalNodeModulesDir);
+                    }
+                    config.resolve.modules = modules;
+                    return config;
+                },
+            },
+        });
+        logger.info("Worker created for task queue", { taskQueue, namespace: finalConfig.namespace });
+        return worker;
+    }));
+    // Return all workers (caller must run them all)
+    if (workers.length === 0) {
+        throw new Error("No task queues configured - cannot create workers");
+    }
+    logger.info("Workflow Workers ready", {
+        taskQueues: finalConfig.taskQueues,
+        workerCount: workers.length,
+        workflowCount,
+    });
+    return { workers, connection };
+}
+/**
+ * Starts Workflow Workers and runs them until interrupted.
+ *
+ * Creates a Temporal connection, initializes workers from provided workflows, and
+ * handles graceful shutdown on SIGINT/SIGTERM. The connection is automatically
+ * managed and closed on shutdown.
+ *
+ * @param config - Worker configuration
+ *
+ * @example
+ * ```typescript
+ * // Run workflow workers (blocks until interrupted)
+ * await runWorkflowWorkers({
+ *   workflows: [myWorkflow],
+ *   taskQueues: ["workflow-tasks"],
+ * });
+ * ```
+ */
+async function runWorkflowWorkers(config) {
+    const logger = config.logger ?? defaults_1.defaultLogger;
+    const { workers, connection } = await createWorkflowWorkers(config);
+    // Setup graceful shutdown for all workers
+    let isShuttingDown = false;
+    const shutdown = async () => {
+        if (isShuttingDown)
+            return; // Prevent duplicate shutdown
+        isShuttingDown = true;
+        logger.info("Shutting down Workflow Workers", { workerCount: workers.length });
+        await Promise.all(workers.map((worker) => worker.shutdown()));
+        await connection.close();
+        logger.info("Workflow Workers shutdown complete");
+        // TODO: process.exit(0) here makes this function non-composable when multiple
+        // worker types run in the same process (e.g., startAllWorkers). Consider
+        // returning cleanly and letting the caller control process exit. Look for:
+        // the Promise.all in startAllWorkers resolving naturally after shutdown,
+        // rather than racing on process.exit(0). Not urgent since production
+        // always uses separate containers and local dev handles this via Temporal
+        // server-side task retries.
+        process.exit(0);
+    };
+    process.on("SIGINT", () => void shutdown());
+    process.on("SIGTERM", () => void shutdown());
+    // Run all workers in parallel
+    try {
+        await Promise.all(workers.map((worker) => worker.run()));
+    }
+    catch (error) {
+        logger.error("Workflow Workers error", {
+            error: error instanceof Error ? error.message : String(error),
+        });
+        throw error;
+    }
+}
+//# sourceMappingURL=workflow-worker.js.map

package/dist/internal/async/register/workflow-worker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-worker.js","sourceRoot":"","sources":["../../../../src/internal/async/register/workflow-worker.ts"],"names":[],"mappings":"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"}

package/dist/internal/async/register-scripts/start-activity-worker.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Start Activity Worker
+ *
+ * Generic framework function that starts Temporal Activity Workers from a
+ * configured Composer instance. The Composer provides the Temporal connection
+ * config (server address, namespace), context provider, and logger.
+ *
+ * The caller is responsible for determining task queues and concurrency settings
+ * (e.g., from environment variables, worker profiles, or hardcoded defaults).
+ *
+ * ## Usage:
+ *
+ * ```typescript
+ * import { startActivityWorker } from "@lotiai/composer";
+ * import { composer } from "./my-app-composer";
+ *
+ * await startActivityWorker(composer, {
+ *   taskQueues: ["standard-tasks"],
+ *   maxConcurrentActivityTaskExecutions: 15,
+ * });
+ * ```
+ *
+ * @module start-activity-worker
+ */
+import type { Composer } from "../../context-provider";
+import type { Workflow } from "../../dag-sync-workflow";
+/**
+ * Options for starting an activity worker.
+ */
+export interface StartActivityWorkerOptions {
+    /**
+     * Task queues to listen on for activity tasks.
+     */
+    taskQueues: string[];
+    /**
+     * Maximum number of concurrent activity executions per queue.
+     */
+    maxConcurrentActivityTaskExecutions: number;
+    /**
+     * Workflow definitions to register. Steps are extracted from these.
+     */
+    workflows: Workflow<any, any, any>[];
+    /**
+     * Whether to ensure the Temporal namespace exists before starting workers.
+     * Useful for local development where the namespace may not exist yet.
+     *
+     * @default true
+     */
+    ensureNamespace?: boolean;
+}
+/**
+ * Starts Temporal Activity Workers using a configured Composer instance.
+ *
+ * This function:
+ * 1. Optionally ensures the Temporal namespace exists (idempotent)
+ * 2. Logs the worker configuration
+ * 3. Delegates to `composer.runActivityWorkers()` which handles worker lifecycle
+ *    (connection, bundle loading, shutdown signals)
+ * 4. Exits with code 1 on failure
+ *
+ * The Composer instance provides:
+ * - Temporal server address and namespace (from its temporal config)
+ * - Context provider (for step execution lifecycle)
+ * - Logger (for structured log output)
+ *
+ * @param composer - A fully configured Composer instance (must have temporal config)
+ * @param options - Worker startup options (task queues, concurrency)
+ */
+export declare function startActivityWorker<TContext>(composer: Composer<TContext>, options: StartActivityWorkerOptions): Promise<void>;
+//# sourceMappingURL=start-activity-worker.d.ts.map

package/dist/internal/async/register-scripts/start-activity-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"start-activity-worker.d.ts","sourceRoot":"","sources":["../../../../src/internal/async/register-scripts/start-activity-worker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAGxD;;GAEG;AACH,MAAM,WAAW,0BAA0B;IACzC;;OAEG;IACH,UAAU,EAAE,MAAM,EAAE,CAAC;IAErB;;OAEG;IACH,mCAAmC,EAAE,MAAM,CAAC;IAE5C;;OAEG;IACH,SAAS,EAAE,QAAQ,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC;IAErC;;;;;OAKG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,mBAAmB,CAAC,QAAQ,EAChD,QAAQ,EAAE,QAAQ,CAAC,QAAQ,CAAC,EAC5B,OAAO,EAAE,0BAA0B,GAClC,OAAO,CAAC,IAAI,CAAC,CA6Bf"}

package/dist/internal/async/register-scripts/start-activity-worker.js

@@ -0,0 +1,75 @@
+"use strict";
+/**
+ * Start Activity Worker
+ *
+ * Generic framework function that starts Temporal Activity Workers from a
+ * configured Composer instance. The Composer provides the Temporal connection
+ * config (server address, namespace), context provider, and logger.
+ *
+ * The caller is responsible for determining task queues and concurrency settings
+ * (e.g., from environment variables, worker profiles, or hardcoded defaults).
+ *
+ * ## Usage:
+ *
+ * ```typescript
+ * import { startActivityWorker } from "@lotiai/composer";
+ * import { composer } from "./my-app-composer";
+ *
+ * await startActivityWorker(composer, {
+ *   taskQueues: ["standard-tasks"],
+ *   maxConcurrentActivityTaskExecutions: 15,
+ * });
+ * ```
+ *
+ * @module start-activity-worker
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startActivityWorker = startActivityWorker;
+const ensure_namespace_1 = require("../utils/ensure-namespace");
+/**
+ * Starts Temporal Activity Workers using a configured Composer instance.
+ *
+ * This function:
+ * 1. Optionally ensures the Temporal namespace exists (idempotent)
+ * 2. Logs the worker configuration
+ * 3. Delegates to `composer.runActivityWorkers()` which handles worker lifecycle
+ *    (connection, bundle loading, shutdown signals)
+ * 4. Exits with code 1 on failure
+ *
+ * The Composer instance provides:
+ * - Temporal server address and namespace (from its temporal config)
+ * - Context provider (for step execution lifecycle)
+ * - Logger (for structured log output)
+ *
+ * @param composer - A fully configured Composer instance (must have temporal config)
+ * @param options - Worker startup options (task queues, concurrency)
+ */
+async function startActivityWorker(composer, options) {
+    const logger = composer.logger;
+    const { serverAddress, namespace } = composer.temporal;
+    logger.info("Starting Activity Workers", {
+        serverAddress,
+        namespace,
+        taskQueues: options.taskQueues,
+        maxConcurrentActivityTaskExecutions: options.maxConcurrentActivityTaskExecutions,
+        ensureNamespace: options.ensureNamespace ?? true,
+    });
+    try {
+        // Ensure namespace exists before starting workers (idempotent)
+        if (options.ensureNamespace !== false) {
+            await (0, ensure_namespace_1.ensureNamespaceExists)(serverAddress, namespace);
+        }
+        await composer.runActivityWorkers({
+            taskQueues: options.taskQueues,
+            maxConcurrentActivityTaskExecutions: options.maxConcurrentActivityTaskExecutions,
+            workflows: options.workflows,
+        });
+    }
+    catch (error) {
+        logger.error("Failed to start Activity Workers", {
+            error: error instanceof Error ? error.message : String(error),
+        });
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=start-activity-worker.js.map

package/dist/internal/async/register-scripts/start-activity-worker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"start-activity-worker.js","sourceRoot":"","sources":["../../../../src/internal/async/register-scripts/start-activity-worker.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;;AAoDH,kDAgCC;AAhFD,gEAAkE;AA8BlE;;;;;;;;;;;;;;;;;GAiBG;AACI,KAAK,UAAU,mBAAmB,CACvC,QAA4B,EAC5B,OAAmC;IAEnC,MAAM,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC;IAC/B,MAAM,EAAE,aAAa,EAAE,SAAS,EAAE,GAAG,QAAQ,CAAC,QAAQ,CAAC;IAEvD,MAAM,CAAC,IAAI,CAAC,2BAA2B,EAAE;QACvC,aAAa;QACb,SAAS;QACT,UAAU,EAAE,OAAO,CAAC,UAAU;QAC9B,mCAAmC,EAAE,OAAO,CAAC,mCAAmC;QAChF,eAAe,EAAE,OAAO,CAAC,eAAe,IAAI,IAAI;KACjD,CAAC,CAAC;IAEH,IAAI,CAAC;QACH,+DAA+D;QAC/D,IAAI,OAAO,CAAC,eAAe,KAAK,KAAK,EAAE,CAAC;YACtC,MAAM,IAAA,wCAAqB,EAAC,aAAa,EAAE,SAAS,CAAC,CAAC;QACxD,CAAC;QAED,MAAM,QAAQ,CAAC,kBAAkB,CAAC;YAChC,UAAU,EAAE,OAAO,CAAC,UAAU;YAC9B,mCAAmC,EAAE,OAAO,CAAC,mCAAmC;YAChF,SAAS,EAAE,OAAO,CAAC,SAAS;SAC7B,CAAC,CAAC;IACL,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,CAAC,KAAK,CAAC,kCAAkC,EAAE;YAC/C,KAAK,EAAE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC;SAC9D,CAAC,CAAC;QACH,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAClB,CAAC;AACH,CAAC"}

package/dist/internal/async/register-scripts/start-all-workers.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Start All Workers
+ *
+ * Generic framework function that starts both Temporal Workflow Workers and
+ * Activity Workers in parallel from a configured Composer instance. This is a
+ * convenience function for local development when you want to run the entire
+ * worker system in a single process.
+ *
+ * ## Usage:
+ *
+ * ```typescript
+ * import { startAllWorkers } from "@lotiai/composer";
+ * import { composer } from "./my-app-composer";
+ * import { myWorkflow } from "./workflows/my-workflow";
+ *
+ * await startAllWorkers(composer, {
+ *   workflows: [myWorkflow],
+ *   workflow: {
+ *     taskQueues: ["workflow-tasks"],
+ *     maxConcurrentWorkflowTaskExecutions: 100,
+ *   },
+ *   activity: {
+ *     taskQueues: ["standard-tasks"],
+ *     maxConcurrentActivityTaskExecutions: 15,
+ *   },
+ * });
+ * ```
+ *
+ * ## Note:
+ *
+ * In production, you would typically run these workers in separate containers/processes
+ * to enable independent scaling and deployment. This function is primarily for
+ * local development convenience.
+ *
+ * @module start-all-workers
+ */
+import type { Composer } from "../../context-provider";
+import type { Workflow } from "../../dag-sync-workflow";
+import { type StartActivityWorkerOptions } from "./start-activity-worker";
+import { type StartWorkflowWorkerOptions } from "./start-workflow-worker";
+/**
+ * Options for starting all workers (workflow + activity) in a single process.
+ */
+export interface StartAllWorkersOptions {
+    /**
+     * Workflow definitions shared by both workers.
+     * Activity worker extracts steps; workflow worker generates plans.
+     */
+    workflows: Workflow<any, any, any>[];
+    /**
+     * Options for the workflow worker (task queues, concurrency).
+     * The `ensureNamespace` and `workflows` options are controlled at the top level.
+     */
+    workflow: Omit<StartWorkflowWorkerOptions, "ensureNamespace" | "workflows">;
+    /**
+     * Options for the activity worker (task queues, concurrency).
+     * The `ensureNamespace` and `workflows` options are controlled at the top level.
+     */
+    activity: Omit<StartActivityWorkerOptions, "ensureNamespace" | "workflows">;
+    /**
+     * Whether to ensure the Temporal namespace exists before starting workers.
+     * When true, the namespace check is performed once before starting both workers.
+     *
+     * @default true
+     */
+    ensureNamespace?: boolean;
+}
+/**
+ * Starts both Temporal Workflow Workers and Activity Workers in parallel
+ * using a configured Composer instance.
+ *
+ * This function:
+ * 1. Optionally ensures the Temporal namespace exists (once, not per worker)
+ * 2. Logs the combined worker configuration
+ * 3. Delegates to `startWorkflowWorker()` and `startActivityWorker()` via `Promise.all`
+ *
+ * @param composer - A fully configured Composer instance (must have temporal config)
+ * @param options - Combined worker startup options
+ */
+export declare function startAllWorkers<TContext>(composer: Composer<TContext>, options: StartAllWorkersOptions): Promise<void>;
+//# sourceMappingURL=start-all-workers.d.ts.map

package/dist/internal/async/register-scripts/start-all-workers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"start-all-workers.d.ts","sourceRoot":"","sources":["../../../../src/internal/async/register-scripts/start-all-workers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAExD,OAAO,EAAE,KAAK,0BAA0B,EAAuB,MAAM,yBAAyB,CAAC;AAC/F,OAAO,EAAE,KAAK,0BAA0B,EAAuB,MAAM,yBAAyB,CAAC;AAE/F;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC;;;OAGG;IACH,SAAS,EAAE,QAAQ,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC;IAErC;;;OAGG;IACH,QAAQ,EAAE,IAAI,CAAC,0BAA0B,EAAE,iBAAiB,GAAG,WAAW,CAAC,CAAC;IAE5E;;;OAGG;IACH,QAAQ,EAAE,IAAI,CAAC,0BAA0B,EAAE,iBAAiB,GAAG,WAAW,CAAC,CAAC;IAE5E;;;;;OAKG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,eAAe,CAAC,QAAQ,EAC5C,QAAQ,EAAE,QAAQ,CAAC,QAAQ,CAAC,EAC5B,OAAO,EAAE,sBAAsB,GAC9B,OAAO,CAAC,IAAI,CAAC,CA+Bf"}