vite-plugin-taro 0.3.2 → 0.4.1

package/dist/node/vite-plugin.js

@@ -1,33 +1,17 @@
 import react from '@vitejs/plugin-react';
-import { BuildContext } from './build-context.js';
-import { createConditionalDirectivePlugin } from './plugins/conditional-directives.js';
-import { createTaroRuntimePlugin } from './plugins/taro-runtime.js';
-import { createH5TargetPlugins, createH5ViteConfig } from './targets/h5/plugin.js';
-import { createWxTargetPlugins, createWxViteConfig } from './targets/wx/plugin.js';
-/** Creates the Vite plugins for the selected Taro target. */
+import { createClientTaroPlugin } from './plugins/client/client-taro.js';
+import { createConditionalDirectivePlugin } from './plugins/conditional/conditional-directives.js';
+import { createCssPlugins } from './plugins/css/plugins.js';
+import { createH5TargetPlugins } from './plugins/h5/plugins.js';
+import { createWxTargetPlugins } from './plugins/wx/plugins.js';
+/** Creates the Vite plugins for one Taro target. */
 export default function vitePluginTaro(options) {
-    const context = new BuildContext(options);
     return [
-        createBuildCoordinator(context),
-        createConditionalDirectivePlugin(context),
-        createTaroRuntimePlugin(),
-        ...context.css.plugins,
+        createConditionalDirectivePlugin(options.target),
+        createClientTaroPlugin(),
+        ...createCssPlugins(options.target),
         ...react(),
-        ...(context.project.target === 'wx' ? createWxTargetPlugins(context) : []),
-        ...(context.project.target === 'h5' ? createH5TargetPlugins(context) : [])
+        ...(options.target === 'wx' ? createWxTargetPlugins(options) : []),
+        ...(options.target === 'h5' ? createH5TargetPlugins(options) : [])
     ];
 }
-/** Establishes build mode and resolved Vite state before target hooks consume the context. */
-function createBuildCoordinator(context) {
-    return {
-        name: 'vite-plugin-taro:build',
-        enforce: 'pre',
-        config(_, environment) {
-            context.configure(environment);
-            return context.project.target === 'wx' ? createWxViteConfig(context) : createH5ViteConfig(context);
-        },
-        configResolved(config) {
-            context.resolve(config);
-        }
-    };
-}

package/dist/options.d.ts

@@ -1,15 +1,14 @@
-/** Plain JSON object emitted into Mini Program/Web config payloads. */
+/** A JSON object used by generated target configs. */
 export type JsonObject = Record<string, unknown>;
 /** Build target handled by this plugin. */
 export type VitePluginTaroTarget = 'wx' | 'h5';
-/** Describes one React-backed page shared by WeChat Mini Program and Web builds. */
+/** Configures one Taro page. */
 export type VitePluginTaroPageOption = {
     /** Taro route and output path without a file extension. */
     path: string;
-    /** Page config merged into the generated target config. */
     config: JsonObject;
 };
-/** Required build inputs for the Vite/Rolldown Taro renderer plugin. */
+/** Configures the Vite Taro plugin. */
 export interface VitePluginTaroOptions {
     target: VitePluginTaroTarget;
     app: string;

package/dist/runtime/{taro → client/taro}/api.d.ts

@@ -1,4 +1,3 @@
-/** Physical runtime module backing the public `virtual:taro/api` facade. */
 import '@tarojs/plugin-framework-react/dist/runtime';
 import Taro from '@tarojs/taro';
 export * from '@tarojs/taro';

package/dist/runtime/client/taro/api.js

@@ -0,0 +1,9 @@
+import '@tarojs/plugin-framework-react/dist/runtime';
+import { hooks } from '@tarojs/runtime';
+import Taro from '@tarojs/taro';
+if (hooks.isExist('initNativeApi')) {
+    hooks.call('initNativeApi', Taro);
+}
+// @ts-expect-error @tarojs/taro declares export= types, but the facade also exposes its runtime named exports.
+export * from '@tarojs/taro';
+export default Taro;

package/dist/runtime/client/taro/component.d.ts

@@ -0,0 +1 @@
+export * from '@tarojs/components';

package/dist/runtime/client/taro/component.js

@@ -0,0 +1 @@
+export * from '@tarojs/components';

package/dist/runtime/client/taro/define-native-component.d.ts

@@ -0,0 +1,7 @@
+import type { ComponentType, PropsWithChildren } from 'react';
+export type NativeComponentEvent<Detail> = {
+    readonly detail: Detail;
+};
+/** Defines a typed JSX interface from a static `() => import('./relative-entry.js')` reference. */
+export declare function defineNativeComponent(loadEntry: () => Promise<unknown>): ComponentType<PropsWithChildren>;
+export declare function defineNativeComponent<const Props extends object>(loadEntry: () => Promise<unknown>): ComponentType<PropsWithChildren<Props>>;

package/dist/runtime/client/taro/define-native-component.js

@@ -0,0 +1,4 @@
+export function defineNativeComponent(loadEntry) {
+    void loadEntry;
+    throw new Error('Native component interface was not compiled');
+}

package/dist/runtime/h5/app.d.ts

@@ -0,0 +1,2 @@
+/** biome-ignore-all assist/source/organizeImports: keep side effect orders */
+export {};

package/dist/runtime/h5/app.js

@@ -0,0 +1,15 @@
+/** biome-ignore-all assist/source/organizeImports: keep side effect orders */
+import { createHashHistory, createReactApp, createRouter, handleAppMount, window } from './taro-runtime.js';
+import React from 'react';
+import ReactDOM from 'react-dom/client';
+// @ts-expect-error: The H5 build resolves this private App component.
+import AppComponent from '\0vpt:app-component';
+const browserWindow = window;
+const config = __VITE_PLUGIN_TARO_H5_APP_CONFIG__;
+browserWindow.__taroAppConfig = config;
+config.routes = __VITE_PLUGIN_TARO_H5_ROUTES__;
+const app = createReactApp(AppComponent, React, ReactDOM, config);
+const history = createHashHistory({ window: browserWindow });
+handleAppMount(config, history);
+// @ts-expect-error Taro's implementation receives the React adapter object despite declaring a string.
+createRouter(history, app, config, React);

package/dist/runtime/h5/taro-runtime.d.ts

@@ -2,5 +2,5 @@
 import '@tarojs/components/global.css';
 import '@tarojs/components/dist/taro-components/taro-components.css';
 export { createReactApp } from '@tarojs/plugin-framework-react/dist/runtime';
-export { createBrowserHistory, createHashHistory, createRouter, handleAppMount } from '@tarojs/router';
+export { createHashHistory, createRouter, handleAppMount } from '@tarojs/router';
 export { window } from '@tarojs/runtime';

package/dist/runtime/h5/taro-runtime.js

@@ -1,9 +1,6 @@
 /** Runtime exports consumed by the generated H5 entry. */
 import '@tarojs/components/global.css';
 import '@tarojs/components/dist/taro-components/taro-components.css';
-// Import the CSS files directly instead of @tarojs/plugin-platform-h5/dist/runtime:
-// that runtime adds only taro-components.css plus optional polyfills, while generated H5 entries also need global.css.
-// @ts-expect-error Taro exposes createReactApp from this runtime-only deep entry without types.
 export { createReactApp } from '@tarojs/plugin-framework-react/dist/runtime';
-export { createBrowserHistory, createHashHistory, createRouter, handleAppMount } from '@tarojs/router';
+export { createHashHistory, createRouter, handleAppMount } from '@tarojs/router';
 export { window } from '@tarojs/runtime';

package/dist/runtime/wx/amphibious/bootstrap.d.ts

@@ -0,0 +1,4 @@
+import '../systemjs/system-core.js';
+/** Shares one App configuration object between the specialized bootstrap and App capsule. */
+export declare const appConfig: Record<string, unknown>;
+export declare const __vitePreload: <Value>(load: () => Value) => Value;

package/dist/runtime/wx/amphibious/bootstrap.js

@@ -0,0 +1,16 @@
+// Install the minimal SystemJS loader and its synchronous-import extension before any native entry requests a capsule.
+import '../systemjs/system-core.js';
+import { transport } from './transport.js';
+/** Shares one App configuration object between the specialized bootstrap and App capsule. */
+export const appConfig = __VITE_PLUGIN_TARO_APP_CONFIG__;
+// WX has no modulepreload transport. Genuine application import() boundaries retain System.import() and may load
+// asynchronous subpackage or top-level-await graphs through this identity wrapper.
+export const __vitePreload = (load) => load();
+// SystemJS installs on WeChat's `global` object; its properties are not lexical bindings.
+const installedSystem = global.System;
+if (!installedSystem) {
+    throw new Error('SystemJS failed to initialize in the WeChat runtime');
+}
+// Transport returns synchronous registrations for main-package capsules and amphibious modules, and promise-like
+// registrations only for capsules that physically live in generated subpackages.
+installedSystem.instantiate = transport;

package/dist/runtime/wx/amphibious/transport.d.ts

@@ -0,0 +1,2 @@
+/** Dispatches to one generated literal require and bridges amphibious CommonJS namespaces inline. */
+export declare const transport: (moduleId: string) => System.Registration | PromiseLike<System.Registration>;

package/dist/runtime/wx/amphibious/transport.js

@@ -0,0 +1,4 @@
+// Transport itself executes only as native CommonJS. It lives beside bootstrap because together they implement the
+// amphibious boundary that publishes native namespaces to SystemJS without re-evaluating their module bodies.
+/** Dispatches to one generated literal require and bridges amphibious CommonJS namespaces inline. */
+export const transport = __VITE_PLUGIN_TARO_TRANSPORT__;

package/dist/runtime/wx/capsule/app.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/wx/capsule/app.js

@@ -0,0 +1,7 @@
+// biome-ignore assist/source/organizeImports: Taro must initialize before the App component.
+import { createReactApp, ReactDOM } from './taro-runtime.js';
+import React from 'react';
+import { appConfig } from '../amphibious/bootstrap.js';
+// @ts-expect-error: The wx build resolves this private App component.
+import AppComponent from '\0vpt:app-component';
+export default createReactApp(AppComponent, React, ReactDOM, appConfig);

package/dist/runtime/wx/capsule/component.d.ts

@@ -0,0 +1,3 @@
+import './app.ts';
+declare const _default: any;
+export default _default;

package/dist/runtime/wx/capsule/component.js

@@ -0,0 +1,4 @@
+// Keep recursive Component activation behind the same App initialization barrier as Page activation.
+import './app.js';
+import { createRecursiveComponentConfig } from './taro-runtime.js';
+export default createRecursiveComponentConfig('comp');

package/dist/runtime/wx/capsule/page.d.ts

@@ -0,0 +1,3 @@
+import './app.ts';
+declare const config: import("@tarojs/runtime").PageInstance;
+export default config;

package/dist/runtime/wx/capsule/page.js

@@ -0,0 +1,68 @@
+// App and Page shells activate independently; make Current.app initialization an explicit prerequisite for Page mount.
+import './app.js';
+// @ts-expect-error: The wx build replaces this private import with the configured Page component.
+import PageComponent from '\0vpt:page-component';
+import { Current, createPageConfig, document, injectPageInstance } from './taro-runtime.js';
+const config = createPageConfig(PageComponent, __VITE_PLUGIN_TARO_PAGE_PATH__, { root: { cn: [] } }, __VITE_PLUGIN_TARO_PAGE_CONFIG__);
+export default config;
+/** Forwards a call with the native page instance as `this`, matching Taro's invocation. */
+function forward(handler, receiver, args) {
+    ;
+    handler?.apply(receiver, args);
+}
+// DevTools re-executes the page and replays the replacement lifecycle on every edit. Taro's
+// onUnload unmounts the React tree and onLoad mounts a fresh one, destroying state. While
+// the runtime says a patch was just delivered, the pair is intercepted instead: onUnload
+// captures the surviving page identity, and onLoad restores it onto the replacement native
+// instance and rebinds the retained tree to it (pageElement.ctx + a full re-render). The
+// capsule module is cached across re-executions, so this closure holds the capture.
+// Ordinary navigation (no patch) passes through unchanged. The wrappers are regular
+// functions so the native page instance (`this`) reaches the original handlers.
+if (typeof __rolldown_runtime__ !== 'undefined') {
+    const originalOnUnload = config.onUnload;
+    const originalOnLoad = config.onLoad;
+    const originalOnShow = config.onShow;
+    let captured;
+    config.onUnload = function (...args) {
+        if (__rolldown_runtime__.isHotReloading()) {
+            const instance = this;
+            captured = {
+                $taroPath: instance.$taroPath,
+                $taroParams: instance.$taroParams
+            };
+            return;
+        }
+        forward(originalOnUnload, this, args);
+    };
+    config.onLoad = function (...args) {
+        if (__rolldown_runtime__.isHotReloading() && captured) {
+            // Restore the surviving page identity onto the replacement native instance: the
+            // re-loaded $taroPath embeds a fresh timestamp, so without this the tree and the
+            // native side would disagree on the page key.
+            const instance = this;
+            instance.$taroPath = captured.$taroPath;
+            instance.$taroParams = captured.$taroParams;
+            // Rebind the retained tree to the replacement receiver and resync the native
+            // data: updateChildNodes enqueues the full hydrated node tree (root.cn) — the
+            // surviving tree's mutations were consumed long ago, so without it the payload
+            // queue is empty and the new receiver renders nothing.
+            injectPageInstance(instance, captured.$taroPath);
+            Current.page = instance;
+            const pageElement = document.getElementById(captured.$taroPath);
+            pageElement.ctx = instance;
+            pageElement.updateChildNodes();
+            pageElement.performUpdate(true);
+            return;
+        }
+        forward(originalOnLoad, this, args);
+    };
+    config.onShow = function (...args) {
+        if (__rolldown_runtime__.isHotReloading()) {
+            // The window ends at the first show; the user's onShow must not re-run on a
+            // synthetic re-execution (it could reset state).
+            __rolldown_runtime__.clearHotReloading();
+            return;
+        }
+        forward(originalOnShow, this, args);
+    };
+}

package/dist/runtime/wx/capsule/taro-runtime.d.ts

@@ -0,0 +1,6 @@
+/** biome-ignore-all assist/source/organizeImports: keep side effect orders */
+/** Taro runtime exports shared by the App, Page, and recursive Component capsules. */
+import '@tarojs/plugin-platform-weapp/dist/runtime.js';
+export { createReactApp } from '@tarojs/plugin-framework-react/dist/runtime';
+export { default as ReactDOM } from '@tarojs/react';
+export { createPageConfig, createRecursiveComponentConfig, Current, document, injectPageInstance } from '@tarojs/runtime';

package/dist/runtime/wx/capsule/taro-runtime.js

@@ -0,0 +1,6 @@
+/** biome-ignore-all assist/source/organizeImports: keep side effect orders */
+/** Taro runtime exports shared by the App, Page, and recursive Component capsules. */
+import '@tarojs/plugin-platform-weapp/dist/runtime.js';
+export { createReactApp } from '@tarojs/plugin-framework-react/dist/runtime';
+export { default as ReactDOM } from '@tarojs/react';
+export { createPageConfig, createRecursiveComponentConfig, Current, document, injectPageInstance } from '@tarojs/runtime';

package/dist/runtime/wx/dev/dev-runtime.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/wx/dev/dev-runtime.js

@@ -0,0 +1,246 @@
+// WX dev runtime — bundled and injected verbatim at the end of the shared Rolldown
+// runtime chunk (`assets/rolldown-runtime.js`, required first by every chunk). Defines the
+// App-global `__rolldown_runtime__` that generated modules call.
+//
+// The `DevRuntime` base class is injected into the chunk by Rolldown's dev-mode
+// transform, so the WX host only extends it.
+//
+// Delivery is passive: every valid hmr/patches.js suffix is acknowledged by Rolldown
+// sequence, then applied synchronously before the Page continues evaluating. Already-applied
+// sequences are ignored when another Page requires the same physical file.
+/**
+ * Per-module hot state, mirroring Rolldown's web runtime: accept is a passive registration;
+ * the propagation invokes the previous execution's callbacks with the fresh exports.
+ */
+class WxHotContext {
+    _internal = {
+        updateStyle() { },
+        removeStyle() { }
+    };
+    /** Registered self-accept callbacks; a bare accept is represented by a no-op callback. */
+    acceptCallbacks = [];
+    /** Set when a callback rejects a Refresh boundary; the current update then rebuilds. */
+    invalidationReason;
+    accept(callback) {
+        this.acceptCallbacks.push(callback ?? (() => { }));
+    }
+    hasAccepts() {
+        return this.acceptCallbacks.length > 0;
+    }
+    /** Invokes this old context's callbacks and returns any requested invalidation. */
+    runAccept(moduleExports) {
+        for (const callback of this.acceptCallbacks) {
+            callback(moduleExports);
+        }
+        return this.invalidationReason;
+    }
+    invalidate(reason) {
+        this.invalidationReason = reason ?? 'the accepting module invalidated the update';
+    }
+    // Vite's generated CSS module calls hot.prune with its style teardown; the physical
+    // rebuild replaces styles wholesale, so it is a no-op.
+    prune(_callback) { }
+}
+/** The WX host: extends the Rolldown contract instead of reimplementing it. */
+class WxDevRuntime extends DevRuntime {
+    hmrInfo;
+    /** Highest Rolldown sequence successfully applied. */
+    appliedSeq = 0;
+    /** Active hot contexts per module id; the propagation invokes their callbacks. */
+    moduleHotContexts = new Map();
+    constructor() {
+        // The base has no messenger: the engine tracks per-client shipped payloads instead
+        // of executed module ids, so the wx host registers the client session itself.
+        super('');
+    }
+    /**
+     * Generated code always calls this before registerModule and reads `_internal` from the
+     * return value. Mirrors Rolldown's web runtime: each execution immediately replaces the
+     * module's hot context; the apply plan has already captured the previous callbacks.
+     */
+    createModuleHotContext(moduleId) {
+        const hotContext = new WxHotContext();
+        this.moduleHotContexts.set(moduleId, hotContext);
+        return hotContext;
+    }
+    /** Computes accepting boundaries and every executed module that must be re-armed. */
+    computeHmrUpdate(changedIds) {
+        // Mutable traversal accumulators are confined to one synchronous update plan.
+        const boundaries = [];
+        const updateSet = new Set();
+        for (const changedId of changedIds) {
+            if (!this.isExecuted(changedId))
+                continue;
+            // Mutable only for the current DFS path, providing O(1) cycle checks.
+            const path = new Set([changedId]);
+            const fullReloadReason = this.bubble(changedId, path, updateSet, boundaries);
+            if (fullReloadReason) {
+                throw new Error(fullReloadReason);
+            }
+        }
+        return boundaries.length > 0 ? { boundaries, updateSet } : undefined;
+    }
+    /** Walks executed importers until an accepting boundary is found. */
+    bubble(moduleId, path, updateSet, boundaries) {
+        if (updateSet.has(moduleId))
+            return undefined;
+        updateSet.add(moduleId);
+        if (this.moduleHotContexts.get(moduleId)?.hasAccepts()) {
+            boundaries.push(moduleId);
+            return undefined;
+        }
+        const importers = this.getImporters(moduleId).filter((importer) => this.isExecuted(importer));
+        if (importers.length === 0) {
+            return `no HMR boundary found for module ${moduleId}`;
+        }
+        for (const importer of importers) {
+            if (path.has(importer)) {
+                return `circular HMR propagation between ${moduleId} and ${importer}`;
+            }
+            path.add(importer);
+            const fullReloadReason = this.bubble(importer, path, updateSet, boundaries);
+            path.delete(importer);
+            if (fullReloadReason)
+                return fullReloadReason;
+        }
+        return undefined;
+    }
+    /**
+     * Applies one patch in three phases: capture old contexts, evict the whole update set,
+     * then re-run accepting modules and pass their fresh exports to the old contexts.
+     */
+    applyHmrUpdate(changedIds) {
+        const update = this.computeHmrUpdate(changedIds);
+        if (!update)
+            return;
+        for (const moduleId of update.updateSet) {
+            if (!this.hasFactory(moduleId)) {
+                throw new Error(`no HMR factory for module ${moduleId}`);
+            }
+        }
+        const applies = update.boundaries.map((moduleId) => ({
+            moduleId,
+            hotContext: this.moduleHotContexts.get(moduleId)
+        }));
+        // This eviction must happen before initModule: otherwise its cache gate returns the
+        // old exports and the freshly registered factory never executes.
+        for (const moduleId of update.updateSet) {
+            this.removeModuleCache(moduleId);
+        }
+        for (const { moduleId, hotContext } of applies) {
+            const invalidationReason = hotContext?.runAccept(this.initModule(moduleId));
+            if (invalidationReason) {
+                throw new Error(`${moduleId}: ${invalidationReason}`);
+            }
+        }
+    }
+    /** Consumed once per App heap from hmr/info.js; the host buildId is the delivery identity. */
+    initialize(info) {
+        if (this.hmrInfo) {
+            return;
+        }
+        this.hmrInfo = info;
+        // Anchor: the host publishes only after the runtime reports its delivery position.
+        void this.sendReport({ kind: 'delivery', seq: this.appliedSeq });
+    }
+    /** True between a patch delivery and the next page show: a hot reload is in progress. */
+    hotReloading = false;
+    /** The capsule wrapper asks this during the synthetic lifecycle of a hot reload. */
+    isHotReloading() {
+        return this.hotReloading;
+    }
+    /** The wrapped onShow ends the hot reload after the replacement cycle. */
+    clearHotReloading() {
+        this.hotReloading = false;
+    }
+    /** The only direct effect of hmr/patches.js: validate, store, acknowledge, and apply. */
+    storePatches(payload) {
+        const info = this.hmrInfo;
+        if (!info || payload.buildId !== info.buildId) {
+            console.warn('[vpt] patches for a stale build');
+            return;
+        }
+        const deliveredSeq = Math.max(this.appliedSeq, payload.patches.at(-1)?.seq ?? 0);
+        void this.sendReport({ kind: 'delivery', seq: deliveredSeq });
+        // A delivered patch means DevTools is about to replay the page lifecycle on the
+        // re-executing Pages; the capsule wrapper suppresses the synthetic unmount/mount so
+        // the React tree survives and Refresh swaps the code in place.
+        this.hotReloading = true;
+        // Apply synchronously: the page's imports below the require resolve against the
+        // freshly registered modules, so the re-executed Page evaluates with the new code.
+        this.applyPatches(payload.patches);
+    }
+    /** Applies one physical suffix in Rolldown sequence order. */
+    applyPatches(patches) {
+        for (const patch of patches) {
+            if (patch.seq <= this.appliedSeq)
+                continue;
+            try {
+                const expectedSeq = this.appliedSeq + 1;
+                if (patch.seq !== expectedSeq) {
+                    throw new Error(`missing patch sequence ${expectedSeq}`);
+                }
+                patch.factory();
+                this.applyHmrUpdate(patch.changedIds);
+                this.appliedSeq = patch.seq;
+            }
+            catch (error) {
+                console.warn(`[vpt] patch sequence ${patch.seq} failed; apply stopped`, error);
+                void this.sendReport({ kind: 'rebuild' });
+                return;
+            }
+        }
+    }
+    /** Sends one metadata-only report to the host; executable code never travels over HTTP. */
+    sendReport(data) {
+        const info = this.hmrInfo;
+        if (!info) {
+            // A report without initialize is a programming error; fail loudly instead of
+            // silently dropping the sync traffic.
+            throw new Error('WX dev runtime is not initialized');
+        }
+        return new Promise((resolve, reject) => {
+            wx.request({
+                url: info.endpoint,
+                method: 'POST',
+                data: { buildId: info.buildId, ...data },
+                header: { 'content-type': 'application/json' },
+                success() {
+                    resolve();
+                },
+                fail(error) {
+                    reject(error);
+                }
+            });
+        });
+    }
+}
+const runtime = new WxDevRuntime();
+globalThis.__rolldown_runtime__ = runtime;
+// Install the React DevTools hook before the Taro renderer injects itself: the runtime chunk
+// is the first module of the App heap, and the renderer checks the hook when it evaluates at
+// App mount. The refresh runtime's own injection (see react-refresh.ts) replays this hook's
+// renderers, so the hook must store what inject receives — a real DevTools hook keeps the
+// renderer in the renderers Map; without the stored renderer the replay captures nothing and
+// Refresh has no renderer helpers to schedule re-renders on.
+//
+// The hook lives on `global`, and every free `__REACT_DEVTOOLS_GLOBAL_HOOK__` reference in
+// react-family modules is rewritten to `global.__REACT_DEVTOOLS_GLOBAL_HOOK__`: the
+// The WeChat runtime scope does not resolve free variables against `global` (verified: the free
+// lookup is undefined while the member access exists), so the renderer would never inject
+// otherwise. `??=` keeps a pre-installed hook (e.g. a real DevTools integration) intact; the
+// runtime chunk's own lowering keeps the operator es2018-compatible.
+const reactDevtoolsHook = {
+    renderers: new Map(),
+    supportsFiber: true,
+    inject: (injected) => {
+        const id = reactDevtoolsHook.renderers.size;
+        reactDevtoolsHook.renderers.set(id, injected);
+        return id;
+    },
+    onScheduleFiberRoot: () => { },
+    onCommitFiberRoot: () => { },
+    onCommitFiberUnmount: () => { }
+};
+global.__REACT_DEVTOOLS_GLOBAL_HOOK__ ??= reactDevtoolsHook;
+export {};

package/dist/runtime/wx/native/app.d.ts

@@ -0,0 +1 @@
+import '../amphibious/bootstrap.ts';

package/dist/runtime/wx/native/app.js

@@ -0,0 +1,3 @@
+import '../amphibious/bootstrap.js';
+import appConfig from '../capsule/app.js';
+App(appConfig);

package/dist/runtime/wx/native/component.d.ts

@@ -0,0 +1 @@
+import '../amphibious/bootstrap.ts';

package/dist/runtime/wx/native/component.js

@@ -0,0 +1,3 @@
+import '../amphibious/bootstrap.js';
+import componentConfig from '../capsule/component.js';
+Component(componentConfig);

package/dist/runtime/wx/native/page.d.ts

@@ -0,0 +1 @@
+import '../amphibious/bootstrap.ts';

package/dist/runtime/wx/native/page.js

@@ -0,0 +1,4 @@
+import '../amphibious/bootstrap.js';
+// @ts-expect-error: The wx build resolves the route-specific Page capsule.
+import pageConfig from '\0vpt:page-capsule';
+Page(pageConfig);

package/dist/runtime/wx/systemjs/system-core.d.ts

@@ -0,0 +1,4 @@
+export { REGISTRY, systemJSPrototype };
+declare var REGISTRY: string | symbol;
+declare var systemJSPrototype: any;
+export declare function getOrCreateLoad(loader: any, id: any, firstParentUrl: any, meta: any): any;