@lotiai/composer 0.2.0 → 0.2.1

package/dist/internal/async/build-scripts/utils/import-module.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Shared dynamic module import utility.
+ *
+ * Handles the fragile import logic needed for both compiled JS (dist/) and
+ * TypeScript (src/) environments, including require.cache invalidation and
+ * ESM cache-busting. Extracted so that all definition collectors share a
+ * single implementation and don't drift.
+ *
+ * @module import-module
+ */
+/**
+ * Dynamically imports a TypeScript/JavaScript module with proper cache handling.
+ *
+ * - In compiled JS environments: rewrites `src/` to `dist/` and `.ts` to `.js`,
+ *   then clears `require.cache` before importing.
+ * - In ESM/tsx environments: appends a cache-busting query parameter.
+ */
+export declare function importModuleFromFile(filePath: string): Promise<Record<string, unknown>>;
+//# sourceMappingURL=import-module.d.ts.map

package/dist/internal/async/build-scripts/utils/import-module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-module.d.ts","sourceRoot":"","sources":["../../../../../src/internal/async/build-scripts/utils/import-module.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH;;;;;;GAMG;AACH,wBAAsB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CA4B7F"}

package/dist/internal/async/build-scripts/utils/import-module.js

@@ -0,0 +1,80 @@
+"use strict";
+/**
+ * Shared dynamic module import utility.
+ *
+ * Handles the fragile import logic needed for both compiled JS (dist/) and
+ * TypeScript (src/) environments, including require.cache invalidation and
+ * ESM cache-busting. Extracted so that all definition collectors share a
+ * single implementation and don't drift.
+ *
+ * @module import-module
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.importModuleFromFile = importModuleFromFile;
+const node_path_1 = require("node:path");
+/**
+ * Dynamically imports a TypeScript/JavaScript module with proper cache handling.
+ *
+ * - In compiled JS environments: rewrites `src/` to `dist/` and `.ts` to `.js`,
+ *   then clears `require.cache` before importing.
+ * - In ESM/tsx environments: appends a cache-busting query parameter.
+ */
+async function importModuleFromFile(filePath) {
+    let absolutePath = (0, node_path_1.resolve)(filePath);
+    const isCompiledJs = __filename.endsWith(".js");
+    const isNodeEnv = typeof require !== "undefined" && typeof require.cache !== "undefined";
+    const shouldUseRequireCache = isCompiledJs || isNodeEnv;
+    if (isCompiledJs) {
+        const lastSrcIdx = absolutePath.lastIndexOf("/src/");
+        if (lastSrcIdx !== -1) {
+            absolutePath = `${absolutePath.substring(0, lastSrcIdx)}/dist/${absolutePath.substring(lastSrcIdx + 5)}`;
+        }
+        absolutePath = absolutePath.replace(/\.ts$/, ".js");
+    }
+    if (shouldUseRequireCache) {
+        const resolvedPath = require.resolve(absolutePath);
+        delete require.cache[resolvedPath];
+        for (const key of Object.keys(require.cache)) {
+            if (key === absolutePath || key === resolvedPath) {
+                delete require.cache[key];
+            }
+        }
+        return await Promise.resolve(`${absolutePath}`).then(s => __importStar(require(s)));
+    }
+    const cacheBuster = `?t=${Date.now()}`;
+    return await Promise.resolve(`${`${absolutePath}${cacheBuster}`}`).then(s => __importStar(require(s)));
+}
+//# sourceMappingURL=import-module.js.map

package/dist/internal/async/build-scripts/utils/import-module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-module.js","sourceRoot":"","sources":["../../../../../src/internal/async/build-scripts/utils/import-module.ts"],"names":[],"mappings":";AAAA;;;;;;;;;GASG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAWH,oDA4BC;AArCD,yCAAoC;AAEpC;;;;;;GAMG;AACI,KAAK,UAAU,oBAAoB,CAAC,QAAgB;IACzD,IAAI,YAAY,GAAG,IAAA,mBAAO,EAAC,QAAQ,CAAC,CAAC;IAErC,MAAM,YAAY,GAAG,UAAU,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IAChD,MAAM,SAAS,GAAG,OAAO,OAAO,KAAK,WAAW,IAAI,OAAO,OAAO,CAAC,KAAK,KAAK,WAAW,CAAC;IACzF,MAAM,qBAAqB,GAAG,YAAY,IAAI,SAAS,CAAC;IAExD,IAAI,YAAY,EAAE,CAAC;QACjB,MAAM,UAAU,GAAG,YAAY,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;QACrD,IAAI,UAAU,KAAK,CAAC,CAAC,EAAE,CAAC;YACtB,YAAY,GAAG,GAAG,YAAY,CAAC,SAAS,CAAC,CAAC,EAAE,UAAU,CAAC,SAAS,YAAY,CAAC,SAAS,CAAC,UAAU,GAAG,CAAC,CAAC,EAAE,CAAC;QAC3G,CAAC;QACD,YAAY,GAAG,YAAY,CAAC,OAAO,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;IACtD,CAAC;IAED,IAAI,qBAAqB,EAAE,CAAC;QAC1B,MAAM,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC;QACnD,OAAO,OAAO,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;QACnC,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;YAC7C,IAAI,GAAG,KAAK,YAAY,IAAI,GAAG,KAAK,YAAY,EAAE,CAAC;gBACjD,OAAO,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;YAC5B,CAAC;QACH,CAAC;QACD,OAAO,yBAAa,YAAY,uCAAC,CAAC;IACpC,CAAC;IAED,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC;IACvC,OAAO,yBAAa,GAAG,YAAY,GAAG,WAAW,EAAE,uCAAC,CAAC;AACvD,CAAC"}

package/dist/internal/async/build-scripts/utils/type-guards.d.ts

@@ -0,0 +1,123 @@
+/**
+ * Type Guards for Step and Workflow Definitions
+ *
+ * Provides runtime type guards for validating step and workflow definitions
+ * during build-time file scanning and dynamic module loading.
+ *
+ * ## Purpose
+ *
+ * These type guards are used by the build system to:
+ * 1. Distinguish valid step/workflow exports from other exported values
+ * 2. Filter out helper functions, constants, and types during collection
+ * 3. Validate that dynamically imported modules contain properly structured definitions
+ *
+ * ## Usage
+ *
+ * ```typescript
+ * import { isStep, isWorkflow } from './type-guards';
+ *
+ * // During file scanning
+ * const module = await import('./some-file.ts');
+ * for (const value of Object.values(module)) {
+ *   if (isStep(value)) {
+ *     console.log('Found step:', value.name);
+ *   } else if (isWorkflow(value)) {
+ *     console.log('Found workflow:', value.name);
+ *   }
+ * }
+ * ```
+ *
+ * ## Type Guard Criteria
+ *
+ * ### Step Definition
+ * A valid step must have:
+ * - `name` (string): Unique identifier
+ * - `needs` (array): Input dependencies
+ * - `provides` (array): Output fields
+ * - `run` (function): Execution logic
+ *
+ * ### Workflow Definition
+ * A valid workflow must have:
+ * - `name` (string): Unique identifier
+ * - `steps` (array): Step sequence
+ * - `requiredInitial` (array or undefined): Optional initial data requirements
+ *
+ * ## Implementation Notes
+ *
+ * These type guards intentionally use `any` types because they operate on
+ * dynamically loaded module exports where the actual types are not known
+ * until runtime. The guards perform structural validation to ensure the
+ * objects match the expected Step/Workflow interface shape.
+ */
+import type { FanOutMetadata } from "../../../dag-sync-fanout";
+import type { Step } from "../../../dag-sync-step";
+import type { Workflow } from "../../../dag-sync-workflow";
+import type { ScheduleDefinition } from "../../schedule/define-schedule";
+/**
+ * Type guard to check if a value is a step definition.
+ *
+ * Validates that the value has all required step properties:
+ * - name (string)
+ * - needs (array)
+ * - provides (array)
+ * - run (function)
+ *
+ * @param value - Value to check
+ * @returns True if the value is a valid Step definition
+ *
+ * @example
+ * ```typescript
+ * const exported = { name: 'myStep', needs: [], provides: ['result'], run: async () => {} };
+ * if (isStep(exported)) {
+ *   console.log('Valid step:', exported.name);
+ * }
+ * ```
+ */
+export declare function isStep(value: any): value is Step<any, any, any>;
+/**
+ * Type guard to check if a value is a workflow definition.
+ *
+ * Validates that the value has all required workflow properties:
+ * - name (string)
+ * - steps (array)
+ * - requiredInitial (array OR undefined - this field is optional)
+ *
+ * Note: `requiredInitial` is optional in the Workflow type definition.
+ * Workflows that consist only of independent steps or steps that depend
+ * on each other's outputs don't require initial data.
+ *
+ * @param value - Value to check
+ * @returns True if the value is a valid Workflow definition
+ *
+ * @example
+ * ```typescript
+ * // Workflow with required initial data
+ * const wf1 = { name: 'myWorkflow', steps: [], requiredInitial: ['input'] };
+ * console.log(isWorkflow(wf1)); // true
+ *
+ * // Workflow without required initial data
+ * const wf2 = { name: 'independentWorkflow', steps: [] };
+ * console.log(isWorkflow(wf2)); // true (requiredInitial is optional)
+ * ```
+ */
+/**
+ * Type guard to check if a value is a FanOut step definition.
+ *
+ * A FanOut is a Step that also has a `__fanOut` metadata object containing
+ * childWorkflow, mapInput, aggregateResults, and concurrency.
+ */
+export declare function isFanOut(value: any): value is Step<any, any, any> & {
+    __fanOut: FanOutMetadata;
+};
+export declare function isWorkflow(value: any): value is Workflow<any, any, any>;
+/**
+ * Type guard to check if a value is a schedule definition.
+ *
+ * Validates that the value has the `__scheduleDefinition` marker
+ * and required schedule properties.
+ *
+ * @param value - Value to check
+ * @returns True if the value is a valid ScheduleDefinition
+ */
+export declare function isScheduleDefinition(value: unknown): value is ScheduleDefinition;
+//# sourceMappingURL=type-guards.d.ts.map

package/dist/internal/async/build-scripts/utils/type-guards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-guards.d.ts","sourceRoot":"","sources":["../../../../../src/internal/async/build-scripts/utils/type-guards.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,wBAAwB,CAAC;AACnD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAEzE;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,GAAG,GAAG,KAAK,IAAI,IAAI,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAS/D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,GAAG,GAAG,KAAK,IAAI,IAAI,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,GAAG;IAAE,QAAQ,EAAE,cAAc,CAAA;CAAE,CAEhG;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,GAAG,GAAG,KAAK,IAAI,QAAQ,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAQvE;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,kBAAkB,CAShF"}

package/dist/internal/async/build-scripts/utils/type-guards.js

@@ -0,0 +1,145 @@
+"use strict";
+/**
+ * Type Guards for Step and Workflow Definitions
+ *
+ * Provides runtime type guards for validating step and workflow definitions
+ * during build-time file scanning and dynamic module loading.
+ *
+ * ## Purpose
+ *
+ * These type guards are used by the build system to:
+ * 1. Distinguish valid step/workflow exports from other exported values
+ * 2. Filter out helper functions, constants, and types during collection
+ * 3. Validate that dynamically imported modules contain properly structured definitions
+ *
+ * ## Usage
+ *
+ * ```typescript
+ * import { isStep, isWorkflow } from './type-guards';
+ *
+ * // During file scanning
+ * const module = await import('./some-file.ts');
+ * for (const value of Object.values(module)) {
+ *   if (isStep(value)) {
+ *     console.log('Found step:', value.name);
+ *   } else if (isWorkflow(value)) {
+ *     console.log('Found workflow:', value.name);
+ *   }
+ * }
+ * ```
+ *
+ * ## Type Guard Criteria
+ *
+ * ### Step Definition
+ * A valid step must have:
+ * - `name` (string): Unique identifier
+ * - `needs` (array): Input dependencies
+ * - `provides` (array): Output fields
+ * - `run` (function): Execution logic
+ *
+ * ### Workflow Definition
+ * A valid workflow must have:
+ * - `name` (string): Unique identifier
+ * - `steps` (array): Step sequence
+ * - `requiredInitial` (array or undefined): Optional initial data requirements
+ *
+ * ## Implementation Notes
+ *
+ * These type guards intentionally use `any` types because they operate on
+ * dynamically loaded module exports where the actual types are not known
+ * until runtime. The guards perform structural validation to ensure the
+ * objects match the expected Step/Workflow interface shape.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isStep = isStep;
+exports.isFanOut = isFanOut;
+exports.isWorkflow = isWorkflow;
+exports.isScheduleDefinition = isScheduleDefinition;
+/**
+ * Type guard to check if a value is a step definition.
+ *
+ * Validates that the value has all required step properties:
+ * - name (string)
+ * - needs (array)
+ * - provides (array)
+ * - run (function)
+ *
+ * @param value - Value to check
+ * @returns True if the value is a valid Step definition
+ *
+ * @example
+ * ```typescript
+ * const exported = { name: 'myStep', needs: [], provides: ['result'], run: async () => {} };
+ * if (isStep(exported)) {
+ *   console.log('Valid step:', exported.name);
+ * }
+ * ```
+ */
+function isStep(value) {
+    return (value &&
+        typeof value === "object" &&
+        typeof value.name === "string" &&
+        Array.isArray(value.needs) &&
+        Array.isArray(value.provides) &&
+        typeof value.run === "function");
+}
+/**
+ * Type guard to check if a value is a workflow definition.
+ *
+ * Validates that the value has all required workflow properties:
+ * - name (string)
+ * - steps (array)
+ * - requiredInitial (array OR undefined - this field is optional)
+ *
+ * Note: `requiredInitial` is optional in the Workflow type definition.
+ * Workflows that consist only of independent steps or steps that depend
+ * on each other's outputs don't require initial data.
+ *
+ * @param value - Value to check
+ * @returns True if the value is a valid Workflow definition
+ *
+ * @example
+ * ```typescript
+ * // Workflow with required initial data
+ * const wf1 = { name: 'myWorkflow', steps: [], requiredInitial: ['input'] };
+ * console.log(isWorkflow(wf1)); // true
+ *
+ * // Workflow without required initial data
+ * const wf2 = { name: 'independentWorkflow', steps: [] };
+ * console.log(isWorkflow(wf2)); // true (requiredInitial is optional)
+ * ```
+ */
+/**
+ * Type guard to check if a value is a FanOut step definition.
+ *
+ * A FanOut is a Step that also has a `__fanOut` metadata object containing
+ * childWorkflow, mapInput, aggregateResults, and concurrency.
+ */
+function isFanOut(value) {
+    return isStep(value) && "__fanOut" in value && value.__fanOut != null;
+}
+function isWorkflow(value) {
+    return (value &&
+        typeof value === "object" &&
+        typeof value.name === "string" &&
+        Array.isArray(value.steps) &&
+        (Array.isArray(value.requiredInitial) || value.requiredInitial === undefined));
+}
+/**
+ * Type guard to check if a value is a schedule definition.
+ *
+ * Validates that the value has the `__scheduleDefinition` marker
+ * and required schedule properties.
+ *
+ * @param value - Value to check
+ * @returns True if the value is a valid ScheduleDefinition
+ */
+function isScheduleDefinition(value) {
+    return (value != null &&
+        typeof value === "object" &&
+        value.__scheduleDefinition === true &&
+        typeof value.scheduleId === "string" &&
+        typeof value.workflowName === "string" &&
+        value.spec != null);
+}
+//# sourceMappingURL=type-guards.js.map

package/dist/internal/async/build-scripts/utils/type-guards.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-guards.js","sourceRoot":"","sources":["../../../../../src/internal/async/build-scripts/utils/type-guards.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;;AA2BH,wBASC;AAkCD,4BAEC;AAED,gCAQC;AAWD,oDASC;AA/FD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,SAAgB,MAAM,CAAC,KAAU;IAC/B,OAAO,CACL,KAAK;QACL,OAAO,KAAK,KAAK,QAAQ;QACzB,OAAO,KAAK,CAAC,IAAI,KAAK,QAAQ;QAC9B,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC;QAC1B,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,QAAQ,CAAC;QAC7B,OAAO,KAAK,CAAC,GAAG,KAAK,UAAU,CAChC,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH;;;;;GAKG;AACH,SAAgB,QAAQ,CAAC,KAAU;IACjC,OAAO,MAAM,CAAC,KAAK,CAAC,IAAI,UAAU,IAAI,KAAK,IAAI,KAAK,CAAC,QAAQ,IAAI,IAAI,CAAC;AACxE,CAAC;AAED,SAAgB,UAAU,CAAC,KAAU;IACnC,OAAO,CACL,KAAK;QACL,OAAO,KAAK,KAAK,QAAQ;QACzB,OAAO,KAAK,CAAC,IAAI,KAAK,QAAQ;QAC9B,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC;QAC1B,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,eAAe,CAAC,IAAI,KAAK,CAAC,eAAe,KAAK,SAAS,CAAC,CAC9E,CAAC;AACJ,CAAC;AAED;;;;;;;;GAQG;AACH,SAAgB,oBAAoB,CAAC,KAAc;IACjD,OAAO,CACL,KAAK,IAAI,IAAI;QACb,OAAO,KAAK,KAAK,QAAQ;QACxB,KAAiC,CAAC,oBAAoB,KAAK,IAAI;QAChE,OAAQ,KAAiC,CAAC,UAAU,KAAK,QAAQ;QACjE,OAAQ,KAAiC,CAAC,YAAY,KAAK,QAAQ;QAClE,KAAiC,CAAC,IAAI,IAAI,IAAI,CAChD,CAAC;AACJ,CAAC"}

package/dist/internal/async/config/cleanup-policy.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Cleanup Policy Configuration
+ *
+ * Defines rules for cleaning up old composer bundles from S3.
+ * This policy helps manage storage costs while preserving bundles
+ * needed for in-flight workflows.
+ */
+/**
+ * Cleanup policy for managing composer bundle retention in S3.
+ *
+ * There are two types of bundles:
+ * - **Version bundles**: Individual builds by git hash (e.g., workflow-bundle-abc1234.js)
+ *   Governed by: minimumRetentionDays, gracePeriodHours, forceKeepHashes
+ * - **Merged bundles**: Combined bundles containing multiple versions (e.g., merged-workflow-bundle.js)
+ *   Governed by: maxMergedBundlesToKeep
+ */
+export interface CleanupPolicy {
+    /**
+     * Minimum number of days to retain a version bundle before considering deletion.
+     * Version bundles newer than this are always kept regardless of other factors.
+     * Only applies to version bundles (per git hash), not merged bundles.
+     */
+    minimumRetentionDays: number;
+    /**
+     * Git hashes that should never be deleted, regardless of age or activity.
+     * Useful for pinning specific production versions or important releases.
+     * Only applies to version bundles.
+     */
+    forceKeepHashes: string[];
+    /**
+     * Number of hours after a workflow becomes inactive before its version bundle
+     * can be deleted (assuming minimumRetentionDays has passed).
+     * This grace period prevents premature deletion of recently-completed workflows.
+     * Only applies to version bundles.
+     */
+    gracePeriodHours: number;
+    /**
+     * Maximum number of merged bundles to keep in S3.
+     * Older merged bundles are deleted first (FIFO).
+     * This enables fast rollback to recent versions.
+     * Only applies to merged bundles, not version bundles.
+     * Note: Does not respect minimumRetentionDays - purely count-based.
+     */
+    maxMergedBundlesToKeep: number;
+}
+/**
+ * Cleanup policy for composer bundles
+ */
+export declare const CLEANUP_POLICY: CleanupPolicy;
+//# sourceMappingURL=cleanup-policy.d.ts.map

package/dist/internal/async/config/cleanup-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cleanup-policy.d.ts","sourceRoot":"","sources":["../../../../src/internal/async/config/cleanup-policy.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;;;;;GAQG;AACH,MAAM,WAAW,aAAa;IAC5B;;;;OAIG;IACH,oBAAoB,EAAE,MAAM,CAAC;IAE7B;;;;OAIG;IACH,eAAe,EAAE,MAAM,EAAE,CAAC;IAE1B;;;;;OAKG;IACH,gBAAgB,EAAE,MAAM,CAAC;IAEzB;;;;;;OAMG;IACH,sBAAsB,EAAE,MAAM,CAAC;CAChC;AAED;;GAEG;AACH,eAAO,MAAM,cAAc,EAAE,aAK5B,CAAC"}

package/dist/internal/async/config/cleanup-policy.js

@@ -0,0 +1,20 @@
+"use strict";
+/**
+ * Cleanup Policy Configuration
+ *
+ * Defines rules for cleaning up old composer bundles from S3.
+ * This policy helps manage storage costs while preserving bundles
+ * needed for in-flight workflows.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLEANUP_POLICY = void 0;
+/**
+ * Cleanup policy for composer bundles
+ */
+exports.CLEANUP_POLICY = {
+    minimumRetentionDays: 1,
+    forceKeepHashes: [],
+    gracePeriodHours: 48,
+    maxMergedBundlesToKeep: 5,
+};
+//# sourceMappingURL=cleanup-policy.js.map

package/dist/internal/async/config/cleanup-policy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cleanup-policy.js","sourceRoot":"","sources":["../../../../src/internal/async/config/cleanup-policy.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;;AA4CH;;GAEG;AACU,QAAA,cAAc,GAAkB;IAC3C,oBAAoB,EAAE,CAAC;IACvB,eAAe,EAAE,EAAE;IACnB,gBAAgB,EAAE,EAAE;IACpB,sBAAsB,EAAE,CAAC;CAC1B,CAAC"}

package/dist/internal/async/config/worker-profiles.d.ts

@@ -0,0 +1,172 @@
+/**
+ * Worker Profile Definitions for Temporal Activity Workers
+ *
+ * This module defines worker profiles that map step performance characteristics
+ * to appropriate infrastructure resources.
+ *
+ * ## Profiles
+ *
+ * - **standard**: General business logic (API calls, DB queries, content acquisition).
+ *   0.5 vCPU / 2GB per container, 15 concurrent activities, scales 2-10.
+ * - **heavy**: CPU-intensive or long-running work (zone ingestion, large data processing).
+ *   2 vCPU / 4GB per container, 5 concurrent activities, starts at 3 containers and scales 1-3 by default.
+ *
+ * Each profile maps to a dedicated Temporal task queue and ECS service.
+ *
+ * ## Configuration
+ *
+ * Defaults are defined here. Users can override via `composer.build-config.ts`:
+ * ```typescript
+ * workerProfiles: {
+ *   standard: { cpu: 1024, memory: 4096 }  // Override just what you need
+ * }
+ * ```
+ */
+import type { ComposerBuildConfig, WorkerProfileOverrides, WorkerProfileResources } from "../../../build-config/index";
+/**
+ * Worker profile type.
+ *
+ * Steps declare their profile via the `workerProfile` field. Steps without an
+ * explicit profile default to "standard".
+ */
+export type WorkerProfile = "standard" | "heavy";
+/**
+ * Configuration for a worker profile, defining its resource characteristics
+ * and operational parameters.
+ */
+export interface WorkerProfileConfig {
+    /** Human-readable name */
+    name: string;
+    /** Temporal task queue name for this profile */
+    taskQueue: string;
+    /** Description of when to use this profile */
+    description: string;
+    /** Resource configuration (CPU, memory, scaling) */
+    resources: WorkerProfileResources;
+}
+/**
+ * Default worker profile configuration defining resource characteristics and task queues.
+ *
+ * These defaults are referenced by:
+ * - Step definitions (via `workerProfile` field - currently all use "standard")
+ * - Activity workers (to register on the "standard-tasks" queue)
+ * - Infrastructure as Code (to create appropriately sized ECS tasks)
+ *
+ * Users can override these defaults via `composer.build-config.ts`.
+ */
+export declare const WORKER_PROFILES: Record<WorkerProfile, WorkerProfileConfig>;
+/**
+ * Default worker profile for steps that don't explicitly declare one.
+ *
+ * Using "standard" as the default provides reasonable performance for
+ * typical business logic without over-provisioning resources.
+ */
+export declare const DEFAULT_WORKER_PROFILE: WorkerProfile;
+/**
+ * Gets the task queue name for a given worker profile.
+ *
+ * @param profile - The worker profile
+ * @returns Temporal task queue name
+ */
+export declare function getTaskQueueForProfile(profile: WorkerProfile): string;
+/**
+ * Validates that a profile string is a valid WorkerProfile.
+ *
+ * @param profile - The profile string to validate
+ * @returns true if valid, false otherwise
+ */
+export declare function isValidWorkerProfile(profile: string): profile is WorkerProfile;
+/**
+ * Gets all task queue names (useful for workers that listen to multiple queues).
+ *
+ * @returns Array of all task queue names
+ */
+export declare function getAllTaskQueues(): string[];
+/**
+ * Gets the effective resources for a worker profile, merging config overrides with defaults.
+ *
+ * @param profile - The worker profile name
+ * @param configOverrides - Optional overrides from composer.build-config.ts
+ * @returns The merged resource configuration
+ *
+ * @example
+ * ```typescript
+ * // With no overrides, returns defaults
+ * getEffectiveResources("standard");
+ * // { cpu: 512, memory: 2048, maxConcurrentActivities: 15, minCount: 2, initialCount: 2, maxCount: 10 }
+ *
+ * // With overrides, merges them
+ * getEffectiveResources("standard", { cpu: 1024 });
+ * // { cpu: 1024, memory: 2048, maxConcurrentActivities: 15, minCount: 2, initialCount: 2, maxCount: 10 }
+ * ```
+ */
+export declare function getEffectiveResources(profile: WorkerProfile, configOverrides?: WorkerProfileOverrides): WorkerProfileResources;
+/**
+ * Gets the effective worker profile config, merging config overrides with defaults.
+ *
+ * @param profile - The worker profile name
+ * @param config - Optional composer config containing workerProfiles overrides
+ * @returns The full profile config with merged resources
+ */
+export declare function getEffectiveProfileConfig(profile: WorkerProfile, config?: ComposerBuildConfig): WorkerProfileConfig;
+export interface ResolvedProfilesForEnvironment {
+    dedicatedProfiles: Partial<Record<WorkerProfile, WorkerProfileConfig>>;
+    fallbackQueues: Partial<Record<WorkerProfile, string[]>>;
+}
+/**
+ * Resolves which worker profiles are deployed for an environment and which task
+ * queues should be absorbed by fallback profiles.
+ *
+ * Profiles with no envExclusiveOptIn are always dedicated.
+ * Profiles with envExclusiveOptIn deploy only when environment is listed.
+ */
+export declare function resolveProfilesForEnvironment(environment: string, config?: ComposerBuildConfig): ResolvedProfilesForEnvironment;
+export interface ResolveActivityWorkerRuntimeConfigOptions {
+    environment: string;
+    workerProfile: string;
+    config: ComposerBuildConfig;
+}
+export interface ActivityWorkerRuntimeConfig {
+    workerProfile: WorkerProfile;
+    taskQueues: string[];
+    maxConcurrentActivityTaskExecutions: number;
+}
+/**
+ * Resolves runtime configuration for a single activity worker process.
+ *
+ * Validates the given profile, resolves the environment topology, and returns
+ * the task queues this worker should listen on plus the profile-derived
+ * max concurrent activities.
+ */
+export declare function resolveActivityWorkerRuntimeConfig(options: ResolveActivityWorkerRuntimeConfigOptions): ActivityWorkerRuntimeConfig;
+export interface LoadAndResolveActivityWorkerRuntimeConfigOptions extends Omit<ResolveActivityWorkerRuntimeConfigOptions, "config"> {
+    /** Directory containing the composer.build-config.ts file. Defaults to process.cwd(). */
+    buildConfigDir?: string;
+}
+/**
+ * Convenience wrapper that loads build config from disk and then resolves
+ * activity worker runtime configuration.
+ */
+export declare function loadAndResolveActivityWorkerRuntimeConfig(options: LoadAndResolveActivityWorkerRuntimeConfigOptions): Promise<ActivityWorkerRuntimeConfig>;
+export interface CombinedWorkerConfigOptions {
+    environment: string;
+    /** Directory containing the composer.build-config.ts file. Defaults to process.cwd(). */
+    buildConfigDir?: string;
+}
+export interface CombinedWorkerConfig {
+    taskQueues: string[];
+    maxConcurrentActivityTaskExecutions: number;
+    maxConcurrentWorkflowTaskExecutions: number;
+}
+/**
+ * Loads build config and resolves combined worker configuration
+ * across all dedicated profiles for the given environment.
+ *
+ * Designed for local development where a single process handles all
+ * task queues. Collects every dedicated profile's primary queue
+ * plus any absorbed fallback queues, sums maxConcurrentActivities,
+ * and takes the max of maxConcurrentWorkflows across profiles
+ * (since there is only one workflow worker regardless of activity profiles).
+ */
+export declare function loadAndResolveCombinedWorkerConfigForLocalDev(options: CombinedWorkerConfigOptions): Promise<CombinedWorkerConfig>;
+//# sourceMappingURL=worker-profiles.d.ts.map

package/dist/internal/async/config/worker-profiles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-profiles.d.ts","sourceRoot":"","sources":["../../../../src/internal/async/config/worker-profiles.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EACV,mBAAmB,EACnB,sBAAsB,EACtB,sBAAsB,EACvB,MAAM,6BAA6B,CAAC;AAGrC;;;;;GAKG;AACH,MAAM,MAAM,aAAa,GAAG,UAAU,GAAG,OAAO,CAAC;AAEjD;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IAClC,0BAA0B;IAC1B,IAAI,EAAE,MAAM,CAAC;IAEb,gDAAgD;IAChD,SAAS,EAAE,MAAM,CAAC;IAElB,8CAA8C;IAC9C,WAAW,EAAE,MAAM,CAAC;IAEpB,oDAAoD;IACpD,SAAS,EAAE,sBAAsB,CAAC;CACnC;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,aAAa,EAAE,mBAAmB,CA+BtE,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,EAAE,aAA0B,CAAC;AAEhE;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,aAAa,GAAG,MAAM,CAErE;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,IAAI,aAAa,CAE9E;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,IAAI,MAAM,EAAE,CAE3C;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,aAAa,EACtB,eAAe,CAAC,EAAE,sBAAsB,GACvC,sBAAsB,CAmBxB;AAED;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,aAAa,EACtB,MAAM,CAAC,EAAE,mBAAmB,GAC3B,mBAAmB,CAOrB;AAED,MAAM,WAAW,8BAA8B;IAC7C,iBAAiB,EAAE,OAAO,CAAC,MAAM,CAAC,aAAa,EAAE,mBAAmB,CAAC,CAAC,CAAC;IACvE,cAAc,EAAE,OAAO,CAAC,MAAM,CAAC,aAAa,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC;CAC1D;AAED;;;;;;GAMG;AACH,wBAAgB,6BAA6B,CAC3C,WAAW,EAAE,MAAM,EACnB,MAAM,CAAC,EAAE,mBAAmB,GAC3B,8BAA8B,CA+ChC;AAED,MAAM,WAAW,yCAAyC;IACxD,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,mBAAmB,CAAC;CAC7B;AAED,MAAM,WAAW,2BAA2B;IAC1C,aAAa,EAAE,aAAa,CAAC;IAC7B,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,mCAAmC,EAAE,MAAM,CAAC;CAC7C;AAED;;;;;;GAMG;AACH,wBAAgB,kCAAkC,CAChD,OAAO,EAAE,yCAAyC,GACjD,2BAA2B,CA8B7B;AAED,MAAM,WAAW,gDACf,SAAQ,IAAI,CAAC,yCAAyC,EAAE,QAAQ,CAAC;IACjE,yFAAyF;IACzF,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;GAGG;AACH,wBAAsB,yCAAyC,CAC7D,OAAO,EAAE,gDAAgD,GACxD,OAAO,CAAC,2BAA2B,CAAC,CAUtC;AAED,MAAM,WAAW,2BAA2B;IAC1C,WAAW,EAAE,MAAM,CAAC;IACpB,yFAAyF;IACzF,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,oBAAoB;IACnC,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,mCAAmC,EAAE,MAAM,CAAC;IAC5C,mCAAmC,EAAE,MAAM,CAAC;CAC7C;AAED;;;;;;;;;GASG;AACH,wBAAsB,6CAA6C,CACjE,OAAO,EAAE,2BAA2B,GACnC,OAAO,CAAC,oBAAoB,CAAC,CAsB/B"}