@lark-apaas/coding-template-nestjs-react-fullstack 0.1.27-alpha.20260824122815 → 0.1.27

package/template/scripts/vite-cache-runtime.mjs

@@ -1,3098 +0,0 @@
-#!/usr/bin/env node
-
-import fs from 'node:fs';
-import path from 'node:path';
-import http from 'node:http';
-import net from 'node:net';
-import { createRequire, Module } from 'node:module';
-import { createHash } from 'node:crypto';
-import { spawn } from 'node:child_process';
-import { pathToFileURL } from 'node:url';
-import {
-  validateCacheGeneration,
-  validateCacheGenerationReceipt,
-} from './cache-generation-preflight.mjs';
-
-const projectRoot = path.resolve(
-  process.env.MIAODA_WORKSPACE_ROOT || process.cwd()
-);
-
-const MIAODA_PREVIEW_RENDERED_PLUGIN_NAME = 'miaoda-preview-rendered';
-const MIAODA_PREVIEW_RENDERED_CLIENT = String.raw`
-(() => {
-  if (globalThis.__miaodaPreviewRenderedReporterInstalled) return;
-  globalThis.__miaodaPreviewRenderedReporterInstalled = true;
-
-  const runID = new URLSearchParams(globalThis.location.search).get(
-    '__miaoda_preview_run_id'
-  );
-  if (!/^[A-Za-z0-9_-]{1,64}$/.test(runID || '')) return;
-
-  let targetOrigin = globalThis.location.origin;
-  try {
-    if (document.referrer) targetOrigin = new URL(document.referrer).origin;
-  } catch {}
-  const allowedParentOrigins = new Set([
-    globalThis.location.origin,
-    'https://miaoda.feishu-boe.cn',
-    'https://miaoda.feishu-pre.cn',
-    'https://miaoda.feishu.cn',
-  ]);
-  if (!allowedParentOrigins.has(targetOrigin)) return;
-
-  let reportSequence = 0;
-  let reportCycle = 0;
-  let reportedCycle = -1;
-  let quietTimer;
-  let observer;
-  let firstScheduledAt = performance.now();
-  let domFallbackNotBefore = firstScheduledAt + 5_000;
-  const timeOrigin =
-    performance.timeOrigin ||
-    performance.timing?.navigationStart ||
-    Date.now() - performance.now();
-  const hasRenderedContent = () =>
-    [...document.body.children].some(element => {
-      if (['SCRIPT', 'STYLE', 'LINK'].includes(element.tagName)) return false;
-      return element.childElementCount > 0 || element.textContent?.trim();
-    });
-  const report = ({ customTtiMs, renderedAtEpochMs, source }) => {
-    if (reportedCycle === reportCycle) return;
-    reportedCycle = reportCycle;
-    reportSequence += 1;
-    clearTimeout(quietTimer);
-    observer?.disconnect();
-    globalThis.parent.postMessage(
-      {
-        type: 'MiaodaPreviewRendered',
-        data: {
-          runID,
-          customTtiMs: Math.max(0, customTtiMs),
-          renderedAtEpochMs,
-          occurrence: reportSequence,
-          source,
-        },
-      },
-      targetOrigin
-    );
-  };
-  const reportFromBuilderTti = event => {
-    const customTtiMs = event?.detail?.time;
-    if (typeof customTtiMs !== 'number' || !Number.isFinite(customTtiMs)) {
-      return;
-    }
-    const eventEpochMs = event?.detail?.renderedAtEpochMs;
-    const renderedAtEpochMs =
-      typeof eventEpochMs === 'number' && Number.isFinite(eventEpochMs)
-        ? eventEpochMs
-        : timeOrigin + performance.now();
-    report({
-      customTtiMs,
-      renderedAtEpochMs,
-      source: 'builderV3-custom-TTI',
-    });
-  };
-  const reportFromDomFallback = () => {
-    if (reportedCycle === reportCycle) return;
-    if (!document.body || !hasRenderedContent()) {
-      if (performance.now() - firstScheduledAt < 10_000) schedule();
-      return;
-    }
-    const renderedAt = performance.now();
-    report({
-      customTtiMs: renderedAt,
-      renderedAtEpochMs: timeOrigin + renderedAt,
-      source: 'dom-fallback',
-    });
-  };
-  const schedule = () => {
-    if (reportedCycle === reportCycle) return;
-    clearTimeout(quietTimer);
-    const delay = Math.max(100, domFallbackNotBefore - performance.now());
-    quietTimer = setTimeout(
-      () =>
-        requestAnimationFrame(() => requestAnimationFrame(reportFromDomFallback)),
-      delay
-    );
-  };
-  const start = async () => {
-    await document.fonts?.ready?.catch?.(() => undefined);
-    firstScheduledAt = performance.now();
-    domFallbackNotBefore = firstScheduledAt + 5_000;
-    observer = new MutationObserver(schedule);
-    observer.observe(document.documentElement, {
-      attributes: true,
-      childList: true,
-      subtree: true,
-      characterData: true,
-    });
-    schedule();
-    setTimeout(() => observer.disconnect(), 10_000);
-  };
-  if (document.readyState === 'loading') {
-    globalThis.addEventListener('DOMContentLoaded', () => void start(), {
-      once: true,
-    });
-  } else {
-    void start();
-  }
-  globalThis.addEventListener('builderV3-custom-TTI', reportFromBuilderTti);
-  if (import.meta.hot) {
-    import.meta.hot.on('vite:afterUpdate', () => {
-      reportCycle += 1;
-      firstScheduledAt = performance.now();
-      domFallbackNotBefore = firstScheduledAt + 5_000;
-      observer?.disconnect();
-      observer = new MutationObserver(schedule);
-      observer.observe(document.documentElement, {
-        attributes: true,
-        childList: true,
-        subtree: true,
-        characterData: true,
-      });
-      schedule();
-    });
-  }
-})();
-`;
-
-function createMiaodaPreviewRenderedPlugin() {
-  return {
-    name: MIAODA_PREVIEW_RENDERED_PLUGIN_NAME,
-    apply: 'serve',
-    transformIndexHtml: {
-      order: 'post',
-      handler() {
-        return [
-          {
-            tag: 'script',
-            attrs: { type: 'module' },
-            children: MIAODA_PREVIEW_RENDERED_CLIENT,
-            injectTo: 'body',
-          },
-        ];
-      },
-    },
-  };
-}
-
-async function runFreshRuntimeChild() {
-  process.chdir(projectRoot);
-  process.env.MIAODA_CACHE_BOOTSTRAP_ENABLED = 'false';
-  for (const environmentName of [
-    'MIAODA_CACHE_ROOT',
-    'MIAODA_CACHE_VALIDATION_RECEIPT_FILE',
-    'MIAODA_PLATFORM_RUNTIME_ROOT',
-    'MIAODA_PLATFORM_RUNTIME_MANIFEST',
-    'MIAODA_VITE_CACHE_PREPARE',
-    'MIAODA_VITE_CACHE_DIR',
-    'MIAODA_VITE_CONFIG_PACKAGE_ALIASES',
-    'MIAODA_VITE_DEPENDENCY_ASSETS_ROOT',
-    'MIAODA_VITE_DEPENDENCY_GRAPH_HASH',
-    'MIAODA_VITE_FORCE_REOPTIMIZE',
-    'MIAODA_VITE_RUNTIME_CACHE_DIR',
-  ]) {
-    delete process.env[environmentName];
-  }
-  const projectRequire = createRequire(path.join(projectRoot, 'package.json'));
-  const projectViteEntry = projectRequire.resolve('vite');
-  const projectVite = await import(pathToFileURL(projectViteEntry).href);
-  const createFreshServer = readExport(projectVite, 'createServer');
-  const loadFreshConfigFromFile = readExport(projectVite, 'loadConfigFromFile');
-  const freshConfigFile = [
-    'vite.config.ts',
-    'vite.config.mts',
-    'vite.config.js',
-    'vite.config.mjs',
-    'vite.config.cjs',
-  ]
-    .map(file => path.join(projectRoot, file))
-    .find(file => fs.existsSync(file));
-  let freshProjectConfig = {};
-  if (freshConfigFile) {
-    const loaded = await loadFreshConfigFromFile(
-      { command: 'serve', mode: process.env.NODE_ENV },
-      freshConfigFile,
-      projectRoot
-    );
-    if (!loaded) {
-      throw new Error(`MIAODA_VITE_CONFIG_LOAD_FAILED: ${freshConfigFile}`);
-    }
-    freshProjectConfig = loaded.config;
-  }
-  const freshRuntimePreviewRendered = createMiaodaPreviewRenderedPlugin();
-  const freshServer = await createFreshServer({
-    ...freshProjectConfig,
-    configFile: false,
-    root: projectRoot,
-    // The workspace config can already contain the preview reporter. Keep the
-    // image-owned implementation as the single source of truth so one iframe
-    // render cannot be reported twice after the fresh runtime takes over.
-    plugins: [
-      freshRuntimePreviewRendered,
-      ...(freshProjectConfig.plugins || []).filter(
-        plugin => plugin?.name !== MIAODA_PREVIEW_RENDERED_PLUGIN_NAME
-      ),
-    ],
-    server: {
-      ...(freshProjectConfig.server || {}),
-      host: '127.0.0.1',
-      port: 0,
-      strictPort: false,
-    },
-  });
-  await freshServer.listen();
-  const freshAppManifestFile = path.resolve(
-    process.env.MIAODA_APP_RUNTIME_MANIFEST ||
-      path.join(projectRoot, '.miaoda-cache', 'current', 'app-runtime.json')
-  );
-  const freshAppManifest = JSON.parse(
-    fs.readFileSync(freshAppManifestFile, 'utf8')
-  );
-  const freshClientEntry = freshAppManifest.clientEntry;
-  if (
-    typeof freshClientEntry !== 'string' ||
-    !freshClientEntry ||
-    freshClientEntry.startsWith('/') ||
-    freshClientEntry.split('/').includes('..')
-  ) {
-    await freshServer.close();
-    throw new Error('MIAODA_VITE_FRESH_CLIENT_ENTRY_INVALID');
-  }
-  const freshClientEntryUrl = `/${freshClientEntry}`;
-  await freshServer.warmupRequest(freshClientEntryUrl);
-  await freshServer.waitForRequestsIdle(freshClientEntryUrl);
-  const address = freshServer.httpServer?.address();
-  if (!address || typeof address === 'string') {
-    await freshServer.close();
-    throw new Error('MIAODA_VITE_FRESH_RUNTIME_ADDRESS_MISSING');
-  }
-  process.stdout.write(
-    `${JSON.stringify({
-      event: 'miaoda_vite_fresh_runtime_child_ready',
-      pid: process.pid,
-      port: address.port,
-      viteVersion: projectRequire('vite/package.json').version,
-      pluginNames: freshServer.config.plugins.map(plugin => plugin.name),
-    })}\n`
-  );
-  if (typeof process.send === 'function') {
-    process.send({
-      event: 'miaoda_vite_fresh_runtime_child_ready',
-      port: address.port,
-      webSocketToken: freshServer.config.webSocketToken,
-    });
-  }
-  await new Promise(resolve => {
-    let closing = false;
-    const closeFreshServer = async signal => {
-      if (closing) return;
-      closing = true;
-      process.stdout.write(
-        `${JSON.stringify({
-          event: 'miaoda_vite_fresh_runtime_child_stopping',
-          signal,
-        })}\n`
-      );
-      await freshServer.close().catch(() => undefined);
-      resolve();
-    };
-    process.once('SIGINT', () => void closeFreshServer('SIGINT'));
-    process.once('SIGTERM', () => void closeFreshServer('SIGTERM'));
-    process.once('SIGHUP', () => void closeFreshServer('SIGHUP'));
-  });
-}
-
-if (process.argv.includes('--fresh-runtime-child')) {
-  await runFreshRuntimeChild();
-  process.exit(0);
-}
-
-const platformRuntimeRoot = path.resolve(
-  process.env.MIAODA_PLATFORM_RUNTIME_ROOT || '/opt/miaoda/preview-runtime'
-);
-const fullstackCliRoot = path.resolve(
-  process.env.MIAODA_FULLSTACK_CLI_ROOT ||
-    '/usr/lib/node_modules/@lark-apaas/fullstack-cli'
-);
-const prepareCache = process.env.MIAODA_VITE_CACHE_PREPARE === 'true';
-const managedByCoordinator =
-  process.env.MIAODA_RUNTIME_MANAGED_BY_COORDINATOR === 'true';
-const servingReadyMarker = '/tmp/event/MIAODA_VITE_CACHE_SERVING_READY';
-const defaultCachePointer = path.join(projectRoot, '.miaoda-cache', 'current');
-const requestedCacheRoot = path.resolve(
-  process.env.MIAODA_CACHE_ROOT || defaultCachePointer
-);
-const cacheRoot = prepareCache
-  ? requestedCacheRoot
-  : fs.realpathSync(requestedCacheRoot);
-if (!prepareCache && !process.env.MIAODA_CACHE_ROOT) {
-  const generationStore = fs.realpathSync(
-    path.join(projectRoot, '.miaoda-cache', 'generations')
-  );
-  const generationRelative = path.relative(generationStore, cacheRoot);
-  if (!/^[a-f0-9]{64}$/.test(generationRelative)) {
-    throw new Error('MIAODA_CACHE_GENERATION_POINTER_REJECTED');
-  }
-}
-const runtimeManifestFile = path.resolve(
-  process.env.MIAODA_PLATFORM_RUNTIME_MANIFEST ||
-    path.join(platformRuntimeRoot, 'runtime-manifest.json')
-);
-const appManifestFile = path.resolve(
-  process.env.MIAODA_APP_RUNTIME_MANIFEST ||
-    path.join(cacheRoot, 'app-runtime.json')
-);
-const dependencyReadyFile = path.resolve(
-  process.env.MIAODA_DEPENDENCY_READY_FILE ||
-    path.join(projectRoot, '.miaoda-runtime', 'dependencies-ready.json')
-);
-const dependencyHandoffExitCode = 75;
-const sealedCacheDir = path.resolve(
-  process.env.MIAODA_VITE_CACHE_DIR || path.join(cacheRoot, 'vite')
-);
-let cacheDir = sealedCacheDir;
-const prepareTimeoutMs = Number(
-  process.env.MIAODA_VITE_CACHE_PREPARE_TIMEOUT_MS || 120_000
-);
-const closeTimeoutMs = Number(
-  process.env.MIAODA_VITE_CACHE_CLOSE_TIMEOUT_MS || 2_000
-);
-const runtimeStartedAt = process.hrtime.bigint();
-const durationMs = startedAt =>
-  Number(process.hrtime.bigint() - startedAt) / 1_000_000;
-function emitRuntimePhase(phase, startedAt, details = {}) {
-  process.stdout.write(
-    `${JSON.stringify({
-      event: 'miaoda_cache_runtime_phase',
-      runtime: 'vite',
-      phase,
-      durationMs: Number(durationMs(startedAt).toFixed(3)),
-      ...details,
-    })}\n`
-  );
-}
-
-function readLinuxProcessIo() {
-  if (process.platform !== 'linux') return undefined;
-  try {
-    return Object.fromEntries(
-      fs
-        .readFileSync('/proc/self/io', 'utf8')
-        .trim()
-        .split('\n')
-        .map(line => {
-          const separator = line.indexOf(':');
-          return [
-            line.slice(0, separator),
-            Number(line.slice(separator + 1).trim()),
-          ];
-        })
-        .filter(([, value]) => Number.isFinite(value))
-    );
-  } catch {
-    return undefined;
-  }
-}
-
-function runtimeImportSnapshot() {
-  return {
-    startedAt: process.hrtime.bigint(),
-    cpu: process.cpuUsage(),
-    resources: process.resourceUsage(),
-    linuxIo: readLinuxProcessIo(),
-  };
-}
-
-function runtimeImportMetrics(snapshot) {
-  const cpu = process.cpuUsage(snapshot.cpu);
-  const resources = process.resourceUsage();
-  const linuxIo = readLinuxProcessIo();
-  const wallMs = durationMs(snapshot.startedAt);
-  const userCpuMs = cpu.user / 1_000;
-  const systemCpuMs = cpu.system / 1_000;
-  const cpuMs = userCpuMs + systemCpuMs;
-  const delta = name =>
-    Math.max(
-      0,
-      Number(resources[name] || 0) - Number(snapshot.resources[name] || 0)
-    );
-  const linuxDelta = name =>
-    snapshot.linuxIo && linuxIo
-      ? Math.max(
-          0,
-          Number(linuxIo[name] || 0) - Number(snapshot.linuxIo[name] || 0)
-        )
-      : undefined;
-  return {
-    durationMs: Number(wallMs.toFixed(3)),
-    userCpuMs: Number(userCpuMs.toFixed(3)),
-    systemCpuMs: Number(systemCpuMs.toFixed(3)),
-    cpuMs: Number(cpuMs.toFixed(3)),
-    unaccountedWallMs: Number(Math.max(0, wallMs - cpuMs).toFixed(3)),
-    cpuToWallRatio: Number((wallMs > 0 ? cpuMs / wallMs : 0).toFixed(3)),
-    fsReadOperations: delta('fsRead'),
-    minorPageFaults: delta('minorPageFault'),
-    majorPageFaults: delta('majorPageFault'),
-    voluntaryContextSwitches: delta('voluntaryContextSwitches'),
-    involuntaryContextSwitches: delta('involuntaryContextSwitches'),
-    ...(linuxIo && snapshot.linuxIo
-      ? {
-          linuxReadChars: linuxDelta('rchar'),
-          linuxReadSyscalls: linuxDelta('syscr'),
-          linuxStorageReadBytes: linuxDelta('read_bytes'),
-        }
-      : {}),
-  };
-}
-
-function dependencyCacheMetadataState() {
-  const metadataFile = path.join(cacheDir, 'deps', '_metadata.json');
-  try {
-    const source = fs.readFileSync(metadataFile);
-    const stat = fs.statSync(metadataFile);
-    const metadata = JSON.parse(source.toString('utf8'));
-    return {
-      exists: true,
-      sizeBytes: source.byteLength,
-      mtimeMs: Number(stat.mtimeMs.toFixed(3)),
-      sha256: createHash('sha256').update(source).digest('hex'),
-      optimizedDependencies: Object.keys(metadata.optimized || {}).length,
-      optimizedChunks: Object.keys(metadata.chunks || {}).length,
-    };
-  } catch {
-    return { exists: false };
-  }
-}
-
-let stableProxy;
-let cacheBackend;
-let activeBackend;
-let freshRuntimeChild;
-let freshRuntimeRetryTimer;
-let freshRuntimeRetryDelayMs = 1_000;
-let dependencyReadyPoller;
-let webSocketCutoverBackend;
-const proxyUpgradeConnections = new Set();
-const stableRuntimeId = `vite-cache-${process.pid}`;
-
-function targetForRequest() {
-  return activeBackend ?? cacheBackend;
-}
-
-function proxyHttpRequest(request, response) {
-  if (request.url?.split('?', 1)[0] === '/dev/cache-runtime') {
-    response.statusCode = 200;
-    response.setHeader('content-type', 'application/json; charset=utf-8');
-    response.setHeader('cache-control', 'no-store');
-    response.end(
-      JSON.stringify({
-        mode: projectDependenciesReady() ? 'dependencies-ready' : 'cache-only',
-        serverId: stableRuntimeId,
-        pid: process.pid,
-        runtimeAbiHash: appRuntimeManifest.runtimeAbiHash,
-        cacheDir,
-        activeRuntime: activeBackend?.kind ?? 'cache',
-        dependencySource:
-          activeBackend?.kind === 'fresh'
-            ? 'project-node-modules'
-            : 'generation-vite-cache',
-      })
-    );
-    return;
-  }
-  const target = targetForRequest(request.url);
-  if (!target) {
-    response.statusCode = 503;
-    response.end('Vite runtime is starting');
-    return;
-  }
-  const upstream = http.request(
-    {
-      host: '127.0.0.1',
-      port: target.port,
-      method: request.method,
-      path: request.url,
-      headers: request.headers,
-    },
-    upstreamResponse => {
-      const responseHeaders = {
-        ...upstreamResponse.headers,
-        'x-miaoda-vite-runtime': target.kind,
-      };
-      response.writeHead(
-        upstreamResponse.statusCode ?? 502,
-        upstreamResponse.statusMessage,
-        responseHeaders
-      );
-      upstreamResponse.pipe(response);
-    }
-  );
-  upstream.once('error', error => {
-    if (!response.headersSent) response.writeHead(502);
-    response.end(`Vite upstream unavailable: ${error.code || error.message}`);
-  });
-  request.pipe(upstream);
-}
-
-function webSocketUpgradeRequest(request, target) {
-  let upstreamUrl = request.url;
-  if (target.webSocketToken) {
-    const parsedUrl = new URL(request.url || '/', 'http://localhost');
-    if (parsedUrl.searchParams.has('token')) {
-      parsedUrl.searchParams.set('token', target.webSocketToken);
-    }
-    upstreamUrl = `${parsedUrl.pathname}${parsedUrl.search}`;
-  }
-  const headers = request.rawHeaders
-    .reduce((lines, value, index) => {
-      if (index % 2 === 0) lines.push(`${value}: `);
-      else lines[lines.length - 1] += `${value}\r\n`;
-      return lines;
-    }, [])
-    .join('');
-  return `${request.method} ${upstreamUrl} HTTP/${request.httpVersion}\r\n${headers}\r\n`;
-}
-
-function cleanupWebSocketConnection(connection) {
-  if (connection.closed) return;
-  connection.closed = true;
-  proxyUpgradeConnections.delete(connection);
-  connection.socket.unpipe();
-  connection.upstream?.unpipe();
-  connection.upstream?.destroy();
-}
-
-async function replaceWebSocketBackend(
-  connection,
-  target,
-  { forwardHandshake = false, initialHead = Buffer.alloc(0) } = {}
-) {
-  if (connection.closed || connection.socket.destroyed) {
-    throw new Error('MIAODA_VITE_HMR_CLIENT_CLOSED');
-  }
-  if (connection.replacement) await connection.replacement;
-  if (
-    connection.backendKind === target.kind &&
-    connection.upstream &&
-    !connection.upstream.destroyed
-  ) {
-    return;
-  }
-
-  const replacement = new Promise((resolve, reject) => {
-    const client = connection.socket;
-    const previousUpstream = connection.upstream;
-    client.pause();
-    client.unpipe(previousUpstream);
-    previousUpstream?.unpipe(client);
-    connection.upstream = undefined;
-    previousUpstream?.destroy();
-
-    const upstream = net.connect(target.port, '127.0.0.1');
-    let handshake = Buffer.alloc(0);
-    let settled = false;
-    const fail = error => {
-      if (settled) return;
-      settled = true;
-      upstream.destroy();
-      client.resume();
-      reject(error);
-    };
-    const onHandshakeData = chunk => {
-      handshake = Buffer.concat([handshake, chunk]);
-      if (handshake.length > 64 * 1024) {
-        fail(new Error('MIAODA_VITE_HMR_UPSTREAM_HANDSHAKE_TOO_LARGE'));
-        return;
-      }
-      const headerEnd = handshake.indexOf('\r\n\r\n');
-      if (headerEnd < 0) return;
-      const responseHead = handshake.subarray(0, headerEnd + 4);
-      if (!/^HTTP\/1\.[01] 101\b/.test(responseHead.toString('latin1'))) {
-        fail(new Error('MIAODA_VITE_HMR_UPSTREAM_HANDSHAKE_REJECTED'));
-        return;
-      }
-      settled = true;
-      upstream.off('data', onHandshakeData);
-      connection.upstream = upstream;
-      connection.backendKind = target.kind;
-      if (forwardHandshake) client.write(responseHead);
-      const remaining = handshake.subarray(headerEnd + 4);
-      if (remaining.length > 0) client.write(remaining);
-      client.pipe(upstream, { end: false });
-      upstream.pipe(client, { end: false });
-      client.resume();
-      const recover = () => {
-        if (closing || connection.closed || connection.upstream !== upstream) {
-          return;
-        }
-        connection.upstream = undefined;
-        client.unpipe(upstream);
-        upstream.unpipe(client);
-        const fallback =
-          target.kind === 'fresh'
-            ? cacheBackend
-            : (webSocketCutoverBackend ?? activeBackend);
-        if (!fallback || fallback.kind === target.kind) {
-          client.destroy();
-          return;
-        }
-        void replaceWebSocketBackend(connection, fallback).catch(() =>
-          client.destroy()
-        );
-      };
-      upstream.once('error', recover);
-      upstream.once('close', recover);
-      resolve();
-    };
-    upstream.once('error', fail);
-    upstream.once('connect', () => {
-      upstream.write(webSocketUpgradeRequest(connection.request, target));
-      if (initialHead.length > 0) upstream.write(initialHead);
-      upstream.on('data', onHandshakeData);
-    });
-  });
-  connection.replacement = replacement;
-  try {
-    await replacement;
-  } finally {
-    if (connection.replacement === replacement) {
-      connection.replacement = undefined;
-    }
-  }
-}
-
-async function migrateWebSocketConnections(target) {
-  const migrated = [];
-  try {
-    for (const connection of [...proxyUpgradeConnections]) {
-      if (connection.closed) continue;
-      await replaceWebSocketBackend(connection, target);
-      migrated.push(connection);
-    }
-  } catch (error) {
-    if (target.kind !== 'cache' && cacheBackend) {
-      await Promise.allSettled(
-        migrated.map(connection =>
-          replaceWebSocketBackend(connection, cacheBackend)
-        )
-      );
-    }
-    throw error;
-  }
-}
-
-function proxyWebSocketUpgrade(request, socket, head) {
-  const target = webSocketCutoverBackend ?? targetForRequest(request.url);
-  if (!target) {
-    socket.destroy();
-    return;
-  }
-  const connection = {
-    request,
-    socket,
-    upstream: undefined,
-    backendKind: undefined,
-    replacement: undefined,
-    closed: false,
-  };
-  proxyUpgradeConnections.add(connection);
-  socket.once('close', () => cleanupWebSocketConnection(connection));
-  socket.once('error', () => cleanupWebSocketConnection(connection));
-  void replaceWebSocketBackend(connection, target, {
-    forwardHandshake: true,
-    initialHead: head,
-  }).catch(() => socket.destroy());
-}
-
-async function startStableProxy(port, host) {
-  stableProxy = http.createServer(proxyHttpRequest);
-  stableProxy.on('upgrade', proxyWebSocketUpgrade);
-  await new Promise((resolve, reject) => {
-    stableProxy.once('error', reject);
-    stableProxy.listen(port, host, () => {
-      stableProxy.off('error', reject);
-      resolve();
-    });
-  });
-}
-
-async function closeStableProxy() {
-  if (!stableProxy) return;
-  const proxy = stableProxy;
-  stableProxy = undefined;
-  for (const connection of proxyUpgradeConnections) {
-    connection.socket.destroy();
-    cleanupWebSocketConnection(connection);
-  }
-  proxy.closeIdleConnections?.();
-  proxy.closeAllConnections?.();
-  let timeout;
-  try {
-    await Promise.race([
-      new Promise(resolve => proxy.close(() => resolve())),
-      new Promise(resolve => {
-        timeout = setTimeout(resolve, closeTimeoutMs);
-      }),
-    ]);
-  } finally {
-    if (timeout) clearTimeout(timeout);
-  }
-}
-
-function publishServingReadyMarker(file) {
-  fs.mkdirSync(path.dirname(file), { recursive: true });
-  const temporaryFile = `${file}.${process.pid}.tmp`;
-  fs.writeFileSync(
-    temporaryFile,
-    `${JSON.stringify({ schemaVersion: 1, readyAt: new Date().toISOString() })}\n`,
-    { mode: 0o600 }
-  );
-  fs.renameSync(temporaryFile, file);
-}
-if (!prepareCache) {
-  fs.rmSync(servingReadyMarker, { force: true });
-  process.once('exit', () => {
-    try {
-      fs.rmSync(servingReadyMarker, { force: true });
-    } catch {}
-  });
-}
-if (
-  !Number.isSafeInteger(closeTimeoutMs) ||
-  closeTimeoutMs < 100 ||
-  closeTimeoutMs > 30_000
-) {
-  throw new Error('MIAODA_VITE_CACHE_CLOSE_TIMEOUT_INVALID');
-}
-process.env.NODE_ENV ||= 'development';
-
-let validatedGeneration;
-if (!prepareCache) {
-  const validationStartedAt = process.hrtime.bigint();
-  let validatedBy = 'full-sha';
-  let validationReceiptMiss;
-  const validationReceiptFile =
-    process.env.MIAODA_CACHE_VALIDATION_RECEIPT_FILE;
-  if (validationReceiptFile) {
-    try {
-      validatedGeneration = validateCacheGenerationReceipt({
-        projectRoot,
-        cacheRoot,
-        runtimeManifestFile,
-        receiptFile: validationReceiptFile,
-        artifactScope: 'vite',
-      });
-      validatedBy = 'platform-receipt';
-    } catch (error) {
-      validationReceiptMiss = String(
-        error instanceof Error ? error.message : error
-      ).split(':')[0];
-    }
-  }
-  if (!validatedGeneration) {
-    validatedGeneration = validateCacheGeneration({
-      projectRoot,
-      cacheRoot,
-      runtimeManifestFile,
-      artifactScope: 'vite',
-    });
-  }
-  if (
-    !process.env.MIAODA_CACHE_ROOT &&
-    path.basename(cacheRoot) !== validatedGeneration.generation.generationId
-  ) {
-    throw new Error('MIAODA_CACHE_GENERATION_POINTER_ID_MISMATCH');
-  }
-  if (
-    validatedGeneration.artifacts.appRuntime !==
-    fs.realpathSync(appManifestFile)
-  ) {
-    throw new Error('MIAODA_CACHE_APP_MANIFEST_PATH_MISMATCH');
-  }
-  if (
-    path.dirname(validatedGeneration.artifacts.viteMetadata) !==
-    path.join(fs.realpathSync(sealedCacheDir), 'deps')
-  ) {
-    throw new Error('MIAODA_CACHE_VITE_METADATA_PATH_MISMATCH');
-  }
-  emitRuntimePhase('generation_validation', validationStartedAt, {
-    artifactScope: 'vite',
-    validatedBy,
-    ...(validationReceiptMiss ? { validationReceiptMiss } : {}),
-  });
-}
-
-function resolveRuntimeCacheDir() {
-  if (prepareCache) return sealedCacheDir;
-  // The active server must not read from the sealed generation directly. A
-  // dependency restore may atomically publish a refreshed generation while
-  // this process keeps serving the already-rendered page without a handoff.
-  const runtimeCacheBase = path.resolve(projectRoot, '.miaoda-runtime', 'vite');
-  const runtimeCacheDir = path.resolve(
-    process.env.MIAODA_VITE_RUNTIME_CACHE_DIR ||
-      path.join(runtimeCacheBase, validatedGeneration.generation.generationId)
-  );
-  if (path.dirname(runtimeCacheDir) !== runtimeCacheBase) {
-    throw new Error(
-      `MIAODA_VITE_RUNTIME_CACHE_PATH_REJECTED: ${runtimeCacheDir}`
-    );
-  }
-  const runtimeParent = path.dirname(runtimeCacheBase);
-  for (const directory of [runtimeParent, runtimeCacheBase]) {
-    if (fs.existsSync(directory) && fs.lstatSync(directory).isSymbolicLink()) {
-      throw new Error(
-        `MIAODA_VITE_RUNTIME_CACHE_SYMLINK_REJECTED: ${directory}`
-      );
-    }
-    fs.mkdirSync(directory, { recursive: true });
-  }
-  const realProjectRoot = fs.realpathSync(projectRoot);
-  const realRuntimeCacheBase = fs.realpathSync(runtimeCacheBase);
-  if (!realRuntimeCacheBase.startsWith(`${realProjectRoot}${path.sep}`)) {
-    throw new Error(
-      `MIAODA_VITE_RUNTIME_CACHE_PATH_REJECTED: ${runtimeCacheBase}`
-    );
-  }
-  if (
-    fs.existsSync(runtimeCacheDir) &&
-    fs.lstatSync(runtimeCacheDir).isSymbolicLink()
-  ) {
-    throw new Error(
-      `MIAODA_VITE_RUNTIME_CACHE_SYMLINK_REJECTED: ${runtimeCacheDir}`
-    );
-  }
-  return runtimeCacheDir;
-}
-
-async function selectRuntimeCacheStrategy(runtimeCacheDir) {
-  if (prepareCache) {
-    return {
-      cacheDir: sealedCacheDir,
-      strategy: 'sealed-prepare',
-      ordinaryCopy: false,
-    };
-  }
-  // Never fall back to an ordinary copy: walking and copying thousands of Vite
-  // cache files is slower than loading Vite itself. Prefer an exact reflink
-  // clone when the workspace filesystem supports copy-on-write; otherwise use
-  // the generation restored for this sandbox directly. The recycle producer
-  // validates/rebuilds the generation before it is archived for the next
-  // sandbox, so runtime changes cannot be silently published as a valid cache.
-  const probeSource = path.join(sealedCacheDir, 'deps', '_metadata.json');
-  const probeTarget = path.join(
-    path.dirname(runtimeCacheDir),
-    `.reflink-probe-${process.pid}-${Date.now()}`
-  );
-  const directResult = reason => ({
-    cacheDir: sealedCacheDir,
-    strategy: 'direct',
-    ordinaryCopy: false,
-    reflinkFallbackReason: reason,
-  });
-  try {
-    await fs.promises.copyFile(
-      probeSource,
-      probeTarget,
-      fs.constants.COPYFILE_FICLONE_FORCE
-    );
-  } catch (error) {
-    return directResult(error?.code || 'REFLINK_PROBE_FAILED');
-  } finally {
-    await fs.promises.rm(probeTarget, { force: true }).catch(() => undefined);
-  }
-
-  return {
-    cacheDir: runtimeCacheDir,
-    strategy: 'reflink',
-    ordinaryCopy: false,
-  };
-}
-
-async function materializeRuntimeCache(selection) {
-  if (selection.strategy !== 'reflink') {
-    return {
-      ...selection,
-      completedAt: process.hrtime.bigint(),
-    };
-  }
-
-  await fs.promises.rm(selection.cacheDir, {
-    recursive: true,
-    force: true,
-    maxRetries: 2,
-  });
-  // The probe already proved that this filesystem supports reflinks. Force
-  // copy-on-write for every regular file; an unexpected clone failure rejects
-  // the cache candidate instead of silently performing an ordinary copy.
-  await fs.promises.cp(sealedCacheDir, selection.cacheDir, {
-    recursive: true,
-    force: false,
-    errorOnExist: true,
-    preserveTimestamps: true,
-    mode: fs.constants.COPYFILE_FICLONE_FORCE,
-  });
-  return {
-    ...selection,
-    completedAt: process.hrtime.bigint(),
-  };
-}
-
-const runtimeCacheCandidateDir = resolveRuntimeCacheDir();
-const runtimeCacheSelection = await selectRuntimeCacheStrategy(
-  runtimeCacheCandidateDir
-);
-cacheDir = runtimeCacheSelection.cacheDir;
-// Config loaders bypass Vite hooks, so expose exactly the immutable image
-// runtime. Never inherit NODE_PATH: it may point back at Workspace node_modules
-// and would invalidate the node_modules-free contract.
-process.env.NODE_PATH = path.join(platformRuntimeRoot, 'node_modules');
-// PostCSS/Tailwind config files execute through Node's CJS loader and bypass
-// Vite resolveId hooks. Point that loader only at the image-owned runtime.
-Module._initPaths();
-
-async function waitForPreparedCache() {
-  const metadataFile = path.join(cacheDir, 'deps', '_metadata.json');
-  const deadline = Date.now() + prepareTimeoutMs;
-  while (Date.now() < deadline) {
-    try {
-      const metadata = JSON.parse(fs.readFileSync(metadataFile, 'utf8'));
-      return {
-        metadataFile,
-        optimizedDependencies: Object.keys(metadata.optimized || {}).length,
-      };
-    } catch {
-      await new Promise(resolve => setTimeout(resolve, 100));
-    }
-  }
-  throw new Error(
-    `MIAODA_VITE_CACHE_PREPARE_TIMEOUT: ${metadataFile} was not committed within ${prepareTimeoutMs}ms`
-  );
-}
-
-for (const requiredPath of [
-  platformRuntimeRoot,
-  runtimeManifestFile,
-  appManifestFile,
-]) {
-  if (!fs.existsSync(requiredPath)) {
-    throw new Error(`MIAODA_CACHE_BOOTSTRAP_INPUT_MISSING: ${requiredPath}`);
-  }
-}
-const realPlatformRuntimeRoot = fs.realpathSync(platformRuntimeRoot);
-const platformRuntimeManifest = JSON.parse(
-  fs.readFileSync(runtimeManifestFile, 'utf8')
-);
-const vitePatch = platformRuntimeManifest.viteDependencyHashPatch;
-const vitePatchTarget = path.resolve(
-  realPlatformRuntimeRoot,
-  String(vitePatch?.target || '')
-);
-if (
-  vitePatch?.schemaVersion !== 1 ||
-  vitePatch?.patchId !== 'vite-8.1.5-cache-runtime-identity-v4' ||
-  !/^[a-f0-9]{64}$/.test(vitePatch?.targetSha256 || '') ||
-  !vitePatchTarget.startsWith(`${realPlatformRuntimeRoot}${path.sep}`) ||
-  !fs.existsSync(vitePatchTarget) ||
-  fs.lstatSync(vitePatchTarget).isSymbolicLink() ||
-  createHash('sha256')
-    .update(fs.readFileSync(vitePatchTarget))
-    .digest('hex') !== vitePatch.targetSha256
-) {
-  throw new Error('MIAODA_RUNTIME_VITE_PATCH_INVALID');
-}
-// The image launcher intentionally does not need to export this optional
-// override when it uses the default root. Vite's patched config bundler runs
-// later in this same process and must still receive the canonical trust root
-// used to validate the finite image-owned package alias map.
-process.env.MIAODA_PLATFORM_RUNTIME_ROOT = realPlatformRuntimeRoot;
-
-const runtimeRequire = createRequire(
-  path.join(platformRuntimeRoot, 'package.json')
-);
-const appRuntimeManifest = JSON.parse(fs.readFileSync(appManifestFile, 'utf8'));
-if (
-  !/^[a-f0-9]{64}$/.test(appRuntimeManifest.clientDependencyGraphHash || '')
-) {
-  throw new Error('MIAODA_CLIENT_DEPENDENCY_GRAPH_INVALID');
-}
-const supportedVitePresets = new Set([
-  '@lark-apaas/fullstack-vite-preset',
-  '@lark-apaas/coding-vite-preset',
-  '@lark-apaas/coding-preset-vite-react',
-]);
-const activeVitePreset =
-  appRuntimeManifest.vitePreset || '@lark-apaas/fullstack-vite-preset';
-if (!supportedVitePresets.has(activeVitePreset)) {
-  throw new Error(
-    `MIAODA_VITE_PRESET_UNSUPPORTED: ${String(activeVitePreset)}`
-  );
-}
-
-function projectDependenciesReady() {
-  if (prepareCache || !validatedGeneration?.generation?.generationId) {
-    return false;
-  }
-  try {
-    const markerStat = fs.lstatSync(dependencyReadyFile);
-    if (!markerStat.isFile() || markerStat.isSymbolicLink()) return false;
-    const marker = JSON.parse(fs.readFileSync(dependencyReadyFile, 'utf8'));
-    if (marker.generationId !== validatedGeneration.generation.generationId) {
-      return false;
-    }
-    const projectNodeModules = fs.realpathSync(
-      path.join(projectRoot, 'node_modules')
-    );
-    const resolvedProjectVite = fs.realpathSync(
-      createRequire(path.join(projectRoot, 'package.json')).resolve('vite')
-    );
-    const viteRelativePath = path.relative(
-      projectNodeModules,
-      resolvedProjectVite
-    );
-    if (
-      !viteRelativePath ||
-      viteRelativePath === '..' ||
-      viteRelativePath.startsWith(`..${path.sep}`) ||
-      path.isAbsolute(viteRelativePath)
-    ) {
-      return false;
-    }
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function scheduleFreshRuntimeRetry() {
-  if (
-    closing ||
-    prepareCache ||
-    freshRuntimeChild ||
-    freshRuntimeRetryTimer ||
-    !projectDependenciesReady()
-  ) {
-    return;
-  }
-  const delayMs = freshRuntimeRetryDelayMs;
-  freshRuntimeRetryDelayMs = Math.min(freshRuntimeRetryDelayMs * 2, 30_000);
-  freshRuntimeRetryTimer = setTimeout(() => {
-    freshRuntimeRetryTimer = undefined;
-    startFreshRuntime();
-  }, delayMs);
-  freshRuntimeRetryTimer.unref();
-}
-
-function startFreshRuntime() {
-  if (
-    closing ||
-    prepareCache ||
-    freshRuntimeChild ||
-    !projectDependenciesReady()
-  ) {
-    return;
-  }
-  const startedAt = process.hrtime.bigint();
-  const childEnvironment = {
-    ...process.env,
-    NODE_PATH: '',
-    MIAODA_CACHE_BOOTSTRAP_ENABLED: 'false',
-    MIAODA_APP_RUNTIME_MANIFEST: appManifestFile,
-  };
-  delete childEnvironment.MIAODA_VITE_CACHE_PREPARE;
-  delete childEnvironment.MIAODA_VITE_CACHE_DIR;
-  delete childEnvironment.MIAODA_VITE_FORCE_REOPTIMIZE;
-  const child = spawn(
-    process.execPath,
-    [process.argv[1], '--fresh-runtime-child'],
-    {
-      cwd: projectRoot,
-      env: childEnvironment,
-      stdio: ['ignore', 'pipe', 'pipe', 'ipc'],
-    }
-  );
-  freshRuntimeChild = child;
-  let ready = false;
-  let cutover = false;
-  const childStartedAtMs = Date.now();
-  const timeout = setTimeout(() => {
-    if (!ready) child.kill('SIGTERM');
-  }, 30_000);
-  timeout.unref();
-  child.stdout?.on('data', chunk => process.stdout.write(chunk));
-  child.stderr?.on('data', chunk => process.stderr.write(chunk));
-  child.on('message', event => {
-    if (
-      ready ||
-      event?.event !== 'miaoda_vite_fresh_runtime_child_ready' ||
-      !Number.isSafeInteger(event.port) ||
-      event.port <= 0 ||
-      typeof event.webSocketToken !== 'string' ||
-      !event.webSocketToken
-    ) {
-      return;
-    }
-    ready = true;
-    clearTimeout(timeout);
-    const freshBackend = {
-      kind: 'fresh',
-      port: event.port,
-      pid: child.pid,
-      webSocketToken: event.webSocketToken,
-    };
-    webSocketCutoverBackend = freshBackend;
-    void migrateWebSocketConnections(freshBackend)
-      .then(() => {
-        if (
-          freshRuntimeChild !== child ||
-          child.exitCode !== null ||
-          child.signalCode !== null
-        ) {
-          throw new Error('MIAODA_VITE_FRESH_RUNTIME_EXITED_DURING_CUTOVER');
-        }
-        activeBackend = freshBackend;
-        webSocketCutoverBackend = undefined;
-        cutover = true;
-        emitRuntimePhase('fresh_cutover', startedAt, {
-          childPid: child.pid,
-          childPort: event.port,
-          migratedHmrConnections: proxyUpgradeConnections.size,
-          refresh: false,
-        });
-      })
-      .catch(async error => {
-        activeBackend = cacheBackend;
-        webSocketCutoverBackend = cacheBackend;
-        await migrateWebSocketConnections(cacheBackend).catch(() => undefined);
-        webSocketCutoverBackend = undefined;
-        process.stderr.write(
-          `${JSON.stringify({
-            event: 'miaoda_vite_fresh_cutover_failed',
-            message: error.message,
-          })}\n`
-        );
-        if (child.exitCode === null && child.signalCode === null) {
-          child.kill('SIGTERM');
-        }
-      });
-  });
-  child.once('error', error => {
-    process.stderr.write(
-      `${JSON.stringify({
-        event: 'miaoda_vite_fresh_runtime_error',
-        message: error.message,
-      })}\n`
-    );
-  });
-  child.once('exit', (code, signal) => {
-    clearTimeout(timeout);
-    if (freshRuntimeChild === child) freshRuntimeChild = undefined;
-    if (
-      activeBackend?.pid === child.pid ||
-      webSocketCutoverBackend?.pid === child.pid
-    ) {
-      activeBackend = cacheBackend;
-      webSocketCutoverBackend = cacheBackend;
-      void migrateWebSocketConnections(cacheBackend).finally(() => {
-        if (webSocketCutoverBackend === cacheBackend) {
-          webSocketCutoverBackend = undefined;
-        }
-      });
-    }
-    process.stdout.write(
-      `${JSON.stringify({
-        event: 'miaoda_vite_fresh_runtime_exited',
-        pid: child.pid,
-        code,
-        signal,
-        wasReady: ready,
-        cutover,
-      })}\n`
-    );
-    if (Date.now() - childStartedAtMs >= 60_000) {
-      freshRuntimeRetryDelayMs = 1_000;
-    }
-    scheduleFreshRuntimeRetry();
-  });
-}
-
-const normalizeProjectRelativePath = (value, fallback, name) => {
-  const relativePath = value || fallback;
-  if (
-    typeof relativePath !== 'string' ||
-    !relativePath ||
-    relativePath !== path.posix.normalize(relativePath) ||
-    relativePath === '..' ||
-    relativePath.startsWith('../') ||
-    path.posix.isAbsolute(relativePath) ||
-    relativePath.includes('\\')
-  ) {
-    throw new Error(`MIAODA_${name}_INVALID`);
-  }
-  return relativePath;
-};
-const clientRootRelative = normalizeProjectRelativePath(
-  appRuntimeManifest.clientRoot,
-  'client',
-  'CLIENT_ROOT'
-);
-const clientEntryRelative = normalizeProjectRelativePath(
-  appRuntimeManifest.clientEntry,
-  'client/src/index.tsx',
-  'CLIENT_ENTRY'
-);
-const clientRoot = path.resolve(projectRoot, clientRootRelative);
-const clientEntryFile = path.resolve(projectRoot, clientEntryRelative);
-for (const candidate of [clientRoot, clientEntryFile]) {
-  if (
-    candidate !== projectRoot &&
-    !candidate.startsWith(`${projectRoot}${path.sep}`)
-  ) {
-    throw new Error(`MIAODA_CLIENT_PATH_ESCAPE: ${candidate}`);
-  }
-}
-const runtimeConfigPackageNames = [
-  '@lark-apaas/fullstack-presets',
-  '@lark-apaas/fullstack-vite-preset',
-  '@lark-apaas/coding-vite-preset',
-  '@lark-apaas/coding-preset-vite-react',
-  'vite',
-  '@lark-apaas/vite-inspector-plugin',
-  '@vitejs/plugin-react',
-  'vite-tsconfig-paths',
-];
-const requiredRuntimeConfigPackageNames = new Set([
-  '@lark-apaas/fullstack-presets',
-  '@lark-apaas/fullstack-vite-preset',
-  activeVitePreset,
-  'vite',
-]);
-const runtimeConfigPackageAliases = Object.fromEntries(
-  runtimeConfigPackageNames.flatMap(packageName => {
-    let entry;
-    try {
-      entry = fs.realpathSync(runtimeRequire.resolve(packageName));
-    } catch (error) {
-      if (requiredRuntimeConfigPackageNames.has(packageName)) throw error;
-      return [];
-    }
-    const relative = path.relative(realPlatformRuntimeRoot, entry);
-    if (
-      relative === '..' ||
-      relative.startsWith(`..${path.sep}`) ||
-      path.isAbsolute(relative)
-    ) {
-      if (requiredRuntimeConfigPackageNames.has(packageName)) {
-        throw new Error(
-          `MIAODA_VITE_CONFIG_RUNTIME_PACKAGE_PATH_REJECTED: ${packageName}`
-        );
-      }
-      return [];
-    }
-    return [[packageName, entry]];
-  })
-);
-// Vite bundles vite.config before normal plugin resolution. Force the finite,
-// image-owned config toolchain there as well, otherwise producer startup with
-// restored node_modules and consumer startup without it can load different
-// preset versions and invalidate Vite's own optimizer metadata.
-process.env.MIAODA_VITE_CONFIG_PACKAGE_ALIASES = JSON.stringify(
-  runtimeConfigPackageAliases
-);
-if (prepareCache) {
-  const clientDependencyGraphModule = await import(
-    pathToFileURL(
-      path.join(fullstackCliRoot, 'dist', 'client-dependency-graph.js')
-    ).href
-  );
-  const buildClientDependencyGraph =
-    clientDependencyGraphModule.buildClientDependencyGraph ??
-    clientDependencyGraphModule.default?.buildClientDependencyGraph;
-  if (typeof buildClientDependencyGraph !== 'function') {
-    throw new Error(
-      'MIAODA_FULLSTACK_CLI_RUNTIME_EXPORT_MISSING: buildClientDependencyGraph'
-    );
-  }
-  const currentClientDependencyGraph = buildClientDependencyGraph({
-    projectRoot,
-    runtimeAbiHash: appRuntimeManifest.runtimeAbiHash,
-    includeAllProductionDependencies:
-      appRuntimeManifest.applicationKind === 'frontend-only',
-  });
-  if (
-    currentClientDependencyGraph.hash !==
-    appRuntimeManifest.clientDependencyGraphHash
-  ) {
-    throw new Error('MIAODA_CLIENT_DEPENDENCY_GRAPH_MISMATCH');
-  }
-}
-// A small, exact-version image patch replaces only Vite's coarse whole-lock
-// hash. Vite's native resolved-config hash, _metadata.json, optimized chunks
-// and CJS interop remain Vite-owned end to end.
-process.env.MIAODA_VITE_DEPENDENCY_GRAPH_HASH =
-  appRuntimeManifest.clientDependencyGraphHash;
-const dependencyAssetsRoot = path.join(cacheDir, 'dependency-assets');
-// Tailwind's Jiti loader bypasses Vite resolution when it evaluates
-// tailwind.config.*. Give the finite image adapter a sealed dependency source
-// root so its content globs never need Workspace node_modules.
-process.env.MIAODA_VITE_DEPENDENCY_ASSETS_ROOT = dependencyAssetsRoot;
-// Importing Vite is more than a filesystem warm-up: Node resolves, parses and
-// evaluates the module graph once, then keeps that exact graph in this process.
-// Finalize every cache-runtime value that a preset may capture at module scope
-// before starting the import. App configuration, plugins and sockets are still
-// created only at the original startup barrier below.
-process.env.MIAODA_CACHE_BOOTSTRAP_ENABLED = 'true';
-process.env.MIAODA_VITE_CACHE_DIR = cacheDir;
-process.env.MIAODA_VITE_FORCE_REOPTIMIZE = 'false';
-const materializeStartedAt = process.hrtime.bigint();
-const materializeRuntimeCachePromise = materializeRuntimeCache(
-  runtimeCacheSelection
-);
-const runtimeImportsStartedAt = process.hrtime.bigint();
-const runtimeImportsPromise = (async () => {
-  // The preset's CommonJS output imports Vite for mergeConfig. Keep these
-  // imports sequential even though the whole sequence now overlaps the
-  // remaining cache-runtime preparation.
-  const viteModule = await importRuntimeBootstrap('vite');
-  const presetModule = await importRuntimeBootstrap(activeVitePreset);
-  const resolverPresetModule =
-    activeVitePreset === '@lark-apaas/fullstack-vite-preset'
-      ? presetModule
-      : await importRuntimeBootstrap('@lark-apaas/fullstack-vite-preset');
-  return { viteModule, presetModule, resolverPresetModule };
-})().then(
-  value => ({
-    ok: true,
-    value,
-    completedAt: process.hrtime.bigint(),
-  }),
-  error => ({
-    ok: false,
-    error,
-    completedAt: process.hrtime.bigint(),
-  })
-);
-const runtimePreparationWaitStartedAt = process.hrtime.bigint();
-const [runtimeImportsResult, materializeResult] = await Promise.all([
-  runtimeImportsPromise,
-  materializeRuntimeCachePromise,
-]);
-const runtimePreparationWaitDurationMs = durationMs(
-  runtimePreparationWaitStartedAt
-);
-const runtimeImportsDurationMs =
-  Number(runtimeImportsResult.completedAt - runtimeImportsStartedAt) /
-  1_000_000;
-const materializeDurationMs =
-  Number(materializeResult.completedAt - materializeStartedAt) / 1_000_000;
-const runtimePreparationCompletedAt =
-  runtimeImportsResult.completedAt > materializeResult.completedAt
-    ? runtimeImportsResult.completedAt
-    : materializeResult.completedAt;
-const runtimePreparationDurationMs =
-  Number(runtimePreparationCompletedAt - materializeStartedAt) / 1_000_000;
-const overlapStartedAt =
-  runtimeImportsStartedAt > materializeStartedAt
-    ? runtimeImportsStartedAt
-    : materializeStartedAt;
-const overlapCompletedAt =
-  runtimeImportsResult.completedAt < materializeResult.completedAt
-    ? runtimeImportsResult.completedAt
-    : materializeResult.completedAt;
-const runtimePreparationOverlapDurationMs = Math.max(
-  0,
-  Number(overlapCompletedAt - overlapStartedAt) / 1_000_000
-);
-const materializedBeforeImportMs = Math.max(
-  0,
-  Number(
-    (materializeResult.completedAt < runtimeImportsStartedAt
-      ? materializeResult.completedAt
-      : runtimeImportsStartedAt) - materializeStartedAt
-  ) / 1_000_000
-);
-cacheDir = materializeResult.cacheDir;
-emitRuntimePhase('materialize_runtime_cache', materializeStartedAt, {
-  durationMs: Number(materializeDurationMs.toFixed(3)),
-  prepareCache,
-  parallelWithRuntimeImports: true,
-  strategy: materializeResult.strategy,
-  ordinaryCopy: materializeResult.ordinaryCopy,
-  ...(materializeResult.reflinkFallbackReason
-    ? { reflinkFallbackReason: materializeResult.reflinkFallbackReason }
-    : {}),
-});
-emitRuntimePhase('runtime_imports', runtimeImportsStartedAt, {
-  durationMs: Number(runtimeImportsDurationMs.toFixed(3)),
-  waitDurationMs: Number(runtimePreparationWaitDurationMs.toFixed(3)),
-  overlapDurationMs: Number(runtimePreparationOverlapDurationMs.toFixed(3)),
-  preloaded: true,
-});
-emitRuntimePhase('runtime_preparation_parallel', materializeStartedAt, {
-  durationMs: Number(runtimePreparationDurationMs.toFixed(3)),
-  waitDurationMs: Number(runtimePreparationWaitDurationMs.toFixed(3)),
-  serialDurationMs: Number(
-    (runtimeImportsDurationMs + materializeDurationMs).toFixed(3)
-  ),
-  overlappedDurationMs: Number(runtimePreparationOverlapDurationMs.toFixed(3)),
-  materializedBeforeImportMs: Number(materializedBeforeImportMs.toFixed(3)),
-});
-if (!runtimeImportsResult.ok) throw runtimeImportsResult.error;
-const { viteModule, presetModule, resolverPresetModule } =
-  runtimeImportsResult.value;
-const dependencyAssetsManifestFile = path.join(
-  dependencyAssetsRoot,
-  'manifest.json'
-);
-const emptyDependencyAssetsManifest = () => ({
-  schemaVersion: 3,
-  cssSpecifiers: {},
-  tailwindPluginSpecifiers: {},
-  sourcePackages: {},
-});
-let dependencyAssetsManifest = fs.existsSync(dependencyAssetsManifestFile)
-  ? JSON.parse(fs.readFileSync(dependencyAssetsManifestFile, 'utf8'))
-  : emptyDependencyAssetsManifest();
-if (dependencyAssetsManifest.schemaVersion !== 3) {
-  throw new Error('MIAODA_VITE_DEPENDENCY_ASSETS_SCHEMA_UNSUPPORTED');
-}
-if (prepareCache) {
-  fs.rmSync(dependencyAssetsRoot, { recursive: true, force: true });
-  fs.mkdirSync(dependencyAssetsRoot, { recursive: true });
-  dependencyAssetsManifest = emptyDependencyAssetsManifest();
-}
-
-const inlineTsconfigFile = path.join(cacheDir, 'tsconfig.raw.json');
-
-function writeJsonAtomic(file, value) {
-  fs.mkdirSync(path.dirname(file), { recursive: true });
-  const temporaryFile = `${file}.${process.pid}.tmp`;
-  fs.writeFileSync(temporaryFile, `${JSON.stringify(value, null, 2)}\n`);
-  fs.renameSync(temporaryFile, file);
-}
-
-function formatTypescriptDiagnostics(typescript, diagnostics) {
-  return diagnostics
-    .map(diagnostic => {
-      const message = typescript.flattenDiagnosticMessageText(
-        diagnostic.messageText,
-        '\n'
-      );
-      if (!diagnostic.file || diagnostic.start === undefined) return message;
-      const position = diagnostic.file.getLineAndCharacterOfPosition(
-        diagnostic.start
-      );
-      return `${diagnostic.file.fileName}:${position.line + 1}:${
-        position.character + 1
-      }: ${message}`;
-    })
-    .join('\n');
-}
-
-function normalizeInlineCompilerOptions(typescript, compilerOptions) {
-  const normalized = {};
-  const copyString = key => {
-    if (typeof compilerOptions[key] === 'string') {
-      normalized[key] = compilerOptions[key];
-    }
-  };
-  const copyBoolean = key => {
-    if (typeof compilerOptions[key] === 'boolean') {
-      normalized[key] = compilerOptions[key];
-    }
-  };
-  for (const key of ['jsxFactory', 'jsxFragmentFactory', 'jsxImportSource']) {
-    copyString(key);
-  }
-  for (const key of [
-    'experimentalDecorators',
-    'emitDecoratorMetadata',
-    'strict',
-    'strictNullChecks',
-    'verbatimModuleSyntax',
-    'useDefineForClassFields',
-    'preserveValueImports',
-  ]) {
-    copyBoolean(key);
-  }
-
-  const jsxName = typescript.JsxEmit[compilerOptions.jsx];
-  const jsxValues = {
-    React: 'react',
-    ReactJSX: 'react-jsx',
-    ReactJSXDev: 'react-jsxdev',
-    Preserve: 'preserve',
-    ReactNative: 'react-native',
-  };
-  if (jsxValues[jsxName]) normalized.jsx = jsxValues[jsxName];
-
-  const targetName = typescript.ScriptTarget[compilerOptions.target];
-  if (targetName) normalized.target = targetName.toLowerCase();
-
-  const importsName =
-    typescript.ImportsNotUsedAsValues?.[compilerOptions.importsNotUsedAsValues];
-  if (importsName)
-    normalized.importsNotUsedAsValues = importsName.toLowerCase();
-  return normalized;
-}
-
-function resolveInlineTsconfig() {
-  if (!prepareCache) {
-    if (!fs.existsSync(inlineTsconfigFile)) {
-      throw new Error(
-        `MIAODA_VITE_INLINE_TSCONFIG_MISSING: ${inlineTsconfigFile}`
-      );
-    }
-    const cached = JSON.parse(fs.readFileSync(inlineTsconfigFile, 'utf8'));
-    if (
-      cached.schemaVersion !== 1 ||
-      !cached.compilerOptions ||
-      typeof cached.compilerOptions !== 'object' ||
-      Array.isArray(cached.compilerOptions)
-    ) {
-      throw new Error('MIAODA_VITE_INLINE_TSCONFIG_INVALID');
-    }
-    return { compilerOptions: cached.compilerOptions };
-  }
-
-  const typescript = runtimeRequire('typescript');
-  const configFile = ['tsconfig.app.json', 'tsconfig.json']
-    .map(file => path.join(projectRoot, file))
-    .find(file => fs.existsSync(file));
-  let compilerOptions = {};
-  if (configFile) {
-    const readResult = typescript.readConfigFile(
-      configFile,
-      typescript.sys.readFile
-    );
-    if (readResult.error) {
-      throw new Error(
-        `MIAODA_VITE_TSCONFIG_RESOLVE_FAILED:\n${formatTypescriptDiagnostics(
-          typescript,
-          [readResult.error]
-        )}`
-      );
-    }
-    const parsed = typescript.parseJsonConfigFileContent(
-      readResult.config,
-      typescript.sys,
-      projectRoot,
-      undefined,
-      configFile
-    );
-    if (parsed.errors.length > 0) {
-      throw new Error(
-        `MIAODA_VITE_TSCONFIG_RESOLVE_FAILED:\n${formatTypescriptDiagnostics(
-          typescript,
-          parsed.errors
-        )}`
-      );
-    }
-    compilerOptions = normalizeInlineCompilerOptions(
-      typescript,
-      parsed.options
-    );
-  }
-  writeJsonAtomic(inlineTsconfigFile, {
-    schemaVersion: 1,
-    compilerOptions,
-  });
-  return { compilerOptions };
-}
-
-const inlineTsconfig = resolveInlineTsconfig();
-
-function isInside(parent, candidate) {
-  const relative = path.relative(path.resolve(parent), path.resolve(candidate));
-  return (
-    relative === '' ||
-    (relative !== '..' &&
-      !relative.startsWith(`..${path.sep}`) &&
-      !path.isAbsolute(relative))
-  );
-}
-
-function cssSpecifierCacheKey(specifier, basedir) {
-  const resolvedBasedir = path.resolve(basedir);
-  const realBasedir = fs.existsSync(resolvedBasedir)
-    ? fs.realpathSync(resolvedBasedir)
-    : resolvedBasedir;
-  let importerIdentity;
-  const cachedPackage = Object.entries(dependencyAssetsManifest.sourcePackages)
-    .map(([packagePath, relativeRoot]) => ({
-      packagePath,
-      packageRoot: path.resolve(cacheDir, relativeRoot),
-    }))
-    .filter(({ packageRoot }) => fs.existsSync(packageRoot))
-    .map(packageEntry => ({
-      ...packageEntry,
-      realPackageRoot: fs.realpathSync(packageEntry.packageRoot),
-    }))
-    .filter(({ realPackageRoot }) => isInside(realPackageRoot, realBasedir))
-    .sort(
-      (left, right) =>
-        right.realPackageRoot.length - left.realPackageRoot.length
-    )[0];
-  if (cachedPackage) {
-    importerIdentity = `package:${cachedPackage.packagePath}:${path
-      .relative(cachedPackage.realPackageRoot, realBasedir)
-      .split(path.sep)
-      .join('/')}`;
-  } else {
-    const installedPackage = [...clientGraphPackages.entries()]
-      .map(([packagePath, graphPackage]) => {
-        const packageRoot = path.resolve(projectRoot, packagePath);
-        if (!fs.existsSync(packageRoot)) return undefined;
-        const realPackageRoot = fs.realpathSync(packageRoot);
-        if (!isInside(realPackageRoot, realBasedir)) return undefined;
-        const packageJson = JSON.parse(
-          fs.readFileSync(path.join(realPackageRoot, 'package.json'), 'utf8')
-        );
-        const packageName = packageNameFromNodeModulesRoot(
-          path.join(projectRoot, 'node_modules'),
-          packageRoot
-        );
-        if (
-          !packageName ||
-          packageJson.name !== packageName ||
-          packageJson.version !== graphPackage.version
-        ) {
-          throw new Error(
-            `MIAODA_VITE_DEPENDENCY_PACKAGE_IDENTITY_REJECTED: ${packageRoot}`
-          );
-        }
-        return { packagePath, realPackageRoot };
-      })
-      .filter(Boolean)
-      .sort(
-        (left, right) =>
-          right.realPackageRoot.length - left.realPackageRoot.length
-      )[0];
-    if (installedPackage) {
-      importerIdentity = `package:${installedPackage.packagePath}:${path
-        .relative(installedPackage.realPackageRoot, realBasedir)
-        .split(path.sep)
-        .join('/')}`;
-    }
-  }
-  if (importerIdentity) {
-    return JSON.stringify([importerIdentity, specifier]);
-  }
-  const realCacheDir = fs.realpathSync(cacheDir);
-  const realProjectRoot = fs.realpathSync(projectRoot);
-  if (isInside(realCacheDir, realBasedir)) {
-    importerIdentity = `cache:${path
-      .relative(realCacheDir, realBasedir)
-      .split(path.sep)
-      .join('/')}`;
-  } else if (isInside(realProjectRoot, realBasedir)) {
-    importerIdentity = `project:${path
-      .relative(realProjectRoot, realBasedir)
-      .split(path.sep)
-      .join('/')}`;
-  } else {
-    throw new Error(
-      `MIAODA_VITE_CSS_IMPORTER_PATH_REJECTED: ${resolvedBasedir}`
-    );
-  }
-  return JSON.stringify([importerIdentity, specifier]);
-}
-
-function clientStyleUrls() {
-  const styleRoot = path.join(clientRoot, 'src');
-  if (!fs.existsSync(styleRoot)) return [];
-  const urls = [];
-  const visit = directory => {
-    for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
-      const absolute = path.join(directory, entry.name);
-      if (entry.isSymbolicLink()) continue;
-      if (entry.isDirectory()) {
-        visit(absolute);
-      } else if (entry.isFile() && /\.(?:css|pcss|postcss)$/.test(entry.name)) {
-        urls.push(
-          `/${path.relative(projectRoot, absolute).split(path.sep).join('/')}`
-        );
-      }
-    }
-  };
-  visit(styleRoot);
-  return urls.sort();
-}
-
-function withViteBase(base, urlPath) {
-  const basePath = new URL(base || '/', 'http://vite.local').pathname;
-  if (basePath === '/' || basePath === './') return urlPath;
-  return `${basePath.replace(/\/$/, '')}/${urlPath.replace(/^\//, '')}`;
-}
-
-function writeDependencyAssetsManifest() {
-  fs.mkdirSync(dependencyAssetsRoot, { recursive: true });
-  const temporaryFile = `${dependencyAssetsManifestFile}.${process.pid}.tmp`;
-  fs.writeFileSync(
-    temporaryFile,
-    `${JSON.stringify(dependencyAssetsManifest, null, 2)}\n`
-  );
-  fs.renameSync(temporaryFile, dependencyAssetsManifestFile);
-}
-
-function packageNameFromNodeModulesRoot(projectNodeModules, packageRoot) {
-  const relative = path.relative(projectNodeModules, packageRoot);
-  if (
-    !relative ||
-    relative === '..' ||
-    relative.startsWith(`..${path.sep}`) ||
-    path.isAbsolute(relative)
-  ) {
-    return undefined;
-  }
-  const segments = relative.split(path.sep);
-  const nestedIndex = segments.lastIndexOf('node_modules');
-  const packageSegments = segments.slice(nestedIndex + 1);
-  const expectedLength = packageSegments[0]?.startsWith('@') ? 2 : 1;
-  if (packageSegments.length !== expectedLength) return undefined;
-  const packageName = packageSegments.join('/');
-  return /^(?:@[a-z0-9][a-z0-9._~-]*\/)?[a-z0-9][a-z0-9._~-]*$/i.test(
-    packageName
-  )
-    ? packageName
-    : undefined;
-}
-
-function canonicalPackagePath(projectNodeModules, packageRoot) {
-  const relative = path.relative(projectNodeModules, packageRoot);
-  if (
-    !relative ||
-    relative === '..' ||
-    relative.startsWith(`..${path.sep}`) ||
-    path.isAbsolute(relative)
-  ) {
-    return undefined;
-  }
-  const packagePath = `node_modules/${relative.split(path.sep).join('/')}`;
-  return packagePath === path.posix.normalize(packagePath) &&
-    !packagePath.includes('\\')
-    ? packagePath
-    : undefined;
-}
-
-const clientGraphPackages = new Map();
-for (const graphPackage of appRuntimeManifest.clientDependencyGraph.packages) {
-  if (
-    typeof graphPackage?.path !== 'string' ||
-    graphPackage.path !== path.posix.normalize(graphPackage.path) ||
-    !graphPackage.path.startsWith('node_modules/') ||
-    graphPackage.path.includes('\\') ||
-    clientGraphPackages.has(graphPackage.path)
-  ) {
-    throw new Error('MIAODA_CLIENT_DEPENDENCY_GRAPH_PACKAGE_PATH_INVALID');
-  }
-  clientGraphPackages.set(graphPackage.path, graphPackage);
-}
-
-function findProjectPackage(resolvedFile) {
-  const projectNodeModules = fs.realpathSync(
-    path.join(projectRoot, 'node_modules')
-  );
-  let current = path.dirname(fs.realpathSync(resolvedFile));
-  while (isInside(projectNodeModules, current)) {
-    const packageJsonFile = path.join(current, 'package.json');
-    if (fs.existsSync(packageJsonFile)) {
-      const packageJson = JSON.parse(fs.readFileSync(packageJsonFile, 'utf8'));
-      const expectedPackageName = packageNameFromNodeModulesRoot(
-        projectNodeModules,
-        current
-      );
-      const packagePath = canonicalPackagePath(projectNodeModules, current);
-      const graphPackage = packagePath
-        ? clientGraphPackages.get(packagePath)
-        : undefined;
-      if (
-        expectedPackageName &&
-        packageJson.name === expectedPackageName &&
-        packageJson.version === graphPackage?.version &&
-        packagePath &&
-        isInside(fs.realpathSync(projectNodeModules), fs.realpathSync(current))
-      ) {
-        return {
-          packageName: expectedPackageName,
-          packagePath,
-          packageRoot: current,
-        };
-      }
-      throw new Error(
-        `MIAODA_VITE_DEPENDENCY_PACKAGE_IDENTITY_REJECTED: ${current}`
-      );
-    }
-    const parent = path.dirname(current);
-    if (parent === current) break;
-    current = parent;
-  }
-  throw new Error(
-    `MIAODA_VITE_DEPENDENCY_ASSET_OUTSIDE_PROJECT: ${resolvedFile}`
-  );
-}
-
-function snapshotProjectPackage(packageName, packagePath, packageRoot) {
-  if (!prepareCache) {
-    const relativeRoot = dependencyAssetsManifest.sourcePackages[packagePath];
-    if (!relativeRoot) {
-      throw new Error(`MIAODA_VITE_DEPENDENCY_ASSET_MISSING: ${packagePath}`);
-    }
-    const cachedRoot = path.resolve(cacheDir, relativeRoot);
-    if (
-      !isInside(cacheDir, cachedRoot) ||
-      !fs.existsSync(cachedRoot) ||
-      !isInside(fs.realpathSync(cacheDir), fs.realpathSync(cachedRoot))
-    ) {
-      throw new Error(
-        `MIAODA_VITE_DEPENDENCY_ASSET_PATH_REJECTED: ${packagePath}`
-      );
-    }
-    return cachedRoot;
-  }
-  const destination = path.resolve(
-    dependencyAssetsRoot,
-    ...packagePath.split('/')
-  );
-  if (!isInside(dependencyAssetsRoot, destination)) {
-    throw new Error(
-      `MIAODA_VITE_DEPENDENCY_ASSET_PATH_REJECTED: ${packagePath}`
-    );
-  }
-  if (!fs.existsSync(destination)) {
-    fs.mkdirSync(path.dirname(destination), { recursive: true });
-    fs.cpSync(packageRoot, destination, {
-      recursive: true,
-      errorOnExist: true,
-      force: false,
-      preserveTimestamps: true,
-      filter(source) {
-        if (fs.lstatSync(source).isSymbolicLink()) {
-          throw new Error(
-            `MIAODA_VITE_DEPENDENCY_ASSET_SYMLINK_REJECTED: ${source}`
-          );
-        }
-        return true;
-      },
-    });
-  }
-  dependencyAssetsManifest.sourcePackages[packagePath] = path.relative(
-    cacheDir,
-    destination
-  );
-  writeDependencyAssetsManifest();
-  return destination;
-}
-
-const snapshottedClientPackageClosures = new Set();
-
-function snapshotClientPackageClosure(packagePath) {
-  const graphPackage = clientGraphPackages.get(packagePath);
-  if (!graphPackage) {
-    throw new Error(
-      `MIAODA_VITE_DEPENDENCY_GRAPH_PACKAGE_MISSING: ${packagePath}`
-    );
-  }
-  if (!prepareCache) {
-    const packageName = packageNameFromNodeModulesRoot(
-      path.join(projectRoot, 'node_modules'),
-      path.join(projectRoot, ...packagePath.split('/'))
-    );
-    if (!packageName) {
-      throw new Error(
-        `MIAODA_VITE_DEPENDENCY_PACKAGE_IDENTITY_REJECTED: ${packagePath}`
-      );
-    }
-    return snapshotProjectPackage(packageName, packagePath, undefined);
-  }
-
-  const packageRoot = path.join(projectRoot, ...packagePath.split('/'));
-  const identity = findProjectPackage(path.join(packageRoot, 'package.json'));
-  const cachedRoot = snapshotProjectPackage(
-    identity.packageName,
-    identity.packagePath,
-    identity.packageRoot
-  );
-  if (snapshottedClientPackageClosures.has(packagePath)) return cachedRoot;
-  snapshottedClientPackageClosures.add(packagePath);
-  for (const dependencyPath of Object.values(graphPackage.edges).sort()) {
-    snapshotClientPackageClosure(dependencyPath);
-  }
-  return cachedRoot;
-}
-
-function snapshotResolvedProjectFile(resolvedFile) {
-  const { packageName, packagePath, packageRoot } =
-    findProjectPackage(resolvedFile);
-  const cachedPackageRoot = snapshotProjectPackage(
-    packageName,
-    packagePath,
-    packageRoot
-  );
-  return {
-    packageName,
-    cachedFile: path.join(
-      cachedPackageRoot,
-      path.relative(packageRoot, resolvedFile)
-    ),
-  };
-}
-
-function originalProjectBasedir(basedir) {
-  const resolvedBasedir = path.resolve(basedir);
-  const realBasedir = fs.existsSync(resolvedBasedir)
-    ? fs.realpathSync(resolvedBasedir)
-    : resolvedBasedir;
-  const cachedPackage = Object.entries(dependencyAssetsManifest.sourcePackages)
-    .map(([packagePath, relativeRoot]) => ({
-      packagePath,
-      packageRoot: path.resolve(cacheDir, relativeRoot),
-    }))
-    .filter(({ packageRoot }) => fs.existsSync(packageRoot))
-    .map(packageEntry => ({
-      ...packageEntry,
-      realPackageRoot: fs.realpathSync(packageEntry.packageRoot),
-    }))
-    .filter(({ realPackageRoot }) => isInside(realPackageRoot, realBasedir))
-    .sort(
-      (left, right) =>
-        right.realPackageRoot.length - left.realPackageRoot.length
-    )[0];
-  if (!cachedPackage) return resolvedBasedir;
-  return path.join(
-    projectRoot,
-    ...cachedPackage.packagePath.split('/'),
-    path.relative(cachedPackage.realPackageRoot, realBasedir)
-  );
-}
-
-function resolveCachedTailwindPluginSpecifier(specifier, basedir) {
-  const cacheKey = cssSpecifierCacheKey(specifier, basedir);
-  const cachedSpecifier =
-    dependencyAssetsManifest.tailwindPluginSpecifiers[cacheKey];
-  if (!prepareCache) {
-    if (!cachedSpecifier) {
-      throw new Error(`MIAODA_VITE_TAILWIND_PLUGIN_CACHE_MISS: ${specifier}`);
-    }
-    const cachedFile = path.resolve(cacheDir, cachedSpecifier);
-    if (
-      !isInside(cacheDir, cachedFile) ||
-      !fs.existsSync(cachedFile) ||
-      !isInside(fs.realpathSync(cacheDir), fs.realpathSync(cachedFile))
-    ) {
-      throw new Error(
-        `MIAODA_VITE_TAILWIND_PLUGIN_CACHE_PATH_REJECTED: ${specifier}`
-      );
-    }
-    return cachedFile;
-  }
-
-  const projectBasedir = originalProjectBasedir(basedir);
-  const projectRequire = createRequire(
-    path.join(projectBasedir, '__miaoda_tailwind_plugin_resolver.cjs')
-  );
-  const resolvedFile = fs.realpathSync(projectRequire.resolve(specifier));
-  const identity = findProjectPackage(resolvedFile);
-  const cachedPackageRoot = snapshotClientPackageClosure(identity.packagePath);
-  const cachedFile = path.join(
-    cachedPackageRoot,
-    path.relative(identity.packageRoot, resolvedFile)
-  );
-  dependencyAssetsManifest.tailwindPluginSpecifiers[cacheKey] = path
-    .relative(cacheDir, cachedFile)
-    .split(path.sep)
-    .join('/');
-  writeDependencyAssetsManifest();
-  return cachedFile;
-}
-
-function listFilesRecursively(root) {
-  const files = [];
-  const visit = directory => {
-    for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
-      const absolute = path.join(directory, entry.name);
-      if (entry.isDirectory()) {
-        visit(absolute);
-      } else if (entry.isFile()) {
-        files.push(absolute);
-      }
-    }
-  };
-  visit(root);
-  return files;
-}
-
-async function snapshotPreparedDependencyImports() {
-  if (!prepareCache) return { rewrittenImports: 0, sourcePackages: 0 };
-  const depsRoot = path.join(cacheDir, 'deps');
-  if (!fs.existsSync(depsRoot)) {
-    throw new Error('MIAODA_VITE_PREPARED_DEPS_MISSING');
-  }
-  const projectNodeModules = fs.realpathSync(
-    path.join(projectRoot, 'node_modules')
-  );
-  const lexicalProjectNodeModules = path.join(projectRoot, 'node_modules');
-  const lexer = await importFromRuntime('es-module-lexer');
-  await lexer.init;
-  let rewrittenImports = 0;
-  for (const moduleFile of listFilesRecursively(depsRoot).filter(file =>
-    file.endsWith('.js')
-  )) {
-    const source = fs.readFileSync(moduleFile, 'utf8');
-    const [imports] = lexer.parse(source);
-    const replacements = [];
-    for (const imported of imports) {
-      const specifier = imported.n;
-      if (!specifier) continue;
-      const suffixIndex = specifier.search(/[?#]/);
-      const pathname =
-        suffixIndex === -1 ? specifier : specifier.slice(0, suffixIndex);
-      const suffix = suffixIndex === -1 ? '' : specifier.slice(suffixIndex);
-      if (!path.isAbsolute(pathname)) continue;
-      if (!fs.existsSync(pathname)) {
-        if (isInside(lexicalProjectNodeModules, pathname)) {
-          throw new Error(
-            `MIAODA_VITE_PREPARED_DEPENDENCY_IMPORT_MISSING: ${pathname}`
-          );
-        }
-        continue;
-      }
-      const canonicalPathname = fs.realpathSync(pathname);
-      if (!isInside(projectNodeModules, canonicalPathname)) continue;
-      const { cachedFile } = snapshotResolvedProjectFile(canonicalPathname);
-      let relative = path.relative(path.dirname(moduleFile), cachedFile);
-      if (!relative.startsWith('.')) relative = `./${relative}`;
-      replacements.push({
-        start: imported.s,
-        end: imported.e,
-        value: `${relative.split(path.sep).join('/')}${suffix}`,
-      });
-    }
-    if (replacements.length === 0) continue;
-    let rewritten = source;
-    for (const replacement of replacements.sort(
-      (left, right) => right.start - left.start
-    )) {
-      rewritten =
-        rewritten.slice(0, replacement.start) +
-        replacement.value +
-        rewritten.slice(replacement.end);
-    }
-    fs.writeFileSync(moduleFile, rewritten);
-    rewrittenImports += replacements.length;
-  }
-  writeDependencyAssetsManifest();
-  return {
-    rewrittenImports,
-    sourcePackages: Object.keys(dependencyAssetsManifest.sourcePackages).length,
-  };
-}
-
-async function importFromRuntime(specifier) {
-  const resolved = runtimeRequire.resolve(specifier);
-  return import(pathToFileURL(resolved).href);
-}
-
-async function importRuntimeBootstrap(specifier) {
-  const resolved = fs.realpathSync(runtimeRequire.resolve(specifier));
-  const relativeEntry = path.relative(realPlatformRuntimeRoot, resolved);
-  if (
-    relativeEntry === '..' ||
-    relativeEntry.startsWith(`..${path.sep}`) ||
-    path.isAbsolute(relativeEntry)
-  ) {
-    throw new Error(`MIAODA_VITE_RUNTIME_IMPORT_PATH_REJECTED: ${specifier}`);
-  }
-  const snapshot = runtimeImportSnapshot();
-  try {
-    const module = await import(pathToFileURL(resolved).href);
-    process.stdout.write(
-      `${JSON.stringify({
-        event: 'miaoda_vite_runtime_import_diagnostics',
-        schemaVersion: 1,
-        specifier,
-        entry: relativeEntry.split(path.sep).join('/'),
-        ok: true,
-        ...runtimeImportMetrics(snapshot),
-      })}\n`
-    );
-    return module;
-  } catch (error) {
-    process.stdout.write(
-      `${JSON.stringify({
-        event: 'miaoda_vite_runtime_import_diagnostics',
-        schemaVersion: 1,
-        specifier,
-        entry: relativeEntry.split(path.sep).join('/'),
-        ok: false,
-        ...runtimeImportMetrics(snapshot),
-      })}\n`
-    );
-    throw error;
-  }
-}
-
-function readExport(module, name) {
-  const value = module[name] ?? module.default?.[name];
-  if (typeof value !== 'function') {
-    throw new Error(`MIAODA_RUNTIME_EXPORT_MISSING: ${name}`);
-  }
-  return value;
-}
-
-function readDefaultExport(module, specifier) {
-  const value = module.default ?? module;
-  if (typeof value !== 'function') {
-    throw new Error(`MIAODA_RUNTIME_DEFAULT_EXPORT_MISSING: ${specifier}`);
-  }
-  return value;
-}
-
-const enhancedResolve = runtimeRequire('enhanced-resolve');
-const cssResolver = enhancedResolve.create.sync({
-  conditionNames: ['style', 'import', 'browser', 'default'],
-  extensions: ['.css'],
-  mainFields: ['style', 'main'],
-  symlinks: false,
-});
-const resolveCss = (specifier, basedir) => cssResolver(basedir, specifier);
-
-function debugCssResolution(specifier, basedir, resolved) {
-  if (process.env.MIAODA_DEBUG_CACHE_RESOLUTION === 'true') {
-    process.stdout.write(
-      `${JSON.stringify({
-        event: 'miaoda_cache_css_resolved',
-        specifier,
-        basedir,
-        resolved,
-      })}\n`
-    );
-  }
-  return resolved;
-}
-
-const preparedCssImportFiles = new Set();
-
-function snapshotCssImportClosure(cssFile) {
-  if (!prepareCache || preparedCssImportFiles.has(cssFile)) return;
-  preparedCssImportFiles.add(cssFile);
-  const source = fs.readFileSync(cssFile, 'utf8');
-  for (const match of source.matchAll(/@import\s+["']([^"']+)["']/g)) {
-    const specifier = match[1];
-    if (specifier === 'tailwindcss') continue;
-    const resolved =
-      specifier.startsWith('.') || path.isAbsolute(specifier)
-        ? resolveCss(specifier, path.dirname(cssFile))
-        : resolveCachedCssSpecifier(specifier, path.dirname(cssFile));
-    if (/\.(?:css|pcss|postcss)$/.test(resolved)) {
-      snapshotCssImportClosure(resolved);
-    }
-  }
-}
-
-function resolveCachedCssSpecifier(specifier, basedir) {
-  if (specifier === '@/inspector.dev.css') {
-    return debugCssResolution(
-      specifier,
-      basedir,
-      runtimeRequire.resolve(`${activeVitePreset}/src/empty.css`)
-    );
-  }
-  if (specifier.startsWith('@/')) {
-    return debugCssResolution(
-      specifier,
-      basedir,
-      path.join(clientRoot, 'src', specifier.slice(2))
-    );
-  }
-  if (specifier.startsWith('.') || path.isAbsolute(specifier)) {
-    return debugCssResolution(
-      specifier,
-      basedir,
-      resolveCss(specifier, basedir)
-    );
-  }
-  if (specifier === 'tailwindcss') {
-    return debugCssResolution(
-      specifier,
-      basedir,
-      resolveCss(specifier, platformRuntimeRoot)
-    );
-  }
-  const cacheKey = cssSpecifierCacheKey(specifier, basedir);
-  const cachedSpecifier = dependencyAssetsManifest.cssSpecifiers[cacheKey];
-  if (!prepareCache && cachedSpecifier) {
-    const cachedFile = path.resolve(cacheDir, cachedSpecifier);
-    if (
-      !isInside(cacheDir, cachedFile) ||
-      !fs.existsSync(cachedFile) ||
-      !isInside(fs.realpathSync(cacheDir), fs.realpathSync(cachedFile))
-    ) {
-      throw new Error(
-        `MIAODA_VITE_CSS_DEPENDENCY_CACHE_PATH_REJECTED: ${specifier}`
-      );
-    }
-    return debugCssResolution(specifier, basedir, cachedFile);
-  }
-  if (!prepareCache) {
-    throw new Error(`MIAODA_VITE_CSS_DEPENDENCY_CACHE_MISS: ${specifier}`);
-  }
-  const projectResolved = resolveCss(specifier, basedir);
-  const realResolved = fs.realpathSync(projectResolved);
-  const realCacheDir = fs.realpathSync(cacheDir);
-  let cachedFile;
-  if (isInside(realCacheDir, realResolved)) {
-    const ownedBySnapshot = Object.values(
-      dependencyAssetsManifest.sourcePackages
-    ).some(relativeRoot => {
-      const packageRoot = path.resolve(cacheDir, relativeRoot);
-      return (
-        fs.existsSync(packageRoot) &&
-        isInside(fs.realpathSync(packageRoot), realResolved)
-      );
-    });
-    if (!ownedBySnapshot) {
-      throw new Error(
-        `MIAODA_VITE_CSS_DEPENDENCY_CACHE_PATH_REJECTED: ${specifier}`
-      );
-    }
-    cachedFile = realResolved;
-  } else {
-    ({ cachedFile } = snapshotResolvedProjectFile(realResolved));
-  }
-  const cachedRelative = path.relative(
-    fs.realpathSync(cacheDir),
-    fs.realpathSync(cachedFile)
-  );
-  if (
-    !cachedRelative ||
-    cachedRelative === '..' ||
-    cachedRelative.startsWith(`..${path.sep}`) ||
-    path.isAbsolute(cachedRelative)
-  ) {
-    throw new Error(
-      `MIAODA_VITE_CSS_DEPENDENCY_CACHE_PATH_REJECTED: ${specifier}`
-    );
-  }
-  dependencyAssetsManifest.cssSpecifiers[cacheKey] = cachedRelative
-    .split(path.sep)
-    .join('/');
-  writeDependencyAssetsManifest();
-  snapshotCssImportClosure(cachedFile);
-  return debugCssResolution(specifier, basedir, cachedFile);
-}
-
-function snapshotClientCssImports() {
-  if (!prepareCache) return;
-  for (const url of clientStyleUrls()) {
-    const sourceFile = path.join(projectRoot, url.replace(/^\//, ''));
-    const source = fs.readFileSync(sourceFile, 'utf8');
-    for (const match of source.matchAll(/@import\s+["']([^"']+)["']/g)) {
-      const specifier = match[1];
-      if (
-        specifier === 'tailwindcss' ||
-        specifier.startsWith('.') ||
-        path.isAbsolute(specifier)
-      ) {
-        continue;
-      }
-      const cachedFile = resolveCachedCssSpecifier(
-        specifier,
-        path.dirname(sourceFile)
-      );
-      snapshotCssImportClosure(cachedFile);
-    }
-    for (const match of source.matchAll(/@plugin\s+["']([^"']+)["']/g)) {
-      const specifier = match[1];
-      if (specifier.startsWith('.') || path.isAbsolute(specifier)) continue;
-      resolveCachedTailwindPluginSpecifier(specifier, path.dirname(sourceFile));
-    }
-  }
-}
-
-snapshotClientCssImports();
-
-const stableDependencyAssetsRoot = path.join(
-  projectRoot,
-  '.miaoda-runtime',
-  'dependency-assets',
-  appRuntimeManifest.clientDependencyGraphHash
-);
-function publishStableDependencyAssetsPointer() {
-  const runtimeStateRoot = path.join(projectRoot, '.miaoda-runtime');
-  const stableParent = path.dirname(stableDependencyAssetsRoot);
-  for (const directory of [runtimeStateRoot, stableParent]) {
-    if (fs.existsSync(directory) && fs.lstatSync(directory).isSymbolicLink()) {
-      throw new Error(
-        `MIAODA_VITE_DEPENDENCY_ASSET_RUNTIME_SYMLINK_REJECTED: ${directory}`
-      );
-    }
-    fs.mkdirSync(directory, { recursive: true });
-  }
-  if (
-    fs.existsSync(stableDependencyAssetsRoot) &&
-    !fs.lstatSync(stableDependencyAssetsRoot).isSymbolicLink()
-  ) {
-    throw new Error(
-      `MIAODA_VITE_DEPENDENCY_ASSET_RUNTIME_PATH_REJECTED: ${stableDependencyAssetsRoot}`
-    );
-  }
-  const temporary = `${stableDependencyAssetsRoot}.${process.pid}.tmp`;
-  if (fs.existsSync(temporary)) {
-    if (!fs.lstatSync(temporary).isSymbolicLink()) {
-      throw new Error(
-        `MIAODA_VITE_DEPENDENCY_ASSET_RUNTIME_PATH_REJECTED: ${temporary}`
-      );
-    }
-    fs.unlinkSync(temporary);
-  }
-  fs.symlinkSync(path.relative(stableParent, dependencyAssetsRoot), temporary);
-  fs.renameSync(temporary, stableDependencyAssetsRoot);
-}
-publishStableDependencyAssetsPointer();
-
-function resolveTailwindSourceSpecifier(specifier, sourceFile) {
-  const marker = `${path.sep}node_modules${path.sep}`;
-  const normalized = path.normalize(
-    path.resolve(path.dirname(sourceFile || projectRoot), specifier)
-  );
-  const markerIndex = normalized.indexOf(marker);
-  if (markerIndex < 0) return specifier;
-  const packagePattern = normalized.slice(markerIndex + marker.length);
-  const segments = packagePattern.split(path.sep);
-  const packageName = packagePattern.startsWith('@')
-    ? segments.slice(0, 2).join('/')
-    : segments[0];
-  const packagePath = `node_modules/${packageName}`;
-  let cachedPackageRoot;
-  if (prepareCache) {
-    const packageRoot = path.join(
-      projectRoot,
-      'node_modules',
-      ...packageName.split('/')
-    );
-    const resolvedPackage = findProjectPackage(
-      path.join(packageRoot, 'package.json')
-    );
-    cachedPackageRoot = snapshotProjectPackage(
-      resolvedPackage.packageName,
-      resolvedPackage.packagePath,
-      resolvedPackage.packageRoot
-    );
-  } else {
-    cachedPackageRoot = snapshotProjectPackage(
-      packageName,
-      packagePath,
-      undefined
-    );
-  }
-  const packageRelativePattern = segments
-    .slice(packageName.startsWith('@') ? 2 : 1)
-    .join(path.sep);
-  return path.join(cachedPackageRoot, packageRelativePattern);
-}
-
-function snapshotDefaultTailwindContentPackage() {
-  const packageName = '@lark-apaas/client-toolkit';
-  const packagePath = `node_modules/${packageName}`;
-  if (!clientGraphPackages.has(packagePath)) return;
-  if (!prepareCache) {
-    snapshotProjectPackage(packageName, packagePath, undefined);
-    return;
-  }
-  const packageRoot = path.join(
-    projectRoot,
-    'node_modules',
-    ...packageName.split('/')
-  );
-  const resolvedPackage = findProjectPackage(
-    path.join(packageRoot, 'package.json')
-  );
-  snapshotProjectPackage(
-    resolvedPackage.packageName,
-    resolvedPackage.packagePath,
-    resolvedPackage.packageRoot
-  );
-}
-
-// The image-owned fullstack-presets adapter evaluates tailwind.config.* via
-// Jiti, outside Vite's resolver. Persist only the default content package when
-// it is part of the actual client graph, then make both producer and consumer
-// resolve the same version from the sealed generation.
-snapshotDefaultTailwindContentPackage();
-
-async function createCachePostcssConfig() {
-  const configCandidates = [
-    'postcss.config.js',
-    'postcss.config.cjs',
-    'postcss.config.mjs',
-  ];
-  if (
-    !configCandidates.some(file => fs.existsSync(path.join(projectRoot, file)))
-  ) {
-    return undefined;
-  }
-  const postcssImport = readDefaultExport(
-    await importFromRuntime('postcss-import'),
-    'postcss-import'
-  );
-  const tailwindPostcss = readDefaultExport(
-    await importFromRuntime('@tailwindcss/postcss'),
-    '@tailwindcss/postcss'
-  );
-  const autoprefixer = readDefaultExport(
-    await importFromRuntime('autoprefixer'),
-    'autoprefixer'
-  );
-  const runtimeTailwindPaths = {
-    postcssPlugin: 'miaoda-runtime-tailwind-paths',
-    Once(root) {
-      // Tailwind consumes @plugin in its own Once hook. Rewrite after
-      // postcss-import expands local files but before Tailwind runs; AtRule
-      // visitors execute too late for imported plugin directives.
-      root.walkAtRules(rule => {
-        const quoted = /^(["'])(.+)\1$/.exec(rule.params.trim());
-        if (!quoted) return;
-        const [, quote, specifier] = quoted;
-        if (
-          rule.name === 'plugin' &&
-          !specifier.startsWith('.') &&
-          !path.isAbsolute(specifier)
-        ) {
-          rule.params = `${quote}${resolveCachedTailwindPluginSpecifier(
-            specifier,
-            path.dirname(rule.source?.input.file || projectRoot)
-          )}${quote}`;
-        }
-        if (rule.name === 'source') {
-          rule.params = `${quote}${resolveTailwindSourceSpecifier(
-            specifier,
-            rule.source?.input.file
-          )}${quote}`;
-        }
-      });
-    },
-  };
-  return {
-    plugins: [
-      postcssImport({
-        skipDuplicates: false,
-        resolve(specifier, basedir) {
-          return resolveCachedCssSpecifier(specifier, basedir);
-        },
-      }),
-      runtimeTailwindPaths,
-      tailwindPostcss({ base: projectRoot }),
-      autoprefixer(),
-    ],
-  };
-}
-
-const createServer = readExport(viteModule, 'createServer');
-const loadConfigFromFile = readExport(viteModule, 'loadConfigFromFile');
-const mergeConfig = readExport(viteModule, 'mergeConfig');
-const createDefaultViteConfig = readExport(
-  presetModule,
-  activeVitePreset === '@lark-apaas/fullstack-vite-preset'
-    ? 'createFullstackViteConfig'
-    : 'defineConfig'
-);
-const platformRuntimeResolverPlugin = readExport(
-  resolverPresetModule,
-  'platformRuntimeResolverPlugin'
-);
-const capabilitiesPlugin = readExport(
-  resolverPresetModule,
-  'capabilitiesPlugin'
-);
-
-process.chdir(projectRoot);
-
-const runtimeResolver = platformRuntimeResolverPlugin({
-  projectRoot,
-  platformRuntimeRoot,
-  runtimeManifestFile,
-  appManifestFile,
-  dependencyReadyFile,
-  generationId: validatedGeneration?.generation.generationId,
-  cacheDir,
-  entryFile: clientEntryFile,
-  allowProjectDependencies: prepareCache,
-});
-// Presets historically shipped different capability implementations. Cache
-// startup must never bake the generation-time JSON map into optimized deps.
-// Use one image-owned implementation for both FullStack and JSP Page: the
-// virtual module stays stable while current workspace data is injected into
-// every HTML response and capability edits trigger a browser reload.
-const runtimeCapabilities = capabilitiesPlugin();
-const runtimePreviewRendered = createMiaodaPreviewRenderedPlugin();
-const cacheCssDependencyPaths = {
-  name: 'miaoda-cache-css-dependency-paths',
-  enforce: 'pre',
-  resolveId(source) {
-    return cachedCssAliases.get(source) ?? null;
-  },
-  transform(source, id) {
-    const cleanId = id.split(/[?#]/, 1)[0];
-    if (!/\.(?:css|pcss|postcss)$/.test(cleanId)) return null;
-    const sourceFile = cleanId.startsWith('/@fs/')
-      ? cleanId.slice('/@fs'.length)
-      : cleanId;
-    const basedir = path.dirname(sourceFile);
-    let changed = false;
-    let code = source.replace(
-      /(@import\s+)(["'])([^"']+)\2/g,
-      (match, prefix, quote, specifier) => {
-        if (specifier.startsWith('.') || path.isAbsolute(specifier)) {
-          return match;
-        }
-        changed = true;
-        return `${prefix}${quote}${resolveCachedCssSpecifier(
-          specifier,
-          basedir
-        )}${quote}`;
-      }
-    );
-    code = code.replace(
-      /(@source\s+)(["'])([^"']+)\2/g,
-      (match, prefix, quote, specifier) => {
-        const resolved = resolveTailwindSourceSpecifier(specifier, sourceFile);
-        if (resolved === specifier) return match;
-        changed = true;
-        return `${prefix}${quote}${resolved}${quote}`;
-      }
-    );
-    code = code.replace(
-      /(@plugin\s+)(["'])([^"']+)\2/g,
-      (match, prefix, quote, specifier) => {
-        if (specifier.startsWith('.') || path.isAbsolute(specifier)) {
-          return match;
-        }
-        changed = true;
-        return `${prefix}${quote}${resolveCachedTailwindPluginSpecifier(
-          specifier,
-          basedir
-        )}${quote}`;
-      }
-    );
-    return changed ? { code, map: null } : null;
-  },
-};
-const clientEntryUrl = `/${path
-  .relative(projectRoot, clientEntryFile)
-  .split(path.sep)
-  .join('/')}`;
-const cacheClientEntryPlugin = {
-  name: 'miaoda-cache-client-entry',
-  transformIndexHtml: {
-    order: 'pre',
-    handler(html) {
-      if (!fs.existsSync(clientEntryFile) || html.includes(clientEntryUrl)) {
-        return html;
-      }
-      return {
-        html,
-        tags: [
-          {
-            tag: 'script',
-            attrs: { type: 'module', src: clientEntryUrl },
-            injectTo: 'body',
-          },
-        ],
-      };
-    },
-  },
-};
-const lifecycleRoots = [
-  'node_modules',
-  'dist',
-  '.miaoda-cache',
-  '.miaoda-runtime',
-  '.githooks',
-].map(relative => path.join(projectRoot, relative));
-const lifecycleFiles = new Set(
-  [
-    '.spark_project',
-    'package.json',
-    'package-lock.json',
-    'npm-shrinkwrap.json',
-    'pnpm-lock.yaml',
-    'yarn.lock',
-    'scripts/build.sh',
-    'scripts/cache-runtime-coordinator.mjs',
-    'scripts/cache-generation-prune.mjs',
-    'scripts/cache-generation-preflight.mjs',
-    'scripts/dev-local.js',
-    'scripts/dev.js',
-    'scripts/dev.sh',
-    'scripts/hooks/run-precommit.js',
-    'scripts/lint.js',
-    'scripts/patch-vite-dependency-graph-hash.mjs',
-    'scripts/prune-smart.js',
-    'scripts/run.sh',
-    'scripts/server-cache-runtime.mjs',
-    'scripts/vite-cache-runtime.mjs',
-  ].map(relative => path.join(projectRoot, relative))
-);
-const isLifecycleWrite = file => {
-  const resolved = path.resolve(file);
-  return (
-    lifecycleFiles.has(resolved) ||
-    lifecycleRoots.some(
-      root => resolved === root || resolved.startsWith(`${root}${path.sep}`)
-    )
-  );
-};
-const cacheLifecycleHmrGuard = {
-  name: 'miaoda-cache-lifecycle-hmr-guard',
-  // Tailwind can map a change in an unrelated generated file back to
-  // client/src/index.css. Run last and decide from the actual changed file,
-  // otherwise dependency restore would emit hundreds of synthetic CSS HMRs.
-  hotUpdate: {
-    order: 'post',
-    handler(options) {
-      if (!prepareCache && isLifecycleWrite(options.file)) return [];
-    },
-  },
-};
-const cachePostcssConfig = await createCachePostcssConfig();
-const cachedCssAliases = new Map();
-const ambiguousCachedCssAliases = new Set();
-for (const specifierMap of [
-  dependencyAssetsManifest.cssSpecifiers,
-  dependencyAssetsManifest.tailwindPluginSpecifiers,
-]) {
-  for (const [cacheKey, relativeFile] of Object.entries(specifierMap)) {
-    const parsedKey = JSON.parse(cacheKey);
-    const specifier = parsedKey?.[1];
-    if (typeof specifier !== 'string') {
-      throw new Error('MIAODA_VITE_CSS_DEPENDENCY_CACHE_KEY_INVALID');
-    }
-    const cachedFile = path.resolve(cacheDir, relativeFile);
-    const assetRelative = path.relative(dependencyAssetsRoot, cachedFile);
-    if (
-      !assetRelative ||
-      assetRelative === '..' ||
-      assetRelative.startsWith(`..${path.sep}`) ||
-      path.isAbsolute(assetRelative)
-    ) {
-      throw new Error(
-        `MIAODA_VITE_CSS_DEPENDENCY_CACHE_PATH_REJECTED: ${specifier}`
-      );
-    }
-    const stableCachedFile = path.join(
-      stableDependencyAssetsRoot,
-      assetRelative
-    );
-    if (ambiguousCachedCssAliases.has(specifier)) continue;
-    const previous = cachedCssAliases.get(specifier);
-    if (previous && previous !== stableCachedFile) {
-      // A nested package can intentionally resolve the same CSS specifier to
-      // a different version. The transform hook above rewrites each import
-      // with its importer-aware cached path; a global Vite alias would destroy
-      // that distinction, so omit only the ambiguous shortcut.
-      cachedCssAliases.delete(specifier);
-      ambiguousCachedCssAliases.add(specifier);
-      continue;
-    }
-    cachedCssAliases.set(specifier, stableCachedFile);
-  }
-}
-const runtimeCssAliases = [
-  {
-    find: /^@\/inspector\.dev\.css$/,
-    replacement: runtimeRequire.resolve(`${activeVitePreset}/src/empty.css`),
-  },
-  {
-    find: /^tailwindcss$/,
-    replacement: runtimeRequire.resolve('tailwindcss/index.css'),
-  },
-  ...[...cachedCssAliases.entries()].map(([find, replacement]) => ({
-    find,
-    replacement,
-  })),
-];
-const runtimeOverrides = {
-  root: projectRoot,
-  cacheDir,
-  // Vite 8/Oxc otherwise auto-discovers the project tsconfig for every TSX
-  // transform. A package-based `extends` would make cache-only startup depend
-  // on Workspace node_modules. Use the producer-resolved, sealed subset in
-  // both producer and consumer so transform identity remains stable.
-  oxc: {
-    tsconfig: inlineTsconfig,
-  },
-  // Both producer and cache consumer bind internally. In consumer mode the
-  // stable public port is owned by the switch proxy so a normal project Vite
-  // can take over without changing the iframe URL.
-  server: {
-    host: '127.0.0.1',
-    port: 0,
-    strictPort: false,
-  },
-  resolve: {
-    // Cache-only mode already seals the aliases below. Avoid asking Vite's
-    // tsconfig-path resolver to load package-based `extends` from Workspace
-    // node_modules before dependency restore completes.
-    tsconfigPaths: false,
-    alias: [
-      ...runtimeCssAliases,
-      { find: '@', replacement: path.join(clientRoot, 'src') },
-      { find: '@client', replacement: clientRoot },
-      { find: '@shared', replacement: path.join(projectRoot, 'shared') },
-    ],
-  },
-  plugins: [
-    cacheCssDependencyPaths,
-    runtimeResolver,
-    cacheClientEntryPlugin,
-    cacheLifecycleHmrGuard,
-  ],
-  optimizeDeps: {
-    include: appRuntimeManifest.optimizeDependencies || [],
-    // The manifest is the complete dependency set for this generation. Source
-    // discovery would re-enter unresolved Workspace dependencies before the
-    // external npm restore has finished.
-    noDiscovery: true,
-    rolldownOptions: {
-      transform: {
-        tsconfig: inlineTsconfig,
-      },
-    },
-  },
-  ...(cachePostcssConfig ? { css: { postcss: cachePostcssConfig } } : {}),
-};
-const configFile = [
-  'vite.config.ts',
-  'vite.config.mts',
-  'vite.config.js',
-  'vite.config.mjs',
-  'vite.config.cjs',
-]
-  .map(file => path.join(projectRoot, file))
-  .find(file => fs.existsSync(file));
-let config;
-const configLoadStartedAt = process.hrtime.bigint();
-if (configFile) {
-  const loaded = await loadConfigFromFile(
-    { command: 'serve', mode: process.env.NODE_ENV },
-    configFile,
-    projectRoot
-  );
-  if (!loaded) {
-    throw new Error(`MIAODA_VITE_CONFIG_LOAD_FAILED: ${configFile}`);
-  }
-  // A template config already expands defineConfig() into the complete preset.
-  // Merge only the image-owned delta or every preset plugin/middleware would
-  // be registered twice. NODE_PATH above never points at Workspace dependencies.
-  config = mergeConfig(loaded.config, runtimeOverrides);
-} else {
-  config = createDefaultViteConfig(runtimeOverrides);
-}
-if (cachePostcssConfig) {
-  config.css = {
-    ...(config.css || {}),
-    postcss: cachePostcssConfig,
-  };
-}
-// The JSP preset registers Tailwind as an early CSS transform. Snapshot and
-// rewrite package CSS first, otherwise Tailwind would resolve @import against
-// Workspace node_modules before the cache plugin sees it.
-config.plugins = [
-  cacheCssDependencyPaths,
-  runtimeCapabilities,
-  runtimePreviewRendered,
-  ...(config.plugins || []).filter(
-    plugin =>
-      plugin !== cacheCssDependencyPaths &&
-      plugin?.name !== 'miaoda-capabilities-bundle' &&
-      plugin?.name !== MIAODA_PREVIEW_RENDERED_PLUGIN_NAME
-  ),
-];
-emitRuntimePhase('config_load', configLoadStartedAt, {
-  configFile: Boolean(configFile),
-});
-
-let server;
-let closing = false;
-async function closeServerBounded() {
-  if (!server) return { closeTimedOut: false };
-  let timeout;
-  try {
-    return await Promise.race([
-      server.close().then(() => ({ closeTimedOut: false })),
-      new Promise(resolve => {
-        // Keep this timer referenced. Some Vite/plugin teardown paths return
-        // an unsettled promise after all handles are gone, which otherwise
-        // makes Node exit with code 13 before the prepared cache is published.
-        timeout = setTimeout(
-          () => resolve({ closeTimedOut: true }),
-          closeTimeoutMs
-        );
-      }),
-    ]);
-  } finally {
-    if (timeout) clearTimeout(timeout);
-  }
-}
-async function close(signal) {
-  if (closing) return;
-  closing = true;
-  process.stdout.write(
-    `${JSON.stringify({ event: 'miaoda_vite_cache_runtime_stopping', signal })}\n`
-  );
-  if (dependencyReadyPoller) clearInterval(dependencyReadyPoller);
-  if (freshRuntimeRetryTimer) clearTimeout(freshRuntimeRetryTimer);
-  freshRuntimeRetryTimer = undefined;
-  if (freshRuntimeChild) freshRuntimeChild.kill('SIGTERM');
-  await Promise.all([
-    closeStableProxy().catch(() => undefined),
-    closeServerBounded().catch(() => undefined),
-  ]);
-  process.exit(0);
-}
-
-let dependencyHandoffStarted = false;
-async function handoffToOriginalVite() {
-  if (
-    closing ||
-    dependencyHandoffStarted ||
-    managedByCoordinator ||
-    prepareCache ||
-    !projectDependenciesReady()
-  ) {
-    return;
-  }
-  dependencyHandoffStarted = true;
-  process.stdout.write(
-    `${JSON.stringify({
-      event: 'miaoda_vite_dependency_handoff_started',
-      exitCode: dependencyHandoffExitCode,
-    })}\n`
-  );
-  closing = true;
-  if (dependencyReadyPoller) clearInterval(dependencyReadyPoller);
-  await Promise.all([
-    closeStableProxy().catch(() => undefined),
-    closeServerBounded().catch(() => undefined),
-  ]);
-  process.exit(dependencyHandoffExitCode);
-}
-
-process.once('SIGINT', () => void close('SIGINT'));
-process.once('SIGTERM', () => void close('SIGTERM'));
-process.once('SIGHUP', () => void close('SIGHUP'));
-
-const dependencyCacheMetadataBeforeCreate = prepareCache
-  ? undefined
-  : dependencyCacheMetadataState();
-try {
-  const createServerStartedAt = process.hrtime.bigint();
-  server = await createServer({
-    ...config,
-    configFile: false,
-    root: projectRoot,
-  });
-  emitRuntimePhase('create_server', createServerStartedAt);
-} catch (error) {
-  throw error;
-}
-if (process.env.MIAODA_DEBUG_VITE_CONFIG_HASH === 'true') {
-  const hashConfig = server.environments.client.config;
-  const stringify = value =>
-    JSON.stringify(value, (_key, item) => {
-      if (typeof item === 'function' || item instanceof RegExp) {
-        return item.toString();
-      }
-      return item;
-    });
-  const hash = value =>
-    createHash('sha256').update(stringify(value)).digest('hex');
-  const configHashInput = {
-    define: !hashConfig.keepProcessEnv
-      ? process.env.NODE_ENV || hashConfig.mode
-      : null,
-    root: hashConfig.root,
-    resolve: hashConfig.resolve,
-    assetsInclude: hashConfig.assetsInclude,
-    plugins: hashConfig.plugins.map(plugin => plugin.name),
-    optimizeDeps: {
-      include: hashConfig.optimizeDeps.include
-        ? [...new Set(hashConfig.optimizeDeps.include)].sort()
-        : undefined,
-      exclude: hashConfig.optimizeDeps.exclude
-        ? [...new Set(hashConfig.optimizeDeps.exclude)].sort()
-        : undefined,
-      rolldownOptions: {
-        ...hashConfig.optimizeDeps.rolldownOptions,
-        plugins: undefined,
-        onLog: undefined,
-        onwarn: undefined,
-        checks: undefined,
-        output: {
-          ...hashConfig.optimizeDeps.rolldownOptions?.output,
-          plugins: undefined,
-        },
-      },
-    },
-    optimizeDepsPluginNames: hashConfig.optimizeDepsPluginNames,
-  };
-  let cachedConfigHash;
-  try {
-    cachedConfigHash = JSON.parse(
-      fs.readFileSync(path.join(cacheDir, 'deps', '_metadata.json'), 'utf8')
-    ).configHash;
-  } catch {
-    cachedConfigHash = undefined;
-  }
-  process.stdout.write(
-    `${JSON.stringify({
-      event: 'miaoda_vite_config_hash_inputs',
-      prepareCache,
-      calculatedConfigHash: hash(configHashInput).slice(0, 8),
-      cachedConfigHash,
-      define: configHashInput.define,
-      root: configHashInput.root,
-      resolveHash: hash(hashConfig.resolve),
-      assetsIncludeHash: hash(hashConfig.assetsInclude),
-      plugins: hashConfig.plugins.map(plugin => plugin.name),
-      optimizeDepsInclude: [
-        ...new Set(hashConfig.optimizeDeps.include || []),
-      ].sort(),
-      optimizeDepsExclude: [
-        ...new Set(hashConfig.optimizeDeps.exclude || []),
-      ].sort(),
-      optimizeDepsRolldownHash: hash({
-        ...hashConfig.optimizeDeps.rolldownOptions,
-        plugins: undefined,
-        onLog: undefined,
-        onwarn: undefined,
-        checks: undefined,
-        output: {
-          ...hashConfig.optimizeDeps.rolldownOptions?.output,
-          plugins: undefined,
-        },
-      }),
-      optimizeDepsPluginNames: hashConfig.optimizeDepsPluginNames,
-    })}\n`
-  );
-}
-try {
-  const listenStartedAt = process.hrtime.bigint();
-  await server.listen();
-  emitRuntimePhase('listen', listenStartedAt);
-
-  if (!prepareCache) {
-    const dependencyCacheMetadataAfterListen = dependencyCacheMetadataState();
-    process.stdout.write(
-      `${JSON.stringify({
-        event: 'miaoda_vite_dependency_cache_diagnostics',
-        schemaVersion: 1,
-        noDiscovery: true,
-        forceReoptimize: false,
-        metadataExistedBeforeCreate:
-          dependencyCacheMetadataBeforeCreate?.exists === true,
-        metadataExistsAfterListen:
-          dependencyCacheMetadataAfterListen.exists === true,
-        metadataContentChanged:
-          dependencyCacheMetadataBeforeCreate?.sha256 !==
-          dependencyCacheMetadataAfterListen.sha256,
-        metadataMtimeChanged:
-          dependencyCacheMetadataBeforeCreate?.mtimeMs !==
-          dependencyCacheMetadataAfterListen.mtimeMs,
-        optimizedDependenciesBefore:
-          dependencyCacheMetadataBeforeCreate?.optimizedDependencies ?? 0,
-        optimizedDependenciesAfter:
-          dependencyCacheMetadataAfterListen.optimizedDependencies ?? 0,
-        optimizedChunksBefore:
-          dependencyCacheMetadataBeforeCreate?.optimizedChunks ?? 0,
-        optimizedChunksAfter:
-          dependencyCacheMetadataAfterListen.optimizedChunks ?? 0,
-      })}\n`
-    );
-  }
-
-  const address = server.httpServer?.address();
-  const internalPort =
-    address && typeof address !== 'string' ? address.port : config.server?.port;
-  let port = internalPort;
-  if (!prepareCache) {
-    const publicPort = Number(process.env.CLIENT_DEV_PORT || 8080);
-    if (
-      !Number.isSafeInteger(publicPort) ||
-      publicPort <= 0 ||
-      publicPort > 65_535
-    ) {
-      throw new Error('MIAODA_VITE_PUBLIC_PORT_INVALID');
-    }
-    cacheBackend = {
-      kind: 'cache',
-      port: internalPort,
-      pid: process.pid,
-      webSocketToken: server.config.webSocketToken,
-    };
-    activeBackend = cacheBackend;
-    await startStableProxy(
-      publicPort,
-      process.env.CLIENT_DEV_HOST || '0.0.0.0'
-    );
-    port = publicPort;
-    publishServingReadyMarker(servingReadyMarker);
-    if (!managedByCoordinator) {
-      dependencyReadyPoller = setInterval(() => {
-        if (projectDependenciesReady()) void handoffToOriginalVite();
-      }, 250);
-      dependencyReadyPoller.unref();
-      if (projectDependenciesReady()) void handoffToOriginalVite();
-    }
-  }
-  if (prepareCache) {
-    await server.warmupRequest(clientEntryUrl);
-    for (const styleUrl of clientStyleUrls()) {
-      const publicStyleUrl = withViteBase(server.config.base, styleUrl);
-      const styleResponse = await fetch(
-        `http://127.0.0.1:${port}${publicStyleUrl}?direct`
-      );
-      if (!styleResponse.ok) {
-        throw new Error(
-          `MIAODA_VITE_STYLE_PREPARE_FAILED: ${publicStyleUrl} ${styleResponse.status} ${await styleResponse.text()}`
-        );
-      }
-      await styleResponse.arrayBuffer();
-    }
-    await server.waitForRequestsIdle();
-    const preparedCache = await waitForPreparedCache();
-    const closeResult = await closeServerBounded();
-    const dependencyAssets = await snapshotPreparedDependencyImports();
-    process.stdout.write(
-      `${JSON.stringify({
-        event: 'miaoda_vite_cache_runtime_prepared',
-        pid: process.pid,
-        port,
-        cacheDir,
-        ...preparedCache,
-        ...dependencyAssets,
-        ...closeResult,
-      })}\n`
-    );
-    process.exit(0);
-  }
-  process.stdout.write(
-    `${JSON.stringify({
-      event: 'miaoda_vite_cache_runtime_ready',
-      pid: process.pid,
-      port,
-      cachePort: internalPort,
-      cacheDir,
-      sealedCacheDir,
-      dependencyReadyFile,
-      startupValidation: 'sealed-cache-only',
-      startupDurationMs: Number(durationMs(runtimeStartedAt).toFixed(3)),
-      pluginNames: server.config.plugins.map(plugin => plugin.name),
-    })}\n`
-  );
-} catch (error) {
-  await closeStableProxy().catch(() => undefined);
-  await closeServerBounded().catch(() => undefined);
-  throw error;
-}