@powerhousedao/builder-tools 6.2.3-dev.2 → 6.2.3-dev.20

package/dist/index.d.mts

@@ -1,3 +1,4 @@
+import { DYNAMIC_BASE_PLACEHOLDER } from "@powerhousedao/shared/connect";
 import { CommonServerOptions, HtmlTagDescriptor, InlineConfig, Plugin } from "vite";
 import { PowerhouseConfig, PowerhousePackage } from "@powerhousedao/config";
 import { PHConnectRuntimeConfig } from "@powerhousedao/shared/clis";
@@ -61,9 +62,9 @@ declare function connectBuildHashPlugin(buildHash: string): Plugin;
 //#endregion
 //#region connect-utils/externalize-vendor.d.ts
 interface VendorPrebuildOptions {
-  /** Project root (the reactor-project dir). */
+  /** Project root the vendor deps resolve from. */
   dirname: string;
-  /** Bare specifiers to bundle into the vendor (defaults to the heavy libs). */
+  /** Specifiers to prebuild into the vendor (defaults to the dev set). */
   include?: string[];
   /** Specifiers left external to the build (defaults to the React family). */
   external?: string[];
@@ -73,6 +74,18 @@ interface VendorPrebuildOptions {
   errorRef?: {
     message?: string;
   };
+  /**
+   * The APP's base — the same string the app build uses (the dynamic-base
+   * placeholder, or a normalized deploy base like "/app/"). The vendor's own
+   * build base is this plus the vendor segment, so emitted asset URLs land
+   * under <app-base>__vendor__/. Default: the dynamic placeholder + segment
+   * (dev behavior). Import-map values stay base-relative; the production
+   * build strips the leading slash (values then resolve against the page URL
+   * under any deploy base), the dev flow prefixes its own base.
+   */
+  base?: string;
+  /** NODE_ENV define for the vendor build (default "development"). */
+  nodeEnv?: "development" | "production";
 }
 /**
  * The stable Connect libraries worth prebuilding. The React family is NOT here —
@@ -88,8 +101,10 @@ declare const DEFAULT_VENDOR_INCLUDE: string[];
 declare const VENDOR_EXTERNAL: string[];
 interface PrebuiltVendor {
   vendorDir: string;
-  /** import map: bare specifier -> "/__vendor__/<entry>.js". */
+  /** import map: bare specifier -> "/__vendor__/<entry>.js" (base-relative). */
   imports: Record<string, string>;
+  /** Resolved versions of every included + external package. */
+  versions: Record<string, string>;
 }
 /** URL prefix the vendor bundle is served under by the dev middleware. */
 declare const VENDOR_URL_PREFIX = "/__vendor__/";
@@ -99,6 +114,25 @@ declare const VENDOR_URL_PREFIX = "/__vendor__/";
  * Returns null on any failure (caller falls back to a normal dev server).
  */
 declare function prebuildConnectVendor(options: VendorPrebuildOptions): Promise<PrebuiltVendor | null>;
+/**
+ * The published specifiers whose entry file the vendor build never emitted.
+ * URLs are base-less (`/__vendor__/x.js`) and resolve inside `vendorDir`.
+ */
+declare function missingVendorEntries(vendorDir: string, imports: Record<string, string>): {
+  spec: string;
+  url: string;
+}[];
+/**
+ * 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.
+ */
+declare function withVendorBase(imports: Record<string, string>, base: string): Record<string, string>;
 //#endregion
 //#region connect-utils/types.d.ts
 type IConnectOptions = {
@@ -127,6 +161,16 @@ type IConnectOptions = {
   cliPackageRegistryUrl?: string;
   dynamicBase?: boolean;
   favicon?: string;
+  /**
+   * Production vendor: the prebuilt shared-dependency bundle's import map and
+   * version table (from `prebuildConnectVendor`). When set on a production
+   * build, the shared specifiers are externalized from the app bundle and
+   * merged into the page import map. Build input only.
+   */
+  vendor?: {
+    imports: Record<string, string>;
+    versions: Record<string, string>;
+  };
 };
 type ConnectCommonOptions = {
   base?: string;
@@ -315,6 +359,11 @@ declare const runtimeConfigSchema: {
               readonly description: "Studio mode. Enables builder-only capabilities: Connect loads the vetra package and exposes DocumentModel (and vetra spec types) as creatable documents. Forced on by `ph vetra` / `ph connect studio`; false by default.";
               readonly default: false;
             };
+            readonly workflowsEnabled: {
+              readonly type: "boolean";
+              readonly description: "Powerhouse workflows in Connect. When true the tab loads the @powerhousedao/workflow package (workflow + connection documents, their editors and Workflow Studio) and the reactor worker registers its document models. Connect's counterpart to the reactor-side `workflows.enabled` / PH_WORKFLOWS_ENABLED; independent of studioMode. False by default.";
+              readonly default: false;
+            };
           };
         };
         readonly ai: {
@@ -939,16 +988,6 @@ declare function getConnectHtmlTags(options?: {
 declare function getConnectBaseViteConfig(options: IConnectOptions): InlineConfig;
 //#endregion
 //#region connect-utils/vite-plugins/dynamic-base.d.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.
- */
-declare const DYNAMIC_BASE_PLACEHOLDER = "/__PH_DYNAMIC_BASE__/";
 /**
  * Rewrites the placeholder base in emitted JS chunks to a runtime expression so
  * one built `dist/connect` serves under any subpath. Rolldown-native: per-match
@@ -1018,5 +1057,11 @@ declare const THEME_BOOT_MARKER = "data-ph-theme-boot";
  */
 declare function connectThemeBootPlugin(): Plugin;
 //#endregion
-export { BUILD_HASH_FILE, BuildHashInput, ConnectBuildOptions, ConnectCommonOptions, ConnectPreviewOptions, ConnectStudioOptions, DEFAULT_CONNECT_OUTDIR, DEFAULT_VENDOR_INCLUDE, DYNAMIC_BASE_PLACEHOLDER, EXTERNAL_PACKAGES_IMPORT, IConnectOptions, IMPORT_SCRIPT_FILE, LOCAL_PACKAGE_ID, PH_DIR_NAME, PhConfigPluginOptions, PrebuiltVendor, RUNTIME_CONFIG_SCHEMA_ID, RUNTIME_CONFIG_SCHEMA_URL, THEME_BOOT_MARKER, VENDOR_EXTERNAL, VENDOR_URL_PREFIX, VendorPrebuildOptions, ViteDevOptions, 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 };
+//#region connect-utils/vite-plugins/vendor-import-map.d.ts
+type VendorImportMapOptions = {
+  /** bare specifier -> URL (already base-prefixed by the caller). */imports: Record<string, string>;
+};
+declare function vendorImportMapPlugin(options: VendorImportMapOptions): Plugin;
+//#endregion
+export { BUILD_HASH_FILE, BuildHashInput, ConnectBuildOptions, ConnectCommonOptions, ConnectPreviewOptions, ConnectStudioOptions, DEFAULT_CONNECT_OUTDIR, DEFAULT_VENDOR_INCLUDE, DYNAMIC_BASE_PLACEHOLDER, EXTERNAL_PACKAGES_IMPORT, IConnectOptions, IMPORT_SCRIPT_FILE, LOCAL_PACKAGE_ID, PH_DIR_NAME, PhConfigPluginOptions, PrebuiltVendor, RUNTIME_CONFIG_SCHEMA_ID, RUNTIME_CONFIG_SCHEMA_URL, THEME_BOOT_MARKER, VENDOR_EXTERNAL, VENDOR_URL_PREFIX, VendorImportMapOptions, VendorPrebuildOptions, ViteDevOptions, 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 };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../connect-utils/constants.ts","../connect-utils/vite-plugins/build-hash.ts","../connect-utils/externalize-vendor.ts","../connect-utils/types.ts","../connect-utils/helpers.ts","../connect-utils/runtime-config-schema.ts","../connect-utils/vite-config.ts","../connect-utils/vite-plugins/dynamic-base.ts","../connect-utils/vite-plugins/ph-config.ts","../connect-utils/vite-plugins/theme-boot.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../connect-utils/constants.ts","../connect-utils/vite-plugins/build-hash.ts","../connect-utils/externalize-vendor.ts","../connect-utils/types.ts","../connect-utils/helpers.ts","../connect-utils/runtime-config-schema.ts","../connect-utils/vite-config.ts","../connect-utils/vite-plugins/dynamic-base.ts","../connect-utils/vite-plugins/ph-config.ts","../connect-utils/vite-plugins/theme-boot.ts","../connect-utils/vite-plugins/vendor-import-map.ts"],"mappings":"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"}

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, 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 { DEFAULT_CONNECT_CONFIG, DYNAMIC_BASE_PLACEHOLDER, PWA_FILE_HANDLER_ACTION, buildRuntimeConfig, deepMerge, loadConnectEnv, mergeManifest, mergePwaConfig, normalizeBasePath, phConnectRuntimeConfigSchema, powerhousePackageSchema, setConnectEnv, unionStrings, withInferredCategory } 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";
@@ -91,16 +91,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.
@@ -144,7 +134,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 +151,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 +231,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 +272,72 @@ 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$2, specs) {
+	const req = createRequire(join(dirname$2, "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$2, "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$2, "node_modules", pkg));
+				const meta = JSON.parse(readFileSync(join(pkgRoot, "package.json"), "utf8"));
+				version = String(meta.version ?? "unknown");
+			} catch {
+				try {
+					let dir = dirname(req.resolve(spec));
+					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) {
@@ -406,11 +444,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 +464,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 +481,71 @@ 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]) => {
+		return !existsSync(join(vendorDir, url.startsWith(prefix) ? url.slice(12) : url));
+	}).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$3, 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$3, 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 +554,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 +586,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 +618,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 +706,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 +725,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]' },
@@ -1776,6 +1885,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;
@@ -2032,11 +2183,12 @@ function getConnectBaseViteConfig(options) {
 			}),
 			devReactImportmapPlugin(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),
@@ -2051,6 +2203,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, phConfigPlugin, prebuildConnectVendor, prependToHtmlHead, readJsonFile, removeBase64EnvValues, resolveConnectBundle, resolveConnectPackageJson, resolveConnectPublicDir, resolvePackage, resolveViteConfigPath, runShellScriptPlugin, runTsc, runtimeConfigSchema, stripVersionFromPackage };
+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 };
 
 //# sourceMappingURL=index.mjs.map