@powerhousedao/reactor 6.2.2-dev.3 → 6.2.2-dev.4

package/dist/index.js

@@ -2686,6 +2686,98 @@ var InMemoryQueue = class {
 	}
 };
 //#endregion
+//#region src/core/model-sources.ts
+function modelSourceKey(module) {
+	return `${module.documentModel.global.id}@${module.version ?? 1}`;
+}
+function isDocumentModelModule(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const candidate = value;
+	return typeof candidate.reducer === "function" && typeof candidate.documentModel?.global?.id === "string";
+}
+/**
+* Resolves every source to live modules by importing file/package sources
+* host-side and scanning their exports, so the host registry and the worker
+* manifest are derived from one list and cannot diverge.
+*/
+async function resolveModelSources(sources) {
+	const resolved = /* @__PURE__ */ new Map();
+	for (const source of sources) {
+		if (isDocumentModelModule(source)) {
+			addEntry(resolved, {
+				module: source,
+				spec: null
+			});
+			continue;
+		}
+		for (const entry of await resolveImportableSource(source)) addEntry(resolved, entry);
+	}
+	const modules = [];
+	const manifest = [];
+	const moduleOnlyKeys = [];
+	for (const [key, entry] of resolved) {
+		modules.push(entry.module);
+		if (entry.spec) manifest.push({
+			documentType: entry.module.documentModel.global.id,
+			version: String(entry.module.version ?? 1),
+			spec: entry.spec
+		});
+		else moduleOnlyKeys.push(key);
+	}
+	return {
+		modules,
+		manifest,
+		moduleOnlyKeys
+	};
+}
+function addEntry(map, entry) {
+	const key = modelSourceKey(entry.module);
+	const existing = map.get(key);
+	if (!existing) {
+		map.set(key, entry);
+		return;
+	}
+	if (!existing.spec && entry.spec) existing.spec = entry.spec;
+}
+async function resolveImportableSource(source) {
+	const isFile = "filePath" in source;
+	const specifier = isFile ? new URL(`file://${source.filePath}`).href : source.subpath ? `${source.packageName}/${source.subpath}` : source.packageName;
+	const moduleRef = isFile ? { filePath: source.filePath } : { packageName: specifier };
+	let moduleNs;
+	try {
+		moduleNs = await import(
+			/* @vite-ignore */
+			specifier
+);
+	} catch (error) {
+		throw new Error(`Failed to import document-model source "${describeSource(source)}"`, { cause: error });
+	}
+	if (source.exportName !== void 0) {
+		const value = moduleNs[source.exportName];
+		if (!isDocumentModelModule(value)) throw new Error(`Export "${source.exportName}" of document-model source "${describeSource(source)}" is not a DocumentModelModule`);
+		return [{
+			module: value,
+			spec: { module: {
+				...moduleRef,
+				exportName: source.exportName
+			} }
+		}];
+	}
+	const entries = [];
+	for (const [exportName, value] of Object.entries(moduleNs)) if (isDocumentModelModule(value)) entries.push({
+		module: value,
+		spec: { module: {
+			...moduleRef,
+			exportName
+		} }
+	});
+	if (entries.length === 0) throw new Error(`Document-model source "${describeSource(source)}" has no DocumentModelModule exports`);
+	return entries;
+}
+function describeSource(source) {
+	return "filePath" in source ? source.filePath : source.subpath ? `${source.packageName}/${source.subpath}` : source.packageName;
+}
+//#endregion
 //#region src/registry/document-model-resolver.ts
 /**
 * Encapsulates the logic for resolving document model modules on demand.
@@ -2743,10 +2835,11 @@ var DocumentModelResolver = class {
 		return loadPromise;
 	}
 	async loadRegisterAndBroadcast(documentType) {
-		const module = await this.loader.load(documentType);
-		const [result] = this.registry.registerModules(module);
-		if (result.status === "error" && !DuplicateModuleError.isError(result.error)) throw result.error;
-		await this.broadcastIfPossible(documentType);
+		const resolved = await resolveModelSources([await this.loader.load(documentType)]);
+		if (!resolved.modules.some((module) => module.documentModel.global.id === documentType)) throw new Error(`Loader source resolved no module for document type: ${documentType}`);
+		const results = this.registry.registerModules(...resolved.modules);
+		for (const result of results) if (result.status === "error" && !DuplicateModuleError.isError(result.error)) throw result.error;
+		if (this.broadcastHook) for (const entry of resolved.manifest) await this.broadcastHook(entry);
 	}
 	async notifyPeersModelLoaded(documentType) {
 		if (!this.modelLoadedHook) return;
@@ -2756,12 +2849,6 @@ var DocumentModelResolver = class {
 			this.logger.warn(`MODEL_LOADED hook failed: ${documentType}`, error);
 		}
 	}
-	async broadcastIfPossible(documentType) {
-		if (!this.broadcastHook || !this.loader.resolveSpec) return;
-		const entry = await this.loader.resolveSpec(documentType);
-		if (!entry) return;
-		await this.broadcastHook(entry);
-	}
 };
 /**
 * No-op resolver used when no document model loader is configured.
@@ -6478,9 +6565,12 @@ var Reactor = class {
 };
 //#endregion
 //#region src/core/reactor-builder.ts
+function sameDatabaseTarget(a, b) {
+	return a.host === b.host && a.port === b.port && a.database === b.database;
+}
 var ReactorBuilder = class {
 	logger;
-	documentModels = [];
+	documentModelSources = [];
 	upgradeManifests = [];
 	features = { legacyStorageEnabled: false };
 	readModels = [];
@@ -6501,12 +6591,8 @@ var ReactorBuilder = class {
 	documentModelLoader;
 	shutdownHooks = [];
 	driveContainerTypes = DEFAULT_DRIVE_CONTAINER_TYPES;
-	documentModelSpecs = [];
-	workerPoolConfig;
+	workerPool;
 	resolvedModelManifest;
-	workerDbConfig;
-	workerSignatureVerifierSpec;
-	workerFactory;
 	projectionShardConfig;
 	projectionWorkerFactory;
 	instrumentedPools = [];
@@ -6514,8 +6600,15 @@ var ReactorBuilder = class {
 		this.logger = logger;
 		return this;
 	}
-	withDocumentModels(models) {
-		this.documentModels = models;
+	/**
+	* Register document-model sources: live modules, importable files, or
+	* importable packages. Appends across calls. At `buildModule()` every
+	* source is resolved host-side and registered on the registry; file and
+	* package sources additionally form the worker manifest when the worker
+	* pool is enabled (live modules cannot cross a thread boundary).
+	*/
+	withDocumentModelSources(sources) {
+		this.documentModelSources.push(...sources);
 		return this;
 	}
 	withUpgradeManifests(manifests) {
@@ -6630,58 +6723,30 @@ var ReactorBuilder = class {
 		this.shutdownHooks.push(hook);
 		return this;
 	}
-	withDocumentModelSpecs(specs) {
-		this.documentModelSpecs = specs;
-		return this;
-	}
-	/**
-	* Stores the worker-pool configuration. When `config.enabled === true` the
-	* builder constructs a {@link WorkerPoolJobExecutorManager} in place of the
-	* in-process {@link SimpleJobExecutorManager}.
-	*/
-	withWorkerPool(config) {
-		this.workerPoolConfig = config;
-		return this;
-	}
-	/**
-	* Postgres connection info forwarded to each worker so it can open its own
-	* pool. Required when `workerPool.enabled === true` unless a custom
-	* `withWorkerFactory` or `withExecutor` is provided.
-	*/
-	withWorkerDbConfig(db) {
-		this.workerDbConfig = db;
-		return this;
-	}
-	/**
-	* Factory spec the worker imports to instantiate its signature verifier.
-	* Required when `workerPool.enabled === true` unless a custom
-	* `withWorkerFactory` or `withExecutor` is provided.
-	*/
-	withWorkerSignatureVerifierSpec(spec) {
-		this.workerSignatureVerifierSpec = spec;
-		return this;
-	}
 	/**
-	* Inject a custom {@link WorkerFactory}. When set, the builder skips
-	* default thread-transport wiring and hands the factory directly to the
-	* pool manager. Use this in tests or to plug in a different transport
-	* (e.g. a child-process adapter).
+	* Enable the executor worker pool: N `node:worker_threads` workers with
+	* sticky per-document routing, replacing the in-process executor. Calling
+	* this enables the pool — there is no `enabled` flag. Provide `db`
+	* (each worker opens its own Postgres pool; the parent database is built
+	* from it too unless {@link withKysely} is set) or a custom `factory`
+	* transport. `verifier` is imported by the default transport's workers;
+	* omitted = no executor-side signature verification.
 	*/
-	withWorkerFactory(factory) {
-		this.workerFactory = factory;
+	withWorkerPool(options) {
+		this.workerPool = options;
 		return this;
 	}
 	/**
 	* Configure N sharded projection workers. When set, the builder replaces
 	* the default in-process {@link ReadModelCoordinator} with a
-	* {@link ProjectionShardManager}. The same `DbConfig` registered via
-	* {@link withWorkerDbConfig} is reused for the projection workers'
-	* connection info; only the `poolSize` is overridden by
-	* {@link ProjectionShardBuilderConfig.poolSize}.
+	* {@link ProjectionShardManager}.
 	*
-	* Requires {@link withWorkerDbConfig} (the projection workers need
-	* connection info to open their own pools). The same model manifest
-	* resolved from {@link withDocumentModelSpecs} is forwarded.
+	* Projection workers open their own Postgres pools from `config.db`,
+	* falling back to the executor worker pool's `db` when
+	* {@link withWorkerPool} is configured with one; only the `poolSize` is
+	* overridden by {@link ProjectionShardBuilderConfig.poolSize}. The same
+	* model manifest resolved from {@link withDocumentModelSources} is
+	* forwarded.
 	*/
 	withProjectionShards(config) {
 		this.projectionShardConfig = config;
@@ -6704,41 +6769,23 @@ var ReactorBuilder = class {
 	}
 	async buildModule() {
 		if (!this.logger) this.logger = new ConsoleLogger(["reactor"]);
-		if (this.workerPoolConfig?.enabled) {
-			if (this.documentModels.length > 0) throw new Error("workerPool.enabled requires withDocumentModelSpecs; remove withDocumentModels() in worker-pool mode.");
-			if (this.documentModelSpecs.length === 0) throw new Error("workerPool.enabled requires at least one spec registered via withDocumentModelSpecs.");
-			const needsDefaultFactory = !this.executorManager && !this.workerFactory;
-			if (needsDefaultFactory && !this.workerDbConfig) throw new Error("workerPool.enabled requires withWorkerDbConfig (or a custom withWorkerFactory / withExecutor).");
-			if (needsDefaultFactory && !this.workerSignatureVerifierSpec) throw new Error("workerPool.enabled requires withWorkerSignatureVerifierSpec (or a custom withWorkerFactory / withExecutor).");
-		}
-		if (this.documentModelSpecs.length > 0) this.resolvedModelManifest = this.documentModelSpecs.map((input) => {
-			if ("filePath" in input) return {
-				documentType: "<unresolved>",
-				version: "<unresolved>",
-				spec: { module: {
-					filePath: input.filePath,
-					exportName: "documentModel"
-				} }
-			};
-			return {
-				documentType: "<unresolved>",
-				version: input.version,
-				spec: { module: {
-					packageName: input.packageName,
-					exportName: "documentModel"
-				} }
-			};
-		});
+		const resolvedSources = await resolveModelSources(this.documentModelSources);
+		if (this.workerPool) {
+			if (resolvedSources.manifest.length === 0) throw new Error("withWorkerPool requires at least one worker-importable document-model source ({ filePath } or { packageName }).");
+			if (resolvedSources.moduleOnlyKeys.length > 0) throw new Error(`withWorkerPool requires worker-importable sources, but these models were registered only as live modules: ${resolvedSources.moduleOnlyKeys.join(", ")}. Provide a { filePath } or { packageName } source for each.`);
+		}
+		this.resolvedModelManifest = resolvedSources.manifest.length > 0 ? resolvedSources.manifest : void 0;
 		const documentModelRegistry = new DocumentModelRegistry();
 		if (this.upgradeManifests.length > 0) {
 			const results = documentModelRegistry.registerUpgradeManifests(...this.upgradeManifests);
 			for (const result of results) if (result.status === "error") this.logger.error("Failed to register upgrade manifest: @error", result.error.message);
 		}
-		if (this.documentModels.length > 0) {
-			const results = documentModelRegistry.registerModules(...this.documentModels);
+		if (resolvedSources.modules.length > 0) {
+			const results = documentModelRegistry.registerModules(...resolvedSources.modules);
 			for (const result of results) if (result.status === "error") this.logger.error("Failed to register document model: @error", result.error.message);
 		}
-		const baseDatabase = this.kyselyInstance ?? (this.workerPoolConfig?.enabled && this.workerDbConfig ? await this.createPostgresDatabase(this.workerDbConfig) : await createDefaultDatabase());
+		const reactorDbConfig = this.resolveReactorDbConfig();
+		const baseDatabase = this.kyselyInstance ?? (reactorDbConfig ? await this.createPostgresDatabase(reactorDbConfig) : await createDefaultDatabase());
 		if (this.migrationStrategy === "auto") {
 			const result = await runMigrations(baseDatabase, REACTOR_SCHEMA);
 			if (!result.success && result.error) throw new Error(`Database migration failed: ${result.error.message}`);
@@ -6764,10 +6811,16 @@ var ReactorBuilder = class {
 		const executionScope = new KyselyExecutionScope(database, operationStore, operationIndex, keyframeStore, writeCache, documentMetaCache, collectionMembershipCache);
 		let executorManager = this.executorManager;
 		let executorStartCount = this.executorConfig.maxConcurrency ?? 1;
-		if (!executorManager) if (this.workerPoolConfig?.enabled) {
-			const poolManager = new WorkerPoolJobExecutorManager(this.workerFactory ?? await this.createDefaultWorkerFactory(this.workerPoolConfig), eventBus, queue, jobTracker, this.logger, resolver, collectionMembershipCache, this.executorConfig.jobTimeoutMs);
+		if (!executorManager) if (this.workerPool) {
+			const pool = this.workerPool;
+			let factory = pool.factory;
+			if (!factory) {
+				if (pool.db === void 0) throw new Error("unreachable: worker pool configured without db or factory");
+				factory = await this.createDefaultWorkerFactory(pool.numWorkers, pool.db, pool.verifier);
+			}
+			const poolManager = new WorkerPoolJobExecutorManager(factory, eventBus, queue, jobTracker, this.logger, resolver, collectionMembershipCache, this.executorConfig.jobTimeoutMs);
 			executorManager = poolManager;
-			executorStartCount = this.workerPoolConfig.numWorkers;
+			executorStartCount = pool.numWorkers;
 			if (resolver instanceof DocumentModelResolver) resolver.setBroadcastHook((entry) => poolManager.loadModel(entry));
 		} else executorManager = new SimpleJobExecutorManager(() => new SimpleJobExecutor(this.logger, documentModelRegistry, operationStore, eventBus, writeCache, operationIndex, documentMetaCache, collectionMembershipCache, this.driveContainerTypes, this.executorConfig, this.signatureVerifier, executionScope), eventBus, queue, jobTracker, this.logger, resolver, this.executorConfig.jobTimeoutMs);
 		await executorManager.start(executorStartCount);
@@ -6843,6 +6896,19 @@ var ReactorBuilder = class {
 		return module;
 	}
 	/**
+	* The single Postgres config for the parent, executor workers, and
+	* projection shards. They must share one physical database (the parent
+	* writes operations; workers and shards read them), so divergent
+	* worker/shard targets throw. `withKysely` overrides the parent and is not
+	* validated against a worker/shard `db`.
+	*/
+	resolveReactorDbConfig() {
+		const workerDb = this.workerPool?.db;
+		const projectionDb = this.projectionShardConfig?.db;
+		if (workerDb && projectionDb && !sameDatabaseTarget(workerDb, projectionDb)) throw new Error("withWorkerPool({ db }) and withProjectionShards({ db }) must address the same Postgres database (same host, port, and database); the parent writes operations there and the projection shards read them.");
+		return workerDb ?? projectionDb;
+	}
+	/**
 	* Constructs a {@link ProjectionShardManager} bound to the host event
 	* bus. Builds the default thread-transport factory unless one was
 	* injected via {@link withProjectionWorkerFactory}. Calls
@@ -6850,11 +6916,12 @@ var ReactorBuilder = class {
 	* is returned to the caller.
 	*/
 	async createProjectionShardManager(config, eventBus) {
-		if (!this.workerDbConfig) throw new Error("withProjectionShards requires withWorkerDbConfig; projection workers need connection info to open their own pools.");
+		const baseDb = this.resolveReactorDbConfig();
+		if (!baseDb) throw new Error("withProjectionShards requires a db (or an executor worker pool configured with one); projection workers need connection info to open their own pools.");
 		const models = this.resolvedModelManifest ?? [];
 		const db = {
-			...this.workerDbConfig,
-			poolSize: config.poolSize ?? this.workerDbConfig.poolSize,
+			...baseDb,
+			poolSize: config.poolSize ?? baseDb.poolSize,
 			applicationName: "reactor-projection-shard"
 		};
 		const factory = this.projectionWorkerFactory ?? await this.createDefaultProjectionWorkerFactory();
@@ -6889,18 +6956,21 @@ var ReactorBuilder = class {
 		return () => createProjectionThreadTransport(projectionWorkerEntryPath);
 	}
 	/**
-	* Default {@link WorkerFactory} used when `workerPool.enabled` is set and
-	* the caller did not inject `withWorkerFactory`. Each worker spawns a real
-	* `node:worker_threads` Worker pointing at the compiled `worker/entry.js`.
+	* Default {@link WorkerFactory} used when the pool options carry no
+	* custom `factory`. Each worker spawns a real `node:worker_threads`
+	* Worker pointing at the compiled `worker/entry.js`.
 	*/
-	async createDefaultWorkerFactory(poolConfig) {
+	async createDefaultWorkerFactory(numWorkers, db, signatureVerifier) {
 		const [{ WorkerHandle }, { createThreadTransport }, { workerEntryPath }] = await Promise.all([
 			import("./worker-handle-B1w03nRA.js"),
 			import("./transport-ByGviWdZ.js"),
 			import("./worker-DBJOv8Gp.js").then((n) => n.n)
 		]);
-		const db = this.workerDbConfig;
-		const signatureVerifier = this.workerSignatureVerifierSpec;
+		const poolConfig = {
+			enabled: true,
+			numWorkers,
+			workerType: "thread"
+		};
 		const models = this.resolvedModelManifest ?? [];
 		const logger = this.logger;
 		return (index) => {