@savvy-web/tsdown-plugins 0.1.0

package/index.d.ts

@@ -0,0 +1,1457 @@
+import { CatalogAssemblyError, CatalogResolutionError, ManifestLike, ManifestLike as ManifestLike$1 } from "workspaces-effect";
+import { Plugin } from "rolldown";
+import { Context, Effect, Layer, Schema } from "effect";
+import { JsxEmit, ModuleDetectionKind, ModuleKind, ModuleResolutionKind, NewLineKind, ParsedCommandLine, ScriptTarget } from "typescript";
+import * as Schema$1 from "effect/Schema";
+import * as Effect$1 from "effect/Effect";
+import { Option } from "effect/Option";
+import { Scope } from "effect/Scope";
+import { Sink } from "effect/Sink";
+import { Stream } from "effect/Stream";
+import * as Brand from "effect/Brand";
+import { Tag } from "effect/Context";
+import { JsonSchemaError, JsonSchemaOutput } from "json-schema-effect";
+
+//#region src/jsx/config.d.ts
+/** Resolved JSX transform settings, mirroring the subset of rolldown's JsxOptions the bundler forwards. */
+interface JsxConfig {
+  /** "automatic" auto-imports the JSX factories (react-jsx); "classic" does not (React.createElement). */
+  readonly runtime?: "classic" | "automatic" | undefined;
+  /** The JSX import source for the automatic runtime (e.g. "react", "preact"). */
+  readonly importSource?: string | undefined;
+}
+/** The jsx-relevant slice of a tsconfig's compilerOptions. */
+interface TsconfigJsx {
+  readonly jsx?: string | undefined;
+  readonly jsxImportSource?: string | undefined;
+}
+/**
+ * Resolve the effective JSX config: an explicit override wins; otherwise infer from the tsconfig
+ * values. Returns undefined when no JSX transform is needed (preserve/none).
+ */
+declare function resolveJsxConfig(tsconfig: TsconfigJsx, override: JsxConfig | undefined): JsxConfig | undefined;
+/**
+ * Read the jsx-relevant compilerOptions from a package's own tsconfig.json (best-effort;
+ * returns empty on absence or parse error).
+ */
+declare function readTsconfigJsx(cwd: string): TsconfigJsx;
+//#endregion
+//#region src/manifest/transform.d.ts
+type Json = Record<string, unknown>;
+/**
+ * Which exports get a CJS `require` condition. `true`/`false` apply uniformly to every
+ * TS export; a Set marks ONLY the listed export keys (e.g. "./changesets/markdownlint")
+ * as dual — used by per-entry format overrides.
+ */
+type DualExports = boolean | ReadonlySet<string>;
+/**
+ * The default `transform` applied to every package's manifest when its
+ * `savvy.build.ts` does not provide one of its own. Strips the build/dev-only
+ * fields in {@link NON_PUBLISHED_FIELDS} from the emitted package.json.
+ *
+ * This is the pattern nearly every package repeated by hand (inherited from
+ * rslib-builder); `defineBuild` now applies it automatically so a package needs a
+ * `transform` only when it has genuinely custom manifest work to do (e.g. silk
+ * promoting workspace deps to peerDependencies). A custom transform REPLACES this
+ * default — re-export it and call it from a custom transform to keep the stripping.
+ *
+ * `targetGroup` is accepted (so this is assignable wherever the full transform
+ * signature is expected) but unused; the strip is identical for every group.
+ *
+ * Pure: the supplied `pkg` is NOT mutated — a shallow copy with the fields removed
+ * is returned, so external callers invoking this from a custom transform keep their
+ * input intact.
+ */
+declare function defaultManifestTransform({
+  pkg
+}: {
+  pkg: Json;
+}): Json;
+/**
+ * Rewrite an exports map: TS string targets become a types/import conditions object.
+ * Each TS condition also gets a `require` entry when `dual` is `true` (uniform) or when
+ * the export key is in the `dual` Set (per-entry).
+ *
+ * The output path is derived from the export KEY via the shared entry-name function,
+ * never from the source path, so the manifest target always matches the emitted file.
+ */
+declare function transformExports(exports: unknown, dual?: DualExports): unknown;
+/** Rewrite bin: TS targets to bin/[command].js (string to bin/cli.js); strip leading ./ otherwise. */
+declare function transformBin(bin: unknown): unknown;
+/** FINAL guard: strip leading ./ from bin paths (npm 11.x drops ./-prefixed bins). */
+declare function normalizeBinPaths(bin: unknown): unknown;
+interface TransformManifestOptions {
+  /** Run after the standard transforms, before the bin final-guard + sort. */
+  readonly transform?: ((pkg: Json) => Json) | undefined;
+  /** Which exports emit dual import/require conditions. boolean = uniform; Set = per-export-key. */
+  readonly dual?: DualExports | undefined;
+}
+/** Apply the full standard manifest transform (excluding catalog resolution, done upstream). */
+declare function transformManifest(pkg: Json, options?: TransformManifestOptions): Json;
+//#endregion
+//#region src/manifest/emit-manifest.d.ts
+interface TargetGroupRef {
+  readonly id: string;
+  /** The package.json name this group's manifest carries (the declarative rename). */
+  readonly name: string;
+  readonly isProd: boolean;
+}
+interface BuildEmittedManifestOptions {
+  readonly pkg: Json;
+  readonly targetGroup: TargetGroupRef;
+  readonly devManifest: "preserve" | "resolve";
+  readonly transform?: ((args: {
+    pkg: Json;
+    targetGroup: TargetGroupRef;
+  }) => Json) | undefined;
+  /** Which exports emit dual import/require conditions. boolean (uniform) or a Set of export keys (per-entry). */
+  readonly dual?: DualExports | undefined;
+}
+/** Compute the final manifest bytes for a TargetGroup (catalog resolution + standard transforms). */
+declare function buildEmittedManifest(options: BuildEmittedManifestOptions): Promise<Json>;
+interface EmitManifestOptions {
+  readonly targetGroup: TargetGroupRef;
+  readonly devManifest?: "preserve" | "resolve" | undefined;
+  readonly transform?: ((args: {
+    pkg: Json;
+    targetGroup: TargetGroupRef;
+  }) => Json) | undefined;
+  /** Source package dir to read package.json/LICENSE/README from. */
+  readonly sourceDir: string;
+  /** Which exports emit dual import/require conditions. boolean (uniform) or a Set of export keys (per-entry). */
+  readonly dual?: DualExports | undefined;
+}
+/** Rolldown plugin: emit the transformed package.json + LICENSE/README into the output pkg/ root. */
+declare function emitManifest(options: EmitManifestOptions): Plugin;
+//#endregion
+//#region src/build/target-groups.d.ts
+/** A build group id: "dev" or any prod byte-variant id (e.g. "npm", "github", a custom key). */
+type TargetGroupId = string;
+/** An output module format the build can emit. */
+type BuildFormat = "esm" | "cjs";
+/** A prod/dev group to build: its folder id and the resolved package name its manifest carries. */
+interface BuildGroupSpec {
+  readonly id: TargetGroupId;
+  readonly name: string;
+}
+interface DeriveOptions {
+  readonly group: TargetGroupId;
+  readonly cwd: string;
+  readonly version: string;
+  readonly entry: Record<string, string>;
+  readonly tsconfigPath: string;
+  readonly devManifest: "preserve" | "resolve";
+  readonly externals?: ReadonlyArray<string>;
+  /** Output formats to emit. Defaults to esm-only when unset. */
+  readonly format?: ReadonlyArray<BuildFormat> | undefined;
+  /** Minify prod output (prod groups only; dev is never minified). Defaults to false. */
+  readonly minify?: boolean | undefined;
+  /** JSX transform settings to forward to rolldown's inputOptions. */
+  readonly jsx?: JsxConfig | 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.
+   */
+  readonly bundledPackages?: ReadonlyArray<string> | undefined;
+}
+/**
+ * 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).
+ */
+interface DerivedTsdownOptions {
+  readonly outDir: string;
+  readonly sourcemap: boolean;
+  readonly minify: boolean;
+  readonly format: ReadonlyArray<BuildFormat>;
+  readonly unbundle: true;
+  /** JS pass starts fresh; it owns the outDir before the dts pass appends to it. */
+  readonly clean: true;
+  readonly platform: "node";
+  /**
+   * 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.
+   */
+  readonly fixedExtension: false;
+  readonly entry: Record<string, string>;
+  /** JS pass emits no declarations; the dts pass owns them. */
+  readonly dts: false;
+  readonly define: Record<string, string>;
+  readonly isProd: boolean;
+  /**
+   * 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.
+   */
+  readonly cjsDefault?: boolean | undefined;
+  /** JSX transform settings to forward to rolldown's inputOptions. */
+  readonly jsx?: JsxConfig | undefined;
+}
+/** Derive the JS-pass tsdown options for one TargetGroup (per-module JS, no dts). */
+declare function deriveTargetGroupOptions(options: DeriveOptions): DerivedTsdownOptions;
+//#endregion
+//#region src/build/build-target-groups.d.ts
+/** Signature compatible with tsdown's `build(inlineConfig)`. */
+type TsdownBuild = (config: Record<string, unknown>) => Promise<unknown>;
+/**
+ * One entry partition built with its own format + bundling posture, layered into the
+ * SAME outDir as the base build (clean:false). Anything omitted falls back to the base
+ * build's value. `entry` is a subset of the package's entries (entryName -> source path).
+ */
+interface EntryOverride {
+  readonly entry: Record<string, string>;
+  readonly format?: ReadonlyArray<BuildFormat> | undefined;
+  readonly externals?: ReadonlyArray<string> | undefined;
+  readonly bundle?: ReadonlyArray<string> | undefined;
+  readonly bundleNodeModules?: boolean | undefined;
+  readonly bundledPackages?: ReadonlyArray<string> | undefined;
+  readonly dtsExternals?: ReadonlyArray<string> | undefined;
+}
+interface BuildTargetGroupsOptions {
+  readonly cwd: string;
+  readonly version: string;
+  readonly entry: Record<string, string>;
+  readonly tsconfigPath: string;
+  readonly groups: ReadonlyArray<BuildGroupSpec>;
+  readonly devManifest: "preserve" | "resolve";
+  readonly externals?: ReadonlyArray<string>;
+  /**
+   * 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.
+   */
+  readonly dtsExternals?: 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.
+   */
+  readonly bundledPackages?: ReadonlyArray<string> | 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).
+   */
+  readonly bundleNodeModules?: boolean | 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).
+   */
+  readonly bundle?: ReadonlyArray<string> | undefined;
+  /** Output formats to emit. Defaults to esm-only when unset. */
+  readonly format?: ReadonlyArray<BuildFormat> | 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.
+   */
+  readonly minify?: boolean | undefined;
+  readonly transform?: (args: {
+    pkg: Json;
+    targetGroup: TargetGroupRef;
+  }) => Json;
+  /**
+   * 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.
+   */
+  readonly extraPlugins?: ReadonlyArray<Plugin>;
+  /** JSX transform settings forwarded to rolldown's inputOptions. */
+  readonly jsx?: JsxConfig | 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.
+   */
+  readonly overrides?: ReadonlyArray<EntryOverride> | 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.
+   */
+  readonly dualExports?: DualExports | undefined;
+  /** Injectable for tests; defaults to tsdown's build. */
+  readonly build?: TsdownBuild;
+}
+/**
+ * Run tsdown.build() per TargetGroup. Composable so the escape hatch gets multi-group too.
+ *
+ * Each group runs TWO passes to the SAME outDir:
+ *  1. JS pass — per-module JS (`unbundle: true`, `dts: false`), with the `emitManifest` plugin
+ *     and the `public/` copy. Default `clean: true` gives it a fresh outDir.
+ *  2. dts pass — bundled declarations only (`unbundle: false`, `dts: { emitDtsOnly: true }`,
+ *     `clean: false`). No manifest plugin, no copy, no sourcemaps. `clean: false` is load-bearing:
+ *     it must NOT wipe the JS the first pass just wrote.
+ *
+ * Why two passes: tsdown's `unbundle` maps to rolldown `output.preserveModules` for the whole
+ * build (JS and the dts plugin share it), so a single pass cannot give per-module JS + bundled
+ * dts. Per-module dts breaks type portability (TS2883); bundling the JS re-bundles workspace
+ * consumers. The split keeps per-module JS AND rolled-up, self-contained declarations.
+ */
+declare function buildTargetGroups(options: BuildTargetGroupsOptions): Promise<void>;
+//#endregion
+//#region src/build/cjs-default-interop.d.ts
+/**
+ * Rolldown plugin: append the CJS default-interop footer to ENTRY chunks of the
+ * `cjs` format that export a default alongside named exports.
+ *
+ * Gated tightly so it never touches the wrong chunk:
+ *  - format must be `cjs` (ESM is untouched; `import().default` on ESM is already correct);
+ *  - the chunk must be an ENTRY chunk — never a SHARED chunk. Shared chunks are required by
+ *    entry chunks via their named bindings (e.g. `require_changesets.changesets_exports.X`);
+ *    reassigning a shared chunk's `module.exports` to its own default would break those reads
+ *    (many bundled vendor chunks carry an `exports.default`);
+ *  - the chunk must export a `default` AND at least one named export. A default-only chunk
+ *    already gets `module.exports = <default>` from rolldown, and a named-only chunk has no
+ *    default to promote.
+ *
+ * The emitted footer is also self-guarded (`module.exports.default !== void 0`), so it is a
+ * runtime no-op whenever the static gate is ever too generous.
+ */
+declare function cjsDefaultInterop(): Plugin;
+//#endregion
+//#region src/build/node-builtin-default-interop.d.ts
+/**
+ * Rewrite a default import / default re-export of a Node built-in into the
+ * equivalent NAMESPACE form, so rolldown's CJS codegen produces correct interop.
+ *
+ * Why this exists — a rolldown 1.1.0 codegen defect (verified against the latest
+ * published rolldown 1.1.0 / tsdown 0.22.2, with no newer release to upgrade to):
+ *
+ *   // SOURCE (e.g. vfile's lib/minproc.js)
+ *   export {default as minproc} from 'node:process'
+ *   // ...consumed as minproc.cwd()
+ *
+ *   // rolldown CJS OUTPUT (BROKEN)
+ *   let node_process = require("node:process");
+ *   node_process.default.cwd()           // <- require("node:process").default is undefined
+ *
+ * For a default import of an EXTERNAL Node builtin, rolldown emits a bare
+ * `require("node:x")` WITHOUT its `__toESM` interop wrapper, yet still accesses
+ * `.default` — which is `undefined` on a builtin's CJS export object, so the call
+ * throws `Cannot read properties of undefined (reading 'cwd')` at runtime. NAMED
+ * imports are unaffected (`(0, node_process.cwd)()` reads a real property), and a
+ * NAMESPACE import is handled correctly: rolldown wraps it as
+ * `node_process = __toESM(require("node:process"), 1)`, which synthesizes `.default`
+ * and copies every own property, so member access works. This transform converts the
+ * broken default form into the working namespace form BEFORE codegen, so it is immune
+ * to minification and applies identically to per-module and bundled output.
+ *
+ * rolldown exposes no Rollup-style `output.interop` knob to fix this at the output
+ * layer, which is why the correction happens here on the source.
+ *
+ * Rewrites (the two static forms that occur in practice, anchored to statement start):
+ *  - `import NAME from "node:x"`            -> `import * as NAME from "node:x"`
+ *  - `export { default as NAME } from "node:x"` -> `export * as NAME from "node:x"`
+ *  - `import NAME, { a, b } from "node:x"`  -> `import * as NAME from "node:x"; import { a, b } from "node:x"`
+ *
+ * The namespace binding NAME carries the builtin's named exports (`NAME.cwd`,
+ * `NAME.join`, ...), which is exactly how a default import of a builtin is consumed
+ * in practice. ESM output is unaffected at runtime (a namespace import of a builtin
+ * resolves to the same members), so the plugin is safe to attach to dual builds.
+ */
+declare function nodeBuiltinDefaultInterop(): Plugin;
+//#endregion
+//#region src/build/strip-maps.d.ts
+/**
+ * Remove declaration source-map files (`.d.ts.map` / `.d.cts.map`) from a built `pkg`
+ * directory, returning the removed paths.
+ *
+ * The dts pass emits these next to each `.d.ts` (the resolved dts tsconfig sets
+ * `declarationMap: true`) because API Extractor reads them during meta generation to
+ * resolve original-source positions. But they are dead weight in a PUBLISHED package —
+ * they reference `.ts` sources the tarball does not ship — and they leak local source
+ * paths, so the prod build strips them AFTER meta generation has consumed them. The dev
+ * build keeps them (it is never published, and `savvy build --target meta` reads them).
+ *
+ * Recurses, but skips `node_modules` so it does not traverse a self-contained bundle's
+ * vendored tree — only the package's own emitted declarations carry maps worth stripping.
+ */
+declare function removeDeclarationMaps(pkgDir: string): string[];
+//#endregion
+//#region src/build/sync-public.d.ts
+/**
+ * Mirror `sourceDir` into `targetDir`, idempotently.
+ *
+ * Replaces tsdown's built-in `copy`, whose non-recursive mkdir throws `EEXIST` when the target
+ * already exists (re-builds, `prepare`-on-install, concurrent turbo invocations). Behavior:
+ *
+ * - source absent: no-op.
+ * - target absent: copy `sourceDir` wholesale.
+ * - target present: copy only files that are new or whose bytes differ, then delete target files
+ *   that no longer exist in the source and prune the directories left empty.
+ *
+ * The byte-diff keeps unchanged files (and their timestamps) untouched, so a large copied asset
+ * tree — e.g. the mcp markdown corpus — is not rewritten on every build.
+ */
+declare function syncPublicDir(sourceDir: string, targetDir: string): void;
+//#endregion
+//#region src/catalog/resolve-catalogs.d.ts
+/**
+ * Resolve every `catalog:`/`workspace:` specifier in a manifest to a concrete spec,
+ * delegating to workspaces-effect's CatalogResolver. The resolver discovers the
+ * workspace root from `process.cwd()` (run this from inside the target workspace)
+ * and assembles catalogs durably (inline + config-dependency hook-replay + lockfile),
+ * so no transient `.pnpm-workspace-state-v1.json` is required.
+ *
+ * Rejects with `CatalogResolutionError` on an unresolvable reference, or
+ * `CatalogAssemblyError` if the workspace catalog set cannot be assembled.
+ */
+declare function resolveManifest(pkg: ManifestLike$1): Promise<ManifestLike$1>;
+//#endregion
+//#region src/errors.d.ts
+declare const MetaGenerationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "MetaGenerationError";
+} & Readonly<A>;
+/** API Extractor meta generation failed for an entry. */
+declare class MetaGenerationError extends MetaGenerationError_base<{
+  readonly entry: string;
+  readonly reason: string;
+}> {
+  get message(): string;
+}
+declare const ConfigValidationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "ConfigValidationError";
+} & Readonly<A>;
+/** A savvy.build.ts or publishConfig.targets config is structurally invalid; raised before any build work. */
+declare class ConfigValidationError extends ConfigValidationError_base<{
+  readonly path: string;
+  readonly reason: string;
+}> {
+  get message(): string;
+}
+//#endregion
+//#region src/exe/config.d.ts
+/** Default Node runtime embedded in the SEA (parity with the vitest-agent reference). */
+declare const DEFAULT_EXE_NODE_VERSION = "25.9.0";
+/** A resolved per-platform SEA target. `platform` uses the tsdown/\@tsdown/exe token (win, not win32). */
+interface ExeTarget {
+  readonly platform: "darwin" | "linux" | "win";
+  readonly arch: "arm64" | "x64";
+  readonly nodeVersion: string;
+}
+/** A target before nodeVersion defaulting (platform/arch only). */
+interface ExeTargetInput {
+  readonly platform: "darwin" | "linux" | "win";
+  readonly arch: "arm64" | "x64";
+}
+/** SEA seaConfig overrides (subset; the rest are defaulted). */
+interface ExeSeaConfig {
+  readonly disableExperimentalSEAWarning?: boolean | undefined;
+  readonly useCodeCache?: boolean | undefined;
+  readonly useSnapshot?: boolean | undefined;
+}
+/** One SEA binary to compile. */
+interface ExeConfig {
+  /** Output binary basename (no extension/suffix). */
+  readonly fileName: string;
+  /** Bin entry; defaults to ./src/bin.ts. */
+  readonly entry?: string | undefined;
+  /** Node runtime to embed; defaults to DEFAULT_EXE_NODE_VERSION. */
+  readonly nodeVersion?: string | undefined;
+  /** seaConfig overrides merged over the defaults. */
+  readonly seaConfig?: ExeSeaConfig | undefined;
+  /** Explicit targets; default inferred from the package os/cpu. */
+  readonly targets?: ReadonlyArray<ExeTargetInput> | undefined;
+}
+/** Fully-resolved SEA binary spec (no optionals). */
+interface NormalizedExe {
+  readonly fileName: string;
+  readonly entry: string;
+  readonly targets: ReadonlyArray<ExeTarget>;
+  readonly seaConfig: {
+    readonly disableExperimentalSEAWarning: boolean;
+    readonly useCodeCache: boolean;
+    readonly useSnapshot: boolean;
+  };
+}
+/** The package's own os/cpu fields, used to infer a single platform target. */
+interface PkgOsCpu {
+  readonly os: ReadonlyArray<string>;
+  readonly cpu: ReadonlyArray<string>;
+}
+/**
+ * Normalize `exe` (object or array) into one fully-resolved spec per binary.
+ *
+ * Pure function; structural validation (missing fileName, empty targets) lives in the
+ * config-validation layer.
+ */
+declare function normalizeExeOptions(exe: ExeConfig | ReadonlyArray<ExeConfig>, pkg: PkgOsCpu): ReadonlyArray<NormalizedExe>;
+//#endregion
+//#region src/meta/config.d.ts
+/** A single TSDoc tag definition (parity with api-extractor's TSDoc config). */
+interface TsdocTagDefinition {
+  readonly tagName: string;
+  readonly syntaxKind: "block" | "inline" | "modifier";
+  readonly allowMultiple?: boolean | undefined;
+}
+/** An api-extractor message-suppression rule. messageId is exact-matched; pattern (regex or substring) is AND-matched against the text. */
+interface WarningSuppressionRule {
+  readonly messageId: string;
+  readonly pattern?: string | undefined;
+}
+/** TSDoc / doc-warning configuration. suppressWarnings is doc functionality, so it lives here. */
+interface TsdocOptions {
+  readonly suppressWarnings?: ReadonlyArray<WarningSuppressionRule> | undefined;
+  readonly tagDefinitions?: ReadonlyArray<TsdocTagDefinition> | undefined;
+}
+/** The `meta` field on defineBuild. Absent means no api-model generation. */
+interface MetaOptions {
+  /** Directories to copy the api-model into on `savvy build --target meta`. */
+  readonly localPaths?: ReadonlyArray<string> | undefined;
+  readonly tsdoc?: TsdocOptions | undefined;
+}
+/** Fully-resolved meta options (no optionals). */
+interface NormalizedMeta {
+  readonly localPaths: ReadonlyArray<string>;
+  readonly tsdoc: {
+    readonly suppressWarnings: ReadonlyArray<WarningSuppressionRule>;
+    readonly tagDefinitions: ReadonlyArray<TsdocTagDefinition>;
+  };
+}
+/** Fill defaults so downstream code never branches on undefined. */
+declare function normalizeMetaOptions(meta: MetaOptions): NormalizedMeta;
+//#endregion
+//#region src/targets/config.d.ts
+/** A single object-form publish target. Uses `from` XOR `name` (never both). */
+interface PublishTargetObject {
+  /** Registry endpoint. Required for custom keys; defaulted for `npm`/`github`. */
+  readonly registry?: string | undefined;
+  /** Name override for this target's own group. Mutually exclusive with `from`. */
+  readonly name?: string | undefined;
+  /** Reuse another target's group bytes (deploy them to this registry). Mutually exclusive with `name`. */
+  readonly from?: string | undefined;
+}
+/** A `publishConfig.targets` value: `true` (well-known registry, base name), a string (name override), or an object. */
+type PublishTargetValue = true | string | PublishTargetObject;
+/** The `publishConfig.targets` map, keyed by target id (`npm`, `github`, or a custom key). */
+type PublishTargets = Record<string, PublishTargetValue>;
+/** A distinct byte-variant build group (one per distinct resolved name). */
+interface ResolvedGroup {
+  /** Folder id; the group's output dir nests this id under dist/prod, with a pkg subfolder. */
+  readonly id: string;
+  /** The `package.json.name` this group's manifest carries. */
+  readonly name: string;
+  /** The group's pkg output dir, relative to the package root. */
+  readonly dir: string;
+}
+/** A resolved registry target (one per `publishConfig.targets` key). */
+interface ResolvedTarget {
+  /** The `publishConfig.targets` key. */
+  readonly id: string;
+  /** The group id whose bytes this target deploys. */
+  readonly group: string;
+  /** The resolved name for that group. */
+  readonly name: string;
+  /** The resolved registry endpoint. */
+  readonly registry: string;
+}
+/** The full resolution of `publishConfig.targets`: the distinct groups to build, and every target bound to one. */
+interface TargetResolution {
+  readonly groups: ReadonlyArray<ResolvedGroup>;
+  readonly targets: ReadonlyArray<ResolvedTarget>;
+}
+/** True when a target value is the object form (carries registry/name/from). */
+declare function isTargetObject(value: PublishTargetValue): value is PublishTargetObject;
+//#endregion
+//#region src/config-validation/ConfigValidator.d.ts
+/** The normalized facts the validator checks, assembled by the bundler before any build work. */
+interface ValidationInput {
+  readonly baseName: string;
+  /** Whether the package declares an exports map (for the model-without-exports cross-field rule). */
+  readonly hasExports: boolean;
+  readonly targets?: PublishTargets | undefined;
+  readonly exe?: ExeConfig | ReadonlyArray<ExeConfig> | undefined;
+  readonly osCpu?: {
+    readonly os: ReadonlyArray<string>;
+    readonly cpu: ReadonlyArray<string>;
+  } | undefined;
+  readonly meta?: MetaOptions | undefined;
+}
+declare const ConfigValidator_base: Context.TagClass<ConfigValidator, "@savvy-web/tsdown-plugins/ConfigValidator", {
+  readonly validate: (input: ValidationInput) => Effect.Effect<void, ConfigValidationError>;
+}>;
+/** Fast-fail config validator; runs first in the bundler over the resolved config. */
+declare class ConfigValidator extends ConfigValidator_base {}
+//#endregion
+//#region src/config-validation/ConfigValidatorLive.d.ts
+/** Live ConfigValidator: wraps the synchronous rule set, surfacing ConfigValidationError as a typed Effect failure. */
+declare const ConfigValidatorLive: Layer.Layer<ConfigValidator, never, never>;
+//#endregion
+//#region src/dts/resolved-tsconfig.d.ts
+interface ResolvedTsconfigOptions {
+  /** Absolute package root. */
+  readonly cwd: string;
+  /** Explicit `types` to forward (default ["node"]). Pulled from the project tsconfig by the caller. */
+  readonly types?: ReadonlyArray<string> | undefined;
+  /** TS `compilerOptions.jsx` to forward into the dts tsconfig (e.g. "react-jsx"). */
+  readonly jsx?: string | undefined;
+  /** TS `compilerOptions.jsxImportSource` to forward (e.g. "react"). */
+  readonly jsxImportSource?: string | undefined;
+}
+interface ResolvedTsconfig {
+  readonly compilerOptions: Record<string, unknown>;
+  readonly include: ReadonlyArray<string>;
+  readonly exclude: ReadonlyArray<string>;
+}
+/** Build the portable absolute-path tsconfig object (ported from rslib writeBundleTempConfig). */
+declare function buildResolvedTsconfig(options: ResolvedTsconfigOptions): ResolvedTsconfig;
+/** Write the resolved tsconfig to a temp file and return its absolute path. */
+declare function writeResolvedTsconfig(options: ResolvedTsconfigOptions): string;
+//#endregion
+//#region src/entry/extract.d.ts
+interface PackageJsonLike {
+  readonly exports?: unknown;
+  readonly bin?: unknown;
+}
+interface ExtractOptions {
+  readonly exportsAsIndexes?: boolean | undefined;
+}
+interface ExtractResult {
+  /** entry name to TS source path */
+  readonly entries: Record<string, string>;
+  /** entry name to original export key (for downstream output-map alignment) */
+  readonly exportPaths: Record<string, string>;
+}
+/**
+ * Map an export key to the tsdown entry name (the emitted output basename).
+ *
+ * `.` becomes `index`; otherwise the leading `./` is stripped and, unless
+ * `exportsAsIndexes` is set, nested slashes are flattened to dashes
+ * (e.g. `./changesets/markdownlint` to `changesets-markdownlint`). The manifest
+ * transform reuses this so the declared output path always matches the emitted file.
+ *
+ * @internal
+ */
+declare const createEntryName: (exportKey: string, exportsAsIndexes: boolean) => string;
+declare function extractEntries(pkg: PackageJsonLike, options?: ExtractOptions): ExtractResult;
+//#endregion
+//#region src/entry/package-json-entries.d.ts
+interface PackageJsonEntriesOptions extends ExtractOptions {
+  /** In-memory package.json. If omitted, reads `<cwd>/package.json`. */
+  readonly pkg?: PackageJsonLike;
+  /** Working directory for reading package.json. Defaults to process.cwd(). */
+  readonly cwd?: string;
+}
+/** Derive a tsdown `entry` record (name to source path) from a package.json. */
+declare function packageJsonEntries(options?: PackageJsonEntriesOptions): Record<string, string>;
+//#endregion
+//#region src/exe/build.d.ts
+/** A minimal structural type for tsdown's build, kept loose so this package keeps no tsdown runtime dep (interface-only). */
+type ExeBuild = (config: unknown) => Promise<unknown>;
+/** Options for compiling SEA binaries. */
+interface RunExeBuildOptions {
+  readonly cwd: string;
+  /** Directory the binaries are emitted into (e.g. dist/dev/pkg/bin). */
+  readonly outDir: string;
+  /** One fully-resolved spec per binary. */
+  readonly specs: ReadonlyArray<NormalizedExe>;
+  /** Injectable tsdown build (defaults to tsdown's build function). */
+  readonly build?: ExeBuild | undefined;
+}
+/** Compile each SEA binary via tsdown's exe mode. One tsdown build per spec. */
+declare function runExeBuild(options: RunExeBuildOptions): Promise<void>;
+//#endregion
+//#region src/meta/generate.d.ts
+interface GenerateMetaOptions {
+  readonly cwd: string;
+  readonly packageName: string;
+  /** Resolved tsconfig (from writeResolvedTsconfig) for the api-extractor compiler. */
+  readonly tsconfigPath: string;
+  /** Directory holding the tsdown-emitted per-file .d.ts (e.g. dist/dev/pkg). */
+  readonly dtsDir: string;
+  /** Map of entry name to the .d.ts basename (without extension) inside dtsDir. */
+  readonly entries: Record<string, string>;
+  /** Map of entry name to its export path (".", "./sub"). */
+  readonly exportPaths: Record<string, string>;
+  /** Where to write the meta bundle (.api.json + package.json + tsconfig.json). */
+  readonly outMetaDir: string;
+  /** Directories (relative to cwd) to copy the meta bundle into. */
+  readonly localPaths: ReadonlyArray<string>;
+  readonly tsdoc: NormalizedMeta["tsdoc"];
+}
+interface MetaResult {
+  readonly apiJsonPath: string;
+  readonly apiJsonFilename: string;
+}
+/**
+ * Generate the api-model meta bundle from already-emitted .d.ts. Writes tsdoc.json (idempotent),
+ * runs the extractor per entry, merges if needed, and writes the "virtual TS env" trio to
+ * outMetaDir (`<unscoped>.api.json` + the final `package.json` + a portable `tsconfig.json`),
+ * copying that trio into each localPaths dir. The api-extractor `tsdoc-metadata.json` is a
+ * published-package artifact and is written into `dtsDir` (the built pkg/), not the meta bundle.
+ */
+declare function generateMeta(options: GenerateMetaOptions): Promise<MetaResult>;
+//#endregion
+//#region src/meta/tsconfig-resolver.d.ts
+/**
+ * Compiler options with enum values converted to their string equivalents.
+ *
+ * @remarks
+ * Open-ended record because TypeScript compiler options vary by version.
+ *
+ * @public
+ */
+interface ResolvedCompilerOptions {
+  [key: string]: unknown;
+}
+/**
+ * Portable, JSON-serializable tsconfig.json (compilerOptions-only).
+ *
+ * @remarks
+ * Designed for virtual TypeScript environments (shiki/Twoslash, API Extractor)
+ * where file paths and emit settings are controlled externally. Holds no
+ * machine-specific absolute paths and no emit/path/file-selection options.
+ *
+ * @public
+ */
+interface PortableTsconfig {
+  /** JSON schema for IDE support. */
+  $schema: string;
+  /** Compiler options with enum values converted to strings. */
+  compilerOptions: ResolvedCompilerOptions;
+}
+/**
+ * Resolves a TypeScript `ParsedCommandLine` to a portable, JSON-serializable
+ * tsconfig (compilerOptions-only) for virtual TypeScript environments.
+ *
+ * @remarks
+ * Converts TypeScript's internal enum representation back to portable JSON
+ * suitable for tooling that needs type information without emitting files:
+ *
+ * - Converts enum values (target, module, moduleResolution, jsx, etc.) to strings.
+ * - Converts lib references from full paths (`lib.esnext.d.ts`) to short names (`esnext`).
+ * - Forces `composite: false` and `noEmit: true`.
+ * - Excludes path-dependent options (rootDir, outDir, baseUrl, paths, typeRoots, types).
+ * - Excludes emit-related options (declaration, sourceMap, etc.).
+ * - Excludes file selection (include, exclude, files, references).
+ * - Adds `$schema` for IDE support.
+ *
+ * @public
+ */
+declare class TsconfigResolver {
+  /** @internal */
+  private static readonly SCRIPT_TARGET_MAP;
+  /** @internal */
+  private static readonly MODULE_KIND_MAP;
+  /** @internal */
+  private static readonly MODULE_RESOLUTION_MAP;
+  /** @internal */
+  private static readonly JSX_EMIT_MAP;
+  /** @internal */
+  private static readonly MODULE_DETECTION_MAP;
+  /** @internal */
+  private static readonly NEW_LINE_MAP;
+  /** Converts a {@link ScriptTarget} enum value to its string form (e.g. `es2023`). */
+  static convertScriptTarget(target: ScriptTarget | undefined): string | undefined;
+  /** Converts a {@link ModuleKind} enum value to its string form (e.g. `nodenext`). */
+  static convertModuleKind(module: ModuleKind | undefined): string | undefined;
+  /** Converts a {@link ModuleResolutionKind} enum value to its string form (e.g. `nodenext`). */
+  static convertModuleResolution(resolution: ModuleResolutionKind | undefined): string | undefined;
+  /** Converts a {@link JsxEmit} enum value to its string form (e.g. `preserve`, `react-jsx`). */
+  static convertJsxEmit(jsx: JsxEmit | undefined): string | undefined;
+  /** Converts a {@link ModuleDetectionKind} enum value to its string form (e.g. `force`). */
+  static convertModuleDetection(detection: ModuleDetectionKind | undefined): string | undefined;
+  /** Converts a {@link NewLineKind} enum value to its string form (`lf` or `crlf`). */
+  static convertNewLine(newLine: NewLineKind | undefined): string | undefined;
+  /**
+   * Converts a lib reference to its canonical short name.
+   *
+   * @remarks
+   * `ParsedCommandLine` stores lib references as full paths like `lib.esnext.d.ts`
+   * or `/path/to/typescript/lib/lib.dom.d.ts`. This returns the short tsconfig form
+   * (`esnext`, `dom`).
+   */
+  static convertLibReference(lib: string): string;
+  /**
+   * Resolves a parsed TypeScript config to a portable, compilerOptions-only tsconfig.
+   */
+  resolve(parsed: ParsedCommandLine): PortableTsconfig;
+}
+/**
+ * Resolves the package's effective compiler options (following `extends`) into a
+ * portable, JSON-serializable tsconfig for the meta release bundle.
+ *
+ * @remarks
+ * Resolves the package's own `<cwd>/tsconfig.json` (which extends the shared
+ * `@savvy-web/bundler/ecma.json` base) via the TypeScript API so the result
+ * carries the full effective options (target/module/strict/jsx/lib), then
+ * converts them to a portable, compilerOptions-only shape with no absolute
+ * paths or emit/file-selection options.
+ *
+ * When the package has no own `tsconfig.json` (e.g. a minimal test fixture),
+ * falls back to `fallbackConfigPath` — the build's already-resolved dts tsconfig,
+ * which always exists during a build. If neither is present, returns a minimal
+ * portable config carrying only the virtual-environment flags.
+ *
+ * @param cwd - Absolute package root.
+ * @param fallbackConfigPath - Optional resolved tsconfig to use when the package has no own one.
+ * @returns The portable tsconfig object.
+ *
+ * @public
+ */
+declare function resolvePortableTsconfig(cwd: string, fallbackConfigPath?: string): PortableTsconfig;
+//#endregion
+//#region src/report/schema.d.ts
+declare const ReportTimings: Schema.Struct<{
+  totalMs: typeof Schema.Number;
+}>;
+declare const TargetGroupReport: Schema.Struct<{
+  id: typeof Schema.String;
+  entries: Schema.Array$<typeof Schema.String>;
+  emittedFiles: Schema.Array$<typeof Schema.String>;
+  timings: Schema.Struct<{
+    totalMs: typeof Schema.Number;
+  }>;
+  warnings: Schema.Array$<typeof Schema.String>;
+  errors: Schema.Array$<typeof Schema.String>;
+}>;
+declare const BuildReport: Schema.Struct<{
+  package: typeof Schema.String;
+  targetGroups: Schema.Array$<Schema.Struct<{
+    id: typeof Schema.String;
+    entries: Schema.Array$<typeof Schema.String>;
+    emittedFiles: Schema.Array$<typeof Schema.String>;
+    timings: Schema.Struct<{
+      totalMs: typeof Schema.Number;
+    }>;
+    warnings: Schema.Array$<typeof Schema.String>;
+    errors: Schema.Array$<typeof Schema.String>;
+  }>>;
+}>;
+type BuildReport = typeof BuildReport.Type;
+type TargetGroupReport = typeof TargetGroupReport.Type;
+//#endregion
+//#region src/report/formatters/types.d.ts
+interface RenderedOutput {
+  readonly target: "stdout" | "file" | "github-summary";
+  readonly content: string;
+  readonly contentType: string;
+}
+interface FormatterContext {
+  readonly noColor: boolean;
+}
+interface Formatter {
+  readonly format: string;
+  readonly render: (reports: ReadonlyArray<BuildReport>, ctx: FormatterContext) => ReadonlyArray<RenderedOutput>;
+}
+//#endregion
+//#region src/report/formatters/ci-annotations.d.ts
+declare const CiAnnotationsFormatter: Formatter;
+//#endregion
+//#region src/report/formatters/json.d.ts
+declare const JsonFormatter: Formatter;
+//#endregion
+//#region src/report/formatters/markdown.d.ts
+declare const MarkdownFormatter: Formatter;
+//#endregion
+//#region src/report/formatters/silent.d.ts
+declare const SilentFormatter: Formatter;
+//#endregion
+//#region src/report/formatters/terminal.d.ts
+declare const TerminalFormatter: Formatter;
+//#endregion
+//#region src/report/services/EnvironmentDetector.d.ts
+type Environment = "agent-shell" | "terminal" | "ci-github" | "ci-generic";
+declare const EnvironmentDetector_base: Context.TagClass<EnvironmentDetector, "@savvy-web/tsdown-plugins/EnvironmentDetector", {
+  readonly detect: () => Effect.Effect<Environment>;
+}>;
+declare class EnvironmentDetector extends EnvironmentDetector_base {}
+//#endregion
+//#region src/report/layers/EnvironmentDetectorLive.d.ts
+declare const EnvironmentDetectorLive: Layer.Layer<EnvironmentDetector, never, never>;
+//#endregion
+//#region src/report/services/ExecutorResolver.d.ts
+type Executor = "human" | "agent" | "ci";
+declare const ExecutorResolver_base: Context.TagClass<ExecutorResolver, "@savvy-web/tsdown-plugins/ExecutorResolver", {
+  readonly resolve: (env: Environment) => Effect.Effect<Executor>;
+}>;
+declare class ExecutorResolver extends ExecutorResolver_base {}
+//#endregion
+//#region src/report/layers/ExecutorResolverLive.d.ts
+declare const ExecutorResolverLive: Layer.Layer<ExecutorResolver, never, never>;
+//#endregion
+//#region src/report/services/FormatSelector.d.ts
+type OutputFormat = "terminal" | "json" | "markdown" | "ci-annotations" | "silent";
+declare const FormatSelector_base: Context.TagClass<FormatSelector, "@savvy-web/tsdown-plugins/FormatSelector", {
+  readonly select: (executor: Executor, explicit?: OutputFormat, env?: Environment) => Effect.Effect<OutputFormat>;
+}>;
+declare class FormatSelector extends FormatSelector_base {}
+//#endregion
+//#region src/report/layers/FormatSelectorLive.d.ts
+declare const FormatSelectorLive: Layer.Layer<FormatSelector, never, never>;
+//#endregion
+//#region src/report/services/OutputRenderer.d.ts
+declare const OutputRenderer_base: Context.TagClass<OutputRenderer, "@savvy-web/tsdown-plugins/OutputRenderer", {
+  readonly render: (reports: ReadonlyArray<BuildReport>, format: OutputFormat, ctx: FormatterContext) => Effect.Effect<ReadonlyArray<RenderedOutput>>;
+}>;
+declare class OutputRenderer extends OutputRenderer_base {}
+//#endregion
+//#region src/report/layers/OutputRendererLive.d.ts
+declare const OutputRendererLive: Layer.Layer<OutputRenderer, never, never>;
+//#endregion
+//#region src/report/pipeline.d.ts
+declare const ReportPipelineLive: Layer.Layer<EnvironmentDetector | ExecutorResolver | FormatSelector | OutputRenderer, never, never>;
+interface RenderReportOptions {
+  readonly explicitFormat?: OutputFormat;
+  /** Override env detection (mainly for tests). */
+  readonly env?: Environment;
+  readonly noColor: boolean;
+}
+declare const renderReport: (reports: ReadonlyArray<BuildReport>, options: RenderReportOptions) => Effect.Effect<ReadonlyArray<RenderedOutput>, never, EnvironmentDetector | ExecutorResolver | FormatSelector | OutputRenderer>;
+//#endregion
+//#region ../../node_modules/.pnpm/@effect+platform@0.96.1_effect@3.21.3/node_modules/@effect/platform/dist/dts/Error.d.ts
+/**
+ * @since 1.0.0
+ * @category type id
+ */
+declare const TypeId: unique symbol;
+/**
+ * @since 1.0.0
+ * @category type id
+ */
+type TypeId = typeof TypeId;
+declare const BadArgument_base: Schema$1.TaggedErrorClass<BadArgument, "BadArgument", {
+  readonly _tag: Schema$1.tag<"BadArgument">;
+} & {
+  module: Schema$1.Literal<["Clipboard", "Command", "FileSystem", "KeyValueStore", "Path", "Stream", "Terminal"]>;
+  method: typeof Schema$1.String;
+  description: Schema$1.optional<typeof Schema$1.String>;
+  cause: Schema$1.optional<typeof Schema$1.Defect>;
+}>;
+/**
+ * @since 1.0.0
+ * @category Models
+ */
+declare class BadArgument extends BadArgument_base {
+  /**
+   * @since 1.0.0
+   */
+  readonly [TypeId]: typeof TypeId;
+  /**
+   * @since 1.0.0
+   */
+  get message(): string;
+}
+declare const SystemError_base: Schema$1.TaggedErrorClass<SystemError, "SystemError", {
+  readonly _tag: Schema$1.tag<"SystemError">;
+} & {
+  reason: Schema$1.Literal<["AlreadyExists", "BadResource", "Busy", "InvalidData", "NotFound", "PermissionDenied", "TimedOut", "UnexpectedEof", "Unknown", "WouldBlock", "WriteZero"]>;
+  module: Schema$1.Literal<["Clipboard", "Command", "FileSystem", "KeyValueStore", "Path", "Stream", "Terminal"]>;
+  method: typeof Schema$1.String;
+  description: Schema$1.optional<typeof Schema$1.String>;
+  syscall: Schema$1.optional<typeof Schema$1.String>;
+  pathOrDescriptor: Schema$1.optional<Schema$1.Union<[typeof Schema$1.String, typeof Schema$1.Number]>>;
+  cause: Schema$1.optional<typeof Schema$1.Defect>;
+}>;
+/**
+ * @since 1.0.0
+ * @category models
+ */
+declare class SystemError extends SystemError_base {
+  /**
+   * @since 1.0.0
+   */
+  readonly [TypeId]: typeof TypeId;
+  /**
+   * @since 1.0.0
+   */
+  get message(): string;
+}
+/**
+ * @since 1.0.0
+ * @category Models
+ */
+type PlatformError = BadArgument | SystemError;
+/**
+ * @since 1.0.0
+ * @category Models
+ */
+declare const PlatformError: Schema$1.Union<[typeof BadArgument, typeof SystemError]>;
+//#endregion
+//#region ../../node_modules/.pnpm/@effect+platform@0.96.1_effect@3.21.3/node_modules/@effect/platform/dist/dts/FileSystem.d.ts
+/**
+ * @since 1.0.0
+ * @category model
+ */
+interface FileSystem {
+  /**
+   * Check if a file can be accessed.
+   * You can optionally specify the level of access to check for.
+   */
+  readonly access: (path: string, options?: AccessFileOptions) => Effect$1.Effect<void, PlatformError>;
+  /**
+   * Copy a file or directory from `fromPath` to `toPath`.
+   *
+   * Equivalent to `cp -r`.
+   */
+  readonly copy: (fromPath: string, toPath: string, options?: CopyOptions) => Effect$1.Effect<void, PlatformError>;
+  /**
+   * Copy a file from `fromPath` to `toPath`.
+   */
+  readonly copyFile: (fromPath: string, toPath: string) => Effect$1.Effect<void, PlatformError>;
+  /**
+   * Change the permissions of a file.
+   */
+  readonly chmod: (path: string, mode: number) => Effect$1.Effect<void, PlatformError>;
+  /**
+   * Change the owner and group of a file.
+   */
+  readonly chown: (path: string, uid: number, gid: number) => Effect$1.Effect<void, PlatformError>;
+  /**
+   * Check if a path exists.
+   */
+  readonly exists: (path: string) => Effect$1.Effect<boolean, PlatformError>;
+  /**
+   * Create a hard link from `fromPath` to `toPath`.
+   */
+  readonly link: (fromPath: string, toPath: string) => Effect$1.Effect<void, PlatformError>;
+  /**
+   * Create a directory at `path`. You can optionally specify the mode and
+   * whether to recursively create nested directories.
+   */
+  readonly makeDirectory: (path: string, options?: MakeDirectoryOptions) => Effect$1.Effect<void, PlatformError>;
+  /**
+   * Create a temporary directory.
+   *
+   * By default the directory will be created inside the system's default
+   * temporary directory, but you can specify a different location by setting
+   * the `directory` option.
+   *
+   * You can also specify a prefix for the directory name by setting the
+   * `prefix` option.
+   */
+  readonly makeTempDirectory: (options?: MakeTempDirectoryOptions) => Effect$1.Effect<string, PlatformError>;
+  /**
+   * Create a temporary directory inside a scope.
+   *
+   * Functionally equivalent to `makeTempDirectory`, but the directory will be
+   * automatically deleted when the scope is closed.
+   */
+  readonly makeTempDirectoryScoped: (options?: MakeTempDirectoryOptions) => Effect$1.Effect<string, PlatformError, Scope>;
+  /**
+   * Create a temporary file.
+   * The directory creation is functionally equivalent to `makeTempDirectory`.
+   * The file name will be a randomly generated string.
+   */
+  readonly makeTempFile: (options?: MakeTempFileOptions) => Effect$1.Effect<string, PlatformError>;
+  /**
+   * Create a temporary file inside a scope.
+   *
+   * Functionally equivalent to `makeTempFile`, but the file will be
+   * automatically deleted when the scope is closed.
+   */
+  readonly makeTempFileScoped: (options?: MakeTempFileOptions) => Effect$1.Effect<string, PlatformError, Scope>;
+  /**
+   * Open a file at `path` with the specified `options`.
+   *
+   * The file handle will be automatically closed when the scope is closed.
+   */
+  readonly open: (path: string, options?: OpenFileOptions) => Effect$1.Effect<File$1, PlatformError, Scope>;
+  /**
+   * List the contents of a directory.
+   *
+   * You can recursively list the contents of nested directories by setting the
+   * `recursive` option.
+   */
+  readonly readDirectory: (path: string, options?: ReadDirectoryOptions) => Effect$1.Effect<Array<string>, PlatformError>;
+  /**
+   * Read the contents of a file.
+   */
+  readonly readFile: (path: string) => Effect$1.Effect<Uint8Array, PlatformError>;
+  /**
+   * Read the contents of a file.
+   */
+  readonly readFileString: (path: string, encoding?: string) => Effect$1.Effect<string, PlatformError>;
+  /**
+   * Read the destination of a symbolic link.
+   */
+  readonly readLink: (path: string) => Effect$1.Effect<string, PlatformError>;
+  /**
+   * Resolve a path to its canonicalized absolute pathname.
+   */
+  readonly realPath: (path: string) => Effect$1.Effect<string, PlatformError>;
+  /**
+   * Remove a file or directory.
+   */
+  readonly remove: (path: string, options?: RemoveOptions) => Effect$1.Effect<void, PlatformError>;
+  /**
+   * Rename a file or directory.
+   */
+  readonly rename: (oldPath: string, newPath: string) => Effect$1.Effect<void, PlatformError>;
+  /**
+   * Create a writable `Sink` for the specified `path`.
+   */
+  readonly sink: (path: string, options?: SinkOptions) => Sink<void, Uint8Array, never, PlatformError>;
+  /**
+   * Get information about a file at `path`.
+   */
+  readonly stat: (path: string) => Effect$1.Effect<File$1.Info, PlatformError>;
+  /**
+   * Create a readable `Stream` for the specified `path`.
+   *
+   * Changing the `bufferSize` option will change the internal buffer size of
+   * the stream. It defaults to `4`.
+   *
+   * The `chunkSize` option will change the size of the chunks emitted by the
+   * stream. It defaults to 64kb.
+   *
+   * Changing `offset` and `bytesToRead` will change the offset and the number
+   * of bytes to read from the file.
+   */
+  readonly stream: (path: string, options?: StreamOptions) => Stream<Uint8Array, PlatformError>;
+  /**
+   * Create a symbolic link from `fromPath` to `toPath`.
+   */
+  readonly symlink: (fromPath: string, toPath: string) => Effect$1.Effect<void, PlatformError>;
+  /**
+   * Truncate a file to a specified length. If the `length` is not specified,
+   * the file will be truncated to length `0`.
+   */
+  readonly truncate: (path: string, length?: SizeInput) => Effect$1.Effect<void, PlatformError>;
+  /**
+   * Change the file system timestamps of the file at `path`.
+   */
+  readonly utimes: (path: string, atime: Date | number, mtime: Date | number) => Effect$1.Effect<void, PlatformError>;
+  /**
+   * Watch a directory or file for changes.
+   *
+   * By default, only changes to the direct children of the directory are reported.
+   * Set the `recursive` option to `true` to watch for changes in subdirectories as well.
+   *
+   * Note: The `recursive` option behavior depends on the backend implementation:
+   * - When using the default Node.js `fs.watch()` backend: The `recursive`
+   *   option is supported on all platforms (Node.js v20+).
+   * - When using `@parcel/watcher` (via `NodeFileSystem/ParcelWatcher` layer):
+   *   Watching is always recursive on all platforms. This option is ignored.
+   */
+  readonly watch: (path: string, options?: WatchOptions) => Stream<WatchEvent, PlatformError>;
+  /**
+   * Write data to a file at `path`.
+   */
+  readonly writeFile: (path: string, data: Uint8Array, options?: WriteFileOptions) => Effect$1.Effect<void, PlatformError>;
+  /**
+   * Write a string to a file at `path`.
+   */
+  readonly writeFileString: (path: string, data: string, options?: WriteFileStringOptions) => Effect$1.Effect<void, PlatformError>;
+}
+/**
+ * Represents a size in bytes.
+ *
+ * @since 1.0.0
+ * @category sizes
+ */
+type Size = Brand.Branded<bigint, "Size">;
+/**
+ * Represents a size in bytes.
+ *
+ * @since 1.0.0
+ * @category sizes
+ */
+type SizeInput = bigint | number | Size;
+/**
+ * @since 1.0.0
+ * @category sizes
+ */
+declare const Size: (bytes: SizeInput) => Size;
+/**
+ * @since 1.0.0
+ * @category model
+ */
+type OpenFlag = "r" | "r+" | "w" | "wx" | "w+" | "wx+" | "a" | "ax" | "a+" | "ax+";
+/**
+ * @since 1.0.0
+ * @category options
+ */
+interface AccessFileOptions {
+  readonly ok?: boolean;
+  readonly readable?: boolean;
+  readonly writable?: boolean;
+}
+/**
+ * @since 1.0.0
+ * @category options
+ */
+interface MakeDirectoryOptions {
+  readonly recursive?: boolean;
+  readonly mode?: number;
+}
+/**
+ * @since 1.0.0
+ * @category options
+ */
+interface CopyOptions {
+  readonly overwrite?: boolean;
+  readonly preserveTimestamps?: boolean;
+}
+/**
+ * @since 1.0.0
+ * @category options
+ */
+interface MakeTempDirectoryOptions {
+  readonly directory?: string;
+  readonly prefix?: string;
+}
+/**
+ * @since 1.0.0
+ * @category options
+ */
+interface MakeTempFileOptions {
+  readonly directory?: string;
+  readonly prefix?: string;
+  readonly suffix?: string;
+}
+/**
+ * @since 1.0.0
+ * @category options
+ */
+interface OpenFileOptions {
+  readonly flag?: OpenFlag;
+  readonly mode?: number;
+}
+/**
+ * @since 1.0.0
+ * @category options
+ */
+interface ReadDirectoryOptions {
+  readonly recursive?: boolean;
+}
+/**
+ * @since 1.0.0
+ * @category options
+ */
+interface RemoveOptions {
+  /**
+   * When `true`, you can recursively remove nested directories.
+   */
+  readonly recursive?: boolean;
+  /**
+   * When `true`, exceptions will be ignored if `path` does not exist.
+   */
+  readonly force?: boolean;
+}
+/**
+ * @since 1.0.0
+ * @category options
+ */
+interface SinkOptions extends OpenFileOptions {}
+/**
+ * @since 1.0.0
+ * @category options
+ */
+interface StreamOptions {
+  readonly bufferSize?: number;
+  readonly bytesToRead?: SizeInput;
+  readonly chunkSize?: SizeInput;
+  readonly offset?: SizeInput;
+}
+/**
+ * @since 1.0.0
+ * @category options
+ */
+interface WriteFileOptions {
+  readonly flag?: OpenFlag;
+  readonly mode?: number;
+}
+/**
+ * @since 1.0.0
+ * @category options
+ */
+interface WriteFileStringOptions {
+  readonly flag?: OpenFlag;
+  readonly mode?: number;
+}
+/**
+ * @since 1.0.0
+ * @category options
+ */
+interface WatchOptions {
+  /**
+   * When `true`, the watcher will also watch for changes in subdirectories.
+   */
+  readonly recursive?: boolean;
+}
+/**
+ * @since 1.0.0
+ * @category tag
+ */
+declare const FileSystem: Tag<FileSystem, FileSystem>;
+/**
+ * @since 1.0.0
+ * @category type id
+ */
+declare const FileTypeId: unique symbol;
+/**
+ * @since 1.0.0
+ * @category type id
+ */
+type FileTypeId = typeof FileTypeId;
+/**
+ * @since 1.0.0
+ * @category model
+ */
+interface File$1 {
+  readonly [FileTypeId]: FileTypeId;
+  readonly fd: File$1.Descriptor;
+  readonly stat: Effect$1.Effect<File$1.Info, PlatformError>;
+  readonly seek: (offset: SizeInput, from: SeekMode) => Effect$1.Effect<void>;
+  readonly sync: Effect$1.Effect<void, PlatformError>;
+  readonly read: (buffer: Uint8Array) => Effect$1.Effect<Size, PlatformError>;
+  readonly readAlloc: (size: SizeInput) => Effect$1.Effect<Option<Uint8Array>, PlatformError>;
+  readonly truncate: (length?: SizeInput) => Effect$1.Effect<void, PlatformError>;
+  readonly write: (buffer: Uint8Array) => Effect$1.Effect<Size, PlatformError>;
+  readonly writeAll: (buffer: Uint8Array) => Effect$1.Effect<void, PlatformError>;
+}
+/**
+ * @since 1.0.0
+ */
+declare namespace File$1 {
+  /**
+   * @since 1.0.0
+   * @category model
+   */
+  type Descriptor = Brand.Branded<number, "FileDescriptor">;
+  /**
+   * @since 1.0.0
+   * @category model
+   */
+  type Type = "File" | "Directory" | "SymbolicLink" | "BlockDevice" | "CharacterDevice" | "FIFO" | "Socket" | "Unknown";
+  /**
+   * @since 1.0.0
+   * @category model
+   */
+  interface Info {
+    readonly type: Type;
+    readonly mtime: Option<Date>;
+    readonly atime: Option<Date>;
+    readonly birthtime: Option<Date>;
+    readonly dev: number;
+    readonly ino: Option<number>;
+    readonly mode: number;
+    readonly nlink: Option<number>;
+    readonly uid: Option<number>;
+    readonly gid: Option<number>;
+    readonly rdev: Option<number>;
+    readonly size: Size;
+    readonly blksize: Option<Size>;
+    readonly blocks: Option<number>;
+  }
+}
+/**
+ * @since 1.0.0
+ * @category model
+ */
+type SeekMode = "start" | "current";
+/**
+ * @since 1.0.0
+ * @category model
+ */
+type WatchEvent = WatchEvent.Create | WatchEvent.Update | WatchEvent.Remove;
+/**
+ * @since 1.0.0
+ * @category model
+ */
+declare namespace WatchEvent {
+  /**
+   * @since 1.0.0
+   * @category model
+   */
+  interface Create {
+    readonly _tag: "Create";
+    readonly path: string;
+  }
+  /**
+   * @since 1.0.0
+   * @category model
+   */
+  interface Update {
+    readonly _tag: "Update";
+    readonly path: string;
+  }
+  /**
+   * @since 1.0.0
+   * @category model
+   */
+  interface Remove {
+    readonly _tag: "Remove";
+    readonly path: string;
+  }
+}
+//#endregion
+//#region src/report/schema-export.d.ts
+/** Generate the SchemaStore-compatible JSON Schema document for BuildReport. */
+declare const generateBuildReportSchema: () => Effect.Effect<JsonSchemaOutput, JsonSchemaError, FileSystem>;
+//#endregion
+//#region src/report/timer.d.ts
+declare function formatTime(ms: number): string;
+interface Timer {
+  readonly elapsed: () => number;
+  readonly format: () => string;
+}
+/** Create a wall-clock timer. (Date.now is fine in runtime build code.) */
+declare function createTimer(now?: () => number): Timer;
+//#endregion
+//#region src/targets/binding.d.ts
+/** Write the target-to-group binding to dist/prod/targets.json for the release action to consume. Returns the path. */
+declare function writeTargetsBinding(cwd: string, resolution: TargetResolution): string;
+//#endregion
+//#region src/targets/resolve-targets.d.ts
+/** Resolve a `publishConfig.targets` map into the distinct groups to build and every target bound to one. Pure; throws ConfigValidationError on structurally-invalid config. */
+declare function resolveTargets(options: {
+  targets: PublishTargets;
+  baseName: string;
+}): TargetResolution;
+//#endregion
+export { type BuildEmittedManifestOptions, type BuildFormat, type BuildGroupSpec, type BuildReport, BuildReport as BuildReportSchema, type BuildTargetGroupsOptions, CatalogAssemblyError, CatalogResolutionError, CiAnnotationsFormatter, ConfigValidationError, ConfigValidator, ConfigValidatorLive, DEFAULT_EXE_NODE_VERSION, type DeriveOptions, type DerivedTsdownOptions, type DualExports, type EmitManifestOptions, type EntryOverride, type Environment, EnvironmentDetector, EnvironmentDetectorLive, type ExeBuild, type ExeConfig, type ExeSeaConfig, type ExeTarget, type ExeTargetInput, type Executor, ExecutorResolver, ExecutorResolverLive, type ExtractOptions, type ExtractResult, FormatSelector, FormatSelectorLive, type Formatter, type FormatterContext, type GenerateMetaOptions, type Json, JsonFormatter, type JsxConfig, type ManifestLike, MarkdownFormatter, MetaGenerationError, type MetaOptions, type MetaResult, type NormalizedExe, type NormalizedMeta, type OutputFormat, OutputRenderer, OutputRendererLive, type PackageJsonEntriesOptions, type PackageJsonLike, type PkgOsCpu, type PortableTsconfig, type PublishTargetObject, type PublishTargetValue, type PublishTargets, type RenderReportOptions, type RenderedOutput, ReportPipelineLive, ReportTimings, type ResolvedCompilerOptions, type ResolvedGroup, type ResolvedTarget, type ResolvedTsconfig, type ResolvedTsconfigOptions, type RunExeBuildOptions, SilentFormatter, type TargetGroupId, type TargetGroupRef, type TargetGroupReport, TargetGroupReport as TargetGroupReportSchema, type TargetResolution, TerminalFormatter, type Timer, type TransformManifestOptions, type TsconfigJsx, TsconfigResolver, type TsdocOptions, type TsdocTagDefinition, type TsdownBuild, type ValidationInput, type WarningSuppressionRule, buildEmittedManifest, buildResolvedTsconfig, buildTargetGroups, cjsDefaultInterop, createEntryName, createTimer, defaultManifestTransform, deriveTargetGroupOptions, emitManifest, extractEntries, formatTime, generateBuildReportSchema, generateMeta, isTargetObject, nodeBuiltinDefaultInterop, normalizeBinPaths, normalizeExeOptions, normalizeMetaOptions, packageJsonEntries, readTsconfigJsx, removeDeclarationMaps, renderReport, resolveJsxConfig, resolveManifest, resolvePortableTsconfig, resolveTargets, runExeBuild, syncPublicDir, transformBin, transformExports, transformManifest, writeResolvedTsconfig, writeTargetsBinding };
+//# sourceMappingURL=index.d.ts.map