vite-plugin-taro 0.2.2 → 0.3.0

package/dist/node/targets/wx/dev-server/js-utils.js

@@ -0,0 +1,28 @@
+import { transformWithOxc } from 'vite';
+const wxJavaScriptTarget = 'es2018';
+/** Lowers generated JavaScript syntax that WeChat's upload parser does not accept. */
+export async function transformWxCompatibleJavaScript(code, filename) {
+    const result = await transformWithOxc(code, filename, {
+        lang: 'js',
+        target: wxJavaScriptTarget,
+        sourcemap: false,
+        assumptions: {
+            // Avoid external Oxc helpers when lowering public class fields in already-bundled chunks.
+            setPublicClassFields: true
+        }
+    });
+    return result.code;
+}
+/** Applies the compatibility transform to every JavaScript chunk in a DevEngine output batch. */
+export async function transformWxOutputChunks(output) {
+    await Promise.all(output.map(async (item, index) => {
+        if (item.type !== 'chunk')
+            return;
+        output[index] = {
+            type: 'chunk',
+            fileName: item.fileName,
+            modules: item.modules,
+            code: await transformWxCompatibleJavaScript(item.code, item.fileName)
+        };
+    }));
+}

package/dist/node/targets/wx/dev-server/output.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Normalizes private DevEngine output before the development session writes it to the fixed WX project directory.
+ * DevEngine rebuilds may be partial, so these helpers mutate only files present in the current output.
+ */
+/** File shape emitted by Vite's private bundled-development engine. */
+export type WxOutputFile = {
+    type: 'chunk';
+    fileName: string;
+    code: string;
+    modules?: Record<string, unknown>;
+} | {
+    type: 'asset';
+    fileName: string;
+    source: string | Uint8Array;
+};
+/** Extracts Vite's development CSS payloads and materializes them as app.wxss. */
+export declare function normalizeWxBundleStyles(output: WxOutputFile[]): string | undefined;
+export declare function setWxAppStyles(output: WxOutputFile[], source: string): void;
+export declare function isWxFullBuildOutput(output: WxOutputFile[]): boolean;

package/dist/node/targets/wx/dev-server/output.js

@@ -0,0 +1,44 @@
+/**
+ * Normalizes private DevEngine output before the development session writes it to the fixed WX project directory.
+ * DevEngine rebuilds may be partial, so these helpers mutate only files present in the current output.
+ */
+/** Extracts Vite's development CSS payloads and materializes them as app.wxss. */
+export function normalizeWxBundleStyles(output) {
+    const styles = [];
+    for (let index = output.length - 1; index >= 0; index--) {
+        const item = output[index];
+        if (!item)
+            continue;
+        if (item.type === 'asset' && item.fileName.endsWith('.css')) {
+            styles.unshift(typeof item.source === 'string' ? item.source : new TextDecoder().decode(item.source));
+            output.splice(index, 1);
+        }
+        else if (item.type === 'chunk') {
+            styles.push(...collectEmbeddedStyles(item.code));
+        }
+    }
+    if (styles.length === 0)
+        return;
+    const source = styles.join('\n');
+    setWxAppStyles(output, source);
+    return source;
+}
+export function setWxAppStyles(output, source) {
+    const index = output.findIndex((item) => item.type === 'asset' && item.fileName === 'app.wxss');
+    const appStyle = { type: 'asset', fileName: 'app.wxss', source };
+    if (index >= 0)
+        output[index] = appStyle;
+    else
+        output.push(appStyle);
+}
+export function isWxFullBuildOutput(output) {
+    return output.some((item) => item.fileName === 'app.js');
+}
+function collectEmbeddedStyles(code) {
+    const styles = [];
+    for (const match of code.matchAll(/__vite__css(?:\$\d+)?\s*=\s*("(?:\\.|[^"\\])*");/g)) {
+        if (match[1])
+            styles.push(JSON.parse(match[1]));
+    }
+    return styles;
+}

package/dist/node/targets/wx/dev-server/rolldown-runtime-source.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Self-contained source injected into Rolldown's DevEngine as the WX module bootstrap runtime.
+ *
+ * This TypeScript module runs in Node and only exports source text. The exported JavaScript becomes
+ * `runtime.js`, executes before every application module, and therefore cannot import Taro, React,
+ * or any module that depends on the runtime it is creating.
+ */
+export declare const wxRolldownRuntimeSource = "\nvar BaseDevRuntime = DevRuntime;\nclass WxHotContext {\n  callbacks = [];\n  data = {};\n  _internal = { updateStyle() {}, removeStyle() {} };\n  constructor(moduleId) { this.moduleId = moduleId; }\n  accept(...args) {\n    if (args.length === 0) {\n      this.callbacks.push({ deps: this.moduleId, callback: undefined });\n    } else if (args.length === 1 && typeof args[0] === 'function') {\n      this.callbacks.push({ deps: this.moduleId, callback: args[0] });\n    } else if (args.length === 1) {\n      this.callbacks.push({ deps: args[0], callback: undefined });\n    } else {\n      this.callbacks.push({ deps: args[0], callback: args[1] });\n    }\n  }\n  acceptExports(_exports, callback) { this.accept(callback); }\n  dispose() {}\n  prune() {}\n  invalidate() {}\n  on() {}\n  off() {}\n  send() {}\n}\nclass WxRolldownRuntime extends BaseDevRuntime {\n  contexts = new Map();\n  patchedModules = new Set();\n  applyingPatch = false;\n\n  createEsmInitializer = (id, initialize, _deduplicate, result) => () => {\n    if (!initialize) return result;\n    if (!this.applyingPatch && this.patchedModules.has(id)) {\n      initialize = undefined;\n      return result;\n    }\n    const callback = initialize;\n    initialize = undefined;\n    result = callback(id);\n    if (this.applyingPatch) this.patchedModules.add(id);\n    return result;\n  };\n\n  createCjsInitializer = (id, initialize, _deduplicate, module) => () => {\n    if (module) return module.exports;\n    if (!this.applyingPatch && this.patchedModules.has(id)) return this.loadExports(id);\n    module = { exports: {} };\n    initialize(module.exports, module, id);\n    if (this.applyingPatch) this.patchedModules.add(id);\n    return module.exports;\n  };\n\n  createModuleHotContext(moduleId) {\n    const previous = this.contexts.get(moduleId);\n    const context = new WxHotContext(moduleId);\n    if (previous) {\n      context.callbacks = previous.callbacks;\n      context.data = previous.data;\n    }\n    this.contexts.set(moduleId, context);\n    return context;\n  }\n\n  beginPatch() { this.applyingPatch = true; }\n  endPatch() { this.applyingPatch = false; }\n\n  applyUpdates(boundaries) {\n    for (const [boundary, acceptedVia] of boundaries) {\n      const context = this.contexts.get(boundary);\n      if (!context) continue;\n      const callbacks = [...context.callbacks];\n      if (boundary === acceptedVia) context.callbacks = [];\n      for (const { deps, callback } of callbacks) {\n        if (!callback) continue;\n        if (Array.isArray(deps)) {\n          if (deps.includes(acceptedVia)) callback(deps.map((id) => this.loadExports(id)));\n        } else if (deps === acceptedVia) {\n          callback(this.loadExports(acceptedVia));\n        }\n      }\n    }\n  }\n}\n// A full DevEngine runtime starts a new page-update generation before any application chunk executes.\nglobalThis.__VITE_PLUGIN_TARO_WX_PAGE_UPDATE__ = { ready: false };\nglobalThis.__rolldown_runtime__ = new WxRolldownRuntime(undefined, 'vite-plugin-taro-wx');\n";

package/dist/node/targets/wx/dev-server/rolldown-runtime-source.js

@@ -0,0 +1,95 @@
+/**
+ * Self-contained source injected into Rolldown's DevEngine as the WX module bootstrap runtime.
+ *
+ * This TypeScript module runs in Node and only exports source text. The exported JavaScript becomes
+ * `runtime.js`, executes before every application module, and therefore cannot import Taro, React,
+ * or any module that depends on the runtime it is creating.
+ */
+export const wxRolldownRuntimeSource = `
+var BaseDevRuntime = DevRuntime;
+class WxHotContext {
+  callbacks = [];
+  data = {};
+  _internal = { updateStyle() {}, removeStyle() {} };
+  constructor(moduleId) { this.moduleId = moduleId; }
+  accept(...args) {
+    if (args.length === 0) {
+      this.callbacks.push({ deps: this.moduleId, callback: undefined });
+    } else if (args.length === 1 && typeof args[0] === 'function') {
+      this.callbacks.push({ deps: this.moduleId, callback: args[0] });
+    } else if (args.length === 1) {
+      this.callbacks.push({ deps: args[0], callback: undefined });
+    } else {
+      this.callbacks.push({ deps: args[0], callback: args[1] });
+    }
+  }
+  acceptExports(_exports, callback) { this.accept(callback); }
+  dispose() {}
+  prune() {}
+  invalidate() {}
+  on() {}
+  off() {}
+  send() {}
+}
+class WxRolldownRuntime extends BaseDevRuntime {
+  contexts = new Map();
+  patchedModules = new Set();
+  applyingPatch = false;
+
+  createEsmInitializer = (id, initialize, _deduplicate, result) => () => {
+    if (!initialize) return result;
+    if (!this.applyingPatch && this.patchedModules.has(id)) {
+      initialize = undefined;
+      return result;
+    }
+    const callback = initialize;
+    initialize = undefined;
+    result = callback(id);
+    if (this.applyingPatch) this.patchedModules.add(id);
+    return result;
+  };
+
+  createCjsInitializer = (id, initialize, _deduplicate, module) => () => {
+    if (module) return module.exports;
+    if (!this.applyingPatch && this.patchedModules.has(id)) return this.loadExports(id);
+    module = { exports: {} };
+    initialize(module.exports, module, id);
+    if (this.applyingPatch) this.patchedModules.add(id);
+    return module.exports;
+  };
+
+  createModuleHotContext(moduleId) {
+    const previous = this.contexts.get(moduleId);
+    const context = new WxHotContext(moduleId);
+    if (previous) {
+      context.callbacks = previous.callbacks;
+      context.data = previous.data;
+    }
+    this.contexts.set(moduleId, context);
+    return context;
+  }
+
+  beginPatch() { this.applyingPatch = true; }
+  endPatch() { this.applyingPatch = false; }
+
+  applyUpdates(boundaries) {
+    for (const [boundary, acceptedVia] of boundaries) {
+      const context = this.contexts.get(boundary);
+      if (!context) continue;
+      const callbacks = [...context.callbacks];
+      if (boundary === acceptedVia) context.callbacks = [];
+      for (const { deps, callback } of callbacks) {
+        if (!callback) continue;
+        if (Array.isArray(deps)) {
+          if (deps.includes(acceptedVia)) callback(deps.map((id) => this.loadExports(id)));
+        } else if (deps === acceptedVia) {
+          callback(this.loadExports(acceptedVia));
+        }
+      }
+    }
+  }
+}
+// A full DevEngine runtime starts a new page-update generation before any application chunk executes.
+globalThis.__VITE_PLUGIN_TARO_WX_PAGE_UPDATE__ = { ready: false };
+globalThis.__rolldown_runtime__ = new WxRolldownRuntime(undefined, 'vite-plugin-taro-wx');
+`;

package/dist/node/targets/wx/dev-server/update-server-state.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Pure host-side stop-and-wait protocol state machine.
+ *
+ * It retains versioned Rolldown deltas and selects one missing range for the active App Service. HTTP and filesystem
+ * effects are represented as commands and handled by update-transport.ts.
+ */
+type WxUpdateDelta = {
+    version: number;
+    code: string;
+};
+export type WxUpdateBatch = {
+    buildId: string;
+    sessionId: string;
+    fromVersion: number;
+    targetVersion: number;
+    deltas: WxUpdateDelta[];
+};
+type WxUpdateServerState = {
+    buildId: string;
+    hostVersion: number;
+    retainedDeltaBytes: number;
+    deltas: WxUpdateDelta[];
+    activeSessionId?: string;
+    retiredSessionIds: string[];
+    inFlight?: Pick<WxUpdateBatch, 'sessionId' | 'fromVersion' | 'targetVersion'>;
+};
+type WxUpdateServerEvent = {
+    type: 'delta-added';
+    code: string;
+    bytes?: number;
+} | {
+    type: 'client-registered';
+    buildId: string;
+    sessionId: string;
+    version: number;
+} | {
+    type: 'client-reported';
+    buildId: string;
+    sessionId: string;
+    version: number;
+} | {
+    type: 'batch-publish-failed';
+    sessionId: string;
+    targetVersion: number;
+} | {
+    type: 'full-build-committed';
+    buildId: string;
+};
+export type WxUpdateServerCommand = {
+    type: 'publish-batch';
+    batch: WxUpdateBatch;
+} | {
+    type: 'request-full-build';
+    reason: 'client-version-ahead' | 'invalid-client-version';
+} | {
+    type: 'ignore-client';
+    reason: 'stale-build' | 'retired-session' | 'unknown-session';
+};
+type WxUpdateServerTransition = {
+    state: WxUpdateServerState;
+    commands: WxUpdateServerCommand[];
+};
+export declare function createWxUpdateServerState(buildId: string): WxUpdateServerState;
+export declare function transitionWxUpdateServer(state: WxUpdateServerState, event: WxUpdateServerEvent): WxUpdateServerTransition;
+export {};

package/dist/node/targets/wx/dev-server/update-server-state.js

@@ -0,0 +1,116 @@
+export function createWxUpdateServerState(buildId) {
+    return {
+        buildId,
+        hostVersion: 0,
+        retainedDeltaBytes: 0,
+        deltas: [],
+        retiredSessionIds: []
+    };
+}
+export function transitionWxUpdateServer(state, event) {
+    switch (event.type) {
+        case 'delta-added': {
+            const version = state.hostVersion + 1;
+            return transition({
+                ...state,
+                hostVersion: version,
+                retainedDeltaBytes: state.retainedDeltaBytes + (event.bytes ?? event.code.length),
+                deltas: [...state.deltas, { version, code: event.code }]
+            });
+        }
+        case 'client-registered':
+            return registerClient(state, event);
+        case 'client-reported':
+            return reportClient(state, event);
+        case 'batch-publish-failed':
+            if (state.inFlight?.sessionId !== event.sessionId || state.inFlight.targetVersion !== event.targetVersion) {
+                return transition(state);
+            }
+            return transition({ ...state, inFlight: undefined });
+        case 'full-build-committed':
+            return transition(createWxUpdateServerState(event.buildId));
+    }
+}
+function registerClient(state, client) {
+    const rejected = rejectClient(state, client);
+    if (rejected)
+        return rejected;
+    if (state.retiredSessionIds.includes(client.sessionId)) {
+        return command(state, { type: 'ignore-client', reason: 'retired-session' });
+    }
+    if (state.activeSessionId === client.sessionId)
+        return transition(state);
+    const retiredSessionIds = state.activeSessionId
+        ? [...new Set([...state.retiredSessionIds, state.activeSessionId])]
+        : state.retiredSessionIds;
+    const registered = {
+        ...state,
+        activeSessionId: client.sessionId,
+        retiredSessionIds,
+        inFlight: undefined
+    };
+    return transition(registered);
+}
+function reportClient(state, client) {
+    const rejected = rejectClient(state, client);
+    if (rejected)
+        return rejected;
+    if (state.retiredSessionIds.includes(client.sessionId)) {
+        return command(state, { type: 'ignore-client', reason: 'retired-session' });
+    }
+    if (client.sessionId !== state.activeSessionId) {
+        return command(state, { type: 'ignore-client', reason: 'unknown-session' });
+    }
+    return synchronizeClient(state, client.version);
+}
+function rejectClient(state, client) {
+    if (client.buildId !== state.buildId) {
+        return command(state, { type: 'ignore-client', reason: 'stale-build' });
+    }
+    if (!Number.isInteger(client.version) || client.version < 0) {
+        return command(state, { type: 'request-full-build', reason: 'invalid-client-version' });
+    }
+    if (client.version > state.hostVersion) {
+        return command(state, { type: 'request-full-build', reason: 'client-version-ahead' });
+    }
+}
+function synchronizeClient(state, clientVersion) {
+    let synchronized = state;
+    const inFlight = state.inFlight;
+    if (inFlight) {
+        if (clientVersion === inFlight.fromVersion) {
+            const batch = createBatch(state, clientVersion, inFlight.targetVersion);
+            return command(state, { type: 'publish-batch', batch });
+        }
+        if (clientVersion !== inFlight.targetVersion) {
+            return command(state, { type: 'request-full-build', reason: 'invalid-client-version' });
+        }
+        synchronized = { ...state, inFlight: undefined };
+    }
+    if (clientVersion >= synchronized.hostVersion)
+        return transition(synchronized);
+    const batch = createBatch(synchronized, clientVersion, synchronized.hostVersion);
+    return command({
+        ...synchronized,
+        inFlight: {
+            sessionId: batch.sessionId,
+            fromVersion: batch.fromVersion,
+            targetVersion: batch.targetVersion
+        }
+    }, { type: 'publish-batch', batch });
+}
+function createBatch(state, fromVersion, targetVersion) {
+    return {
+        buildId: state.buildId,
+        sessionId: state.activeSessionId,
+        fromVersion,
+        targetVersion,
+        deltas: state.deltas.filter((delta) => delta.version > fromVersion && delta.version <= targetVersion)
+    };
+}
+function transition(state) {
+    return { state, commands: [] };
+}
+function command(state, value) {
+    return { state, commands: [value] };
+}

package/dist/node/targets/wx/dev-server/update-transport.d.ts

@@ -0,0 +1,28 @@
+import type { ViteDevServer } from 'vite';
+export declare class WxUpdateTransport {
+    private readonly server;
+    private readonly requestFullBuild;
+    private readonly writeUpdateFile;
+    private state;
+    private readonly token;
+    private readonly pendingPolls;
+    private closed;
+    constructor(server: ViteDevServer, requestFullBuild: () => void, writeUpdateFile: (buildId: string, source: string) => Promise<void>);
+    get retainedDeltaCount(): number;
+    get retainedDeltaBytes(): number;
+    install(): void;
+    close(): void;
+    addDelta(code: string): void;
+    createBuildId(): string;
+    isCurrentBuild(buildId: string): boolean;
+    commitFullBuild(buildId: string): void;
+    /** Generates late-bound App metadata after Vite has selected its actual listening port. */
+    createControlSource(buildId?: string): string;
+    private readonly handleRequest;
+    private executePollCommands;
+    private holdPoll;
+    private respondToAll;
+    private finishPoll;
+    private apply;
+    private writeBatch;
+}

package/dist/node/targets/wx/dev-server/update-transport.js

@@ -0,0 +1,212 @@
+/**
+ * Adapts the pure server protocol to Vite HTTP middleware and literal update-file publication.
+ * HTTP messages contain metadata only; executable JavaScript reaches DevTools through the injected file writer.
+ */
+import { randomBytes } from 'node:crypto';
+import { createWxUpdateServerState, transitionWxUpdateServer } from './update-server-state.js';
+const endpointPath = '/__vite_plugin_taro_wx_update__';
+// Keep the host response below update-client.ts's 30-second wx.request timeout.
+const pollTimeout = 25_000;
+export class WxUpdateTransport {
+    server;
+    requestFullBuild;
+    writeUpdateFile;
+    state = createWxUpdateServerState(createId());
+    token = createId();
+    pendingPolls = new Map();
+    closed = false;
+    constructor(server, requestFullBuild, writeUpdateFile) {
+        this.server = server;
+        this.requestFullBuild = requestFullBuild;
+        this.writeUpdateFile = writeUpdateFile;
+    }
+    get retainedDeltaCount() {
+        return this.state.hostVersion;
+    }
+    get retainedDeltaBytes() {
+        return this.state.retainedDeltaBytes;
+    }
+    install() {
+        this.server.middlewares.use(endpointPath, this.handleRequest);
+    }
+    close() {
+        this.closed = true;
+        this.respondToAll({ type: 'rebuilding' });
+    }
+    addDelta(code) {
+        this.apply({ type: 'delta-added', code, bytes: Buffer.byteLength(code) });
+        this.respondToAll({ type: 'changed' });
+    }
+    createBuildId() {
+        return createId();
+    }
+    isCurrentBuild(buildId) {
+        return this.state.buildId === buildId;
+    }
+    commitFullBuild(buildId) {
+        this.apply({ type: 'full-build-committed', buildId });
+        this.respondToAll({ type: 'rebuilding' });
+    }
+    /** Generates late-bound App metadata after Vite has selected its actual listening port. */
+    createControlSource(buildId = this.state.buildId) {
+        const address = this.server.httpServer?.address();
+        const port = address && typeof address !== 'string' ? address.port : this.server.config.server.port;
+        return `globalThis.__VITE_PLUGIN_TARO_WX_CONTROL__ = ${JSON.stringify({
+            url: `http://localhost:${port}${endpointPath}`,
+            token: this.token,
+            buildId
+        })};\n`;
+    }
+    handleRequest = async (request, response) => {
+        if (this.closed || request.method !== 'POST') {
+            respond(response, 404, { type: 'not-found' });
+            return;
+        }
+        let body;
+        try {
+            body = JSON.parse(await readBody(request));
+        }
+        catch {
+            respond(response, 400, { type: 'invalid-request' });
+            return;
+        }
+        if (body.token !== this.token || !isClientReport(body)) {
+            respond(response, 403, { type: 'forbidden' });
+            return;
+        }
+        if (body.action === 'rebuild') {
+            this.requestFullBuild();
+            respond(response, 202, { type: 'rebuilding' });
+            return;
+        }
+        if (body.action === 'register') {
+            const transition = this.apply({
+                type: 'client-registered',
+                buildId: body.buildId,
+                sessionId: body.sessionId,
+                version: body.version
+            });
+            if (transition.some((command) => command.type === 'request-full-build'))
+                this.requestFullBuild();
+            respond(response, 200, { type: 'registered' });
+            return;
+        }
+        if (body.action !== 'poll') {
+            respond(response, 400, { type: 'invalid-request' });
+            return;
+        }
+        const commands = this.apply({
+            type: 'client-reported',
+            buildId: body.buildId,
+            sessionId: body.sessionId,
+            version: body.version
+        });
+        await this.executePollCommands(body.sessionId, commands, response);
+    };
+    async executePollCommands(sessionId, commands, response) {
+        const publish = commands.find((command) => command.type === 'publish-batch');
+        if (publish?.type === 'publish-batch') {
+            try {
+                await this.writeBatch(publish.batch);
+                respond(response, 200, { type: 'batch-published', targetVersion: publish.batch.targetVersion });
+            }
+            catch {
+                this.apply({
+                    type: 'batch-publish-failed',
+                    sessionId: publish.batch.sessionId,
+                    targetVersion: publish.batch.targetVersion
+                });
+                respond(response, 500, { type: 'publish-failed' });
+            }
+            return;
+        }
+        if (commands.some((command) => command.type === 'request-full-build')) {
+            this.requestFullBuild();
+            respond(response, 202, { type: 'rebuilding' });
+            return;
+        }
+        if (commands.some((command) => command.type === 'ignore-client')) {
+            respond(response, 409, { type: 'rebuilding' });
+            return;
+        }
+        this.holdPoll(sessionId, response);
+    }
+    holdPoll(sessionId, response) {
+        const previous = this.pendingPolls.get(sessionId);
+        if (previous)
+            this.finishPoll(sessionId, previous, { type: 'changed' });
+        let pending;
+        pending = {
+            response,
+            timeout: setTimeout(() => this.finishPoll(sessionId, pending, { type: 'idle' }), pollTimeout)
+        };
+        this.pendingPolls.set(sessionId, pending);
+        response.on('close', () => this.finishPoll(sessionId, pending));
+    }
+    respondToAll(value) {
+        for (const [sessionId, pending] of this.pendingPolls)
+            this.finishPoll(sessionId, pending, value);
+    }
+    finishPoll(sessionId, pending, value) {
+        if (this.pendingPolls.get(sessionId) !== pending)
+            return;
+        clearTimeout(pending.timeout);
+        this.pendingPolls.delete(sessionId);
+        if (value)
+            respond(pending.response, 200, value);
+    }
+    apply(event) {
+        const transition = transitionWxUpdateServer(this.state, event);
+        this.state = transition.state;
+        return transition.commands;
+    }
+    async writeBatch(batch) {
+        await this.writeUpdateFile(batch.buildId, renderBatch(batch, createId()));
+    }
+}
+/** Renders executable code for update.js; this source is never included in an HTTP response. */
+function renderBatch(batch, nonce) {
+    return `// ${nonce}\nglobalThis.__VITE_PLUGIN_TARO_WX_UPDATE_CLIENT__.receiveBatch(${JSON.stringify({
+        buildId: batch.buildId,
+        fromVersion: batch.fromVersion,
+        targetVersion: batch.targetVersion
+    })}, () => {
+${indent(batch.deltas.map((delta) => delta.code).join('\n'), 4)}
+});\n`;
+}
+function indent(value, spaces) {
+    const prefix = ' '.repeat(spaces);
+    return value
+        .split('\n')
+        .map((line) => `${prefix}${line}`)
+        .join('\n');
+}
+function isClientReport(value) {
+    return (typeof value.token === 'string' &&
+        typeof value.action === 'string' &&
+        typeof value.buildId === 'string' &&
+        typeof value.sessionId === 'string' &&
+        typeof value.version === 'number');
+}
+async function readBody(request) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of request) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        size += buffer.length;
+        if (size > 64 * 1024)
+            throw new Error('WX update request body is too large.');
+        chunks.push(buffer);
+    }
+    return Buffer.concat(chunks).toString('utf8');
+}
+function respond(response, status, body) {
+    if (response.writableEnded)
+        return;
+    response.statusCode = status;
+    response.setHeader('content-type', 'application/json');
+    response.end(JSON.stringify(body));
+}
+function createId() {
+    return randomBytes(16).toString('hex');
+}

package/dist/node/targets/wx/dev-server/vite-bundled-dev-adapter.d.ts

@@ -0,0 +1,44 @@
+import type { ResolvedConfig, ViteDevServer } from 'vite';
+import type { WxOutputFile } from './output.ts';
+/** HMR boundary shape returned by Vite's private WX DevEngine integration. */
+type WxDevEngineBoundary = {
+    boundary: string;
+    acceptedVia: string;
+};
+/** Update result shape returned by Vite's private bundled-development engine. */
+export type WxDevEngineUpdate = {
+    type: 'Noop';
+} | {
+    type: 'FullReload';
+    reason?: string;
+} | {
+    type: 'Patch';
+    code: string;
+    filename: string;
+    hmrBoundaries: WxDevEngineBoundary[];
+};
+type ViteBundledDevCallbacks = {
+    onOutput(output: WxOutputFile[]): void;
+    onPatch(files: string[], output: WxDevEngineUpdate): boolean;
+    onError(message: string): void;
+    waitForInitialBundle(): Promise<void>;
+};
+/** Isolates the private Vite bundled-development API used by the WX session. */
+export declare class ViteBundledDevAdapter {
+    private readonly config;
+    private readonly server;
+    private readonly callbacks;
+    private bundledDev;
+    constructor(config: ResolvedConfig, server: ViteDevServer, callbacks: ViteBundledDevCallbacks);
+    install(): void;
+    registerBundleModules(output: WxOutputFile[]): number;
+    registerPatchModules(code: string): void;
+    private registerModules;
+    rebuild(): Promise<void>;
+    private installOptions;
+    private installOutput;
+    private installPatches;
+    private installListener;
+    private handlePayload;
+}
+export {};