@sanity/pkg-utils 7.4.1-canary.0 → 7.5.0

package/dist/_chunks-cjs/index.cjs

@@ -18,25 +18,58 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
   mod
 ));
-var path = require("node:path"), rimraf = require("rimraf"), node_module = require("node:module"), chalk = require("chalk"), zod = require("zod"), fs = require("node:fs/promises"), node_fs = require("node:fs"), config = require("@sanity/browserslist-config"), zodValidationError = require("zod-validation-error"), rxjs = require("rxjs"), _documentCurrentScript = typeof document < "u" ? document.currentScript : null;
+var path = require("node:path"), rimraf = require("rimraf"), node_module = require("node:module"), node = require("esbuild-register/dist/node"), pkgUp = require("pkg-up"), findConfig = require("find-config"), node_fs = require("node:fs"), chalk = require("chalk"), zod = require("zod"), fs = require("node:fs/promises"), browserslist = require("browserslist"), config$1 = require("@sanity/browserslist-config"), ts = require("typescript"), zodValidationError = require("zod-validation-error"), rxjs = require("rxjs"), apiExtractor = require("@microsoft/api-extractor"), mkdirp = require("mkdirp"), prettier = require("prettier"), tsdocConfig = require("@microsoft/tsdoc-config"), jsoncParser = require("jsonc-parser"), recast = require("recast"), typeScriptParser = require("recast/parsers/typescript.js"), rollup = require("rollup"), rollupPlugin = require("@optimize-lodash/rollup-plugin"), alias = require("@rollup/plugin-alias"), pluginBabel = require("@rollup/plugin-babel"), commonjs = require("@rollup/plugin-commonjs"), json = require("@rollup/plugin-json"), pluginNodeResolve = require("@rollup/plugin-node-resolve"), replace = require("@rollup/plugin-replace"), terser = require("@rollup/plugin-terser"), esbuild = require("rollup-plugin-esbuild"), treeify = require("treeify"), prettyBytes = require("pretty-bytes"), prompts = require("prompts"), node_child_process = require("node:child_process"), getLatestVersion = require("get-latest-version"), gitUrlParse = require("git-url-parse"), outdent = require("outdent"), operators = require("rxjs/operators"), globby = require("globby"), chokidar = require("chokidar"), _documentCurrentScript = typeof document < "u" ? document.currentScript : null;
 function _interopDefaultCompat(e) {
   return e && typeof e == "object" && "default" in e ? e : { default: e };
 }
-var path__default = /* @__PURE__ */ _interopDefaultCompat(path), chalk__default = /* @__PURE__ */ _interopDefaultCompat(chalk), fs__default = /* @__PURE__ */ _interopDefaultCompat(fs), config__default = /* @__PURE__ */ _interopDefaultCompat(config);
+function _interopNamespaceCompat(e) {
+  if (e && typeof e == "object" && "default" in e) return e;
+  var n = /* @__PURE__ */ Object.create(null);
+  return e && Object.keys(e).forEach(function(k) {
+    if (k !== "default") {
+      var d = Object.getOwnPropertyDescriptor(e, k);
+      Object.defineProperty(n, k, d.get ? d : {
+        enumerable: !0,
+        get: function() {
+          return e[k];
+        }
+      });
+    }
+  }), n.default = e, Object.freeze(n);
+}
+var path__default = /* @__PURE__ */ _interopDefaultCompat(path), rimraf__namespace = /* @__PURE__ */ _interopNamespaceCompat(rimraf), pkgUp__default = /* @__PURE__ */ _interopDefaultCompat(pkgUp), findConfig__default = /* @__PURE__ */ _interopDefaultCompat(findConfig), chalk__default = /* @__PURE__ */ _interopDefaultCompat(chalk), fs__default = /* @__PURE__ */ _interopDefaultCompat(fs), browserslist__default = /* @__PURE__ */ _interopDefaultCompat(browserslist), config__default = /* @__PURE__ */ _interopDefaultCompat(config$1), ts__default = /* @__PURE__ */ _interopDefaultCompat(ts), prettier__namespace = /* @__PURE__ */ _interopNamespaceCompat(prettier), typeScriptParser__default = /* @__PURE__ */ _interopDefaultCompat(typeScriptParser), alias__default = /* @__PURE__ */ _interopDefaultCompat(alias), commonjs__default = /* @__PURE__ */ _interopDefaultCompat(commonjs), json__default = /* @__PURE__ */ _interopDefaultCompat(json), replace__default = /* @__PURE__ */ _interopDefaultCompat(replace), terser__default = /* @__PURE__ */ _interopDefaultCompat(terser), esbuild__default = /* @__PURE__ */ _interopDefaultCompat(esbuild), treeify__default = /* @__PURE__ */ _interopDefaultCompat(treeify), prettyBytes__default = /* @__PURE__ */ _interopDefaultCompat(prettyBytes), prompts__default = /* @__PURE__ */ _interopDefaultCompat(prompts), getLatestVersion__default = /* @__PURE__ */ _interopDefaultCompat(getLatestVersion), gitUrlParse__default = /* @__PURE__ */ _interopDefaultCompat(gitUrlParse), globby__default = /* @__PURE__ */ _interopDefaultCompat(globby), chokidar__namespace = /* @__PURE__ */ _interopNamespaceCompat(chokidar);
+function fileExists(filePath) {
+  try {
+    return node_fs.statSync(filePath), !0;
+  } catch {
+    return !1;
+  }
+}
+const CONFIG_FILE_NAMES = [
+  "package.config.ts",
+  "package.config.js",
+  "package.config.cjs",
+  "package.config.mjs"
+];
+function findConfigFile(cwd) {
+  const pkgJsonPath = findConfig__default.default("package.json", { cwd });
+  if (!pkgJsonPath) return;
+  const pkgPath = path__default.default.dirname(pkgJsonPath);
+  for (const fileName of CONFIG_FILE_NAMES) {
+    const configPath = path__default.default.resolve(pkgPath, fileName);
+    if (fileExists(configPath))
+      return configPath;
+  }
+}
+const require$2 = node_module.createRequire(typeof document > "u" ? require("url").pathToFileURL(__filename).href : _documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === "SCRIPT" && _documentCurrentScript.src || new URL("_chunks-cjs/index.cjs", document.baseURI).href);
 async function loadConfig(options) {
-  const [{ register }, { default: pkgUp }, { findConfigFile }] = await Promise.all([
-    import("esbuild-register/dist/node"),
-    import("pkg-up"),
-    Promise.resolve().then(function() {
-      return require("./findConfigFile.cjs");
-    })
-  ]), { cwd } = options, pkgPath = await pkgUp({ cwd });
+  const { cwd } = options, pkgPath = await pkgUp__default.default({ cwd });
   if (!pkgPath) return;
   const root = path__default.default.dirname(pkgPath), configFile = await findConfigFile(root);
   if (!configFile || !configFile.startsWith(cwd))
     return;
   const esbuildOptions = { extensions: [".js", ".mjs", ".ts"] }, { unregister } = globalThis.__DEV__ ? { unregister: () => {
-  } } : register(esbuildOptions), mod = node_module.createRequire(typeof document > "u" ? require("url").pathToFileURL(__filename).href : _documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === "SCRIPT" && _documentCurrentScript.src || new URL("_chunks-cjs/index.cjs", document.baseURI).href)(configFile);
+  } } : node.register(esbuildOptions), mod = require$2(configFile);
   return unregister(), mod?.default || mod || void 0;
 }
 function assertLast(a, arr) {
@@ -47,13 +80,75 @@ function assertOrder(a, b, arr) {
   const aIdx = arr.indexOf(a), bIdx = arr.indexOf(b);
   return aIdx === -1 || bIdx === -1 ? !0 : aIdx < bIdx;
 }
+const pkgSchema = zod.z.object({
+  type: zod.z.optional(zod.z.enum(["commonjs", "module"])),
+  name: zod.z.string(),
+  version: zod.z.string(),
+  license: zod.z.string(),
+  bin: zod.z.optional(zod.z.record(zod.z.string())),
+  dependencies: zod.z.optional(zod.z.record(zod.z.string())),
+  devDependencies: zod.z.optional(zod.z.record(zod.z.string())),
+  peerDependencies: zod.z.optional(zod.z.record(zod.z.string())),
+  source: zod.z.optional(zod.z.string()),
+  main: zod.z.optional(zod.z.string()),
+  browser: zod.z.optional(zod.z.record(zod.z.string())),
+  module: zod.z.optional(zod.z.string()),
+  types: zod.z.optional(zod.z.string()),
+  exports: zod.z.optional(
+    zod.z.record(
+      zod.z.union([
+        zod.z.custom((val) => /^\.\/.*\.json$/.test(val)),
+        zod.z.custom((val) => /^\.\/.*\.css$/.test(val)),
+        zod.z.object({
+          types: zod.z.optional(zod.z.string()),
+          source: zod.z.optional(zod.z.string()),
+          browser: zod.z.optional(
+            zod.z.object({
+              source: zod.z.string(),
+              import: zod.z.optional(zod.z.string()),
+              require: zod.z.optional(zod.z.string())
+            })
+          ),
+          node: zod.z.optional(
+            zod.z.object({
+              source: zod.z.optional(zod.z.string()),
+              import: zod.z.optional(zod.z.string()),
+              require: zod.z.optional(zod.z.string())
+            })
+          ),
+          import: zod.z.optional(zod.z.string()),
+          require: zod.z.optional(zod.z.string()),
+          default: zod.z.string()
+        }),
+        zod.z.object({
+          types: zod.z.optional(zod.z.string()),
+          svelte: zod.z.string(),
+          default: zod.z.optional(zod.z.string())
+        })
+      ])
+    )
+  ),
+  browserslist: zod.z.optional(zod.z.union([zod.z.string(), zod.z.array(zod.z.string())])),
+  sideEffects: zod.z.optional(zod.z.union([zod.z.boolean(), zod.z.array(zod.z.string())])),
+  // @TODO type this properly
+  typesVersions: zod.z.optional(zod.z.any())
+}), typoMap = /* @__PURE__ */ new Map();
+for (const key of pkgSchema.keyof()._def.values)
+  typoMap.set(key.toUpperCase(), key);
+function validatePkg(input) {
+  const pkg = pkgSchema.parse(input), invalidKey = Object.keys(input).find((key) => {
+    const needle = key.toUpperCase();
+    return typoMap.has(needle) ? typoMap.get(needle) !== key : !1;
+  });
+  if (invalidKey)
+    throw new TypeError(
+      `
+- package.json: "${invalidKey}" is not a valid key. Did you mean "${typoMap.get(invalidKey.toUpperCase())}"?`
+    );
+  return pkg;
+}
 async function loadPkg(options) {
-  const [{ default: pkgUp }, { validatePkg }] = await Promise.all([
-    import("pkg-up"),
-    Promise.resolve().then(function() {
-      return require("./validatePkg.cjs");
-    })
-  ]), { cwd } = options, pkgPath = await pkgUp({ cwd });
+  const { cwd } = options, pkgPath = await pkgUp__default.default({ cwd });
   if (!pkgPath) throw new Error("no package.json found");
   const buf = await fs__default.default.readFile(pkgPath), raw = JSON.parse(buf.toString());
   return validatePkg(raw), raw;
@@ -135,166 +230,56 @@ function createLogger() {
     }
   };
 }
-function createSpinner(msg) {
-  const startTime = Date.now();
-  return console.log(msg), {
-    complete: () => {
-      console.log(`${chalk__default.default.green("[success]")} ${chalk__default.default.gray(`${Date.now() - startTime}ms`)}`);
-    },
-    error: () => {
-      console.log(`${chalk__default.default.red("[error]")} ${chalk__default.default.gray(`${Date.now() - startTime}ms`)}`);
-    }
-  };
-}
-async function build(options) {
-  const [{ resolveBuildContext }, { resolveBuildTasks }, { buildTaskHandlers }] = await Promise.all([
-    Promise.resolve().then(function() {
-      return require("./resolveBuildContext.cjs");
-    }),
-    Promise.resolve().then(function() {
-      return require("./resolveBuildTasks.cjs");
-    }),
-    Promise.resolve().then(function() {
-      return require("./index2.cjs");
-    })
-  ]), {
-    cwd,
-    emitDeclarationOnly,
-    strict = !1,
-    tsconfig: tsconfigOption,
-    clean = !1
-  } = options, logger = createLogger(), config2 = await loadConfig({ cwd }), pkg = await loadPkgWithReporting({ cwd, logger, strict }), tsconfig = tsconfigOption || config2?.tsconfig || "tsconfig.json", ctx = await resolveBuildContext({
-    config: config2,
-    cwd,
-    emitDeclarationOnly,
-    logger,
-    pkg,
-    strict,
-    tsconfig
-  });
-  clean && (logger.log(
-    `Deleting the \`dist\` folder: './${path__default.default.relative(cwd, ctx.distPath)}' before building...`
-  ), await rimraf.rimraf(ctx.distPath));
-  const buildTasks = resolveBuildTasks(ctx);
-  for (const task of buildTasks) {
-    const handler = buildTaskHandlers[task.type], taskName = handler.name(ctx, task), spinner = createSpinner(taskName);
-    try {
-      const result = await handler.exec(ctx, task).toPromise();
-      spinner.complete(), ctx.logger.log(), handler.complete(ctx, task, result);
-    } catch (err) {
-      if (spinner.error(), err instanceof Error) {
-        const RE_CWD = new RegExp(`${cwd}`, "g");
-        ctx.logger.error(err.message.replace(RE_CWD, ".")), ctx.logger.log();
-      }
-      handler.error(ctx, task, err), process.exit(1);
-    }
+function browserslistToEsbuild(browserslistConfig, options = {}) {
+  if (!browserslistConfig) {
+    const path2 = process.cwd();
+    browserslistConfig = browserslist__default.default.loadConfig({ path: path2, ...options });
   }
+  const SUPPORTED_ESBUILD_TARGETS = [
+    "es",
+    "chrome",
+    "edge",
+    "firefox",
+    "ios",
+    "node",
+    "safari",
+    "opera",
+    "ie"
+  ], UNSUPPORTED = ["android 4"], replaces = {
+    ios_saf: "ios",
+    android: "chrome"
+  }, separator = " ";
+  return browserslist__default.default(browserslistConfig, options).filter((b) => !UNSUPPORTED.some((u) => b.startsWith(u))).map((b) => b === "safari TP" ? browserslist__default.default("last 1 safari version")[0] : b).map((b) => b.split(separator)).map((b) => (replaces[b[0]] && (b[0] = replaces[b[0]]), b)).map((b) => (b[1].includes("-") && (b[1] = b[1].slice(0, b[1].indexOf("-"))), b)).map((b) => (b[1].endsWith(".0") && (b[1] = b[1].slice(0, -2)), b)).filter((b) => /^\d+(\.\d+)*$/.test(b[1])).filter((b) => SUPPORTED_ESBUILD_TARGETS.includes(b[0])).reduce((acc, b) => {
+    const existingIndex = acc.findIndex((br) => br[0] === b[0]);
+    return existingIndex !== -1 ? acc[existingIndex][1] = b[1] : acc.push(b), acc;
+  }, []).map((b) => b.join(""));
 }
-function createConsoleSpy(options) {
-  const { onRestored } = options || {}, original = {
-    log: console.log,
-    warn: console.warn,
-    error: console.error
-  }, messages = [];
-  return console.log = (...args) => messages.push({ type: "log", args }), console.warn = (...args) => messages.push({ type: "warn", args }), console.error = (...args) => messages.push({ type: "error", args }), {
-    messages,
-    restore: () => {
-      console.log = original.log, console.warn = original.warn, console.error = original.error, onRestored?.(messages);
-    }
-  };
-}
-function fileExists(filePath) {
-  try {
-    return node_fs.statSync(filePath), !0;
-  } catch {
-    return !1;
-  }
+function resolveConfigProperty(prop, initialValue) {
+  return prop ? typeof prop == "function" ? prop(initialValue) : prop : initialValue;
 }
-async function check(options) {
-  const [{ resolveBuildContext }, { printPackageTree }] = await Promise.all([
-    Promise.resolve().then(function() {
-      return require("./resolveBuildContext.cjs");
-    }),
-    Promise.resolve().then(function() {
-      return require("./printPackageTree.cjs");
-    })
-  ]), { cwd, strict = !1, tsconfig: tsconfigOption } = options, logger = createLogger(), config2 = await loadConfig({ cwd }), pkg = await loadPkgWithReporting({ cwd, logger, strict }), tsconfig = tsconfigOption || config2?.tsconfig || "tsconfig.json", ctx = await resolveBuildContext({ config: config2, cwd, logger, pkg, strict, tsconfig });
-  if (printPackageTree(ctx), strict) {
-    const missingFiles = [];
-    for (const [, exp] of Object.entries(ctx.exports || {}))
-      exp.source && !fileExists(path__default.default.resolve(cwd, exp.source)) && missingFiles.push(exp.source), exp.require && !fileExists(path__default.default.resolve(cwd, exp.require)) && missingFiles.push(exp.require), exp.import && !fileExists(path__default.default.resolve(cwd, exp.import)) && missingFiles.push(exp.import);
-    ctx.pkg.types && !fileExists(path__default.default.resolve(cwd, ctx.pkg.types)) && missingFiles.push(ctx.pkg.types), missingFiles.length && (logger.error(`missing files: ${missingFiles.join(", ")}`), process.exit(1));
-    const exportPaths = {
-      require: [],
-      import: []
-    };
-    for (const exp of Object.values(ctx.exports || {}))
-      exp._exported && (exp.require && exportPaths.require.push(exp.require), exp.import && exportPaths.import.push(exp.import));
-    const external = [
-      ...Object.keys(pkg.dependencies || {}),
-      ...Object.keys(pkg.devDependencies || {})
-    ], consoleSpy = createConsoleSpy();
-    exportPaths.import.length && checkExports(exportPaths.import, { cwd, external, format: "esm", logger }), exportPaths.require.length && checkExports(exportPaths.require, { cwd, external, format: "cjs", logger }), consoleSpy.restore();
-  }
+const DEFAULT_BROWSERSLIST_QUERY = config__default.default;
+function pathContains(containerPath, itemPath) {
+  return !path__default.default.relative(containerPath, itemPath).startsWith("..");
 }
-async function checkExports(exportPaths, options) {
-  const { build: build2 } = await import("esbuild"), { cwd, external, format, logger } = options, code = exportPaths.map((id) => format ? `import('${id}');` : `require('${id}');`).join(`
-`);
-  try {
-    const esbuildResult = await build2({
-      bundle: !0,
-      external,
-      format,
-      logLevel: "silent",
-      // otherwise output maps to stdout as we're using stdin
-      outfile: "/dev/null",
-      platform: "node",
-      stdin: {
-        contents: code,
-        loader: "js",
-        resolveDir: cwd
+function findCommonDirPath(filePaths) {
+  let ret;
+  for (const filePath of filePaths) {
+    let dirPath = path__default.default.dirname(filePath);
+    if (!ret) {
+      ret = dirPath;
+      continue;
+    }
+    for (; dirPath !== ret && (dirPath = path__default.default.dirname(dirPath), dirPath !== ret); ) {
+      if (pathContains(dirPath, ret)) {
+        ret = dirPath;
+        break;
       }
-    });
-    if (esbuildResult.errors.length > 0) {
-      for (const msg of esbuildResult.errors)
-        printEsbuildMessage(logger.warn, msg), logger.log();
-      process.exit(1);
+      if (dirPath === ".") return;
     }
-    const esbuildWarnings = esbuildResult.warnings.filter((msg) => {
-      (msg.detail || msg.text).includes("does not affect esbuild's own target setting");
-    });
-    for (const msg of esbuildWarnings)
-      printEsbuildMessage(logger.warn, msg), logger.log();
-  } catch (err) {
-    if (isEsbuildFailure(err)) {
-      const { errors } = err;
-      for (const msg of errors)
-        printEsbuildMessage(logger.error, msg), logger.log();
-    } else err instanceof Error ? (logger.error(err.stack || err.message), logger.log()) : (logger.error(`${err}`), logger.log());
-    process.exit(1);
   }
+  return ret;
 }
-function printEsbuildMessage(log, msg) {
-  msg.location ? log(
-    [
-      `${msg.detail || msg.text}
-`,
-      `${msg.location.line} | ${msg.location.lineText}
-`,
-      `in ./${msg.location.file}:${msg.location.line}:${msg.location.column}`
-    ].join("")
-  ) : log(msg.detail || msg.text);
-}
-function isEsbuildFailure(err) {
-  return err instanceof Error && "errors" in err && Array.isArray(err.errors) && err.errors.every(isEsbuildMessage) && "warnings" in err && Array.isArray(err.warnings) && err.warnings.every(isEsbuildMessage);
-}
-function isEsbuildMessage(msg) {
-  return typeof msg == "object" && msg !== null && "text" in msg && typeof msg.text == "string" && "location" in msg && (msg.location === null || typeof msg.location == "object");
-}
-function defineConfig(configOptions) {
-  return configOptions;
-}
-const DEFAULT_BROWSERSLIST_QUERY = config__default.default, fileEnding = /\.[mc]?js$/, dtsEnding = ".d.ts", defaultEnding = ".js", mjsEnding = ".mjs", cjsEnding = ".cjs", mtsEnding = ".d.mts", ctsEnding = ".d.cts";
+const fileEnding = /\.[mc]?js$/, dtsEnding = ".d.ts", defaultEnding = ".js", mjsEnding = ".mjs", cjsEnding = ".cjs", mtsEnding = ".d.mts", ctsEnding = ".d.cts";
 function getTargetPaths(_type, expOrBundle) {
   const type = _type === "module" ? "module" : "commonjs", set = /* @__PURE__ */ new Set();
   return expOrBundle?.import && set.add(expOrBundle.import.replace(fileEnding, type === "module" ? dtsEnding : mtsEnding)), expOrBundle?.require && set.add(expOrBundle.require.replace(fileEnding, type === "commonjs" ? dtsEnding : ctsEnding)), isPkgExport$1(expOrBundle) && (expOrBundle.browser?.source || (expOrBundle.browser?.import && set.add(
@@ -444,43 +429,24 @@ function parseExports(options) {
 function isPkgExport(value) {
   return isRecord(value) && "source" in value && typeof value.source == "string";
 }
-function defineTemplateOption(option) {
-  return option;
-}
-async function isEmptyDirectory(dirPath) {
-  return (await fs.readdir(dirPath)).length === 0;
+async function loadTSConfig(options) {
+  const { cwd, tsconfigPath } = options, configPath = ts__default.default.findConfigFile(cwd, ts__default.default.sys.fileExists, tsconfigPath);
+  if (!configPath)
+    return;
+  const configFile = ts__default.default.readConfigFile(configPath, ts__default.default.sys.readFile);
+  return ts__default.default.parseJsonConfigFileContent(configFile.config, ts__default.default.sys, cwd);
 }
-async function init(options) {
-  const [{ createFromTemplate }, { defaultTemplate }] = await Promise.all([
-    Promise.resolve().then(function() {
-      return require("./index3.cjs");
-    }),
-    Promise.resolve().then(function() {
-      return require("./template.cjs");
-    })
-  ]);
-  if (!options.cwd)
-    throw new Error("Missing required option: cwd");
-  if (!options.path)
-    throw new Error("Missing required option: path");
-  const logger = createLogger(), packagePath = path.resolve(options.cwd, options.path);
-  await ensurePackagePath(packagePath), await createFromTemplate({
-    cwd: options.cwd,
-    logger,
-    template: defaultTemplate,
-    packagePath
-  });
+function resolveBrowserTarget(versions) {
+  const target = versions.filter(
+    (version) => version.startsWith("chrome") || version.startsWith("edge") || version.startsWith("firefox") || version.startsWith("ios") || version.startsWith("safari") || version.startsWith("opera")
+  );
+  if (target.length !== 0)
+    return target;
 }
-async function ensurePackagePath(packagePath) {
-  const { mkdirp } = await import("mkdirp");
-  if (!fileExists(packagePath)) {
-    await mkdirp(packagePath);
-    return;
-  }
-  if (!(await fs.lstat(packagePath)).isDirectory())
-    throw new Error("the package path is a file, not a directory");
-  if (!await isEmptyDirectory(packagePath))
-    throw new Error("the package directory is not empty");
+function resolveNodeTarget(versions) {
+  const target = versions.filter((version) => version.startsWith("node"));
+  if (target.length !== 0)
+    return target;
 }
 const toggle = zod.z.union([zod.z.literal("error"), zod.z.literal("warn"), zod.z.literal("off")]), strictOptions = zod.z.object({
   noPackageJsonTypings: toggle.default("error"),
@@ -495,56 +461,439 @@ const toggle = zod.z.union([zod.z.literal("error"), zod.z.literal("warn"), zod.z
 function parseStrictOptions(input) {
   return validationSchema.parse({ strictOptions: input }, { errorMap: zodValidationError.errorMap }).strictOptions;
 }
-const LOG_LEVELS = {
-  error: "error",
-  info: "info",
-  off: "none",
-  warn: "warning"
-};
-function getExtractMessagesConfig(options) {
-  const { rules, disabled = !1 } = options;
-  function ruleToLogLevel(key, defaultLevel) {
-    const r = rules?.[key];
-    return r ? LOG_LEVELS[r] : defaultLevel || "warning";
+async function resolveBuildContext(options) {
+  const {
+    config: config2,
+    cwd,
+    emitDeclarationOnly = !1,
+    logger,
+    pkg,
+    strict,
+    tsconfig: tsconfigPath
+  } = options, tsconfig = await loadTSConfig({ cwd, tsconfigPath }), strictOptions2 = parseStrictOptions(config2?.strictOptions ?? {});
+  let browserslist2 = pkg.browserslist;
+  if (!browserslist2) {
+    if (strict && strictOptions2.noImplicitBrowsersList !== "off") {
+      if (strictOptions2.noImplicitBrowsersList === "error")
+        throw new Error(
+          '\n- package.json: "browserslist" is missing, set it to `"browserslist": "extends @sanity/browserslist-config"`'
+        );
+      logger.warn(
+        'Could not detect a `browserslist` property in `package.json`, using default configuration. Add `"browserslist": "extends @sanity/browserslist-config"` to silence this warning.'
+      );
+    }
+    browserslist2 = DEFAULT_BROWSERSLIST_QUERY;
   }
+  const targetVersions = browserslistToEsbuild(browserslist2);
+  if (strict && strictOptions2.noImplicitSideEffects !== "off" && typeof pkg.sideEffects > "u") {
+    const msg = "package.json: `sideEffects` is missing, see https://webpack.js.org/guides/tree-shaking/#clarifying-tree-shaking-and-sideeffects for how to define `sideEffects`";
+    if (strictOptions2.noImplicitSideEffects === "error")
+      throw new Error(msg);
+    logger.warn(msg);
+  }
+  const nodeTarget = resolveNodeTarget(targetVersions), webTarget = resolveBrowserTarget(targetVersions);
+  if (!nodeTarget)
+    throw new Error("no matching `node` target");
+  if (!webTarget)
+    throw new Error("no matching `web` target");
+  const target = {
+    "*": webTarget.concat(nodeTarget),
+    browser: webTarget,
+    node: nodeTarget
+  }, parsedExports = parseExports({
+    cwd,
+    pkg,
+    strict,
+    strictOptions: strictOptions2,
+    logger
+  }).reduce(
+    (acc, { _path: exportPath, ...exportEntry }) => Object.assign(acc, { [exportPath]: exportEntry }),
+    {}
+  ), exports2 = resolveConfigProperty(config2?.exports, parsedExports), parsedExternal = [
+    ...pkg.dependencies ? Object.keys(pkg.dependencies) : [],
+    ...pkg.peerDependencies ? Object.keys(pkg.peerDependencies) : []
+  ], external = config2 && Array.isArray(config2.external) ? [...parsedExternal, ...config2.external] : resolveConfigProperty(config2?.external, parsedExternal), externalWithTypes = /* @__PURE__ */ new Set([pkg.name, ...external, ...external.map(transformPackageName)]), bundledDependencies = (pkg.devDependencies ? Object.keys(pkg.devDependencies) : []).filter(
+    // Do not bundle anything that is marked as external
+    (_) => !externalWithTypes.has(_)
+  ), bundledPackages = config2 && Array.isArray(config2.extract?.bundledPackages) ? [...bundledDependencies, ...config2.extract.bundledPackages] : resolveConfigProperty(config2?.extract?.bundledPackages, bundledDependencies), outputPaths = Object.values(exports2).flatMap((exportEntry) => [
+    exportEntry.import,
+    exportEntry.require,
+    exportEntry.browser?.import,
+    exportEntry.browser?.require,
+    exportEntry.node?.source && exportEntry.node.import,
+    exportEntry.node?.source && exportEntry.node.require
+  ].filter(Boolean)).map((p) => path__default.default.resolve(cwd, p)), commonDistPath = findCommonDirPath(outputPaths);
+  if (commonDistPath === cwd)
+    throw new Error(
+      "all output files must share a common parent directory which is not the root package directory"
+    );
+  if (commonDistPath && !pathContains(cwd, commonDistPath))
+    throw new Error("all output files must be located within the package");
+  const configDistPath = config2?.dist ? path__default.default.resolve(cwd, config2.dist) : void 0;
+  if (configDistPath && commonDistPath && configDistPath !== commonDistPath && !pathContains(configDistPath, commonDistPath))
+    throw logger.log(`did you mean to configure \`dist: './${path__default.default.relative(cwd, commonDistPath)}'\`?`), new Error("all output files must be located with the configured `dist` path");
+  const distPath = configDistPath || commonDistPath;
+  if (!distPath)
+    throw new Error("could not detect `dist` path");
   return {
-    compilerMessageReporting: {
-      default: {
-        logLevel: disabled ? "none" : "warning"
-      }
+    config: config2,
+    cwd,
+    distPath,
+    emitDeclarationOnly,
+    exports: exports2,
+    external,
+    bundledPackages,
+    files: [],
+    logger,
+    pkg,
+    runtime: config2?.runtime ?? "*",
+    strict,
+    target,
+    ts: {
+      config: tsconfig,
+      configPath: tsconfigPath
     },
-    extractorMessageReporting: disabled ? {
-      default: {
-        logLevel: "none",
-        addToApiReportFile: !1
+    dts: config2?.dts === "rolldown" ? "rolldown" : "api-extractor"
+  };
+}
+function transformPackageName(packageName) {
+  if (packageName.startsWith("@types/"))
+    return packageName;
+  if (packageName.startsWith("@")) {
+    const [scope, name] = packageName.split("/");
+    return `@types/${scope.slice(1)}__${name}`;
+  } else
+    return `@types/${packageName}`;
+}
+function resolveBuildTasks(ctx) {
+  const { config: config2, pkg, target } = ctx, bundles = config2?.bundles || [], tasks = [], exports2 = Object.entries(ctx.exports || {}).map(
+    ([_path, exp]) => ({ _path, ...exp })
+  ), dtsTask2 = {
+    type: "build:dts",
+    entries: []
+  }, rolldownDtsTask2 = {}, rollupTasks = {};
+  function addRollupTaskEntry(format, runtime, entry) {
+    const buildId = `${format}:${runtime}`;
+    ctx.dts === "rolldown" && (rolldownDtsTask2[buildId] ? rolldownDtsTask2[buildId].entries.push(entry) : rolldownDtsTask2[buildId] = {
+      type: "rolldown:dts",
+      buildId,
+      entries: [entry],
+      runtime,
+      format,
+      target: target[runtime]
+    }), ctx.emitDeclarationOnly || (rollupTasks[buildId] ? rollupTasks[buildId].entries.push(entry) : rollupTasks[buildId] = {
+      type: "build:js",
+      buildId,
+      entries: [entry],
+      runtime,
+      format,
+      target: target[runtime]
+    });
+  }
+  if (ctx.dts === "api-extractor") {
+    for (const exp of exports2) {
+      const importId = path__default.default.join(pkg.name, exp._path);
+      exp.source?.endsWith(".ts") && dtsTask2.entries.push({
+        importId,
+        exportPath: exp._path,
+        sourcePath: exp.source,
+        targetPaths: getTargetPaths(pkg.type, exp)
+      }), exp.browser?.source?.endsWith(".ts") && dtsTask2.entries.push({
+        importId,
+        exportPath: exp._path,
+        sourcePath: exp.browser.source,
+        targetPaths: getTargetPaths(pkg.type, exp.browser)
+      }), exp.node?.source?.endsWith(".ts") && dtsTask2.entries.push({
+        importId,
+        exportPath: exp._path,
+        sourcePath: exp.node.source,
+        targetPaths: getTargetPaths(pkg.type, exp.node)
+      });
+    }
+    for (const bundle of bundles)
+      if (bundle.source?.endsWith(".ts")) {
+        const exportPath = (bundle.import || bundle.require).replace(/\.[mc]?js$/, ""), importId = path__default.default.join(pkg.name, exportPath);
+        dtsTask2.entries.push({
+          importId,
+          exportPath,
+          sourcePath: bundle.source,
+          targetPaths: getTargetPaths(pkg.type, bundle)
+        });
       }
-    } : {
-      default: {
-        logLevel: "warning",
-        addToApiReportFile: !1
-      },
-      "ae-forgotten-export": {
-        /**
-         * This is hardcoded to `none` as it's no longer needed since TypeScript 5.5 https://github.com/microsoft/TypeScript/issues/42873
-         * It's hardcoded to `none` since supported by API Extractor when using `module: 'Preserve'` doesn't support it well since `@microsoft/api-extractor` v7.49.0, which upgraded from TS 5.4 to 5.7 internally
-         */
-        logLevel: "none",
-        addToApiReportFile: !1
-      },
-      "ae-incompatible-release-tags": {
-        logLevel: ruleToLogLevel("ae-incompatible-release-tags", "error"),
-        addToApiReportFile: !1
-      },
-      "ae-internal-missing-underscore": {
-        logLevel: ruleToLogLevel("ae-internal-missing-underscore"),
-        addToApiReportFile: !1
-      },
-      "ae-missing-release-tag": {
-        logLevel: ruleToLogLevel("ae-missing-release-tag", "error"),
-        addToApiReportFile: !1
-      },
-      "ae-wrong-input-file-type": {
-        logLevel: "none",
+    dtsTask2.entries.length && tasks.push(dtsTask2);
+  }
+  for (const exp of exports2) {
+    const output = exp.require;
+    output && addRollupTaskEntry("commonjs", ctx.runtime, {
+      path: exp._path,
+      source: exp.source,
+      output
+    });
+  }
+  for (const exp of exports2) {
+    const output = exp.import;
+    output && addRollupTaskEntry("esm", ctx.runtime, {
+      path: exp._path,
+      source: exp.source,
+      output
+    });
+  }
+  for (const exp of exports2) {
+    const output = exp.browser?.require;
+    output && addRollupTaskEntry("commonjs", "browser", {
+      path: exp._path,
+      source: exp.browser?.source || exp.source,
+      output
+    });
+  }
+  for (const exp of exports2) {
+    const output = exp.browser?.import;
+    output && addRollupTaskEntry("esm", "browser", {
+      path: exp._path,
+      source: exp.browser?.source || exp.source,
+      output
+    });
+  }
+  for (const bundle of bundles) {
+    const idx = bundles.indexOf(bundle);
+    bundle.require && addRollupTaskEntry("commonjs", bundle.runtime || ctx.runtime, {
+      path: `__$$bundle_cjs_${idx}$$__`,
+      source: bundle.source,
+      output: bundle.require
+    }), bundle.import && addRollupTaskEntry("esm", bundle.runtime || ctx.runtime, {
+      path: `__$$bundle_esm_${idx}$$__`,
+      source: bundle.source,
+      output: bundle.import
+    });
+  }
+  return tasks.push(...Object.values(rolldownDtsTask2)), tasks.push(...Object.values(rollupTasks)), tasks;
+}
+function createSpinner(msg) {
+  const startTime = Date.now();
+  return console.log(msg), {
+    complete: () => {
+      console.log(`${chalk__default.default.green("[success]")} ${chalk__default.default.gray(`${Date.now() - startTime}ms`)}`);
+    },
+    error: () => {
+      console.log(`${chalk__default.default.red("[error]")} ${chalk__default.default.gray(`${Date.now() - startTime}ms`)}`);
+    }
+  };
+}
+function printExtractMessages(ctx, messages) {
+  const { cwd, logger } = ctx, warnings = messages.filter((msg) => msg.logLevel === "warning");
+  warnings.length && logger.log();
+  for (const msg of warnings) {
+    const sourceFilePath = msg.sourceFilePath && path__default.default.relative(cwd, msg.sourceFilePath);
+    msg.messageId !== "TS6307" && logger.log(
+      [
+        `${chalk__default.default.cyan(sourceFilePath || "?")}`,
+        `:${chalk__default.default.yellow(msg.sourceFileLine)}:${chalk__default.default.yellow(msg.sourceFileColumn)}`,
+        ` - ${chalk__default.default.yellow("warning")} ${chalk__default.default.gray(msg.messageId)}
+`,
+        msg.text,
+        `
+`
+      ].join("")
+    );
+  }
+  const errors = messages.filter((msg) => msg.logLevel === "error");
+  !warnings.length && errors.length && logger.log("");
+  for (const msg of errors) {
+    const sourceFilePath = msg.sourceFilePath && path__default.default.relative(cwd, msg.sourceFilePath);
+    logger.log(
+      [
+        `${chalk__default.default.cyan(sourceFilePath || "?")}`,
+        `:${chalk__default.default.yellow(msg.sourceFileLine)}:${chalk__default.default.yellow(msg.sourceFileColumn)}`,
+        ` - ${chalk__default.default.red("error")} ${chalk__default.default.gray(msg.messageId)}
+`,
+        msg.text,
+        `
+`
+      ].join("")
+    );
+  }
+  errors.length && process.exit(1);
+}
+var printExtractMessages$1 = /* @__PURE__ */ Object.freeze({
+  __proto__: null,
+  printExtractMessages
+});
+function printDiagnostic(options) {
+  const { cwd, logger, diagnostic } = options;
+  if (diagnostic.file && diagnostic.start) {
+    const { line, character } = ts__default.default.getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start), message = ts__default.default.flattenDiagnosticMessageText(diagnostic.messageText, `
+`), file = path__default.default.relative(cwd, diagnostic.file.fileName), output = [
+      `${chalk__default.default.yellow(file)}:${chalk__default.default.blue(line + 1)}:${chalk__default.default.blue(character + 1)} - `,
+      `${chalk__default.default.gray(`TS${diagnostic.code}:`)} ${message}`
+    ].join("");
+    diagnostic.category === ts__default.default.DiagnosticCategory.Error && logger.error(output), diagnostic.category === ts__default.default.DiagnosticCategory.Warning && logger.warn(output), diagnostic.category === ts__default.default.DiagnosticCategory.Message && logger.log(output), diagnostic.category === ts__default.default.DiagnosticCategory.Suggestion && logger.log(output);
+  } else
+    logger.log(ts__default.default.flattenDiagnosticMessageText(diagnostic.messageText, `
+`));
+}
+async function buildTypes(options) {
+  const { cwd, logger, outDir, tsconfig, strict = !1 } = options, compilerOptions = {
+    ...tsconfig.options,
+    declaration: !0,
+    declarationDir: outDir,
+    emitDeclarationOnly: !0,
+    noEmit: !1,
+    noEmitOnError: strict ? !0 : tsconfig.options.noEmitOnError ?? !0,
+    outDir
+  }, program = ts__default.default.createProgram(tsconfig.fileNames, compilerOptions), emitResult = program.emit(), allDiagnostics = ts__default.default.getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
+  for (const diagnostic of allDiagnostics)
+    printDiagnostic({ cwd, logger, diagnostic });
+  if (emitResult.emitSkipped && allDiagnostics.filter((diag) => diag.category === ts__default.default.DiagnosticCategory.Error).length)
+    throw new Error("failed to compile TypeScript definitions");
+}
+class DtsError extends Error {
+  messages;
+  constructor(message, messages) {
+    super(message), this.messages = messages;
+  }
+}
+function createApiExtractorConfig(options) {
+  const {
+    bundledPackages,
+    distPath,
+    exportPath,
+    filePath,
+    messages,
+    projectFolder,
+    mainEntryPointFilePath,
+    tsconfig,
+    tsconfigPath,
+    dtsRollupEnabled
+  } = options;
+  return {
+    apiReport: {
+      enabled: !1,
+      reportFileName: "<unscopedPackageName>.api.md"
+    },
+    bundledPackages,
+    // If `paths` are used for self-referencing imports (e.g. the module is named `sanity`, and the `sanity/structure` export is also importing from `sanity/router`),
+    compiler: tsconfig.options.paths ? {
+      overrideTsconfig: {
+        extends: tsconfigPath,
+        compilerOptions: {
+          // An empty object replaces whatever is in the original tsconfig file
+          paths: {}
+        }
+      }
+    } : { tsconfigFilePath: tsconfigPath },
+    docModel: {
+      enabled: !1,
+      apiJsonFilePath: path__default.default.resolve(distPath, `${exportPath}.api.json`)
+    },
+    dtsRollup: {
+      enabled: dtsRollupEnabled,
+      untrimmedFilePath: path__default.default.resolve(distPath, filePath)
+      // betaTrimmedFilePath: path.resolve(distPath, filePath.replace('.d.ts', '-beta.d.ts')),
+      // publicTrimmedFilePath: path.resolve(distPath, filePath.replace('.d.ts', '-public.d.ts')),
+    },
+    tsdocMetadata: {
+      enabled: !1
+    },
+    messages,
+    mainEntryPointFilePath,
+    projectFolder
+  };
+}
+var createApiExtractorConfig$1 = /* @__PURE__ */ Object.freeze({
+  __proto__: null,
+  createApiExtractorConfig
+});
+const require$1 = node_module.createRequire(typeof document > "u" ? require("url").pathToFileURL(__filename).href : _documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === "SCRIPT" && _documentCurrentScript.src || new URL("_chunks-cjs/index.cjs", document.baseURI).href);
+async function createTSDocConfig(opts) {
+  const { customTags } = opts;
+  if (customTags.length === 0)
+    return;
+  const tsDocBaseBuf = await fs.readFile(
+    require$1.resolve("@microsoft/api-extractor/extends/tsdoc-base.json")
+  ), tsDocBaseConfig = jsoncParser.parse(tsDocBaseBuf.toString()), tagDefinitions = (tsDocBaseConfig.tagDefinitions || []).concat(
+    customTags.map((t) => ({
+      tagName: `@${t.name}`,
+      syntaxKind: t.syntaxKind,
+      allowMultiple: t.allowMultiple
+    }))
+  ), supportForTags = { ...tsDocBaseConfig.supportForTags };
+  for (const customTag of customTags)
+    supportForTags[`@${customTag.name}`] = !0;
+  return tsdocConfig.TSDocConfigFile.loadFromObject({
+    ...tsDocBaseConfig,
+    noStandardTags: !1,
+    tagDefinitions,
+    supportForTags
+  });
+}
+var createTSDocConfig$1 = /* @__PURE__ */ Object.freeze({
+  __proto__: null,
+  createTSDocConfig
+});
+async function extractModuleBlocksFromTypes({
+  tsOutDir,
+  extractResult
+}) {
+  const program = extractResult.compilerState.program, moduleBlocks = [], sourceFiles = [...program.getSourceFiles()].filter((sourceFile) => sourceFile.fileName.includes(tsOutDir));
+  for (const sourceFile of sourceFiles)
+    sourceFile.text.includes("declare module") && moduleBlocks.push(...extractModuleBlocks(sourceFile.text));
+  return moduleBlocks;
+}
+function extractModuleBlocks(fileContent) {
+  return recast.parse(fileContent, {
+    parser: typeScriptParser__default.default
+  }).program.body.filter((node2) => node2.type === "TSModuleDeclaration").map((node2) => recast.print(node2).code);
+}
+const LOG_LEVELS = {
+  error: "error",
+  info: "info",
+  off: "none",
+  warn: "warning"
+};
+function getExtractMessagesConfig(options) {
+  const { rules, disabled = !1 } = options;
+  function ruleToLogLevel(key, defaultLevel) {
+    const r = rules?.[key];
+    return r ? LOG_LEVELS[r] : defaultLevel || "warning";
+  }
+  return {
+    compilerMessageReporting: {
+      default: {
+        logLevel: disabled ? "none" : "warning"
+      }
+    },
+    extractorMessageReporting: disabled ? {
+      default: {
+        logLevel: "none",
+        addToApiReportFile: !1
+      }
+    } : {
+      default: {
+        logLevel: "warning",
+        addToApiReportFile: !1
+      },
+      "ae-forgotten-export": {
+        /**
+         * This is hardcoded to `none` as it's no longer needed since TypeScript 5.5 https://github.com/microsoft/TypeScript/issues/42873
+         * It's hardcoded to `none` since supported by API Extractor when using `module: 'Preserve'` doesn't support it well since `@microsoft/api-extractor` v7.49.0, which upgraded from TS 5.4 to 5.7 internally
+         */
+        logLevel: "none",
+        addToApiReportFile: !1
+      },
+      "ae-incompatible-release-tags": {
+        logLevel: ruleToLogLevel("ae-incompatible-release-tags", "error"),
+        addToApiReportFile: !1
+      },
+      "ae-internal-missing-underscore": {
+        logLevel: ruleToLogLevel("ae-internal-missing-underscore"),
+        addToApiReportFile: !1
+      },
+      "ae-missing-release-tag": {
+        logLevel: ruleToLogLevel("ae-missing-release-tag", "error"),
+        addToApiReportFile: !1
+      },
+      "ae-wrong-input-file-type": {
+        logLevel: "none",
         addToApiReportFile: !1
       }
     },
@@ -576,21 +925,1438 @@ function getExtractMessagesConfig(options) {
     }
   };
 }
-async function watch(options) {
-  const [{ resolveBuildContext }, { resolveWatchTasks }, { watchTaskHandlers }, { watchConfigFiles }] = await Promise.all([
+var getExtractMessagesConfig$1 = /* @__PURE__ */ Object.freeze({
+  __proto__: null,
+  getExtractMessagesConfig
+});
+async function extractTypes(options) {
+  const {
+    bundledPackages,
+    customTags,
+    distPath,
+    exportPath,
+    files,
+    filePaths,
+    projectPath,
+    rules,
+    sourceTypesPath,
+    tmpPath,
+    tsconfig,
+    tsconfigPath,
+    extractorDisabled
+  } = options, tsdocConfigFile = await createTSDocConfig({
+    customTags: customTags || []
+  }), filePath = filePaths[0].replace(/\.d\.[mc]ts$/, ".d.ts"), shouldCleanUpDts = !filePaths.includes(filePath), extractorConfig = apiExtractor.ExtractorConfig.prepare({
+    configObject: createApiExtractorConfig({
+      bundledPackages,
+      distPath,
+      exportPath,
+      filePath,
+      messages: getExtractMessagesConfig({ rules, disabled: extractorDisabled }),
+      projectFolder: projectPath,
+      mainEntryPointFilePath: sourceTypesPath,
+      tsconfig,
+      tsconfigPath,
+      dtsRollupEnabled: !0
+    }),
+    configObjectFullPath: void 0,
+    tsdocConfigFile,
+    packageJsonFullPath: path__default.default.resolve(projectPath, "package.json")
+  }), messages = [], extractorResult = apiExtractor.Extractor.invoke(extractorConfig, {
+    // Equivalent to the "--local" command-line parameter
+    localBuild: !0,
+    // Equivalent to the "--verbose" command-line parameter
+    showVerboseMessages: !0,
+    // handle messages
+    messageCallback(message) {
+      messages.push(message), message.handled = !0;
+    }
+  }), typesPath = path__default.default.resolve(distPath, filePath), typesBuf = await fs__default.default.readFile(typesPath), prettierConfig = await prettier__namespace.resolveConfig(typesPath);
+  await mkdirp.mkdirp(path__default.default.dirname(typesPath));
+  const moduleBlocks = await extractModuleBlocksFromTypes({
+    extractResult: extractorResult,
+    tsOutDir: tmpPath
+  }), code = [typesBuf.toString(), ...moduleBlocks].join(`
+
+`), prettyCode = await prettier__namespace.format(code, {
+    ...prettierConfig,
+    filepath: typesPath
+  });
+  for (const expFilePath of filePaths) {
+    const expTypesPath = path__default.default.resolve(distPath, expFilePath);
+    await fs__default.default.writeFile(expTypesPath, prettyCode), files.push({
+      type: "types",
+      path: expTypesPath
+    });
+  }
+  return shouldCleanUpDts && await fs__default.default.unlink(typesPath), { extractorResult, messages };
+}
+async function doExtract(ctx, task) {
+  const { config: config2, cwd, files, logger, strict, ts: ts2, bundledPackages } = ctx;
+  if (!ts2.config || !ts2.configPath)
+    return { type: "dts", messages: [], results: [] };
+  const { outDir, rootDir = cwd } = ts2.config.options;
+  if (!outDir)
+    throw new Error("tsconfig.json is missing `compilerOptions.outDir`");
+  const tmpPath = path__default.default.resolve(outDir, "__tmp__");
+  await buildTypes({ cwd, logger, outDir: tmpPath, strict, tsconfig: ts2.config });
+  const messages = [], results = [];
+  for (const entry of task.entries) {
+    const exportPath = entry.exportPath === "." ? "./index" : entry.exportPath, sourceTypesPath = path__default.default.resolve(
+      tmpPath,
+      path__default.default.relative(rootDir, path__default.default.resolve(cwd, entry.sourcePath)).replace(/\.ts$/, ".d.ts")
+    ), targetPaths = entry.targetPaths.map((targetPath) => path__default.default.resolve(cwd, targetPath)), filePaths = targetPaths.map((targetPath) => path__default.default.relative(outDir, targetPath)), result = await extractTypes({
+      bundledPackages: bundledPackages || [],
+      customTags: config2?.extract?.customTags,
+      distPath: outDir,
+      exportPath,
+      files,
+      filePaths,
+      projectPath: cwd,
+      rules: config2?.extract?.rules,
+      sourceTypesPath,
+      tsconfig: ts2.config,
+      tmpPath,
+      tsconfigPath: path__default.default.resolve(cwd, ts2.configPath || "tsconfig.json"),
+      extractorDisabled: config2?.extract?.enabled === !1
+    });
+    messages.push(...result.messages);
+    const errors = result.messages.filter((msg) => msg.logLevel === "error");
+    if (errors.length > 0)
+      throw await rimraf.rimraf(tmpPath), new DtsError(`encountered ${errors.length} errors when extracting types`, errors);
+    results.push({ sourcePath: path__default.default.resolve(cwd, entry.sourcePath), filePaths: targetPaths });
+  }
+  return await rimraf.rimraf(tmpPath), { type: "dts", messages, results };
+}
+const dtsTask = {
+  name: (ctx, task) => [
+    `Build type definitions with ${chalk__default.default.bold(ctx.dts)}...`,
+    "  entries:",
+    ...task.entries.map((entry) => entry.targetPaths.map((targetPath) => [
+      `    - ${chalk__default.default.cyan(entry.importId)}: `,
+      `${chalk__default.default.yellow(entry.sourcePath)} ${chalk__default.default.gray("\u2192")} ${chalk__default.default.yellow(targetPath)}`
+    ].join("")).join(`
+`))
+  ].join(`
+`),
+  exec: (ctx, task) => new rxjs.Observable((observer) => {
+    doExtract(ctx, task).then((result) => {
+      observer.next(result), observer.complete();
+    }).catch((err) => {
+      observer.error(err);
+    });
+  }),
+  complete: (ctx, _task, result) => {
+    printExtractMessages(ctx, result.messages);
+  },
+  error: (ctx, _task, err) => {
+    const { logger } = ctx;
+    err instanceof DtsError ? printExtractMessages(ctx, err.messages) : err instanceof Error && logger.error(err);
+  }
+}, dtsWatchTask = {
+  name: (_ctx, task) => [
+    "build type definitions",
+    ...task.entries.map((entry) => entry.targetPaths.map((targetPath) => [
+      `    - ${chalk__default.default.cyan(entry.importId)}: `,
+      `${chalk__default.default.yellow(entry.sourcePath)} ${chalk__default.default.gray("\u2192")} ${chalk__default.default.yellow(targetPath)}`
+    ].join("")))
+  ].join(`
+`),
+  exec: (ctx, task) => {
+    const { config: config2, cwd, files, logger, strict, ts: tsContext, bundledPackages } = ctx;
+    return new rxjs.Observable((observer) => {
+      if (!tsContext.config || !tsContext.configPath) {
+        observer.next({ type: "dts", messages: [], results: [] }), observer.complete();
+        return;
+      }
+      const { outDir, rootDir = cwd } = tsContext.config.options;
+      if (!outDir) {
+        observer.error(new Error("tsconfig.json is missing `compilerOptions.outDir`"));
+        return;
+      }
+      const tmpPath = path__default.default.resolve(outDir, "__tmp__");
+      buildTypes({
+        cwd,
+        logger,
+        outDir: tmpPath,
+        tsconfig: tsContext.config,
+        strict
+      }).catch((err) => {
+        observer.error(err);
+      });
+      const host = ts__default.default.createWatchCompilerHost(
+        tsContext.configPath,
+        {
+          ...tsContext.config.options,
+          declaration: !0,
+          declarationDir: tmpPath,
+          emitDeclarationOnly: !0,
+          noEmit: !1,
+          noEmitOnError: strict ? !0 : tsContext.config.options.noEmitOnError ?? !0,
+          outDir: tmpPath
+        },
+        ts__default.default.sys,
+        ts__default.default.createEmitAndSemanticDiagnosticsBuilderProgram,
+        (diagnostic) => {
+          logger.error(ts__default.default.flattenDiagnosticMessageText(diagnostic.messageText, `
+`));
+        },
+        (diagnostic) => {
+          logger.info(ts__default.default.flattenDiagnosticMessageText(diagnostic.messageText, `
+`));
+        }
+      ), origPostProgramCreate = host.afterProgramCreate;
+      host.afterProgramCreate = async (program) => {
+        origPostProgramCreate?.(program);
+        const messages = [], results = [];
+        for (const entry of task.entries) {
+          const exportPath = entry.exportPath === "." ? "./index" : entry.exportPath, sourceTypesPath = path__default.default.resolve(
+            tmpPath,
+            path__default.default.relative(rootDir, path__default.default.resolve(cwd, entry.sourcePath)).replace(/\.ts$/, ".d.ts")
+          ), targetPaths = entry.targetPaths.map((targetPath) => path__default.default.resolve(cwd, targetPath)), filePaths = targetPaths.map((targetPath) => path__default.default.relative(outDir, targetPath));
+          try {
+            const result = await extractTypes({
+              bundledPackages: bundledPackages || [],
+              customTags: config2?.extract?.customTags,
+              cwd,
+              distPath: outDir,
+              exportPath,
+              files,
+              filePaths,
+              projectPath: cwd,
+              rules: config2?.extract?.rules,
+              sourceTypesPath,
+              tsconfig: tsContext.config,
+              tmpPath,
+              tsconfigPath: path__default.default.resolve(cwd, tsContext.configPath || "tsconfig.json"),
+              extractorDisabled: config2?.extract?.enabled === !1
+            });
+            messages.push(...result.messages), results.push({ sourcePath: path__default.default.resolve(cwd, entry.sourcePath), filePaths: targetPaths });
+          } catch (err) {
+            if (err instanceof DtsError)
+              messages.push(...err.messages);
+            else {
+              observer.error(err);
+              return;
+            }
+          }
+        }
+        observer.next({ type: "dts", messages, results });
+      };
+      const watchProgram = ts__default.default.createWatchProgram(host);
+      return () => {
+        watchProgram.close(), rimraf__namespace.sync(tmpPath);
+      };
+    });
+  },
+  complete: (ctx, task, result) => {
+    const { logger } = ctx;
+    printExtractMessages(ctx, result.messages), logger.success(
+      `build type definitions
+       ${task.entries.map(
+        (entry) => `    - ${chalk__default.default.cyan(entry.importId)}: ${chalk__default.default.yellow(entry.sourcePath)} ${chalk__default.default.gray("\u2192")} ${chalk__default.default.yellow(entry.targetPaths.join(", "))}`
+      ).join(`
+       `)}`
+    ), logger.log("");
+  },
+  error: (ctx, _task, err) => {
+    const { logger } = ctx;
+    err instanceof DtsError ? printExtractMessages(ctx, err.messages) : err instanceof Error && logger.error(err);
+  }
+};
+function createConsoleSpy(options) {
+  const { onRestored } = options || {}, original = {
+    log: console.log,
+    warn: console.warn,
+    error: console.error
+  }, messages = [];
+  return console.log = (...args) => messages.push({ type: "log", args }), console.warn = (...args) => messages.push({ type: "warn", args }), console.error = (...args) => messages.push({ type: "error", args }), {
+    messages,
+    restore: () => {
+      console.log = original.log, console.warn = original.warn, console.error = original.error, onRestored?.(messages);
+    }
+  };
+}
+const rolldownDtsTask = {
+  name: (ctx, task) => {
+    const bundleEntries = task.entries.filter((e) => e.path.includes("__$$bundle_")), entries = task.entries.filter((e) => !e.path.includes("__$$bundle_")), targetLines = task.target.length ? ["  target:", ...task.target.map((t) => `    - ${chalk__default.default.yellow(t)}`)] : [], bundlesLines = bundleEntries.length ? [
+      "  bundles:",
+      ...bundleEntries.map(
+        (e) => [
+          "    - ",
+          `${chalk__default.default.yellow(e.source)} ${chalk__default.default.gray("\u2192")} ${chalk__default.default.yellow(replaceFileEnding(e.output))}`
+        ].join("")
+      )
+    ] : [], entriesLines = entries.length ? [
+      "  entries:",
+      ...entries.map(
+        (e) => [
+          "    - ",
+          `${chalk__default.default.cyan(path__default.default.join(ctx.pkg.name, e.path))}: `,
+          `${chalk__default.default.yellow(e.source)} ${chalk__default.default.gray("\u2192")} ${chalk__default.default.yellow(replaceFileEnding(e.output))}`
+        ].join("")
+      )
+    ] : [];
+    return [
+      `Build type definitions with ${chalk__default.default.bold("rolldown")}...`,
+      `  format: ${chalk__default.default.yellow(task.format)}`,
+      ...targetLines,
+      ...bundlesLines,
+      ...entriesLines
+    ].join(`
+`);
+  },
+  exec: (ctx, task) => rxjs.from(execPromise$1(ctx, task)),
+  complete: () => {
+  },
+  error: (_ctx, _task, err) => {
+    console.error(err);
+  }
+};
+async function execPromise$1(ctx, task) {
+  const [{ rolldown }, { resolveRolldownConfig }] = await Promise.all([
+    import("rolldown"),
+    Promise.resolve().then(function() {
+      return require("./resolveRolldownConfig.cjs");
+    })
+  ]), { distPath, files, logger } = ctx, outDir = path__default.default.relative(ctx.cwd, distPath), consoleSpy = createConsoleSpy({
+    onRestored: (messages) => {
+      for (const msg of messages) {
+        const text = String(msg.args[0]);
+        msg.code !== "CIRCULAR_DEPENDENCY" && (text.startsWith("Dynamic import can only") || text.startsWith("Sourcemap is likely to be incorrect") || (msg.type === "log" && logger.info(...msg.args), msg.type === "warn" && logger.warn(...msg.args), msg.type === "error" && logger.error(...msg.args)));
+      }
+    }
+  });
+  try {
+    const { inputOptions, outputOptions } = resolveRolldownConfig(ctx, task), bundle = await rolldown({
+      ...inputOptions,
+      onwarn(warning) {
+        consoleSpy.messages.push({
+          type: "warn",
+          code: warning.code,
+          args: [warning.message]
+        });
+      }
+    }), { output } = await bundle.generate(outputOptions);
+    for (const chunkOrAsset of output)
+      chunkOrAsset.type === "asset" ? files.push({
+        type: "asset",
+        path: path__default.default.resolve(outDir, chunkOrAsset.fileName)
+      }) : files.push({
+        type: "chunk",
+        path: path__default.default.resolve(outDir, chunkOrAsset.fileName)
+      });
+    await bundle.write(outputOptions), await bundle.close(), consoleSpy.restore();
+  } catch (err) {
+    throw consoleSpy.restore(), err;
+  }
+}
+function replaceFileEnding(path2) {
+  switch (!0) {
+    case path2.endsWith(".mjs"):
+      return path2.replace(/\.mjs$/, ".d.mts");
+    case path2.endsWith(".cjs"):
+      return path2.replace(/\.cjs$/, ".d.cts");
+    default:
+      return path2.replace(/\.js$/, ".d.ts");
+  }
+}
+function resolveRollupConfig(ctx, buildTask) {
+  const { format, runtime, target } = buildTask, { config: config2, cwd, exports: _exports, external, distPath, logger, pkg, ts: ts2 } = ctx, outputExt = pkgExtMap[pkg.type || "commonjs"][format], minify = config2?.minify ?? !1, outDir = path__default.default.relative(cwd, distPath), pathAliases = Object.fromEntries(
+    Object.entries(ts2.config?.options.paths || {}).map(([key, val]) => [key, path__default.default.resolve(cwd, ts2.config?.options.baseUrl || ".", val[0])])
+  ), entries = buildTask.entries.map((entry) => ({
+    ...entry,
+    name: path__default.default.relative(outDir, entry.output).replace(/\.[^/.]+$/, "")
+  }), {}), exportIds = _exports && Object.keys(_exports).map((exportPath) => path__default.default.join(pkg.name, exportPath)), sourcePaths = _exports && Object.values(_exports).map((e) => path__default.default.resolve(cwd, e.source)), replacements = Object.fromEntries(
+    Object.entries(config2?.define || {}).map(([key, val]) => [key, JSON.stringify(val)])
+  ), { optimizeLodash: enableOptimizeLodash = hasDependency(pkg, "lodash") } = config2?.rollup || {}, defaultPlugins = [
+    replace__default.default({
+      preventAssignment: !0,
+      values: pkg.name === "@sanity/pkg-utils" ? { ...replacements } : {
+        "process.env.PKG_FILE_PATH": (arg) => {
+          const sourcePath = `./${path__default.default.relative(cwd, arg)}`, entry = entries.find((e) => e.source === sourcePath);
+          return entry ? JSON.stringify(
+            path__default.default.relative(cwd, path__default.default.resolve(outDir, entry.name + outputExt))
+          ) : (console.error(`could not find source entry: ${sourcePath}`), "null");
+        },
+        "process.env.PKG_FORMAT": JSON.stringify(format),
+        "process.env.PKG_RUNTIME": JSON.stringify(runtime),
+        "process.env.PKG_VERSION": JSON.stringify(process.env.PKG_VERSION || pkg.version),
+        ...replacements
+      }
+    }),
+    alias__default.default({
+      entries: { ...pathAliases }
+    }),
+    pluginNodeResolve.nodeResolve({
+      browser: runtime === "browser",
+      extensions: [".cjs", ".mjs", ".js", ".jsx", ".json", ".node"],
+      preferBuiltins: !0
+    }),
+    commonjs__default.default(),
+    json__default.default(),
+    (config2?.babel?.reactCompiler || config2?.babel?.styledComponents) && pluginBabel.babel({
+      babelrc: !1,
+      presets: ["@babel/preset-typescript"],
+      babelHelpers: "bundled",
+      extensions: [".ts", ".tsx", ".js", ".jsx"],
+      plugins: [
+        // The styled-components plugin needs to run before the react-compiler plugin, in case the css prop is used
+        config2?.babel?.styledComponents && [
+          "babel-plugin-styled-components",
+          {
+            // Unnecessary, as the way we use styled-components in Sanity is usually by wrapping `@sanity/ui` primitives, not declaring new ones like "const Button = styled.button``"
+            fileName: !1,
+            // Native template literals take less space than this transpilation
+            transpileTemplateLiterals: !1,
+            // Massively helps dead code elimination and tree-shaking
+            pure: !0,
+            // disabled, as pkg-utils tends to be used for npm publishing, while other tooling, like `sanity dev`, `next dev`, etc are used for testing
+            cssProp: !1,
+            ...typeof config2.babel.styledComponents == "object" ? config2.babel.styledComponents : {}
+          }
+        ],
+        config2?.babel?.reactCompiler && [
+          "babel-plugin-react-compiler",
+          config2?.reactCompilerOptions || {}
+        ]
+      ].filter(Boolean)
+    }),
+    esbuild__default.default({
+      jsx: config2?.jsx ?? "automatic",
+      jsxFactory: config2?.jsxFactory ?? "createElement",
+      jsxFragment: config2?.jsxFragment ?? "Fragment",
+      jsxImportSource: config2?.jsxImportSource ?? "react",
+      target,
+      tsconfig: ctx.ts.configPath || "tsconfig.json",
+      treeShaking: !0,
+      minifySyntax: config2?.minify !== !1,
+      supported: {
+        "template-literal": !0
+      }
+    }),
+    Array.isArray(config2?.babel?.plugins) && pluginBabel.getBabelOutputPlugin({
+      babelrc: !1,
+      plugins: config2.babel.plugins
+    }),
+    enableOptimizeLodash && rollupPlugin.optimizeLodashImports({
+      useLodashEs: format === "esm" && hasDependency(pkg, "lodash-es") ? !0 : void 0,
+      ...typeof config2?.rollup?.optimizeLodash == "boolean" ? {} : config2?.rollup?.optimizeLodash
+    }),
+    minify && terser__default.default({
+      compress: { directives: !1, passes: 10 },
+      ecma: 2020,
+      output: {
+        comments: (_node, comment) => {
+          const text = comment.value;
+          return comment.type === "comment2" ? /@preserve|@license|@cc_on/i.test(text) : !1;
+        },
+        preserve_annotations: !0
+      }
+    })
+  ].filter(Boolean), userPlugins = config2?.rollup?.plugins, plugins = Array.isArray(userPlugins) ? defaultPlugins.concat(userPlugins) : resolveConfigProperty(config2?.rollup?.plugins, defaultPlugins), hashChunkFileNames = config2?.rollup?.hashChunkFileNames ?? !1, chunkFileNames = `${hashChunkFileNames ? "_chunks" : "_chunks-[format]"}/${hashChunkFileNames ? "[name]-[hash]" : "[name]"}${outputExt}`, entryFileNames = `[name]${outputExt}`;
+  return {
+    inputOptions: {
+      context: cwd,
+      external: (id, importer) => {
+        if (exportIds?.includes(id))
+          return !0;
+        if (importer && (id.startsWith(".") || id.startsWith("/"))) {
+          const idPath = path__default.default.resolve(path__default.default.dirname(importer), id);
+          if (sourcePaths?.includes(idPath))
+            return logger.warn(
+              `detected self-referencing import \u2013 treating as external: ${path__default.default.relative(
+                cwd,
+                idPath
+              )}`
+            ), !0;
+        }
+        const idParts = id.split("/"), name = idParts[0].startsWith("@") ? `${idParts[0]}/${idParts[1]}` : idParts[0];
+        return !!(name && external.includes(name));
+      },
+      input: entries.reduce(
+        (acc, entry) => Object.assign(acc, { [entry.name]: entry.source }),
+        {}
+      ),
+      watch: {
+        chokidar: {
+          usePolling: !0
+        }
+      },
+      plugins,
+      treeshake: {
+        preset: "recommended",
+        propertyReadSideEffects: !1,
+        moduleSideEffects: "no-external",
+        ...config2?.rollup?.treeshake
+      },
+      experimentalLogSideEffects: config2?.rollup?.experimentalLogSideEffects
+    },
+    outputOptions: {
+      chunkFileNames,
+      compact: minify,
+      dir: outDir,
+      entryFileNames,
+      esModule: !0,
+      format,
+      interop: "compat",
+      sourcemap: config2?.sourcemap ?? !0,
+      hoistTransitiveImports: !1,
+      minifyInternalExports: minify,
+      ...config2?.rollup?.output
+    }
+  };
+}
+function hasDependency(pkg, packageName) {
+  return pkg.dependencies ? packageName in pkg.dependencies : pkg.peerDependencies ? packageName in pkg.peerDependencies : !1;
+}
+const rollupTask = {
+  name: (ctx, task) => {
+    const bundleEntries = task.entries.filter((e) => e.path.includes("__$$bundle_")), entries = task.entries.filter((e) => !e.path.includes("__$$bundle_")), targetLines = task.target.length ? ["  target:", ...task.target.map((t) => `    - ${chalk__default.default.yellow(t)}`)] : [], bundlesLines = bundleEntries.length ? [
+      "  bundles:",
+      ...bundleEntries.map(
+        (e) => [
+          "    - ",
+          `${chalk__default.default.yellow(e.source)} ${chalk__default.default.gray("\u2192")} ${chalk__default.default.yellow(e.output)}`
+        ].join("")
+      )
+    ] : [], entriesLines = entries.length ? [
+      "  entries:",
+      ...entries.map(
+        (e) => [
+          "    - ",
+          `${chalk__default.default.cyan(path__default.default.join(ctx.pkg.name, e.path))}: `,
+          `${chalk__default.default.yellow(e.source)} ${chalk__default.default.gray("\u2192")} ${chalk__default.default.yellow(e.output)}`
+        ].join("")
+      )
+    ] : [];
+    return [
+      "Build javascript files...",
+      `  format: ${chalk__default.default.yellow(task.format)}`,
+      ...targetLines,
+      ...bundlesLines,
+      ...entriesLines
+    ].join(`
+`);
+  },
+  exec: (ctx, task) => new rxjs.Observable((observer) => {
+    execPromise(ctx, task).then((result) => {
+      observer.next(result), observer.complete();
+    }).catch((err) => observer.error(err));
+  }),
+  complete: () => {
+  },
+  error: (_ctx, _task, err) => {
+    console.error(err);
+  }
+};
+async function execPromise(ctx, task) {
+  const { distPath, files, logger } = ctx, outDir = path__default.default.relative(ctx.cwd, distPath), consoleSpy = createConsoleSpy({
+    onRestored: (messages) => {
+      for (const msg of messages) {
+        const text = String(msg.args[0]);
+        msg.code !== "CIRCULAR_DEPENDENCY" && (text.startsWith("Dynamic import can only") || text.startsWith("Sourcemap is likely to be incorrect") || (msg.type === "log" && logger.info(...msg.args), msg.type === "warn" && logger.warn(...msg.args), msg.type === "error" && logger.error(...msg.args)));
+      }
+    }
+  });
+  try {
+    const { inputOptions, outputOptions } = resolveRollupConfig(ctx, task), bundle = await rollup.rollup({
+      ...inputOptions,
+      onwarn(warning) {
+        consoleSpy.messages.push({
+          type: "warn",
+          code: warning.code,
+          args: [warning.message]
+        });
+      }
+    }), { output } = await bundle.generate(outputOptions);
+    for (const chunkOrAsset of output)
+      chunkOrAsset.type === "asset" ? files.push({
+        type: "asset",
+        path: path__default.default.resolve(outDir, chunkOrAsset.fileName)
+      }) : files.push({
+        type: "chunk",
+        path: path__default.default.resolve(outDir, chunkOrAsset.fileName)
+      });
+    await bundle.write(outputOptions), await bundle.close(), consoleSpy.restore();
+  } catch (err) {
+    throw consoleSpy.restore(), err;
+  }
+}
+const rollupWatchTask = {
+  name: (ctx, task) => `build javascript files (target ${task.target.join(" + ")}, format ${task.format})
+       ${task.entries.map((e) => `${chalk__default.default.blue(path__default.default.join(ctx.pkg.name, e.path))}: ${e.source} -> ${e.output}`).join(`
+       `)}`,
+  exec: (ctx, task) => {
+    const { inputOptions, outputOptions } = resolveRollupConfig(ctx, task);
+    return new rxjs.Observable((observer) => {
+      const watchOptions = {
+        ...inputOptions,
+        output: outputOptions
+      }, watcher = rollup.watch(watchOptions);
+      return watcher.on("event", (event) => {
+        observer.next(event);
+      }), () => {
+        watcher.close();
+      };
+    });
+  },
+  complete: (ctx, task, event) => {
+    const { logger } = ctx;
+    if (event.code === "BUNDLE_END") {
+      logger.success(
+        `build javascript files (target ${task.target.join(" + ")}, format ${task.format})
+       ${task.entries.map((e) => `${chalk__default.default.blue(path__default.default.join(ctx.pkg.name, e.path))}: ${e.source} -> ${e.output}`).join(`
+       `)}`
+      ), logger.log("");
+      return;
+    }
+    if (event.code !== "BUNDLE_START" && event.code !== "END" && event.code === "ERROR") {
+      logger.error(event.code, event);
+      return;
+    }
+  },
+  error: (ctx, _task, err) => {
+    const { logger } = ctx;
+    err instanceof Error && logger.log(err);
+  }
+}, buildTaskHandlers = {
+  "build:dts": dtsTask,
+  "build:js": rollupTask,
+  "rolldown:dts": rolldownDtsTask
+}, watchTaskHandlers = {
+  "watch:dts": dtsWatchTask,
+  "watch:js": rollupWatchTask
+};
+async function build(options) {
+  const {
+    cwd,
+    emitDeclarationOnly,
+    strict = !1,
+    tsconfig: tsconfigOption,
+    clean = !1
+  } = options, logger = createLogger(), config2 = await loadConfig({ cwd }), pkg = await loadPkgWithReporting({ cwd, logger, strict }), tsconfig = tsconfigOption || config2?.tsconfig || "tsconfig.json", ctx = await resolveBuildContext({
+    config: config2,
+    cwd,
+    emitDeclarationOnly,
+    logger,
+    pkg,
+    strict,
+    tsconfig
+  });
+  clean && (logger.log(
+    `Deleting the \`dist\` folder: './${path__default.default.relative(cwd, ctx.distPath)}' before building...`
+  ), await rimraf.rimraf(ctx.distPath));
+  const buildTasks = resolveBuildTasks(ctx);
+  for (const task of buildTasks) {
+    const handler = buildTaskHandlers[task.type], taskName = handler.name(ctx, task), spinner = createSpinner(taskName);
+    try {
+      const result = await handler.exec(ctx, task).toPromise();
+      spinner.complete(), ctx.logger.log(), handler.complete(ctx, task, result);
+    } catch (err) {
+      if (spinner.error(), err instanceof Error) {
+        const RE_CWD = new RegExp(`${cwd}`, "g");
+        ctx.logger.error(err.message.replace(RE_CWD, ".")), ctx.logger.log();
+      }
+      handler.error(ctx, task, err), process.exit(1);
+    }
+  }
+}
+function getFilesize(file) {
+  const stats = node_fs.statSync(file);
+  return prettyBytes__default.default(stats.size);
+}
+function getFileInfo(cwd, filePath) {
+  const p = path__default.default.resolve(cwd, filePath), exists = fileExists(p), size = exists ? getFilesize(p) : void 0;
+  return { exists, size };
+}
+function printPackageTree(ctx) {
+  const { cwd, exports: exports2, logger, pkg } = ctx;
+  if (!exports2) return;
+  logger.log(`${chalk__default.default.blue(pkg.name)}@${chalk__default.default.green(pkg.version)}`);
+  const tree = {};
+  pkg.type && (tree.type = chalk__default.default.yellow(pkg.type)), pkg.bin && (tree.bin = Object.fromEntries(
+    Object.entries(pkg.bin).map(([name, file]) => [chalk__default.default.cyan(name), fileInfo(file)])
+  ));
+  function fileInfo(file) {
+    const info = getFileInfo(cwd, file);
+    return info.size ? `${chalk__default.default.yellow(file)} ${chalk__default.default.gray(info.size)}` : `${chalk__default.default.gray(file)} ${chalk__default.default.red("does not exist")}`;
+  }
+  tree.exports = Object.fromEntries(
+    Object.entries(exports2).filter(([, entry]) => entry._exported).map(([exportPath, entry]) => {
+      const exp = {
+        source: fileInfo(entry.source),
+        browser: void 0,
+        require: void 0,
+        node: void 0,
+        import: void 0,
+        default: fileInfo(entry.default)
+      };
+      return entry.browser ? (exp.browser = { source: fileInfo(entry.browser.source) }, entry.browser.import && (exp.browser.import = fileInfo(entry.browser.import)), entry.browser.require && (exp.browser.require = fileInfo(entry.browser.require))) : delete exp.browser, entry.require ? exp.require = fileInfo(entry.require) : delete exp.require, entry.node ? (exp.node = {}, entry.node.source && (exp.node.source = fileInfo(entry.node.source)), entry.node.import && (exp.node.import = fileInfo(entry.node.import)), entry.node.require && (exp.node.require = fileInfo(entry.node.require))) : delete exp.node, entry.import ? exp.import = fileInfo(entry.import) : delete exp.import, [chalk__default.default.cyan(path__default.default.join(pkg.name, exportPath)), exp];
+    })
+  ), logger.log(treeify__default.default.asTree(tree, !0, !0));
+}
+async function check(options) {
+  const { cwd, strict = !1, tsconfig: tsconfigOption } = options, logger = createLogger(), spinner = createSpinner("");
+  try {
+    const config2 = await loadConfig({ cwd }), pkg = await loadPkgWithReporting({ cwd, logger, strict }), tsconfig = tsconfigOption || config2?.tsconfig || "tsconfig.json", ctx = await resolveBuildContext({ config: config2, cwd, logger, pkg, strict, tsconfig });
+    if (printPackageTree(ctx), strict) {
+      const missingFiles = [];
+      for (const [, exp] of Object.entries(ctx.exports || {}))
+        exp.source && !fileExists(path__default.default.resolve(cwd, exp.source)) && missingFiles.push(exp.source), exp.require && !fileExists(path__default.default.resolve(cwd, exp.require)) && missingFiles.push(exp.require), exp.import && !fileExists(path__default.default.resolve(cwd, exp.import)) && missingFiles.push(exp.import);
+      ctx.pkg.types && !fileExists(path__default.default.resolve(cwd, ctx.pkg.types)) && missingFiles.push(ctx.pkg.types), missingFiles.length && (logger.error(`missing files: ${missingFiles.join(", ")}`), process.exit(1));
+      const exportPaths = {
+        require: [],
+        import: []
+      };
+      for (const exp of Object.values(ctx.exports || {}))
+        exp._exported && (exp.require && exportPaths.require.push(exp.require), exp.import && exportPaths.import.push(exp.import));
+      const external = [
+        ...Object.keys(pkg.dependencies || {}),
+        ...Object.keys(pkg.devDependencies || {})
+      ], consoleSpy = createConsoleSpy();
+      exportPaths.import.length && checkExports(exportPaths.import, { cwd, external, format: "esm", logger }), exportPaths.require.length && checkExports(exportPaths.require, { cwd, external, format: "cjs", logger }), consoleSpy.restore();
+    }
+    ctx.dts === "rolldown" && ctx.config?.extract?.enabled !== !1 && await checkApiExtractorReleaseTags(ctx), spinner.complete();
+  } catch (err) {
+    if (spinner.error(), err instanceof Error) {
+      const RE_CWD = new RegExp(`${cwd}`, "g");
+      logger.error(err.message.replace(RE_CWD, ".")), logger.log();
+    }
+    process.exit(1);
+  }
+}
+async function checkExports(exportPaths, options) {
+  const { build: build2 } = await import("esbuild"), { cwd, external, format, logger } = options, code = exportPaths.map((id) => format ? `import('${id}');` : `require('${id}');`).join(`
+`);
+  try {
+    const esbuildResult = await build2({
+      bundle: !0,
+      external,
+      format,
+      logLevel: "silent",
+      // otherwise output maps to stdout as we're using stdin
+      outfile: "/dev/null",
+      platform: "node",
+      stdin: {
+        contents: code,
+        loader: "js",
+        resolveDir: cwd
+      }
+    });
+    if (esbuildResult.errors.length > 0) {
+      for (const msg of esbuildResult.errors)
+        printEsbuildMessage(logger.warn, msg), logger.log();
+      process.exit(1);
+    }
+    const esbuildWarnings = esbuildResult.warnings.filter((msg) => {
+      (msg.detail || msg.text).includes("does not affect esbuild's own target setting");
+    });
+    for (const msg of esbuildWarnings)
+      printEsbuildMessage(logger.warn, msg), logger.log();
+  } catch (err) {
+    if (isEsbuildFailure(err)) {
+      const { errors } = err;
+      for (const msg of errors)
+        printEsbuildMessage(logger.error, msg), logger.log();
+    } else err instanceof Error ? (logger.error(err.stack || err.message), logger.log()) : (logger.error(`${err}`), logger.log());
+    process.exit(1);
+  }
+}
+function printEsbuildMessage(log, msg) {
+  msg.location ? log(
+    [
+      `${msg.detail || msg.text}
+`,
+      `${msg.location.line} | ${msg.location.lineText}
+`,
+      `in ./${msg.location.file}:${msg.location.line}:${msg.location.column}`
+    ].join("")
+  ) : log(msg.detail || msg.text);
+}
+function isEsbuildFailure(err) {
+  return err instanceof Error && "errors" in err && Array.isArray(err.errors) && err.errors.every(isEsbuildMessage) && "warnings" in err && Array.isArray(err.warnings) && err.warnings.every(isEsbuildMessage);
+}
+function isEsbuildMessage(msg) {
+  return typeof msg == "object" && msg !== null && "text" in msg && typeof msg.text == "string" && "location" in msg && (msg.location === null || typeof msg.location == "object");
+}
+async function checkApiExtractorReleaseTags(ctx) {
+  const [
+    { Extractor, ExtractorConfig },
+    { createApiExtractorConfig: createApiExtractorConfig2 },
+    { createTSDocConfig: createTSDocConfig2 },
+    { getExtractMessagesConfig: getExtractMessagesConfig2 },
+    { printExtractMessages: printExtractMessages2 }
+  ] = await Promise.all([
+    import("@microsoft/api-extractor"),
     Promise.resolve().then(function() {
-      return require("./resolveBuildContext.cjs");
+      return createApiExtractorConfig$1;
     }),
     Promise.resolve().then(function() {
-      return require("./resolveWatchTasks.cjs");
+      return createTSDocConfig$1;
     }),
     Promise.resolve().then(function() {
-      return require("./index2.cjs");
+      return getExtractMessagesConfig$1;
     }),
     Promise.resolve().then(function() {
-      return require("./watchConfigFiles.cjs");
+      return printExtractMessages$1;
     })
-  ]), { cwd, strict = !1, tsconfig: tsconfigOption } = options, logger = createLogger();
+  ]), customTags = ctx.config?.extract?.customTags || [], bundledPackages = ctx.bundledPackages, distPath = ctx.distPath, outDir = ctx.ts.config?.options.outDir, rules = ctx.config?.extract?.rules || {};
+  if (!outDir)
+    throw new Error("tsconfig.json is missing `compilerOptions.outDir`");
+  for (const exp of Object.values(ctx.exports || {})) {
+    if (!exp._exported || !exp.default.endsWith(".js")) continue;
+    const dtsPath = exp.default.replace(/\.js$/, ".d.ts"), exportPath = path__default.default.resolve(ctx.cwd, dtsPath), tsdocConfigFile = await createTSDocConfig2({
+      customTags
+    }), extractorConfig = ExtractorConfig.prepare({
+      configObject: createApiExtractorConfig2({
+        bundledPackages,
+        distPath,
+        exportPath,
+        filePath: path__default.default.relative(outDir, dtsPath),
+        messages: getExtractMessagesConfig2({ rules }),
+        projectFolder: ctx.cwd,
+        mainEntryPointFilePath: exportPath,
+        tsconfig: ctx.ts.config,
+        tsconfigPath: path__default.default.resolve(ctx.cwd, ctx.ts.configPath || "tsconfig.json"),
+        dtsRollupEnabled: !1
+      }),
+      configObjectFullPath: void 0,
+      tsdocConfigFile,
+      packageJsonFullPath: path__default.default.resolve(ctx.cwd, "package.json")
+    }), messages = [];
+    Extractor.invoke(extractorConfig, {
+      // Equivalent to the "--local" command-line parameter
+      localBuild: !0,
+      // Equivalent to the "--verbose" command-line parameter
+      showVerboseMessages: !0,
+      // handle messages
+      messageCallback(message) {
+        messages.push(message), message.handled = !0;
+      }
+    }), printExtractMessages2(ctx, messages);
+  }
+}
+function defineConfig(configOptions) {
+  return configOptions;
+}
+function defineTemplateOption(option) {
+  return option;
+}
+const promptsTypes = {
+  string: "text"
+};
+async function createFromTemplate(options) {
+  const { cwd, logger, packagePath, template: templateOrResolver } = options, template = typeof templateOrResolver == "function" ? await templateOrResolver({ cwd, logger, packagePath }) : templateOrResolver;
+  logger.log("create new package at", path.relative(cwd, packagePath));
+  const templateOptions = {};
+  for (const templateOption of template.options) {
+    const templateValidate = templateOption.validate, res = await prompts__default.default(
+      {
+        type: promptsTypes[templateOption.type],
+        name: templateOption.name,
+        message: templateOption.description,
+        validate: templateValidate ? (prev) => templateValidate(prev) : void 0,
+        initial: typeof templateOption.initial == "function" ? templateOption.initial(templateOptions) : templateOption.initial
+      },
+      { onCancel: () => process.exit(0) }
+    );
+    templateOptions[templateOption.name] = templateOption.parse ? templateOption.parse(res[templateOption.name]) : res[templateOption.name];
+  }
+  const features = {};
+  for (const templateFeature of template.features) {
+    const res = templateFeature.optional ? await prompts__default.default(
+      {
+        type: "confirm",
+        name: "confirm",
+        message: `use ${templateFeature.name}?`,
+        initial: templateFeature.initial
+      },
+      { onCancel: () => process.exit(0) }
+    ) : void 0;
+    features[templateFeature.name] = res?.confirm || !templateFeature.optional;
+  }
+  const files = await template.getFiles(templateOptions, features);
+  files.sort((a, b) => a.name.localeCompare(b.name));
+  for (const file of files) {
+    const filePath = path.resolve(packagePath, file.name);
+    await mkdirp.mkdirp(path.dirname(filePath)), await fs.writeFile(filePath, file.contents.trim() + `
+`), logger.success(`wrote ${path.relative(cwd, filePath)}`);
+  }
+}
+async function isEmptyDirectory(dirPath) {
+  return (await fs.readdir(dirPath)).length === 0;
+}
+const overridableDefaults = {
+  endOfLine: "lf",
+  tabWidth: 2,
+  useTabs: !1
+}, config = {
+  ...overridableDefaults,
+  printWidth: 100,
+  semi: !1,
+  singleQuote: !0,
+  quoteProps: "consistent",
+  bracketSpacing: !1,
+  plugins: ["prettier-plugin-packagejson"],
+  overrides: [
+    {
+      files: ["*.json5"],
+      options: {
+        quoteProps: "preserve",
+        singleQuote: !1
+      }
+    },
+    {
+      files: ["*.yml"],
+      options: {
+        singleQuote: !1
+      }
+    }
+  ]
+}, RE_NAME = /^(?:@(?:[a-z0-9-*~][a-z0-9-*._~]*)\/)?[a-z0-9-~][a-z0-9-._~]*$/i, defaultTemplate = async ({ cwd, logger, packagePath }) => {
+  const gitConfig = getGitUserConfig(cwd);
+  return {
+    options: [
+      {
+        name: "repo",
+        type: "string",
+        description: "git url",
+        validate: (v) => {
+          if (!v) return !0;
+          try {
+            return gitUrlParse__default.default(v), !0;
+          } catch {
+            return "invalid git url";
+          }
+        },
+        parse: (v) => {
+          if (!v) return null;
+          const result = gitUrlParse__default.default(v);
+          return { source: result.source, owner: result.owner, name: result.name };
+        }
+      },
+      {
+        name: "pkgName",
+        type: "string",
+        description: "package name",
+        initial: (options) => options.repo?.name || void 0,
+        validate: (v) => v ? RE_NAME.exec(v) ? !0 : "invalid package name" : "package name is required",
+        parse: (v) => {
+          if (!v)
+            throw new Error("package name is required");
+          if (!RE_NAME.exec(v))
+            throw new Error("invalid package name");
+          const [scope, name] = v.split("/");
+          return { scope, name, fullName: v };
+        }
+      },
+      {
+        name: "description",
+        type: "string",
+        description: "package description"
+      },
+      {
+        name: "authorName",
+        type: "string",
+        description: "package author name",
+        initial: gitConfig.user
+      },
+      {
+        name: "authorEmail",
+        type: "string",
+        description: "package author email",
+        initial: gitConfig.email
+      },
+      {
+        name: "license",
+        type: "string",
+        description: "package license",
+        initial: "MIT",
+        validate: (v) => v ? !0 : "license is required"
+      }
+    ],
+    features: [
+      {
+        name: "eslint",
+        optional: !0,
+        initial: !0
+      },
+      {
+        name: "prettier",
+        optional: !0,
+        initial: !0
+      },
+      {
+        name: "typescript",
+        optional: !0,
+        initial: !0
+      }
+    ],
+    async getFiles(options, features) {
+      const { pkgName, repo } = options, { fullName: name } = pkgName, author = [options.authorName, options.authorEmail && `<${options.authorEmail}>`].filter(Boolean).join(" ") ?? void 0, pkgJson = {
+        name,
+        version: "0.0.0",
+        description: options.description ?? void 0,
+        keywords: [],
+        homepage: void 0,
+        bugs: void 0,
+        repository: void 0,
+        license: options.license,
+        author,
+        sideEffects: !1,
+        type: "module",
+        exports: {
+          ".": {
+            source: features.typescript ? "./src/index.ts" : "./src/index.js",
+            require: "./dist/index.cjs",
+            default: "./dist/index.js"
+          },
+          "./package.json": "./package.json"
+        },
+        main: "./dist/index.cjs",
+        module: "./dist/index.js",
+        types: void 0,
+        files: ["dist", "src"],
+        scripts: {
+          build: "pkg build --strict --clean --check",
+          format: features.prettier ? "prettier --write --cache --ignore-unknown ." : void 0
+        },
+        "lint-staged": features.prettier ? {
+          "*": ["prettier --write --cache --ignore-unknown"]
+        } : void 0,
+        browserslist: "extends @sanity/browserslist-config",
+        prettier: features.prettier ? "@sanity/prettier-config" : void 0,
+        dependencies: {},
+        devDependencies: {
+          "@sanity/pkg-utils": "^6",
+          "@sanity/prettier-config": features.prettier ? "^1" : void 0,
+          "@typescript-eslint/eslint-plugin": void 0,
+          "@typescript-eslint/parser": void 0,
+          eslint: void 0,
+          "eslint-config-prettier": void 0,
+          "eslint-plugin-import": void 0,
+          "eslint-plugin-prettier": void 0,
+          "eslint-plugin-simple-import-sort": void 0,
+          "lint-staged": "^15",
+          prettier: features.prettier ? "^3" : void 0,
+          typescript: void 0
+        },
+        engines: {
+          node: ">=18.0.0"
+        }
+      }, files = [];
+      if (files.push({
+        name: ".editorconfig",
+        contents: outdent.outdent`
+        root = true
+
+        [*]
+        charset = utf-8
+        indent_style = space
+        indent_size = 2
+        end_of_line = lf
+        insert_final_newline = true
+        trim_trailing_whitespace = true
+        `
+      }), files.push({
+        name: ".gitignore",
+        contents: outdent.outdent`
+        *.local
+        *.log
+        *.tgz
+
+        .DS_Store
+        dist
+        etc
+        node_modules
+        `
+      }), features.prettier && files.push({
+        name: ".prettierignore",
+        contents: outdent.outdent`
+          dist
+          pnpm-lock.yaml
+          `
+      }), repo && (pkgJson.repository = {
+        type: "git",
+        url: `git+ssh://git@${repo.source}/${repo.owner}/${repo.name}.git`
+      }, pkgJson.bugs = {
+        url: `https://${repo.source}/${repo.owner}/${repo.name}/issues`
+      }, pkgJson.homepage = `https://${repo.source}/${repo.owner}/${repo.name}#readme`), features.typescript) {
+        pkgJson.types = "./dist/index.d.ts", pkgJson.scripts = {
+          ...pkgJson.scripts,
+          "ts:check": "tsc --noEmit"
+        };
+        const devDependencies = pkgJson.devDependencies;
+        isRecord(devDependencies) && (devDependencies.typescript = "^5.4");
+      }
+      if (features.eslint) {
+        const eslintConfig = {
+          root: !0,
+          env: {
+            browser: !0,
+            es6: !0,
+            node: !0
+          },
+          extends: [
+            "eslint:recommended",
+            features.prettier ? "plugin:prettier/recommended" : void 0
+          ].filter(Boolean),
+          parserOptions: {
+            ecmaVersion: 2020,
+            sourceType: "module"
+          },
+          plugins: [
+            "import",
+            "simple-import-sort",
+            features.prettier ? "prettier" : void 0
+          ].filter(Boolean),
+          rules: {
+            "no-console": "error",
+            "no-shadow": "error",
+            "no-warning-comments": ["warn", { location: "start", terms: ["todo", "fixme"] }],
+            "quote-props": ["warn", "consistent-as-needed"],
+            "simple-import-sort/exports": "warn",
+            "simple-import-sort/imports": "warn",
+            strict: ["warn", "global"]
+          }
+        };
+        if (files.push({
+          name: ".eslintignore",
+          contents: outdent.outdent`
+          dist
+          `
+        }), pkgJson.scripts = {
+          ...pkgJson.scripts,
+          lint: features.typescript ? "eslint . --ext .cjs,.js,.ts,.tsx" : "eslint . --ext .cjs,.js"
+        }, pkgJson.devDependencies = {
+          ...pkgJson.devDependencies,
+          eslint: "^8",
+          "eslint-config-prettier": features.prettier ? "^9" : void 0,
+          "eslint-plugin-import": "^2",
+          "eslint-plugin-prettier": features.prettier ? "^5" : void 0,
+          "eslint-plugin-simple-import-sort": "^12"
+        }, features.typescript) {
+          pkgJson.devDependencies = {
+            ...pkgJson.devDependencies,
+            "@typescript-eslint/eslint-plugin": "^7",
+            "@typescript-eslint/parser": "^7"
+          };
+          const eslintConfigOverride = {
+            files: ["**/*.ts", "**/*.tsx"],
+            parser: "@typescript-eslint/parser",
+            parserOptions: {
+              project: ["./tsconfig.json"]
+            },
+            extends: [
+              "eslint:recommended",
+              features.prettier ? "plugin:prettier/recommended" : void 0,
+              "plugin:@typescript-eslint/eslint-recommended",
+              "plugin:@typescript-eslint/recommended"
+            ].filter(Boolean),
+            plugins: [
+              "import",
+              "@typescript-eslint",
+              "simple-import-sort",
+              features.prettier ? "prettier" : void 0
+            ].filter(Boolean),
+            rules: {
+              "@typescript-eslint/explicit-module-boundary-types": "error",
+              "@typescript-eslint/interface-name-prefix": "off",
+              "@typescript-eslint/member-delimiter-style": "off",
+              "@typescript-eslint/no-empty-interface": "off"
+            }
+          };
+          eslintConfig.overrides = [eslintConfigOverride];
+        }
+        files.push({
+          name: ".eslintrc.cjs",
+          contents: await prettierFormat(
+            path.resolve(packagePath, ".eslintrc.cjs"),
+            outdent.outdent`
+            'use strict'
+
+            /** @type import('eslint').Linter.Config */
+            module.exports = ${JSON.stringify(eslintConfig, null, 2)}
+            `,
+            config
+          )
+        });
+      }
+      features.typescript && (files.push({
+        name: "tsconfig.settings.json",
+        contents: await prettierFormat(
+          path.resolve(packagePath, "tsconfig.settings.json"),
+          outdent.outdent`
+            {
+              "extends": "@sanity/pkg-utils/tsconfig/strictest.json",
+              "compilerOptions": {
+                "rootDir": ".",
+                "outDir": "./dist"
+              }
+            }
+            `,
+          config
+        )
+      }), files.push({
+        name: "tsconfig.dist.json",
+        contents: await prettierFormat(
+          path.resolve(packagePath, "tsconfig.dist.json"),
+          outdent.outdent`
+            {
+              "extends": "./tsconfig.settings",
+              "include": ["./src"],
+              "exclude": ["./src/**/*.test.ts"]
+            }
+            `,
+          config
+        )
+      }), files.push({
+        name: "tsconfig.json",
+        contents: await prettierFormat(
+          path.resolve(packagePath, "tsconfig.json"),
+          outdent.outdent`
+            {
+              "extends": "./tsconfig.settings",
+              "include": ["./**/*.cjs", "./**/*.ts", "./**/*.tsx"],
+              "exclude": ["./node_modules"]
+            }
+            `,
+          config
+        )
+      })), features.typescript ? (files.push({
+        name: "package.config.ts",
+        contents: await prettierFormat(
+          path.resolve(packagePath, "package.config.ts"),
+          outdent.outdent`
+            import {defineConfig} from '@sanity/pkg-utils'
+
+            // https://github.com/sanity-io/pkg-utils#configuration
+            export default defineConfig({
+              // the path to the tsconfig file for distributed builds
+              tsconfig: 'tsconfig.dist.json',
+            })
+            `,
+          config
+        )
+      }), files.push({
+        name: "src/index.ts",
+        contents: await prettierFormat(
+          path.resolve(packagePath, "src/index.ts"),
+          outdent.outdent`
+            /** @public */
+            export function main(): void {
+              //
+            }
+            `,
+          config
+        )
+      })) : (files.push({
+        name: "package.config.js",
+        contents: await prettierFormat(
+          path.resolve(packagePath, "package.config.js"),
+          outdent.outdent`
+            import {defineConfig} from '@sanity/pkg-utils'
+
+            export default defineConfig({
+              extract: {
+                rules: {
+                  // do not require internal members to be prefixed with \`_\`
+                  'ae-internal-missing-underscore': 'off',
+                },
+              },
+            })
+            `,
+          config
+        )
+      }), files.push({
+        name: "src/index.js",
+        contents: await prettierFormat(
+          path.resolve(packagePath, "src/index.js"),
+          outdent.outdent`
+            /** @public */
+            export function main() {
+              //
+            }
+            `,
+          config
+        )
+      }));
+      try {
+        pkgJson.dependencies = await resolveLatestDeps(pkgJson.dependencies ?? {});
+      } catch (error) {
+        logger.warn(error instanceof Error ? error.message : error);
+      }
+      try {
+        pkgJson.devDependencies = await resolveLatestDeps(pkgJson.devDependencies ?? {});
+      } catch (error) {
+        logger.warn(error instanceof Error ? error.message : error);
+      }
+      return files.push({
+        name: "package.json",
+        contents: await prettierFormat(
+          path.resolve(packagePath, "package.json"),
+          JSON.stringify(pkgJson, null, 2),
+          config
+        )
+      }), files;
+    }
+  };
+};
+function prettierFormat(filepath, input, prettierOptions) {
+  return prettier.format(input, { ...prettierOptions, plugins: [], filepath });
+}
+async function resolveLatestDeps(deps) {
+  const depsEntries = Object.entries(deps), latestDeps = {};
+  for (const entry of depsEntries) {
+    const [name, version] = entry;
+    if (version) {
+      const latestVersion = await getLatestVersion__default.default(name, version);
+      latestDeps[name] = latestVersion ? `^${latestVersion}` : version;
+    }
+  }
+  return latestDeps;
+}
+function getGitUserConfig(cwd) {
+  let user, email;
+  try {
+    user = node_child_process.execSync("git config user.name", { encoding: "utf8", cwd }).trim() || void 0, email = node_child_process.execSync("git config user.email", { encoding: "utf8", cwd }).trim() || void 0;
+  } catch {
+  }
+  return { user, email };
+}
+async function init(options) {
+  if (!options.cwd)
+    throw new Error("Missing required option: cwd");
+  if (!options.path)
+    throw new Error("Missing required option: path");
+  const logger = createLogger(), packagePath = path.resolve(options.cwd, options.path);
+  await ensurePackagePath(packagePath), await createFromTemplate({
+    cwd: options.cwd,
+    logger,
+    template: defaultTemplate,
+    packagePath
+  });
+}
+async function ensurePackagePath(packagePath) {
+  if (!fileExists(packagePath)) {
+    await mkdirp.mkdirp(packagePath);
+    return;
+  }
+  if (!(await fs.lstat(packagePath)).isDirectory())
+    throw new Error("the package path is a file, not a directory");
+  if (!await isEmptyDirectory(packagePath))
+    throw new Error("the package directory is not empty");
+}
+function resolveWatchTasks(ctx) {
+  const { pkg, target } = ctx, tasks = [], exports2 = Object.entries(ctx.exports || {}).map(
+    ([_path, exp]) => ({ _path, ...exp })
+  ), dtsTask2 = {
+    type: "watch:dts",
+    entries: []
+  }, rollupTasks = {};
+  function addRollupTaskEntry(format, runtime, entry) {
+    const buildId = `${format}:${runtime}`;
+    rollupTasks[buildId] ? rollupTasks[buildId].entries.push(entry) : rollupTasks[buildId] = {
+      type: "watch:js",
+      buildId,
+      entries: [entry],
+      runtime,
+      format,
+      target: target[runtime]
+    };
+  }
+  for (const exp of exports2) {
+    const importId = path__default.default.join(pkg.name, exp._path);
+    exp.source?.endsWith(".ts") && dtsTask2.entries.push({
+      importId,
+      exportPath: exp._path,
+      sourcePath: exp.source,
+      targetPaths: getTargetPaths(pkg.type, exp)
+    }), exp.browser?.source?.endsWith(".ts") && dtsTask2.entries.push({
+      importId,
+      exportPath: exp._path,
+      sourcePath: exp.browser.source,
+      targetPaths: getTargetPaths(pkg.type, exp.browser)
+    }), exp.node?.source?.endsWith(".ts") && dtsTask2.entries.push({
+      importId,
+      exportPath: exp._path,
+      sourcePath: exp.node.source,
+      targetPaths: getTargetPaths(pkg.type, exp.node)
+    });
+  }
+  for (const exp of exports2) {
+    const output = exp.require;
+    output && addRollupTaskEntry("commonjs", ctx.runtime, {
+      path: exp._path,
+      source: exp.source,
+      output
+    });
+  }
+  for (const exp of exports2) {
+    const output = exp.browser?.require;
+    output && addRollupTaskEntry("commonjs", "browser", {
+      path: exp._path,
+      source: exp.browser?.source || exp.source,
+      output
+    });
+  }
+  for (const exp of exports2) {
+    const output = exp.import;
+    output && addRollupTaskEntry("esm", ctx.runtime, {
+      path: exp._path,
+      source: exp.source,
+      output
+    });
+  }
+  for (const exp of exports2) {
+    const output = exp.browser?.import;
+    output && addRollupTaskEntry("esm", "browser", {
+      path: exp._path,
+      source: exp.browser?.source || exp.source,
+      output
+    });
+  }
+  return dtsTask2.entries.length && tasks.push(dtsTask2), tasks.push(...Object.values(rollupTasks)), tasks;
+}
+function globFiles(patterns) {
+  return globby__default.default(patterns.map((pattern) => pattern.split(path__default.default.sep).join(path__default.default.posix.sep)));
+}
+function watchFiles(patterns) {
+  return new rxjs.Observable((observer) => {
+    const watcher = chokidar__namespace.watch(patterns, {
+      ignoreInitial: !0
+    });
+    function handleFileEvent(type, file) {
+      type === "error" || file instanceof Error ? observer.error(file) : observer.next({ type, file });
+    }
+    return watcher.on("all", handleFileEvent), () => {
+      watcher.off("all", handleFileEvent), watcher.close();
+    };
+  });
+}
+async function watchConfigFiles(options) {
+  const { cwd, logger } = options, initialFiles = await globFiles([
+    path__default.default.resolve(cwd, "package.json"),
+    path__default.default.resolve(cwd, "package.config.cjs"),
+    path__default.default.resolve(cwd, "package.config.js"),
+    path__default.default.resolve(cwd, "package.config.ts")
+  ]);
+  return watchFiles([
+    path__default.default.resolve(cwd, "package.json"),
+    path__default.default.resolve(cwd, "package.config.cjs"),
+    path__default.default.resolve(cwd, "package.config.js"),
+    path__default.default.resolve(cwd, "package.config.ts")
+  ]).pipe(
+    operators.scan((files, fileEvent) => fileEvent.type === "add" ? files.concat(fileEvent.file) : fileEvent.type === "unlink" ? files.filter((f) => f !== fileEvent.file) : fileEvent.type === "change" ? (logger.log(
+      "--------------------------------------------------------------------------------"
+    ), logger.info(path__default.default.relative(cwd, fileEvent.file), "changed"), logger.log(""), files.slice(0)) : files, initialFiles),
+    operators.startWith(initialFiles),
+    operators.distinctUntilChanged()
+  );
+}
+async function watch(options) {
+  const { cwd, strict = !1, tsconfig: tsconfigOption } = options, logger = createLogger();
   (await watchConfigFiles({ cwd, logger })).pipe(
     rxjs.switchMap(async (configFiles) => {
       if (!configFiles.map((f) => path__default.default.relative(cwd, f)).find((f) => f === "package.json"))
@@ -619,15 +2385,11 @@ async function watch(options) {
 exports.DEFAULT_BROWSERSLIST_QUERY = DEFAULT_BROWSERSLIST_QUERY;
 exports.build = build;
 exports.check = check;
-exports.createConsoleSpy = createConsoleSpy;
 exports.createLogger = createLogger;
 exports.defineConfig = defineConfig;
 exports.defineTemplateOption = defineTemplateOption;
-exports.fileExists = fileExists;
 exports.getExtractMessagesConfig = getExtractMessagesConfig;
-exports.getTargetPaths = getTargetPaths;
 exports.init = init;
-exports.isRecord = isRecord;
 exports.loadConfig = loadConfig;
 exports.loadPkg = loadPkg;
 exports.loadPkgWithReporting = loadPkgWithReporting;