@assistant-ui/metro 0.0.4 → 0.0.6

package/dist/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../src/index.ts"],"mappings":";;AASA;;;;KAAY,eAAA;EACV,WAAA;IAEM,oBAAA;IAAA,CACC,GAAA;EAAA;EAAA,CAGN,GAAA;AAAA;;;;AAQkC;AAwBrC;cAxBa,wBAAA;;;;;;;;;;;;;AAwBmD;;;;;;;;;;iBAAhD,OAAA,WAAkB,eAAA,EAAiB,MAAA,EAAQ,CAAA,GAAI,CAAA"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/index.ts"],"mappings":";;;;;;KASY;EACV;IAEM;KACC;;GAGN;;;;;;;cAQU;;;;;;;;;;;;;;;;;;;;;;;iBAwBG,QAAQ,UAAU,iBAAiB,QAAQ,IAAI"}

package/dist/transformer.cjs

@@ -40,7 +40,7 @@ _babel_types = __toESM(_babel_types, 1);
 const DIRECTIVE = "use generative";
 //#endregion
 //#region ../x-generative-compiler/dist/package.js
-var version = "0.0.6";
+var version = "0.0.10";
 //#endregion
 //#region ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/constants.js
 var require_constants = /* @__PURE__ */ __commonJSMin(((exports, module) => {
@@ -623,7 +623,11 @@ var require_coerce = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		}
 		if (match === null) return null;
 		const major = match[2];
-		return parse(`${major}.${match[3] || "0"}.${match[4] || "0"}${options.includePrerelease && match[5] ? `-${match[5]}` : ""}${options.includePrerelease && match[6] ? `+${match[6]}` : ""}`, options);
+		const minor = match[3] || "0";
+		const patch = match[4] || "0";
+		const prerelease = options.includePrerelease && match[5] ? `-${match[5]}` : "";
+		const build = options.includePrerelease && match[6] ? `+${match[6]}` : "";
+		return parse(`${major}.${minor}.${patch}${prerelease}${build}`, options);
 	};
 	module.exports = coerce;
 }));
@@ -639,7 +643,8 @@ var require_truncate = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		return clonedVersion && doTruncation(clonedVersion, truncation);
 	};
 	const cloneInputVersion = (version, options) => {
-		return parse(version instanceof SemVer ? version.version : version, options);
+		const versionStringToParse = version instanceof SemVer ? version.version : version;
+		return parse(versionStringToParse, options);
 	};
 	const doTruncation = (version, truncation) => {
 		if (isPrerelease(truncation)) return version.version;
@@ -1425,6 +1430,11 @@ var import_semver = (/* @__PURE__ */ __commonJSMin(((exports, module) => {
 		rcompareIdentifiers: identifiers.rcompareIdentifiers
 	};
 })))();
+const parserPlugins = [
+	"typescript",
+	"jsx",
+	"explicitResourceManagement"
+];
 const traverse = typeof _babel_traverse.default === "function" ? _babel_traverse.default : _babel_traverse.default.default;
 const generate = typeof _babel_generator.default === "function" ? _babel_generator.default : _babel_generator.default.default;
 /** The required wrapper around a toolkit's tools (stripped at build time). */
@@ -1444,6 +1454,8 @@ const DISTRIBUTION_PACKAGES = [
 	"@assistant-ui/react-native",
 	"@assistant-ui/react-ink"
 ];
+/** Package that exports the generative UI runtime split by export condition. */
+const GENERATIVE_UI_PACKAGE = "@assistant-ui/react-generative-ui";
 /**
 * The class whose instances expose split-by-condition tools (`present()`,
 * `promptUser()`). A toolkit entry that calls a method on one of these passes
@@ -1571,18 +1583,14 @@ function compileGenerative(code, options) {
 	const { target, filename } = options;
 	const ast = (0, _babel_parser.parse)(code, {
 		sourceType: "module",
-		plugins: [
-			"typescript",
-			"jsx",
-			"explicitResourceManagement"
-		]
+		plugins: parserPlugins
 	});
 	if (!ast.program.directives.some((d) => d.value.value === "use generative")) throw new GenerativeCompileError(`missing "${DIRECTIVE}" directive`, filename);
 	ensureCompilerCompatibleWithCore(ast, filename);
 	ensureDefaultExport(ast, filename);
 	const generativeInstances = collectGenerativeInstances(ast);
 	const interactableToolImports = collectInteractableToolImports(ast);
-	const toolkitSpreadNames = collectToolkitSpreadNames(ast, filename, createToolkitNameContext());
+	const { spreadNames: toolkitSpreadNames, namespaceImports } = collectToolkitSpreadNames(ast, filename, createToolkitNameContext());
 	const flags = {
 		keptRender: false,
 		keptBackendExecute: false
@@ -1599,7 +1607,7 @@ function compileGenerative(code, options) {
 		}
 		if (_babel_types.isIdentifier(callee, { name: TOOLKIT_WRAPPER })) {
 			if (!object) throw new GenerativeCompileError(`${TOOLKIT_WRAPPER}() takes an inline object literal of tools`, filename);
-			compileToolkit(object, target, generativeInstances, interactableToolImports, toolkitSpreadNames, flags, filename);
+			compileToolkit(object, target, generativeInstances, interactableToolImports, toolkitSpreadNames, namespaceImports, flags, filename);
 			path.replaceWith(object);
 			path.skip();
 		}
@@ -1611,7 +1619,7 @@ function compileGenerative(code, options) {
 	if (target === "server" && keptBackendExecute && (options.injectServerOnly ?? true)) ast.program.body.unshift(_babel_types.importDeclaration([], _babel_types.stringLiteral("server-only")));
 	const result = generate(ast, {
 		sourceMaps: options.sourceMaps ?? false,
-		filename,
+		...filename ? { filename } : {},
 		jsescOption: { minimal: true }
 	}, code);
 	return {
@@ -1733,6 +1741,15 @@ function unwrapToCall(node, name) {
 	return null;
 }
 /**
+* Unwraps a statement to its variable declaration through an `export` wrapper,
+* or returns `null`.
+*/
+function asVariableDeclaration(statement) {
+	if (_babel_types.isVariableDeclaration(statement)) return statement;
+	if (_babel_types.isExportNamedDeclaration(statement) && _babel_types.isVariableDeclaration(statement.declaration)) return statement.declaration;
+	return null;
+}
+/**
 * Collects the names bound to `new JSONGenerativeUI(...)` (e.g.
 * `const generative = new JSONGenerativeUI({ library })`). A toolkit entry that
 * calls a method on one of these is a generative tool whose halves the library
@@ -1740,15 +1757,25 @@ function unwrapToCall(node, name) {
 */
 function collectGenerativeInstances(ast) {
 	const names = /* @__PURE__ */ new Set();
+	const generativeFactories = collectGenerativeFactoryImports(ast);
 	for (const statement of ast.program.body) {
-		if (!_babel_types.isVariableDeclaration(statement)) continue;
-		for (const declaration of statement.declarations) {
+		const variableDeclaration = asVariableDeclaration(statement);
+		if (!variableDeclaration) continue;
+		for (const declaration of variableDeclaration.declarations) {
 			const { id, init } = declaration;
-			if (_babel_types.isIdentifier(id) && _babel_types.isNewExpression(init) && _babel_types.isIdentifier(init.callee, { name: GENERATIVE_FACTORY })) names.add(id.name);
+			if (_babel_types.isIdentifier(id) && _babel_types.isNewExpression(init) && _babel_types.isIdentifier(init.callee) && generativeFactories.has(init.callee.name)) names.add(id.name);
 		}
 	}
 	return names;
 }
+function collectGenerativeFactoryImports(ast) {
+	const names = /* @__PURE__ */ new Set();
+	for (const statement of ast.program.body) {
+		if (!_babel_types.isImportDeclaration(statement) || statement.source.value !== GENERATIVE_UI_PACKAGE) continue;
+		for (const specifier of statement.specifiers) if (_babel_types.isImportSpecifier(specifier) && _babel_types.isIdentifier(specifier.imported, { name: GENERATIVE_FACTORY })) names.add(specifier.local.name);
+	}
+	return names;
+}
 /**
 * Collects the local names `unstable_interactableTool` is imported under from a
 * distribution package, so toolkit entries calling it can be recognized
@@ -1791,13 +1818,20 @@ function interactableToolConfig(value, imports) {
 *   toolkit can't leak a backend `execute` to the client. Only the default
 *   export crosses the generative-module boundary, so named imports don't
 *   qualify — they would be `undefined` once that module is build-split.
+*
+* A namespace import (`import * as kit from "..."`) of a generative module is
+* tracked separately in `namespaceImports` so a `...kit` / `...kit.default`
+* spread can be rejected with a specific callout: only the default export
+* crosses the boundary, so a namespace spread is never safe.
 */
 function collectToolkitSpreadNames(ast, filename, context) {
 	const spreadNames = /* @__PURE__ */ new Map();
+	const namespaceImports = /* @__PURE__ */ new Set();
 	const localToolkitCalls = /* @__PURE__ */ new Map();
 	for (const statement of ast.program.body) {
-		if (_babel_types.isVariableDeclaration(statement)) {
-			for (const declaration of statement.declarations) {
+		const localDeclaration = asVariableDeclaration(statement);
+		if (localDeclaration) {
+			for (const declaration of localDeclaration.declarations) {
 				const { id, init } = declaration;
 				if (_babel_types.isIdentifier(id) && init) {
 					const toolkitCall = unwrapToToolkitCall(init);
@@ -1808,9 +1842,12 @@ function collectToolkitSpreadNames(ast, filename, context) {
 		}
 		if (_babel_types.isImportDeclaration(statement)) {
 			const defaultSpecifier = statement.specifiers.find((specifier) => _babel_types.isImportDefaultSpecifier(specifier));
-			if (!defaultSpecifier) continue;
+			const namespaceSpecifier = statement.specifiers.find((specifier) => _babel_types.isImportNamespaceSpecifier(specifier));
+			if (!defaultSpecifier && !namespaceSpecifier) continue;
 			const names = getGenerativeImportToolkitNames(statement.source.value, filename, context);
-			if (names !== void 0) spreadNames.set(defaultSpecifier.local.name, names);
+			if (names === void 0) continue;
+			if (defaultSpecifier) spreadNames.set(defaultSpecifier.local.name, names);
+			if (namespaceSpecifier) namespaceImports.add(namespaceSpecifier.local.name);
 		}
 	}
 	const resolveLocal = (name) => {
@@ -1823,7 +1860,10 @@ function collectToolkitSpreadNames(ast, filename, context) {
 		return publicNames;
 	};
 	for (const name of localToolkitCalls.keys()) resolveLocal(name);
-	return spreadNames;
+	return {
+		spreadNames,
+		namespaceImports
+	};
 }
 const MODULE_EXTENSIONS = [
 	".ts",
@@ -1870,11 +1910,7 @@ function getGenerativeImportToolkitNames(source, filename, context) {
 	try {
 		const names = getDefaultExportToolkitNames((0, _babel_parser.parse)(code, {
 			sourceType: "module",
-			plugins: [
-				"typescript",
-				"jsx",
-				"explicitResourceManagement"
-			]
+			plugins: parserPlugins
 		}), resolved, context);
 		context.importedToolkitNamesByFile.set(resolved, names);
 		return names;
@@ -1891,7 +1927,7 @@ function getDefaultExportToolkitNames(ast, filename, context) {
 	if (!def) return null;
 	const toolkitCall = unwrapToToolkitCall(def.declaration);
 	if (!toolkitCall || !_babel_types.isObjectExpression(toolkitCall.arguments[0])) return null;
-	const spreadNames = collectToolkitSpreadNames(ast, filename, context);
+	const { spreadNames } = collectToolkitSpreadNames(ast, filename, context);
 	return uniqueToolkitNames(collectToolkitObjectNames(toolkitCall.arguments[0], spreadNames));
 }
 /** Resolves an import specifier (relative or `tsconfig`-aliased) to a file on disk. */
@@ -2080,6 +2116,25 @@ function isSafeToolkitSpread(entry, toolkitSpreadNames) {
 	const directMcpToolkit = unwrapToCall(entry.argument, MCP_TOOLKIT_WRAPPER);
 	return !!directMcpToolkit && _babel_types.isObjectExpression(directMcpToolkit.arguments[0]);
 }
+function genericUnsafeToolkitEntryMessage() {
+	return "each tool must be an inline object literal (`name: { ... }`) or a compiler-visible toolkit spread / generative tool (e.g. `...defineMcpToolkit(...)`, `...baseToolkit`, `generative.present()`, or `unstable_interactableTool(...)`) so its `execute` can be routed";
+}
+function describeUnsafeToolkitEntry(entry) {
+	if (!_babel_types.isObjectProperty(entry)) return genericUnsafeToolkitEntryMessage();
+	const toolName = memberName(entry.key, entry.computed);
+	const raw = entryRawValue(entry);
+	if (!toolName || !raw) return genericUnsafeToolkitEntryMessage();
+	return `tool "${toolName}" cannot be \`${generate(raw).code}\`; use an inline object literal (\`${toolName}: { ... }\`) or a compiler-visible toolkit spread / generative tool so its \`execute\` can be routed`;
+}
+function namespaceToolkitSpreadMessage() {
+	return `a namespace import (\`import * as kit from "..."\`) can't be spread into ${TOOLKIT_WRAPPER}({ ... }); only a generative module's default export crosses the build-split boundary, so import it as a default (\`import kit from "..."\`) and spread \`...kit\` instead`;
+}
+/** The `kit` in `...kit` or `...kit.default`, or null for a computed/opaque base. */
+function namespaceSpreadBaseName(argument) {
+	if (_babel_types.isIdentifier(argument)) return argument.name;
+	if (_babel_types.isMemberExpression(argument) && !argument.computed && _babel_types.isIdentifier(argument.object)) return argument.object.name;
+	return null;
+}
 /** The `JSONGenerativeUI` methods that produce a split-by-condition tool. */
 const GENERATIVE_TOOL_METHODS = /* @__PURE__ */ new Set(["present", "promptUser"]);
 /**
@@ -2112,7 +2167,7 @@ function compileComponents(object, target, flags, filename) {
 * `generative.present()` passes through, the library having already split it.
 * Mutates the object in place and records outcomes in {@link TargetFlags}.
 */
-function compileToolkit(object, target, instances, interactableToolImports, toolkitSpreadNames, flags, filename) {
+function compileToolkit(object, target, instances, interactableToolImports, toolkitSpreadNames, namespaceImports, flags, filename) {
 	if (target === "client") warnDuplicateToolkitNames(object, toolkitSpreadNames, filename);
 	const nextProperties = [];
 	for (const entry of object.properties) {
@@ -2134,19 +2189,24 @@ function compileToolkit(object, target, instances, interactableToolImports, tool
 				nextProperties.push(entry);
 				continue;
 			}
-			throw new GenerativeCompileError("each tool must be an inline object literal (`name: { ... }`) or a compiler-visible toolkit spread / generative tool (e.g. `...defineMcpToolkit(...)`, `...baseToolkit`, `generative.present()`, or `unstable_interactableTool(...)`) so its `execute` can be routed", filename);
+			if (_babel_types.isSpreadElement(entry)) {
+				const namespaceBase = namespaceSpreadBaseName(entry.argument);
+				if (namespaceBase && namespaceImports.has(namespaceBase)) throw new GenerativeCompileError(namespaceToolkitSpreadMessage(), filename);
+			}
+			throw new GenerativeCompileError(describeUnsafeToolkitEntry(entry), filename);
 		}
+		const toolName = _babel_types.isObjectProperty(entry) ? memberName(entry.key, entry.computed) : void 0;
 		const execute = findMember(value, "execute");
 		const isStub = execute ? executeIsStubTool(execute) : false;
 		const isExternal = execute ? executeIsExternalTool(execute) : false;
-		const type = inferToolType(value, filename);
+		const type = inferToolType(value, toolName, filename);
 		const hasRender = !!findMember(value, "render");
 		const hasRenderText = !!findMember(value, "renderText");
-		if (type === "frontend" && !hasRender && !hasRenderText) throw new GenerativeCompileError("a frontend tool must declare a `render` or `renderText` (it has no server execute to show otherwise)", filename);
-		if (type === "human" && !hasRender) throw new GenerativeCompileError("a human tool must declare a `render` so it can collect input", filename);
-		if (type === "provider" && execute) applyProviderToolConfig(value, execute, _babel_types.isObjectProperty(entry) ? memberName(entry.key, entry.computed) : void 0, filename);
+		if (type === "frontend" && !hasRender && !hasRenderText) throw new GenerativeCompileError(`${typedToolSubject("frontend", toolName)} must declare a \`render\` or \`renderText\` (it has no server execute to show otherwise)`, filename);
+		if (type === "human" && !hasRender) throw new GenerativeCompileError(`${typedToolSubject("human", toolName)} must declare a \`render\` so it can collect input`, filename);
+		if (type === "provider" && execute) applyProviderToolConfig(value, execute, toolName, filename);
 		if (isExternal) {
-			if (!hasRender && !hasRenderText) throw new GenerativeCompileError("an external tool must declare a `render` or `renderText` (assistant-ui only renders calls for tools defined elsewhere)", filename);
+			if (!hasRender && !hasRenderText) throw new GenerativeCompileError(`${typedToolSubject("external", toolName)} must declare a \`render\` or \`renderText\` (assistant-ui only renders calls for tools defined elsewhere)`, filename);
 			if (target === "server") continue;
 			stripExternalToolMetadata(value);
 		}
@@ -2242,15 +2302,22 @@ function stripUseClient(member) {
 * The loader writes the result back as a `type` field (see {@link setToolType})
 * so the runtime keeps it.
 */
-function inferToolType(object, filename) {
+function inferToolType(object, toolName, filename) {
 	const execute = findMember(object, "execute");
-	if (!execute) throw new GenerativeCompileError("every tool must declare an `execute`; use `humanTool()` for a human-in-the-loop tool", filename);
+	if (!execute) throw new GenerativeCompileError(`${toolSubject(toolName)} must declare an \`execute\`; use \`humanTool()\` for a human-in-the-loop tool`, filename);
 	if (executeIsHumanTool(execute)) return "human";
 	if (executeIsProviderTool(execute)) return "provider";
 	if (executeIsStubTool(execute)) return "frontend";
 	if (executeIsExternalTool(execute)) return "backend";
 	return executeIsClient(execute) ? "frontend" : "backend";
 }
+function toolSubject(toolName) {
+	return toolName ? `tool "${toolName}"` : "every tool";
+}
+function typedToolSubject(type, toolName) {
+	if (toolName) return `${type} tool "${toolName}"`;
+	return `${/^[aeiou]/i.test(type) ? "an" : "a"} ${type} tool`;
+}
 function stripExternalToolMetadata(object) {
 	removeMember(object, "description");
 	removeMember(object, "parameters");