@savvy-web/tsdown-plugins 0.1.0

package/meta/tsconfig-resolver.js

@@ -0,0 +1,260 @@
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+import { JsxEmit, ModuleDetectionKind, ModuleKind, ModuleResolutionKind, NewLineKind, ScriptTarget, flattenDiagnosticMessageText, getParsedCommandLineOfConfigFile, sys } from "typescript";
+
+//#region src/meta/tsconfig-resolver.ts
+/**
+* JSON schema URL for tsconfig.json files.
+* @internal
+*/
+const TSCONFIG_SCHEMA_URL = "https://json.schemastore.org/tsconfig";
+/**
+* Boolean compiler options preserved in the portable config.
+*
+* @remarks
+* These options affect type checking and module semantics without producing
+* build artifacts. Emit-related options are excluded.
+*
+* @internal
+*/
+const PRESERVED_BOOLEAN_OPTIONS = [
+	"strict",
+	"strictNullChecks",
+	"strictFunctionTypes",
+	"strictBindCallApply",
+	"strictPropertyInitialization",
+	"noImplicitAny",
+	"noImplicitThis",
+	"alwaysStrict",
+	"noUnusedLocals",
+	"noUnusedParameters",
+	"exactOptionalPropertyTypes",
+	"noImplicitReturns",
+	"noFallthroughCasesInSwitch",
+	"noUncheckedIndexedAccess",
+	"noImplicitOverride",
+	"noPropertyAccessFromIndexSignature",
+	"allowUnusedLabels",
+	"allowUnreachableCode",
+	"esModuleInterop",
+	"allowSyntheticDefaultImports",
+	"forceConsistentCasingInFileNames",
+	"resolveJsonModule",
+	"isolatedModules",
+	"verbatimModuleSyntax",
+	"skipLibCheck",
+	"skipDefaultLibCheck",
+	"downlevelIteration",
+	"importHelpers",
+	"preserveConstEnums",
+	"isolatedDeclarations",
+	"allowImportingTsExtensions",
+	"rewriteRelativeImportExtensions",
+	"allowArbitraryExtensions",
+	"useDefineForClassFields",
+	"noLib",
+	"preserveSymlinks"
+];
+/**
+* String compiler options preserved in the portable config.
+* @internal
+*/
+const PRESERVED_STRING_OPTIONS = [
+	"jsxFactory",
+	"jsxFragmentFactory",
+	"jsxImportSource",
+	"reactNamespace"
+];
+/**
+* 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
+*/
+var TsconfigResolver = class TsconfigResolver {
+	/** @internal */
+	static SCRIPT_TARGET_MAP = new Map([
+		[ScriptTarget.ES5, "es5"],
+		[ScriptTarget.ES2015, "es2015"],
+		[ScriptTarget.ES2016, "es2016"],
+		[ScriptTarget.ES2017, "es2017"],
+		[ScriptTarget.ES2018, "es2018"],
+		[ScriptTarget.ES2019, "es2019"],
+		[ScriptTarget.ES2020, "es2020"],
+		[ScriptTarget.ES2021, "es2021"],
+		[ScriptTarget.ES2022, "es2022"],
+		[ScriptTarget.ES2023, "es2023"],
+		[ScriptTarget.ES2024, "es2024"],
+		[ScriptTarget.ESNext, "esnext"],
+		[ScriptTarget.JSON, "json"]
+	]);
+	/** @internal */
+	static MODULE_KIND_MAP = new Map([
+		[ModuleKind.CommonJS, "commonjs"],
+		[ModuleKind.ES2015, "es2015"],
+		[ModuleKind.ES2020, "es2020"],
+		[ModuleKind.ES2022, "es2022"],
+		[ModuleKind.ESNext, "esnext"],
+		[ModuleKind.Node16, "node16"],
+		[101, "node18"],
+		[102, "node20"],
+		[ModuleKind.NodeNext, "nodenext"],
+		[ModuleKind.Preserve, "preserve"]
+	]);
+	/** @internal */
+	static MODULE_RESOLUTION_MAP = new Map([
+		[ModuleResolutionKind.Node10, "node10"],
+		[ModuleResolutionKind.Node16, "node16"],
+		[ModuleResolutionKind.NodeNext, "nodenext"],
+		[ModuleResolutionKind.Bundler, "bundler"]
+	]);
+	/** @internal */
+	static JSX_EMIT_MAP = new Map([
+		[JsxEmit.None, "none"],
+		[JsxEmit.Preserve, "preserve"],
+		[JsxEmit.React, "react"],
+		[JsxEmit.ReactNative, "react-native"],
+		[JsxEmit.ReactJSX, "react-jsx"],
+		[JsxEmit.ReactJSXDev, "react-jsxdev"]
+	]);
+	/** @internal */
+	static MODULE_DETECTION_MAP = new Map([
+		[ModuleDetectionKind.Legacy, "legacy"],
+		[ModuleDetectionKind.Auto, "auto"],
+		[ModuleDetectionKind.Force, "force"]
+	]);
+	/** @internal */
+	static NEW_LINE_MAP = new Map([[NewLineKind.CarriageReturnLineFeed, "crlf"], [NewLineKind.LineFeed, "lf"]]);
+	/** Converts a {@link ScriptTarget} enum value to its string form (e.g. `es2023`). */
+	static convertScriptTarget(target) {
+		if (target === void 0) return void 0;
+		const mapped = TsconfigResolver.SCRIPT_TARGET_MAP.get(target);
+		if (mapped !== void 0) return mapped;
+		return `es${target}`;
+	}
+	/** Converts a {@link ModuleKind} enum value to its string form (e.g. `nodenext`). */
+	static convertModuleKind(module) {
+		if (module === void 0) return void 0;
+		const mapped = TsconfigResolver.MODULE_KIND_MAP.get(module);
+		if (mapped !== void 0) return mapped;
+		return String(module);
+	}
+	/** Converts a {@link ModuleResolutionKind} enum value to its string form (e.g. `nodenext`). */
+	static convertModuleResolution(resolution) {
+		if (resolution === void 0) return void 0;
+		const mapped = TsconfigResolver.MODULE_RESOLUTION_MAP.get(resolution);
+		if (mapped !== void 0) return mapped;
+		return String(resolution);
+	}
+	/** Converts a {@link JsxEmit} enum value to its string form (e.g. `preserve`, `react-jsx`). */
+	static convertJsxEmit(jsx) {
+		if (jsx === void 0) return void 0;
+		const mapped = TsconfigResolver.JSX_EMIT_MAP.get(jsx);
+		if (mapped !== void 0) return mapped;
+		return String(jsx);
+	}
+	/** Converts a {@link ModuleDetectionKind} enum value to its string form (e.g. `force`). */
+	static convertModuleDetection(detection) {
+		if (detection === void 0) return void 0;
+		const mapped = TsconfigResolver.MODULE_DETECTION_MAP.get(detection);
+		if (mapped !== void 0) return mapped;
+		return String(detection);
+	}
+	/** Converts a {@link NewLineKind} enum value to its string form (`lf` or `crlf`). */
+	static convertNewLine(newLine) {
+		if (newLine === void 0) return void 0;
+		const mapped = TsconfigResolver.NEW_LINE_MAP.get(newLine);
+		if (mapped !== void 0) return mapped;
+		return String(newLine);
+	}
+	/**
+	* 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) {
+		return (lib.includes("/") || lib.includes("\\") ? lib.split(/[\\/]/).pop() ?? lib : lib).replace(/^lib\./, "").replace(/\.d\.ts$/, "");
+	}
+	/**
+	* Resolves a parsed TypeScript config to a portable, compilerOptions-only tsconfig.
+	*/
+	resolve(parsed) {
+		const opts = parsed.options;
+		const compilerOptions = {};
+		if (opts.target !== void 0) compilerOptions.target = TsconfigResolver.convertScriptTarget(opts.target);
+		if (opts.module !== void 0) compilerOptions.module = TsconfigResolver.convertModuleKind(opts.module);
+		if (opts.moduleResolution !== void 0) compilerOptions.moduleResolution = TsconfigResolver.convertModuleResolution(opts.moduleResolution);
+		if (opts.moduleDetection !== void 0) compilerOptions.moduleDetection = TsconfigResolver.convertModuleDetection(opts.moduleDetection);
+		if (opts.jsx !== void 0) compilerOptions.jsx = TsconfigResolver.convertJsxEmit(opts.jsx);
+		if (opts.newLine !== void 0) compilerOptions.newLine = TsconfigResolver.convertNewLine(opts.newLine);
+		if (opts.lib && opts.lib.length > 0) compilerOptions.lib = opts.lib.map(TsconfigResolver.convertLibReference);
+		compilerOptions.composite = false;
+		compilerOptions.noEmit = true;
+		for (const opt of PRESERVED_BOOLEAN_OPTIONS) if (opts[opt] !== void 0) compilerOptions[opt] = opts[opt];
+		for (const opt of PRESERVED_STRING_OPTIONS) if (opts[opt] !== void 0) compilerOptions[opt] = opts[opt];
+		return {
+			$schema: TSCONFIG_SCHEMA_URL,
+			compilerOptions
+		};
+	}
+};
+/**
+* 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
+*/
+function resolvePortableTsconfig(cwd, fallbackConfigPath) {
+	const ownConfig = join(cwd, "tsconfig.json");
+	const configPath = existsSync(ownConfig) ? ownConfig : fallbackConfigPath !== void 0 && existsSync(fallbackConfigPath) ? fallbackConfigPath : void 0;
+	if (configPath === void 0) return {
+		$schema: TSCONFIG_SCHEMA_URL,
+		compilerOptions: {
+			composite: false,
+			noEmit: true
+		}
+	};
+	const parsed = getParsedCommandLineOfConfigFile(configPath, {}, {
+		...sys,
+		onUnRecoverableConfigFileDiagnostic: (diagnostic) => {
+			const message = flattenDiagnosticMessageText(diagnostic.messageText, "\n");
+			throw new Error(`Cannot resolve portable tsconfig at ${configPath}: ${message}`);
+		}
+	});
+	if (parsed === void 0) throw new Error(`Failed to parse tsconfig at ${configPath}`);
+	return new TsconfigResolver().resolve(parsed);
+}
+
+//#endregion
+export { TsconfigResolver, resolvePortableTsconfig };

package/meta/tsdoc-config.js

@@ -0,0 +1,47 @@
+import { join } from "node:path";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { StandardTags } from "@microsoft/tsdoc";
+import deepEqual from "deep-equal";
+
+//#region src/meta/tsdoc-config.ts
+const TSDOC_SCHEMA = "https://developer.microsoft.com/json-schemas/tsdoc/v0/tsdoc.schema.json";
+const SYNTAX_KIND_MAP = {
+	block: "block",
+	inline: "inline",
+	modifier: "modifier"
+};
+/** Build the tsdoc.json object: standard tags enabled, every standard tag marked supported, plus any custom tags. */
+function buildTsdocConfig(tsdoc) {
+	const supportForTags = {};
+	for (const def of StandardTags.allDefinitions) supportForTags[def.tagName] = true;
+	const tagDefinitions = tsdoc.tagDefinitions.map((t) => ({
+		tagName: t.tagName,
+		syntaxKind: SYNTAX_KIND_MAP[t.syntaxKind],
+		...t.allowMultiple !== void 0 ? { allowMultiple: t.allowMultiple } : {}
+	}));
+	for (const t of tagDefinitions) supportForTags[t.tagName] = true;
+	const config = {
+		$schema: TSDOC_SCHEMA,
+		noStandardTags: false,
+		reportUnsupportedHtmlElements: true,
+		supportForTags
+	};
+	if (tagDefinitions.length > 0) config.tagDefinitions = tagDefinitions;
+	return config;
+}
+/** Write tsdoc.json to `cwd`. Deterministic and idempotent: skips the write when the existing file is byte-equal to the computed config. Returns the path. */
+function writeTsdocConfig(cwd, tsdoc) {
+	const path = join(cwd, "tsdoc.json");
+	const config = buildTsdocConfig({
+		suppressWarnings: tsdoc.suppressWarnings ?? [],
+		tagDefinitions: tsdoc.tagDefinitions ?? []
+	});
+	if (existsSync(path)) try {
+		if (deepEqual(JSON.parse(readFileSync(path, "utf-8")), config, { strict: true })) return path;
+	} catch {}
+	writeFileSync(path, `${JSON.stringify(config, null, "	")}\n`, "utf-8");
+	return path;
+}
+
+//#endregion
+export { writeTsdocConfig };

package/package.json

@@ -0,0 +1,45 @@
+{
+	"name": "@savvy-web/tsdown-plugins",
+	"version": "0.1.0",
+	"private": false,
+	"description": "Interface-only tsdown/rolldown plugin pack powering @savvy-web/bundler",
+	"homepage": "https://github.com/savvy-web/systems/tree/main/packages/tsdown-plugins",
+	"bugs": {
+		"url": "https://github.com/savvy-web/systems/issues"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/savvy-web/systems.git",
+		"directory": "packages/tsdown-plugins"
+	},
+	"license": "MIT",
+	"author": {
+		"name": "C. Spencer Beggs",
+		"email": "spencer@savvyweb.systems",
+		"url": "https://savvyweb.systems"
+	},
+	"sideEffects": false,
+	"type": "module",
+	"exports": {
+		".": {
+			"types": "./index.d.ts",
+			"import": "./index.js"
+		}
+	},
+	"dependencies": {
+		"@effect/platform-node": "^0.106.0",
+		"@microsoft/api-extractor": "^7.58.7",
+		"@microsoft/tsdoc": "^0.16.0",
+		"@microsoft/tsdoc-config": "^0.18.1",
+		"deep-equal": "^2.2.3",
+		"json-schema-effect": "^0.2.1",
+		"picocolors": "^1.1.1",
+		"sort-package-json": "^3.6.1",
+		"std-env": "^4.1.0",
+		"typescript": "^6.0.3",
+		"workspaces-effect": "^1.2.0"
+	},
+	"peerDependencies": {
+		"effect": ">=3.21.0"
+	}
+}

package/report/formatters/ci-annotations.js

@@ -0,0 +1,20 @@
+//#region src/report/formatters/ci-annotations.ts
+const esc = (s) => s.replace(/%/g, "%25").replace(/\r/g, "%0D").replace(/\n/g, "%0A");
+const CiAnnotationsFormatter = {
+	format: "ci-annotations",
+	render: (reports) => {
+		const lines = [];
+		for (const r of reports) for (const g of r.targetGroups) {
+			for (const e of g.errors) lines.push(`::error title=${esc(r.package)} (${esc(g.id)})::${esc(e)}`);
+			for (const w of g.warnings) lines.push(`::warning title=${esc(r.package)} (${esc(g.id)})::${esc(w)}`);
+		}
+		return lines.length === 0 ? [] : [{
+			target: "stdout",
+			content: lines.join("\n"),
+			contentType: "text/plain"
+		}];
+	}
+};
+
+//#endregion
+export { CiAnnotationsFormatter };

package/report/formatters/json.js

@@ -0,0 +1,12 @@
+//#region src/report/formatters/json.ts
+const JsonFormatter = {
+	format: "json",
+	render: (reports) => [{
+		target: "stdout",
+		content: JSON.stringify(reports, null, 2),
+		contentType: "application/json"
+	}]
+};
+
+//#endregion
+export { JsonFormatter };

package/report/formatters/markdown.js

@@ -0,0 +1,25 @@
+//#region src/report/formatters/markdown.ts
+const MarkdownFormatter = {
+	format: "markdown",
+	render: (reports) => {
+		const lines = [];
+		for (const r of reports) {
+			const failing = r.targetGroups.filter((g) => g.errors.length > 0);
+			if (failing.length > 0) {
+				lines.push(`## ❌ ${r.package}`);
+				for (const g of failing) {
+					lines.push(`- **${g.id}**`);
+					for (const e of g.errors) lines.push(`  - ${e}`);
+				}
+			} else lines.push(`## ✅ ${r.package}`);
+		}
+		return [{
+			target: "stdout",
+			content: lines.join("\n"),
+			contentType: "text/markdown"
+		}];
+	}
+};
+
+//#endregion
+export { MarkdownFormatter };

package/report/formatters/silent.js

@@ -0,0 +1,8 @@
+//#region src/report/formatters/silent.ts
+const SilentFormatter = {
+	format: "silent",
+	render: () => []
+};
+
+//#endregion
+export { SilentFormatter };

package/report/formatters/terminal.js

@@ -0,0 +1,29 @@
+import { formatTime } from "../timer.js";
+import pc from "picocolors";
+
+//#region src/report/formatters/terminal.ts
+const TerminalFormatter = {
+	format: "terminal",
+	render: (reports, ctx) => {
+		const color = (fn, s) => ctx.noColor ? s : fn(s);
+		const lines = [];
+		for (const r of reports) {
+			lines.push(color(pc.bold, r.package));
+			for (const g of r.targetGroups) {
+				const status = g.errors.length ? color(pc.red, "✗") : color(pc.green, "✓");
+				lines.push(`  ${status} ${g.id} — ${g.emittedFiles.length} files (${formatTime(g.timings.totalMs)})`);
+				for (const e of g.errors) lines.push(`    ${color(pc.red, "error")}: ${e}`);
+				for (const w of g.warnings) lines.push(`    ${color(pc.yellow, "warn")}: ${w}`);
+			}
+		}
+		const content = lines.join("\n");
+		return content === "" ? [] : [{
+			target: "stdout",
+			content,
+			contentType: "text/plain"
+		}];
+	}
+};
+
+//#endregion
+export { TerminalFormatter };

package/report/layers/EnvironmentDetectorLive.js

@@ -0,0 +1,15 @@
+import { EnvironmentDetector } from "../services/EnvironmentDetector.js";
+import { Effect, Layer } from "effect";
+import { isAgent, isCI } from "std-env";
+
+//#region src/report/layers/EnvironmentDetectorLive.ts
+const isGitHub = () => process.env.GITHUB_ACTIONS === "true" || process.env.GITHUB_ACTIONS === "1";
+const EnvironmentDetectorLive = Layer.succeed(EnvironmentDetector, { detect: () => Effect.sync(() => {
+	if (isAgent) return "agent-shell";
+	if (isGitHub()) return "ci-github";
+	if (isCI) return "ci-generic";
+	return "terminal";
+}) });
+
+//#endregion
+export { EnvironmentDetectorLive };

package/report/layers/ExecutorResolverLive.js

@@ -0,0 +1,8 @@
+import { ExecutorResolver } from "../services/ExecutorResolver.js";
+import { Effect, Layer } from "effect";
+
+//#region src/report/layers/ExecutorResolverLive.ts
+const ExecutorResolverLive = Layer.succeed(ExecutorResolver, { resolve: (env) => Effect.succeed(env === "agent-shell" ? "agent" : env === "terminal" ? "human" : "ci") });
+
+//#endregion
+export { ExecutorResolverLive };

package/report/layers/FormatSelectorLive.js

@@ -0,0 +1,8 @@
+import { FormatSelector } from "../services/FormatSelector.js";
+import { Effect, Layer } from "effect";
+
+//#region src/report/layers/FormatSelectorLive.ts
+const FormatSelectorLive = Layer.succeed(FormatSelector, { select: (executor, explicit, env) => Effect.succeed(explicit ?? (env === "ci-github" && executor === "ci" ? "ci-annotations" : executor === "agent" ? "markdown" : executor === "ci" ? "json" : "terminal")) });
+
+//#endregion
+export { FormatSelectorLive };

package/report/layers/OutputRendererLive.js

@@ -0,0 +1,23 @@
+import { CiAnnotationsFormatter } from "../formatters/ci-annotations.js";
+import { JsonFormatter } from "../formatters/json.js";
+import { MarkdownFormatter } from "../formatters/markdown.js";
+import { SilentFormatter } from "../formatters/silent.js";
+import { TerminalFormatter } from "../formatters/terminal.js";
+import { OutputRenderer } from "../services/OutputRenderer.js";
+import { Effect, Layer } from "effect";
+
+//#region src/report/layers/OutputRendererLive.ts
+const formatters = new Map([
+	["terminal", TerminalFormatter],
+	["json", JsonFormatter],
+	["markdown", MarkdownFormatter],
+	["ci-annotations", CiAnnotationsFormatter],
+	["silent", SilentFormatter]
+]);
+const OutputRendererLive = Layer.succeed(OutputRenderer, { render: (reports, format, ctx) => Effect.sync(() => {
+	const f = formatters.get(format);
+	return f ? f.render(reports, ctx) : [];
+}) });
+
+//#endregion
+export { OutputRendererLive };

package/report/pipeline.js

@@ -0,0 +1,25 @@
+import { EnvironmentDetector } from "./services/EnvironmentDetector.js";
+import { EnvironmentDetectorLive } from "./layers/EnvironmentDetectorLive.js";
+import { ExecutorResolver } from "./services/ExecutorResolver.js";
+import { ExecutorResolverLive } from "./layers/ExecutorResolverLive.js";
+import { FormatSelector } from "./services/FormatSelector.js";
+import { FormatSelectorLive } from "./layers/FormatSelectorLive.js";
+import { OutputRenderer } from "./services/OutputRenderer.js";
+import { OutputRendererLive } from "./layers/OutputRendererLive.js";
+import { Effect, Layer } from "effect";
+
+//#region src/report/pipeline.ts
+const ReportPipelineLive = Layer.mergeAll(EnvironmentDetectorLive, ExecutorResolverLive, FormatSelectorLive, OutputRendererLive);
+const renderReport = (reports, options) => Effect.gen(function* () {
+	const detector = yield* EnvironmentDetector;
+	const executorResolver = yield* ExecutorResolver;
+	const formatSelector = yield* FormatSelector;
+	const renderer = yield* OutputRenderer;
+	const env = options.env ?? (yield* detector.detect());
+	const executor = yield* executorResolver.resolve(env);
+	const format = yield* formatSelector.select(executor, options.explicitFormat, env);
+	return yield* renderer.render(reports, format, { noColor: options.noColor });
+});
+
+//#endregion
+export { ReportPipelineLive, renderReport };

package/report/schema-export.js

@@ -0,0 +1,18 @@
+import { BuildReport } from "./schema.js";
+import { Effect } from "effect";
+import { JsonSchemaExporter } from "json-schema-effect";
+
+//#region src/report/schema-export.ts
+const SCHEMA_ID = "https://savvyweb.systems/schemas/build-report.schema.json";
+/** Generate the SchemaStore-compatible JSON Schema document for BuildReport. */
+const generateBuildReportSchema = () => Effect.gen(function* () {
+	return yield* (yield* JsonSchemaExporter).generate({
+		name: "build-report",
+		schema: BuildReport,
+		rootDefName: "BuildReport",
+		$id: SCHEMA_ID
+	});
+}).pipe(Effect.provide(JsonSchemaExporter.Live));
+
+//#endregion
+export { generateBuildReportSchema };

package/report/schema.js

@@ -0,0 +1,19 @@
+import { Schema } from "effect";
+
+//#region src/report/schema.ts
+const ReportTimings = Schema.Struct({ totalMs: Schema.Number }).annotations({ identifier: "ReportTimings" });
+const TargetGroupReport = Schema.Struct({
+	id: Schema.String,
+	entries: Schema.Array(Schema.String),
+	emittedFiles: Schema.Array(Schema.String),
+	timings: ReportTimings,
+	warnings: Schema.Array(Schema.String),
+	errors: Schema.Array(Schema.String)
+}).annotations({ identifier: "TargetGroupReport" });
+const BuildReport = Schema.Struct({
+	package: Schema.String,
+	targetGroups: Schema.Array(TargetGroupReport)
+}).annotations({ identifier: "BuildReport" });
+
+//#endregion
+export { BuildReport, ReportTimings, TargetGroupReport };

package/report/services/EnvironmentDetector.js

@@ -0,0 +1,7 @@
+import { Context } from "effect";
+
+//#region src/report/services/EnvironmentDetector.ts
+var EnvironmentDetector = class extends Context.Tag("@savvy-web/tsdown-plugins/EnvironmentDetector")() {};
+
+//#endregion
+export { EnvironmentDetector };

package/report/services/ExecutorResolver.js

@@ -0,0 +1,7 @@
+import { Context } from "effect";
+
+//#region src/report/services/ExecutorResolver.ts
+var ExecutorResolver = class extends Context.Tag("@savvy-web/tsdown-plugins/ExecutorResolver")() {};
+
+//#endregion
+export { ExecutorResolver };

package/report/services/FormatSelector.js

@@ -0,0 +1,7 @@
+import { Context } from "effect";
+
+//#region src/report/services/FormatSelector.ts
+var FormatSelector = class extends Context.Tag("@savvy-web/tsdown-plugins/FormatSelector")() {};
+
+//#endregion
+export { FormatSelector };

package/report/services/OutputRenderer.js

@@ -0,0 +1,7 @@
+import { Context } from "effect";
+
+//#region src/report/services/OutputRenderer.ts
+var OutputRenderer = class extends Context.Tag("@savvy-web/tsdown-plugins/OutputRenderer")() {};
+
+//#endregion
+export { OutputRenderer };

package/report/timer.js

@@ -0,0 +1,15 @@
+//#region src/report/timer.ts
+function formatTime(ms) {
+	return ms < 1e3 ? `${Math.round(ms)}ms` : `${(ms / 1e3).toFixed(2)}s`;
+}
+/** Create a wall-clock timer. (Date.now is fine in runtime build code.) */
+function createTimer(now = Date.now) {
+	const start = now();
+	return {
+		elapsed: () => now() - start,
+		format: () => formatTime(now() - start)
+	};
+}
+
+//#endregion
+export { createTimer, formatTime };

package/targets/binding.js

@@ -0,0 +1,15 @@
+import { join } from "node:path";
+import { mkdirSync, writeFileSync } from "node:fs";
+
+//#region src/targets/binding.ts
+/** Write the target-to-group binding to dist/prod/targets.json for the release action to consume. Returns the path. */
+function writeTargetsBinding(cwd, resolution) {
+	const dir = join(cwd, "dist", "prod");
+	mkdirSync(dir, { recursive: true });
+	const path = join(dir, "targets.json");
+	writeFileSync(path, `${JSON.stringify(resolution, null, "	")}\n`, "utf-8");
+	return path;
+}
+
+//#endregion
+export { writeTargetsBinding };

package/targets/config.js

@@ -0,0 +1,8 @@
+//#region src/targets/config.ts
+/** True when a target value is the object form (carries registry/name/from). */
+function isTargetObject(value) {
+	return typeof value === "object" && value !== null;
+}
+
+//#endregion
+export { isTargetObject };