@codefast/cli 0.8.1 → 0.10.0

package/dist/core/workspace/resolver.js

@@ -1,35 +1,28 @@
-import { globSync } from "node:fs";
 import path from "node:path";
-import { fileURLToPath } from "node:url";
 import { parse as parseYaml } from "yaml";
 import { messageFrom } from "#/core/errors";
 import { createAnyGlobMatcher } from "#/core/glob";
 import { logger } from "#/core/logger";
+import { findNearestAncestor } from "#/core/workspace/ancestor-directories";
+import { packageJsonFileName, workspaceYamlFileName } from "#/core/workspace/well-known-files";
 /**
- * Resolves the monorepo root (directory containing `pnpm-workspace.yaml`).
+ * Resolves the project root: the `pnpm-workspace.yaml` directory, or the nearest `package.json` for a single package.
  *
- * @since 0.3.16-canary.0
+ * @since 0.10.0
  */
-export function findRepoRoot(fromDirectory, fs) {
-    const candidates = [path.dirname(fileURLToPath(import.meta.url)), fromDirectory];
-    for (const start of candidates) {
-        let dir = path.resolve(start);
-        for (;;) {
-            if (fs.existsSync(path.join(dir, "pnpm-workspace.yaml"))) {
-                return dir;
-            }
-            const parent = path.dirname(dir);
-            if (parent === dir) {
-                break;
-            }
-            dir = parent;
-        }
+export function resolveProjectRoot(fromDirectory, fs) {
+    // Resolution follows where the user is (cwd), not where the CLI is installed.
+    const workspaceRoot = findNearestAncestor(fromDirectory, (directoryPath) => fs.existsSync(path.join(directoryPath, workspaceYamlFileName)));
+    if (workspaceRoot !== undefined) {
+        return { rootDir: workspaceRoot, mode: "workspace" };
     }
-    throw new Error(`Could not locate monorepo root (missing pnpm-workspace.yaml). Searched from: ${candidates.join(", ")}`);
+    const packageRoot = findNearestAncestor(fromDirectory, (directoryPath) => fs.existsSync(path.join(directoryPath, packageJsonFileName)));
+    if (packageRoot !== undefined) {
+        return { rootDir: packageRoot, mode: "single-package" };
+    }
+    throw new Error(`Could not locate a project root (no pnpm-workspace.yaml and no package.json found from: ${fromDirectory})`);
 }
-const workspaceYamlFileName = "pnpm-workspace.yaml";
 const defaultIncludePatterns = ["packages/*"];
-const packageJsonFileName = "package.json";
 function toPosix(filePath) {
     return filePath.split(path.sep).join("/");
 }
@@ -71,33 +64,28 @@ function splitPnpmWorkspacePackagesArray(raw) {
     return { include, exclude };
 }
 function parsePnpmWorkspaceDocument(doc) {
-    const wf = workspaceYamlFileName;
-    if (doc === null || doc === undefined) {
-        throw new Error(`${wf} root document must be an object (got empty or null)`);
-    }
-    if (typeof doc !== "object" || Array.isArray(doc)) {
-        throw new Error(`${wf} root must be a mapping, not an array or scalar`);
+    if (doc === null || typeof doc !== "object" || Array.isArray(doc)) {
+        throw new Error(`${workspaceYamlFileName} root must be a mapping, not an array or scalar`);
     }
     const parsedDoc = doc;
     if (!Object.prototype.hasOwnProperty.call(parsedDoc, "packages")) {
         return { include: [], exclude: [], hasPackagesKey: false, isEmptyPackagesArray: false };
     }
-    const pkgs = parsedDoc.packages;
-    if (!Array.isArray(pkgs)) {
-        throw new Error(`${wf} field "packages" must be an array`);
+    const packagesField = parsedDoc.packages;
+    if (!Array.isArray(packagesField)) {
+        throw new Error(`${workspaceYamlFileName} field "packages" must be an array`);
     }
-    if (pkgs.length === 0) {
+    if (packagesField.length === 0) {
         return { include: [], exclude: [], hasPackagesKey: true, isEmptyPackagesArray: true };
     }
     return {
-        ...splitPnpmWorkspacePackagesArray(pkgs),
+        ...splitPnpmWorkspacePackagesArray(packagesField),
         hasPackagesKey: true,
         isEmptyPackagesArray: false,
     };
 }
 async function readWorkspaceYaml(rootDir, fs) {
-    const wf = workspaceYamlFileName;
-    const workspaceYamlPath = path.join(rootDir, wf);
+    const workspaceYamlPath = path.join(rootDir, workspaceYamlFileName);
     if (!fs.existsSync(workspaceYamlPath)) {
         return { exists: false };
     }
@@ -106,7 +94,7 @@ async function readWorkspaceYaml(rootDir, fs) {
         raw = await fs.readFile(workspaceYamlPath, "utf8");
     }
     catch (caughtReadError) {
-        throw new Error(`Failed to read ${wf}: ${messageFrom(caughtReadError)}`, {
+        throw new Error(`Failed to read ${workspaceYamlFileName}: ${messageFrom(caughtReadError)}`, {
             cause: caughtReadError,
         });
     }
@@ -115,12 +103,12 @@ async function readWorkspaceYaml(rootDir, fs) {
         doc = parseYaml(raw);
     }
     catch (caughtYamlParseError) {
-        throw new Error(`Failed to parse ${wf}: ${messageFrom(caughtYamlParseError)}`, {
+        throw new Error(`Failed to parse ${workspaceYamlFileName}: ${messageFrom(caughtYamlParseError)}`, {
             cause: caughtYamlParseError,
         });
     }
     if (doc === null || doc === undefined) {
-        throw new Error(`${wf} must define a mapping at the document root`);
+        throw new Error(`${workspaceYamlFileName} must define a mapping at the document root`);
     }
     return { exists: true, doc };
 }
@@ -131,47 +119,42 @@ async function readWorkspaceYaml(rootDir, fs) {
  */
 export async function listWorkspacePackageDirectories(rootDirectoryPathAbsolute, fs, suppressGlobPermissionDiagnostics) {
     const workspaceYaml = await readWorkspaceYaml(rootDirectoryPathAbsolute, fs);
-    const defInc = defaultIncludePatterns;
+    if (!workspaceYaml.exists) {
+        // No pnpm-workspace.yaml: treat the nearest package as the whole workspace.
+        const rootPackageJsonPath = path.join(rootDirectoryPathAbsolute, packageJsonFileName);
+        return {
+            packageDirectoryPathsAbsolute: fs.existsSync(rootPackageJsonPath) ? [rootDirectoryPathAbsolute] : [],
+            layoutSource: "single-package",
+            hasPnpmWorkspaceYamlFile: false,
+        };
+    }
     let include;
     let exclude;
     let layoutSource;
-    const hasPnpmWorkspaceYamlFile = workspaceYaml.exists;
-    if (!workspaceYaml.exists) {
-        include = [...defInc];
+    const parsed = parsePnpmWorkspaceDocument(workspaceYaml.doc);
+    if (!parsed.hasPackagesKey) {
+        include = [...defaultIncludePatterns];
         exclude = [];
         layoutSource = "default-patterns";
     }
+    else if (parsed.isEmptyPackagesArray) {
+        return {
+            packageDirectoryPathsAbsolute: [],
+            layoutSource: "declared-empty",
+            hasPnpmWorkspaceYamlFile: true,
+        };
+    }
     else {
-        const parsed = parsePnpmWorkspaceDocument(workspaceYaml.doc);
-        if (!parsed.hasPackagesKey) {
-            include = [...defInc];
-            exclude = [];
-            layoutSource = "default-patterns";
-        }
-        else if (parsed.isEmptyPackagesArray) {
-            return {
-                packageDirectoryPathsAbsolute: [],
-                layoutSource: "declared-empty",
-                hasPnpmWorkspaceYamlFile: true,
-            };
-        }
-        else {
-            include = parsed.include;
-            exclude = parsed.exclude;
-            layoutSource = "pnpm-workspace-yaml";
-        }
+        include = parsed.include;
+        exclude = parsed.exclude;
+        layoutSource = "pnpm-workspace-yaml";
     }
     const foundRelativePosixPackageRoots = new Set();
-    const globOpts = {
-        cwd: rootDirectoryPathAbsolute,
-        posix: true,
-        ...(path.sep === "\\" ? { windowsPathsNoEscape: true } : {}),
-    };
     for (const pattern of include) {
-        const globPat = workspacePatternToPackageJsonGlob(pattern);
+        const packageJsonGlob = workspacePatternToPackageJsonGlob(pattern);
         let matches;
         try {
-            matches = globSync(globPat, globOpts);
+            matches = fs.globSync(packageJsonGlob, { cwd: rootDirectoryPathAbsolute });
         }
         catch (caughtGlobError) {
             if (isGlobPermissionError(caughtGlobError)) {
@@ -184,26 +167,26 @@ export async function listWorkspacePackageDirectories(rootDirectoryPathAbsolute,
                 cause: caughtGlobError,
             });
         }
+        const suffix = `/${packageJsonFileName}`;
         for (const matchedPath of matches) {
-            const posix = toPosix(matchedPath);
-            const suffix = `/${packageJsonFileName}`;
-            if (!posix.endsWith(suffix)) {
+            const posixPath = toPosix(matchedPath);
+            if (!posixPath.endsWith(suffix)) {
                 continue;
             }
-            const rel = posix.slice(0, -suffix.length);
-            if (!rel) {
+            const relativeRoot = posixPath.slice(0, -suffix.length);
+            if (!relativeRoot) {
                 continue;
             }
-            foundRelativePosixPackageRoots.add(rel);
+            foundRelativePosixPackageRoots.add(relativeRoot);
         }
     }
     const isExcluded = createAnyGlobMatcher(exclude, { dot: true });
-    const filteredRelative = [...foundRelativePosixPackageRoots].filter((rel) => !isExcluded(rel));
+    const filteredRelative = [...foundRelativePosixPackageRoots].filter((relativeRoot) => !isExcluded(relativeRoot));
     filteredRelative.sort((a, b) => a.localeCompare(b));
-    const packageDirectoryPathsAbsolute = filteredRelative.map((rel) => path.resolve(rootDirectoryPathAbsolute, rel.split("/").join(path.sep)));
+    const packageDirectoryPathsAbsolute = filteredRelative.map((relativeRoot) => path.resolve(rootDirectoryPathAbsolute, relativeRoot.split("/").join(path.sep)));
     return {
         packageDirectoryPathsAbsolute,
         layoutSource,
-        hasPnpmWorkspaceYamlFile,
+        hasPnpmWorkspaceYamlFile: true,
     };
 }

package/dist/core/workspace/skip-directories.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Directory names every workspace walk skips: build output, vendored trees, and tool caches.
+ *
+ * @since 0.6.0
+ */
+export declare const defaultSkipDirectoryNames: ReadonlySet<string>;

package/dist/core/workspace/source-walk.d.ts

@@ -0,0 +1,16 @@
+import type { FilesystemPort } from "#/core/filesystem/port";
+/**
+ * Every hand-written source file a comment convention applies to — `.ts`, `.tsx`, `.css`, and ignore files.
+ *
+ * @remarks Emitted declarations are excluded: they carry whatever the compiler copied over,
+ * and rewriting them would be undone by the next build.
+ *
+ * @since 0.6.0
+ */
+export declare function walkSourceFiles(rootDirectoryPath: string, fs: FilesystemPort): Array<string>;
+/**
+ * Which comment syntax a path is written in, or `null` when the convention does not cover it.
+ *
+ * @since 0.6.0
+ */
+export declare function sourceCommentLanguage(filePath: string): "css" | "ignore" | "js" | null;

package/dist/core/workspace/source-walk.js

@@ -1,7 +1,15 @@
 import path from "node:path";
-import { defaultSkipDirectoryNames } from "#/core/workspace/skip-directories";
+import { walkFiles } from "#/core/workspace/walk-files";
+// Ignore files carry the divider convention over `#` comments — the content rules stay code-only.
+const ignoreFileNames = new Set([
+    ".gitignore",
+    ".dockerignore",
+    ".npmignore",
+    ".prettierignore",
+    ".eslintignore",
+]);
 /**
- * Every hand-written source file a comment convention applies to — `.ts`, `.tsx`, and `.css`.
+ * Every hand-written source file a comment convention applies to — `.ts`, `.tsx`, `.css`, and ignore files.
  *
  * @remarks Emitted declarations are excluded: they carry whatever the compiler copied over,
  * and rewriting them would be undone by the next build.
@@ -9,9 +17,7 @@ import { defaultSkipDirectoryNames } from "#/core/workspace/skip-directories";
  * @since 0.6.0
  */
 export function walkSourceFiles(rootDirectoryPath, fs) {
-    const result = [];
-    visitSourcePaths(result, rootDirectoryPath, fs);
-    return result;
+    return walkFiles(rootDirectoryPath, fs, (filePath) => sourceCommentLanguage(filePath) !== null);
 }
 /**
  * Which comment syntax a path is written in, or `null` when the convention does not cover it.
@@ -25,20 +31,8 @@ export function sourceCommentLanguage(filePath) {
     if (filePath.endsWith(".ts") || filePath.endsWith(".tsx")) {
         return "js";
     }
-    return filePath.endsWith(".css") ? "css" : null;
-}
-function visitSourcePaths(result, entryPath, fs) {
-    const entryStats = fs.statSync(entryPath);
-    if (entryStats.isDirectory()) {
-        for (const childName of fs.readdirSync(entryPath)) {
-            if (defaultSkipDirectoryNames.has(childName)) {
-                continue;
-            }
-            visitSourcePaths(result, path.join(entryPath, childName), fs);
-        }
-        return;
-    }
-    if (sourceCommentLanguage(entryPath) !== null) {
-        result.push(entryPath);
+    if (filePath.endsWith(".css")) {
+        return "css";
     }
+    return ignoreFileNames.has(path.basename(filePath)) ? "ignore" : null;
 }

package/dist/core/workspace/typescript-walk.d.ts

@@ -0,0 +1,7 @@
+import type { FilesystemPort } from "#/core/filesystem/port";
+/**
+ * Recursively collects the `.ts`/`.tsx` file paths under a root, skipping `.d.ts` and skip-listed directories.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function walkTsxFiles(rootDirectoryPath: string, fs: FilesystemPort): Array<string>;

package/dist/core/workspace/typescript-walk.js

@@ -1,30 +1,9 @@
-import path from "node:path";
-import { defaultSkipDirectoryNames } from "#/core/workspace/skip-directories";
+import { walkFiles } from "#/core/workspace/walk-files";
 /**
  * Recursively collects the `.ts`/`.tsx` file paths under a root, skipping `.d.ts` and skip-listed directories.
  *
  * @since 0.3.16-canary.0
  */
 export function walkTsxFiles(rootDirectoryPath, fs) {
-    const result = [];
-    visitTsxPaths(result, rootDirectoryPath, fs);
-    return result;
-}
-function visitTsxPaths(result, entryPath, fs) {
-    const entryStats = fs.statSync(entryPath);
-    if (entryStats.isDirectory()) {
-        for (const childName of fs.readdirSync(entryPath)) {
-            if (defaultSkipDirectoryNames.has(childName)) {
-                continue;
-            }
-            visitTsxPaths(result, path.join(entryPath, childName), fs);
-        }
-        return;
-    }
-    if (entryPath.endsWith(".d.ts")) {
-        return;
-    }
-    if (entryPath.endsWith(".tsx") || entryPath.endsWith(".ts")) {
-        result.push(entryPath);
-    }
+    return walkFiles(rootDirectoryPath, fs, (filePath) => !filePath.endsWith(".d.ts") && (filePath.endsWith(".ts") || filePath.endsWith(".tsx")));
 }

package/dist/core/workspace/walk-files.d.ts

@@ -0,0 +1,7 @@
+import type { FilesystemPort } from "#/core/filesystem/port";
+/**
+ * Every file under a root the predicate accepts, skipping build output and vendored trees.
+ *
+ * @since 0.10.0
+ */
+export declare function walkFiles(rootDirectoryPath: string, fs: FilesystemPort, shouldInclude: (filePath: string) => boolean): Array<string>;

package/dist/core/workspace/walk-files.js

@@ -0,0 +1,27 @@
+import path from "node:path";
+import { defaultSkipDirectoryNames } from "#/core/workspace/skip-directories";
+/**
+ * Every file under a root the predicate accepts, skipping build output and vendored trees.
+ *
+ * @since 0.10.0
+ */
+export function walkFiles(rootDirectoryPath, fs, shouldInclude) {
+    const result = [];
+    visit(result, rootDirectoryPath, fs, shouldInclude);
+    return result;
+}
+function visit(result, entryPath, fs, shouldInclude) {
+    const entryStats = fs.statSync(entryPath);
+    if (entryStats.isDirectory()) {
+        for (const childName of fs.readdirSync(entryPath)) {
+            if (defaultSkipDirectoryNames.has(childName)) {
+                continue;
+            }
+            visit(result, path.join(entryPath, childName), fs, shouldInclude);
+        }
+        return;
+    }
+    if (shouldInclude(entryPath)) {
+        result.push(entryPath);
+    }
+}

package/dist/core/workspace/well-known-files.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The manifest file name that marks a package directory.
+ *
+ * @since 0.10.0
+ */
+export declare const packageJsonFileName = "package.json";
+/**
+ * The pnpm workspace manifest file name that marks a workspace root.
+ *
+ * @since 0.10.0
+ */
+export declare const workspaceYamlFileName = "pnpm-workspace.yaml";
+/**
+ * The build output directory name packages emit to.
+ *
+ * @since 0.10.0
+ */
+export declare const distDirName = "dist";

package/dist/core/workspace/well-known-files.js

@@ -0,0 +1,18 @@
+/**
+ * The manifest file name that marks a package directory.
+ *
+ * @since 0.10.0
+ */
+export const packageJsonFileName = "package.json";
+/**
+ * The pnpm workspace manifest file name that marks a workspace root.
+ *
+ * @since 0.10.0
+ */
+export const workspaceYamlFileName = "pnpm-workspace.yaml";
+/**
+ * The build output directory name packages emit to.
+ *
+ * @since 0.10.0
+ */
+export const distDirName = "dist";

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The `@codefast/cli` public API: run the CLI in-process, and author a typed `codefast.config.*`.
+ */
+export { runCli } from "#/cli";
+export { defineConfig } from "#/core/config/define-config";
+export type { CodefastAfterWriteHook, CodefastArrangeConfig, CodefastConfig, CodefastTagConfig, MirrorConfig, } from "#/core/config/schema";

package/dist/index.js

@@ -0,0 +1,5 @@
+/**
+ * The `@codefast/cli` public API: run the CLI in-process, and author a typed `codefast.config.*`.
+ */
+export { runCli } from "#/cli";
+export { defineConfig } from "#/core/config/define-config";

package/dist/mirror/cli-result.d.ts

@@ -0,0 +1,13 @@
+import type { GlobalStats } from "#/mirror/domain/types";
+/**
+ * Maps a mirror run's stats to the process exit code.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function exitCodeForMirrorSyncResult(stats: GlobalStats): number;
+/**
+ * Serializes a mirror run's stats as the single-line JSON summary printed under `--json`.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function formatMirrorSyncJsonOutput(stats: GlobalStats, elapsedSeconds: number, write?: boolean): string;

package/dist/mirror/cli-schema.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+import type { MirrorSyncRunRequest } from "#/mirror/sync-types";
+/**
+ * Zod schema validating a `MirrorSyncRunRequest`.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare const mirrorSyncRunRequestSchema: z.ZodType<MirrorSyncRunRequest>;

package/dist/mirror/command.d.ts

@@ -0,0 +1,7 @@
+import { Command } from "commander";
+/**
+ * Creates the `mirror` subcommand, which writes `package.json#exports` from `dist/`.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function createMirrorCommand(): Command;

package/dist/mirror/dist-filesystem-impl.d.ts

@@ -0,0 +1,8 @@
+import type { FilesystemPort } from "#/core/filesystem/port";
+import type { DistFilesystem } from "#/mirror/domain/dist-filesystem";
+/**
+ * Creates the `DistFilesystem` the mirror scan uses, backed by a `FilesystemPort`.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function createMirrorDistFilesystem(fs: FilesystemPort): DistFilesystem;

package/dist/mirror/domain/constants.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The JavaScript extensions accepted as runtime entries in `dist/`.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare const VALID_JS_EXTENSIONS: ReadonlySet<string>;
+/**
+ * The declaration-file extensions accepted as type entries in `dist/`.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare const VALID_DTS_EXTENSIONS: ReadonlySet<string>;
+/**
+ * The `package.json` self-export specifier every generated map includes.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare const PACKAGE_JSON_EXPORT = "./package.json";

package/dist/mirror/domain/constants.js

@@ -1,15 +1,3 @@
-/**
- * The build output directory the mirror scan reads.
- *
- * @since 0.3.16-canary.0
- */
-export const DIST_DIR = "dist";
-/**
- * The manifest file name the mirror rewrites.
- *
- * @since 0.3.16-canary.0
- */
-export const PACKAGE_JSON = "package.json";
 /**
  * The JavaScript extensions accepted as runtime entries in `dist/`.
  *

package/dist/mirror/domain/dirent-guard.d.ts

@@ -0,0 +1,10 @@
+import type { DirectoryEntry } from "#/core/filesystem/port";
+/**
+ * Narrow `fs.promises.readdir` overload result to `Dirent[]` when `withFileTypes: true`.
+ * Accepts both historical checks (`isFile` / `isDirectory`) in one guard.
+ * Returning `true` for an empty array is intentional: callers treat empty lists
+ * the same regardless of the element type, so `[]` is safely accepted as `Dirent[]`.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function isDirentList(x: Array<string> | Array<DirectoryEntry>): x is Array<DirectoryEntry>;

package/dist/mirror/domain/dist-filesystem.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Filesystem surface used by mirror export generation (relative paths under `dist/`).
+ *
+ * @since 0.3.16-canary.0
+ */
+export interface DistFilesystem {
+    listRelativeFilesRecursively(dirPath: string): Promise<Array<string>>;
+    isDirectoryCssOnly(distDir: string, dirPath: string): Promise<boolean>;
+}

package/dist/mirror/domain/errors.d.ts

@@ -0,0 +1,24 @@
+/**
+ * The error codes a mirror run can fail with.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare const MirrorErrorCode: {
+    readonly FATAL: "FATAL";
+    readonly PACKAGE_WRITE: "PACKAGE_WRITE";
+};
+/**
+ * The union of `MirrorErrorCode` values.
+ *
+ * @since 0.3.16-canary.0
+ */
+export type MirrorErrorCode = (typeof MirrorErrorCode)[keyof typeof MirrorErrorCode];
+/**
+ * An `Error` carrying a `MirrorErrorCode` for mirror-specific failures.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare class MirrorError extends Error {
+    readonly code: MirrorErrorCode;
+    constructor(code: MirrorErrorCode, message: string, options?: ErrorOptions);
+}

package/dist/mirror/domain/exports.d.ts

@@ -0,0 +1,36 @@
+import type { DistFilesystem } from "#/mirror/domain/dist-filesystem";
+import type { GenerateExportsResult } from "#/mirror/domain/types";
+/**
+ * Creates a transform that strips a configured prefix from export paths, or `null` when none is set.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function createPathTransform(strip: string | undefined): ((pathString: string) => string) | null;
+/**
+ * Options shaping the conditions and specifiers of a generated exports map.
+ *
+ * @since 0.3.16-canary.3
+ */
+export interface GenerateExportsOptions {
+    /** Include a `source` condition pointing to the original source file. Pass `true` to
+     *  auto-derive via `resolveSourcePath`, or a string to set an explicit path for the
+     *  root export (`.`) only. */
+    source?: boolean | string;
+    /** Include the `types` condition when a `.d.ts` file exists (default `true`). */
+    types?: boolean;
+    /** Include the `import` condition (default `true`). */
+    import?: boolean;
+    /** Specifiers to leave out of the generated map — see `mirror.<pkg>.exclude`. Matched against
+     *  the post-`strip` specifier; a trailing `/*` excludes the whole subtree. */
+    exclude?: ReadonlyArray<string>;
+    /** Override the default source path derivation. Receives the module path relative to
+     *  `dist/` (e.g. `"components/button"`) and returns the full source specifier
+     *  (e.g. `"./src/components/button.tsx"`). When omitted, falls back to `./src/<path>.ts`. */
+    resolveSourcePath?: (modulePath: string) => string;
+}
+/**
+ * Generates a package's `package.json#exports` map from its `dist/` contents.
+ *
+ * @since 0.5.0-canary.8
+ */
+export declare function generateExports(fileSystemService: DistFilesystem, distDir: string, pathTransform: ((pathString: string) => string) | null, cssConfig: Record<string, unknown> | boolean | undefined, extraExports: Record<string, string>, options?: GenerateExportsOptions): Promise<GenerateExportsResult>;

package/dist/mirror/domain/package-display-name.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Domain rule: prefer `package.json#name` when it is present, otherwise use folder basename.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function resolvePackageDisplayName(packageJson: {
+    name?: unknown;
+}, folderBasename: string): string;

package/dist/mirror/domain/path-normalizer.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Converts a path's separators to forward slashes.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function normalizePath(pathString: string): string;