@tailor-platform/sdk 1.84.0 → 1.85.1

package/CHANGELOG.md

@@ -1,5 +1,37 @@
 # @tailor-platform/sdk
 
+## 1.85.1
+
+### Patch Changes
+
+- [#2016](https://github.com/tailor-platform/sdk/pull/2016) [`3af95bb`](https://github.com/tailor-platform/sdk/commit/3af95bb486b6df71b835b3529fd0757eff0e8c47) Thanks [@toiroakr](https://github.com/toiroakr)! - Remove a dead `node:module` import from a shared runtime helper chunk that could cause resolver bundling (and `deploy`) to fail with an `UNRESOLVED_IMPORT` error for projects importing `@tailor-platform/sdk/runtime`
+
+## 1.85.0
+
+### Minor Changes
+
+- [#1910](https://github.com/tailor-platform/sdk/pull/1910) [`3153400`](https://github.com/tailor-platform/sdk/commit/3153400e27d8fefcdc6d7c0d0c5ab902f4bb73a3) Thanks [@dqn](https://github.com/dqn)! - Add an `--upsert` flag to seed. Without it, seeding a workspace that already holds some of the rows fails the whole batch for that type on the first duplicate id and inserts nothing. With `--upsert`, every TailorDB row must include an `id`; rows with new ids are inserted, rows with existing ids are updated, and omitted optional fields keep their stored values. Built-In IdP users are created or updated by name, with separate counts for each result. Default behavior is unchanged.
+
+- [#1891](https://github.com/tailor-platform/sdk/pull/1891) [`1c323c3`](https://github.com/tailor-platform/sdk/commit/1c323c3809c825293d3aef7c5ac4605755d39baf) Thanks [@dqn](https://github.com/dqn)! - Add `tailordb migration validate` command that runs the same schema checks as `deploy` without applying anything: migration file integrity (including required `migrate.ts` scripts), local types vs. the latest migration snapshot, and remote schema vs. the migration checkpoint. Issues are reported per namespace with type/field-level detail, `--json` emits a machine-readable report, and the command exits with a non-zero code when drift is found, making it usable as a CI safety gate before deploying.
+  
+  As part of this, `deploy`'s remote schema verification now propagates migration state lookup failures instead of silently skipping verification; only a not-yet-deployed namespace is still treated as a first apply.
+
+### Patch Changes
+
+- [#1911](https://github.com/tailor-platform/sdk/pull/1911) [`62faf2f`](https://github.com/tailor-platform/sdk/commit/62faf2fd3c1260a7aa1aa809db77f31f66ca3b42) Thanks [@dqn](https://github.com/dqn)! - Use each importing file's nearest tsconfig `paths` aliases as a fallback when bundling resolvers, executors, workflows, auth hooks, HTTP adapters, TailorDB hooks and validators, functions, seeds, queries, and migration scripts. A local dependency belonging to a different TypeScript project could previously leave an import unresolved when the bundle entry's project could not resolve it. Normal bundle resolution still takes precedence, so the importing file's aliases apply only when the import would otherwise be unresolved.
+
+- [#1911](https://github.com/tailor-platform/sdk/pull/1911) [`8afbff1`](https://github.com/tailor-platform/sdk/commit/8afbff1c7b12d0fdedb03e0601b81c851dcafb4f) Thanks [@dqn](https://github.com/dqn)! - Fail the build when a bundled file imports a module that cannot be resolved. Previously such an import was silently left in the bundle and only failed at runtime after deploy, including when the tsconfig selected for the build did not declare an alias used by the source. The error names the unresolved specifier, the importing file, and the `tsconfig.json` the build used. Imports explicitly marked as external by a bundler, such as the platform-provided `tailordb` module, remain unaffected.
+
+- [#1937](https://github.com/tailor-platform/sdk/pull/1937) [`648351e`](https://github.com/tailor-platform/sdk/commit/648351ea7ea7b42f18650c1766b5e3c9ff8de83f) Thanks [@dqn](https://github.com/dqn)! - Retry transient connection interruptions for read-only CLI requests
+
+- [#1920](https://github.com/tailor-platform/sdk/pull/1920) [`26626e0`](https://github.com/tailor-platform/sdk/commit/26626e0f05d269a36d0d75cc73a70150fc94f3aa) Thanks [@toiroakr](https://github.com/toiroakr)! - Remove the `undici` dependency. Running the CLI no longer replaces the process-wide HTTP stack with a bundled `undici` build.
+
+- [#1928](https://github.com/tailor-platform/sdk/pull/1928) [`0c97bc7`](https://github.com/tailor-platform/sdk/commit/0c97bc787eb4157626ddd21bbce52e14b015b854) Thanks [@renovate](https://github.com/apps/renovate)! - fix(deps): update dependency globals to v17.8.0
+
+- [#1935](https://github.com/tailor-platform/sdk/pull/1935) [`174eae9`](https://github.com/tailor-platform/sdk/commit/174eae988236ef32a98bcc294150a67ae6eda58d) Thanks [@renovate](https://github.com/apps/renovate)! - fix(deps): update dependency @0no-co/graphql.web to v1.3.3
+
+- [#1936](https://github.com/tailor-platform/sdk/pull/1936) [`54a2690`](https://github.com/tailor-platform/sdk/commit/54a2690b1223318f82d5358e41995ab93368ec86) Thanks [@renovate](https://github.com/apps/renovate)! - fix(deps): update oxc
+
 ## 1.84.0
 
 ### Minor Changes

package/dist/application-C-zsrNjn.mjs

@@ -0,0 +1,3 @@
+import { n as generatePluginFilesIfNeeded, r as loadApplication, t as defineApplication } from "./application-m5tYtz0-.mjs";
+
+export { defineApplication, generatePluginFilesIfNeeded };

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

@@ -5,7 +5,9 @@ import { a as TailorFieldSchema, i as AuthInvokerSchema, n as ExecutorSchema, o
 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";
 
@@ -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;
@@ -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);
 }
 /**
@@ -4118,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};
@@ -4129,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: {
@@ -4146,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
 /**
@@ -4251,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;
 					}
 				},
@@ -4278,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: {
@@ -4293,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`);
@@ -4585,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) => {
@@ -4598,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: {
@@ -4615,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];
@@ -4924,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}";
@@ -4935,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 = [
@@ -4954,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: {
@@ -4969,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];
@@ -5761,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, normalizeBaseUrl as G, initOperatorClient as H, fetchUserInfo as I, byName as J, rememberPlatformConfigForToken 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, isNotFoundError as W, LOG_LEVELS as X, createApplyLimiter 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, resolveStaticWebsiteUrls 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-CnCljDwk.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