@powerhousedao/builder-tools 6.2.3-dev.44 → 6.2.3-dev.46

package/dist/index.mjs

@@ -1,10 +1,10 @@
 import { createRequire } from "node:module";
 import { createHash, randomUUID } from "node:crypto";
-import fs, { chmodSync, 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, workflowsSettingConflict } from "@powerhousedao/shared/connect";
+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";
@@ -294,15 +294,15 @@ function readCacheHit(importMapPath, include, external, versionDigest) {
 * Unresolvable specs contribute a "missing" sentinel, unknown versions
 * "unknown".
 */
-function resolveDepVersions(dirname$2, specs) {
-	const req = createRequire(join(dirname$2, "noop.js"));
+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 (pkg in seen) continue;
 		if (selfMeta === null) try {
-			selfMeta = JSON.parse(readFileSync(join(dirname$2, "package.json"), "utf8"));
+			selfMeta = JSON.parse(readFileSync(join(dirname$3, "package.json"), "utf8"));
 		} catch {
 			selfMeta = {};
 		}
@@ -311,7 +311,7 @@ function resolveDepVersions(dirname$2, specs) {
 		else {
 			version = "missing";
 			try {
-				const pkgRoot = realpathSync(join(dirname$2, "node_modules", pkg));
+				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 {
@@ -520,12 +520,12 @@ function withVendorBase(imports, base) {
 * 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$3, vendorDir, include, external, versionDigest, versions, base, nodeEnv) {
+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$3, tmpDir, include, external, base, nodeEnv);
+		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();
@@ -744,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) {
@@ -1053,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) {
@@ -1135,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));
@@ -1157,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();
@@ -1171,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` : ""));
@@ -1182,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>`);
@@ -1596,7 +2314,7 @@ const BASE_MANIFEST = {
 */
 const BASE_PRECACHE = {
 	maximumFileSizeToCacheInBytes: 16777216,
-	globPatterns: ["**/*.{js,css,html,wasm,data,ico,png,svg,webp,woff,woff2}"],
+	globPatterns: ["**/*.{js,css,html,wasm,data,ico,png,svg,webp,woff,woff2}", "__reactor_worker__/**/*.json"],
 	globIgnores: [
 		"**/powerhouse.config.json",
 		"**/*.map",
@@ -1862,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
@@ -2200,6 +3003,7 @@ function getConnectBaseViteConfig(options) {
 				projectRoot: options.dirname
 			}),
 			devReactImportmapPlugin(options.dirname),
+			reactorWorkerDevPlugin(options.dirname),
 			...plugins,
 			esmExternalRequirePlugin({ external: [...reactExternal, ...options.vendor && mode === "production" ? Object.keys(options.vendor.imports) : []] }),
 			reactSelfHostPlugin({
@@ -2224,6 +3028,6 @@ function getConnectBaseViteConfig(options) {
 	};
 }
 //#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, missingVendorEntries, phConfigPlugin, prebuildConnectVendor, prependToHtmlHead, readJsonFile, removeBase64EnvValues, resolveConnectBundle, resolveConnectPackageJson, resolveConnectPublicDir, resolvePackage, resolveViteConfigPath, runShellScriptPlugin, runTsc, runtimeConfigSchema, stripVersionFromPackage, vendorImportMapPlugin, withVendorBase };
+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