@powerhousedao/reactor-api 6.2.2-dev.83 → 6.2.2-dev.84

package/dist/index.mjs

@@ -1,5 +1,5 @@
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="a3bbf8ae-c16f-5c87-aaf9-23e0709811cd")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="1ef5d33d-849a-5b1b-8d6e-74296692d4e4")}catch(e){}}();
 import { _ as createAuthorizationService, a as isSubgraphClass, b as MalformedStoredOperationError, d as loadSubgraphs, f as BaseSubgraph, g as AuthorizedDocumentHandle, h as AuthorizationPolicy, i as buildGraphqlOperations, l as loadDocumentModels, m as createCanonicalDocumentIdResolver, n as buildGraphQlDriveDocument, o as debounce, p as CanonicalDocumentIdResolutionError, r as buildGraphqlOperation, s as extractUpgradeManifests, t as buildGraphQlDocument, u as loadProcessors, v as AuthEvaluationUnsupportedError, y as ForbiddenError } from "./utils-lHoPB-ft.mjs";
 import { AnalyticsQueryEngine } from "@powerhousedao/analytics-engine-core";
 import { AnalyticsModel, AnalyticsResolvers, typedefs } from "@powerhousedao/analytics-engine-graphql";
@@ -318,11 +318,11 @@ async function createGatewayAdapter(type, logger) {
 async function createHttpAdapter(type) {
 	switch (type) {
 		case "express": {
-			const { createExpressHttpAdapter } = await import("./adapter-http-express-D5OpUIbV.mjs");
+			const { createExpressHttpAdapter } = await import("./adapter-http-express-Cf918YME.mjs");
 			return createExpressHttpAdapter();
 		}
 		case "fastify": {
-			const { createFastifyHttpAdapter } = await import("./adapter-http-fastify-B248RJtm.mjs");
+			const { createFastifyHttpAdapter } = await import("./adapter-http-fastify-DVBSR7C6.mjs");
 			return createFastifyHttpAdapter();
 		}
 	}
@@ -3212,6 +3212,12 @@ function filterLatestDocumentModelVersions(documentModels) {
 	return Array.from(latestByName.values());
 }
 const DefaultFeatureFlags = { enableDocumentModelSubgraphs: true };
+/**
+* The registration-source label for document-model-generated subgraphs, so
+* they can be pruned like package-contributed ones (see
+* regenerateDocumentModelSubgraphs).
+*/
+const DOCUMENT_MODEL_SUBGRAPH_SOURCE = "document-models";
 var GraphQLManager = class {
 	initialized = false;
 	coreSubgraphsMap = /* @__PURE__ */ new Map();
@@ -3225,6 +3231,16 @@ var GraphQLManager = class {
 	/** Cached document models for schema generation - updated on init and regenerate */
 	cachedDocumentModels = [];
 	subgraphHandlerCache = /* @__PURE__ */ new Map();
+	/** subgraphPath → the http adapter handle of its mounted route. */
+	subgraphRouteHandles = /* @__PURE__ */ new Map();
+	/** Handle of the currently mounted supergraph SSE route, if any. */
+	sseRouteHandle;
+	/**
+	* Package name → the subgraph instances registered from it, keyed by
+	* subgraph name. Tracks the package association so that removed packages
+	* can be torn down (see unregisterPackage / prunePackageSubgraphs).
+	*/
+	packageSubgraphs = /* @__PURE__ */ new Map();
 	/** Per-subgraph handlers by name, before auth/drive middleware is applied,
 	* for in-process queries by trusted internals. */
 	#internalSubgraphHandlers = /* @__PURE__ */ new Map();
@@ -3307,7 +3323,8 @@ var GraphQLManager = class {
 		try {
 			const models = (await this.reactorClient.getDocumentModelModules()).results;
 			this.cachedDocumentModels = models;
-			await this.#setupDocumentModelSubgraphs("graphql", models);
+			const registeredNames = await this.#setupDocumentModelSubgraphs("graphql", models);
+			await this.prunePackageSubgraphs(DOCUMENT_MODEL_SUBGRAPH_SOURCE, registeredNames);
 			await this.updateRouter();
 			this.logger.info("Regenerated document model subgraphs with @count models", models.length);
 		} catch (error) {
@@ -3325,6 +3342,7 @@ var GraphQLManager = class {
 	}
 	async #setupDocumentModelSubgraphs(supergraph, documentModels) {
 		const latestDocumentModels = filterLatestDocumentModelVersions(documentModels);
+		const registeredNames = /* @__PURE__ */ new Set();
 		for (const documentModel of latestDocumentModels) {
 			if (DOCUMENT_MODELS_TO_EXCLUDE.includes(documentModel.documentModel.global.id)) continue;
 			if (!hasOperationSchemas(documentModel)) continue;
@@ -3340,42 +3358,71 @@ var GraphQLManager = class {
 					authorizationService: this.authorizationService,
 					syncServingGate: this.syncServingGate
 				});
-				await this.#addSubgraphInstance(subgraphInstance, supergraph, false);
+				await this.#addSubgraphInstance(subgraphInstance, supergraph, false, DOCUMENT_MODEL_SUBGRAPH_SOURCE);
+				registeredNames.add(subgraphInstance.name);
 			} catch (error) {
 				this.logger.error(`Failed to setup document model subgraph for ${documentModel.documentModel.global.id}`, error instanceof Error ? error.message : error);
 				this.logger.debug("@error", error);
 			}
 		}
+		return registeredNames;
+	}
+	/** Core subgraph names are reserved: they register with core=true during
+	* init() and no package subgraph may take one of their names. */
+	#isCoreNameReserved(name) {
+		for (const subgraphs of this.coreSubgraphsMap.values()) if (subgraphs.some((it) => it.name === name)) return true;
+		return false;
 	}
-	async #addSubgraphInstance(subgraphInstance, supergraph = "", core = false) {
+	async #addSubgraphInstance(subgraphInstance, supergraph = "", core = false, packageName) {
+		if (!core && this.#isCoreNameReserved(subgraphInstance.name)) {
+			this.logger.error("Rejecting subgraph @name: name is reserved by a registered core subgraph", subgraphInstance.name);
+			return;
+		}
 		const subgraphsMap = core ? this.coreSubgraphsMap : this.subgraphs;
 		const existingSubgraph = subgraphsMap.get(supergraph)?.find((it) => it.name === subgraphInstance.name);
 		if (existingSubgraph === subgraphInstance) {
 			this.logger.debug(`Skipping duplicate subgraph: ${subgraphInstance.name}`);
 			return existingSubgraph;
 		}
-		if (existingSubgraph) await this.#removeSubgraphInstance(existingSubgraph, subgraphsMap);
+		if (existingSubgraph) await this.#removeSubgraphInstance(existingSubgraph);
 		await subgraphInstance.onSetup?.();
 		const subgraphs = subgraphsMap.get(supergraph) ?? [];
 		subgraphs.push(subgraphInstance);
 		subgraphsMap.set(supergraph, subgraphs);
 		if (supergraph !== "" && supergraph !== "graphql") subgraphsMap.get("graphql")?.push(subgraphInstance);
+		if (packageName !== void 0) {
+			let byName = this.packageSubgraphs.get(packageName);
+			if (!byName) {
+				byName = /* @__PURE__ */ new Map();
+				this.packageSubgraphs.set(packageName, byName);
+			}
+			byName.set(subgraphInstance.name, subgraphInstance);
+		}
 		this.logger.info(`${existingSubgraph ? "Replaced" : "Registered"} ${this.path.endsWith("/") ? this.path : this.path + "/"}${supergraph ? supergraph + "/" : ""}${subgraphInstance.name} subgraph.`);
 		return subgraphInstance;
 	}
-	/** Tear down a replaced subgraph: onDisconnect, drop it from every bucket,
-	* and invalidate its cached handlers so #setupSubgraphs rebuilds them. */
-	async #removeSubgraphInstance(instance, subgraphsMap) {
+	/**
+	* Tear down a subgraph instance: disconnect it, drop it from every
+	* bucket, unmount its route, dispose its WebSocket handler, and remove
+	* its internal handler. Used when a subgraph is replaced or its package
+	* is removed; #setupSubgraphs then never re-mounts it.
+	*/
+	async #removeSubgraphInstance(instance) {
 		try {
 			await instance.onDisconnect?.();
 		} catch (error) {
 			this.logger.error("Error disconnecting subgraph @name: @error", instance.name, error);
 		}
-		for (const [bucket, subgraphs] of subgraphsMap.entries()) {
+		for (const subgraphsMap of [this.coreSubgraphsMap, this.subgraphs]) for (const [bucket, subgraphs] of subgraphsMap.entries()) {
 			if (!subgraphs.includes(instance)) continue;
 			subgraphsMap.set(bucket, subgraphs.filter((it) => it !== instance));
 			const subgraphPath = this.#getSubgraphPath(instance, bucket);
 			this.subgraphHandlerCache.delete(subgraphPath);
+			const routeHandle = this.subgraphRouteHandles.get(subgraphPath);
+			if (routeHandle !== void 0) {
+				this.httpAdapter.unmount(routeHandle);
+				this.subgraphRouteHandles.delete(subgraphPath);
+			}
 			const wsDisposer = this.subgraphWsDisposers.get(subgraphPath);
 			if (wsDisposer) {
 				this.subgraphWsDisposers.delete(subgraphPath);
@@ -3387,6 +3434,11 @@ var GraphQLManager = class {
 			}
 		}
 		if (this.#internalSubgraphHandlers.get(instance.name)?.subgraph === instance) this.#internalSubgraphHandlers.delete(instance.name);
+		for (const [packageName, byName] of this.packageSubgraphs) {
+			if (byName.get(instance.name) !== instance) continue;
+			byName.delete(instance.name);
+			if (byName.size === 0) this.packageSubgraphs.delete(packageName);
+		}
 	}
 	/**
 	* Register a pre-constructed subgraph instance.
@@ -3409,7 +3461,13 @@ var GraphQLManager = class {
 	getAuthorizationService() {
 		return this.authorizationService;
 	}
-	async registerSubgraph(subgraph, supergraph = "", core = false) {
+	/**
+	* Register a subgraph class. `packageName` labels the resulting instance
+	* with its contributing package so the instance can be torn down when the
+	* package is removed or drops the subgraph (see unregisterPackage and
+	* prunePackageSubgraphs).
+	*/
+	async registerSubgraph(subgraph, supergraph = "", core = false, packageName) {
 		const subgraphInstance = new subgraph({
 			relationalDb: this.relationalDb,
 			analyticsStore: this.analyticsStore,
@@ -3421,7 +3479,35 @@ var GraphQLManager = class {
 			authorizationService: this.authorizationService,
 			syncServingGate: this.syncServingGate
 		});
-		return this.#addSubgraphInstance(subgraphInstance, supergraph, core);
+		return this.#addSubgraphInstance(subgraphInstance, supergraph, core, packageName);
+	}
+	/**
+	* Tear down every subgraph instance registered from `packageName`:
+	* disconnects the instances, unmounts their routes, disposes their
+	* WebSocket handlers, then refreshes the router so the supergraph SDL and
+	* the supergraph SSE handler no longer reference them. No-op if the
+	* package has no registered subgraphs.
+	*/
+	async unregisterPackage(packageName) {
+		const byName = this.packageSubgraphs.get(packageName);
+		if (!byName || byName.size === 0) return;
+		for (const instance of Array.from(byName.values())) await this.#removeSubgraphInstance(instance);
+		await this.updateRouter();
+	}
+	/**
+	* Remove this package's registered subgraphs whose names are not in
+	* `keepNames` — the package is still loaded but dropped some of its
+	* subgraphs. Refreshes the router if anything was removed.
+	*/
+	async prunePackageSubgraphs(packageName, keepNames) {
+		const byName = this.packageSubgraphs.get(packageName);
+		if (!byName) return;
+		let removed = 0;
+		for (const [name, instance] of Array.from(byName.entries())) if (!keepNames.has(name)) {
+			await this.#removeSubgraphInstance(instance);
+			removed++;
+		}
+		if (removed > 0) await this.updateRouter();
 	}
 	/** Find a registered subgraph by name, core or package-contributed. */
 	getSubgraphByName(name) {
@@ -3515,10 +3601,18 @@ var GraphQLManager = class {
 		return (connectionParams) => this.#createWebSocketContext(connectionParams);
 	}
 	setSupergraph(supergraph, subgraphs) {
-		this.subgraphs.set(supergraph, subgraphs);
+		const accepted = [];
+		for (const subgraph of subgraphs) {
+			if (this.#isCoreNameReserved(subgraph.name)) {
+				this.logger.error("Rejecting subgraph @name: name is reserved by a registered core subgraph", subgraph.name);
+				continue;
+			}
+			accepted.push(subgraph);
+		}
+		this.subgraphs.set(supergraph, accepted);
 		const globalSubgraphs = this.subgraphs.get("graphql");
-		if (globalSubgraphs) this.subgraphs.set("graphql", [...globalSubgraphs, ...subgraphs]);
-		else this.subgraphs.set("graphql", subgraphs);
+		if (globalSubgraphs) this.subgraphs.set("graphql", [...globalSubgraphs, ...accepted]);
+		else this.subgraphs.set("graphql", accepted);
 		return this.updateRouter();
 	}
 	async shutdown() {
@@ -3534,7 +3628,7 @@ var GraphQLManager = class {
 		});
 	}
 	#getSubgraphPath(subgraph, supergraph) {
-		return path.posix.join(subgraph.path ?? "", supergraph, subgraph.name);
+		return path.posix.join(this.path, supergraph, subgraph.name);
 	}
 	/** The in-process handler map is keyed by bare name, so two distinct
 	* subgraphs sharing one name would shadow each other: keep the first. */
@@ -3555,13 +3649,20 @@ var GraphQLManager = class {
 			this.logger.debug(`Setting up subgraph ${subgraph.name}`);
 			const subgraphPath = this.#getSubgraphPath(subgraph, supergraph);
 			try {
-				if (this.subgraphHandlerCache.has(subgraphPath)) continue;
+				const cached = this.subgraphHandlerCache.get(subgraphPath);
+				if (cached) {
+					if (cached.subgraph !== subgraph) this.logger.warn("Subgraph path @path already mounted by @kept; @name is shadowed and will not be mounted", subgraphPath, cached.subgraph.name, subgraph.name);
+					continue;
+				}
 				const schema = createSchema(this.cachedDocumentModels, subgraph.resolvers, subgraph.typeDefs);
 				const rawHandler = await this.gatewayAdapter.createHandler(schema, this.#makeContextFactory());
 				const fetchHandler = this.#composeFetchMiddleware(rawHandler);
-				this.subgraphHandlerCache.set(subgraphPath, fetchHandler);
+				this.subgraphHandlerCache.set(subgraphPath, {
+					handler: fetchHandler,
+					subgraph
+				});
 				this.#setInternalSubgraphHandler(subgraph, subgraphPath, rawHandler);
-				this.httpAdapter.mount(subgraphPath, fetchHandler);
+				this.subgraphRouteHandles.set(subgraphPath, this.httpAdapter.mount(subgraphPath, fetchHandler));
 				if (subgraph.hasSubscriptions) {
 					try {
 						if (this.subgraphWsDisposers.get(subgraphPath)) this.logger.warn("Overwriting existing WebSocket disposer for subgraph at path @path", subgraphPath);
@@ -3626,7 +3727,13 @@ var GraphQLManager = class {
 	#setupSupergraphSSE(superGraphPath) {
 		const allSubgraphs = this.#getAllSubgraphs();
 		const modules = Array.from(allSubgraphs.values()).filter((subgraph) => subgraph.hasSubscriptions).map((subgraph) => this.#buildSubgraphSchemaModule(subgraph));
-		if (modules.length === 0) return;
+		if (modules.length === 0) {
+			if (this.sseRouteHandle !== void 0) {
+				this.httpAdapter.unmount(this.sseRouteHandle);
+				this.sseRouteHandle = void 0;
+			}
+			return;
+		}
 		try {
 			const mergedSchema = createMergedSchema(modules);
 			this.#setupSSEHandler(mergedSchema, superGraphPath);
@@ -3650,7 +3757,8 @@ var GraphQLManager = class {
 			contextFactory: this.#makeContextFactory()
 		});
 		const handler = this.#composeFetchMiddleware(rawHandler);
-		this.httpAdapter.mount(ssePath, handler, { exact: true });
+		if (this.sseRouteHandle !== void 0) this.httpAdapter.unmount(this.sseRouteHandle);
+		this.sseRouteHandle = this.httpAdapter.mount(ssePath, handler, { exact: true });
 	}
 	/**
 	* Compose the request-level fetch middleware chain. Auth runs first
@@ -4740,10 +4848,10 @@ const ADMIN_USERS = getAdminUsers();
 //#endregion
 //#region src/graphql/system/version.ts
 function getVersion() {
-	return "6.2.2-dev.83";
+	return "6.2.2-dev.84";
 }
 function getGitHash() {
-	return "ebe44292295ea32a81913f3968be5723fd916ac4";
+	return "61e064863083d9933ca46160f31bac814e119e18";
 }
 function getGitUrl() {
 	return buildTreeUrl(getGitHash());
@@ -5196,24 +5304,32 @@ var PackageManager = class {
 		const documentModels = await this.loadDocumentModels([pkg]);
 		const upgradeManifests = await this.loadUpgradeManifests([pkg]);
 		const upgradeManifestsMap = new Map(this.upgradeManifestsMap);
-		upgradeManifestsMap.set(pkg, upgradeManifests.get(pkg) ?? []);
+		const pkgManifests = upgradeManifests.get(pkg) ?? [];
+		if (pkgManifests.length === 0) upgradeManifestsMap.delete(pkg);
+		else upgradeManifestsMap.set(pkg, pkgManifests);
 		this.upgradeManifestsMap = upgradeManifestsMap;
 		const documentModelsMap = new Map(this.docModelsMap);
-		documentModelsMap.set(pkg, documentModels.get(pkg) ?? []);
+		const pkgModels = documentModels.get(pkg) ?? [];
+		if (pkgModels.length === 0) documentModelsMap.delete(pkg);
+		else documentModelsMap.set(pkg, pkgModels);
 		this.updatePackagesMap(documentModelsMap);
 	}
 	async updateSubgraphsForPackage(pkg) {
 		this.logger.debug(`Updating subgraphs for package: ${pkg}`);
 		const subgraphs = await this.loadSubgraphs([pkg]);
 		const subgraphsMap = new Map(this.subgraphsMap);
-		subgraphsMap.set(pkg, subgraphs.get(pkg) ?? []);
+		const pkgSubgraphs = subgraphs.get(pkg) ?? [];
+		if (pkgSubgraphs.length === 0) subgraphsMap.delete(pkg);
+		else subgraphsMap.set(pkg, pkgSubgraphs);
 		this.updateSubgraphsMap(subgraphsMap);
 	}
 	async updateProcessorsForPackage(pkg) {
 		this.logger.debug(`Updating processors for package: ${pkg}`);
 		const processors = await this.loadProcessors([pkg]);
 		const processorsMap = new Map(this.processorMap);
-		processorsMap.set(pkg, processors.get(pkg) ?? []);
+		const pkgProcessors = processors.get(pkg) ?? [];
+		if (pkgProcessors.length === 0) processorsMap.delete(pkg);
+		else processorsMap.set(pkg, pkgProcessors);
 		this.updateProcessorsMap(processorsMap);
 	}
 	/** Debounced per key so repeated subscribePackages calls reuse one timer. */
@@ -5285,6 +5401,28 @@ var PackageManager = class {
 		this.processorMap = processorsMap;
 		this.eventEmitter.emit("processorsChange", processorsMap);
 	}
+	/**
+	* Remove `pkg` from all package maps and emit the change events, tearing
+	* down everything the package registered (subgraphs, processors, document
+	* models). For an uninstalled package no loader can serve it again, so
+	* nothing can re-add it.
+	*/
+	removePackage(pkg) {
+		this.logger.info(`Removing package: ${pkg}`);
+		const dropKey = (map) => {
+			if (!map.has(pkg)) return map;
+			const next = new Map(map);
+			next.delete(pkg);
+			return next;
+		};
+		this.docModelsMap = dropKey(this.docModelsMap);
+		this.upgradeManifestsMap = dropKey(this.upgradeManifestsMap);
+		this.subgraphsMap = dropKey(this.subgraphsMap);
+		this.processorMap = dropKey(this.processorMap);
+		this.updatePackagesMap(this.docModelsMap);
+		this.updateSubgraphsMap(this.subgraphsMap);
+		this.updateProcessorsMap(this.processorMap);
+	}
 	onDocumentModelsChange(handler) {
 		this.eventEmitter.on("documentModelsChange", handler);
 	}
@@ -6359,7 +6497,7 @@ function buildSyncServingGate(reactorModule, authorizationConfig, logger) {
 async function setupGraphQLManager(httpAdapter, authFetchMiddleware, requireAuthFetchMiddleware, httpServer, wsServer, client, relationalDb, analyticsStore, syncManager, subgraphs, logger, authorizationService, authService, documentPermissionService, enableDocumentModelSubgraphs, port, reactorDriveClient, syncServingGate) {
 	const graphqlManager = new GraphQLManager(config.basePath, httpServer, wsServer, client, relationalDb, analyticsStore, syncManager, logger, httpAdapter, await createGatewayAdapter("apollo", logger), authService, documentPermissionService, { enableDocumentModelSubgraphs }, port, authorizationService, reactorDriveClient, syncServingGate);
 	await graphqlManager.init(subgraphs.core, authFetchMiddleware, requireAuthFetchMiddleware);
-	for (const [, collection] of subgraphs.extended.entries()) for (const subgraph of collection) await graphqlManager.registerSubgraph(subgraph, "graphql");
+	for (const [packageName, collection] of subgraphs.extended.entries()) for (const subgraph of collection) await graphqlManager.registerSubgraph(subgraph, "graphql", false, packageName);
 	await graphqlManager.updateRouter();
 	return graphqlManager;
 }
@@ -6386,14 +6524,28 @@ function setupEventListeners(pkgManager, graphqlManager, reactorProcessorManager
 		}
 		graphqlManager.regenerateDocumentModelSubgraphs();
 	});
+	let knownSubgraphPackages = /* @__PURE__ */ new Set();
 	pkgManager.onSubgraphsChange((packagedSubgraphs) => {
 		(async () => {
-			for (const [, subgraphs] of packagedSubgraphs) for (const subgraph of subgraphs) await graphqlManager.registerSubgraph(subgraph, "graphql");
+			for (const [packageName, subgraphs] of packagedSubgraphs) {
+				const incomingNames = /* @__PURE__ */ new Set();
+				for (const subgraph of subgraphs) {
+					const instance = await graphqlManager.registerSubgraph(subgraph, "graphql", false, packageName);
+					if (!instance) continue;
+					incomingNames.add(instance.name);
+				}
+				await graphqlManager.prunePackageSubgraphs(packageName, incomingNames);
+			}
+			for (const packageName of knownSubgraphPackages) if (!packagedSubgraphs.has(packageName)) await graphqlManager.unregisterPackage(packageName);
+			knownSubgraphPackages = new Set(packagedSubgraphs.keys());
 			await graphqlManager.updateRouter();
 		})();
 	});
+	let knownProcessorPackages = /* @__PURE__ */ new Set();
 	pkgManager.onProcessorsChange((processors) => {
 		(async () => {
+			for (const packageName of knownProcessorPackages) if (!processors.has(packageName)) await reactorProcessorManager.unregisterFactory(packageName);
+			knownProcessorPackages = new Set(processors.keys());
 			for (const [packageName, fns] of processors) {
 				await reactorProcessorManager.unregisterFactory(packageName);
 				const validBuilders = fns.map((fn) => fn(module)).filter((factory) => typeof factory === "function");
@@ -6729,7 +6881,8 @@ async function initializeAndStartAPI(clientInitializer, options, processorApp) {
 		syncManager,
 		documentModelRegistry,
 		readiness,
-		attachmentReferenceProjection
+		attachmentReferenceProjection,
+		packageManager: packages
 	};
 }
 //#endregion
@@ -6760,6 +6913,7 @@ var PackageManagementService = class {
 	defaultRegistryUrl;
 	httpLoader;
 	documentModelRegistry;
+	packageManager;
 	logger = childLogger(["reactor-api", "package-management-service"]);
 	onModelsChanged;
 	loadedModulesCache = /* @__PURE__ */ new Map();
@@ -6768,6 +6922,7 @@ var PackageManagementService = class {
 		this.defaultRegistryUrl = options.defaultRegistryUrl;
 		this.httpLoader = options.httpLoader;
 		this.documentModelRegistry = options.documentModelRegistry;
+		this.packageManager = options.packageManager;
 	}
 	setOnModelsChanged(callback) {
 		this.onModelsChanged = callback;
@@ -6810,6 +6965,7 @@ var PackageManagementService = class {
 		this.loadedModulesCache.delete(name);
 		if (this.httpLoader) this.httpLoader.documentModelLoader.removeFromCache(name);
 		if (this.documentModelRegistry) this.documentModelRegistry.unregisterModules(...existing.documentTypes);
+		if (this.packageManager) this.packageManager.removePackage(name);
 		this.triggerModelsChanged();
 		this.logger.info("Uninstalled package @name", name);
 		return true;
@@ -6836,4 +6992,4 @@ var PackageManagementService = class {
 export { ADMIN_USERS, ActionCandidateInputSchema, ActionContextInputSchema, ActionInputSchema, AddRelationshipDocument, AnalyticsSubgraph, AttachmentAccessService, AuthDecision, AuthDecisionSchema, AuthService, AuthSubgraph, AuthorizationPolicy, AuthorizedDocumentHandle, BaseSubgraph, CanonicalDocumentIdResolutionError, ChannelMetaInputSchema, CreateDocumentDocument, CreateEmptyDocumentDocument, DeleteDocumentDocument, DeleteDocumentsDocument, DocumentChangeType, DocumentChangeTypeSchema, DocumentChangesDocument, DocumentOperationsFilterInputSchema, DocumentPermissionService, EvaluateActionsDocument, FindDocumentsDocument, GetDocumentDocument, GetDocumentIncomingRelationshipsDocument, GetDocumentModelsDocument, GetDocumentOperationsDocument, GetDocumentOutgoingRelationshipsDocument, GetDocumentWithOperationsDocument, GetJobStatusDocument, GraphQLManager, HttpDocumentModelLoader, HttpPackageLoader, ImportPackageLoader, InMemoryPackageStorage, JobChangesDocument, MoveRelationshipDocument, MutateDocumentAsyncDocument, MutateDocumentDocument, OperationContextInputSchema, OperationInputSchema, OperationWithContextInputSchema, OperationsFilterInputSchema, PGLITE_UTC_PARSERS, PackageManagementService, PackageManager, PackagesSubgraph, PagingInputSchema, PhDocumentFieldsFragmentDoc, PollSyncEnvelopesDocument, PropagationMode, PropagationModeSchema, PushSyncEnvelopesDocument, ReactorSignerAppInputSchema, ReactorSignerInputSchema, ReactorSignerUserInputSchema, ReactorSubgraph, RemoteCursorInputSchema, RemoteFilterInputSchema, RemoveRelationshipDocument, RenameDocumentDocument, SearchFilterInputSchema, SetPreferredEditorDocument, SyncEnvelopeInputSchema, SyncEnvelopeType, SyncEnvelopeTypeSchema, SystemSubgraph, TouchChannelDocument, TouchChannelInputSchema, ViewFilterInputSchema, assertAuthRequiredForDocumentPermissions, assertCredentialVerifierForSource, assertRequireAuthenticatedCallerAllowed, assertSkipCredentialVerificationAllowed, buildGraphQlDocument, buildGraphQlDriveDocument, buildGraphqlOperation, buildGraphqlOperations, buildSubgraphSchemaModule, createAuthFetchMiddleware, createCanonicalDocumentIdResolver, createGatewayAdapter, createHttpAdapter, createMergedSchema, createReactorGraphQLClient, createRenownCredentialVerifier, createSchema, definedNonNullAnySchema, driveIdFromUrl, extractSubgraphsFromModule, generateDocumentModelSchema, getAuthContext, getDbClient, getDocumentModelSchemaName, getDocumentModelTypeDefs, getGitHash, getGitUrl, getSdk, getUniqueDocumentModels, getUniqueUpgradeManifests, getVersion, initAnalyticsStoreSql, initializeAndStartAPI, isDefinedNonNullAny, isExpectedLoaderMiss, isSubgraphClass, parseDriveUrl, renderGraphqlPlayground, resolveRenownConfig };
 
 //# sourceMappingURL=index.mjs.map
-//# debugId=a3bbf8ae-c16f-5c87-aaf9-23e0709811cd
+//# debugId=1ef5d33d-849a-5b1b-8d6e-74296692d4e4