@multiplatform.one/config 7.6.3 → 7.7.1

package/lib/index.js

@@ -1,5 +1,5 @@
-import { t as createViteConfig } from "./vite-W9hIeg2_.js";
-import { t as createStorybookViteConfig } from "./storybook-BnfZmzIL.js";
+import { t as createViteConfig } from "./vite-uwqTTN8M.js";
+import { t as createStorybookViteConfig } from "./storybook-BuO1e8Sb.js";
 import { n as tamaguiWorkspacePathsFile, t as ensureTamaguiWorkspacePaths } from "./tamaguiWorkspacePaths-ZIcqybtn.js";
 import { createVitestConfig } from "./vitest.js";
 

package/lib/{storybook-BnfZmzIL.js → storybook-BuO1e8Sb.js}

@@ -4,6 +4,100 @@ import { createRequire } from "node:module";
 import fs from "node:fs";
 import path from "node:path";
 
+//#region src/singletonDepAliases.ts
+/**
+* Packages that create a React context at module scope and must therefore
+* resolve to exactly ONE module record across the whole bundle.
+*
+* MPO-215. `react-cookie` runs `React.createContext(null)` when its entry
+* evaluates. `@multiplatform.one/storybook` renders `<CookiesProvider>` in the
+* framework decorator and `@multiplatform.one/theme`'s `useTheme` reads it via
+* `useCookies`, so provider and consumer live in two different workspace
+* packages. When those two packages resolve `react-cookie` to two different
+* realpaths — a hoisted `node_modules/react-cookie` for the importer that does
+* not declare it, the pnpm store copy for the one that does — the entry
+* evaluates twice, there are two contexts, and `useCookies` throws
+* `Missing <CookiesProvider>` with the provider sitting two lines above it in
+* the same tree.
+*
+* Nothing catches that today. The dev server pre-bundles bare imports by
+* package NAME, which collapses both realpaths onto one `deps/react-cookie.js`
+* and renders fine; the production build has no optimizer, so both paths
+* survive, every story renders Storybook's error panel, and
+* `storybook build` still exits 0.
+*
+* `resolve.dedupe` does not fix it: measured against Vite 8 / Rolldown, a
+* build with `dedupe: ["react-cookie"]` emitted a byte-identical iframe chunk
+* and the story still threw. An alias to one absolute directory does, which is
+* the same instrument the storybook config already uses to pin react,
+* react-dom and react-is.
+*
+* MPO-217. `@tamagui/web` is the same shape. It owns the theme context, the
+* style registry and the config singleton; `@tamagui/core` re-exports it and
+* `tamagui` re-exports that, so every tamagui component in the tree reads the
+* theme through whichever `@tamagui/web` record its own import chain reached.
+*
+* Measured on the build's module graph at e19a0fda3: `tamagui` resolved to
+* two realpaths. 562 importers (public/components, public/backoffice,
+* public/storybook and the rest) took the pnpm store copy, whose chain is
+* store `tamagui` -> store `@tamagui/core` -> store `@tamagui/web`; five took
+* the hoisted `node_modules/tamagui`, which has no nested node_modules and so
+* walks up to the hoisted `@tamagui/core` and `@tamagui/web`. Those five were
+* public/frappe's story files — the only modules in the repo that import
+* `tamagui` from a package with no copy of its own — and their 14 stories were
+* the 14 that threw `Missing theme.` on storybook-static while rendering on
+* dev. The theme provider is mounted from the store record; their `Button`,
+* `Text` and `YStack` read the hoisted record's context, which no provider
+* ever wrote to.
+*
+* `tamagui` itself is deliberately NOT pinned. A directory alias resolves
+* `tamagui/linear-gradient` to `node_modules/tamagui/linear-gradient/`, a
+* metro-compat stub that `require`s the CJS build, instead of the ESM target
+* the package's exports map picks for the browser. Pinning core and web is
+* enough: both `tamagui` records import `@tamagui/core` by bare specifier, so
+* they funnel into one web record and one theme context.
+*/
+const CONTEXT_SINGLETONS = [
+	"react-cookie",
+	"@tamagui/core",
+	"@tamagui/web"
+];
+/**
+* Vite `resolve.alias` entries pinning each context singleton to one directory.
+*
+* Alias keys match the whole specifier or a `key + "/"` prefix, so subpath
+* imports follow the same copy instead of resolving independently. Entries are
+* omitted when the package is not installed, so a consumer that does not use
+* cookies is unaffected.
+*
+* @param root Directory whose `node_modules` the packages resolve from.
+*/
+function singletonDepAliases(root = process.cwd()) {
+	const aliases = {};
+	const requireFrom = createRequire(path.join(root, "package.json"));
+	for (const pkgName of CONTEXT_SINGLETONS) {
+		const pkgDir = resolvePackageDir$1(pkgName, root, requireFrom);
+		if (pkgDir) aliases[pkgName] = pkgDir;
+	}
+	return aliases;
+}
+function resolvePackageDir$1(pkgName, root, requireFrom) {
+	try {
+		return path.dirname(requireFrom.resolve(`${pkgName}/package.json`));
+	} catch {
+		try {
+			let dir = path.dirname(requireFrom.resolve(pkgName));
+			while (dir !== path.dirname(dir)) {
+				if (fs.existsSync(path.join(dir, "package.json"))) return dir;
+				dir = path.dirname(dir);
+			}
+		} catch {}
+		const hoisted = path.join(root, "node_modules", ...pkgName.split("/"));
+		return fs.existsSync(path.join(hoisted, "package.json")) ? hoisted : void 0;
+	}
+}
+
+//#endregion
 //#region src/unexportedDepAliases.ts
 /**
 * Package subtrees that consumers deep-import but the publisher never declared
@@ -95,7 +189,8 @@ function createStorybookViteConfig(options = {}) {
 	const aliases = {
 		...discoverPackageAliases(path.join(workspaceRoot, "packages")),
 		...discoverPublicPackageViteAliases(workspaceRoot),
-		...unexportedDepAliases(workspaceRoot)
+		...unexportedDepAliases(workspaceRoot),
+		...singletonDepAliases(workspaceRoot)
 	};
 	if (options.aliases) Object.assign(aliases, options.aliases);
 	const sortedAliases = {};
@@ -157,6 +252,8 @@ function createStorybookViteConfig(options = {}) {
 				"@tamagui/themes",
 				"@tamagui/toast",
 				"@tamagui/use-presence",
+				"react-cookie",
+				"tamagui/linear-gradient",
 				"@mdx-js/react",
 				"i18next",
 				"react-i18next",

package/lib/storybook.js

@@ -1,3 +1,3 @@
-import { t as createStorybookViteConfig } from "./storybook-BnfZmzIL.js";
+import { t as createStorybookViteConfig } from "./storybook-BuO1e8Sb.js";
 
 export { createStorybookViteConfig };

package/lib/{vite-W9hIeg2_.js → vite-uwqTTN8M.js}

@@ -92,6 +92,7 @@ function createViteConfig(options = {}) {
 		vitePlugins.push(ssrReactNativeAliasPlugin());
 		vitePlugins.push(clientBrokenEsmPlugin());
 		registerNativeEngineIoBrowserTransports();
+		registerNativeSinglePackageInstances();
 		registerNativeWorkspaceEntries();
 		registerNativePhosphorIcons();
 		if (nativeFixes?.protoShadow !== false) registerNativeProtoShadowFix();
@@ -189,7 +190,13 @@ function createViteConfig(options = {}) {
 	return {
 		css: { modules: { localsConvention: "camelCase" } },
 		build: { chunkSizeWarningLimit: 600 },
-		define: { "process.env.VITE_FRAPPE_ENABLED": JSON.stringify(process.env.VITE_FRAPPE_ENABLED === "true" ? "true" : "false") },
+		define: {
+			"process.env.VITE_FRAPPE_ENABLED": JSON.stringify(process.env.VITE_FRAPPE_ENABLED === "true" ? "true" : "false"),
+			...publicConfigKeys.length > 0 ? {
+				"process.env.VITE_MP_CONFIG": JSON.stringify(process.env.VITE_MP_CONFIG ?? ""),
+				"process.env.VITE_MP_PUBLIC_CONFIG_KEYS": JSON.stringify(process.env.VITE_MP_PUBLIC_CONFIG_KEYS ?? "")
+			} : {}
+		},
 		ssr: ssr || defaultSsr,
 		resolve: {
 			alias: {
@@ -276,6 +283,107 @@ function clientBrokenEsmPlugin() {
 * This re-asserts the browser redirect with no node_modules patch. Web is
 * unaffected (engine.io is SSR-externalized and the web client already maps `browser`).
 */
+/**
+* Collapse duplicate PHYSICAL copies of the same package@version to one path
+* in the NATIVE graph, so React (and every other stateful singleton) exists
+* exactly once in the Hermes bundle.
+*
+* The workspace's node_modules is a MIXED install. `.npmrc` says
+* `node-linker=hoisted`, so the root `node_modules/<pkg>` entries are real
+* directories; but an earlier isolated install left a `node_modules/.pnpm`
+* virtual store plus per-package symlink farms behind — e.g. each package's
+* own `node_modules/react` still points at
+* `../../../node_modules/.pnpm/react@19.2.5/node_modules/react`.
+* Both trees are fully populated with byte-identical copies, and which one an
+* importer reaches depends only on where that importer sits on disk:
+*
+*   apps/one/app      -> node_modules/.pnpm/react@19.2.5/node_modules/react
+*   public/forms/src  -> node_modules/react            (no local symlink)
+*
+* Rolldown resolves symlinks, so the two land as two DIFFERENT absolute paths
+* and it bundles both. React 19's `useContext` is
+* `ReactSharedInternals.H.useContext(Context)` — `H` is the dispatcher the
+* renderer installs during render, and it is only ever set on the copy the
+* renderer imported. A component from the other copy therefore reads `H` as
+* null and the app dies with "Cannot read property 'useContext' of null".
+* That is the whole bug; the same split had also duplicated react-native (427
+* modules each), @tamagui/web, @react-navigation/core, one, scheduler and 58
+* more packages.
+*
+* The rule: an id that resolves inside the virtual store is rewritten to the
+* hoisted root copy when the root copy exists, carries the SAME version, and
+* actually has the file. Version equality is the safety guard — genuine
+* multi-version installs (two @babel/runtime, two viem) keep both copies.
+*
+* On a correctly installed tree this is a no-op by construction: `hoisted`
+* leaves no `.pnpm` store to match, and `isolated` makes the root entry a
+* symlink INTO the store, which realpaths back to the same directory (checked
+* explicitly). It only fires on the mixed tree, and it is cheap because only
+* BARE specifiers are inspected — once a package's entry is canonical, its own
+* relative imports resolve inside the canonical copy for free.
+*/
+function registerNativeSinglePackageInstances() {
+	const g = globalThis;
+	const name = "vxrn-single-package-instances";
+	g.__vxrnAddNativePlugins = g.__vxrnAddNativePlugins ?? [];
+	if (g.__vxrnAddNativePlugins.some((p) => p?.name === name)) return;
+	const rootModules = path.join(findProjectRoot(), "node_modules");
+	const storePath = /[\\/]node_modules[\\/]\.pnpm[\\/][^\\/]+[\\/]node_modules[\\/]((?:@[^\\/]+[\\/])?[^\\/]+)(?:[\\/](.*))?$/;
+	function versionOf(dir) {
+		try {
+			const raw = fs.readFileSync(path.join(dir, "package.json"), "utf8");
+			return JSON.parse(raw).version ?? null;
+		} catch {
+			return null;
+		}
+	}
+	const hoisted = /* @__PURE__ */ new Map();
+	function hoistedTwin(pkg, storeDir) {
+		if (!hoisted.has(pkg)) {
+			const rootDir = path.join(rootModules, pkg);
+			let twin = null;
+			if (fs.existsSync(rootDir)) {
+				const rootVersion = versionOf(rootDir);
+				const storeVersion = versionOf(storeDir);
+				if (rootVersion && rootVersion === storeVersion) try {
+					if (fs.realpathSync(rootDir) !== fs.realpathSync(storeDir)) twin = rootDir;
+				} catch {
+					twin = null;
+				}
+			}
+			hoisted.set(pkg, twin);
+		}
+		return hoisted.get(pkg) ?? null;
+	}
+	const seen = /* @__PURE__ */ new Map();
+	g.__vxrnAddNativePlugins.push({
+		name,
+		async resolveId(id, importer) {
+			if (!id || id.startsWith(".") || id.startsWith("/") || id.startsWith("\0")) return null;
+			const key = `${id} ${importer ?? ""}`;
+			const cached = seen.get(key);
+			if (cached !== void 0) return cached;
+			let out = null;
+			try {
+				const resolved = await this.resolve(id, importer, { skipSelf: true });
+				const match = resolved?.external ? null : resolved?.id?.match(storePath);
+				if (resolved && match) {
+					const pkg = match[1].split(path.sep).join("/");
+					const rest = match[2] ?? "";
+					const twin = hoistedTwin(pkg, resolved.id.slice(0, resolved.id.length - (rest ? rest.length + 1 : 0)));
+					if (twin) {
+						const candidate = rest ? path.join(twin, rest) : twin;
+						if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) out = candidate;
+					}
+				}
+			} catch {
+				out = null;
+			}
+			seen.set(key, out);
+			return out;
+		}
+	});
+}
 function registerNativeEngineIoBrowserTransports() {
 	const g = globalThis;
 	const name = "vxrn-engineio-browser-transports";
@@ -322,7 +430,12 @@ function registerNativeWorkspaceEntries() {
 			const root = roots.get(id);
 			if (root) {
 				const nativeEntry = path.join(root, "dist/esm/index.native.js");
-				return fs.existsSync(nativeEntry) ? nativeEntry : null;
+				if (fs.existsSync(nativeEntry)) return nativeEntry;
+				const srcTs = path.join(root, "src/index.ts");
+				if (fs.existsSync(srcTs)) return srcTs;
+				const srcTsx = path.join(root, "src/index.tsx");
+				if (fs.existsSync(srcTsx)) return srcTsx;
+				return null;
 			}
 			if (id.endsWith("/dist/esm/index.mjs")) {
 				const nativeEntry = `${id.slice(0, -4)}.native.js`;

package/lib/vite.js

@@ -1,4 +1,4 @@
-import { t as createViteConfig } from "./vite-W9hIeg2_.js";
+import { t as createViteConfig } from "./vite-uwqTTN8M.js";
 import { n as publicPackageViteSourceAliases, t as discoverPublicPackageRoots } from "./workspacePublicPackages-COicQSj4.js";
 
 export { createViteConfig, discoverPublicPackageRoots, publicPackageViteSourceAliases };