miaoda-expo-devkit 0.1.1-beta.98 → 0.1.1-dev.development-build.1

package/pnpm-patches/@expo__cli@55.0.16-55.0.22.patch

@@ -0,0 +1,627 @@
+diff --git a/build/src/start/server/metro/instantiateMetro.js b/build/src/start/server/metro/instantiateMetro.js
+--- a/build/src/start/server/metro/instantiateMetro.js
++++ b/build/src/start/server/metro/instantiateMetro.js
+@@ -90,6 +90,8 @@
+ const _attachAtlas = require("./debugging/attachAtlas");
+ const _createDebugMiddleware = require("./debugging/createDebugMiddleware");
+ const _createMetroMiddleware = require("./dev-server/createMetroMiddleware");
++const _aiErrorCollector = require("./aiErrorCollector");
++const _miaodaHmrControl = require("./miaodaHmrControl");
+ const _runServerfork = require("./runServer-fork");
+ const _withMetroMultiPlatform = require("./withMetroMultiPlatform");
+ const _events = require("../../../events");
+@@ -273,6 +275,7 @@
+     const { middleware, messagesSocket, eventsSocket, websocketEndpoints } = (0, _createMetroMiddleware.createMetroMiddleware)(metroConfig, {
+         getMetroBundler
+     });
++    const aiErrorCollector = !isExporting ? (0, _aiErrorCollector.createAiErrorCollector)(projectRoot) : null;
+     // Get local URL to Metro bundler server (typically configured as 127.0.0.1:8081)
+     const serverBaseUrl = metroBundler.getUrlCreator().constructUrl({
+         scheme: 'http',
+@@ -347,7 +350,10 @@
+             }
+         }), fileBuffer);
+     };
+-    setEventReporter(eventsSocket.reportMetroEvent);
++    setEventReporter((event)=>{
++        eventsSocket.reportMetroEvent(event);
++        aiErrorCollector == null ? void 0 : aiErrorCollector.handleMetroEvent(event);
++    });
+     // This function ensures that modules in source maps are sorted in the same
+     // order as in a plain JS bundle.
+     metro._getSortedModules = function(graph) {
+@@ -381,13 +387,24 @@
+             // Fork of https://github.com/facebook/metro/blob/3b3e0aaf725cfa6907bf2c8b5fbc0da352d29efe/packages/metro/src/HmrServer.js#L327-L393
+             // with patch for `_createModuleId`.
+             const logger = !options.isInitialUpdate ? changeEvent == null ? void 0 : changeEvent.logger : null;
++            const hmrChangeID = `${changeEvent == null ? 'initial' : changeEvent.changeId}:${group.revisionId}`;
++            aiErrorCollector == null ? void 0 : aiErrorCollector.handleMetroEvent({
++                type: 'hmr_update_started',
++                changeID: hmrChangeID
++            });
+             try {
+                 var _revision_graph_transformOptions_customTransformOptions;
+                 const revPromise = this._bundler.getRevision(group.revisionId);
+                 if (!revPromise) {
++                    const revisionError = new (_RevisionNotFoundError()).default(group.revisionId);
++                    aiErrorCollector == null ? void 0 : aiErrorCollector.handleMetroEvent({
++                        type: 'hmr_update_failed',
++                        changeID: hmrChangeID,
++                        error: revisionError
++                    });
+                     return {
+                         type: 'error',
+-                        body: (0, _formatBundlingError().default)(new (_RevisionNotFoundError()).default(group.revisionId))
++                        body: (0, _formatBundlingError().default)(revisionError)
+                     };
+                 }
+                 logger == null ? void 0 : logger.point('updateGraph_start');
+@@ -418,6 +435,10 @@
+                     serverRoot: this._config.server.unstable_serverRoot ?? this._config.projectRoot
+                 });
+                 logger == null ? void 0 : logger.point('serialize_end');
++                aiErrorCollector == null ? void 0 : aiErrorCollector.handleMetroEvent({
++                    type: 'hmr_update_done',
++                    changeID: hmrChangeID
++                });
+                 return {
+                     type: 'update',
+                     body: {
+@@ -430,7 +451,9 @@
+                 const formattedError = (0, _formatBundlingError().default)(error);
+                 this._config.reporter.update({
+                     type: 'bundling_error',
+-                    error
++                    error,
++                    isHmr: true,
++                    changeID: hmrChangeID
+                 });
+                 return {
+                     type: 'error',
+@@ -438,6 +461,11 @@
+                 };
+             }
+         };
++    }
++    if (hmrServer && process.env.EXPO_MIAODA_HMR_CONTROL === '1') {
++        hmrServer._miaodaAttach({
++            stateFile: process.env.EXPO_MIAODA_HMR_STATE_FILE
++        });
+     }
+     return {
+         metro,
+diff --git a/build/src/start/server/metro/runServer-fork.js b/build/src/start/server/metro/runServer-fork.js
+--- a/build/src/start/server/metro/runServer-fork.js
++++ b/build/src/start/server/metro/runServer-fork.js
+@@ -63,6 +63,7 @@
+     return data;
+ }
+ const _log = require("../../../log");
++const _miaodaHmrControl = require("./miaodaHmrControl");
+ function _interop_require_default(obj) {
+     return obj && obj.__esModule ? obj : {
+         default: obj
+@@ -150,6 +151,9 @@
+                 onReady(httpServer);
+             }
+             const hmrServer = new (_HmrServer()).default(metroServer.getBundler(), metroServer.getCreateModuleId(), config);
++            hmrServer._miaodaAttach = (options = {}) => (0, _miaodaHmrControl.attachMiaodaHmrControl)({
++                hmrServer, metro: metroServer, middleware: serverApp, ...options
++            });
+             Object.assign(websocketEndpoints, {
+                 '/hot': (0, _createWebsocketServer().default)({
+                     websocketServer: hmrServer
+diff --git a/build/src/start/server/metro/aiErrorCollector.js b/build/src/start/server/metro/aiErrorCollector.js
+new file mode 100644
+--- /dev/null
++++ b/build/src/start/server/metro/aiErrorCollector.js
+@@ -0,0 +1,222 @@
++"use strict";
++Object.defineProperty(exports, "__esModule", {
++    value: true
++});
++Object.defineProperty(exports, "createAiErrorCollector", {
++    enumerable: true,
++    get: function() {
++        return createAiErrorCollector;
++    }
++});
++const fs = require("fs");
++const os = require("os");
++const path = require("path");
++
++const MAX_VALUE_DEPTH = 4;
++const MAX_STRING_LENGTH = 20000;
++
++function isEnabled() {
++    return process.env.EXPO_AI_ERROR_COLLECTOR === '1';
++}
++
++function getOutputPath(projectRoot) {
++    const configured = process.env.EXPO_AI_ERROR_FILE;
++    if (!configured) return path.join(projectRoot, 'node_modules', '.miaoda-expo', 'ai-error.json');
++    return path.isAbsolute(configured) ? configured : path.resolve(projectRoot, configured);
++}
++
++function toSerializable(value, depth = 0, seen = new Set()) {
++    if (value == null || typeof value === 'boolean' || typeof value === 'number') return value;
++    if (typeof value === 'string') return value.length > MAX_STRING_LENGTH ? value.slice(0, MAX_STRING_LENGTH) + '...[truncated]' : value;
++    if (depth >= MAX_VALUE_DEPTH) return '[truncated]';
++    if (typeof value === 'function' || typeof value === 'symbol') return String(value);
++    if (seen.has(value)) return '[circular]';
++    seen.add(value);
++    if (value instanceof Error) {
++        const error = {
++            name: value.name,
++            message: value.message,
++            stack: value.stack
++        };
++        for (const key of Object.keys(value)) error[key] = toSerializable(value[key], depth + 1, seen);
++        seen.delete(value);
++        return error;
++    }
++    if (Array.isArray(value)) {
++        const result = value.map((item)=>toSerializable(item, depth + 1, seen));
++        seen.delete(value);
++        return result;
++    }
++    if (typeof value === 'object') {
++        const result = {};
++        for (const key of Object.keys(value)) result[key] = toSerializable(value[key], depth + 1, seen);
++        seen.delete(value);
++        return result;
++    }
++    return String(value);
++}
++
++function normalizeError(error, projectRoot, buildID) {
++    const raw = error && typeof error === 'object' ? error : {
++        message: String(error ?? 'Metro bundling failed')
++    };
++    const message = String(raw.message ?? raw.reason ?? error ?? 'Metro bundling failed');
++    const record = {
++        schemaVersion: 1,
++        id: `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`,
++        timestamp: new Date().toISOString(),
++        source: 'metro',
++        eventType: 'bundling_error',
++        buildID: buildID ?? undefined,
++        projectRoot,
++        type: String(raw.type ?? raw.name ?? 'MetroError'),
++        name: raw.name == null ? undefined : String(raw.name),
++        message,
++        filename: raw.filename == null ? undefined : String(raw.filename),
++        lineNumber: typeof raw.lineNumber === 'number' ? raw.lineNumber : undefined,
++        column: typeof raw.column === 'number' ? raw.column : undefined,
++        errors: Array.isArray(raw.errors) ? toSerializable(raw.errors) : [],
++        stack: raw.stack == null ? undefined : String(raw.stack),
++        cause: raw.cause == null ? undefined : toSerializable(raw.cause)
++    };
++    const extra = {};
++    for (const key of Object.keys(raw)) {
++        if (!['type', 'name', 'message', 'filename', 'lineNumber', 'column', 'errors', 'stack', 'cause'].includes(key)) {
++            extra[key] = toSerializable(raw[key]);
++        }
++    }
++    if (Object.keys(extra).length) record.extra = extra;
++    return omitUndefined(record);
++}
++
++function omitUndefined(value) {
++    if (!value || typeof value !== 'object') return value;
++    if (Array.isArray(value)) return value.map(omitUndefined);
++    const result = {};
++    for (const [key, item] of Object.entries(value)) {
++        if (item !== undefined) result[key] = omitUndefined(item);
++    }
++    return result;
++}
++
++function createAiErrorCollector(projectRoot) {
++    if (!isEnabled()) return null;
++    const outputFile = getOutputPath(projectRoot);
++    let activeBuildID = null;
++    let lastFailedBuildID = null;
++    let activeHmrChangeID = null;
++    let state = {
++        schemaVersion: 1,
++        status: 'compiling',
++        buildID: null,
++        updatedAt: new Date().toISOString(),
++        error: null
++    };
++    let warned = false;
++    const publish = (nextState)=>{
++        state = omitUndefined({ ...nextState, updatedAt: new Date().toISOString() });
++        let temporaryFile;
++        try {
++            fs.mkdirSync(path.dirname(outputFile), { recursive: true });
++            temporaryFile = `${outputFile}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`;
++            fs.writeFileSync(temporaryFile, JSON.stringify(state, null, 2) + os.EOL, 'utf8');
++            fs.renameSync(temporaryFile, outputFile);
++        } catch (error) {
++            try {
++                if (temporaryFile) fs.rmSync(temporaryFile, { force: true });
++            } catch {}
++            if (!warned) {
++                warned = true;
++                console.warn(`[expo-ai-error] Could not write ${outputFile}: ${error.message}`);
++            }
++        }
++    };
++    const isCurrentBuild = (buildID, allowMissing = false)=>buildID == null ? allowMissing || activeBuildID == null : activeBuildID == null || buildID === activeBuildID;
++    return {
++        getState() {
++            return state;
++        },
++        handleMetroEvent(event) {
++            if (!event || typeof event !== 'object') return;
++            const type = event.type;
++            const buildID = event.buildID ?? event.bundleDetails?.buildID ?? null;
++            if (type === 'hmr_update_started') {
++                activeHmrChangeID = typeof event.changeID === 'string' ? event.changeID : null;
++                lastFailedBuildID = null;
++                publish({
++                    schemaVersion: 1,
++                    status: 'compiling',
++                    buildID: activeBuildID,
++                    error: null
++                });
++                return;
++            }
++            if (type === 'hmr_update_failed') {
++                if (activeHmrChangeID == null || event.changeID !== activeHmrChangeID) return;
++                publish({
++                    schemaVersion: 1,
++                    status: 'failed',
++                    buildID: activeBuildID,
++                    error: normalizeError(event.error, projectRoot, activeBuildID)
++                });
++                return;
++            }
++            if (type === 'hmr_update_done') {
++                if (activeHmrChangeID == null || event.changeID !== activeHmrChangeID) return;
++                activeHmrChangeID = null;
++                publish({
++                    schemaVersion: 1,
++                    status: 'succeeded',
++                    buildID: activeBuildID,
++                    error: null
++                });
++                return;
++            }
++            if (type === 'bundle_build_started') {
++                activeBuildID = buildID;
++                activeHmrChangeID = null;
++                lastFailedBuildID = null;
++                publish({ schemaVersion: 1, status: 'compiling', buildID, error: null });
++                return;
++            }
++            if (type === 'bundle_build_failed') {
++                if (!isCurrentBuild(buildID)) return;
++                lastFailedBuildID = buildID ?? activeBuildID;
++                publish({
++                    schemaVersion: 1,
++                    status: 'failed',
++                    buildID: lastFailedBuildID,
++                    error: normalizeError(event.error ?? { type: 'MetroBundleError', message: 'Metro bundling failed' }, projectRoot, lastFailedBuildID)
++                });
++                return;
++            }
++            if (type === 'bundling_error') {
++                const isHmrError = event.isHmr === true;
++                if (isHmrError && activeHmrChangeID != null && event.changeID !== activeHmrChangeID) return;
++                const errorBuildID = isHmrError ? activeBuildID : buildID ?? lastFailedBuildID ?? activeBuildID;
++                if (!isCurrentBuild(errorBuildID, true)) return;
++                if (isHmrError) {
++                    // HMR 错误不携带 Metro build ID，保留变更标识以匹配后续恢复事件。
++                    activeHmrChangeID = event.changeID ?? activeHmrChangeID;
++                }
++                lastFailedBuildID = errorBuildID;
++
++                publish({
++                    schemaVersion: 1,
++                    status: 'failed',
++                    buildID: errorBuildID,
++                    error: normalizeError(event.error, projectRoot, errorBuildID)
++                });
++                return;
++            }
++            if (type === 'bundle_build_done') {
++                if (!isCurrentBuild(buildID)) return;
++                activeHmrChangeID = null;
++                lastFailedBuildID = null;
++                publish({ schemaVersion: 1, status: 'succeeded', buildID: buildID ?? activeBuildID, error: null });
++            }
++        }
++    };
++}
++
++//# sourceMappingURL=aiErrorCollector.js.map
+diff --git a/build/src/install/index.js b/build/src/install/index.js
+--- a/build/src/install/index.js
++++ b/build/src/install/index.js
+@@ -55,8 +55,18 @@
+     }
+     // Load modules after the help prompt so `npx expo install -h` shows as fast as possible.
+     const { installAsync } = require('./installAsync');
+-    const { logCmdError } = require('../utils/errors');
++    const { logCmdError, SilentError } = require('../utils/errors');
+     const { resolveArgsAsync } = require('./resolveOptions');
+     const { variadic, options, extras } = await resolveArgsAsync(process.argv.slice(3)).catch(logCmdError);
+-    return installAsync(variadic, options, extras).catch(logCmdError);
++    return installAsync(variadic, options, extras).catch((error)=>{
++        if (
++            error &&
++            typeof error === 'object' &&
++            typeof error.status === 'number' &&
++            Array.isArray(error.output)
++        ) {
++            return logCmdError(new SilentError(error));
++        }
++        return logCmdError(error);
++    });
+ };
+diff --git a/build/src/start/server/metro/miaodaHmrControl.js b/build/src/start/server/metro/miaodaHmrControl.js
+new file mode 100644
+--- /dev/null
++++ b/build/src/start/server/metro/miaodaHmrControl.js
+@@ -0,0 +1,258 @@
++"use strict";
++
++// SDK 55 / Metro 0.83.3. Attach after Expo replaces the HMR serializer.
++const fs = require('node:fs');
++const path = require('node:path');
++const CONTROL = 'miaoda-hmr-control';
++const ROUTES = new Map([
++  ['/innerapi/v1/sourcecode/__hmr_off', 'pause'],
++  ['/innerapi/v1/sourcecode/__hmr_on', 'resume'],
++  ['/innerapi/v1/sourcecode/__hmr_reload', 'reload'],
++  ['/innerapi/v1/sourcecode/__hmr_status', 'status'],
++]);
++
++function attachMiaodaHmrControl({hmrServer: hmr, metro, middleware, stateFile, timeout = 5000}) {
++  let paused = false;
++  let reloadPending = false;
++  let stateVersion = 0;
++  let lastMode = null;
++  if (stateFile && fs.existsSync(stateFile)) {
++    try {
++      const state = JSON.parse(fs.readFileSync(stateFile, 'utf8'));
++      paused = state.paused === true;
++      reloadPending = state.reloadPending === true;
++      stateVersion = Number.isInteger(state.stateVersion) ? state.stateVersion : 0;
++      lastMode = typeof state.lastMode === 'string' ? state.lastMode : null;
++    } catch {
++      // A damaged state file must not release an unfinished edit batch.
++      paused = true;
++    }
++  }
++  const clients = new Map();
++  const groupTasks = new WeakMap();
++  const results = new WeakMap();
++  const registrations = new Set();
++  let serial = Promise.resolve();
++  let controlId = 0;
++  let restoring = null;
++
++  function persist() {
++    if (!stateFile) return;
++    fs.mkdirSync(path.dirname(stateFile), {recursive: true});
++    const temp = `${stateFile}.${process.pid}.tmp`;
++    fs.writeFileSync(temp, JSON.stringify({version: 1, paused, reloadPending, stateVersion, lastMode}));
++    fs.renameSync(temp, stateFile);
++  }
++  function control(info, action, extra = {}) {
++    if (info.version === 1) info.send(JSON.stringify({type: CONTROL, version: 1, action, stateVersion, ...extra}));
++  }
++  function transition(mode) {
++    stateVersion += 1;
++    lastMode = mode;
++  }
++  function status() {
++    return {status: 0, paused, reloadPending, stateVersion, lastMode, protocolVersion: 1};
++  }
++  function pauseClient(info) {
++    if (info.version !== 1 || info.ack) return;
++    const id = ++controlId;
++    let resolve;
++    const promise = new Promise(done => { resolve = done; });
++    info.ack = {id, promise, resolve};
++    control(info, 'pause', {id});
++  }
++  function fail(status, message) {
++    const error = new Error(message);
++    error.status = status;
++    throw error;
++  }
++  async function awaitPaused() {
++    if ([...clients.values()].some(info => info.registered && info.version !== 1)) {
++      fail(409, 'Connected client lacks Miaoda HMR protocol v1; update its JS dependencies and reload.');
++    }
++    for (const info of clients.values()) pauseClient(info);
++    let timer;
++    try {
++      await Promise.race([
++        Promise.all([...clients.values()].filter(info => info.ack).map(info => info.ack.promise)),
++        new Promise((_, reject) => {
++          timer = setTimeout(() => {
++            const error = new Error('Timed out waiting for HMR pause acknowledgement; HMR remains paused.');
++            error.status = 504;
++            reject(error);
++          }, timeout);
++        }),
++      ]);
++    } finally { clearTimeout(timer); }
++  }
++
++  // Gate output immediately, including updates already compiling when pause arrives.
++  const connect = hmr.onClientConnect.bind(hmr);
++  hmr.onClientConnect = async (url, send) => {
++    const info = {send, version: null, registered: false, buffer: [], ack: null};
++    const client = await connect(url, message => {
++      const type = JSON.parse(String(message)).type;
++      if (paused && ['update-start', 'update', 'update-done', 'error'].includes(type)) {
++        info.buffer.push(message);
++      } else send(message);
++    });
++    clients.set(client, info);
++    return client;
++  };
++  const onMessage = hmr.onClientMessage.bind(hmr);
++  hmr.onClientMessage = async (client, message, send) => {
++    let data;
++    try { data = JSON.parse(String(message)); } catch { return onMessage(client, message, send); }
++    const info = clients.get(client);
++    if (data?.type === 'miaoda-hmr-ack' && info) {
++      if (data.version === 1 && data.id === info.ack?.id) info.ack.resolve();
++      return;
++    }
++    if (data?.type === 'register-entrypoints' && info) {
++      // Registration during a resume joins only after that operation has committed.
++      if (restoring) await restoring;
++      info.registered = true;
++      info.version = data.miaodaHmr === 1 ? 1 : null;
++      if (paused) pauseClient(info);
++      else control(info, 'resume');
++    }
++    // Use the gated sender for registration errors as well as graph updates.
++    const task = onMessage(client, message, client.sendFn);
++    if (data?.type !== 'register-entrypoints') return task;
++    registrations.add(task);
++    try { return await task; } finally { registrations.delete(task); }
++  };
++  const disconnect = hmr.onClientDisconnect.bind(hmr);
++  hmr.onClientDisconnect = client => {
++    clients.get(client)?.ack?.resolve();
++    clients.delete(client);
++    return disconnect(client);
++  };
++
++  const prepare = hmr._prepareMessage.bind(hmr);
++  hmr._prepareMessage = async (...args) => {
++    const result = await prepare(...args);
++    results.set(args[0], result);
++    return result;
++  };
++  const handle = hmr._handleFileChange.bind(hmr);
++  function enqueue(group, options, event, force = false) {
++    const previous = groupTasks.get(group) || Promise.resolve();
++    const task = previous.catch(() => {}).then(async () => {
++      // Leave DeltaCalculator's changes intact. Never drop an already-built revision.
++      if (paused && !force) return;
++      await handle(group, options, event);
++    });
++    groupTasks.set(group, task);
++    return task;
++  }
++  hmr._handleFileChange = (group, options, event) => enqueue(group, options, event);
++
++  async function run(action) {
++    if (action === 'pause') {
++      paused = true;
++      transition('paused');
++      persist();
++      await awaitPaused();
++      return {status: 0, paused, mode: 'paused'};
++    }
++    if (action === 'reload' && paused) {
++      reloadPending = true;
++      transition('reload-deferred');
++      persist();
++      return {...status(), mode: 'reload-deferred'};
++    }
++    if (action === 'status') return status();
++    if (action === 'resume' && !paused) return {...status(), mode: 'unchanged'};
++    paused = true;
++    if (action === 'reload') reloadPending = true;
++    transition(action === 'reload' ? 'reload-requested' : 'paused');
++    persist();
++    await awaitPaused();
++    let release;
++    restoring = new Promise(done => { release = done; });
++    try {
++      await Promise.all([...registrations]);
++      const graph = await metro.getBundler().getBundler().getDependencyGraph();
++      const fileMap = graph.getWatcher();
++      if (typeof fileMap.miaodaFlushChanges !== 'function') {
++        fail(503, 'Metro file-map barrier patch is missing; HMR remains paused.');
++      }
++      // Watcher cookie -> file-map processing queue -> change event -> final graph build.
++      await fileMap.miaodaFlushChanges(timeout);
++      const groups = [...new Set(hmr._clientGroups.values())];
++      await Promise.all(groups.map(group => enqueue(group, {isInitialUpdate: false}, undefined, true)));
++      const errors = groups.map(group => results.get(group)).filter(result => result?.type === 'error');
++      const staleGraph = error => ['GraphNotFoundError', 'RevisionNotFoundError'].includes(error?.type);
++      const compileErrors = errors.filter(result => !staleGraph(result.body));
++      if (compileErrors.length) {
++        for (const info of clients.values()) control(info, 'error', {error: compileErrors[0].body});
++        fail(422, 'Final code failed to compile; HMR remains paused. Fix the code and retry __hmr_on.');
++      }
++      const reload = reloadPending || errors.some(result => staleGraph(result.body)) || [...clients.values()].some(info => info.buffer.some(message => {
++        const data = JSON.parse(String(message));
++        return data.type === 'error' && staleGraph(data.body);
++      }));
++      // Persist before releasing clients. A persistence failure must leave the gate closed.
++      const previousReloadPending = reloadPending;
++      paused = false;
++      reloadPending = false;
++      transition(reload ? 'reload' : 'fast-refresh');
++      try { persist(); } catch (error) { paused = true; reloadPending = previousReloadPending; throw error; }
++      for (const info of clients.values()) {
++        if (reload) control(info, 'reload');
++        else {
++          for (const message of info.buffer) info.send(message);
++          control(info, 'resume');
++        }
++        info.buffer = [];
++        info.ack = null;
++      }
++      return {...status(), mode: reload ? 'reload' : 'fast-refresh', clients: clients.size};
++    } finally {
++      restoring = null;
++      release();
++    }
++  }
++  const handler = (req, res, next) => {
++    const pathname = new URL(req.url, 'http://localhost').pathname.replace(/\/$/, '');
++    const action = ROUTES.get(pathname);
++    if (!action || req.method === 'OPTIONS') return next();
++    if (action === 'status') {
++      if (req.method !== 'GET') {
++        res.statusCode = 405;
++        res.setHeader('Allow', 'GET');
++        return res.end();
++      }
++      res.statusCode = 200;
++      res.setHeader('Cache-Control', 'no-store');
++      res.setHeader('Content-Type', 'application/json');
++      return res.end(JSON.stringify(status()));
++    }
++    if (req.method !== 'POST') {
++      res.statusCode = 405;
++      res.setHeader('Allow', 'POST');
++      return res.end();
++    }
++    const task = serial.catch(() => {}).then(() => run(action));
++    serial = task;
++    task.then(body => {
++      res.statusCode = body.mode === 'reload-deferred' ? 202 : 200;
++      res.setHeader('Content-Type', 'application/json');
++      res.end(JSON.stringify(body));
++    }, error => {
++      res.statusCode = error.status || 503;
++      res.setHeader('Content-Type', 'application/json');
++      res.end(JSON.stringify({status: 1, paused, msg: error.message}));
++    });
++  };
++  // Metro has a catch-all middleware: append would make these routes unreachable.
++  middleware.use(handler);
++  middleware.stack.unshift(middleware.stack.pop());
++  return {run: action => {
++    const task = serial.catch(() => {}).then(() => run(action));
++    serial = task;
++    return task;
++  }};
++}
++module.exports = {attachMiaodaHmrControl};