@codefast/cli 0.3.15 → 0.3.16-canary.0

package/dist/{program.mjs → cli.mjs}

@@ -1,11 +1,12 @@
-import { registerCliCommandTreesOnProgram } from "./bootstrap/register-cli-command-trees.mjs";
-import { createCliRuntimeContainer, resolveCliCommands } from "./bootstrap/composition-root.mjs";
+import { createArrangeCommand } from "./arrange/command.mjs";
+import { createMirrorCommand } from "./mirror/command.mjs";
+import { createTagCommand } from "./tag/command.mjs";
 import process from "node:process";
 import { readFileSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { Command } from "commander";
-//#region src/program.ts
+//#region src/cli.ts
 function readVersion() {
 	try {
 		const dir = path.dirname(fileURLToPath(import.meta.url));
@@ -16,25 +17,18 @@ function readVersion() {
 		return "unknown";
 	}
 }
-function createProgram(commands) {
+/**
+* @since 0.3.16-canary.0
+*/
+async function runCli(argv) {
 	const program = new Command();
 	program.name("codefast").description("Codefast monorepo developer CLI").version(readVersion()).option("--no-color", "Disable ANSI color output").configureHelp({ sortSubcommands: true }).showHelpAfterError("(use --help for usage)");
-	registerCliCommandTreesOnProgram(program, commands);
-	return program;
-}
-async function runCli(argv) {
-	const runtimeContainer = createCliRuntimeContainer();
-	try {
-		if (process.env.NODE_ENV !== "production") {
-			runtimeContainer.validate();
-			await runtimeContainer.initializeAsync();
-		}
-		await createProgram(resolveCliCommands(runtimeContainer)).parseAsync(argv, { from: "node" });
-		const code = process.exitCode ?? 0;
-		return typeof code === "number" ? code : Number(code) || 0;
-	} finally {
-		await runtimeContainer.dispose();
-	}
+	program.addCommand(createArrangeCommand());
+	program.addCommand(createMirrorCommand());
+	program.addCommand(createTagCommand());
+	await program.parseAsync(argv, { from: "node" });
+	const code = process.exitCode ?? 0;
+	return typeof code === "number" ? code : Number(code) || 0;
 }
 //#endregion
 export { runCli };

package/dist/core/cli/format-error.mjs

@@ -0,0 +1,15 @@
+//#region src/core/cli/format-error.ts
+/**
+* @since 0.3.16-canary.0
+*/
+function formatAppError(error) {
+	const { code, message } = error;
+	switch (code) {
+		case "NOT_FOUND": return `[NOT_FOUND] ${message}`;
+		case "VALIDATION_ERROR": return `[VALIDATION_ERROR] ${message}`;
+		case "INFRA_FAILURE": return `[INFRA_FAILURE] ${message}`;
+		default: return `Unhandled error code: ${String(code)}`;
+	}
+}
+//#endregion
+export { formatAppError };

package/dist/core/cli/global-options.mjs

@@ -0,0 +1,10 @@
+import { z } from "zod";
+//#region src/core/cli/global-options.ts
+/**
+* Commander global opts shape validated before mirror prelude (`color` from `--no-color`).
+*
+* @since 0.3.16-canary.0
+*/
+const globalCliCommanderOptionsSchema = z.object({ color: z.boolean().optional() });
+//#endregion
+export { globalCliCommanderOptionsSchema };

package/dist/core/cli/positional.mjs

@@ -0,0 +1,11 @@
+//#region src/core/cli/positional.ts
+/**
+* Coerce a raw Commander positional argument to a string, or undefined when absent.
+*
+* @since 0.3.16-canary.0
+*/
+function readOptionalPositionalArg(candidate) {
+	return typeof candidate === "string" ? candidate : void 0;
+}
+//#endregion
+export { readOptionalPositionalArg };

package/dist/core/cli/result-handle.mjs

@@ -0,0 +1,51 @@
+import { formatAppError } from "./format-error.mjs";
+import "../exit-codes.mjs";
+import { logger } from "../logger.mjs";
+import { isVerboseCliDiagnostics } from "../verbose-diagnostics.mjs";
+import process from "node:process";
+//#region src/core/cli/result-handle.ts
+function exitCodeForAppError(error) {
+	switch (error.code) {
+		case "NOT_FOUND": return 1;
+		case "VALIDATION_ERROR": return 2;
+		case "INFRA_FAILURE": return 1;
+		default: return error.code;
+	}
+}
+/**
+* @since 0.3.16-canary.0
+*/
+function handleResult(outcome, onSuccess) {
+	if (!outcome.ok) {
+		logger.err(formatAppError(outcome.error));
+		if (isVerboseCliDiagnostics() && outcome.error.code === "INFRA_FAILURE" && outcome.error.cause instanceof Error && outcome.error.cause.stack !== void 0) logger.err(outcome.error.cause.stack);
+		process.exitCode = exitCodeForAppError(outcome.error);
+		return false;
+	}
+	onSuccess(outcome.value);
+	return true;
+}
+/**
+* @since 0.3.16-canary.0
+*/
+function consumeCliAppError(outcome, options) {
+	if (!outcome.ok) {
+		logger.err(formatAppError(outcome.error));
+		if (isVerboseCliDiagnostics() && outcome.error.code === "INFRA_FAILURE" && outcome.error.cause instanceof Error && outcome.error.cause.stack !== void 0) logger.err(outcome.error.cause.stack);
+		process.exitCode = exitCodeForAppError(outcome.error);
+		return false;
+	}
+	if (options?.successMessage !== void 0) logger.out(options.successMessage);
+	return true;
+}
+/**
+* @since 0.3.16-canary.0
+*/
+async function runCliResultAsync(outcomePromise, onSuccess) {
+	const outcome = await outcomePromise;
+	if (!consumeCliAppError(outcome)) return;
+	const exit = await onSuccess(outcome.value);
+	process.exitCode = exit === void 0 ? 0 : exit;
+}
+//#endregion
+export { consumeCliAppError, handleResult, runCliResultAsync };

package/dist/core/config/loader.mjs

@@ -0,0 +1,79 @@
+import { codefastConfigRootSchema } from "./schema.mjs";
+import path from "node:path";
+import jiti from "jiti";
+//#region src/core/config/loader.ts
+function formatZodError(error, filePath) {
+	const formatted = error.issues.map((issue) => {
+		return `  - ${issue.path.length > 0 ? issue.path.join(".") : "<root>"}: ${issue.message}`;
+	}).join("\n");
+	return `Invalid config schema in ${path.basename(filePath)}:\n${formatted}`;
+}
+function parseLoadedConfig(raw, filePath) {
+	const parsed = codefastConfigRootSchema.safeParse(raw);
+	if (!parsed.success) throw new Error(formatZodError(parsed.error, filePath));
+	return parsed.data;
+}
+const configJsPriority = [
+	"codefast.config.mjs",
+	"codefast.config.js",
+	"codefast.config.cjs"
+];
+const configJson = "codefast.config.json";
+const cachedLoads = /* @__PURE__ */ new Map();
+function listConfigCandidates(startDir, fs) {
+	const candidates = [];
+	let current = path.resolve(startDir);
+	while (true) {
+		for (const name of configJsPriority) {
+			const candidate = path.join(current, name);
+			if (fs.existsSync(candidate)) candidates.push(candidate);
+		}
+		const jsonCandidate = path.join(current, configJson);
+		if (fs.existsSync(jsonCandidate)) candidates.push(jsonCandidate);
+		const parent = path.dirname(current);
+		if (parent === current) break;
+		current = parent;
+	}
+	return candidates;
+}
+async function readConfigFromPath(filePath, jitiBaseDir, fs) {
+	if (path.extname(filePath) === ".json") {
+		const content = await fs.readFile(filePath, "utf8");
+		return parseLoadedConfig(JSON.parse(content), filePath);
+	}
+	const moduleConfig = jiti(jitiBaseDir, {
+		interopDefault: true,
+		moduleCache: false
+	})(filePath);
+	return parseLoadedConfig(typeof moduleConfig === "object" && moduleConfig !== null && "default" in moduleConfig ? moduleConfig.default : moduleConfig, filePath);
+}
+async function loadOnce(startDir, fs) {
+	const warnings = [];
+	const configPaths = listConfigCandidates(startDir, fs);
+	if (configPaths.length === 0) return {
+		config: {},
+		warnings
+	};
+	const configPath = configPaths[0];
+	if (configPath === void 0) return {
+		config: {},
+		warnings
+	};
+	return {
+		config: await readConfigFromPath(configPath, startDir, fs),
+		warnings,
+		configPath
+	};
+}
+/**
+* @since 0.3.16-canary.0
+*/
+function loadConfigPayload(startDir, fs) {
+	const cacheKey = path.resolve(startDir);
+	if (!cachedLoads.has(cacheKey)) cachedLoads.set(cacheKey, loadOnce(cacheKey, fs));
+	const cached = cachedLoads.get(cacheKey);
+	if (cached === void 0) throw new Error("config loader cache invariant violated");
+	return cached;
+}
+//#endregion
+export { loadConfigPayload };

package/dist/{domains/config/domain/codefast-config.schema.mjs → core/config/schema.mjs}

@@ -1,6 +1,9 @@
 import { z } from "zod";
-//#region src/domains/config/domain/codefast-config.schema.ts
+//#region src/core/config/schema.ts
 const afterWriteHookSchema = z.custom((value) => typeof value === "function", { message: "Expected a function" });
+/**
+* @since 0.3.16-canary.0
+*/
 const mirrorConfigSchema = z.object({
 	skipPackages: z.array(z.string()).optional(),
 	pathTransformations: z.record(z.string(), z.object({ removePrefix: z.string().optional() }).strict()).optional(),
@@ -11,12 +14,23 @@ const mirrorConfigSchema = z.object({
 		forceExportFiles: z.boolean().optional()
 	}).strict()])).optional()
 }).strict();
+/**
+* @since 0.3.16-canary.0
+*/
 const codefastTagConfigSchema = z.object({
 	skipPackages: z.array(z.string()).optional(),
 	onAfterWrite: afterWriteHookSchema.optional()
 }).strict();
+/**
+* @since 0.3.16-canary.0
+*/
 const codefastArrangeConfigSchema = z.object({ onAfterWrite: afterWriteHookSchema.optional() }).strict();
-/** Root `codefast.config` Zod schema — single source of truth for both validation and TS types. */ const codefastConfigRootSchema = z.object({
+/**
+* Root `codefast.config` Zod schema — single source of truth for both validation and TS types.
+*
+* @since 0.3.16-canary.0
+*/
+const codefastConfigRootSchema = z.object({
 	mirror: mirrorConfigSchema.optional(),
 	tag: codefastTagConfigSchema.optional(),
 	arrange: codefastArrangeConfigSchema.optional()

package/dist/core/config/warnings.mjs

@@ -0,0 +1,12 @@
+import { logger } from "../logger.mjs";
+//#region src/core/config/warnings.ts
+const yellowAnsi = "\x1B[33m";
+const resetAnsi = "\x1B[0m";
+/**
+* @since 0.3.16-canary.0
+*/
+function reportSchemaWarnings(warnings) {
+	for (const warningMessage of warnings) logger.out(`${yellowAnsi}⚠ ${warningMessage}${resetAnsi}`);
+}
+//#endregion
+export { reportSchemaWarnings };

package/dist/core/config.mjs

@@ -0,0 +1,19 @@
+import { AppError, messageFrom } from "./errors.mjs";
+import { err, ok } from "./result.mjs";
+import { loadConfigPayload } from "./config/loader.mjs";
+import { reportSchemaWarnings } from "./config/warnings.mjs";
+//#region src/core/config.ts
+/**
+* @since 0.3.16-canary.0
+*/
+async function loadCodefastConfig(rootDir, fs) {
+	try {
+		const { config, warnings } = await loadConfigPayload(rootDir, fs);
+		reportSchemaWarnings(warnings);
+		return ok({ config });
+	} catch (caughtError) {
+		return err(new AppError("INFRA_FAILURE", messageFrom(caughtError), caughtError));
+	}
+}
+//#endregion
+export { loadCodefastConfig };

package/dist/{shell/domain/caught-unknown-message.value-object.mjs → core/errors.mjs}

@@ -1,8 +1,24 @@
-//#region src/shell/domain/caught-unknown-message.value-object.ts
+//#region src/core/errors.ts
+/**
+* @since 0.3.16-canary.0
+*/
+var AppError = class {
+	name = "AppError";
+	code;
+	message;
+	cause;
+	constructor(code, message, cause) {
+		this.code = code;
+		this.message = message;
+		if (cause !== void 0) this.cause = cause;
+	}
+};
 /**
 * Stable, user-facing text for values caught as `unknown`.
-* Avoids `String(unknown)` / `[object Object]` and satisfies strict `no-base-to-string`.
-*/ function messageFromCaughtUnknown(value) {
+*
+* @since 0.3.16-canary.0
+*/
+function messageFrom(value) {
 	if (value instanceof Error) return value.message;
 	if (typeof value === "string") return value;
 	if (typeof value === "number" || typeof value === "bigint" || typeof value === "boolean") return String(value);
@@ -16,4 +32,4 @@
 	return "[unserializable non-Error value]";
 }
 //#endregion
-export { messageFromCaughtUnknown };
+export { AppError, messageFrom };

package/dist/core/exit-codes.mjs

@@ -0,0 +1,17 @@
+//#region src/core/exit-codes.ts
+/**
+* Process exit codes for the `codefast` CLI.
+*
+* @since 0.3.16-canary.0
+*/
+const CLI_EXIT_SUCCESS = 0;
+/**
+* @since 0.3.16-canary.0
+*/
+const CLI_EXIT_GENERAL_ERROR = 1;
+/**
+* @since 0.3.16-canary.0
+*/
+const CLI_EXIT_USAGE = 2;
+//#endregion
+export { CLI_EXIT_GENERAL_ERROR, CLI_EXIT_SUCCESS, CLI_EXIT_USAGE };

package/dist/core/filesystem/node.mjs

@@ -0,0 +1,32 @@
+import fsSync from "node:fs";
+import path from "node:path";
+import fsPromises from "node:fs/promises";
+//#region src/core/filesystem/node.ts
+/**
+* @since 0.3.16-canary.0
+*/
+const nodeFilesystem = {
+	existsSync: fsSync.existsSync,
+	statSync: fsSync.statSync,
+	readFileSync: fsSync.readFileSync,
+	writeFileSync: fsSync.writeFileSync,
+	readdirSync: fsSync.readdirSync,
+	canonicalPathSync(inputPath) {
+		try {
+			return fsSync.realpathSync.native(inputPath);
+		} catch {
+			return path.resolve(inputPath);
+		}
+	},
+	readFile: (filePath, enc) => fsPromises.readFile(filePath, enc),
+	writeFile: (filePath, data, enc) => fsPromises.writeFile(filePath, data, enc),
+	readdir: async (filePath, opts) => {
+		const raw = await fsPromises.readdir(filePath, opts);
+		if (!opts?.withFileTypes) return raw;
+		return raw;
+	},
+	rename: (oldPath, newPath) => fsPromises.rename(oldPath, newPath),
+	unlink: (filePath) => fsPromises.unlink(filePath)
+};
+//#endregion
+export { nodeFilesystem };

package/dist/core/logger.mjs

@@ -0,0 +1,15 @@
+import process from "node:process";
+//#region src/core/logger.ts
+/**
+* @since 0.3.16-canary.0
+*/
+const logger = {
+	out(line) {
+		process.stdout.write(`${line}\n`);
+	},
+	err(line) {
+		process.stderr.write(`${line}\n`);
+	}
+};
+//#endregion
+export { logger };

package/dist/{shell/domain/result.model.mjs → core/result.mjs}

@@ -1,12 +1,16 @@
-//#region src/shell/domain/result.model.ts
+//#region src/core/result.ts
 /**
-* Lightweight functional Result type for use-case boundaries.
-*/ function ok(value) {
+* @since 0.3.16-canary.0
+*/
+function ok(value) {
 	return {
 		ok: true,
 		value
 	};
 }
+/**
+* @since 0.3.16-canary.0
+*/
 function err(error) {
 	return {
 		ok: false,

package/dist/core/schema-parse.mjs

@@ -0,0 +1,18 @@
+import { AppError } from "./errors.mjs";
+import { err, ok } from "./result.mjs";
+//#region src/core/schema-parse.ts
+function formatSchemaIssues(issues) {
+	return issues.map((issue) => {
+		return `${issue.path.length > 0 ? `${issue.path.join(".")}: ` : ""}${issue.message}`;
+	}).join("; ");
+}
+/**
+* @since 0.3.16-canary.0
+*/
+function parseWithSchema(schema, input) {
+	const parsed = schema.safeParse(input);
+	if (!parsed.success) return err(new AppError("VALIDATION_ERROR", formatSchemaIssues(parsed.error.issues)));
+	return ok(parsed.data);
+}
+//#endregion
+export { parseWithSchema };

package/dist/{shell/domain/source-text-edit.support.mjs → core/source-text-edit.mjs}

@@ -1,14 +1,13 @@
-//#region src/shell/domain/source-text-edit.support.ts
-/**
-* Pure string utilities for applying non-overlapping text edits and reading line indentation.
-*/ function lineStartIndexContaining(source, pos) {
+//#region src/core/source-text-edit.ts
+function lineStartIndexContaining(source, pos) {
 	const searchPos = Math.max(0, Math.min(pos, source.length));
 	const prevLineBreak = Math.max(source.lastIndexOf("\n", searchPos - 1), source.lastIndexOf("\r", searchPos - 1));
 	return prevLineBreak === -1 ? 0 : prevLineBreak + 1;
 }
 /**
-* Returns only the leading whitespace (tabs / spaces) of the line containing `pos`.
-*/ function indentOfLineContaining(source, pos) {
+* @since 0.3.16-canary.0
+*/
+function indentOfLineContaining(source, pos) {
 	const lineStart = lineStartIndexContaining(source, pos);
 	let lineEnd = source.length;
 	for (let i = lineStart; i < source.length; i++) {
@@ -22,17 +21,16 @@
 	return /^[\t ]*/.exec(line)?.[0] ?? "";
 }
 /**
-* Source slice `[lineStart, pos)` for the line containing `pos`. Aligns continuation lines with
-* a token not at column 0 (e.g. `base: ["foo"` → prefix before the opening `"` of `"foo"`).
-*/ function textPrefixFromLineStartToPosition(source, pos) {
+* @since 0.3.16-canary.0
+*/
+function textPrefixFromLineStartToPosition(source, pos) {
 	const searchPos = Math.max(0, Math.min(pos, source.length));
 	return source.slice(lineStartIndexContaining(source, searchPos), searchPos);
 }
 /**
-* If `tokenEnd` is followed by optional ASCII whitespace then `,`, returns the index after that
-* comma. Otherwise returns `tokenEnd`. Useful when a replacement already ends with `,` and the
-* following source comma must be absorbed.
-*/ function endAfterOptionalCommaFollowingInSource(source, tokenEnd) {
+* @since 0.3.16-canary.0
+*/
+function endAfterOptionalCommaFollowingInSource(source, tokenEnd) {
 	let index = tokenEnd;
 	while (index < source.length) {
 		const ch = source[index];
@@ -45,6 +43,9 @@
 	}
 	return tokenEnd;
 }
+/**
+* @since 0.3.16-canary.0
+*/
 function applyEditsDescending(sourceText, edits) {
 	const sorted = [...edits].sort((editA, editB) => editB.start - editA.start);
 	let out = sourceText;

package/dist/core/verbose-diagnostics.mjs

@@ -0,0 +1,11 @@
+import process from "node:process";
+//#region src/core/verbose-diagnostics.ts
+/**
+* @since 0.3.16-canary.0
+*/
+function isVerboseCliDiagnostics() {
+	const raw = process.env.CODEFAST_VERBOSE;
+	return raw === "1" || raw === "true";
+}
+//#endregion
+export { isVerboseCliDiagnostics };

package/dist/core/workspace/resolver.mjs

@@ -0,0 +1,177 @@
+import { messageFrom } from "../errors.mjs";
+import { logger } from "../logger.mjs";
+import { globSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import picomatch from "picomatch";
+import { parse } from "yaml";
+//#region src/core/workspace/resolver.ts
+/**
+* Resolve the monorepo root (directory containing `pnpm-workspace.yaml`).
+*
+* @since 0.3.16-canary.0
+*/
+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;
+		}
+	}
+	throw new Error(`Could not locate monorepo root (missing pnpm-workspace.yaml). Searched from: ${candidates.join(", ")}`);
+}
+const workspaceYamlFileName = "pnpm-workspace.yaml";
+const defaultIncludePatterns = ["packages/*"];
+const packageJsonFileName = "package.json";
+function toPosix(filePath) {
+	return filePath.split(path.sep).join("/");
+}
+function isGlobPermissionError(caughtError) {
+	if (typeof caughtError !== "object" || caughtError === null || !("code" in caughtError)) return false;
+	const code = caughtError.code;
+	return code === "EACCES" || code === "EPERM";
+}
+function workspacePatternToPackageJsonGlob(pattern) {
+	const normalizedPattern = toPosix(pattern.trim()).replace(/\/+$/, "");
+	if (!normalizedPattern) return `**/${packageJsonFileName}`;
+	return `${normalizedPattern}/${packageJsonFileName}`;
+}
+function splitPnpmWorkspacePackagesArray(raw) {
+	const include = [];
+	const exclude = [];
+	if (!Array.isArray(raw)) return {
+		include,
+		exclude
+	};
+	for (const entry of raw) {
+		if (typeof entry !== "string") continue;
+		const trimmed = entry.trim();
+		if (!trimmed) continue;
+		if (trimmed.startsWith("!")) exclude.push(trimmed.slice(1).trim());
+		else include.push(trimmed);
+	}
+	return {
+		include,
+		exclude
+	};
+}
+function parsePnpmWorkspaceDocument(doc) {
+	const wf = workspaceYamlFileName;
+	if (doc === null || doc === void 0) 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`);
+	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`);
+	if (pkgs.length === 0) return {
+		include: [],
+		exclude: [],
+		hasPackagesKey: true,
+		isEmptyPackagesArray: true
+	};
+	return {
+		...splitPnpmWorkspacePackagesArray(pkgs),
+		hasPackagesKey: true,
+		isEmptyPackagesArray: false
+	};
+}
+async function readWorkspaceYaml(rootDir, fs) {
+	const wf = workspaceYamlFileName;
+	const workspaceYamlPath = path.join(rootDir, wf);
+	if (!fs.existsSync(workspaceYamlPath)) return { exists: false };
+	let raw;
+	try {
+		raw = await fs.readFile(workspaceYamlPath, "utf8");
+	} catch (caughtReadError) {
+		throw new Error(`Failed to read ${wf}: ${messageFrom(caughtReadError)}`);
+	}
+	let doc;
+	try {
+		doc = parse(raw);
+	} catch (caughtYamlParseError) {
+		throw new Error(`Failed to parse ${wf}: ${messageFrom(caughtYamlParseError)}`);
+	}
+	if (doc === null || doc === void 0) throw new Error(`${wf} must define a mapping at the document root`);
+	return {
+		exists: true,
+		doc
+	};
+}
+/**
+* @since 0.3.16-canary.0
+*/
+async function listWorkspacePackageDirectories(rootDirectoryPathAbsolute, fs, suppressGlobPermissionDiagnostics) {
+	const workspaceYaml = await readWorkspaceYaml(rootDirectoryPathAbsolute, fs);
+	const defInc = defaultIncludePatterns;
+	let include;
+	let exclude;
+	let layoutSource;
+	const hasPnpmWorkspaceYamlFile = workspaceYaml.exists;
+	if (!workspaceYaml.exists) {
+		include = [...defInc];
+		exclude = [];
+		layoutSource = "default-patterns";
+	} 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";
+		}
+	}
+	const foundRelativePosixPackageRoots = /* @__PURE__ */ new Set();
+	const globOpts = {
+		cwd: rootDirectoryPathAbsolute,
+		posix: true,
+		...path.sep === "\\" ? { windowsPathsNoEscape: true } : {}
+	};
+	for (const pattern of include) {
+		const globPat = workspacePatternToPackageJsonGlob(pattern);
+		let matches;
+		try {
+			matches = globSync(globPat, globOpts);
+		} catch (caughtGlobError) {
+			if (isGlobPermissionError(caughtGlobError)) {
+				if (!suppressGlobPermissionDiagnostics) logger.out(`⚠ Skipping workspace glob "${pattern}" (${messageFrom(caughtGlobError)})`);
+				continue;
+			}
+			throw new Error(`Invalid workspace glob "${pattern}": ${messageFrom(caughtGlobError)}`);
+		}
+		for (const matchedPath of matches) {
+			const posix = toPosix(matchedPath);
+			const suffix = `/${packageJsonFileName}`;
+			if (!posix.endsWith(suffix)) continue;
+			const rel = posix.slice(0, -suffix.length);
+			if (!rel) continue;
+			foundRelativePosixPackageRoots.add(rel);
+		}
+	}
+	const excludeMatchers = exclude.map((pat) => picomatch(pat, { dot: true }));
+	const filteredRelative = [...foundRelativePosixPackageRoots].filter((rel) => !excludeMatchers.some((isMatch) => isMatch(rel)));
+	filteredRelative.sort((a, b) => a.localeCompare(b));
+	return {
+		packageDirectoryPathsAbsolute: filteredRelative.map((rel) => path.resolve(rootDirectoryPathAbsolute, rel.split("/").join(path.sep))),
+		layoutSource,
+		hasPnpmWorkspaceYamlFile
+	};
+}
+//#endregion
+export { findRepoRoot, listWorkspacePackageDirectories };