@tailor-platform/sdk 1.76.1 → 1.78.0

package/dist/{application-BUfYmf0O.mjs → application-CUxVA7Fs.mjs}

@@ -1,32 +1,20 @@
 import { n as isSdkBranded } from "./brand-Eo4pLXPJ.mjs";
-import { i as PageDirection } from "./resource_pb-BRv7AMXK.mjs";
 import { t as assertDefined } from "./assert-DBxo8jPo.mjs";
-import { a as parseBoolean, n as logger, r as styles } from "./logger-BEiZZ3qT.mjs";
-import { a as TailorFieldSchema, i as AuthInvokerSchema, n as ExecutorSchema, o as loadFilesWithIgnores, r as AuthConfigSchema, s as functionSchema, t as createExecutorService } from "./service-BCRJ-3NV.mjs";
-import { n as enumConstantsPlugin, t as EnumConstantsGeneratorID } from "./enum-constants-j9QBF0cB.mjs";
+import { a as parseBoolean, n as logger, r as styles } from "./logger-BwS4ppwO.mjs";
+import { a as TailorFieldSchema, i as AuthInvokerSchema, n as ExecutorSchema, o as loadFilesWithIgnores, r as AuthConfigSchema, s as functionSchema, t as createExecutorService } from "./service-D12iQGcS.mjs";
 import { t as multiline } from "./multiline-sfHpTZZK.mjs";
-import { n as fileUtilsPlugin, t as FileUtilsGeneratorID } from "./file-utils-DcyIPFQh.mjs";
-import { n as kyselyTypePlugin, t as KyselyGeneratorID } from "./kysely-type-D-zflMGf.mjs";
-import { n as seedPlugin, r as isPluginGeneratedType, t as SeedGeneratorID } from "./seed-fm0LeYP2.mjs";
-import { t as readPackageJson } from "./package-json-8b0O9TlX.mjs";
-import { i as userAgent, n as tightenSecretFilePermissions, r as writeSecretFile } from "./secret-file-VSVGy1V0.mjs";
-import { t as createCLIError } from "./errors-Dtf2WPaW.mjs";
+import { t as isPluginGeneratedType } from "./type-source-DH_LH20p.mjs";
+import { t as userAgent } from "./user-agent-DX2Jnw0-.mjs";
 import { builtinModules, createRequire } from "node:module";
-import { arg } from "politty";
 import { z } from "zod";
 import { create } from "@bufbuild/protobuf";
 import * as fs$1 from "node:fs";
 import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { parseEnv } from "node:util";
 import { MethodOptions_IdempotencyLevel } from "@bufbuild/protobuf/wkt";
 import * as path from "pathe";
 import { join, resolve } from "pathe";
 import { pathToFileURL } from "node:url";
 import * as os from "node:os";
-import { parseTOML, parseYAML, stringifyYAML } from "confbox";
-import { findUpSync } from "find-up-simple";
-import { lt } from "semver";
-import { xdgConfig } from "xdg-basedir";
 import { OAuth2Client } from "@badgateway/oauth2-client";
 import { Code, ConnectError, createClient } from "@connectrpc/connect";
 import { getGlobalDispatcher } from "undici";
@@ -39,256 +27,6 @@ import { parseSync } from "oxc-parser";
 import * as inflection from "inflection";
 import * as globals from "globals";
 
-//#region src/cli/shared/args.ts
-const unitToMs = {
-	ms: 1,
-	s: 1e3,
-	m: 60 * 1e3
-};
-const durationPattern = /^(\d+)(ms|s|m)$/;
-/**
-* Schema for duration string validation (e.g., "3s", "500ms", "1m")
-* Only validates format; use parseDuration() to convert to milliseconds
-*/
-const durationArg = z.string().refine((val) => durationPattern.test(val), { message: "Invalid duration format. Expected format: '3s', '500ms', '1m'" }).refine((val) => {
-	const match = val.match(durationPattern);
-	if (!match) return false;
-	const digits = match[1];
-	return digits !== void 0 && parseInt(digits, 10) > 0;
-}, { message: "Duration must be greater than 0" });
-/**
-* Parse a validated duration string into milliseconds
-* @param duration - Duration string (e.g., "3s", "500ms", "1m")
-* @returns Duration in milliseconds
-*/
-function parseDuration(duration) {
-	const match = assertDefined(duration.match(durationPattern), `invalid duration format: ${duration}`);
-	const value = parseInt(assertDefined(match[1], "duration digits group missing"), 10);
-	const unit = assertDefined(match[2], "duration unit group missing");
-	return value * unitToMs[unit];
-}
-/**
-* Schema for positive integer validation (from string input)
-* Transforms the string to a number
-*/
-const positiveIntArg = z.coerce.number().int().positive();
-/**
-* Schema for non-negative integer validation (from string input).
-* Accepts 0 (used for `--limit 0` to disable the limit).
-*/
-const nonNegativeIntArg = z.coerce.number().int().nonnegative();
-/**
-* Schema for sort order (`asc` or `desc`).
-*/
-const orderArg = z.enum(["asc", "desc"]);
-/**
-* Translate a CLI `--order` value into the proto `PageDirection` enum.
-* Returns `undefined` when the user did not specify an order so that
-* callers can omit the field and fall back to the server default.
-* @param order - Order string from CLI args (`"asc"` | `"desc"` | undefined)
-* @returns PageDirection, or undefined when `order` is undefined
-*/
-function toPageDirection(order) {
-	if (order === void 0) return void 0;
-	return order === "asc" ? PageDirection.ASC : PageDirection.DESC;
-}
-function hasMachineUserFlag(argv) {
-	return argv.slice(0, argv.indexOf("--") === -1 ? argv.length : argv.indexOf("--")).some((token) => token === "-m" || token.startsWith("-m=") || token === "--machine-user" || token.startsWith("--machine-user=") || token === "--machineUser" || token.startsWith("--machineUser=") || token === "--machineuser" || token.startsWith("--machineuser="));
-}
-/**
-* Resolve whether a parsed machine user value came from an explicit CLI option or env fallback.
-* @param machineUser - Parsed machine user value
-* @param argv - Raw CLI argv, excluding the executable and script path
-* @param options - Source resolution options
-* @returns Machine user input source, or undefined when no value was parsed
-*/
-function resolveMachineUserInputSource(machineUser, argv = process.argv.slice(2), options = {}) {
-	if (machineUser === void 0) return void 0;
-	if (options.valueIsExplicit) return "option";
-	if (hasMachineUserFlag(argv)) return "option";
-	return process.env.TAILOR_PLATFORM_MACHINE_USER_NAME === machineUser ? "env" : "option";
-}
-/**
-* Load env files from parsed arguments.
-* Processes --env-file first, then --env-file-if-exists.
-*
-* Follows Node.js --env-file behavior:
-* - Variables already set in the environment are NOT overwritten
-* - Variables from later files override those from earlier files
-* @param envFiles - Required env file path(s) that must exist
-* @param envFilesIfExists - Optional env file path(s) that are loaded if they exist
-*/
-function loadEnvFiles(envFiles, envFilesIfExists) {
-	const originalEnvKeys = new Set(Object.keys(process.env));
-	const load = (files, required) => {
-		for (const file of [files ?? []].flat()) {
-			const envPath = path.resolve(process.cwd(), file);
-			if (!fs$1.existsSync(envPath)) {
-				if (required) throw new Error(`Environment file not found: ${envPath}`);
-				continue;
-			}
-			const parsed = parseEnv(fs$1.readFileSync(envPath, "utf-8"));
-			for (const [key, value] of Object.entries(parsed)) {
-				if (originalEnvKeys.has(key)) continue;
-				process.env[key] = value;
-			}
-		}
-	};
-	load(envFiles, true);
-	load(envFilesIfExists, false);
-}
-/**
-* Common arguments for all CLI commands
-*
-* NOTE: --env-file and --env-file-if-exists collide with Node.js flags due to a bug
-* (https://github.com/nodejs/node/issues/54232). Node.js parses these even after the
-* script path, causing warnings (twice due to tsx loader).
-*/
-const commonArgs = {
-	"env-file": arg(z.string().optional(), {
-		alias: "e",
-		description: "Path to the environment file (error if not found)",
-		completion: {
-			type: "file",
-			matcher: [".env.*", ".env"]
-		}
-	}),
-	"env-file-if-exists": arg(z.string().optional(), {
-		description: "Path to the environment file (ignored if not found)",
-		completion: {
-			type: "file",
-			matcher: [".env.*", ".env"]
-		},
-		effect: (_value, { args }) => {
-			loadEnvFiles(args["env-file"], args["env-file-if-exists"]);
-		}
-	}),
-	verbose: arg(z.boolean().default(false), {
-		description: "Enable verbose logging",
-		effect: (value) => {
-			verboseMode = value;
-		}
-	}),
-	json: arg(z.boolean().default(false), {
-		alias: "j",
-		description: "Output as JSON",
-		effect: (value) => {
-			logger.jsonMode = value;
-		}
-	})
-};
-/**
-* Arguments for commands that require workspace context
-*/
-const workspaceArgs = {
-	"workspace-id": arg(z.string().optional(), {
-		alias: "w",
-		description: "Workspace ID",
-		env: "TAILOR_PLATFORM_WORKSPACE_ID",
-		completion: { type: "none" }
-	}),
-	profile: arg(z.string().optional(), {
-		alias: "p",
-		description: "Workspace profile",
-		env: "TAILOR_PLATFORM_PROFILE",
-		completion: { type: "none" }
-	})
-};
-/**
-* Shared config arg for commands that accept a config file path
-*/
-const configArg = { config: arg(z.string().default("tailor.config.ts"), {
-	alias: "c",
-	description: "Path to SDK config file",
-	env: "TAILOR_PLATFORM_SDK_CONFIG_PATH",
-	completion: {
-		type: "file",
-		extensions: ["ts"]
-	}
-}) };
-/**
-* Shared config arg for commands that accept one or more comma-separated config file paths
-*/
-const multiConfigArg = { config: arg(z.string().default("tailor.config.ts"), {
-	alias: "c",
-	description: "Path to SDK config file. Use comma-separated paths to deploy multiple apps together.",
-	env: "TAILOR_PLATFORM_SDK_CONFIG_PATH",
-	completion: {
-		type: "file",
-		extensions: ["ts"]
-	}
-}) };
-/**
-* Arguments for commands that interact with deployed resources (includes config)
-*/
-const deploymentArgs = {
-	...workspaceArgs,
-	...configArg
-};
-/**
-* Arguments for commands that require confirmation
-*/
-const confirmationArgs = { yes: arg(z.boolean().default(false), {
-	alias: "y",
-	description: "Skip confirmation prompts"
-}) };
-/**
-* Arguments for commands that require organization context
-*/
-const organizationArgs = { "organization-id": arg(z.string(), {
-	alias: "o",
-	description: "Organization ID",
-	env: "TAILOR_PLATFORM_ORGANIZATION_ID",
-	completion: { type: "none" }
-}) };
-/**
-* Arguments for list commands that accept `--order` / `--limit`. Sort
-* order defaults to `desc` (newest first) because most callers want the
-* latest items; pass `--order asc` to opt in to ascending order. The
-* limit is unbounded by default so existing invocations keep returning
-* every item; pass `--limit N` to cap the result size.
-* @param defaultOrder - Default value for `--order` (defaults to `"desc"`)
-* @returns Argument shape suitable for spreading into a command schema
-*/
-const paginationArgs = (defaultOrder = "desc") => ({
-	order: arg(orderArg.default(defaultOrder), { description: "Sort order (asc or desc)" }),
-	limit: arg(nonNegativeIntArg.optional(), {
-		alias: "l",
-		description: "Maximum number of items to return (0 or omit: unlimited)"
-	})
-});
-/**
-* Arguments for time-series log list commands. Defaults to newest-first
-* (`desc`) and a 50-item cap so that listing stays responsive on busy
-* workspaces. Pass `--limit 0` to disable the cap and fetch all entries.
-*/
-const pagedLogArgs = {
-	order: arg(orderArg.default("desc"), { description: "Sort order (asc or desc)" }),
-	limit: arg(nonNegativeIntArg.default(50), {
-		alias: "l",
-		description: "Maximum number of items to return (0: unlimited)"
-	})
-};
-/**
-* Arguments for commands that require folder context
-*/
-const folderArgs = { "folder-id": arg(z.string(), {
-	alias: "f",
-	description: "Folder ID",
-	env: "TAILOR_PLATFORM_FOLDER_ID",
-	completion: { type: "none" }
-}) };
-let verboseMode = false;
-/**
-* Returns whether verbose mode is enabled.
-* Used by the global cleanup handler which doesn't have access to parsed args.
-* @returns Whether verbose mode is enabled
-*/
-function isVerbose() {
-	return verboseMode;
-}
-
-//#endregion
 //#region src/parser/app-config/log-level.ts
 const LOG_LEVELS = [
 	"DEBUG",
@@ -301,110 +39,6 @@ function isLogLevel(value) {
 	return LOG_LEVELS.includes(value);
 }
 
-//#endregion
-//#region src/parser/app-config/schema.ts
-const envValueSchema = z.union([
-	z.string(),
-	z.number(),
-	z.boolean()
-]);
-const LogLevelSchema = z.enum(LOG_LEVELS);
-const logLevelSchema = z.string().refine((value) => LogLevelSchema.safeParse(value.trim().toUpperCase()).success, { message: `'logLevel' must be one of: ${LOG_LEVELS.join(", ")}.` });
-/**
-* Structural validation schema for `defineConfig({...})`. Validates only
-* top-level fields with platform-side constraints (notably `id`); fields
-* that carry SDK builder objects (`auth`, `idp`, `db`, ...) are accepted
-* as opaque values, since their internal shapes are validated by their
-* own factory functions and parser-level schemas.
-*
-* The `id` is auto-managed by `deploy` and stored as a plain UUID. A
-* label-compatible prefix is added at the metadata boundary, so user-facing
-* configs only need to carry a UUID.
-*/
-const AppConfigSchema = z.object({
-	id: z.uuid({ message: "'id' must be a UUID." }).optional(),
-	name: z.string().min(1, { message: "'name' must be a non-empty string." }),
-	env: z.record(z.string(), envValueSchema).optional(),
-	cors: z.array(z.string()).optional(),
-	allowedIpAddresses: z.array(z.string()).optional(),
-	disableIntrospection: z.boolean().optional(),
-	inlineSourcemap: z.boolean().optional(),
-	logLevel: logLevelSchema.optional(),
-	db: z.unknown().optional(),
-	resolver: z.unknown().optional(),
-	idp: z.unknown().optional(),
-	auth: z.unknown().optional(),
-	executor: z.unknown().optional(),
-	workflow: z.unknown().optional(),
-	httpAdapter: z.unknown().optional(),
-	staticWebsites: z.unknown().optional(),
-	aiGateways: z.unknown().optional(),
-	secrets: z.unknown().optional()
-});
-
-//#endregion
-//#region src/parser/generator-config/schema.ts
-const DependencyKindSchema = z.enum([
-	"tailordb",
-	"resolver",
-	"executor"
-]);
-const KyselyTypeConfigSchema = z.tuple([z.literal("@tailor-platform/kysely-type"), z.object({ distPath: z.string() })]);
-const SeedConfigSchema = z.tuple([z.literal("@tailor-platform/seed"), z.object({
-	distPath: z.string(),
-	machineUserName: z.string().optional(),
-	disableIdpUserSync: z.object({
-		userToIdp: z.boolean().optional(),
-		idpToUser: z.boolean().optional()
-	}).optional()
-})]);
-const EnumConstantsConfigSchema = z.tuple([z.literal("@tailor-platform/enum-constants"), z.object({ distPath: z.string() })]);
-const FileUtilsConfigSchema = z.tuple([z.literal("@tailor-platform/file-utils"), z.object({ distPath: z.string() })]);
-const CodeGeneratorSchema = z.object({
-	id: z.string(),
-	description: z.string(),
-	dependencies: z.array(DependencyKindSchema),
-	processType: z.function().optional(),
-	processResolver: z.function().optional(),
-	processExecutor: z.function().optional(),
-	processTailorDBNamespace: z.function().optional(),
-	processResolverNamespace: z.function().optional(),
-	aggregate: z.function({ output: z.any() })
-});
-const BaseGeneratorConfigSchema = z.union([
-	KyselyTypeConfigSchema,
-	SeedConfigSchema,
-	EnumConstantsConfigSchema,
-	FileUtilsConfigSchema,
-	CodeGeneratorSchema
-]);
-
-//#endregion
-//#region src/parser/plugin-config/schema.ts
-const PluginConfigSchema = z.object({
-	id: z.string(),
-	description: z.string(),
-	importPath: z.string().optional(),
-	pluginConfig: z.unknown().optional(),
-	typeConfigRequired: z.union([z.boolean(), functionSchema]).optional(),
-	onTypeLoaded: functionSchema.optional(),
-	onNamespaceLoaded: functionSchema.optional(),
-	onTailorDBReady: functionSchema.optional(),
-	onResolverReady: functionSchema.optional(),
-	onExecutorReady: functionSchema.optional()
-}).passthrough().refine((p) => {
-	return !(p.onTypeLoaded || p.onNamespaceLoaded) || !!p.importPath;
-}, { message: "importPath is required when plugin has definition-time hooks (onTypeLoaded/onNamespaceLoaded)" }).transform((plugin) => plugin);
-
-//#endregion
-//#region src/plugin/builtin/registry.ts
-const builtinPlugins = /* @__PURE__ */ new Map([
-	[KyselyGeneratorID, (options) => kyselyTypePlugin(options)],
-	[SeedGeneratorID, (options) => seedPlugin(options)],
-	[EnumConstantsGeneratorID, (options) => enumConstantsPlugin(options)],
-	[FileUtilsGeneratorID, (options) => fileUtilsPlugin(options)]
-]);
-
 //#endregion
 //#region src/cli/shared/apply-concurrency.ts
 /**
@@ -547,7 +181,7 @@ function initOAuth2Client(config) {
 */
 async function initOperatorClient(accessToken, config) {
 	const platformConfig = config ?? getPlatformConfigForToken(accessToken);
-	const [{ createTracingInterceptor }, { OperatorService }] = await Promise.all([import("./interceptor-D-q1rvRl.mjs"), import("./service_pb-B2FF59sP.mjs")]);
+	const [{ createTracingInterceptor }, { OperatorService }] = await Promise.all([import("./interceptor-D-q1rvRl.mjs"), import("./service_pb-r1T7kpJc.mjs")]);
 	const interceptors = [
 		await userAgentInterceptor(),
 		await bearerTokenInterceptor(accessToken),
@@ -600,9 +234,9 @@ async function bearerTokenInterceptor(accessToken) {
 /**
 * Create an interceptor that retries failed unary requests with backoff.
 *
-* Retries any unary method on `Unavailable`/`ResourceExhausted`, and `Internal`
-* only for methods declared idempotent, up to 3 attempts (despite the historical
-* "idempotent" naming, the first two codes are retried regardless of idempotency).
+* Retries unary methods on `Unavailable`/`ResourceExhausted`, and `Internal`
+* only for methods declared idempotent, up to 3 attempts. Workspace creation is
+* excluded because it has no idempotency key and a lost response is ambiguous.
 * As a targeted exception for the deploy/apply flow, a post-retry `AlreadyExists`
 * from an allowlisted Create (see `RETRY_SAFE_CREATE_METHODS`) is treated as
 * success, since it means a prior attempt already committed the resource
@@ -627,10 +261,10 @@ function retryInterceptor() {
 						logger.debug(`retry: ${req.method.name} returned AlreadyExists on attempt ${i + 1}; treating as success (prior attempt likely committed)`);
 						return synthesizeEmptyUnaryResponse(req);
 					}
-					const { reportCrash } = await import("./crashreport-Dy4ZzSkd.mjs");
+					const { reportCrash } = await import("./crashreport-BafWvjjX.mjs");
 					await reportCrash(error, "handledError");
 				}
-				if (isRetirable(error, req.method.idempotency)) {
+				if (req.method.name !== "CreateWorkspace" && isRetirable(error, req.method.idempotency)) {
 					lastError = error;
 					logger.debug(`retry: ${req.method.name} attempt ${i + 1} failed with ${connectCodeName(error)}; retrying`);
 					continue;
@@ -1032,742 +666,6 @@ async function closeConnectionPool() {
 	await getGlobalDispatcher().close();
 }
 
-//#endregion
-//#region src/cli/shared/token-store.ts
-const SERVICE_NAME = "tailor-platform-cli";
-let entryClass;
-async function getEntryClass() {
-	if (entryClass !== void 0) return entryClass;
-	try {
-		const mod = await import("@napi-rs/keyring");
-		const probe = new mod.Entry(SERVICE_NAME, "__probe__");
-		probe.setPassword("probe");
-		probe.deletePassword();
-		entryClass = mod.Entry;
-	} catch {
-		logger.warn("System keyring is not available. Tokens will be stored in the config file. Set TAILOR_PLATFORM_TOKEN environment variable for CI environments.");
-		entryClass = false;
-	}
-	return entryClass;
-}
-/**
-* Check whether the OS keyring is available and functional.
-* @returns true if keyring is available
-*/
-async function isKeyringAvailable() {
-	return await getEntryClass() !== false;
-}
-/**
-* Load tokens from the OS keyring for a given account.
-* @param account - User identifier (e.g. email or client ID)
-* @returns Token data or undefined if not found or keyring unavailable
-*/
-async function loadKeyringTokens(account) {
-	const Entry = await getEntryClass();
-	if (!Entry) return void 0;
-	try {
-		const raw = new Entry(SERVICE_NAME, account).getPassword();
-		if (raw === null) return void 0;
-		return JSON.parse(raw);
-	} catch {
-		return;
-	}
-}
-/**
-* Save tokens to the OS keyring for a given account.
-* @param account - User identifier (e.g. email or client ID)
-* @param tokens - Token data to store
-*/
-async function saveKeyringTokens(account, tokens) {
-	const Entry = await getEntryClass();
-	if (!Entry) return;
-	new Entry(SERVICE_NAME, account).setPassword(JSON.stringify(tokens));
-}
-/**
-* Delete tokens from the OS keyring for a given account.
-* @param account - User identifier (e.g. email or client ID)
-*/
-async function deleteKeyringTokens(account) {
-	const Entry = await getEntryClass();
-	if (!Entry) return;
-	try {
-		new Entry(SERVICE_NAME, account).deletePassword();
-	} catch {}
-}
-
-//#endregion
-//#region src/cli/shared/context.ts
-const pfProfileSchema = z.object({
-	user: z.string(),
-	workspace_id: z.string(),
-	readonly: z.boolean().optional(),
-	machine_user: z.string().optional(),
-	machine_user_override: z.enum(["allow", "deny"]).optional(),
-	platform_url: z.url().optional(),
-	oauth2_client_id: z.string().optional(),
-	console_url: z.url().optional()
-});
-const pfUserSchemaV1 = z.object({
-	access_token: z.string(),
-	refresh_token: z.string().optional(),
-	token_expires_at: z.string()
-});
-const pfUserKeyringSchema = z.object({
-	storage: z.literal("keyring"),
-	token_expires_at: z.string()
-});
-const pfUserFileSchema = z.object({
-	storage: z.literal("file"),
-	token_expires_at: z.string(),
-	access_token: z.string(),
-	refresh_token: z.string().optional()
-});
-const pfUserSchemaV2 = z.discriminatedUnion("storage", [pfUserKeyringSchema, pfUserFileSchema]);
-const pfConfigSchemaV1 = z.object({
-	version: z.literal(1),
-	users: z.partialRecord(z.string(), pfUserSchemaV1),
-	profiles: z.partialRecord(z.string(), pfProfileSchema),
-	current_user: z.string().nullable()
-});
-const V2_CONFIG_VERSION = 2;
-const LATEST_CONFIG_VERSION = 3;
-const V2_MIN_SDK_VERSION = "1.29.0";
-const V3_MIN_SDK_VERSION = "1.70.0";
-const semverSchema = z.templateLiteral([
-	z.number().int(),
-	".",
-	z.number().int(),
-	".",
-	z.number().int()
-]);
-const pfConfigSchema = z.object({
-	version: z.union([z.literal(V2_CONFIG_VERSION), z.literal(LATEST_CONFIG_VERSION)]),
-	min_sdk_version: semverSchema,
-	latest_version: z.number().int().optional(),
-	latest_min_sdk_version: semverSchema.optional(),
-	users: z.partialRecord(z.string(), pfUserSchemaV2),
-	profiles: z.partialRecord(z.string(), pfProfileSchema),
-	current_user: z.string().nullable()
-});
-function platformConfigPath() {
-	if (!xdgConfig) throw new Error("User home directory not found");
-	return path.join(xdgConfig, "tailor-platform", "config.yaml");
-}
-/**
-* Convert stored profile platform fields to platform client settings.
-* @param profile - Profile platform settings
-* @returns Platform client settings
-*/
-function platformConfigFromProfile(profile) {
-	const config = {
-		...profile?.platform_url ? { platformUrl: profile.platform_url } : {},
-		...profile?.oauth2_client_id ? { oauth2ClientId: profile.oauth2_client_id } : {},
-		...profile?.console_url ? { consoleUrl: profile.console_url } : {}
-	};
-	return Object.keys(config).length > 0 ? config : void 0;
-}
-function platformUserKey(user, config) {
-	const platformUrl = getPlatformBaseUrl(config);
-	if (platformUrl === normalizeBaseUrl("https://api.tailor.tech")) return user;
-	return `${platformUrl}|${user}`;
-}
-function canUseLegacyUserKey(platformUrl) {
-	try {
-		return getPlatformBaseUrl() === platformUrl;
-	} catch {
-		return false;
-	}
-}
-function findUserEntry(config, user, platformConfig, opts = {}) {
-	const userKey = platformUserKey(user, platformConfig);
-	const userEntry = config.users[userKey];
-	if (userEntry) return {
-		userKey,
-		userEntry
-	};
-	const platformUrl = getPlatformBaseUrl(platformConfig);
-	if (userKey !== user && (opts.allowLegacyUserKey === false || !canUseLegacyUserKey(platformUrl))) return {
-		userKey,
-		userEntry
-	};
-	const legacyEntry = config.users[user];
-	return legacyEntry ? {
-		userKey: user,
-		userEntry: legacyEntry
-	} : {
-		userKey,
-		userEntry
-	};
-}
-/**
-* Resolve the config user key that would be used for a user on the selected platform.
-* @param config - Platform config
-* @param user - User name
-* @param platformConfig - Optional platform connection settings
-* @param opts - Token lookup options
-* @returns Resolved config user key
-*/
-function resolveUserTokenKey(config, user, platformConfig, opts) {
-	return findUserEntry(config, user, platformConfig, opts).userKey;
-}
-/**
-* Check whether tokens are registered for a user on the selected platform.
-* @param config - Platform config
-* @param user - User name
-* @param platformConfig - Optional platform connection settings
-* @param opts - Token lookup options
-* @returns True when the user has a registered token entry
-*/
-function hasUserTokenEntry(config, user, platformConfig, opts) {
-	return findUserEntry(config, user, platformConfig, opts).userEntry !== void 0;
-}
-function hasUserKeyForName(users, user) {
-	return users[user] !== void 0 || Object.keys(users).some((key) => key.endsWith(`|${user}`));
-}
-/**
-* Check whether any platform has tokens registered for a user.
-* @param config - Platform config
-* @param user - User name
-* @returns True when the user has a token entry for any platform
-*/
-function hasAnyUserTokenEntry(config, user) {
-	return hasUserKeyForName(config.users, user);
-}
-function hasCurrentUserEntry(users, currentUser) {
-	return hasUserKeyForName(users, currentUser);
-}
-/**
-* Migrate a v1 config to v2.
-* Tokens are kept in the config file (storage: "file") during migration.
-* They will be moved to the OS keyring on next login or token refresh.
-* @param v1Config - v1 configuration to migrate
-* @returns Migrated v2 configuration
-*/
-function migrateV1ToV2(v1Config) {
-	const users = {};
-	for (const [name, v1User] of Object.entries(v1Config.users)) {
-		if (!v1User) continue;
-		users[name] = {
-			access_token: v1User.access_token,
-			refresh_token: v1User.refresh_token,
-			token_expires_at: v1User.token_expires_at,
-			storage: "file"
-		};
-	}
-	return {
-		version: V2_CONFIG_VERSION,
-		min_sdk_version: V2_MIN_SDK_VERSION,
-		users,
-		profiles: v1Config.profiles,
-		current_user: v1Config.current_user
-	};
-}
-async function warnIfNewerConfigAvailable(config) {
-	if (!config.latest_min_sdk_version) return;
-	if (lt((await readPackageJson()).version ?? "0.0.0", config.latest_min_sdk_version)) logger.warn(multiline`
-      A newer config version (${String(config.latest_version)}) is available.
-      Please update your SDK to >= ${config.latest_min_sdk_version}: pnpm update @tailor-platform/sdk
-    `);
-}
-/**
-* Read Tailor Platform CLI configuration, migrating from tailorctl or v1 if necessary.
-* @returns Parsed platform configuration
-*/
-async function readPlatformConfig() {
-	const configPath = platformConfigPath();
-	if (!fs$1.existsSync(configPath)) {
-		logger.warn(`Config not found at ${configPath}, migrating from tailorctl config...`);
-		const tcConfig = readTailorctlConfig();
-		const v1Config = tcConfig ? fromTailorctlConfig(tcConfig) : {
-			version: 1,
-			users: {},
-			profiles: {},
-			current_user: null
-		};
-		writePlatformConfig(v1Config);
-		return migrateV1ToV2(v1Config);
-	}
-	const rawConfig = parseYAML(fs$1.readFileSync(configPath, "utf-8"));
-	tightenSecretFilePermissions(configPath);
-	const version = rawConfig != null && typeof rawConfig === "object" && "version" in rawConfig ? rawConfig.version : void 0;
-	if (typeof version === "number" && version > LATEST_CONFIG_VERSION) {
-		const minSdk = "min_sdk_version" in rawConfig ? String(rawConfig.min_sdk_version) : void 0;
-		const updateHint = minSdk ? `Please update your SDK to >= ${minSdk}: pnpm update @tailor-platform/sdk` : "Please update your SDK: pnpm update @tailor-platform/sdk";
-		throw new Error(multiline`
-      Config file uses version ${String(version)}, but this SDK only supports up to version ${String(LATEST_CONFIG_VERSION)}.
-      ${updateHint}
-    `);
-	}
-	const configResult = pfConfigSchema.safeParse(rawConfig);
-	if (configResult.success) {
-		await warnIfNewerConfigAvailable(configResult.data);
-		return configResult.data;
-	}
-	const v1Result = pfConfigSchemaV1.safeParse(rawConfig);
-	if (v1Result.success) return migrateV1ToV2(v1Result.data);
-	throw new Error(multiline`
-    Failed to parse config file at ${configPath}.
-    The file may be corrupted or created by an incompatible SDK version.
-  `);
-}
-function toV1ForDisk(config) {
-	const users = {};
-	for (const [name, entry] of Object.entries(config.users)) {
-		if (!entry || entry.storage === "keyring") continue;
-		users[name] = {
-			access_token: entry.access_token,
-			refresh_token: entry.refresh_token,
-			token_expires_at: entry.token_expires_at
-		};
-	}
-	const currentUser = config.current_user && hasCurrentUserEntry(users, config.current_user) ? config.current_user : null;
-	return {
-		version: 1,
-		users,
-		profiles: config.profiles,
-		current_user: currentUser
-	};
-}
-function hasProfilePlatformSettings(config) {
-	return Object.values(config.profiles).some((profile) => profile?.platform_url !== void 0 || profile?.oauth2_client_id !== void 0 || profile?.console_url !== void 0);
-}
-function hasScopedUserKeys(config) {
-	return Object.keys(config.users).some((userKey) => userKey.includes("|"));
-}
-function toLatestForDisk(config) {
-	return {
-		...config.version === 1 ? migrateV1ToV2(config) : config,
-		version: LATEST_CONFIG_VERSION,
-		min_sdk_version: V3_MIN_SDK_VERSION
-	};
-}
-/**
-* Write Tailor Platform CLI configuration to disk.
-* By default, file-backed configs without newer fields are converted to V1 for
-* backward compatibility, so an older SDK can still read the file. Configs
-* containing a keyring user are kept in V2 or later because the keyring storage
-* variant is not representable in V1. Configs containing profile-level Platform
-* settings or platform-scoped user tokens are written in the latest
-* min-SDK-gated format because older SDKs would silently drop or misread those
-* settings.
-* Set TAILOR_USE_KEYRING to write the current in-memory format unconditionally.
-*
-* The config file may contain access/refresh tokens when the OS keyring is
-* unavailable, so it is written via {@link writeSecretFile} so other users
-* on the host cannot read it.
-* @param config - Platform configuration to write
-*/
-function writePlatformConfig(config) {
-	const configPath = platformConfigPath();
-	const hasKeyringUser = config.version !== 1 && Object.values(config.users).some((u) => u?.storage === "keyring");
-	writeSecretFile(configPath, stringifyYAML(hasProfilePlatformSettings(config) || hasScopedUserKeys(config) ? toLatestForDisk(config) : config.version !== 1 && !process.env.TAILOR_USE_KEYRING && !hasKeyringUser ? toV1ForDisk(config) : config));
-}
-const tcContextConfigSchema = z.object({
-	username: z.string().optional(),
-	controlplaneaccesstoken: z.string().optional(),
-	controlplanerefreshtoken: z.string().optional(),
-	controlplanetokenexpiresat: z.string().optional(),
-	workspaceid: z.string().optional()
-});
-const tcConfigSchema = z.object({ global: z.object({ context: z.string().optional() }).optional() }).catchall(tcContextConfigSchema.optional());
-function readTailorctlConfig() {
-	const configPath = path.join(os.homedir(), ".tailorctl", "config");
-	if (!fs$1.existsSync(configPath)) return;
-	const rawConfig = parseTOML(fs$1.readFileSync(configPath, "utf-8"));
-	return tcConfigSchema.parse(rawConfig);
-}
-function fromTailorctlConfig(config) {
-	const users = {};
-	const profiles = {};
-	let currentUser = null;
-	const currentContext = config.global?.context || "default";
-	for (const [key, val] of Object.entries(config)) {
-		if (key === "global") continue;
-		const context = val;
-		if (!context.username || !context.controlplaneaccesstoken || !context.controlplanerefreshtoken || !context.controlplanetokenexpiresat || !context.workspaceid) continue;
-		if (key === currentContext) currentUser = context.username;
-		profiles[key] = {
-			user: context.username,
-			workspace_id: context.workspaceid
-		};
-		const user = users[context.username];
-		if (!user || new Date(user.token_expires_at) < new Date(context.controlplanetokenexpiresat)) users[context.username] = {
-			access_token: context.controlplaneaccesstoken,
-			refresh_token: context.controlplanerefreshtoken,
-			token_expires_at: context.controlplanetokenexpiresat
-		};
-	}
-	return {
-		version: 1,
-		users,
-		profiles,
-		current_user: currentUser
-	};
-}
-function validateUUID(value, source) {
-	const result = z.uuid().safeParse(value);
-	if (!result.success) throw new Error(`Invalid value from ${source}: must be a valid UUID`);
-	return result.data;
-}
-/**
-* Load workspace ID from command options, environment variables, or platform config.
-* In CLI context, env fallback is also handled by politty's arg env option.
-* Priority: opts/workspaceId > env/workspaceId > opts/profile > error
-* @param opts - Workspace and profile options
-* @returns Resolved workspace ID
-*/
-async function loadWorkspaceId(opts) {
-	const profile = opts?.profile || process.env.TAILOR_PLATFORM_PROFILE;
-	if (opts?.workspaceId) return validateUUID(opts.workspaceId, "--workspace-id option");
-	if (process.env.TAILOR_PLATFORM_WORKSPACE_ID) return validateUUID(process.env.TAILOR_PLATFORM_WORKSPACE_ID, "TAILOR_PLATFORM_WORKSPACE_ID environment variable");
-	if (profile) {
-		const wsId = (await readPlatformConfig()).profiles[profile]?.workspace_id;
-		if (!wsId) throw new Error(`Profile "${profile}" not found`);
-		return validateUUID(wsId, `profile "${profile}"`);
-	}
-	throw new Error(multiline`
-    Workspace ID not found.
-    Please specify workspace ID via --workspace-id option or TAILOR_PLATFORM_WORKSPACE_ID environment variable.
-  `);
-}
-/**
-* Load machine user name from command options, environment variables, or platform config.
-* In CLI context, env fallback is also handled by politty's arg env option.
-* Priority: opts/machineUser > env/TAILOR_PLATFORM_MACHINE_USER_NAME > opts/profile (profile default) > undefined.
-* An explicitly empty `opts.machineUser` is rejected with a CLIError (`MACHINE_USER_NAME_EMPTY`) rather than falling back to the env var or profile default.
-* When the active profile has `machine_user_override: "deny"`, an explicit value that differs from the profile's machine user throws a CLIError with code `PROFILE_MACHINE_USER_OVERRIDE_DENIED`.
-* @param opts - Machine user and profile options
-* @returns Resolved machine user name, or undefined if not set
-*/
-async function loadMachineUserName(opts) {
-	if (opts?.machineUser === "") throw createCLIError({
-		code: "MACHINE_USER_NAME_EMPTY",
-		message: "Machine user name cannot be empty.",
-		suggestion: "Pass a non-empty machine user name, or omit the option to use the environment variable or profile default."
-	});
-	const envMachineUser = process.env.TAILOR_PLATFORM_MACHINE_USER_NAME || void 0;
-	const explicitMachineUser = opts?.machineUser ? {
-		source: opts.machineUserSource ?? "option",
-		value: opts.machineUser
-	} : envMachineUser ? {
-		source: "env",
-		value: envMachineUser
-	} : void 0;
-	const explicit = explicitMachineUser?.value;
-	const profile = opts?.profile || process.env.TAILOR_PLATFORM_PROFILE;
-	if (!profile) return explicit;
-	const entry = (await readPlatformConfig()).profiles[profile];
-	if (!entry) {
-		if (explicit) return explicit;
-		throw new Error(`Profile "${profile}" not found`);
-	}
-	if (entry.machine_user && entry.machine_user_override === "deny") {
-		if (explicit && explicit !== entry.machine_user) {
-			const details = explicitMachineUser.source === "env" ? `The machine user is being set to "${explicit}" via the TAILOR_PLATFORM_MACHINE_USER_NAME environment variable, which conflicts with this profile's pinned machine user "${entry.machine_user}".` : `This profile fixes the machine user to "${entry.machine_user}" for application-data commands.`;
-			throw createCLIError({
-				code: "PROFILE_MACHINE_USER_OVERRIDE_DENIED",
-				message: `Profile "${profile}" denies overriding the machine user.`,
-				details,
-				suggestion: `Omit the machine user option, unset TAILOR_PLATFORM_MACHINE_USER_NAME, or run 'tailor-sdk profile update ${profile} --machine-user-override allow'.`
-			});
-		}
-		return entry.machine_user;
-	}
-	return explicit || entry.machine_user;
-}
-/**
-* Load access token from environment variables, command options, or platform config.
-* In CLI context, profile env fallback is also handled by politty's arg env option.
-* Priority: env/TAILOR_PLATFORM_TOKEN > env/TAILOR_TOKEN (deprecated) > opts/profile > env/profile > config/currentUser > error
-* @param opts - Profile options
-* @returns Resolved access token
-*/
-async function loadAccessToken(opts) {
-	const profile = opts?.profile || process.env.TAILOR_PLATFORM_PROFILE;
-	const envToken = process.env.TAILOR_PLATFORM_TOKEN ?? process.env.TAILOR_TOKEN;
-	if (envToken && !process.env.TAILOR_PLATFORM_TOKEN) logger.warn("TAILOR_TOKEN is deprecated. Please use TAILOR_PLATFORM_TOKEN instead.");
-	if (envToken) {
-		rememberPlatformConfigForToken(envToken, await loadPlatformClientConfig({
-			profile,
-			allowMissingProfile: true
-		}));
-		return envToken;
-	}
-	const pfConfig = await readPlatformConfig();
-	const profileEntry = profile ? pfConfig.profiles[profile] : void 0;
-	if (profile && !profileEntry) throw new Error(`Profile "${profile}" not found`);
-	const user = profileEntry?.user ?? pfConfig.current_user;
-	if (!user) throw new Error(multiline`
-      Tailor Platform token not found.
-      Please specify token via TAILOR_PLATFORM_TOKEN environment variable or login using 'tailor-sdk login' command.
-    `);
-	return await fetchLatestToken(pfConfig, user, profileEntry ? platformConfigFromProfile(profileEntry) : void 0);
-}
-/**
-* Load platform connection settings from the active profile.
-* @param opts - Profile options
-* @returns Resolved platform connection settings, or undefined for the default environment
-*/
-async function loadPlatformClientConfig(opts) {
-	const profile = opts?.profile || process.env.TAILOR_PLATFORM_PROFILE;
-	if (!profile) return;
-	let pfConfig;
-	try {
-		pfConfig = await readPlatformConfig();
-	} catch (error) {
-		if (opts?.allowMissingProfile) return;
-		throw error;
-	}
-	const profileEntry = pfConfig.profiles[profile];
-	if (!profileEntry) {
-		if (opts?.allowMissingProfile) return;
-		throw new Error(`Profile "${profile}" not found`);
-	}
-	return platformConfigFromProfile(profileEntry);
-}
-/**
-* Load the Tailor Platform Console base URL from environment variables or the active profile.
-* @param opts - Profile options
-* @returns Resolved Console base URL
-*/
-async function loadConsoleBaseUrl(opts) {
-	return getConsoleBaseUrl(await loadPlatformClientConfig(opts));
-}
-/**
-* Resolve the actual token values for a user, reading from keyring or config as appropriate.
-* @param userEntry - User entry from the config
-* @param user - User identifier
-* @param label - User-facing identifier used in error messages
-* @returns Access token and optional refresh token
-*/
-async function resolveTokens(userEntry, user, label = user) {
-	if (userEntry.storage === "keyring") {
-		const tokens = await loadKeyringTokens(user);
-		if (!tokens) throw new Error(multiline`
-        Credentials not found in OS keyring for "${label}".
-        Please run 'tailor-sdk login' and try again.
-      `);
-		return tokens;
-	}
-	return {
-		accessToken: userEntry.access_token,
-		refreshToken: userEntry.refresh_token
-	};
-}
-/**
-* Save tokens for a user, writing to keyring or config as appropriate.
-* @param config - Platform config
-* @param user - User identifier
-* @param tokens - Token data to save
-* @param tokens.accessToken - Access token to persist
-* @param tokens.refreshToken - Refresh token to persist when available
-* @param expiresAt - Token expiration date
-* @param platformConfig - Optional platform connection settings
-*/
-async function saveUserTokens(config, user, tokens, expiresAt, platformConfig) {
-	const userKey = platformUserKey(user, platformConfig);
-	if (process.env.TAILOR_USE_KEYRING && await isKeyringAvailable()) {
-		await saveKeyringTokens(userKey, tokens);
-		config.users[userKey] = {
-			token_expires_at: expiresAt,
-			storage: "keyring"
-		};
-	} else config.users[userKey] = {
-		access_token: tokens.accessToken,
-		refresh_token: tokens.refreshToken,
-		token_expires_at: expiresAt,
-		storage: "file"
-	};
-}
-/**
-* Delete tokens for a user from keyring if applicable.
-* @param config - Platform config
-* @param user - User identifier
-* @param platformConfig - Optional platform connection settings
-* @param opts - Token lookup options
-*/
-async function deleteUserTokens(config, user, platformConfig, opts) {
-	const { userKey, userEntry } = findUserEntry(config, user, platformConfig, opts);
-	if (userEntry?.storage === "keyring") await deleteKeyringTokens(userKey);
-	delete config.users[userKey];
-}
-/**
-* Resolve stored tokens for a user on the selected platform.
-* @param config - Platform config
-* @param user - User name
-* @param platformConfig - Optional platform connection settings
-* @param opts - Token lookup options
-* @returns Stored user entry and token values, or undefined when the user is not logged in
-*/
-async function loadStoredUserTokens(config, user, platformConfig, opts) {
-	const { userKey, userEntry } = findUserEntry(config, user, platformConfig, opts);
-	if (!userEntry) return void 0;
-	return {
-		userEntry,
-		...await resolveTokens(userEntry, userKey, user)
-	};
-}
-/**
-* Fetch the latest access token, refreshing if necessary.
-* @param config - Platform config
-* @param user - User name
-* @param platformConfig - Optional platform connection settings
-* @returns Latest access token
-*/
-async function fetchLatestToken(config, user, platformConfig) {
-	const { userKey, userEntry } = findUserEntry(config, user, platformConfig);
-	if (!userEntry) throw new Error(multiline`
-      User "${user}" not found.
-      Please verify your user name and login using 'tailor-sdk login' command.
-    `);
-	const tokens = await resolveTokens(userEntry, userKey, user);
-	if (new Date(userEntry.token_expires_at) > /* @__PURE__ */ new Date()) {
-		rememberPlatformConfigForToken(tokens.accessToken, platformConfig);
-		return tokens.accessToken;
-	}
-	if (!tokens.refreshToken) throw new Error(multiline`
-      Token expired.
-      Please run 'tailor-sdk login' and try again.
-    `);
-	const client = initOAuth2Client(platformConfig);
-	let resp;
-	try {
-		resp = await client.refreshToken({
-			accessToken: tokens.accessToken,
-			refreshToken: tokens.refreshToken,
-			expiresAt: Date.parse(userEntry.token_expires_at)
-		});
-	} catch {
-		throw new Error(multiline`
-      Failed to refresh token. Your session may have expired.
-      Please run 'tailor-sdk login' and try again.
-    `);
-	}
-	const newExpiresAt = new Date(assertDefined(resp.expiresAt, "token refresh response missing expiresAt")).toISOString();
-	await saveUserTokens(config, user, {
-		accessToken: resp.accessToken,
-		refreshToken: resp.refreshToken ?? void 0
-	}, newExpiresAt, platformConfig);
-	if (userKey !== platformUserKey(user, platformConfig)) {
-		if (userEntry.storage === "keyring") await deleteKeyringTokens(userKey);
-		delete config.users[userKey];
-	}
-	writePlatformConfig(config);
-	rememberPlatformConfigForToken(resp.accessToken, platformConfig);
-	return resp.accessToken;
-}
-const DEFAULT_CONFIG_FILENAME = "tailor.config.ts";
-/**
-* Load config path from command options, environment variables, or search parent directories.
-* In CLI context, env fallback is also handled by politty's arg env option.
-* Priority: opts/config > env/config > search parent directories
-* @param configPath - Optional explicit config path
-* @returns Resolved config path or undefined
-*/
-function loadConfigPath(configPath) {
-	if (configPath) return configPath;
-	if (process.env.TAILOR_PLATFORM_SDK_CONFIG_PATH) return process.env.TAILOR_PLATFORM_SDK_CONFIG_PATH;
-	return findUpSync(DEFAULT_CONFIG_FILENAME);
-}
-
-//#endregion
-//#region src/cli/shared/mock.ts
-/**
-* Install a stub `globalThis.tailordb` so that user code loaded by the CLI
-* (e.g. via `createGetDB` in `@tailor-platform/sdk/kysely`) can reference
-* `tailordb.Client` without hitting a `ReferenceError`. The CLI never
-* actually executes the user code paths that issue queries, so a no-op
-* client suffices.
-*
-* Exposed as a function (rather than a top-level statement) so that
-* `package.json#sideEffects` can keep the file marked side-effect-free
-* without bundlers eliminating the install step.
-*/
-function installCliTailordbStub() {
-	globalThis.tailordb = { Client: class {
-		constructor(_config) {}
-		async connect() {}
-		async end() {}
-		async queryObject() {
-			return {};
-		}
-	} };
-}
-
-//#endregion
-//#region src/cli/shared/config-loader.ts
-const GeneratorConfigSchema = CodeGeneratorSchema.brand("CodeGenerator");
-/**
-* Load Tailor configuration file and associated generators and plugins.
-* @param configPath - Optional explicit config path
-* @param options - Optional module import behavior.
-* @returns Loaded config, generators, plugins, and config path
-*/
-async function loadConfig(configPath, options = {}) {
-	installCliTailordbStub();
-	const foundPath = loadConfigPath(configPath);
-	if (!foundPath) throw new Error("Configuration file not found: tailor.config.ts not found in current or parent directories");
-	const resolvedPath = path.resolve(process.cwd(), foundPath);
-	if (!fs$1.existsSync(resolvedPath)) throw new Error(`Configuration file not found: ${configPath}`);
-	const configUrl = pathToFileURL(resolvedPath);
-	if (options.importNonce) configUrl.searchParams.set("tailorImportNonce", options.importNonce);
-	const configModule = await import(configUrl.href);
-	if (!configModule || !configModule.default) throw new Error("Invalid Tailor config module: default export not found");
-	const validated = AppConfigSchema.safeParse(configModule.default);
-	if (!validated.success) {
-		const issues = validated.error.issues.map((i) => `  - ${i.path.join(".") || "(root)"}: ${i.message}`).join("\n");
-		throw new Error(`Invalid Tailor config in ${resolvedPath}:\n${issues}`);
-	}
-	const allGenerators = [];
-	const allPlugins = [];
-	for (const value of Object.values(configModule)) if (Array.isArray(value)) {
-		const generatorParsed = value.reduce((acc, item) => {
-			if (!acc.success) return acc;
-			const baseResult = BaseGeneratorConfigSchema.safeParse(item);
-			if (baseResult.success && Array.isArray(baseResult.data)) {
-				const [id, options] = baseResult.data;
-				const pluginFactory = builtinPlugins.get(id);
-				if (pluginFactory) {
-					acc.convertedPlugins.push(pluginFactory(options));
-					return acc;
-				}
-			}
-			const result = GeneratorConfigSchema.safeParse(item);
-			if (result.success) acc.items.push(result.data);
-			else acc.success = false;
-			return acc;
-		}, {
-			success: true,
-			items: [],
-			convertedPlugins: []
-		});
-		if (generatorParsed.success && (generatorParsed.items.length > 0 || generatorParsed.convertedPlugins.length > 0)) {
-			allGenerators.push(...generatorParsed.items);
-			allPlugins.push(...generatorParsed.convertedPlugins);
-			continue;
-		}
-		const pluginParsed = value.reduce((acc, item) => {
-			if (!acc.success) return acc;
-			const result = PluginConfigSchema.safeParse(item);
-			if (result.success) acc.items.push(result.data);
-			else acc.success = false;
-			return acc;
-		}, {
-			success: true,
-			items: []
-		});
-		if (pluginParsed.success && pluginParsed.items.length > 0) allPlugins.push(...pluginParsed.items);
-	}
-	return {
-		config: {
-			...configModule.default,
-			path: resolvedPath
-		},
-		generators: allGenerators,
-		plugins: allPlugins
-	};
-}
-
 //#endregion
 //#region src/cli/cache/hasher.ts
 /**
@@ -2508,100 +1406,20 @@ async function removeStaleEntryFiles(outputDir) {
 	await Promise.all(files.filter((file) => file.endsWith(".entry.js")).map((file) => fs.rm(path.join(outputDir, file), { force: true })));
 }
 
-//#endregion
-//#region src/cli/shared/bundle-log-level.ts
-const INFO_LEVEL_CONSOLE_METHODS = [
-	"console.info",
-	"console.table",
-	"console.dir",
-	"console.dirxml",
-	"console.count",
-	"console.countReset",
-	"console.time",
-	"console.timeLog",
-	"console.timeEnd",
-	"console.group",
-	"console.groupCollapsed",
-	"console.groupEnd",
-	"console.clear"
-];
-const DEBUG_LEVEL_CONSOLE_METHODS = [
-	"console.debug",
-	"console.log",
-	"console.trace"
-];
-const WARN_LEVEL_CONSOLE_METHODS = ["console.warn"];
-const ERROR_LEVEL_CONSOLE_METHODS = ["console.error"];
-const MANUAL_PURE_FUNCTIONS_BY_LOG_LEVEL = {
-	DEBUG: [],
-	INFO: DEBUG_LEVEL_CONSOLE_METHODS,
-	WARN: [...DEBUG_LEVEL_CONSOLE_METHODS, ...INFO_LEVEL_CONSOLE_METHODS],
-	ERROR: [
-		...DEBUG_LEVEL_CONSOLE_METHODS,
-		...INFO_LEVEL_CONSOLE_METHODS,
-		...WARN_LEVEL_CONSOLE_METHODS
-	],
-	SILENT: [
-		...DEBUG_LEVEL_CONSOLE_METHODS,
-		...INFO_LEVEL_CONSOLE_METHODS,
-		...WARN_LEVEL_CONSOLE_METHODS,
-		...ERROR_LEVEL_CONSOLE_METHODS
-	]
-};
-function normalizeBundleLogLevel(value) {
-	const normalized = value.trim().toUpperCase();
-	return isLogLevel(normalized) ? normalized : void 0;
-}
-function resolveBundleLogLevel(configValue) {
-	if (configValue === void 0) return "DEBUG";
-	const resolved = normalizeBundleLogLevel(configValue);
-	if (resolved) return resolved;
-	throw new Error(`Invalid logLevel "${configValue}". Expected one of: ${LOG_LEVELS.join(", ")}`);
-}
-function manualPureFunctionsForLogLevel(logLevel) {
-	return MANUAL_PURE_FUNCTIONS_BY_LOG_LEVEL[logLevel];
-}
-function createLogLevelTreeshakeOptions(logLevel) {
-	const manualPureFunctions = manualPureFunctionsForLogLevel(logLevel);
-	return manualPureFunctions.length > 0 ? { manualPureFunctions } : {};
-}
-
-//#endregion
-//#region src/cli/shared/function-treeshake.ts
-const BASE_FUNCTION_TREESHAKE_OPTIONS = {
-	moduleSideEffects: false,
-	annotations: true,
-	unknownGlobalSideEffects: false
-};
-function mergeFunctionTreeshakeOptions(fragments) {
-	const merged = {};
-	const manualPureFunctions = /* @__PURE__ */ new Set();
-	for (const fragment of fragments) {
-		Object.assign(merged, fragment);
-		for (const name of fragment.manualPureFunctions ?? []) manualPureFunctions.add(name);
-	}
-	if (manualPureFunctions.size > 0) merged.manualPureFunctions = [...manualPureFunctions];
-	else delete merged.manualPureFunctions;
-	return merged;
-}
-function composeFunctionTreeshakeOptions(fragments = []) {
-	return mergeFunctionTreeshakeOptions([BASE_FUNCTION_TREESHAKE_OPTIONS, ...fragments]);
-}
-
-//#endregion
-//#region src/cli/shared/platform-bundle-plugin.ts
-const GATE = /(?<![\w$.])process\.env\.TAILOR_PLATFORM_BUNDLE\b/g;
-const platformBundleDefinePlugin = {
-	name: "tailor-platform-bundle-define",
-	transform(code) {
-		if (!code.includes("process.env.TAILOR_PLATFORM_BUNDLE")) return null;
-		return { code: code.replace(GATE, "true") };
-	}
-};
-
 //#endregion
 //#region src/cli/services/workflow/ast-utils.ts
 /**
+* Read an import or export name from an OXC identifier or string-literal node.
+* @param node - Import/export name node
+* @returns Module binding name, or undefined for an unsupported node
+*/
+function getModuleExportName(node) {
+	if (!node || typeof node !== "object") return void 0;
+	const exportName = node;
+	if (exportName.name) return exportName.name;
+	return typeof exportName.value === "string" ? exportName.value : void 0;
+}
+/**
 * Check if a module source is from the Tailor SDK package (including subpaths)
 * @param source - Module source string
 * @returns True if the source is from the Tailor SDK package
@@ -2644,7 +1462,7 @@ function getTriggerCallInfo(node, sourceText) {
 	const callee = callExpr.callee;
 	if (callee.type !== "MemberExpression") return null;
 	const memberExpr = callee;
-	if (memberExpr.computed || memberExpr.object.type !== "Identifier" || memberExpr.property.name !== "trigger") return null;
+	if (memberExpr.computed || memberExpr.property.name !== "trigger" || memberExpr.object.type !== "Identifier") return null;
 	return {
 		identifierName: memberExpr.object.name,
 		callRange: {
@@ -2731,20 +1549,6 @@ function findStatementEnd(source, position) {
 	if (i < source.length && source[i] === "\n") i++;
 	return i;
 }
-/**
-* Resolve a relative path from a base directory
-* Simple implementation that handles ./ and ../ prefixes
-* @param baseDir - Base directory
-* @param relativePath - Relative path to resolve
-* @returns Resolved absolute path
-*/
-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/services/workflow/sdk-binding-collector.ts
@@ -2888,43 +1692,6 @@ function findAllJobs(program, _sourceText) {
 	walk(program);
 	return jobs;
 }
-/**
-* Build a map from export name to job name from detected jobs
-* @param jobs - Detected job locations
-* @returns Map from export name to job name
-*/
-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
-* @param program - Parsed TypeScript program
-* @param sourceText - Source code text
-* @returns Detected trigger calls
-*/
-function detectTriggerCalls(program, sourceText) {
-	const calls = [];
-	function walk(node) {
-		if (!node || typeof node !== "object") return;
-		const triggerCall = getTriggerCallInfo(node, sourceText);
-		if (triggerCall) calls.push({
-			identifierName: triggerCall.identifierName,
-			callRange: triggerCall.callRange,
-			argsText: triggerCall.argsText,
-			optionsText: triggerCall.optionsText
-		});
-		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/services/workflow/workflow-detector.ts
@@ -2976,400 +1743,396 @@ function findAllWorkflows(program, _sourceText) {
 	walk(program);
 	return workflows;
 }
+
+//#endregion
+//#region src/cli/shared/trigger-context.ts
 /**
-* Build a map from export name to workflow name from detected workflows
-* @param workflows - Detected workflows
-* @returns Map from export name to workflow name
-*/
-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
-* @param program - Parsed TypeScript program
-* @returns Map from local name to import source
+* Normalize a source module path for trigger binding lookup.
+* @param filePath - Source file path or extensionless relative import path
+* @returns Absolute path without a JavaScript or TypeScript extension
 */
-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);
-				}
+function normalizeFilePath(filePath) {
+	return path.resolve(filePath.replace(/[?#].*$/, "")).replace(/\.(ts|mts|cts|js|mjs|cjs)$/, "");
+}
+function createModuleBindings(program, source) {
+	const localBindings = /* @__PURE__ */ new Map();
+	const exports = /* @__PURE__ */ new Map();
+	for (const workflow of findAllWorkflows(program, source)) {
+		const target = {
+			kind: "workflow",
+			name: workflow.name
+		};
+		if (workflow.exportName) localBindings.set(workflow.exportName, target);
+		if (workflow.isDefaultExport) exports.set("default", target);
+	}
+	for (const job of findAllJobs(program, source)) if (job.exportName) localBindings.set(job.exportName, {
+		kind: "job",
+		name: job.name
+	});
+	for (const statement of program.body) {
+		if (statement.type === "ExportDefaultDeclaration") {
+			const declaration = statement.declaration;
+			if (declaration?.type === "Identifier") {
+				const target = localBindings.get(declaration.name);
+				if (target) exports.set("default", target);
 			}
+			continue;
 		}
-		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);
+		if (statement.type !== "ExportNamedDeclaration") continue;
+		const declaration = statement.declaration;
+		if (declaration?.type === "VariableDeclaration") for (const declarator of declaration.declarations) {
+			const id = declarator.id;
+			if (id?.type !== "Identifier") continue;
+			const localName = id.name;
+			const target = localBindings.get(localName);
+			if (target) exports.set(localName, target);
+		}
+		if (statement.source) continue;
+		for (const specifier of statement.specifiers ?? []) {
+			const localName = getModuleExportName(specifier.local);
+			const exportedName = getModuleExportName(specifier.exported);
+			if (!localName || !exportedName) continue;
+			const target = localBindings.get(localName);
+			if (target) exports.set(exportedName, target);
 		}
 	}
-	walk(program);
-	return imports;
+	return {
+		localBindings,
+		exports
+	};
+}
+/**
+* Build trigger context from configured workflow source files.
+* @param workflowConfig - Workflow file loading configuration
+* @param authNamespace - Auth service namespace used by workflow trigger options
+* @returns Module-local workflow and job binding metadata
+*/
+async function buildTriggerContext(workflowConfig, authNamespace) {
+	const modules = /* @__PURE__ */ new Map();
+	if (!workflowConfig) return {
+		modules,
+		authNamespace
+	};
+	for (const file of loadFilesWithIgnores(workflowConfig)) try {
+		const source = await fs$1.promises.readFile(file, "utf-8");
+		const { program } = parseSync("input.ts", source);
+		modules.set(normalizeFilePath(file), createModuleBindings(program, source));
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		logger.warn(`Failed to process workflow file ${file}: ${errorMessage}`, { mode: "stream" });
+	}
+	return {
+		modules,
+		authNamespace
+	};
+}
+function sortedTargets(bindings) {
+	return [...bindings].toSorted(([a], [b]) => a.localeCompare(b)).map(([binding, target]) => [
+		binding,
+		target.kind,
+		target.name
+	]);
+}
+/**
+* Serialize trigger context to a deterministic cache input.
+* @param context - Trigger context to serialize
+* @returns Deterministic string, or an empty string when context is absent
+*/
+function serializeTriggerContext(context) {
+	if (!context) return "";
+	const modules = [...context.modules].toSorted(([a], [b]) => a.localeCompare(b)).map(([file, bindings]) => [
+		file,
+		sortedTargets(bindings.localBindings),
+		sortedTargets(bindings.exports)
+	]);
+	return JSON.stringify(modules) + (context.authNamespace ?? "");
 }
 
 //#endregion
 //#region src/cli/services/workflow/trigger-transformer.ts
-/**
-* Name of the injected runtime normalizer helper. Chosen to be unique enough
-* to avoid collisions with user code.
-*/
 const NORMALIZER_IDENTIFIER = "__tailor_normalizeTriggerOptions";
-/**
-* Build the source text of the injected normalizer helper.
-*
-* Expands a plain-string `authInvoker` (machine user name) in the trigger
-* options to the object form `{ namespace, machineUserName }`; any other
-* options value passes through unchanged. The auth namespace is baked in at
-* bundle time.
-* @param authNamespace - Auth service namespace to embed
-* @returns Source line defining the helper
-*/
 function buildNormalizerHelperSource(authNamespace) {
 	return `const ${NORMALIZER_IDENTIFIER} = (o) => o && typeof o.authInvoker === "string" ? { ...o, authInvoker: { namespace: ${JSON.stringify(authNamespace)}, machineUserName: o.authInvoker } } : o;\n`;
 }
-/**
-* Check if an AST binding pattern (parameter, catch clause, etc.) contains an Identifier with the given name.
-* @param node - AST node to inspect
-* @param name - Identifier name to look for
-* @returns True if the binding pattern contains the name
-*/
-function containsBindingName(node, name) {
-	if (!node || typeof node !== "object") return false;
-	if (node.type === "Identifier" && node.name === name) return true;
-	for (const key of Object.keys(node)) {
-		const child = node[key];
-		if (Array.isArray(child)) {
-			if (child.some((c) => containsBindingName(c, name))) return true;
-		} else if (child && typeof child === "object") {
-			if (containsBindingName(child, name)) return true;
-		}
+function collectBindingNames(node, names) {
+	if (!node || typeof node !== "object") return;
+	switch (node.type) {
+		case "Identifier":
+			names.add(node.name);
+			return;
+		case "ObjectPattern":
+			for (const property of node.properties) collectBindingNames(property.type === "RestElement" ? property.argument : property.value, names);
+			return;
+		case "ArrayPattern":
+			for (const element of node.elements) collectBindingNames(element, names);
+			return;
+		case "AssignmentPattern":
+			collectBindingNames(node.left, names);
+			return;
+		case "RestElement":
+			collectBindingNames(node.argument, names);
+			return;
+		case "TSParameterProperty": collectBindingNames(node.parameter, names);
 	}
-	return false;
 }
-/**
-* Build a map of reference counts for multiple identifiers in a single AST pass.
-* Scope-aware: references inside functions or catch clauses that shadow the name
-* via parameters are excluded, so only references to the original import binding
-* are counted.
-* Excludes import declarations and property names in non-computed member expressions.
-* @param program - The parsed AST program
-* @param names - Set of identifier names to count
-* @returns Map from identifier name to reference count
-*/
-function buildReferenceCountMap(program, names) {
-	if (names.size === 0) return /* @__PURE__ */ new Map();
-	const counts = /* @__PURE__ */ new Map();
-	const shadowDepth = /* @__PURE__ */ new Map();
-	for (const name of names) {
-		counts.set(name, 0);
-		shadowDepth.set(name, 0);
+function declarationNode(statement) {
+	return statement.type === "ExportNamedDeclaration" || statement.type === "ExportDefaultDeclaration" ? statement.declaration : statement;
+}
+function collectBlockBindings(statements, names) {
+	for (const statement of statements) {
+		const declaration = declarationNode(statement);
+		if (!declaration) continue;
+		if (declaration.type === "VariableDeclaration") {
+			if (declaration.kind === "var") continue;
+			for (const declarator of declaration.declarations) collectBindingNames(declarator.id, names);
+		} else if (declaration.type === "FunctionDeclaration" || declaration.type === "ClassDeclaration") collectBindingNames(declaration.id, names);
 	}
-	function walk(node, parentNode, parentKey) {
+}
+function collectFunctionVarBindings(root, names) {
+	function walk(node) {
 		if (!node || typeof node !== "object") return;
-		const nodeType = node.type;
-		if (nodeType === "ImportDeclaration") return;
-		const shadowedHere = [];
-		if (nodeType === "FunctionDeclaration" || nodeType === "FunctionExpression" || nodeType === "ArrowFunctionExpression") {
-			const params = node.params;
-			if (params) {
-				for (const name of names) if (params.some((p) => containsBindingName(p, name))) {
-					shadowDepth.set(name, (shadowDepth.get(name) ?? 0) + 1);
-					shadowedHere.push(name);
-				}
-			}
-		}
-		if (nodeType === "CatchClause") {
-			const param = node.param;
-			if (param) {
-				for (const name of names) if (containsBindingName(param, name)) {
-					shadowDepth.set(name, (shadowDepth.get(name) ?? 0) + 1);
-					shadowedHere.push(name);
-				}
-			}
-		}
-		if (nodeType === "Identifier") {
-			const identName = node.name;
-			if (identName && names.has(identName) && (shadowDepth.get(identName) ?? 0) === 0) {
-				const isMemberProperty = parentNode && parentNode.type === "MemberExpression" && parentKey === "property" && !parentNode.computed;
-				const isObjectPropertyKey = parentNode && parentNode.type === "Property" && parentKey === "key" && !parentNode.shorthand && !parentNode.computed;
-				if (!isMemberProperty && !isObjectPropertyKey) counts.set(identName, (counts.get(identName) ?? 0) + 1);
-			}
-		}
+		if (node !== root && (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression" || node.type === "StaticBlock")) return;
+		if (node.type === "VariableDeclaration" && node.kind === "var") for (const declarator of node.declarations) collectBindingNames(declarator.id, names);
 		for (const key of Object.keys(node)) {
+			if (key === "parent") continue;
 			const child = node[key];
-			if (Array.isArray(child)) child.forEach((c) => walk(c, node, key));
-			else if (child && typeof child === "object") walk(child, node, key);
+			if (Array.isArray(child)) for (const item of child) walk(item);
+			else if (child && typeof child === "object") walk(child);
 		}
-		for (const name of shadowedHere) shadowDepth.set(name, (shadowDepth.get(name) ?? 0) - 1);
 	}
-	walk(program);
-	return counts;
+	walk(root);
 }
-/**
-* Find the text range to remove for a dead default import.
-*
-* - Default-only import (`import wf from "..."`): returns the full declaration range.
-* - Mixed import (`import wf, { helper } from "..."`): returns the range covering
-*   the default specifier and trailing comma/whitespace so the result becomes
-*   `import { helper } from "..."`.
-* @param program - The parsed AST program
-* @param localName - The local name of the default import
-* @param source - The source code text (used to locate the `{` in mixed imports)
-* @returns Range to remove, or null if the import was not found
-*/
-function findDefaultImportRemovalRange(program, localName, source) {
-	for (const statement of program.body) {
-		if (statement.type !== "ImportDeclaration") continue;
-		const importDecl = statement;
-		const specifiers = importDecl.specifiers;
-		for (const spec of specifiers) {
-			if (spec.type !== "ImportDefaultSpecifier") continue;
-			const defaultSpec = spec;
-			if (defaultSpec.local.name !== localName) continue;
-			if (specifiers.length === 1) return {
-				start: importDecl.start,
-				end: importDecl.end,
-				isFullDeclaration: true
-			};
-			const braceIndex = source.indexOf("{", defaultSpec.end);
-			if (braceIndex !== -1) return {
-				start: defaultSpec.start,
-				end: braceIndex,
-				isFullDeclaration: false
-			};
-			return null;
-		}
+function collectScopeBindings(node) {
+	const names = /* @__PURE__ */ new Set();
+	if (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") {
+		collectBindingNames(node.id, names);
+		for (const parameter of node.params) collectBindingNames(parameter, names);
+		collectFunctionVarBindings(node, names);
+		return names;
+	}
+	if (node.type === "BlockStatement") {
+		collectBlockBindings(node.body, names);
+		return names;
+	}
+	if (node.type === "CatchClause") {
+		collectBindingNames(node.param, names);
+		return names;
+	}
+	if (node.type === "ForStatement" || node.type === "ForInStatement" || node.type === "ForOfStatement") {
+		const declaration = node.init ?? node.left;
+		if (declaration?.type === "VariableDeclaration" && declaration.kind !== "var") for (const declarator of declaration.declarations) collectBindingNames(declarator.id, names);
+		return names;
 	}
-	return null;
 }
-/**
-* 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
-* @returns Detected trigger call metadata
-*/
-function detectExtendedTriggerCalls(program, sourceText, workflowNames, jobNames) {
-	const calls = [];
-	function walk(node) {
-		if (!node || typeof node !== "object") return;
-		const triggerCall = getTriggerCallInfo(node, sourceText);
-		if (triggerCall) {
-			const isWorkflow = workflowNames.has(triggerCall.identifierName);
-			const isJob = jobNames.has(triggerCall.identifierName);
-			if (isWorkflow) calls.push({
-				kind: "workflow",
-				identifierName: triggerCall.identifierName,
-				callRange: triggerCall.callRange,
-				argsText: triggerCall.argsText,
-				optionsText: triggerCall.optionsText
-			});
-			else if (isJob) calls.push({
-				kind: "job",
-				identifierName: triggerCall.identifierName,
-				callRange: triggerCall.callRange,
-				argsText: triggerCall.argsText,
-				optionsText: triggerCall.optionsText
-			});
-		}
+function addShadowedBindings(shadowedNames, bindings, targetNames) {
+	if (!bindings) return shadowedNames;
+	const relevantBindings = [...bindings].filter((name) => targetNames.has(name));
+	return relevantBindings.length === 0 ? shadowedNames : /* @__PURE__ */ new Set([...shadowedNames, ...relevantBindings]);
+}
+function walkBindingAware(program, targetNames, visitor) {
+	function walk(node, shadowedNames, parentNode, parentKey) {
+		if (!node || typeof node !== "object" || node.type === "ImportDeclaration") return;
+		const nestedShadowedNames = node.type === "Program" ? shadowedNames : addShadowedBindings(shadowedNames, collectScopeBindings(node), targetNames);
+		visitor(node, nestedShadowedNames, parentNode, parentKey);
 		for (const key of Object.keys(node)) {
+			if (key === "parent") continue;
 			const child = node[key];
-			if (Array.isArray(child)) child.forEach((c) => walk(c));
-			else if (child && typeof child === "object") walk(child);
+			if (Array.isArray(child)) for (const item of child) walk(item, nestedShadowedNames, node, key);
+			else if (child && typeof child === "object") walk(child, nestedShadowedNames, node, key);
 		}
 	}
-	walk(program);
+	walk(program, /* @__PURE__ */ new Set());
+}
+function resolveRelativeImport(context, currentFilePath, importSource) {
+	if (!importSource.startsWith(".")) return void 0;
+	const currentDirectory = path.dirname(currentFilePath.replace(/[?#].*$/, ""));
+	const modulePath = normalizeFilePath(path.resolve(currentDirectory, importSource));
+	return context.modules.get(modulePath) ?? context.modules.get(path.join(modulePath, "index"));
+}
+function collectLocalTargets(program, context, currentFilePath) {
+	const targets = /* @__PURE__ */ new Map();
+	const currentModule = context.modules.get(normalizeFilePath(currentFilePath));
+	if (currentModule) for (const [localName, target] of currentModule.localBindings) targets.set(localName, target);
+	for (const statement of program.body) {
+		if (statement.type !== "ImportDeclaration" || statement.importKind === "type") continue;
+		const importSource = statement.source.value;
+		if (typeof importSource !== "string") continue;
+		const importedModule = resolveRelativeImport(context, currentFilePath, importSource);
+		if (!importedModule) continue;
+		for (const specifier of statement.specifiers) {
+			if (specifier.type === "ImportNamespaceSpecifier") continue;
+			if (specifier.type === "ImportSpecifier" && specifier.importKind === "type") continue;
+			const importedName = specifier.type === "ImportDefaultSpecifier" ? "default" : getModuleExportName(specifier.imported);
+			if (!importedName) continue;
+			const target = importedModule.exports.get(importedName);
+			if (!target) continue;
+			targets.set(specifier.local.name, target);
+		}
+	}
+	return targets;
+}
+function detectTriggerCallsWithTargets(program, sourceText, targets) {
+	const calls = [];
+	walkBindingAware(program, new Set(targets.keys()), (node, shadowedNames) => {
+		const triggerCall = getTriggerCallInfo(node, sourceText);
+		if (!triggerCall || shadowedNames.has(triggerCall.identifierName)) return;
+		const target = targets.get(triggerCall.identifierName);
+		if (target) calls.push({
+			...triggerCall,
+			kind: target.kind,
+			targetName: target.name
+		});
+	});
 	return calls;
 }
-/**
-* Transform trigger calls for resolver/executor/workflow functions
-* Handles 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)
-* @param authNamespace - Auth service namespace used to expand string-literal `authInvoker` to object form
-* @returns Transformed source code with trigger calls rewritten
-*/
-function transformFunctionTriggers(source, workflowNameMap, jobNameMap, workflowFileMap, currentFilePath, authNamespace) {
+function detectResolvedTriggerCalls(program, sourceText, context, currentFilePath) {
+	return detectTriggerCallsWithTargets(program, sourceText, collectLocalTargets(program, context, currentFilePath));
+}
+function transformFunctionTriggers(source, triggerContext, currentFilePath) {
 	const { program } = parseSync("input.ts", source);
-	const localWorkflowNameMap = new Map(workflowNameMap);
-	const workflowDefaultImportNames = /* @__PURE__ */ new Set();
-	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).replace(/\.(ts|mts|cts|js|mjs|cjs)$/, "");
-			const workflowName = workflowFileMap.get(resolvedPath);
-			if (workflowName) {
-				localWorkflowNameMap.set(localName, workflowName);
-				workflowDefaultImportNames.add(localName);
-			}
-		}
-	}
-	const allTriggerCalls = detectExtendedTriggerCalls(program, source, new Set(localWorkflowNameMap.keys()), new Set(jobNameMap.keys()));
+	const localTargets = collectLocalTargets(program, triggerContext, currentFilePath);
+	const { authNamespace } = triggerContext;
+	const allTriggerCalls = detectTriggerCallsWithTargets(program, source, localTargets);
 	const nestedTriggerCalls = [];
 	const triggerCalls = allTriggerCalls.filter((call) => {
 		const parent = allTriggerCalls.find((other) => other !== call && other.callRange.start <= call.callRange.start && call.callRange.end <= other.callRange.end);
-		if (parent) {
-			nestedTriggerCalls.push({
-				call,
-				parent
-			});
-			return false;
-		}
-		return true;
+		if (!parent) return true;
+		nestedTriggerCalls.push({
+			call,
+			parent
+		});
+		return false;
 	});
 	for (const { call, parent } of nestedTriggerCalls) logger.warn(`Nested trigger call "${call.identifierName}.trigger(...)" inside "${parent.identifierName}.trigger(...)" cannot be converted. Move it to a separate statement and pass the result instead.`);
 	const replacements = [];
 	let needsNormalizerHelper = false;
-	const transformedCallsPerIdentifier = /* @__PURE__ */ new Map();
-	for (const call of triggerCalls) if (call.kind === "workflow") {
-		const workflowName = localWorkflowNameMap.get(call.identifierName);
-		if (workflowName) {
+	for (const call of triggerCalls) {
+		let transformedCall;
+		if (call.kind === "workflow") {
 			let optionsPart = "";
 			if (call.optionsText !== void 0) if (authNamespace) {
 				optionsPart = `, ${NORMALIZER_IDENTIFIER}(${call.optionsText})`;
 				needsNormalizerHelper = true;
 			} else optionsPart = `, ${call.optionsText}`;
-			const transformedCall = `tailor.workflow.triggerWorkflow("${workflowName}", ${call.argsText || "undefined"}${optionsPart})`;
-			replacements.push({
-				start: call.callRange.start,
-				end: call.callRange.end,
-				text: transformedCall
-			});
-			transformedCallsPerIdentifier.set(call.identifierName, (transformedCallsPerIdentifier.get(call.identifierName) ?? 0) + 1);
-		}
-	} else {
-		const jobName = jobNameMap.get(call.identifierName);
-		if (jobName) {
+			transformedCall = `tailor.workflow.triggerWorkflow(${JSON.stringify(call.targetName)}, ${call.argsText || "undefined"}${optionsPart})`;
+		} else {
 			const optionsPart = call.optionsText !== void 0 ? `, ${call.optionsText}` : "";
-			const transformedCall = `(async () => tailor.workflow.triggerJobFunction("${jobName}", ${call.argsText || "undefined"}${optionsPart}))()`;
-			replacements.push({
-				start: call.callRange.start,
-				end: call.callRange.end,
-				text: transformedCall
-			});
-			transformedCallsPerIdentifier.set(call.identifierName, (transformedCallsPerIdentifier.get(call.identifierName) ?? 0) + 1);
-		}
-	}
-	const refCounts = buildReferenceCountMap(program, workflowDefaultImportNames);
-	for (const localName of workflowDefaultImportNames) {
-		const transformedCount = transformedCallsPerIdentifier.get(localName) ?? 0;
-		const refCount = refCounts.get(localName) ?? 0;
-		if (refCount === 0 || transformedCount >= refCount) {
-			const removal = findDefaultImportRemovalRange(program, localName, source);
-			if (removal) replacements.push({
-				start: removal.start,
-				end: removal.isFullDeclaration ? findStatementEnd(source, removal.end) : removal.end,
-				text: ""
-			});
+			transformedCall = `(async () => tailor.workflow.triggerJobFunction(${JSON.stringify(call.targetName)}, ${call.argsText || "undefined"}${optionsPart}))()`;
 		}
+		replacements.push({
+			start: call.callRange.start,
+			end: call.callRange.end,
+			text: transformedCall
+		});
 	}
 	const transformed = applyReplacements(source, replacements);
-	if (needsNormalizerHelper && authNamespace) return buildNormalizerHelperSource(authNamespace) + transformed;
-	return transformed;
-}
-
-//#endregion
-//#region src/cli/shared/trigger-context.ts
-/**
-* Normalize a file path by removing extension and resolving to absolute path
-* @param filePath - File path to normalize
-* @returns Normalized absolute path without extension
-*/
-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
-* @param workflowConfig - Workflow file loading configuration
-* @param authNamespace - Auth service namespace (optional, used for string-literal authInvoker expansion)
-* @returns Trigger context built from workflow sources
-*/
-async function buildTriggerContext(workflowConfig, authNamespace) {
-	const workflowNameMap = /* @__PURE__ */ new Map();
-	const jobNameMap = /* @__PURE__ */ new Map();
-	const workflowFileMap = /* @__PURE__ */ new Map();
-	if (!workflowConfig) return {
-		workflowNameMap,
-		jobNameMap,
-		workflowFileMap,
-		authNamespace
-	};
-	const workflowFiles = loadFilesWithIgnores(workflowConfig);
-	for (const file of workflowFiles) try {
-		const source = await fs$1.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 jobMap = buildJobNameMap(findAllJobs(program, source));
-		for (const [exportName, jobName] of jobMap) jobNameMap.set(exportName, jobName);
-	} catch (error) {
-		const errorMessage = error instanceof Error ? error.message : String(error);
-		logger.warn(`Failed to process workflow file ${file}: ${errorMessage}`, { mode: "stream" });
-		continue;
-	}
-	return {
-		workflowNameMap,
-		jobNameMap,
-		workflowFileMap,
-		authNamespace
-	};
-}
-function sortedMapToJson(m) {
-	return JSON.stringify([...m.entries()].toSorted(([a], [b]) => a.localeCompare(b)));
+	return needsNormalizerHelper && authNamespace ? buildNormalizerHelperSource(authNamespace) + transformed : transformed;
 }
-/**
-* Serialize trigger context to a deterministic string for cache hashing.
-* Returns an empty string if no context is provided.
-* @param ctx - Trigger context to serialize
-* @returns Deterministic string representation
-*/
-function serializeTriggerContext(ctx) {
-	if (!ctx) return "";
-	return sortedMapToJson(ctx.workflowNameMap) + sortedMapToJson(ctx.jobNameMap) + sortedMapToJson(ctx.workflowFileMap) + (ctx.authNamespace ?? "");
-}
-/**
-* Create a rolldown plugin for transforming trigger calls
-* Returns undefined if no trigger context is provided
-* @param triggerContext - Trigger context to use for transformations
-* @returns Rolldown plugin or undefined when no context
-*/
 function createTriggerTransformPlugin(triggerContext) {
-	if (!triggerContext) return;
+	if (!triggerContext) return void 0;
 	return {
 		name: "trigger-transform",
 		transform: {
 			filter: { id: { include: [/\.(ts|mts|cts|js|mjs|cjs)$/] } },
 			handler(code, id) {
 				if (!code.includes(".trigger(")) return null;
-				return { code: transformFunctionTriggers(code, triggerContext.workflowNameMap, triggerContext.jobNameMap, triggerContext.workflowFileMap, id, triggerContext.authNamespace) };
+				return { code: transformFunctionTriggers(code, triggerContext, id) };
 			}
 		}
 	};
 }
 
+//#endregion
+//#region src/cli/shared/bundle-log-level.ts
+const INFO_LEVEL_CONSOLE_METHODS = [
+	"console.info",
+	"console.table",
+	"console.dir",
+	"console.dirxml",
+	"console.count",
+	"console.countReset",
+	"console.time",
+	"console.timeLog",
+	"console.timeEnd",
+	"console.group",
+	"console.groupCollapsed",
+	"console.groupEnd",
+	"console.clear"
+];
+const DEBUG_LEVEL_CONSOLE_METHODS = [
+	"console.debug",
+	"console.log",
+	"console.trace"
+];
+const WARN_LEVEL_CONSOLE_METHODS = ["console.warn"];
+const ERROR_LEVEL_CONSOLE_METHODS = ["console.error"];
+const MANUAL_PURE_FUNCTIONS_BY_LOG_LEVEL = {
+	DEBUG: [],
+	INFO: DEBUG_LEVEL_CONSOLE_METHODS,
+	WARN: [...DEBUG_LEVEL_CONSOLE_METHODS, ...INFO_LEVEL_CONSOLE_METHODS],
+	ERROR: [
+		...DEBUG_LEVEL_CONSOLE_METHODS,
+		...INFO_LEVEL_CONSOLE_METHODS,
+		...WARN_LEVEL_CONSOLE_METHODS
+	],
+	SILENT: [
+		...DEBUG_LEVEL_CONSOLE_METHODS,
+		...INFO_LEVEL_CONSOLE_METHODS,
+		...WARN_LEVEL_CONSOLE_METHODS,
+		...ERROR_LEVEL_CONSOLE_METHODS
+	]
+};
+function normalizeBundleLogLevel(value) {
+	const normalized = value.trim().toUpperCase();
+	return isLogLevel(normalized) ? normalized : void 0;
+}
+function resolveBundleLogLevel(configValue) {
+	if (configValue === void 0) return "DEBUG";
+	const resolved = normalizeBundleLogLevel(configValue);
+	if (resolved) return resolved;
+	throw new Error(`Invalid logLevel "${configValue}". Expected one of: ${LOG_LEVELS.join(", ")}`);
+}
+function manualPureFunctionsForLogLevel(logLevel) {
+	return MANUAL_PURE_FUNCTIONS_BY_LOG_LEVEL[logLevel];
+}
+function createLogLevelTreeshakeOptions(logLevel) {
+	const manualPureFunctions = manualPureFunctionsForLogLevel(logLevel);
+	return manualPureFunctions.length > 0 ? { manualPureFunctions } : {};
+}
+
+//#endregion
+//#region src/cli/shared/function-treeshake.ts
+const BASE_FUNCTION_TREESHAKE_OPTIONS = {
+	moduleSideEffects: false,
+	annotations: true,
+	unknownGlobalSideEffects: false
+};
+function mergeFunctionTreeshakeOptions(fragments) {
+	const merged = {};
+	const manualPureFunctions = /* @__PURE__ */ new Set();
+	for (const fragment of fragments) {
+		Object.assign(merged, fragment);
+		for (const name of fragment.manualPureFunctions ?? []) manualPureFunctions.add(name);
+	}
+	if (manualPureFunctions.size > 0) merged.manualPureFunctions = [...manualPureFunctions];
+	else delete merged.manualPureFunctions;
+	return merged;
+}
+function composeFunctionTreeshakeOptions(fragments = []) {
+	return mergeFunctionTreeshakeOptions([BASE_FUNCTION_TREESHAKE_OPTIONS, ...fragments]);
+}
+
+//#endregion
+//#region src/cli/shared/platform-bundle-plugin.ts
+const GATE = /(?<![\w$.])process\.env\.TAILOR_PLATFORM_BUNDLE\b/g;
+const platformBundleDefinePlugin = {
+	name: "tailor-platform-bundle-define",
+	transform(code) {
+		if (!code.includes("process.env.TAILOR_PLATFORM_BUNDLE")) return null;
+		return { code: code.replace(GATE, "true") };
+	}
+};
+
 //#endregion
 //#region src/cli/services/auth/bundler.ts
 /**
@@ -5723,36 +4486,15 @@ function assertUniqueResolverNames(resolvers, namespace) {
 */
 function findVariableDeclarationsByName(program) {
 	const declarations = /* @__PURE__ */ new Map();
-	function walk(node) {
-		if (!node || typeof node !== "object") return;
-		const nodeType = node.type;
-		if (nodeType === "VariableDeclaration") {
-			const varDecl = node;
-			for (const decl of varDecl.declarations) if (decl.id.type === "Identifier" && decl.id.name) {
-				if (!declarations.has(decl.id.name)) declarations.set(decl.id.name, {
-					start: varDecl.start,
-					end: varDecl.end
-				});
-			}
-		}
-		if (nodeType === "ExportNamedDeclaration") {
-			const exportDecl = node;
-			const declaration = exportDecl.declaration;
-			if (declaration?.type === "VariableDeclaration") {
-				const varDecl = declaration;
-				for (const decl of varDecl.declarations) if (decl.id.type === "Identifier" && decl.id.name) declarations.set(decl.id.name, {
-					start: exportDecl.start,
-					end: exportDecl.end
-				});
-			}
-		}
-		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);
-		}
+	for (const statement of program.body) {
+		const declaration = statement.type === "ExportNamedDeclaration" ? statement.declaration : statement;
+		if (declaration?.type !== "VariableDeclaration") continue;
+		const variableDeclaration = declaration;
+		for (const declarator of variableDeclaration.declarations) if (declarator.id.type === "Identifier") declarations.set(declarator.id.name, {
+			start: statement.start,
+			end: statement.end
+		});
 	}
-	walk(program);
 	return declarations;
 }
 /**
@@ -5779,48 +4521,32 @@ function findWorkflowDefaultExport(program) {
 }
 /**
 * Transform workflow source code
-* - 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)
 * @returns Transformed workflow source code
 */
-function transformWorkflowSource(source, targetJobName, targetJobExportName, otherJobExportNames, allJobsMap) {
+function transformWorkflowSource(source, targetJobName, targetJobExportName, otherJobExportNames) {
 	const { program } = parseSync("input.ts", source);
 	const detectedJobs = findAllJobs(program, source);
 	if (!detectedJobs.some((j) => j.name === targetJobName)) return source;
-	const jobNameMap = allJobsMap ?? buildJobNameMap(detectedJobs);
 	const allDeclarations = findVariableDeclarationsByName(program);
-	const triggerCalls = detectTriggerCalls(program, source);
 	const replacements = [];
-	const removedRanges = [];
-	const isInsideRemovedRange = (pos) => {
-		return removedRanges.some((r) => pos >= r.start && pos < r.end);
-	};
-	const isAlreadyMarkedForRemoval = (start) => {
-		return removedRanges.some((r) => r.start === start);
-	};
+	const removedStarts = /* @__PURE__ */ new Set();
 	for (const job of detectedJobs) {
 		if (job.name === targetJobName) continue;
-		if (job.statementRange && !isAlreadyMarkedForRemoval(job.statementRange.start)) {
+		if (job.statementRange && !removedStarts.has(job.statementRange.start)) {
 			const endPos = findStatementEnd(source, job.statementRange.end);
-			removedRanges.push({
-				start: job.statementRange.start,
-				end: endPos
-			});
+			removedStarts.add(job.statementRange.start);
 			replacements.push({
 				start: job.statementRange.start,
 				end: endPos,
 				text: ""
 			});
 		} else if (!job.statementRange) {
-			removedRanges.push({
-				start: job.bodyValueRange.start,
-				end: job.bodyValueRange.end
-			});
+			removedStarts.add(job.bodyValueRange.start);
 			replacements.push({
 				start: job.bodyValueRange.start,
 				end: job.bodyValueRange.end,
@@ -5831,12 +4557,9 @@ function transformWorkflowSource(source, targetJobName, targetJobExportName, oth
 	if (otherJobExportNames) for (const exportName of otherJobExportNames) {
 		if (exportName === targetJobExportName) continue;
 		const declRange = allDeclarations.get(exportName);
-		if (declRange && !isAlreadyMarkedForRemoval(declRange.start)) {
+		if (declRange && !removedStarts.has(declRange.start)) {
 			const endPos = findStatementEnd(source, declRange.end);
-			removedRanges.push({
-				start: declRange.start,
-				end: endPos
-			});
+			removedStarts.add(declRange.start);
 			replacements.push({
 				start: declRange.start,
 				end: endPos,
@@ -5845,31 +4568,15 @@ function transformWorkflowSource(source, targetJobName, targetJobExportName, oth
 		}
 	}
 	const workflowExport = findWorkflowDefaultExport(program);
-	if (workflowExport && !isAlreadyMarkedForRemoval(workflowExport.start)) {
+	if (workflowExport && !removedStarts.has(workflowExport.start)) {
 		const endPos = findStatementEnd(source, workflowExport.end);
-		removedRanges.push({
-			start: workflowExport.start,
-			end: endPos
-		});
+		removedStarts.add(workflowExport.start);
 		replacements.push({
 			start: workflowExport.start,
 			end: endPos,
 			text: ""
 		});
 	}
-	for (const call of triggerCalls) {
-		if (isInsideRemovedRange(call.callRange.start)) continue;
-		const jobName = jobNameMap.get(call.identifierName);
-		if (jobName) {
-			const optionsPart = call.optionsText !== void 0 ? `, ${call.optionsText}` : "";
-			const transformedCall = `(async () => tailor.workflow.triggerJobFunction("${jobName}", ${call.argsText || "undefined"}${optionsPart}))()`;
-			replacements.push({
-				start: call.callRange.start,
-				end: call.callRange.end,
-				text: transformedCall
-			});
-		}
-	}
 	return applyReplacements(source, replacements);
 }
 
@@ -5911,7 +4618,7 @@ async function bundleWorkflowJobs(allJobs, mainJobNames, env = {}, triggerContex
 			bundledCode: /* @__PURE__ */ new Map()
 		};
 	}
-	const { usedJobs, mainJobDeps } = await filterUsedJobs(allJobs, mainJobNames);
+	const { usedJobs, mainJobDeps } = await filterUsedJobs(allJobs, mainJobNames, triggerContext);
 	logger.newline();
 	logger.log(`Bundling ${styles.highlight(usedJobs.length.toString())} files for ${styles.info("\"workflow-job\"")}`);
 	const outputDir = path.resolve(getDistDir(), "workflow-jobs");
@@ -5945,9 +4652,10 @@ async function bundleWorkflowJobs(allJobs, mainJobNames, env = {}, triggerContex
 * Also returns a map of mainJob -> all jobs it depends on (for metadata).
 * @param allJobs - All available job infos
 * @param mainJobNames - Names of main jobs
+* @param triggerContext - Module binding metadata for resolving trigger targets
 * @returns Used jobs and main job dependency map
 */
-async function filterUsedJobs(allJobs, mainJobNames) {
+async function filterUsedJobs(allJobs, mainJobNames, triggerContext) {
 	if (allJobs.length === 0 || mainJobNames.length === 0) return {
 		usedJobs: [],
 		mainJobDeps: {}
@@ -5958,26 +4666,19 @@ async function filterUsedJobs(allJobs, mainJobNames) {
 		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$1.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 triggerCalls = detectResolvedTriggerCalls(program, source, triggerContext, sourceFile);
 			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 (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);
-				}
+				for (const call of triggerCalls) if (call.kind === "job" && call.callRange.start >= detectedJob.bodyValueRange.start && call.callRange.end <= detectedJob.bodyValueRange.end) jobDeps.add(call.targetName);
 				if (jobDeps.size > 0) jobDependencies.push({
 					jobName: job.name,
 					deps: jobDeps
@@ -6038,10 +4739,8 @@ async function bundleSingleJob(job, allJobs, outputDir, tsconfig, env, triggerCo
         }
       `;
 			fs$1.writeFileSync(entryPath, entryContent);
-			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);
 			const resolvedSourceFile = safeRealpath(job.sourceFile);
+			const otherJobExportNames = allJobs.filter((candidate) => candidate.name !== job.name && safeRealpath(candidate.sourceFile) === resolvedSourceFile).map((j) => j.exportName);
 			const plugins = [
 				{
 					name: "workflow-transform",
@@ -6050,8 +4749,8 @@ async function bundleSingleJob(job, allJobs, outputDir, tsconfig, env, triggerCo
 						handler(code, id) {
 							if (!code.includes("createWorkflowJob") && !code.includes("createWorkflow") && !code.includes(".trigger(")) return null;
 							let transformed = code;
-							if (safeRealpath(id) === resolvedSourceFile) transformed = transformWorkflowSource(code, job.name, job.exportName, otherJobExportNames, allJobsMap);
-							if (triggerContext && transformed.includes(".trigger(")) transformed = transformFunctionTriggers(transformed, triggerContext.workflowNameMap, triggerContext.jobNameMap, triggerContext.workflowFileMap, id, triggerContext.authNamespace);
+							if (safeRealpath(id) === resolvedSourceFile) transformed = transformWorkflowSource(code, job.name, job.exportName, otherJobExportNames);
+							if (transformed.includes(".trigger(")) transformed = transformFunctionTriggers(transformed, triggerContext, id);
 							if (transformed === code) return null;
 							return { code: transformed };
 						}
@@ -6846,5 +5545,5 @@ async function loadApplication(params) {
 }
 
 //#endregion
-export { getOAuth2ClientId as $, hasAnyUserTokenEntry as A, readPlatformConfig as B, createBundleCache as C, toPageDirection as Ct, loadConfig as D, hashFile as E, loadMachineUserName as F, defaultPlatformBaseUrl as G, saveUserTokens as H, loadPlatformClientConfig as I, fetchMachineUserToken as J, fetchAll as K, loadStoredUserTokens as L, loadAccessToken as M, loadConfigPath as N, deleteUserTokens as O, loadConsoleBaseUrl as P, getConsoleBaseUrl as Q, loadWorkspaceId as R, hasGenerationHooks as S, resolveMachineUserInputSource as St, hashContent as T, writePlatformConfig as U, resolveUserTokenKey as V, closeConnectionPool as W, fetchPlatformMachineUserToken as X, fetchPaged as Y, fetchUserInfo as Z, platformBundleDefinePlugin as _, organizationArgs as _t, resolveInlineSourcemap as a, resolveStaticWebsiteUrls as at, resolveBundleLogLevel as b, parseDuration as bt, ResolverSchema as c, configArg as ct, buildExecutorArgsExpr as d, durationArg as dt, getOrNull as et, buildResolverOperationHookExpr as f, folderArgs as ft, stringifyFunction as g, orderArg as gt, TailorDBTypeSchema as h, nonNegativeIntArg as ht, resolverBundleKey as i, isDefaultPlatform as it, hasUserTokenEntry as j, fetchLatestToken as k, HTTP_METHODS as l, confirmationArgs as lt, assertUniqueTailorDBTypeNamesWithExternal as m, multiConfigArg as mt, generatePluginFilesIfNeeded as n, initOAuth2Client as nt, WorkflowJobFunctionExecutionPolicySchema as o, byName as ot, assertUniqueLocalTailorDBTypeNames as p, isVerbose as pt, fetchAllTolerant as q, loadApplication as r, initOperatorClient as rt, WorkflowJobSchema as s, commonArgs as st, defineApplication as t, getPlatformBaseUrl as tt, INVOKER_EXPR as u, deploymentArgs as ut, composeFunctionTreeshakeOptions as v, pagedLogArgs as vt, getDistDir as w, workspaceArgs as wt, getPluginGenerationDependencies as x, positiveIntArg as xt, createLogLevelTreeshakeOptions as y, paginationArgs as yt, platformConfigFromProfile as z };
-//# sourceMappingURL=application-BUfYmf0O.mjs.map
+export { fetchAllTolerant as A, initOperatorClient as B, createBundleCache as C, closeConnectionPool as D, hashFile as E, getConsoleBaseUrl as F, byName as G, normalizeBaseUrl as H, getOAuth2ClientId as I, LOG_LEVELS as K, getOrNull as L, fetchPaged as M, fetchPlatformMachineUserToken as N, defaultPlatformBaseUrl as O, fetchUserInfo as P, getPlatformBaseUrl as R, hasGenerationHooks as S, hashContent as T, rememberPlatformConfigForToken as U, isDefaultPlatform as V, resolveStaticWebsiteUrls as W, platformBundleDefinePlugin as _, resolveInlineSourcemap as a, resolveBundleLogLevel as b, ResolverSchema as c, buildExecutorArgsExpr as d, buildResolverOperationHookExpr as f, stringifyFunction as g, TailorDBTypeSchema as h, resolverBundleKey as i, fetchMachineUserToken as j, fetchAll as k, HTTP_METHODS as l, assertUniqueTailorDBTypeNamesWithExternal as m, generatePluginFilesIfNeeded as n, WorkflowJobFunctionExecutionPolicySchema as o, assertUniqueLocalTailorDBTypeNames as p, loadApplication as r, WorkflowJobSchema as s, defineApplication as t, INVOKER_EXPR as u, composeFunctionTreeshakeOptions as v, getDistDir as w, getPluginGenerationDependencies as x, createLogLevelTreeshakeOptions as y, initOAuth2Client as z };
+//# sourceMappingURL=application-CUxVA7Fs.mjs.map