@happyvertical/smrt-core 0.51.6 → 0.51.8

package/README.md

@@ -191,6 +191,32 @@ generates routes, types, registration, and virtual modules, but it disables
 source/package scans, watch rescans, and manifest writes. Omit
 `generationSnapshot` for normal local development.
 
+#### Where consumer manifests are resolved
+
+`smrtConsumer()` resolves each consumed package's manifest through that
+package's own `package.json#exports` map first — the `./manifest.json` entry
+(or its `./manifest` alias), which every s-m-r-t model package is required
+to publish — and only then falls back to the conventional
+`dist/manifest/static-manifest.js`, `dist/manifest.json`, and `manifest.json`
+paths. A package whose build emits elsewhere (for example a triple-purpose
+package that maps `"./manifest.json": "./dist/lib/manifest.json"`) therefore
+loads normally.
+
+Every declared target is a candidate, not a single choice: an export array is
+a fallback list and each recognized condition contributes its own target, so a
+missing first entry does not hide a valid later one. Candidates are probed in
+order and the first one that loads wins, so a candidate that exists but cannot
+be read, parsed, or imported is reported and skipped rather than ending the
+search — the conventional paths stay reachable behind a stale or malformed
+export target. Targets that resolve outside the package directory are dropped,
+both lexically and after following symlinks; the package root is itself
+resolved through symlinks first, so pnpm and workspace installs are unaffected.
+
+A package that yields no usable manifest is never skipped silently. An entry in
+an explicit `packages` list is an assertion, so it fails the build by name;
+a package found by dependency-name discovery only warns by name and contributes
+no objects.
+
 #### Consumer web collection definitions
 
 `smrtConsumer()` also resolves `@smrt/web` for browser collection consumers:

package/agents/build-knowledge.md

@@ -36,6 +36,19 @@ owned by each consumer.
 Keep `manifest.json` runtime-focused. `smrt-knowledge.json` is the deterministic
 agent contract for downstream review and architecture tools.
 
+The CLI's schema-command gate reads that same merged file: a pure-consumer
+project (0 local objects) qualifies on the consumed packages its manifest
+records, so a clobbered `objects` map is what made `smrt db:migrate` report
+`missing_local_manifest` (#2925).
+
+`.smrt/manifest.json` has two writers and neither owns all of it: `smrtPlugin()`
+contributes the project's scanned objects and `smrtConsumer()` the consumed
+packages' entries. Both writes are merge-preserving, keyed on each entry's
+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.
+
 The schema-version-1 object projection is additive and high-signal: it retains
 normalized tenant mode/field, explicit `cti`/`sti` strategy, conflict columns,
 method signatures, and field defaults/constraints/readonly/transient flags.

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;AAWnC,OAAO,EAGL,KAAK,gBAAgB,EACtB,MAAM,uCAAuC,CAAC;AAoB/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,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;AA0VD;;GAEG;AACH,wBAAgB,YAAY,CAAC,OAAO,GAAE,mBAAwB,GAAG,MAAM,CAqVtE"}
+{"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;AAoB/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,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;AA0VD;;GAEG;AACH,wBAAgB,YAAY,CAAC,OAAO,GAAE,mBAAwB,GAAG,MAAM,CAqWtE"}

package/dist/consumer-plugin/index.js

@@ -3,6 +3,7 @@ import { canonicalSvelteKitPath } from "../vite-plugin/sveltekit-path.js";
 import { clearGeneratedSvelteKitRouteFiles, reconcileSvelteKitRouteGitignore } from "../vite-plugin/sveltekit-generator.js";
 import { generateWebModule, isCollectionManifestClass, resolveCollectionItemObject } from "../vite-plugin/web-collections.js";
 import { buildDomainKnowledgeManifest } from "../knowledge.js";
+import { manifestExportCandidates } from "../manifest/package-manifest-exports.js";
 import { loadVerifiedSmrtGenerationSnapshot, serializeSmrtGenerationSnapshot, sha256SmrtGenerationSnapshot } from "../generation-snapshot.js";
 import { resolveFileKnowledgeConfig } from "../knowledge-config.js";
 import { generateClientModule } from "../vite-plugin/generated-client.js";
@@ -181,9 +182,29 @@ function smrtConsumer(options = {}) {
 		if (!generationSnapshot) throw new Error("[smrt:consumer] Generation snapshot is not configured");
 		return loadVerifiedSmrtGenerationSnapshot(generationSnapshot, projectRoot, "dependencies");
 	}
+	/**
+	* Resolve the packages to aggregate, and whether that list was asserted by
+	* the consumer's config. An explicit list fails closed when a package
+	* yields no manifest; a heuristically discovered one only warns.
+	*/
+	async function resolveConsumerPackages() {
+		if (packages.length === 0 && !disableScanning) return {
+			names: await discoverSmrtPackages(projectRoot),
+			explicit: false
+		};
+		return {
+			names: packages,
+			explicit: packages.length > 0
+		};
+	}
 	async function generateConfigTypes(manifest) {
 		if (!generateTypes || typesGenerated) return;
-		typeManifest = manifest ?? (generationSnapshot ? loadGenerationSnapshot() : await aggregateTypeManifests(packages.length === 0 && !disableScanning ? await discoverSmrtPackages(projectRoot) : packages, projectRoot));
+		if (manifest) typeManifest = manifest;
+		else if (generationSnapshot) typeManifest = loadGenerationSnapshot();
+		else {
+			const resolved = await resolveConsumerPackages();
+			typeManifest = await aggregateTypeManifests(resolved.names, projectRoot, { explicit: resolved.explicit });
+		}
 		await generateProjectTypes(typeManifest, typesDir, projectRoot);
 		typesGenerated = true;
 	}
@@ -198,8 +219,8 @@ function smrtConsumer(options = {}) {
 				const previousConsumerRouteRoots = loadConsumerSvelteKitRouteRoots(projectRoot);
 				if (consumerSvelteKit) {
 					await assertConsumerSvelteKitFormerRouteRootsAreSafe(userConfig, projectRoot, previousConsumerRouteRoots, env);
-					const routePackages = packages.length === 0 && !disableScanning ? await discoverSmrtPackages(projectRoot) : packages;
-					const routeManifest = generationSnapshot ? loadGenerationSnapshot() : await aggregateTypeManifests(routePackages, projectRoot);
+					const routePackages = await resolveConsumerPackages();
+					const routeManifest = generationSnapshot ? loadGenerationSnapshot() : await aggregateTypeManifests(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);
@@ -259,11 +280,11 @@ function smrtConsumer(options = {}) {
 				}
 				return;
 			}
-			if (packages.length === 0 && !disableScanning) smrtPackages = await discoverSmrtPackages(projectRoot);
-			else smrtPackages = packages;
+			const resolvedPackages = await resolveConsumerPackages();
+			smrtPackages = resolvedPackages.names;
 			if (smrtPackages.length > 0) {
 				console.log(`[smrt:consumer] Found SMRT packages: ${smrtPackages.join(", ")}`);
-				typeManifest = await aggregateTypeManifests(smrtPackages, projectRoot);
+				typeManifest = await aggregateTypeManifests(smrtPackages, projectRoot, { explicit: resolvedPackages.explicit });
 				const agentSurface = producerApi ? await producerApi.resolveKnowledgeAgentSurface() : void 0;
 				await saveAggregatedManifest(typeManifest, projectRoot, producerApi?.resolveKnowledgeConfig, agentSurface);
 				await generateRegistrationFile(typeManifest, projectRoot);
@@ -343,66 +364,137 @@ async function discoverSmrtPackages(projectRoot) {
 	return packages;
 }
 /**
-* Check if a package has SMRT manifest
+* Manifest locations probed for a consumed package, in preference order.
+*
+* The package's own `package.json#exports` map comes first: it is the
+* published contract for where the manifest lives, and a package whose build
+* emits outside this framework's conventional layout (for example
+* `"./manifest.json": "./dist/lib/manifest.json"`) is otherwise skipped
+* entirely (issue #2923). The conventional paths remain as a fallback for
+* packages that ship a manifest without exporting a subpath for it.
+*/
+function legacyStaticManifestPath(packageDir) {
+	return path.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")
+	];
+}
+/**
+* Whether a dependency looks like a SMRT package, for the name-heuristic
+* discovery path only.
+*
+* This decides whether a package this framework knows nothing about is pulled
+* into aggregation at all, so mere existence of a manifest-shaped file is not
+* enough: `manifest.json` at a package root or `dist/manifest.json` is a
+* common artifact of unrelated tooling (Vite build manifests, PWA and
+* extension manifests). A false positive would announce a stranger under
+* "Found SMRT packages", tell the user to publish a manifest for a package
+* that has nothing to do with SMRT, and — for a JS candidate — evaluate that
+* dependency's module inside the build.
+*
+* A JSON candidate is therefore confirmed by parsing it and requiring
+* `moduleType: 'smrt'`, matching what build-time discovery requires. A JS
+* candidate cannot be identified without importing it, which is the thing
+* being avoided, so only the historical `dist/manifest/static-manifest.js`
+* location counts — exactly the probe this function used before #2923.
 */
 async function hasSmrtManifest(nodeModulesPath, packageName) {
 	const packagePath = path.join(nodeModulesPath, packageName);
-	const manifestPath = path.join(packagePath, "dist", "manifest", "static-manifest.js");
-	return fs.existsSync(manifestPath);
+	const legacyStaticManifest = legacyStaticManifestPath(packagePath);
+	for (const manifestPath of packageManifestCandidates(packagePath)) {
+		if (!fs.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;
+		} catch {}
+	}
+	return false;
 }
 /**
-* Aggregate type manifests from multiple packages
+* Aggregate type manifests from multiple packages.
+*
+* A package that yields no usable manifest is never dropped silently
+* (issue #2923): an explicitly listed package fails the build, and a
+* heuristically discovered one warns by name. Silence here surfaces much
+* later as missing tables, routes, and generated types with nothing in the
+* build log to connect them to the package that was skipped.
+*
+* @param packages - Package names to aggregate.
+* @param projectRoot - Consumer project root containing `node_modules`.
+* @param options - `explicit` marks a caller-supplied `packages` list, whose
+*   entries are assertions rather than guesses and therefore fail closed.
 */
-async function aggregateTypeManifests(packages, projectRoot) {
+async function aggregateTypeManifests(packages, projectRoot, options = {}) {
 	const aggregatedManifest = {
 		version: "1.0.0",
 		timestamp: 0,
 		smrtDependencies: [...packages],
 		objects: {}
 	};
-	for (const packageName of packages) try {
-		const packageDir = path.join(projectRoot, "node_modules", packageName);
-		const packageJsonPath = path.join(packageDir, "package.json");
-		let packageJson;
+	const unresolvedPackages = [];
+	for (const packageName of packages) {
+		let loadedManifest = false;
 		try {
-			const packageJsonContent = fs.readFileSync(packageJsonPath, "utf-8");
-			packageJson = JSON.parse(packageJsonContent);
-		} catch {
-			console.warn(`[smrt:consumer] Could not read package.json for ${packageName}`);
-			continue;
-		}
-		const manifestCandidates = [
-			path.join(packageDir, "dist", "manifest", "static-manifest.js"),
-			path.join(packageDir, "dist", "manifest.json"),
-			path.join(packageDir, "manifest.json")
-		];
-		for (const manifestPath of manifestCandidates) if (fs.existsSync(manifestPath)) {
-			let manifest;
-			if (manifestPath.endsWith(".js")) {
-				const manifestModule = await import(manifestPath);
-				manifest = manifestModule.staticManifest || manifestModule.default;
-			} else {
-				const manifestContent = fs.readFileSync(manifestPath, "utf-8");
-				manifest = JSON.parse(manifestContent);
+			const packageDir = path.join(projectRoot, "node_modules", packageName);
+			const packageJsonPath = path.join(packageDir, "package.json");
+			let packageJson;
+			try {
+				const packageJsonContent = fs.readFileSync(packageJsonPath, "utf-8");
+				packageJson = JSON.parse(packageJsonContent);
+			} catch {
+				console.warn(`[smrt:consumer] Could not read package.json for ${packageName}`);
+				unresolvedPackages.push(packageName);
+				continue;
 			}
-			if (manifest?.objects) {
-				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;
-					aggregatedManifest.objects[objectName] = {
-						...def,
-						packageName: def.packageName || manifest.packageName || packageName,
-						packageVersion: def.packageVersion || manifest.packageVersion || packageJson.version,
-						importPath: def.importPath || determineImportPath(packageJson),
-						exportName: def.exportName || def.className || objectName,
-						collectionExportName: def.collectionExportName || `${def.className || objectName}Collection`
-					};
+			const manifestCandidates = packageManifestCandidates(packageDir, packageJson);
+			for (const manifestPath of manifestCandidates) if (fs.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");
+						manifest = JSON.parse(manifestContent);
+					}
+				} catch (error) {
+					console.warn(`[smrt:consumer] Could not load manifest candidate ${manifestPath} for ${packageName}; trying the next location:`, error);
+					continue;
+				}
+				if (manifest?.objects) {
+					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;
+						aggregatedManifest.objects[objectName] = {
+							...def,
+							packageName: def.packageName || manifest.packageName || packageName,
+							packageVersion: def.packageVersion || manifest.packageVersion || packageJson.version,
+							importPath: def.importPath || determineImportPath(packageJson),
+							exportName: def.exportName || def.className || objectName,
+							collectionExportName: def.collectionExportName || `${def.className || objectName}Collection`
+						};
+					}
+					loadedManifest = true;
+					break;
 				}
-				break;
 			}
+		} catch (error) {
+			console.warn(`[smrt:consumer] Error loading manifest from ${packageName}:`, error);
 		}
-	} catch (error) {
-		console.warn(`[smrt:consumer] Error loading manifest from ${packageName}:`, error);
+		if (!loadedManifest) unresolvedPackages.push(packageName);
+	}
+	if (unresolvedPackages.length > 0) {
+		const named = unresolvedPackages.join(", ");
+		if (options.explicit) throw new Error(`[smrt:consumer] No SMRT manifest could be resolved for ${named}. Listed packages must publish a manifest through package.json#exports ("./manifest.json") or at dist/manifest.json, dist/manifest/static-manifest.js, or manifest.json. Build the package, or remove it from smrtConsumer({ packages }).`);
+		console.warn(`[smrt:consumer] No SMRT manifest could be resolved for ${named}; contributing 0 objects. If the package provides SMRT objects, publish its manifest through package.json#exports ("./manifest.json").`);
 	}
 	return aggregatedManifest;
 }