vercel 59.4.0 → 59.6.2

package/dist/chunks/set-C3UQUQ42.js

@@ -0,0 +1,243 @@
+import { createRequire as __createRequire } from 'node:module';
+import { fileURLToPath as __fileURLToPath } from 'node:url';
+import { dirname as __dirname_ } from 'node:path';
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __dirname_(__filename);
+import {
+  EMPTY_PATH_ERROR,
+  ENVIRONMENT_ERROR,
+  RATE_ERROR,
+  RULE_LIMIT,
+  formatRate,
+  formatRuleTarget,
+  handleTracingApiError,
+  hasSameKey,
+  invalidArguments,
+  isRuleEnvironment,
+  parseSampleRate,
+  readProjectTracing,
+  resolveConfigScope,
+  subcommandArguments,
+  toApiRate,
+  toRule,
+  writeConfigJson,
+  writeSamplingRules
+} from "./chunk-V3MDDR2X.js";
+import "./chunk-5GGUB4EO.js";
+import {
+  validateJsonOutput
+} from "./chunk-KXDWXXJH.js";
+import {
+  tracesCommand
+} from "./chunk-7Q45OKWR.js";
+import {
+  setSubcommand
+} from "./chunk-GY5I4AYD.js";
+import {
+  help
+} from "./chunk-2YRAWYGE.js";
+import "./chunk-VJ5NAOWB.js";
+import "./chunk-FXD67VN5.js";
+import {
+  TelemetryClient
+} from "./chunk-XNFHNTS2.js";
+import "./chunk-NGGLYKNU.js";
+import "./chunk-GGP5R3FU.js";
+import {
+  printError
+} from "./chunk-AYLY3ZVL.js";
+import {
+  parseArguments
+} from "./chunk-57RHXXXG.js";
+import "./chunk-RKDCNQ4S.js";
+import "./chunk-BMKU5KEL.js";
+import {
+  getCommandName,
+  getCommandNamePlain,
+  getFlagsSpecification
+} from "./chunk-Q2DGFCO7.js";
+import "./chunk-P4QNYOFB.js";
+import "./chunk-52QYYTM5.js";
+import {
+  output_manager_default
+} from "./chunk-QFAS4OVW.js";
+import {
+  require_source
+} from "./chunk-S7KYDPEM.js";
+import {
+  __toESM
+} from "./chunk-TZ2YI2VH.js";
+
+// src/commands/traces/config/set.ts
+var import_chalk = __toESM(require_source(), 1);
+
+// src/util/telemetry/commands/traces/config/set.ts
+var TracesConfigSetTelemetryClient = class extends TelemetryClient {
+  /**
+   * The environment word is a closed set, so a valid value is tracked raw.
+   * Anything else is a typo the CLI rejected and is redacted.
+   */
+  trackCliArgumentEnvironment(environment) {
+    if (environment) {
+      this.trackCliArgument({
+        arg: "environment",
+        value: isRuleEnvironment(environment) ? environment : this.redactedValue
+      });
+    }
+  }
+  trackCliArgumentRate(rate) {
+    if (rate) {
+      this.trackCliArgument({
+        arg: "rate",
+        value: this.redactedValue
+      });
+    }
+  }
+  /** The path prefix is customer data. */
+  trackCliArgumentRequestPath(requestPath) {
+    if (requestPath) {
+      this.trackCliArgument({
+        arg: "requestPath",
+        value: this.redactedValue
+      });
+    }
+  }
+  trackCliFlagJson(json) {
+    if (json) {
+      this.trackCliFlag("json");
+    }
+  }
+};
+
+// src/commands/traces/config/set.ts
+var USAGE = "traces config set <environment> <rate> [requestPath]";
+async function set(client) {
+  const telemetry = new TracesConfigSetTelemetryClient({
+    opts: { store: client.telemetryEventStore }
+  });
+  let parsedArgs;
+  const flagsSpecification = getFlagsSpecification(setSubcommand.options);
+  try {
+    parsedArgs = parseArguments(client.argv.slice(2), flagsSpecification);
+  } catch (err) {
+    printError(err);
+    return 1;
+  }
+  const { flags } = parsedArgs;
+  const [environmentArg, rateArg, ...pathArgs] = subcommandArguments(
+    parsedArgs.args
+  );
+  const pathArg = pathArgs[0];
+  telemetry.trackCliArgumentEnvironment(environmentArg);
+  telemetry.trackCliArgumentRate(rateArg);
+  telemetry.trackCliArgumentRequestPath(pathArg);
+  telemetry.trackCliOptionFormat(flags["--format"]);
+  telemetry.trackCliFlagJson(flags["--json"]);
+  telemetry.trackCliOptionProject(flags["--project"]);
+  if (environmentArg === void 0 || rateArg === void 0) {
+    output_manager_default.print(
+      help(setSubcommand, {
+        parent: { ...tracesCommand, name: "traces config" },
+        columns: client.stderr.columns
+      })
+    );
+    return 2;
+  }
+  if (pathArgs.length > 1) {
+    output_manager_default.error(`Too many arguments. Usage: ${getCommandName(USAGE)}`);
+    return 2;
+  }
+  if (!isRuleEnvironment(environmentArg)) {
+    return invalidArguments(
+      client,
+      `${ENVIRONMENT_ERROR} Received: ${environmentArg}`
+    );
+  }
+  const sampleRate = parseSampleRate(rateArg);
+  if (sampleRate === void 0) {
+    return invalidArguments(client, `${RATE_ERROR} Received: ${rateArg}`);
+  }
+  if (pathArg !== void 0 && pathArg.trim() === "") {
+    return invalidArguments(client, EMPTY_PATH_ERROR);
+  }
+  const formatResult = validateJsonOutput(flags);
+  if (!formatResult.valid) {
+    output_manager_default.error(formatResult.error);
+    return 1;
+  }
+  const asJson = formatResult.jsonOutput || client.nonInteractive;
+  const scope = await resolveConfigScope(client, {
+    project: flags["--project"]
+  });
+  if ("exitCode" in scope) {
+    return scope.exitCode;
+  }
+  const rule = {
+    environment: environmentArg,
+    requestPath: pathArg ?? null,
+    sampleRate
+  };
+  if (!asJson) {
+    output_manager_default.spinner("Updating trace sampling rules\u2026");
+  }
+  let project;
+  let tracing;
+  let entries;
+  try {
+    ({ project, tracing, entries } = await readProjectTracing({
+      client,
+      ...scope
+    }));
+  } catch (err) {
+    output_manager_default.stopSpinner();
+    return handleTracingApiError(client, err);
+  }
+  const existingIndex = entries.findIndex((entry) => hasSameKey(entry.row, rule));
+  const previous = existingIndex === -1 ? void 0 : entries[existingIndex].row;
+  const nextRules = existingIndex === -1 ? [...entries.map((entry) => entry.rule), toRule(rule)] : entries.map(
+    (entry, index) => index === existingIndex ? { ...entry.rule, rate: toApiRate(rule.sampleRate) } : entry.rule
+  );
+  if (nextRules.length > RULE_LIMIT) {
+    output_manager_default.stopSpinner();
+    return invalidArguments(
+      client,
+      `A project can have at most ${RULE_LIMIT} trace sampling rules, and ${project.name} already has ${entries.length}. Remove one with ${getCommandName("traces config rm <environment> [requestPath]")} first.`
+    );
+  }
+  try {
+    await writeSamplingRules({ client, ...scope, tracing, rules: nextRules });
+  } catch (err) {
+    output_manager_default.stopSpinner();
+    return handleTracingApiError(client, err);
+  }
+  output_manager_default.stopSpinner();
+  const target = formatRuleTarget(rule.environment, rule.requestPath);
+  const wasClause = previous ? ` (was ${formatRate(previous.sampleRate)})` : "";
+  const successLine = (subject) => `Set ${subject} to ${formatRate(rule.sampleRate)}${wasClause}. ${nextRules.length} of ${RULE_LIMIT} rules.`;
+  if (asJson) {
+    writeConfigJson(client, {
+      project,
+      bare: rule,
+      envelope: {
+        rule,
+        previousSampleRate: previous?.sampleRate ?? null,
+        ruleCount: nextRules.length,
+        ruleLimit: RULE_LIMIT
+      },
+      message: successLine(target),
+      next: [
+        {
+          command: getCommandNamePlain("traces config ls"),
+          when: "Read back every sampling rule"
+        }
+      ]
+    });
+    return 0;
+  }
+  output_manager_default.success(successLine(import_chalk.default.bold(target)));
+  return 0;
+}
+export {
+  set as default
+};

package/dist/chunks/{tags-RCNRFX7U.js → tags-BTVDROFG.js}

@@ -14,12 +14,13 @@ import {
   AGENT_REASON,
   buildCommandWithGlobalFlags,
   outputAgentError
-} from "./chunk-TH2XUVDP.js";
-import "./chunk-SOFC4MLS.js";
+} from "./chunk-NGGLYKNU.js";
+import "./chunk-BMKU5KEL.js";
+import "./chunk-Q2DGFCO7.js";
 import "./chunk-P4QNYOFB.js";
 import {
   output_manager_default
-} from "./chunk-OX7KI3LF.js";
+} from "./chunk-QFAS4OVW.js";
 import "./chunk-S7KYDPEM.js";
 import "./chunk-TZ2YI2VH.js";
 
@@ -52,9 +53,9 @@ async function tags(client, argv, telemetry) {
   }
   switch (subcommand) {
     case "ls":
-      return (await import("./ls-SXJFBLUT.js")).default(client, args, telemetry);
+      return (await import("./ls-3MH2OCP3.js")).default(client, args, telemetry);
     case "inspect":
-      return (await import("./inspect-ZW5N6O5P.js")).default(client, args, telemetry);
+      return (await import("./inspect-RDMC2Z3Q.js")).default(client, args, telemetry);
     default:
       output_manager_default.error(`Unhandled tags subcommand: ${subcommand}`);
       return 1;

package/dist/chunks/{types-AJHILHO5.js → types-JGANJ5EQ.js}

@@ -9,22 +9,26 @@ import {
 } from "./chunk-KXDWXXJH.js";
 import {
   typesSubcommand
-} from "./chunk-3KNPVXJ3.js";
+} from "./chunk-4KD5BYHB.js";
 import {
-  printError,
-  table
-} from "./chunk-VAFU7DXZ.js";
+  printError
+} from "./chunk-AYLY3ZVL.js";
 import {
   parseArguments
-} from "./chunk-XLKFJPMT.js";
+} from "./chunk-57RHXXXG.js";
+import {
+  table
+} from "./chunk-RKDCNQ4S.js";
 import {
-  getFlagsSpecification,
   isAPIError
-} from "./chunk-SOFC4MLS.js";
+} from "./chunk-BMKU5KEL.js";
+import {
+  getFlagsSpecification
+} from "./chunk-Q2DGFCO7.js";
 import "./chunk-P4QNYOFB.js";
 import {
   output_manager_default
-} from "./chunk-OX7KI3LF.js";
+} from "./chunk-QFAS4OVW.js";
 import {
   require_source
 } from "./chunk-S7KYDPEM.js";

package/dist/chunks/{update-I7QGAOYF.js → update-B6PSOHUW.js}

@@ -8,47 +8,51 @@ import {
   parseCustomAlertQueryBody,
   resolveCustomAlertProjectName,
   setMissingCustomAlertProjectScope
-} from "./chunk-PD4DYNSB.js";
+} from "./chunk-GZQQNLF5.js";
 import {
   emitRulesArgParseError,
   handleRulesApiError,
   parseRulesFlagsAndScope,
   rulesItemPath
-} from "./chunk-CHEZBD7H.js";
-import "./chunk-VCE6QKFE.js";
-import "./chunk-KQRVZWJU.js";
-import "./chunk-O5DLWLT7.js";
-import "./chunk-JKQWQA2T.js";
+} from "./chunk-R5PULMHT.js";
+import "./chunk-2O5J3KMT.js";
+import "./chunk-3T7WSWZH.js";
+import "./chunk-LXZVOR6F.js";
+import "./chunk-AINIBIP4.js";
 import {
   validateJsonOutput
 } from "./chunk-KXDWXXJH.js";
 import {
   rulesUpdateSubcommand
-} from "./chunk-UMA66MKW.js";
-import "./chunk-HMJVUXE6.js";
-import "./chunk-CYNB6LL4.js";
+} from "./chunk-XM3LOQIX.js";
+import "./chunk-VJ5NAOWB.js";
+import "./chunk-FXD67VN5.js";
+import "./chunk-XNFHNTS2.js";
 import {
   AGENT_REASON,
   buildCommandWithGlobalFlags,
   outputAgentError
-} from "./chunk-TH2XUVDP.js";
+} from "./chunk-NGGLYKNU.js";
 import "./chunk-GGP5R3FU.js";
 import {
   printError
-} from "./chunk-VAFU7DXZ.js";
+} from "./chunk-AYLY3ZVL.js";
 import {
   parseArguments
-} from "./chunk-XLKFJPMT.js";
+} from "./chunk-57RHXXXG.js";
+import "./chunk-RKDCNQ4S.js";
+import {
+  isAPIError
+} from "./chunk-BMKU5KEL.js";
 import {
   getFlagsSpecification,
-  isAPIError,
   packageName
-} from "./chunk-SOFC4MLS.js";
+} from "./chunk-Q2DGFCO7.js";
 import "./chunk-P4QNYOFB.js";
 import "./chunk-52QYYTM5.js";
 import {
   output_manager_default
-} from "./chunk-OX7KI3LF.js";
+} from "./chunk-QFAS4OVW.js";
 import "./chunk-S7KYDPEM.js";
 import "./chunk-TZ2YI2VH.js";
 

package/dist/commands/build/builder-worker.cjs

@@ -0,0 +1,281 @@
+/**
+ * Forked worker that runs a single builder's `build()` (and `diagnostics()`) in its own
+ * process for `vc build`. Running each build out-of-process gives it isolated stdout/stderr
+ * — which the parent pipes and can prefix per line with the service name — and isolated
+ * env, which is a prerequisite for running builds in parallel.
+ *
+ * This is modeled on the `vc dev` worker (../dev/builder-worker.cjs) and shares its IPC
+ * contract (`ready` / `build` / `buildResult`), but it serializes Lambda/EdgeFunction outputs
+ * by preserving their `files` map (as FileFsRef/FileBlob descriptors) instead of zipping them.
+ * `vc build`'s writeLambda relies on `lambda.files` for the FileFsRef-by-reference optimization,
+ * the `filePathMap`, and `standalone` symlink handling — all of which are lost if we ship only
+ * a `zipBuffer` the way the dev worker does.
+ *
+ * Like the dev worker, this file is copied verbatim into `dist` next to the compiled `build`
+ * command, so it must only `require` `@vercel/build-utils` and Node built-ins.
+ */
+const { FileFsRef, Span } = require('@vercel/build-utils');
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const crypto = require('node:crypto');
+
+// Trace events produced by the builder's own spans (children of buildOptions.span) are collected
+// here and shipped back to the parent, which reports them under its `vc.builder` span so forked
+// builds keep full trace fidelity. Included on both success and error messages so a failed build
+// still contributes the spans it managed to record. Emptied after each send so a later phase
+// (the deferred pre-deploy step) ships only the events it newly recorded.
+let collectedTraceEvents = [];
+const traceReporter = { report: event => collectedTraceEvents.push(event) };
+// Take the events collected so far and reset the buffer, so the next send starts fresh.
+function drainTraceEvents() {
+  const events = collectedTraceEvents;
+  collectedTraceEvents = [];
+  return events;
+}
+
+// Above this size a FileBlob's Buffer is written to a temp file rather than sent inline over
+// IPC. Even under structured-clone serialization the whole Buffer is copied into a single IPC
+// message; spilling very large blobs to disk bounds that per-message memory spike.
+const BLOB_FILE_THRESHOLD = 256 * 1024 * 1024; // 256MB
+
+process.on('unhandledRejection', err => {
+  // biome-ignore lint/suspicious/noConsole: intentional console usage
+  console.error('Exiting builder due to build error:');
+  // biome-ignore lint/suspicious/noConsole: intentional console usage
+  console.error(err);
+  process.exit(1);
+});
+
+// A builder may register a pre-deploy callback during build(). The CLI runs pre-deploys only
+// after every build succeeds, so we hold the callback here and run it when the parent sends a
+// `runPreDeploy` message, keeping the builder-computed env the callback captured.
+let preDeployCallback;
+
+// Key under which processMessage stashes the diagnostics it collected for a build that threw, so
+// the error path in onMessage can ship them. A Symbol, so `serializeError` (which copies own
+// property *names*) can't fold it into the error the parent writes into builds.json.
+const DIAGNOSTICS = Symbol('diagnostics');
+
+process.on('message', onMessage);
+
+// Convert an Error into a plain object with all its properties enumerable. Structured-clone IPC
+// reconstructs a native Error but keeps only `name`/`message`/`stack` — custom props a builder
+// sets (e.g. NowBuildError's `code`/`link`, which the parent writes into builds.json) would be
+// dropped. A plain object clones losslessly; the parent rebuilds an Error from it.
+function serializeError(err) {
+  if (!err || typeof err !== 'object') return err;
+  const plain = { name: err.name, message: err.message, stack: err.stack };
+  for (const key of Object.getOwnPropertyNames(err)) {
+    plain[key] = err[key];
+  }
+  return plain;
+}
+
+function onMessage(message) {
+  if (message && message.type === 'runPreDeploy') {
+    runPreDeploy();
+    return;
+  }
+  processMessage(message).catch(err => {
+    process.removeListener('message', onMessage);
+    process.send(
+      {
+        type: 'buildResult',
+        error: serializeError(err),
+        // A failed build is exactly when diagnostics matter most, so ship whatever the builder
+        // recorded before it threw. `processMessage` collects them in a `finally` and stashes
+        // them on the error (see DIAGNOSTICS) on its way out.
+        diagnostics: err?.[DIAGNOSTICS],
+        traceEvents: drainTraceEvents(),
+      },
+      () => process.exit(1)
+    );
+  });
+}
+
+function runPreDeploy() {
+  Promise.resolve()
+    .then(() => preDeployCallback?.())
+    .then(
+      () =>
+        process.send(
+          { type: 'preDeployResult', traceEvents: drainTraceEvents() },
+          () => process.exit(0)
+        ),
+      err => {
+        process.send(
+          {
+            type: 'preDeployResult',
+            error: serializeError(err),
+            traceEvents: drainTraceEvents(),
+          },
+          () => process.exit(1)
+        );
+      }
+    );
+}
+
+// Re-prototype a plain object sent over IPC back into a FileFsRef instance.
+function rehydrateFile(obj) {
+  return Object.assign(Object.create(FileFsRef.prototype), obj);
+}
+
+// Serialize a Files map for transport. FileFsRef entries are cheap path references and pass
+// through as-is; FileBlob entries carry a Buffer, which is left inline unless it exceeds the
+// threshold, in which case it is spilled to a temp file the parent reads and unlinks.
+function serializeFiles(files) {
+  if (!files) return files;
+  for (const name of Object.keys(files)) {
+    const file = files[name];
+    if (file && file.type === 'FileBlob' && Buffer.isBuffer(file.data)) {
+      if (file.data.length > BLOB_FILE_THRESHOLD) {
+        const tmp = path.join(
+          os.tmpdir(),
+          `vercel-build-blob-${crypto.randomBytes(8).toString('hex')}`
+        );
+        fs.writeFileSync(tmp, file.data);
+        file.dataPath = tmp;
+        delete file.data;
+      }
+    }
+  }
+  return files;
+}
+
+// Collect diagnostics from the same builder instance that just built. diagnostics() returns a
+// Files map (e.g. { 'package-manifest.json': FileBlob }); serialize it like build outputs so the
+// parent can validate/write it. Traced here in the worker (the span rides back with the rest), and
+// failures must not propagate — diagnostics are best-effort and never fail (or mask) a build.
+async function collectDiagnostics(builder, buildOptions) {
+  try {
+    const diagnostics = await buildOptions.span
+      .child('vc.builder.diagnostics')
+      .trace(
+        async () => (await builder.diagnostics?.(buildOptions)) || undefined
+      );
+    if (diagnostics) serializeFiles(diagnostics);
+    return diagnostics;
+  } catch (err) {
+    // Surface to the worker's stderr (piped/inherited to the parent) but don't fail the build.
+    // biome-ignore lint/suspicious/noConsole: intentional console usage
+    console.error(`[vc] collecting diagnostics failed: ${err}`);
+    return undefined;
+  }
+}
+
+async function processMessage(message) {
+  const { requirePath, buildOptions, expectsPreDeploy } = message;
+  const builder = require(requirePath);
+
+  // `files` arrive as plain objects — turn them back into FileFsRef instances the builder expects.
+  for (const name of Object.keys(buildOptions.files)) {
+    buildOptions.files[name] = rehydrateFile(buildOptions.files[name]);
+  }
+
+  // Give the builder a span backed by our collecting reporter so the child spans it records are
+  // shipped back to the parent. The parent dropped the real Span (a class instance can't cross
+  // IPC), so we reconstruct one here; it has no parent id — the parent reparents this root under
+  // its own `vc.builder` span via Span.reportChildEvents when the events are reported.
+  buildOptions.span = new Span({
+    name: 'vc.builder.worker',
+    reporter: traceReporter,
+  });
+
+  // Capture any pre-deploy callback the builder registers during build(); the parent triggers
+  // it later via a `runPreDeploy` message. Only wired when the parent said a pre-deploy command
+  // is configured for this build.
+  if (expectsPreDeploy) {
+    buildOptions.registerPreDeploy = callback => {
+      preDeployCallback = callback;
+    };
+  }
+
+  // Build in a try/finally so diagnostics are collected on both outcomes, mirroring `doBuild`'s
+  // handling on the in-process path: a build that threw is exactly when its diagnostics matter
+  // most.
+  let result;
+  let diagnostics;
+  let buildError;
+  try {
+    result = await builder.build(buildOptions);
+  } catch (err) {
+    buildError = err;
+    throw err;
+  } finally {
+    diagnostics = await collectDiagnostics(builder, buildOptions);
+    // A failed build has no result message to carry the diagnostics, so stash them on the error
+    // for `onMessage` to ship. Symbol-keyed, so `serializeError` (which copies own property
+    // *names*) can't fold them into the error the parent writes into builds.json.
+    if (buildError && typeof buildError === 'object') {
+      Object.defineProperty(buildError, DIAGNOSTICS, { value: diagnostics });
+    }
+    // Stop the worker root span so it (and its recorded children) are collected before the events
+    // are drained and shipped for the parent to report under its `vc.builder` span.
+    buildOptions.span.stop();
+  }
+
+  // Locate the concrete V2/V3 result and its version WITHOUT unwrapping the wire payload:
+  // the parent (and writeBuildResult) still expect a BuildResultVX wrapper for
+  // `builder.version === -1` builders, so we serialize the inner outputs in place and send
+  // the original `result` back untouched in shape.
+  let effectiveVersion = builder.version;
+  let concrete = result;
+  if (builder.version === -1) {
+    effectiveVersion = result.resultVersion;
+    concrete = result.result;
+  }
+
+  // The IPC channel uses `serialization: 'advanced'` (V8 structured clone), which preserves
+  // Buffers, cycles (e.g. `@vercel/next`'s `result.childProcesses`), and shared object identity
+  // — the same Lambda referenced by many V2 keys or many `Prerender.lambda` fields arrives as
+  // ONE instance, which writeBuildResult relies on for symlink dedup. So the only remaining job
+  // here is spilling oversized FileBlob Buffers to temp files (see serializeFiles). We still walk
+  // every reachable `files` map, using `seen` so a shared Lambda is spilled at most once.
+  const seen = new Set();
+  const serializeOutput = output => {
+    if (!output || typeof output !== 'object' || seen.has(output)) return;
+    seen.add(output);
+    if (output.type === 'Lambda' || output.type === 'EdgeFunction') {
+      serializeFiles(output.files);
+    } else if (output.type === 'Prerender') {
+      // Prerender wraps a `lambda` (with its own `files`) and a `fallback` file.
+      if (output.lambda) serializeOutput(output.lambda);
+      if (output.fallback) serializeFiles({ fallback: output.fallback });
+    }
+  };
+
+  // Build Output API results (`{ buildOutputPath }`) have no in-memory `output` to serialize —
+  // their outputs live on disk and the parent reads them from there.
+  if (concrete.output) {
+    if (effectiveVersion === 3) {
+      serializeOutput(concrete.output);
+    } else {
+      for (const value of Object.values(concrete.output)) {
+        serializeOutput(value);
+      }
+    }
+  }
+
+  // With a pending pre-deploy the worker stays alive to run the callback (which holds the
+  // builder-computed env) when the parent later sends `runPreDeploy`; the parent tears the
+  // worker down once done. Without one, the parent kills the worker as soon as it has the result.
+  // Drain the collected events here so the deferred pre-deploy step ships only what it records.
+  const hasPreDeploy = Boolean(preDeployCallback);
+  process.send({
+    type: 'buildResult',
+    result,
+    // The concrete result's shape (single V3 output vs. a V2 map of named outputs) can't be
+    // inferred reliably from the payload — a V2 map may legitimately hold a key named `type`
+    // — so tell the parent which one it is instead of making it guess.
+    outputVersion: effectiveVersion,
+    diagnostics,
+    hasPreDeploy,
+    // Builders share state through `meta` (e.g. runNpmInstall's dedup set). This worker had a
+    // structured-clone copy, so send it back for the parent to merge into the shared meta.
+    meta: buildOptions.meta,
+    traceEvents: drainTraceEvents(),
+  });
+}
+
+process.send({ type: 'ready' });