@lark-apaas/fullstack-cli 1.1.59-alpha.20260720153322 → 1.1.59-alpha.20260720184331

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lark-apaas/fullstack-cli",
-  "version": "1.1.59-alpha.20260720153322",
+  "version": "1.1.59-alpha.20260720184331",
   "description": "CLI tool for fullstack template management",
   "type": "module",
   "main": "dist/index.js",

package/templates/scripts/preview-phase-outbox.cjs

@@ -9,9 +9,11 @@ const DEFAULT_MAX_RUN_BYTES = 2 * 1024 * 1024;
 const DEFAULT_MAX_ROOT_BYTES = 64 * 1024 * 1024;
 const DEFAULT_MAX_ROOT_DIRECTORIES = 128;
 const DEFAULT_MAX_ROOT_SCAN_DIRECTORIES = 256;
+const DEFAULT_MAX_RUN_SCAN_ENTRIES = 64;
 const RUN_ID_PATTERN = /^prv_[A-Za-z0-9_-]{1,60}$/;
 const STATE_ID_PATTERN = /^[A-Za-z0-9_-]{1,128}$/;
 const PROCESS_START_TICKS_PATTERN = /^\d+$/;
+const PRODUCER_EPOCH_PATTERN = /^ppe_[a-f0-9]{32}$/;
 
 function readLinuxProcessStartTicks(fileSystem, pid) {
   try {
@@ -51,6 +53,7 @@ function createPreviewPhaseOutbox(options) {
   const randomUUID = options.random_uuid || require('crypto').randomUUID;
   const now = options.now || Date.now;
   const writerInstanceID = options.writer_instance_id || randomUUID();
+  const producerEpoch = options.producer_epoch;
   const getProcessStartTicks =
     options.get_process_start_ticks ||
     (pid => readLinuxProcessStartTicks(fileSystem, pid));
@@ -65,16 +68,18 @@ function createPreviewPhaseOutbox(options) {
     options.max_root_directories ?? DEFAULT_MAX_ROOT_DIRECTORIES;
   const maxRootScanDirectories =
     options.max_root_scan_directories ?? DEFAULT_MAX_ROOT_SCAN_DIRECTORIES;
+  const maxRunScanEntries =
+    options.max_run_scan_entries ?? DEFAULT_MAX_RUN_SCAN_ENTRIES;
   if (!RUN_ID_PATTERN.test(options.run_id || '')) {
     throw new Error('invalid preview run_id for phase outbox');
   }
+  if (!PRODUCER_EPOCH_PATTERN.test(producerEpoch || '')) {
+    throw new Error('invalid preview phase producer_epoch');
+  }
   if (!STATE_ID_PATTERN.test(writerInstanceID)) {
     throw new Error('invalid preview phase writer_instance_id');
   }
-  if (
-    currentProcessStartTicks != null &&
-    !PROCESS_START_TICKS_PATTERN.test(currentProcessStartTicks)
-  ) {
+  if (!PROCESS_START_TICKS_PATTERN.test(currentProcessStartTicks || '')) {
     throw new Error('invalid preview phase process_start_ticks');
   }
   if (!Number.isSafeInteger(maxRunBytes) || maxRunBytes <= 0) {
@@ -92,6 +97,9 @@ function createPreviewPhaseOutbox(options) {
   ) {
     throw new Error('invalid preview phase max_root_scan_directories');
   }
+  if (!Number.isSafeInteger(maxRunScanEntries) || maxRunScanEntries <= 0) {
+    throw new Error('invalid preview phase max_run_scan_entries');
+  }
   const runDir = path.join(root, options.run_id);
   const eventsPath = path.join(runDir, 'events.jsonl');
   const metaPath = path.join(runDir, 'meta.json');
@@ -99,6 +107,10 @@ function createPreviewPhaseOutbox(options) {
   const sealPath = path.join(runDir, 'sealed.json');
   const degradedPath = path.join(runDir, 'degraded.json');
   const quiesceRequestPath = path.join(runDir, 'quiesce.request.json');
+  const producerEpochMarkerPath = path.join(
+    root,
+    `producer-epoch-${producerEpoch}.json`
+  );
   let recovered = false;
   let metadata = null;
   let writerLockOwned = false;
@@ -109,6 +121,10 @@ function createPreviewPhaseOutbox(options) {
   let sealRequested = false;
   let closed = false;
   let closeResult = false;
+  let producerMarkerActive = false;
+  let producerMarkerTerminal = false;
+  let producerStartedAtMs = null;
+  let producerTerminalAtMs = null;
 
   function rootQuotaError(message) {
     const error = new Error(message);
@@ -116,13 +132,30 @@ function createPreviewPhaseOutbox(options) {
     return error;
   }
 
-  function inspectRootUsage() {
-    const entries = fileSystem.readdirSync(root, { withFileTypes: true });
-    if (entries.length > maxRootScanDirectories) {
-      throw rootQuotaError(
-        `preview phase root scan exceeds ${maxRootScanDirectories} entries`
-      );
+  function readDirectoryEntriesBounded(directoryPath, limit, quotaMessage) {
+    const entries = [];
+    const directory = fileSystem.opendirSync(directoryPath);
+    try {
+      while (entries.length <= limit) {
+        const entry = directory.readSync();
+        if (!entry) break;
+        entries.push(entry);
+        if (entries.length > limit) {
+          throw rootQuotaError(quotaMessage);
+        }
+      }
+    } finally {
+      directory.closeSync();
     }
+    return entries;
+  }
+
+  function inspectRootUsage() {
+    const entries = readDirectoryEntriesBounded(
+      root,
+      maxRootScanDirectories,
+      `preview phase root scan exceeds ${maxRootScanDirectories} entries`
+    );
     let directories = 0;
     let bytes = 0;
     const disappearingEntry = error =>
@@ -152,9 +185,11 @@ function createPreviewPhaseOutbox(options) {
       directories += 1;
       let runEntries;
       try {
-        runEntries = fileSystem.readdirSync(entryPath, {
-          withFileTypes: true,
-        });
+        runEntries = readDirectoryEntriesBounded(
+          entryPath,
+          maxRunScanEntries,
+          `preview phase run scan exceeds ${maxRunScanEntries} entries: ${entryPath}`
+        );
       } catch (error) {
         if (disappearingEntry(error)) continue;
         throw error;
@@ -223,6 +258,19 @@ function createPreviewPhaseOutbox(options) {
     }
   }
 
+  function syncRootDirectory() {
+    const flags =
+      fs.constants.O_RDONLY |
+      (fs.constants.O_DIRECTORY || 0) |
+      (fs.constants.O_NOFOLLOW || 0);
+    const fd = fileSystem.openSync(root, flags);
+    try {
+      fileSystem.fsyncSync(fd);
+    } finally {
+      fileSystem.closeSync(fd);
+    }
+  }
+
   function writeAll(fd, payload) {
     let offset = 0;
     while (offset < payload.length) {
@@ -239,6 +287,24 @@ function createPreviewPhaseOutbox(options) {
     }
   }
 
+  function writeDurableTempFile(tempPath, payload) {
+    let fd = null;
+    try {
+      const flags =
+        fs.constants.O_CREAT |
+        fs.constants.O_EXCL |
+        fs.constants.O_WRONLY |
+        (fs.constants.O_NOFOLLOW || 0);
+      fd = fileSystem.openSync(tempPath, flags, 0o600);
+      writeAll(fd, payload);
+      fileSystem.fsyncSync(fd);
+    } finally {
+      if (fd != null) {
+        fileSystem.closeSync(fd);
+      }
+    }
+  }
+
   function publishImmutableState(filePath, label, value) {
     const tempPath = path.join(
       runDir,
@@ -272,6 +338,194 @@ function createPreviewPhaseOutbox(options) {
     }
   }
 
+  function producerMarkerConflict() {
+    const error = new Error(
+      `preview phase producer epoch already belongs to another writer: ${producerEpoch}`
+    );
+    error.code = 'PREVIEW_PHASE_PRODUCER_EPOCH_CONFLICT';
+    return error;
+  }
+
+  function validateProducerMarker(marker) {
+    const terminal = marker?.state === 'terminal';
+    if (
+      marker?.protocol !== 'preview-phase-producer-epoch-v1' ||
+      marker.schema_version !== 1 ||
+      marker.epoch !== producerEpoch ||
+      !RUN_ID_PATTERN.test(marker.run_id || '') ||
+      !STATE_ID_PATTERN.test(marker.generation || '') ||
+      !STATE_ID_PATTERN.test(marker.writer_instance_id || '') ||
+      !Number.isSafeInteger(marker.pid) ||
+      marker.pid <= 0 ||
+      !PROCESS_START_TICKS_PATTERN.test(marker.process_start_ticks || '') ||
+      !Number.isFinite(marker.started_at_ms) ||
+      marker.started_at_ms <= 0 ||
+      (marker.state !== 'active' && !terminal) ||
+      (terminal &&
+        (!Number.isFinite(marker.terminal_at_ms) ||
+          marker.terminal_at_ms < marker.started_at_ms)) ||
+      (!terminal && marker.terminal_at_ms !== undefined)
+    ) {
+      throw new Error(
+        `invalid preview phase producer epoch marker: ${producerEpochMarkerPath}`
+      );
+    }
+    return marker;
+  }
+
+  function markerBelongsToThisWriter(marker) {
+    return (
+      marker.epoch === producerEpoch &&
+      marker.run_id === options.run_id &&
+      marker.generation === metadata.generation &&
+      marker.writer_instance_id === writerInstanceID &&
+      marker.pid === process.pid &&
+      (marker.process_start_ticks || '') === (currentProcessStartTicks || '')
+    );
+  }
+
+  function readAndValidateProducerMarker() {
+    return validateProducerMarker(
+      readRegularJSON(producerEpochMarkerPath, 'producer epoch marker')
+    );
+  }
+
+  function buildProducerMarker(state) {
+    return {
+      protocol: 'preview-phase-producer-epoch-v1',
+      schema_version: 1,
+      epoch: producerEpoch,
+      run_id: options.run_id,
+      generation: metadata.generation,
+      writer_instance_id: writerInstanceID,
+      pid: process.pid,
+      process_start_ticks: currentProcessStartTicks,
+      started_at_ms: producerStartedAtMs,
+      state,
+      ...(state === 'terminal' ? { terminal_at_ms: producerTerminalAtMs } : {}),
+    };
+  }
+
+  function publishActiveProducerMarker() {
+    if (producerMarkerActive) return;
+    if (!metadata || !writerLockOwned) {
+      throw new Error(
+        'preview phase producer marker requires writer ownership'
+      );
+    }
+    if (fileSystem.existsSync(producerEpochMarkerPath)) {
+      const existing = readAndValidateProducerMarker();
+      if (!markerBelongsToThisWriter(existing) || existing.state !== 'active') {
+        throw producerMarkerConflict();
+      }
+      producerStartedAtMs = existing.started_at_ms;
+      producerMarkerActive = true;
+      return;
+    }
+
+    producerStartedAtMs = producerStartedAtMs ?? now();
+    const marker = buildProducerMarker('active');
+    const tempPath = path.join(
+      root,
+      `.producer-epoch.${producerEpoch}.${process.pid}.${writerInstanceID}.tmp`
+    );
+    let fd = null;
+    try {
+      const flags =
+        fs.constants.O_CREAT |
+        fs.constants.O_EXCL |
+        fs.constants.O_WRONLY |
+        (fs.constants.O_NOFOLLOW || 0);
+      fd = fileSystem.openSync(tempPath, flags, 0o600);
+      writeAll(fd, Buffer.from(`${JSON.stringify(marker)}\n`, 'utf8'));
+      fileSystem.fsyncSync(fd);
+      fileSystem.closeSync(fd);
+      fd = null;
+      try {
+        fileSystem.linkSync(tempPath, producerEpochMarkerPath);
+        syncRootDirectory();
+      } catch (error) {
+        if (error?.code !== 'EEXIST') throw error;
+        const existing = readAndValidateProducerMarker();
+        if (
+          !markerBelongsToThisWriter(existing) ||
+          existing.state !== 'active'
+        ) {
+          throw producerMarkerConflict();
+        }
+        producerStartedAtMs = existing.started_at_ms;
+      }
+      producerMarkerActive = true;
+    } finally {
+      if (fd != null) {
+        try {
+          fileSystem.closeSync(fd);
+        } catch {}
+      }
+      let tempRemoved = false;
+      try {
+        fileSystem.rmSync(tempPath, { force: true });
+        tempRemoved = true;
+      } catch {
+        // A stale temp file is never accepted as lifecycle proof.
+      }
+      if (tempRemoved) syncRootDirectory();
+    }
+  }
+
+  function publishTerminalProducerMarker() {
+    if (producerMarkerTerminal) return;
+    const existing = readAndValidateProducerMarker();
+    if (!markerBelongsToThisWriter(existing)) {
+      throw producerMarkerConflict();
+    }
+    producerStartedAtMs = existing.started_at_ms;
+    if (existing.state === 'terminal') {
+      producerTerminalAtMs = existing.terminal_at_ms;
+      producerMarkerActive = true;
+      producerMarkerTerminal = true;
+      return;
+    }
+    producerTerminalAtMs =
+      producerTerminalAtMs ?? Math.max(now(), producerStartedAtMs);
+    const marker = buildProducerMarker('terminal');
+    const tempPath = path.join(
+      root,
+      `.producer-terminal.${producerEpoch}.${process.pid}.${writerInstanceID}.tmp`
+    );
+    let fd = null;
+    try {
+      const flags =
+        fs.constants.O_CREAT |
+        fs.constants.O_EXCL |
+        fs.constants.O_WRONLY |
+        (fs.constants.O_NOFOLLOW || 0);
+      fd = fileSystem.openSync(tempPath, flags, 0o600);
+      writeAll(fd, Buffer.from(`${JSON.stringify(marker)}\n`, 'utf8'));
+      fileSystem.fsyncSync(fd);
+      fileSystem.closeSync(fd);
+      fd = null;
+      fileSystem.renameSync(tempPath, producerEpochMarkerPath);
+      syncRootDirectory();
+      producerMarkerActive = true;
+      producerMarkerTerminal = true;
+    } finally {
+      if (fd != null) {
+        try {
+          fileSystem.closeSync(fd);
+        } catch {}
+      }
+      let tempRemoved = false;
+      try {
+        fileSystem.rmSync(tempPath, { force: true });
+        tempRemoved = true;
+      } catch {
+        // A stale temp file is never accepted as lifecycle proof.
+      }
+      if (tempRemoved) syncRootDirectory();
+    }
+  }
+
   function readAndValidateMetadata() {
     const stat = fileSystem.lstatSync(metaPath);
     if (!stat.isFile() || stat.isSymbolicLink()) {
@@ -282,6 +536,7 @@ function createPreviewPhaseOutbox(options) {
     if (
       metadata.protocol !== 'preview-phase-outbox-v1' ||
       metadata.schema_version !== 1 ||
+      metadata.producer_epoch !== producerEpoch ||
       metadata.run_id !== options.run_id ||
       !/^[A-Za-z0-9_-]{1,128}$/.test(metadata.generation || '') ||
       !Number.isFinite(metadata.created_at_ms) ||
@@ -303,6 +558,7 @@ function createPreviewPhaseOutbox(options) {
     const candidate = {
       protocol: 'preview-phase-outbox-v1',
       schema_version: 1,
+      producer_epoch: producerEpoch,
       generation: randomUUID(),
       run_id: options.run_id,
       created_at_ms: now(),
@@ -313,13 +569,13 @@ function createPreviewPhaseOutbox(options) {
       `.meta.${process.pid}.${candidate.generation}.tmp`
     );
     try {
-      fileSystem.writeFileSync(tempPath, `${JSON.stringify(candidate)}\n`, {
-        encoding: 'utf8',
-        flag: 'wx',
-        mode: 0o600,
-      });
+      writeDurableTempFile(
+        tempPath,
+        Buffer.from(`${JSON.stringify(candidate)}\n`, 'utf8')
+      );
       try {
         fileSystem.linkSync(tempPath, metaPath);
+        syncRunDirectory();
       } catch (error) {
         if (error?.code !== 'EEXIST') throw error;
       }
@@ -386,11 +642,10 @@ function createPreviewPhaseOutbox(options) {
       `.writer.${process.pid}.${writerInstanceID}.tmp`
     );
     try {
-      fileSystem.writeFileSync(tempPath, `${JSON.stringify(lock)}\n`, {
-        encoding: 'utf8',
-        flag: 'wx',
-        mode: 0o600,
-      });
+      writeDurableTempFile(
+        tempPath,
+        Buffer.from(`${JSON.stringify(lock)}\n`, 'utf8')
+      );
       try {
         fileSystem.linkSync(tempPath, writerLockPath);
         writerLockOwned = true;
@@ -586,6 +841,7 @@ function createPreviewPhaseOutbox(options) {
       ensureMetadata();
       assertGenerationIsOpen();
       acquireWriterLock();
+      publishActiveProducerMarker();
       // Any existing writer identity is authoritative to JS. Dead-owner
       // recovery and torn-tail finalization belong exclusively to shell-server.
       assertGenerationIsNotDegraded();
@@ -699,10 +955,25 @@ function createPreviewPhaseOutbox(options) {
         const seal = readAndValidateSeal();
         fallbackRequired ||= seal.fallback_required === true;
         if (writerLockOwned) {
+          publishActiveProducerMarker();
+          publishTerminalProducerMarker();
           removeOwnedWriterLock();
         } else if (fileSystem.existsSync(writerLockPath)) {
           closeResult = false;
           return false;
+        } else {
+          const marker = readAndValidateProducerMarker();
+          if (
+            !markerBelongsToThisWriter(marker) ||
+            marker.state !== 'terminal'
+          ) {
+            closeResult = false;
+            return false;
+          }
+          producerStartedAtMs = marker.started_at_ms;
+          producerTerminalAtMs = marker.terminal_at_ms;
+          producerMarkerActive = true;
+          producerMarkerTerminal = true;
         }
         closed = true;
         closeResult = true;
@@ -712,6 +983,7 @@ function createPreviewPhaseOutbox(options) {
       if (!writerLockOwned) {
         acquireWriterLock();
       }
+      publishActiveProducerMarker();
       observeDegradedMarker();
       if (eventsFD != null) {
         fileSystem.fdatasyncSync(eventsFD);
@@ -747,6 +1019,7 @@ function createPreviewPhaseOutbox(options) {
         sealed_at_ms: now(),
         fallback_required: fallbackRequired,
       });
+      publishTerminalProducerMarker();
       removeOwnedWriterLock();
       closeResult = true;
       closed = true;
@@ -777,6 +1050,7 @@ function createPreviewPhaseOutbox(options) {
     seal_path: sealPath,
     degraded_path: degradedPath,
     quiesce_request_path: quiesceRequestPath,
+    producer_epoch_marker_path: producerEpochMarkerPath,
   };
 }
 
@@ -786,6 +1060,7 @@ module.exports = {
   DEFAULT_MAX_ROOT_BYTES,
   DEFAULT_MAX_ROOT_DIRECTORIES,
   DEFAULT_MAX_ROOT_SCAN_DIRECTORIES,
+  DEFAULT_MAX_RUN_SCAN_ENTRIES,
   MAX_EVENT_BYTES,
   createPreviewPhaseOutbox,
 };

package/templates/scripts/preview-startup-timing.cjs

@@ -4,7 +4,10 @@ const fs = require('fs');
 const crypto = require('crypto');
 const net = require('net');
 const path = require('path');
-const { createPreviewPhaseOutbox } = require('./preview-phase-outbox.cjs');
+const {
+  MAX_EVENT_BYTES,
+  createPreviewPhaseOutbox,
+} = require('./preview-phase-outbox.cjs');
 
 const PREFIX = '[MiaodaPreviewPhase] ';
 const RUN_ID_PATTERN = /^prv_[A-Za-z0-9_-]{1,60}$/;
@@ -86,18 +89,28 @@ function createPreviewPhaseReporter(options = {}) {
     });
   const producerInstanceID = randomUUID();
   const runId = env.MIAODA_PREVIEW_RUN_ID || '';
-  const outbox = RUN_ID_PATTERN.test(runId)
-    ? createPreviewPhaseOutbox({
+  let outbox = null;
+  let outboxInitializationError = null;
+  if (RUN_ID_PATTERN.test(runId)) {
+    try {
+      outbox = createPreviewPhaseOutbox({
         root: options.outbox_root || env.MIAODA_PREVIEW_PHASE_OUTBOX_ROOT,
         run_id: runId,
+        producer_epoch: env.MIAODA_PREVIEW_PHASE_PRODUCER_EPOCH,
+        process_start_ticks: options.process_start_ticks,
+        get_process_start_ticks: options.get_process_start_ticks,
         fs: options.fs,
         random_uuid: randomUUID,
         now,
-      })
-    : null;
+      });
+    } catch (error) {
+      outboxInitializationError = error;
+    }
+  }
   const producerSequences = new Map();
   const startupTerminalPhases = new Set();
   let reporterSealed = false;
+  let terminalCloseScheduled = false;
   let quiescePollTimer = null;
 
   function reportDiagnostic(diagnostic) {
@@ -108,6 +121,33 @@ function createPreviewPhaseReporter(options = {}) {
     }
   }
 
+  function scheduleTerminalClose() {
+    if (terminalCloseScheduled || reporterSealed) return;
+    terminalCloseScheduled = true;
+    queueMicrotask(() => {
+      terminalCloseScheduled = false;
+      if (reporterSealed) return;
+      // backend_tcp_ready's synchronous onReady callback emits the initial
+      // deferred-typecheck decision immediately after the readiness event.
+      // Closing in a microtask keeps that terminal startup decision inside the
+      // same durable generation without extending the outbox into later source
+      // changes or daemon restarts.
+      flush();
+      close();
+    });
+  }
+
+  if (outboxInitializationError) {
+    reportDiagnostic({
+      code: 'outbox_initialization_failed',
+      run_id: runId,
+      error:
+        outboxInitializationError instanceof Error
+          ? outboxInitializationError.message
+          : String(outboxInitializationError),
+    });
+  }
+
   function emitForProducer(eventProducer, phase, status, detail = {}) {
     if (!RUN_ID_PATTERN.test(runId) || reporterSealed) return false;
     const atMs = detail.at_ms == null ? now() : detail.at_ms;
@@ -132,34 +172,60 @@ function createPreviewPhaseReporter(options = {}) {
       recorded_at_ms: now(),
       transport: 'outbox',
     };
+    let serializedEvent = JSON.stringify(event);
+    if (Buffer.byteLength(serializedEvent, 'utf8') > MAX_EVENT_BYTES) {
+      reportDiagnostic({
+        code: 'event_rejected',
+        reason: 'event_too_large',
+        run_id: runId,
+        phase,
+        event_id: event.event_id,
+      });
+      return false;
+    }
     let persisted = false;
-    try {
-      persisted = outbox.append(event);
-    } catch (error) {
-      if (error?.code === 'PREVIEW_PHASE_EVENT_TOO_LARGE') {
-        reportDiagnostic({
-          code: 'event_rejected',
-          reason: 'event_too_large',
-          run_id: runId,
-          phase,
-          event_id: event.event_id,
-        });
-        return false;
-      }
+    if (!outbox) {
       event.transport = 'stdout_fallback';
-      if (error?.code !== 'PREVIEW_PHASE_OUTBOX_DEGRADED') {
-        reportDiagnostic({
-          code: 'outbox_append_failed',
-          run_id: runId,
-          phase,
-          event_id: event.event_id,
-          error: error instanceof Error ? error.message : String(error),
-        });
+    } else {
+      try {
+        persisted = outbox.append(event);
+      } catch (error) {
+        if (error?.code === 'PREVIEW_PHASE_EVENT_TOO_LARGE') {
+          reportDiagnostic({
+            code: 'event_rejected',
+            reason: 'event_too_large',
+            run_id: runId,
+            phase,
+            event_id: event.event_id,
+          });
+          return false;
+        }
+        event.transport = 'stdout_fallback';
+        if (error?.code !== 'PREVIEW_PHASE_OUTBOX_DEGRADED') {
+          reportDiagnostic({
+            code: 'outbox_append_failed',
+            run_id: runId,
+            phase,
+            event_id: event.event_id,
+            error: error instanceof Error ? error.message : String(error),
+          });
+        }
       }
     }
+    serializedEvent = JSON.stringify(event);
+    if (Buffer.byteLength(serializedEvent, 'utf8') > MAX_EVENT_BYTES) {
+      reportDiagnostic({
+        code: 'event_rejected',
+        reason: 'event_too_large',
+        run_id: runId,
+        phase,
+        event_id: event.event_id,
+      });
+      return false;
+    }
     let mirrored = false;
     try {
-      write(`${PREFIX}${JSON.stringify(event)}`);
+      write(`${PREFIX}${serializedEvent}`);
       mirrored = true;
     } catch (error) {
       reportDiagnostic({
@@ -178,8 +244,7 @@ function createPreviewPhaseReporter(options = {}) {
     ) {
       startupTerminalPhases.add(phase);
       if (startupTerminalPhases.size === 2) {
-        flush();
-        close();
+        scheduleTerminalClose();
       }
     }
     return delivered;
@@ -247,7 +312,7 @@ function createPreviewPhaseReporter(options = {}) {
 
   function flush() {
     if (reporterSealed) return true;
-    if (!outbox) return true;
+    if (!outbox) return outboxInitializationError == null;
     try {
       return outbox.flush();
     } catch (error) {
@@ -288,7 +353,7 @@ function createPreviewPhaseReporter(options = {}) {
 
   function close() {
     if (reporterSealed) return true;
-    if (!outbox) return true;
+    if (!outbox) return outboxInitializationError == null;
     try {
       const sealed = outbox.close();
       if (sealed) {