@codefast/cli 0.9.0 → 0.11.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 { Filesystem } from "#/core/filesystem/filesystem";
+/**
+ * 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: Filesystem): 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 { Filesystem } from "#/core/filesystem/filesystem";
+/**
+ * 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: Filesystem): 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 { Filesystem } from "#/core/filesystem/filesystem";
+/**
+ * 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: Filesystem, 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 * as z from "zod";
+import type { MirrorSyncRunRequest } from "#/mirror/domain/types";
+/**
+ * Zod schema validating a `MirrorSyncRunRequest`.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare const mirrorSyncRunRequestSchema: z.ZodType<MirrorSyncRunRequest>;

package/dist/mirror/cli-schema.js

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import * as z from "zod";
 /**
  * Zod schema validating a `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/command.js

@@ -1,74 +1,45 @@
-import process from "node:process";
 import { Command } from "commander";
-import { globalCliCommanderOptionsSchema } from "#/core/cli/global-options";
-import { readOptionalPositionalArg } from "#/core/cli/positional";
-import { consumeCliAppError } from "#/core/cli/result-handle";
+import { applyCommandPipeline } from "#/core/cli/command-pipeline";
 import { nodeFilesystem } from "#/core/filesystem/node";
-import { logger } from "#/core/logger";
-import { parseWithSchema } from "#/core/schema-parse";
 import { exitCodeForMirrorSyncResult, formatMirrorSyncJsonOutput } from "#/mirror/cli-result";
 import { mirrorSyncRunRequestSchema } from "#/mirror/cli-schema";
 import { MirrorSyncProgressPresenter } from "#/mirror/output";
 import { prepareMirrorSync } from "#/mirror/prepare";
-import { runMirrorSync } from "#/mirror/sync";
+import { runMirrorSync } from "#/mirror/run";
+const mirrorPipeline = {
+    positional: { name: "[package]", help: "Optional package path relative to repo root (e.g. packages/ui)" },
+    schema: mirrorSyncRunRequestSchema,
+    configureArgv: (command) => {
+        command.option("--dry-run", "Report what would change without writing package.json", false);
+        command.option("-v, --verbose", "Print extra diagnostics", false);
+    },
+    prepare: (fs, input) => prepareMirrorSync(fs, {
+        currentWorkingDirectory: input.currentWorkingDirectory,
+        packageArg: input.rawArg,
+        globals: input.globals,
+    }),
+    buildRequest: ({ prelude, opts }) => ({
+        rootDir: prelude.rootDir,
+        config: prelude.config.mirror ?? {},
+        packageFilter: prelude.packageFilter,
+        write: !opts.dryRun,
+    }),
+    createPresenter: ({ opts, globals }) => {
+        const presenter = new MirrorSyncProgressPresenter();
+        presenter.configure({ noColor: globals.color === false, verbose: !!opts.verbose, dryRun: !!opts.dryRun });
+        return presenter;
+    },
+    run: (fs, request, presenter) => runMirrorSync(fs, { ...request, listener: presenter }),
+    formatJson: ({ result, opts, elapsedSeconds }) => formatMirrorSyncJsonOutput(result, elapsedSeconds, !opts.dryRun),
+    exitCode: exitCodeForMirrorSyncResult,
+};
 /**
  * Creates the `mirror` subcommand, which writes `package.json#exports` from `dist/`.
  *
  * @since 0.3.16-canary.0
  */
 export function createMirrorCommand() {
-    const cmd = new Command("mirror")
-        .description("Write package.json exports from dist/ for workspace packages")
-        .argument("[package]", "Optional package path relative to repo root (e.g. packages/ui)")
-        .option("--dry-run", "Report what would change without writing package.json", false)
-        .option("-v, --verbose", "Print extra diagnostics", false)
-        .option("--json", "Print one JSON summary on stdout (suppresses human progress)", false)
-        .action(async (packageArg, opts, command) => {
-        const globalsOptionCarrier = command.optsWithGlobals?.() ??
-            command.opts();
-        const globalOptionsOutcome = parseWithSchema(globalCliCommanderOptionsSchema, globalsOptionCarrier);
-        if (!consumeCliAppError(globalOptionsOutcome)) {
-            return;
-        }
-        const prelude = await prepareMirrorSync(nodeFilesystem, {
-            currentWorkingDirectory: process.cwd(),
-            packageArg: readOptionalPositionalArg(packageArg),
-            globals: globalOptionsOutcome.value,
-        });
-        if (!consumeCliAppError(prelude)) {
-            return;
-        }
-        const write = !opts.dryRun;
-        const { rootDir, config, packageFilter } = prelude.value;
-        const parsed = parseWithSchema(mirrorSyncRunRequestSchema, {
-            rootDir,
-            config: config.mirror ?? {},
-            packageFilter,
-            write,
-        });
-        if (!consumeCliAppError(parsed)) {
-            return;
-        }
-        const json = !!opts.json;
-        const noColor = globalOptionsOutcome.value.color === false;
-        const verbose = !!opts.verbose;
-        const progressPresenter = new MirrorSyncProgressPresenter();
-        const listener = json ? undefined : progressPresenter;
-        if (!json) {
-            progressPresenter.configure({ noColor, verbose, dryRun: !write });
-        }
-        const startTime = performance.now();
-        const outcome = await runMirrorSync(nodeFilesystem, {
-            ...parsed.value,
-            listener,
-        });
-        if (!consumeCliAppError(outcome)) {
-            return;
-        }
-        if (json) {
-            logger.out(formatMirrorSyncJsonOutput(outcome.value, (performance.now() - startTime) / 1000, write));
-        }
-        process.exitCode = exitCodeForMirrorSyncResult(outcome.value);
-    });
+    const cmd = new Command("mirror").description("Write package.json exports from dist/ for workspace packages");
+    applyCommandPipeline(cmd, nodeFilesystem, mirrorPipeline);
     return cmd;
 }

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

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

package/dist/mirror/{dist-filesystem-impl.js → dist-filesystem-node.js}

@@ -2,7 +2,7 @@ import path from "node:path";
 import { isDirentList } from "#/mirror/domain/dirent-guard";
 import { normalizePath } from "#/mirror/domain/path-normalizer";
 /**
- * Creates the `DistFilesystem` the mirror scan uses, backed by a `FilesystemPort`.
+ * Creates the `DistFilesystem` the mirror scan uses, backed by a `Filesystem`.
  *
  * @since 0.3.16-canary.0
  */

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/filesystem";
+/**
+ * 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>;
+}