@sanity/tsdown-config 0.20.0 → 0.21.1

package/README.md

@@ -43,6 +43,66 @@ export default defineConfig({
 })
 ```
 
+### React Server Components (`reactServer`)
+
+React Server Components refuse to load React Compiler output — `react/compiler-runtime` throws
+in the `react-server` environment, since memoization can never pay off for components that
+render exactly once. The React team's guidance for libraries that ship compiled code is to
+[publish two entrypoints](https://github.com/facebook/react/issues/31702): the compiled one for
+the client, and an uncompiled one under the `react-server` export condition.
+
+The `reactServer` option of `reactCompiler` (an option of this config, never forwarded to the
+compiler) bakes that pattern in. It's experimental (`@alpha`) and not covered by semver: it can
+change behavior or be removed entirely in a minor version.
+
+```ts
+export default defineConfig({
+  tsconfig: 'tsconfig.dist.json',
+  reactCompiler: {target: '19', reactServer: true},
+})
+```
+
+Every entry is built twice from the same source, and the only difference is that React Compiler
+auto-memoization is applied to the non-`react-server` output. The uncompiled build lands next to
+the compiled one with `.react-server` inserted before the extension (`dist/index.js` ↔
+`dist/index.react-server.js`), only the compiled build emits the `.d.ts` files, and — when the
+[`exports` feature](#exports) is enabled — every entry export gains a `react-server` condition,
+with a `types` condition specified before it (the `.react-server.` files have no declaration
+siblings, so the explicit `types` condition points every resolution mode — including consumers
+with `react-server` in their `customConditions` — at the compiled build's declarations):
+
+```json
+{
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "react-server": "./dist/index.react-server.js",
+      "default": "./dist/index.js"
+    }
+  }
+}
+```
+
+React Server Components resolve the uncompiled build, everything else (client components, SSR,
+plain Node) resolves the compiled one. The `.react-server.` files never become export subpaths of
+their own.
+
+Nothing is stripped from either output, so pair `reactServer` with deleting manual
+`useMemo`/`useCallback` calls from the source: server components stop paying for memoization
+that cannot pay off, and client components get the compiler's finer-grained auto-memoization
+instead of the hand-written hooks.
+
+`reactServer` is meant for isomorphic libraries that render in both worlds without a
+`'use client'` directive (pure renderers like `@portabletext/react`). Client-only packages that
+ship `'use client'` don't need it — they always load through the `default` condition anyway.
+Also note the general dual-entrypoint caveat: the two conditions are two module instances, so
+module-scope identity (e.g. `createContext`) is not shared between server and client trees —
+which is exactly the boundary React draws for such libraries anyway.
+
+With `reactServer` the config resolves to two tsdown configs, so the
+[isolated declarations annotation](#isolated-declarations) becomes
+`satisfies Promise<UserConfig[]>`.
+
 ## styled-components
 
 If your package uses `styled-components`, enable the same `styledComponents` transform that `@sanity/pkg-utils` has:
@@ -252,6 +312,8 @@ Without the annotation, type-checking `tsdown.config.ts` with the `@sanity/tscon
 enable `declaration`) fails with TS2883 in pnpm projects: the inferred type of the default export
 can only be named through `@sanity/tsdown-config`'s own copy of `tsdown`, which isn't portable.
 `satisfies Promise<UserConfig>` names the type through your own `tsdown` dependency instead.
+With [`reactCompiler.reactServer`](#react-server-components-reactserver) the config resolves to
+two tsdown configs, so the annotation becomes `satisfies Promise<UserConfig[]>`.
 
 Keep the `isolated-declarations` preset scoped to the tsconfig that tsdown builds with (e.g. a
 `tsconfig.dist.json` that only includes `./src`). If `isolatedDeclarations` covers

package/dist/index.d.mts

@@ -53,9 +53,43 @@ interface StyledComponentsOptions {
  * The typings resolve in userland once `babel-plugin-react-compiler` (an optional peer
  * dependency, required to use `reactCompiler`) is installed, and always match the installed
  * version of the compiler.
+ *
+ * On top of the compiler's own options, `reactServer` opts into the dual React Server
+ * Components build — it's handled by this config and never forwarded to
+ * `babel-plugin-react-compiler`.
  * @public
  */
-type ReactCompilerOptions = Partial<PluginOptions>;
+type ReactCompilerOptions = Partial<PluginOptions> & {
+  /**
+   * Also emit an uncompiled build of every entry (`<name>.react-server.js` next to `<name>.js`),
+   * wired to the `react-server` export condition in `package.json`:
+   *
+   * ```json
+   * ".": {
+   *   "types": "./dist/index.d.ts",
+   *   "react-server": "./dist/index.react-server.js",
+   *   "default": "./dist/index.js"
+   * }
+   * ```
+   *
+   * React Server Components refuse to load React Compiler output (`react/compiler-runtime`
+   * throws in the `react-server` environment), so a library that ships compiled code
+   * publishes two entrypoints: the compiled one (the `default` condition) and an uncompiled
+   * one (the `react-server` condition) — see
+   * https://github.com/facebook/react/issues/31702.
+   *
+   * Both builds come from the same source, and the only difference is that React Compiler
+   * auto-memoization is applied to the non-`react-server` output; nothing is stripped from
+   * either output. Pair it with deleting manual `useMemo`/`useCallback` calls from the
+   * source: server components stop paying for memoization that can never pay off (they
+   * render exactly once), and client components get the compiler's finer-grained
+   * memoization instead.
+   * @defaultValue false
+   * @alpha This option is experimental and not covered by semver: it can change behavior or
+   * be removed entirely in a minor version.
+   */
+  reactServer?: boolean;
+};
 /**
  * @public
  */
@@ -137,6 +171,11 @@ interface PackageOptions extends Pick<UserConfig, "tsconfig" | "entry" | "format
    * This is the same feature as the `babel: {reactCompiler: true}` and `reactCompilerOptions`
    * options in `@sanity/pkg-utils`. Unlike `styledComponents` there's no oxc native port of the
    * React Compiler yet, so `babel-plugin-react-compiler` needs to be installed.
+   *
+   * The options object also accepts `reactServer: true` (an option of this config, not the
+   * compiler), which additionally emits an uncompiled build of every entry wired to the
+   * `react-server` export condition, for libraries that render in React Server Components —
+   * see {@link ReactCompilerOptions.reactServer}.
    * @defaultValue false
    */
   reactCompiler?: boolean | ReactCompilerOptions;
@@ -167,6 +206,34 @@ interface PackageOptions extends Pick<UserConfig, "tsconfig" | "entry" | "format
    */
   vanillaExtract?: boolean | PackageVanillaExtractOptions;
 }
+/**
+ * With `reactCompiler.reactServer` the config resolves to two tsdown configs: the compiled
+ * `default` variant and the uncompiled `react-server` variant.
+ * @public
+ */
+declare function defineConfig(options: PackageOptions & {
+  reactCompiler: ReactCompilerOptions & {
+    reactServer: true;
+  };
+}): Promise<UserConfig[]>;
+/**
+ * Without `reactCompiler.reactServer` the config resolves to a single tsdown config.
+ * @public
+ */
+declare function defineConfig(options: PackageOptions & {
+  reactCompiler: ReactCompilerOptions & {
+    reactServer?: false;
+  };
+}): Promise<UserConfig>;
+/**
+ * When TypeScript can't tell whether `reactCompiler.reactServer` is set (a widened `boolean`,
+ * e.g. through a `ReactCompilerOptions`-typed variable), the config resolves to either shape —
+ * check `Array.isArray` on the result.
+ * @public
+ */
+declare function defineConfig(options: PackageOptions & {
+  reactCompiler: ReactCompilerOptions;
+}): Promise<UserConfig | UserConfig[]>;
 /**
  * @public
  */

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;KA8BY,+BAA+B;;;;;UAM1B;;EAEf;;;;;EAKA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;EACA;;EAEA;;;;;;;;;KAUU,uBAAuB,QAAQ;;;;UAK1B,uBAAuB,KACtC;;;;;;;;;;;;;EAeA,WAAW;;;;;;;;;;;;;;;;;;;EAmBX,QAAQ;;;;;;;;;;;;;;;EAeR,UAAU;;;;;;;EAOV,YAAY;;;;;;EAMZ,OAAO;;;;;;;;;;EAUP,MAAM;;;;;;;;;;EAUN,0BAA0B;;;;;;;;EAQ1B,6BAA6B;;;;;;;;;;;;;;;;;;EAkB7B,2BAA2B;;;;;iBAMP,aAAa,UAAS,iBAAsB,QAAQ"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;KAgCY,+BAA+B;;;;;UAM1B;;EAEf;;;;;EAKA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;EACA;;EAEA;;;;;;;;;;;;;KAcU,uBAAuB,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6BzC;;;;;UAMe,uBAAuB,KACtC;;;;;;;;;;;;;EAeA,WAAW;;;;;;;;;;;;;;;;;;;EAmBX,QAAQ;;;;;;;;;;;;;;;EAeR,UAAU;;;;;;;EAOV,YAAY;;;;;;EAMZ,OAAO;;;;;;;;;;EAUP,MAAM;;;;;;;;;;;;;;;EAeN,0BAA0B;;;;;;;;EAQ1B,6BAA6B;;;;;;;;;;;;;;;;;;EAkB7B,2BAA2B;;;;;;;iBAQb,aACd,SAAS;EAAkB,eAAe;IAAwB;;IACjE,QAAQ;;;;;iBAKK,aACd,SAAS;EAAkB,eAAe;IAAwB;;IACjE,QAAQ;;;;;;;iBAOK,aACd,SAAS;EAAkB,eAAe;IACzC,QAAQ,aAAa;;;;iBAIR,aAAa,UAAU,iBAAiB,QAAQ"}

package/dist/index.mjs

@@ -1,10 +1,15 @@
+import path from "node:path";
 import { detect } from "package-manager-detector/detect";
 import { defineConfig as defineConfig$1, mergeConfig } from "tsdown";
 /**
 * @public
 */
 async function defineConfig(options = {}) {
-	let { entry, tsconfig, dts, define, target, outDir, clean, css } = options, platform = options.platform ?? "neutral", sourcemap = options.sourcemap ?? !0, reactCompiler = options.reactCompiler ?? !1, styledComponents = options.styledComponents ?? !1, report = { gzip: !1 }, format = options.format ?? "esm", inputOptions = {
+	let reactCompiler = options.reactCompiler ?? !1;
+	return typeof reactCompiler == "object" && reactCompiler.reactServer === !0 ? Promise.all([resolvePackageConfig(options, "default"), resolvePackageConfig(options, "react-server")]) : resolvePackageConfig(options, "standalone");
+}
+async function resolvePackageConfig(options, variant) {
+	let { entry, tsconfig, define, target, outDir, css } = options, isReactServer = variant === "react-server", dts = !isReactServer && options.dts, clean = !isReactServer && options.clean, publint = !isReactServer, platform = options.platform ?? "neutral", sourcemap = options.sourcemap ?? !0, reactCompiler = isReactServer ? !1 : options.reactCompiler ?? !1, styledComponents = options.styledComponents ?? !1, report = { gzip: !1 }, format = options.format ?? "esm", inputOptions = {
 		preserveEntrySignatures: "strict",
 		experimental: { attachDebugInfo: "none" },
 		...platform === "neutral" && { resolve: { mainFields: ["module", "main"] } },
@@ -20,8 +25,8 @@ async function defineConfig(options = {}) {
 		...neverBundle === void 0 ? {} : { neverBundle }
 	}, plugins = [];
 	if (reactCompiler !== !1) {
-		let [{ default: pluginBabel }, { reactCompilerPreset }] = await Promise.all([import("@rolldown/plugin-babel"), import("@vitejs/plugin-react")]);
-		plugins.push(await pluginBabel({ presets: [reactCompilerPreset(typeof reactCompiler == "object" ? reactCompiler : {})] }));
+		let [{ default: pluginBabel }, { reactCompilerPreset }] = await Promise.all([import("@rolldown/plugin-babel"), import("@vitejs/plugin-react")]), { reactServer: _reactServer, ...reactCompilerOptions } = typeof reactCompiler == "object" ? reactCompiler : {};
+		plugins.push(await pluginBabel({ presets: [reactCompilerPreset(reactCompilerOptions)] }));
 	}
 	if (options.vanillaExtract) {
 		let { esbuildTargetToLightningCSS, vanillaExtractPlugin } = await import("@sanity/vanilla-extract-tsdown-plugin"), vanillaExtract = options.vanillaExtract === !0 ? {} : options.vanillaExtract, cssTarget = vanillaExtract.target ?? target, { lightningcss } = vanillaExtract;
@@ -43,10 +48,14 @@ async function defineConfig(options = {}) {
 			lightningcss
 		}));
 	}
-	let { exports } = mergeConfig({ exports: {
-		enabled: "local-only",
-		...(await detect({ cwd: process.cwd() }))?.name === "pnpm" && { devExports: !0 }
-	} }, { exports: options.exports });
+	let exports = !1;
+	if (!isReactServer) {
+		let packageManager = await detect({ cwd: process.cwd() });
+		({exports} = mergeConfig({ exports: {
+			enabled: "local-only",
+			...packageManager?.name === "pnpm" && { devExports: !0 }
+		} }, { exports: options.exports })), variant === "default" && exports && (exports = withReactServerExports(exports));
+	}
 	return defineConfig$1({
 		checks: { circularDependency: !0 },
 		clean,
@@ -59,9 +68,10 @@ async function defineConfig(options = {}) {
 		format,
 		inputOptions,
 		outDir,
+		outExtensions: isReactServer ? reactServerOutExtensions : void 0,
 		platform,
 		plugins,
-		publint: !0,
+		publint,
 		report,
 		sourcemap,
 		target,
@@ -76,6 +86,113 @@ async function defineConfig(options = {}) {
 		}
 	});
 }
+/**
+* The `outExtensions` of the `react-server` variant: tsdown's default extension for the
+* format and package type (see `resolveJsOutputExtension` in tsdown), with `.react-server` inserted
+* so the variant's entries sit next to the compiled ones (`index.js` ↔ `index.react-server.js`,
+* `index.cjs` ↔ `index.react-server.cjs`, and `.mjs` accordingly for CommonJS packages).
+*/
+const reactServerOutExtensions = ({ format, pkgType }) => ({ js: format === "cjs" ? pkgType === "module" ? ".react-server.cjs" : ".react-server.js" : pkgType === "module" ? ".react-server.js" : ".react-server.mjs" });
+/**
+* Wires the `react-server` conditions into tsdown's `exports` feature by composing into
+* `exports.customExports` (the same composition `@sanity/vanilla-extract-tsdown-plugin` uses
+* for its conditional CSS export): a pre-existing `customExports` applies first — both its
+* function and record forms, mirroring how tsdown itself applies them — and the
+* `react-server` conditions are inserted into the result. The composed function runs for both
+* the local `exports` map and `publishConfig.exports`; with `devExports` the local map points
+* at source files, which the entry-file matching leaves untouched (source resolves for every
+* condition in development, which is correct — uncompiled source is exactly what the
+* `react-server` condition ships).
+*/
+function withReactServerExports(exportsOption) {
+	let exportsOptions = exportsOption === !0 ? {} : typeof exportsOption == "string" ? { enabled: exportsOption } : exportsOption, previousCustomExports = exportsOptions.customExports;
+	return exportsOptions.customExports = async (exportsMap, context) => addReactServerConditions(typeof previousCustomExports == "function" ? await previousCustomExports(exportsMap, context) : previousCustomExports ? {
+		...exportsMap,
+		...previousCustomExports
+	} : exportsMap, context), exportsOptions;
+}
+/** Matches the JS output extensions tsdown emits for `es`/`cjs` chunks. */
+const RE_JS_FILE = /\.(m?js|cjs)$/, RUNTIME_CONDITIONS = /* @__PURE__ */ new Set([
+	"import",
+	"require",
+	"default"
+]);
+/**
+* Inserts a `react-server` condition into every entry export of an `exports`-shaped map,
+* pointing at the `.react-server.` sibling emitted by the `react-server` variant — e.g.
+* `"./dist/index.js"` becomes
+* `{"types": "./dist/index.d.ts", "react-server": "./dist/index.react-server.js", "default": "./dist/index.js"}`.
+*
+* The `react-server` variant emits no `.d.ts` siblings, so TypeScript's adjacent-file lookup
+* cannot resolve types for `./dist/index.react-server.js` — a `types` condition pointing at
+* the compiled variant's declarations is specified before `react-server` instead (conditions
+* match in order, so it covers every resolution mode). It's only added when the declarations
+* actually exist among the compiled variant's chunks, and an already-present `types`
+* condition is left in place.
+*
+* Entries are recognized by comparing export targets against the compiled variant's entry
+* chunks — reconstructed in the exact `./<outDir relative to the package root>/<fileName>`
+* form tsdown writes into the exports map, so entries that share a leaf name (`index.js` vs
+* `features/index.js`) can never shadow each other, and non-entry exports (`./package.json`,
+* the conditional `./bundle.css` export of `vanillaExtract`, `devExports` source paths like
+* `./src/index.ts`) pass through untouched. The `react-server` files themselves never enter
+* the map — the `react-server` variant builds with `exports: false` — so they don't become
+* export subpaths of their own.
+*/
+function addReactServerConditions(exportsMap, context) {
+	let pkg = context.pkg, pkgRoot = path.dirname(pkg.packageJsonPath ?? "package.json"), entryFiles = /* @__PURE__ */ new Set(), dtsFiles = /* @__PURE__ */ new Set();
+	for (let [format, formatChunks] of Object.entries(context.chunks)) if (format === "es" || format === "cjs") for (let chunk of formatChunks) {
+		if (chunk.type !== "chunk") continue;
+		let target = exportTarget(pkgRoot, chunk.outDir, chunk.fileName);
+		chunk.isEntry && RE_JS_FILE.test(chunk.fileName) ? entryFiles.add(target) : RE_DTS_FILE.test(chunk.fileName) && dtsFiles.add(target);
+	}
+	let isEntryFile = (value) => typeof value == "string" && entryFiles.has(value), dtsFor = (value) => {
+		let dtsFile = toDtsFile(value);
+		return dtsFiles.has(dtsFile) ? dtsFile : void 0;
+	}, result = {};
+	for (let [key, value] of Object.entries(exportsMap)) result[key] = withReactServerCondition(value, isEntryFile, dtsFor);
+	return result;
+}
+/**
+* Mirrors tsdown's own `join` for exports targets:
+* `./<outDir relative to the package root>/<fileName>`, with POSIX separators.
+*/
+function exportTarget(pkgRoot, outDir, fileName) {
+	let outDirRelative = path.relative(pkgRoot, outDir).replaceAll("\\", "/");
+	return `${outDirRelative ? `./${outDirRelative}` : "."}/${fileName.replaceAll("\\", "/")}`;
+}
+function withReactServerCondition(value, isEntryFile, dtsFor) {
+	if (isEntryFile(value)) {
+		let types = dtsFor(value);
+		return {
+			...types === void 0 ? {} : { types },
+			"react-server": toServerFile(value),
+			default: value
+		};
+	}
+	if (typeof value != "object" || !value || Array.isArray(value)) return value;
+	let conditions = Object.entries(value), matched = conditions.filter((entry) => RUNTIME_CONDITIONS.has(entry[0]) && isEntryFile(entry[1])), [firstMatch] = matched;
+	if (!firstMatch) return value;
+	let hasTypes = conditions.some(([condition]) => condition === "types"), missingTypes = hasTypes ? void 0 : dtsFor(firstMatch[1]), serverTarget = matched.length === 1 ? toServerFile(firstMatch[1]) : Object.fromEntries(matched.map(([condition, target]) => {
+		let types = hasTypes ? void 0 : dtsFor(target);
+		return [condition, types === void 0 ? toServerFile(target) : {
+			types,
+			default: toServerFile(target)
+		}];
+	})), next = {}, inserted = !1;
+	for (let [condition, target] of conditions) !inserted && RUNTIME_CONDITIONS.has(condition) && (matched.length === 1 && missingTypes !== void 0 && (next.types = missingTypes), next["react-server"] = serverTarget, inserted = !0), next[condition] = target;
+	return inserted || (next["react-server"] = serverTarget), next;
+}
+/** Matches the declaration file extensions tsdown emits next to `es`/`cjs` chunks. */
+const RE_DTS_FILE = /\.d\.(ts|mts|cts)$/;
+/** `./dist/index.js` → `./dist/index.react-server.js` (and `.mjs`/`.cjs` accordingly). */
+function toServerFile(file) {
+	return file.replace(RE_JS_FILE, ".react-server.$1");
+}
+/** `./dist/index.js` → `./dist/index.d.ts` (`.mjs` → `.d.mts`, `.cjs` → `.d.cts`). */
+function toDtsFile(file) {
+	return file.replace(RE_JS_FILE, (extension) => extension === ".mjs" ? ".d.mts" : extension === ".cjs" ? ".d.cts" : ".d.ts");
+}
 export { defineConfig };
 
 //# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":["defineTsdownConfig"],"sources":["../src/index.ts"],"sourcesContent":["import type {Options as VanillaExtractPluginOptions} from '@sanity/vanilla-extract-tsdown-plugin'\nimport type {PluginOptions as ReactCompilerPluginOptions} from 'babel-plugin-react-compiler'\nimport {detect} from 'package-manager-detector/detect'\nimport {\n  defineConfig as defineTsdownConfig,\n  mergeConfig,\n  type Rolldown,\n  type UserConfig,\n} from 'tsdown'\n\n/**\n * Options for the `vanillaExtract` option — the same options as\n * `@sanity/vanilla-extract-tsdown-plugin` (`identifiers`, `fileName`, `minify`, `target`,\n * `lightningcss`, and `inject`, all modeled after the `css` options of `@tsdown/css`), with\n * three Sanity-flavored defaults on top:\n *\n * - `inject` defaults to `{nodeCompat: true}` (instead of the plugin's `false`), wiring up the\n *   conditional CSS export pattern that Sanity libraries ship with. Set `inject: true` for a\n *   plain relative CSS import, or `inject: false` to only extract the CSS.\n * - `minify` defaults to `true` (instead of the plugin's `false`, which matches `css.minify`\n *   in `@tsdown/css`): published Sanity libraries ship minified CSS. Set `minify: false` for\n *   readable output.\n * - When the effective CSS syntax lowering target (`target`, falling back to the top-level\n *   `target`) is undefined or names no browsers (e.g. `'node20'`, resolved from\n *   `engines.node`), the lowering targets are resolved from `@sanity/browserslist-config` and\n *   passed through `lightningcss.targets` — where the plugin (like `@tsdown/css`) would skip\n *   lowering. `target: false` stays the explicit off switch, and a user-provided\n *   `lightningcss.targets` wins over the fallback.\n * @public\n */\nexport type PackageVanillaExtractOptions = VanillaExtractPluginOptions\n\n/**\n * Options for the `styled-components` transform, the same options as `babel-plugin-styled-components`.\n * @public\n */\nexport interface StyledComponentsOptions {\n  /** @defaultValue true */\n  displayName?: boolean\n  /**\n   * @defaultValue []\n   * @example [\"\\@xstyled/styled-components\", \"\\@xstyled/styled-components/*\"]\n   */\n  topLevelImportPaths?: string[]\n  /** @defaultValue true */\n  ssr?: boolean\n  /** @defaultValue false */\n  fileName?: boolean\n  /** @defaultValue [\"index\"] */\n  meaninglessFileNames?: string[]\n  /** @defaultValue true */\n  minify?: boolean\n  /** @defaultValue false */\n  transpileTemplateLiterals?: boolean\n  namespace?: string\n  /** @defaultValue true */\n  pure?: boolean\n}\n\n/**\n * Options for the React Compiler, the same options as `babel-plugin-react-compiler`.\n * The typings resolve in userland once `babel-plugin-react-compiler` (an optional peer\n * dependency, required to use `reactCompiler`) is installed, and always match the installed\n * version of the compiler.\n * @public\n */\nexport type ReactCompilerOptions = Partial<ReactCompilerPluginOptions>\n\n/**\n * @public\n */\nexport interface PackageOptions extends Pick<\n  UserConfig,\n  'tsconfig' | 'entry' | 'format' | 'dts' | 'define' | 'target' | 'outDir'\n> {\n  /**\n   * @defaultValue 'neutral'\n   *\n   * When left at `'neutral'` (the default), two resolution tweaks compensate for rolldown's\n   * strict neutral defaults: `deps.neverBundle` includes `/^node:/` (node built-ins stay external\n   * so neutral does not warn about them as unresolvable; only node runtimes execute those code\n   * paths), and `inputOptions.resolve.mainFields` falls back to `['module', 'main']` for inlined\n   * dependencies that ship no `exports` map (e.g. `rxjs-etc/operators`). Prefer `'neutral'` over\n   * `'node'` for packages that also run in the browser - `'node'` makes CommonJS-interop emit a\n   * module-scope `createRequire(import.meta.url)` for inlined CJS deps, which crashes\n   * browser-bundled consumers.\n   */\n  platform?: UserConfig['platform']\n  /**\n   * Clean directories before each build. Prefer an array of folders over a separate `\"clean\"`\n   * script in `package.json` (e.g. `rimraf dist coverage`) — tsdown removes them as part of\n   * `tsdown` / `pnpm build`, so packages don't need `rimraf`, a `clean` script, or\n   * `prebuild`/`run-s clean build` wiring.\n   *\n   * - `true` (tsdown's default when left undefined) cleans `outDir` (`'dist'` by default)\n   * - `false` skips cleaning\n   * - a `string[]` replaces that default with the listed paths/globs — include `outDir` (e.g.\n   *   `'dist'`) when you still want it cleaned alongside other folders\n   *\n   * @defaultValue true\n   * @example\n   * ```ts\n   * // Instead of `\"clean\": \"rimraf dist coverage\"` in package.json:\n   * clean: ['dist', 'coverage']\n   * ```\n   */\n  clean?: UserConfig['clean']\n  /**\n   * tsdown's `exports` option, with defaults suited for publishing Sanity libraries:\n   * `enabled: 'local-only'` generates the `exports` map during local builds and skips it in CI\n   * (where the committed `package.json` is already up to date). When pnpm is detected,\n   * `devExports: true` also keeps the local `exports` map pointing at source files while\n   * `publishConfig.exports` receives the built files.\n   *\n   * Userland values apply with tsdown's `mergeConfig` semantics: an object deep-merges over\n   * these defaults (so individual fields can be overridden), while any other value - `false`\n   * to disable exports generation, or a bare CI condition (`'ci-only'`/`'local-only'`) -\n   * replaces them entirely.\n   * @defaultValue `{enabled: 'local-only', devExports: true}` for pnpm projects;\n   * `{enabled: 'local-only'}` otherwise.\n   */\n  exports?: UserConfig['exports']\n  /**\n   * Whether to generate source map files. The same default as the `sourcemap` option in\n   * `@sanity/pkg-utils` - tsdown itself defaults to `false` and does not read `sourceMap` from\n   * the tsconfig.\n   * @defaultValue true\n   */\n  sourcemap?: UserConfig['sourcemap']\n  /**\n   * tsdown's `deps` option. When `platform` is `'neutral'` (the default), `neverBundle` always\n   * includes `/^node:/` and userland `neverBundle` entries are appended (tsdown's `mergeConfig`\n   * would replace the array). Other `deps` fields pass through as-is.\n   */\n  deps?: UserConfig['deps']\n  /**\n   * tsdown's experimental [`css` option](https://tsdown.dev/options/css) (CSS modules,\n   * preprocessors, Lightning CSS / PostCSS, inject, etc). Passed through as-is — requires\n   * [`@tsdown/css`](https://www.npmjs.com/package/@tsdown/css) to be installed in the project.\n   * Safe to combine with {@link PackageOptions.vanillaExtract}: vanilla-extract extracts into\n   * `bundle.css` by default, while `@tsdown/css` merges other CSS (including `.module.css`)\n   * into `style.css`, so the two pipelines do not collide.\n   * @see https://tsdown.dev/reference/api/Interface.InlineConfig#css\n   */\n  css?: UserConfig['css']\n  /**\n   * Runs `babel-plugin-react-compiler` on the source files before they are bundled, so published\n   * components are memoized automatically. Pass `true` to use the defaults, or an options object\n   * to configure the compiler (e.g. `{target: '18'}`).\n   * This is the same feature as the `babel: {reactCompiler: true}` and `reactCompilerOptions`\n   * options in `@sanity/pkg-utils`. Unlike `styledComponents` there's no oxc native port of the\n   * React Compiler yet, so `babel-plugin-react-compiler` needs to be installed.\n   * @defaultValue false\n   */\n  reactCompiler?: boolean | ReactCompilerOptions\n  /**\n   * Applies the `styled-components` transform (`displayName`, `componentId`, CSS minification, etc)\n   * with the same defaults as the `babel: {styledComponents: true}` option in `@sanity/pkg-utils`.\n   * Unlike `@sanity/pkg-utils` it doesn't use `babel-plugin-styled-components`, but oxc's native port of it,\n   * so there's no need to install babel dependencies.\n   * @defaultValue false\n   */\n  styledComponents?: boolean | StyledComponentsOptions\n  /**\n   * Enables `@sanity/vanilla-extract-tsdown-plugin` to extract CSS into a separate file,\n   * minified and lowered with `lightningcss`. The lowering targets come from the effective\n   * `target` (`vanillaExtract.target`, falling back to the top-level `target`) when it names\n   * browsers; when it's undefined or browserless (e.g. `'node20'`), they're resolved from\n   * `@sanity/browserslist-config` instead — see {@link PackageVanillaExtractOptions}. Pass\n   * `true` to use the defaults, or an object to customize.\n   *\n   * By default (`inject: {nodeCompat: true}`) the plugin also injects the self-referential\n   * `import \"<pkg>/bundle.css\"`, emits a `bundle-css.js` shim, and writes the conditional\n   * `\"./bundle.css\"` export to `package.json` - see {@link PackageVanillaExtractOptions}.\n   * This is the same feature as `rollup.vanillaExtract` in `@sanity/pkg-utils`.\n   *\n   * Combines with {@link PackageOptions.css}: enable both when a package uses vanilla-extract\n   * alongside CSS modules (or other `@tsdown/css` features).\n   * @alpha\n   */\n  vanillaExtract?: boolean | PackageVanillaExtractOptions\n}\n\n/**\n * @public\n */\nexport async function defineConfig(options: PackageOptions = {}): Promise<UserConfig> {\n  // `tsconfig`, `entry`, `dts`, `define`, `target`, `outDir`, `clean` and `css` are passed\n  // through to tsdown as-is. When left undefined, tsdown keeps its default behavior\n  // (`tsconfig` is auto-detected from the project, `dts` from `package.json`, `define`\n  // replaces nothing, `target` applies no syntax downleveling, `outDir` defaults to `'dist'`,\n  // `clean` defaults to `true` — cleaning `outDir` before each build — and `css` stays off\n  // unless `@tsdown/css` is installed and the option is set).\n  const {entry, tsconfig, dts, define, target, outDir, clean, css} = options\n  const platform = options.platform ?? 'neutral'\n  const sourcemap = options.sourcemap ?? true\n  const reactCompiler = options.reactCompiler ?? false\n  const styledComponents = options.styledComponents ?? false\n  const report = {gzip: false} as const satisfies UserConfig['report']\n  const publint = true\n  const format = options.format ?? 'esm'\n  // When `platform` is `'neutral'`, restore the conventional `module`/`main` fallback that\n  // rolldown's strict neutral defaults drop - needed for inlined deps without an `exports` map.\n  const inputOptions = {\n    // https://github.com/rolldown/rolldown/blob/main/packages/rolldown/src/options/docs/preserve-entry-signatures.md#strict\n    preserveEntrySignatures: 'strict',\n    experimental: {attachDebugInfo: 'none'},\n    ...(platform === 'neutral' && {\n      resolve: {mainFields: ['module', 'main']},\n    }),\n    ...(styledComponents !== false && {\n      transform: {\n        plugins: {\n          styledComponents: {\n            // The same defaults as `babel: {styledComponents: true}` in `@sanity/pkg-utils`:\n            // `fileName` is unnecessary, as the way we use styled-components in Sanity is usually by wrapping\n            // `@sanity/ui` primitives, not declaring new ones like \"const Button = styled.button``\"\n            fileName: false,\n            // Native template literals take less space than this transpilation, and unlike\n            // `babel-plugin-styled-components`, oxc doesn't add a `@__PURE__` annotation to the\n            // transpiled call expression either, so enabling it wouldn't improve tree-shaking\n            transpileTemplateLiterals: false,\n            // Helps dead code elimination and tree-shaking, although oxc only annotates plain call\n            // expressions so far, not tagged template expressions (https://github.com/rollup/rollup/issues/4035)\n            pure: true,\n            // Disabled, as tsdown tends to be used for npm publishing, while other tooling,\n            // like `sanity dev`, `next dev`, etc are used for testing\n            cssProp: false,\n            ...(typeof styledComponents === 'object' ? styledComponents : {}),\n          },\n        },\n      },\n    }),\n  } satisfies UserConfig['inputOptions']\n\n  // `neverBundle` is concatenated (not `mergeConfig`'d) so per-package externals add to the\n  // `/^node:/` default for `platform: 'neutral'` instead of replacing it. Rolldown's\n  // `ExternalOption` array form is `Array<string | RegExp>` only; a function override is composed.\n  const userNeverBundle = options.deps?.neverBundle\n  const nodeBuiltinExternal = platform === 'neutral' ? /^node:/ : undefined\n  const neverBundle: NonNullable<UserConfig['deps']>['neverBundle'] =\n    userNeverBundle == null\n      ? nodeBuiltinExternal && [nodeBuiltinExternal]\n      : nodeBuiltinExternal == null || userNeverBundle === true\n        ? userNeverBundle\n        : typeof userNeverBundle === 'function'\n          ? (id, importer, isResolved) =>\n              nodeBuiltinExternal.test(id) || userNeverBundle(id, importer, isResolved)\n          : Array.isArray(userNeverBundle)\n            ? [nodeBuiltinExternal, ...userNeverBundle]\n            : [nodeBuiltinExternal, userNeverBundle]\n  const deps: UserConfig['deps'] =\n    options.deps === undefined && neverBundle === undefined\n      ? undefined\n      : {\n          ...options.deps,\n          ...(neverBundle === undefined ? {} : {neverBundle}),\n        }\n\n  // `outputOptions` is left to tsdown's defaults - notably chunk filenames keep tsdown's hashed\n  // default (unless userland sets `hash`), which prevents chunk/entry filename collisions\n  // (https://github.com/sanity-io/ui/issues/2262).\n  const plugins: Rolldown.Plugin[] = []\n  if (reactCompiler !== false) {\n    // Follows the official tsdown recipe for the React Compiler:\n    // https://tsdown.dev/recipes/react-support#enabling-react-compiler\n    // The plugins are lazy loaded so they're only paid for when the React Compiler is enabled.\n    // `babel-plugin-react-compiler` itself is resolved by Babel from the consumer package during\n    // the build, which is why it can be an optional peer dependency. Once rolldown ships its rust\n    // port of the React Compiler this can be swapped out for an oxc transform, like `styledComponents`.\n    const [{default: pluginBabel}, {reactCompilerPreset}] = await Promise.all([\n      import('@rolldown/plugin-babel'),\n      import('@vitejs/plugin-react'),\n    ])\n    plugins.push(\n      await pluginBabel({\n        presets: [reactCompilerPreset(typeof reactCompiler === 'object' ? reactCompiler : {})],\n      }),\n    )\n  }\n  if (options.vanillaExtract) {\n    // Lazy loaded, like `reactCompiler`, so the CSS toolchain is only paid for when the option is\n    // enabled. The plugin compiles the `.css.ts` files and extracts the CSS into a single file.\n    // Its `inject` option is general purpose (and, like `css.inject` in `@tsdown/css`, disabled\n    // by default), so this config supplies the default most Sanity libraries want:\n    // `{nodeCompat: true}` wires up the whole conditional CSS export pattern - the\n    // self-referential CSS import, the no-op JS shim, and the conditional `./<fileName>` export\n    // written through this config's `exports` option (which the plugin's `tsdownConfig` hook\n    // composes into).\n    const {esbuildTargetToLightningCSS, vanillaExtractPlugin} =\n      await import('@sanity/vanilla-extract-tsdown-plugin')\n    const vanillaExtract = options.vanillaExtract === true ? {} : options.vanillaExtract\n\n    // The plugin follows `@tsdown/css`: without browser targets, CSS syntax lowering is\n    // skipped. The extracted CSS always runs in browsers, so when the effective target\n    // (`vanillaExtract.target`, falling back to the top-level `target`) is undefined or names\n    // no browsers (e.g. `'node20'` - also what tsdown derives from `engines.node`, which\n    // speaks to the JS runtime), this config resolves the lowering targets from\n    // `@sanity/browserslist-config` and passes them through `lightningcss.targets` instead.\n    // `target: false` stays the explicit off switch, and a user-provided\n    // `lightningcss.targets` wins over the fallback.\n    const cssTarget = vanillaExtract.target ?? target\n    let {lightningcss} = vanillaExtract\n    if (\n      cssTarget !== false &&\n      !lightningcss?.targets &&\n      (cssTarget === undefined || !esbuildTargetToLightningCSS(cssTarget))\n    ) {\n      // Lazy loaded as well: `browserslistToTargets` is a pure helper, but `lightningcss` is a\n      // native package that only needs to load when the fallback applies\n      const [{default: browserslist}, {default: browserslistConfig}, {browserslistToTargets}] =\n        await Promise.all([\n          import('browserslist'),\n          import('@sanity/browserslist-config'),\n          import('lightningcss'),\n        ])\n      lightningcss = {\n        ...lightningcss,\n        targets: browserslistToTargets(browserslist(browserslistConfig)),\n      }\n    }\n\n    plugins.push(\n      vanillaExtractPlugin({\n        inject: {nodeCompat: true},\n        minify: true,\n        ...vanillaExtract,\n        lightningcss,\n      }),\n    )\n  }\n\n  const packageManager = await detect({cwd: process.cwd()})\n  // tsdown's `exports` feature is enabled with Sanity-flavored defaults, and userland values\n  // apply with tsdown's own `mergeConfig` semantics: an object deep-merges over the defaults,\n  // anything else (`false`, a CI condition) replaces them.\n  const {exports} = mergeConfig(\n    {\n      exports: {\n        enabled: 'local-only',\n        // Only opt in by default when pnpm is detected: support for replacing package fields\n        // from `publishConfig` is not reliable across package managers.\n        ...(packageManager?.name === 'pnpm' && {devExports: true}),\n      },\n    },\n    {exports: options.exports},\n  )\n\n  return defineTsdownConfig({\n    // Rolldown defaults `circularDependency` to `false`; enable it so Sanity library builds\n    // surface import cycles (bigger bundles / execution-order hazards) as warnings.\n    // Override via `mergeConfig(..., {checks: {circularDependency: false}})`.\n    // https://rolldown.rs/reference/InputOptions.checks#circulardependency\n    checks: {circularDependency: true},\n    clean,\n    css,\n    define,\n    deps,\n    dts,\n    entry,\n    exports,\n    format,\n    inputOptions,\n    outDir,\n    platform,\n    plugins,\n    publint,\n    report,\n    sourcemap,\n    target,\n    tsconfig,\n    // Compress the output (constant folding, dead code elimination) without mangling\n    // identifiers or stripping whitespace: consumers' production builds minify `node_modules`\n    // again anyway, so full minification here would only hurt debuggability, not final app\n    // bundle sizes. `keepNames` preserves the function and class names the compress pass\n    // would otherwise strip as unreferenced - e.g. the inner name in\n    // `forwardRef(function Button(…) {…})`, which React DevTools reads via `Function.name`.\n    // That name is the tree-shakeable alternative to a top-level `Button.displayName = '…'`\n    // assignment (a side effect that pins unused components into consumer bundles, see\n    // https://github.com/sanity-io/ui/pull/2435), and names stripped at publish time are\n    // unrecoverable in userland.\n    minify: {\n      compress: {keepNames: {function: true, class: true}},\n      codegen: false,\n      mangle: false,\n    },\n  })\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.mjs","names":["defineTsdownConfig"],"sources":["../src/index.ts"],"sourcesContent":["import path from 'node:path'\nimport type {Options as VanillaExtractPluginOptions} from '@sanity/vanilla-extract-tsdown-plugin'\nimport type {PluginOptions as ReactCompilerPluginOptions} from 'babel-plugin-react-compiler'\nimport {detect} from 'package-manager-detector/detect'\nimport {\n  defineConfig as defineTsdownConfig,\n  mergeConfig,\n  type PackageJsonWithPath,\n  type Rolldown,\n  type UserConfig,\n} from 'tsdown'\n\n/**\n * Options for the `vanillaExtract` option — the same options as\n * `@sanity/vanilla-extract-tsdown-plugin` (`identifiers`, `fileName`, `minify`, `target`,\n * `lightningcss`, and `inject`, all modeled after the `css` options of `@tsdown/css`), with\n * three Sanity-flavored defaults on top:\n *\n * - `inject` defaults to `{nodeCompat: true}` (instead of the plugin's `false`), wiring up the\n *   conditional CSS export pattern that Sanity libraries ship with. Set `inject: true` for a\n *   plain relative CSS import, or `inject: false` to only extract the CSS.\n * - `minify` defaults to `true` (instead of the plugin's `false`, which matches `css.minify`\n *   in `@tsdown/css`): published Sanity libraries ship minified CSS. Set `minify: false` for\n *   readable output.\n * - When the effective CSS syntax lowering target (`target`, falling back to the top-level\n *   `target`) is undefined or names no browsers (e.g. `'node20'`, resolved from\n *   `engines.node`), the lowering targets are resolved from `@sanity/browserslist-config` and\n *   passed through `lightningcss.targets` — where the plugin (like `@tsdown/css`) would skip\n *   lowering. `target: false` stays the explicit off switch, and a user-provided\n *   `lightningcss.targets` wins over the fallback.\n * @public\n */\nexport type PackageVanillaExtractOptions = VanillaExtractPluginOptions\n\n/**\n * Options for the `styled-components` transform, the same options as `babel-plugin-styled-components`.\n * @public\n */\nexport interface StyledComponentsOptions {\n  /** @defaultValue true */\n  displayName?: boolean\n  /**\n   * @defaultValue []\n   * @example [\"\\@xstyled/styled-components\", \"\\@xstyled/styled-components/*\"]\n   */\n  topLevelImportPaths?: string[]\n  /** @defaultValue true */\n  ssr?: boolean\n  /** @defaultValue false */\n  fileName?: boolean\n  /** @defaultValue [\"index\"] */\n  meaninglessFileNames?: string[]\n  /** @defaultValue true */\n  minify?: boolean\n  /** @defaultValue false */\n  transpileTemplateLiterals?: boolean\n  namespace?: string\n  /** @defaultValue true */\n  pure?: boolean\n}\n\n/**\n * Options for the React Compiler, the same options as `babel-plugin-react-compiler`.\n * The typings resolve in userland once `babel-plugin-react-compiler` (an optional peer\n * dependency, required to use `reactCompiler`) is installed, and always match the installed\n * version of the compiler.\n *\n * On top of the compiler's own options, `reactServer` opts into the dual React Server\n * Components build — it's handled by this config and never forwarded to\n * `babel-plugin-react-compiler`.\n * @public\n */\nexport type ReactCompilerOptions = Partial<ReactCompilerPluginOptions> & {\n  /**\n   * Also emit an uncompiled build of every entry (`<name>.react-server.js` next to `<name>.js`),\n   * wired to the `react-server` export condition in `package.json`:\n   *\n   * ```json\n   * \".\": {\n   *   \"types\": \"./dist/index.d.ts\",\n   *   \"react-server\": \"./dist/index.react-server.js\",\n   *   \"default\": \"./dist/index.js\"\n   * }\n   * ```\n   *\n   * React Server Components refuse to load React Compiler output (`react/compiler-runtime`\n   * throws in the `react-server` environment), so a library that ships compiled code\n   * publishes two entrypoints: the compiled one (the `default` condition) and an uncompiled\n   * one (the `react-server` condition) — see\n   * https://github.com/facebook/react/issues/31702.\n   *\n   * Both builds come from the same source, and the only difference is that React Compiler\n   * auto-memoization is applied to the non-`react-server` output; nothing is stripped from\n   * either output. Pair it with deleting manual `useMemo`/`useCallback` calls from the\n   * source: server components stop paying for memoization that can never pay off (they\n   * render exactly once), and client components get the compiler's finer-grained\n   * memoization instead.\n   * @defaultValue false\n   * @alpha This option is experimental and not covered by semver: it can change behavior or\n   * be removed entirely in a minor version.\n   */\n  reactServer?: boolean\n}\n\n/**\n * @public\n */\nexport interface PackageOptions extends Pick<\n  UserConfig,\n  'tsconfig' | 'entry' | 'format' | 'dts' | 'define' | 'target' | 'outDir'\n> {\n  /**\n   * @defaultValue 'neutral'\n   *\n   * When left at `'neutral'` (the default), two resolution tweaks compensate for rolldown's\n   * strict neutral defaults: `deps.neverBundle` includes `/^node:/` (node built-ins stay external\n   * so neutral does not warn about them as unresolvable; only node runtimes execute those code\n   * paths), and `inputOptions.resolve.mainFields` falls back to `['module', 'main']` for inlined\n   * dependencies that ship no `exports` map (e.g. `rxjs-etc/operators`). Prefer `'neutral'` over\n   * `'node'` for packages that also run in the browser - `'node'` makes CommonJS-interop emit a\n   * module-scope `createRequire(import.meta.url)` for inlined CJS deps, which crashes\n   * browser-bundled consumers.\n   */\n  platform?: UserConfig['platform']\n  /**\n   * Clean directories before each build. Prefer an array of folders over a separate `\"clean\"`\n   * script in `package.json` (e.g. `rimraf dist coverage`) — tsdown removes them as part of\n   * `tsdown` / `pnpm build`, so packages don't need `rimraf`, a `clean` script, or\n   * `prebuild`/`run-s clean build` wiring.\n   *\n   * - `true` (tsdown's default when left undefined) cleans `outDir` (`'dist'` by default)\n   * - `false` skips cleaning\n   * - a `string[]` replaces that default with the listed paths/globs — include `outDir` (e.g.\n   *   `'dist'`) when you still want it cleaned alongside other folders\n   *\n   * @defaultValue true\n   * @example\n   * ```ts\n   * // Instead of `\"clean\": \"rimraf dist coverage\"` in package.json:\n   * clean: ['dist', 'coverage']\n   * ```\n   */\n  clean?: UserConfig['clean']\n  /**\n   * tsdown's `exports` option, with defaults suited for publishing Sanity libraries:\n   * `enabled: 'local-only'` generates the `exports` map during local builds and skips it in CI\n   * (where the committed `package.json` is already up to date). When pnpm is detected,\n   * `devExports: true` also keeps the local `exports` map pointing at source files while\n   * `publishConfig.exports` receives the built files.\n   *\n   * Userland values apply with tsdown's `mergeConfig` semantics: an object deep-merges over\n   * these defaults (so individual fields can be overridden), while any other value - `false`\n   * to disable exports generation, or a bare CI condition (`'ci-only'`/`'local-only'`) -\n   * replaces them entirely.\n   * @defaultValue `{enabled: 'local-only', devExports: true}` for pnpm projects;\n   * `{enabled: 'local-only'}` otherwise.\n   */\n  exports?: UserConfig['exports']\n  /**\n   * Whether to generate source map files. The same default as the `sourcemap` option in\n   * `@sanity/pkg-utils` - tsdown itself defaults to `false` and does not read `sourceMap` from\n   * the tsconfig.\n   * @defaultValue true\n   */\n  sourcemap?: UserConfig['sourcemap']\n  /**\n   * tsdown's `deps` option. When `platform` is `'neutral'` (the default), `neverBundle` always\n   * includes `/^node:/` and userland `neverBundle` entries are appended (tsdown's `mergeConfig`\n   * would replace the array). Other `deps` fields pass through as-is.\n   */\n  deps?: UserConfig['deps']\n  /**\n   * tsdown's experimental [`css` option](https://tsdown.dev/options/css) (CSS modules,\n   * preprocessors, Lightning CSS / PostCSS, inject, etc). Passed through as-is — requires\n   * [`@tsdown/css`](https://www.npmjs.com/package/@tsdown/css) to be installed in the project.\n   * Safe to combine with {@link PackageOptions.vanillaExtract}: vanilla-extract extracts into\n   * `bundle.css` by default, while `@tsdown/css` merges other CSS (including `.module.css`)\n   * into `style.css`, so the two pipelines do not collide.\n   * @see https://tsdown.dev/reference/api/Interface.InlineConfig#css\n   */\n  css?: UserConfig['css']\n  /**\n   * Runs `babel-plugin-react-compiler` on the source files before they are bundled, so published\n   * components are memoized automatically. Pass `true` to use the defaults, or an options object\n   * to configure the compiler (e.g. `{target: '18'}`).\n   * This is the same feature as the `babel: {reactCompiler: true}` and `reactCompilerOptions`\n   * options in `@sanity/pkg-utils`. Unlike `styledComponents` there's no oxc native port of the\n   * React Compiler yet, so `babel-plugin-react-compiler` needs to be installed.\n   *\n   * The options object also accepts `reactServer: true` (an option of this config, not the\n   * compiler), which additionally emits an uncompiled build of every entry wired to the\n   * `react-server` export condition, for libraries that render in React Server Components —\n   * see {@link ReactCompilerOptions.reactServer}.\n   * @defaultValue false\n   */\n  reactCompiler?: boolean | ReactCompilerOptions\n  /**\n   * Applies the `styled-components` transform (`displayName`, `componentId`, CSS minification, etc)\n   * with the same defaults as the `babel: {styledComponents: true}` option in `@sanity/pkg-utils`.\n   * Unlike `@sanity/pkg-utils` it doesn't use `babel-plugin-styled-components`, but oxc's native port of it,\n   * so there's no need to install babel dependencies.\n   * @defaultValue false\n   */\n  styledComponents?: boolean | StyledComponentsOptions\n  /**\n   * Enables `@sanity/vanilla-extract-tsdown-plugin` to extract CSS into a separate file,\n   * minified and lowered with `lightningcss`. The lowering targets come from the effective\n   * `target` (`vanillaExtract.target`, falling back to the top-level `target`) when it names\n   * browsers; when it's undefined or browserless (e.g. `'node20'`), they're resolved from\n   * `@sanity/browserslist-config` instead — see {@link PackageVanillaExtractOptions}. Pass\n   * `true` to use the defaults, or an object to customize.\n   *\n   * By default (`inject: {nodeCompat: true}`) the plugin also injects the self-referential\n   * `import \"<pkg>/bundle.css\"`, emits a `bundle-css.js` shim, and writes the conditional\n   * `\"./bundle.css\"` export to `package.json` - see {@link PackageVanillaExtractOptions}.\n   * This is the same feature as `rollup.vanillaExtract` in `@sanity/pkg-utils`.\n   *\n   * Combines with {@link PackageOptions.css}: enable both when a package uses vanilla-extract\n   * alongside CSS modules (or other `@tsdown/css` features).\n   * @alpha\n   */\n  vanillaExtract?: boolean | PackageVanillaExtractOptions\n}\n\n/**\n * With `reactCompiler.reactServer` the config resolves to two tsdown configs: the compiled\n * `default` variant and the uncompiled `react-server` variant.\n * @public\n */\nexport function defineConfig(\n  options: PackageOptions & {reactCompiler: ReactCompilerOptions & {reactServer: true}},\n): Promise<UserConfig[]>\n/**\n * Without `reactCompiler.reactServer` the config resolves to a single tsdown config.\n * @public\n */\nexport function defineConfig(\n  options: PackageOptions & {reactCompiler: ReactCompilerOptions & {reactServer?: false}},\n): Promise<UserConfig>\n/**\n * When TypeScript can't tell whether `reactCompiler.reactServer` is set (a widened `boolean`,\n * e.g. through a `ReactCompilerOptions`-typed variable), the config resolves to either shape —\n * check `Array.isArray` on the result.\n * @public\n */\nexport function defineConfig(\n  options: PackageOptions & {reactCompiler: ReactCompilerOptions},\n): Promise<UserConfig | UserConfig[]>\n/**\n * @public\n */\nexport function defineConfig(options?: PackageOptions): Promise<UserConfig>\n/**\n * @public\n */\nexport async function defineConfig(\n  options: PackageOptions = {},\n): Promise<UserConfig | UserConfig[]> {\n  const reactCompiler = options.reactCompiler ?? false\n  // `reactCompiler.reactServer` opts into the dual React Server Components build: the same\n  // config twice, where the only difference is that React Compiler auto-memoization is applied\n  // to the non-`react-server` variant. Both variants build in one `tsdown` run — tsdown builds\n  // the configs in parallel, cleans the shared `outDir` once before either variant emits, and\n  // runs `exports` generation and `publint` per `package.json` only after every build for that\n  // package has finished (so the `react-server` files exist by the time they're validated).\n  if (typeof reactCompiler === 'object' && reactCompiler.reactServer === true) {\n    return Promise.all([\n      resolvePackageConfig(options, 'default'),\n      resolvePackageConfig(options, 'react-server'),\n    ])\n  }\n  return resolvePackageConfig(options, 'standalone')\n}\n\n/**\n * The build variants {@link defineConfig} produces: the classic single build\n * (`'standalone'`), or — with `reactCompiler.reactServer` — the compiled `'default'` variant\n * and the uncompiled `'react-server'` variant of the dual React Server Components build.\n */\ntype PackageConfigVariant = 'standalone' | 'default' | 'react-server'\n\nasync function resolvePackageConfig(\n  options: PackageOptions,\n  variant: PackageConfigVariant,\n): Promise<UserConfig> {\n  // `tsconfig`, `entry`, `dts`, `define`, `target`, `outDir`, `clean` and `css` are passed\n  // through to tsdown as-is. When left undefined, tsdown keeps its default behavior\n  // (`tsconfig` is auto-detected from the project, `dts` from `package.json`, `define`\n  // replaces nothing, `target` applies no syntax downleveling, `outDir` defaults to `'dist'`,\n  // `clean` defaults to `true` — cleaning `outDir` before each build — and `css` stays off\n  // unless `@tsdown/css` is installed and the option is set).\n  const {entry, tsconfig, define, target, outDir, css} = options\n  const isReactServer = variant === 'react-server'\n  // The `react-server` variant skips d.ts generation (the compiled variant's declarations\n  // serve both entries — a `types` condition specified before `react-server` points every\n  // resolution mode at them), never cleans (tsdown collects the clean paths of all configs\n  // and cleans once, before either variant emits, so the compiled variant's `clean` already\n  // covers the run), and skips `publint` (it runs once, from the compiled variant, after\n  // both builds finish).\n  const dts = isReactServer ? false : options.dts\n  const clean = isReactServer ? false : options.clean\n  const publint = !isReactServer\n  const platform = options.platform ?? 'neutral'\n  const sourcemap = options.sourcemap ?? true\n  // The React Compiler is what the `react-server` variant exists to avoid: compiled output\n  // loads `react/compiler-runtime`, which throws in the `react-server` environment.\n  const reactCompiler = isReactServer ? false : (options.reactCompiler ?? false)\n  const styledComponents = options.styledComponents ?? false\n  const report = {gzip: false} as const satisfies UserConfig['report']\n  const format = options.format ?? 'esm'\n  // When `platform` is `'neutral'`, restore the conventional `module`/`main` fallback that\n  // rolldown's strict neutral defaults drop - needed for inlined deps without an `exports` map.\n  const inputOptions = {\n    // https://github.com/rolldown/rolldown/blob/main/packages/rolldown/src/options/docs/preserve-entry-signatures.md#strict\n    preserveEntrySignatures: 'strict',\n    experimental: {attachDebugInfo: 'none'},\n    ...(platform === 'neutral' && {\n      resolve: {mainFields: ['module', 'main']},\n    }),\n    ...(styledComponents !== false && {\n      transform: {\n        plugins: {\n          styledComponents: {\n            // The same defaults as `babel: {styledComponents: true}` in `@sanity/pkg-utils`:\n            // `fileName` is unnecessary, as the way we use styled-components in Sanity is usually by wrapping\n            // `@sanity/ui` primitives, not declaring new ones like \"const Button = styled.button``\"\n            fileName: false,\n            // Native template literals take less space than this transpilation, and unlike\n            // `babel-plugin-styled-components`, oxc doesn't add a `@__PURE__` annotation to the\n            // transpiled call expression either, so enabling it wouldn't improve tree-shaking\n            transpileTemplateLiterals: false,\n            // Helps dead code elimination and tree-shaking, although oxc only annotates plain call\n            // expressions so far, not tagged template expressions (https://github.com/rollup/rollup/issues/4035)\n            pure: true,\n            // Disabled, as tsdown tends to be used for npm publishing, while other tooling,\n            // like `sanity dev`, `next dev`, etc are used for testing\n            cssProp: false,\n            ...(typeof styledComponents === 'object' ? styledComponents : {}),\n          },\n        },\n      },\n    }),\n  } satisfies UserConfig['inputOptions']\n\n  // `neverBundle` is concatenated (not `mergeConfig`'d) so per-package externals add to the\n  // `/^node:/` default for `platform: 'neutral'` instead of replacing it. Rolldown's\n  // `ExternalOption` array form is `Array<string | RegExp>` only; a function override is composed.\n  const userNeverBundle = options.deps?.neverBundle\n  const nodeBuiltinExternal = platform === 'neutral' ? /^node:/ : undefined\n  const neverBundle: NonNullable<UserConfig['deps']>['neverBundle'] =\n    userNeverBundle == null\n      ? nodeBuiltinExternal && [nodeBuiltinExternal]\n      : nodeBuiltinExternal == null || userNeverBundle === true\n        ? userNeverBundle\n        : typeof userNeverBundle === 'function'\n          ? (id, importer, isResolved) =>\n              nodeBuiltinExternal.test(id) || userNeverBundle(id, importer, isResolved)\n          : Array.isArray(userNeverBundle)\n            ? [nodeBuiltinExternal, ...userNeverBundle]\n            : [nodeBuiltinExternal, userNeverBundle]\n  const deps: UserConfig['deps'] =\n    options.deps === undefined && neverBundle === undefined\n      ? undefined\n      : {\n          ...options.deps,\n          ...(neverBundle === undefined ? {} : {neverBundle}),\n        }\n\n  // `outputOptions` is left to tsdown's defaults - notably chunk filenames keep tsdown's hashed\n  // default (unless userland sets `hash`), which prevents chunk/entry filename collisions\n  // (https://github.com/sanity-io/ui/issues/2262).\n  const plugins: Rolldown.Plugin[] = []\n  if (reactCompiler !== false) {\n    // Follows the official tsdown recipe for the React Compiler:\n    // https://tsdown.dev/recipes/react-support#enabling-react-compiler\n    // The plugins are lazy loaded so they're only paid for when the React Compiler is enabled.\n    // `babel-plugin-react-compiler` itself is resolved by Babel from the consumer package during\n    // the build, which is why it can be an optional peer dependency. Once rolldown ships its rust\n    // port of the React Compiler this can be swapped out for an oxc transform, like `styledComponents`.\n    const [{default: pluginBabel}, {reactCompilerPreset}] = await Promise.all([\n      import('@rolldown/plugin-babel'),\n      import('@vitejs/plugin-react'),\n    ])\n    // `reactServer` belongs to this config, not the compiler — drop it before handing the\n    // options over to the babel preset.\n    const {reactServer: _reactServer, ...reactCompilerOptions} =\n      typeof reactCompiler === 'object' ? reactCompiler : {}\n    plugins.push(\n      await pluginBabel({\n        presets: [reactCompilerPreset(reactCompilerOptions)],\n      }),\n    )\n  }\n  if (options.vanillaExtract) {\n    // Lazy loaded, like `reactCompiler`, so the CSS toolchain is only paid for when the option is\n    // enabled. The plugin compiles the `.css.ts` files and extracts the CSS into a single file.\n    // Its `inject` option is general purpose (and, like `css.inject` in `@tsdown/css`, disabled\n    // by default), so this config supplies the default most Sanity libraries want:\n    // `{nodeCompat: true}` wires up the whole conditional CSS export pattern - the\n    // self-referential CSS import, the no-op JS shim, and the conditional `./<fileName>` export\n    // written through this config's `exports` option (which the plugin's `tsdownConfig` hook\n    // composes into).\n    const {esbuildTargetToLightningCSS, vanillaExtractPlugin} =\n      await import('@sanity/vanilla-extract-tsdown-plugin')\n    const vanillaExtract = options.vanillaExtract === true ? {} : options.vanillaExtract\n\n    // The plugin follows `@tsdown/css`: without browser targets, CSS syntax lowering is\n    // skipped. The extracted CSS always runs in browsers, so when the effective target\n    // (`vanillaExtract.target`, falling back to the top-level `target`) is undefined or names\n    // no browsers (e.g. `'node20'` - also what tsdown derives from `engines.node`, which\n    // speaks to the JS runtime), this config resolves the lowering targets from\n    // `@sanity/browserslist-config` and passes them through `lightningcss.targets` instead.\n    // `target: false` stays the explicit off switch, and a user-provided\n    // `lightningcss.targets` wins over the fallback.\n    const cssTarget = vanillaExtract.target ?? target\n    let {lightningcss} = vanillaExtract\n    if (\n      cssTarget !== false &&\n      !lightningcss?.targets &&\n      (cssTarget === undefined || !esbuildTargetToLightningCSS(cssTarget))\n    ) {\n      // Lazy loaded as well: `browserslistToTargets` is a pure helper, but `lightningcss` is a\n      // native package that only needs to load when the fallback applies\n      const [{default: browserslist}, {default: browserslistConfig}, {browserslistToTargets}] =\n        await Promise.all([\n          import('browserslist'),\n          import('@sanity/browserslist-config'),\n          import('lightningcss'),\n        ])\n      lightningcss = {\n        ...lightningcss,\n        targets: browserslistToTargets(browserslist(browserslistConfig)),\n      }\n    }\n\n    plugins.push(\n      vanillaExtractPlugin({\n        inject: {nodeCompat: true},\n        minify: true,\n        ...vanillaExtract,\n        lightningcss,\n      }),\n    )\n  }\n\n  // The `react-server` variant does not participate in `exports` generation: its files are\n  // wired in through the compiled variant's `react-server` conditions instead of becoming\n  // export subpaths of their own.\n  let exports: UserConfig['exports'] = false\n  if (!isReactServer) {\n    const packageManager = await detect({cwd: process.cwd()})\n    // tsdown's `exports` feature is enabled with Sanity-flavored defaults, and userland values\n    // apply with tsdown's own `mergeConfig` semantics: an object deep-merges over the defaults,\n    // anything else (`false`, a CI condition) replaces them.\n    ;({exports} = mergeConfig(\n      {\n        exports: {\n          enabled: 'local-only',\n          // Only opt in by default when pnpm is detected: support for replacing package fields\n          // from `publishConfig` is not reliable across package managers.\n          ...(packageManager?.name === 'pnpm' && {devExports: true}),\n        },\n      },\n      {exports: options.exports},\n    ))\n    if (variant === 'default' && exports) {\n      // The compiled variant owns `exports` generation for the dual build, so the\n      // `react-server` conditions are composed into its `customExports`: every entry export\n      // gains a `react-server` condition pointing at the `.react-server.` sibling that the\n      // `react-server` variant emits.\n      exports = withReactServerExports(exports)\n    }\n  }\n\n  return defineTsdownConfig({\n    // Rolldown defaults `circularDependency` to `false`; enable it so Sanity library builds\n    // surface import cycles (bigger bundles / execution-order hazards) as warnings.\n    // Override via `mergeConfig(..., {checks: {circularDependency: false}})`.\n    // https://rolldown.rs/reference/InputOptions.checks#circulardependency\n    checks: {circularDependency: true},\n    clean,\n    css,\n    define,\n    deps,\n    dts,\n    entry,\n    exports,\n    format,\n    inputOptions,\n    outDir,\n    // The `react-server` variant writes its files next to the compiled ones, with `.react-server`\n    // inserted before tsdown's default extension (`index.js` ↔ `index.react-server.js`). Hashed\n    // chunk filenames get the suffix too, so the two variants' chunks never collide in the\n    // shared `outDir`.\n    outExtensions: isReactServer ? reactServerOutExtensions : undefined,\n    platform,\n    plugins,\n    publint,\n    report,\n    sourcemap,\n    target,\n    tsconfig,\n    // Compress the output (constant folding, dead code elimination) without mangling\n    // identifiers or stripping whitespace: consumers' production builds minify `node_modules`\n    // again anyway, so full minification here would only hurt debuggability, not final app\n    // bundle sizes. `keepNames` preserves the function and class names the compress pass\n    // would otherwise strip as unreferenced - e.g. the inner name in\n    // `forwardRef(function Button(…) {…})`, which React DevTools reads via `Function.name`.\n    // That name is the tree-shakeable alternative to a top-level `Button.displayName = '…'`\n    // assignment (a side effect that pins unused components into consumer bundles, see\n    // https://github.com/sanity-io/ui/pull/2435), and names stripped at publish time are\n    // unrecoverable in userland.\n    minify: {\n      compress: {keepNames: {function: true, class: true}},\n      codegen: false,\n      mangle: false,\n    },\n  })\n}\n\n/**\n * The `outExtensions` of the `react-server` variant: tsdown's default extension for the\n * format and package type (see `resolveJsOutputExtension` in tsdown), with `.react-server` inserted\n * so the variant's entries sit next to the compiled ones (`index.js` ↔ `index.react-server.js`,\n * `index.cjs` ↔ `index.react-server.cjs`, and `.mjs` accordingly for CommonJS packages).\n */\nconst reactServerOutExtensions: NonNullable<UserConfig['outExtensions']> = ({format, pkgType}) => ({\n  js:\n    format === 'cjs'\n      ? pkgType === 'module'\n        ? '.react-server.cjs'\n        : '.react-server.js'\n      : pkgType === 'module'\n        ? '.react-server.js'\n        : '.react-server.mjs',\n})\n\ntype ExportsOptions = Extract<NonNullable<UserConfig['exports']>, object>\ntype CustomExportsFunction = Extract<\n  NonNullable<ExportsOptions['customExports']>,\n  (...args: never[]) => unknown\n>\ntype ExportsMap = Parameters<CustomExportsFunction>[0]\n/**\n * Wires the `react-server` conditions into tsdown's `exports` feature by composing into\n * `exports.customExports` (the same composition `@sanity/vanilla-extract-tsdown-plugin` uses\n * for its conditional CSS export): a pre-existing `customExports` applies first — both its\n * function and record forms, mirroring how tsdown itself applies them — and the\n * `react-server` conditions are inserted into the result. The composed function runs for both\n * the local `exports` map and `publishConfig.exports`; with `devExports` the local map points\n * at source files, which the entry-file matching leaves untouched (source resolves for every\n * condition in development, which is correct — uncompiled source is exactly what the\n * `react-server` condition ships).\n */\nfunction withReactServerExports(\n  exportsOption: Exclude<NonNullable<UserConfig['exports']>, false>,\n): ExportsOptions {\n  // Normalize the `boolean | CIOption | object` forms of the `exports` option into the\n  // object form, preserving the enabled-ness (`true` and bare CI conditions mean enabled)\n  const exportsOptions: ExportsOptions =\n    exportsOption === true\n      ? {}\n      : typeof exportsOption === 'string'\n        ? {enabled: exportsOption}\n        : exportsOption\n  const previousCustomExports = exportsOptions.customExports\n  exportsOptions.customExports = async (exportsMap, context) => {\n    // Apply a pre-existing `customExports` first (both its function and record forms,\n    // mirroring how tsdown itself applies them), then insert the `react-server` conditions\n    const base =\n      typeof previousCustomExports === 'function'\n        ? await previousCustomExports(exportsMap, context)\n        : previousCustomExports\n          ? {...exportsMap, ...previousCustomExports}\n          : exportsMap\n    return addReactServerConditions(base, context)\n  }\n  return exportsOptions\n}\n\n/** Matches the JS output extensions tsdown emits for `es`/`cjs` chunks. */\nconst RE_JS_FILE = /\\.(m?js|cjs)$/\n\n/** The conditions tsdown generates that resolve at runtime, in contrast to `types` etc. */\nconst RUNTIME_CONDITIONS = new Set(['import', 'require', 'default'])\n\n/**\n * Inserts a `react-server` condition into every entry export of an `exports`-shaped map,\n * pointing at the `.react-server.` sibling emitted by the `react-server` variant — e.g.\n * `\"./dist/index.js\"` becomes\n * `{\"types\": \"./dist/index.d.ts\", \"react-server\": \"./dist/index.react-server.js\", \"default\": \"./dist/index.js\"}`.\n *\n * The `react-server` variant emits no `.d.ts` siblings, so TypeScript's adjacent-file lookup\n * cannot resolve types for `./dist/index.react-server.js` — a `types` condition pointing at\n * the compiled variant's declarations is specified before `react-server` instead (conditions\n * match in order, so it covers every resolution mode). It's only added when the declarations\n * actually exist among the compiled variant's chunks, and an already-present `types`\n * condition is left in place.\n *\n * Entries are recognized by comparing export targets against the compiled variant's entry\n * chunks — reconstructed in the exact `./<outDir relative to the package root>/<fileName>`\n * form tsdown writes into the exports map, so entries that share a leaf name (`index.js` vs\n * `features/index.js`) can never shadow each other, and non-entry exports (`./package.json`,\n * the conditional `./bundle.css` export of `vanillaExtract`, `devExports` source paths like\n * `./src/index.ts`) pass through untouched. The `react-server` files themselves never enter\n * the map — the `react-server` variant builds with `exports: false` — so they don't become\n * export subpaths of their own.\n */\nfunction addReactServerConditions(\n  exportsMap: ExportsMap,\n  context: Parameters<CustomExportsFunction>[1],\n): ExportsMap {\n  // tsdown always resolves the package with its path here: its own exports generation reads\n  // `packageJsonPath` unconditionally from the same object it passes to `customExports` -\n  // only the declared context type is the plain `PackageJson` shape.\n  const pkg: Partial<PackageJsonWithPath> = context.pkg\n  const pkgRoot = path.dirname(pkg.packageJsonPath ?? 'package.json')\n  // Export targets of the compiled variant's entry JS and declaration chunks; the\n  // `react-server` variant's files sit next to the entries with `.react-server` inserted\n  // before the extension\n  const entryFiles = new Set<string>()\n  const dtsFiles = new Set<string>()\n  for (const [format, formatChunks] of Object.entries(context.chunks)) {\n    // Only `es` and `cjs` chunks become package exports (mirroring tsdown's own generation)\n    if (format !== 'es' && format !== 'cjs') continue\n    for (const chunk of formatChunks) {\n      if (chunk.type !== 'chunk') continue\n      const target = exportTarget(pkgRoot, chunk.outDir, chunk.fileName)\n      if (chunk.isEntry && RE_JS_FILE.test(chunk.fileName)) {\n        entryFiles.add(target)\n      } else if (RE_DTS_FILE.test(chunk.fileName)) {\n        dtsFiles.add(target)\n      }\n    }\n  }\n  const isEntryFile = (value: unknown): value is string =>\n    typeof value === 'string' && entryFiles.has(value)\n  // The `types` file for an entry export target, when the compiled variant emitted it\n  const dtsFor = (value: string): string | undefined => {\n    const dtsFile = toDtsFile(value)\n    return dtsFiles.has(dtsFile) ? dtsFile : undefined\n  }\n\n  const result: ExportsMap = {}\n  for (const [key, value] of Object.entries(exportsMap as Record<string, unknown>)) {\n    result[key] = withReactServerCondition(value, isEntryFile, dtsFor)\n  }\n  return result\n}\n\n/**\n * Mirrors tsdown's own `join` for exports targets:\n * `./<outDir relative to the package root>/<fileName>`, with POSIX separators.\n */\nfunction exportTarget(pkgRoot: string, outDir: string, fileName: string): string {\n  const outDirRelative = path.relative(pkgRoot, outDir).replaceAll('\\\\', '/')\n  return `${outDirRelative ? `./${outDirRelative}` : '.'}/${fileName.replaceAll('\\\\', '/')}`\n}\n\nfunction withReactServerCondition(\n  value: unknown,\n  isEntryFile: (value: unknown) => value is string,\n  dtsFor: (value: string) => string | undefined,\n): unknown {\n  // A bare-string entry export (e.g. the pure-ESM publish shape `\".\": \"./dist/index.js\"`)\n  // becomes a conditional export, with `types` specified before `react-server` so type\n  // resolution never reaches the declaration-less `.react-server.` file\n  if (isEntryFile(value)) {\n    const types = dtsFor(value)\n    return {\n      ...(types === undefined ? {} : {types}),\n      'react-server': toServerFile(value),\n      'default': value,\n    }\n  }\n  if (typeof value !== 'object' || value === null || Array.isArray(value)) return value\n  const conditions = Object.entries(value)\n  const matched = conditions.filter(\n    (entry): entry is [string, string] => RUNTIME_CONDITIONS.has(entry[0]) && isEntryFile(entry[1]),\n  )\n  const [firstMatch] = matched\n  if (!firstMatch) return value\n  const hasTypes = conditions.some(([condition]) => condition === 'types')\n  // A single runtime file maps to a plain path (with a `types` condition inserted ahead of\n  // `react-server` below, unless one is already specified). A dual-format entry nests its\n  // `import` and `require` files under the `react-server` condition, each with its own\n  // format-matched `types` — a single top-level `types` file cannot serve both resolution\n  // modes, which is also why tsdown's own dual-format output relies on adjacent-file lookup.\n  const missingTypes = hasTypes ? undefined : dtsFor(firstMatch[1])\n  const serverTarget =\n    matched.length === 1\n      ? toServerFile(firstMatch[1])\n      : Object.fromEntries(\n          matched.map(([condition, target]) => {\n            const types = hasTypes ? undefined : dtsFor(target)\n            return [\n              condition,\n              types === undefined ? toServerFile(target) : {types, default: toServerFile(target)},\n            ]\n          }),\n        )\n  // Conditions match in order, so `react-server` is inserted right before the first runtime\n  // condition (`import`/`require`/`default`), keeping `types` and custom development\n  // conditions (`devExports`) ahead of it\n  const next: Record<string, unknown> = {}\n  let inserted = false\n  for (const [condition, target] of conditions) {\n    if (!inserted && RUNTIME_CONDITIONS.has(condition)) {\n      if (matched.length === 1 && missingTypes !== undefined) {\n        next['types'] = missingTypes\n      }\n      next['react-server'] = serverTarget\n      inserted = true\n    }\n    next[condition] = target\n  }\n  if (!inserted) {\n    next['react-server'] = serverTarget\n  }\n  return next\n}\n\n/** Matches the declaration file extensions tsdown emits next to `es`/`cjs` chunks. */\nconst RE_DTS_FILE = /\\.d\\.(ts|mts|cts)$/\n\n/** `./dist/index.js` → `./dist/index.react-server.js` (and `.mjs`/`.cjs` accordingly). */\nfunction toServerFile(file: string): string {\n  return file.replace(RE_JS_FILE, '.react-server.$1')\n}\n\n/** `./dist/index.js` → `./dist/index.d.ts` (`.mjs` → `.d.mts`, `.cjs` → `.d.cts`). */\nfunction toDtsFile(file: string): string {\n  return file.replace(RE_JS_FILE, (extension) =>\n    extension === '.mjs' ? '.d.mts' : extension === '.cjs' ? '.d.cts' : '.d.ts',\n  )\n}\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/tsdown-config",
-  "version": "0.20.0",
+  "version": "0.21.1",
   "description": "Shared configuration for tsdown",
   "keywords": [
     "sanity-io",
@@ -38,23 +38,23 @@
     "@babel/core": "^7.29.7",
     "@rolldown/plugin-babel": "^0.2.3",
     "@sanity/browserslist-config": "^1.0.5",
-    "@vitejs/plugin-react": "^6.0.3",
-    "browserslist": "^4.28.6",
+    "@vitejs/plugin-react": "^6.0.4",
+    "browserslist": "^4.28.7",
     "lightningcss": "^1.33.0",
-    "package-manager-detector": "^1.7.0",
-    "publint": "^0.3.21",
-    "@sanity/vanilla-extract-tsdown-plugin": "^0.2.9"
+    "package-manager-detector": "^1.8.0",
+    "publint": "^0.3.22",
+    "@sanity/vanilla-extract-tsdown-plugin": "^0.2.10"
   },
   "devDependencies": {
-    "@tsdown/css": "^0.22.13",
+    "@tsdown/css": "^0.22.14",
     "@types/babel__core": "^7.20.5",
     "babel-plugin-react-compiler": "^1.0.0",
     "rolldown": "~1.2.0",
     "tinyexec": "^1.2.4",
-    "tsdown": "^0.22.13",
+    "tsdown": "^0.22.14",
     "typescript": "7.0.2",
     "vitest": "^4.1.10",
-    "@sanity/pkg-utils": "^11.0.14",
+    "@sanity/pkg-utils": "^11.0.15",
     "@sanity/tsconfig": "^2.2.1"
   },
   "peerDependencies": {