@lark-apaas/fullstack-cli 1.1.64-alpha.20260902123941 → 1.1.64

package/templates/scripts/server-handoff-runtime.mjs

@@ -1,1904 +0,0 @@
-#!/usr/bin/env node
-
-import fs from 'node:fs';
-import http from 'node:http';
-import net from 'node:net';
-import path from 'node:path';
-import { spawn } from 'node:child_process';
-import { createHash, randomUUID } from 'node:crypto';
-import { fileURLToPath } from 'node:url';
-
-const SCHEMA_VERSION = 7;
-const BUNDLE_ENTRY = 'payload/server.bundle.cjs';
-const MAX_GENERATION_FILES = 50_000;
-const MAX_GENERATION_BYTES = 256 * 1024 * 1024;
-const MAX_GENERATION_FILE_BYTES = 64 * 1024 * 1024;
-const MAX_FILE_INDEX_BYTES = 16 * 1024 * 1024;
-const MAX_MANIFEST_BYTES = 1024 * 1024;
-const MAX_READINESS_RESPONSE_BYTES = 64 * 1024;
-const SOURCE_RETRY_INITIAL_DELAY_MS = 250;
-const SOURCE_RETRY_MAX_DELAY_MS = 5_000;
-const RUNTIME_CONTROL_ENV_KEYS = new Set([
-  'MIAODA_COLD_START_DECISION_FILE',
-  'MIAODA_DEPENDENCY_READY_FILE',
-  'MIAODA_NEST_BACKEND_OWNER',
-  'MIAODA_NEST_BUNDLE_HANDOFF_ENABLED',
-  'MIAODA_NEST_BUNDLE_ROOT',
-  'MIAODA_NEST_READINESS_PATH',
-  'MIAODA_PLATFORM_ENV_NOT_BEFORE_MS',
-  'MIAODA_RUNTIME_ENV_FILE',
-  'MIAODA_RUNTIME_OWNER_FILE',
-  'MIAODA_RUNTIME_PROCESS_REGISTRY_FILE',
-  'MIAODA_STARTUP_BOOT_ID',
-  'MIAODA_WORKSPACE_ROOT',
-  'PWD',
-  'WORKSPACE_DIR',
-]);
-
-const projectRoot = path.resolve(
-  process.env.MIAODA_WORKSPACE_ROOT || process.cwd()
-);
-const platformWorkspaceRoot = path.resolve(
-  process.env.WORKSPACE_DIR || projectRoot
-);
-const cacheRoot = path.resolve(
-  projectRoot,
-  process.env.MIAODA_NEST_BUNDLE_ROOT || '.miaoda-cache/server'
-);
-const ownerFile = path.resolve(
-  process.env.MIAODA_RUNTIME_OWNER_FILE ||
-    '/tmp/miaoda-cold-start/runtime-owner.json'
-);
-const handoffStateFile = path.join(
-  path.dirname(ownerFile),
-  'handoff-state.json'
-);
-const processRegistryFile = path.resolve(
-  process.env.MIAODA_RUNTIME_PROCESS_REGISTRY_FILE ||
-    '/tmp/miaoda-cold-start/runtime-processes.json'
-);
-const receiptFile = path.resolve(
-  process.env.MIAODA_DEPENDENCY_READY_FILE ||
-    '/tmp/miaoda-cold-start/restore-receipt.json'
-);
-const runtimeEnvFile = path.resolve(
-  process.env.MIAODA_RUNTIME_ENV_FILE ||
-    path.join(platformWorkspaceRoot, '.force', 'environment', 'env')
-);
-const bootId = process.env.MIAODA_STARTUP_BOOT_ID || '';
-const restoreEpochMs = Number(process.env.MIAODA_PLATFORM_ENV_NOT_BEFORE_MS);
-const publicHost = process.env.SERVER_HOST || '0.0.0.0';
-const publicPort = Number(process.env.SERVER_PORT || 3000);
-const logDir = path.resolve(projectRoot, process.env.LOG_DIR || 'logs');
-const configuredClientBasePath = process.env.CLIENT_BASE_PATH;
-const readinessBasePath =
-  configuredClientBasePath?.startsWith('/') &&
-  !configuredClientBasePath.startsWith('//')
-    ? configuredClientBasePath.replace(/\/+$/, '')
-    : '';
-const readinessPath =
-  process.env.MIAODA_NEST_READINESS_PATH ||
-  `${readinessBasePath}/__innerapi__/capability/list`;
-const sourceReadyTimeoutMs = positiveDuration(
-  'MIAODA_NEST_SOURCE_READY_TIMEOUT_MS',
-  60_000
-);
-const shutdownTimeoutMs = positiveDuration(
-  'MIAODA_NEST_SHUTDOWN_TIMEOUT_MS',
-  5_000
-);
-const drainTimeoutMs = positiveDuration('MIAODA_NEST_DRAIN_TIMEOUT_MS', 5_000);
-const processStartTicks =
-  readLinuxProcessStartTicks(process.pid) ||
-  String(
-    Math.max(1, Math.floor((Date.now() - process.uptime() * 1000) * 1000))
-  );
-const rootSourceHashIgnoredDirectories = new Set([
-  '.agents',
-  '.claude',
-  '.git',
-  '.miaoda-cache',
-  '.miaoda-runtime',
-  '.turbo',
-  'coverage',
-  'dist',
-  'logs',
-]);
-const ownedProcessWrapperSource = String.raw`
-const fs = require('node:fs');
-const { spawn, spawnSync } = require('node:child_process');
-const command = process.argv[1];
-const args = JSON.parse(process.argv[2]);
-let finishing;
-
-function linuxIdentity(pid) {
-  if (process.platform !== 'linux') return undefined;
-  try {
-    const stat = fs.readFileSync('/proc/' + pid + '/stat', 'utf8');
-    const fields = stat.slice(stat.lastIndexOf(')') + 1).trim().split(/\s+/);
-    return {
-      state: fields[0],
-      processGroupId: Number(fields[2]),
-      processStartTicks: fields[19],
-    };
-  } catch {
-    return undefined;
-  }
-}
-
-function ownedMembers() {
-  const members = [];
-  if (process.platform !== 'linux') {
-    try {
-      const listing = spawnSync('/bin/ps', ['-axo', 'pid=,pgid='], {
-        encoding: 'utf8',
-      });
-      if (listing.status !== 0) return members;
-      for (const line of listing.stdout.split(/\r?\n/)) {
-        const match = line.trim().match(/^(\d+)\s+(\d+)$/);
-        if (!match) continue;
-        const pid = Number(match[1]);
-        if (pid !== process.pid && Number(match[2]) === process.pid) {
-          members.push({ pid });
-        }
-      }
-    } catch {}
-    return members;
-  }
-  for (const name of fs.readdirSync('/proc')) {
-    if (!/^\d+$/.test(name)) continue;
-    const pid = Number(name);
-    if (pid === process.pid) continue;
-    const identity = linuxIdentity(pid);
-    if (
-      identity?.processGroupId === process.pid &&
-      identity.state !== 'Z'
-    ) {
-      members.push({ pid, processStartTicks: identity.processStartTicks });
-    }
-  }
-  return members;
-}
-
-const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
-async function finish(exitCode) {
-  if (finishing) return finishing;
-  finishing = (async () => {
-    try { process.kill(-process.pid, 'SIGTERM'); } catch {}
-    const deadline = Date.now() + 500;
-    while (ownedMembers().length > 0 && Date.now() < deadline) await sleep(25);
-    if (process.platform !== 'linux' && ownedMembers().length > 0) {
-      try { process.kill(-process.pid, 'SIGKILL'); } catch {}
-      return;
-    }
-    for (const member of ownedMembers()) {
-      const current = linuxIdentity(member.pid);
-      if (current?.processGroupId !== process.pid ||
-          current.processStartTicks !== member.processStartTicks) continue;
-      try { process.kill(member.pid, 'SIGKILL'); } catch {}
-    }
-    const killDeadline = Date.now() + 500;
-    while (ownedMembers().length > 0 && Date.now() < killDeadline) await sleep(25);
-    process.exit(exitCode);
-  })();
-  return finishing;
-}
-
-for (const signal of ['SIGTERM', 'SIGINT', 'SIGHUP']) {
-  process.on(signal, () => { void finish(0); });
-}
-const child = spawn(command, args, {
-  cwd: process.cwd(),
-  env: process.env,
-  detached: false,
-  shell: false,
-  stdio: 'inherit',
-});
-child.once('error', () => { void finish(1); });
-child.once('exit', (code, signal) => {
-  void finish(signal || code !== 0 ? (code || 1) : 0);
-});
-`;
-
-const children = new Set();
-const proxySockets = new Set();
-const upgradeSockets = new Set();
-let proxy;
-let proxyListening = false;
-let proxyOwnedPublicPort = false;
-let activeUpstream;
-let cacheUpstream;
-let sourceUpstream;
-let promoted = false;
-let cacheReadyAtMs = 0;
-let currentGenerationId = '';
-let shuttingDown = false;
-let shutdownPromise;
-let resolveLifetime;
-const lifetime = new Promise(resolve => {
-  resolveLifetime = resolve;
-});
-
-function positiveDuration(name, fallback) {
-  const value = Number(process.env[name] || fallback);
-  return Number.isFinite(value) && value > 0 ? value : fallback;
-}
-
-function validateRuntimeConfiguration() {
-  if (process.env.MIAODA_NEST_BUNDLE_HANDOFF_ENABLED !== 'true') {
-    throw new Error('MIAODA_NEST_BUNDLE_HANDOFF_DISABLED');
-  }
-  if (!bootId) throw new Error('MIAODA_STARTUP_BOOT_ID_REQUIRED');
-  if (!Number.isSafeInteger(restoreEpochMs) || restoreEpochMs <= 0) {
-    throw new Error('MIAODA_PLATFORM_ENV_NOT_BEFORE_MS_INVALID');
-  }
-  if (
-    !Number.isSafeInteger(publicPort) ||
-    publicPort <= 0 ||
-    publicPort > 65_535
-  ) {
-    throw new Error('MIAODA_NEST_PUBLIC_PORT_INVALID');
-  }
-}
-
-function readLinuxProcessStartTicks(pid) {
-  return readLinuxProcessIdentity(pid)?.processStartTicks;
-}
-
-function readLinuxProcessIdentity(pid) {
-  if (process.platform !== 'linux' || !Number.isSafeInteger(pid) || pid <= 0)
-    return undefined;
-  try {
-    const stat = fs.readFileSync(`/proc/${pid}/stat`, 'utf8');
-    const commandEnd = stat.lastIndexOf(')');
-    if (commandEnd < 0) return undefined;
-    const fieldsFromState = stat
-      .slice(commandEnd + 1)
-      .trim()
-      .split(/\s+/);
-    const startTicks = fieldsFromState[19];
-    const processGroupId = fieldsFromState[2];
-    return /^\d+$/.test(startTicks || '') && /^\d+$/.test(processGroupId || '')
-      ? {
-          state: fieldsFromState[0],
-          processStartTicks: startTicks,
-          processGroupId: Number(processGroupId),
-        }
-      : undefined;
-  } catch {
-    return undefined;
-  }
-}
-
-function hash(contents) {
-  return createHash('sha256').update(contents).digest('hex');
-}
-
-function hasExactKeys(value, expected) {
-  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
-  const actual = Object.keys(value).sort();
-  return (
-    actual.length === expected.length &&
-    actual.every((key, index) => key === [...expected].sort()[index])
-  );
-}
-
-function isInside(root, candidate) {
-  const relative = path.relative(root, candidate);
-  return (
-    relative === '' ||
-    (!relative.startsWith('..') && !path.isAbsolute(relative))
-  );
-}
-
-function walkFiles(root, directory, output) {
-  if (!fs.existsSync(directory)) return;
-  for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
-    if (
-      entry.name === 'node_modules' ||
-      (directory === root && rootSourceHashIgnoredDirectories.has(entry.name))
-    ) {
-      continue;
-    }
-    const candidate = path.join(directory, entry.name);
-    if (entry.isSymbolicLink()) {
-      throw new Error(
-        `MIAODA_NEST_SOURCE_SYMLINK_REJECTED:${path.relative(root, candidate)}`
-      );
-    }
-    if (entry.isDirectory()) walkFiles(root, candidate, output);
-    else if (entry.isFile()) output.push(candidate);
-    else {
-      throw new Error(
-        `MIAODA_NEST_SOURCE_SPECIAL_FILE_REJECTED:${path.relative(root, candidate)}`
-      );
-    }
-  }
-}
-
-function workspaceSourceSha256() {
-  const files = [];
-  walkFiles(projectRoot, projectRoot, files);
-  const digest = createHash('sha256');
-  for (const file of files.sort()) {
-    digest.update(path.relative(projectRoot, file).split(path.sep).join('/'));
-    digest.update('\0');
-    updateHashFromFile(digest, file);
-    digest.update('\0');
-  }
-  return digest.digest('hex');
-}
-
-function updateHashFromFile(digest, file) {
-  const descriptor = fs.openSync(file, 'r');
-  const buffer = Buffer.allocUnsafe(1024 * 1024);
-  try {
-    const before = fs.fstatSync(descriptor);
-    let position = 0;
-    while (position < before.size) {
-      const bytesRead = fs.readSync(
-        descriptor,
-        buffer,
-        0,
-        Math.min(buffer.length, before.size - position),
-        position
-      );
-      if (bytesRead === 0) break;
-      digest.update(buffer.subarray(0, bytesRead));
-      position += bytesRead;
-    }
-    const after = fs.fstatSync(descriptor);
-    if (
-      position !== before.size ||
-      after.size !== before.size ||
-      after.mtimeMs !== before.mtimeMs
-    ) {
-      throw new Error(`MIAODA_NEST_SOURCE_CHANGED_WHILE_HASHING:${file}`);
-    }
-  } finally {
-    fs.closeSync(descriptor);
-  }
-}
-
-function stableJson(value) {
-  if (Array.isArray(value)) return `[${value.map(stableJson).join(',')}]`;
-  if (value && typeof value === 'object') {
-    return `{${Object.entries(value)
-      .sort(([left], [right]) => compareCodeUnits(left, right))
-      .map(([key, item]) => `${JSON.stringify(key)}:${stableJson(item)}`)
-      .join(',')}}`;
-  }
-  return JSON.stringify(value);
-}
-
-function compareCodeUnits(left, right) {
-  return left < right ? -1 : left > right ? 1 : 0;
-}
-
-function runtimeIdentity() {
-  const header = process.report?.getReport()?.header;
-  return {
-    nodeVersion: process.versions.node,
-    nodeModulesAbi: process.versions.modules,
-    platform: process.platform,
-    arch: process.arch,
-    libc:
-      typeof header?.glibcVersionRuntime === 'string'
-        ? `glibc-${header.glibcVersionRuntime}`
-        : process.platform === 'linux'
-          ? 'linux-unknown-libc'
-          : 'not-applicable',
-  };
-}
-
-function validatedMetadataFile(generationRoot, name, maxBytes) {
-  const requested = path.join(generationRoot, name);
-  const requestedStats = fs.lstatSync(requested);
-  if (requestedStats.isSymbolicLink()) {
-    throw new Error(`MIAODA_NEST_CACHE_ARTIFACT_SYMLINK:${name}`);
-  }
-  if (!requestedStats.isFile() || requestedStats.size > maxBytes) {
-    throw new Error(`MIAODA_NEST_CACHE_METADATA_SIZE_INVALID:${name}`);
-  }
-  const real = fs.realpathSync(requested);
-  if (!isInside(generationRoot, real) || !fs.statSync(real).isFile()) {
-    throw new Error(`MIAODA_NEST_CACHE_ARTIFACT_ESCAPED:${name}`);
-  }
-  return real;
-}
-
-function validateFileIndex(generationRoot, manifest, fileIndexFile) {
-  const indexStats = fs.statSync(fileIndexFile);
-  if (indexStats.size > MAX_FILE_INDEX_BYTES) {
-    throw new Error('MIAODA_NEST_CACHE_FILE_INDEX_TOO_LARGE');
-  }
-  const indexContents = fs.readFileSync(fileIndexFile);
-  if (hash(indexContents) !== manifest.fileIndexSha256) {
-    throw new Error('MIAODA_NEST_CACHE_FILE_INDEX_HASH_MISMATCH');
-  }
-  const files = JSON.parse(indexContents.toString('utf8'));
-  if (
-    !Array.isArray(files) ||
-    files.length === 0 ||
-    files.length > MAX_GENERATION_FILES
-  ) {
-    throw new Error('MIAODA_NEST_CACHE_FILE_INDEX_INVALID');
-  }
-  const expected = new Map();
-  let previous = '';
-  let totalBytes = 0;
-  for (const file of files) {
-    if (
-      !hasExactKeys(file, ['path', 'sha256', 'size', 'mode']) ||
-      typeof file.path !== 'string' ||
-      !file.path.startsWith('payload/') ||
-      file.path.split('/').includes('node_modules') ||
-      file.path.includes('\\') ||
-      path.posix.isAbsolute(file.path) ||
-      path.posix.normalize(file.path) !== file.path ||
-      file.path <= previous ||
-      !/^[a-f0-9]{64}$/.test(file.sha256 || '') ||
-      !Number.isSafeInteger(file.size) ||
-      file.size < 0 ||
-      file.size > MAX_GENERATION_FILE_BYTES ||
-      !Number.isSafeInteger(file.mode) ||
-      file.mode < 0 ||
-      file.mode > 0o777
-    ) {
-      throw new Error('MIAODA_NEST_CACHE_FILE_INDEX_INVALID');
-    }
-    previous = file.path;
-    totalBytes += file.size;
-    if (totalBytes > MAX_GENERATION_BYTES) {
-      throw new Error('MIAODA_NEST_CACHE_GENERATION_TOO_LARGE');
-    }
-    expected.set(file.path, file);
-  }
-  const payloadRoot = path.join(generationRoot, 'payload');
-  if (fs.lstatSync(payloadRoot).isSymbolicLink()) {
-    throw new Error('MIAODA_NEST_CACHE_PAYLOAD_SYMLINK');
-  }
-  const realPayloadRoot = fs.realpathSync(payloadRoot);
-  if (!isInside(generationRoot, realPayloadRoot)) {
-    throw new Error('MIAODA_NEST_CACHE_PAYLOAD_ESCAPED');
-  }
-  const seen = new Set();
-  const visit = directory => {
-    for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
-      const requested = path.join(directory, entry.name);
-      if (entry.isSymbolicLink()) {
-        throw new Error('MIAODA_NEST_CACHE_PAYLOAD_SYMLINK');
-      }
-      if (entry.isDirectory()) {
-        if (entry.name === 'node_modules') {
-          throw new Error('MIAODA_NEST_CACHE_PAYLOAD_NODE_MODULES_FORBIDDEN');
-        }
-        visit(requested);
-        continue;
-      }
-      if (!entry.isFile()) {
-        throw new Error('MIAODA_NEST_CACHE_PAYLOAD_SPECIAL_FILE');
-      }
-      const real = fs.realpathSync(requested);
-      if (!isInside(realPayloadRoot, real)) {
-        throw new Error('MIAODA_NEST_CACHE_PAYLOAD_ESCAPED');
-      }
-      const relative = `payload/${path
-        .relative(realPayloadRoot, real)
-        .split(path.sep)
-        .join('/')}`;
-      const record = expected.get(relative);
-      const stats = fs.statSync(real);
-      const contents = fs.readFileSync(real);
-      if (
-        !record ||
-        stats.nlink !== 1 ||
-        contents.length !== record.size ||
-        (stats.mode & 0o777) !== record.mode ||
-        hash(contents) !== record.sha256
-      ) {
-        throw new Error(`MIAODA_NEST_CACHE_PAYLOAD_MISMATCH:${relative}`);
-      }
-      seen.add(relative);
-    }
-  };
-  visit(realPayloadRoot);
-  if (seen.size !== expected.size) {
-    throw new Error('MIAODA_NEST_CACHE_PAYLOAD_FILE_SET_MISMATCH');
-  }
-  return expected;
-}
-
-function readValidatedGeneration() {
-  const realProjectRoot = fs.realpathSync(projectRoot);
-  const realCacheRoot = fs.realpathSync(cacheRoot);
-  if (!isInside(realProjectRoot, realCacheRoot)) {
-    throw new Error('MIAODA_NEST_CACHE_ROOT_ESCAPED_PROJECT');
-  }
-  const requestedGenerationsRoot = path.join(realCacheRoot, 'generations');
-  if (fs.lstatSync(requestedGenerationsRoot).isSymbolicLink()) {
-    throw new Error('MIAODA_NEST_CACHE_GENERATIONS_SYMLINK');
-  }
-  const generationsRoot = fs.realpathSync(requestedGenerationsRoot);
-  if (!isInside(realCacheRoot, generationsRoot)) {
-    throw new Error('MIAODA_NEST_CACHE_GENERATIONS_ESCAPED');
-  }
-  const entries = fs.readdirSync(generationsRoot, { withFileTypes: true });
-  if (
-    entries.length !== 1 ||
-    !entries[0].isDirectory() ||
-    entries[0].isSymbolicLink() ||
-    !/^[a-f0-9]{64}$/.test(entries[0].name)
-  ) {
-    throw new Error('MIAODA_NEST_CACHE_GENERATION_SELECTION_INVALID');
-  }
-  const generationId = entries[0].name;
-  const requestedGenerationRoot = path.join(generationsRoot, generationId);
-  if (fs.lstatSync(requestedGenerationRoot).isSymbolicLink()) {
-    throw new Error('MIAODA_NEST_CACHE_GENERATION_SYMLINK');
-  }
-  const generationRoot = fs.realpathSync(requestedGenerationRoot);
-  if (!isInside(generationsRoot, generationRoot)) {
-    throw new Error('MIAODA_NEST_CACHE_GENERATION_ESCAPED');
-  }
-  const generationEntries = fs.readdirSync(generationRoot).sort();
-  if (
-    stableJson(generationEntries) !==
-    stableJson(['files.mtree.json', 'manifest.json', 'payload'])
-  ) {
-    throw new Error('MIAODA_NEST_CACHE_GENERATION_FILE_SET_INVALID');
-  }
-  const manifestFile = validatedMetadataFile(
-    generationRoot,
-    'manifest.json',
-    MAX_MANIFEST_BYTES
-  );
-  const fileIndexFile = validatedMetadataFile(
-    generationRoot,
-    'files.mtree.json',
-    MAX_FILE_INDEX_BYTES
-  );
-  const manifest = JSON.parse(fs.readFileSync(manifestFile, 'utf8'));
-  if (
-    !hasExactKeys(manifest, [
-      'schemaVersion',
-      'generationId',
-      'sourceSha256',
-      'expectedCapabilityIds',
-      'runtime',
-      'fileIndexSha256',
-    ]) ||
-    !hasExactKeys(manifest.runtime, [
-      'nodeVersion',
-      'nodeModulesAbi',
-      'platform',
-      'arch',
-      'libc',
-    ])
-  ) {
-    throw new Error('MIAODA_NEST_CACHE_MANIFEST_SCHEMA_INVALID');
-  }
-  if (
-    manifest.schemaVersion !== SCHEMA_VERSION ||
-    manifest.generationId !== generationId ||
-    !Array.isArray(manifest.expectedCapabilityIds) ||
-    manifest.expectedCapabilityIds.some(
-      (id, index) =>
-        typeof id !== 'string' ||
-        id.length === 0 ||
-        id.length > 256 ||
-        (index > 0 && id <= manifest.expectedCapabilityIds[index - 1])
-    ) ||
-    manifest.sourceSha256 !== workspaceSourceSha256() ||
-    stableJson(manifest.runtime) !== stableJson(runtimeIdentity()) ||
-    !/^[a-f0-9]{64}$/.test(manifest.fileIndexSha256 || '')
-  ) {
-    throw new Error('MIAODA_NEST_CACHE_MANIFEST_MISMATCH');
-  }
-  const files = validateFileIndex(generationRoot, manifest, fileIndexFile);
-  if (!files.has(BUNDLE_ENTRY)) {
-    throw new Error('MIAODA_NEST_CACHE_ENTRY_INVALID');
-  }
-  const computedGenerationId = hash(
-    stableJson({
-      expectedCapabilityIds: manifest.expectedCapabilityIds,
-      fileIndexSha256: manifest.fileIndexSha256,
-      runtime: manifest.runtime,
-      schemaVersion: manifest.schemaVersion,
-      sourceSha256: manifest.sourceSha256,
-    })
-  );
-  if (computedGenerationId !== generationId) {
-    throw new Error('MIAODA_NEST_CACHE_MANIFEST_MISMATCH:generationId');
-  }
-  const entryFile = path.join(generationRoot, ...BUNDLE_ENTRY.split('/'));
-  return {
-    generationId,
-    entryFile,
-    expectedCapabilityIds: manifest.expectedCapabilityIds,
-    workspaceNodeModulesPath: path.join(realProjectRoot, 'node_modules'),
-  };
-}
-
-function probeHost(host) {
-  if (!host || host === '0.0.0.0') return '127.0.0.1';
-  if (host === '::' || host === '[::]') return '::1';
-  return host.replace(/^\[|\]$/g, '');
-}
-
-function reservePort(host) {
-  return new Promise((resolve, reject) => {
-    const server = net.createServer();
-    server.once('error', reject);
-    server.listen(0, host, () => {
-      const address = server.address();
-      if (!address || typeof address === 'string') {
-        server.close(() =>
-          reject(new Error('MIAODA_NEST_INTERNAL_PORT_RESERVATION_FAILED'))
-        );
-        return;
-      }
-      server.close(error => (error ? reject(error) : resolve(address.port)));
-    });
-  });
-}
-
-function writeLog(stream, file, mirror) {
-  if (!stream) return;
-  const output = fs.createWriteStream(file, { flags: 'a', mode: 0o600 });
-  stream.on('data', chunk => {
-    output.write(chunk);
-    mirror.write(chunk);
-  });
-  stream.once('end', () => output.end());
-}
-
-function childRunning(record) {
-  const child = record?.child;
-  return Boolean(
-    child?.pid && child.exitCode === null && child.signalCode === null
-  );
-}
-
-export function ownedGroupRunning(
-  record,
-  {
-    readIdentity = readLinuxProcessIdentity,
-    listProcessIds = () => fs.readdirSync('/proc'),
-  } = {}
-) {
-  const pid = record?.child?.pid;
-  if (!pid) return false;
-  if (process.platform === 'linux') {
-    const leaderIdentity = readIdentity(pid);
-    if (
-      leaderIdentity &&
-      (leaderIdentity.processStartTicks !== record.processStartTicks ||
-        leaderIdentity.processGroupId !== pid)
-    ) {
-      return false;
-    }
-    // If the group leader already exited, Linux keeps its numeric process-group
-    // id reserved while owned descendants remain. A later foreign leader can
-    // only reuse the pid after the old group disappears, and is rejected above
-    // by its different birth identity. A zombie is already dead: it cannot hold
-    // a port or execute code, and a container PID 1 is not guaranteed to reap it
-    // promptly. Require at least one non-zombie member before signaling/waiting.
-    try {
-      for (const name of listProcessIds()) {
-        if (!/^\d+$/.test(name)) continue;
-        const member = readIdentity(Number(name));
-        if (member?.processGroupId === pid && member.state !== 'Z') {
-          const currentLeader = readIdentity(pid);
-          return Boolean(
-            !currentLeader ||
-            (currentLeader.processStartTicks === record.processStartTicks &&
-              currentLeader.processGroupId === pid)
-          );
-        }
-      }
-      return false;
-    } catch {}
-  }
-  try {
-    process.kill(-pid, 0);
-    return true;
-  } catch (error) {
-    return error?.code === 'EPERM';
-  }
-}
-
-function waitForChild(record) {
-  if (!childRunning(record)) return Promise.resolve();
-  return new Promise(resolve => record.child.once('exit', () => resolve()));
-}
-
-function isCapabilityReadinessPayload(contents, expectedCapabilityIds = []) {
-  if (contents.length > MAX_READINESS_RESPONSE_BYTES) return false;
-  try {
-    const payload = JSON.parse(contents.toString('utf8'));
-    if (
-      !(
-        payload &&
-        typeof payload === 'object' &&
-        payload.status_code === '0' &&
-        payload.data &&
-        typeof payload.data === 'object' &&
-        !Array.isArray(payload.data) &&
-        Array.isArray(payload.data.capabilities)
-      )
-    ) {
-      return false;
-    }
-    const actualIds = new Set(
-      payload.data.capabilities
-        .map(capability => capability?.id)
-        .filter(id => typeof id === 'string' && id.length > 0)
-    );
-    return expectedCapabilityIds.every(id => actualIds.has(id));
-  } catch {
-    return false;
-  }
-}
-
-function spawnOwned(name, command, args, options = {}) {
-  const child = spawn(
-    process.execPath,
-    ['-e', ownedProcessWrapperSource, command, JSON.stringify(args)],
-    {
-      cwd: projectRoot,
-      detached: true,
-      stdio: ['ignore', 'pipe', 'pipe'],
-      env: {
-        ...(options.baseEnv || process.env),
-        ...options.env,
-        PWD: projectRoot,
-      },
-      shell: false,
-    }
-  );
-  const childProcessStartTicks =
-    readLinuxProcessStartTicks(child.pid) ||
-    (process.platform === 'linux'
-      ? undefined
-      : String(Math.max(1, Date.now() * 1000 + (child.pid || 0))));
-  if (!child.pid || !childProcessStartTicks) {
-    if (child.pid) {
-      try {
-        process.kill(-child.pid, 'SIGKILL');
-      } catch {}
-    }
-    throw new Error(`MIAODA_NEST_CHILD_IDENTITY_UNAVAILABLE:${name}`);
-  }
-  const record = {
-    name,
-    child,
-    processStartTicks: childProcessStartTicks,
-    expectedExit: false,
-  };
-  children.add(record);
-  try {
-    publishProcessRegistry();
-  } catch (error) {
-    children.delete(record);
-    try {
-      process.kill(-child.pid, 'SIGKILL');
-    } catch {}
-    throw error;
-  }
-  const logFile = path.join(logDir, options.logName || `${name}.std.log`);
-  writeLog(child.stdout, logFile, process.stdout);
-  writeLog(child.stderr, logFile, process.stderr);
-  child.once('exit', (code, signal) => {
-    if (shuttingDown || record.expectedExit) return;
-    if (name === 'cache' && promoted) return;
-    if (name === 'source' && activeUpstream?.record !== record) return;
-    void shutdown(
-      `${name}-exit:${signal || (code ?? 1)}`,
-      code === 0 ? 1 : (code ?? 1)
-    );
-  });
-  child.once('error', error => {
-    if (
-      !shuttingDown &&
-      !record.expectedExit &&
-      !(name === 'source' && activeUpstream?.record !== record)
-    ) {
-      void shutdown(`${name}-spawn-error:${error.message}`, 1);
-    }
-  });
-  return record;
-}
-
-async function terminateOwned(record) {
-  record.expectedExit = true;
-  const pid = record.child.pid;
-  if (!pid) {
-    children.delete(record);
-    return;
-  }
-  const waitForGroup = async () => {
-    const deadline = Date.now() + shutdownTimeoutMs;
-    while (ownedGroupRunning(record) && Date.now() < deadline) {
-      await new Promise(resolve => setTimeout(resolve, 25));
-    }
-    return !ownedGroupRunning(record);
-  };
-  if (ownedGroupRunning(record)) {
-    try {
-      process.kill(-pid, 'SIGTERM');
-    } catch {}
-  }
-  if (!(await waitForGroup())) {
-    try {
-      process.kill(-pid, 'SIGKILL');
-    } catch {}
-    if (!(await waitForGroup())) {
-      throw new Error(
-        `MIAODA_NEST_OWNED_GROUP_STILL_RUNNING:${record.name}:${pid}`
-      );
-    }
-  }
-  await waitForChild(record);
-  children.delete(record);
-  publishProcessRegistry();
-}
-
-function waitForHttp(record, upstream, timeoutMs, expectedCapabilityIds) {
-  const deadline = Date.now() + timeoutMs;
-  return new Promise((resolve, reject) => {
-    let settled = false;
-    let retryTimer;
-    const finish = error => {
-      if (settled) return;
-      settled = true;
-      if (retryTimer) clearTimeout(retryTimer);
-      if (error) reject(error);
-      else resolve();
-    };
-    const retry = () => {
-      if (settled) return;
-      const remaining = deadline - Date.now();
-      if (remaining <= 0) {
-        finish(new Error(`${record.name} HTTP readiness timeout`));
-        return;
-      }
-      retryTimer = setTimeout(attempt, Math.min(50, remaining));
-    };
-    const attempt = () => {
-      if (settled) return;
-      if (shuttingDown)
-        return finish(new Error('MIAODA_NEST_RUNTIME_STOPPING'));
-      if (!childRunning(record))
-        return finish(new Error(`${record.name} exited before HTTP readiness`));
-      const remaining = deadline - Date.now();
-      if (remaining <= 0)
-        return finish(new Error(`${record.name} HTTP readiness timeout`));
-      let attemptSettled = false;
-      const request = http.get(
-        {
-          host: upstream.host,
-          port: upstream.port,
-          path: readinessPath,
-        },
-        response => {
-          if (attemptSettled || settled) {
-            response.destroy();
-            return;
-          }
-          if (response.statusCode !== 200) {
-            attemptSettled = true;
-            response.resume();
-            retry();
-            return;
-          }
-          const chunks = [];
-          let responseBytes = 0;
-          response.on('data', chunk => {
-            if (attemptSettled || settled) return;
-            const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-            responseBytes += buffer.length;
-            if (responseBytes > MAX_READINESS_RESPONSE_BYTES) {
-              attemptSettled = true;
-              response.destroy();
-              retry();
-              return;
-            }
-            chunks.push(buffer);
-          });
-          response.once('end', () => {
-            if (attemptSettled || settled) return;
-            attemptSettled = true;
-            if (
-              isCapabilityReadinessPayload(
-                Buffer.concat(chunks),
-                expectedCapabilityIds
-              )
-            )
-              finish();
-            else retry();
-          });
-          response.once('error', () => {
-            if (attemptSettled || settled) return;
-            attemptSettled = true;
-            retry();
-          });
-        }
-      );
-      request.setTimeout(remaining, () => {
-        request.destroy(new Error(`${record.name} HTTP readiness timeout`));
-      });
-      request.once('error', error => {
-        if (attemptSettled || settled) return;
-        attemptSettled = true;
-        if (
-          Date.now() >= deadline ||
-          error.message === `${record.name} HTTP readiness timeout`
-        ) {
-          finish(new Error(`${record.name} HTTP readiness timeout`));
-        } else {
-          retry();
-        }
-      });
-    };
-    attempt();
-  });
-}
-
-function retain(upstream) {
-  upstream.inflight += 1;
-  let released = false;
-  return () => {
-    if (released) return;
-    released = true;
-    upstream.inflight = Math.max(0, upstream.inflight - 1);
-  };
-}
-
-function createProxy() {
-  const server = http.createServer((request, response) => {
-    const upstream = activeUpstream;
-    if (!upstream) {
-      response.writeHead(503, { 'content-type': 'application/json' });
-      response.end('{"error":"MIAODA_NEST_UPSTREAM_PENDING"}\n');
-      return;
-    }
-    const release = retain(upstream);
-    const upstreamRequest = http.request(
-      {
-        host: upstream.host,
-        port: upstream.port,
-        method: request.method,
-        path: request.url,
-        headers: request.headers,
-      },
-      upstreamResponse => {
-        response.writeHead(
-          upstreamResponse.statusCode || 502,
-          upstreamResponse.statusMessage || '',
-          upstreamResponse.headers
-        );
-        upstreamResponse.pipe(response);
-      }
-    );
-    upstreamRequest.once('error', error => {
-      if (!response.headersSent) {
-        response.writeHead(502, { 'content-type': 'application/json' });
-        response.end(
-          `${JSON.stringify({ error: 'MIAODA_NEST_UPSTREAM_UNAVAILABLE', upstream: upstream.name })}\n`
-        );
-      } else {
-        response.destroy(error);
-      }
-    });
-    request.once('aborted', () => upstreamRequest.destroy());
-    response.once('finish', release);
-    response.once('close', release);
-    request.pipe(upstreamRequest);
-  });
-  server.on('connection', socket => {
-    proxySockets.add(socket);
-    socket.once('close', () => proxySockets.delete(socket));
-  });
-  server.on('upgrade', (request, clientSocket, head) => {
-    const upstream = activeUpstream;
-    if (!upstream) return clientSocket.destroy();
-    const release = retain(upstream);
-    const upstreamSocket = net.createConnection({
-      host: upstream.host,
-      port: upstream.port,
-    });
-    upgradeSockets.add(clientSocket);
-    upgradeSockets.add(upstreamSocket);
-    let released = false;
-    const close = () => {
-      if (!released) {
-        released = true;
-        release();
-      }
-      upgradeSockets.delete(clientSocket);
-      upgradeSockets.delete(upstreamSocket);
-      clientSocket.destroy();
-      upstreamSocket.destroy();
-    };
-    upstreamSocket.once('connect', () => {
-      let headers = `${request.method} ${request.url} HTTP/${request.httpVersion}\r\n`;
-      for (let index = 0; index < request.rawHeaders.length; index += 2) {
-        headers += `${request.rawHeaders[index]}: ${request.rawHeaders[index + 1]}\r\n`;
-      }
-      upstreamSocket.write(`${headers}\r\n`);
-      if (head.length > 0) upstreamSocket.write(head);
-      clientSocket.pipe(upstreamSocket).pipe(clientSocket);
-    });
-    clientSocket.once('error', close);
-    clientSocket.once('close', close);
-    upstreamSocket.once('error', close);
-    upstreamSocket.once('close', close);
-  });
-  return server;
-}
-
-function listenProxy() {
-  proxy = createProxy();
-  return new Promise((resolve, reject) => {
-    const onError = error => {
-      proxy.off('listening', onListening);
-      reject(error);
-    };
-    const onListening = () => {
-      proxy.off('error', onError);
-      proxyListening = true;
-      proxyOwnedPublicPort = true;
-      resolve();
-    };
-    proxy.once('error', onError);
-    proxy.once('listening', onListening);
-    proxy.listen(publicPort, publicHost);
-  });
-}
-
-function assertNoSymlinkParents(file, label = 'OWNER') {
-  let current = path.dirname(file);
-  const existing = [];
-  while (!fs.existsSync(current)) {
-    existing.push(current);
-    const parent = path.dirname(current);
-    if (parent === current) break;
-    current = parent;
-  }
-  while (true) {
-    if (fs.lstatSync(current).isSymbolicLink())
-      throw new Error(`MIAODA_RUNTIME_${label}_PARENT_SYMLINK`);
-    const parent = path.dirname(current);
-    if (parent === current) break;
-    current = parent;
-  }
-  for (const directory of existing.reverse())
-    fs.mkdirSync(directory, { mode: 0o700 });
-}
-
-function atomicWritePrivateJson(file, payload, label) {
-  assertNoSymlinkParents(file, label);
-  if (fs.existsSync(file) && fs.lstatSync(file).isSymbolicLink()) {
-    throw new Error(`MIAODA_RUNTIME_${label}_TARGET_SYMLINK`);
-  }
-  const temporary = `${file}.${process.pid}.${randomUUID()}.tmp`;
-  const flags =
-    fs.constants.O_WRONLY |
-    fs.constants.O_CREAT |
-    fs.constants.O_EXCL |
-    (fs.constants.O_NOFOLLOW || 0);
-  const fd = fs.openSync(temporary, flags, 0o600);
-  try {
-    fs.writeFileSync(fd, `${JSON.stringify(payload)}\n`);
-    fs.fsyncSync(fd);
-  } finally {
-    fs.closeSync(fd);
-  }
-  try {
-    fs.renameSync(temporary, file);
-  } finally {
-    if (fs.existsSync(temporary)) fs.unlinkSync(temporary);
-  }
-}
-
-function readPrivateJson(file, validator) {
-  try {
-    const stat = fs.lstatSync(file);
-    if (stat.isSymbolicLink() || !stat.isFile()) return undefined;
-    const fd = fs.openSync(
-      file,
-      fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW || 0)
-    );
-    try {
-      const opened = fs.fstatSync(fd);
-      if (
-        !opened.isFile() ||
-        opened.dev !== stat.dev ||
-        opened.ino !== stat.ino
-      )
-        return undefined;
-      const payload = JSON.parse(fs.readFileSync(fd, 'utf8'));
-      return validator(payload) ? payload : undefined;
-    } finally {
-      fs.closeSync(fd);
-    }
-  } catch {
-    return undefined;
-  }
-}
-
-const OWNER_KEYS = [
-  'schemaVersion',
-  'bootId',
-  'restoreEpochMs',
-  'generationId',
-  'pid',
-  'processStartTicks',
-  'publicPort',
-  'createdAtMs',
-];
-
-function ownerPayloadIsStrict(payload) {
-  return (
-    hasExactKeys(payload, OWNER_KEYS) &&
-    payload.schemaVersion === 1 &&
-    typeof payload.bootId === 'string' &&
-    payload.bootId.length > 0 &&
-    Number.isSafeInteger(payload.restoreEpochMs) &&
-    payload.restoreEpochMs > 0 &&
-    typeof payload.generationId === 'string' &&
-    /^[a-f0-9]{64}$/.test(payload.generationId) &&
-    Number.isSafeInteger(payload.pid) &&
-    payload.pid > 0 &&
-    typeof payload.processStartTicks === 'string' &&
-    /^\d+$/.test(payload.processStartTicks) &&
-    Number.isSafeInteger(payload.publicPort) &&
-    payload.publicPort > 0 &&
-    payload.publicPort <= 65_535 &&
-    Number.isSafeInteger(payload.createdAtMs) &&
-    payload.createdAtMs >= payload.restoreEpochMs
-  );
-}
-
-function readStrictOwnerMarker() {
-  return readPrivateJson(ownerFile, ownerPayloadIsStrict);
-}
-
-function ownerProcessIdentityIsLive(owner) {
-  if (!ownerPayloadIsStrict(owner)) return false;
-  if (owner.pid === process.pid)
-    return owner.processStartTicks === processStartTicks;
-  const actualStartTicks = readLinuxProcessStartTicks(owner.pid);
-  return Boolean(
-    actualStartTicks && actualStartTicks === owner.processStartTicks
-  );
-}
-
-const PROCESS_REGISTRY_KEYS = [
-  'schemaVersion',
-  'bootId',
-  'restoreEpochMs',
-  'runtimePid',
-  'runtimeProcessStartTicks',
-  'updatedAtMs',
-  'processes',
-];
-
-function processRegistryPayloadIsStrict(payload) {
-  if (
-    !hasExactKeys(payload, PROCESS_REGISTRY_KEYS) ||
-    payload.schemaVersion !== 1 ||
-    typeof payload.bootId !== 'string' ||
-    payload.bootId.length === 0 ||
-    !Number.isSafeInteger(payload.restoreEpochMs) ||
-    payload.restoreEpochMs <= 0 ||
-    !Number.isSafeInteger(payload.runtimePid) ||
-    payload.runtimePid <= 0 ||
-    typeof payload.runtimeProcessStartTicks !== 'string' ||
-    !/^\d+$/.test(payload.runtimeProcessStartTicks) ||
-    !Number.isSafeInteger(payload.updatedAtMs) ||
-    payload.updatedAtMs < payload.restoreEpochMs ||
-    !Array.isArray(payload.processes)
-  ) {
-    return false;
-  }
-  const roles = new Set();
-  for (const owned of payload.processes) {
-    if (
-      !hasExactKeys(owned, ['role', 'pid', 'processStartTicks']) ||
-      !['cache', 'source', 'action-plugin-init'].includes(owned.role) ||
-      roles.has(owned.role) ||
-      !Number.isSafeInteger(owned.pid) ||
-      owned.pid <= 0 ||
-      typeof owned.processStartTicks !== 'string' ||
-      !/^\d+$/.test(owned.processStartTicks)
-    ) {
-      return false;
-    }
-    roles.add(owned.role);
-  }
-  return true;
-}
-
-function registryRuntimeIdentityIsLive(registry) {
-  if (!processRegistryPayloadIsStrict(registry)) return false;
-  if (registry.runtimePid === process.pid) {
-    return registry.runtimeProcessStartTicks === processStartTicks;
-  }
-  const actualStartTicks = readLinuxProcessStartTicks(registry.runtimePid);
-  return Boolean(
-    actualStartTicks && actualStartTicks === registry.runtimeProcessStartTicks
-  );
-}
-
-function publishProcessRegistry() {
-  const existing = readPrivateJson(
-    processRegistryFile,
-    processRegistryPayloadIsStrict
-  );
-  if (
-    existing &&
-    registryRuntimeIdentityIsLive(existing) &&
-    (existing.runtimePid !== process.pid ||
-      existing.runtimeProcessStartTicks !== processStartTicks)
-  ) {
-    throw new Error('MIAODA_RUNTIME_PROCESS_REGISTRY_ALREADY_LIVE');
-  }
-  const processes = [...children]
-    .filter(record => record.child?.pid && record.processStartTicks)
-    .map(record => ({
-      role: record.name,
-      pid: record.child.pid,
-      processStartTicks: record.processStartTicks,
-    }))
-    .sort((left, right) => left.role.localeCompare(right.role));
-  atomicWritePrivateJson(
-    processRegistryFile,
-    {
-      schemaVersion: 1,
-      bootId,
-      restoreEpochMs,
-      runtimePid: process.pid,
-      runtimeProcessStartTicks: processStartTicks,
-      updatedAtMs: Date.now(),
-      processes,
-    },
-    'PROCESS_REGISTRY'
-  );
-}
-
-function removeOwnedProcessRegistry() {
-  try {
-    const before = fs.lstatSync(processRegistryFile);
-    if (before.isSymbolicLink()) return;
-    const fd = fs.openSync(
-      processRegistryFile,
-      fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW || 0)
-    );
-    let payload;
-    let opened;
-    try {
-      opened = fs.fstatSync(fd);
-      payload = JSON.parse(fs.readFileSync(fd, 'utf8'));
-    } finally {
-      fs.closeSync(fd);
-    }
-    const after = fs.lstatSync(processRegistryFile);
-    if (
-      processRegistryPayloadIsStrict(payload) &&
-      payload.runtimePid === process.pid &&
-      payload.runtimeProcessStartTicks === processStartTicks &&
-      payload.bootId === bootId &&
-      payload.restoreEpochMs === restoreEpochMs &&
-      opened.isFile() &&
-      before.dev === opened.dev &&
-      before.ino === opened.ino &&
-      before.dev === after.dev &&
-      before.ino === after.ino
-    ) {
-      fs.unlinkSync(processRegistryFile);
-    }
-  } catch {}
-}
-
-function publishOwner(generationId) {
-  assertNoSymlinkParents(ownerFile, 'OWNER');
-  if (fs.existsSync(ownerFile)) {
-    const target = fs.lstatSync(ownerFile);
-    if (target.isSymbolicLink())
-      throw new Error('MIAODA_RUNTIME_OWNER_TARGET_SYMLINK');
-    const existingOwner = readStrictOwnerMarker();
-    if (existingOwner && ownerProcessIdentityIsLive(existingOwner)) {
-      throw new Error('MIAODA_RUNTIME_OWNER_ALREADY_LIVE');
-    }
-  }
-  const payload = {
-    schemaVersion: 1,
-    bootId,
-    restoreEpochMs,
-    generationId,
-    pid: process.pid,
-    processStartTicks,
-    publicPort,
-    createdAtMs: Date.now(),
-  };
-  atomicWritePrivateJson(ownerFile, payload, 'OWNER');
-}
-
-const HANDOFF_STATE_KEYS = [
-  'schemaVersion',
-  'bootId',
-  'restoreEpochMs',
-  'generationId',
-  'runtimePid',
-  'runtimeProcessStartTicks',
-  'phase',
-  'activeUpstream',
-  'publicPort',
-  'cachePort',
-  'sourcePort',
-  'cacheReadyAtMs',
-  'sourcePromotedAtMs',
-  'updatedAtMs',
-];
-
-function handoffStatePayloadIsStrict(payload) {
-  return (
-    hasExactKeys(payload, HANDOFF_STATE_KEYS) &&
-    payload.schemaVersion === 1 &&
-    payload.bootId === bootId &&
-    payload.restoreEpochMs === restoreEpochMs &&
-    /^[a-f0-9]{64}$/.test(payload.generationId || '') &&
-    payload.runtimePid === process.pid &&
-    payload.runtimeProcessStartTicks === processStartTicks &&
-    ['cache-ready', 'source-promoted'].includes(payload.phase) &&
-    payload.activeUpstream ===
-      (payload.phase === 'cache-ready' ? 'cache' : 'source') &&
-    payload.publicPort === publicPort &&
-    Number.isSafeInteger(payload.cachePort) &&
-    payload.cachePort > 0 &&
-    (payload.sourcePort === null ||
-      (Number.isSafeInteger(payload.sourcePort) && payload.sourcePort > 0)) &&
-    Number.isSafeInteger(payload.cacheReadyAtMs) &&
-    payload.cacheReadyAtMs >= restoreEpochMs &&
-    (payload.sourcePromotedAtMs === null ||
-      (Number.isSafeInteger(payload.sourcePromotedAtMs) &&
-        payload.sourcePromotedAtMs >= payload.cacheReadyAtMs)) &&
-    Number.isSafeInteger(payload.updatedAtMs) &&
-    payload.updatedAtMs >= payload.cacheReadyAtMs
-  );
-}
-
-function publishHandoffState(phase, sourcePort = null) {
-  const now = Date.now();
-  if (!cacheReadyAtMs) cacheReadyAtMs = now;
-  const payload = {
-    schemaVersion: 1,
-    bootId,
-    restoreEpochMs,
-    generationId: currentGenerationId,
-    runtimePid: process.pid,
-    runtimeProcessStartTicks: processStartTicks,
-    phase,
-    activeUpstream: phase === 'cache-ready' ? 'cache' : 'source',
-    publicPort,
-    cachePort: cacheUpstream.port,
-    sourcePort,
-    cacheReadyAtMs,
-    sourcePromotedAtMs: phase === 'source-promoted' ? now : null,
-    updatedAtMs: now,
-  };
-  if (!handoffStatePayloadIsStrict(payload)) {
-    throw new Error('MIAODA_NEST_HANDOFF_STATE_INVALID');
-  }
-  atomicWritePrivateJson(handoffStateFile, payload, 'HANDOFF_STATE');
-  process.stderr.write(
-    `${JSON.stringify({
-      event:
-        phase === 'cache-ready'
-          ? 'miaoda_nest_cache_ready'
-          : 'miaoda_nest_source_promoted',
-      bootId,
-      generationId: currentGenerationId,
-      publicPort,
-      cachePort: cacheUpstream.port,
-      sourcePort,
-      elapsedMs: now - restoreEpochMs,
-    })}\n`
-  );
-}
-
-function removeOwnedHandoffState() {
-  try {
-    const before = fs.lstatSync(handoffStateFile);
-    if (before.isSymbolicLink()) return;
-    const fd = fs.openSync(
-      handoffStateFile,
-      fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW || 0)
-    );
-    let payload;
-    let opened;
-    try {
-      opened = fs.fstatSync(fd);
-      payload = JSON.parse(fs.readFileSync(fd, 'utf8'));
-    } finally {
-      fs.closeSync(fd);
-    }
-    const after = fs.lstatSync(handoffStateFile);
-    if (
-      handoffStatePayloadIsStrict(payload) &&
-      opened.isFile() &&
-      before.dev === opened.dev &&
-      before.ino === opened.ino &&
-      before.dev === after.dev &&
-      before.ino === after.ino
-    ) {
-      fs.unlinkSync(handoffStateFile);
-    }
-  } catch {}
-}
-
-function removeOwnedMarker() {
-  try {
-    const before = fs.lstatSync(ownerFile);
-    if (before.isSymbolicLink()) return;
-    const fd = fs.openSync(
-      ownerFile,
-      fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW || 0)
-    );
-    let payload;
-    let opened;
-    try {
-      opened = fs.fstatSync(fd);
-      payload = JSON.parse(fs.readFileSync(fd, 'utf8'));
-    } finally {
-      fs.closeSync(fd);
-    }
-    const after = fs.lstatSync(ownerFile);
-    if (
-      ownerPayloadIsStrict(payload) &&
-      payload?.pid === process.pid &&
-      payload?.processStartTicks === processStartTicks &&
-      payload?.bootId === bootId &&
-      Number(payload?.restoreEpochMs) === restoreEpochMs &&
-      opened.isFile() &&
-      before.dev === opened.dev &&
-      before.ino === opened.ino &&
-      before.dev === after.dev &&
-      before.ino === after.ino
-    ) {
-      fs.unlinkSync(ownerFile);
-    }
-  } catch {}
-}
-
-function receiptReady(expectedGenerationId) {
-  try {
-    const receipt = JSON.parse(fs.readFileSync(receiptFile, 'utf8'));
-    if (
-      receipt?.schemaVersion !== 1 ||
-      receipt.bootId !== bootId ||
-      Number(receipt.restoreEpochMs) !== restoreEpochMs ||
-      receipt.generationId !== expectedGenerationId ||
-      typeof receipt.nodeModulesPath !== 'string'
-    )
-      return false;
-    const nodeModules = fs.realpathSync(receipt.nodeModulesPath);
-    return (
-      fs.statSync(nodeModules).isDirectory() &&
-      isInside(fs.realpathSync(projectRoot), nodeModules)
-    );
-  } catch {
-    return false;
-  }
-}
-
-function parseRuntimeEnvironment(contents) {
-  const environment = Object.create(null);
-  const lines = contents.split(/\r?\n/);
-  for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
-    const rawLine = lines[lineIndex];
-    const line = rawLine.trim();
-    if (!line || line.startsWith('#')) continue;
-    const assignment = line.match(
-      /^export[ \t]+([A-Za-z_][A-Za-z0-9_]*)[ \t]*=[ \t]*/
-    );
-    if (!assignment)
-      throw new Error(`MIAODA_RUNTIME_ENV_INVALID_LINE:${lineIndex + 1}`);
-    const key = assignment[1];
-    if (Object.hasOwn(environment, key)) {
-      throw new Error(`MIAODA_RUNTIME_ENV_DUPLICATE_KEY:${lineIndex + 1}`);
-    }
-    let encoded = line.slice(assignment[0].length);
-    if (!encoded.startsWith('"')) {
-      throw new Error(
-        `MIAODA_RUNTIME_ENV_VALUE_NOT_DOUBLE_QUOTED:${lineIndex + 1}`
-      );
-    }
-    let value = '';
-    let closedAt = -1;
-    let index = 1;
-    while (closedAt < 0) {
-      for (; index < encoded.length; index += 1) {
-        const character = encoded[index];
-        if (character === '"') {
-          closedAt = index;
-          break;
-        }
-        if (character === '\\') {
-          const next = encoded[index + 1];
-          if (next === undefined) break;
-          if (next === '\\' || next === '"') value += next;
-          else value += `\\${next}`;
-          index += 1;
-        } else {
-          if (character === '\0') {
-            throw new Error(`MIAODA_RUNTIME_ENV_NUL:${lineIndex + 1}`);
-          }
-          value += character;
-        }
-      }
-      if (closedAt >= 0) break;
-      if (lineIndex + 1 >= lines.length) {
-        throw new Error(
-          `MIAODA_RUNTIME_ENV_UNTERMINATED_VALUE:${lineIndex + 1}`
-        );
-      }
-      if (encoded.endsWith('\\')) value += '\\';
-      value += '\n';
-      encoded += `\n${lines[(lineIndex += 1)]}`;
-      index += 1;
-    }
-    if (encoded.slice(closedAt + 1).trim() !== '') {
-      throw new Error(`MIAODA_RUNTIME_ENV_UNTERMINATED_VALUE:${lineIndex + 1}`);
-    }
-    if (!RUNTIME_CONTROL_ENV_KEYS.has(key)) environment[key] = value;
-  }
-  return environment;
-}
-
-function readRuntimeEnvironment() {
-  const requested = fs.lstatSync(runtimeEnvFile);
-  if (requested.isSymbolicLink())
-    throw new Error('MIAODA_RUNTIME_ENV_FILE_SYMLINK');
-  const realFile = fs.realpathSync(runtimeEnvFile);
-  if (
-    !isInside(fs.realpathSync(platformWorkspaceRoot), realFile) ||
-    !fs.statSync(realFile).isFile()
-  ) {
-    throw new Error('MIAODA_RUNTIME_ENV_FILE_ESCAPED_WORKSPACE');
-  }
-  const size = fs.statSync(realFile).size;
-  if (size > 1024 * 1024) throw new Error('MIAODA_RUNTIME_ENV_FILE_TOO_LARGE');
-  return parseRuntimeEnvironment(fs.readFileSync(realFile, 'utf8'));
-}
-
-async function waitForReceipt(expectedGenerationId) {
-  while (!shuttingDown && !receiptReady(expectedGenerationId)) {
-    await new Promise(resolve => setTimeout(resolve, 50));
-  }
-  if (shuttingDown) throw new Error('MIAODA_NEST_RUNTIME_STOPPING');
-}
-
-async function runActionPluginInit(baseEnv) {
-  const record = spawnOwned(
-    'action-plugin-init',
-    process.platform === 'win32' ? 'fullstack-cli.cmd' : 'fullstack-cli',
-    ['action-plugin', 'init'],
-    { baseEnv, logName: 'server-handoff.std.log' }
-  );
-  record.expectedExit = true;
-  await waitForChild(record);
-  const exitCode = record.child.exitCode;
-  await terminateOwned(record);
-  if (exitCode !== 0) {
-    process.stderr.write(
-      `${JSON.stringify({
-        event: 'miaoda_action_plugin_init_failed',
-        exitCode,
-        continueStartup: true,
-      })}\n`
-    );
-  }
-}
-
-async function waitForDrain(upstream) {
-  const deadline = Date.now() + drainTimeoutMs;
-  while (upstream.inflight > 0 && Date.now() < deadline && !shuttingDown) {
-    await new Promise(resolve => setTimeout(resolve, 25));
-  }
-}
-
-function reportSourcePromotionFailure(stage, error, retryDelayMs) {
-  process.stderr.write(
-    `${JSON.stringify({
-      event: 'miaoda_nest_source_promotion_retry',
-      stage,
-      error: error instanceof Error ? error.message : String(error),
-      retryDelayMs,
-      cacheContinuesServing: true,
-    })}\n`
-  );
-}
-
-async function waitForSourceRetry(delayMs) {
-  const deadline = Date.now() + delayMs;
-  while (!shuttingDown && Date.now() < deadline) {
-    await new Promise(resolve =>
-      setTimeout(resolve, Math.min(50, deadline - Date.now()))
-    );
-  }
-}
-
-async function startAndPromoteSource(baseEnv, expectedCapabilityIds) {
-  const sourcePort = await reservePort(probeHost(publicHost));
-  const candidate = {
-    name: 'source',
-    host: probeHost(publicHost),
-    port: sourcePort,
-    inflight: 0,
-  };
-  sourceUpstream = candidate;
-  const sourceRecord = spawnOwned(
-    'source',
-    process.platform === 'win32' ? 'npm.cmd' : 'npm',
-    ['run', 'dev:server'],
-    {
-      baseEnv,
-      env: {
-        SERVER_HOST: candidate.host,
-        SERVER_PORT: String(sourcePort),
-      },
-      logName: 'server.std.log',
-    }
-  );
-  candidate.record = sourceRecord;
-  try {
-    await waitForHttp(
-      sourceRecord,
-      candidate,
-      sourceReadyTimeoutMs,
-      expectedCapabilityIds
-    );
-  } catch (error) {
-    try {
-      await terminateOwned(sourceRecord);
-    } catch (cleanupError) {
-      if (sourceUpstream === candidate) sourceUpstream = undefined;
-      await shutdown(
-        `source-cleanup-failed:${
-          cleanupError instanceof Error
-            ? cleanupError.message
-            : String(cleanupError)
-        }`,
-        1
-      );
-      throw cleanupError;
-    }
-    if (sourceUpstream === candidate) sourceUpstream = undefined;
-    throw error;
-  }
-  activeUpstream = candidate;
-  try {
-    await waitForDrain(cacheUpstream);
-    await terminateOwned(cacheUpstream.record);
-    publishHandoffState('source-promoted', candidate.port);
-    promoted = true;
-  } catch (error) {
-    await shutdown(
-      `miaoda_nest_source_cutover_finalize_failed:${
-        error instanceof Error ? error.message : String(error)
-      }`,
-      1
-    );
-    throw error;
-  }
-}
-
-async function promoteSource(expectedGenerationId, expectedCapabilityIds) {
-  await waitForReceipt(expectedGenerationId);
-  let retryDelayMs = SOURCE_RETRY_INITIAL_DELAY_MS;
-  let baseEnv;
-  while (!shuttingDown && !baseEnv) {
-    try {
-      baseEnv = { ...process.env, ...readRuntimeEnvironment() };
-      await runActionPluginInit(baseEnv);
-    } catch (error) {
-      baseEnv = undefined;
-      reportSourcePromotionFailure('environment-and-init', error, retryDelayMs);
-      await waitForSourceRetry(retryDelayMs);
-      retryDelayMs = Math.min(retryDelayMs * 2, SOURCE_RETRY_MAX_DELAY_MS);
-    }
-  }
-  retryDelayMs = SOURCE_RETRY_INITIAL_DELAY_MS;
-  while (!shuttingDown && !promoted) {
-    try {
-      await startAndPromoteSource(baseEnv, expectedCapabilityIds);
-    } catch (error) {
-      if (shuttingDown) break;
-      reportSourcePromotionFailure('source-readiness', error, retryDelayMs);
-      await waitForSourceRetry(retryDelayMs);
-      retryDelayMs = Math.min(retryDelayMs * 2, SOURCE_RETRY_MAX_DELAY_MS);
-    }
-  }
-}
-
-function closeProxyBounded() {
-  if (!proxy || !proxyListening) return Promise.resolve();
-  proxyListening = false;
-  return new Promise(resolve => {
-    let settled = false;
-    let timer;
-    const finish = () => {
-      if (settled) return;
-      settled = true;
-      if (timer) clearTimeout(timer);
-      resolve();
-    };
-    proxy.close(finish);
-    timer = setTimeout(() => {
-      for (const socket of proxySockets) socket.destroy();
-      for (const socket of upgradeSockets) socket.destroy();
-      proxy.closeAllConnections?.();
-      finish();
-    }, shutdownTimeoutMs);
-    timer.unref?.();
-  });
-}
-
-function verifyOwnedPortReleased() {
-  if (!proxyOwnedPublicPort) return Promise.resolve();
-  return new Promise((resolve, reject) => {
-    const server = net.createServer();
-    server.once('error', reject);
-    server.listen(publicPort, publicHost, () => {
-      server.close(error => (error ? reject(error) : resolve()));
-    });
-  });
-}
-
-function shutdown(reason, exitCode = 0) {
-  if (shutdownPromise) return shutdownPromise;
-  shuttingDown = true;
-  shutdownPromise = (async () => {
-    process.stderr.write(
-      `${JSON.stringify({ event: 'miaoda_nest_handoff_shutdown', reason, exitCode })}\n`
-    );
-    await closeProxyBounded();
-    const terminations = await Promise.allSettled(
-      [...children].map(record => terminateOwned(record))
-    );
-    let ownedProcessesReleased = true;
-    for (const result of terminations) {
-      if (result.status !== 'rejected') continue;
-      ownedProcessesReleased = false;
-      process.stderr.write(
-        `${JSON.stringify({
-          event: 'miaoda_nest_owned_group_release_failed',
-          error:
-            result.reason instanceof Error
-              ? result.reason.message
-              : String(result.reason),
-        })}\n`
-      );
-      exitCode = exitCode || 1;
-    }
-    try {
-      await verifyOwnedPortReleased();
-    } catch (error) {
-      process.stderr.write(
-        `${JSON.stringify({
-          event: 'miaoda_nest_public_port_release_failed',
-          error: error instanceof Error ? error.message : String(error),
-        })}\n`
-      );
-      exitCode = exitCode || 1;
-    }
-    removeOwnedHandoffState();
-    removeOwnedMarker();
-    if (ownedProcessesReleased) removeOwnedProcessRegistry();
-    process.exitCode = exitCode;
-    resolveLifetime();
-  })();
-  return shutdownPromise;
-}
-
-async function main() {
-  validateRuntimeConfiguration();
-  fs.mkdirSync(logDir, { recursive: true });
-  const generation = readValidatedGeneration();
-  currentGenerationId = generation.generationId;
-  const cachePort = await reservePort(probeHost(publicHost));
-  cacheUpstream = {
-    name: 'cache',
-    host: probeHost(publicHost),
-    port: cachePort,
-    inflight: 0,
-  };
-  cacheUpstream.record = spawnOwned(
-    'cache',
-    process.execPath,
-    [generation.entryFile],
-    {
-      env: {
-        NODE_PATH: generation.workspaceNodeModulesPath,
-        NODE_OPTIONS: '',
-        NODE_ENV: 'development',
-        SERVER_HOST: cacheUpstream.host,
-        SERVER_PORT: String(cachePort),
-        MIAODA_SERVER_CACHE_PROBE: '',
-        DEPRECATED_SKIP_INIT_DB_CONNECTION:
-          process.env.DEPRECATED_SKIP_INIT_DB_CONNECTION || 'true',
-        FORCE_AUTHN_INNERAPI_DOMAIN:
-          process.env.FORCE_AUTHN_INNERAPI_DOMAIN || 'http://127.0.0.1',
-        FORCE_AUTHN_ACCESS_KEY:
-          process.env.FORCE_AUTHN_ACCESS_KEY || 'server-startup-cache',
-        FORCE_AUTHN_ACCESS_SECRET:
-          process.env.FORCE_AUTHN_ACCESS_SECRET || 'server-startup-cache',
-      },
-      logName: 'server-cache.std.log',
-    }
-  );
-  await waitForHttp(
-    cacheUpstream.record,
-    cacheUpstream,
-    sourceReadyTimeoutMs,
-    generation.expectedCapabilityIds
-  );
-  activeUpstream = cacheUpstream;
-  await listenProxy();
-  publishOwner(generation.generationId);
-  publishHandoffState('cache-ready');
-  void promoteSource(
-    generation.generationId,
-    generation.expectedCapabilityIds
-  ).catch(error => {
-    if (!shuttingDown) {
-      process.stderr.write(
-        `${JSON.stringify({
-          event: 'miaoda_nest_source_promotion_stopped',
-          error: error instanceof Error ? error.message : String(error),
-          cacheContinuesServing: true,
-        })}\n`
-      );
-    }
-  });
-  await lifetime;
-}
-
-function isDirectExecution() {
-  if (!process.argv[1]) return false;
-  try {
-    return (
-      fs.realpathSync(process.argv[1]) ===
-      fs.realpathSync(fileURLToPath(import.meta.url))
-    );
-  } catch {
-    return false;
-  }
-}
-
-if (isDirectExecution()) {
-  for (const signal of ['SIGTERM', 'SIGINT', 'SIGHUP']) {
-    process.on(signal, () => {
-      void shutdown(`signal:${signal}`, 0);
-    });
-  }
-  process.on('uncaughtException', error => {
-    void shutdown(`uncaughtException:${error.message}`, 1);
-  });
-  process.on('unhandledRejection', error => {
-    void shutdown(
-      `unhandledRejection:${error instanceof Error ? error.message : String(error)}`,
-      1
-    );
-  });
-
-  main().catch(error =>
-    shutdown(
-      `fatal:${error instanceof Error ? error.message : String(error)}`,
-      1
-    )
-  );
-}