vite-plugin-taro 0.6.20-beta.2 → 0.6.20

package/dist/node/plugins/wx/dev/dev-host.d.ts

@@ -1,20 +1,29 @@
 import type { ViteDevServer } from 'vite';
 import type { VptOptions } from '../../../../options.ts';
+import { type RuntimeControlMessage, type RuntimeReport } from '../../../../runtime/wx/dev/wx-hmr-protocol.ts';
 import type { WxStylePlugin } from '../styles/plugins.ts';
+import type { WxHmrMode } from './hmr-mode.ts';
+declare module 'vite' {
+    interface CustomEventMap {
+        'vpt:wx-hmr:control': RuntimeControlMessage;
+        'vpt:wx-hmr:report': RuntimeReport;
+    }
+}
 export type WxDevHost = Readonly<{
     close: () => Promise<void>;
 }>;
 /**
- * Creates the wx dev host: the adapter that owns the physical Rolldown DevEngine (created
- * with dev(...)) and the patch publisher, and replaces Vite's bundledDev.listen so the
- * engine writes directly to the Mini Program output directory instead of serving browser
- * HMR over HTTP.
+ * Creates the WX dev host: the adapter that owns the physical Rolldown DevEngine, shared patch journal, and selected mode effects.
+ * It replaces Vite's browser-oriented `bundledDev.listen()` because a Mini Program cannot execute Vite's browser module graph;
+ * its engine must write a complete native project while the selected mode supplies an environment-valid patch mechanism.
  *
  * The shared style plugin carries the resolver's immutable App/Page cascade policy while Rolldown remains authoritative for
- * every live import edge.
+ * every live import edge. Keeping those responsibilities in the same serialized host transaction prevents JavaScript factories,
+ * physical WXSS, and Rolldown's published frontier from describing different source generations.
  */
-export declare function createWxDevHost({ server, options, styles }: {
+export declare function createWxDevHost({ server, options, styles, hmrMode }: {
     server: ViteDevServer;
     options: VptOptions;
     styles: WxStylePlugin;
+    hmrMode: WxHmrMode;
 }): Promise<WxDevHost>;

package/dist/node/plugins/wx/dev/hmr-files.d.ts

@@ -1,23 +1,12 @@
-import type { BindingClientHmrUpdate } from 'rolldown/experimental';
+import type { HmrInfo } from './hmr-protocol.ts';
 export declare const developmentAppWxssFileName = "app.wxss";
 export declare const globalWxssFileName = "assets/global.wxss";
 export declare const hmrInfoFileName = "hmr/info.js";
-export declare const hmrPatchesFileName = "hmr/patches.js";
-/** Report endpoint path served by the wx dev control edge. */
-export declare const hmrControlPath = "/__vpt_hmr__";
-/** Immutable App metadata for the current complete physical build. */
-export type HmrInfo = Readonly<{
-    buildId: string;
-    endpoint: string;
-}>;
-/** The Patch variant of Rolldown's per-client HMR update, admitted into the patch history. */
-export type PatchUpdate = Extract<BindingClientHmrUpdate['update'], {
-    type: 'Patch';
-}>;
-/** Renders the synchronous CommonJS metadata module loaded by the runtime chunk. */
+/**
+ * Renders immutable CommonJS metadata because App startup must initialize the runtime synchronously before any entry capsule.
+ * Freezing also prevents application code from accidentally changing the build identity or socket endpoint for the App heap.
+ */
 export declare function renderHmrInfo(info: HmrInfo): string;
-/** Provides a valid dependency before the host has a patch range to publish. */
-export declare function renderInitialHmrPatches(): string;
 /**
  * Renders the native App style entry for one complete development build.
  *
@@ -27,11 +16,10 @@ export declare function renderInitialHmrPatches(): string;
  */
 export declare function renderDevelopmentAppWxss(buildId: string): string;
 /**
- * Renders the cumulative patch suffix as inert CommonJS data.
+ * Atomically publishes one physical development file so DevTools can observe only complete generations.
  *
- * DevTools re-executes the Page because this dependency changed. The Page entry passes the exported payload to the persistent
- * App runtime synchronously before importing its capsule, keeping delivery explicit and leaving this file free of side effects.
+ * Writing directly to the watched JavaScript path exposes truncate and partial-write states as separate filesystem events. A
+ * sibling temporary file plus same-filesystem rename makes the destination replacement atomic while remaining reusable for
+ * metadata and styles; the `.txt` suffix keeps DevTools from compiling the temporary source as another Mini Program module.
  */
-export declare function renderHmrPatches(buildId: string, patches: readonly PatchUpdate[]): string;
-/** Atomically publishes one physical HMR module so DevTools can observe only complete JavaScript generations. */
-export declare function writeHmrFile(outDir: string, fileName: string, source: string): Promise<void>;
+export declare function writeDevelopmentFile(outDir: string, fileName: string, source: string): Promise<void>;

package/dist/node/plugins/wx/dev/hmr-mode.d.ts

@@ -0,0 +1,31 @@
+import type { Plugin } from 'vite';
+import type { VptHmrOptions } from '../../../../options.ts';
+import type { PatchPublication } from './hmr-protocol.ts';
+/** One mode-selected effect executed by the development host. */
+export type WxHmrAction = Readonly<{
+    kind: 'event';
+    event: string;
+    data: unknown;
+}> | Readonly<{
+    kind: 'write';
+    fileName: string;
+    source: string;
+}>;
+/**
+ * The behavior that genuinely differs between WX HMR implementations.
+ *
+ * The descriptor is selected once during plugin composition and returns declarative effects. The shared host alone performs
+ * physical writes and event transport, so neither mode receives a Vite server or owns asynchronous infrastructure.
+ */
+export type WxHmrMode = Readonly<{
+    runtimeFile: string;
+    plugins: readonly Plugin[];
+    reset: () => WxHmrAction | undefined;
+    publish: (publication: PatchPublication) => WxHmrAction;
+    createEntryBanner: (pageFiles: ReadonlySet<string>) => (chunk: Readonly<{
+        name: string;
+        fileName: string;
+    }>) => string;
+}>;
+/** Resolves exactly one implementation before the WX development host is created. */
+export declare function createWxHmrMode(options: VptHmrOptions | undefined): WxHmrMode;

package/dist/node/plugins/wx/dev/hmr-protocol.d.ts

@@ -0,0 +1,16 @@
+import type { BindingClientHmrUpdate } from 'rolldown/experimental';
+/** Shared Vite WebSocket path for runtime reports and mode-specific HMR events. */
+export declare const hmrEndpointPath = "/__vpt_hmr__";
+export type { HmrInfo, RuntimeReport } from '../../../../runtime/wx/dev/wx-hmr-protocol.ts';
+/** The Patch variant of Rolldown's per-client HMR update admitted into the patch journal. */
+export type PatchUpdate = Extract<BindingClientHmrUpdate['update'], {
+    type: 'Patch';
+}>;
+/**
+ * One cumulative patch suffix coupled to its build identity. Delivery receives this structured value instead of reading journal
+ * state, keeping physical rendering stateless and making stale-build rejection part of the payload the runtime actually sees.
+ */
+export type PatchPublication = Readonly<{
+    buildId: string;
+    patches: readonly PatchUpdate[];
+}>;

package/dist/node/plugins/wx/dev/modes/devtools/devtools-hmr-mode.d.ts

@@ -0,0 +1,31 @@
+import type { WxHmrMode } from '../../hmr-mode.ts';
+import type { PatchUpdate } from '../../hmr-protocol.ts';
+export declare const devtoolsPatchesFileName = "hmr/patches.js";
+/**
+ * Collects the behavior that depends on WeChat DevTools project-file compilation.
+ *
+ * Runtime entry, Page transform, entry banners, and patch delivery stay in one descriptor because they implement one protocol:
+ * DevTools observes a changed Page dependency, re-executes the Page shell, and that shell synchronously gives the cumulative
+ * native factory payload to the persistent App runtime. Mixing any one of these pieces with another mode would break that chain.
+ */
+export declare function createDevtoolsHmrMode(): WxHmrMode;
+/** Provides a valid, inert CommonJS dependency before the host has a patch range to publish. */
+export declare function renderInitialDevtoolsPatches(): string;
+/**
+ * Renders the cumulative patch suffix as inert CommonJS data.
+ *
+ * DevTools re-executes a live Page because this physical dependency changed. The Page banner passes the exported payload to the
+ * persistent App runtime before importing its capsule. Keeping the module inert—rather than applying factories at top level—
+ * makes that ordering explicit, lets the runtime reject stale build IDs, and makes replay by several live Pages safe.
+ */
+export declare function renderDevtoolsPatches(buildId: string, patches: readonly PatchUpdate[]): string;
+/**
+ * Injects Page handoff at the exact native registration edge rather than wrapping arbitrary user `Page` calls.
+ *
+ * The native shell has one stable `Page(pageConfig)` contract. Failing when that contract changes is intentional: silently
+ * skipping this transform would let DevTools unload the live Taro Page and destroy React state while appearing to support HMR.
+ */
+export declare function injectPageShellHmr(code: string): {
+    code: string;
+    map: null;
+};

package/dist/node/plugins/wx/dev/modes/interpreter/interpreter-hmr-mode.d.ts

@@ -0,0 +1,3 @@
+import type { WxHmrMode } from '../../hmr-mode.ts';
+/** Creates the pure interpreter adapter whose events are dispatched by the shared development host. */
+export declare function createInterpreterHmrMode(): WxHmrMode;

package/dist/node/plugins/wx/dev/patch-journal.d.ts

@@ -0,0 +1,45 @@
+import type { PatchPublication, PatchUpdate } from './hmr-protocol.ts';
+type PublishPatches = (publication: PatchPublication) => Promise<void>;
+/**
+ * Owns the cumulative sequence range between the host's published frontier and the runtime's applied frontier.
+ *
+ * For example, if the runtime has applied sequence 4:
+ *
+ * 1. produce([5, 6]) publishes [5, 6];
+ * 2. produce([7]) before an application report publishes [5, 6, 7], so a mode may miss the first delivery safely;
+ * 3. acknowledge(6) retains [7];
+ * 4. produce([8]) then publishes [7, 8], exactly the suffix the runtime still needs.
+ *
+ * The host may advance Rolldown's published frontier immediately after each durable publication, but the journal prunes only
+ * through the runtime's last successful ACK. Published and applied sequences are deliberately distinct: collapsing them would
+ * make one missed delivery unrecoverable. The journal owns that gap and build identity while the mode owns representation.
+ */
+export declare class PatchJournal {
+    private readonly publishPatches;
+    private buildId;
+    private readonly pendingPatches;
+    constructor(publishPatches: PublishPatches);
+    /** True when the buildId belongs to the current complete build. */
+    isCurrentBuild(buildId: string): boolean;
+    /** Begins a fresh build and returns both sides of the client-session rotation. */
+    startBuild(): Readonly<{
+        buildId: string;
+        previousBuildId: string | undefined;
+    }>;
+    /**
+     * Appends a Rolldown batch and publishes the complete range not yet applied by the runtime.
+     *
+     * Host action serialization guarantees this readonly view cannot be mutated by an ACK, build rotation, or later production
+     * until publishPatches settles. Resolution proves only that the mode made the suffix durable, not that the App applied it; a
+     * failed publication therefore leaves the appended range intact, and a successful one remains until an explicit ACK.
+     */
+    produce(patches: readonly PatchUpdate[]): Promise<void>;
+    /**
+     * Removes only the prefix covered by the runtime's successful application frontier.
+     *
+     * Publication must never call this method: retaining the gap between published and applied frontiers is what lets a mode
+     * safely coalesce, replay, or miss an intermediate delivery without losing a factory required by the live App generation.
+     */
+    acknowledge(seq: number): void;
+}
+export {};

package/dist/node/plugins/wx/dev/plugins.d.ts

@@ -6,8 +6,8 @@ export declare function isWxClientEnvironment(environment: Readonly<{
     name: string;
 }>): boolean;
 /**
- * Adds the serve-only bundled-development plugin set for the wx target: the dev adapter,
- * Page HMR activation, and React Refresh adaptation transforms.
+ * Adds the serve-only bundled-development plugin set for the wx target: the shared dev adapter, selected HMR mode, and React
+ * Refresh adaptation transforms.
  *
  * The shared style pipeline already owns the resolver's ordered App/Page cascade policy, so the host does not reconstruct it
  * from unrelated Rolldown shell and transport entries.
@@ -24,13 +24,9 @@ export declare function createWxDevelopmentPlugin(options: VptOptions, styles: W
  * 3. let the host replace the wrapper again with the new build ID, causing a second App reload.
  *
  * Deleting only the in-memory bundle entry avoids both premature writes. Development sets `emptyOutDir: false`, so the prior
- * physical `app.wxss` remains available while the complete output is written. The host replaces it exactly once after
- * `hmr/patches.js` and `hmr/info.js` are durable. Incremental HMR never enters this complete-output hook and continues changing
- * only `assets/global.wxss`, which preserves the App heap. The serve-only plugin leaves production output unchanged.
+ * physical `app.wxss` remains available while the complete output is written. The host replaces it exactly once after the
+ * selected mode has reset and the matching `hmr/info.js` identity is durable. Incremental HMR never enters this complete-
+ * output hook and changes only `assets/global.wxss`; rewriting the App root would reload the heap while a JavaScript patch is
+ * awaiting acknowledgement. The serve-only plugin leaves production output unchanged.
  */
 export declare function removeDevelopmentAppWxss(bundle: Record<string, unknown>): void;
-/** Injects the retained snapshot at the exact native Page registration edge. */
-export declare function injectPageShellHmr(code: string): {
-    code: string;
-    map: null;
-};

package/dist/node/plugins/wx/dev/wx-dev-options.d.ts

@@ -2,6 +2,7 @@ import type { InputOptions, OutputOptions } from 'rolldown';
 import { type DevEngine } from 'rolldown/experimental';
 import type { ViteDevServer } from 'vite';
 import type { VptOptions } from '../../../../options.ts';
+import type { WxHmrMode } from './hmr-mode.ts';
 type BundledDevRolldownOptions = InputOptions & {
     experimental?: {
         [key: string]: unknown;
@@ -19,10 +20,11 @@ export type BundledDev = {
  * Installs physical WX output and runtime conventions over Vite's browser-oriented bundled-development options.
  * Build completion deliberately remains outside this options adapter: DevEngine onOutput is the single lifecycle authority.
  */
-export declare function installWxDevOptions({ bundledDev, server, options }: {
+export declare function installWxDevOptions({ bundledDev, server, options, hmrMode }: {
     bundledDev: BundledDev;
     server: ViteDevServer;
     options: VptOptions;
+    hmrMode: WxHmrMode;
 }): void;
 /** Returns the configured output after rejecting states unsupported by the physical WX engine. */
 export declare function requireSingleOutput(rolldownOptions: BundledDevRolldownOptions): OutputOptions;

package/dist/options.d.ts

@@ -2,6 +2,11 @@
 export type VptJsonObject = Record<string, unknown>;
 /** Build target handled by this plugin. */
 export type VptTarget = 'wx' | 'h5';
+/** Selects one implemented WX development HMR delivery and execution mechanism. */
+export type VptHmrOptions = Readonly<{
+    /** `devtools` executes native patch files; `interpreter` fetches source and evaluates it without native Page reload. */
+    mode: 'devtools' | 'interpreter';
+}>;
 /** Configures one Taro page. */
 export type VptPageOption = {
     /**
@@ -69,4 +74,10 @@ export interface VptOptions {
      * The file is emitted only when this value is provided for a `wx` build. It is ignored for `h5`.
      */
     sitemapJson?: VptJsonObject;
+    /**
+     * Selects the WX development HMR mode. Omission uses `devtools`.
+     *
+     * This option affects only `vite serve` for the `wx` target and never changes H5 or production output.
+     */
+    hmr?: VptHmrOptions;
 }

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

@@ -4,3 +4,8 @@ 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 } from '@tarojs/runtime';
+import { customWrapperCache } from '@tarojs/runtime';
+// DevTools HMR runs in the bootstrap chunk, so publish the application graph's cache once on their shared App global.
+if (process.env.NODE_ENV === 'development') {
+    Reflect.set(global, Symbol.for('customWrapperCache'), customWrapperCache);
+}

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

@@ -0,0 +1,30 @@
+/*
+ * DevTools adapter injected into the App-global Rolldown runtime chunk. Every Page evaluates the inert `hmr/patches.js` payload
+ * before its route capsule, while this singleton survives Page JavaScript hot reload in the App heap. That lifetime difference is
+ * what allows module and React state to survive repeated native Page registration.
+ */
+import { WxHmrRuntime } from '../../wx-hmr-runtime.js';
+import { injectPageHmr as injectDevtoolsPageHmr } from './page-hmr.js';
+/** Adapts physical DevTools patch modules and Page replacement onto the shared WX HMR runtime. */
+class DevtoolsHmrRuntime extends WxHmrRuntime {
+    /** Applies one Page-delivered payload before the native shell imports its route capsule. */
+    applyPatches(payload) {
+        // The initial physical dependency exports undefined until the host has a patch range. Once present, apply synchronously:
+        // imports below the Page banner must resolve against the new registry during this same native Page evaluation.
+        if (!payload)
+            return;
+        this.applyPatchPayload(payload, installDevtoolsPatch);
+    }
+    /** Preserves the mounted Page connection while DevTools re-registers its static config. */
+    injectPageHmr(config) {
+        return injectDevtoolsPageHmr(config);
+    }
+}
+/** Executes only the native registration program; graph application remains owned by `WxHmrRuntime`. */
+function installDevtoolsPatch(patch) {
+    patch.factory();
+}
+// Generated modules already address this App-global name. Install exactly one adapter with the runtime chunk rather than one per
+// Page, because Page hot reload re-evaluates shells while the App heap and its module registry remain alive.
+const runtime = new DevtoolsHmrRuntime();
+globalThis.__rolldown_runtime__ = runtime;

package/dist/runtime/wx/dev/modes/devtools/page-hmr.d.ts

@@ -0,0 +1,20 @@
+type NativePage = {
+    data: Record<string, unknown>;
+};
+declare const pageHmrStateKey: unique symbol;
+type PageHmrState = {
+    /** True only across the unload/load/show sequence triggered by one native re-registration. */
+    isReregistering: boolean;
+    /** The Page bound to `this` by ordinary onLoad, retained until ordinary onUnload. */
+    mountedPage: NativePage | undefined;
+};
+type HmrPageConfig = {
+    data: Record<string, unknown>;
+    onUnload?: unknown;
+    onLoad?: unknown;
+    onShow?: unknown;
+    [pageHmrStateKey]?: PageHmrState;
+};
+/** Tracks the mounted native Page and prepares its static config for DevTools re-registration. */
+export declare function injectPageHmr(config: HmrPageConfig): HmrPageConfig;
+export {};

package/dist/runtime/wx/dev/modes/devtools/page-hmr.js

@@ -0,0 +1,133 @@
+// A symbol cannot collide with WeChat or Taro's string-named Page options, and it lets a later injection recover the exact
+// config-local state without a route map or runtime-global WeakMap.
+const pageHmrStateKey = Symbol('vpt.pageHmrState');
+/** Calls a native lifecycle with the same Page bound to `this` and the same arguments. */
+function forward(handler, page, args) {
+    if (typeof handler === 'function')
+        handler.apply(page, args);
+}
+/** Tracks the mounted native Page and prepares its static config for DevTools re-registration. */
+export function injectPageHmr(config) {
+    const existingState = config[pageHmrStateKey];
+    if (existingState) {
+        const mountedPage = existingState.mountedPage;
+        /*
+         * The static config can outlive a native Page instance. Before its first ordinary onLoad, or after a real onUnload,
+         * there is no mounted Page or current view-model to carry into another registration. Leave the lifecycle gate unarmed
+         * and preserve the config's existing initial data so a future real onLoad still enters Taro normally.
+         */
+        if (!mountedPage) {
+            return config;
+        }
+        /*
+         * Arm the lifecycle wrappers on this exact static config before it is passed back to `Page(config)`. DevTools then
+         * triggers an unload/load/show sequence for that native re-registration: unload and load observe `true` and return before
+         * entering Taro, preserving the mounted React tree and its original Page connection; show consumes the one-shot gate by
+         * restoring `false`. Ordinary navigation never enters this branch, and every Page config owns an independent state, so
+         * no route map, global phase, or Page identity comparison participates in the decision.
+         */
+        existingState.isReregistering = true;
+        /*
+         * `Page(config)` reads `config.data` as the initial native view-model for this registration. The Page owns current app
+         * and ordinary Page fields, while each mounted CustomWrapper owns the current snapshot below its native boundary. Join
+         * those already-serialized snapshots before registration so WeChat never publishes the stale initial placeholder tree.
+         * This lifecycle handoff performs no setData call and runs before React Refresh can publish another logical tree.
+         */
+        config.data = mountedPage.data;
+        applyCustomWrapperSnapshots(config.data);
+        return config;
+    }
+    const originalOnUnload = config.onUnload;
+    const originalOnLoad = config.onLoad;
+    const originalOnShow = config.onShow;
+    /*
+     * This mutable config-local state spans ordinary Page mount/unmount and one DevTools re-registration lifecycle. Lifecycle
+     * wrappers close over this exact object, while a later `injectPageHmr(config)` retrieves it through the symbol and avoids
+     * wrapping twice. Config-local ownership avoids route maps, runtime-global phase flags, and state shared by independent Page
+     * registrations; the state becomes unreachable together with its static config.
+     */
+    const state = {
+        isReregistering: false,
+        mountedPage: undefined
+    };
+    config[pageHmrStateKey] = state;
+    config.onUnload = function (...args) {
+        if (state.isReregistering) {
+            return;
+        }
+        forward(originalOnUnload, this, args);
+        state.mountedPage = undefined;
+    };
+    config.onLoad = function (...args) {
+        if (state.isReregistering) {
+            return;
+        }
+        forward(originalOnLoad, this, args);
+        state.mountedPage = this;
+    };
+    config.onShow = function (...args) {
+        if (state.isReregistering) {
+            // DevTools' synthetic unload/load/show cycle ends here. Consume the gate exactly once so the next real navigation
+            // forwards ordinary Taro lifecycles instead of being mistaken for the same registration.
+            state.isReregistering = false;
+            return;
+        }
+        forward(originalOnShow, this, args);
+    };
+    return config;
+}
+const customWrapperCacheKey = Symbol.for('customWrapperCache');
+/**
+ * Replaces stale Page.data placeholders with each mounted CustomWrapper's current native snapshot in at most one O(n)
+ * traversal. This mutates only the registration data before WeChat reads it; it performs no setData call and does not
+ * inspect React.
+ */
+function applyCustomWrapperSnapshots(data) {
+    const customWrapperCache = Reflect.get(global, customWrapperCacheKey);
+    if (!(customWrapperCache instanceof Map)) {
+        throw new Error('WX CustomWrapper cache is not installed in the App global.');
+    }
+    if (customWrapperCache.size === 0) {
+        return;
+    }
+    // This local mutable set lets the lazy traversal stop after every mounted wrapper snapshot has been consumed. Cache
+    // entries owned by another mounted Page remain, naturally falling back to a complete traversal of this Page.
+    const remainingSids = new Set(customWrapperCache.keys());
+    for (const sid of materializeSnapshots(data, customWrapperCache)) {
+        remainingSids.delete(sid);
+        if (remainingSids.size === 0) {
+            return;
+        }
+    }
+}
+/** Lazily traverses the Page snapshot and yields each mounted CustomWrapper sid after replacing its stale node. */
+function* materializeSnapshots(value, customWrapperCache) {
+    if (Array.isArray(value)) {
+        for (let index = 0; index < value.length; index++) {
+            yield* replaceCustomWrapperSnapshot(value, index, customWrapperCache);
+            yield* materializeSnapshots(value[index], customWrapperCache);
+        }
+    }
+    else if (isRecord(value)) {
+        for (const key in value) {
+            yield* replaceCustomWrapperSnapshot(value, key, customWrapperCache);
+            yield* materializeSnapshots(value[key], customWrapperCache);
+        }
+    }
+}
+/** Assigns a snapshot before yielding its sid, so closing the generator cannot discard the final replacement. */
+function* replaceCustomWrapperSnapshot(container, key, customWrapperCache) {
+    const value = container[key];
+    if (!isRecord(value) || value.nn !== 'custom-wrapper' || typeof value.sid !== 'string') {
+        return;
+    }
+    const snapshot = customWrapperCache.get(value.sid)?.data.i;
+    if (!snapshot) {
+        return;
+    }
+    container[key] = snapshot;
+    yield value.sid;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/dist/runtime/wx/dev/modes/interpreter/interpreter-protocol.d.ts

@@ -0,0 +1,12 @@
+import type { RuntimePatch } from '../../wx-hmr-runtime.ts';
+export declare const interpreterServerEvent = "vpt:wx-interpreter:source";
+/** One Rolldown patch whose existing code field is interpreted instead of wrapped in a native factory. */
+export type InterpreterPatch = RuntimePatch & {
+    readonly code: string;
+};
+/** Messages published by the host over Vite's existing WebSocket. */
+export type InterpreterServerMessage = Readonly<{
+    kind: 'patches';
+    buildId: string;
+    patches: readonly InterpreterPatch[];
+}>;

package/dist/runtime/wx/dev/modes/interpreter/interpreter-protocol.js

@@ -0,0 +1 @@
+export const interpreterServerEvent = 'vpt:wx-interpreter:source';

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

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

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

@@ -0,0 +1,29 @@
+/*
+ * Interpreter adapter injected into the App-global Rolldown runtime chunk. Vite's shared WebSocket publishes cumulative
+ * registration source, Sval evaluates it, and the shared runtime owns the retained socket, graph application, and reports.
+ */
+import Sval from 'sval';
+import { WxHmrRuntime } from '../../wx-hmr-runtime.js';
+import { interpreterServerEvent } from './interpreter-protocol.js';
+/** Interprets cumulative patch source received by the shared App-level HMR socket. */
+class InterpreterHmrRuntime extends WxHmrRuntime {
+    /** One installer and Sval scope retain interpreted factory closures for this App heap. */
+    installPatch;
+    constructor() {
+        super();
+        const interpreter = new Sval();
+        interpreter.import('__rolldown_runtime__', this);
+        this.installPatch = (patch) => interpreter.run(patch.code);
+    }
+    onSocketEvent(info, event, data) {
+        if (event !== interpreterServerEvent)
+            return;
+        const message = data;
+        if (message.buildId !== info.buildId || !this.applyPatchPayload(message, this.installPatch)) {
+            this.stopSocket('patch application stopped');
+        }
+    }
+}
+// The App-global singleton owns interpreted factory closures while its base owns socket, module cache, and Refresh boundaries.
+const runtime = new InterpreterHmrRuntime();
+globalThis.__rolldown_runtime__ = runtime;

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

@@ -0,0 +1,22 @@
+/** Host-to-App terminal control over the App heap's authenticated Vite socket. */
+export declare const runtimeControlEvent = "vpt:wx-hmr:control";
+/** App-to-host application frontier and rebuild reports over the same socket. */
+export declare const runtimeReportEvent = "vpt:wx-hmr:report";
+/** Build identity and authenticated socket endpoint fixed for one App heap. */
+export type HmrInfo = Readonly<{
+    buildId: string;
+    endpoint: string;
+}>;
+export type RuntimeReport = Readonly<{
+    kind: 'applied';
+    buildId: string;
+    seq: number;
+}> | Readonly<{
+    kind: 'rebuild';
+    buildId: string;
+    reason: string;
+}>;
+export type RuntimeControlMessage = Readonly<{
+    kind: 'close';
+    reason: string;
+}>;

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

@@ -0,0 +1,4 @@
+/** Host-to-App terminal control over the App heap's authenticated Vite socket. */
+export const runtimeControlEvent = 'vpt:wx-hmr:control';
+/** App-to-host application frontier and rebuild reports over the same socket. */
+export const runtimeReportEvent = 'vpt:wx-hmr:report';