create-flowdular 0.6.0 → 0.6.2

package/template/default/platform/octane.config.ts

@@ -44,6 +44,10 @@ import {
 	createReadinessEndpoint,
 	healthEndpoint,
 } from './src/server/health.ts';
+import {
+	createPlatformRuntimeLifecycle,
+	prepareAndActivatePlatformRuntimeLifecycle,
+} from './src/server/lifecycle.ts';
 import { createMetricsRoutes } from './src/server/metrics.ts';
 import {
 	platformRuntimeRole,
@@ -97,6 +101,11 @@ function firstRunConfig(databasePreconfigured = false) {
 }
 
 async function createPlatformConfig() {
+	if (process.env.FD_INTERNAL_PLATFORM_TERMINATING === 'true') {
+		throw new Error(
+			'Platform startup was requested while the process is stopping.',
+		);
+	}
 	loadPlatformEnvironmentFile(workspaceRoot);
 	const serverless = process.env.FD_DEPLOYMENT_TARGET === 'vercel';
 	if (!building && !platformDatabaseConfigured(process.env)) {
@@ -215,10 +224,11 @@ async function createPlatformConfig() {
    catalogue, so every reader sees the declarations the modules agreed on. */
 	dataClasses.seal();
 
-	let stopping = false;
-	const shutdown = async () => {
-		if (stopping) return;
-		stopping = true;
+	/* Each evaluation of this file is one generation, and Vite evaluates it more
+	   than once per process. The generation retires when the next one is
+	   prepared, when the development server stops, or on a stop signal. */
+	const lifecycle = createPlatformRuntimeLifecycle();
+	lifecycle.add(async () => {
 		await ticker?.close();
 		for (const composition of moduleCompositions) {
 			await composition.stop?.();
@@ -230,24 +240,38 @@ async function createPlatformConfig() {
 		/* Last, so the spans and error reports this process queued while it stopped
 	   still leave with it. */
 		await observability.dispose();
-	};
+	});
 
 	/* check() proves the runtime role holds neither SUPERUSER nor BYPASSRLS before
    any module reads a row. */
 	if (!building) {
 		try {
-			await databases.check();
-			/* Platform-scoped settings are read by background work before any request
-		   could prime them; a workspace is primed by the authentication middleware. */
-			await settings.prime(PLATFORM_SETTINGS_TENANT);
-			for (const composition of moduleCompositions)
-				await composition.prepare?.();
+			/* The previous generation retires once this one is prepared, and this
+			   one starts its workers only after the previous has drained. */
+			await prepareAndActivatePlatformRuntimeLifecycle(lifecycle, [
+				async () => {
+					await databases.check();
+				},
+				/* Platform-scoped settings are read by background work before any request
+			   could prime them; a workspace is primed by the authentication middleware. */
+				() => settings.prime(PLATFORM_SETTINGS_TENANT),
+				...moduleCompositions.map(
+					(composition) => () => composition.prepare?.(),
+				),
+			]);
+			/* A stop that arrived while this generation was preparing retired only
+			   the generations active then, so this one retires itself. */
+			if (process.env.FD_INTERNAL_PLATFORM_TERMINATING === 'true') {
+				throw new Error(
+					'Platform startup was requested while the process is stopping.',
+				);
+			}
 			for (const composition of moduleCompositions) composition.start?.();
 			await startModuleWorkers(moduleCompositions, runtimeRole);
 		} catch (error) {
 			/* A worker that started before the failure would keep running in a
 		   process that never serves. The boot failure is the one rethrown. */
-			await shutdown().catch((cleanupError: unknown) => {
+			await lifecycle.retire().catch((cleanupError: unknown) => {
 				serverLogger().error('platform boot cleanup failed', {
 					module: 'platform',
 					err: cleanupError,
@@ -259,10 +283,23 @@ async function createPlatformConfig() {
 
 	// Bundling needs route declarations without background work or retained leases.
 	if (building) {
-		await shutdown();
+		await lifecycle.retire();
 	} else {
-		process.once('SIGINT', () => void shutdown());
-		process.once('SIGTERM', () => void shutdown());
+		/* scripts/dev.mjs retires every generation itself; a production server
+		   has only these. */
+		const retire = () =>
+			void lifecycle.retire().catch((error: unknown) => {
+				serverLogger().error('platform shutdown failed', {
+					module: 'platform',
+					err: error,
+				});
+			});
+		process.once('SIGINT', retire);
+		process.once('SIGTERM', retire);
+		lifecycle.add(() => {
+			process.off('SIGINT', retire);
+			process.off('SIGTERM', retire);
+		});
 	}
 
 	return defineConfig({
@@ -273,6 +310,7 @@ async function createPlatformConfig() {
 			createCorsMiddleware({
 				allowOrigin: (origin) => authRuntime.apiOriginAllowed(origin),
 			}),
+			lifecycle.middleware,
 			...(firstRun ? [firstRun.middleware] : []),
 			authRuntime.middleware,
 		],

package/template/default/platform/package.json

@@ -15,7 +15,7 @@
 		"@octanejs/vite-plugin": "0.2.1",
 		"octane": "0.9.1",
 		"pg": "8.23.0",
-		"@flowdular/sdk": "0.6.0"
+		"@flowdular/sdk": "0.6.2"
 	},
 	"devDependencies": {
 		"@octanejs/app-core": "0.1.1",

package/template/default/platform/scripts/dev.mjs

@@ -1,3 +1,4 @@
+import { createServer as createHttpServer } from 'node:http';
 import { resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { spawnSync } from 'node:child_process';
@@ -9,6 +10,12 @@ import {
 	createTheme,
 	printReady,
 } from '@flowdular/sdk/dev-console';
+import {
+	PLATFORM_SHUTDOWN_BUDGET_MS,
+	retirePlatformRuntimes,
+	stopOnSignals,
+	stopServing,
+} from '@flowdular/sdk/dev-console/shutdown';
 
 const appRoot = resolve(fileURLToPath(new URL('..', import.meta.url)));
 /* `pnpm dev -- --port 4396 --host 0.0.0.0` overrides vite.config.ts, so a
@@ -27,36 +34,81 @@ const verbose =
 const color = shouldUseColor();
 const restoreConsole = installOctaneConsoleBridge(verbose, color);
 
+/* Vite serves in middleware mode behind this server. A Vite that listens
+   itself exits the process on SIGTERM as soon as it has closed, before
+   octane.config.ts has released its databases. */
 let server;
+const httpServer = createHttpServer((request, response) =>
+	server.middlewares(request, response),
+);
+let localUrl;
 try {
 	server = await createServer({
 		root: appRoot,
 		configFile: resolve(appRoot, 'vite.config.ts'),
 		customLogger: createOctaneLogger(verbose, color),
 		clearScreen: false,
-		...(Number.isInteger(port) && port > 0
-			? { server: { port, strictPort: true, ...(host ? { host } : {}) } }
-			: host
-				? { server: { host } }
-				: {}),
+		server: {
+			middlewareMode: true,
+			ws: { server: httpServer },
+			...(Number.isInteger(port) && port > 0 ? { port, strictPort: true } : {}),
+			...(host ? { host } : {}),
+		},
+	});
+	/* The address Vite would have bound: vite.config.ts or the flags above,
+	   and localhost when neither names a host. */
+	const listenPort = server.config.server.port;
+	const configuredHost = server.config.server.host;
+	const listenHost =
+		configuredHost === true ? undefined : configuredHost || 'localhost';
+	await new Promise((resolveListen, rejectListen) => {
+		httpServer.once('error', rejectListen);
+		httpServer.listen(listenPort, listenHost, () => {
+			httpServer.off('error', rejectListen);
+			resolveListen();
+		});
 	});
-	await server.listen();
+	const displayHost =
+		listenHost === undefined || listenHost === '0.0.0.0' || listenHost === '::'
+			? 'localhost'
+			: listenHost;
+	localUrl = `http://${displayHost.includes(':') ? `[${displayHost}]` : displayHost}:${listenPort}/`;
 } catch (error) {
+	if (httpServer.listening) httpServer.close();
 	restoreConsole();
 	throw error;
 }
+
+/* The process ends on its own once every runtime generation has released
+   what it holds, so one that was still preparing when the stop arrived
+   drains as well; the deadline bounds the wait. */
+async function stop() {
+	process.env.FD_INTERNAL_PLATFORM_TERMINATING = 'true';
+	try {
+		await Promise.all([
+			stopServing(httpServer, server),
+			retirePlatformRuntimes(),
+		]);
+	} finally {
+		await server.close();
+		restoreConsole();
+	}
+}
+stopOnSignals(
+	() =>
+		void stop().catch((error) => {
+			console.error(error instanceof Error ? error.message : String(error));
+			process.exitCode = 1;
+		}),
+	{ deadlineMs: PLATFORM_SHUTDOWN_BUDGET_MS },
+);
+
 printReady({
 	title: 'FLOWDULAR',
 	subtitle: 'development workspace',
 	theme: createTheme(color),
 	lines: [
-		[
-			'local',
-			server.resolvedUrls?.local?.[0] ??
-				server.resolvedUrls?.network?.[0] ??
-				'the address vite.config.ts sets',
-			'info',
-		],
+		['local', localUrl, 'info'],
 		['diagnostics', verbose ? 'verbose' : 'quiet · use --verbose', 'muted'],
 	],
 });
@@ -80,8 +132,7 @@ function openBrowser(url) {
 	return !result.error && result.status === 0;
 }
 
-const localUrl = server.resolvedUrls?.local?.[0];
-if (localUrl && !process.argv.includes('--no-open')) {
+if (!process.argv.includes('--no-open')) {
 	const setupUrl = new URL('/setup', localUrl).href;
 	try {
 		const response = await fetch(setupUrl, {
@@ -96,9 +147,3 @@ if (localUrl && !process.argv.includes('--no-open')) {
 		// The server remains usable when a browser is unavailable.
 	}
 }
-
-/* Closing without exiting lets octane.config.ts release the database on the
-   same signal; the process ends once both have drained. */
-const stop = () => void server.close().finally(restoreConsole);
-process.once('SIGINT', stop);
-process.once('SIGTERM', stop);

package/template/default/platform/src/server/lifecycle.ts

@@ -0,0 +1,325 @@
+import process from 'node:process';
+import { randomUUID } from 'node:crypto';
+import type { EventEmitter } from 'node:events';
+import { BroadcastChannel } from 'node:worker_threads';
+import type { Middleware } from '@octanejs/app-core';
+import { serverLogger, trackResponseBody } from '@flowdular/sdk/server';
+
+export const PLATFORM_LIFECYCLE_SYMBOL = Symbol.for(
+	'flowdular.platform.runtime-lifecycle',
+);
+export const PLATFORM_LIFECYCLE_ACTIVATE_EVENT =
+	'flowdular:platform-runtime-activate';
+export const PLATFORM_LIFECYCLE_RETIRE_EVENT =
+	'flowdular:platform-runtime-retire';
+const PLATFORM_LIFECYCLE_CHANNEL = 'flowdular.platform.runtime-lifecycle';
+
+type Dispose = () => void | Promise<void>;
+
+export interface PlatformRuntimeLifecycle {
+	readonly middleware: Middleware;
+	/** Runs as soon as retirement begins, before the requests in flight drain:
+	    for a producer that holds a request open until it is told to stop. */
+	addInterrupt(interrupt: Dispose): void;
+	addQuiesce(quiesce: Dispose): void;
+	add(dispose: Dispose): void;
+	retire(): Promise<void>;
+}
+
+type ProcessWithLifecycle = NodeJS.Process & {
+	[PLATFORM_LIFECYCLE_SYMBOL]?: PlatformRuntimeLifecycle;
+};
+
+/* An event stream never finishes on its own. Its protocol has the client
+	reconnect and resume from Last-Event-ID, which reaches the next generation,
+	so retirement ends it instead of waiting for it. Any other body drains. */
+function isEventStream(response: Response): boolean {
+	const type = response.headers.get('content-type')?.split(';', 1)[0];
+	return type?.trim().toLowerCase() === 'text/event-stream';
+}
+
+/* EventSource stops reconnecting for good on any answer but a 200 event
+	stream, and a production server keeps listening while it retires. A stream
+	request to a retired generation gets an empty stream that ends at once, so
+	the client keeps reconnecting until the next process answers. */
+function retiredResponse(request: Request | undefined): Response {
+	if (
+		request?.method === 'GET' &&
+		request.headers.get('accept')?.includes('text/event-stream')
+	) {
+		return new Response('retry: 1000\n\n', {
+			headers: {
+				'content-type': 'text/event-stream; charset=utf-8',
+				'cache-control': 'no-store',
+			},
+		});
+	}
+	return new Response(null, {
+		status: 503,
+		headers: { 'retry-after': '1' },
+	});
+}
+
+/* Vite evaluates octane.config.ts again when one of its SSR dependencies is
+	invalidated. A generation owns every resource created by that evaluation.
+	Retirement interrupts what would hold a request open, waits for requests
+	already using the old route closures, then disposes its resources in
+	reverse composition order. */
+export function createPlatformRuntimeLifecycle(): PlatformRuntimeLifecycle {
+	const disposers: Dispose[] = [];
+	const quiescers: Dispose[] = [];
+	const interrupts = new Set<Dispose>();
+	let interrupted: Promise<unknown[]> = Promise.resolve([]);
+	let activeRequests = 0;
+	let retired = false;
+	let finishing = false;
+	let disposal: Promise<void> | undefined;
+	let resolveDisposal: (() => void) | undefined;
+	let rejectDisposal: ((error: unknown) => void) | undefined;
+
+	const finish = () => {
+		if (!retired || activeRequests !== 0 || disposal === undefined || finishing)
+			return;
+		finishing = true;
+		const currentQuiescers = quiescers.splice(0).reverse();
+		const current = disposers.splice(0).reverse();
+		void (async () => {
+			const failures = await interrupted;
+			/* Every background producer stops before any module repository closes. */
+			for (const quiesce of currentQuiescers) {
+				try {
+					await quiesce();
+				} catch (error) {
+					failures.push(error);
+				}
+			}
+			for (const dispose of current) {
+				try {
+					await dispose();
+				} catch (error) {
+					failures.push(error);
+				}
+			}
+			if (failures.length > 0) {
+				/* A logger reads the message, not the errors array, so each cause
+				   is named there rather than left for a debugger. */
+				rejectDisposal?.(
+					new AggregateError(
+						failures,
+						'Platform runtime teardown did not release every resource: ' +
+							failures
+								.map((failure) =>
+									failure instanceof Error ? failure.message : String(failure),
+								)
+								.join('; '),
+					),
+				);
+			} else {
+				resolveDisposal?.();
+			}
+		})();
+	};
+
+	const interrupt = async (): Promise<unknown[]> => {
+		const failures: unknown[] = [];
+		await Promise.all(
+			[...interrupts].map(async (run) => {
+				try {
+					await run();
+				} catch (error) {
+					failures.push(error);
+				}
+			}),
+		);
+		return failures;
+	};
+
+	const lifecycle: PlatformRuntimeLifecycle = {
+		middleware: async (context, next) => {
+			if (retired) return retiredResponse(context.request);
+			activeRequests += 1;
+			let endStream: (() => void) | undefined;
+			const release = () => {
+				if (endStream) interrupts.delete(endStream);
+				activeRequests -= 1;
+				finish();
+			};
+			try {
+				const response = await next();
+				const signal = context.request?.signal;
+				if (!isEventStream(response)) {
+					return trackResponseBody(response, release, signal);
+				}
+				const end = new AbortController();
+				endStream = () => end.abort(new Error('The platform runtime retired.'));
+				if (retired) endStream();
+				else interrupts.add(endStream);
+				return trackResponseBody(
+					response,
+					release,
+					signal ? AbortSignal.any([signal, end.signal]) : end.signal,
+				);
+			} catch (error) {
+				release();
+				throw error;
+			}
+		},
+		addInterrupt(run) {
+			if (retired) {
+				void Promise.resolve()
+					.then(run)
+					.catch((error: unknown) => {
+						serverLogger().error('late platform interrupt failed', {
+							module: 'platform',
+							err: error,
+						});
+					});
+				return;
+			}
+			interrupts.add(run);
+		},
+		addQuiesce(quiesce) {
+			if (retired) {
+				void Promise.resolve()
+					.then(quiesce)
+					.catch((error: unknown) => {
+						serverLogger().error('late platform quiesce failed', {
+							module: 'platform',
+							err: error,
+						});
+					});
+				return;
+			}
+			quiescers.push(quiesce);
+		},
+		add(dispose) {
+			if (retired) {
+				void Promise.resolve()
+					.then(dispose)
+					.catch((error: unknown) => {
+						serverLogger().error('late platform teardown failed', {
+							module: 'platform',
+							err: error,
+						});
+					});
+				return;
+			}
+			disposers.push(dispose);
+		},
+		retire() {
+			if (!disposal) {
+				disposal = new Promise<void>((resolve, reject) => {
+					resolveDisposal = resolve;
+					rejectDisposal = reject;
+				});
+				retired = true;
+				interrupted = interrupt();
+				finish();
+			}
+			return disposal;
+		},
+	};
+	return lifecycle;
+}
+
+/* Activation happens only after the new configuration composed successfully.
+	A failed HMR evaluation therefore tears down only its partial generation and
+	leaves the previous, still-routable generation alive. */
+export function activatePlatformRuntimeLifecycle(
+	lifecycle: PlatformRuntimeLifecycle,
+): Promise<void> {
+	const owner = process as ProcessWithLifecycle;
+	const events = process as unknown as EventEmitter;
+	const generationId = `${process.pid}:${randomUUID()}`;
+	const channel = new BroadcastChannel(PLATFORM_LIFECYCLE_CHANNEL);
+	channel.unref();
+	const previous = owner[PLATFORM_LIFECYCLE_SYMBOL];
+	owner[PLATFORM_LIFECYCLE_SYMBOL] = lifecycle;
+	/* Octane loads its config once through the Vite config loader and again
+	   through the SSR module runner. Their process wrappers do not share custom
+	   properties, but both delegate EventEmitter operations to the real process.
+	   The event is therefore the cross-runner ownership handoff. */
+	const onActivation = (
+		next: PlatformRuntimeLifecycle,
+		report?: (retirement: Promise<void>) => void,
+	) => {
+		if (next === lifecycle) return;
+		const retirement = lifecycle.retire();
+		report?.(retirement);
+		void retirement.catch((error: unknown) => {
+			serverLogger().error('stale platform teardown failed', {
+				module: 'platform',
+				err: error,
+			});
+		});
+	};
+	const onRetire = (report: (retirement: Promise<void>) => void) => {
+		report(lifecycle.retire());
+	};
+	channel.onmessage = (event) => {
+		if (!event.data || typeof event.data !== 'object') return;
+		const message = event.data as { type?: unknown; generationId?: unknown };
+		if (
+			message.type !== 'retire-all' &&
+			(message.type !== 'activate' || message.generationId === generationId)
+		) {
+			return;
+		}
+		/* Closing a BroadcastChannel from inside its own callback can wait for the
+		   callback to return. Start retirement in the next microtask so channel
+		   teardown cannot deadlock the generation it is releasing. */
+		queueMicrotask(() => {
+			void lifecycle.retire().catch((error: unknown) => {
+				serverLogger().error('cross-runner platform teardown failed', {
+					module: 'platform',
+					err: error,
+				});
+			});
+		});
+	};
+	events.on(PLATFORM_LIFECYCLE_ACTIVATE_EVENT, onActivation);
+	events.on(PLATFORM_LIFECYCLE_RETIRE_EVENT, onRetire);
+	lifecycle.add(() => {
+		channel.close();
+		events.off(PLATFORM_LIFECYCLE_ACTIVATE_EVENT, onActivation);
+		events.off(PLATFORM_LIFECYCLE_RETIRE_EVENT, onRetire);
+		if (owner[PLATFORM_LIFECYCLE_SYMBOL] === lifecycle) {
+			delete owner[PLATFORM_LIFECYCLE_SYMBOL];
+		}
+	});
+	const retirements = new Set<Promise<void>>();
+	events.emit(
+		PLATFORM_LIFECYCLE_ACTIVATE_EVENT,
+		lifecycle,
+		(retirement: Promise<void>) => retirements.add(retirement),
+	);
+	channel.postMessage({ type: 'activate', generationId });
+	if (previous && previous !== lifecycle) {
+		const retirement = previous.retire();
+		retirements.add(retirement);
+		void retirement.catch((error: unknown) => {
+			serverLogger().error('stale platform teardown failed', {
+				module: 'platform',
+				err: error,
+			});
+		});
+	}
+	return Promise.all(retirements).then(() => undefined);
+}
+
+/* Preparation may inspect durable state but must not create write handles,
+	 workers or timers. Only a fully prepared generation may retire the one that
+	 is currently serving requests. */
+export async function prepareAndActivatePlatformRuntimeLifecycle(
+	lifecycle: PlatformRuntimeLifecycle,
+	preparations: readonly (() => void | Promise<void>)[],
+): Promise<void> {
+	for (const prepare of preparations) await prepare();
+	await activatePlatformRuntimeLifecycle(lifecycle);
+}
+
+export function activePlatformRuntimeLifecycle():
+	| PlatformRuntimeLifecycle
+	| undefined {
+	return (process as ProcessWithLifecycle)[PLATFORM_LIFECYCLE_SYMBOL];
+}

package/template/default/platform/src/server/setup/modules.ts

@@ -1,10 +1,11 @@
-import { readdirSync, readFileSync } from 'node:fs';
-import { join, resolve } from 'node:path';
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
 import {
 	DATABASE_CAPABILITY_IDS,
 	DATABASE_DIALECT_IDS,
 	type ModuleDatabaseRequirements,
 } from '@flowdular/sdk/database';
+import { findModuleManifests } from '@flowdular/sdk/kernel/module-manifests';
 import projectManifest from '../../../../flowdular.json';
 
 /**
@@ -27,9 +28,10 @@ export const PLATFORM_MODULE_DATABASE_REQUIREMENTS = Object.freeze({
 export interface EnabledDatabaseModules {
 	readonly modules: readonly ModuleDatabaseRequirements[];
 	/**
-	 * True when the module manifests could not be read, so every enabled module
-	 * is treated as owning tenant-scoped tables. Over-approximating keeps the
-	 * check strict; the review screen says the list came from this fallback.
+	 * True when a module manifest could not be read, so the enabled module it
+	 * belongs to is treated as owning tenant-scoped tables. Over-approximating
+	 * keeps the check strict; the review screen says the list came from this
+	 * fallback.
 	 */
 	readonly approximated: boolean;
 }
@@ -75,9 +77,10 @@ function requirements(
 
 /**
  * The enabled modules that own database tables, in `flowdular.json` order.
- * A container image ships only `platform/dist`, so the enabled list falls back
- * to the manifest bundled at build time and, without the module manifests
- * beside it, every enabled module is assumed to own tenant-scoped tables.
+ * Manifests are found where the CLI finds them, @flowdular/sdk included. A
+ * container image ships only `platform/dist`, so the enabled list falls back
+ * to the manifest bundled at build time and an enabled module whose manifest
+ * is not beside it is assumed to own tenant-scoped tables.
  */
 export function enabledDatabaseModules(
 	workspaceRoot: string,
@@ -87,37 +90,30 @@ export function enabledDatabaseModules(
 		(projectManifest as ProjectManifest);
 	const enabled = stringList(project.modules?.enabled);
 	if (enabled.length === 0) return { modules: [], approximated: false };
-	const roots = stringList(project.modules?.roots);
+	let paths: readonly string[] = [];
+	try {
+		paths = findModuleManifests(workspaceRoot, project.modules?.roots);
+	} catch {
+		/* Unreadable roots leave every module to the strict fallback below. */
+	}
 	const manifests = new Map<string, ModuleManifest>();
-	for (const root of roots.length > 0 ? roots : ['modules']) {
-		const directory = resolve(workspaceRoot, root);
-		let entries: readonly string[];
-		try {
-			entries = readdirSync(directory);
-		} catch {
-			continue;
+	for (const path of paths) {
+		const manifest = readJson<ModuleManifest>(path);
+		if (typeof manifest?.id === 'string') {
+			manifests.set(manifest.id, manifest);
 		}
-		for (const entry of entries) {
-			const manifest = readJson<ModuleManifest>(
-				join(directory, entry, 'module.json'),
-			);
-			if (typeof manifest?.id === 'string') {
-				manifests.set(manifest.id, manifest);
-			}
-		}
-	}
-	if (manifests.size === 0) {
-		return {
-			modules: enabled.map((moduleId) => requirements(moduleId, true)),
-			approximated: true,
-		};
 	}
 	const modules: ModuleDatabaseRequirements[] = [];
+	let approximated = false;
 	for (const moduleId of enabled) {
 		const manifest = manifests.get(moduleId);
-		if (!manifest) continue;
+		if (!manifest) {
+			modules.push(requirements(moduleId, true));
+			approximated = true;
+			continue;
+		}
 		if (!stringList(manifest.capabilities).includes('database')) continue;
 		modules.push(requirements(moduleId, manifest.tenancy === 'required'));
 	}
-	return { modules, approximated: false };
+	return { modules, approximated };
 }