putmein-test 1.0.0

package/dist/ray/node_modules/next/dist/server/dev/dev-validation-worker.js

@@ -0,0 +1,308 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    applyHmrUpdate: null,
+    invalidateCaches: null,
+    runDevValidation: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    applyHmrUpdate: function() {
+        return applyHmrUpdate;
+    },
+    invalidateCaches: function() {
+        return invalidateCaches;
+    },
+    runDevValidation: function() {
+        return runDevValidation;
+    }
+});
+require("../require-hook");
+require("../node-environment");
+const _path = require("path");
+const _fs = require("fs");
+const _url = require("url");
+const _installbindings = require("../../build/swc/install-bindings");
+const _installcodeframe = require("../lib/install-code-frame");
+const _loadcomponents = require("../load-components");
+const _setuphttpagentenv = require("../setup-http-agent-env");
+const _devvalidationerrordelivery = require("../app-render/dev-validation-error-delivery");
+const _devvalidationevents = require("../app-render/dev-validation-events");
+const _loadmanifestexternal = require("../load-manifest.external");
+const _requirecache = require("./require-cache");
+const _manifestssingleton = require("../app-render/manifests-singleton");
+const _patcherrorinspect = require("../patch-error-inspect");
+/**
+ * Resolves a chunk's source map by reading the `.map` file the bundler emitted
+ * next to it, for chunks inside `distDir`.
+ *
+ * The main thread answers the same question through the Turbopack project
+ * handle, which cannot cross a thread boundary. Reading from disk is
+ * project-free and, more importantly, does not depend on the chunk having been
+ * evaluated in this thread: Node.js caches source maps per isolate, and the
+ * worker never renders server components, so it holds maps only for the chunks
+ * `loadComponents` pulled in. Frames arriving in the transported payload can
+ * point at any chunk the main render touched.
+ *
+ * Reading from disk covers the chunks, because the worker only runs under
+ * Turbopack (see `next-dev-server.ts`), which writes a `.map` beside every one
+ * of them. A module the server updated in place has no chunk of its own and is
+ * covered instead by this thread applying the same update (see
+ * `applyHmrUpdate`), which leaves its inline map in Node.js' cache here. Frames
+ * from dependencies that are not bundled never reach this point, because
+ * `filterStackFrameDEV` drops `node_modules` and `node:` frames; bundled
+ * dependencies appear as chunks inside `distDir` like any other code.
+ */ function createDiskSourceMapLookup(distDir) {
+    // The frames carry resolved paths, so compare against the resolved `distDir`
+    // to keep the containment check meaningful when the project sits behind a
+    // symlink.
+    let canonicalDistDir = distDir;
+    try {
+        canonicalDistDir = (0, _fs.realpathSync)(distDir);
+    } catch  {}
+    const payloads = new Map();
+    return function findSourceMapPayloadOnDisk(sourceURL) {
+        let chunkPath = sourceURL;
+        if (chunkPath.startsWith('file://')) {
+            try {
+                chunkPath = (0, _url.fileURLToPath)(chunkPath);
+            } catch  {
+                return undefined;
+            }
+        }
+        if (!(0, _path.isAbsolute)(chunkPath)) {
+            // Not an emitted chunk, e.g. `<anonymous>`.
+            return undefined;
+        }
+        const cached = payloads.get(chunkPath);
+        if (cached !== undefined || payloads.has(chunkPath)) {
+            return cached;
+        }
+        let payload;
+        const relativePath = (0, _path.relative)(canonicalDistDir, chunkPath);
+        // Only chunks emitted into `distDir` have a source map to point at, and
+        // this keeps the lookup from reading arbitrary paths off disk.
+        if (!relativePath.startsWith('..') && !(0, _path.isAbsolute)(relativePath)) {
+            try {
+                payload = JSON.parse((0, _fs.readFileSync)(chunkPath + '.map', 'utf8'));
+            } catch  {
+                payload = undefined;
+            }
+        }
+        payloads.set(chunkPath, payload);
+        return payload;
+    };
+}
+// Match the main dev server (`next-dev-server.ts`), which raises this so the
+// server captures deeper stacks. React's owner-stack capture during the
+// validation prerenders depends on it, so without it the worker's errors lose
+// their owner-stack source attribution.
+try {
+    Error.stackTraceLimit = 50;
+} catch  {}
+// The lifecycle markers E2E tests read from the CLI. Emitted on the worker's
+// stdout (piped to the parent) so they interleave with the parent's captured
+// output the same way the in-process `runWithDevValidationLogging` markers do.
+// Gated on the same test env that path checks.
+const isTestLoggingEnabled = !!(process.env.__NEXT_TEST_MODE && process.env.NEXT_TEST_LOG_VALIDATION);
+/**
+ * Adapts the pool's supersede flag into an `AbortSignal` the validation passes
+ * check at their depth/yield boundaries. The pool shares an `Int32Array`-backed
+ * `SharedArrayBuffer` whose first slot the main thread flips to non-zero (with
+ * `Atomics.store` + `Atomics.notify`) when a newer navigation supersedes this
+ * one. We wait for that notification with `Atomics.waitAsync`, which is
+ * event-driven rather than polled. A validation that finishes without being
+ * superseded calls `cleanup()`, which wakes our own still-pending wait so it
+ * leaves no waiter (and no retained buffer) behind.
+ */ function createSupersedeSignal(abortBuffer) {
+    const controller = new AbortController();
+    const flag = new Int32Array(abortBuffer);
+    if (Atomics.load(flag, 0) !== 0) {
+        controller.abort();
+        return {
+            signal: controller.signal,
+            cleanup: ()=>{}
+        };
+    }
+    let settled = false;
+    const wait = Atomics.waitAsync(flag, 0, 0);
+    if (wait.async) {
+        wait.value.then(()=>{
+            if (settled) {
+                return;
+            }
+            settled = true;
+            // Woken either by a real supersede or by `cleanup()`; only the former
+            // leaves the flag set.
+            if (Atomics.load(flag, 0) !== 0) {
+                controller.abort();
+            }
+        });
+    } else if (Atomics.load(flag, 0) !== 0) {
+        // The flag flipped between the load above and the wait.
+        controller.abort();
+    }
+    return {
+        signal: controller.signal,
+        cleanup: ()=>{
+            if (!settled) {
+                Atomics.notify(flag, 0);
+            }
+        }
+    };
+}
+/**
+ * Waits out the test-only validation delay, resolving early if the render is
+ * superseded. Mirrors the delay in `runWithDevValidationLogging` so scheduler
+ * tests observe the same in-flight window on the worker path.
+ */ async function applyTestValidationDelay(signal) {
+    const delayMs = Number(process.env.NEXT_TEST_DEV_VALIDATION_DELAY_MS);
+    if (!Number.isFinite(delayMs) || delayMs <= 0 || signal.aborted) {
+        return;
+    }
+    await new Promise((resolve)=>{
+        const finishDelay = ()=>{
+            clearTimeout(timeout);
+            signal.removeEventListener('abort', finishDelay);
+            resolve();
+        };
+        const timeout = setTimeout(finishDelay, delayMs);
+        signal.addEventListener('abort', finishDelay, {
+            once: true
+        });
+    });
+}
+/**
+ * Registers the client reference manifests of the pages that supplied client
+ * references to the render being validated, beyond the validated route's own
+ * manifest. This thread has its own manifests singleton, which `loadComponents`
+ * seeds with only the validated route, so without these the dev-only cross-page
+ * lookup in `createProxiedClientReferenceManifest` has no other manifest to
+ * search and decoding the transported payload fails. Usually a no-op, since the
+ * main thread only records a page when React's I/O tracking actually carried a
+ * reference across pages.
+ */ async function registerAdditionalClientReferenceManifests(distDir, pages) {
+    if (pages.length === 0) {
+        return;
+    }
+    // Set by `loadComponents`. One server actions manifest covers the whole app,
+    // so the pages registered here share the validated route's.
+    const serverActionsManifest = (0, _manifestssingleton.getServerActionsManifest)();
+    await Promise.all(pages.map(async (page)=>{
+        const clientReferenceManifest = await (0, _loadcomponents.loadClientReferenceManifestForPage)(distDir, page);
+        if (clientReferenceManifest) {
+            (0, _manifestssingleton.setManifestsSingleton)({
+                page,
+                clientReferenceManifest,
+                serverActionsManifest
+            });
+        }
+    }));
+}
+async function applyHmrUpdate(update) {
+    if (typeof __turbopack_server_hmr_apply__ !== 'function') {
+        return 'no-runtime';
+    }
+    try {
+        __turbopack_server_hmr_apply__(update);
+    } catch  {
+        // The dev server responds to the same failure by re-evaluating every
+        // module from disk. This thread cannot be repaired in place either, so the
+        // caller drops it.
+        return 'failed';
+    }
+    return 'applied';
+}
+async function invalidateCaches(filePaths, evictModules) {
+    if (evictModules) {
+        (0, _requirecache.deleteCache)(filePaths);
+        return;
+    }
+    for (const filePath of filePaths){
+        (0, _loadmanifestexternal.clearManifestCache)(filePath);
+    }
+}
+async function runDevValidation(message, abortBuffer) {
+    // Load the native SWC bindings and wire the code-frame renderer so the errors
+    // logged below render with a source-mapped code frame, matching the
+    // in-process dev output (the E2E tests snapshot the CLI text between the
+    // validation markers). The `build/swc` graph these pull in is bundled as a
+    // runtime external (see `next-runtime.webpack-config.js`), so it resolves
+    // from the installed `next/dist` tree rather than being compiled into this
+    // worker bundle, the same way the unbundled build worker loads it.
+    await (0, _installbindings.installBindings)();
+    (0, _installcodeframe.installCodeFrameSupport)();
+    (0, _patcherrorinspect.setBundlerFindSourceMapImplementation)(createDiskSourceMapLookup(message.distDir));
+    (0, _setuphttpagentenv.setHttpClientAndAgentOptions)({
+        httpAgentOptions: message.nextConfigSerializable.httpAgentOptions
+    });
+    // Populates the manifests singleton for the route via `setManifestsSingleton`
+    // inside `loadComponents`, exactly as a real request does. The pool tears the
+    // worker down on HMR / route recompile so the next validation reloads from a
+    // clean require cache.
+    const { ComponentMod } = await (0, _loadcomponents.loadComponents)({
+        distDir: message.distDir,
+        page: message.page,
+        isAppPath: true,
+        isDev: true,
+        sriEnabled: false,
+        needsManifestsForLegacyReasons: true
+    });
+    await registerAdditionalClientReferenceManifests(message.distDir, message.additionalClientReferenceManifestPages);
+    const { signal, cleanup } = createSupersedeSignal(abortBuffer);
+    if (isTestLoggingEnabled) {
+        console.log((0, _devvalidationevents.formatValidationEvent)({
+            type: 'validation_start',
+            requestId: message.requestId,
+            url: message.request.urlPathname + message.request.urlSearch,
+            responseFinished: message.responseFinished
+        }));
+    }
+    try {
+        if (isTestLoggingEnabled) {
+            await applyTestValidationDelay(signal);
+        }
+        if (signal.aborted) {
+            return null;
+        }
+        // Crossing into the app-page bundle: the entire validation runs there, so
+        // the client prerenders use the same React the user's client components
+        // resolve through `ComponentMod`.
+        const validationErrors = await ComponentMod.routeModule.runValidationInDev(ComponentMod, message, signal);
+        if (validationErrors === undefined || signal.aborted) {
+            return null;
+        }
+        const errors = [];
+        for (const validationError of validationErrors){
+            // Log to the worker's stderr; `node-environment` +
+            // `installCodeFrameSupport` render the source-mapped stack and code frame
+            // there, matching the in-process CLI output.
+            console.error(validationError);
+            if (validationError instanceof Error) {
+                errors.push(validationError);
+            }
+        }
+        if (errors.length === 0) {
+            return null;
+        }
+        return await (0, _devvalidationerrordelivery.serializeValidationErrorsToFlight)(ComponentMod, errors);
+    } finally{
+        cleanup();
+        if (isTestLoggingEnabled) {
+            console.log((0, _devvalidationevents.formatValidationEvent)({
+                type: signal.aborted ? 'validation_aborted' : 'validation_end',
+                requestId: message.requestId,
+                url: message.request.urlPathname + message.request.urlSearch
+            }));
+        }
+    }
+}
+
+//# sourceMappingURL=dev-validation-worker.js.map

package/dist/ray/node_modules/next/dist/server/dev/get-source-map-from-file.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getSourceMapFromFile", {
+    enumerable: true,
+    get: function() {
+        return getSourceMapFromFile;
+    }
+});
+const _promises = /*#__PURE__*/ _interop_require_default(require("fs/promises"));
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _url = /*#__PURE__*/ _interop_require_default(require("url"));
+const _datauritobuffer = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/data-uri-to-buffer"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function getSourceMapUrl(fileContents) {
+    const regex = /\/\/[#@] ?sourceMappingURL=([^\s'"]+)\s*$/gm;
+    let match = null;
+    for(;;){
+        let next = regex.exec(fileContents);
+        if (next == null) {
+            break;
+        }
+        match = next;
+    }
+    if (!(match && match[1])) {
+        return null;
+    }
+    return match[1].toString();
+}
+async function getSourceMapFromFile(filename) {
+    filename = filename.startsWith('file://') ? _url.default.fileURLToPath(filename) : filename;
+    let fileContents;
+    try {
+        fileContents = await _promises.default.readFile(filename, 'utf-8');
+    } catch (error) {
+        throw Object.defineProperty(new Error(`Failed to read file contents of ${filename}.`, {
+            cause: error
+        }), "__NEXT_ERROR_CODE", {
+            value: "E466",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    const sourceUrl = getSourceMapUrl(fileContents);
+    if (!sourceUrl) {
+        return undefined;
+    }
+    if (sourceUrl.startsWith('data:')) {
+        let buffer;
+        try {
+            buffer = (0, _datauritobuffer.default)(sourceUrl);
+        } catch (error) {
+            throw Object.defineProperty(new Error(`Failed to parse source map URL for ${filename}.`, {
+                cause: error
+            }), "__NEXT_ERROR_CODE", {
+                value: "E199",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        if (buffer.type !== 'application/json') {
+            throw Object.defineProperty(new Error(`Unknown source map type for ${filename}: ${buffer.typeFull}.`), "__NEXT_ERROR_CODE", {
+                value: "E113",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        try {
+            return JSON.parse(buffer.toString());
+        } catch (error) {
+            throw Object.defineProperty(new Error(`Failed to parse source map for ${filename}.`, {
+                cause: error
+            }), "__NEXT_ERROR_CODE", {
+                value: "E318",
+                enumerable: false,
+                configurable: true
+            });
+        }
+    }
+    const sourceMapFilename = _path.default.resolve(_path.default.dirname(filename), decodeURIComponent(sourceUrl));
+    try {
+        const sourceMapContents = await _promises.default.readFile(sourceMapFilename, 'utf-8');
+        return JSON.parse(sourceMapContents.toString());
+    } catch (error) {
+        throw Object.defineProperty(new Error(`Failed to parse source map ${sourceMapFilename}.`, {
+            cause: error
+        }), "__NEXT_ERROR_CODE", {
+            value: "E220",
+            enumerable: false,
+            configurable: true
+        });
+    }
+}
+
+//# sourceMappingURL=get-source-map-from-file.js.map

package/dist/ray/node_modules/next/dist/server/dev/hot-middleware.js

@@ -0,0 +1,276 @@
+// Based on https://github.com/webpack-contrib/webpack-hot-middleware/blob/9708d781ae0e46179cf8ea1a94719de4679aaf53/middleware.js
+// Included License below
+// Copyright JS Foundation and other contributors
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// 'Software'), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+// THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "WebpackHotMiddleware", {
+    enumerable: true,
+    get: function() {
+        return WebpackHotMiddleware;
+    }
+});
+const _utils = require("../../build/utils");
+const _hotreloadertypes = require("./hot-reloader-types");
+const _devindicatorserverstate = require("./dev-indicator-server-state");
+const _messages = require("./messages");
+const _requestinsights = require("../lib/trace/request-insights");
+function isMiddlewareStats(stats) {
+    for (const key of stats.compilation.entrypoints.keys()){
+        if ((0, _utils.isMiddlewareFilename)(key)) {
+            return true;
+        }
+    }
+    return false;
+}
+function statsToJson(stats) {
+    if (!stats) return {};
+    return stats.toJson({
+        all: false,
+        errors: true,
+        hash: true,
+        warnings: true
+    });
+}
+function getStatsForSyncEvent(clientStats, serverStats) {
+    if (!clientStats) return serverStats == null ? void 0 : serverStats.stats;
+    if (!serverStats) return clientStats == null ? void 0 : clientStats.stats;
+    // Prefer the server compiler stats if it has errors.
+    // Otherwise we may end up in a state where the client compilation is the latest but without errors.
+    // This causes the error overlay to not display the build error.
+    if (serverStats.stats.hasErrors()) {
+        return serverStats.stats;
+    }
+    // Return the latest stats
+    return serverStats.ts > clientStats.ts ? serverStats.stats : clientStats.stats;
+}
+class WebpackHotMiddleware {
+    constructor(compilers, versionInfo, devtoolsFrontendUrl, config, devToolsConfig){
+        this.versionInfo = versionInfo;
+        this.devtoolsFrontendUrl = devtoolsFrontendUrl;
+        this.config = config;
+        this.devToolsConfig = devToolsConfig;
+        this.clientsWithoutHtmlRequestId = new Set();
+        this.clientsByHtmlRequestId = new Map();
+        this.closed = false;
+        this.clientLatestStats = null;
+        this.middlewareLatestStats = null;
+        this.serverLatestStats = null;
+        this.onClientInvalid = ()=>{
+            var _this_serverLatestStats;
+            if (this.closed || ((_this_serverLatestStats = this.serverLatestStats) == null ? void 0 : _this_serverLatestStats.stats.hasErrors())) return;
+            this.publish({
+                type: _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.BUILDING
+            });
+        };
+        this.onClientDone = (statsResult)=>{
+            var _this_serverLatestStats;
+            this.clientLatestStats = {
+                ts: Date.now(),
+                stats: statsResult
+            };
+            if (this.closed || ((_this_serverLatestStats = this.serverLatestStats) == null ? void 0 : _this_serverLatestStats.stats.hasErrors())) return;
+            this.publishStats(statsResult);
+        };
+        this.onServerInvalid = ()=>{
+            var _this_serverLatestStats, _this_clientLatestStats;
+            if (!((_this_serverLatestStats = this.serverLatestStats) == null ? void 0 : _this_serverLatestStats.stats.hasErrors())) return;
+            this.serverLatestStats = null;
+            if ((_this_clientLatestStats = this.clientLatestStats) == null ? void 0 : _this_clientLatestStats.stats) {
+                this.publishStats(this.clientLatestStats.stats);
+            }
+        };
+        this.onServerDone = (statsResult)=>{
+            if (this.closed) return;
+            if (statsResult.hasErrors()) {
+                this.serverLatestStats = {
+                    ts: Date.now(),
+                    stats: statsResult
+                };
+                this.publishStats(statsResult);
+            }
+        };
+        this.onEdgeServerInvalid = ()=>{
+            var _this_middlewareLatestStats, _this_clientLatestStats;
+            if (!((_this_middlewareLatestStats = this.middlewareLatestStats) == null ? void 0 : _this_middlewareLatestStats.stats.hasErrors())) return;
+            this.middlewareLatestStats = null;
+            if ((_this_clientLatestStats = this.clientLatestStats) == null ? void 0 : _this_clientLatestStats.stats) {
+                this.publishStats(this.clientLatestStats.stats);
+            }
+        };
+        this.onEdgeServerDone = (statsResult)=>{
+            if (this.closed) return;
+            if (!isMiddlewareStats(statsResult)) {
+                this.onServerInvalid();
+                this.onServerDone(statsResult);
+            }
+            if (statsResult.hasErrors()) {
+                this.middlewareLatestStats = {
+                    ts: Date.now(),
+                    stats: statsResult
+                };
+                this.publishStats(statsResult);
+            }
+        };
+        this./**
+   * To sync we use the most recent stats but also we append middleware
+   * errors. This is because it is possible that middleware fails to compile
+   * and we still want to show the client overlay with the error while
+   * the error page should be rendered just fine.
+   */ onHMR = (client, htmlRequestId)=>{
+            if (this.closed) return;
+            if (htmlRequestId) {
+                this.clientsByHtmlRequestId.set(htmlRequestId, client);
+            } else {
+                this.clientsWithoutHtmlRequestId.add(client);
+            }
+            client.addEventListener('close', ()=>{
+                if (htmlRequestId) {
+                    this.clientsByHtmlRequestId.delete(htmlRequestId);
+                } else {
+                    this.clientsWithoutHtmlRequestId.delete(client);
+                }
+            });
+            const syncStats = getStatsForSyncEvent(this.clientLatestStats, this.serverLatestStats);
+            if (syncStats) {
+                var _this_middlewareLatestStats;
+                const stats = statsToJson(syncStats);
+                const middlewareStats = statsToJson((_this_middlewareLatestStats = this.middlewareLatestStats) == null ? void 0 : _this_middlewareLatestStats.stats);
+                if (_devindicatorserverstate.devIndicatorServerState.disabledUntil < Date.now()) {
+                    _devindicatorserverstate.devIndicatorServerState.disabledUntil = 0;
+                }
+                this.publish({
+                    type: _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.SYNC,
+                    hash: stats.hash,
+                    errors: [
+                        ...stats.errors || [],
+                        ...middlewareStats.errors || []
+                    ],
+                    warnings: [
+                        ...stats.warnings || [],
+                        ...middlewareStats.warnings || []
+                    ],
+                    versionInfo: this.versionInfo,
+                    debug: {
+                        devtoolsFrontendUrl: this.devtoolsFrontendUrl
+                    },
+                    devIndicator: _devindicatorserverstate.devIndicatorServerState,
+                    devToolsConfig: this.devToolsConfig,
+                    requestInsights: this.config.experimental.requestInsights || (0, _requestinsights.isRequestInsightsEnabled)() ? (0, _requestinsights.getRequestInsightsSnapshot)() : undefined
+                });
+            }
+        };
+        this.publishStats = (statsResult)=>{
+            const stats = statsResult.toJson({
+                all: false,
+                hash: true,
+                warnings: true,
+                errors: true,
+                moduleTrace: true
+            });
+            this.publish({
+                type: _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.BUILT,
+                hash: stats.hash,
+                warnings: stats.warnings || [],
+                errors: stats.errors || []
+            });
+        };
+        this.getClient = (htmlRequestId)=>{
+            return this.clientsByHtmlRequestId.get(htmlRequestId);
+        };
+        this.publishToClient = (client, message)=>{
+            if (this.closed) {
+                return;
+            }
+            const data = typeof message.type === 'number' ? (0, _messages.createBinaryHmrMessageData)(message) : JSON.stringify(message);
+            client.send(data);
+        };
+        this.publish = (message)=>{
+            if (this.closed) {
+                return;
+            }
+            for (const wsClient of [
+                ...this.clientsWithoutHtmlRequestId,
+                ...this.clientsByHtmlRequestId.values()
+            ]){
+                this.publishToClient(wsClient, message);
+            }
+        };
+        this.publishToLegacyClients = (message)=>{
+            if (this.closed) {
+                return;
+            }
+            // Clients with a request ID are inferred App Router clients. If Cache
+            // Components is not enabled, we consider those legacy clients. Pages
+            // Router clients are also considered legacy clients. TODO: Maybe mark
+            // clients as App Router / Pages Router clients explicitly, instead of
+            // inferring it from the presence of a request ID.
+            if (!this.config.cacheComponents) {
+                for (const wsClient of this.clientsByHtmlRequestId.values()){
+                    this.publishToClient(wsClient, message);
+                }
+            }
+            for (const wsClient of this.clientsWithoutHtmlRequestId){
+                this.publishToClient(wsClient, message);
+            }
+        };
+        this.close = ()=>{
+            if (this.closed) {
+                return;
+            }
+            // Can't remove compiler plugins, so we just set a flag and noop if closed
+            // https://github.com/webpack/tapable/issues/32#issuecomment-350644466
+            this.closed = true;
+            for (const wsClient of [
+                ...this.clientsWithoutHtmlRequestId,
+                ...this.clientsByHtmlRequestId.values()
+            ]){
+                // it's okay to not cleanly close these websocket connections, this is dev
+                wsClient.terminate();
+            }
+            this.clientsWithoutHtmlRequestId.clear();
+            this.clientsByHtmlRequestId.clear();
+        };
+        this.deleteClient = (client, htmlRequestId)=>{
+            if (htmlRequestId) {
+                this.clientsByHtmlRequestId.delete(htmlRequestId);
+            } else {
+                this.clientsWithoutHtmlRequestId.delete(client);
+            }
+        };
+        this.hasClients = ()=>{
+            return this.clientsWithoutHtmlRequestId.size + this.clientsByHtmlRequestId.size > 0;
+        };
+        this.getClientCount = ()=>{
+            return this.clientsWithoutHtmlRequestId.size + this.clientsByHtmlRequestId.size;
+        };
+        compilers[0].hooks.invalid.tap('webpack-hot-middleware', this.onClientInvalid);
+        compilers[0].hooks.done.tap('webpack-hot-middleware', this.onClientDone);
+        compilers[1].hooks.invalid.tap('webpack-hot-middleware', this.onServerInvalid);
+        compilers[1].hooks.done.tap('webpack-hot-middleware', this.onServerDone);
+        compilers[2].hooks.done.tap('webpack-hot-middleware', this.onEdgeServerDone);
+        compilers[2].hooks.invalid.tap('webpack-hot-middleware', this.onEdgeServerInvalid);
+    }
+    updateDevToolsConfig(newConfig) {
+        this.devToolsConfig = newConfig;
+    }
+}
+
+//# sourceMappingURL=hot-middleware.js.map