@diia-inhouse/workflow 1.17.11 → 2.5.0

package/dist/cli/determinism/errorClassifier.js

@@ -1,65 +1,61 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isNewStepsAdded = isNewStepsAdded;
-exports.classifyReplayError = classifyReplayError;
-const workflow_1 = require("@temporalio/workflow");
+import { DeterminismViolationError } from "@temporalio/workflow";
+//#region src/cli/determinism/errorClassifier.ts
 const activityMismatchRegex = /Activity type of scheduled event '(.+?)' does not match activity type of activity command '(.+?)'/;
 function isNewStepsAdded(error) {
-    return error.errorType === 'DeterminismViolation' && error.errorMessage.includes('WorkflowExecutionCompleted');
+	return error.errorType === "DeterminismViolation" && error.errorMessage.includes("WorkflowExecutionCompleted");
 }
 function classifyReplayError(workflowId, error) {
-    if (error instanceof workflow_1.DeterminismViolationError) {
-        const message = error.message || '';
-        const match = message.match(activityMismatchRegex);
-        if (match) {
-            const [, scheduledEvent, activityCommand] = match;
-            return {
-                type: 'determinism-violation',
-                subtype: 'activity-mismatch',
-                entry: {
-                    workflowId,
-                    errorType: 'DeterminismViolation',
-                    errorMessage: message,
-                    details: {
-                        issue: 'Activity Type Mismatch',
-                        explanation: `The workflow history expected activity '${scheduledEvent}' but the code attempted to execute '${activityCommand}'`,
-                    },
-                },
-            };
-        }
-        if (message.includes('WorkflowExecutionCompleted')) {
-            return {
-                type: 'determinism-violation',
-                subtype: 'new-steps-added',
-                entry: {
-                    workflowId,
-                    errorType: 'DeterminismViolation',
-                    errorMessage: message,
-                    details: {
-                        issue: 'New Steps Added',
-                        explanation: 'This workflow has been modified to add new steps after the point where it previously completed. This is safe to ignore as it does not affect existing history.',
-                    },
-                },
-            };
-        }
-        return {
-            type: 'determinism-violation',
-            subtype: 'other',
-            entry: {
-                workflowId,
-                errorType: 'DeterminismViolation',
-                errorMessage: message,
-            },
-        };
-    }
-    return {
-        type: 'replay-failure',
-        subtype: undefined,
-        entry: {
-            workflowId,
-            errorType: 'ReplayFailure',
-            errorMessage: error.message,
-        },
-    };
+	if (error instanceof DeterminismViolationError) {
+		const message = error.message || "";
+		const match = message.match(activityMismatchRegex);
+		if (match) {
+			const [, scheduledEvent, activityCommand] = match;
+			return {
+				type: "determinism-violation",
+				subtype: "activity-mismatch",
+				entry: {
+					workflowId,
+					errorType: "DeterminismViolation",
+					errorMessage: message,
+					details: {
+						issue: "Activity Type Mismatch",
+						explanation: `The workflow history expected activity '${scheduledEvent}' but the code attempted to execute '${activityCommand}'`
+					}
+				}
+			};
+		}
+		if (message.includes("WorkflowExecutionCompleted")) return {
+			type: "determinism-violation",
+			subtype: "new-steps-added",
+			entry: {
+				workflowId,
+				errorType: "DeterminismViolation",
+				errorMessage: message,
+				details: {
+					issue: "New Steps Added",
+					explanation: "This workflow has been modified to add new steps after the point where it previously completed. This is safe to ignore as it does not affect existing history."
+				}
+			}
+		};
+		return {
+			type: "determinism-violation",
+			subtype: "other",
+			entry: {
+				workflowId,
+				errorType: "DeterminismViolation",
+				errorMessage: message
+			}
+		};
+	}
+	return {
+		type: "replay-failure",
+		subtype: void 0,
+		entry: {
+			workflowId,
+			errorType: "ReplayFailure",
+			errorMessage: error.message
+		}
+	};
 }
-//# sourceMappingURL=errorClassifier.js.map
+//#endregion
+export { classifyReplayError, isNewStepsAdded };

package/dist/cli/determinism/historyFiles.js

@@ -1,107 +1,78 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.collectHistoryFiles = collectHistoryFiles;
-exports.parseHistoryFile = parseHistoryFile;
-exports.loadHistoryEntries = loadHistoryEntries;
-const node_fs_1 = require("node:fs");
-const node_path_1 = __importDefault(require("node:path"));
-const ENCRYPTED_ENCODING = 'YmluYXJ5L2VuY3J5cHRlZA=='; // base64 of 'binary/encrypted'
+import path from "node:path";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+//#region src/cli/determinism/historyFiles.ts
+const ENCRYPTED_ENCODING = "YmluYXJ5L2VuY3J5cHRlZA==";
 function collectHistoryFiles(dir) {
-    // eslint-disable-next-line security/detect-non-literal-fs-filename
-    const dirExists = (0, node_fs_1.existsSync)(dir); // nosemgrep: eslint.detect-non-literal-fs-filename
-    if (!dirExists) {
-        throw new Error(`History directory does not exist: ${dir}`);
-    }
-    const files = [];
-    // eslint-disable-next-line security/detect-non-literal-fs-filename
-    const entries = (0, node_fs_1.readdirSync)(dir, { withFileTypes: true }); // nosemgrep: eslint.detect-non-literal-fs-filename
-    for (const entry of entries) {
-        const fullPath = node_path_1.default.join(dir, entry.name);
-        if (entry.isDirectory()) {
-            files.push(...collectHistoryFiles(fullPath));
-        }
-        else if (entry.name.endsWith('.json')) {
-            files.push(fullPath);
-        }
-    }
-    return files;
+	if (!existsSync(dir)) throw new Error(`History directory does not exist: ${dir}`);
+	const files = [];
+	const entries = readdirSync(dir, { withFileTypes: true });
+	for (const entry of entries) {
+		const fullPath = path.join(dir, entry.name);
+		if (entry.isDirectory()) files.push(...collectHistoryFiles(fullPath));
+		else if (entry.name.endsWith(".json")) files.push(fullPath);
+	}
+	return files;
 }
 const TERMINAL_EVENT_TYPES = new Set([
-    'EVENT_TYPE_WORKFLOW_EXECUTION_COMPLETED',
-    'EVENT_TYPE_WORKFLOW_EXECUTION_FAILED',
-    'EVENT_TYPE_WORKFLOW_EXECUTION_TIMED_OUT',
-    'EVENT_TYPE_WORKFLOW_EXECUTION_CANCELED',
-    'EVENT_TYPE_WORKFLOW_EXECUTION_TERMINATED',
+	"EVENT_TYPE_WORKFLOW_EXECUTION_COMPLETED",
+	"EVENT_TYPE_WORKFLOW_EXECUTION_FAILED",
+	"EVENT_TYPE_WORKFLOW_EXECUTION_TIMED_OUT",
+	"EVENT_TYPE_WORKFLOW_EXECUTION_CANCELED",
+	"EVENT_TYPE_WORKFLOW_EXECUTION_TERMINATED"
 ]);
 function parseHistoryFile(filePath) {
-    const workflowId = node_path_1.default.basename(filePath, '.json');
-    // eslint-disable-next-line security/detect-non-literal-fs-filename
-    const content = JSON.parse((0, node_fs_1.readFileSync)(filePath, 'utf8')); // nosemgrep: eslint.detect-non-literal-fs-filename
-    const history = content.history ?? content;
-    const events = history.events ?? [];
-    const startEvent = events.find((e) => e.eventType === 'EVENT_TYPE_WORKFLOW_EXECUTION_STARTED');
-    const workflowType = startEvent?.workflowExecutionStartedEventAttributes?.workflowType?.name ?? 'unknown';
-    const encrypted = hasEncryptedPayloads(events);
-    const running = !events.some((e) => TERMINAL_EVENT_TYPES.has(e.eventType ?? ''));
-    return { workflowId, workflowType, history, encrypted, running };
+	const workflowId = path.basename(filePath, ".json");
+	const content = JSON.parse(readFileSync(filePath, "utf8"));
+	const history = content.history ?? content;
+	const events = history.events ?? [];
+	return {
+		workflowId,
+		workflowType: events.find((e) => e.eventType === "EVENT_TYPE_WORKFLOW_EXECUTION_STARTED")?.workflowExecutionStartedEventAttributes?.workflowType?.name ?? "unknown",
+		history,
+		encrypted: hasEncryptedPayloads(events),
+		running: !events.some((e) => TERMINAL_EVENT_TYPES.has(e.eventType ?? ""))
+	};
 }
 function hasEncryptedPayloads(events) {
-    for (const event of events) {
-        for (const [key, val] of Object.entries(event)) {
-            if (!key.includes('Attributes') || typeof val !== 'object' || val === null) {
-                continue;
-            }
-            for (const nested of Object.values(val)) {
-                if (typeof nested !== 'object' || nested === null) {
-                    continue;
-                }
-                const payloads = nested.payloads;
-                if (!Array.isArray(payloads)) {
-                    continue;
-                }
-                for (const payload of payloads) {
-                    if (payload.metadata?.encoding === ENCRYPTED_ENCODING) {
-                        return true;
-                    }
-                }
-            }
-        }
-    }
-    return false;
+	for (const event of events) for (const [key, val] of Object.entries(event)) {
+		if (!key.includes("Attributes") || typeof val !== "object" || val === null) continue;
+		for (const nested of Object.values(val)) {
+			if (typeof nested !== "object" || nested === null) continue;
+			const payloads = nested.payloads;
+			if (!Array.isArray(payloads)) continue;
+			for (const payload of payloads) if (payload.metadata?.encoding === ENCRYPTED_ENCODING) return true;
+		}
+	}
+	return false;
 }
 function loadHistoryEntries(historyDir, workflows, options = {}) {
-    const { limit, encryptionEnabled = false, logger } = options;
-    let historyFiles = collectHistoryFiles(historyDir);
-    if (limit && limit > 0 && historyFiles.length > limit) {
-        historyFiles = historyFiles.slice(0, limit);
-    }
-    const entries = [];
-    let encryptedCount = 0;
-    let runningCount = 0;
-    for (const filePath of historyFiles) {
-        try {
-            const entry = parseHistoryFile(filePath);
-            if (entry.workflowType !== 'unknown' && !workflows[entry.workflowType]) {
-                continue;
-            }
-            if (entry.running) {
-                runningCount++;
-                continue;
-            }
-            if (entry.encrypted && !encryptionEnabled) {
-                encryptedCount++;
-                continue;
-            }
-            entries.push(entry);
-        }
-        catch (err) {
-            const workflowId = node_path_1.default.basename(filePath, '.json');
-            logger?.warn(`Skipping ${workflowId} — failed to parse: ${err.message}`);
-        }
-    }
-    return { entries, encryptedCount, runningCount };
+	const { limit, encryptionEnabled = false, logger } = options;
+	let historyFiles = collectHistoryFiles(historyDir);
+	if (limit && limit > 0 && historyFiles.length > limit) historyFiles = historyFiles.slice(0, limit);
+	const entries = [];
+	let encryptedCount = 0;
+	let runningCount = 0;
+	for (const filePath of historyFiles) try {
+		const entry = parseHistoryFile(filePath);
+		if (entry.workflowType !== "unknown" && !workflows[entry.workflowType]) continue;
+		if (entry.running) {
+			runningCount++;
+			continue;
+		}
+		if (entry.encrypted && !encryptionEnabled) {
+			encryptedCount++;
+			continue;
+		}
+		entries.push(entry);
+	} catch (err) {
+		const workflowId = path.basename(filePath, ".json");
+		logger?.warn(`Skipping ${workflowId} — failed to parse: ${err.message}`);
+	}
+	return {
+		entries,
+		encryptedCount,
+		runningCount
+	};
 }
-//# sourceMappingURL=historyFiles.js.map
+//#endregion
+export { loadHistoryEntries };

package/dist/cli/determinism/index.js

@@ -1,19 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.printReport = exports.replaySingle = exports.replayBatch = exports.resolveWorkflowsPath = exports.buildReplayOptions = exports.DeterminismReportBuilder = exports.loadHistoryEntries = exports.isNewStepsAdded = exports.classifyReplayError = void 0;
-var errorClassifier_1 = require("./errorClassifier");
-Object.defineProperty(exports, "classifyReplayError", { enumerable: true, get: function () { return errorClassifier_1.classifyReplayError; } });
-Object.defineProperty(exports, "isNewStepsAdded", { enumerable: true, get: function () { return errorClassifier_1.isNewStepsAdded; } });
-var historyFiles_1 = require("./historyFiles");
-Object.defineProperty(exports, "loadHistoryEntries", { enumerable: true, get: function () { return historyFiles_1.loadHistoryEntries; } });
-var report_1 = require("./report");
-Object.defineProperty(exports, "DeterminismReportBuilder", { enumerable: true, get: function () { return report_1.DeterminismReportBuilder; } });
-var replayOptions_1 = require("./replayOptions");
-Object.defineProperty(exports, "buildReplayOptions", { enumerable: true, get: function () { return replayOptions_1.buildReplayOptions; } });
-Object.defineProperty(exports, "resolveWorkflowsPath", { enumerable: true, get: function () { return replayOptions_1.resolveWorkflowsPath; } });
-var replayExecutor_1 = require("./replayExecutor");
-Object.defineProperty(exports, "replayBatch", { enumerable: true, get: function () { return replayExecutor_1.replayBatch; } });
-Object.defineProperty(exports, "replaySingle", { enumerable: true, get: function () { return replayExecutor_1.replaySingle; } });
-var reportPrinter_1 = require("./reportPrinter");
-Object.defineProperty(exports, "printReport", { enumerable: true, get: function () { return reportPrinter_1.printReport; } });
-//# sourceMappingURL=index.js.map
+import "./errorClassifier.js";
+import "./historyFiles.js";
+import "./report.js";
+import "./replayOptions.js";
+import "./replayExecutor.js";
+import "./reportPrinter.js";
+export {};

package/dist/cli/determinism/replayExecutor.js

@@ -1,139 +1,120 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.replaySingle = replaySingle;
-exports.replayBatch = replayBatch;
-const worker_1 = require("@temporalio/worker");
-const workflow_1 = require("@temporalio/workflow");
-const errorClassifier_1 = require("./errorClassifier");
-class TimeoutError extends Error {
-    timeoutMs;
-    name = 'TimeoutError';
-    constructor(timeoutMs) {
-        super(`Replay timed out after ${timeoutMs / 1000}s`);
-        this.timeoutMs = timeoutMs;
-    }
-}
+import { classifyReplayError } from "./errorClassifier.js";
+import { DeterminismViolationError } from "@temporalio/workflow";
+import { Worker } from "@temporalio/worker";
+import { setTimeout as setTimeout$1 } from "node:timers/promises";
+//#region src/cli/determinism/replayExecutor.ts
+var TimeoutError = class extends Error {
+	timeoutMs;
+	name = "TimeoutError";
+	constructor(timeoutMs) {
+		super(`Replay timed out after ${timeoutMs / 1e3}s`);
+		this.timeoutMs = timeoutMs;
+	}
+};
 function runWithTimeout(options, history, workflowId, timeoutMs) {
-    return new Promise((resolve, reject) => {
-        const timer = setTimeout(() => reject(new TimeoutError(timeoutMs)), timeoutMs);
-        void worker_1.Worker.runReplayHistory(options, history, workflowId)
-            .then(resolve, reject)
-            .finally(() => clearTimeout(timer));
-    });
+	return new Promise((resolve, reject) => {
+		const timer = setTimeout(() => reject(new TimeoutError(timeoutMs)), timeoutMs);
+		Worker.runReplayHistory(options, history, workflowId).then(resolve, reject).finally(() => clearTimeout(timer));
+	});
 }
 async function replaySingle(options, history, workflowId, workflowType, config) {
-    let failedAttempts = 0;
-    const originalErrors = [];
-    for (let attempt = 1; attempt <= config.maxRetries; attempt++) {
-        try {
-            if (attempt > 1) {
-                const delay = Math.min(config.retryDelayMs * Math.pow(2, attempt - 2), 4000);
-                await new Promise((resolve) => setTimeout(resolve, delay));
-            }
-            await runWithTimeout(options, history, workflowId, config.timeoutMs);
-            return {
-                status: 'success',
-                workflowId,
-                workflowType,
-                recoveredOnRetry: attempt > 1,
-                failedAttempts,
-                originalErrors,
-            };
-        }
-        catch (err) {
-            if (err instanceof workflow_1.DeterminismViolationError) {
-                const classification = (0, errorClassifier_1.classifyReplayError)(workflowId, err);
-                return { status: 'failure', workflowId, workflowType, error: classification.entry };
-            }
-            if (err instanceof TimeoutError) {
-                return { status: 'timeout', workflowId, workflowType, timeoutMs: err.timeoutMs };
-            }
-            failedAttempts++;
-            originalErrors.push(`Attempt ${attempt}: ${err instanceof Error ? err.message : String(err)}`);
-        }
-    }
-    return {
-        status: 'failure',
-        workflowId,
-        workflowType,
-        error: {
-            workflowId,
-            errorType: 'ReplayFailure',
-            errorMessage: `Replay failed after ${config.maxRetries} attempts`,
-            details: { originalErrors },
-        },
-    };
+	let failedAttempts = 0;
+	const originalErrors = [];
+	for (let attempt = 1; attempt <= config.maxRetries; attempt++) try {
+		if (attempt > 1) await setTimeout$1(Math.min(config.retryDelayMs * Math.pow(2, attempt - 2), 4e3));
+		await runWithTimeout(options, history, workflowId, config.timeoutMs);
+		return {
+			status: "success",
+			workflowId,
+			workflowType,
+			recoveredOnRetry: attempt > 1,
+			failedAttempts,
+			originalErrors
+		};
+	} catch (err) {
+		if (err instanceof DeterminismViolationError) return {
+			status: "failure",
+			workflowId,
+			workflowType,
+			error: classifyReplayError(workflowId, err).entry
+		};
+		if (err instanceof TimeoutError) return {
+			status: "timeout",
+			workflowId,
+			workflowType,
+			timeoutMs: err.timeoutMs
+		};
+		failedAttempts++;
+		originalErrors.push(`Attempt ${attempt}: ${err instanceof Error ? err.message : String(err)}`);
+	}
+	return {
+		status: "failure",
+		workflowId,
+		workflowType,
+		error: {
+			workflowId,
+			errorType: "ReplayFailure",
+			errorMessage: `Replay failed after ${config.maxRetries} attempts`,
+			details: { originalErrors }
+		}
+	};
 }
-const DEFAULT_BATCH_TIMEOUT_MS = 30_000;
+const DEFAULT_BATCH_TIMEOUT_MS = 3e4;
 async function* replayBatch(options, entries, timeoutMs = DEFAULT_BATCH_TIMEOUT_MS) {
-    const entryMap = new Map(entries.map((e) => [e.workflowId, e]));
-    const entryOrder = entries.map((e) => e.workflowId);
-    let nextExpectedIndex = 0;
-    async function* historyIterator() {
-        for (const entry of entries) {
-            yield { history: entry.history, workflowId: entry.workflowId };
-        }
-    }
-    const iterator = worker_1.Worker.runReplayHistories(options, historyIterator())[Symbol.asyncIterator]();
-    while (true) {
-        const nextResult = await Promise.race([
-            iterator.next(),
-            new Promise((resolve) => setTimeout(() => resolve('timeout'), timeoutMs)),
-        ]);
-        if (nextResult === 'timeout') {
-            // The replay stream is stuck — emit timeout for the current expected workflow and abort
-            const stuckWorkflowId = entryOrder[nextExpectedIndex];
-            if (stuckWorkflowId) {
-                const entry = entryMap.get(stuckWorkflowId);
-                yield {
-                    status: 'timeout',
-                    workflowId: stuckWorkflowId,
-                    workflowType: entry?.workflowType ?? 'unknown',
-                    timeoutMs,
-                };
-            }
-            // Cannot continue — the worker is stuck, remaining workflows won't be processed
-            break;
-        }
-        if (nextResult.done) {
-            break;
-        }
-        const result = nextResult.value;
-        const entry = entryMap.get(result.workflowId);
-        const workflowType = entry?.workflowType ?? 'unknown';
-        // Track progress for timeout detection
-        const resultIndex = entryOrder.indexOf(result.workflowId);
-        if (resultIndex >= nextExpectedIndex) {
-            nextExpectedIndex = resultIndex + 1;
-        }
-        if (result.error) {
-            if (result.error instanceof workflow_1.DeterminismViolationError) {
-                const classification = (0, errorClassifier_1.classifyReplayError)(result.workflowId, result.error);
-                yield { status: 'failure', workflowId: result.workflowId, workflowType, error: classification.entry };
-            }
-            else {
-                yield {
-                    status: 'failure',
-                    workflowId: result.workflowId,
-                    workflowType,
-                    error: {
-                        workflowId: result.workflowId,
-                        errorType: 'ReplayFailure',
-                        errorMessage: result.error.message,
-                    },
-                };
-            }
-        }
-        else {
-            yield {
-                status: 'success',
-                workflowId: result.workflowId,
-                workflowType,
-                recoveredOnRetry: false,
-                failedAttempts: 0,
-                originalErrors: [],
-            };
-        }
-    }
+	const entryMap = new Map(entries.map((e) => [e.workflowId, e]));
+	const entryOrder = entries.map((e) => e.workflowId);
+	let nextExpectedIndex = 0;
+	async function* historyIterator() {
+		for (const entry of entries) yield {
+			history: entry.history,
+			workflowId: entry.workflowId
+		};
+	}
+	const iterator = Worker.runReplayHistories(options, historyIterator())[Symbol.asyncIterator]();
+	while (true) {
+		const nextResult = await Promise.race([iterator.next(), setTimeout$1(timeoutMs).then(() => "timeout")]);
+		if (nextResult === "timeout") {
+			const stuckWorkflowId = entryOrder[nextExpectedIndex];
+			if (stuckWorkflowId) yield {
+				status: "timeout",
+				workflowId: stuckWorkflowId,
+				workflowType: entryMap.get(stuckWorkflowId)?.workflowType ?? "unknown",
+				timeoutMs
+			};
+			break;
+		}
+		if (nextResult.done) break;
+		const result = nextResult.value;
+		const workflowType = entryMap.get(result.workflowId)?.workflowType ?? "unknown";
+		const resultIndex = entryOrder.indexOf(result.workflowId);
+		if (resultIndex >= nextExpectedIndex) nextExpectedIndex = resultIndex + 1;
+		if (result.error) if (result.error instanceof DeterminismViolationError) {
+			const classification = classifyReplayError(result.workflowId, result.error);
+			yield {
+				status: "failure",
+				workflowId: result.workflowId,
+				workflowType,
+				error: classification.entry
+			};
+		} else yield {
+			status: "failure",
+			workflowId: result.workflowId,
+			workflowType,
+			error: {
+				workflowId: result.workflowId,
+				errorType: "ReplayFailure",
+				errorMessage: result.error.message
+			}
+		};
+		else yield {
+			status: "success",
+			workflowId: result.workflowId,
+			workflowType,
+			recoveredOnRetry: false,
+			failedAttempts: 0,
+			originalErrors: []
+		};
+	}
 }
-//# sourceMappingURL=replayExecutor.js.map
+//#endregion
+export { replayBatch, replaySingle };

package/dist/cli/determinism/replayOptions.js

@@ -1,26 +1,17 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveWorkflowsPath = resolveWorkflowsPath;
-exports.buildReplayOptions = buildReplayOptions;
-const node_path_1 = __importDefault(require("node:path"));
-const encryption_1 = require("../../encryption");
+import { getDataConverter } from "../../encryption/dataConverter.js";
+import "../../encryption/index.js";
+import path from "node:path";
+//#region src/cli/determinism/replayOptions.ts
 function resolveWorkflowsPath(workflowsPath) {
-    const baseDir = node_path_1.default.resolve('./dist');
-    const fullPath = node_path_1.default.resolve(baseDir, workflowsPath, 'index.js');
-    if (!fullPath.startsWith(baseDir + node_path_1.default.sep)) {
-        throw new Error(`Invalid workflows path: path traversal detected in '${workflowsPath}'`);
-    }
-    return fullPath;
+	const baseDir = path.resolve("./dist");
+	const fullPath = path.resolve(baseDir, workflowsPath, "index.js");
+	if (!fullPath.startsWith(baseDir + path.sep)) throw new Error(`Invalid workflows path: path traversal detected in '${workflowsPath}'`);
+	return fullPath;
 }
 async function buildReplayOptions(workflowsPath, encryption, envService) {
-    const fullPath = resolveWorkflowsPath(workflowsPath);
-    const options = { workflowsPath: fullPath };
-    if (encryption.enabled && envService) {
-        options.dataConverter = await (0, encryption_1.getDataConverter)(encryption.keyId, envService);
-    }
-    return options;
+	const options = { workflowsPath: resolveWorkflowsPath(workflowsPath) };
+	if (encryption.enabled && envService) options.dataConverter = await getDataConverter(encryption.keyId, envService);
+	return options;
 }
-//# sourceMappingURL=replayOptions.js.map
+//#endregion
+export { buildReplayOptions, resolveWorkflowsPath };