@tailor-platform/sdk 1.73.2 → 1.74.0

package/dist/{application-Bb9NNp5m.mjs → application-DwmoI6ZQ.mjs}

@@ -1,7 +1,7 @@
 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-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-DiEtAsvc.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 { t as multiline } from "./multiline-sfHpTZZK.mjs";
 import { n as fileUtilsPlugin, t as FileUtilsGeneratorID } from "./file-utils-DcyIPFQh.mjs";
@@ -1540,8 +1540,8 @@ function createDepCollectorPlugin() {
 
 //#endregion
 //#region src/cli/cache/bundle-cache.ts
-function buildCacheKey(kind, name) {
-	return `${kind}:${name}`;
+function buildCacheKey(kind, name, namespace) {
+	return namespace ? `${kind}:${namespace}:${name}` : `${kind}:${name}`;
 }
 function combineHash(fileHash, contextHash) {
 	if (!contextHash) return fileHash;
@@ -1568,10 +1568,11 @@ function computeBundlerContextHash(params) {
 * @returns The bundled code string
 */
 async function withCache(params) {
-	const { cache, kind, name, sourceFile, contextHash, build } = params;
+	const { cache, kind, namespace, name, sourceFile, contextHash, build } = params;
 	if (!cache) return await build([]);
 	const content = cache.tryRestore({
 		kind,
+		namespace,
 		name,
 		contextHash
 	});
@@ -1583,6 +1584,7 @@ async function withCache(params) {
 	const code = await build([plugin]);
 	cache.save({
 		kind,
+		namespace,
 		name,
 		sourceFile,
 		content: code,
@@ -1598,7 +1600,7 @@ async function withCache(params) {
 */
 function createBundleCache(store) {
 	function tryRestore(params) {
-		const cacheKey = buildCacheKey(params.kind, params.name);
+		const cacheKey = buildCacheKey(params.kind, params.name, params.namespace);
 		const entry = store.getEntry(cacheKey);
 		if (!entry) return;
 		let currentHash;
@@ -1611,8 +1613,8 @@ function createBundleCache(store) {
 		return store.restoreBundleContent(cacheKey);
 	}
 	function save(params) {
-		const { kind, name, sourceFile, content, dependencyPaths, contextHash } = params;
-		const cacheKey = buildCacheKey(kind, name);
+		const { kind, namespace, name, sourceFile, content, dependencyPaths, contextHash } = params;
+		const cacheKey = buildCacheKey(kind, name, namespace);
 		const allDeps = dependencyPaths.includes(sourceFile) ? dependencyPaths : [sourceFile, ...dependencyPaths];
 		const inputHash = combineHash(hashFiles(allDeps), contextHash);
 		const contentHash = hashContent(content);
@@ -2324,6 +2326,32 @@ function getImportSource(node) {
 	}
 	return null;
 }
+function argumentSourceText(arg, sourceText) {
+	if (arg && typeof arg === "object" && "start" in arg && "end" in arg) return sourceText.slice(arg.start, arg.end);
+}
+/**
+* Get metadata for a static `identifier.trigger(...)` call.
+* @param node - AST node to inspect
+* @param sourceText - Source code text
+* @returns Trigger call metadata, or null when the node is not a trigger call
+*/
+function getTriggerCallInfo(node, sourceText) {
+	if (!node || typeof node !== "object" || node.type !== "CallExpression") return null;
+	const callExpr = node;
+	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;
+	return {
+		identifierName: memberExpr.object.name,
+		callRange: {
+			start: callExpr.start,
+			end: callExpr.end
+		},
+		argsText: argumentSourceText(callExpr.arguments[0], sourceText) ?? "",
+		optionsText: argumentSourceText(callExpr.arguments[1], sourceText)
+	};
+}
 /**
 * Unwrap AwaitExpression to get the inner expression
 * @param node - AST expression node
@@ -2370,12 +2398,20 @@ function findProperty(properties, name) {
 /**
 * Apply string replacements to source code
 * Replacements are applied from end to start to maintain positions
+* Ranges must not overlap; applying an overlapping range on top of an
+* already-shifted string would splice at stale offsets and corrupt the output,
+* so overlap is rejected up front
 * @param source - Original source code
 * @param replacements - Replacements to apply
 * @returns Transformed source code
 */
 function applyReplacements(source, replacements) {
 	const sorted = replacements.toSorted((a, b) => b.start - a.start);
+	for (let i = 0; i + 1 < sorted.length; i++) {
+		const current = assertDefined(sorted[i], `replacement missing at index ${i}`);
+		const previous = assertDefined(sorted[i + 1], `replacement missing at index ${i + 1}`);
+		if (previous.end > current.start) throw new Error(`applyReplacements: overlapping replacement ranges [${previous.start}, ${previous.end}) and [${current.start}, ${current.end})`);
+	}
 	let result = source;
 	for (const r of sorted) result = result.slice(0, r.start) + r.text + result.slice(r.end);
 	return result;
@@ -2570,29 +2606,12 @@ function detectTriggerCalls(program, sourceText) {
 	const calls = [];
 	function walk(node) {
 		if (!node || typeof node !== "object") return;
-		if (node.type === "CallExpression") {
-			const callExpr = node;
-			const callee = callExpr.callee;
-			if (callee.type === "MemberExpression") {
-				const memberExpr = callee;
-				if (!memberExpr.computed && memberExpr.object.type === "Identifier" && memberExpr.property.name === "trigger") {
-					const identifierName = memberExpr.object.name;
-					let argsText = "";
-					if (callExpr.arguments.length > 0) {
-						const firstArg = callExpr.arguments[0];
-						if (firstArg && "start" in firstArg && "end" in firstArg) argsText = sourceText.slice(firstArg.start, firstArg.end);
-					}
-					calls.push({
-						identifierName,
-						callRange: {
-							start: callExpr.start,
-							end: callExpr.end
-						},
-						argsText
-					});
-				}
-			}
-		}
+		const triggerCall = getTriggerCallInfo(node, sourceText);
+		if (triggerCall) calls.push({
+			identifierName: triggerCall.identifierName,
+			callRange: triggerCall.callRange,
+			argsText: triggerCall.argsText
+		});
 		for (const key of Object.keys(node)) {
 			const child = node[key];
 			if (Array.isArray(child)) child.forEach((c) => walk(c));
@@ -2698,44 +2717,19 @@ function detectDefaultImports(program) {
 * Name of the injected runtime normalizer helper. Chosen to be unique enough
 * to avoid collisions with user code.
 */
-const NORMALIZER_IDENTIFIER = "__tailor_normalizeAuthInvoker";
+const NORMALIZER_IDENTIFIER = "__tailor_normalizeTriggerOptions";
 /**
 * Build the source text of the injected normalizer helper.
 *
-* Accepts either a plain string (machine user name) or the object form
-* `{ namespace, machineUserName }`, and always returns the object form.
-* The auth namespace is baked in at bundle time.
+* 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} = (v) => typeof v === "string" ? { namespace: ${JSON.stringify(authNamespace)}, machineUserName: v } : v;\n`;
-}
-/**
-* Extract authInvoker info from a config object expression
-* Returns the authInvoker value text and whether it's a shorthand property
-* @param configArg - Config argument node
-* @param sourceText - Source code text
-* @returns Extracted authInvoker info, if any
-*/
-function extractAuthInvokerInfo(configArg, sourceText) {
-	if (!configArg || typeof configArg !== "object") return void 0;
-	if (configArg.type !== "ObjectExpression") return void 0;
-	const objExpr = configArg;
-	for (const prop of objExpr.properties) {
-		if (prop.type !== "Property") continue;
-		const objProp = prop;
-		if ((objProp.key.type === "Identifier" ? objProp.key.name : objProp.key.type === "Literal" ? objProp.key.value : null) === "authInvoker") {
-			if (objProp.shorthand) return {
-				isShorthand: true,
-				valueText: "authInvoker"
-			};
-			return {
-				isShorthand: false,
-				valueText: sourceText.slice(objProp.value.start, objProp.value.end)
-			};
-		}
-	}
+	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.
@@ -2865,48 +2859,23 @@ function detectExtendedTriggerCalls(program, sourceText, workflowNames, jobNames
 	const calls = [];
 	function walk(node) {
 		if (!node || typeof node !== "object") return;
-		if (node.type === "CallExpression") {
-			const callExpr = node;
-			const callee = callExpr.callee;
-			if (callee.type === "MemberExpression") {
-				const memberExpr = callee;
-				const identifierName = !memberExpr.computed && memberExpr.object.type === "Identifier" ? memberExpr.object.name : null;
-				const propertyName = !memberExpr.computed ? memberExpr.property.name : null;
-				if (identifierName && propertyName === "trigger") {
-					const isWorkflow = workflowNames.has(identifierName);
-					const isJob = jobNames.has(identifierName);
-					if (isWorkflow || isJob) {
-						const argCount = callExpr.arguments.length;
-						let argsText = "";
-						if (argCount > 0) {
-							const firstArg = callExpr.arguments[0];
-							if (firstArg && "start" in firstArg && "end" in firstArg) argsText = sourceText.slice(firstArg.start, firstArg.end);
-						}
-						if (isWorkflow && argCount >= 2) {
-							const secondArg = callExpr.arguments[1];
-							const authInvoker = extractAuthInvokerInfo(secondArg, sourceText);
-							if (authInvoker) calls.push({
-								kind: "workflow",
-								identifierName,
-								callRange: {
-									start: callExpr.start,
-									end: callExpr.end
-								},
-								argsText,
-								authInvoker
-							});
-						} else if (isJob) calls.push({
-							kind: "job",
-							identifierName,
-							callRange: {
-								start: callExpr.start,
-								end: callExpr.end
-							},
-							argsText
-						});
-					}
-				}
-			}
+		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
+			});
 		}
 		for (const key of Object.keys(node)) {
 			const child = node[key];
@@ -2945,20 +2914,32 @@ function transformFunctionTriggers(source, workflowNameMap, jobNameMap, workflow
 			}
 		}
 	}
-	const triggerCalls = detectExtendedTriggerCalls(program, source, new Set(localWorkflowNameMap.keys()), new Set(jobNameMap.keys()));
+	const allTriggerCalls = detectExtendedTriggerCalls(program, source, new Set(localWorkflowNameMap.keys()), new Set(jobNameMap.keys()));
+	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;
+	});
+	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" && call.authInvoker) {
+	for (const call of triggerCalls) if (call.kind === "workflow") {
 		const workflowName = localWorkflowNameMap.get(call.identifierName);
 		if (workflowName) {
-			const rawExpr = call.authInvoker.isShorthand ? "authInvoker" : call.authInvoker.valueText;
-			let authInvokerExpr;
-			if (authNamespace) {
-				authInvokerExpr = `${NORMALIZER_IDENTIFIER}(${rawExpr})`;
+			let optionsPart = "";
+			if (call.optionsText !== void 0) if (authNamespace) {
+				optionsPart = `, ${NORMALIZER_IDENTIFIER}(${call.optionsText})`;
 				needsNormalizerHelper = true;
-			} else authInvokerExpr = rawExpr;
-			const transformedCall = `tailor.workflow.triggerWorkflow("${workflowName}", ${call.argsText || "undefined"}, { authInvoker: ${authInvokerExpr} })`;
+			} else optionsPart = `, ${call.optionsText}`;
+			const transformedCall = `tailor.workflow.triggerWorkflow("${workflowName}", ${call.argsText || "undefined"}${optionsPart})`;
 			replacements.push({
 				start: call.callRange.start,
 				end: call.callRange.end,
@@ -2966,7 +2947,7 @@ function transformFunctionTriggers(source, workflowNameMap, jobNameMap, workflow
 			});
 			transformedCallsPerIdentifier.set(call.identifierName, (transformedCallsPerIdentifier.get(call.identifierName) ?? 0) + 1);
 		}
-	} else if (call.kind === "job") {
+	} else {
 		const jobName = jobNameMap.get(call.identifierName);
 		if (jobName) {
 			const transformedCall = `(async () => tailor.workflow.triggerJobFunction("${jobName}", ${call.argsText || "undefined"}))()`;
@@ -3161,6 +3142,28 @@ async function bundleAuthHooks(options) {
 	return bundledCode;
 }
 
+//#endregion
+//#region src/utils/script-expr.ts
+const MAX_GENERATED_CODE_LENGTH = 2e3;
+function formatGeneratedCode(expr) {
+	if (expr.length <= MAX_GENERATED_CODE_LENGTH) return `Generated code:\n${expr}`;
+	return `Generated code (truncated to ${MAX_GENERATED_CODE_LENGTH} of ${expr.length} characters):\n${expr.slice(0, MAX_GENERATED_CODE_LENGTH)}\n...`;
+}
+/**
+* Assert that a generated script expression is syntactically valid JavaScript.
+* Invalid generated code would otherwise surface much later as a confusing
+* bundler or platform-side syntax error, far from the definition that caused it.
+* @param expr - Generated JavaScript expression
+* @param context - What generated the expression, used to label the error
+* @returns The expression unchanged when it parses successfully
+*/
+function assertParsableExpression(expr, context) {
+	const { errors } = parseSync("generated-expr.js", `(${expr}\n);`);
+	if (errors.length === 0) return expr;
+	const details = errors.map((error) => `  - ${error.message}`).join("\n");
+	throw new Error(`Generated ${context} script is not valid JavaScript.\nParse errors:\n${details}\n` + formatGeneratedCode(expr));
+}
+
 //#endregion
 //#region src/parser/service/tailordb/hooks-validate-precompiled-expr.ts
 const PRECOMPILED_EXPR_KEY = "__precompiledScriptExpr";
@@ -3214,30 +3217,38 @@ const stringifyFunction = (fn) => {
 	if (firstObjectProperty(`({m: ${src}})`)) return src;
 	const wrapped = `({${src}})`;
 	const property = firstObjectProperty(wrapped);
-	if (property?.type === "Property" && property.method && !property.computed && property.value.type === "FunctionExpression") {
+	if (property?.type === "Property" && property.method && property.computed) throw new Error("Computed-key method shorthand cannot be converted to a TailorDB script expression. Use an arrow function or function expression instead.");
+	if (property?.type === "Property" && property.method && property.value.type === "FunctionExpression") {
 		const { async, generator } = property.value;
 		const body = wrapped.slice(property.value.start, property.value.end);
 		return `${async ? "async " : ""}function${generator ? "*" : ""} ${body}`;
 	}
 	return src;
 };
+function formatScriptContext(kind, context) {
+	if (!context) return kind === "validate" ? kind : "hooks";
+	return `${kind} for ${context.typeName}.${context.fieldPath.join(".")}`;
+}
 /**
 * Convert a hook or validator function to a script expression.
 * @param fn - Hook or validator function
+* @param kind - Label naming the source of the expression in conversion errors
+* @param context - Optional field context for conversion errors
 * @returns JavaScript expression calling the function
 */
-const convertToScriptExpr = (fn) => {
+const convertToScriptExpr = (fn, kind, context) => {
 	const precompiledExpr = getPrecompiledScriptExpr(fn);
 	if (precompiledExpr) return precompiledExpr;
-	return `(${stringifyFunction(fn)})({ value: _value, data: _data, user: ${tailorUserMap} })`;
+	return assertParsableExpression(`(${stringifyFunction(fn)})({ value: _value, data: _data, user: ${tailorUserMap} })`, formatScriptContext(kind, context));
 };
 /**
 * Parse TailorDBField into OperatorFieldConfig.
 * This transforms user-defined functions into script expressions.
 * @param field - TailorDB field definition
+* @param context - Optional field context for conversion errors
 * @returns Parsed operator field configuration
 */
-function parseFieldConfig(field) {
+function parseFieldConfig(field, context) {
 	const metadata = field.metadata;
 	const fieldType = field.type;
 	const rawRelation = field.rawRelation;
@@ -3247,7 +3258,10 @@ function parseFieldConfig(field) {
 		...metadata,
 		rawRelation,
 		...fieldType === "nested" && nestedFields && Object.keys(nestedFields).length > 0 ? { fields: Object.entries(nestedFields).reduce((acc, [key, nestedField]) => {
-			acc[key] = parseFieldConfig(nestedField);
+			acc[key] = parseFieldConfig(nestedField, context && {
+				...context,
+				fieldPath: [...context.fieldPath, key]
+			});
 			return acc;
 		}, {}) } : {},
 		validate: metadata.validate?.map((v) => {
@@ -3259,13 +3273,13 @@ function parseFieldConfig(field) {
 				message: v[1]
 			};
 			return {
-				script: { expr: convertToScriptExpr(fn) },
+				script: { expr: convertToScriptExpr(fn, "validate", context) },
 				errorMessage: message
 			};
 		}),
 		hooks: metadata.hooks ? {
-			create: metadata.hooks.create ? { expr: convertToScriptExpr(metadata.hooks.create) } : void 0,
-			update: metadata.hooks.update ? { expr: convertToScriptExpr(metadata.hooks.update) } : void 0
+			create: metadata.hooks.create ? { expr: convertToScriptExpr(metadata.hooks.create, "hooks.create", context) } : void 0,
+			update: metadata.hooks.update ? { expr: convertToScriptExpr(metadata.hooks.update, "hooks.update", context) } : void 0
 		} : void 0,
 		serial: metadata.serial ? {
 			start: metadata.serial.start,
@@ -3508,7 +3522,7 @@ function applyRelationMetadataToFieldConfig(fieldConfig, metadata) {
 function parseTypes(rawTypes, namespace, typeSourceInfo) {
 	const types = createRecord();
 	const allTypeNames = new Set(Object.keys(rawTypes));
-	for (const [typeName, type] of Object.entries(rawTypes)) types[typeName] = parseTailorDBType(type, allTypeNames, rawTypes);
+	for (const [typeName, type] of Object.entries(rawTypes)) types[typeName] = parseTailorDBType(type, allTypeNames, rawTypes, typeSourceInfo);
 	buildBackwardRelationships(types, namespace, typeSourceInfo);
 	validatePluralFormUniqueness(types, namespace, typeSourceInfo);
 	return types;
@@ -3518,21 +3532,26 @@ function parseTypes(rawTypes, namespace, typeSourceInfo) {
 * @param type - TailorDB type to parse
 * @param allTypeNames - Set of all TailorDB type names
 * @param rawTypes - All raw TailorDB types keyed by name
+* @param typeSourceInfo - Optional type source information
 * @returns Parsed TailorDB type
 */
-function parseTailorDBType(type, allTypeNames, rawTypes) {
+function parseTailorDBType(type, allTypeNames, rawTypes, typeSourceInfo) {
 	const metadata = type.metadata;
 	const pluralForm = metadata.settings?.pluralForm || inflection.pluralize(type.name);
+	const typeLocation = formatTypeSourceLocation(getTypeSourceInfo(typeSourceInfo, type.name));
 	const fields = createRecord();
 	const forwardRelationships = createRecord();
 	for (const [fieldName, fieldDef] of Object.entries(type.fields)) {
-		let fieldConfig = parseFieldConfig(fieldDef);
-		const rawRelation = fieldConfig.rawRelation;
 		const context = {
 			typeName: type.name,
 			fieldName,
 			allTypeNames
 		};
+		let fieldConfig = parseFieldConfig(fieldDef, {
+			typeName: type.name,
+			fieldPath: [fieldName]
+		});
+		const rawRelation = fieldConfig.rawRelation;
 		if (rawRelation) {
 			validateRelationConfig(rawRelation, context);
 			if ([
@@ -3552,9 +3571,18 @@ function parseTailorDBType(type, allTypeNames, rawTypes) {
 		const relationInfo = rawRelation ? buildRelationInfo(rawRelation, context) : void 0;
 		if (relationInfo) {
 			parsedField.relation = { ...relationInfo };
+			const forwardName = relationInfo.forwardName;
+			if (forwardName.length === 0) throw new Error(`Forward relation name for field "${fieldName}" on type "${type.name}"${typeLocation} cannot be empty. Use the "as" option in .relation({ toward: { as: ... } }) to specify a non-empty name.`);
+			const existingForward = forwardRelationships[forwardName];
+			if (existingForward) throw new Error(`Forward relation name "${forwardName}" on type "${type.name}"${typeLocation} is duplicated between fields "${existingForward.targetField}" and "${fieldName}". Use the "as" option in .relation({ toward: { as: ... } }) to specify a unique name.`);
+			if (Object.hasOwn(type.fields, forwardName)) {
+				const message = forwardName === fieldName ? `Forward relation name "${forwardName}" on type "${type.name}"${typeLocation} is the same as its own relation field "${fieldName}". Use the "as" option in .relation({ toward: { as: ... } }) to specify a different name.` : `Forward relation name "${forwardName}" from field "${fieldName}" on type "${type.name}"${typeLocation} conflicts with existing field "${forwardName}". Use the "as" option in .relation({ toward: { as: ... } }) to specify a different name.`;
+				throw new Error(message);
+			}
+			if (Object.hasOwn(metadata.files, forwardName)) throw new Error(`Forward relation name "${forwardName}" from field "${fieldName}" on type "${type.name}"${typeLocation} conflicts with files field "${forwardName}". Use the "as" option in .relation({ toward: { as: ... } }) to specify a different name.`);
 			const targetType = rawTypes[relationInfo.targetType];
-			forwardRelationships[relationInfo.forwardName] = {
-				name: relationInfo.forwardName,
+			forwardRelationships[forwardName] = {
+				name: forwardName,
 				targetType: relationInfo.targetType,
 				targetField: fieldName,
 				sourceField: relationInfo.key,
@@ -3615,13 +3643,11 @@ function buildBackwardRelationships(types, namespace, typeSourceInfo) {
 	for (const [targetTypeName, backwardNames] of Object.entries(backwardNameSources)) {
 		const targetType = types[targetTypeName];
 		if (targetType === void 0) throw new Error(`type not found: ${targetTypeName}`);
-		const targetTypeSourceInfo = getTypeSourceInfo(typeSourceInfo, targetTypeName);
-		const targetLocation = targetTypeSourceInfo ? isPluginGeneratedType(targetTypeSourceInfo) ? ` (plugin: ${targetTypeSourceInfo.pluginId})` : ` (${targetTypeSourceInfo.filePath})` : "";
+		const targetLocation = formatTypeSourceLocation(getTypeSourceInfo(typeSourceInfo, targetTypeName));
 		for (const [backwardName, sources] of Object.entries(backwardNames)) {
 			if (sources.length > 1) {
 				const sourceList = sources.map((s) => {
-					const sourceInfo = getTypeSourceInfo(typeSourceInfo, s.sourceType);
-					const location = sourceInfo ? isPluginGeneratedType(sourceInfo) ? ` (plugin: ${sourceInfo.pluginId})` : ` (${sourceInfo.filePath})` : "";
+					const location = formatTypeSourceLocation(getTypeSourceInfo(typeSourceInfo, s.sourceType));
 					return `${s.sourceType}.${s.fieldName}${location}`;
 				}).join(", ");
 				errors.push(`Backward relation name "${backwardName}" on type "${targetTypeName}" is duplicated from: ${sourceList}. Use the "backward" option in .relation() to specify unique names.`);
@@ -3629,17 +3655,21 @@ function buildBackwardRelationships(types, namespace, typeSourceInfo) {
 			if (Object.hasOwn(targetType.fields, backwardName)) {
 				const source = sources[0];
 				if (source === void 0) throw new Error(`no source found for backward name: ${backwardName}`);
-				const sourceInfo = getTypeSourceInfo(typeSourceInfo, source.sourceType);
-				const sourceLocation = sourceInfo ? isPluginGeneratedType(sourceInfo) ? ` (plugin: ${sourceInfo.pluginId})` : ` (${sourceInfo.filePath})` : "";
+				const sourceLocation = formatTypeSourceLocation(getTypeSourceInfo(typeSourceInfo, source.sourceType));
 				errors.push(`Backward relation name "${backwardName}" from ${source.sourceType}.${source.fieldName}${sourceLocation} conflicts with existing field "${backwardName}" on type "${targetTypeName}"${targetLocation}. Use the "backward" option in .relation() to specify a different name.`);
 			}
 			if (targetType.files && Object.hasOwn(targetType.files, backwardName)) {
 				const source = sources[0];
 				if (source === void 0) throw new Error(`no source found for backward name: ${backwardName}`);
-				const sourceInfo = getTypeSourceInfo(typeSourceInfo, source.sourceType);
-				const sourceLocation = sourceInfo ? isPluginGeneratedType(sourceInfo) ? ` (plugin: ${sourceInfo.pluginId})` : ` (${sourceInfo.filePath})` : "";
+				const sourceLocation = formatTypeSourceLocation(getTypeSourceInfo(typeSourceInfo, source.sourceType));
 				errors.push(`Backward relation name "${backwardName}" from ${source.sourceType}.${source.fieldName}${sourceLocation} conflicts with files field "${backwardName}" on type "${targetTypeName}"${targetLocation}. Use the "backward" option in .relation() to specify a different name.`);
 			}
+			if (Object.hasOwn(targetType.forwardRelationships, backwardName)) {
+				const source = sources[0];
+				if (source === void 0) throw new Error(`no source found for backward name: ${backwardName}`);
+				const sourceLocation = formatTypeSourceLocation(getTypeSourceInfo(typeSourceInfo, source.sourceType));
+				errors.push(`Relation name "${backwardName}" on type "${targetTypeName}"${targetLocation} is used by both a forward relationship and a backward relationship from ${source.sourceType}.${source.fieldName}${sourceLocation}. Use the "as" option in .relation({ toward: { as: ... } }) or the "backward" option in .relation() to specify unique names.`);
+			}
 		}
 	}
 	if (errors.length > 0) throw new Error(`Backward relation name conflicts detected in TailorDB service "${namespace}".\n${errors.map((e) => `  - ${e}`).join("\n")}`);
@@ -3658,8 +3688,7 @@ function validatePluralFormUniqueness(types, namespace, typeSourceInfo) {
 	for (const [, parsedType] of Object.entries(types)) {
 		const singularQuery = inflection.camelize(parsedType.name, true);
 		if (singularQuery === inflection.camelize(parsedType.pluralForm, true)) {
-			const sourceInfo = getTypeSourceInfo(typeSourceInfo, parsedType.name);
-			const location = sourceInfo ? isPluginGeneratedType(sourceInfo) ? ` (plugin: ${sourceInfo.pluginId})` : ` (${sourceInfo.filePath})` : "";
+			const location = formatTypeSourceLocation(getTypeSourceInfo(typeSourceInfo, parsedType.name));
 			errors.push(`Type "${parsedType.name}"${location} has identical singular and plural query names "${singularQuery}". Use db.type(["${parsedType.name}", "UniquePluralForm"], {...}) to set a unique pluralForm.`);
 		}
 	}
@@ -3685,8 +3714,7 @@ function validatePluralFormUniqueness(types, namespace, typeSourceInfo) {
 	const duplicates = [...queryNameToSource].filter(([, sources]) => sources.length > 1);
 	for (const [queryName, sources] of duplicates) {
 		const sourceList = sources.map((s) => {
-			const sourceInfo = getTypeSourceInfo(typeSourceInfo, s.typeName);
-			const location = sourceInfo ? isPluginGeneratedType(sourceInfo) ? ` (plugin: ${sourceInfo.pluginId})` : ` (${sourceInfo.filePath})` : "";
+			const location = formatTypeSourceLocation(getTypeSourceInfo(typeSourceInfo, s.typeName));
 			return `"${s.typeName}"${location} (${s.kind})`;
 		}).join(", ");
 		errors.push(`GraphQL query field "${queryName}" conflicts between: ${sourceList}`);
@@ -3696,6 +3724,10 @@ function validatePluralFormUniqueness(types, namespace, typeSourceInfo) {
 function getTypeSourceInfo(typeSourceInfo, typeName) {
 	return typeSourceInfo && Object.hasOwn(typeSourceInfo, typeName) ? typeSourceInfo[typeName] : void 0;
 }
+function formatTypeSourceLocation(sourceInfo) {
+	if (!sourceInfo) return "";
+	return isPluginGeneratedType(sourceInfo) ? ` (plugin: ${sourceInfo.pluginId})` : ` (${sourceInfo.filePath})`;
+}
 function createRecord() {
 	return Object.create(null);
 }
@@ -4211,12 +4243,13 @@ function buildMinimalEntryFromResolved(imports, declarations, fnSource, sourceFi
 }
 async function bundleScriptTarget(args) {
 	const { fn, kind, sourceFilePath, sourceBindings, tempDir, targetIndex, tsconfig } = args;
+	const context = `${kind} in ${sourceFilePath}`;
 	const fnSource = stringifyFunction(fn);
-	const inlineExpr = `(${fnSource})({ value: _value, data: _data, user: ${tailorUserMap} })`;
+	const inlineExpr = assertParsableExpression(`(${fnSource})({ value: _value, data: _data, user: ${tailorUserMap} })`, context);
 	const freeVars = findUndefinedReferences(`const __fn = ${fnSource};`);
 	if (freeVars.size === 0) return inlineExpr;
 	const { imports, declarations, unresolved } = resolveNeededBindings(freeVars, sourceBindings);
-	if (unresolved.length > 0) throw new Error(`${kind} in ${sourceFilePath} captures unresolvable variables (${unresolved.join(", ")}). Hooks and validators must not reference variables that cannot be resolved from the source file.
+	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 entryPath = join(tempDir, `tailordb-script-${targetIndex}.entry.ts`);
@@ -4239,7 +4272,7 @@ async function bundleScriptTarget(args) {
 		},
 		logLevel: "silent"
 	})).output[0].code;
-	return buildPrecompiledExpr(bundledCode);
+	return assertParsableExpression(buildPrecompiledExpr(bundledCode), context);
 }
 /**
 * Precompile TailorDB hooks/validators into self-contained script expressions using rolldown.
@@ -4372,8 +4405,23 @@ function assertUniqueLocalTailorDBTypeNames(args) {
 */
 async function assertUniqueTailorDBTypeNamesWithExternal(args) {
 	const localSources = collectLocalTailorDBTypeNameSources(args);
-	const externalSources = args.externalTailorDBNamespaces.length > 0 ? await fetchExternalTailorDBTypeNameSources(args) : [];
-	assertUniqueTailorDBTypeNames({ sources: [...localSources, ...externalSources] });
+	const plannedExternalServices = args.plannedExternalTailorDBServices ?? [];
+	const plannedExternalNamespaces = new Set(plannedExternalServices.map((service) => service.namespace));
+	const plannedExternalSources = collectLocalTailorDBTypeNameSources({ tailorDBServices: plannedExternalServices }).map((source) => ({
+		...source,
+		kind: "external"
+	}));
+	const remoteExternalNamespaces = args.externalTailorDBNamespaces.filter((namespace) => !plannedExternalNamespaces.has(namespace));
+	const externalSources = remoteExternalNamespaces.length > 0 ? await fetchExternalTailorDBTypeNameSources({
+		client: args.client,
+		workspaceId: args.workspaceId,
+		externalTailorDBNamespaces: remoteExternalNamespaces
+	}) : [];
+	assertUniqueTailorDBTypeNames({ sources: [
+		...localSources,
+		...plannedExternalSources,
+		...externalSources
+	] });
 }
 function formatTailorDBTypeNameSource(source) {
 	const namespaceLabel = source.kind === "external" ? `external namespace "${source.namespace}"` : `namespace "${source.namespace}"`;
@@ -5226,12 +5274,12 @@ async function bundleResolvers(namespace, config, triggerContext, cache, inlineS
 	} catch {
 		tsconfig = void 0;
 	}
-	const results = await withBundleConcurrency(resolvers, (resolver) => bundleSingleResolver(resolver, outputDir, tsconfig, triggerContext, cache, inlineSourcemap, bundleLogLevel));
+	const results = await withBundleConcurrency(resolvers, (resolver) => bundleSingleResolver(namespace, resolver, outputDir, tsconfig, triggerContext, cache, inlineSourcemap, bundleLogLevel));
 	for (const [name, code] of results) bundledCode.set(name, code);
 	logger.log(`${styles.success("Bundled")} ${styles.info(`"${namespace}"`)}`);
 	return bundledCode;
 }
-async function bundleSingleResolver(resolver, outputDir, tsconfig, triggerContext, cache, inlineSourcemap, bundleLogLevel = "DEBUG") {
+async function bundleSingleResolver(namespace, resolver, outputDir, tsconfig, triggerContext, cache, inlineSourcemap, bundleLogLevel = "DEBUG") {
 	const serializedTriggerContext = serializeTriggerContext(triggerContext);
 	const contextHash = computeBundlerContextHash({
 		sourceFile: resolver.sourceFile,
@@ -5243,6 +5291,7 @@ async function bundleSingleResolver(resolver, outputDir, tsconfig, triggerContex
 	const code = await withCache({
 		cache,
 		kind: "resolver",
+		namespace,
 		name: resolver.name,
 		sourceFile: resolver.sourceFile,
 		contextHash,
@@ -5337,9 +5386,26 @@ function createResolverService(namespace, config) {
 			const resolverFiles = loadFilesWithIgnores(config);
 			logger.log(`Found ${styles.highlight(resolverFiles.length.toString())} resolver files for service ${styles.highlight(`"${namespace}"`)}`);
 			await Promise.all(resolverFiles.map((resolverFile) => loadResolverForFile(resolverFile)));
+			assertUniqueResolverNames(resolvers, namespace);
 		}
 	};
 }
+/**
+* Assert that every loaded resolver in a namespace has a unique name.
+* Resolvers are stored by source file, so two files declaring the same
+* `name` would otherwise silently share a single bundle cache entry.
+* @param resolvers - Loaded resolvers keyed by source file
+* @param namespace - The namespace the resolvers belong to
+*/
+function assertUniqueResolverNames(resolvers, namespace) {
+	const seenNames = /* @__PURE__ */ new Map();
+	for (const [file, resolver] of Object.entries(resolvers)) {
+		const relativePath = path.relative(process.cwd(), file);
+		const existing = seenNames.get(resolver.name);
+		if (existing) throw new Error(`Duplicate resolver name "${resolver.name}" found in namespace "${namespace}":\n  - ${existing}\n  - ${relativePath}\nEach resolver must have a unique name within a namespace.`);
+		seenNames.set(resolver.name, relativePath);
+	}
+}
 
 //#endregion
 //#region src/cli/services/workflow/source-transformer.ts
@@ -5444,11 +5510,17 @@ function transformWorkflowSource(source, targetJobName, targetJobExportName, oth
 				end: endPos,
 				text: ""
 			});
-		} else if (!job.statementRange) replacements.push({
-			start: job.bodyValueRange.start,
-			end: job.bodyValueRange.end,
-			text: "() => {}"
-		});
+		} else if (!job.statementRange) {
+			removedRanges.push({
+				start: job.bodyValueRange.start,
+				end: job.bodyValueRange.end
+			});
+			replacements.push({
+				start: job.bodyValueRange.start,
+				end: job.bodyValueRange.end,
+				text: "() => {}"
+			});
+		}
 	}
 	if (otherJobExportNames) for (const exportName of otherJobExportNames) {
 		if (exportName === targetJobExportName) continue;
@@ -5900,6 +5972,12 @@ function resolveInlineSourcemap(configValue) {
 	return true;
 }
 
+//#endregion
+//#region src/cli/shared/resolver-bundle-key.ts
+function resolverBundleKey(namespace, resolverName) {
+	return `${namespace}:${resolverName}`;
+}
+
 //#endregion
 //#region src/parser/service/aigateway/schema.ts
 const NAME_PATTERN = /^[a-z0-9][a-z0-9-]{1,28}[a-z0-9]$/;
@@ -6387,7 +6465,7 @@ async function loadApplication(params) {
 	};
 	for (const pipeline of resolverResult.resolverServices) {
 		const resolverBundles = await bundleResolvers(pipeline.namespace, pipeline.config, triggerContext, bundleCache, inlineSourcemap, bundleLogLevel);
-		for (const [name, code] of resolverBundles) bundledScripts.resolvers.set(name, code);
+		for (const [name, code] of resolverBundles) bundledScripts.resolvers.set(resolverBundleKey(pipeline.namespace, name), code);
 	}
 	if (executorService) bundledScripts.executors = await bundleExecutors({
 		config: executorService.config,
@@ -6454,5 +6532,5 @@ async function loadApplication(params) {
 }
 
 //#endregion
-export { initOperatorClient as $, loadAccessToken as A, saveUserTokens as B, hashContent as C, fetchLatestToken as D, deleteUserTokens as E, loadStoredUserTokens as F, fetchMachineUserToken as G, closeConnectionPool as H, loadWorkspaceId as I, fetchUserInfo as J, fetchPaged as K, platformConfigFromProfile as L, loadConsoleBaseUrl as M, loadMachineUserName as N, hasAnyUserTokenEntry as O, loadPlatformClientConfig as P, initOAuth2Client as Q, readPlatformConfig as R, getDistDir as S, loadConfig as T, defaultPlatformBaseUrl as U, writePlatformConfig as V, fetchAll as W, getOAuth2ClientId as X, getConsoleBaseUrl as Y, getPlatformBaseUrl as Z, createLogLevelTreeshakeOptions as _, WorkflowJobSchema as a, hasGenerationHooks as b, INVOKER_EXPR as c, assertUniqueLocalTailorDBTypeNames as d, isDefaultPlatform as et, assertUniqueTailorDBTypeNamesWithExternal as f, composeFunctionTreeshakeOptions as g, platformBundleDefinePlugin as h, resolveInlineSourcemap as i, loadConfigPath as j, hasUserTokenEntry as k, buildExecutorArgsExpr as l, stringifyFunction as m, generatePluginFilesIfNeeded as n, byName as nt, ResolverSchema as o, TailorDBTypeSchema as p, fetchPlatformMachineUserToken as q, loadApplication as r, HTTP_METHODS as s, defineApplication as t, resolveStaticWebsiteUrls as tt, buildResolverOperationHookExpr as u, resolveBundleLogLevel as v, hashFile as w, createBundleCache as x, getPluginGenerationDependencies as y, resolveUserTokenKey as z };
-//# sourceMappingURL=application-Bb9NNp5m.mjs.map
+export { initOAuth2Client as $, hasUserTokenEntry as A, resolveUserTokenKey as B, getDistDir as C, deleteUserTokens as D, loadConfig as E, loadPlatformClientConfig as F, fetchAll as G, writePlatformConfig as H, loadStoredUserTokens as I, fetchPlatformMachineUserToken as J, fetchMachineUserToken as K, loadWorkspaceId as L, loadConfigPath as M, loadConsoleBaseUrl as N, fetchLatestToken as O, loadMachineUserName as P, getPlatformBaseUrl as Q, platformConfigFromProfile as R, createBundleCache as S, hashFile as T, closeConnectionPool as U, saveUserTokens as V, defaultPlatformBaseUrl as W, getConsoleBaseUrl as X, fetchUserInfo as Y, getOAuth2ClientId as Z, composeFunctionTreeshakeOptions as _, resolveInlineSourcemap as a, getPluginGenerationDependencies as b, HTTP_METHODS as c, buildResolverOperationHookExpr as d, initOperatorClient as et, assertUniqueLocalTailorDBTypeNames as f, platformBundleDefinePlugin as g, stringifyFunction as h, resolverBundleKey as i, loadAccessToken as j, hasAnyUserTokenEntry as k, INVOKER_EXPR as l, TailorDBTypeSchema as m, generatePluginFilesIfNeeded as n, resolveStaticWebsiteUrls as nt, WorkflowJobSchema as o, assertUniqueTailorDBTypeNamesWithExternal as p, fetchPaged as q, loadApplication as r, byName as rt, ResolverSchema as s, defineApplication as t, isDefaultPlatform as tt, buildExecutorArgsExpr as u, createLogLevelTreeshakeOptions as v, hashContent as w, hasGenerationHooks as x, resolveBundleLogLevel as y, readPlatformConfig as z };
+//# sourceMappingURL=application-DwmoI6ZQ.mjs.map