@tailor-platform/sdk 0.12.4 → 0.13.0

package/dist/{list-4T6XN_zi.mjs → list-D-R1mEOM.mjs}

@@ -1,4 +1,4 @@
-import { WORKFLOW_JOB_BRAND, getDistDir, tailorUserMap } from "./job-wYkb6yMl.mjs";
+import { WORKFLOW_JOB_BRAND, getDistDir, tailorUserMap } from "./job-vYIg6hFf.mjs";
 import { createRequire } from "node:module";
 import { defineCommand } from "citty";
 import * as path from "node:path";
@@ -587,9 +587,7 @@ function defineApplication(config) {
 //#region src/parser/service/workflow/schema.ts
 const WorkflowJobSchema = z.object({
 	name: z.string(),
-	get deps() {
-		return z.array(WorkflowJobSchema).optional();
-	},
+	trigger: functionSchema,
 	body: functionSchema
 });
 const WorkflowSchema = z.object({
@@ -601,17 +599,16 @@ const WorkflowSchema = z.object({
 //#region src/cli/application/workflow/service.ts
 /**
 * Load workflow files and collect all jobs in a single pass.
+* Dependencies are detected at bundle time via AST analysis.
 */
 async function loadAndCollectJobs(config) {
 	const workflows = {};
 	const workflowSources = [];
 	const collectedJobs = [];
-	let unusedJobs = [];
 	if (!config.files || config.files.length === 0) return {
 		workflows,
 		workflowSources,
 		jobs: collectedJobs,
-		unusedJobs,
 		fileCount: 0
 	};
 	const workflowFiles = loadFilesWithIgnores(config);
@@ -630,27 +627,13 @@ async function loadAndCollectJobs(config) {
 			const existing = allJobsMap.get(job.name);
 			if (existing) throw new Error(`Duplicate job name "${job.name}" found:\n  - ${existing.sourceFile} (export: ${existing.exportName})\n  - ${job.sourceFile} (export: ${job.exportName})\nEach job must have a unique name.`);
 			allJobsMap.set(job.name, job);
+			collectedJobs.push(job);
 		}
 	}
-	const tracedJobs = /* @__PURE__ */ new Map();
-	for (const { workflow } of workflowSources) traceJobDependencies(workflow.mainJob, tracedJobs);
-	const notExportedJobs = [];
-	for (const jobName of tracedJobs.keys()) if (!allJobsMap.has(jobName)) notExportedJobs.push(jobName);
-	if (notExportedJobs.length > 0) throw new Error(`The following workflow jobs are used but not exported:\n` + notExportedJobs.map((name) => `  - "${name}"`).join("\n") + "\n\nAll workflow jobs must be named exports. Example:\n  export const myJob = createWorkflowJob({ name: \"my-job\", ... });\n\nAlso ensure that files containing job exports are included in the workflow.files glob pattern.");
-	unusedJobs = Array.from(allJobsMap.keys()).filter((jobName) => !tracedJobs.has(jobName));
-	for (const [jobName, job] of tracedJobs) {
-		const exportedMetadata = allJobsMap.get(jobName);
-		const depNames = job.deps?.map((dep) => dep.name);
-		collectedJobs.push({
-			...exportedMetadata,
-			deps: depNames
-		});
-	}
 	return {
 		workflows,
 		workflowSources,
 		jobs: collectedJobs,
-		unusedJobs,
 		fileCount
 	};
 }
@@ -665,7 +648,6 @@ function printLoadedWorkflows(result) {
 		const relativePath = path.relative(process.cwd(), sourceFile);
 		console.log("Workflow:", styleText("greenBright", `"${workflow.name}"`), "loaded from", styleText("cyan", relativePath));
 	}
-	if (result.unusedJobs.length > 0) console.warn(`⚠️  Warning: Unused workflow jobs found: ${result.unusedJobs.join(", ")}`);
 }
 /**
 * Load a single file and extract jobs and workflow
@@ -707,14 +689,6 @@ async function loadFileContent(filePath) {
 function isWorkflowJob(value) {
 	return value != null && typeof value === "object" && WORKFLOW_JOB_BRAND in value && value[WORKFLOW_JOB_BRAND] === true;
 }
-/**
-* Recursively trace all job dependencies
-*/
-function traceJobDependencies(job, visited) {
-	if (visited.has(job.name)) return;
-	visited.set(job.name, job);
-	if (job.deps && Array.isArray(job.deps)) for (const dep of job.deps) traceJobDependencies(dep, visited);
-}
 
 //#endregion
 //#region src/cli/bundler/executor/loader.ts
@@ -1048,29 +1022,27 @@ function findAllJobs(program, _sourceText) {
 				const configObj = args[0];
 				const nameProp = findProperty(configObj.properties, "name");
 				const bodyProp = findProperty(configObj.properties, "body");
-				const depsProp = findProperty(configObj.properties, "deps");
 				if (nameProp && isStringLiteral(nameProp.value) && bodyProp && isFunctionExpression(bodyProp.value)) {
 					let statementRange;
-					for (let i = 0; i < parents.length; i++) {
+					let exportName;
+					for (let i = parents.length - 1; i >= 0; i--) {
 						const parent = parents[i];
-						if (parent.type === "ExportNamedDeclaration" || parent.type === "VariableDeclaration") {
-							statementRange = {
-								start: parent.start,
-								end: parent.end
-							};
-							break;
+						if (parent.type === "VariableDeclarator") {
+							const declarator = parent;
+							if (declarator.id?.type === "Identifier") exportName = declarator.id.name;
 						}
+						if (parent.type === "ExportNamedDeclaration" || parent.type === "VariableDeclaration") statementRange = {
+							start: parent.start,
+							end: parent.end
+						};
 					}
 					jobs.push({
 						name: nameProp.value.value,
+						exportName,
 						nameRange: {
 							start: nameProp.start,
 							end: nameProp.end
 						},
-						depsRange: depsProp ? {
-							start: depsProp.start,
-							end: depsProp.end
-						} : void 0,
 						bodyValueRange: {
 							start: bodyProp.value.start,
 							end: bodyProp.value.end
@@ -1101,19 +1073,6 @@ function applyReplacements(source, replacements) {
 	return result;
 }
 /**
-* Find the end position including trailing comma
-*/
-function findTrailingCommaEnd(source, position) {
-	let i = position;
-	while (i < source.length) {
-		const char = source[i];
-		if (char === ",") return i + 1;
-		if (!/\s/.test(char)) break;
-		i++;
-	}
-	return position;
-}
-/**
 * Find the end of a statement including any trailing newline
 */
 function findStatementEnd(source, position) {
@@ -1123,6 +1082,55 @@ function findStatementEnd(source, position) {
 	return i;
 }
 /**
+* Detect all .trigger() calls in the source code
+* Returns information about each trigger call for transformation
+*/
+function detectTriggerCalls(program, sourceText) {
+	const calls = [];
+	function walk(node) {
+		if (!node || typeof node !== "object") return;
+		if (node.type === "CallExpression") {
+			const callExpr = node;
+			const callee = callExpr.callee;
+			if (callee.type === "MemberExpression") {
+				const memberExpr = callee;
+				if (!memberExpr.computed && memberExpr.object.type === "Identifier" && memberExpr.property.name === "trigger") {
+					const identifierName = memberExpr.object.name;
+					let argsText = "";
+					if (callExpr.arguments.length > 0) {
+						const firstArg = callExpr.arguments[0];
+						const lastArg = callExpr.arguments[callExpr.arguments.length - 1];
+						if (firstArg && lastArg && "start" in firstArg && "end" in lastArg) argsText = sourceText.slice(firstArg.start, lastArg.end);
+					}
+					calls.push({
+						identifierName,
+						callRange: {
+							start: callExpr.start,
+							end: callExpr.end
+						},
+						argsText
+					});
+				}
+			}
+		}
+		for (const key of Object.keys(node)) {
+			const child = node[key];
+			if (Array.isArray(child)) child.forEach((c) => walk(c));
+			else if (child && typeof child === "object") walk(child);
+		}
+	}
+	walk(program);
+	return calls;
+}
+/**
+* Build a map from export name to job name from detected jobs
+*/
+function buildJobNameMap(jobs) {
+	const map = /* @__PURE__ */ new Map();
+	for (const job of jobs) if (job.exportName) map.set(job.exportName, job.name);
+	return map;
+}
+/**
 * Find variable declarations by export names
 * Returns a map of export name to statement range
 */
@@ -1162,54 +1170,74 @@ function findVariableDeclarationsByName(program) {
 }
 /**
 * Transform workflow source code
-* - Target job: remove deps
+* - Transform .trigger() calls to tailor.workflow.triggerJobFunction()
 * - Other jobs: remove entire variable declaration
 *
 * @param source - The source code to transform
 * @param targetJobName - The name of the target job (from job config)
 * @param targetJobExportName - The export name of the target job (optional, for enhanced detection)
 * @param otherJobExportNames - Export names of other jobs to remove (optional, for enhanced detection)
+* @param allJobsMap - Map from export name to job name for trigger transformation (optional)
 */
-function transformWorkflowSource(source, targetJobName, targetJobExportName, otherJobExportNames) {
+function transformWorkflowSource(source, targetJobName, targetJobExportName, otherJobExportNames, allJobsMap) {
 	const { program } = parseSync("input.ts", source);
 	const detectedJobs = findAllJobs(program, source);
+	const jobNameMap = allJobsMap ?? buildJobNameMap(detectedJobs);
 	const allDeclarations = findVariableDeclarationsByName(program);
+	const triggerCalls = detectTriggerCalls(program, source);
 	const replacements = [];
-	const removedRanges = /* @__PURE__ */ new Set();
-	const markRemoved = (start, end) => {
-		removedRanges.add(`${start}-${end}`);
+	const removedRanges = [];
+	const isInsideRemovedRange = (pos) => {
+		return removedRanges.some((r) => pos >= r.start && pos < r.end);
 	};
-	const isRemoved = (start, end) => {
-		return removedRanges.has(`${start}-${end}`);
+	const isAlreadyMarkedForRemoval = (start) => {
+		return removedRanges.some((r) => r.start === start);
 	};
-	for (const job of detectedJobs) if (job.name === targetJobName) {
-		if (job.depsRange) replacements.push({
-			start: job.depsRange.start,
-			end: findTrailingCommaEnd(source, job.depsRange.end),
-			text: ""
-		});
-	} else if (job.statementRange && !isRemoved(job.statementRange.start, job.statementRange.end)) {
-		replacements.push({
-			start: job.statementRange.start,
-			end: findStatementEnd(source, job.statementRange.end),
-			text: ""
+	for (const job of detectedJobs) {
+		if (job.name === targetJobName) continue;
+		if (job.statementRange && !isAlreadyMarkedForRemoval(job.statementRange.start)) {
+			const endPos = findStatementEnd(source, job.statementRange.end);
+			removedRanges.push({
+				start: job.statementRange.start,
+				end: endPos
+			});
+			replacements.push({
+				start: job.statementRange.start,
+				end: endPos,
+				text: ""
+			});
+		} else if (!job.statementRange) replacements.push({
+			start: job.bodyValueRange.start,
+			end: job.bodyValueRange.end,
+			text: "() => {}"
 		});
-		markRemoved(job.statementRange.start, job.statementRange.end);
-	} else if (!job.statementRange) replacements.push({
-		start: job.bodyValueRange.start,
-		end: job.bodyValueRange.end,
-		text: "() => {}"
-	});
+	}
 	if (otherJobExportNames) for (const exportName of otherJobExportNames) {
 		if (exportName === targetJobExportName) continue;
 		const declRange = allDeclarations.get(exportName);
-		if (declRange && !isRemoved(declRange.start, declRange.end)) {
+		if (declRange && !isAlreadyMarkedForRemoval(declRange.start)) {
+			const endPos = findStatementEnd(source, declRange.end);
+			removedRanges.push({
+				start: declRange.start,
+				end: endPos
+			});
 			replacements.push({
 				start: declRange.start,
-				end: findStatementEnd(source, declRange.end),
+				end: endPos,
 				text: ""
 			});
-			markRemoved(declRange.start, declRange.end);
+		}
+	}
+	for (const call of triggerCalls) {
+		if (isInsideRemovedRange(call.callRange.start)) continue;
+		const jobName = jobNameMap.get(call.identifierName);
+		if (jobName) {
+			const transformedCall = `tailor.workflow.triggerJobFunction("${jobName}", ${call.argsText || "undefined"})`;
+			replacements.push({
+				start: call.callRange.start,
+				end: call.callRange.end,
+				text: transformedCall
+			});
 		}
 	}
 	return applyReplacements(source, replacements);
@@ -1221,18 +1249,20 @@ function transformWorkflowSource(source, targetJobName, targetJobExportName, oth
 * Bundle workflow jobs
 *
 * This function:
-* 1. Uses a transform plugin to remove deps during bundling (preserves module resolution)
-* 2. Creates entry file
-* 3. Bundles in a single step with tree-shaking
+* 1. Detects which jobs are actually used (mainJobs + their dependencies)
+* 2. Uses a transform plugin to transform trigger calls during bundling
+* 3. Creates entry file and bundles with tree-shaking
 */
-async function bundleWorkflowJobs(allJobs) {
+async function bundleWorkflowJobs(allJobs, mainJobNames, env = {}) {
 	if (allJobs.length === 0) {
 		console.log(styleText("dim", "No workflow jobs to bundle"));
 		return;
 	}
+	const usedJobs = await filterUsedJobs(allJobs, mainJobNames);
 	console.log("");
-	console.log("Bundling", styleText("cyanBright", allJobs.length.toString()), "files for", styleText("cyan", "\"workflow-job\""));
+	console.log("Bundling", styleText("cyanBright", usedJobs.length.toString()), "files for", styleText("cyan", "\"workflow-job\""));
 	const outputDir = path.resolve(getDistDir(), "workflow-jobs");
+	if (fs.existsSync(outputDir)) fs.rmSync(outputDir, { recursive: true });
 	fs.mkdirSync(outputDir, { recursive: true });
 	let tsconfig;
 	try {
@@ -1240,28 +1270,81 @@ async function bundleWorkflowJobs(allJobs) {
 	} catch {
 		tsconfig = void 0;
 	}
-	await Promise.all(allJobs.map((job) => bundleSingleJob(job, allJobs, outputDir, tsconfig)));
+	await Promise.all(usedJobs.map((job) => bundleSingleJob(job, usedJobs, outputDir, tsconfig, env)));
 	console.log(styleText("green", "Bundled"), styleText("cyan", "\"workflow-job\""));
 }
-async function bundleSingleJob(job, allJobs, outputDir, tsconfig) {
-	const depsJobNames = findJobDeps(job.name, allJobs);
-	const jobsObject = generateJobsObject(depsJobNames);
+/**
+* Filter jobs to only include those that are actually used.
+* A job is "used" if:
+* - It's a mainJob of a workflow
+* - It's called via .trigger() from another used job (transitively)
+*/
+async function filterUsedJobs(allJobs, mainJobNames) {
+	if (allJobs.length === 0 || mainJobNames.length === 0) return [];
+	const jobsBySourceFile = /* @__PURE__ */ new Map();
+	for (const job of allJobs) {
+		const existing = jobsBySourceFile.get(job.sourceFile) || [];
+		existing.push(job);
+		jobsBySourceFile.set(job.sourceFile, existing);
+	}
+	const exportNameToJobName = /* @__PURE__ */ new Map();
+	for (const job of allJobs) exportNameToJobName.set(job.exportName, job.name);
+	const dependencies = /* @__PURE__ */ new Map();
+	const fileResults = await Promise.all(Array.from(jobsBySourceFile.entries()).map(async ([sourceFile, jobs]) => {
+		try {
+			const source = await fs.promises.readFile(sourceFile, "utf-8");
+			const { program } = parseSync("input.ts", source);
+			const detectedJobs = findAllJobs(program, source);
+			const localExportNameToJobName = /* @__PURE__ */ new Map();
+			for (const detected of detectedJobs) if (detected.exportName) localExportNameToJobName.set(detected.exportName, detected.name);
+			const triggerCalls = detectTriggerCalls(program, source);
+			const jobDependencies = [];
+			for (const job of jobs) {
+				const detectedJob = detectedJobs.find((d) => d.name === job.name);
+				if (!detectedJob) continue;
+				const jobDeps = /* @__PURE__ */ new Set();
+				for (const call of triggerCalls) if (detectedJob.bodyValueRange && call.callRange.start >= detectedJob.bodyValueRange.start && call.callRange.end <= detectedJob.bodyValueRange.end) {
+					const triggeredJobName = localExportNameToJobName.get(call.identifierName) || exportNameToJobName.get(call.identifierName);
+					if (triggeredJobName) jobDeps.add(triggeredJobName);
+				}
+				if (jobDeps.size > 0) jobDependencies.push({
+					jobName: job.name,
+					deps: jobDeps
+				});
+			}
+			return jobDependencies;
+		} catch {
+			return [];
+		}
+	}));
+	for (const jobDependencies of fileResults) for (const { jobName, deps } of jobDependencies) dependencies.set(jobName, deps);
+	const usedJobNames = /* @__PURE__ */ new Set();
+	function markUsed(jobName) {
+		if (usedJobNames.has(jobName)) return;
+		usedJobNames.add(jobName);
+		const deps = dependencies.get(jobName);
+		if (deps) for (const dep of deps) markUsed(dep);
+	}
+	for (const mainJobName of mainJobNames) markUsed(mainJobName);
+	return allJobs.filter((job) => usedJobNames.has(job.name));
+}
+async function bundleSingleJob(job, allJobs, outputDir, tsconfig, env) {
 	const entryPath = path.join(outputDir, `${job.name}.entry.js`);
 	const absoluteSourcePath = path.resolve(job.sourceFile).replace(/\\/g, "/");
 	const entryContent = ml`
     import { ${job.exportName} } from "${absoluteSourcePath}";
 
-    const jobs = {
-      ${jobsObject}
-    };
+    const env = ${JSON.stringify(env)};
 
     globalThis.main = async (input) => {
-      return await ${job.exportName}.body(input, jobs);
+      return await ${job.exportName}.body(input, { env });
     };
   `;
 	fs.writeFileSync(entryPath, entryContent);
 	const outputPath = path.join(outputDir, `${job.name}.js`);
 	const otherJobExportNames = allJobs.filter((j) => j.name !== job.name).map((j) => j.exportName);
+	const allJobsMap = /* @__PURE__ */ new Map();
+	for (const j of allJobs) allJobsMap.set(j.exportName, j.name);
 	await rolldown.build(rolldown.defineConfig({
 		input: entryPath,
 		output: {
@@ -1277,8 +1360,8 @@ async function bundleSingleJob(job, allJobs, outputDir, tsconfig) {
 			transform: {
 				filter: { id: { include: [/\.ts$/, /\.js$/] } },
 				handler(code) {
-					if (!code.includes("createWorkflowJob")) return null;
-					return { code: transformWorkflowSource(code, job.name, job.exportName, otherJobExportNames) };
+					if (!code.includes("createWorkflowJob") && !code.includes(".trigger(")) return null;
+					return { code: transformWorkflowSource(code, job.name, job.exportName, otherJobExportNames, allJobsMap) };
 				}
 			}
 		}],
@@ -1290,18 +1373,6 @@ async function bundleSingleJob(job, allJobs, outputDir, tsconfig) {
 		logLevel: "silent"
 	}));
 }
-/**
-* Find the dependencies of a specific job
-*/
-function findJobDeps(targetJobName, allJobs) {
-	return allJobs.find((j) => j.name === targetJobName)?.deps ?? [];
-}
-function generateJobsObject(jobNames) {
-	if (jobNames.length === 0) return "";
-	return jobNames.map((jobName) => {
-		return `"${jobName.replace(/[-\s]/g, "_")}": (args) => tailor.workflow.triggerJobFunction("${jobName}", args)`;
-	}).join(",\n        ");
-}
 
 //#endregion
 //#region src/parser/generator-config/index.ts
@@ -5685,59 +5756,56 @@ function protoGqlOperand(operand) {
 async function applyWorkflow(client, result, phase = "create-update") {
 	const { changeSet } = result;
 	if (phase === "create-update") {
-		await Promise.all(changeSet.creates.map(async (create) => {
-			const jobFunctions = {};
-			for (const [jobName, script] of create.scripts.entries()) {
-				const response = await client.createWorkflowJobFunction({
-					workspaceId: create.workspaceId,
-					jobFunctionName: jobName,
-					script
-				});
-				if (response.jobFunction) jobFunctions[jobName] = response.jobFunction.version;
-			}
+		const jobFunctionVersions = await registerJobFunctions(client, changeSet);
+		await Promise.all([...changeSet.creates.map(async (create) => {
 			await client.createWorkflow({
 				workspaceId: create.workspaceId,
 				workflowName: create.workflow.name,
 				mainJobFunctionName: create.workflow.mainJob.name,
-				jobFunctions
+				jobFunctions: jobFunctionVersions
 			});
 			await client.setMetadata(create.metaRequest);
-		}));
-		await Promise.all(changeSet.updates.map(async (update) => {
-			const jobFunctions = {};
-			for (const [jobName, script] of update.scripts.entries()) {
-				const response = await client.updateWorkflowJobFunction({
-					workspaceId: update.workspaceId,
-					jobFunctionName: jobName,
-					script
-				});
-				if (response.jobFunction) jobFunctions[jobName] = response.jobFunction.version;
-			}
+		}), ...changeSet.updates.map(async (update) => {
 			await client.updateWorkflow({
 				workspaceId: update.workspaceId,
 				workflowName: update.workflow.name,
 				mainJobFunctionName: update.workflow.mainJob.name,
-				jobFunctions
+				jobFunctions: jobFunctionVersions
 			});
 			await client.setMetadata(update.metaRequest);
-		}));
+		})]);
 	} else if (phase === "delete") await Promise.all(changeSet.deletes.map((del) => client.deleteWorkflow({
 		workspaceId: del.workspaceId,
 		workflowId: del.workflowId
 	})));
 }
 /**
-* Recursively collect all job names from a workflow's mainJob and its dependencies
+* Register all job functions once, returns a map of job name to version.
+* Uses update for existing workflows, create for new workflows.
 */
-function collectJobNamesFromWorkflow(workflow) {
-	const jobNames = /* @__PURE__ */ new Set();
-	const collectFromJob = (job) => {
-		if (!job || jobNames.has(job.name)) return;
-		jobNames.add(job.name);
-		if (job.deps && Array.isArray(job.deps)) for (const dep of job.deps) collectFromJob(dep);
-	};
-	collectFromJob(workflow.mainJob);
-	return jobNames;
+async function registerJobFunctions(client, changeSet) {
+	const jobFunctionVersions = {};
+	const firstWorkflow = changeSet.creates[0] || changeSet.updates[0];
+	if (!firstWorkflow) return jobFunctionVersions;
+	const { workspaceId, scripts } = firstWorkflow;
+	const hasExistingWorkflows = changeSet.updates.length > 0;
+	const results = await Promise.all(Array.from(scripts.entries()).map(async ([jobName, script]) => {
+		const response = hasExistingWorkflows ? await client.updateWorkflowJobFunction({
+			workspaceId,
+			jobFunctionName: jobName,
+			script
+		}) : await client.createWorkflowJobFunction({
+			workspaceId,
+			jobFunctionName: jobName,
+			script
+		});
+		return {
+			jobName,
+			version: response.jobFunction?.version
+		};
+	}));
+	for (const { jobName, version } of results) if (version) jobFunctionVersions[jobName] = version;
+	return jobFunctionVersions;
 }
 function trn(workspaceId, name) {
 	return `trn:v1:workspace:${workspaceId}:workflow:${name}`;
@@ -5767,13 +5835,6 @@ async function planWorkflow(client, workspaceId, appName, workflows) {
 	}));
 	const allScripts = await loadWorkflowScripts();
 	for (const workflow of Object.values(workflows)) {
-		const requiredJobNames = collectJobNamesFromWorkflow(workflow);
-		const scripts = /* @__PURE__ */ new Map();
-		for (const jobName of requiredJobNames) {
-			const script = allScripts.get(jobName);
-			if (script) scripts.set(jobName, script);
-			else console.warn(`Warning: Script for job "${jobName}" not found in workflow "${workflow.name}"`);
-		}
 		const existing = existingWorkflows[workflow.name];
 		const metaRequest = await buildMetaRequest(trn(workspaceId, workflow.name), appName);
 		if (existing) {
@@ -5790,7 +5851,7 @@ async function planWorkflow(client, workspaceId, appName, workflows) {
 				name: workflow.name,
 				workspaceId,
 				workflow,
-				scripts,
+				scripts: allScripts,
 				metaRequest
 			});
 			delete existingWorkflows[workflow.name];
@@ -5798,7 +5859,7 @@ async function planWorkflow(client, workspaceId, appName, workflows) {
 			name: workflow.name,
 			workspaceId,
 			workflow,
-			scripts,
+			scripts: allScripts,
 			metaRequest
 		});
 	}
@@ -5824,7 +5885,7 @@ async function loadWorkflowScripts() {
 	const jobsDir = path.join(getDistDir(), "workflow-jobs");
 	if (!fs.existsSync(jobsDir)) return scripts;
 	const files = fs.readdirSync(jobsDir);
-	for (const file of files) if (file.endsWith(".js") && !file.endsWith(".base.js") && !file.endsWith(".transformed.js") && !file.endsWith(".map")) {
+	for (const file of files) if (/^[^.]+\.js$/.test(file)) {
 		const jobName = file.replace(/\.js$/, "");
 		const scriptPath = path.join(jobsDir, file);
 		const script = fs.readFileSync(scriptPath, "utf-8");
@@ -5846,7 +5907,10 @@ async function apply(options) {
 	if (application.workflowConfig) workflowResult = await loadAndCollectJobs(application.workflowConfig);
 	for (const app$1 of application.applications) for (const pipeline$1 of app$1.resolverServices) await buildPipeline(pipeline$1.namespace, pipeline$1.config);
 	if (application.executorService) await buildExecutor(application.executorService.config);
-	if (workflowResult && workflowResult.jobs.length > 0) await buildWorkflow(workflowResult.jobs);
+	if (workflowResult && workflowResult.jobs.length > 0) {
+		const mainJobNames = workflowResult.workflowSources.map((ws) => ws.workflow.mainJob.name);
+		await buildWorkflow(workflowResult.jobs, mainJobNames, application.env);
+	}
 	if (buildOnly) return;
 	const accessToken = await loadAccessToken({
 		useProfile: true,
@@ -5951,8 +6015,8 @@ async function buildPipeline(namespace, config) {
 async function buildExecutor(config) {
 	await bundleExecutors(config);
 }
-async function buildWorkflow(collectedJobs) {
-	await bundleWorkflowJobs(collectedJobs);
+async function buildWorkflow(collectedJobs, mainJobNames, env) {
+	await bundleWorkflowJobs(collectedJobs, mainJobNames, env);
 }
 const applyCommand = defineCommand({
 	meta: {
@@ -7384,4 +7448,4 @@ const listCommand = defineCommand({
 
 //#endregion
 export { PATScope, apply, applyCommand, commonArgs, createCommand, deleteCommand, fetchAll, fetchLatestToken, fetchUserInfo, formatArgs, generate, generateCommand, generateUserTypes, getCommand, initOAuth2Client, initOperatorClient, listCommand, listCommand$1, listCommand$2, loadAccessToken, loadConfig, loadWorkspaceId, machineUserList, machineUserToken, oauth2ClientGet, oauth2ClientList, parseFormat, printWithFormat, readPackageJson, readPlatformConfig, remove, removeCommand, show, showCommand, tokenCommand, withCommonArgs, workspaceCreate, workspaceDelete, workspaceList, writePlatformConfig };
-//# sourceMappingURL=list-4T6XN_zi.mjs.map
+//# sourceMappingURL=list-D-R1mEOM.mjs.map