@yorozu/build 0.1.0

package/misc/exec.d.ts

@@ -0,0 +1,15 @@
+import { SpawnOptions } from 'node:child_process';
+export interface ExecResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}
+export declare class ExecError extends Error {
+    readonly cmd: Array<string>;
+    readonly result: ExecResult;
+    constructor(cmd: Array<string>, result: ExecResult);
+}
+export declare function exec(cmd: Array<string>, options?: SpawnOptions & {
+    throwOnError?: boolean;
+    quiet?: boolean;
+}): Promise<ExecResult>;

package/misc/fs.d.ts

@@ -0,0 +1,4 @@
+import { CopyOptions } from 'node:fs';
+export declare function fileExists(path: string): Promise<boolean>;
+export declare function directoryExists(path: string): Promise<boolean>;
+export declare function tryCopy(src: string, dest: string, options?: CopyOptions): Promise<void>;

package/misc/index.d.ts

@@ -0,0 +1,6 @@
+export * from './_config';
+export * from './exec';
+export * from './fs';
+export * from './path';
+export * from './publish-order';
+export * from './tsconfig';

package/misc/path.d.ts

@@ -0,0 +1 @@
+export declare function normalizeFilePath(filePath: string | URL): string;

package/misc/publish-order.d.ts

@@ -0,0 +1,3 @@
+import { WorkspacePackage } from '../package-json/collect-package-jsons';
+export declare function sortWorkspaceByPublishOrder(packages: Array<WorkspacePackage>): Array<WorkspacePackage>;
+export declare function determinePublishOrder(dependencies: Record<string, Array<string>>): Array<string>;

package/misc/tsconfig.d.ts

@@ -0,0 +1,2 @@
+export declare function getTsconfigFor(cwd: string): Promise<unknown>;
+export declare function getTsconfigFiles(cwd: string): Promise<Array<string>>;

package/npm/index.d.ts

@@ -0,0 +1 @@
+export * from './npm-api';

package/npm/npm-api.d.ts

@@ -0,0 +1,6 @@
+export declare const NPM_PACKAGE_NAME_REGEX: RegExp;
+export declare function npmCheckVersion(params: {
+    registry?: string;
+    package: string;
+    version: string;
+}): Promise<boolean>;

package/package-json/collect-package-jsons.d.ts

@@ -0,0 +1,9 @@
+import { PackageJson } from './types';
+export interface WorkspacePackage {
+    path: string;
+    packageJsonPath: string;
+    root: boolean;
+    json: PackageJson;
+}
+export declare function collectPackageJsons(workspaceRoot: string | URL, includeRoot?: boolean): Promise<Array<WorkspacePackage>>;
+export declare function filterPackageJsonsForPublish(packages: Array<WorkspacePackage>, registry: "jsr" | "npm"): Array<WorkspacePackage>;

package/package-json/find-package-json.d.ts

@@ -0,0 +1 @@
+export declare function findPackageJson(from: string | URL): Promise<string | null>;

package/package-json/index.d.ts

@@ -0,0 +1,6 @@
+export * from './collect-package-jsons';
+export * from './find-package-json';
+export * from './parse';
+export * from './process-package-json';
+export * from './types';
+export * from './utils';

package/package-json/parse.d.ts

@@ -0,0 +1,11 @@
+import { PackageJson } from './types';
+export declare function parsePackageJson(packageJson: string, format?: "json" | "yaml"): PackageJson;
+export declare function parsePackageJsonFile(packageJsonPath: string | URL): Promise<PackageJson>;
+export declare function parsePackageJsonFromDir(dir: string | URL): Promise<{
+    path: string;
+    json: PackageJson;
+}>;
+export declare function parseWorkspaceRootPackageJson(workspaceRoot: string | URL): Promise<{
+    path: string;
+    json: PackageJson;
+}>;

package/package-json/process-package-json.d.ts

@@ -0,0 +1,20 @@
+import { PackageJson } from './types';
+interface ProcessPackageJsonParams {
+    packageJson: PackageJson;
+    onlyEntrypoints?: boolean;
+    workspaceVersions?: Map<string, string>;
+    bundledWorkspaceDeps?: Array<RegExp>;
+    rootPackageJson?: PackageJson;
+    rootFieldsToCopy?: Set<string>;
+    shouldCopyEntrypoint?: (name: string, target: string) => boolean;
+    fixedVersion?: string;
+}
+interface ProcessPackageJsonReturn {
+    packageJson: PackageJson;
+    packageJsonOriginal: PackageJson;
+    entrypoints: Map<string, string>;
+    entrypointsToCopy: Map<string, string>;
+}
+export declare function processPackageJson(params: ProcessPackageJsonParams): ProcessPackageJsonReturn;
+export declare function removeCommonjsExports(exports: Record<string, unknown>): void;
+export {};

package/package-json/types.d.ts

@@ -0,0 +1,39 @@
+import { ZodObject } from 'zod';
+export interface PackageJson {
+    name?: string;
+    type?: "module" | "commonjs";
+    version?: string;
+    private?: boolean;
+    description?: string;
+    packageManager?: string;
+    license?: string;
+    homepage?: string;
+    repository?: string | {
+        type: string;
+        url: string;
+    };
+    keywords?: Array<string>;
+    catalogs?: Record<string, Record<string, string>>;
+    workspaces?: Array<string>;
+    scripts?: Record<string, string>;
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    peerDependencies?: Record<string, string>;
+    optionalDependencies?: Record<string, string>;
+    bundledDependencies?: Array<string>;
+    engines?: Record<string, string>;
+    pnpm?: {
+        overrides: Record<string, string>;
+    };
+    yorozu?: {
+        jsr?: "skip" | "only";
+        npm?: "skip" | "only";
+        keepScripts?: Array<string>;
+        distOnlyFields?: Record<string, unknown>;
+        ownVersioning?: boolean;
+        private?: boolean;
+        standalone?: boolean;
+    };
+    [key: string]: any;
+}
+export declare const PackageJsonSchema: ZodObject;

package/package-json/utils.d.ts

@@ -0,0 +1,4 @@
+import { WorkspacePackage } from './collect-package-jsons';
+export declare function findPackageByName(packages: Array<WorkspacePackage>, name: string): WorkspacePackage;
+export declare function findRootPackage(packages: Array<WorkspacePackage>): WorkspacePackage;
+export declare function collectVersions(packages: Array<WorkspacePackage>): Map<string, string>;

package/package.json

@@ -0,0 +1,59 @@
+{
+    "name": "@yorozu/build",
+    "type": "module",
+    "version": "0.1.0",
+    "description": "build and release utilities for yorozu packages",
+    "license": "MIT",
+    "dependencies": {
+        "@drizzle-team/brocli": "0.12.0",
+        "@yorozu/utils": "^0.1.0",
+        "cross-spawn": "7.0.6",
+        "detect-indent": "7.0.2",
+        "esbuild": "0.25.12",
+        "js-yaml": "4.1.1",
+        "json5": "2.2.3",
+        "picomatch": "4.0.4",
+        "semver": "7.7.4",
+        "tinyglobby": "0.2.16",
+        "zod": "4.3.6"
+    },
+    "peerDependencies": {
+        "typedoc": "0.28.19",
+        "typescript": "6.0.2",
+        "vite": "8.0.8"
+    },
+    "exports": {
+        ".": {
+            "import": {
+                "types": "./index.d.ts",
+                "default": "./index.js"
+            }
+        },
+        "./vite": {
+            "import": {
+                "types": "./vite.d.ts",
+                "default": "./vite.js"
+            }
+        },
+        "./jsr": {
+            "import": {
+                "types": "./jsr.d.ts",
+                "default": "./jsr.js"
+            }
+        }
+    },
+    "author": "inshinrei",
+    "sideEffects": false,
+    "bin": {
+        "yorozu-build": "yorozu-build.js"
+    },
+    "peerDependenciesMeta": {
+        "typedoc": {
+            "optional": true
+        }
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/inshinrei/yorozu.git"
+    }
+}

package/versioning/bump-version.d.ts

@@ -0,0 +1,31 @@
+import { ReleaseType } from 'semver';
+import { CommitInfo } from '../git/utils';
+import { WorkspacePackage } from '../package-json/collect-package-jsons';
+import { VersioningOptions } from './types';
+export interface BumpVersionPackage {
+    package: WorkspacePackage;
+    prevVersion: string;
+}
+export interface BumpVersionResult {
+    previousVersion: string;
+    nextVersion: string;
+    nextVersions: Record<string, string>;
+    changedPackages: Array<BumpVersionPackage>;
+    releaseType: ReleaseType;
+    hasBreakingChanges: boolean;
+    hasFeatures: boolean;
+}
+export declare function determineBumpType(params: {
+    oldVersion: string;
+    commits: Array<CommitInfo>;
+}): ReleaseType;
+export declare function bumpVersion(params: {
+    workspace: Array<WorkspacePackage>;
+    all?: boolean;
+    type?: ReleaseType;
+    cwd?: string | URL;
+    since: string;
+    params?: VersioningOptions;
+    dryRun?: boolean;
+    withRoot?: boolean;
+}): Promise<BumpVersionResult>;

package/versioning/collect-files.d.ts

@@ -0,0 +1,21 @@
+import { WorkspacePackage } from '../package-json/index';
+import { VersioningOptions } from './types';
+export interface ProjectChangedFile {
+    package: WorkspacePackage;
+    file: string;
+    root: string;
+}
+export declare function findProjectChangedFiles(params: {
+    params?: VersioningOptions;
+    workspace?: Array<WorkspacePackage>;
+    root?: string | URL;
+    since: string;
+    until?: string;
+}): Promise<Array<ProjectChangedFile>>;
+export declare function findProjectChangedPackages(params: {
+    params?: VersioningOptions;
+    workspace?: Array<WorkspacePackage>;
+    root?: string | URL;
+    since: string;
+    until?: string;
+}): Promise<Array<WorkspacePackage>>;

package/versioning/generate-changelog.d.ts

@@ -0,0 +1,8 @@
+import { WorkspacePackage } from '../package-json/index';
+import { VersioningOptions } from './types';
+export declare function generateChangelog(params: {
+    workspace: Array<WorkspacePackage>;
+    cwd?: string | URL;
+    since: string;
+    params?: VersioningOptions;
+}): Promise<string>;

package/versioning/index.d.ts

@@ -0,0 +1,4 @@
+export * from './bump-version';
+export * from './collect-files';
+export * from './generate-changelog';
+export * from './types';

package/versioning/types.d.ts

@@ -0,0 +1,21 @@
+import { MaybePromise } from '@yorozu/utils';
+import { CommitInfo, ConventionalCommit } from '../git/utils';
+import { WorkspacePackage } from '../package-json/collect-package-jsons';
+import { ProjectChangedFile } from './collect-files';
+export interface ChangelogGeneratorParams {
+    onCommitParseFailed?: (commit: CommitInfo) => void;
+    onCommitsFetched?: (commits: Array<CommitInfo>) => Promise<void>;
+    commitFilter?: (commit: CommitInfo, parsed: ConventionalCommit) => boolean;
+    commitFilterWithFiles?: (commit: CommitInfo, parsed: ConventionalCommit, files: Array<string>) => boolean;
+    commitFormatter?: (commit: CommitInfo, parsed: ConventionalCommit, files: Array<string>) => string;
+    packageCommitsFormatter?: (packageName: string, commits: Record<string, string>) => string;
+}
+export interface VersioningOptions {
+    taggingSchema?: "semver" | "date";
+    include?: Array<string> | null;
+    exclude?: Array<string> | null;
+    bumpWithDependants?: boolean | "only-minor";
+    shouldInclude?: (file: ProjectChangedFile) => MaybePromise<boolean>;
+    changelog?: ChangelogGeneratorParams;
+    beforeReleaseCommit?: (workspace: Array<WorkspacePackage>) => MaybePromise<void>;
+}

package/vite/build-plugin.d.ts

@@ -0,0 +1,73 @@
+import { MaybeArray, MaybePromise } from '@yorozu/utils';
+import { PluginOption } from 'vite';
+import { BuildHookContext } from '../config';
+export declare function yorozuBuild(params: {
+    root: URL | string;
+    /**
+     * package root, will be passed to vite's `root` option
+     *
+     * @default `process.cwd()`
+     */
+    packageRoot?: string;
+    /**
+     * files to copy from the workspace root directory to the build directory
+     *
+     * @default ['LICENSE']
+     */
+    copyRootFiles?: Array<string>;
+    /**
+     * files to copy from the package root directory to the build directory
+     *
+     * @default ['README.md']
+     */
+    copyPackageFiles?: Array<string>;
+    /**
+     * the modifiable part of the chunk file name
+     * there will be a prefix of `chunks/[format]/` and a suffix of `.js`
+     * @default `[hash]`
+     */
+    chunkFileName?: string;
+    /**
+     * workspace dependencies that are bundled with the library,
+     * and as such shouldn't present in the final package.json
+     */
+    bundledWorkspaceDeps?: MaybeArray<string | RegExp>;
+    rootFieldsToCopy?: Array<string>;
+    /** when true, will automatically add `sideEffects: false` to generated package.json-s */
+    autoSideEffectsFalse?: boolean;
+    /**
+     * hook to run *before* anything is done to the package.json file
+     * you **can** modify the .packageJson property of the context
+     *
+     * this hook is called before vite build has started,
+     * and as such `.outDir` is not available yet
+     * (note: this hook is run *before* package-level hooks)
+     */
+    preparePackageJson?: (ctx: BuildHookContext) => void;
+    /**
+     * hook to run *after* the package.json file is finalized,
+     * right before it is written to disk
+     * you **can** modify the .packageJson property of the context
+     * (note: this hook is run *before* package-level hooks)
+     */
+    finalizePackageJson?: (ctx: BuildHookContext) => MaybePromise<void>;
+    /**
+     * hook to run *after* the build is done,
+     * time to do any final modifications to the package contents
+     * (note: this hook is run *before* package-level hooks)
+     */
+    finalize?: (ctx: BuildHookContext) => MaybePromise<void>;
+    /**
+     * when using with `vite-plugin-dts`, use this flag instead of
+     * their `insertTypesEntry` option to insert the types entry,
+     * as their implementation doesn't always yield the correct result
+     *
+     * @default false
+     */
+    insertTypesEntry?: boolean;
+    /**
+     * when using with `vite-plugin-dts`, this value should match `entryRoot`
+     * value passed to the `vite-plugin-dts` plugin
+     */
+    typesEntryRoot?: string;
+}): Promise<PluginOption[]>;

package/vite/config.d.ts

@@ -0,0 +1,47 @@
+import { AnyToNever, MaybePromise } from '@yorozu/utils';
+import { TypeDocOptions } from 'typedoc';
+import { Plugin, UserConfig } from 'vite';
+import { BuildHookContext, JsrConfig } from '../config';
+export interface CustomBuildConfigObject {
+    /** jsr-specific configuration */
+    jsr?: JsrConfig;
+    /** any additional vite plugins to be added before the yorozu-build plugin */
+    pluginsPre?: Array<Plugin>;
+    /** any additional vite plugins to be added after the yorozu-build plugin */
+    pluginsPost?: Array<Plugin>;
+    /** vite config to be merged into the base config */
+    viteConfig?: UserConfig;
+    /**
+     * a predicate to determine if the entrypoint should be copied to the target directory as-is, without being processed by vite
+     *
+     * - `name` is the name of the entrypoint (e.g. `./foo.json`)
+     * - `target` is the target path (e.g. `./src/foo.json`)
+     *
+     * the default implementation skips any non-javascript entrypoints, which is particularly useful for json and wasm files
+     *
+     * @default (name, target) => !!target.match(/(?<!\.d)\.([mc]?[jt]sx?)$/i)
+     */
+    shouldCopyEntrypoint?: (name: string, target: string) => boolean;
+    /**
+     * hook to run *before* anything is done to the package.json file
+     * you **can** modify the .packageJson property of the context
+     *
+     * this hook is called before vite build has started,
+     * and as such `.outDir` is not available yet
+     */
+    preparePackageJson?: (ctx: BuildHookContext) => void;
+    /**
+     * hook to run *after* the package.json file is finalized,
+     * right before it is written to disk
+     * you **can** modify the .packageJson property of the context
+     */
+    finalizePackageJson?: (ctx: BuildHookContext) => MaybePromise<void>;
+    /**
+     * hook to run *after* the build is done,
+     * time to do any final modifications to the package contents
+     */
+    finalize?: (ctx: BuildHookContext) => MaybePromise<void>;
+    /** package-specific configuration for typedoc */
+    typedoc?: AnyToNever<Partial<TypeDocOptions>> | ((current: AnyToNever<Partial<TypeDocOptions>>) => AnyToNever<Partial<TypeDocOptions>>);
+}
+export type CustomBuildConfig = CustomBuildConfigObject | (() => CustomBuildConfigObject);

package/vite/index.d.ts

@@ -0,0 +1,2 @@
+export * from './build-plugin';
+export * from './config';

package/vite.d.ts

@@ -0,0 +1 @@
+export * from "./vite/index.js"

package/vite.js

@@ -0,0 +1,184 @@
+import { asNonNull, collectPackageJsons, collectVersions, directoryExists, fileExists, glob, loadBuildConfig, normalizeFilePath, parallelMap, processPackageJson, removeCommonjsExports, tryCopy, warn } from "./chunks/21EFCjEU.js";
+import process from "node:process";
+import { dirname, join, relative } from "node:path";
+import * as fsp from "node:fs/promises";
+//#region ../utils/src/misc/objects.ts
+function deepMerge(into, from, options = {}) {
+	if (!Array.isArray(from)) from = [from];
+	if (from.length === 0) return into;
+	const { undefined: undefinedStrategy = "ignore", properties: propertiesStrategy = "replace", arrays: arraysStrategy = "replace", objects: objectsStrategy = "merge" } = options;
+	for (let i = 0; i < from.length; i++) {
+		const source = from[i];
+		for (const key in source) {
+			if (!Object.hasOwn(source, key)) continue;
+			const value = source[key];
+			const existing = into[key];
+			if (value === void 0) {
+				if (undefinedStrategy === "replace") into[key] = void 0;
+				continue;
+			}
+			if (Array.isArray(value)) {
+				if (arraysStrategy === "merge" && Array.isArray(existing)) existing.push(...value);
+				else if (arraysStrategy === "ignore" && existing !== void 0) {} else into[key] = [...value];
+				continue;
+			}
+			if (typeof value === "object" && value !== null) {
+				if (objectsStrategy === "merge" && typeof existing === "object" && existing !== null) into[key] = deepMerge(existing, value, options);
+				else if (objectsStrategy === "ignore" && existing !== void 0) {} else into[key] = { ...value };
+				continue;
+			}
+			if (propertiesStrategy === "ignore" && existing !== void 0) {} else into[key] = value;
+		}
+	}
+	return into;
+}
+//#endregion
+//#region ../utils/src/misc/string.ts
+function assertStartsWith(str, prefix) {
+	if (!str.startsWith(prefix)) throw new TypeError(`String does not starts with ${prefix}.`, { cause: {
+		str,
+		prefix
+	} });
+}
+//#endregion
+//#region src/vite/build-plugin.ts
+var DEFAULT_LIB_FORMATS = ["es"];
+function stripTrailingSlash(filePath) {
+	return filePath.replace(/\/$/g, "");
+}
+function toBundledWorkspaceDeps(deps) {
+	if (deps === void 0) return void 0;
+	return (Array.isArray(deps) ? deps : [deps]).map((dep) => typeof dep === "string" ? new RegExp(dep) : dep);
+}
+async function yorozuBuild(params) {
+	let { copyRootFiles = ["LICENSE"], copyPackageFiles = ["README.md"], chunkFileName = "[hash]", rootFieldsToCopy, packageRoot = process.cwd(), bundledWorkspaceDeps, autoSideEffectsFalse = false, insertTypesEntry = false, typesEntryRoot } = params;
+	let rootDir = normalizeFilePath(params.root);
+	let fixedVersion = process.env.__YOROZU_INTERNAL_FIXED_VERSION;
+	let cachedWorkspace = process.env.__YOROZU_INTERNAL_PACKAGES_LIST;
+	let allPackageJsons = cachedWorkspace !== void 0 ? JSON.parse(cachedWorkspace) : await collectPackageJsons(rootDir, true);
+	let rootPackageJson = allPackageJsons.find((it) => it.root)?.json;
+	if (!rootPackageJson) throw new Error("Could not find root package.json");
+	let normalizedPackageRoot = stripTrailingSlash(packageRoot);
+	let ourPackageJson = allPackageJsons.find((it) => stripTrailingSlash(it.path) === normalizedPackageRoot)?.json;
+	if (!ourPackageJson) throw new Error(`Could not find package.json for ${packageRoot}`);
+	if (rootPackageJson === ourPackageJson) return [{
+		name: "vite-plugin-yorozu-build",
+		config(_ctx, env) {
+			if (env.command === "build" && env.mode === "production") throw new Error("[@yorozu/build] Cannot build the root package from root. Please change cwd to the package directory, or pass it via `packageRoot` option.");
+		}
+	}];
+	let workspaceVersions = collectVersions(allPackageJsons);
+	let isNoop = false;
+	let packageConfig = await loadBuildConfig(packageRoot);
+	let hookContext = {
+		outDir: "",
+		packageDir: packageRoot,
+		packageName: asNonNull(ourPackageJson.name),
+		packageJson: ourPackageJson,
+		jsr: false,
+		typedoc: false
+	};
+	params.preparePackageJson?.(hookContext);
+	packageConfig?.preparePackageJson?.(hookContext);
+	let { packageJson, entrypoints, entrypointsToCopy } = processPackageJson({
+		packageJson: hookContext.packageJson,
+		rootPackageJson,
+		workspaceVersions,
+		bundledWorkspaceDeps: toBundledWorkspaceDeps(bundledWorkspaceDeps),
+		rootFieldsToCopy: rootFieldsToCopy != null ? new Set(rootFieldsToCopy) : void 0,
+		fixedVersion,
+		shouldCopyEntrypoint: packageConfig?.shouldCopyEntrypoint
+	});
+	if (fixedVersion != null) packageJson.version = fixedVersion;
+	hookContext.packageJson = packageJson;
+	if (packageJson.sideEffects == null) if (autoSideEffectsFalse) packageJson.sideEffects = false;
+	else {
+		warn(`[@yorozu/build] package.json for ${packageJson.name} has no sideEffects field, this may cause issues with tree-shaking`);
+		warn("[@yorozu/build] (tip: set `autoSideEffectsFalse: true` in plugin params to add it automatically)");
+	}
+	let buildCjs = false;
+	let buildDir;
+	return [
+		...packageConfig?.pluginsPre ?? [],
+		{
+			name: "vite-plugin-yorozu-build",
+			async config(config, env) {
+				if (env.command !== "build") {
+					isNoop = true;
+					return null;
+				}
+				buildDir = join(packageRoot, config.build?.outDir ?? "dist");
+				hookContext.outDir = buildDir;
+				let libOptions = config?.build?.lib;
+				let libOptionsCustom = packageConfig?.viteConfig?.build?.lib;
+				let outputFormats = (libOptions === false ? void 0 : libOptions?.formats) ?? (libOptionsCustom === false ? void 0 : libOptionsCustom?.formats) ?? [...DEFAULT_LIB_FORMATS];
+				buildCjs = outputFormats.includes("cjs");
+				return deepMerge({
+					root: packageRoot,
+					build: {
+						emptyOutDir: true,
+						target: "es2022",
+						minify: false,
+						rollupOptions: { output: {
+							minifyInternalExports: false,
+							chunkFileNames: buildCjs ? `chunks/[format]/${chunkFileName}.js` : `chunks/${chunkFileName}.js`
+						} },
+						lib: {
+							entry: Object.fromEntries(entrypoints),
+							formats: outputFormats
+						}
+					}
+				}, packageConfig?.viteConfig ?? {});
+			},
+			async closeBundle() {
+				if (isNoop) return;
+				if (!buildCjs) removeCommonjsExports(packageJson.exports);
+				await params.finalizePackageJson?.(hookContext);
+				await packageConfig?.finalizePackageJson?.(hookContext);
+				await fsp.writeFile(join(buildDir, "package.json"), JSON.stringify(packageJson, null, 4));
+				for (let file of copyRootFiles) await tryCopy(join(rootDir, file), join(buildDir, file));
+				for (let file of copyPackageFiles) await tryCopy(join(packageRoot, file), join(buildDir, file));
+				if (insertTypesEntry) for (let [name, value] of entrypoints) {
+					let dTsFile = join(buildDir, `${name}.d.ts`);
+					if (await fileExists(dTsFile)) continue;
+					let entrypointFile = value;
+					if (!value.endsWith(".ts")) continue;
+					if (typesEntryRoot == null) {
+						assertStartsWith(entrypointFile, "./");
+						while (true) {
+							if (await fileExists(join(buildDir, entrypointFile.replace(/\.ts$/, ".d.ts")))) break;
+							let idx = entrypointFile.indexOf("/", 2);
+							if (idx === -1) throw new Error(`Could not find d.ts for entrypoint ${entrypointFile}, please pass typesEntryRoot explicitly`);
+							entrypointFile = `./${entrypointFile.slice(idx + 1)}`;
+						}
+					} else {
+						entrypointFile = relative(typesEntryRoot, join(packageRoot, entrypointFile));
+						if (!entrypointFile.startsWith(".")) entrypointFile = `./${entrypointFile}`;
+					}
+					entrypointFile = entrypointFile.replace(/\.ts$/, ".js");
+					await fsp.writeFile(dTsFile, `export * from ${JSON.stringify(entrypointFile)}`);
+				}
+				if (buildCjs) {
+					if (await directoryExists(join(buildDir, "chunks/cjs"))) {
+						let cjsFile = join(buildDir, "chunks/cjs/package.json");
+						await fsp.writeFile(cjsFile, JSON.stringify({ type: "commonjs" }));
+					}
+					await parallelMap(await glob("**/*.d.ts", { cwd: buildDir }), async (file) => {
+						let fullPath = join(buildDir, file);
+						await fsp.cp(fullPath, fullPath.replace(/\.d\.ts$/, ".d.cts"));
+					});
+				}
+				for (let [name, value] of entrypointsToCopy) {
+					let target = join(buildDir, name);
+					await fsp.mkdir(dirname(target), { recursive: true });
+					await tryCopy(join(packageRoot, value), target);
+				}
+				await params.finalize?.(hookContext);
+				await packageConfig?.finalize?.(hookContext);
+			}
+		},
+		...packageConfig?.pluginsPost ?? []
+	];
+}
+//#endregion
+export { yorozuBuild };

package/yorozu-build.d.ts

@@ -0,0 +1 @@
+export * from "./cli/main.js"