@tailor-platform/sdk 0.12.4 → 0.14.0

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

@@ -1,4 +1,4 @@
-import { WORKFLOW_JOB_BRAND, getDistDir, tailorUserMap } from "./job-wYkb6yMl.mjs";
+import { WORKFLOW_JOB_BRAND, getDistDir, tailorUserMap } from "./job-inTmXxpa.mjs";
 import { createRequire } from "node:module";
 import { defineCommand } from "citty";
 import * as path from "node:path";
@@ -115,16 +115,180 @@ function loadFilesWithIgnores(config) {
 	return files;
 }
 
+//#endregion
+//#region src/parser/service/auth/schema.ts
+const AuthInvokerSchema = z.object({
+	namespace: z.string(),
+	machineUserName: z.string()
+});
+const secretValueSchema = z.object({
+	vaultName: z.string(),
+	secretKey: z.string()
+});
+const samlBaseSchema = z.object({
+	name: z.string(),
+	kind: z.literal("SAML"),
+	spCertBase64: secretValueSchema.optional(),
+	spKeyBase64: secretValueSchema.optional()
+});
+const OIDCSchema = z.object({
+	name: z.string(),
+	kind: z.literal("OIDC"),
+	clientID: z.string(),
+	clientSecret: secretValueSchema,
+	providerURL: z.string(),
+	issuerURL: z.string().optional(),
+	usernameClaim: z.string().optional()
+});
+const SAMLSchema = samlBaseSchema.extend({
+	metadataURL: z.string().optional(),
+	rawMetadata: z.string().optional()
+}).refine((value) => {
+	const hasMetadata = value.metadataURL !== void 0;
+	const hasRaw = value.rawMetadata !== void 0;
+	return hasMetadata !== hasRaw;
+}, "Provide either metadataURL or rawMetadata");
+const IDTokenSchema = z.object({
+	name: z.string(),
+	kind: z.literal("IDToken"),
+	providerURL: z.string(),
+	issuerURL: z.string().optional(),
+	clientID: z.string(),
+	usernameClaim: z.string().optional()
+});
+const BuiltinIdPSchema = z.object({
+	name: z.string(),
+	kind: z.literal("BuiltInIdP"),
+	namespace: z.string(),
+	clientName: z.string()
+});
+const IdProviderSchema = z.discriminatedUnion("kind", [
+	OIDCSchema,
+	SAMLSchema,
+	IDTokenSchema,
+	BuiltinIdPSchema
+]);
+const OAuth2ClientGrantTypeSchema = z.union([z.literal("authorization_code"), z.literal("refresh_token")]);
+const OAuth2ClientSchema = z.object({
+	description: z.string().optional(),
+	grantTypes: z.array(OAuth2ClientGrantTypeSchema).default(["authorization_code", "refresh_token"]),
+	redirectURIs: z.array(z.union([
+		z.templateLiteral(["https://", z.string()]),
+		z.templateLiteral(["http://", z.string()]),
+		z.templateLiteral([z.string(), ":url"]),
+		z.templateLiteral([
+			z.string(),
+			":url/",
+			z.string()
+		])
+	])),
+	clientType: z.union([
+		z.literal("confidential"),
+		z.literal("public"),
+		z.literal("browser")
+	]).optional()
+});
+const SCIMAuthorizationSchema = z.object({
+	type: z.union([z.literal("oauth2"), z.literal("bearer")]),
+	bearerSecret: secretValueSchema.optional()
+});
+const SCIMAttributeTypeSchema = z.union([
+	z.literal("string"),
+	z.literal("number"),
+	z.literal("boolean"),
+	z.literal("datetime"),
+	z.literal("complex")
+]);
+const SCIMAttributeSchema = z.object({
+	type: SCIMAttributeTypeSchema,
+	name: z.string(),
+	description: z.string().optional(),
+	mutability: z.union([
+		z.literal("readOnly"),
+		z.literal("readWrite"),
+		z.literal("writeOnly")
+	]).optional(),
+	required: z.boolean().optional(),
+	multiValued: z.boolean().optional(),
+	uniqueness: z.union([
+		z.literal("none"),
+		z.literal("server"),
+		z.literal("global")
+	]).optional(),
+	canonicalValues: z.array(z.string()).nullable().optional(),
+	get subAttributes() {
+		return z.array(SCIMAttributeSchema).nullable().optional();
+	}
+});
+const SCIMSchemaSchema = z.object({
+	name: z.string(),
+	attributes: z.array(SCIMAttributeSchema)
+});
+const SCIMAttributeMappingSchema = z.object({
+	tailorDBField: z.string(),
+	scimPath: z.string()
+});
+const SCIMResourceSchema = z.object({
+	name: z.string(),
+	tailorDBNamespace: z.string(),
+	tailorDBType: z.string(),
+	coreSchema: SCIMSchemaSchema,
+	attributeMapping: z.array(SCIMAttributeMappingSchema)
+});
+const SCIMSchema = z.object({
+	machineUserName: z.string(),
+	authorization: SCIMAuthorizationSchema,
+	resources: z.array(SCIMResourceSchema)
+});
+const TenantProviderSchema = z.object({
+	namespace: z.string(),
+	type: z.string(),
+	signatureField: z.string()
+});
+const UserProfileSchema = z.object({
+	type: z.object({
+		name: z.string(),
+		fields: z.any(),
+		metadata: z.any(),
+		hooks: z.any(),
+		validate: z.any(),
+		features: z.any(),
+		indexes: z.any(),
+		files: z.any(),
+		permission: z.any(),
+		gqlPermission: z.any(),
+		_output: z.any()
+	}),
+	usernameField: z.string(),
+	attributes: z.record(z.string(), z.literal(true)).optional(),
+	attributeList: z.array(z.string()).optional()
+});
+const ValueOperandSchema = z.union([
+	z.string(),
+	z.boolean(),
+	z.array(z.string()),
+	z.array(z.boolean())
+]);
+const MachineUserSchema = z.object({
+	attributes: z.record(z.string(), ValueOperandSchema).optional(),
+	attributeList: z.array(z.uuid()).optional()
+});
+const AuthConfigSchema = z.object({
+	name: z.string(),
+	userProfile: UserProfileSchema.optional(),
+	machineUsers: z.record(z.string(), MachineUserSchema).optional(),
+	oauth2Clients: z.record(z.string(), OAuth2ClientSchema).optional(),
+	idProvider: IdProviderSchema.optional(),
+	scim: SCIMSchema.optional(),
+	tenantProvider: TenantProviderSchema.optional()
+}).brand("AuthConfig");
+
 //#endregion
 //#region src/parser/service/common.ts
 const functionSchema = z.custom((val) => typeof val === "function");
 
 //#endregion
 //#region src/parser/service/executor/schema.ts
-const InvokerSchema = z.object({
-	authName: z.string(),
-	machineUser: z.string()
-});
 const RecordTriggerSchema = z.object({
 	kind: z.enum([
 		"recordCreated",
@@ -154,14 +318,14 @@ const TriggerSchema = z.discriminatedUnion("kind", [
 const FunctionOperationSchema = z.object({
 	kind: z.enum(["function", "jobFunction"]),
 	body: functionSchema,
-	invoker: InvokerSchema.optional()
+	authInvoker: AuthInvokerSchema.optional()
 });
 const GqlOperationSchema = z.object({
 	kind: z.literal("graphql"),
 	appName: z.string().optional(),
 	query: z.string(),
 	variables: functionSchema.optional(),
-	invoker: InvokerSchema.optional()
+	authInvoker: AuthInvokerSchema.optional()
 });
 const WebhookOperationSchema = z.object({
 	kind: z.literal("webhook"),
@@ -587,9 +751,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 +763,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 +791,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 +812,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
@@ -691,29 +837,583 @@ async function loadFileContent(filePath) {
 			}
 		}
 	} catch (error) {
-		const relativePath = path.relative(process.cwd(), filePath);
-		console.error(styleText("red", "Failed to load workflow from"), styleText("redBright", relativePath));
-		console.error(error);
-		throw error;
+		const relativePath = path.relative(process.cwd(), filePath);
+		console.error(styleText("red", "Failed to load workflow from"), styleText("redBright", relativePath));
+		console.error(error);
+		throw error;
+	}
+	return {
+		jobs,
+		workflow
+	};
+}
+/**
+* Check if a value is a WorkflowJob by looking for the brand symbol
+*/
+function isWorkflowJob(value) {
+	return value != null && typeof value === "object" && WORKFLOW_JOB_BRAND in value && value[WORKFLOW_JOB_BRAND] === true;
+}
+
+//#endregion
+//#region src/cli/bundler/workflow/ast-utils.ts
+/**
+* Check if a module source is from \@tailor-platform/sdk (including subpaths)
+*/
+function isTailorSdkSource(source) {
+	return /^@tailor-platform\/sdk(\/|$)/.test(source);
+}
+/**
+* Get the source string from a dynamic import or require call
+*/
+function getImportSource(node) {
+	if (!node) return null;
+	if (node.type === "ImportExpression") {
+		const source = node.source;
+		if (source.type === "Literal" && typeof source.value === "string") return source.value;
+	}
+	if (node.type === "CallExpression") {
+		const callExpr = node;
+		if (callExpr.callee.type === "Identifier" && callExpr.callee.name === "require") {
+			const arg = callExpr.arguments[0];
+			if (arg && "type" in arg && arg.type === "Literal" && "value" in arg && typeof arg.value === "string") return arg.value;
+		}
+	}
+	return null;
+}
+/**
+* Unwrap AwaitExpression to get the inner expression
+*/
+function unwrapAwait(node) {
+	if (node?.type === "AwaitExpression") return node.argument;
+	return node;
+}
+/**
+* Check if a node is a string literal
+*/
+function isStringLiteral(node) {
+	return node?.type === "Literal" && typeof node.value === "string";
+}
+/**
+* Check if a node is a function expression (arrow or regular)
+*/
+function isFunctionExpression(node) {
+	return node?.type === "ArrowFunctionExpression" || node?.type === "FunctionExpression";
+}
+/**
+* Find a property in an object expression
+*/
+function findProperty(properties, name) {
+	for (const prop of properties) if (prop.type === "Property") {
+		const objProp = prop;
+		if ((objProp.key.type === "Identifier" ? objProp.key.name : objProp.key.type === "Literal" ? objProp.key.value : null) === name) return {
+			key: objProp.key,
+			value: objProp.value,
+			start: objProp.start,
+			end: objProp.end
+		};
+	}
+	return null;
+}
+/**
+* Apply string replacements to source code
+* Replacements are applied from end to start to maintain positions
+*/
+function applyReplacements(source, replacements) {
+	const sorted = [...replacements].sort((a, b) => b.start - a.start);
+	let result = source;
+	for (const r of sorted) result = result.slice(0, r.start) + r.text + result.slice(r.end);
+	return result;
+}
+/**
+* Find the end of a statement including any trailing newline
+*/
+function findStatementEnd(source, position) {
+	let i = position;
+	while (i < source.length && (source[i] === ";" || source[i] === " " || source[i] === "	")) i++;
+	if (i < source.length && source[i] === "\n") i++;
+	return i;
+}
+/**
+* Resolve a relative path from a base directory
+* Simple implementation that handles ./ and ../ prefixes
+*/
+function resolvePath(baseDir, relativePath) {
+	const parts = relativePath.replace(/\\/g, "/").split("/");
+	const baseParts = baseDir.replace(/\\/g, "/").split("/");
+	for (const part of parts) if (part === ".") {} else if (part === "..") baseParts.pop();
+	else baseParts.push(part);
+	return baseParts.join("/");
+}
+
+//#endregion
+//#region src/cli/bundler/workflow/sdk-binding-collector.ts
+/**
+* Collect all import bindings for a specific function from \@tailor-platform/sdk
+* Returns a Set of local names that refer to the function
+*/
+function collectSdkBindings(program, functionName) {
+	const bindings = /* @__PURE__ */ new Set();
+	function walk(node) {
+		if (!node || typeof node !== "object") return;
+		const nodeType = node.type;
+		if (nodeType === "ImportDeclaration") {
+			const importDecl = node;
+			const source = importDecl.source?.value;
+			if (typeof source === "string" && isTailorSdkSource(source)) {
+				for (const specifier of importDecl.specifiers || []) if (specifier.type === "ImportSpecifier") {
+					const importSpec = specifier;
+					const imported = importSpec.imported.type === "Identifier" ? importSpec.imported.name : importSpec.imported.value;
+					if (imported === functionName) bindings.add(importSpec.local?.name || imported);
+				} else if (specifier.type === "ImportDefaultSpecifier" || specifier.type === "ImportNamespaceSpecifier") {
+					const spec = specifier;
+					bindings.add(`__namespace__:${spec.local?.name}`);
+				}
+			}
+		}
+		if (nodeType === "VariableDeclaration") {
+			const varDecl = node;
+			for (const decl of varDecl.declarations || []) {
+				const init = unwrapAwait(decl.init);
+				const source = getImportSource(init);
+				if (source && isTailorSdkSource(source)) {
+					const id = decl.id;
+					if (id?.type === "Identifier") bindings.add(`__namespace__:${id.name}`);
+					else if (id?.type === "ObjectPattern") {
+						const objPattern = id;
+						for (const prop of objPattern.properties || []) if (prop.type === "Property") {
+							const bindingProp = prop;
+							const keyName = bindingProp.key.type === "Identifier" ? bindingProp.key.name : bindingProp.key.value;
+							if (keyName === functionName) {
+								const localName = bindingProp.value.type === "Identifier" ? bindingProp.value.name : keyName;
+								bindings.add(localName ?? "");
+							}
+						}
+					}
+				}
+			}
+		}
+		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 bindings;
+}
+/**
+* Check if a CallExpression is a call to a specific SDK function
+*/
+function isSdkFunctionCall(node, bindings, functionName) {
+	if (node.type !== "CallExpression") return false;
+	const callee = node.callee;
+	if (callee.type === "Identifier") {
+		const identifier = callee;
+		return bindings.has(identifier.name);
+	}
+	if (callee.type === "MemberExpression") {
+		const memberExpr = callee;
+		if (!memberExpr.computed) {
+			const object = memberExpr.object;
+			const property = memberExpr.property;
+			if (object.type === "Identifier" && bindings.has(`__namespace__:${object.name}`) && property.name === functionName) return true;
+		}
+	}
+	return false;
+}
+
+//#endregion
+//#region src/cli/bundler/workflow/job-detector.ts
+/**
+* Find all workflow jobs by detecting createWorkflowJob calls from \@tailor-platform/sdk
+*/
+function findAllJobs(program, _sourceText) {
+	const jobs = [];
+	const bindings = collectSdkBindings(program, "createWorkflowJob");
+	function walk(node, parents = []) {
+		if (!node || typeof node !== "object") return;
+		if (isSdkFunctionCall(node, bindings, "createWorkflowJob")) {
+			const args = node.arguments;
+			if (args?.length >= 1 && args[0]?.type === "ObjectExpression") {
+				const configObj = args[0];
+				const nameProp = findProperty(configObj.properties, "name");
+				const bodyProp = findProperty(configObj.properties, "body");
+				if (nameProp && isStringLiteral(nameProp.value) && bodyProp && isFunctionExpression(bodyProp.value)) {
+					let statementRange;
+					let exportName;
+					for (let i = parents.length - 1; i >= 0; i--) {
+						const parent = parents[i];
+						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
+						},
+						bodyValueRange: {
+							start: bodyProp.value.start,
+							end: bodyProp.value.end
+						},
+						statementRange
+					});
+				}
+			}
+		}
+		const newParents = [...parents, node];
+		for (const key of Object.keys(node)) {
+			const child = node[key];
+			if (Array.isArray(child)) child.forEach((c) => walk(c, newParents));
+			else if (child && typeof child === "object") walk(child, newParents);
+		}
+	}
+	walk(program);
+	return jobs;
+}
+/**
+* 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;
+}
+/**
+* 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;
+}
+
+//#endregion
+//#region src/cli/bundler/workflow/workflow-detector.ts
+/**
+* Find all workflows by detecting createWorkflow calls from \@tailor-platform/sdk
+*/
+function findAllWorkflows(program, _sourceText) {
+	const workflows = [];
+	const bindings = collectSdkBindings(program, "createWorkflow");
+	function walk(node, parents = []) {
+		if (!node || typeof node !== "object") return;
+		if (isSdkFunctionCall(node, bindings, "createWorkflow")) {
+			const args = node.arguments;
+			if (args?.length >= 1 && args[0]?.type === "ObjectExpression") {
+				const configObj = args[0];
+				const nameProp = findProperty(configObj.properties, "name");
+				if (nameProp && isStringLiteral(nameProp.value)) {
+					let exportName;
+					let isDefaultExport = false;
+					for (let i = parents.length - 1; i >= 0; i--) {
+						const parent = parents[i];
+						if (parent.type === "VariableDeclarator") {
+							const declarator = parent;
+							if (declarator.id?.type === "Identifier") {
+								exportName = declarator.id.name;
+								break;
+							}
+						}
+						if (parent.type === "ExportDefaultDeclaration") isDefaultExport = true;
+					}
+					workflows.push({
+						name: nameProp.value.value,
+						exportName,
+						isDefaultExport
+					});
+				}
+			}
+		}
+		const newParents = [...parents, node];
+		for (const key of Object.keys(node)) {
+			const child = node[key];
+			if (Array.isArray(child)) child.forEach((c) => walk(c, newParents));
+			else if (child && typeof child === "object") walk(child, newParents);
+		}
+	}
+	walk(program);
+	return workflows;
+}
+/**
+* Build a map from export name to workflow name from detected workflows
+*/
+function buildWorkflowNameMap(workflows) {
+	const map = /* @__PURE__ */ new Map();
+	for (const workflow of workflows) if (workflow.exportName) map.set(workflow.exportName, workflow.name);
+	return map;
+}
+/**
+* Detect default imports in a source file and return a map from local name to import source
+*/
+function detectDefaultImports(program) {
+	const imports = /* @__PURE__ */ new Map();
+	function walk(node) {
+		if (!node || typeof node !== "object") return;
+		if (node.type === "ImportDeclaration") {
+			const importDecl = node;
+			const source = importDecl.source?.value;
+			if (typeof source === "string") {
+				for (const specifier of importDecl.specifiers || []) if (specifier.type === "ImportDefaultSpecifier") {
+					const spec = specifier;
+					if (spec.local?.name) imports.set(spec.local.name, source);
+				}
+			}
+		}
+		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 imports;
+}
+
+//#endregion
+//#region src/cli/bundler/workflow/trigger-transformer.ts
+/**
+* Extract authInvoker info from a config object expression
+* Returns the authInvoker value text and whether it's a shorthand property
+*/
+function extractAuthInvokerInfo(configArg, sourceText) {
+	if (!configArg || typeof configArg !== "object") return void 0;
+	if (configArg.type !== "ObjectExpression") return void 0;
+	const objExpr = configArg;
+	for (const prop of objExpr.properties) {
+		if (prop.type !== "Property") continue;
+		const objProp = prop;
+		if ((objProp.key.type === "Identifier" ? objProp.key.name : objProp.key.type === "Literal" ? objProp.key.value : null) === "authInvoker") {
+			if (objProp.shorthand) return {
+				isShorthand: true,
+				valueText: "authInvoker"
+			};
+			return {
+				isShorthand: false,
+				valueText: sourceText.slice(objProp.value.start, objProp.value.end)
+			};
+		}
+	}
+}
+/**
+* Detect .trigger() calls for known workflows and jobs
+* Only detects calls where the identifier is in workflowNames or jobNames
+*
+* @param program - The parsed AST program
+* @param sourceText - The source code text
+* @param workflowNames - Set of known workflow identifier names
+* @param jobNames - Set of known job identifier names
+*/
+function detectExtendedTriggerCalls(program, sourceText, workflowNames, jobNames) {
+	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;
+					const isWorkflow = workflowNames.has(identifierName);
+					const isJob = jobNames.has(identifierName);
+					if (!isWorkflow && !isJob) return;
+					const argCount = callExpr.arguments.length;
+					let argsText = "";
+					if (argCount > 0) {
+						const firstArg = callExpr.arguments[0];
+						if (firstArg && "start" in firstArg && "end" in firstArg) argsText = sourceText.slice(firstArg.start, firstArg.end);
+					}
+					if (isWorkflow && argCount >= 2) {
+						const secondArg = callExpr.arguments[1];
+						const authInvoker = extractAuthInvokerInfo(secondArg, sourceText);
+						if (authInvoker) calls.push({
+							kind: "workflow",
+							identifierName,
+							callRange: {
+								start: callExpr.start,
+								end: callExpr.end
+							},
+							argsText,
+							authInvoker
+						});
+					} else if (isJob) calls.push({
+						kind: "job",
+						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;
+}
+/**
+* Transform trigger calls for resolver/executor/workflow functions
+* Handles both job.trigger() and workflow.trigger() calls
+*
+* @param source - The source code to transform
+* @param workflowNameMap - Map from variable name to workflow name
+* @param jobNameMap - Map from variable name to job name
+* @param workflowFileMap - Map from file path (without extension) to workflow name for default exports
+* @param currentFilePath - Path of the current file being transformed (for resolving relative imports)
+*/
+function transformFunctionTriggers(source, workflowNameMap, jobNameMap, workflowFileMap, currentFilePath) {
+	const { program } = parseSync("input.ts", source);
+	const localWorkflowNameMap = new Map(workflowNameMap);
+	if (workflowFileMap && currentFilePath) {
+		const defaultImports = detectDefaultImports(program);
+		const currentDir = currentFilePath.replace(/[/\\][^/\\]+$/, "");
+		for (const [localName, importSource] of defaultImports) {
+			if (!importSource.startsWith(".")) continue;
+			const resolvedPath = resolvePath(currentDir, importSource);
+			const workflowName = workflowFileMap.get(resolvedPath);
+			if (workflowName) localWorkflowNameMap.set(localName, workflowName);
+		}
+	}
+	const workflowNames = new Set(localWorkflowNameMap.keys());
+	const jobNames = new Set(jobNameMap.keys());
+	const triggerCalls = detectExtendedTriggerCalls(program, source, workflowNames, jobNames);
+	const replacements = [];
+	for (const call of triggerCalls) if (call.kind === "workflow" && call.authInvoker) {
+		const workflowName = localWorkflowNameMap.get(call.identifierName);
+		if (workflowName) {
+			const authInvokerExpr = call.authInvoker.isShorthand ? "authInvoker" : call.authInvoker.valueText;
+			const transformedCall = `tailor.workflow.triggerWorkflow("${workflowName}", ${call.argsText || "undefined"}, { authInvoker: ${authInvokerExpr} })`;
+			replacements.push({
+				start: call.callRange.start,
+				end: call.callRange.end,
+				text: transformedCall
+			});
+		}
+	} else if (call.kind === "job") {
+		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);
+}
+
+//#endregion
+//#region src/cli/bundler/trigger-context.ts
+/**
+* Normalize a file path by removing extension and resolving to absolute path
+*/
+function normalizeFilePath(filePath) {
+	const absolutePath = path.resolve(filePath);
+	const ext = path.extname(absolutePath);
+	return absolutePath.slice(0, -ext.length);
+}
+/**
+* Build trigger context from workflow configuration
+* Scans workflow files to collect workflow and job mappings
+*/
+async function buildTriggerContext(workflowConfig) {
+	const workflowNameMap = /* @__PURE__ */ new Map();
+	const jobNameMap = /* @__PURE__ */ new Map();
+	const workflowFileMap = /* @__PURE__ */ new Map();
+	if (!workflowConfig) return {
+		workflowNameMap,
+		jobNameMap,
+		workflowFileMap
+	};
+	const workflowFiles = loadFilesWithIgnores(workflowConfig);
+	for (const file of workflowFiles) try {
+		const source = await fs.promises.readFile(file, "utf-8");
+		const { program } = parseSync("input.ts", source);
+		const workflows = findAllWorkflows(program, source);
+		const workflowMap = buildWorkflowNameMap(workflows);
+		for (const [exportName, workflowName] of workflowMap) workflowNameMap.set(exportName, workflowName);
+		for (const workflow of workflows) if (workflow.isDefaultExport) {
+			const normalizedPath = normalizeFilePath(file);
+			workflowFileMap.set(normalizedPath, workflow.name);
+		}
+		const jobs = findAllJobs(program, source);
+		const jobMap = buildJobNameMap(jobs);
+		for (const [exportName, jobName] of jobMap) jobNameMap.set(exportName, jobName);
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		console.warn(styleText("yellow", `Warning: Failed to process workflow file ${file}: ${errorMessage}`));
+		continue;
 	}
 	return {
-		jobs,
-		workflow
+		workflowNameMap,
+		jobNameMap,
+		workflowFileMap
 	};
 }
 /**
-* Check if a value is a WorkflowJob by looking for the brand symbol
-*/
-function isWorkflowJob(value) {
-	return value != null && typeof value === "object" && WORKFLOW_JOB_BRAND in value && value[WORKFLOW_JOB_BRAND] === true;
-}
-/**
-* Recursively trace all job dependencies
+* Create a rolldown plugin for transforming trigger calls
+* Returns undefined if no trigger context is provided
 */
-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);
+function createTriggerTransformPlugin(triggerContext) {
+	if (!triggerContext) return;
+	return {
+		name: "trigger-transform",
+		transform: {
+			filter: { id: { include: [/\.ts$/, /\.js$/] } },
+			handler(code, id) {
+				if (!code.includes(".trigger(")) return null;
+				return { code: transformFunctionTriggers(code, triggerContext.workflowNameMap, triggerContext.jobNameMap, triggerContext.workflowFileMap, id) };
+			}
+		}
+	};
 }
 
 //#endregion
@@ -734,7 +1434,7 @@ async function loadExecutor(executorFilePath) {
 * 1. Creates entry file that extracts operation.body
 * 2. Bundles in a single step with tree-shaking
 */
-async function bundleExecutors(config) {
+async function bundleExecutors(config, triggerContext) {
 	const files = loadFilesWithIgnores(config);
 	if (files.length === 0) throw new Error(`No files found matching pattern: ${config.files?.join(", ")}`);
 	console.log("");
@@ -767,10 +1467,10 @@ async function bundleExecutors(config) {
 	} catch {
 		tsconfig = void 0;
 	}
-	await Promise.all(executors.map((executor) => bundleSingleExecutor(executor, outputDir, tsconfig)));
+	await Promise.all(executors.map((executor) => bundleSingleExecutor(executor, outputDir, tsconfig, triggerContext)));
 	console.log(styleText("green", "Bundled"), styleText("cyan", "\"executor\""));
 }
-async function bundleSingleExecutor(executor, outputDir, tsconfig) {
+async function bundleSingleExecutor(executor, outputDir, tsconfig, triggerContext) {
 	const entryPath = path.join(outputDir, `${executor.name}.entry.js`);
 	const absoluteSourcePath = path.resolve(executor.sourceFile).replace(/\\/g, "/");
 	const entryContent = ml`
@@ -782,6 +1482,8 @@ async function bundleSingleExecutor(executor, outputDir, tsconfig) {
   `;
 	fs.writeFileSync(entryPath, entryContent);
 	const outputPath = path.join(outputDir, `${executor.name}.js`);
+	const triggerPlugin = createTriggerTransformPlugin(triggerContext);
+	const plugins = triggerPlugin ? [triggerPlugin] : [];
 	await rolldown.build(rolldown.defineConfig({
 		input: entryPath,
 		output: {
@@ -792,6 +1494,7 @@ async function bundleSingleExecutor(executor, outputDir, tsconfig) {
 			inlineDynamicImports: true
 		},
 		tsconfig,
+		plugins,
 		treeshake: {
 			moduleSideEffects: false,
 			annotations: true,
@@ -820,7 +1523,7 @@ async function loadResolver(resolverFilePath) {
 * 2. Creates entry file
 * 3. Bundles in a single step with tree-shaking
 */
-async function bundleResolvers(namespace, config) {
+async function bundleResolvers(namespace, config, triggerContext) {
 	const files = loadFilesWithIgnores(config);
 	if (files.length === 0) throw new Error(`No files found matching pattern: ${config.files?.join(", ")}`);
 	console.log("");
@@ -845,10 +1548,10 @@ async function bundleResolvers(namespace, config) {
 	} catch {
 		tsconfig = void 0;
 	}
-	await Promise.all(resolvers.map((resolver) => bundleSingleResolver(resolver, outputDir, tsconfig)));
+	await Promise.all(resolvers.map((resolver) => bundleSingleResolver(resolver, outputDir, tsconfig, triggerContext)));
 	console.log(styleText("green", "Bundled"), styleText("cyan", `"${namespace}"`));
 }
-async function bundleSingleResolver(resolver, outputDir, tsconfig) {
+async function bundleSingleResolver(resolver, outputDir, tsconfig, triggerContext) {
 	const entryPath = path.join(outputDir, `${resolver.name}.entry.js`);
 	const absoluteSourcePath = path.resolve(resolver.sourceFile).replace(/\\/g, "/");
 	const entryContent = ml`
@@ -881,6 +1584,8 @@ async function bundleSingleResolver(resolver, outputDir, tsconfig) {
   `;
 	fs.writeFileSync(entryPath, entryContent);
 	const outputPath = path.join(outputDir, `${resolver.name}.js`);
+	const triggerPlugin = createTriggerTransformPlugin(triggerContext);
+	const plugins = triggerPlugin ? [triggerPlugin] : [];
 	await rolldown.build(rolldown.defineConfig({
 		input: entryPath,
 		output: {
@@ -891,6 +1596,7 @@ async function bundleSingleResolver(resolver, outputDir, tsconfig) {
 			inlineDynamicImports: true
 		},
 		tsconfig,
+		plugins,
 		treeshake: {
 			moduleSideEffects: false,
 			annotations: true,
@@ -901,227 +1607,7 @@ async function bundleSingleResolver(resolver, outputDir, tsconfig) {
 }
 
 //#endregion
-//#region src/cli/bundler/workflow/ast-transformer.ts
-/**
-* Check if a module source is from \@tailor-platform/sdk (including subpaths)
-*/
-function isTailorSdkSource(source) {
-	return /^@tailor-platform\/sdk(\/|$)/.test(source);
-}
-/**
-* Get the source string from a dynamic import or require call
-*/
-function getImportSource(node) {
-	if (!node) return null;
-	if (node.type === "ImportExpression") {
-		const source = node.source;
-		if (source.type === "Literal" && typeof source.value === "string") return source.value;
-	}
-	if (node.type === "CallExpression") {
-		const callExpr = node;
-		if (callExpr.callee.type === "Identifier" && callExpr.callee.name === "require") {
-			const arg = callExpr.arguments[0];
-			if (arg && "type" in arg && arg.type === "Literal" && "value" in arg && typeof arg.value === "string") return arg.value;
-		}
-	}
-	return null;
-}
-/**
-* Unwrap AwaitExpression to get the inner expression
-*/
-function unwrapAwait(node) {
-	if (node?.type === "AwaitExpression") return node.argument;
-	return node;
-}
-/**
-* Collect all import bindings for createWorkflowJob from \@tailor-platform/sdk
-* Returns a Set of local names that refer to createWorkflowJob
-*/
-function collectCreateWorkflowJobBindings(program) {
-	const bindings = /* @__PURE__ */ new Set();
-	function walk(node) {
-		if (!node || typeof node !== "object") return;
-		const nodeType = node.type;
-		if (nodeType === "ImportDeclaration") {
-			const importDecl = node;
-			const source = importDecl.source?.value;
-			if (typeof source === "string" && isTailorSdkSource(source)) {
-				for (const specifier of importDecl.specifiers || []) if (specifier.type === "ImportSpecifier") {
-					const importSpec = specifier;
-					const imported = importSpec.imported.type === "Identifier" ? importSpec.imported.name : importSpec.imported.value;
-					if (imported === "createWorkflowJob") bindings.add(importSpec.local?.name || imported);
-				} else if (specifier.type === "ImportDefaultSpecifier" || specifier.type === "ImportNamespaceSpecifier") {
-					const spec = specifier;
-					bindings.add(`__namespace__:${spec.local?.name}`);
-				}
-			}
-		}
-		if (nodeType === "VariableDeclaration") {
-			const varDecl = node;
-			for (const decl of varDecl.declarations || []) {
-				const init = unwrapAwait(decl.init);
-				const source = getImportSource(init);
-				if (source && isTailorSdkSource(source)) {
-					const id = decl.id;
-					if (id?.type === "Identifier") bindings.add(`__namespace__:${id.name}`);
-					else if (id?.type === "ObjectPattern") {
-						const objPattern = id;
-						for (const prop of objPattern.properties || []) if (prop.type === "Property") {
-							const bindingProp = prop;
-							const keyName = bindingProp.key.type === "Identifier" ? bindingProp.key.name : bindingProp.key.value;
-							if (keyName === "createWorkflowJob") {
-								const localName = bindingProp.value.type === "Identifier" ? bindingProp.value.name : keyName;
-								bindings.add(localName ?? "");
-							}
-						}
-					}
-				}
-			}
-		}
-		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 bindings;
-}
-/**
-* Check if a CallExpression is a createWorkflowJob call
-*/
-function isCreateWorkflowJobCall(node, bindings) {
-	if (node.type !== "CallExpression") return false;
-	const callee = node.callee;
-	if (callee.type === "Identifier") {
-		const identifier = callee;
-		return bindings.has(identifier.name);
-	}
-	if (callee.type === "MemberExpression") {
-		const memberExpr = callee;
-		if (!memberExpr.computed) {
-			const object = memberExpr.object;
-			const property = memberExpr.property;
-			if (object.type === "Identifier" && bindings.has(`__namespace__:${object.name}`) && property.name === "createWorkflowJob") return true;
-		}
-	}
-	return false;
-}
-/**
-* Check if a node is a string literal
-*/
-function isStringLiteral(node) {
-	return node?.type === "Literal" && typeof node.value === "string";
-}
-/**
-* Check if a node is a function expression (arrow or regular)
-*/
-function isFunctionExpression(node) {
-	return node?.type === "ArrowFunctionExpression" || node?.type === "FunctionExpression";
-}
-/**
-* Find a property in an object expression
-*/
-function findProperty(properties, name) {
-	for (const prop of properties) if (prop.type === "Property") {
-		const objProp = prop;
-		if ((objProp.key.type === "Identifier" ? objProp.key.name : objProp.key.type === "Literal" ? objProp.key.value : null) === name) return {
-			key: objProp.key,
-			value: objProp.value,
-			start: objProp.start,
-			end: objProp.end
-		};
-	}
-	return null;
-}
-/**
-* Find all workflow jobs by detecting createWorkflowJob calls from \@tailor-platform/sdk
-*/
-function findAllJobs(program, _sourceText) {
-	const jobs = [];
-	const bindings = collectCreateWorkflowJobBindings(program);
-	function walk(node, parents = []) {
-		if (!node || typeof node !== "object") return;
-		if (isCreateWorkflowJobCall(node, bindings)) {
-			const args = node.arguments;
-			if (args?.length >= 1 && args[0]?.type === "ObjectExpression") {
-				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++) {
-						const parent = parents[i];
-						if (parent.type === "ExportNamedDeclaration" || parent.type === "VariableDeclaration") {
-							statementRange = {
-								start: parent.start,
-								end: parent.end
-							};
-							break;
-						}
-					}
-					jobs.push({
-						name: nameProp.value.value,
-						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
-						},
-						statementRange
-					});
-				}
-			}
-		}
-		const newParents = [...parents, node];
-		for (const key of Object.keys(node)) {
-			const child = node[key];
-			if (Array.isArray(child)) child.forEach((c) => walk(c, newParents));
-			else if (child && typeof child === "object") walk(child, newParents);
-		}
-	}
-	walk(program);
-	return jobs;
-}
-/**
-* Apply string replacements to source code
-* Replacements are applied from end to start to maintain positions
-*/
-function applyReplacements(source, replacements) {
-	const sorted = [...replacements].sort((a, b) => b.start - a.start);
-	let result = source;
-	for (const r of sorted) result = result.slice(0, r.start) + r.text + result.slice(r.end);
-	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) {
-	let i = position;
-	while (i < source.length && (source[i] === ";" || source[i] === " " || source[i] === "	")) i++;
-	if (i < source.length && source[i] === "\n") i++;
-	return i;
-}
+//#region src/cli/bundler/workflow/source-transformer.ts
 /**
 * Find variable declarations by export names
 * Returns a map of export name to statement range
@@ -1162,54 +1648,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 +1727,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 = {}, triggerContext) {
 	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 +1748,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, triggerContext)));
 	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, triggerContext) {
 	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: {
@@ -1276,9 +1837,11 @@ async function bundleSingleJob(job, allJobs, outputDir, tsconfig) {
 			name: "workflow-transform",
 			transform: {
 				filter: { id: { include: [/\.ts$/, /\.js$/] } },
-				handler(code) {
-					if (!code.includes("createWorkflowJob")) return null;
-					return { code: transformWorkflowSource(code, job.name, job.exportName, otherJobExportNames) };
+				handler(code, id) {
+					if (!code.includes("createWorkflowJob") && !code.includes("createWorkflow") && !code.includes(".trigger(")) return null;
+					let transformed = transformWorkflowSource(code, job.name, job.exportName, otherJobExportNames, allJobsMap);
+					if (triggerContext && transformed.includes(".trigger(")) transformed = transformFunctionTriggers(transformed, triggerContext.workflowNameMap, triggerContext.jobNameMap, triggerContext.workflowFileMap, id);
+					return { code: transformed };
 				}
 			}
 		}],
@@ -1290,18 +1853,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
@@ -3866,12 +4417,12 @@ function protoIdPConfig(idpConfig) {
 				value: {
 					...idpConfig.metadataURL !== void 0 ? { metadataUrl: idpConfig.metadataURL } : { rawMetadata: idpConfig.rawMetadata },
 					...idpConfig.spCertBase64 && { spCertBase64: {
-						vaultName: idpConfig.spCertBase64.VaultName,
-						secretKey: idpConfig.spCertBase64.SecretKey
+						vaultName: idpConfig.spCertBase64.vaultName,
+						secretKey: idpConfig.spCertBase64.secretKey
 					} },
 					...idpConfig.spKeyBase64 && { spKeyBase64: {
-						vaultName: idpConfig.spKeyBase64.VaultName,
-						secretKey: idpConfig.spKeyBase64.SecretKey
+						vaultName: idpConfig.spKeyBase64.vaultName,
+						secretKey: idpConfig.spKeyBase64.secretKey
 					} }
 				}
 			} }
@@ -3884,8 +4435,8 @@ function protoIdPConfig(idpConfig) {
 				value: {
 					clientIdKey: idpConfig.clientID,
 					clientSecretKey: {
-						vaultName: idpConfig.clientSecret.VaultName,
-						secretKey: idpConfig.clientSecret.SecretKey
+						vaultName: idpConfig.clientSecret.vaultName,
+						secretKey: idpConfig.clientSecret.secretKey
 					},
 					providerUrl: idpConfig.providerURL,
 					issuerUrl: idpConfig.issuerURL,
@@ -4321,8 +4872,8 @@ function protoSCIMConfig(scimConfig) {
 		authorizationConfig: {
 			case: "bearerSecret",
 			value: {
-				vaultName: scimConfig.authorization.bearerSecret?.VaultName,
-				secretKey: scimConfig.authorization.bearerSecret?.SecretKey
+				vaultName: scimConfig.authorization.bearerSecret?.vaultName,
+				secretKey: scimConfig.authorization.bearerSecret?.secretKey
 			}
 		}
 	};
@@ -4709,10 +5260,7 @@ function protoExecutor(appName, executor, env) {
 					appName: target.appName ?? appName,
 					query: target.query,
 					variables: target.variables ? { expr: `(${target.variables.toString()})(args)` } : void 0,
-					invoker: target.invoker ? {
-						namespace: target.invoker.authName,
-						machineUserName: target.invoker.machineUser
-					} : void 0
+					invoker: target.authInvoker ?? void 0
 				}
 			} };
 			break;
@@ -4728,10 +5276,7 @@ function protoExecutor(appName, executor, env) {
 					name: `${executor.name}__target`,
 					script,
 					variables: { expr: `({ ...args, appNamespace: args.namespaceName, env: ${JSON.stringify(env)} })` },
-					invoker: target.invoker ? {
-						namespace: target.invoker.authName,
-						machineUserName: target.invoker.machineUser
-					} : void 0
+					invoker: target.authInvoker ?? void 0
 				}
 			} };
 			break;
@@ -5685,59 +6230,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 +6309,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 +6325,7 @@ async function planWorkflow(client, workspaceId, appName, workflows) {
 				name: workflow.name,
 				workspaceId,
 				workflow,
-				scripts,
+				scripts: allScripts,
 				metaRequest
 			});
 			delete existingWorkflows[workflow.name];
@@ -5798,7 +6333,7 @@ async function planWorkflow(client, workspaceId, appName, workflows) {
 			name: workflow.name,
 			workspaceId,
 			workflow,
-			scripts,
+			scripts: allScripts,
 			metaRequest
 		});
 	}
@@ -5824,7 +6359,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");
@@ -5844,9 +6379,13 @@ async function apply(options) {
 	const application = defineApplication(config);
 	let workflowResult;
 	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);
+	const triggerContext = await buildTriggerContext(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, triggerContext);
+	if (application.executorService) await buildExecutor(application.executorService.config, triggerContext);
+	if (workflowResult && workflowResult.jobs.length > 0) {
+		const mainJobNames = workflowResult.workflowSources.map((ws) => ws.workflow.mainJob.name);
+		await buildWorkflow(workflowResult.jobs, mainJobNames, application.env, triggerContext);
+	}
 	if (buildOnly) return;
 	const accessToken = await loadAccessToken({
 		useProfile: true,
@@ -5945,14 +6484,14 @@ async function apply(options) {
 	await applyTailorDB(client, tailorDB, "delete");
 	console.log("Successfully applied changes.");
 }
-async function buildPipeline(namespace, config) {
-	await bundleResolvers(namespace, config);
+async function buildPipeline(namespace, config, triggerContext) {
+	await bundleResolvers(namespace, config, triggerContext);
 }
-async function buildExecutor(config) {
-	await bundleExecutors(config);
+async function buildExecutor(config, triggerContext) {
+	await bundleExecutors(config, triggerContext);
 }
-async function buildWorkflow(collectedJobs) {
-	await bundleWorkflowJobs(collectedJobs);
+async function buildWorkflow(collectedJobs, mainJobNames, env, triggerContext) {
+	await bundleWorkflowJobs(collectedJobs, mainJobNames, env, triggerContext);
 }
 const applyCommand = defineCommand({
 	meta: {
@@ -7384,4 +7923,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-B8Uv3SPW.mjs.map