@happyvertical/smrt-core 0.57.45 → 0.57.47

package/dist/consumer-plugin/index.js

@@ -1,10 +1,12 @@
 import "../scanner/types.js";
+import { isTestArtifactManifest } from "../manifest/test-artifacts.js";
 import { canonicalSvelteKitPath } from "../vite-plugin/sveltekit-path.js";
 import { clearGeneratedSvelteKitRouteFiles, reconcileSvelteKitRouteGitignore, resolveApiActionSet } from "../vite-plugin/sveltekit-generator.js";
 import { generateWebModule, isCollectionManifestClass, resolveCollectionItemObject } from "../vite-plugin/web-collections.js";
 import { publishArtifactFiles } from "./artifact-publication.js";
 import { resolveFileKnowledgeConfig } from "../knowledge-config.js";
 import { buildDomainKnowledgeManifest } from "../knowledge.js";
+import { selectObjectDeclarations } from "../manifest/object-declarations.js";
 import { manifestExportCandidates } from "../manifest/package-manifest-exports.js";
 import { loadVerifiedSmrtGenerationSnapshot, serializeSmrtGenerationSnapshot, sha256SmrtGenerationSnapshot } from "../generation-snapshot.js";
 import { generateClientModule } from "../vite-plugin/generated-client.js";
@@ -12,7 +14,8 @@ import { activeProducerKnowledgeRoutePaths, activeSvelteKitRouteParticipants, as
 import { generateDeclarations } from "../prebuild/index.js";
 import { separateHostedStiCollections } from "./hosted-sti-collections.js";
 import * as path$1 from "node:path";
-import { pathToFileURL } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { resolve as resolve$1 } from "import-meta-resolve";
 import * as fs$1 from "node:fs";
 //#region src/consumer-plugin/index.ts
 /**
@@ -45,6 +48,27 @@ function readInstalledPackageJson(packageJsonPath) {
 		return;
 	}
 }
+var TYPESCRIPT_SOURCE_PATTERN = /(?<!\.d)\.(?:[cm]?ts|tsx)$/;
+/**
+* Whether `specifier` resolves, under Node's ESM `import` conditions from
+* `fromDir`, to a TypeScript source file (#3092). Workspace packages often
+* publish `"import": "./src/index.ts"` for an app that only runs them through
+* Vite. Plain Node cannot evaluate such a module as a SMRT provider: it does
+* not rewrite `./x.js` specifiers to `./x.ts`, never strips types inside
+* `node_modules`, and cannot strip `@smrt()` decorators at all. An
+* unresolvable specifier answers `false`, leaving the existing import (and its
+* existing failure mode) unchanged.
+*
+* @internal Exported for tests.
+*/
+function resolvesToTypeScriptSource(specifier, fromDir) {
+	try {
+		const target = resolve$1(specifier, pathToFileURL(path$1.join(fromDir, "package.json")).href);
+		return target.startsWith("file:") && TYPESCRIPT_SOURCE_PATTERN.test(fileURLToPath(target));
+	} catch {
+		return false;
+	}
+}
 /**
 * Whether an `exports` target (or any condition under it) needs Vite to
 * compile it: a `.svelte`/`.css` file or a `svelte` resolution condition.
@@ -812,7 +836,7 @@ async function saveAggregatedManifest(manifest, projectRoot, resolveKnowledgeCon
 		let merged = manifest;
 		if (fs$1.existsSync(manifestPath)) try {
 			const existing = JSON.parse(fs$1.readFileSync(manifestPath, "utf-8"));
-			if (existing && typeof existing.objects === "object") merged = {
+			if (existing && typeof existing.objects === "object" && !isTestArtifactManifest(existing)) merged = {
 				...existing,
 				...manifest,
 				...existing.packageName ? { packageName: existing.packageName } : {},
@@ -865,6 +889,20 @@ async function generateRegistrationFile(manifest, projectRoot) {
 	const importBindings = /* @__PURE__ */ new Map();
 	const importsByPath = /* @__PURE__ */ new Map();
 	const transitiveNamespaces = /* @__PURE__ */ new Map();
+	const typeScriptSourceMemo = /* @__PURE__ */ new Map();
+	const isTypeScriptSource = (specifier, fromDir) => {
+		const key = `${fromDir}\0${specifier}`;
+		let answer = typeScriptSourceMemo.get(key);
+		if (answer === void 0) {
+			answer = resolvesToTypeScriptSource(specifier, fromDir);
+			typeScriptSourceMemo.set(key, answer);
+		}
+		return answer;
+	};
+	const viteOnlyImportPaths = /* @__PURE__ */ new Set();
+	const markViteOnlyImport = (importPath) => {
+		if (isTypeScriptSource(importPath, projectRoot)) viteOnlyImportPaths.add(importPath);
+	};
 	const transitiveBindings = /* @__PURE__ */ new Map();
 	const transitiveCollectionChecks = [];
 	let nextImportBinding = 0;
@@ -877,16 +915,19 @@ async function generateRegistrationFile(manifest, projectRoot) {
 		const specifiers = importsByPath.get(importPath) ?? /* @__PURE__ */ new Map();
 		specifiers.set(exportName, binding);
 		importsByPath.set(importPath, specifiers);
+		markViteOnlyImport(importPath);
 		return binding;
 	};
 	const getTransitiveBinding = (importPath, providerPackageName, exportName) => {
 		const namespaceKey = `${providerPackageName}\0${importPath}`;
 		let namespace = transitiveNamespaces.get(namespaceKey);
 		if (!namespace) {
+			const providerPackageJson = findInstalledPackageJson(providerPackageName, projectRoot);
 			namespace = {
 				binding: `__smrt_transitive_provider_${transitiveNamespaces.size}`,
 				providerPackageName,
-				importPath
+				importPath,
+				viteOnly: Boolean(providerPackageJson && isTypeScriptSource(importPath, path$1.dirname(providerPackageJson)))
 			};
 			transitiveNamespaces.set(namespaceKey, namespace);
 		}
@@ -978,7 +1019,8 @@ async function generateRegistrationFile(manifest, projectRoot) {
 		const collectionBinding = hasCollection && collectionExportName ? appResolvable ? getImportBinding(importPath, collectionExportName) : getTransitiveBinding(importPath, providerPackageName, collectionExportName) : void 0;
 		if (!appResolvable && collectionBinding) transitiveCollectionChecks.push({
 			collectionBinding,
-			itemBinding: exportBinding
+			itemBinding: exportBinding,
+			viteOnly: transitiveNamespaces.get(`${providerPackageName}\0${importPath}`)?.viteOnly ?? false
 		});
 		importedEntryCount++;
 		if (isCollectionClass(def)) {
@@ -1004,6 +1046,7 @@ async function generateRegistrationFile(manifest, projectRoot) {
 		const contextImport = resolveProviderContextImport(packageName, readInstalledPackageJson(findInstalledPackageJson(packageName, projectRoot)));
 		if (!contextImport || importsByPath.has(contextImport)) continue;
 		importsByPath.set(contextImport, /* @__PURE__ */ new Map());
+		markViteOnlyImport(contextImport);
 	}
 	if (importedEntryCount === 0) {
 		console.log("[smrt:consumer] No external entries - skipping register.js");
@@ -1011,12 +1054,25 @@ async function generateRegistrationFile(manifest, projectRoot) {
 	}
 	const registeredObjectLabel = registeredObjectCount === 1 ? "object" : "objects";
 	const sortedImports = Array.from(importsByPath.entries()).sort(([left], [right]) => left.localeCompare(right));
-	const imports = sortedImports.map(([importPath], index) => `import * as __smrt_provider_${index} from '${importPath}';`);
+	const imports = sortedImports.flatMap(([importPath], index) => viteOnlyImportPaths.has(importPath) ? [] : [`import * as __smrt_provider_${index} from '${importPath}';`]);
+	const viteOnlyImports = sortedImports.flatMap(([importPath], index) => viteOnlyImportPaths.has(importPath) ? [`const __smrt_provider_${index} = SMRT_VITE_RUNTIME ? await import(${JSON.stringify(importPath)}) : {};`] : []);
+	const viteOnlyModules = [...viteOnlyImportPaths, ...Array.from(transitiveNamespaces.values()).filter(({ viteOnly }) => viteOnly).map(({ importPath }) => importPath)].sort((left, right) => left.localeCompare(right));
+	const uniqueViteOnlyModules = [...new Set(viteOnlyModules)];
+	if (uniqueViteOnlyModules.length > 0) console.warn(`[smrt:consumer] ${uniqueViteOnlyModules.join(", ")} resolve${uniqueViteOnlyModules.length === 1 ? "s" : ""} to TypeScript source; .smrt/register.js imports ${uniqueViteOnlyModules.length === 1 ? "it" : "them"} only under Vite. Plain Node (smrt db:migrate, CLIs) keeps their manifests but does not register their constructors; the compiled worker artifact (.smrt/runtime/register.js) still imports them and cannot start under plain Node. Publish a compiled JavaScript export to register them outside Vite (#3092).`);
+	const viteRuntimePrelude = uniqueViteOnlyModules.length > 0 ? `const SMRT_VITE_RUNTIME = Boolean(import.meta.env);
+if (!SMRT_VITE_RUNTIME) {
+  console.warn(${JSON.stringify(`[smrt:register] Skipped TypeScript-source modules under plain Node: ${uniqueViteOnlyModules.join(", ")}. Their manifests remain available; their constructors are registered only under Vite (#3092).`)});
+}
+` : "";
 	const importDeclarations = sortedImports.flatMap(([, specifiers], index) => Array.from(specifiers.entries()).sort(([left], [right]) => left.localeCompare(right)).map(([exportName, binding]) => `const ${binding} = getSmrtExport(__smrt_provider_${index}, ${JSON.stringify(exportName)});`));
-	const transitiveNamespaceDeclarations = Array.from(transitiveNamespaces.values()).sort((left, right) => left.binding.localeCompare(right.binding)).map(({ binding, providerPackageName, importPath }) => `const ${binding} = await importSmrtDependency(${JSON.stringify(importPath)}, ${JSON.stringify(providerPackageName)});`);
+	const transitiveNamespaceDeclarations = Array.from(transitiveNamespaces.values()).sort((left, right) => left.binding.localeCompare(right.binding)).map(({ binding, providerPackageName, importPath, viteOnly }) => {
+		const load = `await importSmrtDependency(${JSON.stringify(importPath)}, ${JSON.stringify(providerPackageName)})`;
+		return viteOnly ? `const ${binding} = SMRT_VITE_RUNTIME ? ${load} : {};` : `const ${binding} = ${load};`;
+	});
+	const viteOnlyNamespaceBindings = new Set(Array.from(transitiveNamespaces.values()).filter(({ viteOnly }) => viteOnly).map(({ binding }) => binding));
 	const transitiveDeclarations = Array.from(transitiveBindings.entries()).sort(([left], [right]) => left.localeCompare(right)).map(([, { binding, namespaceBinding, exportName }]) => `const ${binding} = getSmrtExport(${namespaceBinding}, ${JSON.stringify(exportName)});
-if (!${binding}) throw new Error(${JSON.stringify(`[smrt:consumer] Provider-owned module did not export ${exportName}`)});`);
-	const transitiveCollectionDeclarations = transitiveCollectionChecks.map(({ collectionBinding, itemBinding }) => `if (${collectionBinding}._itemClass !== ${itemBinding}) throw new Error('[smrt:consumer] Provider-owned collection does not match its item constructor');`);
+if (${viteOnlyNamespaceBindings.has(namespaceBinding) ? "SMRT_VITE_RUNTIME && " : ""}!${binding}) throw new Error(${JSON.stringify(`[smrt:consumer] Provider-owned module did not export ${exportName}`)});`);
+	const transitiveCollectionDeclarations = transitiveCollectionChecks.map(({ collectionBinding, itemBinding, viteOnly }) => `if (${viteOnly ? "SMRT_VITE_RUNTIME && " : ""}${collectionBinding}._itemClass !== ${itemBinding}) throw new Error('[smrt:consumer] Provider-owned collection does not match its item constructor');`);
 	const registrationManifestLiteral = JSON.stringify(JSON.stringify(registrationManifests));
 	const content = `/**
  * Auto-generated by @happyvertical/smrt-core/consumer-plugin
@@ -1058,6 +1114,7 @@ const importSmrtDependency = async (specifier, providerPackageName) => {
   }
 };
 ` : ""}
+${viteRuntimePrelude}${viteOnlyImports.join("\n")}
 ${transitiveNamespaceDeclarations.join("\n")}
 ${importDeclarations.join("\n")}
 ${transitiveDeclarations.join("\n")}
@@ -1142,10 +1199,9 @@ export default createMCPServer;
 `;
 }
 function generateFallbackTypesModule(manifest) {
-	const objects = Object.entries(manifest?.objects || {});
-	if (objects.length === 0) return `// No types available`;
-	return objects.map(([_name, obj]) => {
-		return `export interface ${obj.className}Data {
+	if (Object.entries(manifest?.objects || {}).length === 0) return `// No types available`;
+	return selectObjectDeclarations(manifest).map(({ interfaceName }) => {
+		return `export interface ${interfaceName} {
   id?: string;
   created_at?: string;
   updated_at?: string;
@@ -1161,6 +1217,6 @@ export default manifest;
 `;
 }
 //#endregion
-export { isComponentBearingRoot, loadVerifiedSmrtGenerationSnapshot, resolveProviderContextImport, serializeSmrtGenerationSnapshot, sha256SmrtGenerationSnapshot, smrtConsumer };
+export { isComponentBearingRoot, loadVerifiedSmrtGenerationSnapshot, resolveProviderContextImport, resolvesToTypeScriptSource, serializeSmrtGenerationSnapshot, sha256SmrtGenerationSnapshot, smrtConsumer };
 
 //# sourceMappingURL=index.js.map