@phpsandbox/sdk 0.1.12 → 0.1.14

package/examples/laravel-load-test.ts

@@ -1,2800 +0,0 @@
-import fs from 'node:fs/promises';
-import https from 'node:https';
-import {
-  type Disposable,
-  type FileChange,
-  type NotebookInitProgress,
-  type NotebookInitResult,
-  type NotebookInitSuccessResult,
-  type NotebookPreviewSessionData,
-  type NotebookProvisioningAction,
-  NotebookInstance,
-  type PortInfo,
-  PHPSandbox,
-  RemoteError,
-} from '@phpsandbox/sdk';
-import axios from 'axios';
-import NodeWebSocket from 'ws';
-
-type Visibility = 'public' | 'private' | 'unlisted';
-type LoadTestMode = 'full' | 'init';
-type StepStatus = 'passed' | 'failed' | 'skipped';
-type ScenarioStatus = 'passed' | 'failed';
-type LiveScenarioStatus = 'running' | 'passed' | 'failed';
-type EventTone = 'info' | 'pass' | 'fail' | 'warn';
-
-const DEFAULT_PROD_API_URL = 'https://api.phpsandbox.io/v1';
-const DEFAULT_LOCAL_API_URL = 'https://api.phpsandbox.test/v1';
-const CLEANUP_DELETE_CONCURRENCY = 8;
-const SECRETS_STEP_CONCURRENCY = 8;
-const DELETE_RETRY_DELAYS_MS = [500, 1_000, 2_000, 4_000, 8_000, 12_000];
-const SECRETS_RETRY_DELAYS_MS = [500, 1_000, 2_000, 4_000, 8_000, 12_000];
-const TELEMETRY_RETRY_DELAYS_MS = [1_000];
-const PREVIEW_RETRY_DELAYS_MS = [1_000, 2_000, 4_000, 8_000];
-
-class AsyncLimiter {
-  private active = 0;
-  private readonly queue: Array<() => void> = [];
-
-  constructor(private readonly concurrency: number) {}
-
-  async run<T>(action: () => Promise<T>): Promise<T> {
-    if (this.active >= this.concurrency) {
-      await new Promise<void>((resolve) => {
-        this.queue.push(resolve);
-      });
-    }
-
-    this.active += 1;
-    try {
-      return await action();
-    } finally {
-      this.active -= 1;
-      this.queue.shift()?.();
-    }
-  }
-}
-
-interface LoadTestOptions {
-  token: string;
-  local: boolean;
-  apiUrl: string;
-  runtimeOrigin?: string;
-  runtimeUrl?: string;
-  template: string;
-  mode: LoadTestMode;
-  stopOnFailureLevel: boolean;
-  titlePrefix: string;
-  visibility: Visibility;
-  levels: number[];
-  waves: number;
-  pauseMs: number;
-  cleanup: boolean;
-  keepFailed: boolean;
-  debug: boolean;
-  stepTimeoutMs: number;
-  streamTimeoutMs: number;
-  telemetryTimeoutMs: number;
-  maxStreamChars: number;
-  includeContainerRestart: boolean;
-  includeDownload: boolean;
-  includePreview: boolean;
-  includeLsp: boolean;
-  requireInitMessages: string[];
-  expectProvisioned?: boolean;
-  expectProvisioningAction?: NotebookProvisioningAction;
-  reauthorizationUrl?: string;
-  json: boolean;
-  jsonFile?: string;
-  insecureTls: boolean;
-  caFile?: string;
-}
-
-interface InitTraceEvent {
-  source: 'init' | 'provision' | 'trace';
-  atMs: number;
-  kind?: string;
-  step?: string;
-  message: string;
-  details?: string;
-  durationMs?: number;
-}
-
-interface InitTrace {
-  connectedAtMs?: number;
-  initializedAtMs?: number;
-  bootErrorAtMs?: number;
-  bootError?: string;
-  resultType?: NotebookInitResult['type'];
-  provisioned?: boolean;
-  provisioningAction?: NotebookProvisioningAction | null;
-  events: InitTraceEvent[];
-}
-
-interface StepResult {
-  name: string;
-  status: StepStatus;
-  durationMs: number;
-  detail?: string;
-  error?: string;
-}
-
-interface ScenarioResult {
-  id: string;
-  level: number;
-  wave: number;
-  slot: number;
-  status: ScenarioStatus;
-  durationMs: number;
-  notebookId?: string;
-  previewUrl?: string;
-  logsCaptured: number;
-  errors: string[];
-  steps: StepResult[];
-  initTrace?: InitTrace;
-}
-
-interface StageResult {
-  level: number;
-  durationMs: number;
-  scenarios: ScenarioResult[];
-}
-
-interface Deferred<T> {
-  promise: Promise<T>;
-  resolve(value: T): void;
-  reject(reason?: unknown): void;
-  settled: boolean;
-}
-
-interface ParsedArgs {
-  get(key: string): string | boolean | undefined;
-}
-
-interface ScenarioStartMeta {
-  id: string;
-  level: number;
-  wave: number;
-  slot: number;
-}
-
-interface ScenarioLiveState extends ScenarioStartMeta {
-  status: LiveScenarioStatus;
-  startedAt: number;
-  durationMs: number;
-  notebookId?: string;
-  currentStep?: string;
-  lastStep?: string;
-  completedSteps: number;
-  logsCaptured: number;
-  error?: string;
-}
-
-interface LevelLiveStat {
-  planned: number;
-  completed: number;
-  passed: number;
-  failed: number;
-  durations: number[];
-}
-
-interface StepLiveStat {
-  passed: number;
-  failed: number;
-  skipped: number;
-  durations: number[];
-}
-
-interface UiEvent {
-  at: number;
-  tone: EventTone;
-  text: string;
-}
-
-class LoadTestInterruptedError extends Error {
-  public constructor(message: string = 'Interrupted by SIGINT.') {
-    super(message);
-    this.name = 'LoadTestInterruptedError';
-  }
-}
-
-class InterruptController {
-  private readonly abortController = new AbortController();
-
-  public request(): boolean {
-    if (this.abortController.signal.aborted) {
-      return false;
-    }
-
-    this.abortController.abort(new LoadTestInterruptedError());
-    return true;
-  }
-
-  public get signal(): AbortSignal {
-    return this.abortController.signal;
-  }
-
-  public get interrupted(): boolean {
-    return this.abortController.signal.aborted;
-  }
-
-  public throwIfInterrupted(): void {
-    if (this.abortController.signal.aborted) {
-      const reason = this.abortController.signal.reason;
-      throw reason instanceof Error ? reason : new LoadTestInterruptedError();
-    }
-  }
-}
-
-const ansi = {
-  reset: '\x1b[0m',
-  bold: '\x1b[1m',
-  dim: '\x1b[2m',
-  red: '\x1b[31m',
-  green: '\x1b[32m',
-  yellow: '\x1b[33m',
-  blue: '\x1b[34m',
-  magenta: '\x1b[35m',
-  cyan: '\x1b[36m',
-  gray: '\x1b[90m',
-  hideCursor: '\x1b[?25l',
-  showCursor: '\x1b[?25h',
-  clearDown: '\x1b[0J',
-};
-
-const textDecoder = new TextDecoder();
-const cleanupDeleteLimiter = new AsyncLimiter(CLEANUP_DELETE_CONCURRENCY);
-const secretsStepLimiter = new AsyncLimiter(SECRETS_STEP_CONCURRENCY);
-const scenarioAuthor = 'PHPSandbox Load Test <load-test@phpsandbox.local>';
-
-let scenarioSequence = 0;
-
-async function main(): Promise<void> {
-  const options = parseOptions(process.argv.slice(2));
-  const transport = await createNodeTransport(options);
-  const ui = new LoadTestUi(options);
-  const interrupts = new InterruptController();
-  const client = PHPSandbox.realtime(options.token, options.apiUrl, {
-    debug: options.debug,
-    fetch: transport.fetch,
-    webSocket: transport.webSocket,
-  });
-  const removeSignalHandler = installSignalHandler(ui, interrupts);
-
-  ui.start();
-
-  try {
-    const stages: StageResult[] = [];
-    for (const level of options.levels) {
-      if (interrupts.interrupted) {
-        ui.note('Interrupt requested. No further levels will be launched.', 'warn');
-        break;
-      }
-
-      const stage = await runStage(client, options, level, ui, interrupts);
-      if (stage.scenarios.length > 0) {
-        stages.push(stage);
-      }
-
-      if (options.stopOnFailureLevel && stage.scenarios.some((scenario) => scenario.status === 'failed')) {
-        ui.note(`Stopping after level ${level} because at least one scenario failed.`, 'warn');
-        break;
-      }
-
-      if (interrupts.interrupted) {
-        ui.note(`Interrupt requested during level ${level}. Skipping remaining levels.`, 'warn');
-        break;
-      }
-
-      if (options.pauseMs > 0 && level !== options.levels[options.levels.length - 1]) {
-        ui.note(`Pausing for ${options.pauseMs}ms before the next level.`);
-        try {
-          await sleep(options.pauseMs, interrupts.signal);
-        } catch (error) {
-          if (isInterruptedError(error)) {
-            ui.note('Interrupt requested during the inter-level pause.', 'warn');
-            break;
-          }
-
-          throw error;
-        }
-      }
-    }
-
-    const summary = summarizeStages(stages);
-    const payload = sanitizeArtifact({ options, stages, summary });
-    ui.stop();
-    if (interrupts.interrupted) {
-      console.log('Load test interrupted by SIGINT. Partial summary follows.');
-    }
-    console.log(renderSummary(stages, summary));
-
-    if (options.jsonFile) {
-      await fs.mkdir(new URL('.', new URL(`file://${options.jsonFile}`)), { recursive: true }).catch(() => undefined);
-      await fs.writeFile(options.jsonFile, JSON.stringify(payload, null, 2));
-    }
-
-    if (options.json) {
-      console.log(JSON.stringify(payload, null, 2));
-    }
-
-    process.exitCode = interrupts.interrupted ? 130 : summary.failedScenarios > 0 ? 1 : 0;
-  } finally {
-    removeSignalHandler();
-    ui.stop();
-  }
-}
-
-async function runStage(
-  client: PHPSandbox,
-  options: LoadTestOptions,
-  level: number,
-  ui: LoadTestUi,
-  interrupts: InterruptController
-): Promise<StageResult> {
-  ui.onStageStart(level);
-  const stageStartedAt = performance.now();
-  const scenarios: ScenarioResult[] = [];
-
-  for (let wave = 1; wave <= options.waves; wave += 1) {
-    if (interrupts.interrupted) {
-      ui.note(`Level ${level}: stopping before wave ${wave} due to SIGINT.`, 'warn');
-      break;
-    }
-
-    ui.onWaveStart(level, wave, level);
-
-    const waveResults = await Promise.all(
-      Array.from({ length: level }, (_, slot) => runScenario(client, options, level, wave, slot + 1, ui, interrupts))
-    );
-
-    scenarios.push(...waveResults);
-    const succeeded = waveResults.filter((scenario) => scenario.status === 'passed').length;
-    const failed = waveResults.length - succeeded;
-    ui.note(
-      `Level ${level}, wave ${wave}: ${succeeded}/${waveResults.length} passed, ${failed}/${waveResults.length} failed.`,
-      failed > 0 ? 'warn' : 'pass'
-    );
-
-    if (interrupts.interrupted) {
-      ui.note(`Level ${level}: interrupt requested. No further waves will be launched.`, 'warn');
-      break;
-    }
-  }
-
-  return {
-    level,
-    durationMs: performance.now() - stageStartedAt,
-    scenarios,
-  };
-}
-
-async function runScenario(
-  client: PHPSandbox,
-  options: LoadTestOptions,
-  level: number,
-  wave: number,
-  slot: number,
-  ui: LoadTestUi,
-  interrupts: InterruptController
-): Promise<ScenarioResult> {
-  const id = `l${level}-w${wave}-s${slot}-n${++scenarioSequence}`;
-  ui.onScenarioStart({ id, level, wave, slot });
-  const startedAt = performance.now();
-  const steps: StepResult[] = [];
-  const errors: string[] = [];
-
-  let notebook: NotebookInstance | null = null;
-  let previewUrl: string | undefined;
-  let logsCaptured = 0;
-  let logReader: ReadableStreamDefaultReader<import('../src/log.js').RuntimeLogEntry> | null = null;
-  let initTrace: InitTrace | undefined;
-  let readyResult: NotebookInitSuccessResult | undefined;
-  let initTraceDisposables: Disposable[] = [];
-  let redisRunning = false;
-
-  const routeSlug = id.toLowerCase();
-  const routePath = 'routes/web.php';
-  const routeFileName = routePath.split('/').pop() as string;
-  const routeUrlPath = `load-test-${routeSlug}`;
-  const secretName = `LOAD_TEST_${routeSlug.toUpperCase().replace(/[^A-Z0-9]/g, '_')}`;
-  const gitMessage = `load test ${id}`;
-
-  const noteFailure = (message: string) => {
-    errors.push(message);
-  };
-
-  const runCheckedStep = async <T>(
-    name: string,
-    action: () => Promise<T>,
-    optionsOverride: { continueOnError?: boolean; timeoutMs?: number; skipIf?: (error: unknown) => string | undefined } = {}
-  ): Promise<T | undefined> => {
-    interrupts.throwIfInterrupted();
-    const continueOnError = optionsOverride.continueOnError ?? true;
-    const timeoutMs = optionsOverride.timeoutMs ?? options.stepTimeoutMs;
-    const startedAt = performance.now();
-    ui.onStepStart(id, name);
-
-    try {
-      const value = await withTimeout(action(), timeoutMs, `${name} timed out after ${timeoutMs}ms`);
-      const durationMs = performance.now() - startedAt;
-      steps.push({
-        name,
-        status: 'passed',
-        durationMs,
-        detail: trimDetail(describeValue(value)),
-      });
-      ui.onStepResult(id, name, 'passed', durationMs);
-
-      return value;
-    } catch (error) {
-      const skipDetail = optionsOverride.skipIf?.(error);
-      if (skipDetail) {
-        const durationMs = performance.now() - startedAt;
-        steps.push({
-          name,
-          status: 'skipped',
-          durationMs,
-          detail: skipDetail,
-        });
-        ui.onStepResult(id, name, 'skipped', durationMs, skipDetail);
-
-        return undefined;
-      }
-
-      const durationMs = performance.now() - startedAt;
-      steps.push({
-        name,
-        status: 'failed',
-        durationMs,
-        error: formatError(error),
-      });
-      ui.onStepResult(id, name, 'failed', durationMs, formatError(error));
-
-      noteFailure(`${name}: ${formatError(error)}`);
-      if (!continueOnError) {
-        throw error;
-      }
-
-      return undefined;
-    }
-  };
-
-  try {
-    notebook = await runCheckedStep(
-      'notebook.create',
-      async () => {
-        const created = await client.notebook.create(
-          options.template,
-          {
-            title: `${options.titlePrefix} ${id}`,
-            visibility: options.visibility,
-          }
-        );
-
-        const data = {
-          ...created.data,
-          runtimeUrl: resolveRuntimeUrl(created.data.runtimeUrl, options),
-        };
-        created.dispose();
-
-        return client.notebook.open(data);
-      },
-      { continueOnError: false }
-    );
-
-    if (!notebook) {
-      throw new Error('Notebook creation returned no instance.');
-    }
-
-    ui.attachNotebook(id, notebook.data.id);
-    initTrace = { events: [] };
-    const initTraceOrigin = performance.now();
-    initTraceDisposables = [
-      notebook.onDidConnect(() => {
-        initTrace!.connectedAtMs = performance.now() - initTraceOrigin;
-      }),
-      notebook.onDidInitialize((result) => {
-        initTrace!.initializedAtMs = performance.now() - initTraceOrigin;
-        initTrace!.resultType = result.type;
-        if (result.type === 'success') {
-          initTrace!.provisioned = result.data.provisioned;
-          initTrace!.provisioningAction = result.data.provisioningAction;
-        }
-      }),
-      notebook.onDidBootError((error) => {
-        initTrace!.bootErrorAtMs = performance.now() - initTraceOrigin;
-        initTrace!.bootError = formatError(error);
-      }),
-      notebook.listen('init.event', (event: NotebookInitProgress) => {
-        initTrace!.events.push({
-          source: 'init',
-          atMs: performance.now() - initTraceOrigin,
-          kind: event.kind,
-          step: event.step,
-          message: event.message,
-          details: event.details ?? event.line ?? event.chunk ?? event.command,
-        });
-      }),
-      notebook.listen(`Notebook.Provision.Status.${notebook.data.id}` as never, (event: any) => {
-        const progress = event as NotebookInitProgress;
-        initTrace!.events.push({
-          source: 'provision',
-          atMs: performance.now() - initTraceOrigin,
-          kind: progress.kind,
-          step: progress.step,
-          message: progress.message,
-          details: progress.details ?? progress.line ?? progress.chunk ?? progress.command,
-        });
-      }),
-    ];
-
-    await runCheckedStep(
-      'notebook.ready',
-      async () => {
-        const ready = await notebook!.ready();
-        readyResult = ready;
-        previewUrl = ready.data.previewUrl;
-        assertValidUrl(ready.data.previewUrl, 'notebook.ready previewUrl');
-        return `previewUrl=${redactUrl(ready.data.previewUrl)} ${describePorts(assertPortInfoList(ready.data.ports, 'notebook.ready ports'))}`;
-      },
-      { continueOnError: false, timeoutMs: options.stepTimeoutMs * 2 }
-    );
-
-    await runCheckedStep(
-      'notebook.init-trace',
-      async () => validateInitTrace(initTrace, readyResult, options),
-      { continueOnError: false }
-    );
-
-    if (options.mode === 'init') {
-      if (options.includePreview) {
-        await runCheckedStep('preview.fetch', async () => fetchDefaultPreview(options, notebook!, previewUrl));
-      } else {
-        recordSkippedStep(steps, 'preview.fetch', 'Enable with --include-preview.');
-      }
-    }
-
-    if (options.mode !== 'init') {
-      logReader = notebook.runtime.logs.follow().getReader();
-      void (async () => {
-        while (logReader) {
-          const entry = await logReader.read();
-          if (entry.done) {
-            return;
-          }
-          if (entry.value.message.trim().length > 0) {
-            logsCaptured += 1;
-            ui.updateScenarioLogs(id, logsCaptured);
-          }
-        }
-      })().catch(() => {});
-
-      await runCheckedStep('notebook.secrets', async () => {
-        return secretsStepLimiter.run(async () => {
-          await retryWithBackoff(
-            () => notebook!.secrets.set(secretName, `value-${id}`),
-            SECRETS_RETRY_DELAYS_MS,
-            shouldRetryRemoteRateLimitError
-          );
-
-          const secrets = await retryWithBackoff(
-            () => notebook!.secrets.list(),
-            SECRETS_RETRY_DELAYS_MS,
-            shouldRetryRemoteRateLimitError
-          );
-
-          const found = secrets.find((secret) => secret.name === secretName);
-          if (!found) {
-            throw new Error(`Secret ${secretName} was not returned by secrets.list().`);
-          }
-
-          await retryWithBackoff(
-            () => notebook!.secrets.delete(secretName),
-            SECRETS_RETRY_DELAYS_MS,
-            shouldRetryRemoteRateLimitError
-          );
-
-          return secrets.length;
-        });
-      });
-
-      await runCheckedStep('container.ports', async () => {
-        const ports = await notebook!.runtime.ports.list();
-        return describePorts(assertPortInfoList(ports, 'ports.list'));
-      });
-
-      if (options.includeContainerRestart) {
-        await runCheckedStep(
-          'container.restart',
-          async () => {
-            await notebook!.restart();
-            const ports = await notebook!.runtime.ports.list();
-            return describePorts(assertPortInfoList(ports, 'ports.list after restart'));
-          },
-          { timeoutMs: options.stepTimeoutMs * 3, continueOnError: false }
-        );
-      } else {
-        recordSkippedStep(steps, 'container.restart', 'Enable with --include-container-restart.');
-      }
-
-      await runCheckedStep(
-        'container.telemetry',
-        async () =>
-          retryWithBackoff(
-            async () => {
-              const statsReader = notebook!.runtime.metrics.watch().getReader();
-              const portsReader = notebook!.runtime.ports.watch().getReader();
-              try {
-                const statsPromise = withTimeout(statsReader.read(), options.telemetryTimeoutMs, 'metrics.watch')
-                  .then(({ value }) => {
-                    if (!value) throw new Error('metrics.watch ended before a sample was received.');
-                    return `cpu=${value.cpu.usage}/${value.cpu.limit} memory=${value.memory.usage}/${value.memory.limit}`;
-                  });
-                const portsPromise = withTimeout(portsReader.read(), options.telemetryTimeoutMs, 'ports.watch')
-                  .then(({ value }) => describePorts(assertPortInfoList(value ?? [], 'ports.watch')));
-                return await firstFulfilled([statsPromise, portsPromise]);
-              } finally {
-                await Promise.all([statsReader.cancel(), portsReader.cancel()]);
-              }
-            },
-            TELEMETRY_RETRY_DELAYS_MS,
-            shouldRetryTelemetryError
-          ),
-        { timeoutMs: options.telemetryTimeoutMs + 5_000 }
-      );
-
-      await runCheckedStep(
-        'filesystem.watch-and-write',
-        async () => {
-          const changeSeen = createDeferred<FileChange>();
-          const watch = await notebook!.files.watch(
-            'routes',
-            { recursive: true, excludes: ['vendor/**', 'node_modules/**'] },
-            (change) => {
-              if (!changeSeen.settled && change.path.endsWith(routeFileName)) {
-                changeSeen.resolve(change);
-              }
-            }
-          );
-
-          try {
-            const current = textDecoder.decode(await notebook!.files.read(routePath));
-            const next = appendRouteDefinition(current, id, routeUrlPath);
-            await notebook!.files.write(routePath, next);
-
-            const change = await withTimeout(
-              changeSeen.promise,
-              options.stepTimeoutMs,
-              `waiting for a filesystem event for ${routePath}`
-            );
-
-            return `${change.path} (${change.type})`;
-          } finally {
-            watch.dispose();
-          }
-        }
-      );
-
-      await runCheckedStep('filesystem.inspect', async () => {
-        const [raw, stat, directory, tree, found, tail] = await Promise.all([
-          notebook!.files.read(routePath),
-          notebook!.files.stat(routePath),
-          notebook!.files.list('routes'),
-          notebook!.files.tree('routes'),
-          notebook!.files.find(routeFileName, { includes: ['routes/**'], maxResults: 10 }),
-          notebook!.files.tail(routePath, { lines: 20 }),
-        ]);
-
-        const text = textDecoder.decode(raw);
-        if (!text.includes(routeUrlPath)) {
-          throw new Error(`Expected ${routeUrlPath} in ${routePath}.`);
-        }
-
-        const [, matches] = await notebook!.files.search(
-          { pattern: routeUrlPath },
-          { includes: [routePath], excludes: [], maxResults: 10 }
-        );
-
-        if (matches.length === 0) {
-          throw new Error(`file.search() did not find ${routeUrlPath}.`);
-        }
-
-        const exists = await notebook!.files.exists(routePath);
-        if (!exists) {
-          throw new Error(`${routePath} does not exist after write.`);
-        }
-
-        return `size=${stat.size} dir=${directory.length} tree-lines=${tree.split('\n').length} find=${found.length} tail=${tail.length}`;
-      });
-
-      if (options.includePreview) {
-        await runCheckedStep('preview.fetch', async () => fetchScenarioPreview(options, notebook!, previewUrl, routeUrlPath, id));
-      } else {
-        recordSkippedStep(steps, 'preview.fetch', 'Enable with --include-preview.');
-      }
-
-      if (options.includeDownload) {
-        await runCheckedStep('filesystem.download', async () => {
-          const archive = await notebook!.files.download({
-            exclude: ['vendor/**', 'node_modules/**'],
-            include: [routePath, 'composer.json'],
-          });
-          if (archive.size === 0) {
-            throw new Error('file.download() returned an empty blob.');
-          }
-
-          return `${archive.size} bytes`;
-        });
-      } else {
-        recordSkippedStep(steps, 'filesystem.download', 'Enable with --include-download.');
-      }
-
-      await runCheckedStep('shell.run', async () => {
-        const result = await notebook!.run(['php', 'artisan', '--version']).wait();
-        if (result.exitCode !== 0) {
-          throw new Error(result.stderr || result.output);
-        }
-        if (!result.output.toLowerCase().includes('laravel')) {
-          throw new Error(`Unexpected artisan version output: ${trimDetail(result.output)}`);
-        }
-
-        return trimDetail(result.output);
-      }, { skipIf: explainUnsupportedShell });
-
-      await runCheckedStep(
-        'shell.run-stream',
-        async () => {
-          const execution = notebook!.run(
-            ['php', 'artisan', 'route:list', `--path=${routeUrlPath}`],
-            { tty: false },
-          );
-
-          const [streamOutput, result] = await Promise.all([
-            readStreamToString(execution.stdout, options.streamTimeoutMs, options.maxStreamChars).catch((error) => {
-              if (isStreamInactivityError(error)) {
-                return '';
-              }
-
-              throw error;
-            }),
-            withTimeout(execution.wait(), options.stepTimeoutMs, 'waiting for process exit'),
-          ]);
-
-          if (result.exitCode !== 0) {
-            throw new Error(result.stderr || result.output);
-          }
-          const combined = [streamOutput, result.output].filter(Boolean).join('\n');
-          if (!combined.includes(routeUrlPath)) {
-            throw new Error(`route:list output did not contain ${routeUrlPath}.`);
-          }
-
-          return `${combined.length} chars`;
-        },
-        { timeoutMs: options.stepTimeoutMs * 2, skipIf: explainUnsupportedShell }
-      );
-
-      await runCheckedStep(
-        'terminals.create',
-        async () => {
-          const process = await notebook!.terminals.create({
-            command: 'php',
-            args: ['artisan', 'route:list', `--path=${routeUrlPath}`],
-          });
-
-          try {
-            const outputPromise = readStreamToString(process.output, options.streamTimeoutMs, options.maxStreamChars);
-            const exitPromise = withTimeout(process.wait(), options.stepTimeoutMs, 'waiting for terminal process to exit');
-            const [output, exitCode] = await Promise.all([outputPromise, exitPromise]);
-
-            if (exitCode !== 0) {
-              throw new Error(`terminals.create() exited with ${exitCode}: ${trimDetail(output)}`);
-            }
-
-            if (!output.includes(routeUrlPath)) {
-              throw new Error(`terminal output did not contain ${routeUrlPath}.`);
-            }
-
-            return `${output.length} chars`;
-          } finally {
-            await process.kill().catch(() => false);
-          }
-        },
-        { timeoutMs: options.stepTimeoutMs * 2, skipIf: explainUnsupportedShell }
-      );
-
-      await runCheckedStep(
-        'services.redis',
-        async () => {
-          await notebook!.services.list();
-          const started = await notebook!.services.run('redis');
-          redisRunning = started.running || started.state === 'running' || started.state === 'starting';
-
-          const stream = notebook!.services.logs('redis', { follow: true, tail: 25 });
-          const reader = stream.getReader();
-
-          try {
-            const [snapshot, chunk] = await Promise.all([
-              sleep(1_500).then(() => notebook!.services.logs('redis', { tail: 25 })),
-              readNextChunk(reader, options.streamTimeoutMs),
-            ]);
-
-            const combined = [snapshot, chunk].filter(Boolean).join('\n').trim();
-            if (combined.length === 0) {
-              throw new Error('Did not capture redis logs.');
-            }
-
-            return `${combined.length} chars`;
-          } finally {
-            await reader.cancel().catch(() => undefined);
-            reader.releaseLock();
-            await notebook!.services.stop('redis').catch(() => started);
-            redisRunning = false;
-          }
-        },
-        { timeoutMs: options.stepTimeoutMs * 2 }
-      );
-
-      await runCheckedStep('composer.metadata', async () => {
-        let composerLogChunks = 0;
-        const dump = notebook!.composer.run('dump-autoload');
-        for await (const chunk of dump.output) {
-          if (chunk.data.byteLength > 0) {
-            composerLogChunks += 1;
-          }
-        }
-
-        const result = await dump.wait();
-        if (result.exitCode !== 0) {
-          throw new Error(result.stderr || result.output);
-        }
-        const packages = await notebook!.composer.packages();
-        if (packages.length === 0) {
-          throw new Error('composer.packages() returned no packages.');
-        }
-
-        return `packages=${packages.length} composer-log-events=${composerLogChunks}`;
-      }, { timeoutMs: Math.max(options.stepTimeoutMs * 2, 120_000) });
-
-      await runCheckedStep('git.checkpoint', async () => {
-        const status = await notebook!.git.status();
-        if (!status.initialized) {
-          throw new Error('Git repository is not initialized in this notebook.');
-        }
-
-        const branch = status.branch || 'main';
-        const checkpoint = await notebook!.git.checkpoint(scenarioAuthor, gitMessage, branch);
-        const history = await notebook!.git.log(branch);
-        if (!history.some((entry) => entry.message === gitMessage)) {
-          throw new Error(`git.log(${branch}) did not contain the checkpoint message.`);
-        }
-
-        return `${branch} -> ${checkpoint.ref}`;
-      }, { skipIf: explainUnavailableGit });
-
-      await runCheckedStep('repl.eval', async () => {
-        let replOutputEvents = 0;
-        const replDisposable = notebook!.listen('repl.output', () => {
-          replOutputEvents += 1;
-        });
-
-        try {
-          const result = await notebook!.repl.eval(`echo '${routeUrlPath}';`);
-          if (result.exitCode !== 0) {
-            throw new Error(`repl.eval() exited with ${result.exitCode}.`);
-          }
-
-          return `exit=${result.exitCode} output-events=${replOutputEvents}`;
-        } finally {
-          replDisposable.dispose();
-        }
-      });
-
-      if (options.includeLsp) {
-        await runCheckedStep(
-          'lsp.initialize',
-          async () => {
-            const lspId = `load-test-${routeSlug}`;
-            const responsePromise = waitForNextEvent<unknown>(
-              (handler) => notebook!.listen(`lsp.response.${lspId}` as never, handler as never),
-              options.streamTimeoutMs,
-              `lsp.response.${lspId}`
-            );
-
-            await notebook!.lsp.start(lspId);
-            await notebook!.lsp.message(
-              lspId,
-              encodeLspPayload({
-                jsonrpc: '2.0',
-                id: 1,
-                method: 'initialize',
-                params: {
-                  processId: null,
-                  rootUri: 'file:///app',
-                  capabilities: {},
-                  workspaceFolders: [{ uri: 'file:///app', name: 'app' }],
-                },
-              })
-            );
-
-            const response = await responsePromise;
-            await notebook!.lsp.close(lspId);
-            return trimDetail(JSON.stringify(response));
-          },
-          {
-            timeoutMs: options.streamTimeoutMs + 5_000,
-            skipIf: (error) => explainMissingAction(error, 'lsp.start'),
-          }
-        );
-      } else {
-        recordSkippedStep(steps, 'lsp.initialize', 'Enable with --include-lsp.');
-      }
-
-      if (options.reauthorizationUrl) {
-        await runCheckedStep('auth.login-logout', async () => {
-          await notebook!.auth.login(options.reauthorizationUrl!);
-          notebook!.dispose();
-          return 'ok';
-        });
-      } else {
-        recordSkippedStep(steps, 'auth.login-logout', 'Provide --reauthorization-url to exercise auth.');
-      }
-    }
-  } catch (error) {
-    noteFailure(formatError(error));
-  } finally {
-    if (notebook) {
-      if (redisRunning) {
-        await notebook.services.stop('redis').catch(() => undefined);
-      }
-
-      await logReader?.cancel().catch(() => undefined);
-      logReader = null;
-      for (const disposable of initTraceDisposables) {
-        disposable.dispose();
-      }
-
-      const shouldDelete = options.cleanup && (!options.keepFailed || errors.length === 0);
-      if (shouldDelete) {
-        try {
-          await cleanupNotebook(notebook, steps);
-        } catch (error) {
-          noteFailure(`notebook.delete: ${formatError(error)}`);
-        }
-      } else {
-        recordSkippedStep(
-          steps,
-          'notebook.delete',
-          options.cleanup ? 'Notebook kept because the scenario failed.' : 'Cleanup disabled.'
-        );
-        notebook.dispose();
-      }
-    }
-  }
-
-  const status: ScenarioStatus = errors.length === 0 ? 'passed' : 'failed';
-  const durationMs = performance.now() - startedAt;
-  const result = {
-    id,
-    level,
-    wave,
-    slot,
-    status,
-    durationMs,
-    notebookId: notebook?.data.id,
-    previewUrl,
-    logsCaptured,
-    errors,
-    steps,
-    initTrace,
-  };
-
-  ui.onScenarioFinish(result);
-
-  return result;
-}
-
-async function cleanupNotebook(notebook: NotebookInstance, steps: StepResult[]): Promise<void> {
-  try {
-    await recordStep(steps, 'notebook.delete', async () => {
-      const notebookId = notebook.data.id;
-      await cleanupDeleteLimiter.run(async () => {
-        try {
-          await retryWithBackoff(() => notebook.destroy(), DELETE_RETRY_DELAYS_MS, shouldRetryRemoteRateLimitError);
-        } catch (error) {
-          if (formatError(error).includes('Notebook has been deleted')) {
-            return;
-          }
-
-          throw error;
-        }
-      });
-      notebook.dispose();
-      return notebookId;
-    }, 180_000);
-  } catch (error) {
-    notebook.dispose();
-    throw error;
-  }
-}
-
-function summarizeStages(stages: StageResult[]) {
-  const scenarios = stages.flatMap((stage) => stage.scenarios);
-  const passedScenarios = scenarios.filter((scenario) => scenario.status === 'passed').length;
-  const failedScenarios = scenarios.length - passedScenarios;
-  const stepStats = new Map<string, { passed: number; failed: number; skipped: number; durations: number[] }>();
-
-  for (const scenario of scenarios) {
-    for (const step of scenario.steps) {
-      const current = stepStats.get(step.name) ?? { passed: 0, failed: 0, skipped: 0, durations: [] };
-      current[step.status] += 1;
-      if (step.status === 'passed') {
-        current.durations.push(step.durationMs);
-      }
-      stepStats.set(step.name, current);
-    }
-  }
-
-  return {
-    scenarios: scenarios.length,
-    passedScenarios,
-    failedScenarios,
-    stepStats,
-  };
-}
-
-function renderConfiguration(options: LoadTestOptions): string {
-  const lines = [
-    'Laravel sandbox load test configuration:',
-    `  target: ${options.local ? 'local' : 'prod'}`,
-    `  template: ${options.template}`,
-    `  mode: ${options.mode}`,
-    `  stop on failing level: ${options.stopOnFailureLevel}`,
-    `  api url: ${options.apiUrl}`,
-    options.runtimeOrigin ? `  runtime origin override: ${options.runtimeOrigin}` : undefined,
-    options.runtimeUrl ? `  runtime url override: ${redactUrl(options.runtimeUrl)}` : undefined,
-    `  levels: ${options.levels.join(', ')}`,
-    `  waves per level: ${options.waves}`,
-    `  visibility: ${options.visibility}`,
-    `  cleanup: ${options.cleanup} (keep failed: ${options.keepFailed})`,
-    `  include container restart: ${options.includeContainerRestart}`,
-    `  include download: ${options.includeDownload}`,
-    `  include preview: ${options.includePreview}`,
-    `  include lsp: ${options.includeLsp}`,
-    `  required init messages: ${options.requireInitMessages.length > 0 ? options.requireInitMessages.join(' -> ') : 'none'}`,
-    `  expect provisioned: ${options.expectProvisioned ?? 'not asserted'}`,
-    `  expect provisioning action: ${options.expectProvisioningAction ?? 'not asserted'}`,
-    `  include auth: ${Boolean(options.reauthorizationUrl)}`,
-    `  insecure tls: ${options.insecureTls}`,
-    `  ca file: ${options.caFile ?? 'none'}`,
-  ];
-
-  return lines.filter(Boolean).join('\n');
-}
-
-class LoadTestUi {
-  private readonly interactive = Boolean(process.stdout.isTTY);
-  private readonly useColor = this.interactive && process.env.NO_COLOR === undefined;
-  private readonly startedAt = performance.now();
-  private readonly totalPlanned: number;
-  private readonly levelStats = new Map<number, LevelLiveStat>();
-  private readonly stepStats = new Map<string, StepLiveStat>();
-  private readonly scenarios = new Map<string, ScenarioLiveState>();
-  private readonly recentEvents: UiEvent[] = [];
-  private currentLevel?: number;
-  private currentWave?: number;
-  private currentConcurrency?: number;
-  private frameLines = 0;
-  private started = false;
-  private stopped = false;
-  private dirty = false;
-  private renderTimer?: ReturnType<typeof setInterval>;
-
-  public constructor(private readonly options: LoadTestOptions) {
-    this.totalPlanned = options.levels.reduce((sum, level) => sum + level * options.waves, 0);
-    for (const level of options.levels) {
-      this.levelStats.set(level, {
-        planned: level * options.waves,
-        completed: 0,
-        passed: 0,
-        failed: 0,
-        durations: [],
-      });
-    }
-  }
-
-  public start(): void {
-    if (this.started) {
-      return;
-    }
-
-    this.started = true;
-    if (!this.interactive) {
-      console.log(renderConfiguration(this.options));
-      return;
-    }
-
-    process.stdout.write(ansi.hideCursor);
-    this.dirty = true;
-    this.render(true);
-    this.renderTimer = setInterval(() => this.flushRender(), 200);
-    this.renderTimer.unref?.();
-  }
-
-  public stop(): void {
-    if (!this.started || this.stopped) {
-      return;
-    }
-
-    this.stopped = true;
-    if (!this.interactive) {
-      return;
-    }
-
-    if (this.renderTimer) {
-      clearInterval(this.renderTimer);
-      this.renderTimer = undefined;
-    }
-
-    this.render(true);
-    process.stdout.write(`\n${ansi.showCursor}`);
-  }
-
-  public runningScenarioCount(): number {
-    let running = 0;
-    for (const scenario of this.scenarios.values()) {
-      if (scenario.status === 'running') {
-        running += 1;
-      }
-    }
-
-    return running;
-  }
-
-  public note(message: string, tone: EventTone = 'info'): void {
-    this.pushEvent(tone, message);
-    if (!this.interactive) {
-      console.log(message);
-      return;
-    }
-
-    this.markDirty();
-  }
-
-  public onStageStart(level: number): void {
-    this.currentLevel = level;
-    this.currentWave = undefined;
-    this.currentConcurrency = undefined;
-    this.note(`=== Starting level ${level} (${this.options.waves} wave${this.options.waves === 1 ? '' : 's'}) ===`);
-  }
-
-  public onWaveStart(level: number, wave: number, concurrency: number): void {
-    this.currentLevel = level;
-    this.currentWave = wave;
-    this.currentConcurrency = concurrency;
-    this.note(`Level ${level}, wave ${wave}: launching ${concurrency} scenario(s).`);
-  }
-
-  public onScenarioStart(meta: ScenarioStartMeta): void {
-    this.scenarios.set(meta.id, {
-      ...meta,
-      status: 'running',
-      startedAt: performance.now(),
-      durationMs: 0,
-      completedSteps: 0,
-      logsCaptured: 0,
-    });
-    this.markDirty();
-  }
-
-  public attachNotebook(id: string, notebookId: string): void {
-    const state = this.scenarios.get(id);
-    if (!state) {
-      return;
-    }
-
-    state.notebookId = notebookId;
-    this.markDirty();
-  }
-
-  public updateScenarioLogs(id: string, logsCaptured: number): void {
-    const state = this.scenarios.get(id);
-    if (!state) {
-      return;
-    }
-
-    state.logsCaptured = logsCaptured;
-    this.markDirty();
-  }
-
-  public onStepStart(id: string, stepName: string): void {
-    const state = this.scenarios.get(id);
-    if (!state) {
-      return;
-    }
-
-    state.currentStep = stepName;
-    this.markDirty();
-  }
-
-  public onStepResult(id: string, stepName: string, status: StepStatus, durationMs: number, detail?: string): void {
-    const state = this.scenarios.get(id);
-    if (!state) {
-      return;
-    }
-
-    state.completedSteps += 1;
-    state.currentStep = undefined;
-    state.lastStep = `${stepName} ${status} ${formatDuration(durationMs)}`;
-    if (status === 'failed' && detail) {
-      state.error = detail;
-    }
-
-    const stat = this.stepStats.get(stepName) ?? {
-      passed: 0,
-      failed: 0,
-      skipped: 0,
-      durations: [],
-    };
-    stat[status] += 1;
-    if (status === 'passed') {
-      stat.durations.push(durationMs);
-    }
-    this.stepStats.set(stepName, stat);
-
-    this.markDirty();
-  }
-
-  public onScenarioFinish(result: ScenarioResult): void {
-    const state = this.scenarios.get(result.id);
-    if (state) {
-      state.status = result.status;
-      state.durationMs = result.durationMs;
-      state.currentStep = undefined;
-      state.error = result.errors[0];
-      state.logsCaptured = result.logsCaptured;
-      state.notebookId = result.notebookId;
-    }
-
-    const levelStat = this.levelStats.get(result.level);
-    if (levelStat) {
-      levelStat.completed += 1;
-      levelStat[result.status] += 1;
-      levelStat.durations.push(result.durationMs);
-    }
-
-    const notebookPart = result.notebookId ? ` (${result.notebookId})` : '';
-    if (result.status === 'passed') {
-      this.pushEvent('pass', `[${result.id}] PASSED in ${formatDuration(result.durationMs)}${notebookPart}`);
-    } else {
-      this.pushEvent(
-        'fail',
-        `[${result.id}] FAILED in ${formatDuration(result.durationMs)}${notebookPart}${result.errors.length > 0 ? ` :: ${result.errors[0]}` : ''}`
-      );
-    }
-
-    if (!this.interactive) {
-      console.log(
-        `[${result.id}] ${result.status.toUpperCase()} in ${formatDuration(result.durationMs)}${notebookPart}`
-      );
-      return;
-    }
-
-    this.markDirty();
-  }
-
-  private pushEvent(tone: EventTone, text: string): void {
-    this.recentEvents.push({
-      at: performance.now(),
-      tone,
-      text,
-    });
-
-    if (this.recentEvents.length > 200) {
-      this.recentEvents.splice(0, this.recentEvents.length - 200);
-    }
-  }
-
-  private markDirty(): void {
-    this.dirty = true;
-  }
-
-  private flushRender(): void {
-    if (!this.interactive || !this.started || this.stopped) {
-      return;
-    }
-
-    if (!this.dirty && !this.hasRunningScenarios()) {
-      return;
-    }
-
-    this.render();
-  }
-
-  private hasRunningScenarios(): boolean {
-    for (const scenario of this.scenarios.values()) {
-      if (scenario.status === 'running') {
-        return true;
-      }
-    }
-
-    return false;
-  }
-
-  private render(force = false): void {
-    if (!this.interactive || !this.started) {
-      return;
-    }
-
-    if (!force && !this.dirty && !this.hasRunningScenarios()) {
-      return;
-    }
-
-    this.dirty = false;
-    const frame = this.buildFrame();
-    if (this.frameLines > 0) {
-      process.stdout.write(`\x1b[${this.frameLines}F`);
-    }
-    process.stdout.write(ansi.clearDown);
-    process.stdout.write(`${frame}\n`);
-    this.frameLines = frame.split('\n').length;
-  }
-
-  private buildFrame(): string {
-    const width = Math.max(72, process.stdout.columns ?? 120);
-    const completed = Array.from(this.levelStats.values()).reduce((sum, stat) => sum + stat.completed, 0);
-    const passed = Array.from(this.levelStats.values()).reduce((sum, stat) => sum + stat.passed, 0);
-    const failed = Array.from(this.levelStats.values()).reduce((sum, stat) => sum + stat.failed, 0);
-    const runningScenarios = Array.from(this.scenarios.values()).filter((scenario) => scenario.status === 'running');
-    const running = runningScenarios.length;
-    const scenarioDurations = Array.from(this.levelStats.values()).flatMap((stat) => stat.durations);
-    const avgScenarioDuration = scenarioDurations.length > 0 ? average(scenarioDurations) : 0;
-    const p95ScenarioDuration = scenarioDurations.length > 0 ? percentile(scenarioDurations, 95) : 0;
-    const bottlenecks = this.getBottlenecks(6);
-    const primaryBottleneck = bottlenecks[0];
-    const health = this.describeHealth(failed, running, p95ScenarioDuration, primaryBottleneck?.p95 ?? 0);
-
-    const lines: string[] = [];
-    lines.push(this.decorate('PHPSandbox Load Test', ansi.bold, ansi.cyan));
-    lines.push(
-      [
-        `${this.label('target')} ${this.options.local ? 'local' : 'prod'}`,
-        `${this.label('api')} ${this.options.apiUrl}`,
-        `${this.label('template')} ${this.options.template}`,
-        `${this.label('mode')} ${this.options.mode}`,
-        `${this.label('runtime')} ${formatDuration(performance.now() - this.startedAt)}`,
-      ].join('   ')
-    );
-    lines.push(
-      [
-        `${this.label('levels')} ${this.options.levels.join(', ')}`,
-        `${this.label('waves')} ${this.options.waves}`,
-        `${this.label('cleanup')} ${this.options.cleanup ? (this.options.keepFailed ? 'success-only' : 'all') : 'off'}`,
-      ].join('   ')
-    );
-    lines.push('');
-    lines.push(
-      ...this.box(
-        'Run Snapshot',
-        width,
-        this.buildSnapshotLines({
-          width: width - 4,
-          completed,
-          passed,
-          failed,
-          running,
-          avgScenarioDuration,
-          p95ScenarioDuration,
-          primaryBottleneck,
-          health,
-        }),
-        ansi.cyan
-      )
-    );
-    lines.push('');
-
-    if (width >= 118) {
-      const gap = 2;
-      const leftWidth = Math.floor((width - gap) / 2);
-      const rightWidth = width - gap - leftWidth;
-      lines.push(
-        ...this.combineColumns(
-          this.box('Levels', leftWidth, this.buildLevelLines(leftWidth - 4), ansi.blue),
-          leftWidth,
-          this.box('Step Bottlenecks', rightWidth, this.buildBottleneckLines(rightWidth - 4, bottlenecks), ansi.magenta),
-          rightWidth,
-          gap
-        )
-      );
-    } else {
-      lines.push(...this.box('Levels', width, this.buildLevelLines(width - 4), ansi.blue));
-      lines.push('');
-      lines.push(...this.box('Step Bottlenecks', width, this.buildBottleneckLines(width - 4, bottlenecks), ansi.magenta));
-    }
-
-    lines.push('');
-
-    if (width >= 140) {
-      const gap = 2;
-      const leftWidth = Math.floor((width - gap) * 0.62);
-      const rightWidth = width - gap - leftWidth;
-      lines.push(
-        ...this.combineColumns(
-          this.box('Active Scenarios', leftWidth, this.buildActiveScenarioLines(leftWidth - 4, runningScenarios), ansi.green),
-          leftWidth,
-          this.box('Recent Events', rightWidth, this.buildEventLines(rightWidth - 4), ansi.yellow),
-          rightWidth,
-          gap
-        )
-      );
-    } else {
-      lines.push(...this.box('Active Scenarios', width, this.buildActiveScenarioLines(width - 4, runningScenarios), ansi.green));
-      lines.push('');
-      lines.push(...this.box('Recent Events', width, this.buildEventLines(width - 4), ansi.yellow));
-    }
-
-    return lines.join('\n');
-  }
-
-  private buildSnapshotLines(input: {
-    width: number;
-    completed: number;
-    passed: number;
-    failed: number;
-    running: number;
-    avgScenarioDuration: number;
-    p95ScenarioDuration: number;
-    primaryBottleneck?: { name: string; avg: number; p95: number };
-    health: { label: string; tone: EventTone };
-  }): string[] {
-    const progressWidth = Math.max(12, Math.min(34, input.width - 50));
-    const lines: string[] = [];
-    lines.push(
-      `Overall ${this.progressBar(input.completed, this.totalPlanned, progressWidth)} ${input.completed}/${this.totalPlanned} done   ${this.decorate(String(input.passed), ansi.green)} pass   ${this.decorate(String(input.failed), ansi.red)} fail   ${this.decorate(String(input.running), ansi.blue)} running`
-    );
-    lines.push(
-      `Current level ${this.currentLevel ?? '-'}   wave ${this.currentWave ?? '-'}   concurrency ${this.currentConcurrency ?? '-'}   state ${this.decorateHealth(input.health)}`
-    );
-
-    const avgLabel = input.completed > 0 ? this.decorateDuration(input.avgScenarioDuration) : this.decorate('-', ansi.dim);
-    const p95Label = input.completed > 0 ? this.decorateDuration(input.p95ScenarioDuration) : this.decorate('-', ansi.dim);
-    const bottleneck =
-      input.primaryBottleneck === undefined
-        ? 'waiting for step timings'
-        : `${truncate(input.primaryBottleneck.name, Math.max(12, input.width - 48))} p95 ${this.decorateDuration(input.primaryBottleneck.p95)}`;
-
-    lines.push(`Scenarios avg ${avgLabel}   p95 ${p95Label}   bottleneck ${bottleneck}`);
-
-    return lines;
-  }
-
-  private buildLevelLines(contentWidth: number): string[] {
-    const header = `${padRight('Lvl', 4)} ${padRight('Done', 11)} ${padRight('P', 3)} ${padRight('F', 3)} ${padRight('Avg', 8)} ${padRight('P95', 8)} Load`;
-    const lines = [header];
-    const maxP95 = Math.max(
-      1,
-      ...this.options.levels.map((level) => {
-        const stat = this.levelStats.get(level)!;
-        return stat.durations.length > 0 ? percentile(stat.durations, 95) : 0;
-      })
-    );
-    const barWidth = Math.max(6, Math.min(14, contentWidth - 48));
-
-    for (const level of this.options.levels) {
-      const stat = this.levelStats.get(level)!;
-      const avgMs = stat.durations.length > 0 ? average(stat.durations) : 0;
-      const p95Ms = stat.durations.length > 0 ? percentile(stat.durations, 95) : 0;
-      const avg = stat.durations.length > 0 ? this.decorateDuration(avgMs) : this.decorate('-', ansi.dim);
-      const p95 = stat.durations.length > 0 ? this.decorateDuration(p95Ms) : this.decorate('-', ansi.dim);
-      const loadBar = this.metricBar(p95Ms, maxP95, barWidth);
-      lines.push(
-        `${padRight(`L${level}`, 4)} ${padRight(`${stat.completed}/${stat.planned}`, 11)} ${padLeft(String(stat.passed), 3)} ${padLeft(String(stat.failed), 3)} ${padVisibleLeft(avg, 8)} ${padVisibleLeft(p95, 8)} ${loadBar}`
-      );
-    }
-
-    return lines;
-  }
-
-  private buildBottleneckLines(
-    contentWidth: number,
-    bottlenecks: Array<{ name: string; avg: number; p95: number; passed: number; failed: number; skipped: number }>
-  ): string[] {
-    if (bottlenecks.length === 0) {
-      return [this.decorate('waiting for step timings', ansi.dim)];
-    }
-
-    const nameWidth = Math.max(12, contentWidth - 28);
-    const barWidth = Math.max(4, Math.min(10, contentWidth - nameWidth - 20));
-    const header = `${padRight('Step', nameWidth)} ${padRight('Avg', 8)} ${padRight('P95', 8)} P/F/S`;
-    const lines = [header];
-    const maxP95 = Math.max(1, ...bottlenecks.map((entry) => entry.p95));
-
-    for (const entry of bottlenecks.slice(0, 6)) {
-      const counts = `${entry.passed}/${entry.failed}/${entry.skipped}`;
-      lines.push(
-        `${padRight(truncate(entry.name, nameWidth), nameWidth)} ${padVisibleLeft(this.decorateDuration(entry.avg), 8)} ${padVisibleLeft(this.decorateDuration(entry.p95), 8)} ${padLeft(counts, 7)} ${this.metricBar(entry.p95, maxP95, barWidth)}`
-      );
-    }
-
-    return lines;
-  }
-
-  private buildActiveScenarioLines(contentWidth: number, runningScenarios: ScenarioLiveState[]): string[] {
-    const scenarios = [...runningScenarios]
-      .sort((left, right) => left.startedAt - right.startedAt)
-      .slice(0, 10);
-
-    if (scenarios.length === 0) {
-      return [this.decorate('idle', ansi.dim)];
-    }
-
-    const stepWidth = Math.max(18, contentWidth - 42);
-    const header = `${padRight('Scenario', 16)} ${padRight('Step', stepWidth)} ${padLeft('Age', 8)} ${padLeft('Logs', 4)} Nb`;
-    const lines = [header];
-
-    for (const scenario of scenarios) {
-      const step = scenario.currentStep ?? scenario.lastStep ?? 'starting';
-      const notebook = scenario.notebookId ? truncate(scenario.notebookId, 8) : '-';
-      lines.push(
-        `${padRight(scenario.id, 16)} ${padRight(truncate(step, stepWidth), stepWidth)} ${padLeft(formatDuration(performance.now() - scenario.startedAt), 8)} ${padLeft(String(scenario.logsCaptured), 4)} ${padRight(notebook, 8)}`
-      );
-    }
-
-    if (runningScenarios.length > scenarios.length) {
-      lines.push(this.decorate(`... ${runningScenarios.length - scenarios.length} more running scenario(s)`, ansi.dim));
-    }
-
-    return lines;
-  }
-
-  private buildEventLines(contentWidth: number): string[] {
-    const events = this.selectVisibleEvents(8);
-    if (events.length === 0) {
-      return [this.decorate('waiting for events', ansi.dim)];
-    }
-
-    return events.map((event) => {
-      const age = `+${formatDuration(event.at - this.startedAt)}`;
-      return `${this.eventPrefix(event.tone)} ${padRight(age, 8)} ${truncate(event.text, Math.max(12, contentWidth - 14))}`;
-    });
-  }
-
-  private selectVisibleEvents(limit: number): UiEvent[] {
-    const recent = this.recentEvents.slice(-24);
-    const prioritized: UiEvent[] = [];
-    const failures = recent
-      .filter((event) => event.tone === 'fail' || event.tone === 'warn')
-      .slice(-Math.max(2, Math.floor(limit / 2)));
-
-    for (const event of failures) {
-      prioritized.push(event);
-    }
-
-    for (const event of recent.slice(-limit * 2)) {
-      if (prioritized.includes(event)) {
-        continue;
-      }
-      prioritized.push(event);
-      if (prioritized.length >= limit) {
-        break;
-      }
-    }
-
-    return prioritized.slice(-limit);
-  }
-
-  private getBottlenecks(limit: number): Array<{ name: string; avg: number; p95: number; passed: number; failed: number; skipped: number }> {
-    return Array.from(this.stepStats.entries())
-      .map(([name, stat]) => ({
-        name,
-        avg: stat.durations.length > 0 ? average(stat.durations) : 0,
-        p95: stat.durations.length > 0 ? percentile(stat.durations, 95) : 0,
-        passed: stat.passed,
-        failed: stat.failed,
-        skipped: stat.skipped,
-      }))
-      .sort(
-        (left, right) =>
-          right.p95 - left.p95 || right.avg - left.avg || right.failed - left.failed || left.name.localeCompare(right.name)
-      )
-      .slice(0, limit);
-  }
-
-  private describeHealth(
-    failed: number,
-    running: number,
-    p95ScenarioDuration: number,
-    bottleneckP95: number
-  ): { label: string; tone: EventTone } {
-    if (failed > 0) {
-      return { label: 'degraded', tone: 'fail' };
-    }
-
-    if (p95ScenarioDuration >= 90_000 || bottleneckP95 >= 30_000) {
-      return { label: 'under pressure', tone: 'warn' };
-    }
-
-    if (running > 0) {
-      return { label: 'steady', tone: 'pass' };
-    }
-
-    return { label: 'complete', tone: 'info' };
-  }
-
-  private decorateHealth(health: { label: string; tone: EventTone }): string {
-    if (health.tone === 'fail') {
-      return this.decorate(health.label, ansi.red, ansi.bold);
-    }
-    if (health.tone === 'warn') {
-      return this.decorate(health.label, ansi.yellow, ansi.bold);
-    }
-    if (health.tone === 'pass') {
-      return this.decorate(health.label, ansi.green, ansi.bold);
-    }
-
-    return this.decorate(health.label, ansi.cyan, ansi.bold);
-  }
-
-  private box(title: string, width: number, body: string[], accent: string): string[] {
-    const safeWidth = Math.max(28, width);
-    const innerWidth = safeWidth - 4;
-    const titleText = truncate(title, safeWidth - 6);
-    const topFill = Math.max(0, safeWidth - titleText.length - 5);
-    const top = `+ ${this.decorate(titleText, ansi.bold, accent)} ${'-'.repeat(topFill)}+`;
-    const lines = [top];
-
-    for (const line of body) {
-      lines.push(`| ${padVisibleRight(line, innerWidth)} |`);
-    }
-
-    lines.push(`+${'-'.repeat(safeWidth - 2)}+`);
-    return lines;
-  }
-
-  private combineColumns(left: string[], leftWidth: number, right: string[], rightWidth: number, gap: number): string[] {
-    const height = Math.max(left.length, right.length);
-    const output: string[] = [];
-
-    for (let index = 0; index < height; index += 1) {
-      output.push(
-        `${padVisibleRight(left[index] ?? '', leftWidth)}${' '.repeat(gap)}${padVisibleRight(right[index] ?? '', rightWidth)}`
-      );
-    }
-
-    return output;
-  }
-
-  private metricBar(value: number, max: number, width: number): string {
-    const safeWidth = Math.max(4, width);
-    if (max <= 0) {
-      return `[${'.'.repeat(safeWidth)}]`;
-    }
-
-    const filled = Math.max(0, Math.min(safeWidth, Math.round((value / max) * safeWidth)));
-    const bar = `[${'#'.repeat(filled)}${'.'.repeat(Math.max(0, safeWidth - filled))}]`;
-    if (value >= 30_000) {
-      return this.decorate(bar, ansi.red);
-    }
-    if (value >= 10_000) {
-      return this.decorate(bar, ansi.yellow);
-    }
-
-    return this.decorate(bar, ansi.green);
-  }
-
-  private progressBar(completed: number, total: number, width: number): string {
-    if (total <= 0) {
-      return '[----------]';
-    }
-
-    const safeWidth = Math.max(10, width);
-    const filled = Math.max(0, Math.min(safeWidth, Math.round((completed / total) * safeWidth)));
-    return `[${'='.repeat(filled)}${'-'.repeat(Math.max(0, safeWidth - filled))}]`;
-  }
-
-  private decorateDuration(durationMs: number): string {
-    const value = formatDuration(durationMs);
-    if (durationMs >= 30_000) {
-      return this.decorate(value, ansi.red);
-    }
-    if (durationMs >= 10_000) {
-      return this.decorate(value, ansi.yellow);
-    }
-
-    return this.decorate(value, ansi.green);
-  }
-
-  private label(text: string): string {
-    return this.decorate(text, ansi.dim, ansi.gray);
-  }
-
-  private eventPrefix(tone: EventTone): string {
-    if (tone === 'pass') {
-      return this.decorate('OK', ansi.green, ansi.bold);
-    }
-    if (tone === 'fail') {
-      return this.decorate('ER', ansi.red, ansi.bold);
-    }
-    if (tone === 'warn') {
-      return this.decorate('!!', ansi.yellow, ansi.bold);
-    }
-
-    return this.decorate('..', ansi.cyan, ansi.bold);
-  }
-
-  private decorate(text: string, ...codes: string[]): string {
-    if (!this.useColor) {
-      return text;
-    }
-
-    return `${codes.join('')}${text}${ansi.reset}`;
-  }
-}
-
-function renderSummary(
-  stages: StageResult[],
-  summary: ReturnType<typeof summarizeStages>
-): string {
-  const lines: string[] = [];
-  lines.push('\n=== Load test summary ===');
-
-  for (const stage of stages) {
-    const stagePassed = stage.scenarios.filter((scenario) => scenario.status === 'passed').length;
-    const stageFailed = stage.scenarios.length - stagePassed;
-    const durations = stage.scenarios.map((scenario) => scenario.durationMs);
-    lines.push(
-      `Level ${stage.level}: ${stagePassed}/${stage.scenarios.length} passed, ${stageFailed}/${stage.scenarios.length} failed, ` +
-        `avg=${formatDuration(average(durations))}, p95=${formatDuration(percentile(durations, 95))}`
-    );
-  }
-
-  lines.push(
-    `Overall: ${summary.passedScenarios}/${summary.scenarios} passed, ${summary.failedScenarios}/${summary.scenarios} failed`
-  );
-  lines.push('Step timings:');
-
-  for (const [name, stat] of Array.from(summary.stepStats.entries()).sort(([a], [b]) => a.localeCompare(b))) {
-    const durationDetail =
-      stat.durations.length > 0
-        ? `avg=${formatDuration(average(stat.durations))}, p95=${formatDuration(percentile(stat.durations, 95))}`
-        : 'no successful timings';
-
-    lines.push(
-      `  ${name}: pass=${stat.passed} fail=${stat.failed} skip=${stat.skipped} ${durationDetail}`
-    );
-  }
-
-  const failedScenarios = stages
-    .flatMap((stage) => stage.scenarios)
-    .filter((scenario) => scenario.status === 'failed');
-
-  if (failedScenarios.length > 0) {
-    lines.push('Failures:');
-    for (const scenario of failedScenarios) {
-      lines.push(`  ${scenario.id}: ${scenario.errors.join(' | ')}`);
-    }
-  }
-
-  return lines.join('\n');
-}
-
-async function recordStep<T>(
-  steps: StepResult[],
-  name: string,
-  action: () => Promise<T>,
-  timeoutMs: number
-): Promise<T> {
-  const startedAt = performance.now();
-
-  try {
-    const value = await withTimeout(action(), timeoutMs, `${name} timed out after ${timeoutMs}ms`);
-    steps.push({
-      name,
-      status: 'passed',
-      durationMs: performance.now() - startedAt,
-      detail: trimDetail(describeValue(value)),
-    });
-
-    return value;
-  } catch (error) {
-    steps.push({
-      name,
-      status: 'failed',
-      durationMs: performance.now() - startedAt,
-      error: formatError(error),
-    });
-
-    throw error;
-  }
-}
-
-function recordSkippedStep(steps: StepResult[], name: string, detail: string): void {
-  steps.push({
-    name,
-    status: 'skipped',
-    durationMs: 0,
-    detail,
-  });
-}
-
-function createDeferred<T>(): Deferred<T> {
-  let resolveFn: ((value: T) => void) | null = null;
-  let rejectFn: ((reason?: unknown) => void) | null = null;
-
-  const deferred: Deferred<T> = {
-    settled: false,
-    promise: new Promise<T>((resolve, reject) => {
-      resolveFn = (value) => {
-        if (deferred.settled) {
-          return;
-        }
-
-        deferred.settled = true;
-        resolve(value);
-      };
-
-      rejectFn = (reason) => {
-        if (deferred.settled) {
-          return;
-        }
-
-        deferred.settled = true;
-        reject(reason);
-      };
-    }),
-    resolve(value: T) {
-      resolveFn?.(value);
-    },
-    reject(reason?: unknown) {
-      rejectFn?.(reason);
-    },
-  };
-
-  return deferred;
-}
-
-function waitForNextEvent<T>(
-  subscribe: (handler: (data: T) => void) => Disposable,
-  timeoutMs: number,
-  label: string
-): Promise<T> {
-  return new Promise<T>((resolve, reject) => {
-    let disposable: Disposable | null = null;
-    const timer = setTimeout(() => {
-      disposable?.dispose();
-      reject(new Error(`Timed out waiting for ${label}.`));
-    }, timeoutMs);
-
-    disposable = subscribe((data) => {
-      clearTimeout(timer);
-      disposable?.dispose();
-      resolve(data);
-    });
-  });
-}
-
-function firstFulfilled<T>(promises: Array<Promise<T>>): Promise<T> {
-  return new Promise<T>((resolve, reject) => {
-    const errors: unknown[] = [];
-    let pending = promises.length;
-
-    for (const [index, promise] of promises.entries()) {
-      void promise.then(resolve, (error) => {
-        errors[index] = error;
-        pending -= 1;
-        if (pending === 0) {
-          reject(errors[0] ?? new Error('All candidate promises rejected.'));
-        }
-      });
-    }
-  });
-}
-
-async function readStreamToString(
-  stream: ReadableStream<string | Uint8Array>,
-  timeoutMs: number,
-  maxChars: number
-): Promise<string> {
-  const reader = stream.getReader();
-  let output = '';
-
-  try {
-    while (output.length < maxChars) {
-      const chunk = await withTimeout(reader.read(), timeoutMs, 'waiting for stream output');
-      if (chunk.done) {
-        break;
-      }
-
-      output += chunk.value instanceof Uint8Array ? new TextDecoder().decode(chunk.value) : (chunk.value ?? '');
-    }
-
-    return output;
-  } finally {
-    reader.releaseLock();
-  }
-}
-
-async function readNextChunk(
-  reader: ReadableStreamDefaultReader<string>,
-  timeoutMs: number
-): Promise<string> {
-  const chunk = await withTimeout(reader.read(), timeoutMs, 'waiting for the next stream chunk');
-  if (chunk.done || typeof chunk.value !== 'string') {
-    throw new Error('Stream ended before a chunk was received.');
-  }
-
-  return chunk.value;
-}
-
-function isStreamInactivityError(error: unknown): boolean {
-  return formatError(error).includes('waiting for stream output');
-}
-
-function makeRouteContents(id: string, routeUrlPath: string): string {
-  return `// load-test:${id}
-Route::get('/${routeUrlPath}', function () {
-    return response()->json([
-        'scenario' => '${id}',
-        'ok' => true,
-    ]);
-});
-`;
-}
-
-function appendRouteDefinition(currentContents: string, id: string, routeUrlPath: string): string {
-  const snippet = makeRouteContents(id, routeUrlPath);
-  if (currentContents.includes(`load-test:${id}`)) {
-    return currentContents;
-  }
-
-  const trimmed = currentContents.trimEnd();
-  return `${trimmed}\n\n${snippet}`;
-}
-
-async function fetchDefaultPreview(
-  options: LoadTestOptions,
-  notebook: NotebookInstance,
-  previewUrl: string | undefined
-): Promise<string> {
-  if (!previewUrl) {
-    throw new Error('previewUrl was not captured from notebook.ready().');
-  }
-
-  return retryWithBackoff(async () => {
-    const response = await requestPreviewWithSession(options, notebook, previewUrl);
-    if (response.status >= 500) {
-      throw new Error(`Preview returned HTTP ${response.status}: ${trimDetail(response.body)}`);
-    }
-
-    return `status=${response.status} bytes=${response.body.length} url=${redactUrl(previewUrl)}`;
-  }, PREVIEW_RETRY_DELAYS_MS, () => true);
-}
-
-async function fetchScenarioPreview(
-  options: LoadTestOptions,
-  notebook: NotebookInstance,
-  previewUrl: string | undefined,
-  routeUrlPath: string,
-  scenarioId: string
-): Promise<string> {
-  if (!previewUrl) {
-    throw new Error('previewUrl was not captured from notebook.ready().');
-  }
-
-  const routeUrl = previewUrlForPath(previewUrl, routeUrlPath);
-  return retryWithBackoff(async () => {
-    const response = await requestPreviewWithSession(options, notebook, routeUrl);
-    if (response.status !== 200) {
-      throw new Error(`Preview route returned HTTP ${response.status}: ${trimDetail(response.body)}`);
-    }
-    if (!response.body.includes(scenarioId)) {
-      throw new Error(`Preview route response did not include ${scenarioId}.`);
-    }
-
-    return `status=${response.status} bytes=${response.body.length} url=${redactUrl(routeUrl)}`;
-  }, PREVIEW_RETRY_DELAYS_MS, () => true);
-}
-
-function previewUrlForPath(baseUrl: string, path: string): string {
-  const base = baseUrl.endsWith('/') ? baseUrl : `${baseUrl}/`;
-  return new URL(path.replace(/^\/+/, ''), base).toString();
-}
-
-async function requestPreviewWithSession(
-  options: LoadTestOptions,
-  notebook: NotebookInstance,
-  url: string
-): Promise<{ status: number; body: string }> {
-  let session: NotebookPreviewSessionData;
-  try {
-    session = await notebook.preview.createSession({ url });
-  } catch (error) {
-    if (formatError(error).includes('Preview access must be enabled')) {
-      return requestPreview(options, url);
-    }
-
-    throw error;
-  }
-
-  const bootstrapUrl = session.url;
-  const bootstrap = await requestPreview(options, bootstrapUrl, { maxRedirects: 0 });
-  const cookie = firstSetCookie(bootstrap.headers);
-
-  if (bootstrap.status >= 300 && bootstrap.status < 400) {
-    const location = bootstrap.headers.location;
-    const nextUrl = typeof location === 'string' && location.length > 0
-      ? new URL(location, bootstrapUrl).toString()
-      : url;
-
-    return requestPreview(options, nextUrl, {
-      headers: cookie ? { cookie } : undefined,
-    });
-  }
-
-  if (cookie) {
-    return requestPreview(options, url, {
-      headers: { cookie },
-    });
-  }
-
-  return {
-    status: bootstrap.status,
-    body: bootstrap.body,
-  };
-}
-
-function firstSetCookie(headers: Record<string, unknown>): string | undefined {
-  const raw = headers['set-cookie'];
-  const value = Array.isArray(raw) ? raw[0] : raw;
-  if (typeof value !== 'string' || value.length === 0) {
-    return undefined;
-  }
-
-  return value.split(';', 1)[0];
-}
-
-async function requestPreview(
-  options: LoadTestOptions,
-  url: string,
-  requestOptions: { headers?: Record<string, string>; maxRedirects?: number } = {}
-): Promise<{ status: number; body: string; headers: Record<string, unknown> }> {
-  const ca = options.caFile ? await fs.readFile(options.caFile, 'utf8') : undefined;
-  const httpsAgent = url.startsWith('https://')
-    ? new https.Agent({
-        ca,
-        rejectUnauthorized: !options.insecureTls,
-      })
-    : undefined;
-  const response = await axios.request<string>({
-    url,
-    method: 'GET',
-    responseType: 'text',
-    validateStatus: () => true,
-    httpsAgent,
-    headers: requestOptions.headers,
-    maxRedirects: requestOptions.maxRedirects,
-    timeout: options.stepTimeoutMs,
-  });
-
-  return {
-    status: response.status,
-    body: typeof response.data === 'string' ? response.data : String(response.data ?? ''),
-    headers: response.headers as Record<string, unknown>,
-  };
-}
-
-function encodeLspPayload(payload: unknown): string {
-  const body = JSON.stringify(payload);
-  return `Content-Length: ${Buffer.byteLength(body, 'utf8')}\r\n\r\n${body}`;
-}
-
-async function retryWithBackoff<T>(
-  action: () => Promise<T>,
-  delaysMs: number[],
-  shouldRetry: (error: unknown) => boolean
-): Promise<T> {
-  let attempt = 0;
-
-  while (true) {
-    try {
-      return await action();
-    } catch (error) {
-      if (!shouldRetry(error) || attempt >= delaysMs.length) {
-        throw error;
-      }
-
-      await sleep(delaysMs[attempt]);
-      attempt += 1;
-    }
-  }
-}
-
-function formatError(error: unknown): string {
-  if (error instanceof Error) {
-    return error.message;
-  }
-
-  return String(error);
-}
-
-function shouldRetryRemoteRateLimitError(error: unknown): boolean {
-  return RemoteError.is(error, 'RateLimited');
-}
-
-function shouldRetryTelemetryError(error: unknown): boolean {
-  const message = formatError(error);
-  return message.includes('container.stats') || message.includes('container.telemetry');
-}
-
-function isInterruptedError(error: unknown): boolean {
-  return error instanceof LoadTestInterruptedError;
-}
-
-function installSignalHandler(ui: LoadTestUi, interrupts: InterruptController): () => void {
-  const onSigint = () => {
-    if (interrupts.request()) {
-      const running = ui.runningScenarioCount();
-      ui.note(
-        `SIGINT received. Stopping after ${running} active scenario(s) finish their current step and cleanup. Press Ctrl+C again to force exit.`,
-        'warn'
-      );
-      return;
-    }
-
-    ui.note('Second SIGINT received. Exiting immediately.', 'fail');
-    ui.stop();
-    process.exit(130);
-  };
-
-  process.on('SIGINT', onSigint);
-  return () => {
-    process.off('SIGINT', onSigint);
-  };
-}
-
-function explainMissingAction(error: unknown, action: string): string | undefined {
-  const message = formatError(error);
-  if (message.includes(`Action ${action} not found`)) {
-    return `${action} is not implemented by this backend`;
-  }
-
-  return undefined;
-}
-
-function explainUnsupportedShell(error: unknown): string | undefined {
-  const message = formatError(error);
-  if (message.includes('/usr/bin/sh: no such file or directory')) {
-    return 'shell/terminal backend is unavailable in this environment';
-  }
-
-  return undefined;
-}
-
-function explainUnavailableGit(error: unknown): string | undefined {
-  const message = formatError(error);
-  if (message.includes('Git repository is not initialized in this notebook.')) {
-    return 'git service is available but this template is not a git repository';
-  }
-
-  return undefined;
-}
-
-function truncate(value: string, maxLength: number): string {
-  if (value.length <= maxLength) {
-    return value;
-  }
-
-  if (maxLength <= 3) {
-    return value.slice(0, maxLength);
-  }
-
-  return `${value.slice(0, maxLength - 3)}...`;
-}
-
-function stripAnsi(value: string): string {
-  return value.replace(/\x1B\[[0-?]*[ -/]*[@-~]/g, '');
-}
-
-function visibleWidth(value: string): number {
-  return stripAnsi(value).length;
-}
-
-function padVisibleRight(value: string, width: number): string {
-  const plainWidth = visibleWidth(value);
-  if (plainWidth > width) {
-    return truncate(stripAnsi(value), width);
-  }
-
-  return `${value}${' '.repeat(width - plainWidth)}`;
-}
-
-function padVisibleLeft(value: string, width: number): string {
-  const plainWidth = visibleWidth(value);
-  if (plainWidth > width) {
-    return truncate(stripAnsi(value), width);
-  }
-
-  return `${' '.repeat(width - plainWidth)}${value}`;
-}
-
-function padRight(value: string, width: number): string {
-  if (value.length >= width) {
-    return value;
-  }
-
-  return `${value}${' '.repeat(width - value.length)}`;
-}
-
-function padLeft(value: string, width: number): string {
-  if (value.length >= width) {
-    return value;
-  }
-
-  return `${' '.repeat(width - value.length)}${value}`;
-}
-
-function trimDetail(value: string, maxLength = 160): string {
-  const normalized = value.replace(/\s+/g, ' ').trim();
-  if (normalized.length <= maxLength) {
-    return normalized;
-  }
-
-  return `${normalized.slice(0, maxLength - 3)}...`;
-}
-
-function describeValue(value: unknown): string {
-  if (typeof value === 'string') {
-    return value;
-  }
-
-  if (typeof value === 'number' || typeof value === 'boolean') {
-    return String(value);
-  }
-
-  if (value === null || value === undefined) {
-    return String(value);
-  }
-
-  try {
-    return JSON.stringify(value);
-  } catch {
-    return Object.prototype.toString.call(value);
-  }
-}
-
-function sanitizeArtifact<T>(payload: T): T {
-  const cloned = JSON.parse(JSON.stringify(payload));
-
-  if (cloned.options) {
-    if ('token' in cloned.options) {
-      cloned.options.token = '<redacted>';
-    }
-    if ('reauthorizationUrl' in cloned.options) {
-      cloned.options.reauthorizationUrl = '<redacted>';
-    }
-  }
-
-  for (const stage of cloned.stages ?? []) {
-    for (const scenario of stage.scenarios ?? []) {
-      for (const step of scenario.steps ?? []) {
-        if (step.name === 'notebook.ready' && typeof step.detail === 'string') {
-          step.detail = 'notebook initialized successfully';
-        }
-      }
-    }
-  }
-
-  return cloned;
-}
-
-function average(values: number[]): number {
-  if (values.length === 0) {
-    return 0;
-  }
-
-  return values.reduce((sum, value) => sum + value, 0) / values.length;
-}
-
-function percentile(values: number[], percentileValue: number): number {
-  if (values.length === 0) {
-    return 0;
-  }
-
-  const sorted = [...values].sort((a, b) => a - b);
-  const index = Math.min(
-    sorted.length - 1,
-    Math.max(0, Math.ceil((percentileValue / 100) * sorted.length) - 1)
-  );
-
-  return sorted[index];
-}
-
-function formatDuration(durationMs: number): string {
-  if (durationMs < 1000) {
-    return `${durationMs.toFixed(0)}ms`;
-  }
-
-  return `${(durationMs / 1000).toFixed(2)}s`;
-}
-
-function sleep(ms: number, signal?: AbortSignal): Promise<void> {
-  return new Promise((resolve, reject) => {
-    if (signal?.aborted) {
-      reject(signal.reason instanceof Error ? signal.reason : new LoadTestInterruptedError());
-      return;
-    }
-
-    const timer = setTimeout(() => {
-      signal?.removeEventListener('abort', onAbort);
-      resolve();
-    }, ms);
-
-    const onAbort = () => {
-      clearTimeout(timer);
-      signal?.removeEventListener('abort', onAbort);
-      reject(signal?.reason instanceof Error ? signal.reason : new LoadTestInterruptedError());
-    };
-
-    signal?.addEventListener('abort', onAbort, { once: true });
-  });
-}
-
-function withTimeout<T>(promise: Promise<T>, timeoutMs: number, label: string): Promise<T> {
-  return new Promise<T>((resolve, reject) => {
-    const timer = setTimeout(() => reject(new Error(label)), timeoutMs);
-
-    promise.then(
-      (value) => {
-        clearTimeout(timer);
-        resolve(value);
-      },
-      (error) => {
-        clearTimeout(timer);
-        reject(error);
-      }
-    );
-  });
-}
-
-function parseOptions(argv: string[]): LoadTestOptions {
-  const args = parseArgs(argv);
-  const token = stringArg(args, 'token') ?? process.env.PHPSANDBOX_TOKEN;
-
-  if (!token) {
-    throw new Error('Missing PHPSANDBOX_TOKEN. Pass it via the environment or --token.');
-  }
-
-  const levels = resolveLevels(args);
-  const local = booleanArg(args, 'local') ?? false;
-  const caFile = stringArg(args, 'ca-file');
-  const apiUrl =
-    stringArg(args, 'api-url') ??
-    (local ? DEFAULT_LOCAL_API_URL : undefined) ??
-    process.env.PHPSANDBOX_API_URL ??
-    DEFAULT_PROD_API_URL;
-  const insecureTls = booleanArg(args, 'insecure-tls') ?? (local && !caFile);
-
-  return {
-    token,
-    local,
-    apiUrl,
-    runtimeOrigin: stringArg(args, 'runtime-origin'),
-    runtimeUrl: stringArg(args, 'runtime-url'),
-    template: stringArg(args, 'template') ?? 'laravel',
-    mode: resolveMode(args),
-    stopOnFailureLevel: booleanArg(args, 'stop-on-failure-level') ?? false,
-    titlePrefix: stringArg(args, 'title-prefix') ?? 'Laravel SDK Load Test',
-    visibility: visibilityArg(args, 'visibility') ?? 'private',
-    levels,
-    waves: numberArg(args, 'waves') ?? 1,
-    pauseMs: numberArg(args, 'pause-ms') ?? 0,
-    cleanup: booleanArg(args, 'cleanup') ?? true,
-    keepFailed: booleanArg(args, 'keep-failed') ?? false,
-    debug: booleanArg(args, 'debug') ?? false,
-    stepTimeoutMs: numberArg(args, 'step-timeout-ms') ?? 60_000,
-    streamTimeoutMs: numberArg(args, 'stream-timeout-ms') ?? 20_000,
-    telemetryTimeoutMs: numberArg(args, 'telemetry-timeout-ms') ?? 15_000,
-    maxStreamChars: numberArg(args, 'max-stream-chars') ?? 200_000,
-    includeContainerRestart: booleanArg(args, 'include-container-restart') ?? false,
-    includeDownload: booleanArg(args, 'include-download') ?? false,
-    includePreview: booleanArg(args, 'include-preview') ?? false,
-    includeLsp: booleanArg(args, 'include-lsp') ?? false,
-    requireInitMessages: listArg(args, 'require-init-messages'),
-    expectProvisioned: booleanArg(args, 'expect-provisioned'),
-    expectProvisioningAction: provisioningActionArg(args, 'expect-provisioning-action'),
-    reauthorizationUrl: stringArg(args, 'reauthorization-url'),
-    json: booleanArg(args, 'json') ?? false,
-    jsonFile: stringArg(args, 'json-file'),
-    insecureTls,
-    caFile,
-  };
-}
-
-function resolveRuntimeUrl(original: string, options: LoadTestOptions): string {
-  if (options.runtimeUrl) {
-    return options.runtimeUrl;
-  }
-
-  if (!options.runtimeOrigin) {
-    return original;
-  }
-
-  const source = new URL(original);
-  const target = new URL(options.runtimeOrigin);
-  source.protocol = target.protocol;
-  source.host = target.host;
-  return source.toString();
-}
-
-function assertValidUrl(value: unknown, label: string): string {
-  if (typeof value !== 'string' || value.length === 0) {
-    throw new Error(`${label} must be a non-empty string, got ${JSON.stringify(value)}`);
-  }
-
-  try {
-    new URL(value);
-  } catch {
-    throw new Error(`${label} must be a valid URL, got ${JSON.stringify(value)}`);
-  }
-
-  return value;
-}
-
-function assertPortInfoList(value: unknown, label: string): PortInfo[] {
-  if (!Array.isArray(value)) {
-    throw new Error(`${label} must be an array, got ${JSON.stringify(value)}`);
-  }
-
-  value.forEach((rawPort, index) => {
-    if (!rawPort || typeof rawPort !== 'object') {
-      throw new Error(`${label}[${index}] must be an object, got ${JSON.stringify(rawPort)}`);
-    }
-
-    const port = rawPort as Partial<PortInfo>;
-    if (!Number.isInteger(port.port) || (port.port ?? 0) <= 0) {
-      throw new Error(`${label}[${index}].port must be a positive integer, got ${JSON.stringify(port.port)}`);
-    }
-    assertValidUrl(port.url, `${label}[${index}].url`);
-    if (typeof port.subdomain !== 'string' || port.subdomain.length === 0) {
-      throw new Error(`${label}[${index}].subdomain must be a non-empty string, got ${JSON.stringify(port.subdomain)}`);
-    }
-    if (typeof port.default !== 'boolean') {
-      throw new Error(`${label}[${index}].default must be boolean, got ${JSON.stringify(port.default)}`);
-    }
-  });
-
-  return value as PortInfo[];
-}
-
-function validateInitTrace(
-  trace: InitTrace | undefined,
-  ready: NotebookInitSuccessResult | undefined,
-  options: LoadTestOptions
-): string {
-  if (!trace) {
-    throw new Error('Notebook initialization trace was not captured.');
-  }
-
-  if (!ready) {
-    throw new Error('Notebook ready result was not captured.');
-  }
-
-  const initMessages = trace.events
-    .filter((event) => event.source === 'init')
-    .map((event) => event.message)
-    .filter(Boolean);
-  const provisionMessages = trace.events
-    .filter((event) => event.source === 'provision')
-    .map((event) => event.message)
-    .filter(Boolean);
-
-  if (options.requireInitMessages.length > 0) {
-    assertMessagesInOrder(initMessages, options.requireInitMessages);
-  }
-
-  if (options.expectProvisioned !== undefined && ready.data.provisioned !== options.expectProvisioned) {
-    throw new Error(
-      `Expected notebook.ready data.provisioned=${options.expectProvisioned}, got ${ready.data.provisioned}.`
-    );
-  }
-
-  if (
-    options.expectProvisioningAction !== undefined &&
-    ready.data.provisioningAction !== options.expectProvisioningAction
-  ) {
-    throw new Error(
-      `Expected notebook.ready data.provisioningAction=${options.expectProvisioningAction}, got ${ready.data.provisioningAction}.`
-    );
-  }
-
-  return [
-    `result=${trace.resultType ?? 'unknown'}`,
-    `init=${formatMessageTrace(initMessages)}`,
-    provisionMessages.length > 0 ? `provision=${formatMessageTrace(provisionMessages)}` : 'provision=none',
-    `provisioned=${ready.data.provisioned}`,
-    `action=${ready.data.provisioningAction ?? 'none'}`,
-  ].join(' ');
-}
-
-function assertMessagesInOrder(observed: readonly string[], required: readonly string[]): void {
-  let searchFrom = 0;
-
-  for (const expected of required) {
-    const foundAt = observed.findIndex((message, index) => index >= searchFrom && message === expected);
-    if (foundAt === -1) {
-      throw new Error(
-        `Missing required init message ${JSON.stringify(expected)} in order. Observed: ${formatMessageTrace(observed)}`
-      );
-    }
-
-    searchFrom = foundAt + 1;
-  }
-}
-
-function formatMessageTrace(messages: readonly string[]): string {
-  if (messages.length === 0) {
-    return 'none';
-  }
-
-  return uniqueInOrder(messages)
-    .map((message) => trimDetail(message, 60))
-    .join(' -> ');
-}
-
-function uniqueInOrder(values: readonly string[]): string[] {
-  const seen = new Set<string>();
-  const unique: string[] = [];
-
-  for (const value of values) {
-    if (seen.has(value)) {
-      continue;
-    }
-
-    seen.add(value);
-    unique.push(value);
-  }
-
-  return unique;
-}
-
-function describePorts(ports: readonly PortInfo[]): string {
-  const defaultPorts = ports.filter((port) => port.default).map((port) => port.port);
-  return `ports=${ports.length} defaultPorts=${defaultPorts.length > 0 ? defaultPorts.join(',') : 'none'}`;
-}
-
-function redactUrl(value: string): string {
-  try {
-    const url = new URL(value);
-    if (url.search) {
-      url.search = '?redacted=1';
-    }
-    return url.toString();
-  } catch {
-    return '<invalid-url>';
-  }
-}
-
-async function createNodeTransport(options: LoadTestOptions): Promise<{
-  fetch?: typeof globalThis.fetch;
-  webSocket?: typeof NodeWebSocket;
-}> {
-  if (!options.insecureTls && !options.caFile) {
-    return {};
-  }
-
-  if (!options.apiUrl.startsWith('https://')) {
-    return {};
-  }
-
-  const ca = options.caFile ? await fs.readFile(options.caFile, 'utf8') : undefined;
-  const agentOptions = {
-    ca,
-    rejectUnauthorized: !options.insecureTls,
-  };
-  const httpsAgent = new https.Agent(agentOptions);
-
-  class ConfiguredWebSocket extends NodeWebSocket {
-    public constructor(address: string | URL, protocols?: string | string[]) {
-      super(address, protocols, agentOptions);
-    }
-  }
-
-  const fetch: typeof globalThis.fetch = async (input, init) => {
-    const request = input instanceof Request ? input : new Request(input, init);
-    const headers: Record<string, string> = {};
-    request.headers.forEach((value, key) => {
-      headers[key] = value;
-    });
-    const body =
-      request.method === 'GET' || request.method === 'HEAD'
-        ? undefined
-        : Buffer.from(await request.arrayBuffer());
-
-    const response = await axios.request<ArrayBuffer>({
-      url: request.url,
-      method: request.method as any,
-      headers,
-      data: body,
-      responseType: 'arraybuffer',
-      validateStatus: () => true,
-      httpsAgent,
-      signal: request.signal,
-    });
-
-    const responseBody =
-      response.status === 204 || response.status === 205 || response.status === 304
-        ? null
-        : response.data;
-
-    return new Response(responseBody, {
-      status: response.status,
-      statusText: response.statusText,
-      headers: response.headers as HeadersInit,
-    });
-  };
-
-  return {
-    fetch,
-    webSocket: ConfiguredWebSocket as unknown as typeof NodeWebSocket,
-  };
-}
-
-function parseArgs(argv: string[]): ParsedArgs {
-  const values = new Map<string, string | boolean>();
-
-  for (let index = 0; index < argv.length; index += 1) {
-    const arg = argv[index];
-    if (!arg.startsWith('--')) {
-      continue;
-    }
-
-    if (arg.startsWith('--no-')) {
-      values.set(arg.slice(5), false);
-      continue;
-    }
-
-    const trimmed = arg.slice(2);
-    const separatorIndex = trimmed.indexOf('=');
-    if (separatorIndex !== -1) {
-      values.set(trimmed.slice(0, separatorIndex), trimmed.slice(separatorIndex + 1));
-      continue;
-    }
-
-    const next = argv[index + 1];
-    if (next && !next.startsWith('--')) {
-      values.set(trimmed, next);
-      index += 1;
-      continue;
-    }
-
-    values.set(trimmed, true);
-  }
-
-  return {
-    get(key: string) {
-      return values.get(key);
-    },
-  };
-}
-
-function resolveLevels(args: ParsedArgs): number[] {
-  const levelsArg = stringArg(args, 'levels');
-  if (levelsArg) {
-    return levelsArg
-      .split(',')
-      .map((value) => Number.parseInt(value.trim(), 10))
-      .filter((value) => Number.isFinite(value) && value > 0);
-  }
-
-  const maxConcurrency = numberArg(args, 'max-concurrency');
-  if (maxConcurrency) {
-    const step = Math.max(1, numberArg(args, 'step') ?? 1);
-    const levels: number[] = [];
-    for (let value = 1; value <= maxConcurrency; value += step) {
-      levels.push(value);
-    }
-
-    if (levels[levels.length - 1] !== maxConcurrency) {
-      levels.push(maxConcurrency);
-    }
-
-    return levels;
-  }
-
-  const concurrency = numberArg(args, 'concurrency');
-  if (concurrency) {
-    return [concurrency];
-  }
-
-  return [1];
-}
-
-function resolveMode(args: ParsedArgs): LoadTestMode {
-  if (booleanArg(args, 'init-only') === true) {
-    return 'init';
-  }
-
-  const value = stringArg(args, 'mode');
-  if (value === 'init' || value === 'full') {
-    return value;
-  }
-
-  return 'full';
-}
-
-function stringArg(args: ParsedArgs, key: string): string | undefined {
-  const value = args.get(key);
-  return typeof value === 'string' ? value : undefined;
-}
-
-function numberArg(args: ParsedArgs, key: string): number | undefined {
-  const value = args.get(key);
-  if (typeof value !== 'string') {
-    return undefined;
-  }
-
-  const parsed = Number.parseInt(value, 10);
-  return Number.isFinite(parsed) ? parsed : undefined;
-}
-
-function booleanArg(args: ParsedArgs, key: string): boolean | undefined {
-  const value = args.get(key);
-  if (typeof value === 'boolean') {
-    return value;
-  }
-
-  if (typeof value === 'string') {
-    if (value === 'true') {
-      return true;
-    }
-    if (value === 'false') {
-      return false;
-    }
-  }
-
-  return undefined;
-}
-
-function listArg(args: ParsedArgs, key: string): string[] {
-  const value = stringArg(args, key);
-  if (!value) {
-    return [];
-  }
-
-  return value
-    .split(/[|,]/)
-    .map((item) => item.trim())
-    .filter(Boolean);
-}
-
-function provisioningActionArg(args: ParsedArgs, key: string): NotebookProvisioningAction | undefined {
-  const value = stringArg(args, key);
-  if (
-    value === 'github_import' ||
-    value === 'imported_project' ||
-    value === 'forked' ||
-    value === 'template'
-  ) {
-    return value;
-  }
-
-  if (value) {
-    throw new Error(`Invalid --${key}: ${value}`);
-  }
-
-  return undefined;
-}
-
-function visibilityArg(args: ParsedArgs, key: string): Visibility | undefined {
-  const value = stringArg(args, key);
-  if (value === 'public' || value === 'private' || value === 'unlisted') {
-    return value;
-  }
-
-  return undefined;
-}
-
-void main().catch((error) => {
-  console.error(formatError(error));
-  process.exitCode = 1;
-});