vite-plugin-taro 0.6.18 → 0.6.19

package/dist/node/plugins/wx/dev/create-hmr-results-stream.js

@@ -1,57 +0,0 @@
-import { buffer, debounceTime, filter, Subject } from 'rxjs';
-/**
- * Adapts Rolldown's non-awaited HMR callback into lossless quiet-window publications.
- *
- * Debouncing the result stream itself would retain only the final callback and lose incremental patch factories that later
- * patches provably do not reproduce. Instead, the debounced view is only a closing notifier for `buffer`: every callback is
- * retained in arrival order, and one configured quiet period emits the complete window to the host's existing serialized
- * writer. This first stream migration deliberately does not own physical state; `publish` and `reportError` remain synchronous
- * admission callbacks so the dev host can enqueue both through its single writer.
- *
- * DevEngine failures are values, not Observable errors. They represent transient editor generations and carry no executable
- * patch, so the stream reports the final error but otherwise removes them. Successful callbacks on either side remain ordered
- * and lossless; Rolldown generated each against its unpublished client frontier, and the host delivers every retained payload.
- * Completing the returned Subject flushes its current buffer synchronously, allowing host shutdown to await the resulting
- * serialized task rather than silently dropping an admitted patch.
- *
- * Complexity is O(updates + changed files) per emitted window, with one retained reference per callback until the quiet edge.
- */
-export function createHmrResultsStream(settleMilliseconds, scheduler, publish, reportError) {
-    /*
-     * This hot Subject is the sole mutable boundary between Rolldown's non-awaited callback and RxJS. Each next preserves one
-     * compiler generation by reference and in arrival order. buffer owns the temporary lossless window; debounceTime observes the
-     * same Subject only to decide when that window closes. Replacing this with a debounced scalar would discard patch factories,
-     * while letting callback Promises mutate host state directly would overlap publications. Completion flushes the final window
-     * before shutdown, after which the Subject is never reused.
-     */
-    const results = new Subject();
-    results
-        .pipe(buffer(results.pipe(debounceTime(settleMilliseconds, scheduler))), filter((window) => window.length > 0))
-        .subscribe((window) => {
-        /*
-         * An Error is one source generation that produced no executable delta; it does not invalidate successful Rolldown
-         * callbacks already admitted on either side of it. Dropping the whole quiet window would therefore discard real
-         * patch factories, while starting a complete build would compile the same known-invalid editor contents. Keep the
-         * old runtime running, report only the latest diagnostic from a repeated parser burst, and continue below with the
-         * successful callback values exactly as if the temporary invalid save had never produced an HMR payload.
-         */
-        const lastFailure = window.findLast((result) => result instanceof Error);
-        if (lastFailure) {
-            reportError(lastFailure);
-        }
-        const successfulWindow = window.filter((result) => !(result instanceof Error));
-        if (successfulWindow.length > 0) {
-            /*
-             * flatMap preserves callback arrival order and each callback's internal Rolldown order. Updates must not be
-             * deduplicated: later undelivered patches are deltas and do not reproduce factories from earlier sequences.
-             * changedFiles is opaque DevEngine metadata and has no identity semantics in the host, so preserving its raw
-             * concatenation is both cheaper and more faithful than maintaining a second Set-based interpretation here.
-             */
-            publish({
-                updates: successfulWindow.flatMap((result) => result.updates),
-                changedFiles: successfulWindow.flatMap((result) => result.changedFiles)
-            });
-        }
-    });
-    return results;
-}

package/dist/node/plugins/wx/dev/dev-host.js

@@ -1,361 +0,0 @@
-import path from 'node:path';
-import colors from 'picocolors';
-import { dev } from 'rolldown/experimental';
-import { asyncScheduler } from 'rxjs';
-import { createHmrResultsStream } from './create-hmr-results-stream.js';
-import { developmentAppWxssFileName, globalWxssFileName, hmrControlPath, hmrInfoFileName, hmrPatchesFileName, renderDevelopmentAppWxss, renderHmrInfo, renderInitialHmrPatches, writeHmrFile } from './hmr-files.js';
-import { createHostActions } from './host-actions.js';
-import { PatchPublisher } from './patch-publisher.js';
-import { createRuntimeReportsStream } from './runtime-reports.js';
-import { installWxDevOptions, requireSingleOutput } from './wx-dev-options.js';
-/** One short trailing-edge window absorbs editor bursts before style preparation and physical Page notification. */
-const hmrSettleMilliseconds = 16;
-/**
- * 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.
- *
- * The shared style plugin carries the resolver's immutable App/Page cascade policy while Rolldown remains authoritative for
- * every live import edge.
- */
-export async function createWxDevHost({ server, options, styles }) {
-    const bundledDev = getBundledDev(server);
-    // All callbacks admit typed actions through this edge; concatMap is the sole owner of effect ordering and mutable host state.
-    const hostActions = createHostActions(applyHostAction, (action, error) => logWxError(server.config.logger, `wx HMR ${action.kind} failed`, error));
-    const publisher = new PatchPublisher((content) => writeHmrFile(server.config.build.outDir, hmrPatchesFileName, content));
-    // Option installation now configures only Rolldown. Build lifecycle results enter through the engine's output action below.
-    installWxDevOptions({ bundledDev, server, options });
-    const engine = await createEngine();
-    const hmrResults = createHmrResultsStream(hmrSettleMilliseconds, asyncScheduler, (result) => {
-        // One reduced window becomes one existing host transaction: style preparation, one cumulative patch write, then
-        // ordered delivery notifications for every original Rolldown payload retained by the stream.
-        hostActions.next({ kind: 'publish', result: result });
-    }, (error) => {
-        /*
-         * Invalid syntax is a normal intermediate editor generation. Rolldown produced no patch, so neither the published
-         * nor applied runtime frontier needs repair. Triggering a complete build here would immediately compile the same
-         * invalid source and empirically wedges that DevEngine generation. Admit only the diagnostic; when the user saves
-         * valid source, the watch engine emits an ordinary successful callback and resumes the normal publication path.
-         */
-        hostActions.next({ kind: 'error', error: error });
-    });
-    const runtimeReports = createRuntimeReportsStream(hmrSettleMilliseconds, asyncScheduler, (reports) => {
-        // ACK conflation happens before admission, but publisher validation and mutation remain ordered with patch writes and
-        // build rotation. Reports arriving during publication therefore execute only after that physical transaction commits.
-        hostActions.next({ kind: 'reports', reports: reports });
-    });
-    /*
-     * BundledDev is Vite's mutable environment adapter. Transfer its engine slot to the one physical writer created above so
-     * Vite middleware and close() address the same engine; leaving the slot untouched would make listen() create a second,
-     * skip-write browser engine with a divergent graph. Disable Vite's access-triggered regeneration because runtime reports and
-     * Rolldown HMR results now own every rebuild decision. Finally replace listen so readiness waits for physical initial output
-     * instead of Vite's in-memory bundle. These assignments are installation-time ownership transfer, never per-update state.
-     */
-    bundledDev._devEngine = engine;
-    bundledDev.triggerBundleRegenerationIfStale = async () => false;
-    bundledDev.listen = async () => {
-        /*
-         * Subscribe before run because DevEngine intentionally fulfills run() after an initial plugin failure and emits that
-         * Error through onOutput. Observing the existing action edge preserves the exact failure without a second buildEnd
-         * Promise or forwarding Subject; waitForAction does not consume the action from concatMap's reducer subscription.
-         */
-        const initialOutput = hostActions.waitForAction((action) => action.kind === 'output');
-        await engine.run();
-        const { result } = await initialOutput;
-        if (result instanceof Error) {
-            throw result;
-        }
-        await engine.ensureCurrentBuildFinish();
-        // onOutput admission happens on Rolldown's callback stack, but its style publication runs asynchronously through
-        // hostActions. Drain that transaction before returning control to Vite: otherwise the HTTP server can bind while the
-        // initial output action is still finalizing styles, causing both that action and the later listening action to observe
-        // the port and rotate the build identity twice.
-        await hostActions.waitForIdle();
-    };
-    // Vite binds the port only after initServer (and therefore the initial build) completes, so
-    // the actual port is not observable while onOutput runs for the first build. The App metadata
-    // is written once the port is real; later full builds rewrite it from onOutput.
-    server.httpServer?.once('listening', () => {
-        // Port availability is lifecycle data, so initial identity rotation follows prior output/capture actions in the reducer.
-        hostActions.next({ kind: 'listening' });
-    });
-    // The runtime's metadata-only reports land on the control path; the buildId in each report
-    // IS the Rolldown client ID.
-    server.middlewares.use(hmrControlPath, (req, res) => void handleReport(req, res));
-    installDevToolsPrinter(server);
-    return {
-        close: async () => {
-            // Quiet-window completion first admits final HMR publications and rebuild reports into the serialized action edge.
-            hmrResults.complete();
-            runtimeReports.complete();
-            await hostActions.waitForIdle();
-            // Keep the action edge open until the final generation has admitted every output callback.
-            await engine.ensureCurrentBuildFinish();
-            await hostActions.complete();
-        }
-    };
-    /** Atomically materializes the style plugin's prepared global artifact. */
-    async function writeGlobalStyle(wxss) {
-        await writeHmrFile(server.config.build.outDir, globalWxssFileName, wxss);
-    }
-    /** Rotates the build identity and materializes the App metadata for it. */
-    async function rotateBuildSession() {
-        const port = boundPort(server);
-        if (port === undefined) {
-            // The initial output finishes before Vite binds its port. The listening listener
-            // starts the first real client build, avoiding a phantom registered client.
-            return;
-        }
-        const { buildId, previousBuildId } = publisher.startBuild();
-        if (previousBuildId) {
-            await engine.removeClient(previousBuildId);
-        }
-        await engine.registerClient(buildId);
-        await publishBuildMetadata(server, buildId, port);
-    }
-    /**
-     * Mutates only the request-local HTTP response: unsupported methods become 404, malformed bounded bodies become 400, and a
-     * valid report is admitted before the default 200 response ends. No response object or parser state crosses requests.
-     */
-    async function handleReport(req, res) {
-        if (req.method !== 'POST') {
-            res.statusCode = 404;
-            res.end();
-            return;
-        }
-        try {
-            const report = JSON.parse(await readBody(req));
-            runtimeReports.next(report);
-            res.end();
-        }
-        catch (e) {
-            logWxError(server.config.logger, 'wx HMR report failed', e);
-            res.statusCode = 400;
-            res.end();
-        }
-    }
-    /** Reduces one merged source action through the existing authoritative host state. */
-    function applyHostAction(action) {
-        switch (action.kind) {
-            case 'publish':
-                return publishUpdates(action.result);
-            case 'error':
-                logWxError(server.config.logger, 'wx HMR update failed', action.error);
-                return;
-            case 'reports':
-                action.reports.forEach(processReport);
-                return;
-            case 'output':
-                if (action.result instanceof Error) {
-                    logWxError(server.config.logger, 'wx dev build failed', action.result);
-                    return;
-                }
-                return publishCompleteStyles();
-            case 'listening':
-                return rotateBuildSession();
-        }
-    }
-    /** Publishes graph-complete styles before rotating the App-visible build identity. */
-    async function publishCompleteStyles() {
-        await styles.finalizeUpdate([], writeGlobalStyle);
-        await rotateBuildSession();
-    }
-    /** Applies one runtime receipt to the active physical patch history. */
-    function processReport(report) {
-        // Delayed reports from older builds must never prune the live build's cumulative patch history.
-        if (!publisher.isCurrentBuild(report.buildId)) {
-            return;
-        }
-        switch (report.kind) {
-            case 'rebuild': {
-                requestFullBuild(report.reason);
-                return;
-            }
-            case 'applied': {
-                publisher.acknowledge(report.seq);
-                return;
-            }
-        }
-    }
-    /** Creates the physical DevEngine with the wx dev host hooks. */
-    async function createEngine() {
-        const rolldownOptions = await bundledDev.getRolldownOptions();
-        const output = requireSingleOutput(rolldownOptions);
-        return dev(rolldownOptions, output, {
-            /**
-             * Admits Rolldown's non-awaited callback without starting asynchronous host work on the binding callback stack.
-             * The Subject retains Error values as control events and successful values as lossless patch data until its quiet edge.
-             */
-            onHmrUpdates: (result) => {
-                hmrResults.next(result);
-            },
-            // Initial and later complete builds share one admission path; startup merely observes the first OutputAction.
-            onOutput: (result) => {
-                hostActions.next({ kind: 'output', result: result });
-            },
-            rebuildStrategy: 'never',
-            watch: {
-                // Rolldown must observe every source generation and emit every incremental factory: later patches do not
-                // reconstruct modules changed only by an earlier callback. RxJS conflates publication after compilation,
-                // preserving the complete patch sequence while avoiding repeated physical DevTools notifications.
-                skipWrite: false,
-                useDebounce: false
-            }
-        });
-    }
-    /** Centralizes the one diagnostic and DevEngine command used by every rebuild authority. */
-    function requestFullBuild(reason) {
-        server.config.logger.info(`[vpt] wx full rebuild required${reason ? `: ${reason}` : ''}`);
-        engine.triggerFullBuild();
-    }
-    /** Selects active updates and publishes their resulting host transaction. */
-    async function publishUpdates(result) {
-        /*
-         * This transaction-local array preserves every patch in one pass and permits immediate rebuild dominance. It never escapes
-         * the serialized action. A filter/find/flatMap pipeline would scan a large burst repeatedly and allocate an intermediate.
-         */
-        const patches = [];
-        for (const { clientId, update } of result.updates) {
-            if (!publisher.isCurrentBuild(clientId) || update.type === 'Noop') {
-                continue;
-            }
-            if (update.type === 'Patch') {
-                patches.push(update);
-                continue;
-            }
-            requestFullBuild(update.reason);
-            return;
-        }
-        await publishPatchBatch(patches);
-    }
-    /** Publishes one coherent WXSS, patch-file, and Rolldown-frontier transaction. */
-    async function publishPatchBatch(patches) {
-        if (patches.length === 0) {
-            return;
-        }
-        // `onHmrUpdates` runs after every affected transform has updated captured CSS and the live import graph. The style
-        // boundary finalizes every factory before atomically publishing their matching WXSS.
-        const finalizedPatches = await styles.finalizeUpdate(patches, writeGlobalStyle);
-        // Publish global.wxss before the matching JavaScript patch so DevTools observes a coherent HMR transaction.
-        // The physical file must exist before Rolldown advances: once committed, later patches may be generated relative to
-        // this batch even if DevTools has not observed its file event yet. PatchPublisher keeps the unapplied range cumulative,
-        // so any later file generation still carries every factory needed to bridge the runtime's older application frontier.
-        await publisher.produce(finalizedPatches);
-        await commitPublishedBatch(finalizedPatches);
-    }
-    /**
-     * Advances Rolldown's published frontier in the same sequence order materialized in the cumulative physical file.
-     *
-     * Given a batch [5, 6], publisher.produce has already made factories [5, 6] visible in hmr/patches.js. This method then
-     * commits payload 5 followed by payload 6. If DevTools observes neither event before sequence 7 is published, the next
-     * physical file contains [5, 6, 7], while Rolldown is free to generate 7 relative to its already-published sequence 6.
-     */
-    async function commitPublishedBatch(batch) {
-        // Do not use Promise.all or deduplicate filenames. Multiple sequential payloads may target the same output filename,
-        // and each notification commits one distinct Rolldown payload. Awaiting in order preserves the exact frontier encoded
-        // by PatchUpdate.seq and prevents a later payload from becoming visible to the engine before its predecessor.
-        for (const patch of batch) {
-            await engine.notifyPayloadDelivered(patch.filename);
-        }
-    }
-}
-/** The bound HTTP port, or undefined before Vite's server is listening. */
-function boundPort(server) {
-    const httpServer = server.httpServer;
-    if (!httpServer) {
-        return undefined;
-    }
-    const address = httpServer.address();
-    if (!address || typeof address === 'string') {
-        return undefined;
-    }
-    return address.port;
-}
-/** Resets physical patches and then exposes one coherent build identity to a freshly compiled App heap. */
-async function publishBuildMetadata(server, buildId, port) {
-    const info = {
-        buildId,
-        endpoint: `${server.config.server.https ? 'https' : 'http'}://${resolveEndpointHost(server)}:${port}${hmrControlPath}`
-    };
-    await writeHmrFile(server.config.build.outDir, hmrPatchesFileName, renderInitialHmrPatches());
-    await writeHmrFile(server.config.build.outDir, hmrInfoFileName, renderHmrInfo(info));
-    // `removeDevelopmentAppWxss` kept the previous physical wrapper in place while the complete output was written. Replace
-    // it only now, after the empty patch frontier and matching identity are durable. DevTools treats `app.wxss` as an App root,
-    // so this write intentionally causes the one full refresh allowed at a complete-build boundary; the refreshed App reads
-    // the new info above. Incremental updates must never write this file because an App refresh could destroy the heap while
-    // its JavaScript patch is being acknowledged. They publish only the imported `assets/global.wxss` stylesheet instead.
-    await writeHmrFile(server.config.build.outDir, developmentAppWxssFileName, renderDevelopmentAppWxss(buildId));
-}
-/** Replaces browser server URLs with the physical project directory consumed by WeChat DevTools. */
-function installDevToolsPrinter(server) {
-    /*
-     * Vite exposes printing as a mutable server callback because URLs are unknown until startup. WX serves control reports over
-     * HTTP but users open the physical output directory, so retaining the browser printer advertises unusable navigation URLs.
-     * Replacing only this presentation callback leaves resolved URLs and server routing untouched and naturally dies with the
-     * server instance; logging elsewhere would duplicate Vite's one readiness notification.
-     */
-    server.printUrls = () => {
-        server.config.logger.info(`  ${colors.green('➜')}  ${colors.bold('WeChat DevTools')}: ${colors.cyan(relativeToViteConfig(server.config.build.outDir, server.config.configFile, server.config.root))}`);
-    };
-}
-/**
- * The project directory shown in the DevTools banner, relative to the Vite config:
- * `dist/wx` instead of the absolute output path, so it can be pasted into DevTools.
- */
-function relativeToViteConfig(outDir, configFile, root) {
-    const configDirectory = configFile ? path.dirname(configFile) : root;
-    const relativePath = path.relative(configDirectory, outDir).replaceAll('\\', '/');
-    if (!relativePath)
-        return '.';
-    return relativePath.startsWith('.') ? relativePath : `./${relativePath}`;
-}
-/** Logs an error with the plugin prefix, distinguishing Error values from unknowns. */
-function logWxError(logger, prefix, error) {
-    if (Error.isError(error)) {
-        logger.error(`[vpt] ${prefix}`, { error });
-    }
-    else {
-        logger.error(`[vpt] ${prefix} with unknown error: ${error}`);
-    }
-}
-const maximumBodyBytes = 64 * 1024;
-function readBody(req) {
-    return new Promise((resolve, reject) => {
-        /*
-         * Node delivers one HTTP body through multiple callback invocations, so this request-local mutable string is the minimal
-         * state that joins chunks in wire order. The 64 KiB bound caps both retained memory and repeated-concatenation work; the
-         * value is parsed once on end and then discarded. Parsing per chunk is invalid because JSON tokens may cross boundaries,
-         * while retaining request bodies in host state would couple unrelated Page reports and leak across the server lifecycle.
-         */
-        let body = '';
-        req.on('data', (chunk) => {
-            body += chunk.toString('utf8');
-            if (body.length > maximumBodyBytes) {
-                reject(new Error('report body too large'));
-                req.destroy();
-            }
-        });
-        req.on('end', () => resolve(body));
-        req.on('error', reject);
-    });
-}
-/** The bound address host, or loopback for wildcard binds; IPv6 literals are bracketed. */
-function resolveEndpointHost(server) {
-    const address = server.httpServer?.address();
-    if (!address || typeof address === 'string') {
-        return '127.0.0.1';
-    }
-    if (address.address === '0.0.0.0' || address.address === '::') {
-        // Wildcard binds accept loopback connections; 127.0.0.1 is the address DevTools can reach.
-        return '127.0.0.1';
-    }
-    return address.address.includes(':') ? `[${address.address}]` : address.address;
-}
-function getBundledDev(server) {
-    const bundledDev = server.environments.client.bundledDev;
-    if (!bundledDev) {
-        throw new Error('Vite did not create the wx bundled-development environment.');
-    }
-    return bundledDev;
-}

package/dist/node/plugins/wx/dev/hmr-files.js

@@ -1,56 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import fs from 'node:fs/promises';
-import path from 'node:path';
-export const developmentAppWxssFileName = 'app.wxss';
-export const globalWxssFileName = 'assets/global.wxss';
-export const hmrInfoFileName = 'hmr/info.js';
-export const hmrPatchesFileName = 'hmr/patches.js';
-/** Report endpoint path served by the wx dev control edge. */
-export const hmrControlPath = '/__vpt_hmr__';
-/** Renders the synchronous CommonJS metadata module loaded by the runtime chunk. */
-export function renderHmrInfo(info) {
-    return `module.exports = Object.freeze(${JSON.stringify(info)});\n`;
-}
-/** Provides a valid dependency before the host has a patch range to publish. */
-export function renderInitialHmrPatches() {
-    return 'module.exports = undefined;\n';
-}
-/**
- * Renders the native App style entry for one complete development build.
- *
- * Imported global CSS can change while the entry remains byte-identical. DevTools may then reuse an older persistent compile
- * cache after it restarts. Tying this inert comment to the build identity invalidates that cache once per complete build,
- * while incremental style updates continue changing only the imported file and therefore preserve the App heap.
- */
-export function renderDevelopmentAppWxss(buildId) {
-    return `@import "./assets/global.wxss";\n/* vpt-build:${buildId} */\n`;
-}
-/**
- * Renders the cumulative patch suffix as inert CommonJS data.
- *
- * 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.
- */
-export function renderHmrPatches(buildId, patches) {
-    if (patches.length === 0) {
-        throw new Error('Cannot render an empty WX patch range.');
-    }
-    const rendered = patches.map((patch) => `{seq: ${patch.seq}, changedIds: ${JSON.stringify(patch.changedIds)}, factory: () => {\n${patch.code}\n}}`);
-    return `module.exports = {buildId: ${JSON.stringify(buildId)}, patches: [${rendered.join(',')}]};\n`;
-}
-/** Atomically publishes one physical HMR module so DevTools can observe only complete JavaScript generations. */
-export async function writeHmrFile(outDir, fileName, source) {
-    const filePath = path.join(outDir, fileName);
-    const directory = path.dirname(filePath);
-    await fs.mkdir(directory, { recursive: true });
-    const temporaryPath = path.join(directory, `.${path.basename(filePath)}.${randomUUID()}.txt`);
-    try {
-        // DevTools ignores the temporary .txt file; keeping it beside the destination guarantees a same-filesystem rename.
-        await fs.writeFile(temporaryPath, source);
-        await fs.rename(temporaryPath, filePath);
-    }
-    finally {
-        // rename removes the source path on success; force cleanup covers interrupted writes and failed replacements.
-        await fs.rm(temporaryPath, { force: true });
-    }
-}

package/dist/node/plugins/wx/dev/host-actions.js

@@ -1,58 +0,0 @@
-import { catchError, concatMap, defer, EMPTY, filter, firstValueFrom, lastValueFrom, map, Subject } from 'rxjs';
-/**
- * Executes semantic host actions one at a time while keeping source admission synchronous.
- *
- * `concatMap` is the sole effect serializer: each deferred reducer call starts only after the prior Promise settles. Errors are
- * converted to empty inner streams so one failed physical transaction is reported without terminating later host actions.
- * Barrier envelopes participate in the same ordering but run no effect; resolving one proves every action admitted before it
- * has settled. `waitForAction` observes this same admission edge for lifecycle gates without introducing a forwarding Subject.
- * Completing the source drains already-admitted effects and gives shutdown one Promise for final quiescence.
- */
-export function createHostActions(apply, reportError) {
-    /*
-     * This Subject is the host's only mutable admission edge. Independent callback stacks synchronously append semantic actions
-     * or barriers; concatMap owns the queued ordering and admits exactly one asynchronous effect at a time. A Promise chain would
-     * require mutation at every producer and is permanently rejected after one failure, while mergeMap could overlap physical
-     * writes and build rotation. The Subject retains no business frontier itself and is completed only after all external sources
-     * are quiescent, allowing lastValueFrom to prove the final queued effect settled.
-     */
-    const envelopes = new Subject();
-    const completion = lastValueFrom(envelopes.pipe(concatMap((envelope) => {
-        if (envelope.kind === 'barrier') {
-            return defer(() => {
-                envelope.resolve();
-                return EMPTY;
-            });
-        }
-        return defer(() => Promise.resolve(apply(envelope.action))).pipe(catchError((error) => {
-            reportError(envelope.action, error);
-            return EMPTY;
-        }));
-    })), { defaultValue: undefined });
-    return {
-        complete: async () => {
-            envelopes.complete();
-            await completion;
-        },
-        next(action) {
-            envelopes.next({ kind: 'action', action: action });
-        },
-        waitForAction(select) {
-            /*
-             * Subscribe to the multicast admission Subject rather than creating another lifecycle source. Barrier envelopes are
-             * internal ordering controls, so expose only semantic actions and let the caller's type guard select its milestone.
-             * firstValueFrom unsubscribes after the match; concatMap's independent subscription still applies the same action.
-             */
-            return firstValueFrom(envelopes.pipe(filter((envelope) => envelope.kind === 'action'), map((envelope) => envelope.action), filter(select)));
-        },
-        waitForIdle() {
-            /*
-             * The resolver is one transaction-local mutable latch. Enqueuing it behind ordinary actions makes resolution mean
-             * every earlier effect settled, without completing the shared source needed by final DevEngine output callbacks.
-             */
-            const barrier = Promise.withResolvers();
-            envelopes.next({ kind: 'barrier', resolve: barrier.resolve });
-            return barrier.promise;
-        }
-    };
-}

package/dist/node/plugins/wx/dev/patch-publisher.js

@@ -1,77 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { renderHmrPatches } from './hmr-files.js';
-/**
- * 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]) writes [5, 6];
- * 2. produce([7]) before an application report writes [5, 6, 7], so DevTools may miss the first file event safely;
- * 3. acknowledge(6) retains [7];
- * 4. produce([8]) then writes [7, 8], exactly the suffix the runtime still needs.
- *
- * The host may advance Rolldown's published frontier through 8 immediately after those writes, but this history is pruned only
- * through 6 until the runtime reports successful application. Published sequence and applied sequence are deliberately distinct.
- */
-export class PatchPublisher {
-    writePatches;
-    /*
-     * This mutable identity is the sole session authority for runtime reports and per-client Rolldown updates. startBuild rotates
-     * it only after a successful complete output reaches the serialized host reducer. Delayed reports retain their original ID
-     * and therefore fail isCurrentBuild instead of pruning or rebuilding the new session. An immutable constructor value cannot
-     * represent full-build rotation, while deriving identity from patches would leave empty builds without a client ID.
-     */
-    buildId;
-    /*
-     * This mutable ordered suffix bridges two independent frontiers: Rolldown payloads become published immediately after the
-     * cumulative file is durable, but entries remain here until the runtime acknowledges applying their sequence. Appending is
-     * lossless because later patches are deltas; prefix removal is the only valid mutation because acknowledgements are monotonic
-     * frontiers. A Set, latest-only value, or immutable reconstruction would either lose duplicate filenames/order or copy the
-     * complete unapplied history for every burst.
-     */
-    pendingPatches = [];
-    // Explicit field assignment: node --test strips types and does not support parameter properties.
-    constructor(writePatches) {
-        this.writePatches = writePatches;
-    }
-    /** True when the buildId belongs to the current full build. */
-    isCurrentBuild(buildId) {
-        return buildId === this.buildId;
-    }
-    /** Begins a fresh build and returns both sides of the client-session rotation. */
-    startBuild() {
-        const previousBuildId = this.buildId;
-        const buildId = randomUUID();
-        this.buildId = buildId;
-        this.pendingPatches.length = 0;
-        return { buildId, previousBuildId };
-    }
-    /**
-     * Appends a Rolldown batch and publishes the complete range not yet applied by the runtime.
-     *
-     * Resolution means the cumulative JavaScript generation is physically visible. The host may then advance Rolldown's
-     * published frontier immediately; pendingPatches remains intact until an application report proves the runtime caught up.
-     */
-    async produce(patches) {
-        if (this.buildId === undefined || patches.length === 0) {
-            return;
-        }
-        this.pendingPatches.push(...patches);
-        await this.writePatches(renderHmrPatches(this.buildId, this.pendingPatches));
-    }
-    /**
-     * Removes only the prefix covered by the runtime's successful application frontier. Publication alone never calls this:
-     * retaining the gap between published and applied frontiers is what lets DevTools safely miss intermediate file events.
-     */
-    acknowledge(seq) {
-        /*
-         * This local counter scans the monotonic prefix without allocating or invoking a callback for each patch. It exists only
-         * long enough to supply splice's prefix length; pendingPatches remains the sole durable frontier and is mutated once.
-         */
-        let appliedCount = 0;
-        while (appliedCount < this.pendingPatches.length && this.pendingPatches[appliedCount].seq <= seq) {
-            appliedCount++;
-        }
-        this.pendingPatches.splice(0, appliedCount);
-    }
-}