@tailor-platform/sdk 1.83.0 → 1.85.0

package/dist/{application-Cp0FxIm2.mjs → application-m5tYtz0-.mjs}

@@ -1,11 +1,13 @@
 import { n as isSdkBranded } from "./brand-Eo4pLXPJ.mjs";
 import { t as assertDefined } from "./assert-DBxo8jPo.mjs";
 import { a as parseBoolean, n as logger, r as styles } from "./logger-CXQq9YIp.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-B0MaodSg.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-CPJWhTLn.mjs";
 import { t as multiline } from "./multiline-sfHpTZZK.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 { t as createCLIError } from "./errors-DVFS0AZk.mjs";
+import { n as isNodeBuiltinImport, t as getNodeBuiltinMessage } from "./node-builtins-CmaL2Cbq.mjs";
+import { createRequire } from "node:module";
 import { z } from "zod";
 import { create } from "@bufbuild/protobuf";
 import * as fs from "node:fs";
@@ -17,12 +19,12 @@ import { pathToFileURL } from "node:url";
 import * as os from "node:os";
 import { OAuth2Client } from "@badgateway/oauth2-client";
 import { Code, ConnectError, createClient } from "@connectrpc/connect";
-import { getGlobalDispatcher } from "undici";
 import pLimit from "p-limit";
 import { resolveTSConfig } from "pkg-types";
 import * as crypto from "node:crypto";
 import * as rolldown from "rolldown";
 import { parseSync } from "oxc-parser";
+import { createPathsMatcher, getTsconfig } from "get-tsconfig";
 import * as inflection from "inflection";
 import * as globals from "globals";
 
@@ -180,7 +182,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-wRkxUta6.mjs")]);
+	const [{ createTracingInterceptor }, { OperatorService }] = await Promise.all([import("./interceptor-D-q1rvRl.mjs"), import("./service_pb-i8CmnQP4.mjs")]);
 	const interceptors = [
 		await userAgentInterceptor(),
 		await bearerTokenInterceptor(accessToken),
@@ -233,9 +235,10 @@ async function bearerTokenInterceptor(accessToken) {
 /**
 * Create an interceptor that retries failed unary requests with backoff.
 *
-* 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.
+* Retries unary methods on `Unavailable`/`ResourceExhausted`, and
+* `Aborted`/`Internal` only for methods declared side-effect-free or 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
@@ -414,6 +417,7 @@ function isRetirable(error, idempotency) {
 	switch (error.code) {
 		case Code.ResourceExhausted:
 		case Code.Unavailable: return true;
+		case Code.Aborted:
 		case Code.Internal: return idempotency === MethodOptions_IdempotencyLevel.NO_SIDE_EFFECTS || idempotency === MethodOptions_IdempotencyLevel.IDEMPOTENT;
 		default: return false;
 	}
@@ -659,12 +663,20 @@ async function fetchPlatformMachineUserToken(clientId, clientSecret, config) {
 	}).clientCredentials();
 }
 /**
-* Close undici's global HTTP connection pool to prevent libuv UV_HANDLE_CLOSING
+* Close the global HTTP connection pool to prevent libuv UV_HANDLE_CLOSING
 * assertion failure on Windows at process exit (Node.js 23.x+).
 * See: https://github.com/nodejs/node/issues/56645
+*
+* The pool is reached through the global dispatcher symbol rather than the `undici`
+* package: importing that package installs its own Agent over these same globals,
+* replacing the HTTP stack Node's `fetch` already uses. The symbol is versioned per
+* Dispatcher API generation, and the newest one wins because older symbols hold a
+* wrapper around that same pool — closing both would destroy it twice.
 */
 async function closeConnectionPool() {
-	await getGlobalDispatcher().close();
+	const globals = globalThis;
+	const dispatcher = globals[Symbol.for("undici.globalDispatcher.2")] ?? globals[Symbol.for("undici.globalDispatcher.1")];
+	if (typeof dispatcher?.close === "function") await dispatcher.close();
 }
 
 //#endregion
@@ -686,17 +698,27 @@ function hashFile(filePath) {
 	const content = fs.readFileSync(filePath);
 	return crypto.createHash("sha256").update(content).digest("hex");
 }
+const MISSING_FILE_MARKER = "<missing>";
 /**
 * Compute a deterministic SHA-256 hash for multiple files.
 *
 * Paths are sorted alphabetically before hashing so that the result
 * is independent of the order the paths are supplied (e.g. glob ordering).
-* Each file's individual hash is concatenated and then hashed again.
+* Each file's individual hash is concatenated and then hashed again. A path
+* that does not exist contributes a fixed marker instead of a content hash.
 * @param filePaths - Array of absolute file paths
 * @returns Hex-encoded SHA-256 hash representing all files
 */
 function hashFiles(filePaths) {
-	return hashContent(filePaths.toSorted().map((fp) => hashFile(fp)).join(""));
+	return hashContent(filePaths.toSorted().map((fp) => hashFileOrMissing(fp)).join(""));
+}
+function hashFileOrMissing(filePath) {
+	try {
+		return hashFile(filePath);
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return MISSING_FILE_MARKER;
+		throw error;
+	}
 }
 
 //#endregion
@@ -771,7 +793,7 @@ function computeBundlerContextHash(params) {
 */
 async function withCache(params) {
 	const { cache, kind, namespace, name, sourceFile, contextHash, build } = params;
-	if (!cache) return await build([]);
+	if (!cache) return await build([], () => {});
 	const content = cache.tryRestore({
 		kind,
 		namespace,
@@ -782,15 +804,16 @@ async function withCache(params) {
 		logger.debug(`  ${styles.dim("cached")}: ${name}`);
 		return content;
 	}
+	const extraDependencies = /* @__PURE__ */ new Set();
 	const { plugin, getResult } = createDepCollectorPlugin();
-	const code = await build([plugin]);
+	const code = await build([plugin], (filePath) => extraDependencies.add(filePath));
 	cache.save({
 		kind,
 		namespace,
 		name,
 		sourceFile,
 		content: code,
-		dependencyPaths: getResult(),
+		dependencyPaths: [...getResult(), ...extraDependencies],
 		contextHash
 	});
 	return code;
@@ -2020,7 +2043,7 @@ function transformFunctionTriggers(source, triggerContext, currentFilePath) {
 	return needsNormalizerHelper && authNamespace ? buildNormalizerHelperSource(authNamespace) + transformed : transformed;
 }
 function createTriggerTransformPlugin(triggerContext) {
-	if (!triggerContext) return void 0;
+	if (!triggerContext || triggerContext.modules.size === 0) return void 0;
 	return {
 		name: "trigger-transform",
 		transform: {
@@ -2033,6 +2056,50 @@ function createTriggerTransformPlugin(triggerContext) {
 	};
 }
 
+//#endregion
+//#region src/cli/shared/bundle-log.ts
+const ESCALATED_LOG_CODE = "UNRESOLVED_IMPORT";
+/**
+* Collect unresolved imports while keeping every other rolldown log suppressed.
+* @param options - Context used to explain which tsconfig was in effect
+* @returns Rolldown options and a post-build assertion
+*/
+function createBundleLog(options = {}) {
+	const unresolvedImports = /* @__PURE__ */ new Map();
+	return {
+		options: {
+			logLevel: "warn",
+			onLog: (_level, log) => {
+				if (log.code !== ESCALATED_LOG_CODE) return;
+				unresolvedImports.set(JSON.stringify([log.exporter, log.id]), log);
+			}
+		},
+		assertAllResolved() {
+			if (unresolvedImports.size > 0) throw unresolvedImportError([...unresolvedImports.values()], options.tsconfig);
+		}
+	};
+}
+function unresolvedImportError(logs, tsconfig) {
+	const imports = logs.map(formatUnresolvedImport);
+	return createCLIError({
+		code: "UNRESOLVED_IMPORT",
+		message: imports.length === 1 ? `Could not resolve ${imports[0]}.` : `Could not resolve ${imports.length} imports.`,
+		details: imports.length === 1 ? void 0 : imports.map((item) => `- ${item}`).join("\n"),
+		suggestion: unresolvedImportSuggestion(logs, tsconfig)
+	});
+}
+function unresolvedImportSuggestion(logs, tsconfig) {
+	const nodeSuggestions = logs.map((log) => log.exporter).filter((specifier) => specifier !== void 0).filter(isNodeBuiltinImport).map(getNodeBuiltinMessage);
+	const hasOtherImports = logs.some((log) => log.exporter === void 0 || !isNodeBuiltinImport(log.exporter));
+	const pathSuggestion = tsconfig ? `Check that each import path is correct, and that a \`compilerOptions.paths\` entry covering it is declared in the importing file's own tsconfig.json or an ancestor. The build used "${tsconfig}".` : "No tsconfig.json was found, so `compilerOptions.paths` aliases were not applied. Add a tsconfig.json declaring the aliases these files import.";
+	return [.../* @__PURE__ */ new Set([...nodeSuggestions, ...hasOtherImports ? [pathSuggestion] : []])].join("\n");
+}
+function formatUnresolvedImport(log) {
+	const specifier = log.exporter ?? "an imported module";
+	const importerId = log.id?.startsWith("\0") ? `a generated entry (${log.id.slice(1)})` : log.id && `"${log.id}"`;
+	return `"${specifier}"${importerId ? ` imported from ${importerId}` : ""}`;
+}
+
 //#endregion
 //#region src/cli/shared/bundle-log-level.ts
 const INFO_LEVEL_CONSOLE_METHODS = [
@@ -2167,6 +2234,71 @@ async function tryResolve(dir) {
 	}
 }
 
+//#endregion
+//#region src/cli/shared/tsconfig-paths-plugin.ts
+/**
+* Create the rolldown plugin that falls back to tsconfig `paths` aliases from
+* the importing file's own nearest tsconfig.
+* @param options - Resolution context for bundlers whose entry inlines user code
+* @returns Rolldown plugin to add to a bundler's plugin list
+*/
+function createTsconfigPathsPlugin(options = {}) {
+	const tsconfigCache = /* @__PURE__ */ new Map();
+	const contextCache = /* @__PURE__ */ new Map();
+	return {
+		name: "tailor-sdk-tsconfig-paths",
+		resolveId: {
+			order: "post",
+			async handler(source, importer) {
+				if (!importer) return null;
+				if (source.startsWith(".") || source.startsWith("/") || source.startsWith("\0")) return null;
+				const resolutionBasis = importer.startsWith("\0") ? options.virtualEntrySourceFile : importer;
+				if (!resolutionBasis) return null;
+				const resolution = getResolutionContext(path.dirname(resolutionBasis), tsconfigCache, contextCache, options.onTsconfigRead);
+				if (!resolution) return null;
+				const candidates = resolution.matcher(source);
+				if (candidates.length === 0) return null;
+				if (await this.resolve(source, importer, { skipSelf: true })) return null;
+				for (const candidate of candidates) {
+					const resolved = await this.resolve(candidate, importer, { skipSelf: true });
+					if (resolved) return resolved;
+				}
+				return null;
+			}
+		}
+	};
+}
+function getResolutionContext(startDir, tsconfigCache, contextCache, onTsconfigRead) {
+	const cached = contextCache.get(startDir);
+	if (cached !== void 0) return cached;
+	const tsconfig = getTsconfig(startDir, "tsconfig.json", tsconfigCache);
+	reportTsconfigDependencies(tsconfigCache, onTsconfigRead);
+	const paths = tsconfig?.config.compilerOptions?.paths;
+	const matcher = paths && Object.keys(paths).length > 0 ? createPathsMatcher(tsconfig) : null;
+	const resolution = matcher ? { matcher } : null;
+	contextCache.set(startDir, resolution);
+	return resolution;
+}
+function reportTsconfigDependencies(cache, onTsconfigRead) {
+	if (!onTsconfigRead) return;
+	const directories = /* @__PURE__ */ new Set();
+	const dependencies = /* @__PURE__ */ new Set();
+	for (const [key, value] of cache) {
+		const dependencyPath = dependencyPathFromCacheKey(key);
+		if (!dependencyPath) continue;
+		if (key.startsWith("statSync:") && isDirectoryStat(value)) directories.add(dependencyPath);
+		else dependencies.add(dependencyPath);
+	}
+	for (const dependencyPath of dependencies) if (!directories.has(dependencyPath)) onTsconfigRead(dependencyPath);
+}
+function dependencyPathFromCacheKey(key) {
+	if (key.startsWith("readFileSync:") && key.endsWith(":utf8")) return key.slice(13, -5);
+	for (const prefix of ["existsSync:", "statSync:"]) if (key.startsWith(prefix)) return key.slice(prefix.length);
+}
+function isDirectoryStat(value) {
+	return typeof value === "object" && value !== null && "isDirectory" in value && typeof value.isDirectory === "function" && value.isDirectory();
+}
+
 //#endregion
 //#region src/cli/shared/virtual-entry.ts
 /**
@@ -2174,17 +2306,20 @@ async function tryResolve(dir) {
 * @param name - Logical entry name
 * @param code - Entry module source
 * @param sourceType - Parser type for the generated module
+* @param resolutionBasis - Source file whose directory resolves generated imports
 * @returns Rolldown input and plugin for loading the entry
 */
-function createVirtualEntry(name, code, sourceType = "js") {
+function createVirtualEntry(name, code, sourceType = "js", resolutionBasis) {
 	const input = `tailor-sdk-entry:${name}.${sourceType}`;
 	const resolvedId = `\0${input}`;
 	return {
 		input,
 		plugin: {
 			name: "tailor-sdk-virtual-entry",
-			resolveId(source, importer) {
-				return source === input && importer === void 0 ? resolvedId : null;
+			async resolveId(source, importer) {
+				if (source === input && importer === void 0) return resolvedId;
+				if (importer !== resolvedId || !resolutionBasis) return null;
+				return this.resolve(source, resolutionBasis, { skipSelf: true });
 			},
 			load(id) {
 				return id === resolvedId ? code : null;
@@ -2192,6 +2327,27 @@ function createVirtualEntry(name, code, sourceType = "js") {
 		}
 	};
 }
+/**
+* Resolve bare imports in a generated on-disk entry from its owning project.
+*
+* Generated entries live under the CLI output directory, which may be outside
+* the project selected by a config path. Resolving their injected dependencies
+* from that output directory would ignore the selected project's installation.
+* @param entryPath - Absolute path of the generated entry
+* @param projectDir - Directory whose dependencies the generated entry uses
+* @returns Rolldown plugin that rebases generated bare imports
+*/
+function createGeneratedEntryResolverPlugin(entryPath, projectDir) {
+	const normalizedEntryPath = path.resolve(entryPath);
+	const resolutionBasis = path.join(path.resolve(projectDir), "__tailor_sdk_generated_entry__.js");
+	return {
+		name: "tailor-sdk-generated-entry-resolver",
+		async resolveId(source, importer) {
+			if (importer === void 0 || path.resolve(importer) !== normalizedEntryPath || source.startsWith(".") || path.isAbsolute(source) || source.startsWith("\0")) return null;
+			return this.resolve(source, resolutionBasis, { skipSelf: true });
+		}
+	};
+}
 
 //#endregion
 //#region src/cli/services/auth/bundler.ts
@@ -2224,7 +2380,7 @@ async function bundleAuthHooks(options) {
 			bundleLogLevel,
 			prefix: JSON.stringify(Object.fromEntries(Object.entries(env).toSorted(([a], [b]) => a.localeCompare(b))))
 		}),
-		async build(cachePlugins) {
+		async build(cachePlugins, trackDependency) {
 			const entryContent = multiline`
         import _config from "${absoluteConfigPath}";
         const __auth_hook_function = _config.${handlerAccessPath};
@@ -2233,12 +2389,13 @@ async function bundleAuthHooks(options) {
           return await __auth_hook_function({ ...args, env });
         }
       `;
-			const entry = createVirtualEntry(`auth-hook:${functionName}`, entryContent);
+			const entry = createVirtualEntry(`auth-hook:${functionName}`, entryContent, "js", absoluteConfigPath);
 			const triggerPlugin = createTriggerTransformPlugin(triggerContext);
 			const plugins = [entry.plugin];
 			if (triggerPlugin) plugins.push(triggerPlugin);
-			plugins.push(platformBundleDefinePlugin, ...cachePlugins);
-			return (await rolldown.build({
+			plugins.push(createTsconfigPathsPlugin({ onTsconfigRead: trackDependency }), platformBundleDefinePlugin, ...cachePlugins);
+			const bundleLog = createBundleLog({ tsconfig });
+			const result = await rolldown.build({
 				input: entry.input,
 				write: false,
 				output: {
@@ -2251,8 +2408,10 @@ async function bundleAuthHooks(options) {
 				plugins,
 				transform: { define: { "process.env.LOG_LEVEL": JSON.stringify(bundleLogLevel) } },
 				treeshake: composeFunctionTreeshakeOptions([createLogLevelTreeshakeOptions(bundleLogLevel)]),
-				logLevel: "silent"
-			})).output[0].code;
+				...bundleLog.options
+			});
+			bundleLog.assertAllResolved();
+			return result.output[0].code;
 		}
 	});
 	logger.log(`${styles.success("Bundled")} auth hook for ${styles.info(`"${authName}"`)}`);
@@ -3401,9 +3560,14 @@ async function bundleScriptTarget(args) {
 	if (unresolved.length > 0) throw new Error(`${context} captures unresolvable variables (${unresolved.join(", ")}). Hooks and validators must not reference variables that cannot be resolved from the source file.
   ${kind}: ${fnSource}`);
 	const entryContent = buildMinimalEntryFromResolved(imports, declarations, fnSource, sourceFilePath);
-	const entry = createVirtualEntry(`tailordb-script:${typeName}:${targetIndex}`, entryContent, "ts");
-	const bundledCode = (await rolldown.build({
-		plugins: [entry.plugin, platformBundleDefinePlugin],
+	const entry = createVirtualEntry(`tailordb-script:${typeName}:${targetIndex}`, entryContent, "ts", sourceFilePath);
+	const bundleLog = createBundleLog({ tsconfig });
+	const buildResult = await rolldown.build({
+		plugins: [
+			entry.plugin,
+			createTsconfigPathsPlugin({ virtualEntrySourceFile: sourceFilePath }),
+			platformBundleDefinePlugin
+		],
 		input: entry.input,
 		write: false,
 		output: {
@@ -3418,8 +3582,10 @@ async function bundleScriptTarget(args) {
 			annotations: true,
 			unknownGlobalSideEffects: false
 		},
-		logLevel: "silent"
-	})).output[0].code;
+		...bundleLog.options
+	});
+	bundleLog.assertAllResolved();
+	const bundledCode = buildResult.output[0].code;
 	return assertParsableExpression(buildPrecompiledExpr(bundledCode), context);
 }
 /**
@@ -3917,6 +4083,8 @@ function buildExecutorArgsExpr(triggerKind, env) {
 		case "schedule": return `({ ...args, appNamespace: args.namespaceName, ${ACTOR_TRANSFORM_EXPR}, ${envExpr} })`;
 		case "resolverExecuted": return `({ ...args, appNamespace: args.namespaceName, ${ACTOR_TRANSFORM_EXPR}, success: !!args.succeeded, result: args.succeeded?.result.resolver, error: args.failed?.error, ${envExpr} })`;
 		case "incomingWebhook": return `({ ...args, appNamespace: args.namespaceName, rawBody: args.raw_body, ${envExpr} })`;
+		case "workflowExecution":
+		case "workflowJobExecution": return `({ ...args, event: args.eventType?.split(".").pop(), rawEvent: args.eventType, ${ACTOR_TRANSFORM_EXPR}, ...(args.succeeded ? { success: true } : args.failed ? { success: false, error: args.failed.error ?? "" } : {}), ${envExpr} })`;
 		default: return `({ ...args, event: args.eventType?.split(".").pop(), rawEvent: args.eventType, appNamespace: args.namespaceName, ${ACTOR_TRANSFORM_EXPR}, ${envExpr} })`;
 	}
 }
@@ -4116,9 +4284,10 @@ async function bundleSingleExecutor(executor, tsconfig, triggerContext, cache, i
 		name: executor.name,
 		sourceFile: executor.sourceFile,
 		contextHash,
-		async build(cachePlugins) {
+		async build(cachePlugins, trackDependency) {
+			const absoluteSourcePath = path.resolve(executor.sourceFile);
 			const entryContent = multiline`
-        import _internalExecutor from "${path.resolve(executor.sourceFile)}";
+        import _internalExecutor from "${absoluteSourcePath}";
 
         const __executor_function = async (args) => {
           const invoker = ${INVOKER_EXPR};
@@ -4127,12 +4296,13 @@ async function bundleSingleExecutor(executor, tsconfig, triggerContext, cache, i
 
         export { __executor_function as main };
       `;
-			const entry = createVirtualEntry(`executor:${executor.name}`, entryContent);
+			const entry = createVirtualEntry(`executor:${executor.name}`, entryContent, "js", absoluteSourcePath);
 			const triggerPlugin = createTriggerTransformPlugin(triggerContext);
 			const plugins = [entry.plugin];
 			if (triggerPlugin) plugins.push(triggerPlugin);
-			plugins.push(platformBundleDefinePlugin, ...cachePlugins);
-			return (await rolldown.build({
+			plugins.push(createTsconfigPathsPlugin({ onTsconfigRead: trackDependency }), platformBundleDefinePlugin, ...cachePlugins);
+			const bundleLog = createBundleLog({ tsconfig });
+			const result = await rolldown.build({
 				input: entry.input,
 				write: false,
 				output: {
@@ -4144,22 +4314,15 @@ async function bundleSingleExecutor(executor, tsconfig, triggerContext, cache, i
 				tsconfig,
 				plugins,
 				treeshake: composeFunctionTreeshakeOptions([createLogLevelTreeshakeOptions(bundleLogLevel)]),
-				logLevel: "silent"
-			})).output[0].code;
+				...bundleLog.options
+			});
+			bundleLog.assertAllResolved();
+			return result.output[0].code;
 		}
 	});
 	return [executor.name, code];
 }
 
-//#endregion
-//#region src/cli/services/http-adapter/node-builtins.ts
-const NODE_BUILTINS = new Set(builtinModules.filter((m) => !m.startsWith("_")));
-function isNodeBuiltinImport(source) {
-	if (source.startsWith("node:")) return true;
-	const root = source.includes("/") ? source.slice(0, source.indexOf("/")) : source;
-	return NODE_BUILTINS.has(root);
-}
-
 //#endregion
 //#region src/parser/service/http-adapter/methods.ts
 /**
@@ -4249,16 +4412,16 @@ async function bundleAdapterScript(adapter, kind, tsconfig, cache, bundleLogLeve
 		name: adapter.name,
 		sourceFile: adapter.sourceFile,
 		contextHash,
-		async build(cachePlugins) {
+		async build(cachePlugins, trackDependency) {
 			const absoluteSourcePath = path.resolve(adapter.sourceFile);
 			const entryContent = kind === "input" ? buildInputEntry(absoluteSourcePath, adapter.methods, GRAPHQL_WEB_MODULE) : buildOutputEntry(absoluteSourcePath);
-			const entry = createVirtualEntry(`http-adapter:${adapter.name}:${kind}`, entryContent);
+			const entry = createVirtualEntry(`http-adapter:${adapter.name}:${kind}`, entryContent, "js", absoluteSourcePath);
 			const plugins = [
 				entry.plugin,
 				{
 					name: "http-adapter-reject-node-imports",
 					resolveId(source) {
-						if (isNodeBuiltinImport(source)) throw new Error(`HTTP adapter "${adapter.name}" imports Node module "${source}", which is unavailable in the gateway runtime`);
+						if (isNodeBuiltinImport(source)) throw new Error(`HTTP adapter "${adapter.name}": ${getNodeBuiltinMessage(source)}`);
 						return null;
 					}
 				},
@@ -4276,9 +4439,11 @@ async function bundleAdapterScript(adapter, kind, tsconfig, cache, bundleLogLeve
 						return null;
 					}
 				},
+				createTsconfigPathsPlugin({ onTsconfigRead: trackDependency }),
 				...cachePlugins
 			];
-			const bundled = (await rolldown.build({
+			const bundleLog = createBundleLog({ tsconfig });
+			const result = await rolldown.build({
 				input: entry.input,
 				write: false,
 				output: {
@@ -4291,8 +4456,10 @@ async function bundleAdapterScript(adapter, kind, tsconfig, cache, bundleLogLeve
 				plugins,
 				transform: { target: "es2017" },
 				treeshake: composeFunctionTreeshakeOptions([createLogLevelTreeshakeOptions(bundleLogLevel)]),
-				logLevel: "silent"
-			})).output[0].code;
+				...bundleLog.options
+			});
+			bundleLog.assertAllResolved();
+			const bundled = result.output[0].code;
 			const byteLength = Buffer.byteLength(bundled, "utf8");
 			if (byteLength > ADAPTER_BUNDLE_ERROR_BYTES) throw new Error(`HTTP adapter "${adapter.name}" ${kind} script is ${byteLength} bytes, exceeding the ${ADAPTER_BUNDLE_ERROR_BYTES} byte limit`);
 			if (byteLength > ADAPTER_BUNDLE_WARN_BYTES) logger.warn(`HTTP adapter "${adapter.name}" ${kind} script is ${byteLength} bytes, larger than the recommended ${ADAPTER_BUNDLE_WARN_BYTES} byte limit`);
@@ -4583,9 +4750,10 @@ async function bundleSingleResolver(namespace, resolver, tsconfig, triggerContex
 		name: resolver.name,
 		sourceFile: resolver.sourceFile,
 		contextHash,
-		async build(cachePlugins) {
+		async build(cachePlugins, trackDependency) {
+			const absoluteSourcePath = path.resolve(resolver.sourceFile);
 			const entryContent = multiline`
-        import _internalResolver from "${path.resolve(resolver.sourceFile)}";
+        import _internalResolver from "${absoluteSourcePath}";
         import { t } from "@tailor-platform/sdk";
 
         const $tailor_resolver_body = async (context) => {
@@ -4596,12 +4764,13 @@ async function bundleSingleResolver(namespace, resolver, tsconfig, triggerContex
 
         export { $tailor_resolver_body as main };
       `;
-			const entry = createVirtualEntry(`resolver:${resolver.name}`, entryContent);
+			const entry = createVirtualEntry(`resolver:${resolver.name}`, entryContent, "js", absoluteSourcePath);
 			const triggerPlugin = createTriggerTransformPlugin(triggerContext);
 			const plugins = [entry.plugin];
 			if (triggerPlugin) plugins.push(triggerPlugin);
-			plugins.push(platformBundleDefinePlugin, ...cachePlugins);
-			return (await rolldown.build({
+			plugins.push(createTsconfigPathsPlugin({ onTsconfigRead: trackDependency }), platformBundleDefinePlugin, ...cachePlugins);
+			const bundleLog = createBundleLog({ tsconfig });
+			const result = await rolldown.build({
 				input: entry.input,
 				write: false,
 				output: {
@@ -4613,8 +4782,10 @@ async function bundleSingleResolver(namespace, resolver, tsconfig, triggerContex
 				tsconfig,
 				plugins,
 				treeshake: composeFunctionTreeshakeOptions([createLogLevelTreeshakeOptions(bundleLogLevel)]),
-				logLevel: "silent"
-			})).output[0].code;
+				...bundleLog.options
+			});
+			bundleLog.assertAllResolved();
+			return result.output[0].code;
 		}
 	});
 	return [resolver.name, code];
@@ -4922,7 +5093,7 @@ async function bundleSingleJob(job, allJobs, tsconfig, env, triggerContext, cach
 		name: job.name,
 		sourceFile: job.sourceFile,
 		contextHash,
-		async build(cachePlugins) {
+		async build(cachePlugins, trackDependency) {
 			const absoluteSourcePath = path.resolve(job.sourceFile);
 			const entryContent = multiline`
         import { ${job.exportName} } from "${absoluteSourcePath}";
@@ -4933,7 +5104,7 @@ async function bundleSingleJob(job, allJobs, tsconfig, env, triggerContext, cach
           return await ${job.exportName}.body(input, { env, invoker });
         }
       `;
-			const entry = createVirtualEntry(`workflow-job:${job.name}`, entryContent);
+			const entry = createVirtualEntry(`workflow-job:${job.name}`, entryContent, "js", absoluteSourcePath);
 			const resolvedSourceFile = safeRealpath(job.sourceFile);
 			const otherJobExportNames = allJobs.filter((candidate) => candidate.name !== job.name && safeRealpath(candidate.sourceFile) === resolvedSourceFile).map((j) => j.exportName);
 			const plugins = [
@@ -4952,10 +5123,12 @@ async function bundleSingleJob(job, allJobs, tsconfig, env, triggerContext, cach
 						}
 					}
 				},
+				createTsconfigPathsPlugin({ onTsconfigRead: trackDependency }),
 				platformBundleDefinePlugin,
 				...cachePlugins
 			];
-			return (await rolldown.build({
+			const bundleLog = createBundleLog({ tsconfig });
+			const result = await rolldown.build({
 				input: entry.input,
 				write: false,
 				output: {
@@ -4967,8 +5140,10 @@ async function bundleSingleJob(job, allJobs, tsconfig, env, triggerContext, cach
 				tsconfig,
 				plugins,
 				treeshake: composeFunctionTreeshakeOptions([createLogLevelTreeshakeOptions(bundleLogLevel)]),
-				logLevel: "silent"
-			})).output[0].code;
+				...bundleLog.options
+			});
+			bundleLog.assertAllResolved();
+			return result.output[0].code;
 		}
 	});
 	return [job.name, code];
@@ -4979,7 +5154,8 @@ async function bundleSingleJob(job, allJobs, tsconfig, env, triggerContext, cach
 const WorkflowJobSchema = z.object({
 	name: z.string().describe("Job name (must be unique across the project)"),
 	trigger: functionSchema.describe("Trigger function that initiates the job"),
-	body: functionSchema.describe("Job implementation function")
+	body: functionSchema.describe("Job implementation function"),
+	publishEvents: z.boolean().optional().describe("Enable publishing job execution events for this job")
 });
 const durationUnits = [
 	"ms",
@@ -5025,7 +5201,8 @@ const WorkflowSchema = z.object({
 	name: z.string().describe("Workflow name"),
 	mainJob: WorkflowJobSchema.describe("Main job that starts the workflow"),
 	retryPolicy: RetryPolicySchema.optional().describe("Retry policy for the workflow"),
-	concurrencyPolicy: ConcurrencyPolicySchema.optional().describe("Concurrency policy for the workflow")
+	concurrencyPolicy: ConcurrencyPolicySchema.optional().describe("Concurrency policy for the workflow"),
+	publishEvents: z.boolean().optional().describe("Enable publishing workflow execution events for this workflow")
 });
 
 //#endregion
@@ -5147,7 +5324,8 @@ async function loadFileContent(filePath) {
 			if (jobResult.success) jobs.push({
 				name: jobResult.data.name,
 				exportName,
-				sourceFile: filePath
+				sourceFile: filePath,
+				...jobResult.data.publishEvents !== void 0 ? { publishEvents: jobResult.data.publishEvents } : {}
 			});
 			else if (isSdkBranded(exportValue, ["workflow", "workflow-job"])) throw jobResult.error;
 		}
@@ -5756,5 +5934,5 @@ async function loadApplication(params) {
 }
 
 //#endregion
-export { defaultPlatformBaseUrl as A, getPlatformBaseUrl as B, getPluginGenerationDependencies as C, hashContent as D, getDistDir as E, fetchPlatformMachineUserToken as F, rememberPlatformConfigForToken as G, initOperatorClient as H, fetchUserInfo as I, createApplyLimiter as J, resolveStaticWebsiteUrls as K, getConsoleBaseUrl as L, fetchAllTolerant as M, fetchMachineUserToken as N, hashFile as O, fetchPaged as P, getOAuth2ClientId as R, resolveBundleLogLevel as S, createBundleCache as T, isDefaultPlatform as U, initOAuth2Client as V, normalizeBaseUrl as W, LOG_LEVELS as Y, stringifyFunction as _, resolveInlineSourcemap as a, composeFunctionTreeshakeOptions as b, ResolverSchema as c, buildExecutorArgsExpr as d, buildResolverOperationHookExpr as f, TailorDBTypeSchema as g, assertUniqueTailorDBTypeNamesWithExternal as h, resolverBundleKey as i, fetchAll as j, closeConnectionPool as k, HTTP_METHODS as l, assertUniqueLocalTailorDBTypeNames as m, generatePluginFilesIfNeeded as n, WorkflowJobFunctionExecutionPolicySchema as o, buildResolverPermissionAndInputCheckExpr as p, byName as q, loadApplication as r, WorkflowJobSchema as s, defineApplication as t, INVOKER_EXPR as u, resolveTSConfigWithFallback as v, hasGenerationHooks as w, createLogLevelTreeshakeOptions as x, platformBundleDefinePlugin as y, getOrNull as z };
-//# sourceMappingURL=application-Cp0FxIm2.mjs.map
+export { LOG_LEVELS as $, hashContent as A, getConsoleBaseUrl as B, createLogLevelTreeshakeOptions as C, hasGenerationHooks as D, getPluginGenerationDependencies as E, fetchAllTolerant as F, initOperatorClient as G, getOrNull as H, fetchMachineUserToken as I, normalizeBaseUrl as J, isDefaultPlatform as K, fetchPaged as L, closeConnectionPool as M, defaultPlatformBaseUrl as N, createBundleCache as O, fetchAll as P, createApplyLimiter as Q, fetchPlatformMachineUserToken as R, composeFunctionTreeshakeOptions as S, createBundleLog as T, getPlatformBaseUrl as U, getOAuth2ClientId as V, initOAuth2Client as W, resolveStaticWebsiteUrls as X, rememberPlatformConfigForToken as Y, byName as Z, stringifyFunction as _, resolveInlineSourcemap as a, resolveTSConfigWithFallback as b, ResolverSchema as c, buildExecutorArgsExpr as d, buildResolverOperationHookExpr as f, TailorDBTypeSchema as g, assertUniqueTailorDBTypeNamesWithExternal as h, resolverBundleKey as i, hashFile as j, getDistDir as k, HTTP_METHODS as l, assertUniqueLocalTailorDBTypeNames as m, generatePluginFilesIfNeeded as n, WorkflowJobFunctionExecutionPolicySchema as o, buildResolverPermissionAndInputCheckExpr as p, isNotFoundError as q, loadApplication as r, WorkflowJobSchema as s, defineApplication as t, INVOKER_EXPR as u, createGeneratedEntryResolverPlugin as v, resolveBundleLogLevel as w, platformBundleDefinePlugin as x, createTsconfigPathsPlugin as y, fetchUserInfo as z };
+//# sourceMappingURL=application-m5tYtz0-.mjs.map