isomorfeus-asset-manager 0.16.2 → 0.17.0

data/node_modules/esbuild-wasm/lib/main.js

@@ -24,11 +24,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
@@ -215,15 +215,14 @@ function validateTarget(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";
@@ -411,12 +410,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);
@@ -440,12 +437,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`);
@@ -455,17 +451,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)
@@ -563,8 +548,21 @@ function flagsForBuildOptions(callName, options, isTTY2, logLevelDefault, writeD
   }
   if (entryPoints) {
     if (Array.isArray(entryPoints)) {
-      for (let entryPoint of entryPoints) {
-        entries.push(["", validateStringValue(entryPoint, "entry point")]);
+      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 in entryPoints) {
@@ -604,9 +602,7 @@ function flagsForBuildOptions(callName, options, isTTY2, logLevelDefault, writeD
     stdinContents,
     stdinResolveDir,
     absWorkingDir,
-    incremental,
     nodePaths,
-    watch: watchMode,
     mangleCache: validateMangleCache(mangleCache)
   };
 }
@@ -729,8 +725,8 @@ function createChannel(streamIn) {
     if (isFirstPacket) {
       isFirstPacket = false;
       let binaryVersion = String.fromCharCode(...bytes);
-      if (binaryVersion !== "0.16.10") {
-        throw new Error(`Cannot start service: Host version "${"0.16.10"}" does not match binary version ${quote(binaryVersion)}`);
+      if (binaryVersion !== "0.17.12") {
+        throw new Error(`Cannot start service: Host version "${"0.17.12"}" does not match binary version ${quote(binaryVersion)}`);
       }
       return;
     }
@@ -746,7 +742,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 = {};
@@ -767,7 +763,7 @@ function createChannel(streamIn) {
     };
     requestCallbacksByKey[buildKey] = requestCallbacks;
     buildRefs.ref();
-    buildOrServeImpl(
+    buildOrContextImpl(
       callName,
       buildKey,
       sendRequest,
@@ -776,10 +772,8 @@ function createChannel(streamIn) {
       streamIn,
       requestCallbacks,
       options,
-      serveOptions,
       isTTY2,
       defaultWD2,
-      closeData,
       (err, res) => {
         try {
           callback(err, res);
@@ -815,7 +809,13 @@ 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)
@@ -921,30 +921,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;
@@ -952,15 +948,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,
@@ -973,12 +967,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, "");
         }
@@ -988,25 +980,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,
@@ -1015,17 +1008,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)
@@ -1034,170 +1033,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 = [];
@@ -1217,6 +1209,8 @@ var handlePlugins = async (buildKey, sendRequest, sendResponse, refs, streamIn,
       checkForInvalidFlags(item, keys, `on plugin ${quote(name)}`);
       let plugin = {
         name,
+        onStart: false,
+        onEnd: false,
         onResolve: [],
         onLoad: []
       };
@@ -1279,11 +1273,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:`;
@@ -1311,6 +1307,9 @@ var handlePlugins = async (buildKey, sendRequest, sendResponse, refs, streamIn,
           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)
@@ -1459,25 +1458,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() {
@@ -1703,12 +1739,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.16.10";
+var isInternalWorkerThread = ((_a = worker_threads == null ? void 0 : worker_threads.workerData) == null ? void 0 : _a.esbuildVersion) === "0.17.12";
 var esbuildCommandAndArgs = () => {
   if ((!ESBUILD_BINARY_PATH || true) && (path2.basename(__filename) !== "main.js" || path2.basename(__dirname) !== "lib")) {
     throw new Error(
@@ -1775,9 +1814,9 @@ var fsAsync = {
     }
   }
 };
-var version = "0.16.10";
+var version = "0.17.12";
 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);
@@ -1788,10 +1827,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,
@@ -1886,7 +1924,7 @@ var ensureServiceIsRunning = () => {
   if (longLivedService)
     return longLivedService;
   let [command, args] = esbuildCommandAndArgs();
-  let child = child_process.spawn(command, args.concat(`--service=${"0.16.10"}`, "--ping"), {
+  let child = child_process.spawn(command, args.concat(`--service=${"0.17.12"}`, "--ping"), {
     windowsHide: true,
     stdio: ["pipe", "pipe", "inherit"],
     cwd: defaultWD
@@ -1900,7 +1938,7 @@ var ensureServiceIsRunning = () => {
     },
     readFileSync: fs2.readFileSync,
     isSync: false,
-    isWriteUnavailable: false,
+    hasFS: true,
     esbuild: node_exports
   });
   child.stdin.on("error", afterClose);
@@ -1928,61 +1966,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;
 };
@@ -1996,14 +2020,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.16.10"}`), {
+  let stdout = child_process.execFileSync(command, args.concat(`--service=${"0.17.12"}`), {
     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);
@@ -2016,8 +2044,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.16.10" },
+    workerData: { workerPort, defaultWD, esbuildVersion: "0.17.12" },
     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;
@@ -2033,14 +2070,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) {
@@ -2145,10 +2176,10 @@ var node_default = node_exports;
   analyzeMetafileSync,
   build,
   buildSync,
+  context,
   formatMessages,
   formatMessagesSync,
   initialize,
-  serve,
   transform,
   transformSync,
   version