@savvy-web/silk 1.3.7 → 1.3.9

package/changesets-markdownlint.d.ts

@@ -1,7 +1,5 @@
 import { Context, Effect, Layer, Option, Schema } from "effect";
-import { FileSystem } from "@effect/platform";
-import { VoidIfEmpty } from "effect/Types";
-import { YieldableError } from "effect/Cause";
+import { CommandExecutor, FileSystem, Path } from "@effect/platform";
 //#region ../../node_modules/.pnpm/@types+unist@3.0.3/node_modules/@types/unist/index.d.ts
 // ## Interfaces
 /**
@@ -3327,540 +3325,324 @@ interface Catalog {
   readonly [dependencyName: string]: string | undefined;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/workspaces-effect@1.2.0_@effect+platform@0.96.2_effect@3.21.4__effect@3.21.4/node_modules/workspaces-effect/index.d.ts
-/**
- * Raised when assembling the workspace catalog set fails irrecoverably
- * (e.g. `pnpm-workspace.yaml` unreadable/malformed, default catalog defined twice).
- * Per-config-dependency hook failures do NOT raise this — they are logged and skipped.
- *
- * @public
+//#region ../../node_modules/.pnpm/workspaces-effect@2.0.1_@effect+platform@0.96.2_effect@3.21.4__effect@3.21.4/node_modules/workspaces-effect/index.d.ts
+//#region src/errors/CatalogAssemblyError.d.ts
+/**
+ * Base constant for {@link CatalogAssemblyError}.
+ *
+ * @remarks
+ * Exported for api-extractor DTS bundling — the `_base` symbol from
+ * `Data.TaggedError` must be visible in the generated .d.ts file. Tagged
+ * `@public` because it appears in the `extends` clause of a `@public`
+ * subclass; consumers should construct and catch the subclass, not this
+ * base directly.
+ *
+ * @public
+ */
+declare const CatalogAssemblyErrorBase: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "CatalogAssemblyError";
+} & Readonly<A>;
+/**
+ * Raised when assembling the workspace catalog set fails irrecoverably
+ * (e.g. `pnpm-workspace.yaml` unreadable/malformed, default catalog defined twice).
+ * Per-config-dependency hook failures do NOT raise this — they are logged and skipped.
+ *
+ * @public
  */
 declare class CatalogAssemblyError extends CatalogAssemblyErrorBase<{
   readonly source: "manifest" | "config-dependency" | "lockfile";
   readonly reason: string;
 }> {
   get message(): string;
-}
-/**
- * Base constant for {@link CatalogAssemblyError}.
- *
- * @privateRemarks
- * Exported for api-extractor DTS bundling — the `_base` symbol from
- * `Data.TaggedError` must be visible in the generated .d.ts file.
- *
- * @internal
- */
-declare const CatalogAssemblyErrorBase: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => YieldableError & {
-  readonly _tag: "CatalogAssemblyError";
+} //#endregion
+//#region src/errors/CatalogResolutionError.d.ts
+/**
+ * Base constant for {@link CatalogResolutionError}.
+ *
+ * @remarks
+ * Exported for api-extractor DTS bundling — the `_base` symbol from
+ * `Data.TaggedError` must be visible in the generated .d.ts file. Tagged
+ * `@public` because it appears in the `extends` clause of a `@public`
+ * subclass; consumers should construct and catch the subclass, not this
+ * base directly.
+ *
+ * @public
+ */
+//#endregion
+//#region src/errors/GitReadError.d.ts
+/**
+ * Base constant for {@link GitReadError}.
+ *
+ * @remarks
+ * Exported for api-extractor DTS bundling — the `_base` symbol from
+ * `Data.TaggedError` must be visible in the generated .d.ts file.
+ *
+ * @public
+ */
+declare const GitReadErrorBase: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "GitReadError";
 } & Readonly<A>;
-/**
- * Raised when a `catalog:`/`workspace:` specifier in a manifest cannot be resolved
- * (unknown catalog, catalog misconfiguration, or unresolvable workspace reference).
- *
- * @public
- */
-declare class CatalogResolutionError extends CatalogResolutionErrorBase<{
-  readonly field: string;
-  readonly dependency: string;
-  readonly specifier: string;
+/**
+ * Raised when reading workspace state at a git ref fails irrecoverably
+ * (git unavailable, unknown revision, command failure). A path that simply
+ * does not exist at the ref is NOT an error — readers surface that as
+ * `Option.none`.
+ *
+ * @public
+ */
+declare class GitReadError extends GitReadErrorBase<{
+  /** The git command that failed, including arguments. */readonly command: string; /** Working directory in which the command was invoked. */
+  readonly cwd: string; /** Human-readable failure reason — typically captured stderr. */
   readonly reason: string;
 }> {
   get message(): string;
-}
-/**
- * Base constant for {@link CatalogResolutionError}.
- *
- * @privateRemarks
- * Exported for api-extractor DTS bundling — the `_base` symbol from
- * `Data.TaggedError` must be visible in the generated .d.ts file.
- *
- * @internal
- */
-declare const CatalogResolutionErrorBase: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => YieldableError & {
-  readonly _tag: "CatalogResolutionError";
+} //#endregion
+//#region src/errors/LockfileIntegrityError.d.ts
+/**
+ * Base constant for {@link LockfileIntegrityError}.
+ *
+ * @remarks
+ * Exported for api-extractor DTS bundling — the `_base` symbol from
+ * `Data.TaggedError` must be visible in the generated .d.ts file. Tagged
+ * `@public` because it appears in the `extends` clause of a `@public`
+ * subclass; consumers should construct and catch the subclass, not this
+ * base directly.
+ *
+ * @public
+ */
+//#endregion
+//#region src/errors/PackageJsonParseError.d.ts
+/**
+ * Base constant for {@link PackageJsonParseError}.
+ *
+ * @remarks
+ * Exported for api-extractor DTS bundling — the `_base` symbol from
+ * `Data.TaggedError` must be visible in the generated .d.ts file. Tagged
+ * `@public` because it appears in the `extends` clause of a `@public`
+ * subclass; consumers should construct and catch the subclass, not this
+ * base directly.
+ *
+ * @public
+ */
+declare const PackageJsonParseErrorBase: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "PackageJsonParseError";
 } & Readonly<A>;
-/**
- * Resolves a workspace's catalogs and rewrites catalog:/workspace: specifiers.
- *
- * @remarks
- * Assembles the complete catalog set — inline `pnpm-workspace.yaml` catalogs,
- * catalogs injected by config dependencies (via pnpmfile `updateConfig` replay),
- * and lockfile catalogs — without depending on the transient workspace-state file.
- *
- * @public
- */
-declare class CatalogResolver extends CatalogResolver_base {}
-declare const CatalogResolver_base: Context.TagClass<CatalogResolver, "@spencerbeggs/workspaces-effect/CatalogResolver", {
-  /** The complete assembled catalog set for the workspace (cached). */readonly catalogs: () => Effect.Effect<Catalogs, CatalogResolverError>; /** Rewrite all catalog:/workspace: specifiers in a manifest to concrete specs. */
-  readonly resolve: (manifest: ManifestLike) => Effect.Effect<ManifestLike, CatalogResolverError | CatalogResolutionError>; /** Resolve a single dependency specifier; None when no rewrite is needed. */
-  readonly resolveSpecifier: (dependency: string, specifier: string) => Effect.Effect<Option.Option<string>, CatalogResolverError | CatalogResolutionError>;
-}>;
-/** Errors surfaced by CatalogResolver methods (assembly defers I/O to first call). */
-declare type CatalogResolverError = CatalogAssemblyError | LockfileInitError;
-/**
- * Result of comparing two WorkspacePackage dependency snapshots.
- * @public
+/**
+ * Emitted when a package.json file cannot be parsed or validated.
+ *
+ * @remarks
+ * Raised by {@link WorkspaceDiscovery} when a package.json file is found but
+ * contains invalid JSON or does not conform to {@link PackageJsonSchema}. The
+ * `cause` field preserves the underlying parse or schema validation error.
+ *
+ * Fields:
+ * - `filePath` — absolute path to the package.json that failed to parse.
+ * - `cause` — the underlying error (JSON syntax error or Schema decode failure).
+ *
+ * @example Catching the error
+ * ```typescript
+ * import { Effect } from "effect";
+ * import type { PackageJsonParseError } from "workspaces-effect";
+ * import { WorkspaceDiscovery, WorkspaceDiscoveryLive } from "workspaces-effect";
+ *
+ * const program = Effect.gen(function* () {
+ *   const discovery = yield* WorkspaceDiscovery;
+ *   return yield* discovery.discover("/workspace/root");
+ * }).pipe(
+ *   Effect.catchTag("PackageJsonParseError", (e) =>
+ *     Effect.logError(`Bad package.json at ${e.filePath}`).pipe(
+ *       Effect.map(() => [])
+ *     )
+ *   )
+ * );
+ * ```
+ *
+ * @public
  */
-declare interface DependencyDiff {
-  readonly added: Record<string, string>;
-  readonly removed: Record<string, string>;
-  readonly changed: Record<string, {
-    readonly from: string;
-    readonly to: string;
-  }>;
-}
-/**
- * Union of errors that may surface from {@link LockfileReader} method calls
- * because the live layer defers workspace-root discovery, package-manager
- * detection, and lockfile read/parse to the first invocation.
- *
- * @public
- */
-declare type LockfileInitError = WorkspaceRootNotFoundError | PackageManagerDetectionError | LockfileReadError | LockfileParseError;
-/**
- * Emitted when a lockfile exists but cannot be parsed.
- *
- * @remarks
- * Raised by {@link LockfileReader} when the lockfile is successfully read from
- * disk but its contents cannot be parsed into the expected format. Each package
- * manager has a different lockfile format (YAML for pnpm, JSON for npm/bun,
- * custom format for yarn Berry).
- *
- * Fields:
- * - `lockfilePath` — absolute path to the lockfile that failed to parse.
- * - `format` — the package manager format that was attempted (`"pnpm"`, `"npm"`, `"yarn"`, or `"bun"`).
- * - `cause` — the underlying parse error.
- *
- * @example Catching the error
- * ```typescript
- * import { Effect } from "effect";
- * import type { LockfileParseError } from "workspaces-effect";
- * import { LockfileReader, LockfileReaderLive } from "workspaces-effect";
- *
- * const program = Effect.gen(function* () {
- *   const reader = yield* LockfileReader;
- *   return yield* reader.read("/workspace/root");
- * }).pipe(
- *   Effect.catchTag("LockfileParseError", (e) =>
- *     Effect.logError(`Cannot parse ${e.format} lockfile at ${e.lockfilePath}`)
- *   )
- * );
- * ```
- *
- * @public
- */
-declare class LockfileParseError extends LockfileParseErrorBase<{
-  readonly lockfilePath: string;
-  readonly format: "pnpm" | "npm" | "yarn" | "bun";
+declare class PackageJsonParseError extends PackageJsonParseErrorBase<{
+  readonly filePath: string;
   readonly cause: unknown;
 }> {
   get message(): string;
-}
-/**
- * Base constant for {@link LockfileParseError}.
- *
- * @privateRemarks
- * Exported for api-extractor DTS bundling — the `_base` symbol from
- * `Data.TaggedError` must be visible in the generated .d.ts file.
- *
- * @internal
- */
-declare const LockfileParseErrorBase: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => YieldableError & {
-  readonly _tag: "LockfileParseError";
-} & Readonly<A>;
-/**
- * Emitted when a lockfile cannot be read from disk.
- *
- * @remarks
- * Raised by {@link LockfileReader} when the expected lockfile for the detected
- * package manager (e.g., `pnpm-lock.yaml`, `package-lock.json`, `yarn.lock`,
- * `bun.lock`) does not exist or cannot be read due to filesystem permissions.
- *
- * Fields:
- * - `lockfilePath` — absolute path to the lockfile that could not be read.
- * - `reason` — human-readable explanation (e.g., "file not found", "permission denied").
- *
- * @example Catching the error
- * ```typescript
- * import { Effect } from "effect";
- * import type { LockfileReadError } from "workspaces-effect";
- * import { LockfileReader, LockfileReaderLive } from "workspaces-effect";
- *
- * const program = Effect.gen(function* () {
- *   const reader = yield* LockfileReader;
- *   return yield* reader.read("/workspace/root");
- * }).pipe(
- *   Effect.catchTag("LockfileReadError", (e) =>
- *     Effect.logWarning(`No lockfile at ${e.lockfilePath}: ${e.reason}`)
- *   )
- * );
- * ```
- *
- * @public
- */
-declare class LockfileReadError extends LockfileReadErrorBase<{
-  readonly lockfilePath: string;
-  readonly reason: string;
-}> {
-  get message(): string;
-}
-/**
- * Base constant for {@link LockfileReadError}.
- *
- * @privateRemarks
- * Exported for api-extractor DTS bundling — the `_base` symbol from
- * `Data.TaggedError` must be visible in the generated .d.ts file.
- *
- * @internal
- */
-declare const LockfileReadErrorBase: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => YieldableError & {
-  readonly _tag: "LockfileReadError";
+} //#endregion
+//#region src/errors/PackageManagerDetectionError.d.ts
+/**
+ * Base constant for {@link PackageManagerDetectionError}.
+ *
+ * @remarks
+ * Exported for api-extractor DTS bundling — the `_base` symbol from
+ * `Data.TaggedError` must be visible in the generated .d.ts file. Tagged
+ * `@public` because it appears in the `extends` clause of a `@public`
+ * subclass; consumers should construct and catch the subclass, not this
+ * base directly.
+ *
+ * @public
+ */
+//#endregion
+//#region src/errors/PackageNotFoundError.d.ts
+/**
+ * Base constant for {@link PackageNotFoundError}.
+ *
+ * @remarks
+ * Exported for api-extractor DTS bundling — the `_base` symbol from
+ * `Data.TaggedError` must be visible in the generated .d.ts file. Tagged
+ * `@public` because it appears in the `extends` clause of a `@public`
+ * subclass; consumers should construct and catch the subclass, not this
+ * base directly.
+ *
+ * @public
+ */
+declare const PackageNotFoundErrorBase: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "PackageNotFoundError";
 } & Readonly<A>;
-declare interface ManifestLike {
-  readonly name: string;
-  readonly version: string;
-  dependencies?: Record<string, string>;
-  devDependencies?: Record<string, string>;
-  peerDependencies?: Record<string, string>;
-  optionalDependencies?: Record<string, string>;
-  [k: string]: unknown;
-}
-/**
- * Emitted when a package.json file cannot be parsed or validated.
- *
- * @remarks
- * Raised by {@link WorkspaceDiscovery} when a package.json file is found but
- * contains invalid JSON or does not conform to {@link PackageJsonSchema}. The
- * `cause` field preserves the underlying parse or schema validation error.
- *
- * Fields:
- * - `filePath` — absolute path to the package.json that failed to parse.
- * - `cause` — the underlying error (JSON syntax error or Schema decode failure).
- *
- * @example Catching the error
- * ```typescript
- * import { Effect } from "effect";
- * import type { PackageJsonParseError } from "workspaces-effect";
- * import { WorkspaceDiscovery, WorkspaceDiscoveryLive } from "workspaces-effect";
- *
- * const program = Effect.gen(function* () {
- *   const discovery = yield* WorkspaceDiscovery;
- *   return yield* discovery.discover("/workspace/root");
- * }).pipe(
- *   Effect.catchTag("PackageJsonParseError", (e) =>
- *     Effect.logError(`Bad package.json at ${e.filePath}`).pipe(
- *       Effect.map(() => [])
- *     )
- *   )
- * );
- * ```
- *
- * @public
+/**
+ * Emitted when a named package is not found in the workspace.
+ *
+ * @remarks
+ * Raised by {@link WorkspaceDiscovery} or {@link DependencyGraph} when a
+ * lookup by package name yields no match. The `available` field lists all
+ * known package names to aid debugging typos or missing packages.
+ *
+ * Fields:
+ * - `name` — the package name that was requested but not found.
+ * - `available` — all package names currently known in the workspace.
+ *
+ * @example Catching the error
+ * ```typescript
+ * import { Effect } from "effect";
+ * import type { PackageNotFoundError } from "workspaces-effect";
+ * import { DependencyGraph, DependencyGraphLive } from "workspaces-effect";
+ *
+ * const program = Effect.gen(function* () {
+ *   const graph = yield* DependencyGraph;
+ *   return yield* graph.dependenciesOf("@my-org/missing-pkg");
+ * }).pipe(
+ *   Effect.catchTag("PackageNotFoundError", (e) =>
+ *     Effect.logWarning(`"${e.name}" not found. Available: ${e.available.join(", ")}`)
+ *   )
+ * );
+ * ```
+ *
+ * @public
  */
-declare class PackageJsonParseError extends PackageJsonParseErrorBase<{
-  readonly filePath: string;
-  readonly cause: unknown;
+declare class PackageNotFoundError extends PackageNotFoundErrorBase<{
+  readonly name: string;
+  readonly available: ReadonlyArray<string>;
 }> {
   get message(): string;
-}
-/**
- * Base constant for {@link PackageJsonParseError}.
- *
- * @privateRemarks
- * Exported for api-extractor DTS bundling — the `_base` symbol from
- * `Data.TaggedError` must be visible in the generated .d.ts file.
- *
- * @internal
- */
-declare const PackageJsonParseErrorBase: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => YieldableError & {
-  readonly _tag: "PackageJsonParseError";
+} //#endregion
+//#region src/errors/WorkspaceDiscoveryError.d.ts
+/**
+ * Base constant for {@link WorkspaceDiscoveryError}.
+ *
+ * @remarks
+ * Exported for api-extractor DTS bundling — the `_base` symbol from
+ * `Data.TaggedError` must be visible in the generated .d.ts file. Tagged
+ * `@public` because it appears in the `extends` clause of a `@public`
+ * subclass; consumers should construct and catch the subclass, not this
+ * base directly.
+ *
+ * @public
+ */
+declare const WorkspaceDiscoveryErrorBase: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "WorkspaceDiscoveryError";
 } & Readonly<A>;
-/**
- * Minimal package.json schema for workspace discovery.
- *
- * @remarks
- * Captures only the fields needed by workspace tooling — name, version,
- * private flag, workspace patterns, dependency maps, the `packageManager`
- * field (used by Corepack), and `publishConfig`. Unknown fields are silently
- * ignored during decode.
- *
- * Fields:
- * - `name` — the package name.
- * - `version` — the package version string.
- * - `private` — whether the package is private (not published).
- * - `workspaces` — workspace glob patterns (array or object form).
- * - `dependencies` — production dependency map.
- * - `devDependencies` — development dependency map.
- * - `peerDependencies` — peer dependency map.
- * - `packageManager` — Corepack package manager spec (e.g., `"pnpm@9.1.0"`).
- * - `publishConfig` — publishing configuration overrides.
- *
- * @example Decoding a package.json
- * ```typescript
- * import { Schema } from "effect";
- * import { PackageJsonSchema } from "workspaces-effect";
- *
- * const pkg = Schema.decodeUnknownSync(PackageJsonSchema)({
- *   name: "@my-org/app",
- *   version: "1.0.0",
- *   workspaces: ["packages/*"],
- * });
- * ```
- *
- * @public
+/**
+ * Emitted when workspace package discovery fails.
+ *
+ * @remarks
+ * Raised by {@link WorkspaceDiscovery} when glob expansion of workspace
+ * patterns or subsequent package.json reads fail. This can occur if patterns
+ * in pnpm-workspace.yaml or the root package.json `workspaces` field resolve
+ * to invalid or inaccessible directories.
+ *
+ * Fields:
+ * - `root` — the workspace root path where discovery was attempted.
+ * - `reason` — human-readable explanation of what went wrong.
+ *
+ * @example Catching the error
+ * ```typescript
+ * import { Effect } from "effect";
+ * import type { WorkspaceDiscoveryError } from "workspaces-effect";
+ * import { WorkspaceDiscovery, WorkspaceDiscoveryLive } from "workspaces-effect";
+ *
+ * const program = Effect.gen(function* () {
+ *   const discovery = yield* WorkspaceDiscovery;
+ *   return yield* discovery.discover("/workspace/root");
+ * }).pipe(
+ *   Effect.catchTag("WorkspaceDiscoveryError", (e) =>
+ *     Effect.succeed(`Discovery failed at ${e.root}: ${e.reason}`)
+ *   )
+ * );
+ * ```
+ *
+ * @public
  */
-declare const PackageJsonSchema: Schema.Struct<{
-  name: Schema.optional<typeof Schema.String>;
-  version: Schema.optional<typeof Schema.String>;
-  private: Schema.optional<typeof Schema.Boolean>;
-  workspaces: Schema.optional<Schema.Union<[Schema.Array$<typeof Schema.String>, Schema.Struct<{
-    packages: Schema.Array$<typeof Schema.String>;
-  }>]>>;
-  dependencies: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
-  devDependencies: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
-  peerDependencies: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
-  optionalDependencies: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
-  packageManager: Schema.optional<typeof Schema.String>;
-  publishConfig: Schema.optional<typeof PublishConfig>;
-}>;
-/**
- * TypeScript type for the {@link PackageJsonSchema} schema.
- *
- * @public
- */
-declare type PackageJsonType = Schema.Schema.Type<typeof PackageJsonSchema>;
-/**
- * Emitted when the package manager type cannot be determined.
- *
- * @remarks
- * Raised by {@link PackageManagerDetector} when heuristics (lockfile presence,
- * `packageManager` field in root package.json) fail to identify a single
- * package manager for the workspace.
- *
- * Fields:
- * - `searchPath` — the workspace root path that was inspected.
- * - `reason` — human-readable explanation of the detection failure.
- *
- * @example Catching the error
- * ```typescript
- * import { Effect } from "effect";
- * import type { PackageManagerDetectionError } from "workspaces-effect";
- * import { PackageManagerDetector, PackageManagerDetectorLive } from "workspaces-effect";
- *
- * const program = Effect.gen(function* () {
- *   const detector = yield* PackageManagerDetector;
- *   return yield* detector.detect("/workspace/root");
- * }).pipe(
- *   Effect.catchTag("PackageManagerDetectionError", (e) =>
- *     Effect.succeed(`Could not detect PM at ${e.searchPath}: ${e.reason}`)
- *   )
- * );
- * ```
- *
- * @public
- */
-declare class PackageManagerDetectionError extends PackageManagerDetectionErrorBase<{
-  readonly searchPath: string;
+declare class WorkspaceDiscoveryError extends WorkspaceDiscoveryErrorBase<{
+  readonly root: string;
   readonly reason: string;
 }> {
   get message(): string;
-}
-/**
- * Base constant for {@link PackageManagerDetectionError}.
- *
- * @privateRemarks
- * Exported for api-extractor DTS bundling — the `_base` symbol from
- * `Data.TaggedError` must be visible in the generated .d.ts file.
- *
- * @internal
- */
-declare const PackageManagerDetectionErrorBase: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => YieldableError & {
-  readonly _tag: "PackageManagerDetectionError";
+} //#endregion
+//#region src/errors/WorkspaceRootNotFoundError.d.ts
+/**
+ * Base constant for {@link WorkspaceRootNotFoundError}.
+ *
+ * @remarks
+ * Exported for api-extractor DTS bundling — the `_base` symbol from
+ * `Data.TaggedError` must be visible in the generated .d.ts file. Tagged
+ * `@public` because it appears in the `extends` clause of a `@public`
+ * subclass; consumers should construct and catch the subclass, not this
+ * base directly.
+ *
+ * @public
+ */
+declare const WorkspaceRootNotFoundErrorBase: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "WorkspaceRootNotFoundError";
 } & Readonly<A>;
-/**
- * Emitted when a named package is not found in the workspace.
- *
- * @remarks
- * Raised by {@link WorkspaceDiscovery} or {@link DependencyGraph} when a
- * lookup by package name yields no match. The `available` field lists all
- * known package names to aid debugging typos or missing packages.
- *
- * Fields:
- * - `name` — the package name that was requested but not found.
- * - `available` — all package names currently known in the workspace.
- *
- * @example Catching the error
- * ```typescript
- * import { Effect } from "effect";
- * import type { PackageNotFoundError } from "workspaces-effect";
- * import { DependencyGraph, DependencyGraphLive } from "workspaces-effect";
- *
- * const program = Effect.gen(function* () {
- *   const graph = yield* DependencyGraph;
- *   return yield* graph.dependenciesOf("@my-org/missing-pkg");
- * }).pipe(
- *   Effect.catchTag("PackageNotFoundError", (e) =>
- *     Effect.logWarning(`"${e.name}" not found. Available: ${e.available.join(", ")}`)
- *   )
- * );
- * ```
- *
- * @public
+/**
+ * Emitted when no workspace root can be found from the search path.
+ *
+ * @remarks
+ * Raised by {@link WorkspaceRoot} when directory traversal from the search path
+ * to the filesystem root finds no workspace markers (pnpm-workspace.yaml or
+ * package.json with workspaces field).
+ *
+ * Fields:
+ * - `searchPath` — the absolute path from which upward traversal started.
+ * - `reason` — human-readable explanation of why no root was found.
+ *
+ * @example Catching the error
+ * ```typescript
+ * import { Effect } from "effect";
+ * import type { WorkspaceRootNotFoundError } from "workspaces-effect";
+ * import { WorkspaceRoot, WorkspaceRootLive } from "workspaces-effect";
+ *
+ * const program = Effect.gen(function* () {
+ *   const root = yield* WorkspaceRoot;
+ *   return yield* root.find("/some/path");
+ * }).pipe(
+ *   Effect.catchTag("WorkspaceRootNotFoundError", (e) =>
+ *     Effect.succeed(`Fallback: ${e.searchPath}`)
+ *   )
+ * );
+ * ```
+ *
+ * @public
  */
-declare class PackageNotFoundError extends PackageNotFoundErrorBase<{
-  readonly name: string;
-  readonly available: ReadonlyArray<string>;
+declare class WorkspaceRootNotFoundError extends WorkspaceRootNotFoundErrorBase<{
+  readonly searchPath: string;
+  readonly reason: string;
 }> {
   get message(): string;
-}
-/**
- * Base constant for {@link PackageNotFoundError}.
- *
- * @privateRemarks
- * Exported for api-extractor DTS bundling — the `_base` symbol from
- * `Data.TaggedError` must be visible in the generated .d.ts file.
- *
- * @internal
- */
-declare const PackageNotFoundErrorBase: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => YieldableError & {
-  readonly _tag: "PackageNotFoundError";
-} & Readonly<A>;
-/**
- * Service for detecting whether a workspace package is publishable and
- * identifying its publish targets (npm, GitHub Packages, etc.).
- *
- * Inspects `package.json` fields such as `private`, `publishConfig`, and
- * `repository` to determine publishability and target registries.
- *
- * @remarks
- * PublishabilityDetector is part of the Configuration and Lockfiles service
- * group. It is a pure service with no dependencies on other services — it
- * operates solely on the {@link WorkspacePackage} data and the workspace root
- * path passed to it.
- *
- * A package is considered publishable when `private` is not `true` and it has a
- * `name` and `version`. The returned {@link PublishTarget} array describes where
- * the package would be published (e.g., npmjs.org, GitHub Packages) based on
- * `publishConfig.registry` and other signals.
- *
- * The live layer (`PublishabilityDetectorLive`) is a pure layer with no
- * dependencies — it can be provided standalone or via `WorkspacesLive` /
- * `WorkspacesFullLive`.
- *
- * @privateRemarks
- * Uses the class-based `Context.Tag` pattern. The internal tag identifier is
- * `@spencerbeggs/workspaces-effect/PublishabilityDetector`. Since this service
- * has no dependencies, the layer is constructed with `Layer.succeed` rather than
- * `Layer.effect`.
- *
- * @example Checking publishability of all packages
- * ```typescript
- * import { Effect } from "effect";
- * import { NodeContext } from "@effect/platform-node";
- * import { PublishabilityDetector, WorkspaceDiscovery, WorkspacesLive } from "workspaces-effect";
- *
- * const program = Effect.gen(function* () {
- *   const discovery = yield* WorkspaceDiscovery;
- *   const publishability = yield* PublishabilityDetector;
- *   const packages = yield* discovery.listPackages();
- *
- *   for (const pkg of packages) {
- *     const targets = yield* publishability.detect(pkg, "/path/to/monorepo");
- *     if (targets.length > 0) {
- *       console.log(`${pkg.name} publishes to:`, targets.map((t) => t.registry));
- *     } else {
- *       console.log(`${pkg.name} is not publishable`);
- *     }
- *   }
- * });
- *
- * Effect.runPromise(
- *   program.pipe(
- *     Effect.provide(WorkspacesLive),
- *     Effect.provide(NodeContext.layer),
- *   )
- * );
- * ```
- *
- * @public
- */
-declare class PublishabilityDetector extends PublishabilityDetector_base {}
-declare const PublishabilityDetector_base: Context.TagClass<PublishabilityDetector, "@spencerbeggs/workspaces-effect/PublishabilityDetector", {
-  /**
-   * Detect publish targets for a workspace package.
-   *
-   * Analyzes the package's `package.json` fields to determine if and where
-   * it can be published.
-   *
-   * @param pkg - The {@link WorkspacePackage} to analyze.
-   * @param root - Absolute path to the workspace root directory.
-   * @returns An Effect that succeeds with a readonly array of
-   *   {@link PublishTarget} records. An empty array indicates the package is
-   *   not publishable. Never fails.
-   */
-  readonly detect: (pkg: WorkspacePackage, root: string) => Effect.Effect<ReadonlyArray<PublishTarget>>;
-}>;
-/**
- * Live layer for the {@link PublishabilityDetector} service.
- *
- * Determines whether a workspace package is publishable to npm based
- * on its `private` flag and `publishConfig` settings.
- *
- * @remarks
- * This layer is pure -- it has no dependencies on `FileSystem`, `Path`, or
- * any other platform services. It uses `Layer.succeed` rather than
- * `Layer.effect`. Custom layers can override by providing their own
- * `Layer` for `PublishabilityDetector`.
- *
- * @privateRemarks
- * Builds a single {@link PublishTarget} from `publishConfig` fields,
- * defaulting to the public npm registry when no registry is specified.
- *
- * @example
- * ```typescript
- * import { Effect } from "effect";
- * import { PublishabilityDetector, PublishabilityDetectorLive } from "workspaces-effect";
- * import { WorkspacePackage } from "workspaces-effect";
- *
- * const program = Effect.gen(function* () {
- *   const detector = yield* PublishabilityDetector;
- *   const targets = yield* detector.detect(somePackage, "/path/to/root");
- *   return targets;
- * });
- *
- * Effect.runPromise(
- *   program.pipe(Effect.provide(PublishabilityDetectorLive))
- * );
- * ```
- *
- * @public
- */
-/**
- * Schema for the `publishConfig` field in package.json.
- *
- * @remarks
- * Captures the subset of `publishConfig` properties relevant to workspace
- * tooling: registry selection, access control, and publish directory override.
- *
- * Fields:
- * - `access` — `"public"` or `"restricted"` (scoped package visibility).
- * - `registry` — custom registry URL for publishing.
- * - `directory` — subdirectory to publish instead of the package root.
- *
- * @example Decoding publishConfig
- * ```typescript
- * import { Schema } from "effect";
- * import { PublishConfig } from "workspaces-effect";
- *
- * const config = new PublishConfig({
- *   access: "public",
- *   registry: "https://registry.npmjs.org",
- * });
- * ```
- *
- * @public
+} //#endregion
+//#region src/layers/catalog/resolve.d.ts
+/**
+ * Minimal shape of a `package.json` manifest needed to resolve catalog and
+ * workspace specifiers.
+ *
+ * @public
  */
-declare class PublishConfig extends PublishConfig_base {}
 declare const PublishConfig_base: Schema.Class<PublishConfig, {
   access: Schema.optional<Schema.Literal<["public", "restricted"]>>;
   registry: Schema.optional<typeof Schema.String>;
@@ -3884,261 +3666,213 @@ declare const PublishConfig_base: Schema.Class<PublishConfig, {
 } & {
   readonly tag?: string | undefined;
 }, {}, {}>;
-/**
- * A single publish target for a workspace package.
- *
- * @remarks
- * Represents the resolved publishing configuration for a workspace package,
- * combining defaults with any overrides from the package's `publishConfig`
- * field. Used to determine where and how each package should be published.
- *
- * Fields:
- * - `name` — the package name (non-empty string).
- * - `registry` — the target registry URL (e.g., `"https://registry.npmjs.org"`).
- * - `directory` — the directory to publish (empty string means the package root).
- * - `access` — `"public"` or `"restricted"` (scoped package visibility).
- * - `provenance` — whether to publish with provenance attestation (defaults to `false`).
- *
- * @example Creating a PublishTarget
- * ```typescript
- * import { PublishTarget } from "workspaces-effect";
- *
- * const target = new PublishTarget({
- *   name: "@my-org/utils",
- *   registry: "https://registry.npmjs.org",
- *   directory: "dist/npm",
- *   access: "public",
- * });
- * ```
- *
- * @public
- */
-declare class PublishTarget extends PublishTarget_base {}
-declare const PublishTarget_base: Schema.Class<PublishTarget, {
+/**
+ * Schema for the `publishConfig` field in package.json.
+ *
+ * @remarks
+ * Captures the subset of `publishConfig` properties relevant to workspace
+ * tooling: registry selection, access control, and publish directory override.
+ *
+ * Fields:
+ * - `access` — `"public"` or `"restricted"` (scoped package visibility).
+ * - `registry` — custom registry URL for publishing.
+ * - `directory` — subdirectory to publish instead of the package root.
+ *
+ * @example Decoding publishConfig
+ * ```typescript
+ * import { Schema } from "effect";
+ * import { PublishConfig } from "workspaces-effect";
+ *
+ * const config = new PublishConfig({
+ *   access: "public",
+ *   registry: "https://registry.npmjs.org",
+ * });
+ * ```
+ *
+ * @public
+ */
+declare class PublishConfig extends PublishConfig_base {}
+/**
+ * Type alias for the decoded shape of {@link PublishConfig}.
+ *
+ * @public
+ */
+/**
+ * Minimal package.json schema for workspace discovery.
+ *
+ * @remarks
+ * Captures only the fields needed by workspace tooling — name, version,
+ * private flag, workspace patterns, dependency maps, the `packageManager`
+ * field (used by Corepack), and `publishConfig`. Unknown fields are silently
+ * ignored during decode.
+ *
+ * Fields:
+ * - `name` — the package name.
+ * - `version` — the package version string.
+ * - `private` — whether the package is private (not published).
+ * - `workspaces` — workspace glob patterns (array or object form).
+ * - `dependencies` — production dependency map.
+ * - `devDependencies` — development dependency map.
+ * - `peerDependencies` — peer dependency map.
+ * - `packageManager` — Corepack package manager spec (e.g., `"pnpm@9.1.0"`).
+ * - `publishConfig` — publishing configuration overrides.
+ *
+ * @example Decoding a package.json
+ * ```typescript
+ * import { Schema } from "effect";
+ * import { PackageJsonSchema } from "workspaces-effect";
+ *
+ * const pkg = Schema.decodeUnknownSync(PackageJsonSchema)({
+ *   name: "@my-org/app",
+ *   version: "1.0.0",
+ *   workspaces: ["packages/*"],
+ * });
+ * ```
+ *
+ * @public
+ */
+declare const PackageJsonSchema: Schema.Struct<{
+  name: Schema.optional<typeof Schema.String>;
+  version: Schema.optional<typeof Schema.String>;
+  private: Schema.optional<typeof Schema.Boolean>;
+  workspaces: Schema.optional<Schema.Union<[Schema.Array$<typeof Schema.String>, Schema.Struct<{
+    packages: Schema.Array$<typeof Schema.String>;
+  }>]>>;
+  dependencies: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+  devDependencies: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+  peerDependencies: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+  optionalDependencies: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+  packageManager: Schema.optional<typeof Schema.String>;
+  publishConfig: Schema.optional<typeof PublishConfig>;
+}>;
+/**
+ * TypeScript type for the {@link PackageJsonSchema} schema.
+ *
+ * @public
+ */
+type PackageJsonType = Schema.Schema.Type<typeof PackageJsonSchema>;
+/**
+ * Result of comparing two WorkspacePackage dependency snapshots.
+ * @public
+ */
+interface DependencyDiff {
+  readonly added: Record<string, string>;
+  readonly removed: Record<string, string>;
+  readonly changed: Record<string, {
+    readonly from: string;
+    readonly to: string;
+  }>;
+}
+declare const WorkspacePackage_base: Schema.Class<WorkspacePackage, {
   name: typeof Schema.NonEmptyString;
-  registry: typeof Schema.NonEmptyString;
-  directory: typeof Schema.String;
-  access: Schema.Literal<["public", "restricted"]>;
-  provenance: Schema.optionalWith<typeof Schema.Boolean, {
+  version: typeof Schema.String;
+  path: typeof Schema.NonEmptyString;
+  packageJsonPath: typeof Schema.NonEmptyString;
+  relativePath: typeof Schema.String;
+  private: Schema.optionalWith<typeof Schema.Boolean, {
     default: () => false;
   }>;
+  dependencies: Schema.optionalWith<Schema.Record$<typeof Schema.String, typeof Schema.String>, {
+    default: () => {};
+  }>;
+  devDependencies: Schema.optionalWith<Schema.Record$<typeof Schema.String, typeof Schema.String>, {
+    default: () => {};
+  }>;
+  peerDependencies: Schema.optionalWith<Schema.Record$<typeof Schema.String, typeof Schema.String>, {
+    default: () => {};
+  }>;
+  optionalDependencies: Schema.optionalWith<Schema.Record$<typeof Schema.String, typeof Schema.String>, {
+    default: () => {};
+  }>;
+  publishConfig: Schema.optional<typeof PublishConfig>;
 }, Schema.Struct.Encoded<{
   name: typeof Schema.NonEmptyString;
-  registry: typeof Schema.NonEmptyString;
-  directory: typeof Schema.String;
-  access: Schema.Literal<["public", "restricted"]>;
-  provenance: Schema.optionalWith<typeof Schema.Boolean, {
+  version: typeof Schema.String;
+  path: typeof Schema.NonEmptyString;
+  packageJsonPath: typeof Schema.NonEmptyString;
+  relativePath: typeof Schema.String;
+  private: Schema.optionalWith<typeof Schema.Boolean, {
     default: () => false;
   }>;
+  dependencies: Schema.optionalWith<Schema.Record$<typeof Schema.String, typeof Schema.String>, {
+    default: () => {};
+  }>;
+  devDependencies: Schema.optionalWith<Schema.Record$<typeof Schema.String, typeof Schema.String>, {
+    default: () => {};
+  }>;
+  peerDependencies: Schema.optionalWith<Schema.Record$<typeof Schema.String, typeof Schema.String>, {
+    default: () => {};
+  }>;
+  optionalDependencies: Schema.optionalWith<Schema.Record$<typeof Schema.String, typeof Schema.String>, {
+    default: () => {};
+  }>;
+  publishConfig: Schema.optional<typeof PublishConfig>;
 }>, never, {
-  readonly provenance?: boolean;
+  readonly publishConfig?: PublishConfig | undefined;
 } & {
-  readonly access: "public" | "restricted";
+  readonly dependencies?: {
+    readonly [x: string]: string;
+  } | undefined;
 } & {
-  readonly directory: string;
+  readonly devDependencies?: {
+    readonly [x: string]: string;
+  } | undefined;
+} & {
+  readonly optionalDependencies?: {
+    readonly [x: string]: string;
+  } | undefined;
+} & {
+  readonly peerDependencies?: {
+    readonly [x: string]: string;
+  } | undefined;
+} & {
+  readonly private?: boolean | undefined;
 } & {
   readonly name: string;
 } & {
-  readonly registry: string;
+  readonly packageJsonPath: string;
+} & {
+  readonly path: string;
+} & {
+  readonly relativePath: string;
+} & {
+  readonly version: string;
 }, {}, {}>;
-/**
- * Read and parse a package's package.json from disk.
- *
- * Returns the minimal `PackageJsonType` schema fields. For full raw
- * package.json access, read `pkg.packageJsonPath` directly.
- *
- * Not a dual function — takes a single WorkspacePackage argument.
- * Pipeable via `pipe(pkg, readPackageJson)`.
- */
-/**
- * Service for discovering workspace packages in a monorepo.
- *
- * Reads workspace patterns from the PM-specific config (e.g., `pnpm-workspace.yaml`,
- * `package.json` `workspaces` field), resolves glob patterns against the filesystem,
- * and reads each matched `package.json` to produce {@link WorkspacePackage} records.
- *
- * @remarks
- * WorkspaceDiscovery is the last service in the Discovery group and the primary
- * data source for downstream services. DependencyGraph, TopologicalSorter,
- * PackageResolver, and ChangeDetector all depend on the package list it produces.
- *
- * The live layer (`WorkspaceDiscoveryLive`) depends on `WorkspaceRoot` and
- * `PackageManagerDetector`. It requires `FileSystem` and `Path` from
- * `@effect/platform`. Use `WorkspacesLive` or `WorkspacesFullLive` to get all
- * wiring handled automatically.
- *
- * @privateRemarks
- * Uses the class-based `Context.Tag` pattern. The internal tag identifier is
- * `@spencerbeggs/workspaces-effect/WorkspaceDiscovery`. Dependencies (WorkspaceRoot,
- * PackageManagerDetector) are resolved at layer construction time so that service
- * methods have `R = never`.
- *
- * @example Listing all workspace packages
- * ```typescript
- * import { Effect } from "effect";
- * import { NodeContext } from "@effect/platform-node";
- * import { WorkspaceDiscovery, WorkspacesLive } from "workspaces-effect";
- *
- * const program = Effect.gen(function* () {
- *   const discovery = yield* WorkspaceDiscovery;
- *   const packages = yield* discovery.listPackages();
- *   for (const pkg of packages) {
- *     console.log(`${pkg.name} @ ${pkg.path}`);
- *   }
- * });
- *
- * Effect.runPromise(
- *   program.pipe(
- *     Effect.provide(WorkspacesLive),
- *     Effect.provide(NodeContext.layer),
- *   )
- * );
- * ```
- *
- * @public
- */
-declare class WorkspaceDiscovery extends WorkspaceDiscovery_base {}
-declare const WorkspaceDiscovery_base: Context.TagClass<WorkspaceDiscovery, "@spencerbeggs/workspaces-effect/WorkspaceDiscovery", {
-  /**
-   * List all workspace packages.
-   *
-   * Resolves workspace glob patterns and reads each matched `package.json`.
-   *
-   * @param cwd - Optional starting directory. When provided, the workspace
-   *   root is resolved fresh from `cwd` for this call (results cached per
-   *   resolved root). When omitted, uses the root that was eagerly resolved
-   *   from `process.cwd()` at layer construction time.
-   * @returns An Effect that succeeds with a readonly array of
-   *   {@link WorkspacePackage} records, or fails with
-   *   {@link WorkspaceDiscoveryError} if workspace patterns cannot be resolved.
-   */
-  readonly listPackages: (cwd?: string) => Effect.Effect<ReadonlyArray<WorkspacePackage>, WorkspaceDiscoveryError>;
-  /**
-   * Get a specific workspace package by name.
-   *
-   * @param name - The package name as declared in its `package.json` `name` field.
-   * @param cwd - Optional starting directory. See {@link listPackages} for behavior.
-   * @returns An Effect that succeeds with the matching {@link WorkspacePackage},
-   *   or fails with {@link PackageNotFoundError} if no workspace package has that
-   *   name, or {@link WorkspaceDiscoveryError} if discovery itself fails.
-   */
-  readonly getPackage: (name: string, cwd?: string) => Effect.Effect<WorkspacePackage, PackageNotFoundError | WorkspaceDiscoveryError>;
-  /**
-   * Get a map of workspace-relative directory paths to packages.
-   *
-   * Useful for mapping lockfile importer keys to their workspace packages.
-   * Built from `listPackages()` output and inherits its caching.
-   *
-   * @param cwd - Optional starting directory. See {@link listPackages} for behavior.
-   * @returns An Effect that succeeds with a ReadonlyMap keyed by relativePath.
-   */
-  readonly importerMap: (cwd?: string) => Effect.Effect<ReadonlyMap<string, WorkspacePackage>, WorkspaceDiscoveryError>;
-  /**
-   * Discard cached discovery results so the next {@link listPackages}
-   * (and {@link getPackage} / {@link importerMap}, which build on it)
-   * re-reads every `package.json` from disk.
-   *
-   * @remarks
-   * `listPackages` memoizes its result per resolved workspace root for the
-   * lifetime of the layer. That cache is correct for a static tree, but a
-   * process that mutates `package.json` mid-run — for example running
-   * `changeset version` to bump versions and then reading the new versions
-   * back — would otherwise observe the pre-mutation snapshot. Call
-   * `refresh` after such a mutation to force a re-scan.
-   *
-   * The resolved workspace root itself is not discarded (the root does not
-   * move when package contents change), so the next call pays only the
-   * package re-scan, not the root walk. `refresh` clears the cache for
-   * every resolved root.
-   *
-   * @returns An Effect that clears the cache and succeeds with `void`.
-   */
-  readonly refresh: () => Effect.Effect<void>;
-}>;
-/**
- * Emitted when workspace package discovery fails.
- *
- * @remarks
- * Raised by {@link WorkspaceDiscovery} when glob expansion of workspace
- * patterns or subsequent package.json reads fail. This can occur if patterns
- * in pnpm-workspace.yaml or the root package.json `workspaces` field resolve
- * to invalid or inaccessible directories.
- *
- * Fields:
- * - `root` — the workspace root path where discovery was attempted.
- * - `reason` — human-readable explanation of what went wrong.
- *
- * @example Catching the error
- * ```typescript
- * import { Effect } from "effect";
- * import type { WorkspaceDiscoveryError } from "workspaces-effect";
- * import { WorkspaceDiscovery, WorkspaceDiscoveryLive } from "workspaces-effect";
- *
- * const program = Effect.gen(function* () {
- *   const discovery = yield* WorkspaceDiscovery;
- *   return yield* discovery.discover("/workspace/root");
- * }).pipe(
- *   Effect.catchTag("WorkspaceDiscoveryError", (e) =>
- *     Effect.succeed(`Discovery failed at ${e.root}: ${e.reason}`)
- *   )
- * );
- * ```
- *
- * @public
- */
-declare class WorkspaceDiscoveryError extends WorkspaceDiscoveryErrorBase<{
-  readonly root: string;
-  readonly reason: string;
-}> {
-  get message(): string;
-}
-/**
- * Base constant for {@link WorkspaceDiscoveryError}.
- *
- * @privateRemarks
- * Exported for api-extractor DTS bundling — the `_base` symbol from
- * `Data.TaggedError` must be visible in the generated .d.ts file.
- *
- * @internal
- */
-declare const WorkspaceDiscoveryErrorBase: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => YieldableError & {
-  readonly _tag: "WorkspaceDiscoveryError";
-} & Readonly<A>;
-/**
- * A single workspace package within a monorepo.
- *
- * @remarks
- * Produced by {@link WorkspaceDiscovery} for each package found by expanding
- * the workspace glob patterns. Contains the parsed metadata from the
- * package's `package.json` plus its filesystem location.
- *
- * Fields:
- * - `name` — the package name (non-empty string).
- * - `version` — the package version string.
- * - `path` — absolute filesystem path to the package directory.
- * - `packageJsonPath` — absolute path to the package's `package.json` file.
- * - `relativePath` — path relative to the workspace root.
- * - `private` — whether the package is marked private (defaults to `false`).
- * - `dependencies` — production dependency map (defaults to `{}`).
- * - `devDependencies` — development dependency map (defaults to `{}`).
- * - `peerDependencies` — peer dependency map (defaults to `{}`).
- * - `optionalDependencies` — optional dependency map (defaults to `{}`).
- * - `publishConfig` — optional publishing configuration overrides.
- *
- * @example Creating a WorkspacePackage
- * ```typescript
- * import { WorkspacePackage } from "workspaces-effect";
- *
- * const pkg = new WorkspacePackage({
- *   name: "@my-org/utils",
- *   version: "1.0.0",
- *   path: "/workspace/packages/utils",
- *   packageJsonPath: "/workspace/packages/utils/package.json",
- *   relativePath: "packages/utils",
- * });
- * ```
- *
- * @public
+/**
+ * A single workspace package within a monorepo.
+ *
+ * @remarks
+ * Produced by {@link WorkspaceDiscovery} for each package found by expanding
+ * the workspace glob patterns. Contains the parsed metadata from the
+ * package's `package.json` plus its filesystem location.
+ *
+ * Fields:
+ * - `name` — the package name (non-empty string).
+ * - `version` — the package version string.
+ * - `path` — absolute filesystem path to the package directory.
+ * - `packageJsonPath` — absolute path to the package's `package.json` file.
+ * - `relativePath` — path relative to the workspace root.
+ * - `private` — whether the package is marked private (defaults to `false`).
+ * - `dependencies` — production dependency map (defaults to `{}`).
+ * - `devDependencies` — development dependency map (defaults to `{}`).
+ * - `peerDependencies` — peer dependency map (defaults to `{}`).
+ * - `optionalDependencies` — optional dependency map (defaults to `{}`).
+ * - `publishConfig` — optional publishing configuration overrides.
+ *
+ * @example Creating a WorkspacePackage
+ * ```typescript
+ * import { WorkspacePackage } from "workspaces-effect";
+ *
+ * const pkg = new WorkspacePackage({
+ *   name: "@my-org/utils",
+ *   version: "1.0.0",
+ *   path: "/workspace/packages/utils",
+ *   packageJsonPath: "/workspace/packages/utils/package.json",
+ *   relativePath: "packages/utils",
+ * });
+ * ```
+ *
+ * @public
  */
 declare class WorkspacePackage extends WorkspacePackage_base {
   get isRootWorkspace(): boolean;
@@ -4153,12 +3887,12 @@ declare class WorkspacePackage extends WorkspacePackage_base {
   hasAnyDependencyOn(name: string): boolean;
   dependencyVersion(name: string): Option.Option<string>;
   matchesDependency(pattern: string): boolean;
-  /**
-   * Compare two WorkspacePackage dependency snapshots.
-   *
-   * Compares across all dependency types combined. A dependency that moves
-   * between categories (e.g. from `dependencies` to `peerDependencies`) at
-   * the same version will not appear in the diff.
+  /**
+   * Compare two WorkspacePackage dependency snapshots.
+   *
+   * Compares across all dependency types combined. A dependency that moves
+   * between categories (e.g. from `dependencies` to `peerDependencies`) at
+   * the same version will not appear in the diff.
    */
   dependencyDiff(other: WorkspacePackage): DependencyDiff;
   static hasDependency: {
@@ -4195,15 +3929,167 @@ declare class WorkspacePackage extends WorkspacePackage_base {
   };
   static readPackageJson: (self: WorkspacePackage) => Effect.Effect<PackageJsonType, PackageJsonParseError, FileSystem.FileSystem>;
 }
-declare const WorkspacePackage_base: Schema.Class<WorkspacePackage, {
+//#endregion
+//#region src/services/WorkspaceDiscovery.d.ts
+declare const WorkspaceDiscovery_base: Context.TagClass<WorkspaceDiscovery, "@spencerbeggs/workspaces-effect/WorkspaceDiscovery", {
+  /**
+   * List all workspace packages.
+   *
+   * Resolves workspace glob patterns and reads each matched `package.json`.
+   *
+   * @param cwd - Optional starting directory. When provided, the workspace
+   *   root is resolved fresh from `cwd` for this call (results cached per
+   *   resolved root). When omitted, uses the root that was eagerly resolved
+   *   from `process.cwd()` at layer construction time.
+   * @returns An Effect that succeeds with a readonly array of
+   *   {@link WorkspacePackage} records, or fails with
+   *   {@link WorkspaceDiscoveryError} if workspace patterns cannot be resolved.
+   */
+  readonly listPackages: (cwd?: string) => Effect.Effect<ReadonlyArray<WorkspacePackage>, WorkspaceDiscoveryError>;
+  /**
+   * Get a specific workspace package by name.
+   *
+   * @param name - The package name as declared in its `package.json` `name` field.
+   * @param cwd - Optional starting directory. See {@link listPackages} for behavior.
+   * @returns An Effect that succeeds with the matching {@link WorkspacePackage},
+   *   or fails with {@link PackageNotFoundError} if no workspace package has that
+   *   name, or {@link WorkspaceDiscoveryError} if discovery itself fails.
+   */
+  readonly getPackage: (name: string, cwd?: string) => Effect.Effect<WorkspacePackage, PackageNotFoundError | WorkspaceDiscoveryError>;
+  /**
+   * Get a map of workspace-relative directory paths to packages.
+   *
+   * Useful for mapping lockfile importer keys to their workspace packages.
+   * Built from `listPackages()` output and inherits its caching.
+   *
+   * @param cwd - Optional starting directory. See {@link listPackages} for behavior.
+   * @returns An Effect that succeeds with a ReadonlyMap keyed by relativePath.
+   */
+  readonly importerMap: (cwd?: string) => Effect.Effect<ReadonlyMap<string, WorkspacePackage>, WorkspaceDiscoveryError>;
+  /**
+   * Discard cached discovery results so the next {@link listPackages}
+   * (and {@link getPackage} / {@link importerMap}, which build on it)
+   * re-reads every `package.json` from disk.
+   *
+   * @remarks
+   * `listPackages` memoizes its result per resolved workspace root for the
+   * lifetime of the layer. That cache is correct for a static tree, but a
+   * process that mutates `package.json` mid-run — for example running
+   * `changeset version` to bump versions and then reading the new versions
+   * back — would otherwise observe the pre-mutation snapshot. Call
+   * `refresh` after such a mutation to force a re-scan.
+   *
+   * The resolved workspace root itself is not discarded (the root does not
+   * move when package contents change), so the next call pays only the
+   * package re-scan, not the root walk. `refresh` clears the cache for
+   * every resolved root.
+   *
+   * @returns An Effect that clears the cache and succeeds with `void`.
+   */
+  readonly refresh: () => Effect.Effect<void>;
+}>;
+/**
+ * Service for discovering workspace packages in a monorepo.
+ *
+ * Reads workspace patterns from the PM-specific config (e.g., `pnpm-workspace.yaml`,
+ * `package.json` `workspaces` field), resolves glob patterns against the filesystem,
+ * and reads each matched `package.json` to produce {@link WorkspacePackage} records.
+ *
+ * @remarks
+ * WorkspaceDiscovery is the last service in the Discovery group and the primary
+ * data source for downstream services. DependencyGraph, TopologicalSorter,
+ * PackageResolver, and ChangeDetector all depend on the package list it produces.
+ *
+ * The live layer (`WorkspaceDiscoveryLive`) depends on `WorkspaceRoot` and
+ * `PackageManagerDetector`. It requires `FileSystem` and `Path` from
+ * `@effect/platform`. Use `WorkspacesLive` or `WorkspacesFullLive` to get all
+ * wiring handled automatically.
+ *
+ * @privateRemarks
+ * Uses the class-based `Context.Tag` pattern. The internal tag identifier is
+ * `@spencerbeggs/workspaces-effect/WorkspaceDiscovery`. Dependencies (WorkspaceRoot,
+ * PackageManagerDetector) are resolved at layer construction time so that service
+ * methods have `R = never`.
+ *
+ * @example Listing all workspace packages
+ * ```typescript
+ * import { Effect } from "effect";
+ * import { NodeContext } from "@effect/platform-node";
+ * import { WorkspaceDiscovery, WorkspacesLive } from "workspaces-effect";
+ *
+ * const program = Effect.gen(function* () {
+ *   const discovery = yield* WorkspaceDiscovery;
+ *   const packages = yield* discovery.listPackages();
+ *   for (const pkg of packages) {
+ *     console.log(`${pkg.name} @ ${pkg.path}`);
+ *   }
+ * });
+ *
+ * Effect.runPromise(
+ *   program.pipe(
+ *     Effect.provide(WorkspacesLive),
+ *     Effect.provide(NodeContext.layer),
+ *   )
+ * );
+ * ```
+ *
+ * @public
+ */
+declare class WorkspaceDiscovery extends WorkspaceDiscovery_base {} //#endregion
+//#region src/services/WorkspaceRoot.d.ts
+//#endregion
+//#region src/schemas/CatalogSet.d.ts
+declare const CatalogSet_base: Schema.Class<CatalogSet, {
+  entries: Schema.Record$<typeof Schema.String, Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+}, Schema.Struct.Encoded<{
+  entries: Schema.Record$<typeof Schema.String, Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+}>, never, {
+  readonly entries: {
+    readonly [x: string]: {
+      readonly [x: string]: string;
+    };
+  };
+}, {}, {}>;
+/**
+ * An immutable, fully-normalized catalog collection with the one
+ * resolution semantic shared by live and point-in-time resolution.
+ *
+ * @public
+ */
+declare class CatalogSet extends CatalogSet_base {
+  /** An empty catalog set. */
+  static empty(): CatalogSet;
+  /** Wrap a pnpm `Catalogs` map, dropping undefined entries. */
+  static fromCatalogs(catalogs: Catalogs): CatalogSet;
+  /** Parse the `catalog:`/`catalogs:` sections of a pnpm-workspace.yaml text. */
+  static fromWorkspaceYaml(text: string): Effect.Effect<CatalogSet, CatalogAssemblyError>;
+  /**
+   * Normalize a pnpm lockfile `catalogs:` section — entries are either a
+   * specifier string or a `{ specifier, version }` object.
+   */
+  static fromLockfileCatalogs(raw: unknown): CatalogSet;
+  /** Merge sets; later sets win per dependency within a catalog. */
+  static merge(...sets: ReadonlyArray<CatalogSet>): CatalogSet;
+  /** View as the pnpm `Catalogs` shape. */
+  toCatalogs(): Catalogs;
+  /**
+   * Resolve a `catalog:` specifier to its concrete range. `Option.none`
+   * for non-catalog specifiers and unresolved catalog entries.
+   *
+   * @remarks
+   * Deliberately contrasts with `CatalogResolver.resolveSpecifier`: this
+   * method is catalog-only and returns `Option.none` on unresolvable refs,
+   * whereas the live service also handles `workspace:` specifiers and fails
+   * with a typed `CatalogResolutionError`. Both route through
+   * `resolveManifest`, which is the single resolution semantic.
+   */
+  resolveSpecifier(dependency: string, specifier: string): Option.Option<string>;
+} //#endregion
+//#region src/schemas/WorkspaceStateSnapshot.d.ts
+declare const PackageStateSnapshot_base: Schema.Class<PackageStateSnapshot, {
   name: typeof Schema.NonEmptyString;
   version: typeof Schema.String;
-  path: typeof Schema.NonEmptyString;
-  packageJsonPath: typeof Schema.NonEmptyString;
   relativePath: typeof Schema.String;
-  private: Schema.optionalWith<typeof Schema.Boolean, {
-    default: () => false;
-  }>;
   dependencies: Schema.optionalWith<Schema.Record$<typeof Schema.String, typeof Schema.String>, {
     default: () => {};
   }>;
@@ -4216,16 +4102,10 @@ declare const WorkspacePackage_base: Schema.Class<WorkspacePackage, {
   optionalDependencies: Schema.optionalWith<Schema.Record$<typeof Schema.String, typeof Schema.String>, {
     default: () => {};
   }>;
-  publishConfig: Schema.optional<typeof PublishConfig>;
 }, Schema.Struct.Encoded<{
   name: typeof Schema.NonEmptyString;
   version: typeof Schema.String;
-  path: typeof Schema.NonEmptyString;
-  packageJsonPath: typeof Schema.NonEmptyString;
   relativePath: typeof Schema.String;
-  private: Schema.optionalWith<typeof Schema.Boolean, {
-    default: () => false;
-  }>;
   dependencies: Schema.optionalWith<Schema.Record$<typeof Schema.String, typeof Schema.String>, {
     default: () => {};
   }>;
@@ -4238,105 +4118,356 @@ declare const WorkspacePackage_base: Schema.Class<WorkspacePackage, {
   optionalDependencies: Schema.optionalWith<Schema.Record$<typeof Schema.String, typeof Schema.String>, {
     default: () => {};
   }>;
-  publishConfig: Schema.optional<typeof PublishConfig>;
 }>, never, {
-  readonly publishConfig?: PublishConfig | undefined;
-} & {
   readonly dependencies?: {
     readonly [x: string]: string;
-  };
+  } | undefined;
 } & {
   readonly devDependencies?: {
     readonly [x: string]: string;
-  };
+  } | undefined;
 } & {
   readonly optionalDependencies?: {
     readonly [x: string]: string;
-  };
+  } | undefined;
 } & {
   readonly peerDependencies?: {
     readonly [x: string]: string;
-  };
-} & {
-  readonly private?: boolean;
+  } | undefined;
 } & {
   readonly name: string;
-} & {
-  readonly packageJsonPath: string;
-} & {
-  readonly path: string;
 } & {
   readonly relativePath: string;
 } & {
   readonly version: string;
 }, {}, {}>;
-/**
- * Branded non-empty string representing an absolute workspace path.
- *
- * @remarks
- * Applies the `WorkspacePath` brand to `Schema.NonEmptyString`. Used to
- * distinguish workspace directory paths from arbitrary strings in the type
- * system, preventing accidental misuse of unvalidated path values.
- *
- * @example Decoding a workspace path
- * ```typescript
- * import { Schema } from "effect";
- * import { WorkspacePath } from "workspaces-effect";
- *
- * const path = Schema.decodeUnknownSync(WorkspacePath)("/workspace/pkgs/utils");
- * // path: WorkspacePath (branded string)
- * ```
- *
- * @public
- */
-/**
- * Emitted when no workspace root can be found from the search path.
- *
- * @remarks
- * Raised by {@link WorkspaceRoot} when directory traversal from the search path
- * to the filesystem root finds no workspace markers (pnpm-workspace.yaml or
- * package.json with workspaces field).
- *
- * Fields:
- * - `searchPath` — the absolute path from which upward traversal started.
- * - `reason` — human-readable explanation of why no root was found.
- *
- * @example Catching the error
- * ```typescript
- * import { Effect } from "effect";
- * import type { WorkspaceRootNotFoundError } from "workspaces-effect";
- * import { WorkspaceRoot, WorkspaceRootLive } from "workspaces-effect";
- *
- * const program = Effect.gen(function* () {
- *   const root = yield* WorkspaceRoot;
- *   return yield* root.find("/some/path");
- * }).pipe(
- *   Effect.catchTag("WorkspaceRootNotFoundError", (e) =>
- *     Effect.succeed(`Fallback: ${e.searchPath}`)
- *   )
- * );
- * ```
- *
- * @public
+/**
+ * One workspace package as it existed at a point in time.
+ *
+ * @public
  */
-declare class WorkspaceRootNotFoundError extends WorkspaceRootNotFoundErrorBase<{
-  readonly searchPath: string;
-  readonly reason: string;
-}> {
-  get message(): string;
+declare class PackageStateSnapshot extends PackageStateSnapshot_base {}
+declare const WorkspaceStateSnapshot_base: Schema.Class<WorkspaceStateSnapshot, {
+  packages: Schema.Array$<typeof PackageStateSnapshot>;
+  catalogs: typeof CatalogSet;
+}, Schema.Struct.Encoded<{
+  packages: Schema.Array$<typeof PackageStateSnapshot>;
+  catalogs: typeof CatalogSet;
+}>, never, {
+  readonly catalogs: CatalogSet;
+} & {
+  readonly packages: readonly PackageStateSnapshot[];
+}, {}, {}>;
+/**
+ * The full workspace state at a point in time: every package plus that
+ * moment's assembled catalogs. `resolve` answers "what did this specifier
+ * mean HERE" — catalog: against this snapshot's catalogs, workspace:
+ * against this snapshot's package versions.
+ *
+ * @public
+ */
+declare class WorkspaceStateSnapshot extends WorkspaceStateSnapshot_base {
+  #private;
+  /**
+   * name → version map for workspace: resolution. Stable reference.
+   *
+   * @remarks
+   * The returned record is this instance's memo, built once and reused by
+   * every subsequent `resolve` call. Treat it as
+   * read-only -- mutating it corrupts resolution for the lifetime of this
+   * snapshot.
+   */
+  get versions(): Record<string, string>;
+  /** Find a package snapshot by name (O(1) after the first call). */
+  package(name: string): Option.Option<PackageStateSnapshot>;
+  /**
+   * Resolve a catalog:/workspace: specifier against THIS snapshot.
+   * `Option.none` for plain specifiers and unresolvable references.
+   */
+  resolve(dependency: string, specifier: string): Option.Option<string>;
+} //#endregion
+//#region src/services/PointInTimeWorkspace.d.ts
+/**
+ * The umbrella error union covering both {@link PointInTimeWorkspace}
+ * methods: {@link PointInTimeAtError} (raised by `at`) unioned with
+ * {@link PointInTimeWorktreeError} (raised by `worktree`).
+ *
+ * @remarks
+ * - {@link GitReadError} — a `git show`/`git ls-tree` invocation failed for a
+ *   reason other than "path absent at this ref" (absent paths degrade to
+ *   `Option.none`, never an error). `at`-only.
+ * - {@link CatalogAssemblyError} — the `pnpm-workspace.yaml` at the ref (or on
+ *   disk) is malformed YAML. A malformed *lockfile* never fails; it degrades to
+ *   an empty catalog set.
+ * - {@link WorkspaceRootNotFoundError} — the workspace root could not be
+ *   located walking up from `options.cwd` (or `process.cwd()` when omitted).
+ * - {@link WorkspaceDiscoveryError} — `worktree` failed to enumerate the live
+ *   packages via `WorkspaceDiscovery`. `worktree`-only.
+ *
+ * @public
+ */
+type PointInTimeReadError = PointInTimeAtError | PointInTimeWorktreeError;
+/**
+ * Options accepted by both {@link PointInTimeWorkspace} methods.
+ *
+ * @public
+ */
+interface PointInTimeOptions {
+  /**
+   * Starting directory for workspace-root resolution. The root is found by
+   * walking UP from here (same semantics as `WorkspaceDiscovery`); when
+   * omitted, resolution starts from `process.cwd()`.
+   */
+  readonly cwd?: string;
 }
-/**
- * Base constant for {@link WorkspaceRootNotFoundError}.
- *
- * @privateRemarks
- * Exported for api-extractor DTS bundling — the `_base` symbol from
- * `Data.TaggedError` must be visible in the generated .d.ts file.
- *
- * @internal
- */
-declare const WorkspaceRootNotFoundErrorBase: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => YieldableError & {
-  readonly _tag: "WorkspaceRootNotFoundError";
-} & Readonly<A>;
+/**
+ * Errors `at` can raise. `at` never enumerates the live filesystem, so
+ * {@link WorkspaceDiscoveryError} cannot occur.
+ *
+ * @public
+ */
+type PointInTimeAtError = GitReadError | CatalogAssemblyError | WorkspaceRootNotFoundError;
+/**
+ * Errors `worktree` can raise. `worktree` never invokes git, so
+ * {@link GitReadError} cannot occur.
+ *
+ * @public
+ */
+type PointInTimeWorktreeError = CatalogAssemblyError | WorkspaceRootNotFoundError | WorkspaceDiscoveryError;
+declare const PointInTimeWorkspace_base: Context.TagClass<PointInTimeWorkspace, "@spencerbeggs/workspaces-effect/PointInTimeWorkspace", {
+  /**
+   * Workspace state as of a git ref.
+   *
+   * Reads `pnpm-workspace.yaml`, `pnpm-lock.yaml`, and each package's
+   * `package.json` at `ref` via `git show`/`git ls-tree`; packages absent at
+   * the ref are skipped. Cached per `(resolved root, ref)`.
+   *
+   * @param ref - Any git ref (SHA, branch, tag) resolvable in the repo.
+   * @param options - Optional {@link PointInTimeOptions}; `options.cwd` is a
+   *   starting directory to walk UP from when resolving the workspace root
+   *   (same semantics as `WorkspaceDiscovery`) — when omitted, resolution
+   *   starts from `process.cwd()`.
+   * @returns An Effect that succeeds with the {@link WorkspaceStateSnapshot}
+   *   at the ref, or fails with {@link PointInTimeAtError}.
+   */
+  readonly at: (ref: string, options?: PointInTimeOptions) => Effect.Effect<WorkspaceStateSnapshot, PointInTimeAtError>;
+  /**
+   * Workspace state of the live working tree (staged + unstaged edits).
+   *
+   * Enumerates packages via `WorkspaceDiscovery` and reads catalogs from the
+   * on-disk `pnpm-workspace.yaml` and `pnpm-lock.yaml`. Uncached.
+   *
+   * @param options - Optional {@link PointInTimeOptions}; `options.cwd` is a
+   *   starting directory to walk UP from when resolving the workspace root
+   *   (same semantics as `WorkspaceDiscovery`) — when omitted, resolution
+   *   starts from `process.cwd()`.
+   * @returns An Effect that succeeds with the live {@link WorkspaceStateSnapshot},
+   *   or fails with {@link PointInTimeWorktreeError}.
+   */
+  readonly worktree: (options?: PointInTimeOptions) => Effect.Effect<WorkspaceStateSnapshot, PointInTimeWorktreeError>;
+}>;
+/**
+ * Service for reading a monorepo's workspace state at a specific moment: any
+ * git ref (via `git show`/`git ls-tree`, without checking the ref out) or the
+ * live working tree (via `WorkspaceDiscovery`).
+ *
+ * @remarks
+ * Each snapshot carries that moment's packages plus its assembled pnpm catalog
+ * set, so `catalog:`/`workspace:` specifiers resolve against the state as it
+ * existed *then* — not against the current working tree. Catalog precedence is
+ * lockfile-then-inline (inline `pnpm-workspace.yaml` catalogs win).
+ *
+ * The live layer ({@link PointInTimeWorkspaceLive}) resolves `WorkspaceRoot`,
+ * `WorkspaceDiscovery`, `CommandExecutor`, `FileSystem`, and `Path` at layer
+ * construction so both methods have `R = never`. Use `WorkspacesFullLive` to
+ * get all wiring handled automatically.
+ *
+ * @privateRemarks
+ * Uses the class-based `Context.Tag` pattern. The internal tag identifier is
+ * `@spencerbeggs/workspaces-effect/PointInTimeWorkspace`.
+ *
+ * @see {@link PointInTimeWorkspaceLive} for the live implementation.
+ *
+ * @public
+ */
+declare class PointInTimeWorkspace extends PointInTimeWorkspace_base {} //#endregion
+//#region src/layers/PointInTimeWorkspaceLive.d.ts
+/**
+ * Convenience type alias for the {@link PointInTimeWorkspaceLive} layer signature.
+ *
+ * @public
+ */
+//#endregion
+//#region src/schemas/publish.d.ts
+declare const PublishTarget_base: Schema.Class<PublishTarget, {
+  name: typeof Schema.NonEmptyString;
+  registry: typeof Schema.NonEmptyString;
+  directory: typeof Schema.String;
+  access: Schema.Literal<["public", "restricted"]>;
+  provenance: Schema.optionalWith<typeof Schema.Boolean, {
+    default: () => false;
+  }>;
+}, Schema.Struct.Encoded<{
+  name: typeof Schema.NonEmptyString;
+  registry: typeof Schema.NonEmptyString;
+  directory: typeof Schema.String;
+  access: Schema.Literal<["public", "restricted"]>;
+  provenance: Schema.optionalWith<typeof Schema.Boolean, {
+    default: () => false;
+  }>;
+}>, never, {
+  readonly provenance?: boolean | undefined;
+} & {
+  readonly access: "public" | "restricted";
+} & {
+  readonly directory: string;
+} & {
+  readonly name: string;
+} & {
+  readonly registry: string;
+}, {}, {}>;
+/**
+ * A single publish target for a workspace package.
+ *
+ * @remarks
+ * Represents the resolved publishing configuration for a workspace package,
+ * combining defaults with any overrides from the package's `publishConfig`
+ * field. Used to determine where and how each package should be published.
+ *
+ * Fields:
+ * - `name` — the package name (non-empty string).
+ * - `registry` — the target registry URL (e.g., `"https://registry.npmjs.org"`).
+ * - `directory` — the directory to publish (empty string means the package root).
+ * - `access` — `"public"` or `"restricted"` (scoped package visibility).
+ * - `provenance` — whether to publish with provenance attestation (defaults to `false`).
+ *
+ * @example Creating a PublishTarget
+ * ```typescript
+ * import { PublishTarget } from "workspaces-effect";
+ *
+ * const target = new PublishTarget({
+ *   name: "@my-org/utils",
+ *   registry: "https://registry.npmjs.org",
+ *   directory: "dist/npm",
+ *   access: "public",
+ * });
+ * ```
+ *
+ * @public
+ */
+declare class PublishTarget extends PublishTarget_base {} //#endregion
+//#region src/services/PublishabilityDetector.d.ts
+declare const PublishabilityDetector_base: Context.TagClass<PublishabilityDetector, "@spencerbeggs/workspaces-effect/PublishabilityDetector", {
+  /**
+   * Detect publish targets for a workspace package.
+   *
+   * Analyzes the package's `package.json` fields to determine if and where
+   * it can be published.
+   *
+   * @param pkg - The {@link WorkspacePackage} to analyze.
+   * @param root - Absolute path to the workspace root directory.
+   * @returns An Effect that succeeds with a readonly array of
+   *   {@link PublishTarget} records. An empty array indicates the package is
+   *   not publishable. Never fails.
+   */
+  readonly detect: (pkg: WorkspacePackage, root: string) => Effect.Effect<ReadonlyArray<PublishTarget>>;
+}>;
+/**
+ * Service for detecting whether a workspace package is publishable and
+ * identifying its publish targets (npm, GitHub Packages, etc.).
+ *
+ * Inspects `package.json` fields such as `private`, `publishConfig`, and
+ * `repository` to determine publishability and target registries.
+ *
+ * @remarks
+ * PublishabilityDetector is part of the Configuration and Lockfiles service
+ * group. It is a pure service with no dependencies on other services — it
+ * operates solely on the {@link WorkspacePackage} data and the workspace root
+ * path passed to it.
+ *
+ * A package is considered publishable when `private` is not `true` and it has a
+ * `name` and `version`. The returned {@link PublishTarget} array describes where
+ * the package would be published (e.g., npmjs.org, GitHub Packages) based on
+ * `publishConfig.registry` and other signals.
+ *
+ * The live layer (`PublishabilityDetectorLive`) is a pure layer with no
+ * dependencies — it can be provided standalone or via `WorkspacesLive` /
+ * `WorkspacesFullLive`.
+ *
+ * @privateRemarks
+ * Uses the class-based `Context.Tag` pattern. The internal tag identifier is
+ * `@spencerbeggs/workspaces-effect/PublishabilityDetector`. Since this service
+ * has no dependencies, the layer is constructed with `Layer.succeed` rather than
+ * `Layer.effect`.
+ *
+ * @example Checking publishability of all packages
+ * ```typescript
+ * import { Effect } from "effect";
+ * import { NodeContext } from "@effect/platform-node";
+ * import { PublishabilityDetector, WorkspaceDiscovery, WorkspacesLive } from "workspaces-effect";
+ *
+ * const program = Effect.gen(function* () {
+ *   const discovery = yield* WorkspaceDiscovery;
+ *   const publishability = yield* PublishabilityDetector;
+ *   const packages = yield* discovery.listPackages();
+ *
+ *   for (const pkg of packages) {
+ *     const targets = yield* publishability.detect(pkg, "/path/to/monorepo");
+ *     if (targets.length > 0) {
+ *       console.log(`${pkg.name} publishes to:`, targets.map((t) => t.registry));
+ *     } else {
+ *       console.log(`${pkg.name} is not publishable`);
+ *     }
+ *   }
+ * });
+ *
+ * Effect.runPromise(
+ *   program.pipe(
+ *     Effect.provide(WorkspacesLive),
+ *     Effect.provide(NodeContext.layer),
+ *   )
+ * );
+ * ```
+ *
+ * @public
+ */
+declare class PublishabilityDetector extends PublishabilityDetector_base {} //#endregion
+//#region src/layers/PublishabilityDetectorLive.d.ts
+/**
+ * Live layer for the {@link PublishabilityDetector} service.
+ *
+ * Determines whether a workspace package is publishable to npm based
+ * on its `private` flag and `publishConfig` settings.
+ *
+ * @remarks
+ * This layer is pure -- it has no dependencies on `FileSystem`, `Path`, or
+ * any other platform services. It uses `Layer.succeed` rather than
+ * `Layer.effect`. Custom layers can override by providing their own
+ * `Layer` for `PublishabilityDetector`.
+ *
+ * @privateRemarks
+ * Builds a single {@link PublishTarget} from `publishConfig` fields,
+ * defaulting to the public npm registry when no registry is specified.
+ *
+ * @example
+ * ```typescript
+ * import { Effect } from "effect";
+ * import { PublishabilityDetector, PublishabilityDetectorLive } from "workspaces-effect";
+ * import { WorkspacePackage } from "workspaces-effect";
+ *
+ * const program = Effect.gen(function* () {
+ *   const detector = yield* PublishabilityDetector;
+ *   const targets = yield* detector.detect(somePackage, "/path/to/root");
+ *   return targets;
+ * });
+ *
+ * Effect.runPromise(
+ *   program.pipe(Effect.provide(PublishabilityDetectorLive))
+ * );
+ * ```
+ *
+ * @public
+ */
 //#endregion
 //#region ../silk-effects/dist/dev/pkg/index.d.ts
 //#region \0rolldown/runtime.js
@@ -6825,6 +6956,53 @@ declare class GitError extends GitErrorBase<{
 }> {
   get message(): string;
 }
+/**
+ * Base class for {@link ChangesetIOError}.
+ *
+ * @privateRemarks
+ * Effect's `Data.TaggedError` creates an anonymous base class that
+ * api-extractor cannot follow without an explicit export.
+ *
+ * @internal
+ */
+declare const ChangesetIOErrorBase: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "ChangesetIOError";
+} & Readonly<A>;
+/**
+ * Changeset file I/O failure.
+ *
+ * @remarks
+ * Raised by {@link DepsRegen} when reading, writing, listing, or deleting
+ * `.changeset/*.md` files fails. Deletion failures during
+ * {@link DepsRegenShape.execute} are tolerated (stale changesets are
+ * skip-and-continue, so an interrupted run stays safely re-runnable);
+ * read, list, and write failures are loud.
+ *
+ * @example
+ * ```typescript
+ * import { Effect } from "effect";
+ * import { ChangesetIOError } from "@savvy-web/changesets";
+ *
+ * declare const program: Effect.Effect<void, ChangesetIOError>;
+ *
+ * const handled = program.pipe(
+ *   Effect.catchTag("ChangesetIOError", (err) =>
+ *     Effect.logError(`changeset ${err.operation} failed at ${err.path}: ${err.reason}`)
+ *   ),
+ * );
+ * ```
+ *
+ * @see {@link DepsRegen} which produces these errors during plan/execute
+ *
+ * @public
+ */
+declare class ChangesetIOError extends ChangesetIOErrorBase<{
+  /** Absolute path of the file or directory the operation targeted. */readonly path: string; /** The failed operation. */
+  readonly operation: "read" | "write" | "delete" | "list"; /** Human-readable failure reason. */
+  readonly reason: string;
+}> {
+  get message(): string;
+}
 /**
  * Base class for {@link ReleasePlanError}.
  *
@@ -7775,60 +7953,50 @@ declare const ChangelogServiceBase: Context.TagClass<ChangelogService, "Changelo
  * @public
  */
 declare class ChangelogService extends ChangelogServiceBase {} //#endregion
-//#region src/changesets/services/workspace-snapshot.d.ts
+//#region src/services/ChangesetConfig.d.ts
 /**
- * One workspace package as it existed at a specific git ref.
- *
+ * Changeset operating mode for a workspace root.
  * @public
  */
-interface WorkspaceSnapshot {
-  /** Package name from `package.json#name`. */
-  readonly name: string;
-  /** Repo-relative path of the package directory at this ref. */
-  readonly relativePath: string;
-  /** Package version from `package.json#version`. */
-  readonly version: string;
-  /** Declared `dependencies` (raw strings, including `workspace:` / `catalog:` protocols). */
-  readonly dependencies: Readonly<Record<string, string>>;
-  /** Declared `devDependencies`. */
-  readonly devDependencies: Readonly<Record<string, string>>;
-  /** Declared `peerDependencies`. */
-  readonly peerDependencies: Readonly<Record<string, string>>;
-  /** Declared `optionalDependencies`. */
-  readonly optionalDependencies: Readonly<Record<string, string>>;
-}
+type ChangesetMode = "silk" | "vanilla" | "none";
+declare const ChangesetConfig_base: Context.TagClass<ChangesetConfig, "@savvy-web/silk-effects/ChangesetConfig", {
+  readonly mode: (root: string) => Effect.Effect<ChangesetMode>;
+  readonly versionPrivate: (root: string) => Effect.Effect<boolean>;
+  readonly ignorePatterns: (root: string) => Effect.Effect<ReadonlyArray<string>>;
+  readonly isIgnored: (name: string, root: string) => Effect.Effect<boolean>;
+  readonly fixed: (root: string) => Effect.Effect<ReadonlyArray<ReadonlyArray<string>>>;
+}>;
 /**
- * Effect service interface for reading workspace snapshots.
+ * Accessor service over a workspace root's `.changeset/config.json`.
+ *
+ * @remarks
+ * Reads through {@link ChangesetConfigReader} (FileSystem-based) with a per-root cache.
+ * Every accessor is total (error channel `never`): a missing or unreadable config collapses
+ * to `mode: "none"` and empty/false defaults.
  *
+ * @since 0.4.0
  * @public
  */
-interface WorkspaceSnapshotReaderShape {
+declare class ChangesetConfig extends ChangesetConfig_base {
   /**
-   * Read every workspace package's snapshot at the given git ref.
+   * The one ignore matcher: exact name match, or `@scope/*` wildcard.
    *
-   * @param cwd - Project root (must be inside a git repo)
-   * @param ref - Any valid git revision spec — branch, tag, SHA, `HEAD~1`, etc.
-   * @returns Effect resolving to one {@link WorkspaceSnapshot} per workspace
-   *   package present at that ref, or failing with {@link GitError}
+   * `"@scope/*"` matches `"@scope/anything"` (prefix kept includes the trailing slash),
+   * but not the bare scope `"@scope"`.
    */
-  readonly snapshotAt: (cwd: string, ref: string) => Effect.Effect<ReadonlyArray<WorkspaceSnapshot>, GitError>;
+  static matches(name: string, pattern: string): boolean;
 }
 /**
- * @internal
- */
-declare const WorkspaceSnapshotReaderBase: Context.TagClass<WorkspaceSnapshotReader, "WorkspaceSnapshotReader", WorkspaceSnapshotReaderShape>;
-/**
- * Effect service tag for {@link WorkspaceSnapshotReaderShape}.
+ * Live {@link ChangesetConfig} reading via {@link ChangesetConfigReader}, cached per root.
  *
- * @public
- */
-declare class WorkspaceSnapshotReader extends WorkspaceSnapshotReaderBase {}
-/**
- * Production layer for {@link WorkspaceSnapshotReader}.
+ * @remarks
+ * Requires `ChangesetConfigReader` (which requires `FileSystem`). Provide
+ * `ChangesetConfigReaderLive` + a platform layer (`NodeContext.layer`).
  *
+ * @since 0.4.0
  * @public
  */
-declare const WorkspaceSnapshotReaderLive: Layer.Layer<WorkspaceSnapshotReader>; //#endregion
+//#endregion
 //#region src/changesets/utils/dep-diff.d.ts
 /**
  * A workspace package's worth of dependency-table rows.
@@ -7838,38 +8006,26 @@ declare const WorkspaceSnapshotReaderLive: Layer.Layer<WorkspaceSnapshotReader>;
 interface WorkspaceDependencyDiff {
   /** The workspace package whose `package.json` changed. */
   readonly package: string;
-  /** Repo-relative path of the package directory (taken from the `after` snapshot when available). */
+  /** Repo-relative path of the package directory (taken from the `after` snapshot). */
   readonly relativePath: string;
   /** One row per dependency change, sorted by the existing `sortDependencyRows` convention. */
   readonly rows: ReadonlyArray<DependencyTableRow>;
 }
 /**
- * Diff two workspace snapshots and return per-package dependency-table rows.
+ * Diff two workspace snapshots and return per-package dependency-table rows,
+ * comparing already-resolved specifier values per side.
  *
- * @param before - Snapshot at the older ref (typically the merge base). Pass
- *   `null` for workspace packages that did not exist at the older ref — every
- *   declared dep is then reported as `"added"`.
+ * @param before - Snapshot at the older ref (typically the merge base). A
+ *   workspace package absent here reports every declared dep as `"added"`.
  * @param after - Snapshot at the newer ref (typically the working tree).
  * @returns One {@link WorkspaceDependencyDiff} entry per workspace package
- *   that has at least one row. Packages with no changes are omitted.
+ *   that has at least one row. Packages with no resolved-value changes are
+ *   omitted.
  *
  * @public
  */
-declare function computeWorkspaceDependencyDiffs(beforeSnapshots: ReadonlyArray<WorkspaceSnapshot>, afterSnapshots: ReadonlyArray<WorkspaceSnapshot>): ReadonlyArray<WorkspaceDependencyDiff>; //#endregion
+declare function computeWorkspaceDependencyDiffs(before: WorkspaceStateSnapshot, after: WorkspaceStateSnapshot): ReadonlyArray<WorkspaceDependencyDiff>; //#endregion
 //#region src/changesets/services/deps-regen.d.ts
-/**
- * Resolve protocol From/To cells to concrete versions (raw-string fallback
- * when unresolved or on resolver error), leave em-dash sentinels untouched,
- * then optionally drop `devDependency` rows, and re-sort.
- *
- * @param diff - One workspace package's dependency-table rows.
- * @param keepDevDeps - When `true`, retain `devDependency` rows; otherwise
- *   drop them unconditionally (the regen default).
- * @returns An Effect yielding the transformed {@link WorkspaceDependencyDiff}.
- *
- * @public
- */
-declare const resolveDiffRows: (diff: WorkspaceDependencyDiff, keepDevDeps?: boolean) => Effect.Effect<WorkspaceDependencyDiff, never, CatalogResolver>;
 /**
  * Strict detection of "pure dependency changesets" per the documented
  * rules: single-package frontmatter, single `## Dependencies` heading,
@@ -7940,7 +8096,7 @@ interface DepsRegenOptions {
   readonly from?: string;
   /**
    * Newer ref to diff to. Defaults to the working tree (staged + unstaged
-   * + untracked) via {@link snapshotFromWorktree}.
+   * + untracked) via `PointInTimeWorkspace.worktree`.
    */
   readonly to?: string;
 }
@@ -7951,19 +8107,27 @@ interface DepsRegenOptions {
  */
 interface DepsRegenShape {
   /**
-   * Compute a complete {@link RegenPlan} without touching the filesystem.
+   * Compute a complete {@link RegenPlan}. Read-only against the filesystem:
+   * only inspects the existing `.changeset/*.md` files to detect
+   * stale/mixed changesets.
    *
    * @param options - See {@link DepsRegenOptions}.
-   * @returns An Effect yielding the plan, or failing with {@link GitError}.
+   * @returns An Effect yielding the plan, or failing with {@link GitError},
+   *   `WorkspaceDiscoveryError`, {@link ChangesetIOError} (an unreadable
+   *   `.changeset` directory or a genuinely unreadable changeset file list),
+   *   or `PointInTimeReadError` (a snapshot read failed for either ref).
    */
-  readonly plan: (options: DepsRegenOptions) => Effect.Effect<RegenPlan, GitError | WorkspaceDiscoveryError, never>;
+  readonly plan: (options: DepsRegenOptions) => Effect.Effect<RegenPlan, GitError | WorkspaceDiscoveryError | ChangesetIOError | PointInTimeReadError, never>;
   /**
-   * Apply a {@link RegenPlan}: delete stale changesets, write fresh ones.
+   * Apply a {@link RegenPlan}: write fresh changesets first, then delete
+   * stale ones. Writes fail loudly with {@link ChangesetIOError}; deletion
+   * failures are tolerated (skip-and-continue) so an interrupted run stays
+   * safely re-runnable.
    *
    * @param plan - The plan produced by {@link DepsRegenShape.plan}.
    * @returns An Effect yielding a {@link RegenResult}.
    */
-  readonly execute: (plan: RegenPlan) => Effect.Effect<RegenResult, never, never>;
+  readonly execute: (plan: RegenPlan) => Effect.Effect<RegenResult, ChangesetIOError, never>;
 }
 /**
  * @internal
@@ -7990,13 +8154,42 @@ declare class DepsRegen extends DepsRegenBase {}
 /**
  * Live layer for {@link DepsRegen}.
  *
- * Requires {@link WorkspaceSnapshotReader}, {@link ConfigInspector},
- * `WorkspaceDiscovery`, `CatalogResolver`, and `PublishabilityDetector`
- * (the last three from `workspaces-effect`).
+ * Requires `PointInTimeWorkspace`, `WorkspaceDiscovery`,
+ * `PublishabilityDetector` (all from `workspaces-effect`),
+ * {@link ConfigInspector}, {@link ChangesetConfig}, and
+ * `FileSystem.FileSystem` (resolved once at construction and closed over by
+ * the shape, keeping `plan`/`execute` themselves requirement-free).
+ *
+ * @public
+ */
+declare const DepsRegenLive: Layer.Layer<DepsRegen, never, PointInTimeWorkspace | ConfigInspector | WorkspaceDiscovery | PublishabilityDetector | ChangesetConfig | FileSystem.FileSystem>;
+/**
+ * Batteries-included {@link DepsRegen} layer: silk's opinionated default
+ * composition of the full dependency graph. Only the platform services
+ * remain — note that {@link PointInTimeWorkspace} reads git history, so
+ * this layer genuinely requires `CommandExecutor` in addition to
+ * `FileSystem`/`Path`: provide a git-capable platform layer
+ * (`NodeContext.layer`), not a bare filesystem-only layer.
+ *
+ * Gating uses silk's adaptive publishability detector
+ * ({@link PublishabilityDetectorAdaptiveLive}), so the default semantics
+ * are "versionable minus ignored" — identical to the savvy CLI and MCP
+ * runtimes. Consumers who need to swap any dependency (test detectors,
+ * alternate config sources) should keep composing {@link DepsRegenLive}
+ * directly; this layer is purely additive.
+ *
+ * @example
+ * ```typescript
+ * import { NodeContext } from "@effect/platform-node";
+ * import { Layer } from "effect";
+ * import { Changesets } from "@savvy-web/silk-effects";
+ *
+ * const depsRegen = Changesets.DepsRegenDefault.pipe(Layer.provide(NodeContext.layer));
+ * ```
  *
  * @public
  */
-declare const DepsRegenLive: Layer.Layer<DepsRegen, never, WorkspaceSnapshotReader | ConfigInspector | WorkspaceDiscovery | CatalogResolver | PublishabilityDetector>; //#endregion
+declare const DepsRegenDefault: Layer.Layer<DepsRegen, never, FileSystem.FileSystem | Path.Path | CommandExecutor.CommandExecutor>; //#endregion
 //#region src/changesets/schemas/release-plan.d.ts
 /** A semantic-version bump level (the `"none"` plan type is filtered out upstream). @public */
 declare const BumpTypeSchema: Schema.Literal<["major", "minor", "patch"]>;
@@ -8096,8 +8289,8 @@ interface ReleasePlannerShape {
 declare const ReleasePlannerBase: Context.TagClass<ReleasePlanner, "ReleasePlanner", ReleasePlannerShape>;
 /** Effect service tag for the release planner. @public */
 declare class ReleasePlanner extends ReleasePlannerBase {}
-/** Production layer. Requires {@link ConfigInspector} (used by `apply`). @public */
-declare const ReleasePlannerLive: Layer.Layer<ReleasePlanner, never, ConfigInspector>;
+/** Production layer. Requires {@link ConfigInspector} (used by `apply`) and `FileSystem`. @public */
+declare const ReleasePlannerLive: Layer.Layer<ReleasePlanner, never, ConfigInspector | FileSystem.FileSystem>;
 /**
  * Test factory — supply fixed results for any subset of methods. Unsupplied
  * methods fail with a `ReleasePlanError`.
@@ -8771,6 +8964,14 @@ declare const LegacyVersionFilesSchema: Schema.Array$<Schema.Struct<{
  * @internal
  */
 declare function serializeDependencyTableToMarkdown(rows: DependencyTableRow[]): string; //#endregion
+//#region src/changesets/utils/git.d.ts
+/**
+ * Run `git merge-base <base> HEAD`, returning the SHA. Errors propagate
+ * as {@link GitError}.
+ *
+ * @internal
+ */
+declare function gitMergeBase(cwd: string, base: string): Effect.Effect<string, GitError>; //#endregion
 //#region src/changesets/utils/publishability.d.ts
 /**
  * Compute the set of currently-publishable workspace package names.
@@ -8779,12 +8980,24 @@ declare function serializeDependencyTableToMarkdown(rows: DependencyTableRow[]):
  * Uses the currently-active {@link SilkPublishability} — wire the
  * {@link SilkPublishabilityDetectorLive} layer to get silk semantics.
  *
+ * `root` is passed through verbatim to `detector.detect(pkg, root)` for every
+ * package — it must be the project root (the directory containing
+ * `.changeset/`), NOT the individual package's directory. The vanilla
+ * `PublishabilityDetectorLive` and plain `SilkPublishabilityDetectorLive`
+ * both ignore this argument, but the ignore/mode-aware
+ * `PublishabilityDetectorAdaptiveLive` reads `.changeset/config.json`
+ * relative to it, so passing a package subdirectory silently makes every
+ * package resolve to "not publishable". Mirrors
+ * {@link SilkPublishability.listPublishable}, which takes the same
+ * single-root parameter for the same reason.
+ *
  * @param packages - The workspace packages to evaluate
+ * @param root - Absolute path to the project root containing `.changeset/`
  * @returns An Effect yielding a `Set` of publishable package names
  *
  * @public
  */
-declare function listPublishablePackageNames(packages: ReadonlyArray<WorkspacePackage>): Effect.Effect<ReadonlySet<string>, never, PublishabilityDetector>; //#endregion
+declare function listPublishablePackageNames(packages: ReadonlyArray<WorkspacePackage>, root: string): Effect.Effect<ReadonlySet<string>, never, PublishabilityDetector>; //#endregion
 //#region src/changesets/utils/version-files.d.ts
 /**
  * Result of a single version file update.
@@ -8989,27 +9202,6 @@ declare class VersionFiles {
    */
   static processResolvedVersionFiles(scopes: ReadonlyArray<ResolvedPackageScope>, dryRun?: boolean): VersionFileUpdate[];
 } //#endregion
-//#region src/changesets/utils/worktree-snapshot.d.ts
-/**
- * Run `git merge-base <base> HEAD`, returning the SHA. Errors propagate
- * as {@link GitError}.
- *
- * @internal
- */
-declare function gitMergeBase(cwd: string, base: string): Effect.Effect<string, GitError>;
-/**
- * Read every workspace package's `package.json` from the live working
- * tree, returning {@link WorkspaceSnapshot} entries matching the shape
- * `WorkspaceSnapshotReader.snapshotAt` produces for git refs.
- *
- * @remarks
- * Falls back to root-only when `pnpm-workspace.yaml` is missing or
- * unparseable. Uses `node:fs.readdirSync` for directory expansion
- * (portable across platforms — `execFileSync("ls")` is not).
- *
- * @internal
- */
-declare function snapshotFromWorktree(cwd: string): ReadonlyArray<WorkspaceSnapshot>; //#endregion
 //#region ../../node_modules/.pnpm/micromark-util-types@2.0.2/node_modules/micromark-util-types/index.d.ts
 /**
  * Enum of allowed token types.
@@ -9662,7 +9854,7 @@ declare const RequiredSectionsRule$2: Plugin<Root, unknown>; //#endregion
 //#region src/changesets/remark/rules/uncategorized-content.d.ts
 declare const UncategorizedContentRule$2: Plugin<Root, unknown>;
 declare namespace index_d_exports {
-  export { AggregateDependencyTablesPlugin, AppliedRelease, AppliedReleaseEntrySchema, AppliedReleaseSchema, BranchAnalysis, BranchAnalysisSchema, BranchAnalyzer, BranchAnalyzerBase, BranchAnalyzerLive, BranchAnalyzerShape, BranchFileEntry, BranchFileEntrySchema, BumpType, BumpTypeSchema, Categories, Changelog, ChangelogService, ChangelogServiceBase, ChangelogServiceShape, ChangelogTransformer, Changeset, ChangesetLinter, ChangesetOptions, ChangesetOptionsSchema, ChangesetPreview, ChangesetPreviewSchema, ChangesetSchema, ChangesetSummarySchema, ChangesetValidationError, ChangesetValidationErrorBase, Classification, ClassificationReason, ClassificationReasonSchema, ClassificationSchema, CommitHashSchema, ConfigInspector, ConfigInspectorBase, ConfigInspectorLive, ConfigInspectorShape, ConfigurationError, ConfigurationErrorBase, ContentStructureRule$2 as ContentStructureRule, ContributorFootnotesPlugin, DeduplicateItemsPlugin, DependencyAction, DependencyActionSchema, DependencyTable, DependencyTableFormatRule$2 as DependencyTableFormatRule, DependencyTableRow, DependencyTableRowSchema, DependencyTableSchema, DependencyTableType, DependencyTableTypeSchema, DependencyType, DependencyTypeSchema, DependencyUpdate, DependencyUpdateSchema, DepsRegen, DepsRegenBase, DepsRegenLive, DepsRegenOptions, DepsRegenShape, FileStatus, FileStatusSchema, GitError, GitErrorBase, GitHubApiError, GitHubApiErrorBase, GitHubCommitInfo, GitHubInfo, GitHubInfoSchema, GitHubLive, GitHubService, GitHubServiceBase, GitHubServiceShape, GlobSchema, HeadingHierarchyRule$2 as HeadingHierarchyRule, InspectedConfig, InspectedConfigSchema, IssueLinkRefsPlugin, IssueNumberSchema, JsonPathSchema, LegacyVersionFileConfig, LegacyVersionFileConfigSchema, LegacyVersionFilesSchema, LintMessage, MarkdownLive, MarkdownParseError, MarkdownParseErrorBase, MarkdownService, MarkdownServiceBase, MarkdownServiceShape, ContentStructureRule$1 as MarkdownlintContentStructureRule, DependencyTableFormatRule$1 as MarkdownlintDependencyTableFormatRule, HeadingHierarchyRule$1 as MarkdownlintHeadingHierarchyRule, RequiredSectionsRule$1 as MarkdownlintRequiredSectionsRule, UncategorizedContentRule$1 as MarkdownlintUncategorizedContentRule, MergeSectionsPlugin, NonEmptyString, NormalizeFormatPlugin, PackageScope, PackageScopeSchema, PackagesRecordSchema, PendingChangeset, PendingChangesetSchema, PositiveInteger, PreviewRelease, PreviewReleaseSchema, RegenPlan, RegenResult, ReleasePlanError, ReleasePlanErrorBase, ReleasePlanner, ReleasePlannerBase, ReleasePlannerLive, ReleasePlannerShape, ReorderSectionsPlugin, RepoSchema, RequiredSectionsRule$2 as RequiredSectionsRule, ResolvedPackageScope, ResolvedPackageScopeSchema, ResolvedVersionFile, ResolvedVersionFileSchema, SectionCategory, SectionCategorySchema, SilkChangesetPreset, SilkChangesetTransformPreset, SilkChangesetsRules$1 as SilkChangesetsRules, UncategorizedContentRule$2 as UncategorizedContentRule, UrlOrMarkdownLinkSchema, UsernameSchema, VERSION_RE, VersionFileConfig, VersionFileConfigSchema, VersionFileError, VersionFileErrorBase, VersionFileUpdate, VersionFileUpdateRecordSchema, VersionFiles, VersionFilesSchema, VersionOrEmptySchema, VersionType, VersionTypeSchema, WorkspaceDependencyDiff, WorkspaceSnapshot, WorkspaceSnapshotReader, WorkspaceSnapshotReaderBase, WorkspaceSnapshotReaderLive, WorkspaceSnapshotReaderShape, WorkspaceVersion, changelogFunctions, computeWorkspaceDependencyDiffs, gitMergeBase, isPureDependencyChangeset, listPublishablePackageNames, makeBranchAnalyzerTest, makeConfigInspectorTest, makeGitHubTest, makeReleasePlannerTest, resolveDiffRows, serializeDependencyTableToMarkdown, snapshotFromWorktree };
+  export { AggregateDependencyTablesPlugin, AppliedRelease, AppliedReleaseEntrySchema, AppliedReleaseSchema, BranchAnalysis, BranchAnalysisSchema, BranchAnalyzer, BranchAnalyzerBase, BranchAnalyzerLive, BranchAnalyzerShape, BranchFileEntry, BranchFileEntrySchema, BumpType, BumpTypeSchema, Categories, Changelog, ChangelogService, ChangelogServiceBase, ChangelogServiceShape, ChangelogTransformer, Changeset, ChangesetIOError, ChangesetIOErrorBase, ChangesetLinter, ChangesetOptions, ChangesetOptionsSchema, ChangesetPreview, ChangesetPreviewSchema, ChangesetSchema, ChangesetSummarySchema, ChangesetValidationError, ChangesetValidationErrorBase, Classification, ClassificationReason, ClassificationReasonSchema, ClassificationSchema, CommitHashSchema, ConfigInspector, ConfigInspectorBase, ConfigInspectorLive, ConfigInspectorShape, ConfigurationError, ConfigurationErrorBase, ContentStructureRule$2 as ContentStructureRule, ContributorFootnotesPlugin, DeduplicateItemsPlugin, DependencyAction, DependencyActionSchema, DependencyTable, DependencyTableFormatRule$2 as DependencyTableFormatRule, DependencyTableRow, DependencyTableRowSchema, DependencyTableSchema, DependencyTableType, DependencyTableTypeSchema, DependencyType, DependencyTypeSchema, DependencyUpdate, DependencyUpdateSchema, DepsRegen, DepsRegenBase, DepsRegenDefault, DepsRegenLive, DepsRegenOptions, DepsRegenShape, FileStatus, FileStatusSchema, GitError, GitErrorBase, GitHubApiError, GitHubApiErrorBase, GitHubCommitInfo, GitHubInfo, GitHubInfoSchema, GitHubLive, GitHubService, GitHubServiceBase, GitHubServiceShape, GlobSchema, HeadingHierarchyRule$2 as HeadingHierarchyRule, InspectedConfig, InspectedConfigSchema, IssueLinkRefsPlugin, IssueNumberSchema, JsonPathSchema, LegacyVersionFileConfig, LegacyVersionFileConfigSchema, LegacyVersionFilesSchema, LintMessage, MarkdownLive, MarkdownParseError, MarkdownParseErrorBase, MarkdownService, MarkdownServiceBase, MarkdownServiceShape, ContentStructureRule$1 as MarkdownlintContentStructureRule, DependencyTableFormatRule$1 as MarkdownlintDependencyTableFormatRule, HeadingHierarchyRule$1 as MarkdownlintHeadingHierarchyRule, RequiredSectionsRule$1 as MarkdownlintRequiredSectionsRule, UncategorizedContentRule$1 as MarkdownlintUncategorizedContentRule, MergeSectionsPlugin, NonEmptyString, NormalizeFormatPlugin, PackageScope, PackageScopeSchema, PackagesRecordSchema, PendingChangeset, PendingChangesetSchema, PositiveInteger, PreviewRelease, PreviewReleaseSchema, RegenPlan, RegenResult, ReleasePlanError, ReleasePlanErrorBase, ReleasePlanner, ReleasePlannerBase, ReleasePlannerLive, ReleasePlannerShape, ReorderSectionsPlugin, RepoSchema, RequiredSectionsRule$2 as RequiredSectionsRule, ResolvedPackageScope, ResolvedPackageScopeSchema, ResolvedVersionFile, ResolvedVersionFileSchema, SectionCategory, SectionCategorySchema, SilkChangesetPreset, SilkChangesetTransformPreset, SilkChangesetsRules$1 as SilkChangesetsRules, UncategorizedContentRule$2 as UncategorizedContentRule, UrlOrMarkdownLinkSchema, UsernameSchema, VERSION_RE, VersionFileConfig, VersionFileConfigSchema, VersionFileError, VersionFileErrorBase, VersionFileUpdate, VersionFileUpdateRecordSchema, VersionFiles, VersionFilesSchema, VersionOrEmptySchema, VersionType, VersionTypeSchema, WorkspaceDependencyDiff, WorkspaceVersion, changelogFunctions, computeWorkspaceDependencyDiffs, gitMergeBase, isPureDependencyChangeset, listPublishablePackageNames, makeBranchAnalyzerTest, makeConfigInspectorTest, makeGitHubTest, makeReleasePlannerTest, serializeDependencyTableToMarkdown };
 } //#endregion
 //#region src/commitlint/config/schema.d.ts
 /**