@happyvertical/smrt-core 0.57.17 → 0.57.19

package/README.md

@@ -500,6 +500,20 @@ CLI entrypoints should ship two things together:
 2. The `manifest.json` exports for any installed external `@happyvertical/smrt-*`
    packages the runtime needs to hydrate at query time.
 
+For an SSR build, `smrtConsumer()` leaves its consumed providers and their
+transitive server-side `@happyvertical/smrt-*` runtime dependencies external.
+Node therefore resolves native-backed provider dependencies from their
+installed pnpm package context, while core and tenancy retain one server-side
+registry and async context. Mixed packages are split by export: server entries
+stay external, while Svelte and CSS entries remain in Vite's compiler graph.
+The generated consumer registration entrypoint loads transitive-only object
+modules through the configured provider's ESM resolution context. This avoids
+unresolvable app-root imports while preserving the exact model and collection
+constructors used by the provider. The Vite preset retains its narrower
+app-runtime split so SvelteKit control-flow classes keep app identity. This
+applies only to SSR; browser and Svelte component builds retain their normal
+bundled resolution.
+
 `ObjectRegistry.ensureManifestLoaded()` can now auto-load installed external
 classes by either simple name (`'EventType'`) or qualified name
 (`'@happyvertical/smrt-events:EventType'`). `SmrtCollection.list()` and

package/agents/build-knowledge.md

@@ -131,6 +131,9 @@ recorded `packageName` — a plain overwrite in either direction silently drops
 the other's objects, and the last pass of a multi-environment build is not
 reliably the aggregating one (#1760, #2925). `dist/manifest.json` stays
 local-only: a published package must not carry its dependencies' objects.
+Core's canonical generator excludes temporary `__test-*` source roots as well
+as test files and `__tests__`; prepack verifies fresh and reused manifests
+contain no test-artifact marker or fixture source provenance (#4190).
 
 The schema-version-1 object projection is additive and high-signal: it retains
 normalized tenant mode/field, explicit `cti`/`sti` strategy, conflict columns,

package/agents/cookbook-engine.md

@@ -28,7 +28,8 @@ engine.tools / engine.batchTool                      // JSON Schema tool definit
 - **Commands** (20, `COOKBOOK_COMMANDS_VERSION = 1`): `apply_cookbook` (select),
   `import_cookbook`, `add_cookbook`, `remove_cookbook`, `add_recipes`,
   `remove_recipes`, `add_features`, `remove_features`, `set_settings`,
-  `set_policy`, `set_theme`, `reset_theme`, `set_name`, `rename_section`,
+  `set_policy`, `set_theme`, `reset_theme`, `set_name` (name, description and `specs`, free-text requirements beyond
+  the recipes; internal newlines are kept), `rename_section`,
   `rename_item`, `hide`, `show`, `validate`, `export_cookbook`, `undo`. Navigation
   and focus are not commands: they are an adapter concern.
 - **`set_theme`** takes `preset`, `primary` (a brand colour that replaces the

package/dist/consumer-plugin/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/consumer-plugin/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,OAAO,KAAK,EAAa,MAAM,EAAE,MAAM,MAAM,CAAC;AAC9C,OAAO,EAEL,KAAK,6BAA6B,EACnC,MAAM,2BAA2B,CAAC;AAYnC,OAAO,EAGL,KAAK,gBAAgB,EACtB,MAAM,uCAAuC,CAAC;AAqB/C,OAAO,EACL,kCAAkC,EAClC,KAAK,sCAAsC,EAC3C,KAAK,8BAA8B,EACnC,KAAK,6BAA6B,EAClC,KAAK,0BAA0B,EAC/B,+BAA+B,EAC/B,4BAA4B,GAC7B,MAAM,2BAA2B,CAAC;AAqDnC;;;;GAIG;AACH,MAAM,WAAW,4BACf,SAAQ,OAAO,CACb,IAAI,CACF,gBAAgB,EACd,WAAW,GACX,YAAY,GACZ,YAAY,GACZ,gBAAgB,GAChB,aAAa,GACb,cAAc,GACd,aAAa,GACb,gBAAgB,CACnB,CACF;IACD,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;CAC5B;AAED,MAAM,WAAW,mBAAmB;IAClC,4EAA4E;IAC5E,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,uCAAuC;IACvC,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,2CAA2C;IAC3C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,oEAAoE;IACpE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,6BAA6B,CAAC;IACnD;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,GAAG,4BAA4B,CAAC;IACnD;;;;;OAKG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,oDAAoD;IACpD,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,4BAA4B;IAC5B,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAmXD;;GAEG;AACH,wBAAgB,YAAY,CAAC,OAAO,GAAE,mBAAwB,GAAG,MAAM,CAoYtE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/consumer-plugin/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,OAAO,KAAK,EAAa,MAAM,EAAE,MAAM,MAAM,CAAC;AAC9C,OAAO,EAEL,KAAK,6BAA6B,EACnC,MAAM,2BAA2B,CAAC;AAYnC,OAAO,EAGL,KAAK,gBAAgB,EACtB,MAAM,uCAAuC,CAAC;AAqB/C,OAAO,EACL,kCAAkC,EAClC,KAAK,sCAAsC,EAC3C,KAAK,8BAA8B,EACnC,KAAK,6BAA6B,EAClC,KAAK,0BAA0B,EAC/B,+BAA+B,EAC/B,4BAA4B,GAC7B,MAAM,2BAA2B,CAAC;AAsGnC;;;;GAIG;AACH,MAAM,WAAW,4BACf,SAAQ,OAAO,CACb,IAAI,CACF,gBAAgB,EACd,WAAW,GACX,YAAY,GACZ,YAAY,GACZ,gBAAgB,GAChB,aAAa,GACb,cAAc,GACd,aAAa,GACb,gBAAgB,CACnB,CACF;IACD,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;CAC5B;AAED,MAAM,WAAW,mBAAmB;IAClC,4EAA4E;IAC5E,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,uCAAuC;IACvC,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,2CAA2C;IAC3C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,oEAAoE;IACpE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,6BAA6B,CAAC;IACnD;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,GAAG,4BAA4B,CAAC;IACnD;;;;;OAKG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,oDAAoD;IACpD,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,4BAA4B;IAC5B,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAmXD;;GAEG;AACH,wBAAgB,YAAY,CAAC,OAAO,GAAE,mBAAwB,GAAG,MAAM,CA4lBtE"}

package/dist/consumer-plugin/index.js

@@ -18,6 +18,24 @@ import * as fs$1 from "node:fs";
 * Vite plugin for consuming SMRT packages
 * Solves virtual module resolution in downstream projects
 */
+var AmbiguousProviderGraphError = class extends Error {};
+function packageNameFromImportPath(importPath) {
+	const parts = importPath.split("/");
+	return importPath.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0] ?? importPath;
+}
+function findInstalledPackageJson(packageName, searchFrom) {
+	let currentDir = fs$1.existsSync(searchFrom) ? fs$1.realpathSync(searchFrom) : path$1.resolve(searchFrom);
+	while (true) {
+		const candidate = path$1.join(currentDir, "node_modules", packageName, "package.json");
+		if (fs$1.existsSync(candidate)) return fs$1.realpathSync(candidate);
+		const parentDir = path$1.dirname(currentDir);
+		if (parentDir === currentDir) return void 0;
+		currentDir = parentDir;
+	}
+}
+function sameInstalledPackage(left, right) {
+	return Boolean(left && right && fs$1.realpathSync(left) === fs$1.realpathSync(right));
+}
 var VIRTUAL_MODULES = {
 	"@smrt/routes": "smrt-consumer:routes",
 	"@smrt/client": "smrt-consumer:client",
@@ -192,6 +210,8 @@ function smrtConsumer(options = {}) {
 	let typesGenerated = false;
 	let producerApi;
 	let routeLifecycleConfig;
+	let isBuild = false;
+	let selectiveSsrPackages = /* @__PURE__ */ new Map();
 	function loadGenerationSnapshot() {
 		if (!generationSnapshot) throw new Error("[smrt:consumer] Generation snapshot is not configured");
 		return withHostedStiCollections(loadVerifiedSmrtGenerationSnapshot(generationSnapshot, projectRoot, "dependencies"));
@@ -222,6 +242,101 @@ function smrtConsumer(options = {}) {
 			explicit: packages.length > 0
 		};
 	}
+	/**
+	* Keep consumed providers and their SMRT runtime graph in Node's installed
+	* package context during SSR. Native-backed dependencies (such as sharp)
+	* resolve relative to that context, and keeping core/tenancy alongside the
+	* provider prevents the server bundle from creating a second registry or
+	* AsyncLocalStorage instance.
+	*/
+	function resolveConsumerSsrExternalPackages(providerPackages) {
+		const needsViteCompilation = (value) => {
+			if (typeof value === "string") return value.endsWith(".svelte") || value.endsWith(".css");
+			if (!value || typeof value !== "object") return false;
+			return Object.entries(value).some(([condition, target]) => condition === "svelte" || needsViteCompilation(target));
+		};
+		const external = /* @__PURE__ */ new Set();
+		const selective = /* @__PURE__ */ new Map();
+		const visited = /* @__PURE__ */ new Set();
+		const pending = providerPackages.map((packageName) => ({
+			packageName,
+			searchFrom: projectRoot
+		}));
+		while (pending.length > 0) {
+			const candidate = pending.pop();
+			if (!candidate) continue;
+			const { packageName, searchFrom } = candidate;
+			const packageJsonPath = findInstalledPackageJson(packageName, searchFrom);
+			const visitKey = packageJsonPath ?? `${searchFrom}\0${packageName}`;
+			if (visited.has(visitKey)) continue;
+			visited.add(visitKey);
+			let packageJson;
+			if (packageJsonPath) try {
+				packageJson = JSON.parse(fs$1.readFileSync(packageJsonPath, "utf8"));
+			} catch {}
+			const needsSvelteCompilation = typeof packageJson?.svelte === "string" || needsViteCompilation(packageJson?.exports);
+			const isAppResolvable = sameInstalledPackage(packageJsonPath, findInstalledPackageJson(packageName, projectRoot));
+			if (packageName !== "@happyvertical/smrt-app-runtime" && isAppResolvable) if (needsSvelteCompilation && packageJson) selective.set(packageName, {
+				packageJson,
+				packageRoot: path$1.dirname(packageJsonPath)
+			});
+			else external.add(packageName);
+			if (!packageJsonPath || !packageJson) continue;
+			for (const dependencies of [
+				packageJson.dependencies,
+				packageJson.optionalDependencies,
+				packageJson.peerDependencies
+			]) for (const dependency of Object.keys(dependencies ?? {})) if (dependency.startsWith("@happyvertical/smrt-")) pending.push({
+				packageName: dependency,
+				searchFrom: path$1.dirname(packageJsonPath)
+			});
+		}
+		return {
+			external: [...external].sort(),
+			selective
+		};
+	}
+	function matchingExportTarget(exports, exportKey) {
+		if (!exports) return void 0;
+		if (typeof exports === "string") return exportKey === "." ? { target: exports } : void 0;
+		if (typeof exports !== "object") return void 0;
+		const exportMap = exports;
+		if (exportKey in exportMap) return { target: exportMap[exportKey] };
+		if (exportKey === "." && !Object.keys(exportMap).some((key) => key.startsWith("."))) return { target: exportMap };
+		for (const [pattern, target] of Object.entries(exportMap)) {
+			const wildcardIndex = pattern.indexOf("*");
+			if (wildcardIndex < 0) continue;
+			const prefix = pattern.slice(0, wildcardIndex);
+			const suffix = pattern.slice(wildcardIndex + 1);
+			if (exportKey.startsWith(prefix) && exportKey.endsWith(suffix)) return {
+				target,
+				wildcard: exportKey.slice(prefix.length, exportKey.length - suffix.length)
+			};
+		}
+	}
+	function svelteConditionTargets(value) {
+		if (!value || typeof value !== "object") return [];
+		return Object.entries(value).flatMap(([condition, target]) => {
+			if (condition === "svelte") {
+				if (typeof target === "string") return [target];
+				return svelteConditionTargets(target);
+			}
+			return svelteConditionTargets(target);
+		});
+	}
+	function resolvesToSvelteCondition(packageName, packageJson, packageRoot, id, resolvedId) {
+		if (!resolvedId) return false;
+		const exportKey = id === packageName ? "." : `./${id.slice(packageName.length + 1)}`;
+		const matched = matchingExportTarget(packageJson.exports, exportKey);
+		const targets = matched ? svelteConditionTargets(matched.target) : [];
+		if (exportKey === "." && typeof packageJson.svelte === "string") targets.push(packageJson.svelte);
+		const normalizedResolved = resolvedId.split("?")[0];
+		const canonical = (candidate) => fs$1.existsSync(candidate) ? fs$1.realpathSync(candidate) : path$1.resolve(candidate);
+		return targets.some((target) => {
+			const substituted = matched?.wildcard ? target.replaceAll("*", matched.wildcard) : target;
+			return canonical(path$1.resolve(packageRoot, substituted)) === canonical(normalizedResolved);
+		});
+	}
 	async function generateConfigTypes(manifest) {
 		if (!generateTypes || typesGenerated) return;
 		if (manifest) typeManifest = manifest;
@@ -241,11 +356,14 @@ function smrtConsumer(options = {}) {
 			async handler(userConfig, env) {
 				const routeLifecycle = env ?? userConfig;
 				routeLifecycleConfig = routeLifecycle;
+				const consumerPackages = await resolveConsumerPackages();
+				isBuild = env?.command === "build";
+				const ssrResolution = resolveConsumerSsrExternalPackages(consumerPackages.names);
+				selectiveSsrPackages = ssrResolution.selective;
 				const previousConsumerRouteRoots = loadConsumerSvelteKitRouteRoots(projectRoot);
 				if (consumerSvelteKit) {
 					await assertConsumerSvelteKitFormerRouteRootsAreSafe(userConfig, projectRoot, previousConsumerRouteRoots, env);
-					const routePackages = await resolveConsumerPackages();
-					const routeManifest = generationSnapshot ? loadGenerationSnapshot() : await aggregateHosted(routePackages.names, projectRoot, { explicit: routePackages.explicit });
+					const routeManifest = generationSnapshot ? loadGenerationSnapshot() : await aggregateHosted(consumerPackages.names, projectRoot, { explicit: consumerPackages.explicit });
 					const hostedManifest = selectConsumerRouteManifest(routeManifest, consumerSvelteKit);
 					const routesDir = canonicalConsumerRouteRoot(projectRoot, consumerSvelteKit.routesDir ?? "src/routes/api");
 					const reservedRoutePaths = await activeProducerKnowledgeRoutePaths(userConfig, projectRoot, env);
@@ -288,7 +406,13 @@ function smrtConsumer(options = {}) {
 					if (options.svelteKit && typeManifest) await generateRegistrationFile(typeManifest, projectRoot);
 					if (previousConsumerRouteRoots.length > 0) await reconcileConsumerSvelteKitRouteRoots(routeLifecycle, userConfig, projectRoot, previousConsumerRouteRoots, () => removeConsumerSvelteKitRouteRoots(projectRoot), env);
 				}
-				return { build: { rollupOptions: { external: [/\.node$/] } } };
+				return {
+					ssr: {
+						external: ssrResolution.external,
+						noExternal: [...selectiveSsrPackages.keys()].sort()
+					},
+					build: { rollupOptions: { external: [/\.node$/] } }
+				};
 			}
 		},
 		configResolved(resolvedConfig) {
@@ -328,7 +452,21 @@ function smrtConsumer(options = {}) {
 				};
 			}
 		},
-		resolveId(id, _importer) {
+		async resolveId(id, importer, resolveOptions) {
+			if (isBuild && resolveOptions.ssr) for (const [packageName, selectivePackage] of selectiveSsrPackages) {
+				if (id !== packageName && !id.startsWith(`${packageName}/`)) continue;
+				const resolved = await this.resolve(id, importer, {
+					...resolveOptions,
+					skipSelf: true
+				});
+				const compile = resolved?.id.endsWith(".svelte") || resolved?.id.endsWith(".css");
+				const compileSvelteBarrel = resolvesToSvelteCondition(packageName, selectivePackage.packageJson, selectivePackage.packageRoot, id, resolved?.id);
+				if (!compile && !compileSvelteBarrel) return {
+					id,
+					external: true
+				};
+				break;
+			}
 			if (id in VIRTUAL_MODULES) {
 				if (id !== "@smrt/types") return `\0${VIRTUAL_MODULES[id]}`;
 				const typeFileName = getTypeFileName(id);
@@ -467,11 +605,17 @@ async function aggregateTypeManifests(packages, projectRoot, options = {}) {
 		objects: {}
 	};
 	const unresolvedPackages = [];
+	const objectSources = /* @__PURE__ */ new Map();
 	for (const packageName of packages) {
 		let loadedManifest = false;
 		try {
-			const packageDir = path$1.join(projectRoot, "node_modules", packageName);
-			const packageJsonPath = path$1.join(packageDir, "package.json");
+			const packageJsonPath = findInstalledPackageJson(packageName, projectRoot);
+			if (!packageJsonPath) {
+				console.warn(`[smrt:consumer] Could not read package.json for ${packageName}`);
+				unresolvedPackages.push(packageName);
+				continue;
+			}
+			const packageDir = path$1.dirname(packageJsonPath);
 			let packageJson;
 			try {
 				const packageJsonContent = fs$1.readFileSync(packageJsonPath, "utf-8");
@@ -500,11 +644,20 @@ async function aggregateTypeManifests(packages, projectRoot, options = {}) {
 					console.log(`[smrt:consumer] Loaded manifest from ${packageName} (${Object.keys(manifest.objects).length} objects)`);
 					for (const [objectName, objectDef] of Object.entries(manifest.objects)) {
 						const def = objectDef;
+						const importPath = def.importPath || determineImportPath(packageJson);
+						const importPackageName = importPath.startsWith("@") ? importPath.split("/").slice(0, 2).join("/") : importPath.split("/")[0];
+						const resolvedSourcePackageJson = (importPackageName === packageName ? packageJsonPath : void 0) ?? findInstalledPackageJson(importPackageName, packageDir);
+						const sourceIdentity = resolvedSourcePackageJson ? fs$1.realpathSync(resolvedSourcePackageJson) : `${packageName}\0${importPackageName}`;
+						const priorSource = objectSources.get(objectName);
+						if (priorSource && priorSource !== sourceIdentity) throw new AmbiguousProviderGraphError(`[smrt:consumer] ${objectName} is contributed by multiple installed provider graphs; refusing ambiguous constructor identity`);
+						if (priorSource) continue;
+						objectSources.set(objectName, sourceIdentity);
 						aggregatedManifest.objects[objectName] = {
 							...def,
 							packageName: def.packageName || manifest.packageName || packageName,
 							packageVersion: def.packageVersion || manifest.packageVersion || packageJson.version,
-							importPath: def.importPath || determineImportPath(packageJson),
+							importPath,
+							providerPackageName: packageName,
 							exportName: def.exportName || def.className || objectName,
 							collectionExportName: def.collectionExportName || `${def.className || objectName}Collection`
 						};
@@ -514,6 +667,7 @@ async function aggregateTypeManifests(packages, projectRoot, options = {}) {
 				}
 			}
 		} catch (error) {
+			if (error instanceof AmbiguousProviderGraphError) throw error;
 			console.warn(`[smrt:consumer] Error loading manifest from ${packageName}:`, error);
 		}
 		if (!loadedManifest) unresolvedPackages.push(packageName);
@@ -619,6 +773,9 @@ async function generateRegistrationFile(manifest, projectRoot) {
 	const registerPath = path$1.join(smrtDir, "register.js");
 	const importBindings = /* @__PURE__ */ new Map();
 	const importsByPath = /* @__PURE__ */ new Map();
+	const transitiveNamespaces = /* @__PURE__ */ new Map();
+	const transitiveBindings = /* @__PURE__ */ new Map();
+	const transitiveCollectionChecks = [];
 	let nextImportBinding = 0;
 	const getImportBinding = (importPath, exportName) => {
 		const key = `${importPath}\0${exportName}`;
@@ -631,6 +788,37 @@ async function generateRegistrationFile(manifest, projectRoot) {
 		importsByPath.set(importPath, specifiers);
 		return binding;
 	};
+	const getTransitiveBinding = (importPath, providerPackageName, exportName) => {
+		const namespaceKey = `${providerPackageName}\0${importPath}`;
+		let namespace = transitiveNamespaces.get(namespaceKey);
+		if (!namespace) {
+			namespace = {
+				binding: `__smrt_transitive_provider_${transitiveNamespaces.size}`,
+				providerPackageName,
+				importPath
+			};
+			transitiveNamespaces.set(namespaceKey, namespace);
+		}
+		const key = `${namespaceKey}\0${exportName}`;
+		const existing = transitiveBindings.get(key);
+		if (existing) return existing.binding;
+		const binding = `__smrt_consumer_${nextImportBinding++}`;
+		transitiveBindings.set(key, {
+			binding,
+			namespaceBinding: namespace.binding,
+			exportName
+		});
+		return binding;
+	};
+	const isSameProjectAndProviderImport = (importPath, providerPackageName) => {
+		const importPackageName = packageNameFromImportPath(importPath);
+		const projectPackageJson = findInstalledPackageJson(importPackageName, projectRoot);
+		if (!providerPackageName) return Boolean(projectPackageJson);
+		const providerPackageJson = findInstalledPackageJson(providerPackageName, projectRoot);
+		if (!providerPackageJson) return false;
+		return sameInstalledPackage(projectPackageJson, importPackageName === providerPackageName ? providerPackageJson : findInstalledPackageJson(importPackageName, path$1.dirname(providerPackageJson)));
+	};
+	for (const packageName of manifest.smrtDependencies ?? []) if (isSameProjectAndProviderImport(packageName, packageName) && !importsByPath.has(packageName)) importsByPath.set(packageName, /* @__PURE__ */ new Map());
 	const registrations = [];
 	const registrationManifests = {};
 	let importedEntryCount = 0;
@@ -676,8 +864,16 @@ async function generateRegistrationFile(manifest, projectRoot) {
 		const collectionExportName = def.collectionExportName;
 		const hasCollection = def.hasCollection;
 		const tableName = def.collection || objectName.toLowerCase();
-		const exportBinding = getImportBinding(importPath, exportName);
-		const collectionBinding = hasCollection && collectionExportName ? getImportBinding(importPath, collectionExportName) : void 0;
+		const qualifiedName = def.qualifiedName || (objectName.includes(":") ? objectName : `${def.packageName}:${def.className || exportName}`);
+		const providerPackageName = def.providerPackageName;
+		const appResolvable = isSameProjectAndProviderImport(importPath, providerPackageName);
+		if (!appResolvable && !providerPackageName) throw new Error(`[smrt:consumer] ${objectName} has no configured provider provenance for ${importPath}`);
+		const exportBinding = appResolvable ? getImportBinding(importPath, exportName) : getTransitiveBinding(importPath, providerPackageName, exportName);
+		const collectionBinding = hasCollection && collectionExportName ? appResolvable ? getImportBinding(importPath, collectionExportName) : getTransitiveBinding(importPath, providerPackageName, collectionExportName) : void 0;
+		if (!appResolvable && collectionBinding) transitiveCollectionChecks.push({
+			collectionBinding,
+			itemBinding: exportBinding
+		});
 		importedEntryCount++;
 		if (isCollectionClass(def)) continue;
 		const logicalName = def.className || exportName;
@@ -688,7 +884,10 @@ async function generateRegistrationFile(manifest, projectRoot) {
 			objects: { [objectName]: def }
 		};
 		registrations.push(`if (${exportBinding}) ObjectRegistry.register(${exportBinding}, { name: ${JSON.stringify(logicalName)}, packageName: ${JSON.stringify(def.packageName)}, _manifest: smrtRegistrationManifests[${JSON.stringify(objectName)}], _manifestKey: ${JSON.stringify(objectName)} });`);
-		if (collectionBinding) registrations.push(`if (${collectionBinding}) ObjectRegistry.registerCollection('${tableName}', ${collectionBinding});`);
+		if (collectionBinding) registrations.push(`if (${collectionBinding}) {
+  ObjectRegistry.registerCollection(${JSON.stringify(qualifiedName)}, ${collectionBinding});
+  ObjectRegistry.registerCollection(${JSON.stringify(tableName)}, ${collectionBinding});
+}`);
 		registeredObjectCount++;
 	}
 	if (importedEntryCount === 0) {
@@ -699,6 +898,10 @@ async function generateRegistrationFile(manifest, projectRoot) {
 	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 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 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');`);
 	const registrationManifestLiteral = JSON.stringify(JSON.stringify(registrationManifests));
 	const content = `/**
  * Auto-generated by @happyvertical/smrt-core/consumer-plugin
@@ -709,6 +912,7 @@ async function generateRegistrationFile(manifest, projectRoot) {
  */
 
 import { ObjectRegistry } from '@happyvertical/smrt-core';
+${transitiveNamespaces.size > 0 ? "import { registerHooks } from 'node:module';" : ""}
 
 ${imports.join("\n")}
 
@@ -719,7 +923,30 @@ ${imports.join("\n")}
  */
 const getSmrtExport = (provider, exportName) =>
   typeof provider[exportName] === 'function' ? provider[exportName] : undefined;
+${transitiveNamespaces.size > 0 ? `const SMRT_RESOLVER_MODULE = 'data:text/javascript,export default (specifier) => import.meta.resolve(specifier)';
+let smrtResolverToken = 0;
+const importSmrtDependency = async (specifier, providerPackageName) => {
+  const parentURL = import.meta.resolve(providerPackageName);
+  const token = \`smrt-consumer-resolve-\${smrtResolverToken++}\`;
+  const hooks = registerHooks({
+    resolve(requested, context, nextResolve) {
+      return requested === token
+        ? nextResolve(specifier, { ...context, parentURL })
+        : nextResolve(requested, context);
+    },
+  });
+  try {
+    const resolver = (await import(/* @vite-ignore */ SMRT_RESOLVER_MODULE)).default;
+    return import(/* @vite-ignore */ resolver(token));
+  } finally {
+    hooks.deregister();
+  }
+};
+` : ""}
+${transitiveNamespaceDeclarations.join("\n")}
 ${importDeclarations.join("\n")}
+${transitiveDeclarations.join("\n")}
+${transitiveCollectionDeclarations.join("\n")}
 
 const smrtRegistrationManifests = JSON.parse(${registrationManifestLiteral});