@happyvertical/smrt-core 0.55.10 → 0.55.11

package/dist/consumer-plugin/index.js

@@ -10,8 +10,9 @@ import { loadVerifiedSmrtGenerationSnapshot, serializeSmrtGenerationSnapshot, sh
 import { generateClientModule } from "../vite-plugin/generated-client.js";
 import { activeProducerKnowledgeRoutePaths, activeSvelteKitRouteParticipants, assertNoSvelteKitRouteRootSymlinkConflict, assertSvelteKitRouteCoordinationComplete, contributeSvelteKitRoutes, expectedSvelteKitRouteOwners, markSvelteKitRouteParticipant, producerKnowledgeRoutePaths, revokeSvelteKitRoutes } from "../vite-plugin/sveltekit-route-coordinator.js";
 import { generateDeclarations } from "../prebuild/index.js";
-import * as path from "node:path";
-import * as fs from "node:fs";
+import { separateHostedStiCollections } from "./hosted-sti-collections.js";
+import * as path$1 from "node:path";
+import * as fs$1 from "node:fs";
 //#region src/consumer-plugin/index.ts
 /**
 * Vite plugin for consuming SMRT packages
@@ -28,21 +29,21 @@ var VIRTUAL_MODULES = {
 var CONSUMER_SVELTEKIT_ROUTES_ARTIFACT_VERSION = 1;
 var CONSUMER_SVELTEKIT_ROUTES_ARTIFACT = "consumer-sveltekit-routes.json";
 function consumerSvelteKitRoutesArtifactPath(projectRoot) {
-	return path.join(projectRoot, ".smrt", CONSUMER_SVELTEKIT_ROUTES_ARTIFACT);
+	return path$1.join(projectRoot, ".smrt", CONSUMER_SVELTEKIT_ROUTES_ARTIFACT);
 }
 /** Persist only project-relative consumer route roots, never an output file list. */
 function canonicalConsumerRouteRoot(projectRoot, routesDir) {
-	const root = path.resolve(projectRoot);
-	const relative = path.relative(root, path.resolve(root, routesDir));
-	if (!relative || relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) throw new Error(`[smrt:consumer] svelteKit.routesDir must be a project-relative subdirectory (received ${JSON.stringify(routesDir)})`);
-	return relative.split(path.sep).join("/");
+	const root = path$1.resolve(projectRoot);
+	const relative = path$1.relative(root, path$1.resolve(root, routesDir));
+	if (!relative || relative === ".." || relative.startsWith(`..${path$1.sep}`) || path$1.isAbsolute(relative)) throw new Error(`[smrt:consumer] svelteKit.routesDir must be a project-relative subdirectory (received ${JSON.stringify(routesDir)})`);
+	return relative.split(path$1.sep).join("/");
 }
 function loadConsumerSvelteKitRouteRoots(projectRoot) {
 	const artifactPath = consumerSvelteKitRoutesArtifactPath(projectRoot);
-	if (!fs.existsSync(artifactPath)) return [];
+	if (!fs$1.existsSync(artifactPath)) return [];
 	let parsed;
 	try {
-		parsed = JSON.parse(fs.readFileSync(artifactPath, "utf-8"));
+		parsed = JSON.parse(fs$1.readFileSync(artifactPath, "utf-8"));
 	} catch {
 		throw new Error(`[smrt:consumer] Cannot read ${CONSUMER_SVELTEKIT_ROUTES_ARTIFACT}; refusing to leave hosted routes unreconciled`);
 	}
@@ -51,7 +52,7 @@ function loadConsumerSvelteKitRouteRoots(projectRoot) {
 }
 function publishConsumerSvelteKitRouteRoots(projectRoot, routesDir) {
 	const artifactPath = consumerSvelteKitRoutesArtifactPath(projectRoot);
-	fs.mkdirSync(path.dirname(artifactPath), { recursive: true });
+	fs$1.mkdirSync(path$1.dirname(artifactPath), { recursive: true });
 	publishArtifactFiles([{
 		path: artifactPath,
 		content: JSON.stringify({
@@ -62,7 +63,7 @@ function publishConsumerSvelteKitRouteRoots(projectRoot, routesDir) {
 }
 function removeConsumerSvelteKitRouteRoots(projectRoot) {
 	const artifactPath = consumerSvelteKitRoutesArtifactPath(projectRoot);
-	if (fs.existsSync(artifactPath)) fs.unlinkSync(artifactPath);
+	if (fs$1.existsSync(artifactPath)) fs$1.unlinkSync(artifactPath);
 }
 /**
 * A hosting-to-hosting move can replace one configured root with another in a
@@ -73,7 +74,7 @@ function removeConsumerSvelteKitRouteRoots(projectRoot) {
 async function assertConsumerSvelteKitFormerRouteRootsAreSafe(userConfig, projectRoot, routesDir, env) {
 	if (routesDir.length === 0) return;
 	const activeRoots = (await activeSvelteKitRouteParticipants(userConfig, projectRoot, env)).map((participant) => participant.routesDir);
-	for (const priorRoutesDir of routesDir) assertNoSvelteKitRouteRootSymlinkConflict(canonicalSvelteKitPath(path.resolve(projectRoot, priorRoutesDir)), activeRoots);
+	for (const priorRoutesDir of routesDir) assertNoSvelteKitRouteRootSymlinkConflict(canonicalSvelteKitPath(path$1.resolve(projectRoot, priorRoutesDir)), activeRoots);
 }
 async function reconcileConsumerSvelteKitRouteRoots(lifecycle, userConfig, projectRoot, routesDir, afterReconciled, env) {
 	const remaining = new Set(routesDir);
@@ -86,14 +87,14 @@ async function reconcileConsumerSvelteKitRouteRoots(lifecycle, userConfig, proje
 		return;
 	}
 	for (const routesDir of [...remaining]) {
-		const routeRoot = canonicalSvelteKitPath(path.resolve(projectRoot, routesDir));
+		const routeRoot = canonicalSvelteKitPath(path$1.resolve(projectRoot, routesDir));
 		const activeParticipants = await activeSvelteKitRouteParticipants(userConfig, projectRoot, env);
 		assertNoSvelteKitRouteRootSymlinkConflict(routeRoot, activeParticipants.map((participant) => participant.routesDir));
-		if (activeParticipants.find((participant) => participant.owner === "consumer" && (routeRoot === participant.routesDir || routeRoot.startsWith(`${participant.routesDir}${path.sep}`)))) {
+		if (activeParticipants.find((participant) => participant.owner === "consumer" && (routeRoot === participant.routesDir || routeRoot.startsWith(`${participant.routesDir}${path$1.sep}`)))) {
 			reconcileOne(routesDir);
 			continue;
 		}
-		const containingProducer = activeParticipants.find((participant) => participant.owner === "producer" && (routeRoot === participant.routesDir || routeRoot.startsWith(`${participant.routesDir}${path.sep}`)));
+		const containingProducer = activeParticipants.find((participant) => participant.owner === "producer" && (routeRoot === participant.routesDir || routeRoot.startsWith(`${participant.routesDir}${path$1.sep}`)));
 		if (containingProducer) {
 			await revokeSvelteKitRoutes(lifecycle, await expectedSvelteKitRouteOwners(userConfig, containingProducer.projectRoot, containingProducer.routesDir, env), containingProducer.projectRoot, containingProducer.routesDir, () => reconcileOne(routesDir));
 			continue;
@@ -147,6 +148,7 @@ function selectConsumerRouteManifest(manifest, options) {
 		};
 	}
 	const sourceManifest = manifest;
+	const collectionBySlot = /* @__PURE__ */ new Map();
 	for (const [manifestKey, objectDef] of Object.entries(manifest.objects)) {
 		const candidate = objectDef;
 		if (!isCollectionManifestClass(sourceManifest, candidate)) continue;
@@ -155,7 +157,19 @@ function selectConsumerRouteManifest(manifest, options) {
 		const itemRef = itemEntry ? consumerObjectRef(itemEntry[0], itemEntry[1]) : void 0;
 		if (!itemRef || !selected.has(itemRef)) continue;
 		const collectionRef = consumerObjectRef(manifestKey, objectDef);
-		if (collectionRef) objects[collectionRef] = {
+		if (!collectionRef) continue;
+		const slot = `${itemRef}\0${candidate.collection}`;
+		const rival = collectionBySlot.get(slot);
+		if (rival) {
+			const conventional = `${item?.className}Collection`;
+			if (candidate.className !== conventional || rival.className === conventional) continue;
+			delete objects[rival.ref];
+		}
+		collectionBySlot.set(slot, {
+			ref: collectionRef,
+			className: candidate.className
+		});
+		objects[collectionRef] = {
 			...objectDef,
 			qualifiedName: collectionRef
 		};
@@ -180,7 +194,18 @@ function smrtConsumer(options = {}) {
 	let routeLifecycleConfig;
 	function loadGenerationSnapshot() {
 		if (!generationSnapshot) throw new Error("[smrt:consumer] Generation snapshot is not configured");
-		return loadVerifiedSmrtGenerationSnapshot(generationSnapshot, projectRoot, "dependencies");
+		return withHostedStiCollections(loadVerifiedSmrtGenerationSnapshot(generationSnapshot, projectRoot, "dependencies"));
+	}
+	/**
+	* Hosted STI subclasses get their own route collection (#3749), in every
+	* manifest view the plugin derives, so routes, the generated client, the
+	* `@smrt/web` definitions and the registration agree on the endpoint.
+	*/
+	function withHostedStiCollections(manifest) {
+		return consumerSvelteKit ? separateHostedStiCollections(manifest, consumerSvelteKit.objects, (key, def) => consumerObjectRef(key, def)) : manifest;
+	}
+	async function aggregateHosted(...args) {
+		return withHostedStiCollections(await aggregateTypeManifests(...args));
 	}
 	/**
 	* Resolve the packages to aggregate, and whether that list was asserted by
@@ -203,7 +228,7 @@ function smrtConsumer(options = {}) {
 		else if (generationSnapshot) typeManifest = loadGenerationSnapshot();
 		else {
 			const resolved = await resolveConsumerPackages();
-			typeManifest = await aggregateTypeManifests(resolved.names, projectRoot, { explicit: resolved.explicit });
+			typeManifest = await aggregateHosted(resolved.names, projectRoot, { explicit: resolved.explicit });
 		}
 		await generateProjectTypes(typeManifest, typesDir, projectRoot);
 		typesGenerated = true;
@@ -220,14 +245,14 @@ function smrtConsumer(options = {}) {
 				if (consumerSvelteKit) {
 					await assertConsumerSvelteKitFormerRouteRootsAreSafe(userConfig, projectRoot, previousConsumerRouteRoots, env);
 					const routePackages = await resolveConsumerPackages();
-					const routeManifest = generationSnapshot ? loadGenerationSnapshot() : await aggregateTypeManifests(routePackages.names, projectRoot, { explicit: routePackages.explicit });
+					const routeManifest = generationSnapshot ? loadGenerationSnapshot() : await aggregateHosted(routePackages.names, projectRoot, { explicit: routePackages.explicit });
 					const hostedManifest = selectConsumerRouteManifest(routeManifest, consumerSvelteKit);
 					const routesDir = canonicalConsumerRouteRoot(projectRoot, consumerSvelteKit.routesDir ?? "src/routes/api");
 					const reservedRoutePaths = await activeProducerKnowledgeRoutePaths(userConfig, projectRoot, env);
 					const routeOptions = {
 						enabled: true,
 						routesDir,
-						objectsDir: "src/lib/objects",
+						objectsDir: consumerSvelteKit.objectsDir ?? "src/lib/objects",
 						configPath: consumerSvelteKit.configPath ?? "src/lib/server",
 						configFileName: consumerSvelteKit.configFileName ?? "smrt.ts",
 						kebabRoutes: effectiveKebabRoutes,
@@ -286,7 +311,7 @@ function smrtConsumer(options = {}) {
 			smrtPackages = resolvedPackages.names;
 			if (smrtPackages.length > 0) {
 				console.log(`[smrt:consumer] Found SMRT packages: ${smrtPackages.join(", ")}`);
-				typeManifest = await aggregateTypeManifests(smrtPackages, projectRoot, { explicit: resolvedPackages.explicit });
+				typeManifest = await aggregateHosted(smrtPackages, projectRoot, { explicit: resolvedPackages.explicit });
 				const agentSurface = producerApi ? await producerApi.resolveKnowledgeAgentSurface() : void 0;
 				await saveAggregatedManifest(typeManifest, projectRoot, producerApi?.resolveKnowledgeConfig, agentSurface);
 				await generateRegistrationFile(typeManifest, projectRoot);
@@ -307,8 +332,8 @@ function smrtConsumer(options = {}) {
 			if (id in VIRTUAL_MODULES) {
 				if (id !== "@smrt/types") return `\0${VIRTUAL_MODULES[id]}`;
 				const typeFileName = getTypeFileName(id);
-				const typePath = path.join(projectRoot, typesDir, typeFileName);
-				if (fs.existsSync(typePath)) return typePath;
+				const typePath = path$1.join(projectRoot, typesDir, typeFileName);
+				if (fs$1.existsSync(typePath)) return typePath;
 				return `\0${VIRTUAL_MODULES[id]}`;
 			}
 			return null;
@@ -347,12 +372,12 @@ function smrtConsumer(options = {}) {
 */
 async function discoverSmrtPackages(projectRoot) {
 	const packages = [];
-	const nodeModulesPath = path.join(projectRoot, "node_modules");
-	if (!fs.existsSync(nodeModulesPath)) return packages;
+	const nodeModulesPath = path$1.join(projectRoot, "node_modules");
+	if (!fs$1.existsSync(nodeModulesPath)) return packages;
 	try {
-		const packageJsonPath = path.join(projectRoot, "package.json");
-		if (fs.existsSync(packageJsonPath)) {
-			const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+		const packageJsonPath = path$1.join(projectRoot, "package.json");
+		if (fs$1.existsSync(packageJsonPath)) {
+			const packageJson = JSON.parse(fs$1.readFileSync(packageJsonPath, "utf-8"));
 			const allDeps = {
 				...packageJson.dependencies,
 				...packageJson.devDependencies,
@@ -376,14 +401,14 @@ async function discoverSmrtPackages(projectRoot) {
 * packages that ship a manifest without exporting a subpath for it.
 */
 function legacyStaticManifestPath(packageDir) {
-	return path.join(packageDir, "dist", "manifest", "static-manifest.js");
+	return path$1.join(packageDir, "dist", "manifest", "static-manifest.js");
 }
 function packageManifestCandidates(packageDir, packageJson) {
 	return [
 		...manifestExportCandidates(packageDir, packageJson),
 		legacyStaticManifestPath(packageDir),
-		path.join(packageDir, "dist", "manifest.json"),
-		path.join(packageDir, "manifest.json")
+		path$1.join(packageDir, "dist", "manifest.json"),
+		path$1.join(packageDir, "manifest.json")
 	];
 }
 /**
@@ -406,16 +431,16 @@ function packageManifestCandidates(packageDir, packageJson) {
 * location counts — exactly the probe this function used before #2923.
 */
 async function hasSmrtManifest(nodeModulesPath, packageName) {
-	const packagePath = path.join(nodeModulesPath, packageName);
+	const packagePath = path$1.join(nodeModulesPath, packageName);
 	const legacyStaticManifest = legacyStaticManifestPath(packagePath);
 	for (const manifestPath of packageManifestCandidates(packagePath)) {
-		if (!fs.existsSync(manifestPath)) continue;
+		if (!fs$1.existsSync(manifestPath)) continue;
 		if (!manifestPath.endsWith(".json")) {
 			if (manifestPath === legacyStaticManifest) return true;
 			continue;
 		}
 		try {
-			if (JSON.parse(fs.readFileSync(manifestPath, "utf-8"))?.moduleType === "smrt") return true;
+			if (JSON.parse(fs$1.readFileSync(manifestPath, "utf-8"))?.moduleType === "smrt") return true;
 		} catch {}
 	}
 	return false;
@@ -445,11 +470,11 @@ async function aggregateTypeManifests(packages, projectRoot, options = {}) {
 	for (const packageName of packages) {
 		let loadedManifest = false;
 		try {
-			const packageDir = path.join(projectRoot, "node_modules", packageName);
-			const packageJsonPath = path.join(packageDir, "package.json");
+			const packageDir = path$1.join(projectRoot, "node_modules", packageName);
+			const packageJsonPath = path$1.join(packageDir, "package.json");
 			let packageJson;
 			try {
-				const packageJsonContent = fs.readFileSync(packageJsonPath, "utf-8");
+				const packageJsonContent = fs$1.readFileSync(packageJsonPath, "utf-8");
 				packageJson = JSON.parse(packageJsonContent);
 			} catch {
 				console.warn(`[smrt:consumer] Could not read package.json for ${packageName}`);
@@ -457,14 +482,14 @@ async function aggregateTypeManifests(packages, projectRoot, options = {}) {
 				continue;
 			}
 			const manifestCandidates = packageManifestCandidates(packageDir, packageJson);
-			for (const manifestPath of manifestCandidates) if (fs.existsSync(manifestPath)) {
+			for (const manifestPath of manifestCandidates) if (fs$1.existsSync(manifestPath)) {
 				let manifest;
 				try {
 					if (manifestPath.endsWith(".js")) {
 						const manifestModule = await import(manifestPath);
 						manifest = manifestModule.staticManifest || manifestModule.default;
 					} else {
-						const manifestContent = fs.readFileSync(manifestPath, "utf-8");
+						const manifestContent = fs$1.readFileSync(manifestPath, "utf-8");
 						manifest = JSON.parse(manifestContent);
 					}
 				} catch (error) {
@@ -535,13 +560,13 @@ function determineImportPath(packageJson) {
 * the file (including the top-level `packageName` the local write sets).
 */
 async function saveAggregatedManifest(manifest, projectRoot, resolveKnowledgeConfig, agentSurface) {
-	const smrtDir = path.join(projectRoot, ".smrt");
-	const manifestPath = path.join(smrtDir, "manifest.json");
+	const smrtDir = path$1.join(projectRoot, ".smrt");
+	const manifestPath = path$1.join(smrtDir, "manifest.json");
 	try {
-		if (!fs.existsSync(smrtDir)) fs.mkdirSync(smrtDir, { recursive: true });
+		if (!fs$1.existsSync(smrtDir)) fs$1.mkdirSync(smrtDir, { recursive: true });
 		let merged = manifest;
-		if (fs.existsSync(manifestPath)) try {
-			const existing = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+		if (fs$1.existsSync(manifestPath)) try {
+			const existing = JSON.parse(fs$1.readFileSync(manifestPath, "utf-8"));
 			if (existing && typeof existing.objects === "object") merged = {
 				...existing,
 				...manifest,
@@ -552,9 +577,9 @@ async function saveAggregatedManifest(manifest, projectRoot, resolveKnowledgeCon
 				}
 			};
 		} catch {}
-		const knowledgePath = path.join(smrtDir, "smrt-knowledge.json");
-		const packageJsonPath = path.join(projectRoot, "package.json");
-		const packageJson = fs.existsSync(packageJsonPath) ? JSON.parse(fs.readFileSync(packageJsonPath, "utf-8")) : void 0;
+		const knowledgePath = path$1.join(smrtDir, "smrt-knowledge.json");
+		const packageJsonPath = path$1.join(projectRoot, "package.json");
+		const packageJson = fs$1.existsSync(packageJsonPath) ? JSON.parse(fs$1.readFileSync(packageJsonPath, "utf-8")) : void 0;
 		const knowledgeConfig = resolveKnowledgeConfig ? await resolveKnowledgeConfig(merged) : await resolveFileKnowledgeConfig(projectRoot, merged.packageName ?? packageJson?.name);
 		if (knowledgeConfig.enabled === false) {
 			publishArtifactFiles([{
@@ -590,8 +615,8 @@ async function saveAggregatedManifest(manifest, projectRoot, resolveKnowledgeCon
 * for all external SMRT objects discovered during build.
 */
 async function generateRegistrationFile(manifest, projectRoot) {
-	const smrtDir = path.join(projectRoot, ".smrt");
-	const registerPath = path.join(smrtDir, "register.js");
+	const smrtDir = path$1.join(projectRoot, ".smrt");
+	const registerPath = path$1.join(smrtDir, "register.js");
 	const importBindings = /* @__PURE__ */ new Map();
 	const importsByPath = /* @__PURE__ */ new Map();
 	let nextImportBinding = 0;
@@ -706,8 +731,8 @@ export function registerAll() {
   console.log('[smrt:register] Registered ${registeredObjectCount} external ${registeredObjectLabel}');
 }
 `;
-	if (!fs.existsSync(smrtDir)) fs.mkdirSync(smrtDir, { recursive: true });
-	fs.writeFileSync(registerPath, content, "utf-8");
+	if (!fs$1.existsSync(smrtDir)) fs$1.mkdirSync(smrtDir, { recursive: true });
+	fs$1.writeFileSync(registerPath, content, "utf-8");
 	console.log(`[smrt:consumer] Generated .smrt/register.js with ${importedEntryCount} external entries (${registeredObjectCount} registered ${registeredObjectLabel})`);
 }
 /**