@happyvertical/smrt-core 0.49.4 → 0.49.6

package/README.md

@@ -191,12 +191,77 @@ generates routes, types, registration, and virtual modules, but it disables
 source/package scans, watch rescans, and manifest writes. Omit
 `generationSnapshot` for normal local development.
 
+#### Consumer web collection definitions
+
+`smrtConsumer()` also resolves `@smrt/web` for browser collection consumers:
+
+```typescript
+import { collectionDefinitions, getCollectionDefinition } from '@smrt/web';
+```
+
+The module projects the consumer's aggregated dependency manifest through the
+same web-definition generator as `smrtPlugin()`. Each definition retains its
+provider-qualified `objectRef` (for example, `@acme/widgets:Widget`) and its
+manifest-derived fields, actions, relationships, WebMCP descriptors, and
+`manifestHash`. Consumer snapshots select the dependency view, so local project
+objects are not included. During declaration generation the matching
+`smrt-web.d.ts` module is written alongside the other consumer virtual modules.
+
 ### Generated SvelteKit routes
 
 Enable SvelteKit route generation with `svelteKit: { enabled: true }`. Its
 default output directory is `src/routes/api`; set `svelteKit.routesDir` when
 your application uses a different route root.
 
+A consumer can host selected dependency models with the same generator. This is
+an explicit HTTP boundary that is separate from the broader `packages`
+registration inventory. Name exact provider-qualified object references; a
+simple class name, an unknown object, or an empty list fails the build before
+any generated route is replaced:
+
+```ts
+smrtConsumer({
+  packages: runtimeProviderPackages,
+  svelteKit: {
+    objects: ['@acme/widgets:Widget'],
+    routesDir: 'src/routes/api',
+  },
+});
+```
+
+`projectRoot` selects one artifact root for consumer route generation,
+registration, manifests, and types; it defaults to the current working
+directory. It remains the consumer artifact root when a Vite config declares a
+different `root`; pass `projectRoot` explicitly when consumer artifacts should
+share that Vite root or belong elsewhere.
+
+Only the listed objects are passed to route generation, so another API model in
+the same provider remains absent until it is named. `api: false` and an empty
+`api.include` still suppress handlers, and generated auth, writable-field, and
+tenant safeguards are unchanged. `svelteKit: true` remains a legacy consumer
+integration flag and does not host dependency CRUD routes. Consumer-hosted
+`_changes`, `_events`, and `_resources` routes are disabled unless their
+existing option is explicitly enabled; `sync/apply` is generated when a selected model exposes a mutating API
+action.
+
+When `smrtPlugin()` and `smrtConsumer()` generate routes in one SvelteKit
+application, they may use the same canonical `routesDir` and share one
+generated surface, or use disjoint directories. Nested directories are
+rejected before files are changed because a parent generated-root cleanup would
+otherwise own and remove the child surface.
+Canonical ownership resolves symlink aliases through the nearest existing
+directory, so paths that name the same generated directory share one surface.
+When separate artifact roots resolve to that same route directory, their
+resolved object and config outputs must also agree; incompatible settings fail
+before generated handlers or managed ownership records change.
+
+The consumer keeps a private managed-root inventory under `.smrt` after a
+successful explicit hosting plan is validated. Changing its `routesDir`,
+setting `svelteKit: false`, returning to legacy `svelteKit: true`, or omitting
+the option reconciles only consumer-managed generated handlers before SvelteKit
+inventories routes. Handwritten handlers and current producer-owned routes are
+preserved.
+
 The plugin records only the concrete `+server.ts` files it generated in a
 bounded `.gitignore` block. Handwritten handlers below `routesDir` remain
 visible to Git, including routes that live beside generated resource handlers.

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

@@ -1,6 +1,15 @@
 import { Plugin } from 'vite';
 import { SmrtGenerationSnapshotOptions } from '../generation-snapshot.js';
+import { SvelteKitOptions } from '../vite-plugin/sveltekit-generator.js';
 export { loadVerifiedSmrtGenerationSnapshot, type SerializeSmrtGenerationSnapshotOptions, type SmrtGenerationSnapshotArtifact, type SmrtGenerationSnapshotOptions, type SmrtGenerationSnapshotView, serializeSmrtGenerationSnapshot, sha256SmrtGenerationSnapshot, } from '../generation-snapshot.js';
+/**
+ * SvelteKit route-hosting options for dependency models. Unlike `packages`,
+ * `objects` is an HTTP exposure boundary: every entry must be an exact,
+ * provider-qualified manifest key (for example, `@acme/widgets:Widget`).
+ */
+export interface SmrtConsumerSvelteKitOptions extends Partial<Pick<SvelteKitOptions, 'routesDir' | 'configPath' | 'configFileName' | 'kebabRoutes' | 'changesRoute' | 'eventsRoute' | 'resourcesRoute'>> {
+    objects: readonly string[];
+}
 export interface SmrtConsumerOptions {
     /** SMRT packages to scan (e.g., ['@my-org/products', '@my-org/content']) */
     packages?: string[];
@@ -8,7 +17,7 @@ export interface SmrtConsumerOptions {
     generateTypes?: boolean;
     /** Output directory for generated types */
     typesDir?: string;
-    /** Project root path */
+    /** Project root path (defaults to the current working directory) */
     projectRoot?: string;
     /**
      * Reuse an immutable, verified aggregated manifest instead of discovering
@@ -16,11 +25,17 @@ export interface SmrtConsumerOptions {
      * types still consume the verified manifest.
      */
     generationSnapshot?: SmrtGenerationSnapshotOptions;
-    /** SvelteKit integration mode */
-    svelteKit?: boolean;
+    /**
+     * Consumer SvelteKit integration. `true` retains the historical compatibility
+     * mode and does not generate dependency routes. Route hosting requires an
+     * explicit, provider-qualified object allowlist.
+     */
+    svelteKit?: boolean | SmrtConsumerSvelteKitOptions;
     /**
      * Apply kebab-case to generated custom-method URL segments. This must match
-     * the producer plugin's `svelteKit.kebabRoutes` setting.
+     * the producer plugin's `svelteKit.kebabRoutes` setting. When explicit
+     * consumer SvelteKit hosting is configured, its `kebabRoutes` value takes
+     * precedence, including an explicit `false`.
      */
     kebabRoutes?: boolean;
     /** Use static types only (for federation builds) */

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,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AACnC,OAAO,EAEL,KAAK,6BAA6B,EACnC,MAAM,2BAA2B,CAAC;AAUnC,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;AAoDnC,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,wBAAwB;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,6BAA6B,CAAC;IACnD,iCAAiC;IACjC,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB;;;OAGG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,oDAAoD;IACpD,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,4BAA4B;IAC5B,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAiBD;;GAEG;AACH,wBAAgB,YAAY,CAAC,OAAO,GAAE,mBAAwB,GAAG,MAAM,CAoKtE"}
+{"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,CAwTtE"}

package/dist/consumer-plugin/index.js

@@ -1,8 +1,12 @@
 import "../scanner/types.js";
+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 { loadVerifiedSmrtGenerationSnapshot, serializeSmrtGenerationSnapshot, sha256SmrtGenerationSnapshot } from "../generation-snapshot.js";
 import { resolveFileKnowledgeConfig } from "../knowledge-config.js";
 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 { publishArtifactFiles } from "./artifact-publication.js";
 import * as fs from "node:fs";
@@ -17,27 +21,220 @@ var VIRTUAL_MODULES = {
 	"@smrt/client": "smrt-consumer:client",
 	"@smrt/mcp": "smrt-consumer:mcp",
 	"@smrt/types": "smrt-consumer:types",
-	"@smrt/manifest": "smrt-consumer:manifest"
+	"@smrt/manifest": "smrt-consumer:manifest",
+	"@smrt/web": "smrt-consumer:web"
 };
+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);
+}
+/** 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("/");
+}
+function loadConsumerSvelteKitRouteRoots(projectRoot) {
+	const artifactPath = consumerSvelteKitRoutesArtifactPath(projectRoot);
+	if (!fs.existsSync(artifactPath)) return [];
+	let parsed;
+	try {
+		parsed = JSON.parse(fs.readFileSync(artifactPath, "utf-8"));
+	} catch {
+		throw new Error(`[smrt:consumer] Cannot read ${CONSUMER_SVELTEKIT_ROUTES_ARTIFACT}; refusing to leave hosted routes unreconciled`);
+	}
+	if (parsed?.version !== CONSUMER_SVELTEKIT_ROUTES_ARTIFACT_VERSION || !Array.isArray(parsed.routesDir) || parsed.routesDir.some((routesDir) => typeof routesDir !== "string")) throw new Error(`[smrt:consumer] Invalid ${CONSUMER_SVELTEKIT_ROUTES_ARTIFACT}; refusing to leave hosted routes unreconciled`);
+	return [...new Set(parsed.routesDir)].map((routesDir) => canonicalConsumerRouteRoot(projectRoot, routesDir));
+}
+function publishConsumerSvelteKitRouteRoots(projectRoot, routesDir) {
+	const artifactPath = consumerSvelteKitRoutesArtifactPath(projectRoot);
+	fs.mkdirSync(path.dirname(artifactPath), { recursive: true });
+	publishArtifactFiles([{
+		path: artifactPath,
+		content: JSON.stringify({
+			version: CONSUMER_SVELTEKIT_ROUTES_ARTIFACT_VERSION,
+			routesDir: [...new Set(routesDir)].sort()
+		}, null, 2)
+	}]);
+}
+function removeConsumerSvelteKitRouteRoots(projectRoot) {
+	const artifactPath = consumerSvelteKitRoutesArtifactPath(projectRoot);
+	if (fs.existsSync(artifactPath)) fs.unlinkSync(artifactPath);
+}
+/**
+* A hosting-to-hosting move can replace one configured root with another in a
+* fresh lifecycle. Validate every durable former root before the new target
+* journals or clears anything, otherwise a rejected move could alter the
+* prior generated surface before reconciliation notices the conflict.
+*/
+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);
+}
+async function reconcileConsumerSvelteKitRouteRoots(lifecycle, userConfig, projectRoot, routesDir, afterReconciled, env) {
+	const remaining = new Set(routesDir);
+	const reconcileOne = (routesDir) => {
+		remaining.delete(routesDir);
+		if (remaining.size === 0) afterReconciled();
+	};
+	if (remaining.size === 0) {
+		afterReconciled();
+		return;
+	}
+	for (const routesDir of [...remaining]) {
+		const routeRoot = canonicalSvelteKitPath(path.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}`)))) {
+			reconcileOne(routesDir);
+			continue;
+		}
+		const containingProducer = activeParticipants.find((participant) => participant.owner === "producer" && (routeRoot === participant.routesDir || routeRoot.startsWith(`${participant.routesDir}${path.sep}`)));
+		if (containingProducer) {
+			await revokeSvelteKitRoutes(lifecycle, await expectedSvelteKitRouteOwners(userConfig, containingProducer.projectRoot, containingProducer.routesDir, env), containingProducer.projectRoot, containingProducer.routesDir, () => reconcileOne(routesDir));
+			continue;
+		}
+		const owners = await expectedSvelteKitRouteOwners(userConfig, projectRoot, routesDir, env);
+		if (owners.includes("producer")) {
+			await revokeSvelteKitRoutes(lifecycle, owners, projectRoot, routesDir, () => reconcileOne(routesDir));
+			continue;
+		}
+		clearGeneratedSvelteKitRouteFiles(routeRoot, producerKnowledgeRoutePaths(lifecycle), new Set(activeParticipants.map((participant) => participant.routesDir).filter((activeRoot) => activeRoot !== routeRoot)));
+		reconcileSvelteKitRouteGitignore(projectRoot, routesDir);
+		reconcileOne(routesDir);
+	}
+}
+function consumerRouteOptions(value) {
+	if (!value || value === true) return void 0;
+	if (!Array.isArray(value.objects) || value.objects.length === 0) throw new Error("[smrt:consumer] svelteKit.objects must list at least one provider-qualified object reference");
+	for (const objectRef of value.objects) if (typeof objectRef !== "string" || !objectRef.includes(":")) throw new Error(`[smrt:consumer] svelteKit.objects entries must be provider-qualified (received ${JSON.stringify(objectRef)})`);
+	return value;
+}
+function consumerUtilityOption(value) {
+	return value?.enabled === true ? value : { enabled: false };
+}
+function consumerObjectRef(manifestKey, objectDef) {
+	if (manifestKey.includes(":")) return manifestKey;
+	if (objectDef.qualifiedName?.includes(":")) return objectDef.qualifiedName;
+	if (objectDef.packageName && objectDef.className) return `${objectDef.packageName}:${objectDef.className}`;
+}
+/**
+* Select exactly the dependency objects that a consumer explicitly hosts.
+* Validation completes before the generator clears its managed files, so an
+* invalid deployment cannot erase a previously generated route surface.
+*/
+function selectConsumerRouteManifest(manifest, options) {
+	const entriesByRef = /* @__PURE__ */ new Map();
+	for (const [manifestKey, objectDef] of Object.entries(manifest.objects)) {
+		const objectRef = consumerObjectRef(manifestKey, objectDef);
+		if (objectRef) entriesByRef.set(objectRef, [manifestKey, objectDef]);
+	}
+	const selected = /* @__PURE__ */ new Set();
+	const objects = {};
+	for (const objectRef of options.objects) {
+		const entry = entriesByRef.get(objectRef);
+		if (!entry) throw new Error(`[smrt:consumer] svelteKit.objects references unknown dependency object ${JSON.stringify(objectRef)}`);
+		if (selected.has(objectRef)) throw new Error(`[smrt:consumer] svelteKit.objects contains duplicate object ${JSON.stringify(objectRef)}`);
+		selected.add(objectRef);
+		const [, objectDef] = entry;
+		objects[objectRef] = {
+			...objectDef,
+			qualifiedName: objectRef
+		};
+	}
+	const sourceManifest = manifest;
+	for (const [manifestKey, objectDef] of Object.entries(manifest.objects)) {
+		const candidate = objectDef;
+		if (!isCollectionManifestClass(sourceManifest, candidate)) continue;
+		const item = resolveCollectionItemObject(sourceManifest, candidate);
+		const itemEntry = item ? Object.entries(manifest.objects).find(([, value]) => value === item) : void 0;
+		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] = {
+			...objectDef,
+			qualifiedName: collectionRef
+		};
+	}
+	return {
+		...manifest,
+		smrtDependencies: [...new Set(Object.values(manifest.objects).map((objectDef) => objectDef.packageName).filter((packageName) => typeof packageName === "string" && packageName !== manifest.packageName))].sort(),
+		objects
+	};
+}
 /**
 * Consumer plugin for projects that use SMRT packages
 */
 function smrtConsumer(options = {}) {
 	const { packages = [], generateTypes = true, typesDir = "src/types/smrt-generated", projectRoot = process.cwd(), generationSnapshot, disableScanning = false, kebabRoutes = false } = options;
+	const consumerSvelteKit = consumerRouteOptions(options.svelteKit);
+	const effectiveKebabRoutes = consumerSvelteKit?.kebabRoutes ?? kebabRoutes;
 	let smrtPackages = [];
 	let typeManifest = null;
 	let typesGenerated = false;
 	let producerApi;
+	let routeLifecycleConfig;
 	function loadGenerationSnapshot() {
 		if (!generationSnapshot) throw new Error("[smrt:consumer] Generation snapshot is not configured");
 		return loadVerifiedSmrtGenerationSnapshot(generationSnapshot, projectRoot, "dependencies");
 	}
-	return {
+	const plugin = {
 		name: "smrt-consumer",
-		config() {
-			return { build: { rollupOptions: { external: [/\.node$/] } } };
+		enforce: "pre",
+		config: {
+			order: "pre",
+			async handler(userConfig, env) {
+				const routeLifecycle = env ?? userConfig;
+				routeLifecycleConfig = routeLifecycle;
+				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 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",
+						configPath: consumerSvelteKit.configPath ?? "src/lib/server",
+						configFileName: consumerSvelteKit.configFileName ?? "smrt.ts",
+						kebabRoutes: effectiveKebabRoutes,
+						changesRoute: consumerUtilityOption(consumerSvelteKit.changesRoute),
+						eventsRoute: consumerUtilityOption(consumerSvelteKit.eventsRoute),
+						resourcesRoute: consumerUtilityOption(consumerSvelteKit.resourcesRoute),
+						rejectRouteCollisions: true
+					};
+					let ownershipJournaled = false;
+					let reconciliationScheduled = false;
+					await contributeSvelteKitRoutes(routeLifecycle, await expectedSvelteKitRouteOwners(userConfig, projectRoot, routeOptions.routesDir, env), projectRoot, {
+						owner: "consumer",
+						routeManifest: hostedManifest,
+						semanticManifest: routeManifest,
+						options: routeOptions,
+						reservedRoutePaths,
+						beforeCleanup: () => {
+							if (ownershipJournaled) return;
+							ownershipJournaled = true;
+							publishConsumerSvelteKitRouteRoots(projectRoot, [...previousConsumerRouteRoots, routesDir]);
+						},
+						afterGenerate: async () => {
+							if (reconciliationScheduled) return;
+							reconciliationScheduled = true;
+							const priorRoots = previousConsumerRouteRoots.filter((previousRoot) => previousRoot !== routesDir);
+							await reconcileConsumerSvelteKitRouteRoots(routeLifecycle, userConfig, projectRoot, priorRoots, () => publishConsumerSvelteKitRouteRoots(projectRoot, [routesDir]), env);
+						}
+					});
+				} else if (previousConsumerRouteRoots.length > 0) await reconcileConsumerSvelteKitRouteRoots(routeLifecycle, userConfig, projectRoot, previousConsumerRouteRoots, () => removeConsumerSvelteKitRouteRoots(projectRoot), env);
+				return { build: { rollupOptions: { external: [/\.node$/] } } };
+			}
 		},
 		configResolved(resolvedConfig) {
+			if (consumerSvelteKit && routeLifecycleConfig) assertSvelteKitRouteCoordinationComplete(routeLifecycleConfig);
 			producerApi = (resolvedConfig.plugins ?? []).find((plugin) => plugin?.name === "smrt-auto-service")?.api;
 		},
 		async buildStart() {
@@ -75,6 +272,7 @@ function smrtConsumer(options = {}) {
 		},
 		resolveId(id, _importer) {
 			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;
@@ -91,14 +289,17 @@ function smrtConsumer(options = {}) {
 			};
 			switch (cleanId) {
 				case "smrt-consumer:routes": return generateFallbackRoutesModule();
-				case "smrt-consumer:client": return generateFallbackClientModule(typeManifest, { kebabRoutes });
+				case "smrt-consumer:client": return generateFallbackClientModule(typeManifest, { kebabRoutes: effectiveKebabRoutes });
 				case "smrt-consumer:mcp": return generateFallbackMcpModule();
 				case "smrt-consumer:types": return generateFallbackTypesModule(typeManifest);
 				case "smrt-consumer:manifest": return generateFallbackManifestModule(typeManifest);
+				case "smrt-consumer:web": return generateWebModule(typeManifest, { kebabRoutes: effectiveKebabRoutes });
 				default: return null;
 			}
 		}
 	};
+	markSvelteKitRouteParticipant(plugin, "consumer", Boolean(consumerSvelteKit), consumerSvelteKit?.routesDir ?? "src/routes/api", void 0, () => projectRoot);
+	return plugin;
 }
 /**
 * Discover SMRT packages from a consumer app's dependencies.
@@ -146,6 +347,7 @@ async function aggregateTypeManifests(packages, projectRoot) {
 	const aggregatedManifest = {
 		version: "1.0.0",
 		timestamp: 0,
+		smrtDependencies: [...packages],
 		objects: {}
 	};
 	for (const packageName of packages) try {
@@ -430,7 +632,8 @@ function getTypeFileName(virtualModule) {
 		"@smrt/client": "smrt-client.d.ts",
 		"@smrt/mcp": "smrt-mcp.d.ts",
 		"@smrt/types": "smrt-types.d.ts",
-		"@smrt/manifest": "smrt-manifest.d.ts"
+		"@smrt/manifest": "smrt-manifest.d.ts",
+		"@smrt/web": "smrt-web.d.ts"
 	}[virtualModule] || "smrt-unknown.d.ts";
 }
 /**