@codefast/cli 0.9.0 → 0.10.0

package/dist/core/workspace/ancestor-directories.js

@@ -0,0 +1,30 @@
+import path from "node:path";
+/**
+ * Each directory from `fromDirectory` up to and including the filesystem root.
+ *
+ * @since 0.10.0
+ */
+export function* ancestorDirectories(fromDirectory) {
+    let directoryPath = path.resolve(fromDirectory);
+    for (;;) {
+        yield directoryPath;
+        const parent = path.dirname(directoryPath);
+        if (parent === directoryPath) {
+            return;
+        }
+        directoryPath = parent;
+    }
+}
+/**
+ * The nearest ancestor directory (starting at `fromDirectory`) the predicate accepts, or undefined at the filesystem root.
+ *
+ * @since 0.10.0
+ */
+export function findNearestAncestor(fromDirectory, isMatch) {
+    for (const directoryPath of ancestorDirectories(fromDirectory)) {
+        if (isMatch(directoryPath)) {
+            return directoryPath;
+        }
+    }
+    return undefined;
+}

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

@@ -0,0 +1,7 @@
+import type { FilesystemPort } from "#/core/filesystem/port";
+/**
+ * Every markdown file under a root, skipping build output and vendored trees.
+ *
+ * @since 0.5.0
+ */
+export declare function walkMarkdownFiles(rootDirectoryPath: string, fs: FilesystemPort): Array<string>;

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

@@ -1,27 +1,9 @@
-import path from "node:path";
-import { defaultSkipDirectoryNames } from "#/core/workspace/skip-directories";
+import { walkFiles } from "#/core/workspace/walk-files";
 /**
  * Every markdown file under a root, skipping build output and vendored trees.
  *
  * @since 0.5.0
  */
 export function walkMarkdownFiles(rootDirectoryPath, fs) {
-    const result = [];
-    visitMarkdownPaths(result, rootDirectoryPath, fs);
-    return result;
-}
-function visitMarkdownPaths(result, entryPath, fs) {
-    const entryStats = fs.statSync(entryPath);
-    if (entryStats.isDirectory()) {
-        for (const childName of fs.readdirSync(entryPath)) {
-            if (defaultSkipDirectoryNames.has(childName)) {
-                continue;
-            }
-            visitMarkdownPaths(result, path.join(entryPath, childName), fs);
-        }
-        return;
-    }
-    if (entryPath.endsWith(".md")) {
-        result.push(entryPath);
-    }
+    return walkFiles(rootDirectoryPath, fs, (filePath) => filePath.endsWith(".md"));
 }

package/dist/core/workspace/package-version.d.ts

@@ -0,0 +1,9 @@
+import type { FilesystemPort } from "#/core/filesystem/port";
+/**
+ * Finds the `version` of the nearest enclosing `package.json`, or null when the first
+ * one found declares none (the private workspace root is version-less by design).
+ *
+ * @since 0.8.0
+ */
+declare function findNearestPackageVersion(fs: FilesystemPort, targetPath: string): string | null;
+export { findNearestPackageVersion };

package/dist/core/workspace/package-version.js

@@ -1,4 +1,6 @@
 import path from "node:path";
+import { findNearestAncestor } from "#/core/workspace/ancestor-directories";
+import { packageJsonFileName } from "#/core/workspace/well-known-files";
 /**
  * Finds the `version` of the nearest enclosing `package.json`, or null when the first
  * one found declares none (the private workspace root is version-less by design).
@@ -7,18 +9,12 @@ import path from "node:path";
  */
 function findNearestPackageVersion(fs, targetPath) {
     const resolved = path.resolve(targetPath);
-    let current = fs.statSync(resolved).isDirectory() ? resolved : path.dirname(resolved);
-    while (true) {
-        const packageJsonPath = path.join(current, "package.json");
-        if (fs.existsSync(packageJsonPath)) {
-            const version = JSON.parse(fs.readFileSync(packageJsonPath, "utf8")).version;
-            return typeof version === "string" && version.length > 0 ? version : null;
-        }
-        const parent = path.dirname(current);
-        if (parent === current) {
-            return null;
-        }
-        current = parent;
+    const startDirectory = fs.statSync(resolved).isDirectory() ? resolved : path.dirname(resolved);
+    const packageDirectory = findNearestAncestor(startDirectory, (directoryPath) => fs.existsSync(path.join(directoryPath, packageJsonFileName)));
+    if (packageDirectory === undefined) {
+        return null;
     }
+    const version = JSON.parse(fs.readFileSync(path.join(packageDirectory, packageJsonFileName), "utf8")).version;
+    return typeof version === "string" && version.length > 0 ? version : null;
 }
 export { findNearestPackageVersion };

package/dist/core/workspace/resolver.d.ts

@@ -0,0 +1,39 @@
+import type { FilesystemPort } from "#/core/filesystem/port";
+/**
+ * A resolved project root and whether it is a pnpm workspace or a standalone single package.
+ *
+ * @since 0.10.0
+ */
+export type ResolvedProjectRoot = {
+    readonly rootDir: string;
+    readonly mode: "workspace" | "single-package";
+};
+/**
+ * Resolves the project root: the `pnpm-workspace.yaml` directory, or the nearest `package.json` for a single package.
+ *
+ * @since 0.10.0
+ */
+export declare function resolveProjectRoot(fromDirectory: string, fs: FilesystemPort): ResolvedProjectRoot;
+/**
+ * Where the workspace package patterns came from.
+ *
+ * @since 0.3.16-canary.0
+ */
+type WorkspacePackageLayoutSource = "pnpm-workspace-yaml" | "default-patterns" | "declared-empty" | "single-package";
+/**
+ * The discovered workspace package directories together with how the layout was determined.
+ *
+ * @since 0.3.16-canary.0
+ */
+export type WorkspacePackageLayoutOutcome = {
+    readonly packageDirectoryPathsAbsolute: Array<string>;
+    readonly layoutSource: WorkspacePackageLayoutSource;
+    readonly hasPnpmWorkspaceYamlFile: boolean;
+};
+/**
+ * Lists the workspace's package directories per `pnpm-workspace.yaml`, falling back to default patterns.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function listWorkspacePackageDirectories(rootDirectoryPathAbsolute: string, fs: FilesystemPort, suppressGlobPermissionDiagnostics?: boolean): Promise<WorkspacePackageLayoutOutcome>;
+export {};

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,5 +1,5 @@
 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",
@@ -17,9 +17,7 @@ const ignoreFileNames = new Set([
  * @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.
@@ -37,19 +35,4 @@ export function sourceCommentLanguage(filePath) {
         return "css";
     }
     return ignoreFileNames.has(path.basename(filePath)) ? "ignore" : 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);
-    }
 }

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/`.
  *