@powerhousedao/builder-tools 6.2.2-dev.4 → 6.2.2-dev.40

package/dist/index.mjs

@@ -7,12 +7,14 @@ import { fileURLToPath } from "node:url";
 import MagicString from "magic-string";
 import { readFile, writeFile } from "node:fs/promises";
 import { cwd } from "node:process";
-import { DEFAULT_CONNECT_CONFIG, buildRuntimeConfig, deepMerge, loadConnectEnv, normalizeBasePath, phConnectRuntimeConfigSchema, powerhousePackageSchema, setConnectEnv } from "@powerhousedao/shared/connect";
+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";
 import { createLogger, esmExternalRequirePlugin, loadEnv, searchForWorkspaceRoot } from "vite";
 import { createHtmlPlugin } from "vite-plugin-html";
+import { PwaConfigSchema } from "@powerhousedao/shared/document-model";
+import { toCdnUrl } from "@powerhousedao/shared/registry/urls";
 import { VitePWA } from "vite-plugin-pwa";
 //#region connect-utils/constants.ts
 const EXTERNAL_PACKAGES_IMPORT = "PH:EXTERNAL_PACKAGES";
@@ -1130,8 +1132,170 @@ function phConfigPlugin(options) {
 	};
 }
 //#endregion
+//#region connect-utils/vite-plugins/pwa-packages.ts
+const REGISTRY_FETCH_TIMEOUT_MS = 1e4;
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function formatZodIssues(error) {
+	return error.issues.map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`).join("; ");
+}
+/** Turn a parsed manifest JSON into a contribution: its `pwa` fragment (a
+* malformed one → warn + skip that fragment, not the whole contribution) plus a
+* `categories` entry derived from the manifest's `category` field. Returns null
+* only when the manifest yields neither — no `pwa` and no `category`. */
+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;
+	}
+	config = withInferredCategory(config, manifest.category);
+	if (Object.keys(config).length === 0) return null;
+	return {
+		source: label,
+		config
+	};
+}
+/** Read the first parseable manifest among `candidates` (relative to `dir`)
+* and extract its pwa contribution. Candidates that resolve outside `dir`
+* (a hostile `./manifest` export) are warned about and skipped. */
+function readPwaFragmentFromDir(dir, candidates, fallbackLabel, onWarn) {
+	for (const rel of candidates) {
+		const manifestPath = path.resolve(dir, rel);
+		if (path.relative(dir, manifestPath).startsWith("..")) {
+			onWarn(`PWA config: ${fallbackLabel} declares a manifest path outside its package directory (${rel}); ignored.`);
+			continue;
+		}
+		if (!fs.existsSync(manifestPath)) continue;
+		try {
+			return toPwaContribution(JSON.parse(fs.readFileSync(manifestPath, "utf-8")), fallbackLabel, onWarn);
+		} catch {
+			onWarn(`PWA config: could not parse ${fallbackLabel}'s manifest at ${rel}; ignored.`);
+			return null;
+		}
+	}
+	return null;
+}
+function readLocalPackagePwaFragment(projectRoot, name, onWarn) {
+	const pkgDir = path.join(projectRoot, "node_modules", name);
+	let manifestRel;
+	try {
+		const exported = JSON.parse(fs.readFileSync(path.join(pkgDir, "package.json"), "utf-8")).exports?.["./manifest"];
+		if (typeof exported === "string") manifestRel = exported;
+	} catch {}
+	return readPwaFragmentFromDir(pkgDir, [
+		manifestRel,
+		"dist/powerhouse.manifest.json",
+		"powerhouse.manifest.json"
+	].filter((rel) => typeof rel === "string"), name, onWarn);
+}
+async function fetchRegistryPwaFragment(cdnUrl, pkg, onWarn, fetchImpl) {
+	const spec = pkg.version ? `${pkg.packageName}@${pkg.version}` : pkg.packageName;
+	const url = `${cdnUrl}/${spec}/powerhouse.manifest.json`;
+	try {
+		const response = await fetchImpl(url, { signal: AbortSignal.timeout(REGISTRY_FETCH_TIMEOUT_MS) });
+		if (response.status === 404) return null;
+		if (!response.ok) {
+			onWarn(`PWA config: registry returned ${response.status} for ${spec}'s manifest; its pwa fragment (if any) is skipped.`);
+			return null;
+		}
+		return toPwaContribution(await response.json(), pkg.packageName, onWarn);
+	} catch (error) {
+		onWarn(`PWA config: could not fetch ${spec}'s manifest from the registry (${error instanceof Error ? error.message : String(error)}); its pwa fragment (if any) is skipped.`);
+		return null;
+	}
+}
+/**
+* Read the `pwa` fragment of each package in `packages`, in the given order
+* (which becomes their merge precedence — later packages win scalar
+* conflicts). `provider: "local"` packages are read from node_modules;
+* everything else is fetched from the registry CDN (skipped with a warning
+* when `registryUrl` is missing or the registry is unreachable). Packages
+* with no `pwa` fragment are simply absent from the result.
+*/
+async function collectPackagePwaContributions(options) {
+	const projectRoot = options.projectRoot ?? process.cwd();
+	const onWarn = options.onWarn ?? (() => {});
+	const fetchImpl = options.fetchImpl ?? fetch;
+	const cdnUrl = options.registryUrl ? toCdnUrl(options.registryUrl) : null;
+	return (await Promise.all(options.packages.map(async (pkg) => {
+		if (pkg.provider === "local") return readLocalPackagePwaFragment(projectRoot, pkg.packageName, onWarn);
+		if (!cdnUrl) {
+			onWarn(`PWA config: no packageRegistryUrl configured; cannot read ${pkg.packageName}'s pwa fragment (if any) from the registry.`);
+			return null;
+		}
+		return fetchRegistryPwaFragment(cdnUrl, pkg, onWarn, fetchImpl);
+	}))).filter((contribution) => contribution !== null);
+}
+/**
+* Read the pwa fragment from the project's OWN manifest
+* (`powerhouse.manifest.json` under the project root, falling back to the
+* `dist/` copy the project build emits). The root file comes first — it is
+* the source the dist copy is made from, and a stale dist left by an older
+* build must not shadow it. Returns null silently when no manifest exists —
+* not every project ships one — or when it carries neither a `pwa` block nor a
+* `category` to derive `categories` from.
+*
+* The `pwa` block is parsed STRICTLY, like `connect.pwa` and unlike third-party
+* package fragments: the project's own manifest is the developer's config, so
+* an invalid `pwa` block (a typo, or a removed/unknown field such as
+* `protocol_handlers`) FAILS the build instead of being silently skipped — a
+* silently-dropped field would be far harder to notice.
+*/
+function collectProjectPwaContribution(options) {
+	const projectRoot = options.projectRoot ?? process.cwd();
+	for (const rel of ["powerhouse.manifest.json", "dist/powerhouse.manifest.json"]) {
+		const manifestPath = path.resolve(projectRoot, rel);
+		if (!fs.existsSync(manifestPath)) continue;
+		let manifest;
+		try {
+			manifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			throw new Error(`Could not parse ${manifestPath}: ${message}`);
+		}
+		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);
+		if (Object.keys(withCategory).length === 0) return null;
+		return {
+			source: label,
+			config: withCategory
+		};
+	}
+	return null;
+}
+/** Strictly parse a PWA config block, throwing a build-failing error (naming
+* the offending field) when it is invalid. Used for the developer's own config
+* (`connect.pwa` and the project manifest's `pwa`), where a silent drop would
+* be a footgun — unlike third-party package fragments, which warn + skip. */
+function parsePwaConfigStrict(config, description) {
+	const parsed = PwaConfigSchema.safeParse(config);
+	if (!parsed.success) throw new Error(`Invalid ${description}: ${formatZodIssues(parsed.error)}. Fix it or remove the field.`);
+	return parsed.data;
+}
+/**
+* Validate the project's `connect.pwa` block. Unlike package fragments
+* (third-party, warn + skip), the user's own config fails the build: a typo
+* that silently dropped offline coverage would be far harder to notice.
+*/
+function validateProjectPwaConfig(config, configPath) {
+	return parsePwaConfigStrict(config, `connect.pwa in ${configPath}`);
+}
+//#endregion
 //#region connect-utils/vite-plugins/pwa-icons.ts
-const PWA_ICONS = ["pwa-192x192.png", "pwa-512x512.png"];
+const PWA_ICONS = [
+	"pwa-192x192.png",
+	"pwa-512x512.png",
+	"pwa-512x512-maskable.png",
+	"document-icon-192x192.png",
+	"document-icon-512x512.png"
+];
 function connectPwaIconsPlugin() {
 	return {
 		name: "copy-connect-pwa-icons",
@@ -1150,23 +1314,154 @@ function connectPwaIconsPlugin() {
 	};
 }
 //#endregion
+//#region connect-utils/vite-plugins/pwa-overrides.ts
+/**
+* Lay an effective PWA fragment over the plugin's hardcoded manifest + precache
+* base. The manifest is merged by the shared `mergeManifest` with
+* `fragment-wins` scalars (the build-time effective config is the authority);
+* icons and file handlers concatenate after the base set (contributed handlers
+* get Connect's fixed action injected — the open route is not configurable);
+* globs union; the size ceiling takes the max.
+*
+* The serialisable `runtimeCaching` / `navigateFallbackDenylist` overrides are
+* NOT handled here — they are passed straight to the service worker (which
+* registers them after its built-in rules), because injectManifest has no
+* declarative runtimeCaching and Workbox is first-match-wins, so an override
+* can only be appended after the built-ins (intentional for v1).
+*/
+function applyPwaOverrides(base, override) {
+	return {
+		manifest: mergeManifest(base.manifest, override.manifest, { scalarPolicy: "fragment-wins" }),
+		precache: {
+			globPatterns: override.globPatterns?.length ? unionStrings(base.precache.globPatterns, override.globPatterns) : base.precache.globPatterns,
+			globIgnores: override.globIgnores?.length ? unionStrings(base.precache.globIgnores, override.globIgnores) : base.precache.globIgnores,
+			maximumFileSizeToCacheInBytes: typeof override.maximumFileSizeToCacheInBytes === "number" ? Math.max(base.precache.maximumFileSizeToCacheInBytes, override.maximumFileSizeToCacheInBytes) : base.precache.maximumFileSizeToCacheInBytes
+		}
+	};
+}
+//#endregion
 //#region connect-utils/vite-plugins/pwa.ts
 /**
+* Connect's hardcoded PWA manifest. The base layer of the override ladder —
+* package `pwa` fragments and the project's `connect.pwa` block are laid on
+* top of this by `applyPwaOverrides`.
+*/
+const BASE_MANIFEST = {
+	name: "Powerhouse Connect",
+	short_name: "Connect",
+	description: "A navigation, collaboration and reporting tool for decentralised and open organisations.",
+	theme_color: "#ffffff",
+	background_color: "#ffffff",
+	display: "standalone",
+	start_url: ".",
+	scope: ".",
+	icons: [
+		{
+			src: "pwa-192x192.png",
+			sizes: "192x192",
+			type: "image/png"
+		},
+		{
+			src: "pwa-512x512.png",
+			sizes: "512x512",
+			type: "image/png"
+		},
+		{
+			src: "pwa-512x512-maskable.png",
+			sizes: "512x512",
+			type: "image/png",
+			purpose: "maskable"
+		}
+	],
+	file_handlers: [{
+		action: PWA_FILE_HANDLER_ACTION,
+		accept: {
+			"application/vnd.powerhouse.document+zip": [".phd"],
+			"application/vnd.powerhouse.document-model+zip": [".phdm"]
+		},
+		icons: [{
+			src: "document-icon-192x192.png",
+			sizes: "192x192",
+			type: "image/png"
+		}, {
+			src: "document-icon-512x512.png",
+			sizes: "512x512",
+			type: "image/png"
+		}]
+	}],
+	launch_handler: { client_mode: "focus-existing" }
+};
+/**
+* Connect's hardcoded precache config — the base layer for the `injectManifest`
+* precache. Overridable additively (extra globs) or by raising the size ceiling
+* via package/project `pwa` config. The rest of the old Workbox config
+* (runtime-caching rules with their function urlPatterns, the navigation
+* fallback, clientsClaim/skipWaiting/cleanupOutdatedCaches) now lives as
+* imperative code in the hand-written service worker
+* (../service-worker/service-worker.ts), because `injectManifest` has no
+* declarative runtimeCaching option.
+*/
+const BASE_PRECACHE = {
+	maximumFileSizeToCacheInBytes: 16 * 1024 * 1024,
+	globPatterns: ["**/*.{js,css,html,wasm,data,ico,png,svg,webp,woff,woff2}"],
+	globIgnores: ["**/powerhouse.config.json", "**/*.map"]
+};
+const SW_FILENAME = "service-worker.ts";
+/**
+* Absolute directory holding the hand-written service-worker source. Resolved
+* relative to THIS module so it works from source
+* (connect-utils/vite-plugins → ../service-worker) and from the bundled dist
+* (dist/index.mjs → ./service-worker, where tsdown copies it). vite-plugin-pwa
+* resolves `swSrc = path.resolve(root, srcDir, filename)`, and `path.resolve`
+* ignores `root` when `srcDir` is absolute — so the SW ships with
+* builder-tools instead of every project needing its own copy.
+*/
+function resolveServiceWorkerDir() {
+	const here = dirname(fileURLToPath(import.meta.url));
+	const candidates = [resolve(here, "../service-worker"), resolve(here, "service-worker")];
+	return candidates.find((dir) => existsSync(join(dir, SW_FILENAME))) ?? candidates[0];
+}
+/**
+* Virtual module that feeds the hand-written SW its build-time data. Passed
+* into vite-plugin-pwa's SEPARATE injectManifest build via
+* `injectManifest.buildPlugins.vite`: that build runs with `configFile: false`,
+* so the app's own plugins aren't present, but buildPlugins (and `define`) are.
+*/
+function phSwConfigPlugin(data) {
+	const virtualId = "virtual:ph-sw-config";
+	const resolvedId = `\0${virtualId}`;
+	return {
+		name: "ph-sw-config",
+		resolveId(id) {
+			if (id === virtualId) return resolvedId;
+		},
+		load(id) {
+			if (id !== resolvedId) return;
+			return Object.entries(data).map(([key, value]) => `export const ${key} = ${JSON.stringify(value)};`).join("\n");
+		}
+	};
+}
+/**
 * Service-worker / PWA support for Connect, gated by `connect.app.offline`.
 *
-* When enabled (the default), Workbox `generateSW` precaches the built app
-* shell so Connect loads with no network, and runtime-caches the Google-hosted
-* Inter font + the runtime config. Registration is left to the Connect SPA
-* (`serviceWorkerManager`, `injectRegister: null`) rather than the plugin's
-* `virtual:pwa-register` module, so the published `@powerhousedao/connect`
-* tsdown build never has to resolve that virtual import.
+* When enabled (the default), Workbox `injectManifest` bundles Connect's
+* hand-written service worker (../service-worker/service-worker.ts), which
+* precaches the built app shell so Connect loads with no network, runtime-
+* caches the Google-hosted Inter font + the registry CDN + the runtime config,
+* AND serves a dynamic web-app manifest so packages installed AT RUNTIME can
+* extend it (their fragments are mirrored into IndexedDB by the SPA; the base
+* the SW merges onto is embedded here at build time). The manifest and precache
+* config start from the BASE_* defaults above and are extended by `pwa` — the
+* effective, already-merged overrides from build-time packages and the
+* project's `connect.pwa` block (see mergePwaConfig). Registration is left to
+* the Connect SPA (`serviceWorkerManager`, `injectRegister: null`).
 *
 * When disabled, a self-destroying worker is emitted at the same URL so any
 * worker a previous offline-enabled build installed unregisters itself and
 * clears its caches on the browser's next service-worker update check.
 */
 function connectPwaPlugins(options) {
-	const { offlineEnabled } = options;
+	const { offlineEnabled, pwa } = options;
 	if (!offlineEnabled) return [VitePWA({
 		selfDestroying: true,
 		strategies: "generateSW",
@@ -1174,102 +1469,29 @@ function connectPwaPlugins(options) {
 		filename: "service-worker.js",
 		devOptions: { enabled: false }
 	})];
+	const { manifest, precache } = applyPwaOverrides({
+		manifest: BASE_MANIFEST,
+		precache: BASE_PRECACHE
+	}, pwa ?? {});
+	const swConfig = {
+		EMBEDDED_BASE_MANIFEST: manifest,
+		EXTRA_RUNTIME_CACHING: pwa?.runtimeCaching ?? [],
+		NAVIGATE_FALLBACK_DENYLIST_EXTRA: pwa?.navigateFallbackDenylist ?? []
+	};
 	return [connectPwaIconsPlugin(), VitePWA({
-		strategies: "generateSW",
+		strategies: "injectManifest",
+		srcDir: resolveServiceWorkerDir(),
+		filename: SW_FILENAME,
 		registerType: "prompt",
 		injectRegister: null,
-		filename: "service-worker.js",
 		devOptions: { enabled: false },
 		includeManifestIcons: false,
-		manifest: {
-			name: "Powerhouse Connect",
-			short_name: "Connect",
-			description: "A navigation, collaboration and reporting tool for decentralised and open organisations.",
-			theme_color: "#ffffff",
-			background_color: "#ffffff",
-			display: "standalone",
-			start_url: ".",
-			scope: ".",
-			icons: [
-				{
-					src: "pwa-192x192.png",
-					sizes: "192x192",
-					type: "image/png"
-				},
-				{
-					src: "pwa-512x512.png",
-					sizes: "512x512",
-					type: "image/png"
-				},
-				{
-					src: "pwa-512x512.png",
-					sizes: "512x512",
-					type: "image/png",
-					purpose: "maskable"
-				}
-			]
-		},
-		workbox: {
-			clientsClaim: true,
-			skipWaiting: false,
-			cleanupOutdatedCaches: true,
-			maximumFileSizeToCacheInBytes: 16 * 1024 * 1024,
-			globPatterns: ["**/*.{js,css,html,wasm,data,ico,png,svg,webp,woff,woff2}"],
-			globIgnores: ["**/powerhouse.config.json", "**/*.map"],
-			navigateFallback: "index.html",
-			navigateFallbackDenylist: [
-				/\/powerhouse\.config\.json$/,
-				/^\/health$/,
-				/\/__/
-			],
-			runtimeCaching: [
-				{
-					urlPattern: ({ url }) => url.origin === "https://fonts.googleapis.com",
-					handler: "StaleWhileRevalidate",
-					options: { cacheName: "google-fonts-stylesheets" }
-				},
-				{
-					urlPattern: ({ url }) => url.origin === "https://fonts.gstatic.com",
-					handler: "CacheFirst",
-					options: {
-						cacheName: "google-fonts-webfonts",
-						expiration: {
-							maxEntries: 30,
-							maxAgeSeconds: 3600 * 24 * 365
-						},
-						cacheableResponse: { statuses: [0, 200] }
-					}
-				},
-				{
-					urlPattern: ({ url }) => url.pathname.includes("/-/cdn/") && (url.pathname.endsWith("/browser/index.js") || url.pathname.endsWith("/style.css") || url.pathname.endsWith("/package.json")),
-					handler: "StaleWhileRevalidate",
-					options: {
-						cacheName: "ph-package-cdn-entry",
-						expiration: {
-							maxEntries: 60,
-							maxAgeSeconds: 3600 * 24 * 30
-						},
-						cacheableResponse: { statuses: [0, 200] }
-					}
-				},
-				{
-					urlPattern: ({ url }) => url.pathname.includes("/-/cdn/"),
-					handler: "CacheFirst",
-					options: {
-						cacheName: "ph-package-cdn",
-						expiration: {
-							maxEntries: 200,
-							maxAgeSeconds: 3600 * 24 * 30
-						},
-						cacheableResponse: { statuses: [0, 200] }
-					}
-				},
-				{
-					urlPattern: ({ url }) => url.pathname.endsWith("/powerhouse.config.json"),
-					handler: "NetworkFirst",
-					options: { cacheName: "ph-runtime-config" }
-				}
-			]
+		manifest,
+		injectManifest: {
+			globPatterns: precache.globPatterns,
+			globIgnores: [...precache.globIgnores, "**/manifest.webmanifest"],
+			maximumFileSizeToCacheInBytes: precache.maximumFileSizeToCacheInBytes,
+			buildPlugins: { vite: [phSwConfigPlugin(swConfig)] }
 		}
 	})];
 }
@@ -1650,6 +1872,24 @@ function getConnectBaseViteConfig(options) {
 		warnings: ["@import must precede all other statements (besides @charset or empty @layer)"],
 		errors: ["Unterminated string literal"]
 	} });
+	const projectPwa = validateProjectPwaConfig(deepMerge(phConfig.connect?.pwa ?? {}, options.cliConnectOverride?.pwa ?? {}), phConfigPath);
+	const pwaWarn = (msg) => (customLogger ?? console).warn(msg);
+	const pwaPackagesForFragments = mode === "production" ? phPackages : phPackages.filter((p) => p.provider === "local");
+	const pwaPlugins = (async () => {
+		if (!offlineEnabled) return connectPwaPlugins({ offlineEnabled });
+		const contributions = await collectPackagePwaContributions({
+			packages: pwaPackagesForFragments,
+			projectRoot: options.dirname,
+			registryUrl: phPackageRegistryUrl,
+			onWarn: pwaWarn
+		});
+		const projectContribution = collectProjectPwaContribution({ projectRoot: options.dirname });
+		if (projectContribution) contributions.push(projectContribution);
+		return connectPwaPlugins({
+			offlineEnabled,
+			pwa: mergePwaConfig(contributions, projectPwa, pwaWarn)
+		});
+	})();
 	const reactExternal = [
 		"react",
 		"react-dom",
@@ -1714,7 +1954,7 @@ function getConnectBaseViteConfig(options) {
 			connectFaviconPlugin({ faviconPath: options.favicon }),
 			connectThemeBootPlugin(),
 			...options.dynamicBase ? [connectDynamicBasePlugin()] : [],
-			...connectPwaPlugins({ offlineEnabled })
+			pwaPlugins
 		],
 		worker: {
 			format: "es",
@@ -1724,6 +1964,6 @@ function getConnectBaseViteConfig(options) {
 	};
 }
 //#endregion
-export { 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, connectDynamicBasePlugin, connectThemeBootPlugin, copyConnect, ensureNodeVersion, getConnectBaseViteConfig, getConnectHtmlTags, makeImportScriptFromPackages, phConfigPlugin, prebuildConnectVendor, prependToHtmlHead, readJsonFile, removeBase64EnvValues, resolveConnectBundle, resolveConnectPackageJson, resolveConnectPublicDir, resolvePackage, resolveViteConfigPath, runShellScriptPlugin, runTsc, runtimeConfigSchema, stripVersionFromPackage };
+export { 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, connectDynamicBasePlugin, connectThemeBootPlugin, copyConnect, ensureNodeVersion, escapeForRegExp, getConnectBaseViteConfig, getConnectHtmlTags, makeImportScriptFromPackages, phConfigPlugin, prebuildConnectVendor, prependToHtmlHead, readJsonFile, removeBase64EnvValues, resolveConnectBundle, resolveConnectPackageJson, resolveConnectPublicDir, resolvePackage, resolveViteConfigPath, runShellScriptPlugin, runTsc, runtimeConfigSchema, stripVersionFromPackage };
 
 //# sourceMappingURL=index.mjs.map