@multiplatform.one/config 6.7.0 → 7.1.0

package/src/shims/web3Stub.native.js

@@ -0,0 +1,18 @@
+/**
+ * No-op `@multiplatform.one/web3(/native)` shim for NATIVE runs.
+ *
+ * `@multiplatform.one/core`'s loadWalletProvider.native.ts lazily
+ * `import("@multiplatform.one/web3/native")` — an OPTIONAL package many apps
+ * do not install. vxrn's rolldown native bundler leaves the unresolvable
+ * specifier as a bare dynamic `import()` expression in the classic-script
+ * bundle, which Hermes rejects at lazy-compile time with "SyntaxError:
+ * Invalid expression encountered", killing the root _layout route.
+ * createViteConfig's registerNativeWeb3Stub redirects the specifier here so
+ * the import inlines and parses; it auto-skips when web3 is installed.
+ *
+ * Plain JS (not TS): vxrn's native pipeline does not transform node_modules
+ * TypeScript.
+ */
+export function WalletProvider({ children }) {
+  return children ?? null;
+}

package/src/storybook.ts

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import type { Plugin, UserConfig } from "vite";
+import { unexportedDepAliases } from "./unexportedDepAliases.js";
 import { discoverPublicPackageRoots, resolvePackageMainSource } from "./workspacePublicPackages.js";
 
 export interface CreateStorybookViteConfigOptions {
@@ -54,6 +55,7 @@ export function createStorybookViteConfig(
   const aliases = {
     ...discoverPackageAliases(packagesDir),
     ...discoverPublicPackageViteAliases(workspaceRoot),
+    ...unexportedDepAliases(workspaceRoot),
   };
 
   if (options.aliases) {
@@ -81,10 +83,18 @@ export function createStorybookViteConfig(
       // transitive deps (color, query-string, etc.) to be served raw,
       // causing "require is not defined" / missing-export errors in the browser.
       //
-      // "default" must be included: Rolldown 8 strictly enforces exports fields
-      // and requires "default" in the conditions list to resolve unconditional
-      // (plain-string) sub-path exports, e.g. @react-navigation/core's
-      // "./lib/module/EnsureSingleNavigator" entry.
+      // This list does NOT resolve @react-navigation/core's internals. Those are
+      // undeclared subpaths, so no condition can reach them — see
+      // unexportedDepAliases, which maps them by filesystem path instead.
+      //
+      // "default" must be included: Rolldown 8 strictly enforces exports
+      // fields and needs "default" in the conditions list to reach a target
+      // that is only reachable through the default branch — including the
+      // "./lib/module/*" subpath patches/@react-navigation__core@7.17.2.patch
+      // adds, which one's SSRNavigationContainer fork deep-imports. Stock
+      // 7.17.2 exports only "." and "./package.json", so no condition list
+      // alone resolves those files; the patch is what makes them reachable
+      // and this entry is what lets the resolver pick its default target.
       conditions: ["default"],
       extensions: [
         ".storybook.ts",
@@ -141,11 +151,11 @@ export function createStorybookViteConfig(
         "query-string",
         "react-is",
       ],
-      // Rolldown rc.10+ enforces exports fields strictly — @react-navigation/core has
-      // internal files (EnsureSingleNavigator etc.) not listed in its exports map,
-      // causing dep pre-bundle to crash. Exclude the nav packages from pre-bundling;
-      // their CJS transitive deps (color, use-sync-external-store, fast-deep-equal)
-      // are already explicitly in include above so they are still pre-bundled.
+      // Keeps the nav packages out of dep pre-bundling; their CJS transitive deps
+      // (color, use-sync-external-store, fast-deep-equal) are already explicitly in
+      // include above so they are still pre-bundled. Note this only covers the dev
+      // optimizer — the undeclared @react-navigation/core internals that `one`
+      // deep-imports are handled for dev AND build by unexportedDepAliases.
       exclude: [
         "one/dist/esm/vite/one-server-only.mjs",
         "@storybook/preview-api",

package/src/unexportedDepAliases.spec.ts

@@ -0,0 +1,90 @@
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import os from "node:os";
+import path from "node:path";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import { unexportedDepAliases } from "./unexportedDepAliases";
+
+/**
+ * Builds a throwaway tree carrying the PUBLISHED @react-navigation/core exports
+ * map — the one CI installs, before vxrn rewrites it in place. The real tree on
+ * a dev machine is usually already patched, so asserting against it would prove
+ * nothing about the state this alias exists for.
+ */
+function writePristineFixture(root: string, { withPackage = true } = {}) {
+  fs.mkdirSync(root, { recursive: true });
+  fs.writeFileSync(path.join(root, "package.json"), JSON.stringify({ name: "fixture-root" }));
+  if (!withPackage) return;
+
+  const pkgDir = path.join(root, "node_modules", "@react-navigation", "core");
+  fs.mkdirSync(path.join(pkgDir, "lib", "module"), { recursive: true });
+  fs.writeFileSync(
+    path.join(pkgDir, "package.json"),
+    JSON.stringify({
+      name: "@react-navigation/core",
+      version: "7.17.2",
+      main: "./lib/module/index.js",
+      // Verbatim shape of the published manifest: no ./lib/module/* entries.
+      exports: { ".": { default: "./lib/module/index.js" }, "./package.json": "./package.json" },
+    }),
+  );
+  fs.writeFileSync(
+    path.join(pkgDir, "lib", "module", "EnsureSingleNavigator.js"),
+    "export const SingleNavigatorContext = {};\n",
+  );
+  fs.writeFileSync(path.join(pkgDir, "lib", "module", "index.js"), "export const x = 1;\n");
+}
+
+describe("unexportedDepAliases", () => {
+  // realpath: macOS /var is a symlink to /private/var, and require.resolve
+  // reports the resolved path.
+  const root = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), "unexported-dep-aliases-")));
+  const deepSpecifier = "@react-navigation/core/lib/module/EnsureSingleNavigator";
+
+  beforeAll(() => writePristineFixture(root));
+  afterAll(() => fs.rmSync(root, { recursive: true, force: true }));
+
+  it("positive control: the published exports map really does reject the deep import", () => {
+    // Without this, every assertion below could be green against a package that
+    // resolves fine on its own — i.e. an alias guarding nothing.
+    const requireFrom = createRequire(path.join(root, "package.json"));
+    expect(() => requireFrom.resolve(deepSpecifier)).toThrowError(
+      expect.objectContaining({ code: "ERR_PACKAGE_PATH_NOT_EXPORTED" }),
+    );
+  });
+
+  it("maps the internals `one` deep-imports onto a directory that holds them", () => {
+    const aliases = unexportedDepAliases(root);
+    const target = aliases["@react-navigation/core/lib/module"];
+
+    expect(target).toBe(
+      path.join(root, "node_modules", "@react-navigation", "core", "lib", "module"),
+    );
+    // The alias is only worth anything if rewriting the specifier lands on a
+    // real file — Vite replaces the matched key and resolves the rest by path.
+    const rewritten = deepSpecifier.replace("@react-navigation/core/lib/module", target);
+    expect(fs.existsSync(`${rewritten}.js`)).toBe(true);
+  });
+
+  it("scopes the alias to the subtree, leaving the package entry on its exports map", () => {
+    const keys = Object.keys(unexportedDepAliases(root));
+
+    // Vite matches an alias key exactly or as a `key + "/"` prefix. A bare
+    // "@react-navigation/core" key would swallow the package's own entry, and a
+    // trailing slash would stop the key matching at all.
+    expect(keys).toEqual(["@react-navigation/core/lib/module"]);
+    expect(keys[0]).not.toMatch(/\/$/);
+  });
+
+  it("emits nothing when the package is not installed", () => {
+    const bare = fs.realpathSync(
+      fs.mkdtempSync(path.join(os.tmpdir(), "unexported-dep-aliases-bare-")),
+    );
+    writePristineFixture(bare, { withPackage: false });
+    try {
+      expect(unexportedDepAliases(bare)).toEqual({});
+    } finally {
+      fs.rmSync(bare, { recursive: true, force: true });
+    }
+  });
+});

package/src/unexportedDepAliases.ts

@@ -0,0 +1,77 @@
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+
+/**
+ * Package subtrees that consumers deep-import but the publisher never declared
+ * in its `exports` map.
+ *
+ * `one`'s `fork/SSRNavigationContainer` (every dist flavour plus its source)
+ * imports three `@react-navigation/core` internals:
+ *
+ *   @react-navigation/core/lib/module/NavigationBuilderContext
+ *   @react-navigation/core/lib/module/NavigationStateContext
+ *   @react-navigation/core/lib/module/EnsureSingleNavigator
+ *
+ * The published package exports only "." and "./package.json", so those are
+ * undeclared subpaths of a bare specifier — Node rejects them with
+ * ERR_PACKAGE_PATH_NOT_EXPORTED and Rolldown (Vite 8) rejects them at build
+ * time. Both are behaving correctly; the deep imports are the bug.
+ *
+ * vxrn papers over it by rewriting the dependency's package.json in place
+ * (`vxrn` builtInDepPatches, which leaves a package.json.vxrn.original behind),
+ * but that only runs when something invokes vxrn — never during a plain
+ * `vite build` or `storybook build`, and never on a fresh CI install. Mapping
+ * the subtree to its real directory resolves those files by path, which is
+ * exactly where the missing exports entries would have pointed.
+ */
+const UNEXPORTED_SUBTREES: readonly string[] = ["@react-navigation/core/lib/module"];
+
+/**
+ * Vite `resolve.alias` entries that let known-undeclared package internals
+ * resolve by filesystem path.
+ *
+ * Scoped to one subtree of one package: Vite alias keys match the whole
+ * specifier or a `key + "/"` prefix, so sibling paths (`lib/moduleOther`) and
+ * the package's own entry (`@react-navigation/core`) keep going through the
+ * `exports` map. Nothing here disables exports enforcement globally.
+ *
+ * Entries are omitted when the package (or the target directory) is absent, so
+ * consumers that do not install `one`/react-navigation are unaffected.
+ *
+ * @param root Directory whose `node_modules` the packages resolve from.
+ */
+export function unexportedDepAliases(root: string = process.cwd()): Record<string, string> {
+  const aliases: Record<string, string> = {};
+  const requireFrom = createRequire(path.join(root, "package.json"));
+
+  for (const specifier of UNEXPORTED_SUBTREES) {
+    const [pkgName, subpath] = splitPackageSubpath(specifier);
+    const pkgDir = resolvePackageDir(pkgName, root, requireFrom);
+    if (!pkgDir) continue;
+    const target = path.join(pkgDir, subpath);
+    if (fs.existsSync(target)) aliases[specifier] = target;
+  }
+
+  return aliases;
+}
+
+function splitPackageSubpath(specifier: string): [pkgName: string, subpath: string] {
+  const segments = specifier.split("/");
+  const nameLength = specifier.startsWith("@") ? 2 : 1;
+  return [segments.slice(0, nameLength).join("/"), segments.slice(nameLength).join("/")];
+}
+
+function resolvePackageDir(
+  pkgName: string,
+  root: string,
+  requireFrom: NodeRequire,
+): string | undefined {
+  try {
+    return path.dirname(requireFrom.resolve(`${pkgName}/package.json`));
+  } catch {
+    // Packages that don't export "./package.json" can't be resolved that way.
+    const hoisted = path.join(root, "node_modules", ...pkgName.split("/"));
+    return fs.existsSync(path.join(hoisted, "package.json")) ? hoisted : undefined;
+  }
+}

package/src/vite.spec.ts

@@ -0,0 +1,148 @@
+/**
+ * createViteConfig — absorbed consumer workarounds (ssr CJS externals +
+ * native Hermes fixes). These used to live per-app (apps/one and downstream
+ * consumer vite configs); the spec pins the shared defaults and their
+ * escape hatches.
+ */
+
+import { beforeEach, describe, expect, it } from "vitest";
+import type { Plugin } from "vite";
+import { createViteConfig } from "./vite.js";
+
+type NativePlugin = {
+  name?: string;
+  renderChunk?: (code: string) => { code: string; map: null };
+};
+
+const globalWithNativePlugins = globalThis as unknown as {
+  __vxrnAddNativePlugins?: NativePlugin[];
+};
+
+function findPlugin(config: ReturnType<typeof createViteConfig>, name: string): Plugin | undefined {
+  return (config.plugins as Plugin[]).flat().find((p) => p && (p as Plugin).name === name) as
+    | Plugin
+    | undefined;
+}
+
+function runConfigResolved(plugin: Plugin, ssrExternal: string[] | boolean | undefined) {
+  const fakeConfig = { ssr: { external: ssrExternal } } as any;
+  (plugin.configResolved as any)(fakeConfig);
+  return fakeConfig.ssr.external;
+}
+
+beforeEach(() => {
+  // Native fix registration is global and deduped — reset between tests.
+  delete globalWithNativePlugins.__vxrnAddNativePlugins;
+});
+
+describe("ssrCjsExternal", () => {
+  it("appends the default CJS-only ids to ssr.external after one() replaces the list", () => {
+    const config = createViteConfig({ one: true });
+    const plugin = findPlugin(config, "multiplatform-ssr-cjs-external-fix");
+    expect(plugin).toBeDefined();
+    // Simulate one() having replaced ssr.external with its own list.
+    const external = runConfigResolved(plugin!, ["one-framework-entry"]) as string[];
+    expect(external).toContain("one-framework-entry");
+    expect(external).toContain("use-sync-external-store");
+    expect(external).toContain("use-sync-external-store/shim/with-selector");
+    expect(external).toContain("highlight.js/lib/core");
+    expect(external).toContain("turndown");
+    expect(external).toContain("@mixmark-io/domino");
+    expect(external).toContain("qrcode");
+  });
+
+  it("does not duplicate ids already present", () => {
+    const config = createViteConfig({ one: true });
+    const plugin = findPlugin(config, "multiplatform-ssr-cjs-external-fix");
+    const external = runConfigResolved(plugin!, ["use-sync-external-store"]) as string[];
+    expect(external.filter((e) => e === "use-sync-external-store")).toHaveLength(1);
+  });
+
+  it("extends the default list with consumer extras", () => {
+    const config = createViteConfig({ one: true, ssrCjsExternal: ["my-cjs-dep"] });
+    const plugin = findPlugin(config, "multiplatform-ssr-cjs-external-fix");
+    const external = runConfigResolved(plugin!, []) as string[];
+    expect(external).toContain("my-cjs-dep");
+    expect(external).toContain("use-sync-external-store");
+  });
+
+  it("leaves ssr.external: true untouched (everything already external)", () => {
+    const config = createViteConfig({ one: true });
+    const plugin = findPlugin(config, "multiplatform-ssr-cjs-external-fix");
+    expect(runConfigResolved(plugin!, true)).toBe(true);
+  });
+
+  it("can be disabled with ssrCjsExternal: false", () => {
+    const config = createViteConfig({ one: true, ssrCjsExternal: false });
+    expect(findPlugin(config, "multiplatform-ssr-cjs-external-fix")).toBeUndefined();
+  });
+
+  it("is not added without the one framework", () => {
+    const config = createViteConfig({ one: false });
+    expect(findPlugin(config, "multiplatform-ssr-cjs-external-fix")).toBeUndefined();
+  });
+});
+
+describe("nativeFixes.protoShadow", () => {
+  it("registers the Hermes proto-shadow renderChunk fix by default", () => {
+    createViteConfig({ one: true });
+    const plugin = globalWithNativePlugins.__vxrnAddNativePlugins?.find(
+      (p) => p.name === "vxrn-proto-shadow-fix",
+    );
+    expect(plugin).toBeDefined();
+    const result = plugin!.renderChunk!("var x = 1;");
+    // The restore snippet is PREPENDED so it runs before any module code.
+    expect(result.code.endsWith("var x = 1;")).toBe(true);
+    expect(result.code).toContain("Object.prototype");
+    expect(result.code).toContain("hasOwnProperty");
+  });
+
+  it("can be disabled with nativeFixes.protoShadow: false", () => {
+    createViteConfig({ one: true, nativeFixes: { protoShadow: false } });
+    expect(
+      globalWithNativePlugins.__vxrnAddNativePlugins?.some(
+        (p) => p.name === "vxrn-proto-shadow-fix",
+      ),
+    ).toBeFalsy();
+  });
+});
+
+describe("nativeFixes.web3Stub", () => {
+  it("auto-skips when @multiplatform.one/web3 is installed (monorepo has it)", () => {
+    createViteConfig({ one: true });
+    expect(
+      globalWithNativePlugins.__vxrnAddNativePlugins?.some((p) => p.name === "vxrn-web3-stub"),
+    ).toBeFalsy();
+  });
+});
+
+describe("public config bake", () => {
+  const bakedKeys = "VITE_MP_PUBLIC_CONFIG_KEYS";
+  const bakedValues = "VITE_MP_CONFIG";
+
+  beforeEach(() => {
+    delete process.env[bakedKeys];
+    delete process.env[bakedValues];
+  });
+
+  it("bakes the public key NAMES so the SSR server can resolve their values at runtime", () => {
+    // Values stay out of the image (an environment-agnostic build); the names
+    // travel instead, and double as the allowlist that keeps a private key out
+    // of the served document (@multiplatform.one/platform runtimeConfig).
+    createViteConfig({ publicConfigKeys: ["MARKETPLACE_API_URL", "FRAPPE_ENABLED"] });
+    expect(JSON.parse(process.env[bakedKeys]!)).toEqual(["MARKETPLACE_API_URL", "FRAPPE_ENABLED"]);
+  });
+
+  it("still bakes the build-environment VALUES so apps that bake keep working", () => {
+    process.env.MPO_VITE_SPEC_PUBLIC = "baked-in";
+    createViteConfig({ publicConfigKeys: ["MPO_VITE_SPEC_PUBLIC"] });
+    expect(JSON.parse(process.env[bakedValues]!)).toEqual({ MPO_VITE_SPEC_PUBLIC: "baked-in" });
+    delete process.env.MPO_VITE_SPEC_PUBLIC;
+  });
+
+  it("bakes nothing when the app declares no public keys", () => {
+    createViteConfig({});
+    expect(process.env[bakedKeys]).toBeUndefined();
+    expect(process.env[bakedValues]).toBeUndefined();
+  });
+});

package/src/vite.ts

@@ -114,6 +114,41 @@ export interface CreateViteConfigOptions {
    * Only used when `one` is enabled.
    */
   ssrEntries?: string[];
+
+  /**
+   * CJS-only package ids force-appended to `ssr.external` AFTER the one()
+   * plugin replaces the list (via configResolved), so Node's native CJS
+   * loader handles them instead of Vite's ESM evaluator (which chokes on
+   * `module.exports` with "module is not defined"). Only used when `one` is
+   * enabled. Defaults to a list covering use-sync-external-store,
+   * highlight.js, turndown, and friends; pass an array to EXTEND the default
+   * list or `false` to disable entirely.
+   */
+  ssrCjsExternal?: string[] | false;
+
+  /**
+   * Native (vxrn rolldown / Hermes) workaround toggles. Only used when `one`
+   * is enabled; all default to true.
+   */
+  nativeFixes?: {
+    /**
+     * Prepend a snippet to the classic-script native bundle that restores
+     * Object.prototype methods shadowed by hoisted top-level vars (Hermes V1
+     * spec-compliant var hoisting turns a flattened module's
+     * `var hasOwnProperty` into `globalThis.hasOwnProperty = undefined` at
+     * parse time, and React Native core dies at boot calling it).
+     */
+    protoShadow?: boolean;
+    /**
+     * When `@multiplatform.one/web3` is NOT installed, redirect the OPTIONAL
+     * `@multiplatform.one/web3/native` import (from core's
+     * loadWalletProvider.native.ts) to a no-op shim — rolldown otherwise
+     * leaves the unresolvable specifier as a bare dynamic `import()` in the
+     * classic-script bundle, which Hermes rejects at lazy-compile time.
+     * Auto-skipped when web3 is installed.
+     */
+    web3Stub?: boolean;
+  };
 }
 
 /**
@@ -150,6 +185,8 @@ export function createViteConfig(options: CreateViteConfigOptions = {}): UserCon
     externalReactRouter,
     ssrDeps,
     ssrEntries,
+    ssrCjsExternal,
+    nativeFixes,
   } = options;
 
   const projectRoot = _projectRoot || findProjectRoot();
@@ -158,6 +195,13 @@ export function createViteConfig(options: CreateViteConfigOptions = {}): UserCon
   dotenv.config({ path: path.resolve(projectRoot, ".env") });
   if (publicConfigKeys.length > 0) {
     process.env.VITE_MP_CONFIG = JSON.stringify(resolveConfig(publicConfigKeys));
+    // Bake only the NAMES of the public keys, never a value: this is what lets
+    // the SSR node process resolve their values from ITS OWN process.env at
+    // request time and publish them into the served document
+    // (@multiplatform.one/platform runtimeConfig.ts). Values stay out of the
+    // image, so one build is deployable to every environment; the names are
+    // also the allowlist that keeps a private key from ever being serialized.
+    process.env.VITE_MP_PUBLIC_CONFIG_KEYS = JSON.stringify(publicConfigKeys);
   }
 
   const vitePlugins: UserConfig["plugins"] = [];
@@ -189,6 +233,19 @@ export function createViteConfig(options: CreateViteConfigOptions = {}): UserCon
     // react-native-svg, so source keeps importing @phosphor-icons/react and
     // native transparently gets the RN implementation.
     registerNativePhosphorIcons();
+    // Hermes V1 hoisted-var Object.prototype shadow fix (see the nativeFixes
+    // option docs). Every rolldown classic-script native bundle is exposed.
+    if (nativeFixes?.protoShadow !== false) registerNativeProtoShadowFix();
+    // Optional-web3 stub for apps that don't install @multiplatform.one/web3
+    // (auto-skipped when the package resolves).
+    if (nativeFixes?.web3Stub !== false) registerNativeWeb3Stub();
+    // CJS-only ids must land on ssr.external AFTER the one() plugin replaces
+    // the list during config — configResolved runs last, so the appends stick.
+    if (ssrCjsExternal !== false) {
+      vitePlugins.push(
+        ssrCjsExternalFixPlugin([...DEFAULT_SSR_CJS_EXTERNAL, ...(ssrCjsExternal ?? [])]),
+      );
+    }
   }
 
   // Tamagui plugin
@@ -571,6 +628,132 @@ function registerNativeWorkspaceEntries(): void {
   });
 }
 
+/**
+ * CJS-only ids (no usable ESM build) that escape Vite's SSR dep optimizer and
+ * hit the ESM evaluator ("module is not defined" / "exports is not defined")
+ * unless Node's native CJS loader handles them. Union of the lists the
+ * monorepo's apps/one and downstream consumer apps (desibox) carried as
+ * app-side ssrExternalFix plugins; ids for packages an app never imports are
+ * inert, so one shared default list is safe.
+ */
+const DEFAULT_SSR_CJS_EXTERNAL = [
+  "better-sqlite3",
+  "dotenv",
+  "color",
+  "use-sync-external-store",
+  "use-sync-external-store/shim",
+  "use-sync-external-store/shim/with-selector",
+  "highlight.js",
+  "highlight.js/lib/core",
+  "turndown",
+  "@mixmark-io/domino",
+  "lowlight",
+  // CJS-only (module.exports / exports, no usable ESM build) pulled in by
+  // connectkit/wagmi/framer-motion.
+  "shallowequal",
+  "@emotion/is-prop-valid",
+  "hoist-non-react-statics",
+  "qrcode",
+];
+
+/**
+ * Force-append CJS-only ids to `ssr.external`. The one() plugin REPLACES
+ * ssr.external with its own list during the config hook, dropping anything
+ * set statically by createViteConfig — configResolved runs after all config
+ * hooks are merged, so appends here survive.
+ */
+function ssrCjsExternalFixPlugin(extras: string[]): Plugin {
+  return {
+    name: "multiplatform-ssr-cjs-external-fix",
+    configResolved(config) {
+      const external = config.ssr.external ?? [];
+      if (!Array.isArray(external)) return; // true = everything external already
+      for (const e of extras) {
+        if (!external.includes(e)) external.push(e);
+      }
+      (config.ssr as { external?: string[] | boolean }).external = external;
+    },
+  };
+}
+
+/**
+ * Restore Object.prototype methods shadowed by hoisted globals on NATIVE.
+ *
+ * vxrn's rolldown native mode emits the whole dev bundle as ONE classic
+ * script and forces Hermes V1. Hermes V1 implements spec-compliant global
+ * var hoisting, so a flattened module's top-level `var hasOwnProperty`
+ * (e.g. acorn via an mdx pipeline) creates
+ * `globalThis.hasOwnProperty = undefined` at parse time, shadowing
+ * Object.prototype.hasOwnProperty for the entire runtime. React Native core
+ * calls `global.hasOwnProperty()` during boot (FuseboxSessionObserver) and
+ * dies with "undefined is not a function". Prepend a snippet that copies any
+ * Object.prototype method back over an undefined shadowing own-property
+ * before any module code runs — the shadowed vars are reassigned by their
+ * own modules on init, so this only bridges the parse-to-init window.
+ * Registered through globalThis.__vxrnAddNativePlugins (vxrn's native engine
+ * ignores vite resolve/config). Web/SSR bundles are ESM (module-scoped vars)
+ * and unaffected.
+ */
+function registerNativeProtoShadowFix(): void {
+  const g = globalThis as unknown as { __vxrnAddNativePlugins?: unknown[] };
+  const name = "vxrn-proto-shadow-fix";
+  g.__vxrnAddNativePlugins = g.__vxrnAddNativePlugins ?? [];
+  if (g.__vxrnAddNativePlugins.some((p) => (p as { name?: string })?.name === name)) return;
+  const snippet =
+    `(function(){var p=Object.prototype,h=p.hasOwnProperty,ns=Object.getOwnPropertyNames(p);` +
+    `for(var i=0;i<ns.length;i++){var k=ns[i];` +
+    `if(typeof p[k]==="function"&&globalThis[k]===void 0&&h.call(globalThis,k)){` +
+    `try{globalThis[k]=p[k]}catch(e){}}}})();`;
+  g.__vxrnAddNativePlugins.push({
+    name,
+    renderChunk(code: string) {
+      return { code: `${snippet}\n${code}`, map: null };
+    },
+  });
+}
+
+/**
+ * Redirect the OPTIONAL `@multiplatform.one/web3` native import to a no-op
+ * shim on NATIVE when the package is not installed (see the nativeFixes
+ * option docs). Rolldown leaves the unresolvable specifier as a bare dynamic
+ * `import()` in the classic-script native bundle — Hermes rejects that at
+ * lazy-compile time ("SyntaxError: Invalid expression encountered"), killing
+ * the root _layout route. Web/SSR resolve the same specifier through vite's
+ * normal pipeline and are unaffected.
+ */
+function registerNativeWeb3Stub(): void {
+  const g = globalThis as unknown as { __vxrnAddNativePlugins?: unknown[] };
+  const name = "vxrn-web3-stub";
+  g.__vxrnAddNativePlugins = g.__vxrnAddNativePlugins ?? [];
+  if (g.__vxrnAddNativePlugins.some((p) => (p as { name?: string })?.name === name)) return;
+  try {
+    // web3 installed — its real native entry resolves; no stub needed.
+    require.resolve("@multiplatform.one/web3", { paths: [findProjectRoot(), process.cwd()] });
+    return;
+  } catch {
+    // not installed — stub below
+  }
+  // The shim ships as plain JS (vxrn does not transform node_modules TS).
+  // Resolve it relative to this module: `src/shims/` when running from
+  // source, `../src/shims/` from the built `lib/` bundle (src ships in the
+  // published tarball).
+  const here = path.dirname(new URL(import.meta.url).pathname);
+  const shim = [
+    path.resolve(here, "shims/web3Stub.native.js"),
+    path.resolve(here, "../src/shims/web3Stub.native.js"),
+  ].find((candidate) => fs.existsSync(candidate));
+  if (!shim) return;
+  g.__vxrnAddNativePlugins.push({
+    name,
+    resolveId(id: string) {
+      if (id === "@multiplatform.one/web3/native" || id === "@multiplatform.one/web3") {
+        return shim;
+      }
+      return null;
+    },
+  });
+}
+
 function findProjectRoot(): string {
   try {
     const { execSync } = require("node:child_process");

package/types/storybook.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"storybook.d.ts","sourceRoot":"","sources":["../src/storybook.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAU,UAAU,EAAE,MAAM,MAAM,CAAC;AAG/C,MAAM,WAAW,gCAAgC;IAC/C;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IAEvB;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAEjC;;OAEG;IACH,OAAO,CAAC,EAAE,UAAU,CAAC,SAAS,CAAC,CAAC;IAEhC;;OAEG;IACH,MAAM,CAAC,EAAE,UAAU,CAAC,QAAQ,CAAC,CAAC;CAC/B;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,GAAE,gCAAqC,GAC7C,UAAU,CAiHZ"}
+{"version":3,"file":"storybook.d.ts","sourceRoot":"","sources":["../src/storybook.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAU,UAAU,EAAE,MAAM,MAAM,CAAC;AAI/C,MAAM,WAAW,gCAAgC;IAC/C;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IAEvB;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAEjC;;OAEG;IACH,OAAO,CAAC,EAAE,UAAU,CAAC,SAAS,CAAC,CAAC;IAEhC;;OAEG;IACH,MAAM,CAAC,EAAE,UAAU,CAAC,QAAQ,CAAC,CAAC;CAC/B;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,GAAE,gCAAqC,GAC7C,UAAU,CA0HZ"}

package/types/unexportedDepAliases.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Vite `resolve.alias` entries that let known-undeclared package internals
+ * resolve by filesystem path.
+ *
+ * Scoped to one subtree of one package: Vite alias keys match the whole
+ * specifier or a `key + "/"` prefix, so sibling paths (`lib/moduleOther`) and
+ * the package's own entry (`@react-navigation/core`) keep going through the
+ * `exports` map. Nothing here disables exports enforcement globally.
+ *
+ * Entries are omitted when the package (or the target directory) is absent, so
+ * consumers that do not install `one`/react-navigation are unaffected.
+ *
+ * @param root Directory whose `node_modules` the packages resolve from.
+ */
+export declare function unexportedDepAliases(root?: string): Record<string, string>;
+//# sourceMappingURL=unexportedDepAliases.d.ts.map

package/types/unexportedDepAliases.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unexportedDepAliases.d.ts","sourceRoot":"","sources":["../src/unexportedDepAliases.ts"],"names":[],"mappings":"AA6BA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,GAAE,MAAsB,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAazF"}