@keystrokehq/cli 0.0.1

package/dist/build-metadata-BWS7uhd_-DR8gJjTX.mjs

@@ -0,0 +1,1422 @@
+#!/usr/bin/env node
+
+import { i as __toESM } from "./chunk-CH6r78ws.mjs";
+import { n as FileMetadataSchema, t as FILE_METADATA_SCHEMA_VERSION } from "./file-metadata-D1vm-XY2.mjs";
+import { d as getMetadataRoot, l as createMetadataOutputFile, n as BUILD_OUTPUT_DIR_NAME, u as getFileMetadataPath } from "./layout-CbMtQ2tm.mjs";
+import { l as require_out, s as sha256String, t as BASE_IGNORE_PATTERNS } from "./metadata-layout-GUYIUo0i-_aG2zjue.mjs";
+import { a as literalString, c as readStringProperty, i as literalNumber, l as unwrapExpression, n as identifierName, o as parseSourceFile, r as isNode, s as readPropertyValue, t as getFirstObjectArgument, u as visitNode } from "./oxc-B3KI3rf_-n9d1hKNq.mjs";
+import { a as getLocalModuleSpecifier, f as resolveLocalModulePath, l as removeEmptyMetadataDirectories, o as getVariableDeclarators, s as isExportedVariableStatement } from "./source-analysis-Cj-ADyu--BJQcFPCG.mjs";
+import { n as parseRelativeFilePath, r as toRelativeFilePath, t as normalizeRelativeFilePath } from "./normalize-path-CojS-CgQ-DLCOvnD1.mjs";
+import { t as RESERVED_NAMESPACES } from "./constants-CPpPdSNg.mjs";
+import { mkdir, readFile, rm, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { performance } from "node:perf_hooks";
+//#region ../../packages/workflow-builder/dist/build-metadata-BWS7uhd_.mjs
+var import_out = /* @__PURE__ */ __toESM(require_out(), 1);
+const IGNORED_IDENTIFIERS = new Set([
+	"undefined",
+	"null",
+	"NaN",
+	"Infinity",
+	"globalThis",
+	"arguments",
+	"console",
+	"Promise",
+	"Math",
+	"JSON",
+	"Date",
+	"Error",
+	"Array",
+	"Object",
+	"String",
+	"Number",
+	"Boolean",
+	"Map",
+	"Set",
+	"WeakMap",
+	"WeakSet",
+	"Symbol",
+	"RegExp",
+	"parseInt",
+	"parseFloat",
+	"isNaN",
+	"isFinite",
+	"setTimeout",
+	"setInterval",
+	"clearTimeout",
+	"clearInterval",
+	"fetch",
+	"Buffer",
+	"process",
+	"URL",
+	"URLSearchParams",
+	"AbortController",
+	"AbortSignal",
+	"TextEncoder",
+	"TextDecoder",
+	"crypto",
+	"performance",
+	"queueMicrotask",
+	"structuredClone",
+	"atob",
+	"btoa"
+]);
+const IGNORED_IMPORT_SPECIFIERS = new Set(["zod", "zod/v4"]);
+const IGNORED_IMPORT_PREFIXES = ["@keystroke/workflow-core"];
+function analyzeCapturedVariables(sourceFile, definitionAnalysis, relativeFilePath, imports) {
+	const result = /* @__PURE__ */ new Map();
+	const fileScopeConsts = collectFileScopeConsts(sourceFile);
+	const importBindings = buildImportBindingsFromEntries(imports);
+	const definitionNames = new Set(definitionAnalysis.localDefinitions.keys());
+	const ignoredImportNames = /* @__PURE__ */ new Set();
+	for (const binding of importBindings.values()) if (isIgnoredImport(binding.moduleSpecifier)) ignoredImportNames.add(binding.localName);
+	for (const statement of sourceFile.statements) for (const declaration of getVariableDeclarators(statement)) {
+		const varName = identifierName(declaration.id);
+		if (!varName || !isNode(declaration.init)) continue;
+		const localDef = definitionAnalysis.localDefinitions.get(varName);
+		if (!localDef || localDef.kind !== "workflow" && localDef.kind !== "operation" && localDef.kind !== "agent") continue;
+		const configObject = getFirstObjectArgument(declaration.init);
+		if (!configObject) continue;
+		const runFn = findRunProperty(configObject);
+		if (!runFn) continue;
+		const functionScopeNames = collectFunctionScopeNames(runFn);
+		const referencedIdentifiers = collectReferencedIdentifiers(runFn);
+		const captured = /* @__PURE__ */ new Map();
+		for (const identifier of referencedIdentifiers) {
+			if (IGNORED_IDENTIFIERS.has(identifier) || functionScopeNames.has(identifier) || definitionNames.has(identifier) || ignoredImportNames.has(identifier) || captured.has(identifier)) continue;
+			const fileScopeConst = fileScopeConsts.get(identifier);
+			if (fileScopeConst) {
+				captured.set(identifier, buildLocalConstVariable(fileScopeConst, sourceFile, relativeFilePath));
+				continue;
+			}
+			const importBinding = importBindings.get(identifier);
+			if (importBinding) captured.set(identifier, buildImportVariable(importBinding, relativeFilePath));
+		}
+		if (captured.size > 0) result.set(varName, Array.from(captured.values()));
+	}
+	return result;
+}
+function collectFileScopeConsts(sourceFile) {
+	const consts = /* @__PURE__ */ new Map();
+	for (const statement of sourceFile.statements) {
+		const declaration = statement.type === "VariableDeclaration" ? statement : statement.type === "ExportNamedDeclaration" && isNode(statement.declaration) ? statement.declaration : null;
+		if (!declaration || declaration.type !== "VariableDeclaration" || declaration.kind !== "const") continue;
+		for (const variable of getVariableDeclarators(statement)) {
+			const name = identifierName(variable.id);
+			if (!name || !isNode(variable.init)) continue;
+			const { line } = sourceFile.getLineAndCharacterOfPosition(isNode(variable.id) ? variable.id.start : variable.start);
+			consts.set(name, {
+				name,
+				initializer: variable.init,
+				line: line + 1
+			});
+		}
+	}
+	return consts;
+}
+function buildImportBindingsFromEntries(imports) {
+	const bindings = /* @__PURE__ */ new Map();
+	for (const entry of imports) {
+		if (entry.isNamespaceImport && entry.namespaceName) {
+			bindings.set(entry.namespaceName, {
+				localName: entry.namespaceName,
+				importedName: "*",
+				moduleSpecifier: entry.moduleSpecifier
+			});
+			continue;
+		}
+		for (const name of entry.importNames) bindings.set(name, {
+			localName: name,
+			importedName: name,
+			moduleSpecifier: entry.moduleSpecifier
+		});
+	}
+	return bindings;
+}
+function findRunProperty(objectLiteral) {
+	const runValue = readPropertyValue(objectLiteral, "run");
+	if (runValue?.type === "ArrowFunctionExpression" || runValue?.type === "FunctionExpression" || runValue?.type === "FunctionDeclaration") return runValue;
+	return null;
+}
+function collectFunctionScopeNames(fn) {
+	const names = /* @__PURE__ */ new Set();
+	for (const param of Array.isArray(fn.params) ? fn.params : []) collectBindingNames(param, names);
+	if (isNode(fn.body) && fn.body.type === "BlockStatement") collectLocalDeclarations(fn.body, names);
+	return names;
+}
+function collectBindingNames(name, names) {
+	if (!isNode(name)) return;
+	const identifier = identifierName(name);
+	if (identifier) {
+		names.add(identifier);
+		return;
+	}
+	if (name.type === "ObjectPattern") {
+		for (const property of Array.isArray(name.properties) ? name.properties : []) if (isNode(property) && property.type === "Property") collectBindingNames(property.value, names);
+		else if (isNode(property) && property.type === "RestElement") collectBindingNames(property.argument, names);
+		return;
+	}
+	if (name.type === "ArrayPattern") {
+		for (const element of Array.isArray(name.elements) ? name.elements : []) collectBindingNames(element, names);
+		return;
+	}
+	if (name.type === "AssignmentPattern") {
+		collectBindingNames(name.left, names);
+		return;
+	}
+	if (name.type === "RestElement") collectBindingNames(name.argument, names);
+}
+function collectLocalDeclarations(block, names) {
+	visitNode(block, (node) => {
+		if (node.type === "VariableDeclarator") collectBindingNames(node.id, names);
+		if ((node.type === "FunctionDeclaration" || node.type === "ClassDeclaration") && isNode(node.id)) {
+			const name = identifierName(node.id);
+			if (name) names.add(name);
+			return false;
+		}
+		if (node !== block && (node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression")) return false;
+		if (node.type === "CatchClause") collectBindingNames(node.param, names);
+	});
+}
+function collectReferencedIdentifiers(fn) {
+	const identifiers = /* @__PURE__ */ new Set();
+	const body = fn.body;
+	if (!isNode(body)) return identifiers;
+	visitNode(body, (node, parent) => {
+		const identifier = identifierName(node);
+		if (!identifier) return;
+		if (parent?.type === "MemberExpression" && parent.computed === false && parent.property === node) return;
+		if (parent?.type === "Property" && parent.key === node && parent.value !== node) return;
+		identifiers.add(identifier);
+	});
+	return identifiers;
+}
+function buildLocalConstVariable(fileScopeConst, sourceFile, relativeFilePath) {
+	const { valueType, value, sourceText } = classifyInitializer(fileScopeConst.initializer, sourceFile);
+	const resolvable = value !== void 0;
+	return {
+		name: fileScopeConst.name,
+		...value !== void 0 ? { value } : {},
+		...sourceText !== void 0 ? { sourceText } : {},
+		valueType,
+		resolvable,
+		source: "local-const",
+		declaration: {
+			filePath: relativeFilePath,
+			line: fileScopeConst.line
+		}
+	};
+}
+function buildImportVariable(binding, relativeFilePath) {
+	const source = binding.moduleSpecifier.startsWith(".") || binding.moduleSpecifier.startsWith("/") ? "relative-import" : "package-import";
+	return {
+		name: binding.localName,
+		valueType: "unknown",
+		resolvable: false,
+		source,
+		importPath: binding.moduleSpecifier,
+		declaration: {
+			filePath: relativeFilePath,
+			line: 1
+		}
+	};
+}
+function classifyInitializer(node, sourceFile) {
+	const unwrapped = unwrapExpression(node);
+	const stringValue = literalString(unwrapped);
+	if (stringValue !== void 0) return {
+		valueType: "string",
+		value: stringValue
+	};
+	const numberValue = literalNumber(unwrapped);
+	if (numberValue !== void 0) return {
+		valueType: "number",
+		value: numberValue
+	};
+	if (unwrapped.type === "Literal" && typeof unwrapped.value === "boolean") return {
+		valueType: "boolean",
+		value: unwrapped.value
+	};
+	if (unwrapped.type === "UnaryExpression" && unwrapped.operator === "-" && isNode(unwrapped.argument)) {
+		const operand = literalNumber(unwrapped.argument);
+		if (operand !== void 0) return {
+			valueType: "number",
+			value: -operand
+		};
+	}
+	if (unwrapped.type === "ObjectExpression") return {
+		valueType: "object",
+		sourceText: truncateSourceText(sourceFile.getText(unwrapped))
+	};
+	if (unwrapped.type === "ArrayExpression") return {
+		valueType: "array",
+		sourceText: truncateSourceText(sourceFile.getText(unwrapped))
+	};
+	if (unwrapped.type === "ArrowFunctionExpression" || unwrapped.type === "FunctionExpression") return {
+		valueType: "function",
+		sourceText: truncateSourceText(sourceFile.getText(unwrapped))
+	};
+	return {
+		valueType: "unknown",
+		sourceText: truncateSourceText(sourceFile.getText(unwrapped))
+	};
+}
+function truncateSourceText(text, maxLength = 200) {
+	const trimmed = text.replace(/\s+/g, " ").trim();
+	if (trimmed.length <= maxLength) return trimmed;
+	return `${trimmed.slice(0, maxLength - 3)}...`;
+}
+function isIgnoredImport(moduleSpecifier) {
+	if (IGNORED_IMPORT_SPECIFIERS.has(moduleSpecifier)) return true;
+	return IGNORED_IMPORT_PREFIXES.some((prefix) => moduleSpecifier.startsWith(prefix));
+}
+const CORE_IMPORT_PREFIX$1 = "@keystroke/workflow-core";
+function analyzeCredentials(sourceFile) {
+	const localCredentialSetIds = collectLocalCredentialSetIds(sourceFile, collectImportedCoreSymbols$1(sourceFile));
+	const credentials = /* @__PURE__ */ new Map();
+	for (const statement of sourceFile.statements) for (const declaration of getVariableDeclarators(statement)) {
+		if (!isNode(declaration.init)) continue;
+		collectCredentialRefsFromExpression(declaration.init, localCredentialSetIds, credentials);
+	}
+	return Array.from(credentials.values()).sort((left, right) => left.resolvedId.localeCompare(right.resolvedId));
+}
+function collectImportedCoreSymbols$1(sourceFile) {
+	const importedSymbols = new Map([["CredentialSet", "CredentialSet"]]);
+	for (const statement of sourceFile.statements) {
+		if (statement.type !== "ImportDeclaration") continue;
+		if (!literalString(statement.source)?.startsWith(CORE_IMPORT_PREFIX$1) || !Array.isArray(statement.specifiers)) continue;
+		for (const element of statement.specifiers) {
+			if (!isNode(element) || element.type !== "ImportSpecifier") continue;
+			const localName = identifierName(element.local);
+			const importedName = identifierName(element.imported);
+			if (localName && importedName) importedSymbols.set(localName, importedName);
+		}
+	}
+	return importedSymbols;
+}
+function collectLocalCredentialSetIds(sourceFile, importedCoreSymbols) {
+	const credentialSetIds = /* @__PURE__ */ new Map();
+	for (const statement of sourceFile.statements) for (const declaration of getVariableDeclarators(statement)) {
+		const localName = identifierName(declaration.id);
+		if (!localName || !isNode(declaration.init)) continue;
+		const initializer = unwrapExpression(declaration.init);
+		if (initializer.type !== "NewExpression") continue;
+		const calleeName = identifierName(initializer.callee);
+		if (!calleeName || importedCoreSymbols.get(calleeName) !== "CredentialSet") continue;
+		const configObject = getFirstObjectArgument(initializer);
+		const credentialSetId = readStringProperty(configObject, "id");
+		const namespace = readStringProperty(configObject, "namespace");
+		if (namespace && RESERVED_NAMESPACES.includes(namespace)) throw new Error(`CredentialSet "${credentialSetId ?? localName}": namespace "${namespace}" is reserved for official Keystroke integrations. Use a different namespace or remove it.`);
+		if (credentialSetId) {
+			const resolvedId = namespace ? `${namespace}:${credentialSetId}` : credentialSetId;
+			credentialSetIds.set(localName, resolvedId);
+		}
+	}
+	return credentialSetIds;
+}
+function collectCredentialRefsFromExpression(expression, localCredentialSetIds, credentials) {
+	const unwrapped = unwrapExpression(expression);
+	if (unwrapped.type === "NewExpression") {
+		addCredentialRefsFromConfigObject(getFirstObjectArgument(unwrapped), localCredentialSetIds, credentials);
+		return;
+	}
+	if (unwrapped.type === "CallExpression" && isNode(unwrapped.callee)) {
+		if (unwrapped.callee.type !== "MemberExpression") return;
+		for (const argument of Array.isArray(unwrapped.arguments) ? unwrapped.arguments : []) {
+			const objectArgument = isNode(argument) ? unwrapExpression(argument) : null;
+			if (objectArgument?.type === "ObjectExpression") addCredentialRefsFromConfigObject(objectArgument, localCredentialSetIds, credentials);
+		}
+	}
+}
+function addCredentialRefsFromConfigObject(objectLiteral, localCredentialSetIds, credentials) {
+	const credentialArray = unwrapArrayLiteral(readPropertyValue(objectLiteral, "credentialSets"));
+	if (!credentialArray) return;
+	for (const element of credentialArray.elements ?? []) {
+		if (!isNode(element)) continue;
+		const identifier = identifierName(element);
+		if (identifier) {
+			const resolvedId = localCredentialSetIds.get(identifier);
+			if (resolvedId) credentials.set(resolvedId, { resolvedId });
+			continue;
+		}
+		const unwrapped = unwrapExpression(element);
+		if (unwrapped.type === "NewExpression") {
+			const configObject = getFirstObjectArgument(unwrapped);
+			const credentialSetId = readStringProperty(configObject, "id");
+			if (credentialSetId) {
+				const namespace = readStringProperty(configObject, "namespace");
+				const resolvedId = namespace ? `${namespace}:${credentialSetId}` : credentialSetId;
+				credentials.set(resolvedId, { resolvedId });
+			}
+		}
+	}
+}
+function unwrapArrayLiteral(expression) {
+	if (!expression) return null;
+	const unwrapped = unwrapExpression(expression);
+	return unwrapped.type === "ArrayExpression" && Array.isArray(unwrapped.elements) ? unwrapped : null;
+}
+function createSourceLocation(sourceFile, node, relativeFilePath) {
+	const start = sourceFile.getLineAndCharacterOfPosition(node.start);
+	const end = sourceFile.getLineAndCharacterOfPosition(node.end);
+	return {
+		filePath: relativeFilePath,
+		line: start.line + 1,
+		column: start.character + 1,
+		endLine: end.line + 1,
+		endColumn: end.character + 1
+	};
+}
+const CORE_IMPORT_PREFIX = "@keystroke/workflow-core";
+const IMPORTED_CORE_SYMBOLS = new Set([
+	"Workflow",
+	"Step",
+	"Tool",
+	"Operation",
+	"Agent",
+	"CredentialSet",
+	"Sandbox",
+	"McpServer",
+	"CronTrigger",
+	"WebhookTrigger",
+	"PollingTrigger",
+	"cronTrigger",
+	"webhookTrigger",
+	"pollingTrigger"
+]);
+function analyzeDefinitions(sourceFile, relativeFilePath) {
+	const importedCoreSymbols = collectImportedCoreSymbols(sourceFile);
+	const importedTriggerBindings = collectImportedTriggerBindings(sourceFile);
+	const localDefinitions = /* @__PURE__ */ new Map();
+	const definitions = {
+		workflows: [],
+		operations: [],
+		agents: [],
+		triggers: { defined: [] },
+		credentialSets: [],
+		sandboxes: [],
+		mcpServers: []
+	};
+	for (const statement of sourceFile.statements) for (const declaration of getVariableDeclarators(statement)) {
+		const localName = identifierName(declaration.id);
+		if (!localName || !isNode(declaration.init)) continue;
+		const recognizedDefinition = getRecognizedDefinition(declaration.init, importedCoreSymbols, importedTriggerBindings);
+		if (!recognizedDefinition) continue;
+		localDefinitions.set(localName, recognizedDefinition);
+		if (!isExportedVariableStatement(statement)) continue;
+		addExportedDefinition({
+			definitions,
+			exportName: localName,
+			record: recognizedDefinition,
+			relativeFilePath,
+			sourceFile
+		});
+	}
+	for (const statement of sourceFile.statements) {
+		if (statement.type !== "ExportNamedDeclaration" || !Array.isArray(statement.specifiers)) continue;
+		for (const specifier of statement.specifiers) {
+			if (!isNode(specifier) || specifier.type !== "ExportSpecifier") continue;
+			const localName = identifierName(specifier.local);
+			const exportName = identifierName(specifier.exported);
+			if (!localName || !exportName) continue;
+			const localDefinition = localDefinitions.get(localName);
+			if (!localDefinition) continue;
+			addExportedDefinition({
+				definitions,
+				exportName,
+				record: localDefinition,
+				relativeFilePath,
+				sourceFile
+			});
+		}
+	}
+	for (const statement of sourceFile.statements) {
+		if (statement.type !== "ExportDefaultDeclaration" || !isNode(statement.declaration)) continue;
+		const record = getDefaultExportDefinition(statement.declaration, importedCoreSymbols, importedTriggerBindings, localDefinitions);
+		if (!record) continue;
+		addExportedDefinition({
+			definitions,
+			exportName: "default",
+			record,
+			relativeFilePath,
+			sourceFile
+		});
+	}
+	return {
+		definitions,
+		localDefinitions
+	};
+}
+function collectImportedCoreSymbols(sourceFile) {
+	const importedSymbols = new Map([...IMPORTED_CORE_SYMBOLS].map((symbol) => [symbol, symbol]));
+	for (const statement of sourceFile.statements) {
+		if (statement.type !== "ImportDeclaration") continue;
+		if (!literalString(statement.source)?.startsWith(CORE_IMPORT_PREFIX) || !Array.isArray(statement.specifiers)) continue;
+		for (const element of statement.specifiers) {
+			if (!isNode(element) || element.type !== "ImportSpecifier") continue;
+			const importedName = identifierName(element.imported);
+			const localName = identifierName(element.local);
+			if (!importedName || !localName || !IMPORTED_CORE_SYMBOLS.has(importedName)) continue;
+			importedSymbols.set(localName, importedName);
+		}
+	}
+	return importedSymbols;
+}
+function collectImportedTriggerBindings(sourceFile) {
+	const importedBindings = /* @__PURE__ */ new Map();
+	for (const statement of sourceFile.statements) {
+		if (statement.type !== "ImportDeclaration") continue;
+		const moduleSpecifier = literalString(statement.source);
+		if (!moduleSpecifier || !moduleSpecifier.endsWith("/triggers") && moduleSpecifier !== "./triggers" || !Array.isArray(statement.specifiers)) continue;
+		for (const element of statement.specifiers) {
+			if (!isNode(element)) continue;
+			const localName = element.type === "ImportNamespaceSpecifier" || element.type === "ImportSpecifier" ? identifierName(element.local) : void 0;
+			if (localName) importedBindings.set(localName, { moduleSpecifier });
+		}
+	}
+	return importedBindings;
+}
+function getRecognizedDefinition(expression, importedCoreSymbols, importedTriggerBindings) {
+	const unwrappedExpression = unwrapExpression(expression);
+	if (unwrappedExpression.type === "NewExpression") {
+		const callee = isNode(unwrappedExpression.callee) ? unwrappedExpression.callee : null;
+		const importedSymbol = callee ? importedCoreSymbols.get(identifierName(callee) ?? "") : void 0;
+		if (!importedSymbol || !callee) return null;
+		const configObject = getFirstObjectArgument(unwrappedExpression);
+		const displayName = readStringProperty(configObject, "name");
+		if (importedSymbol === "Workflow") return {
+			exportEntryKind: "workflow",
+			kind: "workflow",
+			name: displayName,
+			sourceNode: callee
+		};
+		if (importedSymbol === "Step" || importedSymbol === "Tool" || importedSymbol === "Operation") return {
+			exportEntryKind: "operation",
+			kind: "operation",
+			name: displayName,
+			sourceNode: callee
+		};
+		if (importedSymbol === "Agent") return {
+			exportEntryKind: "agent",
+			kind: "agent",
+			name: displayName,
+			sourceNode: callee
+		};
+		if (importedSymbol === "CredentialSet") {
+			const id = readStringProperty(configObject, "id");
+			const namespace = readStringProperty(configObject, "namespace");
+			return {
+				exportEntryKind: "credential-set",
+				kind: "credential-set",
+				name: displayName,
+				resolvedCredentialSetId: id ? namespace ? `${namespace}:${id}` : id : void 0,
+				sourceNode: callee
+			};
+		}
+		if (importedSymbol === "Sandbox") return {
+			exportEntryKind: "sandbox",
+			kind: "sandbox",
+			name: displayName,
+			sourceNode: callee
+		};
+		if (importedSymbol === "McpServer") return {
+			exportEntryKind: "mcp-server",
+			kind: "mcp-server",
+			name: displayName,
+			sourceNode: callee
+		};
+		if (importedSymbol === "CronTrigger" || importedSymbol === "WebhookTrigger" || importedSymbol === "PollingTrigger") return {
+			exportEntryKind: "trigger",
+			kind: "trigger",
+			name: displayName,
+			triggerType: importedSymbol === "CronTrigger" ? "cron" : importedSymbol === "WebhookTrigger" ? "webhook" : "polling",
+			sourceNode: callee
+		};
+	}
+	if (unwrappedExpression.type === "CallExpression") {
+		const callee = isNode(unwrappedExpression.callee) ? unwrappedExpression.callee : null;
+		const importedSymbol = callee ? importedCoreSymbols.get(identifierName(callee) ?? "") : void 0;
+		if (callee && (importedSymbol === "cronTrigger" || importedSymbol === "webhookTrigger" || importedSymbol === "pollingTrigger")) return {
+			exportEntryKind: "trigger",
+			kind: "trigger",
+			name: readStringProperty(getFirstObjectArgument(unwrappedExpression), "name"),
+			triggerType: importedSymbol === "cronTrigger" ? "cron" : importedSymbol === "webhookTrigger" ? "webhook" : "polling",
+			sourceNode: callee
+		};
+		if (callee) {
+			const importedTriggerCall = getImportedTriggerCall(callee, importedTriggerBindings);
+			if (importedTriggerCall) return {
+				exportEntryKind: "trigger",
+				kind: "trigger",
+				name: readStringProperty(getFirstObjectArgument(unwrappedExpression), "name"),
+				triggerType: inferImportedTriggerType(importedTriggerCall),
+				sourceNode: callee
+			};
+		}
+	}
+	return null;
+}
+function getDefaultExportDefinition(expression, importedCoreSymbols, importedTriggerBindings, localDefinitions) {
+	const localName = identifierName(expression);
+	if (localName) return localDefinitions.get(localName) ?? null;
+	return getRecognizedDefinition(expression, importedCoreSymbols, importedTriggerBindings);
+}
+function getImportedTriggerCall(expression, importedTriggerBindings) {
+	const directBindingName = identifierName(expression);
+	if (directBindingName) {
+		const importedBinding = importedTriggerBindings.get(directBindingName);
+		return importedBinding ? {
+			bindingName: directBindingName,
+			moduleSpecifier: importedBinding.moduleSpecifier
+		} : null;
+	}
+	if (expression.type === "MemberExpression" && expression.computed === false) {
+		const objectName = identifierName(expression.object);
+		const memberName = identifierName(expression.property);
+		const importedBinding = objectName ? importedTriggerBindings.get(objectName) : void 0;
+		if (objectName && importedBinding) return {
+			bindingName: objectName,
+			...memberName ? { memberName } : {},
+			moduleSpecifier: importedBinding.moduleSpecifier
+		};
+	}
+	return null;
+}
+function inferImportedTriggerType(triggerCall) {
+	const bindingName = triggerCall.bindingName.toLowerCase();
+	const memberName = triggerCall.memberName?.toLowerCase();
+	if (bindingName === "polling" || memberName?.includes("poll")) return "polling";
+	return "webhook";
+}
+function addExportedDefinition(options) {
+	const source = createSourceLocation(options.sourceFile, options.record.sourceNode, options.relativeFilePath);
+	if (options.record.kind === "workflow") {
+		options.definitions.workflows.push({
+			name: options.record.name ?? options.exportName,
+			exportName: options.exportName,
+			source
+		});
+		return;
+	}
+	if (options.record.kind === "operation") {
+		options.definitions.operations.push({
+			name: options.record.name ?? options.exportName,
+			exportName: options.exportName,
+			source,
+			...options.record.isBundle ? { isBundle: true } : {}
+		});
+		return;
+	}
+	if (options.record.kind === "agent") {
+		options.definitions.agents.push({
+			agentName: options.record.name ?? options.exportName,
+			exportName: options.exportName,
+			source
+		});
+		return;
+	}
+	if (options.record.kind === "credential-set") {
+		options.definitions.credentialSets.push({
+			credentialSetName: options.record.name ?? options.exportName,
+			...options.record.resolvedCredentialSetId ? { resolvedCredentialSetId: options.record.resolvedCredentialSetId } : {},
+			exportName: options.exportName,
+			source
+		});
+		return;
+	}
+	if (options.record.kind === "sandbox") {
+		options.definitions.sandboxes.push({
+			sandboxName: options.record.name ?? options.exportName,
+			exportName: options.exportName,
+			source
+		});
+		return;
+	}
+	if (options.record.kind === "mcp-server") {
+		options.definitions.mcpServers.push({
+			mcpServerName: options.record.name ?? options.exportName,
+			exportName: options.exportName,
+			source
+		});
+		return;
+	}
+	if (options.record.kind === "trigger") options.definitions.triggers.defined.push({
+		name: options.record.name,
+		triggerType: options.record.triggerType ?? "webhook",
+		exportName: options.exportName,
+		source
+	});
+}
+function analyzeExports(sourceFile, localDefinitions) {
+	const exports = /* @__PURE__ */ new Map();
+	for (const statement of sourceFile.statements) {
+		if (isExportedVariableStatement(statement)) {
+			for (const declaration of getVariableDeclarators(statement)) {
+				const localName = identifierName(declaration.id);
+				if (!localName) continue;
+				const kind = localDefinitions.get(localName)?.exportEntryKind ?? "other";
+				exports.set(localName, kind);
+			}
+			continue;
+		}
+		if (statement.type === "ExportAllDeclaration") {
+			const namespaceExportName = identifierName(statement.exported);
+			if (namespaceExportName) {
+				exports.set(namespaceExportName, "other");
+				continue;
+			}
+		}
+		if (statement.type === "ExportNamedDeclaration" && Array.isArray(statement.specifiers)) {
+			for (const specifier of statement.specifiers) {
+				if (!isNode(specifier) || specifier.type !== "ExportSpecifier") continue;
+				const localName = identifierName(specifier.local);
+				const exportName = identifierName(specifier.exported);
+				if (!localName || !exportName) continue;
+				const kind = localDefinitions.get(localName)?.exportEntryKind ?? "other";
+				exports.set(exportName, kind);
+			}
+			continue;
+		}
+		if (statement.type === "ExportDefaultDeclaration") {
+			const localName = identifierName(statement.declaration);
+			const kind = localName ? localDefinitions.get(localName)?.exportEntryKind : void 0;
+			exports.set("default", kind ?? "other");
+		}
+	}
+	return Array.from(exports.entries()).map(([exportName, kind]) => ({
+		exportName,
+		kind
+	})).sort((left, right) => left.exportName.localeCompare(right.exportName));
+}
+async function analyzeImports(options) {
+	const imports = [];
+	for (const statement of options.sourceFile.statements) {
+		if (statement.type !== "ImportDeclaration") continue;
+		const moduleSpecifier = literalString(statement.source);
+		if (!moduleSpecifier) continue;
+		const entry = {
+			moduleSpecifier,
+			importNames: []
+		};
+		for (const specifier of Array.isArray(statement.specifiers) ? statement.specifiers : []) {
+			if (!isNode(specifier)) continue;
+			if (specifier.type === "ImportDefaultSpecifier") {
+				const localName = identifierName(specifier.local);
+				if (localName) entry.importNames.push(localName);
+				continue;
+			}
+			if (specifier.type === "ImportSpecifier") {
+				const importedName = identifierName(specifier.imported);
+				if (importedName) entry.importNames.push(importedName);
+				continue;
+			}
+			if (specifier.type === "ImportNamespaceSpecifier") {
+				const namespaceName = identifierName(specifier.local);
+				if (namespaceName) {
+					entry.isNamespaceImport = true;
+					entry.namespaceName = namespaceName;
+				}
+			}
+		}
+		const localModuleSpecifier = getLocalModuleSpecifier(moduleSpecifier);
+		if (localModuleSpecifier) {
+			const resolvedPath = await resolveLocalModulePath(options.filePath, localModuleSpecifier);
+			if (resolvedPath) entry.resolvedPath = toRelativeFilePath(options.projectRoot, resolvedPath);
+		}
+		entry.importNames.sort((left, right) => left.localeCompare(right));
+		imports.push(entry);
+	}
+	return imports.sort(compareImportEntries);
+}
+function compareImportEntries(left, right) {
+	return left.moduleSpecifier.localeCompare(right.moduleSpecifier);
+}
+function analyzeWorkflowDelegations(options) {
+	if (options.workflowDefinitions.length === 0) return [...options.workflowDefinitions];
+	const importedBindings = collectImportedBindings(options.sourceFile, options.imports);
+	const localDefinitionInfo = collectLocalDefinitionInfo(options.sourceFile, options.localDefinitions);
+	return options.workflowDefinitions.map((workflowDefinition) => {
+		const runNode = findWorkflowRunFunction(options.sourceFile, workflowDefinition.exportName);
+		if (!runNode) return workflowDefinition;
+		const delegatedAgents = /* @__PURE__ */ new Map();
+		const delegatedWorkflows = /* @__PURE__ */ new Map();
+		visitNode(runNode, (node) => {
+			if (node.type !== "CallExpression" || !isNode(node.callee)) return;
+			const callee = node.callee;
+			if (callee.type !== "MemberExpression" || callee.computed !== false) return;
+			if (identifierName(callee.property) !== "run") return;
+			const bindingName = identifierName(callee.object);
+			if (!bindingName) return;
+			const imported = importedBindings.get(bindingName);
+			const local = localDefinitionInfo.get(bindingName);
+			if (imported?.resolvedPath?.endsWith(".agent.ts")) delegatedAgents.set(bindingName, {
+				exportName: imported.importedName,
+				agentName: imported.importedName,
+				sourceFilePath: imported.resolvedPath
+			});
+			else if (imported?.resolvedPath?.endsWith(".workflow.ts")) delegatedWorkflows.set(bindingName, {
+				exportName: imported.importedName,
+				workflowName: imported.importedName,
+				sourceFilePath: imported.resolvedPath
+			});
+			else if (local?.agentId || (options.localDefinitions.get(bindingName)?.kind ?? "") === "agent") delegatedAgents.set(bindingName, {
+				exportName: bindingName,
+				authoredAgentId: local?.agentId,
+				agentName: local?.name ?? bindingName,
+				...local?.sourceFilePath ? { sourceFilePath: local.sourceFilePath } : {}
+			});
+			else if (local?.workflowId || (options.localDefinitions.get(bindingName)?.kind ?? "") === "workflow") delegatedWorkflows.set(bindingName, {
+				exportName: bindingName,
+				authoredWorkflowId: local?.workflowId,
+				workflowName: local?.name ?? bindingName,
+				...local?.sourceFilePath ? { sourceFilePath: local.sourceFilePath } : {}
+			});
+		});
+		return {
+			...workflowDefinition,
+			...delegatedAgents.size > 0 ? { delegatedAgents: [...delegatedAgents.values()].sort((a, b) => a.exportName.localeCompare(b.exportName)) } : {},
+			...delegatedWorkflows.size > 0 ? { delegatedWorkflows: [...delegatedWorkflows.values()].sort((a, b) => a.exportName.localeCompare(b.exportName)) } : {}
+		};
+	});
+}
+function collectImportedBindings(sourceFile, imports) {
+	const importsByModule = new Map(imports.map((entry) => [entry.moduleSpecifier, entry]));
+	const bindings = /* @__PURE__ */ new Map();
+	for (const statement of sourceFile.statements) {
+		if (statement.type !== "ImportDeclaration") continue;
+		const moduleSpecifier = literalString(statement.source);
+		const entry = moduleSpecifier ? importsByModule.get(moduleSpecifier) : void 0;
+		if (!entry?.resolvedPath || !Array.isArray(statement.specifiers)) continue;
+		for (const specifier of statement.specifiers) {
+			if (!isNode(specifier)) continue;
+			if (specifier.type === "ImportDefaultSpecifier") {
+				const localName = identifierName(specifier.local);
+				if (localName) bindings.set(localName, {
+					localName,
+					importedName: "default",
+					resolvedPath: entry.resolvedPath
+				});
+				continue;
+			}
+			if (specifier.type === "ImportSpecifier") {
+				const localName = identifierName(specifier.local);
+				const importedName = identifierName(specifier.imported);
+				if (localName && importedName) bindings.set(localName, {
+					localName,
+					importedName,
+					resolvedPath: entry.resolvedPath
+				});
+			}
+		}
+	}
+	return bindings;
+}
+function collectLocalDefinitionInfo(sourceFile, localDefinitions) {
+	const info = /* @__PURE__ */ new Map();
+	for (const statement of sourceFile.statements) for (const declaration of getVariableDeclarators(statement)) {
+		const localName = identifierName(declaration.id);
+		if (!localName || !isNode(declaration.init)) continue;
+		const local = localDefinitions.get(localName);
+		if (!local) continue;
+		const objectLiteral = getConfigObject(declaration.init);
+		info.set(localName, {
+			name: readStringProperty(objectLiteral, "name") ?? local.name ?? localName,
+			workflowId: local.kind === "workflow" ? readStringProperty(objectLiteral, "id") : void 0,
+			agentId: local.kind === "agent" ? readStringProperty(objectLiteral, "id") : void 0
+		});
+	}
+	return info;
+}
+function findWorkflowRunFunction(sourceFile, exportName) {
+	for (const statement of sourceFile.statements) for (const declaration of getVariableDeclarators(statement)) {
+		if (identifierName(declaration.id) !== exportName || !isNode(declaration.init)) continue;
+		const objectLiteral = getConfigObject(declaration.init);
+		if (!objectLiteral) return null;
+		const runValue = objectLiteral.properties.filter((property) => isNode(property)).find((property) => property.type === "Property" && identifierName(property.key) === "run")?.value;
+		return isNode(runValue) && (runValue.type === "ArrowFunctionExpression" || runValue.type === "FunctionExpression") ? runValue : null;
+	}
+	return null;
+}
+function getConfigObject(expression) {
+	return getFirstObjectArgument(expression);
+}
+function computeSourceChecksum(source) {
+	return sha256String(source);
+}
+async function analyzeFile(options) {
+	const source = await readFile(options.filePath, "utf-8");
+	const relativeFilePath = options.relativeFilePath ?? toRelativeFilePath(options.projectRoot, options.filePath);
+	const sourceFile = parseSourceFile(options.filePath, source);
+	const definitionAnalysis = analyzeDefinitions(sourceFile, relativeFilePath);
+	const imports = await analyzeImports({
+		sourceFile,
+		filePath: options.filePath,
+		projectRoot: options.projectRoot
+	});
+	const exports = analyzeExports(sourceFile, definitionAnalysis.localDefinitions);
+	const credentials = analyzeCredentials(sourceFile);
+	const capturedVariablesByDefinition = analyzeCapturedVariables(sourceFile, definitionAnalysis, relativeFilePath, imports);
+	const definitions = {
+		...definitionAnalysis.definitions,
+		workflows: analyzeWorkflowDelegations({
+			sourceFile,
+			imports,
+			workflowDefinitions: definitionAnalysis.definitions.workflows,
+			localDefinitions: definitionAnalysis.localDefinitions
+		})
+	};
+	return {
+		filePath: relativeFilePath,
+		sourceChecksum: computeSourceChecksum(source),
+		definitions,
+		imports,
+		exports,
+		credentials,
+		capturedVariablesByDefinition
+	};
+}
+async function restoreMetadataIndexFromCache(options) {
+	const restoredIndex = Object.create(null);
+	let cacheHits = 0;
+	let cacheMisses = 0;
+	let invalidated = false;
+	for (const filePath of Object.keys(options.index).sort((left, right) => left.localeCompare(right)).map(parseRelativeFilePath)) {
+		const metadata = options.index[filePath];
+		if (!metadata) continue;
+		const metadataHash = computeMetadataHash(metadata);
+		const cachedEntry = options.cacheEntries[filePath];
+		if (cachedEntry && cachedEntry.sourceChecksum === metadata.buildInfo.sourceChecksum && cachedEntry.metadataHash === metadataHash && cachedEntry.outputFile === createMetadataOutputFile(filePath)) {
+			const cachedMetadata = await loadCachedMetadataEntry(options.outputDir, cachedEntry);
+			if (cachedMetadata) {
+				restoredIndex[filePath] = cachedMetadata;
+				cacheHits += 1;
+				continue;
+			}
+			invalidated = true;
+		}
+		restoredIndex[filePath] = metadata;
+		cacheMisses += 1;
+	}
+	return {
+		index: restoredIndex,
+		cacheHits,
+		cacheMisses,
+		invalidated
+	};
+}
+async function loadPreservedMetadataIndex(options) {
+	const preservedIndex = Object.create(null);
+	for (const filePath of Object.keys(options.cacheEntries).sort((left, right) => left.localeCompare(right)).map(parseRelativeFilePath)) {
+		if (options.excludePaths.has(filePath)) continue;
+		const cachedEntry = options.cacheEntries[filePath];
+		if (!cachedEntry) continue;
+		const cachedMetadata = await loadCachedMetadataEntry(options.outputDir, cachedEntry);
+		if (cachedMetadata) preservedIndex[filePath] = cachedMetadata;
+	}
+	return preservedIndex;
+}
+function createMetadataCacheEntries(index) {
+	const entries = Object.keys(index).sort((left, right) => left.localeCompare(right));
+	return Object.fromEntries(entries.map((filePath) => {
+		const parsed = parseRelativeFilePath(filePath);
+		const metadata = index[parsed];
+		if (!metadata) throw new Error(`Expected metadata for ${filePath}`);
+		return [filePath, {
+			filePath,
+			sourceChecksum: metadata.buildInfo.sourceChecksum,
+			metadataHash: computeMetadataHash(metadata),
+			outputFile: createMetadataOutputFile(parsed),
+			updatedAt: metadata.buildInfo.generatedAt,
+			crossReferenceFingerprint: computeCrossReferenceFingerprint(metadata)
+		}];
+	}));
+}
+function computeMetadataHash(metadata) {
+	return sha256String(JSON.stringify(normalizeMetadataForHash(metadata)));
+}
+async function loadCachedMetadataEntry(outputDir, cacheEntry) {
+	try {
+		const parsed = JSON.parse(await readFile(getFileMetadataPath(outputDir, cacheEntry.filePath), "utf-8"));
+		const result = FileMetadataSchema.safeParse(parsed);
+		if (!result.success) return null;
+		if (computeMetadataHash(result.data) !== cacheEntry.metadataHash) return null;
+		return result.data;
+	} catch {
+		return null;
+	}
+}
+function computeCrossReferenceFingerprint(metadata) {
+	const payload = {
+		workflows: metadata.definitions.workflows.map((workflow) => ({
+			exportName: workflow.exportName,
+			workflowId: workflow.workflowId,
+			description: workflow.description
+		})),
+		stepsConsumedBy: metadata.consumption.stepsConsumedBy
+	};
+	return sha256String(JSON.stringify(payload));
+}
+function normalizeMetadataForHash(metadata) {
+	return {
+		...metadata,
+		buildInfo: {
+			...metadata.buildInfo,
+			generatedAt: ""
+		}
+	};
+}
+const METADATA_FILE_GLOBS = [
+	"**/*.ts",
+	"**/*.tsx",
+	"**/*.mts"
+];
+const METADATA_FILE_GLOBS_WITHOUT_MTS = ["**/*.ts", "**/*.tsx"];
+const METADATA_IGNORE = [
+	...BASE_IGNORE_PATTERNS,
+	"**/tmp/**",
+	"**/temp/**"
+];
+async function collectMetadataFiles(options) {
+	const resolvedProjectRoot = path.resolve(options.projectRoot);
+	const resolvedOutDir = options.outDir ? path.resolve(resolvedProjectRoot, options.outDir) : path.join(resolvedProjectRoot, BUILD_OUTPUT_DIR_NAME);
+	const relativeOutDir = path.relative(resolvedProjectRoot, resolvedOutDir).replaceAll("\\", "/");
+	const ignore = [...METADATA_IGNORE];
+	if (relativeOutDir.length > 0 && relativeOutDir !== "." && !relativeOutDir.startsWith("../") && !path.isAbsolute(relativeOutDir)) ignore.push(`${relativeOutDir}/**`);
+	const absolutePaths = await (0, import_out.default)(options.includeMts === false ? METADATA_FILE_GLOBS_WITHOUT_MTS : METADATA_FILE_GLOBS, {
+		cwd: resolvedProjectRoot,
+		absolute: true,
+		onlyFiles: true,
+		ignore
+	});
+	absolutePaths.sort((left, right) => left.localeCompare(right));
+	return absolutePaths.map((absolutePath) => ({
+		absolutePath,
+		relativePath: toRelativeFilePath(resolvedProjectRoot, absolutePath)
+	}));
+}
+function buildStepConsumptionIndex(options) {
+	const index = /* @__PURE__ */ new Map();
+	for (const artifact of options.artifacts) {
+		const consumedInFile = toRelativeFilePath(options.projectRoot, artifact.workflow.resolvedFilePath);
+		appendStepConsumptionEntries({
+			index,
+			flowGraph: artifact.flowGraph,
+			workflowName: artifact.manifest.name,
+			consumedInFile,
+			stepNamesByFile: options.stepNamesByFile
+		});
+	}
+	for (const entries of index.values()) entries.sort((left, right) => {
+		if (left.consumedInFile !== right.consumedInFile) return left.consumedInFile.localeCompare(right.consumedInFile);
+		return left.nodeId.localeCompare(right.nodeId);
+	});
+	return index;
+}
+function appendStepConsumptionEntries(options) {
+	for (const node of options.flowGraph.nodes) {
+		if (node.type !== "step" || node.data.kind !== "call") continue;
+		const stepNodeData = node.data;
+		const resolvedPath = stepNodeData.importSource?.resolvedPath;
+		const stepName = stepNodeData.stepName;
+		if (!resolvedPath || stepNodeData.callKind !== "workflow-step" || !stepName) continue;
+		let normalizedResolvedPath;
+		try {
+			normalizedResolvedPath = normalizeRelativeFilePath(resolvedPath);
+		} catch {
+			continue;
+		}
+		const knownStepNames = options.stepNamesByFile?.get(normalizedResolvedPath);
+		if (knownStepNames && !knownStepNames.has(stepName)) continue;
+		const entries = options.index.get(normalizedResolvedPath) ?? [];
+		entries.push({
+			stepName,
+			consumedInFile: options.consumedInFile,
+			workflowName: options.workflowName,
+			nodeId: node.id
+		});
+		options.index.set(normalizedResolvedPath, entries);
+	}
+}
+/** Example filename suffix for each convention (used in validation messages). */
+const CONVENTION_TO_EXAMPLE_SUFFIX = {
+	workflow: ".workflow.ts",
+	operation: ".operation.ts",
+	agent: ".agent.ts",
+	trigger: ".trigger.ts",
+	"credential-set": ".credential-set.ts",
+	sandbox: ".sandbox.ts",
+	"mcp-server": ".mcp-server.ts"
+};
+const SUFFIX_TO_CONVENTION = [
+	[".workflow.ts", "workflow"],
+	[".workflow.tsx", "workflow"],
+	[".workflow.mts", "workflow"],
+	[".operation.ts", "operation"],
+	[".operation.tsx", "operation"],
+	[".operation.mts", "operation"],
+	[".step.ts", "operation"],
+	[".step.tsx", "operation"],
+	[".step.mts", "operation"],
+	[".trigger.ts", "trigger"],
+	[".trigger.tsx", "trigger"],
+	[".trigger.mts", "trigger"],
+	[".agent.ts", "agent"],
+	[".agent.tsx", "agent"],
+	[".agent.mts", "agent"],
+	[".tool.ts", "operation"],
+	[".tool.tsx", "operation"],
+	[".tool.mts", "operation"],
+	[".credential-set.ts", "credential-set"],
+	[".credential-set.tsx", "credential-set"],
+	[".credential-set.mts", "credential-set"],
+	[".sandbox.ts", "sandbox"],
+	[".sandbox.tsx", "sandbox"],
+	[".sandbox.mts", "sandbox"],
+	[".mcp-server.ts", "mcp-server"],
+	[".mcp-server.tsx", "mcp-server"],
+	[".mcp-server.mts", "mcp-server"]
+];
+function detectFileConvention(filePath) {
+	const lower = filePath.toLowerCase();
+	for (const [suffix, convention] of SUFFIX_TO_CONVENTION) if (lower.endsWith(suffix)) return convention;
+	return null;
+}
+/** Returns a representative typed suffix for docs and validation hints (e.g. `.credential-set.ts`). */
+function conventionToExampleSuffix(convention) {
+	return CONVENTION_TO_EXAMPLE_SUFFIX[convention];
+}
+function synthesizeMetadataIndex(options) {
+	const baseIndex = Object.create(null);
+	const operationNamesByFile = /* @__PURE__ */ new Map();
+	const sortedFiles = [...options.analyzedFiles].sort((left, right) => left.filePath.localeCompare(right.filePath));
+	for (const analyzedFile of sortedFiles) {
+		operationNamesByFile.set(analyzedFile.filePath, new Set(analyzedFile.definitions.operations.map((op) => op.name)));
+		const capturedVars = analyzedFile.capturedVariablesByDefinition;
+		const definitions = enrichDefinitionsWithCapturedVariables(analyzedFile.definitions, capturedVars);
+		const metadata = FileMetadataSchema.parse({
+			schemaVersion: FILE_METADATA_SCHEMA_VERSION,
+			filePath: analyzedFile.filePath,
+			fileConvention: detectFileConvention(analyzedFile.filePath),
+			definitions,
+			consumption: { stepsConsumedBy: [] },
+			credentials: analyzedFile.credentials,
+			imports: analyzedFile.imports,
+			exports: analyzedFile.exports,
+			buildInfo: {
+				generatedAt: options.generatedAt,
+				sourceChecksum: analyzedFile.sourceChecksum
+			}
+		});
+		baseIndex[analyzedFile.filePath] = metadata;
+	}
+	enrichWorkflowDefinitions({
+		index: baseIndex,
+		artifacts: options.artifacts,
+		projectRoot: options.projectRoot
+	});
+	const stepConsumptionIndex = buildStepConsumptionIndex({
+		artifacts: options.artifacts,
+		projectRoot: options.projectRoot,
+		stepNamesByFile: operationNamesByFile
+	});
+	for (const [filePath, entries] of stepConsumptionIndex.entries()) {
+		const existingMetadata = baseIndex[filePath];
+		if (!existingMetadata) continue;
+		baseIndex[filePath] = FileMetadataSchema.parse({
+			...existingMetadata,
+			consumption: { stepsConsumedBy: entries }
+		});
+	}
+	return {
+		index: baseIndex,
+		fileCount: sortedFiles.length
+	};
+}
+function enrichDefinitionsWithCapturedVariables(definitions, capturedVars) {
+	if (capturedVars.size === 0) return definitions;
+	return {
+		...definitions,
+		workflows: definitions.workflows.map((wf) => {
+			const vars = capturedVars.get(wf.exportName);
+			return vars?.length ? {
+				...wf,
+				capturedVariables: vars
+			} : wf;
+		}),
+		operations: definitions.operations.map((op) => {
+			const vars = capturedVars.get(op.exportName);
+			return vars?.length ? {
+				...op,
+				capturedVariables: vars
+			} : op;
+		}),
+		agents: definitions.agents.map((agent) => {
+			const vars = capturedVars.get(agent.exportName);
+			return vars?.length ? {
+				...agent,
+				capturedVariables: vars
+			} : agent;
+		})
+	};
+}
+function enrichWorkflowDefinitions(options) {
+	for (const artifact of options.artifacts) {
+		const relativeFilePath = toRelativeFilePath(options.projectRoot, artifact.workflow.resolvedFilePath);
+		const fileMetadata = options.index[relativeFilePath];
+		if (!fileMetadata) continue;
+		const enrichedWorkflows = fileMetadata.definitions.workflows.map((definition) => {
+			if (definition.exportName !== artifact.workflow.localExportName && definition.exportName !== artifact.workflow.exportName) return definition;
+			return {
+				...definition,
+				workflowId: artifact.manifest.id,
+				description: artifact.manifest.description
+			};
+		});
+		options.index[fileMetadata.filePath] = FileMetadataSchema.parse({
+			...fileMetadata,
+			definitions: {
+				...fileMetadata.definitions,
+				workflows: enrichedWorkflows
+			}
+		});
+	}
+}
+const PRIMITIVE_COUNT_KEYS = [
+	{
+		convention: "workflow",
+		countFn: (d) => d.workflows.length,
+		label: "Workflow"
+	},
+	{
+		convention: "operation",
+		countFn: (d) => d.operations.length,
+		label: "Operation"
+	},
+	{
+		convention: "agent",
+		countFn: (d) => d.agents.length,
+		label: "Agent"
+	},
+	{
+		convention: "trigger",
+		countFn: (d) => d.triggers.defined.length,
+		label: "Trigger"
+	},
+	{
+		convention: "credential-set",
+		countFn: (d) => d.credentialSets.length,
+		label: "CredentialSet"
+	},
+	{
+		convention: "sandbox",
+		countFn: (d) => d.sandboxes.length,
+		label: "Sandbox"
+	},
+	{
+		convention: "mcp-server",
+		countFn: (d) => d.mcpServers.length,
+		label: "McpServer"
+	}
+];
+function totalPrimitiveCount(defs) {
+	return PRIMITIVE_COUNT_KEYS.reduce((sum, entry) => sum + entry.countFn(defs), 0);
+}
+function countForConvention(convention, defs) {
+	const entry = PRIMITIVE_COUNT_KEYS.find((e) => e.convention === convention);
+	return entry ? entry.countFn(defs) : 0;
+}
+function otherPrimitiveCount(convention, defs) {
+	return totalPrimitiveCount(defs) - countForConvention(convention, defs);
+}
+function validateFileConventions(analyzedFiles) {
+	const violations = [];
+	for (const file of analyzedFiles) {
+		const convention = detectFileConvention(file.filePath);
+		const defs = file.definitions;
+		if (convention) {
+			const ownCount = countForConvention(convention, defs);
+			if (ownCount > 1) violations.push({
+				filePath: file.filePath,
+				level: "error",
+				message: `File "${file.filePath}" uses .${convention}.ts suffix but exports ${ownCount} ${convention} primitives. Expected exactly 1.`
+			});
+			if (ownCount === 0) violations.push({
+				filePath: file.filePath,
+				level: "warning",
+				message: `File "${file.filePath}" uses .${convention}.ts suffix but exports no ${convention} primitives.`
+			});
+			if (otherPrimitiveCount(convention, defs) > 0) violations.push({
+				filePath: file.filePath,
+				level: "error",
+				message: `File "${file.filePath}" uses .${convention}.ts suffix but also exports primitives of other types. Each primitive type belongs in its own file.`
+			});
+		} else if (totalPrimitiveCount(defs) > 0) {
+			const activeEntries = PRIMITIVE_COUNT_KEYS.filter((entry) => entry.countFn(defs) > 0);
+			const typeLabels = activeEntries.map((entry) => entry.label);
+			const firstConvention = activeEntries[0]?.convention;
+			const exampleSuffix = firstConvention ? conventionToExampleSuffix(firstConvention) : ".workflow.ts";
+			violations.push({
+				filePath: file.filePath,
+				level: "warning",
+				message: `File "${file.filePath}" exports ${typeLabels.join(", ")} primitive(s) but does not use a typed suffix. Consider renaming to use the appropriate suffix (e.g. *${exampleSuffix}).`
+			});
+		}
+	}
+	return violations;
+}
+async function writeMetadataIndex(index, outputDir) {
+	const outputRoot = getMetadataRoot(outputDir);
+	const filePaths = Object.keys(index).sort((left, right) => left.localeCompare(right)).map(parseRelativeFilePath);
+	const desiredOutputFiles = filePaths.map((filePath) => createMetadataOutputFile(filePath));
+	let writtenCount = 0;
+	if (filePaths.length > 0) await mkdir(outputRoot, { recursive: true });
+	for (const filePath of filePaths) {
+		const metadata = FileMetadataSchema.parse(index[filePath]);
+		const outputPath = getFileMetadataPath(outputDir, filePath);
+		const serializedMetadata = `${JSON.stringify(metadata, null, 2)}\n`;
+		await mkdir(path.dirname(outputPath), { recursive: true });
+		if (await readExistingMetadata(outputPath) === serializedMetadata) continue;
+		await writeFile(outputPath, serializedMetadata, "utf-8");
+		writtenCount += 1;
+	}
+	const cleanedCount = await cleanupStaleMetadataFiles(outputDir, desiredOutputFiles);
+	return {
+		fileCount: filePaths.length,
+		writtenCount,
+		cleanedCount,
+		outputRoot,
+		writtenPaths: desiredOutputFiles
+	};
+}
+async function readExistingMetadata(filePath) {
+	try {
+		return await readFile(filePath, "utf-8");
+	} catch {
+		return null;
+	}
+}
+async function cleanupStaleMetadataFiles(outputDir, desiredOutputFiles) {
+	const metadataRoot = getMetadataRoot(outputDir);
+	const existingMetadataFiles = await (0, import_out.default)("**/*.json", {
+		cwd: metadataRoot,
+		onlyFiles: true,
+		absolute: false,
+		suppressErrors: true
+	}).catch(() => []);
+	const desiredFiles = new Set(desiredOutputFiles.map((filePath) => filePath.replace(/^metadata\//u, "")));
+	let cleanedCount = 0;
+	for (const relativeFilePath of existingMetadataFiles) {
+		if (desiredFiles.has(relativeFilePath.replaceAll("\\", "/"))) continue;
+		await rm(path.join(metadataRoot, relativeFilePath), { force: true });
+		cleanedCount += 1;
+	}
+	await removeEmptyMetadataDirectories(metadataRoot);
+	return cleanedCount;
+}
+const METADATA_ANALYZE_CONCURRENCY = 8;
+async function buildMetadataArtifacts(options) {
+	const rebuildDecision = options.rebuildDecision ?? {
+		action: "full-recompute",
+		reason: "default-build"
+	};
+	const metadataPhaseStartedAt = performance.now();
+	options.emit({
+		phase: "metadata-start",
+		fileCount: 0
+	});
+	const metadataFiles = rebuildDecision.action === "targeted" ? await resolveTargetedMetadataFiles(options.projectRoot, rebuildDecision.affectedPaths) : await collectMetadataFiles({
+		projectRoot: options.projectRoot,
+		outDir: options.outputDir,
+		includeMts: true
+	});
+	options.emit({
+		phase: "metadata-scan",
+		filesProcessed: 0,
+		filesTotal: metadataFiles.length
+	});
+	const analyzedFacts = [];
+	for (let batchStart = 0; batchStart < metadataFiles.length; batchStart += METADATA_ANALYZE_CONCURRENCY) {
+		const batch = metadataFiles.slice(batchStart, batchStart + METADATA_ANALYZE_CONCURRENCY);
+		const batchResults = await Promise.all(batch.map((metadataFile) => analyzeFile({
+			filePath: metadataFile.absolutePath,
+			projectRoot: options.projectRoot,
+			relativeFilePath: metadataFile.relativePath
+		})));
+		analyzedFacts.push(...batchResults);
+		options.emit({
+			phase: "metadata-scan",
+			filesProcessed: Math.min(batchStart + batch.length, metadataFiles.length),
+			filesTotal: metadataFiles.length
+		});
+	}
+	analyzedFacts.sort((left, right) => left.filePath.localeCompare(right.filePath));
+	const conventionViolations = validateFileConventions(analyzedFacts);
+	await new Promise((resolve) => {
+		setImmediate(resolve);
+	});
+	const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+	const synthesisResult = synthesizeMetadataIndex({
+		analyzedFiles: analyzedFacts,
+		artifacts: options.artifacts,
+		generatedAt,
+		projectRoot: options.projectRoot
+	});
+	const restoredFromCache = await restoreMetadataIndexFromCache({
+		index: rebuildDecision.action === "targeted" ? {
+			...await loadPreservedMetadataIndex({
+				outputDir: options.outputDir,
+				cacheEntries: options.cacheEntries,
+				excludePaths: new Set(rebuildDecision.affectedPaths)
+			}),
+			...synthesisResult.index
+		} : synthesisResult.index,
+		outputDir: options.outputDir,
+		cacheEntries: options.cacheEntries
+	});
+	options.emit({
+		phase: "metadata-cache-stats",
+		cacheHits: restoredFromCache.cacheHits,
+		cacheMisses: restoredFromCache.cacheMisses,
+		invalidated: options.cacheInvalidated || restoredFromCache.invalidated
+	});
+	const metadataWriteStartedAt = performance.now();
+	const writeResult = await writeMetadataIndex(restoredFromCache.index, options.outputDir);
+	options.emit({
+		phase: "metadata-complete",
+		fileCount: Object.keys(restoredFromCache.index).length,
+		elapsedMs: performance.now() - metadataPhaseStartedAt
+	});
+	options.emit({
+		phase: "metadata-output-complete",
+		writtenCount: writeResult.writtenCount,
+		cleanedCount: writeResult.cleanedCount,
+		elapsedMs: performance.now() - metadataWriteStartedAt
+	});
+	return {
+		result: {
+			fileCount: writeResult.fileCount,
+			writtenCount: writeResult.writtenCount,
+			cleanedCount: writeResult.cleanedCount,
+			outputRoot: writeResult.outputRoot
+		},
+		cacheEntries: createMetadataCacheEntries(restoredFromCache.index),
+		conventionViolations,
+		analyzedFacts
+	};
+}
+async function resolveTargetedMetadataFiles(projectRoot, affectedPaths) {
+	const files = [];
+	for (const relativePath of affectedPaths) {
+		const absolutePath = path.resolve(projectRoot, relativePath);
+		try {
+			if (!(await stat(absolutePath)).isFile()) continue;
+			files.push({
+				absolutePath,
+				relativePath: parseRelativeFilePath(relativePath)
+			});
+		} catch {}
+	}
+	return files.sort((left, right) => left.relativePath.localeCompare(right.relativePath));
+}
+//#endregion
+export { buildMetadataArtifacts };