@savvy-web/mcp 1.3.3 → 1.3.5

package/content/packages/tsdown-plugins/api/interface/buildgroupspec.md

@@ -0,0 +1,32 @@
+---
+id: packages/tsdown-plugins/api/interface/buildgroupspec
+title: "BuildGroupSpec — tsdown-plugins interface"
+summary: "A prod/dev group to build: its folder id and the resolved package name its manifest carries."
+tier: packages
+source: generated
+tags: [tsdown-plugins, api]
+priority: 0.3
+related: []
+---
+
+# BuildGroupSpec
+
+A prod/dev group to build: its folder id and the resolved package name its manifest carries.
+
+```ts
+interface BuildGroupSpec
+```
+
+## Members
+
+### id
+
+```ts
+readonly id: TargetGroupId;
+```
+
+### name
+
+```ts
+readonly name: string;
+```

package/content/packages/tsdown-plugins/api/interface/buildissues.md

@@ -0,0 +1,56 @@
+---
+id: packages/tsdown-plugins/api/interface/buildissues
+title: "BuildIssues — tsdown-plugins interface"
+summary: "The aggregated build-issues artifact written to `dist/<target>/issues.json`."
+tier: packages
+source: generated
+tags: [tsdown-plugins, api]
+priority: 0.3
+related: []
+---
+
+# BuildIssues
+
+The aggregated build-issues artifact written to `dist/<target>/issues.json`.
+
+```ts
+interface BuildIssues
+```
+
+## Members
+
+### errors
+
+```ts
+errors: PlainDiagnostic[];
+```
+
+### generatedAt
+
+```ts
+generatedAt: string;
+```
+
+### package
+
+```ts
+package: string;
+```
+
+### suppressed
+
+```ts
+suppressed: PlainDiagnostic[];
+```
+
+### target
+
+```ts
+target: "dev" | "prod";
+```
+
+### warnings
+
+```ts
+warnings: PlainDiagnostic[];
+```

package/content/packages/tsdown-plugins/api/interface/buildtargetgroupsoptions.md

@@ -0,0 +1,205 @@
+---
+id: packages/tsdown-plugins/api/interface/buildtargetgroupsoptions
+title: "BuildTargetGroupsOptions — tsdown-plugins interface"
+summary: "interface BuildTargetGroupsOptions from @savvy-web/tsdown-plugins."
+tier: packages
+source: generated
+tags: [tsdown-plugins, api]
+priority: 0.3
+related: []
+---
+
+# BuildTargetGroupsOptions
+
+```ts
+interface BuildTargetGroupsOptions
+```
+
+## Members
+
+### build
+
+```ts
+readonly build?: TsdownBuild;
+```
+
+Injectable for tests; defaults to tsdown's build.
+
+### bundle
+
+```ts
+readonly bundle?: ReadonlyArray<string> | undefined;
+```
+
+Force-bundle (inline) these packages into the JS output (tsdown `deps.alwaysBundle`), even declared deps that would otherwise be auto-externalized. The inverse of `externals`. JS pass only; `alwaysBundle` is allowed alongside our `skipNodeModulesBundle: false` (the throw only fires when skipNodeModulesBundle is true).
+
+### bundledPackages
+
+```ts
+readonly bundledPackages?: ReadonlyArray<string> | undefined;
+```
+
+External packages whose declarations are inlined into the bundled dts (rslib `dtsBundledPackages` equivalent). Forwarded to the dts pass as `deps.dts.alwaysBundle` alongside `skipNodeModulesBundle: true`; unlike `deps.onlyBundle` this does not enable tsdown's strict-mode check that errors on every unlisted transitive dependency. The JS pass is unaffected.
+
+### bundleNodeModules
+
+```ts
+readonly bundleNodeModules?: boolean | undefined;
+```
+
+Force-bundle node_modules (and workspace) JS dependencies that are not externalized, restoring the rslib bundle-everything-except-externals behavior. Sets tsdown `deps.skipNodeModulesBundle: false`; the dts pass posture mirrors the JS pass, so the bundled declarations are also self-contained. Defaults to false (current behavior).
+
+### collector
+
+```ts
+readonly collector?: BuildCollector | undefined;
+```
+
+When set, muzzle tsdown (silent + customLogger) and capture metrics/timing into this collector.
+
+### cwd
+
+```ts
+readonly cwd: string;
+```
+
+### define
+
+```ts
+readonly define?: Record<string, string> | undefined;
+```
+
+Compile-time global replacements forwarded to BOTH the JS and dts passes' `define`. Build-wide (shared by every entry partition); merged after the auto-injected `process.env.__PACKAGE_VERSION__` so a user key of the same name wins.
+
+### devManifest
+
+```ts
+readonly devManifest: "preserve" | "resolve";
+```
+
+### dtsExternals
+
+```ts
+readonly dtsExternals?: ReadonlyArray<string> | undefined;
+```
+
+Packages externalized in the dts pass ONLY — emitted as `import ... from "..."` references in the `.d.ts` rather than inlined — while the JS pass still bundles them per `bundleNodeModules`. The dts pass `neverBundle` becomes the union of `externals` and `dtsExternals`. Use when a dependency's types cannot be safely inlined into a single bundled declaration file (e.g. effect's cross-module `declare module` augmentations, which inline into conflicting interface extensions in consumers). The JS pass is unaffected.
+
+### dualExports
+
+```ts
+readonly dualExports?: DualExports | undefined;
+```
+
+Which export keys get a CJS `require` condition in the emitted manifest. Pass a Set when overrides give different entries different formats; omit for the uniform `format`-includes-cjs behavior.
+
+### emitDeclarations
+
+```ts
+readonly emitDeclarations?: boolean | undefined;
+```
+
+Emit a per-module (`unbundle: true`) declaration tree into `dist/prod/<id>/declarations/` per group, in addition to the bundled dts in `pkg/`. API Extractor's diagnostics-run input for the meta pass. Prod-only; the bundler sets it for `--target prod`. Absent → no third pass (byte-identical to the two-pass default). Not captured by the collector.
+
+### entry
+
+```ts
+readonly entry: Record<string, string>;
+```
+
+### exeRewrite
+
+```ts
+readonly exeRewrite?: ExeRewrite | undefined;
+```
+
+When set, rewrite the emitted manifest's exports/bin values equal to the exe source to the SEA path and add it to `files`.
+
+### externals
+
+```ts
+readonly externals?: ReadonlyArray<string>;
+```
+
+### extraPlugins
+
+```ts
+readonly extraPlugins?: ReadonlyArray<Plugin>;
+```
+
+Extra rolldown plugins, forwarded to BOTH the JS pass and the dts-only pass. A plugin with JS-lifecycle side effects (asset emitters, banner injectors) runs in both passes; the dts pass uses `emitDtsOnly`, so for esm-only builds it produces no JS chunks and most rolldown hooks are no-ops there. For DUAL (esm+cjs) builds, however, tsdown's dts pass still RE-EMITS the `.cjs` JS chunk and overwrites the JS pass's `.cjs` output — so a `renderChunk`/`generateBundle` plugin that must persist onto the final `.cjs` (e.g. the built-in cjs-default-interop) has to run in the dts pass too. A caller relying on a hook firing exactly once should guard the second invocation.
+
+### format
+
+```ts
+readonly format?: ReadonlyArray<BuildFormat> | undefined;
+```
+
+Output formats to emit. Defaults to esm-only when unset.
+
+### groups
+
+```ts
+readonly groups: ReadonlyArray<BuildGroupSpec>;
+```
+
+### looseFiles
+
+```ts
+readonly looseFiles?: ReadonlyArray<NormalizedLooseFile> | undefined;
+```
+
+Standalone bundled output files emitted at literal paths into each group's pkg/ dir, outside the exports/dts/meta graph (e.g. pnpm config-dependency pnpmfiles). Each runs as one extra single-entry, bundled (unbundle:false), no-dts, no-manifest pass per group, inheriting the group's bundleNodeModules/bundle/externals posture so the file is self-contained. Caller passes the normalized form (see [normalizeLooseFiles](silk://packages/tsdown-plugins/api/function/normalizeloosefiles)).
+
+### minify
+
+```ts
+readonly minify?: boolean | undefined;
+```
+
+Minify the JS output of PROD groups only (dev is never minified). Defaults to false — this builder targets Node libraries where readable output is preferred.
+
+### overrides
+
+```ts
+readonly overrides?: ReadonlyArray<EntryOverride> | undefined;
+```
+
+Entry partitions with their own format/bundling, built into the same outDir after the base entries. Used for per-entry format overrides (e.g. one CJS entry in an otherwise ESM-only package). The base `entry` must already EXCLUDE these entries.
+
+### subdirExports
+
+```ts
+readonly subdirExports?: ReadonlySet<string> | undefined;
+```
+
+Export keys built into a `<key>/index.*` subdir (e.g. an RSPress `./runtime`).
+
+### transform
+
+```ts
+readonly transform?: (args: {
+    pkg: Json;
+    targetGroup: TargetGroupRef;
+  }) => Json;
+```
+
+### tsconfigPath
+
+```ts
+readonly tsconfigPath: string;
+```
+
+### verbose
+
+```ts
+readonly verbose?: boolean | undefined;
+```
+
+Compute gzip sizes for emitted files (verbose render). Forwarded to the metrics plugin.
+
+### version
+
+```ts
+readonly version: string;
+```

package/content/packages/tsdown-plugins/api/interface/copyambientdtsoptions.md

@@ -0,0 +1,42 @@
+---
+id: packages/tsdown-plugins/api/interface/copyambientdtsoptions
+title: "CopyAmbientDtsOptions — tsdown-plugins interface"
+summary: "interface CopyAmbientDtsOptions from @savvy-web/tsdown-plugins."
+tier: packages
+source: generated
+tags: [tsdown-plugins, api]
+priority: 0.3
+related: []
+---
+
+# CopyAmbientDtsOptions
+
+```ts
+interface CopyAmbientDtsOptions
+```
+
+## Members
+
+### ambient
+
+```ts
+readonly ambient: ReadonlyArray<AmbientDtsEntry>;
+```
+
+The ambient exports to copy (from `extractAmbientDts`).
+
+### outDir
+
+```ts
+readonly outDir: string;
+```
+
+The built package dir to copy into (e.g. `dist/dev/pkg`).
+
+### srcCwd
+
+```ts
+readonly srcCwd: string;
+```
+
+Package root the `source` paths are relative to.

package/content/packages/tsdown-plugins/api/interface/cssoptions.md

@@ -0,0 +1,36 @@
+---
+id: packages/tsdown-plugins/api/interface/cssoptions
+title: "CssOptions — tsdown-plugins interface"
+summary: "CSS handling for a partition's JS pass, forwarded VERBATIM to tsdown's `css` option (consumed by `@tsdown/css`). Structurally typed so tsdown-plugins takes no…"
+tier: packages
+source: generated
+tags: [tsdown-plugins, api]
+priority: 0.3
+related: []
+---
+
+# CssOptions
+
+CSS handling for a partition's JS pass, forwarded VERBATIM to tsdown's `css` option (consumed by `@tsdown/css`). Structurally typed so tsdown-plugins takes no dependency on `@tsdown/css`. The package whose runtime is built must install `@tsdown/css`; tsdown loads it lazily.
+
+```ts
+interface CssOptions
+```
+
+## Members
+
+### (indexer)
+
+```ts
+readonly [k: string]: unknown;
+```
+
+### modules
+
+```ts
+readonly modules?: boolean | {
+    readonly localsConvention?: string;
+    readonly namedExport?: boolean;
+    readonly [k: string]: unknown;
+  };
+```

package/content/packages/tsdown-plugins/api/interface/derivedtsdownoptions.md

@@ -0,0 +1,106 @@
+---
+id: packages/tsdown-plugins/api/interface/derivedtsdownoptions
+title: "DerivedTsdownOptions — tsdown-plugins interface"
+summary: "The JS pass: per-module JavaScript, no declarations. The build runs TWO tsdown passes per TargetGroup to the SAME outDir: - pass 1 (this) emits per-module JS (…"
+tier: packages
+source: generated
+tags: [tsdown-plugins, api]
+priority: 0.3
+related: []
+---
+
+# DerivedTsdownOptions
+
+The JS pass: per-module JavaScript, no declarations. The build runs TWO tsdown passes per TargetGroup to the SAME outDir: - pass 1 (this) emits per-module JS (`unbundle: true`) with `dts: false` and the default `clean: true`, so it starts from a fresh outDir; - pass 2 (`DerivedDtsPassOptions`) emits ONLY bundled declarations (`unbundle: false`, `dts: { emitDtsOnly: true }`) with `clean: false`, so it must NOT wipe pass 1. We cannot do this in a single pass: tsdown's `unbundle` maps to rolldown `output.preserveModules` for the WHOLE build, and the dts plugin shares it — so one pass gives EITHER per-module JS + per-module dts OR bundled JS + bundled dts. Per-module dts breaks type portability (TS2883) when a package exports only its root entry, and bundling the JS re-bundles workspace consumers (e.g. silk re-bundling silk-effects crashes at runtime). The split keeps per-module JS (no re-bundle hazard) AND bundled, self-contained declarations (no TS2883).
+
+```ts
+interface DerivedTsdownOptions
+```
+
+## Members
+
+### cjsDefault
+
+```ts
+readonly cjsDefault?: boolean | undefined;
+```
+
+CJS named-export interop, the equivalent of rslib's cjsInterop: true. This is the real tsdown option name, so it threads straight to the build with no rename. tsdown 0.22.2 finding (verified against the dist Options dts plus the build source): - cjsDefault is a top-level boolean, default true. The build maps it to rolldown's output.exports: cjsDefault ? "auto" : "named", and also silences the MIXED_EXPORT warning. With "auto", a module whose only default-style export is a single default becomes module.exports = value, while named exports stay attached, so a require() call returns the value directly and named exports survive, the interop rslib gives with cjsInterop: true. - We only set it (to true) when cjs is in the format, so esm-only builds leave the tsdown default untouched and stay byte-identical to before.
+
+### clean
+
+```ts
+readonly clean: true;
+```
+
+JS pass starts fresh; it owns the outDir before the dts pass appends to it.
+
+### define
+
+```ts
+readonly define: Record<string, string>;
+```
+
+### dts
+
+```ts
+readonly dts: false;
+```
+
+JS pass emits no declarations; the dts pass owns them.
+
+### entry
+
+```ts
+readonly entry: Record<string, string>;
+```
+
+### fixedExtension
+
+```ts
+readonly fixedExtension: false;
+```
+
+Controls output file extensions. Always false for this builder. tsdown 0.22.2 finding (verified by running a real esm+cjs build of a type:module package): - With fixedExtension: false, tsdown emits ESM index.js plus CJS index.cjs for a type:module package in the JS pass. There is no collision: tsdown derives the .js extension for ESM and the .cjs extension for CJS automatically. An earlier M1.1 note claimed the two formats collide on ambient .js under fixedExtension: false; that claim was wrong and is corrected here. - This .js plus .cjs scheme is the one we want. It matches the rslib parity target, where silk's dual-format output uses import: .js, require: .cjs, and a single types: .d.ts, and it matches the flat manifest the emit-manifest transform writes. - Setting fixedExtension: true would instead yield .mjs plus .cjs (and .d.mts plus .d.cts), which is NOT wanted, so dual-format needs no fixedExtension change and we leave it false. - The matching `.d.ts` / `.d.cts` declarations are emitted by the SEPARATE dts pass (see `DerivedDtsPassOptions`), which keeps `unbundle: false` so the declarations are rolled up.
+
+### format
+
+```ts
+readonly format: ReadonlyArray<BuildFormat>;
+```
+
+### isProd
+
+```ts
+readonly isProd: boolean;
+```
+
+### minify
+
+```ts
+readonly minify: boolean;
+```
+
+### outDir
+
+```ts
+readonly outDir: string;
+```
+
+### platform
+
+```ts
+readonly platform: BuildPlatform;
+```
+
+### sourcemap
+
+```ts
+readonly sourcemap: boolean;
+```
+
+### unbundle
+
+```ts
+readonly unbundle: true;
+```

package/content/packages/tsdown-plugins/api/interface/deriveoptions.md

@@ -0,0 +1,100 @@
+---
+id: packages/tsdown-plugins/api/interface/deriveoptions
+title: "DeriveOptions — tsdown-plugins interface"
+summary: "interface DeriveOptions from @savvy-web/tsdown-plugins."
+tier: packages
+source: generated
+tags: [tsdown-plugins, api]
+priority: 0.3
+related: []
+---
+
+# DeriveOptions
+
+```ts
+interface DeriveOptions
+```
+
+## Members
+
+### bundledPackages
+
+```ts
+readonly bundledPackages?: ReadonlyArray<string> | undefined;
+```
+
+External packages whose declarations should be INLINED into the bundled dts (the rslib `dtsBundledPackages` equivalent). Maps to tsdown's `deps.onlyBundle` in the dts pass, so ONLY these node_modules packages are rolled into the `.d.ts` and every other dependency stays an external `import`. dts-pass-only: runtime JS bundling is unaffected.
+
+### cwd
+
+```ts
+readonly cwd: string;
+```
+
+### define
+
+```ts
+readonly define?: Record<string, string> | undefined;
+```
+
+Compile-time global replacements forwarded to the build `define`. Merged AFTER the auto-injected `process.env.__PACKAGE_VERSION__` so a user key of the same name wins. Values are inserted verbatim (string literals must already be quoted).
+
+### devManifest
+
+```ts
+readonly devManifest: "preserve" | "resolve";
+```
+
+### entry
+
+```ts
+readonly entry: Record<string, string>;
+```
+
+### externals
+
+```ts
+readonly externals?: ReadonlyArray<string>;
+```
+
+### format
+
+```ts
+readonly format?: ReadonlyArray<BuildFormat> | undefined;
+```
+
+Output formats to emit. Defaults to esm-only when unset.
+
+### group
+
+```ts
+readonly group: TargetGroupId;
+```
+
+### minify
+
+```ts
+readonly minify?: boolean | undefined;
+```
+
+Minify prod output (prod groups only; dev is never minified). Defaults to false.
+
+### platform
+
+```ts
+readonly platform?: BuildPlatform | undefined;
+```
+
+JS-pass platform. Defaults to "node"; set "browser" for an RSPress runtime partition.
+
+### tsconfigPath
+
+```ts
+readonly tsconfigPath: string;
+```
+
+### version
+
+```ts
+readonly version: string;
+```

package/content/packages/tsdown-plugins/api/interface/diagnosticinput.md

@@ -0,0 +1,66 @@
+---
+id: packages/tsdown-plugins/api/interface/diagnosticinput
+title: "DiagnosticInput — tsdown-plugins interface"
+summary: "interface DiagnosticInput from @savvy-web/tsdown-plugins."
+tier: packages
+source: generated
+tags: [tsdown-plugins, api]
+priority: 0.3
+related: []
+---
+
+# DiagnosticInput
+
+```ts
+interface DiagnosticInput
+```
+
+## Members
+
+### ciFatal
+
+```ts
+readonly ciFatal?: boolean;
+```
+
+### code
+
+```ts
+readonly code?: string;
+```
+
+### column
+
+```ts
+readonly column?: number;
+```
+
+### file
+
+```ts
+readonly file?: string;
+```
+
+### level
+
+```ts
+readonly level: DiagnosticEntry["level"];
+```
+
+### line
+
+```ts
+readonly line?: number;
+```
+
+### source
+
+```ts
+readonly source: DiagnosticEntry["source"];
+```
+
+### text
+
+```ts
+readonly text: string;
+```