@savvy-web/silk-effects 3.3.1 → 4.0.1

package/changesets/services/branch-analyzer.js

@@ -1,77 +1,35 @@
 import { GitError } from "../errors.js";
 import { ClassificationReasonSchema, ConfigInspector } from "./config-inspector.js";
-import { Context, Effect, Layer, Schema } from "effect";
-import { execFileSync } from "node:child_process";
+import { Context, Effect, Layer, Option, Schema } from "effect";
+import { Git } from "@effected/git";
 
 //#region src/changesets/services/branch-analyzer.ts
-/**
-* `BranchAnalyzer` service — combine a git diff against the base branch with
-* the per-file classification produced by {@link ConfigInspector}.
-*
-* @remarks
-* This is the single call that the changeset-manager agent uses during its
-* inventory step: one invocation returns the diff, the per-file package
-* attribution, the set of packages affected by the branch, and the list of
-* paths that did not map to any known release surface (so the agent can ask
-* the user about them rather than silently excluding).
-*
-* Base-branch resolution order (highest priority first):
-*
-* 1. Explicit `opts.baseBranch` passed to {@link BranchAnalyzerShape.analyzeBranch}.
-* 2. `baseBranch` from `.changeset/config.json` (surfaced via the inspector).
-* 3. The branch `origin/HEAD` points to (`git symbolic-ref refs/remotes/origin/HEAD`).
-* 4. `"main"` as a final fallback.
-*
-* Diff resolution covers everything the user might commit before merging:
-*
-* 1. `git merge-base <base> HEAD` finds the common ancestor.
-* 2. `git diff --name-status <merge-base>` (working tree vs merge-base)
-*    returns every committed, staged, AND unstaged change since the
-*    branch diverged. The two-arg `<merge-base>...HEAD` form would miss
-*    work-in-progress — what the user has open in their editor right
-*    now is exactly the state the agent needs to document.
-* 3. `git ls-files --others --exclude-standard` adds untracked files
-*    (entirely new files not yet `git add`-ed). Each is reported with
-*    status `"added"`.
-*
-* The two results are deduped by path before classification. Renames
-* are reported as `"renamed"` with the new path; the old path is
-* discarded since the classifier needs a single canonical path per
-* file.
-*
-* @see {@link BranchAnalyzer} for the service tag
-* @see {@link BranchAnalyzerLive} for the production layer
-* @see {@link ConfigInspector} for the underlying classification service
-*
-*/
 /** Git diff status as reported by `--name-status`. @public */
-const FileStatusSchema = Schema.Literal("added", "modified", "deleted", "renamed", "copied", "typechange", "unmerged", "unknown").annotations({ identifier: "FileStatus" });
+const FileStatusSchema = Schema.Literals([
+	"added",
+	"modified",
+	"deleted",
+	"renamed",
+	"copied",
+	"typechange",
+	"unmerged",
+	"unknown"
+]).annotate({ identifier: "FileStatus" });
 /** One file entry in the branch analysis output. @public */
 const BranchFileEntrySchema = Schema.Struct({
-	path: Schema.String.annotations({ description: "Repo-relative path (the new path in the case of renames)." }),
+	path: Schema.String.annotate({ description: "Repo-relative path (the new path in the case of renames)." }),
 	status: FileStatusSchema,
-	package: Schema.NullOr(Schema.String).annotations({ description: "Owning package, or null if outside every known release surface." }),
+	package: Schema.NullOr(Schema.String).annotate({ description: "Owning package, or null if outside every known release surface." }),
 	reason: ClassificationReasonSchema
-}).annotations({ identifier: "BranchFileEntry" });
+}).annotate({ identifier: "BranchFileEntry" });
 /** Structured result of analyzing the current branch against its base. @public */
 const BranchAnalysisSchema = Schema.Struct({
 	baseBranch: Schema.String,
 	mergeBaseSha: Schema.String,
 	files: Schema.Array(BranchFileEntrySchema),
 	packagesAffected: Schema.Array(Schema.String),
-	unmappedFiles: Schema.Array(Schema.String).annotations({ description: "Repo-relative paths whose package is null — candidates for an AskUserQuestion." })
-}).annotations({ identifier: "BranchAnalysis" });
-const _tag = Context.Tag("BranchAnalyzer");
-/**
-* Base class for {@link BranchAnalyzer}.
-*
-* @privateRemarks
-* Effect's `Context.Tag` creates an anonymous base class that api-extractor
-* cannot follow without an explicit export. Do not delete.
-*
-* @internal
-*/
-const BranchAnalyzerBase = _tag();
+	unmappedFiles: Schema.Array(Schema.String).annotate({ description: "Repo-relative paths whose package is null — candidates for an AskUserQuestion." })
+}).annotate({ identifier: "BranchAnalysis" });
 /**
 * Effect service tag for {@link BranchAnalyzerShape}.
 *
@@ -90,165 +48,74 @@ const BranchAnalyzerBase = _tag();
 *   program.pipe(
 *     Effect.provide(BranchAnalyzerLive),
 *     Effect.provide(ConfigInspectorLive),
-*     // ... + ChangesetConfigReaderLive + WorkspacesLive + NodeContext.layer
+*     // ... + ChangesetConfigReaderLive + kit workspace layers + NodeServices.layer
 *   ),
 * );
 * ```
 *
 * @public
 */
-var BranchAnalyzer = class extends BranchAnalyzerBase {};
+var BranchAnalyzer = class extends Context.Service()("BranchAnalyzer") {};
 /**
-* Invoke `git` with the given args under `cwd` and return stdout. On
-* non-zero exit (or any throw), maps to a {@link GitError} carrying the
-* command, cwd, and captured stderr.
+* Fold a `@effected/git` typed failure into this package's {@link GitError},
+* preserving the public `ConfigurationError | GitError` error channel.
 */
-function runGit(cwd, args) {
-	return Effect.try({
-		try: () => execFileSync("git", args, {
-			cwd,
-			encoding: "utf8",
-			stdio: [
-				"ignore",
-				"pipe",
-				"pipe"
-			]
-		}),
-		catch: (error) => {
-			const e = error;
-			const stderr = typeof e.stderr === "string" ? e.stderr : e.stderr?.toString() ?? "";
-			return new GitError({
-				command: `git ${args.join(" ")}`,
-				cwd,
-				reason: stderr.trim() || e.message || String(error)
-			});
-		}
-	});
-}
-const STATUS_MAP = {
-	A: "added",
-	M: "modified",
-	D: "deleted",
-	R: "renamed",
-	C: "copied",
-	T: "typechange",
-	U: "unmerged"
-};
-function statusFromCode(code) {
-	const head = code.charAt(0);
-	return STATUS_MAP[head] ?? "unknown";
-}
+const toGitError = (command, cwd) => (e) => new GitError({
+	command,
+	cwd,
+	reason: e.message
+});
 /**
-* Parse `git diff --name-status -z` output into one entry per changed file.
-*
-* `-z` separates fields with NUL bytes and avoids the per-record `\n`
-* delimiter, so paths containing spaces or special characters round-trip
-* cleanly. Rename and copy entries occupy three NUL-separated tokens
-* (status, old path, new path) instead of two; everything else is two.
+* Map `@effected/git`'s `NameStatusEntry` status vocabulary onto this
+* package's public {@link FileStatus} literals. The kit spells
+* `"typeChanged"` where the public schema (stable since 0.x) says
+* `"typechange"`, and adds `"broken"` (git's `B`), which the public schema
+* folds into `"unknown"`.
 */
-function parseNameStatus(output) {
-	if (output.length === 0) return [];
-	const tokens = output.split("\0");
-	if (tokens[tokens.length - 1] === "") tokens.pop();
-	const entries = [];
-	for (let i = 0; i < tokens.length;) {
-		const code = tokens[i] ?? "";
-		if (code.length === 0) {
-			/* v8 ignore next 2 -- defensive guard; trailing empties stripped at parse time */
-			i += 1;
-			continue;
-		}
-		const status = statusFromCode(code);
-		if (status === "renamed" || status === "copied") {
-			const newPath = tokens[i + 2] ?? "";
-			if (newPath.length > 0) entries.push({
-				path: newPath,
-				status
-			});
-			i += 3;
-		} else {
-			const path = tokens[i + 1] ?? "";
-			if (path.length > 0) entries.push({
-				path,
-				status
-			});
-			i += 2;
-		}
+function toFileStatus(status) {
+	switch (status) {
+		case "typeChanged": return "typechange";
+		case "broken": return "unknown";
+		default: return status;
 	}
-	return entries;
-}
-/**
-* Parse a NUL-separated list of paths (e.g., `git ls-files -z` output) into
-* an array of strings, dropping any trailing empty entry left by the final
-* NUL byte.
-*/
-function parseNulSeparatedPaths(output) {
-	if (output.length === 0) return [];
-	const tokens = output.split("\0");
-	if (tokens[tokens.length - 1] === "") tokens.pop();
-	return tokens.filter((t) => t.length > 0);
 }
 /**
 * Resolve the base branch using the documented priority order.
 */
-function resolveBaseBranch(opts) {
+function resolveBaseBranch(git, opts) {
 	if (opts.explicit && opts.explicit.length > 0) return Effect.succeed(opts.explicit);
 	if (opts.configBaseBranch && opts.configBaseBranch !== "main") return Effect.succeed(opts.configBaseBranch);
-	return runGit(opts.cwd, [
-		"symbolic-ref",
-		"--quiet",
-		"--short",
-		"refs/remotes/origin/HEAD"
-	]).pipe(
-		/* v8 ignore start -- callback only reachable with a remote that exposes origin/HEAD */
-		Effect.map((stdout) => {
-			const trimmed = stdout.trim();
-			return trimmed.length > 0 ? trimmed.replace(/^origin\//, "") : opts.configBaseBranch;
-		}),
-		/* v8 ignore stop */
-		Effect.catchAll(() => Effect.succeed(opts.configBaseBranch))
-	);
+	return git.defaultBranch(opts.cwd).pipe(Effect.map(Option.getOrElse(() => opts.configBaseBranch)), Effect.catch(() => Effect.succeed(opts.configBaseBranch)));
 }
-function makeShape(inspector) {
+function makeShape(inspector, git) {
 	const analyzeBranch = (cwd, opts) => Effect.gen(function* () {
 		const inspected = yield* inspector.inspect(cwd);
-		const baseBranch = yield* resolveBaseBranch({
+		const baseBranch = yield* resolveBaseBranch(git, {
 			explicit: opts?.baseBranch,
 			configBaseBranch: inspected.baseBranch,
 			cwd
 		});
-		const mergeBaseSha = (yield* runGit(cwd, [
-			"merge-base",
-			baseBranch,
-			"HEAD"
-		])).trim();
-		const diffEntries = parseNameStatus(yield* runGit(cwd, [
-			"diff",
-			"--name-status",
-			"-z",
-			mergeBaseSha
-		]));
-		const untrackedEntries = parseNulSeparatedPaths(yield* runGit(cwd, [
-			"ls-files",
-			"-z",
-			"--others",
-			"--exclude-standard"
-		])).map((path) => ({
-			path,
-			status: "added"
-		}));
+		const mergeBaseSha = (yield* git.mergeBase(cwd, baseBranch, "HEAD").pipe(Effect.mapError(toGitError(`git merge-base ${baseBranch} HEAD`, cwd)))).trim();
+		const diffEntries = yield* git.nameStatus(cwd, { base: mergeBaseSha }).pipe(Effect.mapError(toGitError(`git diff --name-status ${mergeBaseSha}`, cwd)));
+		const untracked = yield* git.untrackedFiles(cwd).pipe(Effect.mapError(toGitError("git ls-files --others --exclude-standard", cwd)));
 		const isOwnChangeset = (path) => path.startsWith(".changeset/") && path.endsWith(".md");
 		const seen = /* @__PURE__ */ new Set();
 		const rawEntries = [];
 		for (const e of diffEntries) {
 			if (seen.has(e.path) || isOwnChangeset(e.path)) continue;
 			seen.add(e.path);
-			rawEntries.push(e);
+			rawEntries.push({
+				path: e.path,
+				status: toFileStatus(e.status)
+			});
 		}
-		for (const e of untrackedEntries) {
-			if (seen.has(e.path) || isOwnChangeset(e.path)) continue;
-			seen.add(e.path);
-			rawEntries.push(e);
+		for (const path of untracked) {
+			if (seen.has(path) || isOwnChangeset(path)) continue;
+			seen.add(path);
+			rawEntries.push({
+				path,
+				status: "added"
+			});
 		}
 		const paths = rawEntries.map((e) => e.path);
 		const classifications = yield* inspector.classify(cwd, paths);
@@ -275,13 +142,15 @@ function makeShape(inspector) {
 * Live layer for {@link BranchAnalyzer}.
 *
 * Requires {@link ConfigInspector} (which in turn requires
-* `ChangesetConfigReader` and `WorkspaceDiscovery`).
+* `ChangesetConfigReader` and `WorkspaceDiscovery`) and a
+* `ChildProcessSpawner` (satisfied by `NodeServices.layer`) for the
+* internally-composed `@effected/git` layer.
 *
 * @public
 */
 const BranchAnalyzerLive = Layer.effect(BranchAnalyzer, Effect.gen(function* () {
-	return makeShape(yield* ConfigInspector);
-}));
+	return makeShape(yield* ConfigInspector, yield* Git);
+})).pipe(Layer.provide(Git.layer));
 /**
 * Test factory — build a {@link BranchAnalyzer} that returns a fixed
 * {@link BranchAnalysis} for any input.
@@ -293,4 +162,4 @@ function makeBranchAnalyzerTest(fixed) {
 }
 
 //#endregion
-export { BranchAnalysisSchema, BranchAnalyzer, BranchAnalyzerBase, BranchAnalyzerLive, BranchFileEntrySchema, FileStatusSchema, makeBranchAnalyzerTest };
+export { BranchAnalysisSchema, BranchAnalyzer, BranchAnalyzerLive, BranchFileEntrySchema, FileStatusSchema, makeBranchAnalyzerTest };

package/changesets/services/changelog.js

@@ -1,18 +1,6 @@
 import { Context } from "effect";
 
 //#region src/changesets/services/changelog.ts
-const _tag = Context.Tag("ChangelogService");
-/**
-* Base class for ChangelogService.
-*
-* @privateRemarks
-* This export is required for api-extractor documentation generation.
-* Effect's Context.Tag creates an anonymous base class that must be
-* explicitly exported to avoid "forgotten export" warnings. Do not delete.
-*
-* @internal
-*/
-const ChangelogServiceBase = _tag();
 /**
 * Effect service tag for changelog formatting.
 *
@@ -40,11 +28,10 @@ const ChangelogServiceBase = _tag();
 * ```
 *
 * @see {@link ChangelogServiceShape} for the service interface
-* @see {@link ChangelogServiceBase} for the api-extractor base class
 *
 * @public
 */
-var ChangelogService = class extends ChangelogServiceBase {};
+var ChangelogService = class extends Context.Service()("ChangelogService") {};
 
 //#endregion
-export { ChangelogService, ChangelogServiceBase };
+export { ChangelogService };

package/changesets/services/config-inspector.js

@@ -2,11 +2,11 @@ import { ConfigurationError } from "../errors.js";
 import { ChangesetOptionsSchema } from "../schemas/options.js";
 import { ChangesetConfigReader } from "../../services/ChangesetConfigReader.js";
 import { SilkPublishability, readTargetsBinding } from "../../services/SilkPublishability.js";
-import { Context, Effect, Layer, Schema } from "effect";
+import { Context, Effect, FileSystem, Layer, Path, Result, Schema } from "effect";
 import { isAbsolute, join, relative, resolve } from "node:path";
-import { FileSystem } from "@effect/platform";
-import { globSync } from "tinyglobby";
-import { WorkspaceDiscovery } from "workspaces-effect";
+import { GlobPattern, GlobPatternOptions } from "@effected/glob";
+import { descend } from "@effected/walker";
+import { WorkspaceDiscovery } from "@effected/workspaces";
 
 //#region src/changesets/services/config-inspector.ts
 /**
@@ -45,9 +45,9 @@ import { WorkspaceDiscovery } from "workspaces-effect";
 /** A `versionFiles` entry expanded to its absolute target paths. @public */
 const ResolvedVersionFileSchema = Schema.Struct({
 	glob: Schema.String,
-	paths: Schema.Array(Schema.String).annotations({ description: "JSONPath expressions to update (defaults to [\"$.version\"])." }),
+	paths: Schema.Array(Schema.String).annotate({ description: "JSONPath expressions to update (defaults to [\"$.version\"])." }),
 	matchedFiles: Schema.Array(Schema.String)
-}).annotations({ identifier: "ResolvedVersionFile" });
+}).annotate({ identifier: "ResolvedVersionFile" });
 /** A package's resolved release surface. @public */
 const ResolvedPackageScopeSchema = Schema.Struct({
 	name: Schema.String,
@@ -56,43 +56,37 @@ const ResolvedPackageScopeSchema = Schema.Struct({
 	additionalScopes: Schema.Array(Schema.String),
 	additionalScopeFiles: Schema.Array(Schema.String),
 	versionFiles: Schema.Array(ResolvedVersionFileSchema)
-}).annotations({ identifier: "ResolvedPackageScope" });
+}).annotate({ identifier: "ResolvedPackageScope" });
 /** Structured representation of a resolved `.changeset/config.json`. @public */
 const InspectedConfigSchema = Schema.Struct({
 	configPath: Schema.String,
-	projectDir: Schema.String.annotations({ description: "Absolute project root (the directory containing .changeset/)." }),
+	projectDir: Schema.String.annotate({ description: "Absolute project root (the directory containing .changeset/)." }),
 	changelog: Schema.NullOr(Schema.String),
 	baseBranch: Schema.String,
-	access: Schema.Literal("public", "restricted"),
+	access: Schema.Literals(["public", "restricted"]),
 	ignore: Schema.Array(Schema.String),
 	packages: Schema.Array(ResolvedPackageScopeSchema),
 	legacyVersionFilesUsed: Schema.Boolean
-}).annotations({ identifier: "InspectedConfig" });
+}).annotate({ identifier: "InspectedConfig" });
 /** Reason a path was attributed to a package (or left unmapped). @public */
-const ClassificationReasonSchema = Schema.Union(Schema.Literal("workspace"), Schema.Struct({
-	kind: Schema.Literal("additionalScope"),
-	glob: Schema.String
-}), Schema.Struct({
-	kind: Schema.Literal("versionFile"),
-	glob: Schema.String
-}), Schema.Null).annotations({ identifier: "ClassificationReason" });
+const ClassificationReasonSchema = Schema.Union([
+	Schema.Literal("workspace"),
+	Schema.Struct({
+		kind: Schema.Literal("additionalScope"),
+		glob: Schema.String
+	}),
+	Schema.Struct({
+		kind: Schema.Literal("versionFile"),
+		glob: Schema.String
+	}),
+	Schema.Null
+]).annotate({ identifier: "ClassificationReason" });
 /** The result of classifying a single path against a resolved config. @public */
 const ClassificationSchema = Schema.Struct({
 	path: Schema.String,
 	package: Schema.NullOr(Schema.String),
 	reason: ClassificationReasonSchema
-}).annotations({ identifier: "Classification" });
-const _tag = Context.Tag("ConfigInspector");
-/**
-* Base class for {@link ConfigInspector}.
-*
-* @privateRemarks
-* Effect's `Context.Tag` creates an anonymous base class that api-extractor
-* cannot follow without an explicit export. Do not delete.
-*
-* @internal
-*/
-const ConfigInspectorBase = _tag();
+}).annotate({ identifier: "Classification" });
 /**
 * Effect service tag for {@link ConfigInspectorShape}.
 *
@@ -112,7 +106,7 @@ const ConfigInspectorBase = _tag();
 *
 * @public
 */
-var ConfigInspector = class extends ConfigInspectorBase {};
+var ConfigInspector = class extends Context.Service()("ConfigInspector") {};
 /**
 * Pull the changelog formatter ID and its options object out of the raw
 * `.changeset/config.json` shape (where `changelog` may be a tuple, a string,
@@ -175,16 +169,48 @@ function normalizeLegacyOptions(options, configPath) {
 		legacyUsed: true
 	};
 }
+/** Match dotfiles, mirroring the former tinyglobby `dot: true` behavior. */
+const GLOB_OPTIONS = GlobPatternOptions.make({ dot: true });
+/**
+* Compile `glob` via `@effected/glob`, folding a compile-guard trip
+* (over-length pattern, brace-expansion budget, nesting depth) into a
+* {@link ConfigurationError} naming the offending glob on the typed channel.
+*/
+function compileGlob(glob) {
+	return GlobPattern.compile(glob, GLOB_OPTIONS).pipe(Effect.mapError((error) => new ConfigurationError({
+		field: "glob",
+		reason: `Invalid glob pattern ${JSON.stringify(glob)}: ${error.message}`
+	})));
+}
+/**
+* Pure attribution helper: does `glob` (under this service's `dot: true`
+* semantics) match the repo-relative POSIX path `rel`? An uncompilable
+* pattern matches nothing.
+*/
+function globMatchesRel(glob, rel) {
+	const result = Effect.runSync(Effect.result(GlobPattern.compile(glob, GLOB_OPTIONS)));
+	return Result.isSuccess(result) && result.success.matches(rel);
+}
 /**
 * Materialize a glob against `cwd` and return the matched file paths as
-* repo-relative strings. Honors negation patterns and ignores `node_modules`.
+* repo-relative POSIX strings, sorted by relative path. Matches dotfiles (the
+* former tinyglobby `dot: true` semantics); the walk is `@effected/walker`'s
+* `descend` (literal fast path, `enumerationPrefix` bounding,
+* `node_modules`/`.git` pruning), with `onUnreadable: "skip"` preserving the
+* previous silent-skip policy for unreadable directories. The one remaining
+* `DescendError` (depth cap) folds into a {@link ConfigurationError} naming
+* the glob — this service's single typed failure. `descend`'s `Path`
+* requirement is satisfied internally with the core POSIX `Path.layer` (this
+* module already speaks POSIX-relative match paths).
 */
 function materializeGlob(glob, cwd) {
-	return globSync(glob, {
+	return compileGlob(glob).pipe(Effect.flatMap((pattern) => descend(pattern, {
 		cwd,
-		ignore: ["**/node_modules/**"],
-		dot: true
-	});
+		onUnreadable: "skip"
+	}).pipe(Effect.mapError((error) => new ConfigurationError({
+		field: "glob",
+		reason: `Failed to materialize glob ${JSON.stringify(glob)}: ${error.message}`
+	})), Effect.provide(Path.layer))));
 }
 /**
 * Determine whether `child` is the same directory as `parent` or sits inside
@@ -199,33 +225,41 @@ function isInside(parent, child) {
 * options with workspace info.
 */
 function buildResolvedScopes(params) {
-	const { options, workspaces, projectDir, configPath } = params;
-	const packages = options.packages ?? {};
-	const workspacesByName = new Map(workspaces.map((w) => [w.name, w]));
-	const scopes = [];
-	for (const [pkgName, scope] of Object.entries(packages)) {
-		const ws = workspacesByName.get(pkgName);
-		if (!ws) throw new ConfigurationError({
-			field: `packages["${pkgName}"]`,
-			reason: `Unknown package "${pkgName}" in ${configPath}. Known workspace packages: ${workspaces.map((w) => w.name).join(", ") || "(none)"}.`
-		});
-		const additionalScopes = scope.additionalScopes ?? [];
-		const additionalScopeFiles = additionalScopes.flatMap((g) => materializeGlob(g, projectDir));
-		const resolvedVersionFiles = (scope.versionFiles ?? []).map((entry) => ({
-			glob: entry.glob,
-			paths: entry.paths ?? ["$.version"],
-			matchedFiles: materializeGlob(entry.glob, projectDir).map((rel) => join(projectDir, rel))
-		}));
-		scopes.push({
-			name: pkgName,
-			workspaceDir: ws.path,
-			version: ws.version,
-			additionalScopes,
-			additionalScopeFiles: additionalScopeFiles.map((rel) => join(projectDir, rel)),
-			versionFiles: resolvedVersionFiles
-		});
-	}
-	return scopes;
+	return Effect.gen(function* () {
+		const { options, workspaces, projectDir, configPath } = params;
+		const packages = options.packages ?? {};
+		const workspacesByName = new Map(workspaces.map((w) => [w.name, w]));
+		const scopes = [];
+		for (const [pkgName, scope] of Object.entries(packages)) {
+			const ws = workspacesByName.get(pkgName);
+			if (!ws) return yield* Effect.fail(new ConfigurationError({
+				field: `packages["${pkgName}"]`,
+				reason: `Unknown package "${pkgName}" in ${configPath}. Known workspace packages: ${workspaces.map((w) => w.name).join(", ") || "(none)"}.`
+			}));
+			const additionalScopes = scope.additionalScopes ?? [];
+			const additionalScopeFiles = [];
+			for (const g of additionalScopes) additionalScopeFiles.push(...yield* materializeGlob(g, projectDir));
+			const versionFileEntries = scope.versionFiles ?? [];
+			const resolvedVersionFiles = [];
+			for (const entry of versionFileEntries) {
+				const matched = yield* materializeGlob(entry.glob, projectDir);
+				resolvedVersionFiles.push({
+					glob: entry.glob,
+					paths: entry.paths ?? ["$.version"],
+					matchedFiles: matched.map((rel) => join(projectDir, rel))
+				});
+			}
+			scopes.push({
+				name: pkgName,
+				workspaceDir: ws.path,
+				version: ws.version,
+				additionalScopes,
+				additionalScopeFiles: additionalScopeFiles.map((rel) => join(projectDir, rel)),
+				versionFiles: resolvedVersionFiles
+			});
+		}
+		return scopes;
+	});
 }
 /**
 * Read a workspace package's raw package.json. A genuinely missing manifest
@@ -237,8 +271,8 @@ function buildResolvedScopes(params) {
 */
 function readRawPackageJson(fs, pkgDir) {
 	const pkgJsonPath = join(pkgDir, "package.json");
-	return fs.readFileString(pkgJsonPath).pipe(Effect.flatMap((content) => Effect.try(() => JSON.parse(content))), Effect.catchAll((err) => {
-		if (err.reason === "NotFound") return Effect.succeed(null);
+	return fs.readFileString(pkgJsonPath).pipe(Effect.flatMap((content) => Effect.try(() => JSON.parse(content))), Effect.catch((err) => {
+		if (err.reason?._tag === "NotFound") return Effect.succeed(null);
 		return Effect.fail(new ConfigurationError({
 			field: "workspace",
 			reason: `Failed to read or parse ${pkgJsonPath}: ${err instanceof Error ? err.message : String(err)}`
@@ -356,8 +390,8 @@ function makeShape(reader, discovery, fs) {
 			if (e instanceof ConfigurationError) return yield* Effect.fail(e);
 			throw e;
 		}
-		const decodedOptions = yield* Schema.decodeUnknown(ChangesetOptionsSchema)(normalized).pipe(Effect.mapError((parseError) => configErrorFromParseError(parseError, configPath)));
-		const workspaces = (yield* discovery.listPackages(projectDir).pipe(Effect.mapError((err) => new ConfigurationError({
+		const decodedOptions = yield* Schema.decodeUnknownEffect(ChangesetOptionsSchema)(normalized).pipe(Effect.mapError((parseError) => configErrorFromParseError(parseError, configPath)));
+		const workspaces = (yield* discovery.listPackages().pipe(Effect.mapError((err) => new ConfigurationError({
 			field: "workspace",
 			reason: `Workspace discovery failed for ${projectDir}: ${err.message}`
 		})))).map((w) => ({
@@ -368,14 +402,13 @@ function makeShape(reader, discovery, fs) {
 		const hasExplicitPackages = Object.keys(decodedOptions.packages ?? {}).length > 0;
 		let scopes;
 		if (hasExplicitPackages) {
-			let explicitScopes;
+			const explicitScopes = yield* buildResolvedScopes({
+				options: decodedOptions,
+				workspaces,
+				projectDir,
+				configPath
+			}).pipe(Effect.provideService(FileSystem.FileSystem, fs));
 			try {
-				explicitScopes = buildResolvedScopes({
-					options: decodedOptions,
-					workspaces,
-					projectDir,
-					configPath
-				});
 				checkConflicts(explicitScopes, workspaces, projectDir, configPath);
 			} catch (e) {
 				if (e instanceof ConfigurationError) return yield* Effect.fail(e);
@@ -431,7 +464,8 @@ function classifyOne(inspected, path) {
 		reason: "workspace"
 	};
 	for (const s of inspected.packages) if (s.additionalScopeFiles.includes(abs)) {
-		const glob = s.additionalScopes.find((g) => materializeGlob(g, inspected.projectDir).map((rel) => join(inspected.projectDir, rel)).includes(abs));
+		const rel = relative(inspected.projectDir, abs).replaceAll("\\", "/");
+		const glob = s.additionalScopes.find((g) => globMatchesRel(g, rel));
 		return {
 			path,
 			package: s.name,
@@ -485,4 +519,4 @@ function makeConfigInspectorTest(fixed) {
 }
 
 //#endregion
-export { ClassificationReasonSchema, ClassificationSchema, ConfigInspector, ConfigInspectorBase, ConfigInspectorLive, InspectedConfigSchema, ResolvedPackageScopeSchema, ResolvedVersionFileSchema, makeConfigInspectorTest };
+export { ClassificationReasonSchema, ClassificationSchema, ConfigInspector, ConfigInspectorLive, InspectedConfigSchema, ResolvedPackageScopeSchema, ResolvedVersionFileSchema, makeConfigInspectorTest };