@powerhousedao/builder-tools 6.2.3-dev.5 → 6.2.3-dev.50

package/dist/index.mjs

@@ -1,13 +1,13 @@
 import { createRequire } from "node:module";
 import { createHash, randomUUID } from "node:crypto";
-import fs, { createReadStream, existsSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import fs, { chmodSync, createReadStream, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import path, { dirname, extname, isAbsolute, join, resolve } from "node:path";
 import { exec, execSync, spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
+import { DYNAMIC_BASE_PLACEHOLDER, PWA_FILE_HANDLER_ACTION, buildRuntimeConfig, deepMerge, loadConnectEnv, mergeManifest, mergePwaConfig, normalizeBasePath, phConnectRuntimeConfigSchema, powerhousePackageSchema, resolveSourceConnect, setConnectEnv, unionStrings, withInferredCategory, workerPackageFileName, workflowsSettingConflict } from "@powerhousedao/shared/connect";
 import MagicString from "magic-string";
 import { readFile, writeFile } from "node:fs/promises";
 import { cwd } from "node:process";
-import { DEFAULT_CONNECT_CONFIG, PWA_FILE_HANDLER_ACTION, buildRuntimeConfig, deepMerge, loadConnectEnv, mergeManifest, mergePwaConfig, normalizeBasePath, phConnectRuntimeConfigSchema, powerhousePackageSchema, setConnectEnv, unionStrings, withInferredCategory } from "@powerhousedao/shared/connect";
 import { getConfig } from "@powerhousedao/config/node";
 import tailwind from "@tailwindcss/vite";
 import react from "@vitejs/plugin-react";
@@ -44,7 +44,8 @@ function computeBuildHash(input) {
 */
 function readConnectVersion(projectRoot) {
 	try {
-		let dir = dirname(createRequire(join(projectRoot, "package.json")).resolve("@powerhousedao/connect", { paths: [projectRoot] }));
+		const entry = createRequire(join(projectRoot, "package.json")).resolve("@powerhousedao/connect", { paths: [projectRoot] });
+		let dir = dirname(entry);
 		for (;;) {
 			try {
 				const pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf-8"));
@@ -91,16 +92,6 @@ function connectBuildHashPlugin(buildHash) {
 //#endregion
 //#region connect-utils/vite-plugins/dynamic-base.ts
 /**
-* Placeholder base used when Connect is built in dynamic-base mode. The Vite
-* `base` option is set to this token; this plugin rewrites it in the emitted
-* output so the effective base is resolved at serve time from a global instead
-* of being baked at build time.
-*
-* Trailing slash matches `normalizeBasePath` output, so the token sits in the
-* same syntactic position as a concrete base would.
-*/
-const DYNAMIC_BASE_PLACEHOLDER = "/__PH_DYNAMIC_BASE__/";
-/**
 * Global the runtime (ph-clint proxy) must set before the entry bundle loads.
 * Value is the normalized deploy base, e.g. "/myagent/" or "/". The JS rewrite
 * below resolves all asset / lazy-chunk / BASE_URL references against it.
@@ -108,7 +99,8 @@ const DYNAMIC_BASE_PLACEHOLDER = "/__PH_DYNAMIC_BASE__/";
 const RUNTIME_GLOBAL = "globalThis.__PH_DYNAMIC_BASE__";
 const BASE_EXPR = `(${RUNTIME_GLOBAL}||"/")`;
 function workerPrelude(stripPrefix) {
-	return `${RUNTIME_GLOBAL}=self.location.pathname.replace(/${escapeForRegExp(stripPrefix).replace(/\//g, "\\/")}assets\\/[^/]*$/,"");\n`;
+	const prefix = escapeForRegExp(stripPrefix).replace(/\//g, "\\/");
+	return `${RUNTIME_GLOBAL}=self.location.pathname.replace(/${prefix}assets\\/[^/]*$/,"");\n`;
 }
 const PLACEHOLDER_LITERAL = new RegExp(`(["'\`])${escapeForRegExp(DYNAMIC_BASE_PLACEHOLDER)}((?:(?!\\1)[^$])*)\\1`, "g");
 /**
@@ -144,7 +136,7 @@ function connectDynamicBasePlugin(options = {}) {
 		name: "ph-connect-dynamic-base",
 		enforce: "post",
 		renderChunk(code, chunk) {
-			if (!code.includes("/__PH_DYNAMIC_BASE__/")) return null;
+			if (!code.includes(DYNAMIC_BASE_PLACEHOLDER)) return null;
 			const s = new MagicString(code);
 			for (const match of code.matchAll(PLACEHOLDER_LITERAL)) {
 				const rest = match[2];
@@ -161,7 +153,7 @@ function connectDynamicBasePlugin(options = {}) {
 			};
 		},
 		generateBundle(_options, bundle) {
-			for (const file of Object.values(bundle)) if ((file.type === "chunk" ? file.code : file.fileName.endsWith(".css") && typeof file.source === "string" ? file.source : void 0)?.includes("/__PH_DYNAMIC_BASE__/")) this.error(`dynamic-base: unrewritten placeholder ${DYNAMIC_BASE_PLACEHOLDER} remains in ${file.fileName}`);
+			for (const file of Object.values(bundle)) if ((file.type === "chunk" ? file.code : file.fileName.endsWith(".css") && typeof file.source === "string" ? file.source : void 0)?.includes(DYNAMIC_BASE_PLACEHOLDER)) this.error(`dynamic-base: unrewritten placeholder ${DYNAMIC_BASE_PLACEHOLDER} remains in ${file.fileName}`);
 		}
 	};
 }
@@ -241,31 +233,34 @@ async function prebuildConnectVendor(options) {
 	const vendorDir = options.vendorDir ?? join(options.dirname, "node_modules/.ph-vendor");
 	const importMapPath = join(vendorDir, "import-map.json");
 	const versionDigest = resolveVersionDigest(options.dirname, [...include, ...external]);
+	const versions = resolveDepVersions(options.dirname, [...include, ...external]);
+	const base = options.base ?? VENDOR_DYNAMIC_BASE;
+	const nodeEnv = options.nodeEnv ?? "development";
 	try {
 		const hit = readCacheHit(importMapPath, include, external, versionDigest);
 		if (hit) return {
 			vendorDir,
-			imports: hit
+			...hit
 		};
 		const lockDir = `${vendorDir}.lock`;
 		const lock = acquireLock(lockDir);
 		if (!lock) {
-			const imports = await waitForCacheHit(importMapPath, include, external, versionDigest, lockDir);
-			return imports ? {
+			const hit = await waitForCacheHit(importMapPath, include, external, versionDigest, lockDir);
+			return hit ? {
 				vendorDir,
-				imports
+				...hit
 			} : null;
 		}
 		try {
 			const raced = readCacheHit(importMapPath, include, external, versionDigest);
 			if (raced) return {
 				vendorDir,
-				imports: raced
+				...raced
 			};
-			const imports = await buildVendorAtomic(options.dirname, vendorDir, include, external, versionDigest);
-			return imports ? {
+			const result = await buildVendorAtomic(options.dirname, vendorDir, include, external, versionDigest, versions, base, nodeEnv);
+			return result ? {
 				vendorDir,
-				imports
+				...result
 			} : null;
 		} finally {
 			releaseLock(lock);
@@ -279,27 +274,73 @@ function readCacheHit(importMapPath, include, external, versionDigest) {
 	if (!existsSync(importMapPath)) return null;
 	try {
 		const cached = JSON.parse(readFileSync(importMapPath, "utf8"));
-		if (sameSet(cached.include, include) && sameSet(cached.external, external) && cached.versionDigest === versionDigest) return cached.imports;
+		if (sameSet(cached.include, include) && sameSet(cached.external, external) && cached.versionDigest === versionDigest) return {
+			imports: cached.imports,
+			versions: cached.versions ?? {}
+		};
 	} catch {}
 	return null;
 }
-function resolveVersionDigest(dirname, specs) {
-	const seen = /* @__PURE__ */ new Map();
+/**
+* Resolve the installed version of each spec's owning package, deduped by
+* package name. Resolution order per spec:
+*   1. the project itself, when it IS the owning package (a self-vendoring
+*      app has no node_modules self-link);
+*   2. the project's own node_modules link (works for pnpm-strict and
+*      hoisted layouts alike, and — unlike `require.resolve` — for
+*      ESM-only packages whose exports map has no CJS condition);
+*   3. Node's own module resolution (covers transitive installs), walking
+*      the entry up to the owning package's package.json.
+* Unresolvable specs contribute a "missing" sentinel, unknown versions
+* "unknown".
+*/
+function resolveDepVersions(dirname$3, specs) {
+	const req = createRequire(join(dirname$3, "noop.js"));
+	const seen = {};
+	let selfMeta = null;
 	for (const spec of specs) {
 		const { pkg } = parsePkg(spec);
-		if (seen.has(pkg)) continue;
-		let version = "missing";
-		try {
-			const pkgRoot = realpathSync(join(dirname, "node_modules", pkg));
-			const meta = JSON.parse(readFileSync(join(pkgRoot, "package.json"), "utf8"));
-			version = String(meta.version ?? "unknown");
-		} catch {}
-		seen.set(pkg, version);
+		if (pkg in seen) continue;
+		if (selfMeta === null) try {
+			selfMeta = JSON.parse(readFileSync(join(dirname$3, "package.json"), "utf8"));
+		} catch {
+			selfMeta = {};
+		}
+		let version;
+		if (typeof selfMeta.name === "string" && selfMeta.name === pkg && typeof selfMeta.version === "string") version = selfMeta.version;
+		else {
+			version = "missing";
+			try {
+				const pkgRoot = realpathSync(join(dirname$3, "node_modules", pkg));
+				const meta = JSON.parse(readFileSync(join(pkgRoot, "package.json"), "utf8"));
+				version = String(meta.version ?? "unknown");
+			} catch {
+				try {
+					const entry = req.resolve(spec);
+					let dir = dirname(entry);
+					for (let depth = 0; depth < 8; depth++) {
+						if (existsSync(join(dir, "package.json"))) {
+							const meta = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+							version = String(meta.version ?? "unknown");
+							break;
+						}
+						const parent = dirname(dir);
+						if (parent === dir) break;
+						dir = parent;
+					}
+				} catch {}
+			}
+		}
+		seen[pkg] = version;
 	}
+	return seen;
+}
+function resolveVersionDigest(dirname, specs) {
+	const versions = resolveDepVersions(dirname, specs);
 	const h = createHash("sha256");
 	const workerHash = createHash("sha256").update(VENDOR_BUILD_WORKER).digest("hex");
 	h.update(`worker:${workerHash}\n`);
-	for (const pkg of [...seen.keys()].sort()) h.update(`${pkg}@${seen.get(pkg)}\n`);
+	for (const pkg of Object.keys(versions).sort()) h.update(`${pkg}@${versions[pkg]}\n`);
 	return h.digest("hex").slice(0, 16);
 }
 function sameSet(a, b) {
@@ -307,7 +348,7 @@ function sameSet(a, b) {
 	const s = new Set(a);
 	return b.every((x) => s.has(x));
 }
-const LOCK_STALE_MS = 5 * 6e4;
+const LOCK_STALE_MS = 3e5;
 const LOCK_HEARTBEAT_MS = 6e4;
 const ownerFile = (lockDir) => join(lockDir, "owner");
 function lockIsStale(lockDir) {
@@ -406,11 +447,16 @@ function parsePkg(spec) {
 * `@powerhousedao/design-system/connect/toast`, `zod/v4/core`). Those bare
 * imports need their own import-map entry, so expand each listed spec to its
 * package's concrete (non-wildcard, JS) subpath exports that share the spec's
-* prefix. Unresolvable / CSS / JSON targets are skipped. Failures leave the
-* original spec untouched.
+* prefix. Unresolvable / CSS / JSON targets are skipped.
+*
+* A spec whose package isn't installed in `dirname` is dropped entirely
+* rather than kept for the worker: the worker cannot build an entry for a
+* missing package (its `await import` and the vite resolution both fail),
+* and a bare re-export entry would fail the whole vendor build. The
+* importer of a missing shared dep simply bundles its own copy.
 */
 function expandIncludeSubpaths(dirname, include) {
-	const out = new Set(include);
+	const out = /* @__PURE__ */ new Set();
 	for (const spec of include) {
 		const { pkg, sub } = parsePkg(spec);
 		let exp;
@@ -421,6 +467,7 @@ function expandIncludeSubpaths(dirname, include) {
 		} catch {
 			continue;
 		}
+		out.add(sub ? spec : pkg);
 		if (!exp || typeof exp !== "object") continue;
 		const expMap = exp;
 		const prefixKey = sub ? `./${sub}` : ".";
@@ -437,34 +484,72 @@ function expandIncludeSubpaths(dirname, include) {
 	return [...out];
 }
 /**
+* The published specifiers whose entry file the vendor build never emitted.
+* URLs are base-less (`/__vendor__/x.js`) and resolve inside `vendorDir`.
+*/
+function missingVendorEntries(vendorDir, imports) {
+	const prefix = VENDOR_URL_PREFIX;
+	return Object.entries(imports).filter(([, url]) => {
+		const rel = url.startsWith(prefix) ? url.slice(12) : url;
+		return !existsSync(join(vendorDir, rel));
+	}).map(([spec, url]) => ({
+		spec,
+		url
+	}));
+}
+/**
+* Rebase the vendor's base-less entry URLs (`/__vendor__/x.js`) onto the
+* deploy base, so a consumer that resolves them against the page origin lands
+* under that base rather than the server root. A dynamic-base build keeps its
+* placeholder, which the runtime substitutes.
+*
+* `base` is the app base from `prebuildConnectVendor` callers, but the
+* VENDOR_DYNAMIC_BASE default already carries the vendor segment — that
+* trailing segment is dropped first so it is never doubled.
+*/
+function withVendorBase(imports, base) {
+	const segment = VENDOR_URL_PREFIX.replace(/^\/+/, "");
+	const appBase = base.endsWith(segment) ? base.slice(0, base.length - segment.length) : base;
+	return Object.fromEntries(Object.entries(imports).map(([spec, url]) => [spec, `${appBase}/${url}`.replace(/([^:])\/{2,}/g, "$1/").replace(/^\/{2,}/, "/")]));
+}
+/**
 * Build the vendor into a unique temp dir, then atomically swap it into place,
 * so a concurrent reader never sees a partial bundle or import-map.json. Runs
 * the build in a throwaway subprocess (its peak memory is reclaimed on exit);
-* the parent augments the import map with the version digest and does the swap.
-* Returns the published import map, or null on failure.
+* the parent augments the import map with the version digest + the version
+* table, writes the runtime shared-deps module, and does the swap.
+* Returns the published import map + versions, or null on failure.
 */
-async function buildVendorAtomic(dirname$2, vendorDir, include, external, versionDigest) {
+async function buildVendorAtomic(dirname$4, vendorDir, include, external, versionDigest, versions, base, nodeEnv) {
 	const parent = dirname(vendorDir);
 	mkdirSync(parent, { recursive: true });
 	const tmpDir = mkdtempSync(join(parent, ".ph-vendor.tmp-"));
 	try {
-		const { ok, stderr } = await runBuildWorker(dirname$2, tmpDir, include, external);
+		const { ok, stderr } = await runBuildWorker(dirname$4, tmpDir, include, external, base, nodeEnv);
 		const tmpMap = join(tmpDir, "import-map.json");
 		if (!ok || !existsSync(tmpMap)) {
 			const detail = stderr.trim();
 			throw new Error(`vendor build failed${detail ? `:\n${detail}` : " (no output captured)"}`);
 		}
 		const meta = JSON.parse(readFileSync(tmpMap, "utf8"));
+		const unbacked = missingVendorEntries(tmpDir, meta.imports);
+		if (unbacked.length > 0) throw new Error(`vendor build published ${unbacked.length} import-map ${unbacked.length === 1 ? "entry" : "entries"} with no file behind ${unbacked.length === 1 ? "it" : "them"}:\n` + unbacked.map((e) => `  ${e.spec} -> ${e.url}`).join("\n"));
 		meta.versionDigest = versionDigest;
+		meta.versions = versions;
 		writeFileSync(tmpMap, JSON.stringify(meta, null, 2));
+		writeFileSync(join(tmpDir, "shared-deps.js"), `export const imports = ${JSON.stringify(withVendorBase(meta.imports, base))};\nexport const versions = ${JSON.stringify(versions)};\n`);
 		const oldDir = `${vendorDir}.old-${process.pid}-${Date.now()}`;
 		if (existsSync(vendorDir)) renameSync(vendorDir, oldDir);
 		renameSync(tmpDir, vendorDir);
+		chmodSync(vendorDir, 493);
 		rmSync(oldDir, {
 			recursive: true,
 			force: true
 		});
-		return meta.imports;
+		return {
+			imports: meta.imports,
+			versions
+		};
 	} catch (err) {
 		rmSync(tmpDir, {
 			recursive: true,
@@ -473,16 +558,29 @@ async function buildVendorAtomic(dirname$2, vendorDir, include, external, versio
 		throw err;
 	}
 }
+function resolveSelfModulePath() {
+	const selfPath = fileURLToPath(import.meta.url);
+	if (!selfPath.endsWith(".ts")) return selfPath;
+	let dir = dirname(selfPath);
+	for (let depth = 0; depth < 4; depth++) {
+		const candidate = join(dir, "dist", "index.mjs");
+		if (existsSync(candidate)) return candidate;
+		const parent = dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	throw new Error("vendor build needs the built builder-tools bundle (dist/index.mjs); build the package first");
+}
 /**
 * Spawn a throwaway worker that generates one entry per specifier (CJS deps get
 * explicit named re-exports, ESM deps `export *`), `vite build`s them into the
 * given out dir, and writes the import map. Captures stdout/stderr so a failure
 * is debuggable; the normal path stays quiet.
 */
-function runBuildWorker(dirname, outDir, include, external) {
+function runBuildWorker(dirname, outDir, include, external, base, nodeEnv) {
 	const workerPath = join(outDir, "build-worker.mjs");
 	writeFileSync(workerPath, VENDOR_BUILD_WORKER);
-	const selfModulePath = fileURLToPath(import.meta.url);
+	const selfModulePath = resolveSelfModulePath();
 	return new Promise((resolve) => {
 		const child = spawn(process.execPath, [
 			workerPath,
@@ -492,7 +590,9 @@ function runBuildWorker(dirname, outDir, include, external) {
 			VENDOR_URL_PREFIX,
 			JSON.stringify(external),
 			VENDOR_DYNAMIC_BASE,
-			selfModulePath
+			selfModulePath,
+			base,
+			nodeEnv
 		], {
 			cwd: dirname,
 			stdio: [
@@ -522,14 +622,22 @@ function runBuildWorker(dirname, outDir, include, external) {
 * The vendor build worker, written to disk and run as a subprocess. Loads
 * `vite` from the project and `connectDynamicBasePlugin` from builder-tools' own
 * built bundle (selfModulePath). argv: dirname, vendorDir, includeJSON,
-* urlPrefix, externalJSON, dynamicBase, selfModulePath.
+* urlPrefix, externalJSON, dynamicBase, selfModulePath, base (app base),
+* nodeEnv.
 */
 const VENDOR_BUILD_WORKER = `
 import { createRequire } from 'node:module';
 import { mkdirSync, writeFileSync, rmSync } from 'node:fs';
 import { join, isAbsolute } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
-const [dirname, vendorDir, includeJSON, urlPrefix, externalJSON, dynamicBase, selfModulePath] = process.argv.slice(2);
+const [dirname, vendorDir, includeJSON, urlPrefix, externalJSON, dynamicBase, selfModulePath, baseArg, nodeEnvArg] = process.argv.slice(2);
+// Trailing argv are optional (older callers): base defaults to the dynamic
+// placeholder behavior, nodeEnv to development. baseArg is the APP base —
+// the same string the app build uses; the build base appends the vendor
+// segment so emitted asset URLs land under <app-base>__vendor__/.
+const segment = urlPrefix.replace(/^\\/+/, '');
+const base = baseArg ? baseArg + segment : dynamicBase;
+const nodeEnv = nodeEnvArg ?? 'development';
 const include = JSON.parse(includeJSON);
 const external = JSON.parse(externalJSON ?? '[]');
 const externalSet = new Set(external);
@@ -602,14 +710,17 @@ const phVendorResolve = {
 };
 await build({
   root: dirname, configFile: false, logLevel: 'error',
-  // Dynamic-base placeholder + vendor segment: connectDynamicBasePlugin rewrites
-  // emitted chunk/asset URLs to resolve against the deploy base at serve time.
-  base: dynamicBase,
+  // Caller-provided build base (or the dynamic placeholder default):
+  // connectDynamicBasePlugin rewrites emitted chunk/asset URLs to resolve
+  // against the deploy base at serve time.
+  base,
   define: {
-    'process.env.NODE_ENV': '"development"',
+    'process.env.NODE_ENV': JSON.stringify(nodeEnv),
     // BASE_URL resolves to the deploy base (not the vendor prefix) so vendored
     // Connect's router basename + BASE_URL-relative fetches use the right path.
-    'import.meta.env.BASE_URL': JSON.stringify(DYNAMIC_BASE_PLACEHOLDER),
+    // The app base when provided (concrete or placeholder), the placeholder
+    // otherwise (dev flow — rewritten at serve time by the dynamic-base plugin).
+    'import.meta.env.BASE_URL': JSON.stringify(baseArg ?? DYNAMIC_BASE_PLACEHOLDER),
   },
   // phVendorResolve (pre) resolves bares from the worker; esmExternalRequirePlugin owns
   // react/virtual externalization; connectDynamicBasePlugin (post) rewrites the placeholder base.
@@ -618,7 +729,9 @@ await build({
   // segment so the worker recovers the deploy base, not the vendor prefix.
   worker: { format: 'es', plugins: () => [connectDynamicBasePlugin({ forWorker: true, workerStripPrefix: urlPrefix.replace(/^\\/+/, '') })] },
   build: {
-    outDir: vendorDir, emptyOutDir: false, minify: false, target: 'esnext', cssCodeSplit: true,
+    // Production ships this to every visitor, so minify it like the app's own
+    // chunks; dev keeps readable output and the faster build.
+    outDir: vendorDir, emptyOutDir: false, minify: nodeEnv === 'production', target: 'esnext', cssCodeSplit: true,
     rollupOptions: {
       input, preserveEntrySignatures: 'strict',
       output: { format: 'es', entryFileNames: '[name].js', chunkFileNames: 'chunks/[name]-[hash].js', assetFileNames: 'assets/[name]-[hash][extname]' },
@@ -631,6 +744,724 @@ for (const spec of include) imports[spec] = urlPrefix + entryName(spec) + '.js';
 writeFileSync(join(vendorDir, 'import-map.json'), JSON.stringify({ include, external, imports }, null, 2));
 `;
 //#endregion
+//#region connect-utils/reactor-worker-build.ts
+/**
+* Prebuild Connect's reactor SharedWorker into a browser-loadable bundle.
+*
+* The published `@powerhousedao/connect` dist ships `reactor.worker.js` as a
+* library artifact: its dependencies are externalized onto bare specifiers
+* (`@powerhousedao/reactor`, `kysely`, ...). The page resolves those through
+* its `<script type="importmap">`, but import maps are a document feature —
+* a worker never inherits one and no Worker/SharedWorker constructor option
+* can supply one. A bare specifier inside a worker is unresolvable by the
+* platform, so the shipped file can never run as a worker script.
+*
+* This module builds the worker's module graph into a self-contained bundle
+* (one `vite build` in a throwaway subprocess, same pattern as the vendor
+* prebuild). Two modes:
+*
+* - With `vendorImports` (production builds that also ship the `__vendor__/`
+*   bundle): specifiers present in the vendor import map are externalized and
+*   rewritten to `../__vendor__/<entry>.js`. The worker bundle is served as a
+*   sibling of `__vendor__/`, so those relative imports hit the exact URLs
+*   the page's import map uses — one fetch and one HTTP-cache entry per
+*   shared dep for the page and the worker together.
+* - Without (dev servers, `PH_CONNECT_VENDOR=0` builds): everything is
+*   bundled; the worker is self-contained.
+*
+* The build uses Vite's relative base (`"./"`), so emitted chunk and asset
+* URLs resolve against the worker script's own URL. That sidesteps the
+* dynamic-base machinery entirely: the bundle works under any deploy base,
+* concrete or proxy-substituted, as long as it is served under
+* `<app-base>/__reactor_worker__/`.
+*/
+/** URL prefix the worker bundle is served under, next to `__vendor__/`. */
+const REACTOR_WORKER_URL_PREFIX = "/__reactor_worker__/";
+/** Entry filename of the bundle; the tab constructs its SharedWorker from it. */
+const REACTOR_WORKER_ENTRY = "reactor.worker.js";
+/** Metadata file the cache check reads; lives inside the bundle dir. */
+const META_FILE = "worker-meta.json";
+/** Content-Type for the extensions the worker build emits; JS is the default. */
+const REACTOR_WORKER_MIME = {
+	".map": "application/json",
+	".json": "application/json",
+	".wasm": "application/wasm",
+	".data": "application/octet-stream"
+};
+/**
+* The installed Connect dist's worker entry, or null when the installed
+* version predates the worker (the feature is then unavailable, not broken).
+*/
+function resolveReactorWorkerSource(dirname) {
+	try {
+		const candidate = join(realpathSync(join(dirname, "node_modules", "@powerhousedao/connect")), "dist", REACTOR_WORKER_ENTRY);
+		return existsSync(candidate) ? candidate : null;
+	} catch {
+		return null;
+	}
+}
+/** `/__vendor__/<entry>.js` -> `../__vendor__/<entry>.js` (sibling dirs). */
+function vendorRelativePath(vendorUrl) {
+	return `../__vendor__/${vendorUrl.slice(vendorUrl.lastIndexOf("/") + 1)}`;
+}
+const SPECIFIER_PATTERNS = [
+	/(?<![.\w$])import\s*\(\s*["']([^"']+)["']/g,
+	/(?<![.\w$])import\s*[^"'()]*?from\s*["']([^"']+)["']/g,
+	/(?<![.\w$])export\s*[^"'()]*?from\s*["']([^"']+)["']/g,
+	/(?<![.\w$])import\s*["']([^"']+)["']/g
+];
+/**
+* Module specifiers a worker cannot resolve: anything that is not relative,
+* root-relative, or an http(s)/data/blob URL. Used as a post-build guard so a
+* leftover bare (or `node:`) import fails the build with a name instead of
+* shipping a worker that dies on its first import statement.
+*
+* Expects minified (comment-free) output: a raw-text scan cannot tell a real
+* import from a JSDoc code sample, and unminified kysely/viem are full of the
+* latter. The build below always minifies for exactly this reason.
+*/
+function findDisallowedSpecifiers(code) {
+	const found = /* @__PURE__ */ new Set();
+	for (const pattern of SPECIFIER_PATTERNS) for (const match of code.matchAll(pattern)) {
+		const spec = match[1];
+		if (!spec.startsWith("./") && !spec.startsWith("../") && !spec.startsWith("/") && !/^(https?:|data:|blob:)/.test(spec)) found.add(spec);
+	}
+	return [...found].sort();
+}
+/**
+* Fallback list of packages whose BUILT dist shapes the worker bundle's output,
+* used only when the installed Connect's package.json cannot be read (see
+* {@link upstreamWorkerPackages}).
+*/
+const FALLBACK_UPSTREAM_WORKER_PACKAGES = ["@powerhousedao/reactor", "@powerhousedao/reactor-browser"];
+/** Dependency scopes whose installed dist can change the bundle's output. */
+const UPSTREAM_SCOPES = ["@powerhousedao/", "@renown/"];
+/**
+* Packages whose BUILT dist shapes the worker bundle's output even when
+* connect's own dist/reactor.worker.js entry file did not change.
+*
+* That entry is a library artifact whose bare imports this build resolves
+* through node_modules at BUILD time, so a rebuilt dist anywhere in its
+* closure changes the bundle output without touching the entry file's own
+* size/mtime. The list is DERIVED from the installed Connect's own
+* dependencies rather than hardcoded: the bundle pulls `@renown/sdk`,
+* `@powerhousedao/powerhouse-vetra-packages` and `@powerhousedao/shared` out
+* of node_modules too, and a hardcoded pair left every one of those able to be
+* rebuilt behind a cache hit. Connect's dependency list is the cheap stand-in
+* for the resolved bundle graph: every workspace package the worker can reach
+* is reachable through it, and a package not in the bundle only costs a readdir.
+*/
+function upstreamWorkerPackages(dirname) {
+	const connectDir = resolveWorkspacePackageDir(dirname, "@powerhousedao/connect");
+	if (!connectDir) return [...FALLBACK_UPSTREAM_WORKER_PACKAGES];
+	let meta;
+	try {
+		meta = JSON.parse(readFileSync(join(connectDir, "package.json"), "utf8"));
+	} catch {
+		return [...FALLBACK_UPSTREAM_WORKER_PACKAGES];
+	}
+	const names = Object.keys(meta.dependencies ?? {}).filter((name) => UPSTREAM_SCOPES.some((scope) => name.startsWith(scope)));
+	for (const name of FALLBACK_UPSTREAM_WORKER_PACKAGES) if (!names.includes(name)) names.push(name);
+	return names.sort();
+}
+/**
+* This module's own installed version, read by walking up from its file to
+* the nearest `package.json` named "@powerhousedao/builder-tools" (same
+* technique as `build-hash.ts`'s `readConnectVersion`: builder-tools'
+* `exports` map has no `./package.json` subpath, so node resolution can't
+* get there). Works whether this runs from source (tests, this monorepo) or
+* the built dist.
+*/
+function resolveOwnPackageVersion() {
+	try {
+		let dir = dirname(fileURLToPath(import.meta.url));
+		for (;;) {
+			try {
+				const pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+				if (pkg.name === "@powerhousedao/builder-tools") return pkg.version ?? "unknown";
+			} catch {}
+			const parent = dirname(dir);
+			if (parent === dir) break;
+			dir = parent;
+		}
+	} catch {}
+	return "unknown";
+}
+/**
+* This package's own version, computed once. Folded into the worker bundle
+* cache key so a builder-tools release — which can change how the bundle is
+* built (anything in this module beyond {@link WORKER_BUILD_WORKER} itself,
+* e.g. `workerSafeVendorImports`, the resolve plugin) — invalidates bundles
+* a prior builder-tools version cached.
+*/
+const BUILDER_TOOLS_VERSION = resolveOwnPackageVersion();
+/**
+* A workspace package's real directory, resolved the way Node's resolver
+* would (through `node_modules`), or null when it is not installed (e.g. a
+* non-monorepo consumer project — graceful, not an error). pnpm's
+* node_modules symlinks resolve to the real package directory, so this
+* reflects the monorepo's actual dist state, not a stale symlink target.
+*/
+function resolveWorkspacePackageDir(dirname, pkgName) {
+	try {
+		return realpathSync(join(dirname, "node_modules", ...pkgName.split("/")));
+	} catch {
+		return null;
+	}
+}
+/**
+* Cheap content fingerprint of a directory's immediate files: no file bytes
+* are read, just each entry's name/size/mtime, so it stays fast even for a
+* large dist. Sensitive to a rebuild in the common cases: Vite's
+* content-hashed chunk filenames change the name itself; a stable-named file
+* (an entry point) changes size or mtime. Bounded (`maxFiles`) so a
+* pathological directory cannot make this slow — deliberately not a
+* full-tree hash.
+*
+* The names are sorted BEFORE the bound is applied, so the subset the bound
+* keeps is the same subset on every run: readdir order is unspecified, and
+* truncating it first made the fingerprint of a directory past the bound a
+* function of whatever order the filesystem happened to report.
+*/
+function distDirFingerprint(dir, maxFiles = 1e3) {
+	try {
+		return readdirSync(dir, { withFileTypes: true }).filter((e) => e.isFile()).map((e) => e.name).sort().slice(0, maxFiles).map((name) => {
+			const stat = statSync(join(dir, name));
+			return `${name}:${stat.size}:${Math.round(stat.mtimeMs)}`;
+		}).join("|");
+	} catch {
+		return "unreadable";
+	}
+}
+function computeSourceDigest(dirname, entryPath, vendorDir, builderToolsVersion = BUILDER_TOOLS_VERSION) {
+	const h = createHash("sha256");
+	h.update(`builder:${WORKER_BUILD_WORKER_HASH}\n`);
+	h.update(`builder-tools:${builderToolsVersion}\n`);
+	try {
+		const pkgRoot = resolveWorkspacePackageDir(dirname, "@powerhousedao/connect");
+		if (!pkgRoot) throw new Error("unresolved");
+		const meta = JSON.parse(readFileSync(join(pkgRoot, "package.json"), "utf8"));
+		h.update(`connect:${meta.version ?? "unknown"}\n`);
+	} catch {
+		h.update("connect:unresolved\n");
+	}
+	try {
+		const stat = statSync(entryPath);
+		h.update(`entry:${stat.size}:${Math.round(stat.mtimeMs)}\n`);
+	} catch {
+		h.update("entry:unstatable\n");
+	}
+	for (const pkg of upstreamWorkerPackages(dirname)) {
+		const pkgDir = resolveWorkspacePackageDir(dirname, pkg);
+		h.update(`${pkg}:${pkgDir ? distDirFingerprint(join(pkgDir, "dist")) : "unresolved"}\n`);
+	}
+	if (vendorDir) try {
+		h.update(`vendor:${createHash("sha256").update(readFileSync(join(vendorDir, "import-map.json"))).digest("hex")}\n`);
+	} catch {
+		h.update("vendor:unreadable\n");
+	}
+	return h.digest("hex").slice(0, 16);
+}
+function vendorKeyOf(vendorImports) {
+	const entries = Object.entries(vendorImports).sort(([a], [b]) => a.localeCompare(b));
+	return createHash("sha256").update(JSON.stringify(entries)).digest("hex").slice(0, 16);
+}
+function readWorkerCacheHit(metaPath, sourceDigest, vendorKey, nodeEnv) {
+	if (!existsSync(metaPath)) return false;
+	try {
+		const cached = JSON.parse(readFileSync(metaPath, "utf8"));
+		return cached.sourceDigest === sourceDigest && cached.vendorKey === vendorKey && cached.nodeEnv === nodeEnv && existsSync(join(dirname(metaPath), "reactor.worker.js"));
+	} catch {
+		return false;
+	}
+}
+async function waitForWorkerCacheHit(metaPath, sourceDigest, vendorKey, nodeEnv, lockDir) {
+	const deadline = Date.now() + LOCK_STALE_MS;
+	while (Date.now() < deadline) {
+		if (readWorkerCacheHit(metaPath, sourceDigest, vendorKey, nodeEnv)) return true;
+		if (!existsSync(lockDir)) return readWorkerCacheHit(metaPath, sourceDigest, vendorKey, nodeEnv);
+		await new Promise((r) => setTimeout(r, 250));
+	}
+	return false;
+}
+/**
+* Build the worker bundle (once, in a throwaway subprocess) into `outDir`.
+* Idempotent: reuses a cached bundle built from the same connect dist, vendor
+* mapping, and builder logic. Returns null on failure (`errorRef` carries the
+* cause) or when the installed Connect has no worker entry.
+*/
+async function prebuildReactorWorker(options) {
+	const entryPath = options.entryPath ?? resolveReactorWorkerSource(options.dirname);
+	if (!entryPath) {
+		if (options.errorRef) options.errorRef.message = "the installed @powerhousedao/connect ships no dist/reactor.worker.js";
+		return null;
+	}
+	const vendorImports = options.vendor ? workerSafeVendorImports(options.vendor.dir, options.vendor.imports) : {};
+	const nodeEnv = options.nodeEnv ?? "development";
+	const outDir = options.outDir;
+	const metaPath = join(outDir, META_FILE);
+	const sourceDigest = computeSourceDigest(options.dirname, entryPath, options.vendor?.dir);
+	const vendorKey = vendorKeyOf(vendorImports);
+	const result = {
+		outDir,
+		entry: REACTOR_WORKER_ENTRY,
+		sourceDigest,
+		vendorImports
+	};
+	try {
+		if (readWorkerCacheHit(metaPath, sourceDigest, vendorKey, nodeEnv)) return result;
+		const lockDir = `${outDir}.lock`;
+		const lock = acquireLock(lockDir);
+		if (!lock) return await waitForWorkerCacheHit(metaPath, sourceDigest, vendorKey, nodeEnv, lockDir) ? result : null;
+		try {
+			if (readWorkerCacheHit(metaPath, sourceDigest, vendorKey, nodeEnv)) return result;
+			await buildWorkerAtomic(options.dirname, outDir, entryPath, vendorImports, nodeEnv, {
+				sourceDigest,
+				vendorKey,
+				nodeEnv
+			});
+			return result;
+		} finally {
+			releaseLock(lock);
+		}
+	} catch (err) {
+		if (options.errorRef) options.errorRef.message = err instanceof Error ? err.message : String(err);
+		return null;
+	}
+}
+async function buildWorkerAtomic(dirname$2, outDir, entryPath, vendorImports, nodeEnv, meta) {
+	const parent = dirname(outDir);
+	mkdirSync(parent, { recursive: true });
+	const tmpDir = mkdtempSync(join(parent, ".ph-reactor-worker.tmp-"));
+	try {
+		const { ok, stderr } = await runWorkerBuild(dirname$2, tmpDir, { "reactor.worker": entryPath }, vendorImports, nodeEnv);
+		if (!ok || !existsSync(join(tmpDir, "reactor.worker.js"))) {
+			const detail = stderr.trim();
+			throw new Error(`reactor worker build failed${detail ? `:\n${detail}` : " (no output captured)"}`);
+		}
+		assertWorkerResolvable(tmpDir);
+		writeFileSync(join(tmpDir, META_FILE), JSON.stringify(meta, null, 2));
+		publishDirAtomic(tmpDir, outDir);
+	} catch (err) {
+		rmSync(tmpDir, {
+			recursive: true,
+			force: true
+		});
+		throw err;
+	}
+}
+/** Replace `outDir` with the finished `tmpDir`, old contents removed last. */
+function publishDirAtomic(tmpDir, outDir) {
+	const oldDir = `${outDir}.old-${process.pid}-${Date.now()}`;
+	if (existsSync(outDir)) renameSync(outDir, oldDir);
+	renameSync(tmpDir, outDir);
+	chmodSync(outDir, 493);
+	rmSync(oldDir, {
+		recursive: true,
+		force: true
+	});
+}
+const RELATIVE_SPECIFIER_PATTERNS = SPECIFIER_PATTERNS;
+function findRelativeSpecifiers(code) {
+	const found = /* @__PURE__ */ new Set();
+	for (const pattern of RELATIVE_SPECIFIER_PATTERNS) for (const match of code.matchAll(pattern)) {
+		const spec = match[1];
+		if (spec.startsWith("./") || spec.startsWith("../")) found.add(spec);
+	}
+	return [...found];
+}
+function normalizeBundlePath(fromFile, spec) {
+	const segments = fromFile.split("/").slice(0, -1);
+	for (const part of spec.split("/")) {
+		if (part === "" || part === ".") continue;
+		if (part === "..") {
+			if (segments.length === 0) return "";
+			segments.pop();
+			continue;
+		}
+		segments.push(part);
+	}
+	return segments.join("/");
+}
+/**
+* Scan the emitted JS files REACHABLE from the entry via import statements
+* for specifiers a worker cannot resolve. Vendor externals were rewritten to
+* ../__vendor__/ relative paths, so anything bare that survives in the graph
+* is a real defect.
+*
+* Deliberately a graph walk, not a directory walk: the bundled reactor code
+* carries `new URL(..., import.meta.url)` references to its node
+* worker-thread entries (executor/projection workers), which Vite emits as
+* stray assets full of node-only imports. They are unreachable dead weight in
+* a browser bundle — the production vendor output tolerates the same files —
+* and must not fail the build.
+*/
+function findBundleSpecifierOffenders(bundleDir, entry = REACTOR_WORKER_ENTRY) {
+	const offenders = [];
+	walkBundleGraph(bundleDir, entry, (file, code) => {
+		const specs = findDisallowedSpecifiers(code);
+		if (specs.length > 0) offenders.push({
+			file,
+			specs
+		});
+		return true;
+	});
+	return offenders;
+}
+function walkBundleGraph(bundleDir, entry, visit) {
+	const seen = /* @__PURE__ */ new Set();
+	const queue = [entry];
+	while (queue.length > 0) {
+		const rel = queue.shift();
+		if (seen.has(rel)) continue;
+		seen.add(rel);
+		const full = join(bundleDir, rel);
+		if (!existsSync(full) || statSync(full).isDirectory()) continue;
+		if (!rel.endsWith(".js") && !rel.endsWith(".mjs")) continue;
+		const code = readFileSync(full, "utf8");
+		if (!visit(rel, code)) return false;
+		for (const spec of findRelativeSpecifiers(code)) {
+			const next = normalizeBundlePath(rel, spec);
+			if (next) queue.push(next);
+		}
+	}
+	return true;
+}
+function assertWorkerResolvable(bundleDir) {
+	const offenders = findBundleSpecifierOffenders(bundleDir);
+	if (offenders.length > 0) throw new Error("reactor worker bundle contains module specifiers a worker cannot resolve:\n" + offenders.map((o) => `  ${o.file}: ${o.specs.join(", ")}`).join("\n"));
+}
+const WORKER_UNSAFE_MARKERS = ["__PH_DYNAMIC_BASE__", "vite:preloadError"];
+/** The page-only markers present in `code`, in a fixed order. */
+function findWorkerUnsafeMarkers(code) {
+	return WORKER_UNSAFE_MARKERS.filter((marker) => code.includes(marker));
+}
+/**
+* The subset of the vendor's entries a worker may import.
+*
+* The vendor build keeps the React family external: its chunks carry bare
+* `import "react"` statements that the PAGE resolves through its import map.
+* A worker resolves no import map, so externalizing a vendor spec whose chunk
+* closure reaches such an import would kill the worker on its first load —
+* and the chunk graph is shared across vendor entries, so even a React-free
+* module (e.g. an rpc subpath) can be entangled with React through a shared
+* chunk. The vendor is also built for the page: a dynamic-base build rewrites
+* its asset URLs onto a global only the page sets, and its dynamic imports go
+* through Vite's preload helper, which needs `document`. Each entry's own
+* closure inside the vendor dir decides: clean closure, worker-safe; anything
+* bare or page-only in it (see {@link findWorkerUnsafeMarkers}), or a missing
+* entry file, bundled into the worker instead.
+*/
+function workerSafeVendorImports(vendorDir, vendorImports) {
+	const safe = {};
+	for (const [spec, url] of Object.entries(vendorImports)) {
+		const entryFile = url.slice(url.lastIndexOf("/") + 1);
+		if (!existsSync(join(vendorDir, entryFile))) continue;
+		if (walkBundleGraph(vendorDir, entryFile, (_file, code) => findDisallowedSpecifiers(code).length === 0 && findWorkerUnsafeMarkers(code).length === 0)) safe[spec] = url;
+	}
+	return safe;
+}
+/**
+* Builds arbitrary worker-loadable entries with the worker build config.
+* Exported for the local-package bundles, which need the same self-contained
+* output and vendor externalization at a different depth.
+*/
+function runWorkerBuildEntries(dirname, outDir, entries, vendorImports, nodeEnv, vendorPrefix = "../__vendor__/") {
+	return runWorkerBuild(dirname, outDir, entries, vendorImports, nodeEnv, vendorPrefix);
+}
+function runWorkerBuild(dirname, outDir, entries, vendorImports, nodeEnv, vendorPrefix = "../__vendor__/") {
+	const workerPath = join(outDir, "build-worker.mjs");
+	writeFileSync(workerPath, WORKER_BUILD_WORKER);
+	return new Promise((resolve) => {
+		const child = spawn(process.execPath, [
+			workerPath,
+			dirname,
+			outDir,
+			JSON.stringify(entries),
+			JSON.stringify(vendorImports),
+			nodeEnv,
+			resolveBuilderVite() ?? "",
+			vendorPrefix
+		], {
+			cwd: dirname,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+		let stderr = "";
+		child.stdout.on("data", (d) => {
+			stderr += String(d);
+		});
+		child.stderr.on("data", (d) => {
+			stderr += String(d);
+		});
+		child.on("exit", (code) => {
+			rmSync(workerPath, { force: true });
+			resolve({
+				ok: code === 0,
+				stderr
+			});
+		});
+		child.on("error", (e) => resolve({
+			ok: false,
+			stderr: String(e)
+		}));
+	});
+}
+/**
+* The vite installed next to this module. The subprocess must run the vite
+* this build config was written against: a consumer project can pin an older
+* vite/rolldown (overrides) whose bundler leaves unresolvable specifiers bare
+* instead of erroring and shims node builtins differently — the output guard
+* then correctly rejects the bundle. builder-tools declares vite as a direct
+* dependency, so this resolution works wherever builder-tools is installed.
+*/
+function resolveBuilderVite() {
+	try {
+		return createRequire(import.meta.url).resolve("vite");
+	} catch {
+		return null;
+	}
+}
+/**
+* The build subprocess (same pattern as the vendor's). Loads builder-tools'
+* own vite (argv; project fallback) and builds the given entries with
+* relative base, so chunk/asset URLs resolve against each script's own URL
+* under any deploy base. argv: dirname, outDir, entriesJSON (name ->
+* absolute entry path), vendorImportsJSON, nodeEnv, vitePath, vendorPrefix
+* (relative path from the out dir to __vendor__/, e.g. "../__vendor__/").
+*/
+const WORKER_BUILD_WORKER = `
+import { createRequire } from 'node:module';
+import { isAbsolute } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+const [dirname, outDir, entriesJSON, vendorImportsJSON, nodeEnvArg, vitePathArg, vendorPrefixArg] = process.argv.slice(2);
+const nodeEnv = nodeEnvArg ?? 'development';
+const entries = JSON.parse(entriesJSON);
+const vendorImports = JSON.parse(vendorImportsJSON ?? '{}');
+const vendorPrefix = vendorPrefixArg || '../__vendor__/';
+const externalSet = new Set(Object.keys(vendorImports));
+const vendorPath = (spec) => {
+  const url = vendorImports[spec];
+  return vendorPrefix + url.slice(url.lastIndexOf('/') + 1);
+};
+const reqProj = createRequire(dirname + '/noop.js');
+// pathToFileURL: on Windows import('D:\\\\...') parses "D:" as a URL scheme.
+const vitePath = vitePathArg || reqProj.resolve('vite');
+const { build } = await import(pathToFileURL(vitePath).href);
+// Resolve bare specifiers from the project (same plugin as the vendor build):
+// prefer the bundler's browser-condition-aware resolution, fall back to the
+// worker's own resolution for Rolldown's realpath-anchoring bug.
+const phResolveCache = new Map();
+const phWorkerResolve = {
+  name: 'ph-reactor-worker-resolve', enforce: 'pre',
+  async resolveId(source, importer, options) {
+    if (externalSet.has(source)) return null;
+    if (source[0] === '\\0' || source[0] === '.' || isAbsolute(source)) return null;
+    if (source.startsWith('node:') || source.startsWith('data:')) return null;
+    let viaBundler = null;
+    try { viaBundler = await this.resolve(source, importer, { ...options, skipSelf: true }); } catch {}
+    if (viaBundler) return viaBundler;
+    if (phResolveCache.has(source)) return phResolveCache.get(source);
+    let resolved = null;
+    try { resolved = fileURLToPath(import.meta.resolve(source)); } catch {}
+    phResolveCache.set(source, resolved);
+    return resolved;
+  },
+};
+// A worker has no window: on a failed dynamic import, the preload helper's
+// window.dispatchEvent would throw a ReferenceError in place of the real error.
+const PRELOAD_HELPER_ID = '\\0vite/preload-helper.js';
+const PRELOAD_DISPATCH = 'window.dispatchEvent(';
+const phWorkerPreloadHelper = {
+  name: 'ph-reactor-worker-preload-helper',
+  transform(code, id) {
+    if (id !== PRELOAD_HELPER_ID) return null;
+    if (code.split(PRELOAD_DISPATCH).length !== 2) {
+      this.error('expected exactly one ' + PRELOAD_DISPATCH + ' in ' + PRELOAD_HELPER_ID);
+    }
+    return { code: code.replace(PRELOAD_DISPATCH, 'globalThis.dispatchEvent?.('), map: null };
+  },
+};
+await build({
+  root: dirname, configFile: false, logLevel: 'error',
+  // The project's public/ dir belongs to the app build, not this bundle.
+  publicDir: false,
+  // Relative base: emitted chunk/asset URLs resolve against the worker
+  // script's own URL, so the bundle works under any deploy base.
+  base: './',
+  define: {
+    'process.env.NODE_ENV': JSON.stringify(nodeEnv),
+    'import.meta.env.BASE_URL': JSON.stringify('./'),
+  },
+  plugins: [phWorkerResolve, phWorkerPreloadHelper],
+  // pglite ships nested web workers as ES-module chunks.
+  worker: { format: 'es' },
+  build: {
+    // Always minified, dev included: the bundle is browser-served output
+    // (sourcemaps carry the debugging story), and minification strips the
+    // JSDoc comments whose embedded code samples (kysely's, viem's) would
+    // otherwise trip the bare-specifier guard below.
+    outDir, emptyOutDir: false, minify: true, target: 'esnext', sourcemap: true,
+    // No document in a worker: the module-preload polyfill and preload helper
+    // touch the DOM, so dynamic imports must stay plain import().
+    modulePreload: false,
+    rollupOptions: {
+      input: entries,
+      // A models entry is pure re-exports; without this the bundler treats
+      // its exports as unused and tree-shakes the whole file to nothing.
+      // Harmless for the worker entry, which exports nothing to preserve.
+      preserveEntrySignatures: 'strict',
+      external: (id) => externalSet.has(id),
+      output: {
+        format: 'es', entryFileNames: '[name].js',
+        // Chunks live at the bundle root, not a chunks/ subdir: the vendor
+        // paths below are emitted VERBATIM into every chunk, so all modules
+        // must sit at the same depth for ../__vendor__/ to resolve.
+        chunkFileNames: '[name]-[hash].js', assetFileNames: 'assets/[name]-[hash][extname]',
+        paths: (id) => (externalSet.has(id) ? vendorPath(id) : id),
+      },
+    },
+  },
+});
+`;
+const WORKER_BUILD_WORKER_HASH = createHash("sha256").update(WORKER_BUILD_WORKER).digest("hex").slice(0, 16);
+//#endregion
+//#region connect-utils/worker-packages-build.ts
+/**
+* Prebuild a project's local packages into worker-loadable model bundles.
+*
+* The reactor worker gets document models from the registry CDN or from what
+* Connect statically bundled. A project's own (`provider: "local"`) package is
+* in neither, so its document types have no reducer in the worker and their
+* load jobs fail. Dev solves this by pointing the worker at the dev server's
+* transformed models entry; a production deployment has no dev server, so the
+* entry is prebuilt here, next to the worker bundle it is loaded beside.
+*
+* Each package's `browser/document-models/index.js` (reducers only: no React,
+* no CSS, no editors) is built self-contained, with the worker-safe subset of
+* the vendor externalized onto `../../__vendor__/` - two levels up, since
+* these land in `__reactor_worker__/packages/`. A `manifest.json` names what
+* was built so the tab can turn it into package sources without guessing.
+*/
+/** Served under `<base>__reactor_worker__/packages/`. */
+const WORKER_PACKAGES_MANIFEST = "manifest.json";
+/** Vendor is two levels up from `__reactor_worker__/packages/`. */
+const VENDOR_PREFIX = "../../__vendor__/";
+function readVersion(root) {
+	try {
+		const meta = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
+		return typeof meta.version === "string" ? meta.version : void 0;
+	} catch {
+		return;
+	}
+}
+/**
+* A package root's models entry, or null when it ships none.
+*
+* Two roots are possible and both are normal: an installed dependency under
+* `node_modules/<name>`, and the project itself - the vetra case, where the
+* project *is* the local package and has no self-link in node_modules.
+*/
+function resolvePackageModels(dirname, name) {
+	const roots = [];
+	try {
+		roots.push(realpathSync(join(dirname, "node_modules", name)));
+	} catch {}
+	if (readProjectName(dirname) === name) roots.push(dirname);
+	for (const root of roots) {
+		const entryPath = join(root, "dist", "browser", "document-models", "index.js");
+		if (existsSync(entryPath)) return {
+			entryPath,
+			version: readVersion(root)
+		};
+	}
+	return null;
+}
+function readProjectName(dirname) {
+	try {
+		const meta = JSON.parse(readFileSync(join(dirname, "package.json"), "utf8"));
+		return typeof meta.name === "string" ? meta.name : void 0;
+	} catch {
+		return;
+	}
+}
+/**
+* The project's own package name when it ships a models bundle, so a caller
+* can include it beside the configured `provider: "local"` packages. A vetra
+* project declares no package entry for itself, yet its models are exactly
+* the ones the worker is missing.
+*/
+function ownProjectPackage(dirname) {
+	const name = readProjectName(dirname);
+	if (!name) return void 0;
+	return resolvePackageModels(dirname, name) ? name : void 0;
+}
+/**
+* Build each local package's models entry into `outDir` and write the
+* manifest the tab reads. Returns the manifest entries (empty when no local
+* package ships a models bundle), or null when the build itself failed -
+* `errorRef` then carries the cause. Both of those remove `outDir`, so a
+* previous build's bundles never outlive the packages they came from.
+*/
+async function prebuildWorkerPackages(options) {
+	const nodeEnv = options.nodeEnv ?? "production";
+	const resolved = [];
+	for (const name of options.packages) {
+		const models = resolvePackageModels(options.dirname, name);
+		if (!models) continue;
+		resolved.push({
+			entry: {
+				name,
+				version: models.version,
+				file: workerPackageFileName(name)
+			},
+			entryPath: models.entryPath
+		});
+	}
+	if (resolved.length === 0) {
+		rmSync(options.outDir, {
+			recursive: true,
+			force: true
+		});
+		return [];
+	}
+	const vendorImports = options.safeVendorImports ?? (options.vendor ? workerSafeVendorImports(options.vendor.dir, options.vendor.imports) : {});
+	const entries = Object.fromEntries(resolved.map((item) => [item.entry.file.replace(/\.js$/, ""), item.entryPath]));
+	const parent = dirname(options.outDir);
+	mkdirSync(parent, { recursive: true });
+	const tmpDir = mkdtempSync(join(parent, ".ph-worker-packages.tmp-"));
+	try {
+		const { ok, stderr } = await runWorkerBuildEntries(options.dirname, tmpDir, entries, vendorImports, nodeEnv, VENDOR_PREFIX);
+		const missing = resolved.filter((item) => !existsSync(join(tmpDir, item.entry.file)));
+		if (!ok || missing.length > 0) {
+			const detail = stderr.trim();
+			throw new Error(`worker package bundles failed to build${missing.length > 0 ? ` (missing: ${missing.map((m) => m.entry.name).join(", ")})` : ""}${detail ? `:\n${detail}` : ""}`);
+		}
+		for (const item of resolved) {
+			const offenders = findBundleSpecifierOffenders(tmpDir, item.entry.file);
+			if (offenders.length > 0) throw new Error(`worker package bundle for ${item.entry.name} contains module specifiers a worker cannot resolve:\n` + offenders.map((o) => `  ${o.file}: ${o.specs.join(", ")}`).join("\n"));
+		}
+		const manifest = resolved.map((item) => item.entry);
+		writeFileSync(join(tmpDir, WORKER_PACKAGES_MANIFEST), JSON.stringify(manifest, null, 2));
+		publishDirAtomic(tmpDir, options.outDir);
+		return manifest;
+	} catch (err) {
+		rmSync(tmpDir, {
+			recursive: true,
+			force: true
+		});
+		rmSync(options.outDir, {
+			recursive: true,
+			force: true
+		});
+		if (options.errorRef) options.errorRef.message = err instanceof Error ? err.message : String(err);
+		return null;
+	}
+}
+//#endregion
 //#region connect-utils/helpers.ts
 const DEFAULT_CONNECT_OUTDIR = ".ph/connect-build/dist/";
 function resolveViteConfigPath(options) {
@@ -655,7 +1486,8 @@ function resolveConnectPackageJson(root = process.cwd()) {
 */
 function resolveConnectBundle(root = process.cwd()) {
 	const connectIndexPath = resolvePackage("@powerhousedao/connect", root);
-	return join(connectIndexPath.substring(0, connectIndexPath.indexOf("connect") + 7), "dist/");
+	const connectRootPath = connectIndexPath.substring(0, connectIndexPath.indexOf("connect") + 7);
+	return join(connectRootPath, "dist/");
 }
 function resolveConnectPublicDir(root = process.cwd()) {
 	const connectIconPath = resolvePackage("@powerhousedao/connect/public/icon.ico", root);
@@ -939,7 +1771,7 @@ const VENDOR_MIME = {
 const VENDOR_MODE = process.env.PH_CONNECT_EXTERNALIZE_VENDOR === "1";
 const VENDOR_EXTRA = (process.env.PH_CONNECT_VENDOR_EXTRA ?? "").split(",").map((s) => s.trim()).filter(Boolean);
 const HEAVY_LIBS = [...DEFAULT_VENDOR_INCLUDE, ...VENDOR_EXTRA];
-function withBase(base, p) {
+function withBase$1(base, p) {
 	return `${base}${p}`.replace(/\/{2,}/g, "/");
 }
 function externalizePlugin(externals) {
@@ -1002,7 +1834,7 @@ async function devReactImportmapPlugin(projectRoot = process.cwd()) {
 			REACT_DEPS.forEach((d) => include.add(d));
 			if (vendorActive) {
 				HEAVY_LIBS.forEach((d) => include.delete(d));
-				cfg.optimizeDeps.exclude = [...new Set([...cfg.optimizeDeps.exclude ?? [], ...HEAVY_LIBS])];
+				cfg.optimizeDeps.exclude = [.../* @__PURE__ */ new Set([...cfg.optimizeDeps.exclude ?? [], ...HEAVY_LIBS])];
 			}
 			cfg.optimizeDeps.include = [...include];
 		},
@@ -1021,7 +1853,7 @@ async function devReactImportmapPlugin(projectRoot = process.cwd()) {
 			}));
 			if (vendorActive) {
 				const vendorDir = vendor.vendorDir;
-				const vendorPrefixes = [withBase(base, VENDOR_URL_PREFIX), VENDOR_URL_PREFIX];
+				const vendorPrefixes = [withBase$1(base, VENDOR_URL_PREFIX), VENDOR_URL_PREFIX];
 				server.middlewares.use((req, res, next) => {
 					const url = (req.url ?? "").split("?")[0];
 					const prefix = vendorPrefixes.find((p) => url.startsWith(p));
@@ -1043,7 +1875,7 @@ async function devReactImportmapPlugin(projectRoot = process.cwd()) {
 					});
 				});
 			}
-			const shimPrefixes = [withBase(base, SHIM_PATH), `/${SHIM_PATH}`];
+			const shimPrefixes = [withBase$1(base, SHIM_PATH), `/${SHIM_PATH}`];
 			server.middlewares.use((req, res, next) => {
 				const prefix = shimPrefixes.find((p) => req.url?.startsWith(p));
 				if (!prefix) return next();
@@ -1057,7 +1889,7 @@ async function devReactImportmapPlugin(projectRoot = process.cwd()) {
 					return;
 				}
 				const browserHash = info.browserHash ?? optimizer.metadata.browserHash;
-				const depUrl = `${withBase(base, VITE_DEPS_PATH)}/${path.basename(info.file)}?v=${browserHash}`;
+				const depUrl = `${withBase$1(base, VITE_DEPS_PATH)}/${path.basename(info.file)}?v=${browserHash}`;
 				const names = namedExports.get(id) ?? [];
 				res.setHeader("Content-Type", "application/javascript");
 				res.end(`import * as M from ${JSON.stringify(depUrl)};\nconst ns = M.default ?? M;\nexport default ns;\n` + (names.length ? `export const { ${names.join(", ")} } = ns;\n` : ""));
@@ -1068,12 +1900,12 @@ async function devReactImportmapPlugin(projectRoot = process.cwd()) {
 			handler(html, ctx) {
 				const browserHash = ctx.server?.environments.client.depsOptimizer?.metadata.browserHash;
 				if (!browserHash) return;
-				const shimPrefix = withBase(base, SHIM_PATH);
+				const shimPrefix = withBase$1(base, SHIM_PATH);
 				const imports = Object.fromEntries(REACT_DEPS.map((id) => [id, `${shimPrefix}${id}.js?v=${browserHash}`]));
 				let dynamicBaseScript = "";
 				if (vendorActive) {
-					for (const [spec, url] of Object.entries(vendor.imports)) imports[spec] = withBase(base, url);
-					if (vendor.imports["@powerhousedao/connect"]) imports["ph-bundled-packages-virtual"] = withBase(base, BUNDLED_PACKAGES_DEV_URL);
+					for (const [spec, url] of Object.entries(vendor.imports)) imports[spec] = withBase$1(base, url);
+					if (vendor.imports["@powerhousedao/connect"]) imports["ph-bundled-packages-virtual"] = withBase$1(base, BUNDLED_PACKAGES_DEV_URL);
 					dynamicBaseScript = `<script>globalThis.__PH_DYNAMIC_BASE__=${JSON.stringify(base)};<\/script>\n`;
 				}
 				return html.replace(/<script type="importmap">[\s\S]*?<\/script>/, `${dynamicBaseScript}<script type="importmap">${JSON.stringify({ imports }, null, 2)}<\/script>`);
@@ -1118,7 +1950,7 @@ function connectFaviconPlugin(opts = {}) {
 					res.end(readFileSync(resolved.id));
 				}).catch(() => next());
 			};
-			const paths = new Set([faviconRoute, "/icon.ico"]);
+			const paths = /* @__PURE__ */ new Set([faviconRoute, "/icon.ico"]);
 			for (const path of paths) server.middlewares.use(path, handler);
 		},
 		async generateBundle(_options, bundle) {
@@ -1158,13 +1990,20 @@ function readProjectPackageInfo(projectRoot) {
 }
 function phConfigPlugin(options) {
 	const localPackage = readProjectPackageInfo(options.projectRoot ?? process.cwd());
-	const withDefaults = deepMerge(DEFAULT_CONNECT_CONFIG, options.connect ?? {});
+	const sourceSettings = {
+		connect: options.connect,
+		workflows: options.workflows
+	};
+	const conflict = workflowsSettingConflict(sourceSettings);
+	if (conflict) console.warn(`[powerhouse] ${conflict}`);
+	const withDefaults = resolveSourceConnect(sourceSettings);
 	const mergedConnect = options.cliConnectOverride ? deepMerge(withDefaults, options.cliConnectOverride) : withDefaults;
-	const runtimeConfig = buildRuntimeConfig({
+	const source = {
 		packages: options.packages,
 		packageRegistryUrl: options.packageRegistryUrl,
 		connect: mergedConnect
-	}, localPackage);
+	};
+	const runtimeConfig = buildRuntimeConfig(source, localPackage);
 	const content = JSON.stringify({
 		$schema: RUNTIME_CONFIG_SCHEMA_URL,
 		...runtimeConfig
@@ -1217,11 +2056,13 @@ function toPwaContribution(manifest, fallbackLabel, onWarn) {
 	if (!isPlainObject(manifest)) return null;
 	const label = typeof manifest.name === "string" && manifest.name ? manifest.name : fallbackLabel;
 	let config = {};
-	if (manifest.pwa !== void 0) if (!isPlainObject(manifest.pwa)) onWarn(`PWA config: ${label} declares a non-object 'pwa' field in its manifest; ignored.`);
-	else {
-		const parsed = PwaConfigSchema.safeParse(manifest.pwa);
-		if (!parsed.success) onWarn(`PWA config: ${label}'s pwa fragment is invalid; ignored. ${formatZodIssues(parsed.error)}`);
-		else config = parsed.data;
+	if (manifest.pwa !== void 0) {
+		if (!isPlainObject(manifest.pwa)) onWarn(`PWA config: ${label} declares a non-object 'pwa' field in its manifest; ignored.`);
+		else {
+			const parsed = PwaConfigSchema.safeParse(manifest.pwa);
+			if (!parsed.success) onWarn(`PWA config: ${label}'s pwa fragment is invalid; ignored. ${formatZodIssues(parsed.error)}`);
+			else config = parsed.data;
+		}
 	}
 	config = withInferredCategory(config, manifest.category);
 	if (Object.keys(config).length === 0) return null;
@@ -1330,7 +2171,8 @@ function collectProjectPwaContribution(options) {
 		}
 		if (!isPlainObject(manifest)) return null;
 		const label = typeof manifest.name === "string" && manifest.name ? manifest.name : "project manifest";
-		const withCategory = withInferredCategory(manifest.pwa === void 0 ? {} : parsePwaConfigStrict(manifest.pwa, `pwa in ${manifestPath}`), manifest.category);
+		const config = manifest.pwa === void 0 ? {} : parsePwaConfigStrict(manifest.pwa, `pwa in ${manifestPath}`);
+		const withCategory = withInferredCategory(config, manifest.category);
 		if (Object.keys(withCategory).length === 0) return null;
 		return {
 			source: label,
@@ -1471,8 +2313,8 @@ const BASE_MANIFEST = {
 * declarative runtimeCaching option.
 */
 const BASE_PRECACHE = {
-	maximumFileSizeToCacheInBytes: 16 * 1024 * 1024,
-	globPatterns: ["**/*.{js,css,html,wasm,data,ico,png,svg,webp,woff,woff2}"],
+	maximumFileSizeToCacheInBytes: 16777216,
+	globPatterns: ["**/*.{js,css,html,wasm,data,ico,png,svg,webp,woff,woff2}", "__reactor_worker__/**/*.json"],
 	globIgnores: [
 		"**/powerhouse.config.json",
 		"**/*.map",
@@ -1738,6 +2580,91 @@ try {
 }
 `;
 //#endregion
+//#region connect-utils/vite-plugins/reactor-worker-dev.ts
+const DEV_BUNDLE_DIR = "node_modules/.ph-reactor-worker";
+function withBase(base, p) {
+	return `${base}${p}`.replace(/\/{2,}/g, "/");
+}
+/**
+* Dev-only: serve Connect's reactor SharedWorker bundle under
+* `<base>__reactor_worker__/`, building it lazily on first request.
+*
+* The dev server serves Connect from its prebuilt dist in node_modules, where
+* `dist/reactor.worker.js` is a library artifact no worker can resolve. The
+* tab GETs `worker-meta.json` here (JSON, no-cache, written by
+* `prebuildReactorWorker`) to find the bundle and fold its `sourceDigest`
+* into its version fingerprint; without this plugin that GET fails and the
+* worker feature reports itself unavailable instead of dying opaquely.
+*
+* Lazy because it is a full `vite build` of the reactor + PGlite graph. The
+* result is cached in node_modules/.ph-reactor-worker until the installed
+* Connect, its upstream dists, or builder-tools change (`computeSourceDigest`).
+*/
+function reactorWorkerDevPlugin(projectRoot) {
+	let base = "/";
+	let building = null;
+	const ensureBuilt = () => {
+		building ??= (async () => {
+			const errorRef = {};
+			const built = await prebuildReactorWorker({
+				dirname: projectRoot,
+				outDir: path.join(projectRoot, DEV_BUNDLE_DIR),
+				nodeEnv: "development",
+				errorRef
+			});
+			if (!built) {
+				console.warn(`[connect] reactor worker bundle build failed${errorRef.message ? `: ${errorRef.message}` : ""}`);
+				building = null;
+			}
+			return built;
+		})();
+		return building;
+	};
+	return {
+		name: "ph-reactor-worker-dev",
+		apply: "serve",
+		configResolved(config) {
+			base = config.base;
+		},
+		configureServer(server) {
+			const prefixes = [withBase(base, REACTOR_WORKER_URL_PREFIX), REACTOR_WORKER_URL_PREFIX];
+			server.middlewares.use((req, res, next) => {
+				const url = (req.url ?? "").split("?")[0];
+				const prefix = prefixes.find((p) => url.startsWith(p));
+				if (!prefix) return next();
+				const name = url.slice(prefix.length).replace(/^\/+/, "");
+				if (!name) return next();
+				(async () => {
+					const built = await ensureBuilt();
+					if (!built) {
+						res.statusCode = 503;
+						res.setHeader("Content-Type", "text/plain");
+						res.end("reactor worker bundle unavailable (build failed; see server log)");
+						return;
+					}
+					const file = path.join(built.outDir, name);
+					const rel = path.relative(built.outDir, file);
+					if (rel.startsWith("..") || path.isAbsolute(rel)) {
+						next();
+						return;
+					}
+					const stream = createReadStream(file);
+					stream.on("error", () => {
+						if (!res.headersSent) next();
+					});
+					stream.once("open", () => {
+						const ext = file.slice(file.lastIndexOf("."));
+						res.setHeader("Content-Type", REACTOR_WORKER_MIME[ext] ?? "text/javascript");
+						const hashed = !name.startsWith("reactor.worker.js") && !name.endsWith(".json");
+						res.setHeader("Cache-Control", hashed ? "public, max-age=31536000, immutable" : "no-cache");
+						stream.pipe(res);
+					});
+				})();
+			});
+		}
+	};
+}
+//#endregion
 //#region connect-utils/vite-plugins/theme-boot.ts
 /**
 * Marker attribute on the injected script. Serve-time injectors (e.g. the
@@ -1776,6 +2703,48 @@ function connectThemeBootPlugin() {
 	};
 }
 //#endregion
+//#region connect-utils/vite-plugins/vendor-import-map.ts
+function extractImports(raw) {
+	if (typeof raw !== "object" || raw === null) return {};
+	const imports = "imports" in raw ? raw.imports : void 0;
+	if (typeof imports !== "object" || imports === null) return {};
+	const out = {};
+	for (const [key, value] of Object.entries(imports)) if (typeof value === "string") out[key] = value;
+	return out;
+}
+function parseImportMap(raw) {
+	try {
+		return extractImports(JSON.parse(raw));
+	} catch {
+		return {};
+	}
+}
+const INLINE_IMPORTMAP = /<script type="importmap">([\s\S]*?)<\/script>/;
+function vendorImportMapPlugin(options) {
+	const vendorEntries = Object.keys(options.imports).length;
+	return {
+		name: "ph-vendor-import-map",
+		apply: "build",
+		transformIndexHtml(html) {
+			if (!vendorEntries) return;
+			const match = INLINE_IMPORTMAP.exec(html);
+			if (match) {
+				const merged = { imports: {
+					...parseImportMap(match[1]),
+					...options.imports
+				} };
+				return html.replace(INLINE_IMPORTMAP, `<script type="importmap">${JSON.stringify(merged)}<\/script>`);
+			}
+			return [{
+				tag: "script",
+				attrs: { type: "importmap" },
+				children: JSON.stringify({ imports: options.imports }),
+				injectTo: "head-prepend"
+			}];
+		}
+	};
+}
+//#endregion
 //#region connect-utils/vite-config.ts
 function getConnectHtmlTags(options = {}) {
 	const { registryUrl, injectTo = "head" } = options;
@@ -1896,7 +2865,8 @@ function getLocalPackageNamesFromPowerhouseConfig({ packages }) {
 }
 function getConnectBaseViteConfig(options) {
 	const mode = options.mode;
-	const fileEnv = loadEnv(mode, options.envDir ?? options.dirname, "PH_");
+	const envDir = options.envDir ?? options.dirname;
+	const fileEnv = loadEnv(mode, envDir, "PH_");
 	const env = loadConnectEnv({
 		processEnv: process.env,
 		fileEnv
@@ -1968,9 +2938,10 @@ function getConnectBaseViteConfig(options) {
 		});
 		const projectContribution = collectProjectPwaContribution({ projectRoot: options.dirname });
 		if (projectContribution) contributions.push(projectContribution);
+		const mergedPwa = mergePwaConfig(contributions, projectPwa, pwaWarn);
 		return connectPwaPlugins({
 			offlineEnabled,
-			pwa: mergePwaConfig(contributions, projectPwa, pwaWarn)
+			pwa: mergedPwa
 		});
 	})();
 	const reactExternal = [
@@ -2023,6 +2994,7 @@ function getConnectBaseViteConfig(options) {
 				packages: phPackages,
 				projectRoot: options.dirname,
 				connect: phConfig.connect,
+				workflows: phConfig.workflows,
 				packageRegistryUrl: phPackageRegistryUrl ?? void 0,
 				cliConnectOverride: options.cliConnectOverride
 			}),
@@ -2031,12 +3003,14 @@ function getConnectBaseViteConfig(options) {
 				projectRoot: options.dirname
 			}),
 			devReactImportmapPlugin(options.dirname),
+			reactorWorkerDevPlugin(options.dirname),
 			...plugins,
-			esmExternalRequirePlugin({ external: reactExternal }),
+			esmExternalRequirePlugin({ external: [...reactExternal, ...options.vendor && mode === "production" ? Object.keys(options.vendor.imports) : []] }),
 			reactSelfHostPlugin({
 				dirname: options.dirname,
 				dev: mode !== "production" || isDebug
 			}),
+			...options.vendor && mode === "production" ? [vendorImportMapPlugin({ imports: options.vendor.imports })] : [],
 			connectFaviconPlugin({ faviconPath: options.favicon }),
 			connectThemeBootPlugin(),
 			connectBuildHashPlugin(buildHash),
@@ -2047,10 +3021,13 @@ function getConnectBaseViteConfig(options) {
 			format: "es",
 			...options.dynamicBase ? { plugins: () => [connectDynamicBasePlugin({ forWorker: true })] } : {}
 		},
-		build: { sourcemap: true }
+		build: {
+			sourcemap: true,
+			rolldownOptions: { shimMissingExports: true }
+		}
 	};
 }
 //#endregion
-export { BUILD_HASH_FILE, DEFAULT_CONNECT_OUTDIR, DEFAULT_VENDOR_INCLUDE, DYNAMIC_BASE_PLACEHOLDER, EXTERNAL_PACKAGES_IMPORT, IMPORT_SCRIPT_FILE, LOCAL_PACKAGE_ID, PH_DIR_NAME, RUNTIME_CONFIG_SCHEMA_ID, RUNTIME_CONFIG_SCHEMA_URL, THEME_BOOT_MARKER, VENDOR_EXTERNAL, VENDOR_URL_PREFIX, appendToHtmlHead, backupIndexHtml, buildHashFromBuildOptions, computeBuildHash, connectBuildHashPlugin, connectDynamicBasePlugin, connectThemeBootPlugin, copyConnect, ensureNodeVersion, escapeForRegExp, getConnectBaseViteConfig, getConnectHtmlTags, makeImportScriptFromPackages, phConfigPlugin, prebuildConnectVendor, prependToHtmlHead, readJsonFile, removeBase64EnvValues, resolveConnectBundle, resolveConnectPackageJson, resolveConnectPublicDir, resolvePackage, resolveViteConfigPath, runShellScriptPlugin, runTsc, runtimeConfigSchema, stripVersionFromPackage };
+export { BUILDER_TOOLS_VERSION, BUILD_HASH_FILE, DEFAULT_CONNECT_OUTDIR, DEFAULT_VENDOR_INCLUDE, DYNAMIC_BASE_PLACEHOLDER, EXTERNAL_PACKAGES_IMPORT, IMPORT_SCRIPT_FILE, LOCAL_PACKAGE_ID, LOCK_STALE_MS, PH_DIR_NAME, REACTOR_WORKER_ENTRY, REACTOR_WORKER_MIME, REACTOR_WORKER_URL_PREFIX, RUNTIME_CONFIG_SCHEMA_ID, RUNTIME_CONFIG_SCHEMA_URL, THEME_BOOT_MARKER, VENDOR_EXTERNAL, VENDOR_URL_PREFIX, WORKER_PACKAGES_MANIFEST, acquireLock, appendToHtmlHead, backupIndexHtml, buildHashFromBuildOptions, computeBuildHash, computeSourceDigest, connectBuildHashPlugin, connectDynamicBasePlugin, connectThemeBootPlugin, copyConnect, distDirFingerprint, ensureNodeVersion, escapeForRegExp, findBundleSpecifierOffenders, findDisallowedSpecifiers, findWorkerUnsafeMarkers, getConnectBaseViteConfig, getConnectHtmlTags, makeImportScriptFromPackages, missingVendorEntries, ownProjectPackage, phConfigPlugin, prebuildConnectVendor, prebuildReactorWorker, prebuildWorkerPackages, prependToHtmlHead, publishDirAtomic, readJsonFile, releaseLock, removeBase64EnvValues, resolveConnectBundle, resolveConnectPackageJson, resolveConnectPublicDir, resolveOwnPackageVersion, resolvePackage, resolveReactorWorkerSource, resolveViteConfigPath, resolveWorkspacePackageDir, runShellScriptPlugin, runTsc, runWorkerBuildEntries, runtimeConfigSchema, stripVersionFromPackage, upstreamWorkerPackages, vendorImportMapPlugin, vendorRelativePath, withVendorBase, workerSafeVendorImports };
 
 //# sourceMappingURL=index.mjs.map