esbuild 0.15.18 → 0.17.2

package/lib/main.js

@@ -18,6 +18,10 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
@@ -30,11 +34,11 @@ __export(node_exports, {
   analyzeMetafileSync: () => analyzeMetafileSync,
   build: () => build,
   buildSync: () => buildSync,
+  context: () => context,
   default: () => node_default,
   formatMessages: () => formatMessages,
   formatMessagesSync: () => formatMessagesSync,
   initialize: () => initialize,
-  serve: () => serve,
   transform: () => transform,
   transformSync: () => transformSync,
   version: () => version
@@ -175,26 +179,30 @@ var ByteBuffer = class {
 };
 var encodeUTF8;
 var decodeUTF8;
+var encodeInvariant;
 if (typeof TextEncoder !== "undefined" && typeof TextDecoder !== "undefined") {
   let encoder = new TextEncoder();
   let decoder = new TextDecoder();
   encodeUTF8 = (text) => encoder.encode(text);
   decodeUTF8 = (bytes) => decoder.decode(bytes);
+  encodeInvariant = 'new TextEncoder().encode("")';
 } else if (typeof Buffer !== "undefined") {
-  encodeUTF8 = (text) => {
-    let buffer = Buffer.from(text);
-    if (!(buffer instanceof Uint8Array)) {
-      buffer = new Uint8Array(buffer);
-    }
-    return buffer;
-  };
+  encodeUTF8 = (text) => Buffer.from(text);
   decodeUTF8 = (bytes) => {
     let { buffer, byteOffset, byteLength } = bytes;
     return Buffer.from(buffer, byteOffset, byteLength).toString();
   };
+  encodeInvariant = 'Buffer.from("")';
 } else {
   throw new Error("No UTF-8 codec found");
 }
+if (!(encodeUTF8("") instanceof Uint8Array))
+  throw new Error(`Invariant violation: "${encodeInvariant} instanceof Uint8Array" is incorrectly false
+
+This indicates that your JavaScript environment is broken. You cannot use
+esbuild in this environment because esbuild relies on this invariant. This
+is not a problem with esbuild. You need to fix your environment instead.
+`);
 function readUInt32LE(buffer, offset) {
   return buffer[offset++] | buffer[offset++] << 8 | buffer[offset++] << 16 | buffer[offset++] << 24;
 }
@@ -206,25 +214,25 @@ function writeUInt32LE(buffer, value, offset) {
 }
 
 // lib/shared/common.ts
+var quote = JSON.stringify;
 var buildLogLevelDefault = "warning";
 var transformLogLevelDefault = "silent";
 function validateTarget(target) {
-  target += "";
+  validateStringValue(target, "target");
   if (target.indexOf(",") >= 0)
     throw new Error(`Invalid target: ${target}`);
   return target;
 }
 var canBeAnything = () => null;
 var mustBeBoolean = (value) => typeof value === "boolean" ? null : "a boolean";
-var mustBeBooleanOrObject = (value) => typeof value === "boolean" || typeof value === "object" && !Array.isArray(value) ? null : "a boolean or an object";
 var mustBeString = (value) => typeof value === "string" ? null : "a string";
 var mustBeRegExp = (value) => value instanceof RegExp ? null : "a RegExp object";
 var mustBeInteger = (value) => typeof value === "number" && value === (value | 0) ? null : "an integer";
 var mustBeFunction = (value) => typeof value === "function" ? null : "a function";
 var mustBeArray = (value) => Array.isArray(value) ? null : "an array";
 var mustBeObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? null : "an object";
+var mustBeEntryPoints = (value) => typeof value === "object" && value !== null ? null : "an array or an object";
 var mustBeWebAssemblyModule = (value) => value instanceof WebAssembly.Module ? null : "a WebAssembly.Module";
-var mustBeArrayOrRecord = (value) => typeof value === "object" && value !== null ? null : "an array or an object";
 var mustBeObjectOrNull = (value) => typeof value === "object" && !Array.isArray(value) ? null : "an object or null";
 var mustBeStringOrBoolean = (value) => typeof value === "string" || typeof value === "boolean" ? null : "a string or a boolean";
 var mustBeStringOrObject = (value) => typeof value === "string" || typeof value === "object" && value !== null && !Array.isArray(value) ? null : "a string or an object";
@@ -238,13 +246,13 @@ function getFlag(object, keys, key, mustBeFn) {
     return void 0;
   let mustBe = mustBeFn(value);
   if (mustBe !== null)
-    throw new Error(`"${key}" must be ${mustBe}`);
+    throw new Error(`${quote(key)} must be ${mustBe}`);
   return value;
 }
 function checkForInvalidFlags(object, keys, where) {
   for (let key in object) {
     if (!(key in keys)) {
-      throw new Error(`Invalid option ${where}: "${key}"`);
+      throw new Error(`Invalid option ${where}: ${quote(key)}`);
     }
   }
 }
@@ -264,12 +272,12 @@ function validateMangleCache(mangleCache) {
   let validated;
   if (mangleCache !== void 0) {
     validated = /* @__PURE__ */ Object.create(null);
-    for (let key of Object.keys(mangleCache)) {
+    for (let key in mangleCache) {
       let value = mangleCache[key];
       if (typeof value === "string" || value === false) {
         validated[key] = value;
       } else {
-        throw new Error(`Expected ${JSON.stringify(key)} in mangle cache to map to either a string or false`);
+        throw new Error(`Expected ${quote(key)} in mangle cache to map to either a string or false`);
       }
     }
   }
@@ -286,6 +294,12 @@ function pushLogFlags(flags, options, keys, isTTY2, logLevelDefault) {
   flags.push(`--log-level=${logLevel || logLevelDefault}`);
   flags.push(`--log-limit=${logLimit || 0}`);
 }
+function validateStringValue(value, what, key) {
+  if (typeof value !== "string") {
+    throw new Error(`Expected value for ${what}${key !== void 0 ? " " + quote(key) : ""} to be a string, got ${typeof value} instead`);
+  }
+  return value;
+}
 function pushCommonFlags(flags, options, keys) {
   let legalComments = getFlag(options, keys, "legalComments", mustBeString);
   let sourceRoot = getFlag(options, keys, "sourceRoot", mustBeString);
@@ -350,7 +364,7 @@ function pushCommonFlags(flags, options, keys) {
     flags.push(`--ignore-annotations`);
   if (drop)
     for (let what of drop)
-      flags.push(`--drop:${what}`);
+      flags.push(`--drop:${validateStringValue(what, "drop")}`);
   if (mangleProps)
     flags.push(`--mangle-props=${mangleProps.source}`);
   if (reserveProps)
@@ -373,26 +387,29 @@ function pushCommonFlags(flags, options, keys) {
     for (let key in define) {
       if (key.indexOf("=") >= 0)
         throw new Error(`Invalid define: ${key}`);
-      flags.push(`--define:${key}=${define[key]}`);
+      flags.push(`--define:${key}=${validateStringValue(define[key], "define", key)}`);
     }
   }
   if (logOverride) {
     for (let key in logOverride) {
       if (key.indexOf("=") >= 0)
         throw new Error(`Invalid log override: ${key}`);
-      flags.push(`--log-override:${key}=${logOverride[key]}`);
+      flags.push(`--log-override:${key}=${validateStringValue(logOverride[key], "log override", key)}`);
     }
   }
   if (supported) {
     for (let key in supported) {
       if (key.indexOf("=") >= 0)
         throw new Error(`Invalid supported: ${key}`);
-      flags.push(`--supported:${key}=${supported[key]}`);
+      const value = supported[key];
+      if (typeof value !== "boolean")
+        throw new Error(`Expected value for supported ${quote(key)} to be a boolean, got ${typeof value} instead`);
+      flags.push(`--supported:${key}=${value}`);
     }
   }
   if (pure)
     for (let fn of pure)
-      flags.push(`--pure:${fn}`);
+      flags.push(`--pure:${validateStringValue(fn, "pure")}`);
   if (keepNames)
     flags.push(`--keep-names`);
 }
@@ -403,12 +420,10 @@ function flagsForBuildOptions(callName, options, isTTY2, logLevelDefault, writeD
   let keys = /* @__PURE__ */ Object.create(null);
   let stdinContents = null;
   let stdinResolveDir = null;
-  let watchMode = null;
   pushLogFlags(flags, options, keys, isTTY2, logLevelDefault);
   pushCommonFlags(flags, options, keys);
   let sourcemap = getFlag(options, keys, "sourcemap", mustBeStringOrBoolean);
   let bundle = getFlag(options, keys, "bundle", mustBeBoolean);
-  let watch = getFlag(options, keys, "watch", mustBeBooleanOrObject);
   let splitting = getFlag(options, keys, "splitting", mustBeBoolean);
   let preserveSymlinks = getFlag(options, keys, "preserveSymlinks", mustBeBoolean);
   let metafile = getFlag(options, keys, "metafile", mustBeBoolean);
@@ -421,6 +436,7 @@ function flagsForBuildOptions(callName, options, isTTY2, logLevelDefault, writeD
   let mainFields = getFlag(options, keys, "mainFields", mustBeArray);
   let conditions = getFlag(options, keys, "conditions", mustBeArray);
   let external = getFlag(options, keys, "external", mustBeArray);
+  let packages = getFlag(options, keys, "packages", mustBeString);
   let alias = getFlag(options, keys, "alias", mustBeObject);
   let loader = getFlag(options, keys, "loader", mustBeObject);
   let outExtension = getFlag(options, keys, "outExtension", mustBeObject);
@@ -431,12 +447,11 @@ function flagsForBuildOptions(callName, options, isTTY2, logLevelDefault, writeD
   let inject = getFlag(options, keys, "inject", mustBeArray);
   let banner = getFlag(options, keys, "banner", mustBeObject);
   let footer = getFlag(options, keys, "footer", mustBeObject);
-  let entryPoints = getFlag(options, keys, "entryPoints", mustBeArrayOrRecord);
+  let entryPoints = getFlag(options, keys, "entryPoints", mustBeEntryPoints);
   let absWorkingDir = getFlag(options, keys, "absWorkingDir", mustBeString);
   let stdin = getFlag(options, keys, "stdin", mustBeObject);
   let write = (_a2 = getFlag(options, keys, "write", mustBeBoolean)) != null ? _a2 : writeDefault;
   let allowOverwrite = getFlag(options, keys, "allowOverwrite", mustBeBoolean);
-  let incremental = getFlag(options, keys, "incremental", mustBeBoolean) === true;
   let mangleCache = getFlag(options, keys, "mangleCache", mustBeObject);
   keys.plugins = true;
   checkForInvalidFlags(options, keys, `in ${callName}() call`);
@@ -446,17 +461,6 @@ function flagsForBuildOptions(callName, options, isTTY2, logLevelDefault, writeD
     flags.push("--bundle");
   if (allowOverwrite)
     flags.push("--allow-overwrite");
-  if (watch) {
-    flags.push("--watch");
-    if (typeof watch === "boolean") {
-      watchMode = {};
-    } else {
-      let watchKeys = /* @__PURE__ */ Object.create(null);
-      let onRebuild = getFlag(watch, watchKeys, "onRebuild", mustBeFunction);
-      checkForInvalidFlags(watch, watchKeys, `on "watch" in ${callName}() call`);
-      watchMode = { onRebuild };
-    }
-  }
   if (splitting)
     flags.push("--splitting");
   if (preserveSymlinks)
@@ -471,10 +475,12 @@ function flagsForBuildOptions(callName, options, isTTY2, logLevelDefault, writeD
     flags.push(`--outbase=${outbase}`);
   if (tsconfig)
     flags.push(`--tsconfig=${tsconfig}`);
+  if (packages)
+    flags.push(`--packages=${packages}`);
   if (resolveExtensions) {
     let values = [];
     for (let value of resolveExtensions) {
-      value += "";
+      validateStringValue(value, "resolve extension");
       if (value.indexOf(",") >= 0)
         throw new Error(`Invalid resolve extension: ${value}`);
       values.push(value);
@@ -492,7 +498,7 @@ function flagsForBuildOptions(callName, options, isTTY2, logLevelDefault, writeD
   if (mainFields) {
     let values = [];
     for (let value of mainFields) {
-      value += "";
+      validateStringValue(value, "main field");
       if (value.indexOf(",") >= 0)
         throw new Error(`Invalid main field: ${value}`);
       values.push(value);
@@ -502,7 +508,7 @@ function flagsForBuildOptions(callName, options, isTTY2, logLevelDefault, writeD
   if (conditions) {
     let values = [];
     for (let value of conditions) {
-      value += "";
+      validateStringValue(value, "condition");
       if (value.indexOf(",") >= 0)
         throw new Error(`Invalid condition: ${value}`);
       values.push(value);
@@ -511,53 +517,66 @@ function flagsForBuildOptions(callName, options, isTTY2, logLevelDefault, writeD
   }
   if (external)
     for (let name of external)
-      flags.push(`--external:${name}`);
+      flags.push(`--external:${validateStringValue(name, "external")}`);
   if (alias) {
     for (let old in alias) {
       if (old.indexOf("=") >= 0)
         throw new Error(`Invalid package name in alias: ${old}`);
-      flags.push(`--alias:${old}=${alias[old]}`);
+      flags.push(`--alias:${old}=${validateStringValue(alias[old], "alias", old)}`);
     }
   }
   if (banner) {
     for (let type in banner) {
       if (type.indexOf("=") >= 0)
         throw new Error(`Invalid banner file type: ${type}`);
-      flags.push(`--banner:${type}=${banner[type]}`);
+      flags.push(`--banner:${type}=${validateStringValue(banner[type], "banner", type)}`);
     }
   }
   if (footer) {
     for (let type in footer) {
       if (type.indexOf("=") >= 0)
         throw new Error(`Invalid footer file type: ${type}`);
-      flags.push(`--footer:${type}=${footer[type]}`);
+      flags.push(`--footer:${type}=${validateStringValue(footer[type], "footer", type)}`);
     }
   }
   if (inject)
     for (let path3 of inject)
-      flags.push(`--inject:${path3}`);
+      flags.push(`--inject:${validateStringValue(path3, "inject")}`);
   if (loader) {
     for (let ext in loader) {
       if (ext.indexOf("=") >= 0)
         throw new Error(`Invalid loader extension: ${ext}`);
-      flags.push(`--loader:${ext}=${loader[ext]}`);
+      flags.push(`--loader:${ext}=${validateStringValue(loader[ext], "loader", ext)}`);
     }
   }
   if (outExtension) {
     for (let ext in outExtension) {
       if (ext.indexOf("=") >= 0)
         throw new Error(`Invalid out extension: ${ext}`);
-      flags.push(`--out-extension:${ext}=${outExtension[ext]}`);
+      flags.push(`--out-extension:${ext}=${validateStringValue(outExtension[ext], "out extension", ext)}`);
     }
   }
   if (entryPoints) {
     if (Array.isArray(entryPoints)) {
-      for (let entryPoint of entryPoints) {
-        entries.push(["", entryPoint + ""]);
+      for (let i = 0, n = entryPoints.length; i < n; i++) {
+        let entryPoint = entryPoints[i];
+        if (typeof entryPoint === "object" && entryPoint !== null) {
+          let entryPointKeys = /* @__PURE__ */ Object.create(null);
+          let input = getFlag(entryPoint, entryPointKeys, "in", mustBeString);
+          let output = getFlag(entryPoint, entryPointKeys, "out", mustBeString);
+          checkForInvalidFlags(entryPoint, entryPointKeys, "in entry point at index " + i);
+          if (input === void 0)
+            throw new Error('Missing property "in" for entry point at index ' + i);
+          if (output === void 0)
+            throw new Error('Missing property "out" for entry point at index ' + i);
+          entries.push([output, input]);
+        } else {
+          entries.push(["", validateStringValue(entryPoint, "entry point at index " + i)]);
+        }
       }
     } else {
-      for (let [key, value] of Object.entries(entryPoints)) {
-        entries.push([key + "", value + ""]);
+      for (let key in entryPoints) {
+        entries.push([key, validateStringValue(entryPoints[key], "entry point", key)]);
       }
     }
   }
@@ -573,7 +592,7 @@ function flagsForBuildOptions(callName, options, isTTY2, logLevelDefault, writeD
     if (loader2)
       flags.push(`--loader=${loader2}`);
     if (resolveDir)
-      stdinResolveDir = resolveDir + "";
+      stdinResolveDir = resolveDir;
     if (typeof contents === "string")
       stdinContents = encodeUTF8(contents);
     else if (contents instanceof Uint8Array)
@@ -593,9 +612,7 @@ function flagsForBuildOptions(callName, options, isTTY2, logLevelDefault, writeD
     stdinContents,
     stdinResolveDir,
     absWorkingDir,
-    incremental,
     nodePaths,
-    watch: watchMode,
     mangleCache: validateMangleCache(mangleCache)
   };
 }
@@ -718,8 +735,8 @@ function createChannel(streamIn) {
     if (isFirstPacket) {
       isFirstPacket = false;
       let binaryVersion = String.fromCharCode(...bytes);
-      if (binaryVersion !== "0.15.18") {
-        throw new Error(`Cannot start service: Host version "${"0.15.18"}" does not match binary version ${JSON.stringify(binaryVersion)}`);
+      if (binaryVersion !== "0.17.2") {
+        throw new Error(`Cannot start service: Host version "${"0.17.2"}" does not match binary version ${quote(binaryVersion)}`);
       }
       return;
     }
@@ -735,7 +752,7 @@ function createChannel(streamIn) {
         callback(null, packet.value);
     }
   };
-  let buildOrServe = ({ callName, refs, serveOptions, options, isTTY: isTTY2, defaultWD: defaultWD2, callback }) => {
+  let buildOrContext = ({ callName, refs, options, isTTY: isTTY2, defaultWD: defaultWD2, callback }) => {
     let refCount = 0;
     const buildKey = nextBuildKey++;
     const requestCallbacks = {};
@@ -756,7 +773,7 @@ function createChannel(streamIn) {
     };
     requestCallbacksByKey[buildKey] = requestCallbacks;
     buildRefs.ref();
-    buildOrServeImpl(
+    buildOrContextImpl(
       callName,
       buildKey,
       sendRequest,
@@ -765,10 +782,8 @@ function createChannel(streamIn) {
       streamIn,
       requestCallbacks,
       options,
-      serveOptions,
       isTTY2,
       defaultWD2,
-      closeData,
       (err, res) => {
         try {
           callback(err, res);
@@ -804,7 +819,15 @@ function createChannel(streamIn) {
           let outstanding = 1;
           let next = () => {
             if (--outstanding === 0) {
-              let result = { warnings, code: response.code, map: response.map };
+              let result = {
+                warnings,
+                code: response.code,
+                map: response.map,
+                mangleCache: void 0,
+                legalComments: void 0
+              };
+              if ("legalComments" in response)
+                result.legalComments = response == null ? void 0 : response.legalComments;
               if (response.mangleCache)
                 result.mangleCache = response == null ? void 0 : response.mangleCache;
               callback(null, result);
@@ -908,30 +931,26 @@ function createChannel(streamIn) {
     readFromStdout,
     afterClose,
     service: {
-      buildOrServe,
+      buildOrContext,
       transform: transform2,
       formatMessages: formatMessages2,
       analyzeMetafile: analyzeMetafile2
     }
   };
 }
-function buildOrServeImpl(callName, buildKey, sendRequest, sendResponse, refs, streamIn, requestCallbacks, options, serveOptions, isTTY2, defaultWD2, closeData, callback) {
+function buildOrContextImpl(callName, buildKey, sendRequest, sendResponse, refs, streamIn, requestCallbacks, options, isTTY2, defaultWD2, callback) {
   const details = createObjectStash();
-  const logPluginError = (e, pluginName, note, done) => {
+  const isContext = callName === "context";
+  const handleError = (e, pluginName) => {
     const flags = [];
     try {
       pushLogFlags(flags, options, {}, isTTY2, buildLogLevelDefault);
     } catch {
     }
-    const message = extractErrorMessageV8(e, streamIn, details, note, pluginName);
+    const message = extractErrorMessageV8(e, streamIn, details, void 0, pluginName);
     sendRequest(refs, { command: "error", flags, error: message }, () => {
       message.detail = details.load(message.detail);
-      done(message);
-    });
-  };
-  const handleError = (e, pluginName) => {
-    logPluginError(e, pluginName, void 0, (error) => {
-      callback(failureErrorWithLog("Build failed", [error], []), null);
+      callback(failureErrorWithLog(isContext ? "Context failed" : "Build failed", [message], []), null);
     });
   };
   let plugins;
@@ -939,15 +958,13 @@ function buildOrServeImpl(callName, buildKey, sendRequest, sendResponse, refs, s
     const value = options.plugins;
     if (value !== void 0) {
       if (!Array.isArray(value))
-        throw new Error(`"plugins" must be an array`);
+        return handleError(new Error(`"plugins" must be an array`), "");
       plugins = value;
     }
   }
   if (plugins && plugins.length > 0) {
-    if (streamIn.isSync) {
-      handleError(new Error("Cannot use plugins in synchronous API calls"), "");
-      return;
-    }
+    if (streamIn.isSync)
+      return handleError(new Error("Cannot use plugins in synchronous API calls"), "");
     handlePlugins(
       buildKey,
       sendRequest,
@@ -960,12 +977,10 @@ function buildOrServeImpl(callName, buildKey, sendRequest, sendResponse, refs, s
       details
     ).then(
       (result) => {
-        if (!result.ok) {
-          handleError(result.error, result.pluginName);
-          return;
-        }
+        if (!result.ok)
+          return handleError(result.error, result.pluginName);
         try {
-          buildOrServeContinue(result.requestPlugins, result.runOnEndCallbacks);
+          buildOrContextContinue(result.requestPlugins, result.runOnEndCallbacks, result.scheduleOnDisposeCallbacks);
         } catch (e) {
           handleError(e, "");
         }
@@ -975,25 +990,26 @@ function buildOrServeImpl(callName, buildKey, sendRequest, sendResponse, refs, s
     return;
   }
   try {
-    buildOrServeContinue(null, (result, logPluginError2, done) => done());
+    buildOrContextContinue(null, (result, done) => done([], []), () => {
+    });
   } catch (e) {
     handleError(e, "");
   }
-  function buildOrServeContinue(requestPlugins, runOnEndCallbacks) {
-    let writeDefault = !streamIn.isWriteUnavailable;
-    let {
+  function buildOrContextContinue(requestPlugins, runOnEndCallbacks, scheduleOnDisposeCallbacks) {
+    const writeDefault = streamIn.hasFS;
+    const {
       entries,
       flags,
       write,
       stdinContents,
       stdinResolveDir,
       absWorkingDir,
-      incremental,
       nodePaths,
-      watch,
       mangleCache
     } = flagsForBuildOptions(callName, options, isTTY2, buildLogLevelDefault, writeDefault);
-    let request = {
+    if (write && !streamIn.hasFS)
+      throw new Error(`The "write" option is unavailable in this environment`);
+    const request = {
       command: "build",
       key: buildKey,
       entries,
@@ -1002,17 +1018,23 @@ function buildOrServeImpl(callName, buildKey, sendRequest, sendResponse, refs, s
       stdinContents,
       stdinResolveDir,
       absWorkingDir: absWorkingDir || defaultWD2,
-      incremental,
-      nodePaths
+      nodePaths,
+      context: isContext
     };
     if (requestPlugins)
       request.plugins = requestPlugins;
     if (mangleCache)
       request.mangleCache = mangleCache;
-    let serve2 = serveOptions && buildServeData(buildKey, sendRequest, sendResponse, refs, requestCallbacks, serveOptions, request);
-    let rebuild;
-    let stop;
-    let copyResponseToResult = (response, result) => {
+    const buildResponseToResult = (response, callback2) => {
+      const result = {
+        errors: replaceDetailsInMessages(response.errors, details),
+        warnings: replaceDetailsInMessages(response.warnings, details),
+        outputFiles: void 0,
+        metafile: void 0,
+        mangleCache: void 0
+      };
+      const originalErrors = result.errors.slice();
+      const originalWarnings = result.warnings.slice();
       if (response.outputFiles)
         result.outputFiles = response.outputFiles.map(convertOutputFiles);
       if (response.metafile)
@@ -1021,170 +1043,163 @@ function buildOrServeImpl(callName, buildKey, sendRequest, sendResponse, refs, s
         result.mangleCache = response.mangleCache;
       if (response.writeToStdout !== void 0)
         console.log(decodeUTF8(response.writeToStdout).replace(/\n$/, ""));
-    };
-    let buildResponseToResult = (response, callback2) => {
-      let result = {
-        errors: replaceDetailsInMessages(response.errors, details),
-        warnings: replaceDetailsInMessages(response.warnings, details)
-      };
-      copyResponseToResult(response, result);
-      runOnEndCallbacks(result, logPluginError, () => {
-        if (result.errors.length > 0) {
-          return callback2(failureErrorWithLog("Build failed", result.errors, result.warnings), null);
+      runOnEndCallbacks(result, (onEndErrors, onEndWarnings) => {
+        if (originalErrors.length > 0 || onEndErrors.length > 0) {
+          const error = failureErrorWithLog("Build failed", originalErrors.concat(onEndErrors), originalWarnings.concat(onEndWarnings));
+          return callback2(error, null, onEndErrors, onEndWarnings);
         }
-        if (response.rebuild) {
-          if (!rebuild) {
-            let isDisposed = false;
-            rebuild = () => new Promise((resolve, reject) => {
-              if (isDisposed || closeData.didClose)
-                throw new Error("Cannot rebuild");
-              sendRequest(
-                refs,
-                { command: "rebuild", key: buildKey },
-                (error2, response2) => {
+        callback2(null, result, onEndErrors, onEndWarnings);
+      });
+    };
+    let latestResultPromise;
+    let provideLatestResult;
+    if (isContext)
+      requestCallbacks["on-end"] = (id, request2) => new Promise((resolve) => {
+        buildResponseToResult(request2, (err, result, onEndErrors, onEndWarnings) => {
+          const response = {
+            errors: onEndErrors,
+            warnings: onEndWarnings
+          };
+          if (provideLatestResult)
+            provideLatestResult(err, result);
+          latestResultPromise = void 0;
+          provideLatestResult = void 0;
+          sendResponse(id, response);
+          resolve();
+        });
+      });
+    sendRequest(refs, request, (error, response) => {
+      if (error)
+        return callback(new Error(error), null);
+      if (!isContext) {
+        return buildResponseToResult(response, (err, res) => {
+          scheduleOnDisposeCallbacks();
+          return callback(err, res);
+        });
+      }
+      if (response.errors.length > 0) {
+        return callback(failureErrorWithLog("Context failed", response.errors, response.warnings), null);
+      }
+      let didDispose = false;
+      const result = {
+        rebuild: () => {
+          if (!latestResultPromise)
+            latestResultPromise = new Promise((resolve, reject) => {
+              let settlePromise;
+              provideLatestResult = (err, result2) => {
+                if (!settlePromise)
+                  settlePromise = () => err ? reject(err) : resolve(result2);
+              };
+              const triggerAnotherBuild = () => {
+                const request2 = {
+                  command: "rebuild",
+                  key: buildKey
+                };
+                sendRequest(refs, request2, (error2, response2) => {
                   if (error2) {
-                    const message = { id: "", pluginName: "", text: error2, location: null, notes: [], detail: void 0 };
-                    return callback2(failureErrorWithLog("Build failed", [message], []), null);
+                    reject(new Error(error2));
+                  } else if (settlePromise) {
+                    settlePromise();
+                  } else {
+                    triggerAnotherBuild();
                   }
-                  buildResponseToResult(response2, (error3, result3) => {
-                    if (error3)
-                      reject(error3);
-                    else
-                      resolve(result3);
-                  });
-                }
-              );
+                });
+              };
+              triggerAnotherBuild();
             });
-            refs.ref();
-            rebuild.dispose = () => {
-              if (isDisposed)
-                return;
-              isDisposed = true;
-              sendRequest(refs, { command: "rebuild-dispose", key: buildKey }, () => {
-              });
-              refs.unref();
-            };
-          }
-          result.rebuild = rebuild;
-        }
-        if (response.watch) {
-          if (!stop) {
-            let isStopped = false;
-            refs.ref();
-            stop = () => {
-              if (isStopped)
-                return;
-              isStopped = true;
-              delete requestCallbacks["watch-rebuild"];
-              sendRequest(refs, { command: "watch-stop", key: buildKey }, () => {
-              });
-              refs.unref();
-            };
-            if (watch) {
-              requestCallbacks["watch-rebuild"] = (id, request2) => {
-                try {
-                  let watchResponse = request2.args;
-                  let result2 = {
-                    errors: replaceDetailsInMessages(watchResponse.errors, details),
-                    warnings: replaceDetailsInMessages(watchResponse.warnings, details)
-                  };
-                  copyResponseToResult(watchResponse, result2);
-                  runOnEndCallbacks(result2, logPluginError, () => {
-                    if (result2.errors.length > 0) {
-                      if (watch.onRebuild)
-                        watch.onRebuild(failureErrorWithLog("Build failed", result2.errors, result2.warnings), null);
-                      return;
-                    }
-                    result2.stop = stop;
-                    if (watch.onRebuild)
-                      watch.onRebuild(null, result2);
-                  });
-                } catch (err) {
-                  console.error(err);
-                }
+          return latestResultPromise;
+        },
+        watch: (options2 = {}) => new Promise((resolve, reject) => {
+          if (!streamIn.hasFS)
+            throw new Error(`Cannot use the "watch" API in this environment`);
+          const keys = {};
+          checkForInvalidFlags(options2, keys, `in watch() call`);
+          const request2 = {
+            command: "watch",
+            key: buildKey
+          };
+          sendRequest(refs, request2, (error2) => {
+            if (error2)
+              reject(new Error(error2));
+            else
+              resolve(void 0);
+          });
+        }),
+        serve: (options2 = {}) => new Promise((resolve, reject) => {
+          if (!streamIn.hasFS)
+            throw new Error(`Cannot use the "serve" API in this environment`);
+          const keys = {};
+          const port = getFlag(options2, keys, "port", mustBeInteger);
+          const host = getFlag(options2, keys, "host", mustBeString);
+          const servedir = getFlag(options2, keys, "servedir", mustBeString);
+          const keyfile = getFlag(options2, keys, "keyfile", mustBeString);
+          const certfile = getFlag(options2, keys, "certfile", mustBeString);
+          const onRequest = getFlag(options2, keys, "onRequest", mustBeFunction);
+          checkForInvalidFlags(options2, keys, `in serve() call`);
+          const request2 = {
+            command: "serve",
+            key: buildKey,
+            onRequest: !!onRequest
+          };
+          if (port !== void 0)
+            request2.port = port;
+          if (host !== void 0)
+            request2.host = host;
+          if (servedir !== void 0)
+            request2.servedir = servedir;
+          if (keyfile !== void 0)
+            request2.keyfile = keyfile;
+          if (certfile !== void 0)
+            request2.certfile = certfile;
+          sendRequest(refs, request2, (error2, response2) => {
+            if (error2)
+              return reject(new Error(error2));
+            if (onRequest) {
+              requestCallbacks["serve-request"] = (id, request3) => {
+                onRequest(request3.args);
                 sendResponse(id, {});
               };
             }
-          }
-          result.stop = stop;
-        }
-        callback2(null, result);
-      });
-    };
-    if (write && streamIn.isWriteUnavailable)
-      throw new Error(`The "write" option is unavailable in this environment`);
-    if (incremental && streamIn.isSync)
-      throw new Error(`Cannot use "incremental" with a synchronous build`);
-    if (watch && streamIn.isSync)
-      throw new Error(`Cannot use "watch" with a synchronous build`);
-    sendRequest(refs, request, (error, response) => {
-      if (error)
-        return callback(new Error(error), null);
-      if (serve2) {
-        let serveResponse = response;
-        let isStopped = false;
-        refs.ref();
-        let result = {
-          port: serveResponse.port,
-          host: serveResponse.host,
-          wait: serve2.wait,
-          stop() {
-            if (isStopped)
-              return;
-            isStopped = true;
-            serve2.stop();
+            resolve(response2);
+          });
+        }),
+        cancel: () => new Promise((resolve) => {
+          if (didDispose)
+            return resolve();
+          const request2 = {
+            command: "cancel",
+            key: buildKey
+          };
+          sendRequest(refs, request2, () => {
+            resolve();
+          });
+        }),
+        dispose: () => new Promise((resolve) => {
+          if (didDispose)
+            return resolve();
+          didDispose = true;
+          const request2 = {
+            command: "dispose",
+            key: buildKey
+          };
+          sendRequest(refs, request2, () => {
+            resolve();
+            scheduleOnDisposeCallbacks();
             refs.unref();
-          }
-        };
-        refs.ref();
-        serve2.wait.then(refs.unref, refs.unref);
-        return callback(null, result);
-      }
-      return buildResponseToResult(response, callback);
+          });
+        })
+      };
+      refs.ref();
+      callback(null, result);
     });
   }
 }
-var buildServeData = (buildKey, sendRequest, sendResponse, refs, requestCallbacks, options, request) => {
-  let keys = {};
-  let port = getFlag(options, keys, "port", mustBeInteger);
-  let host = getFlag(options, keys, "host", mustBeString);
-  let servedir = getFlag(options, keys, "servedir", mustBeString);
-  let onRequest = getFlag(options, keys, "onRequest", mustBeFunction);
-  let wait = new Promise((resolve, reject) => {
-    requestCallbacks["serve-wait"] = (id, request2) => {
-      if (request2.error !== null)
-        reject(new Error(request2.error));
-      else
-        resolve();
-      sendResponse(id, {});
-    };
-  });
-  request.serve = {};
-  checkForInvalidFlags(options, keys, `in serve() call`);
-  if (port !== void 0)
-    request.serve.port = port;
-  if (host !== void 0)
-    request.serve.host = host;
-  if (servedir !== void 0)
-    request.serve.servedir = servedir;
-  requestCallbacks["serve-request"] = (id, request2) => {
-    if (onRequest)
-      onRequest(request2.args);
-    sendResponse(id, {});
-  };
-  return {
-    wait,
-    stop() {
-      sendRequest(refs, { command: "serve-stop", key: buildKey }, () => {
-      });
-    }
-  };
-};
 var handlePlugins = async (buildKey, sendRequest, sendResponse, refs, streamIn, requestCallbacks, initialOptions, plugins, details) => {
   let onStartCallbacks = [];
   let onEndCallbacks = [];
   let onResolveCallbacks = {};
   let onLoadCallbacks = {};
+  let onDisposeCallbacks = [];
   let nextCallbackID = 0;
   let i = 0;
   let requestPlugins = [];
@@ -1201,9 +1216,11 @@ var handlePlugins = async (buildKey, sendRequest, sendResponse, refs, streamIn,
       let setup = getFlag(item, keys, "setup", mustBeFunction);
       if (typeof setup !== "function")
         throw new Error(`Plugin is missing a setup function`);
-      checkForInvalidFlags(item, keys, `on plugin ${JSON.stringify(name)}`);
+      checkForInvalidFlags(item, keys, `on plugin ${quote(name)}`);
       let plugin = {
         name,
+        onStart: false,
+        onEnd: false,
         onResolve: [],
         onLoad: []
       };
@@ -1238,6 +1255,8 @@ var handlePlugins = async (buildKey, sendRequest, sendResponse, refs, streamIn,
             request.resolveDir = resolveDir;
           if (kind != null)
             request.kind = kind;
+          else
+            throw new Error(`Must specify "kind" when calling "resolve"`);
           if (pluginData != null)
             request.pluginData = details.store(pluginData);
           sendRequest(refs, request, (error, response) => {
@@ -1264,11 +1283,13 @@ var handlePlugins = async (buildKey, sendRequest, sendResponse, refs, streamIn,
           let registeredText = `This error came from the "onStart" callback registered here:`;
           let registeredNote = extractCallerV8(new Error(registeredText), streamIn, "onStart");
           onStartCallbacks.push({ name, callback, note: registeredNote });
+          plugin.onStart = true;
         },
         onEnd(callback) {
           let registeredText = `This error came from the "onEnd" callback registered here:`;
           let registeredNote = extractCallerV8(new Error(registeredText), streamIn, "onEnd");
           onEndCallbacks.push({ name, callback, note: registeredNote });
+          plugin.onEnd = true;
         },
         onResolve(options, callback) {
           let registeredText = `This error came from the "onResolve" callback registered here:`;
@@ -1276,7 +1297,7 @@ var handlePlugins = async (buildKey, sendRequest, sendResponse, refs, streamIn,
           let keys2 = {};
           let filter = getFlag(options, keys2, "filter", mustBeRegExp);
           let namespace = getFlag(options, keys2, "namespace", mustBeString);
-          checkForInvalidFlags(options, keys2, `in onResolve() call for plugin ${JSON.stringify(name)}`);
+          checkForInvalidFlags(options, keys2, `in onResolve() call for plugin ${quote(name)}`);
           if (filter == null)
             throw new Error(`onResolve() call is missing a filter`);
           let id = nextCallbackID++;
@@ -1289,13 +1310,16 @@ var handlePlugins = async (buildKey, sendRequest, sendResponse, refs, streamIn,
           let keys2 = {};
           let filter = getFlag(options, keys2, "filter", mustBeRegExp);
           let namespace = getFlag(options, keys2, "namespace", mustBeString);
-          checkForInvalidFlags(options, keys2, `in onLoad() call for plugin ${JSON.stringify(name)}`);
+          checkForInvalidFlags(options, keys2, `in onLoad() call for plugin ${quote(name)}`);
           if (filter == null)
             throw new Error(`onLoad() call is missing a filter`);
           let id = nextCallbackID++;
           onLoadCallbacks[id] = { name, callback, note: registeredNote };
           plugin.onLoad.push({ id, filter: filter.source, namespace: namespace || "" });
         },
+        onDispose(callback) {
+          onDisposeCallbacks.push(callback);
+        },
         esbuild: streamIn.esbuild
       });
       if (promise)
@@ -1312,11 +1336,11 @@ var handlePlugins = async (buildKey, sendRequest, sendResponse, refs, streamIn,
         let result = await callback();
         if (result != null) {
           if (typeof result !== "object")
-            throw new Error(`Expected onStart() callback in plugin ${JSON.stringify(name)} to return an object`);
+            throw new Error(`Expected onStart() callback in plugin ${quote(name)} to return an object`);
           let keys = {};
           let errors = getFlag(result, keys, "errors", mustBeArray);
           let warnings = getFlag(result, keys, "warnings", mustBeArray);
-          checkForInvalidFlags(result, keys, `from onStart() callback in plugin ${JSON.stringify(name)}`);
+          checkForInvalidFlags(result, keys, `from onStart() callback in plugin ${quote(name)}`);
           if (errors != null)
             response.errors.push(...sanitizeMessages(errors, "errors", details, name));
           if (warnings != null)
@@ -1343,7 +1367,7 @@ var handlePlugins = async (buildKey, sendRequest, sendResponse, refs, streamIn,
         });
         if (result != null) {
           if (typeof result !== "object")
-            throw new Error(`Expected onResolve() callback in plugin ${JSON.stringify(name)} to return an object`);
+            throw new Error(`Expected onResolve() callback in plugin ${quote(name)} to return an object`);
           let keys = {};
           let pluginName = getFlag(result, keys, "pluginName", mustBeString);
           let path3 = getFlag(result, keys, "path", mustBeString);
@@ -1356,7 +1380,7 @@ var handlePlugins = async (buildKey, sendRequest, sendResponse, refs, streamIn,
           let warnings = getFlag(result, keys, "warnings", mustBeArray);
           let watchFiles = getFlag(result, keys, "watchFiles", mustBeArray);
           let watchDirs = getFlag(result, keys, "watchDirs", mustBeArray);
-          checkForInvalidFlags(result, keys, `from onResolve() callback in plugin ${JSON.stringify(name)}`);
+          checkForInvalidFlags(result, keys, `from onResolve() callback in plugin ${quote(name)}`);
           response.id = id2;
           if (pluginName != null)
             response.pluginName = pluginName;
@@ -1402,7 +1426,7 @@ var handlePlugins = async (buildKey, sendRequest, sendResponse, refs, streamIn,
         });
         if (result != null) {
           if (typeof result !== "object")
-            throw new Error(`Expected onLoad() callback in plugin ${JSON.stringify(name)} to return an object`);
+            throw new Error(`Expected onLoad() callback in plugin ${quote(name)} to return an object`);
           let keys = {};
           let pluginName = getFlag(result, keys, "pluginName", mustBeString);
           let contents = getFlag(result, keys, "contents", mustBeStringOrUint8Array);
@@ -1413,7 +1437,7 @@ var handlePlugins = async (buildKey, sendRequest, sendResponse, refs, streamIn,
           let warnings = getFlag(result, keys, "warnings", mustBeArray);
           let watchFiles = getFlag(result, keys, "watchFiles", mustBeArray);
           let watchDirs = getFlag(result, keys, "watchDirs", mustBeArray);
-          checkForInvalidFlags(result, keys, `from onLoad() callback in plugin ${JSON.stringify(name)}`);
+          checkForInvalidFlags(result, keys, `from onLoad() callback in plugin ${quote(name)}`);
           response.id = id2;
           if (pluginName != null)
             response.pluginName = pluginName;
@@ -1444,25 +1468,62 @@ var handlePlugins = async (buildKey, sendRequest, sendResponse, refs, streamIn,
     }
     sendResponse(id, response);
   };
-  let runOnEndCallbacks = (result, logPluginError, done) => done();
+  let runOnEndCallbacks = (result, done) => done([], []);
   if (onEndCallbacks.length > 0) {
-    runOnEndCallbacks = (result, logPluginError, done) => {
+    runOnEndCallbacks = (result, done) => {
       (async () => {
+        const onEndErrors = [];
+        const onEndWarnings = [];
         for (const { name, callback, note } of onEndCallbacks) {
+          let newErrors;
+          let newWarnings;
           try {
-            await callback(result);
+            const value = await callback(result);
+            if (value != null) {
+              if (typeof value !== "object")
+                throw new Error(`Expected onEnd() callback in plugin ${quote(name)} to return an object`);
+              let keys = {};
+              let errors = getFlag(value, keys, "errors", mustBeArray);
+              let warnings = getFlag(value, keys, "warnings", mustBeArray);
+              checkForInvalidFlags(value, keys, `from onEnd() callback in plugin ${quote(name)}`);
+              if (errors != null)
+                newErrors = sanitizeMessages(errors, "errors", details, name);
+              if (warnings != null)
+                newWarnings = sanitizeMessages(warnings, "warnings", details, name);
+            }
           } catch (e) {
-            result.errors.push(await new Promise((resolve) => logPluginError(e, name, note && note(), resolve)));
+            newErrors = [extractErrorMessageV8(e, streamIn, details, note && note(), name)];
+          }
+          if (newErrors) {
+            onEndErrors.push(...newErrors);
+            try {
+              result.errors.push(...newErrors);
+            } catch {
+            }
+          }
+          if (newWarnings) {
+            onEndWarnings.push(...newWarnings);
+            try {
+              result.warnings.push(...newWarnings);
+            } catch {
+            }
           }
         }
-      })().then(done);
+        done(onEndErrors, onEndWarnings);
+      })();
     };
   }
+  let scheduleOnDisposeCallbacks = () => {
+    for (const cb of onDisposeCallbacks) {
+      setTimeout(() => cb(), 0);
+    }
+  };
   isSetupDone = true;
   return {
     ok: true,
     requestPlugins,
-    runOnEndCallbacks
+    runOnEndCallbacks,
+    scheduleOnDisposeCallbacks
   };
 };
 function createObjectStash() {
@@ -1647,7 +1708,7 @@ function sanitizeStringArray(values, property) {
   const result = [];
   for (const value of values) {
     if (typeof value !== "string")
-      throw new Error(`${JSON.stringify(property)} must be an array of strings`);
+      throw new Error(`${quote(property)} must be an array of strings`);
     result.push(value);
   }
   return result;
@@ -1673,35 +1734,35 @@ var fs = require("fs");
 var os = require("os");
 var path = require("path");
 var ESBUILD_BINARY_PATH = process.env.ESBUILD_BINARY_PATH || ESBUILD_BINARY_PATH;
-var packageDarwin_arm64 = "esbuild-darwin-arm64";
-var packageDarwin_x64 = "esbuild-darwin-64";
+var packageDarwin_arm64 = "@esbuild/darwin-arm64";
+var packageDarwin_x64 = "@esbuild/darwin-x64";
 var knownWindowsPackages = {
-  "win32 arm64 LE": "esbuild-windows-arm64",
-  "win32 ia32 LE": "esbuild-windows-32",
-  "win32 x64 LE": "esbuild-windows-64"
+  "win32 arm64 LE": "@esbuild/win32-arm64",
+  "win32 ia32 LE": "@esbuild/win32-ia32",
+  "win32 x64 LE": "@esbuild/win32-x64"
 };
 var knownUnixlikePackages = {
-  "android arm64 LE": "esbuild-android-arm64",
-  "darwin arm64 LE": "esbuild-darwin-arm64",
-  "darwin x64 LE": "esbuild-darwin-64",
-  "freebsd arm64 LE": "esbuild-freebsd-arm64",
-  "freebsd x64 LE": "esbuild-freebsd-64",
-  "linux arm LE": "esbuild-linux-arm",
-  "linux arm64 LE": "esbuild-linux-arm64",
-  "linux ia32 LE": "esbuild-linux-32",
-  "linux mips64el LE": "esbuild-linux-mips64le",
-  "linux ppc64 LE": "esbuild-linux-ppc64le",
-  "linux riscv64 LE": "esbuild-linux-riscv64",
-  "linux s390x BE": "esbuild-linux-s390x",
-  "linux x64 LE": "esbuild-linux-64",
+  "android arm64 LE": "@esbuild/android-arm64",
+  "darwin arm64 LE": "@esbuild/darwin-arm64",
+  "darwin x64 LE": "@esbuild/darwin-x64",
+  "freebsd arm64 LE": "@esbuild/freebsd-arm64",
+  "freebsd x64 LE": "@esbuild/freebsd-x64",
+  "linux arm LE": "@esbuild/linux-arm",
+  "linux arm64 LE": "@esbuild/linux-arm64",
+  "linux ia32 LE": "@esbuild/linux-ia32",
+  "linux mips64el LE": "@esbuild/linux-mips64el",
+  "linux ppc64 LE": "@esbuild/linux-ppc64",
+  "linux riscv64 LE": "@esbuild/linux-riscv64",
+  "linux s390x BE": "@esbuild/linux-s390x",
+  "linux x64 LE": "@esbuild/linux-x64",
   "linux loong64 LE": "@esbuild/linux-loong64",
-  "netbsd x64 LE": "esbuild-netbsd-64",
-  "openbsd x64 LE": "esbuild-openbsd-64",
-  "sunos x64 LE": "esbuild-sunos-64"
+  "netbsd x64 LE": "@esbuild/netbsd-x64",
+  "openbsd x64 LE": "@esbuild/openbsd-x64",
+  "sunos x64 LE": "@esbuild/sunos-x64"
 };
 var knownWebAssemblyFallbackPackages = {
   "android arm LE": "@esbuild/android-arm",
-  "android x64 LE": "esbuild-android-64"
+  "android x64 LE": "@esbuild/android-x64"
 };
 function pkgAndSubpathForCurrentPlatform() {
   let pkg;
@@ -1748,11 +1809,15 @@ function pkgForSomeOtherPlatform() {
 }
 function downloadedBinPath(pkg, subpath) {
   const esbuildLibDir = path.dirname(require.resolve("esbuild"));
-  return path.join(esbuildLibDir, `downloaded-${pkg}-${path.basename(subpath)}`);
+  return path.join(esbuildLibDir, `downloaded-${pkg.replace("/", "-")}-${path.basename(subpath)}`);
 }
 function generateBinPath() {
   if (ESBUILD_BINARY_PATH) {
-    return { binPath: ESBUILD_BINARY_PATH, isWASM: false };
+    if (!fs.existsSync(ESBUILD_BINARY_PATH)) {
+      console.warn(`[esbuild] Ignoring bad configuration: ESBUILD_BINARY_PATH=${ESBUILD_BINARY_PATH}`);
+    } else {
+      return { binPath: ESBUILD_BINARY_PATH, isWASM: false };
+    }
   }
   const { pkg, subpath, isWASM } = pkgAndSubpathForCurrentPlatform();
   let binPath;
@@ -1839,7 +1904,7 @@ for your current platform.`);
         "node_modules",
         ".cache",
         "esbuild",
-        `pnpapi-${pkg}-${"0.15.18"}-${path.basename(subpath)}`
+        `pnpapi-${pkg.replace("/", "-")}-${"0.17.2"}-${path.basename(subpath)}`
       );
       if (!fs.existsSync(binTargetPath)) {
         fs.mkdirSync(path.dirname(binTargetPath), { recursive: true });
@@ -1866,12 +1931,15 @@ if (process.env.ESBUILD_WORKER_THREADS !== "0") {
   } catch {
   }
   let [major, minor] = process.versions.node.split(".");
-  if (+major < 12 || +major === 12 && +minor < 17 || +major === 13 && +minor < 13) {
+  if (
+    // <v12.17.0 does not work
+    +major < 12 || +major === 12 && +minor < 17 || +major === 13 && +minor < 13
+  ) {
     worker_threads = void 0;
   }
 }
 var _a;
-var isInternalWorkerThread = ((_a = worker_threads == null ? void 0 : worker_threads.workerData) == null ? void 0 : _a.esbuildVersion) === "0.15.18";
+var isInternalWorkerThread = ((_a = worker_threads == null ? void 0 : worker_threads.workerData) == null ? void 0 : _a.esbuildVersion) === "0.17.2";
 var esbuildCommandAndArgs = () => {
   if ((!ESBUILD_BINARY_PATH || false) && (path2.basename(__filename) !== "main.js" || path2.basename(__dirname) !== "lib")) {
     throw new Error(
@@ -1938,9 +2006,9 @@ var fsAsync = {
     }
   }
 };
-var version = "0.15.18";
+var version = "0.17.2";
 var build = (options) => ensureServiceIsRunning().build(options);
-var serve = (serveOptions, buildOptions) => ensureServiceIsRunning().serve(serveOptions, buildOptions);
+var context = (buildOptions) => ensureServiceIsRunning().context(buildOptions);
 var transform = (input, options) => ensureServiceIsRunning().transform(input, options);
 var formatMessages = (messages, options) => ensureServiceIsRunning().formatMessages(messages, options);
 var analyzeMetafile = (messages, options) => ensureServiceIsRunning().analyzeMetafile(messages, options);
@@ -1951,10 +2019,9 @@ var buildSync = (options) => {
     return workerThreadService.buildSync(options);
   }
   let result;
-  runServiceSync((service) => service.buildOrServe({
+  runServiceSync((service) => service.buildOrContext({
     callName: "buildSync",
     refs: null,
-    serveOptions: null,
     options,
     isTTY: isTTY(),
     defaultWD,
@@ -2049,7 +2116,7 @@ var ensureServiceIsRunning = () => {
   if (longLivedService)
     return longLivedService;
   let [command, args] = esbuildCommandAndArgs();
-  let child = child_process.spawn(command, args.concat(`--service=${"0.15.18"}`, "--ping"), {
+  let child = child_process.spawn(command, args.concat(`--service=${"0.17.2"}`, "--ping"), {
     windowsHide: true,
     stdio: ["pipe", "pipe", "inherit"],
     cwd: defaultWD
@@ -2063,7 +2130,7 @@ var ensureServiceIsRunning = () => {
     },
     readFileSync: fs2.readFileSync,
     isSync: false,
-    isWriteUnavailable: false,
+    hasFS: true,
     esbuild: node_exports
   });
   child.stdin.on("error", afterClose);
@@ -2091,61 +2158,47 @@ var ensureServiceIsRunning = () => {
     }
   };
   longLivedService = {
-    build: (options) => {
-      return new Promise((resolve, reject) => {
-        service.buildOrServe({
-          callName: "build",
-          refs,
-          serveOptions: null,
-          options,
-          isTTY: isTTY(),
-          defaultWD,
-          callback: (err, res) => err ? reject(err) : resolve(res)
-        });
-      });
-    },
-    serve: (serveOptions, buildOptions) => {
-      if (serveOptions === null || typeof serveOptions !== "object")
-        throw new Error("The first argument must be an object");
-      return new Promise((resolve, reject) => service.buildOrServe({
-        callName: "serve",
+    build: (options) => new Promise((resolve, reject) => {
+      service.buildOrContext({
+        callName: "build",
         refs,
-        serveOptions,
-        options: buildOptions,
+        options,
         isTTY: isTTY(),
         defaultWD,
         callback: (err, res) => err ? reject(err) : resolve(res)
-      }));
-    },
-    transform: (input, options) => {
-      return new Promise((resolve, reject) => service.transform({
-        callName: "transform",
-        refs,
-        input,
-        options: options || {},
-        isTTY: isTTY(),
-        fs: fsAsync,
-        callback: (err, res) => err ? reject(err) : resolve(res)
-      }));
-    },
-    formatMessages: (messages, options) => {
-      return new Promise((resolve, reject) => service.formatMessages({
-        callName: "formatMessages",
-        refs,
-        messages,
-        options,
-        callback: (err, res) => err ? reject(err) : resolve(res)
-      }));
-    },
-    analyzeMetafile: (metafile, options) => {
-      return new Promise((resolve, reject) => service.analyzeMetafile({
-        callName: "analyzeMetafile",
-        refs,
-        metafile: typeof metafile === "string" ? metafile : JSON.stringify(metafile),
-        options,
-        callback: (err, res) => err ? reject(err) : resolve(res)
-      }));
-    }
+      });
+    }),
+    context: (options) => new Promise((resolve, reject) => service.buildOrContext({
+      callName: "context",
+      refs,
+      options,
+      isTTY: isTTY(),
+      defaultWD,
+      callback: (err, res) => err ? reject(err) : resolve(res)
+    })),
+    transform: (input, options) => new Promise((resolve, reject) => service.transform({
+      callName: "transform",
+      refs,
+      input,
+      options: options || {},
+      isTTY: isTTY(),
+      fs: fsAsync,
+      callback: (err, res) => err ? reject(err) : resolve(res)
+    })),
+    formatMessages: (messages, options) => new Promise((resolve, reject) => service.formatMessages({
+      callName: "formatMessages",
+      refs,
+      messages,
+      options,
+      callback: (err, res) => err ? reject(err) : resolve(res)
+    })),
+    analyzeMetafile: (metafile, options) => new Promise((resolve, reject) => service.analyzeMetafile({
+      callName: "analyzeMetafile",
+      refs,
+      metafile: typeof metafile === "string" ? metafile : JSON.stringify(metafile),
+      options,
+      callback: (err, res) => err ? reject(err) : resolve(res)
+    }))
   };
   return longLivedService;
 };
@@ -2159,14 +2212,18 @@ var runServiceSync = (callback) => {
       stdin = bytes;
     },
     isSync: true,
-    isWriteUnavailable: false,
+    hasFS: true,
     esbuild: node_exports
   });
   callback(service);
-  let stdout = child_process.execFileSync(command, args.concat(`--service=${"0.15.18"}`), {
+  let stdout = child_process.execFileSync(command, args.concat(`--service=${"0.17.2"}`), {
     cwd: defaultWD,
     windowsHide: true,
     input: stdin,
+    // We don't know how large the output could be. If it's too large, the
+    // command will fail with ENOBUFS. Reserve 16mb for now since that feels
+    // like it should be enough. Also allow overriding this with an environment
+    // variable.
     maxBuffer: +process.env.ESBUILD_MAX_BUFFER || 16 * 1024 * 1024
   });
   readFromStdout(stdout);
@@ -2179,8 +2236,17 @@ var workerThreadService = null;
 var startWorkerThreadService = (worker_threads2) => {
   let { port1: mainPort, port2: workerPort } = new worker_threads2.MessageChannel();
   let worker = new worker_threads2.Worker(__filename, {
-    workerData: { workerPort, defaultWD, esbuildVersion: "0.15.18" },
+    workerData: { workerPort, defaultWD, esbuildVersion: "0.17.2" },
     transferList: [workerPort],
+    // From node's documentation: https://nodejs.org/api/worker_threads.html
+    //
+    //   Take care when launching worker threads from preload scripts (scripts loaded
+    //   and run using the `-r` command line flag). Unless the `execArgv` option is
+    //   explicitly set, new Worker threads automatically inherit the command line flags
+    //   from the running process and will preload the same preload scripts as the main
+    //   thread. If the preload script unconditionally launches a worker thread, every
+    //   thread spawned will spawn another until the application crashes.
+    //
     execArgv: []
   });
   let nextID = 0;
@@ -2196,14 +2262,8 @@ error: ${text}`);
     if (!options)
       return;
     let plugins = options.plugins;
-    let incremental = options.incremental;
-    let watch = options.watch;
     if (plugins && plugins.length > 0)
       throw fakeBuildError(`Cannot use plugins in synchronous API calls`);
-    if (incremental)
-      throw fakeBuildError(`Cannot use "incremental" with a synchronous build`);
-    if (watch)
-      throw fakeBuildError(`Cannot use "watch" with a synchronous build`);
   };
   let applyProperties = (object, properties) => {
     for (let key in properties) {
@@ -2308,10 +2368,10 @@ var node_default = node_exports;
   analyzeMetafileSync,
   build,
   buildSync,
+  context,
   formatMessages,
   formatMessagesSync,
   initialize,
-  serve,
   transform,
   transformSync,
   version