import { Git, GitCommandError, NotARepositoryError, UnknownRefError } from "@effected/git";
import { Context, Effect, FileSystem, Layer, Option, Path, Schema } from "effect";
import { CatalogAssemblyError, CatalogResolver, DependencyResolutionError, Manifest, PartialReleaseAgeGate, ReleaseAgeGate, UnresolvedDependencyError, WorkspaceResolver } from "@effected/npm";
import { GlobPattern } from "@effected/glob";
import { Lockfile, LockfileFramingError, LockfileIntegrity, LockfileParseError, ResolvedPackage, WorkspaceManifest } from "@effected/lockfiles";
import { Package } from "@effected/package-json";
import { ChildProcessSpawner } from "effect/unstable/process";
import { LocalExec } from "@effected/commands";
//#region src/WorkspacePackage.d.ts
declare const PublishConfig_base: Schema.Class<PublishConfig, Schema.Struct<{
  /** Scoped-package visibility. Its presence overrides `private`. */
  readonly access: Schema.optionalKey<Schema.Literals<readonly ["public", "restricted"]>>;
  /** The registry to publish to. */
  readonly registry: Schema.optionalKey<Schema.String>;
  /** A subdirectory to publish instead of the package root. */
  readonly directory: Schema.optionalKey<Schema.String>;
  /**
   * Whether workspace links point into `directory` during local development —
   * pnpm symlinks the publish directory instead of the package root, so
   * siblings resolve the built artifact they would install from the registry.
   * Meaningful only alongside `directory`.
   */
  readonly linkDirectory: Schema.optionalKey<Schema.Boolean>;
  /** The dist-tag to publish under. */
  readonly tag: Schema.optionalKey<Schema.String>;
}>, {}>;
/**
 * The `publishConfig` fields workspace tooling reads.
 *
 * @remarks
 * Deliberately narrow. `@effected/package-json` models `publishConfig` as an
 * open `Record<string, unknown>` for round-trip fidelity, which preserves every
 * key but types none of them; this is the typed projection of the handful that
 * decide *where, whether and as what* a package publishes. Unknown keys are
 * ignored, not rejected.
 *
 * @public
 */
declare class PublishConfig extends PublishConfig_base {}
/**
 * The result of comparing two {@link WorkspacePackage} dependency snapshots.
 *
 * @remarks
 * Comparison runs across all four dependency kinds combined, so a dependency
 * that moves between kinds at the same version does not appear in the diff.
 *
 * @public
 */
interface DependencyDiff {
  /** Present in the receiver, absent from the other. */
  readonly added: Record<string, string>;
  /** Present in the other, absent from the receiver. */
  readonly removed: Record<string, string>;
  /** Present in both at different specifiers. */
  readonly changed: Record<string, {
    readonly from: string;
    readonly to: string;
  }>;
}
declare const WorkspaceManifestError_base: Schema.Class<WorkspaceManifestError, Schema.TaggedStruct<"WorkspaceManifestError", {
  /** Absolute path to the `package.json` that failed. */
  readonly packageJsonPath: Schema.String;
  /** Whether the file could not be read, or read but not decoded. */
  readonly kind: Schema.Literals<readonly ["read", "decode"]>;
  /** The originating failure, preserved rather than flattened to a string. */
  readonly cause: Schema.Defect;
}>, import("effect/Cause").YieldableError>;
/**
 * Raised when a workspace member's `package.json` cannot be read or decoded
 * into the strict `@effected/package-json` `Package` model.
 *
 * @remarks
 * Discovery itself never raises this — it uses the tolerant projection. Only
 * `WorkspacePackage.manifest` does, so opting into the strict model is an
 * explicit, individually recoverable step.
 *
 * @public
 */
declare class WorkspaceManifestError extends WorkspaceManifestError_base {
  /** Renders the path and failure kind into a one-line message. */
  get message(): string;
}
declare const WorkspacePackage_base: Schema.Class<WorkspacePackage, Schema.Struct<{
  /** The package name. */
  readonly name: Schema.NonEmptyString;
  /** The raw `version` string — deliberately not semver-validated. */
  readonly version: Schema.String;
  /** Absolute path to the package directory. */
  readonly path: Schema.NonEmptyString;
  /** Absolute path to the package's `package.json`. */
  readonly packageJsonPath: Schema.NonEmptyString;
  /** POSIX path relative to the workspace root; `"."` for the root package. */
  readonly relativePath: Schema.String;
  /**
   * Absolute path to the workspace root this package was discovered under.
   *
   * @remarks
   * Carried, not derived. Whoever built this value already knew the root —
   * `WorkspaceDiscovery` resolved it before enumerating, and the sync entry
   * point is handed it — so dropping it forced every consumer into per-package
   * root arithmetic (counting `relativePath` segments and re-ascending that
   * many `..`). That reconstruction is exact only while `path` and
   * `relativePath` agree, and it re-derives something the kit never had to
   * lose.
   *
   * For the root package this equals `path`, and `relativePath` is `"."`.
   */
  readonly workspaceRoot: Schema.NonEmptyString;
  /** Whether the package is marked private. */
  readonly private: Schema.withConstructorDefault<Schema.withDecodingDefaultKey<Schema.Boolean, never>>;
  /** Production dependencies. */
  readonly dependencies: Schema.withConstructorDefault<Schema.withDecodingDefaultKey<Schema.$Record<Schema.String, Schema.String>, never>>;
  /** Development dependencies. */
  readonly devDependencies: Schema.withConstructorDefault<Schema.withDecodingDefaultKey<Schema.$Record<Schema.String, Schema.String>, never>>;
  /** Peer dependencies. */
  readonly peerDependencies: Schema.withConstructorDefault<Schema.withDecodingDefaultKey<Schema.$Record<Schema.String, Schema.String>, never>>;
  /** Optional dependencies. */
  readonly optionalDependencies: Schema.withConstructorDefault<Schema.withDecodingDefaultKey<Schema.$Record<Schema.String, Schema.String>, never>>;
  /** The `publishConfig` block, when present. */
  readonly publishConfig: Schema.optionalKey<typeof PublishConfig>;
  /**
   * The package's `package.json` as read — tolerant access to every field
   * outside the typed discovery slice (`scripts`, `exports`, …) without a
   * second file read.
   *
   * @remarks
   * Values are `unknown` and exactly what discovery parsed; nothing here is
   * validated beyond being a record. For the strict typed model use
   * `manifest()`, which deliberately **re-reads** the file — a point-in-time
   * refresh this captured record cannot provide. Defaults to `{}` for
   * construction sites and previously-serialized values that predate the
   * field.
   */
  readonly manifestRecord: Schema.withConstructorDefault<Schema.withDecodingDefaultKey<Schema.$Record<Schema.String, Schema.Unknown>, never>>;
}>, {}>;
/**
 * A single package inside a workspace: the discovery-relevant slice of its
 * `package.json` plus its filesystem location.
 *
 * @remarks
 * Produced by `WorkspaceDiscovery` for every directory the `packages:` patterns
 * enumerate. The root package is always present with `relativePath` `"."`.
 *
 * @example
 * ```ts
 * import { WorkspacePackage } from "@effected/workspaces";
 *
 * const pkg = WorkspacePackage.make({
 *   name: "@my-org/utils",
 *   version: "1.0.0",
 *   path: "/repo/packages/utils",
 *   packageJsonPath: "/repo/packages/utils/package.json",
 *   relativePath: "packages/utils",
 *   workspaceRoot: "/repo",
 * });
 *
 * pkg.isRootWorkspace; // false
 * pkg.unscopedName;    // "utils"
 * pkg.workspaceRoot;   // "/repo"
 * ```
 *
 * @public
 */
declare class WorkspacePackage extends WorkspacePackage_base {
  /** Whether this is the workspace root package. */
  get isRootWorkspace(): boolean;
  /** Whether the package is publishable in principle (not marked private). */
  get isPublic(): boolean;
  /** The npm scope (`@org`), or `Option.none()` for an unscoped name. */
  get scope(): Option.Option<string>;
  /** The name with any scope stripped. */
  get unscopedName(): string;
  /**
   * Every dependency, merged across the four kinds.
   *
   * @remarks
   * Precedence on a name declared in several kinds runs
   * `dependencies` \> `devDependencies` \> `peerDependencies` \>
   * `optionalDependencies`.
   */
  get allDependencies(): Record<string, string>;
  /** Whether `name` is a production dependency. */
  hasDependency(name: string): boolean;
  /** Whether `name` is a development dependency. */
  hasDevDependency(name: string): boolean;
  /** Whether `name` is a peer dependency. */
  hasPeerDependency(name: string): boolean;
  /** Whether `name` is an optional dependency. */
  hasOptionalDependency(name: string): boolean;
  /** Whether `name` appears in any of the four dependency kinds. */
  hasAnyDependencyOn(name: string): boolean;
  /** The declared specifier for `name`, searched across all four kinds. */
  dependencyVersion(name: string): Option.Option<string>;
  /**
   * Whether any dependency name matches `pattern` — the `minimatch` runtime
   * dependency's one call site, now over `@effected/glob`'s vendored engine.
   *
   * @remarks
   * A `GlobPattern` is total and free to test. A `string` is compiled on every
   * call and an **uncompilable** literal throws: a glob written into a call
   * site is developer wiring, not untrusted input, so it belongs in the defect
   * channel rather than widening the typed channel every caller must branch
   * on. Compile once with `GlobPattern.compile` and pass the result when
   * testing many packages.
   *
   * @param pattern - A compiled pattern, or a source string to compile.
   */
  matchesDependency(pattern: GlobPattern | string): boolean;
  /** Compare this package's dependencies against `other`'s. */
  dependencyDiff(other: WorkspacePackage): DependencyDiff;
  /**
   * Project to `@effected/lockfiles`' `WorkspaceManifest` — the input shape of
   * `LockfileIntegrity.compare`. Total.
   */
  toWorkspaceManifest(): WorkspaceManifest;
  /**
   * Read and decode this package's `package.json` into the strict
   * `@effected/package-json` `Package` model — the bridge from the
   * tolerant discovery projection to the fully typed manifest.
   */
  static readonly manifest: (self: WorkspacePackage) => Effect.Effect<Package, WorkspaceManifestError, FileSystem.FileSystem>;
  /** Instance form of `WorkspacePackage.manifest`. */
  manifest(): Effect.Effect<Package, WorkspaceManifestError, FileSystem.FileSystem>;
}
//#endregion
//#region src/WorkspaceRoot.d.ts
/**
 * The marker filenames {@link WorkspaceRoot} probes for, in priority order.
 *
 * @public
 */
declare const WORKSPACE_MARKERS: ReadonlyArray<string>;
/**
 * Options for {@link WorkspaceRoot}'s `find`.
 *
 * @remarks
 * Both bounds are passed straight through to `@effected/walker`'s
 * `Walker.ascend`; this package does not re-decide either.
 *
 * @public
 */
interface FindWorkspaceRootOptions {
  /**
   * A ceiling directory. The ascent stops after probing it, so an unmarked
   * `stopAt` fails typed as {@link WorkspaceRootNotFoundError} rather than
   * silently escaping into an enclosing repository.
   *
   * @remarks
   * Resolved to an absolute path before comparison, exactly as `cwd` is — a
   * relative or non-normalized ceiling that never string-matched an ancestor
   * would reintroduce the unbounded ascent it was passed to prevent.
   */
  readonly stopAt?: string;
  /**
   * Hard cap on the number of directories probed.
   *
   * @remarks
   * A non-integer or non-positive value is a **defect**, not a typed failure —
   * it is developer wiring, and walker's guard raises it.
   *
   * @defaultValue 256
   */
  readonly maxDepth?: number;
}
declare const WorkspaceRootNotFoundError_base: Schema.Class<WorkspaceRootNotFoundError, Schema.TaggedStruct<"WorkspaceRootNotFoundError", {
  /** The directory the ascent started from. */
  readonly searchPath: Schema.String;
  /** The marker filenames probed at each ancestor. */
  readonly markers: Schema.$Array<Schema.String>;
  /**
   * The resolved ceiling the ascent was bounded by, when one was supplied.
   *
   * @remarks
   * Absent means the ascent ran to the filesystem root. Its presence is what
   * lets a caller tell "there is no workspace root anywhere above me" from
   * "there is none below the ceiling I set" — two failures that otherwise
   * render identically.
   */
  readonly stopAt: Schema.optionalKey<Schema.String>;
}>, import("effect/Cause").YieldableError>;
/**
 * Raised when no workspace root can be found by ascending from a directory.
 *
 * @remarks
 * `markers` records what was probed, so the failure names the contract rather
 * than paraphrasing it in prose.
 *
 * @public
 */
declare class WorkspaceRootNotFoundError extends WorkspaceRootNotFoundError_base {
  /** Renders the search path, probed markers and any ceiling into a one-line message. */
  get message(): string;
}
/**
 * The {@link WorkspaceRoot} service contract.
 *
 * @remarks
 * Named so a consumer can type its own double — or a `Layer.succeed` — against
 * the contract rather than re-deriving it, exactly as `WorkspaceDiscoveryShape`
 * does. Prefer {@link WorkspaceRoot.layerTest} to hand-rolling one.
 *
 * @public
 */
interface WorkspaceRootShape {
  /**
   * The nearest workspace root at or above `cwd`.
   *
   * @param cwd - The directory to start the ascent from; resolved to an
   *   absolute path first.
   * @param options - Optional ascent bounds. Unbounded by default, which
   *   walks to the filesystem root and can therefore resolve to an enclosing
   *   repository's root; pass `stopAt` when the caller knows the ceiling.
   */
  readonly find: (cwd: string, options?: FindWorkspaceRootOptions) => Effect.Effect<string, WorkspaceRootNotFoundError>;
}
declare const WorkspaceRoot_base: Context.ServiceClass<WorkspaceRoot, "@effected/workspaces/WorkspaceRoot", WorkspaceRootShape>;
/**
 * Locates the workspace root by ascending from a starting directory.
 *
 * @example
 * ```ts
 * import { WorkspaceRoot } from "@effected/workspaces";
 * import { Effect } from "effect";
 *
 * const program = Effect.gen(function* () {
 *   const root = yield* WorkspaceRoot;
 *   return yield* root.find("/repo/packages/utils/src");
 * });
 * ```
 *
 * @example
 * Bounded: an unmarked fixture directory fails typed instead of escaping into
 * the enclosing repository.
 *
 * ```ts
 * import { WorkspaceRoot } from "@effected/workspaces";
 * import { Effect } from "effect";
 *
 * const program = Effect.gen(function* () {
 *   const roots = yield* WorkspaceRoot;
 *   return yield* roots.find("/tmp/fixture/packages/a", { stopAt: "/tmp/fixture" });
 * });
 * ```
 *
 * @public
 */
declare class WorkspaceRoot extends WorkspaceRoot_base {
  /** Builds the service over core `FileSystem` and `Path`. */
  static readonly make: Effect.Effect<WorkspaceRootShape, never, FileSystem.FileSystem | Path.Path>;
  /** The live layer. */
  static readonly layer: Layer.Layer<WorkspaceRoot, never, FileSystem.FileSystem | Path.Path>;
  /**
   * A test double resolving every `find` to `root`, with no filesystem.
   *
   * @remarks
   * The nine-copies-of-a-four-line-mock case — a `Layer.succeed` over a `find`
   * that ignores its arguments and succeeds with a fixed root is what consumers
   * were writing by hand. The difference is that this double **honours
   * `stopAt`**: a hand-rolled `find` that ignores the ceiling makes a bounded
   * call pass under test and fail against the live service, which is the
   * failure mode the option exists to catch. A `root` above the ceiling fails
   * here exactly as it would live, with the same
   * {@link WorkspaceRootNotFoundError}.
   *
   * The ceiling is `path.resolve`d through the injected `Path` service before
   * the comparison, exactly as the live `make` path does — so a `stopAt`
   * carrying `..` segments bounds the double identically to the live service,
   * not by raw string. This is why `makeTest` yields an `Effect` requiring
   * `Path`: it captures the service once at construction, the same shape as
   * `make`. Consumers reach for {@link WorkspaceRoot.layerTest}, which provides
   * `Path.layer` internally, so the requirement never surfaces at their call
   * site.
   *
   * `maxDepth` is deliberately NOT modelled: the double does not walk, so it has
   * no depth to cap, and pretending otherwise would encode a fiction. A suite
   * exercising the depth guard wants the live service over a fixture tree.
   *
   * @param root - The root every unbounded `find` resolves to.
   */
  static readonly makeTest: (root: string) => Effect.Effect<WorkspaceRootShape, never, Path.Path>;
  /**
   * The test layer: {@link WorkspaceRoot.makeTest} with `Path.layer` provided.
   *
   * @remarks
   * `makeTest` requires `Path` to normalize the `stopAt` ceiling; this layer
   * supplies core's `Path.layer` internally, so the requirement never reaches a
   * consumer — the published type stays `Layer.Layer<WorkspaceRoot>`.
   *
   * A parameterized layer factory mints a **fresh reference per call**, and
   * layers memoize by reference — bind the result to a `const` and reuse it
   * rather than calling `layerTest(...)` at each composition site.
   *
   * Pair it with `WorkspaceDiscovery.layerTest` to stand up the whole discovery
   * path without a filesystem; between them there is nothing left for a
   * module-level mock of `@effected/workspaces` to do, and a provided layer
   * keeps the service graph — and its typed errors — intact.
   *
   * @example
   * ```ts
   * import { WorkspaceDiscovery, WorkspaceRoot } from "@effected/workspaces";
   * import { Effect } from "effect";
   *
   * const TestRoot = WorkspaceRoot.layerTest("/repo");
   * const TestDiscovery = WorkspaceDiscovery.layerTest({
   *   listPackages: () => Effect.succeed([]),
   * });
   * // program.pipe(Effect.provide(TestRoot), Effect.provide(TestDiscovery))
   * ```
   */
  static readonly layerTest: (root: string) => Layer.Layer<WorkspaceRoot>;
}
//#endregion
//#region src/WorkspaceDiscovery.d.ts
declare const WorkspaceDiscoveryError_base: Schema.Class<WorkspaceDiscoveryError, Schema.TaggedStruct<"WorkspaceDiscoveryError", {
  /** The workspace root discovery was running against. */
  readonly root: Schema.String;
  /** The file that failed. */
  readonly path: Schema.String;
  /** What went wrong with it. */
  readonly kind: Schema.Literals<readonly ["read", "invalidJson", "invalidShape", "invalidYaml", "missingName", "missingVersion"]>;
  /** The originating failure, if there was one. */
  readonly cause: Schema.Defect;
}>, import("effect/Cause").YieldableError>;
/**
 * Raised when a workspace member's `package.json` cannot be read, parsed, or
 * used — it is missing, malformed, or lacks a `name` or `version`.
 *
 * @remarks
 * `kind` is the discriminant a caller branches on; `cause` preserves the
 * originating failure rather than flattening it into a sentence.
 *
 * @public
 */
declare class WorkspaceDiscoveryError extends WorkspaceDiscoveryError_base {
  /** Renders the failing file and kind into a one-line message. */
  get message(): string;
}
declare const WorkspacePatternError_base: Schema.Class<WorkspacePatternError, Schema.TaggedStruct<"WorkspacePatternError", {
  /** The workspace root the patterns were expanded against. */
  readonly root: Schema.String;
  /** The offending pattern, verbatim. */
  readonly pattern: Schema.String;
  /** Why it could not be enumerated. */
  readonly kind: Schema.Literals<readonly ["missingBaseDir", "uncompilable", "depthExceeded", "budgetExceeded", "unreadableDirectory"]>;
  /** A short, structured detail — the missing directory, or the bound exceeded. */
  readonly detail: Schema.String;
}>, import("effect/Cause").YieldableError>;
/**
 * Raised when a `packages:` pattern cannot be enumerated: its base directory is
 * absent (usually a typo), the descent exceeded its depth cap, or the visit
 * budget was exhausted.
 *
 * @public
 */
declare class WorkspacePatternError extends WorkspacePatternError_base {
  /** Renders the pattern and failure kind into a one-line message. */
  get message(): string;
}
declare const PackageNotFoundError_base: Schema.Class<PackageNotFoundError, Schema.TaggedStruct<"PackageNotFoundError", {
  /** The name that was requested. */
  readonly name: Schema.String;
  /** Every workspace package name that does exist. */
  readonly available: Schema.$Array<Schema.String>;
}>, import("effect/Cause").YieldableError>;
/**
 * Raised when a workspace package is requested by a name no member carries.
 *
 * @remarks
 * `available` lists every known member, which is what makes the error
 * actionable — a typo is obvious next to the list it missed.
 *
 * @public
 */
declare class PackageNotFoundError extends PackageNotFoundError_base {
  /** Renders the requested name into a one-line message. */
  get message(): string;
}
declare const WorkspaceInfo_base: Schema.Class<WorkspaceInfo, Schema.Struct<{
  /** Absolute path to the workspace root. */
  readonly root: Schema.String;
  /** The `packages:` patterns, verbatim. */
  readonly patterns: Schema.$Array<Schema.String>;
}>, {}>;
/**
 * Top-level facts about a workspace: where it is, what manages it, and the
 * patterns that define its membership.
 *
 * @public
 */
declare class WorkspaceInfo extends WorkspaceInfo_base {}
/**
 * Every failure `WorkspaceDiscovery.getPackage` can surface: the discovery
 * failures plus a name that matches no member.
 *
 * @public
 */
type WorkspaceLookupFailure = WorkspaceRootNotFoundError | WorkspaceDiscoveryError | WorkspacePatternError | PackageNotFoundError;
/**
 * The error channel of the discovery methods that do not look a package up by
 * name — everything except `getPackage`.
 *
 * @public
 */
type WorkspaceDiscoveryFailure = Exclude<WorkspaceLookupFailure, PackageNotFoundError>;
/**
 * Options for the {@link WorkspaceDiscovery} layer.
 *
 * @public
 */
interface WorkspaceDiscoveryOptions {
  /**
   * The directory the workspace root is resolved from.
   *
   * @defaultValue `process.cwd()`, read lazily on first use — so a
   *   `process.chdir` between providing the layer and the first call is
   *   honoured.
   */
  readonly cwd?: string;
  /** Descent cap for segment-crossing patterns. Defaults to 32. */
  readonly maxDepth?: number;
}
/**
 * The {@link WorkspaceDiscovery} service shape.
 *
 * @public
 */
interface WorkspaceDiscoveryShape {
  /** Facts about the resolved workspace. */
  readonly info: () => Effect.Effect<WorkspaceInfo, WorkspaceDiscoveryFailure>;
  /** Every workspace package, root first, then the rest sorted by relative path. */
  readonly listPackages: () => Effect.Effect<ReadonlyArray<WorkspacePackage>, WorkspaceDiscoveryFailure>;
  /** The discovered packages keyed by their root-relative importer path. */
  readonly importerMap: () => Effect.Effect<ReadonlyMap<string, WorkspacePackage>, WorkspaceDiscoveryFailure>;
  /** A single package by name. */
  readonly getPackage: (name: string) => Effect.Effect<WorkspacePackage, WorkspaceLookupFailure>;
  /** The package owning an absolute file path, by longest-prefix match. */
  readonly resolveFile: (filePath: string) => Effect.Effect<Option.Option<WorkspacePackage>, WorkspaceDiscoveryFailure>;
  /** The distinct packages owning any of `filePaths`. */
  readonly resolveFiles: (filePaths: ReadonlyArray<string>) => Effect.Effect<ReadonlyArray<WorkspacePackage>, WorkspaceDiscoveryFailure>;
  /**
   * Facts about the workspace containing `directory`, discovered against THAT
   * root rather than the layer-bound one.
   */
  readonly infoIn: (directory: string) => Effect.Effect<WorkspaceInfo, WorkspaceDiscoveryFailure>;
  /**
   * Every package of the workspace containing `directory`, discovered against
   * THAT root rather than the layer-bound one.
   *
   * @remarks
   * For a **long-lived host serving many roots** — an MCP server or a language
   * server that resolves one workspace at startup and then answers calls
   * scoped to a git worktree, a nested repository, or another project
   * entirely. The layer-bound {@link WorkspaceDiscoveryShape.listPackages}
   * answers about the root discovered from `options.cwd`, which such a host
   * has no way to vary per call without building a fresh layer.
   *
   * **This re-reads; it does not re-root.** The tempting cheap fix — take the
   * layer's package list and rewrite each `path` onto the caller's directory —
   * produces correct-looking paths over the ORIGINAL root's manifests, so a
   * worktree whose branch adds, removes or renames a package reports the other
   * branch's membership with no error. Patterns, member manifests, names and
   * versions all come from beneath `directory`'s own root here.
   *
   * `directory` may be the workspace root or anything inside it: the root is
   * resolved by the same upward walk the layer-bound path uses, and results are
   * memoized per RESOLVED root, so many directories in one workspace share one
   * discovery. The memo holds one entry per distinct root for the layer's
   * lifetime; {@link WorkspaceDiscoveryShape.refresh} drops all of them.
   *
   * @param directory - Absolute path to the workspace root, or to any
   *   directory inside it.
   */
  readonly listPackagesIn: (directory: string) => Effect.Effect<ReadonlyArray<WorkspacePackage>, WorkspaceDiscoveryFailure>;
  /**
   * Drop every memoized discovery — the layer-bound one and each per-root memo
   * — so the next call re-reads the filesystem.
   */
  readonly refresh: () => Effect.Effect<void>;
  /**
   * Drop only the memo for the workspace containing `directory`, leaving the
   * layer-bound memo and every other root's untouched.
   *
   * @remarks
   * The precise counterpart to {@link WorkspaceDiscoveryShape.refresh} for a
   * host serving several roots: refreshing one worktree because it changed
   * should not discard sibling worktrees that did not, which is all `refresh`
   * can do.
   *
   * **Fails typed on a directory in no workspace**, exactly as
   * {@link WorkspaceDiscoveryShape.listPackagesIn} does for the same input —
   * the three per-root methods answer a bad path the same way, and a caller
   * that would rather treat it as a no-op writes `Effect.ignore`. Refreshing a
   * root that HAS no memo is an ordinary no-op and not an error.
   *
   * @param directory - Absolute path to the workspace root, or to any
   *   directory inside it.
   */
  readonly refreshIn: (directory: string) => Effect.Effect<void, WorkspaceRootNotFoundError>;
}
declare const WorkspaceDiscovery_base: Context.ServiceClass<WorkspaceDiscovery, "@effected/workspaces/WorkspaceDiscovery", WorkspaceDiscoveryShape>;
/**
 * Discovers the packages of a workspace.
 *
 * @remarks
 * Layer construction is O(1): the root walk, pattern read, enumeration and
 * per-package decode all happen on the first method call and are memoized for
 * the lifetime of the layer. A Vitest reporter that builds the layer per call
 * site and never queries it pays nothing.
 *
 * The memo is **success-only**. `Effect.cached` memoizes the first `Exit`,
 * *including an interrupt* — an init interrupted by an unrelated timeout would
 * otherwise brick the layer permanently with a cause outside its declared error
 * channel. A failure or interrupt is therefore retried on the next call, which
 * is a deliberate behaviour change from the v3 library.
 *
 * @example
 * ```ts
 * import { WorkspaceDiscovery } from "@effected/workspaces";
 * import { Effect } from "effect";
 *
 * const program = Effect.gen(function* () {
 *   const discovery = yield* WorkspaceDiscovery;
 *   const packages = yield* discovery.listPackages();
 *   return packages.map((p) => p.name);
 * });
 * ```
 *
 * @public
 */
declare class WorkspaceDiscovery extends WorkspaceDiscovery_base {
  /**
   * Builds the service. Root resolution is one explicit concern: `cwd` is an
   * option here, never an ambient `process.cwd()` read inside a method.
   */
  static readonly make: (options?: WorkspaceDiscoveryOptions) => Effect.Effect<WorkspaceDiscoveryShape, never, WorkspaceRoot | FileSystem.FileSystem | Path.Path>;
  /**
   * The live layer.
   *
   * @remarks
   * A parameterized layer factory mints a **fresh reference per call**, and
   * layers memoize by reference — bind the result to a `const` and reuse it
   * rather than calling `layer(...)` at each composition site.
   */
  static readonly layer: (options?: WorkspaceDiscoveryOptions) => Layer.Layer<WorkspaceDiscovery, never, WorkspaceRoot | FileSystem.FileSystem | Path.Path>;
  /**
   * An in-memory test double of the service shape, with every method
   * defaulted so a test stubs only what it exercises.
   *
   * @remarks
   * The defaults model an **empty workspace**, and the derived methods run
   * over the *effective* `listPackages` — the override when one is supplied —
   * so stubbing only `listPackages` yields a consistent double:
   *
   * - `listPackages` — succeeds with `[]`.
   * - `importerMap` — derived: the packages keyed by `relativePath`.
   * - `getPackage` — derived: a name lookup that fails with the service's own
   *   typed {@link PackageNotFoundError} on a miss, exactly as the live
   *   implementation does.
   * - `resolveFile` / `resolveFiles` — derived: longest-prefix ownership over
   *   `pkg.path`, POSIX-terminated (`"/"`); supply a win32 double explicitly
   *   if your fixture paths are win32.
   * - `refresh` — a no-op (`Effect.void`); there is nothing memoized to drop.
   * - `info` — **dies** with an explanatory defect. No honest default exists
   *   (a fabricated root path would leak into consumer path logic), so an
   *   unstubbed `info()` call is a test-wiring mistake and fails loudly as a
   *   defect rather than succeeding with a lie or failing with a dishonest
   *   typed error. A defect is not absorbed by `Effect.catch` or any
   *   typed-error handler — deliberately, so code under test with a
   *   best-effort `catch` cannot make the mandatory stub look optional; the
   *   unstubbed call still fails the test.
   *
   * @example
   * ```ts
   * import { WorkspaceDiscovery, WorkspacePackage } from "@effected/workspaces";
   * import { Effect } from "effect";
   *
   * const double = WorkspaceDiscovery.makeTest({
   *   listPackages: () =>
   *     Effect.succeed([
   *       WorkspacePackage.make({
   *         name: "@my-org/utils",
   *         version: "1.0.0",
   *         path: "/repo/packages/utils",
   *         packageJsonPath: "/repo/packages/utils/package.json",
   *         relativePath: "packages/utils",
   *         workspaceRoot: "/repo",
   *       }),
   *     ]),
   * });
   * // `getPackage`, `importerMap`, `resolveFile(s)` now answer consistently.
   * ```
   */
  static readonly makeTest: (overrides?: Partial<WorkspaceDiscoveryShape>) => WorkspaceDiscoveryShape;
  /**
   * The test layer: {@link WorkspaceDiscovery.makeTest} behind
   * `Layer.succeed`, so a suite provides only the methods it exercises.
   *
   * @remarks
   * A parameterized layer factory mints a **fresh reference per call**, and
   * layers memoize by reference — bind the result to a `const` and reuse it
   * rather than calling `layerTest(...)` at each composition site.
   *
   * @example
   * ```ts
   * import { WorkspaceDiscovery } from "@effected/workspaces";
   * import { Effect } from "effect";
   *
   * const TestDiscovery = WorkspaceDiscovery.layerTest({
   *   listPackages: () => Effect.succeed([]),
   * });
   * // program.pipe(Effect.provide(TestDiscovery))
   * ```
   */
  static readonly layerTest: (overrides?: Partial<WorkspaceDiscoveryShape>) => Layer.Layer<WorkspaceDiscovery>;
  /**
   * The real implementation of `@effected/npm`'s `WorkspaceResolver` contract
   * — the one `@effected/package-json` declares but cannot fill.
   *
   * @remarks
   * `versionOf` returns `Option.none()` for a name that is not a workspace
   * member, per the contract's convention; the `DependencyResolutionError`
   * channel is reserved for a failure of the resolution *mechanism* (an
   * unfindable root, an unreadable manifest), never an ordinary miss.
   *
   * @example
   * ```ts
   * import { Package } from "@effected/package-json";
   * import { WorkspaceDiscovery } from "@effected/workspaces";
   * import { Layer } from "effect";
   *
   * const resolvers = WorkspaceDiscovery.workspaceResolver.pipe(
   *   Layer.provide(WorkspaceDiscovery.layer()),
   * );
   * // `Package.resolve` now resolves `workspace:*` for real.
   * ```
   */
  static readonly workspaceResolver: Layer.Layer<WorkspaceResolver, never, WorkspaceDiscovery>;
}
//#endregion
//#region src/ChangeDetector.d.ts
declare const ChangeDetectionOptions_base: Schema.Class<ChangeDetectionOptions, Schema.Struct<{
  /**
   * The ref to compare against.
   *
   * @defaultValue `"HEAD~1"`
   */
  readonly base: Schema.withConstructorDefault<Schema.withDecodingDefaultKey<Schema.String, never>>;
  /**
   * The ref to compare to.
   *
   * @defaultValue `"HEAD"`
   */
  readonly head: Schema.withConstructorDefault<Schema.withDecodingDefaultKey<Schema.String, never>>;
  /**
   * Whether to include staged, unstaged and untracked working-tree changes on
   * top of the committed range.
   *
   * @defaultValue `false`
   */
  readonly includeUncommitted: Schema.withConstructorDefault<Schema.withDecodingDefaultKey<Schema.Boolean, never>>;
}>, {}>;
/**
 * Which git refs to compare, and whether to fold in the working tree.
 *
 * @example
 * ```ts
 * import { ChangeDetectionOptions } from "@effected/workspaces";
 *
 * ChangeDetectionOptions.make({});                       // HEAD~1...HEAD
 * ChangeDetectionOptions.make({ base: "origin/main" });  // against a branch
 * ```
 *
 * @public
 */
declare class ChangeDetectionOptions extends ChangeDetectionOptions_base {}
declare const ChangeDetectionError_base: Schema.Class<ChangeDetectionError, Schema.TaggedStruct<"ChangeDetectionError", {
  /** The operation that could not run. */
  readonly operation: Schema.String;
  /** The originating failure. */
  readonly cause: Schema.Defect;
}>, import("effect/Cause").YieldableError>;
/**
 * Raised when change detection cannot proceed for a reason that is not one of
 * git's own typed failures — the wrapper for "detection has no ground to stand
 * on".
 *
 * @remarks
 * A git command that merely *fails* surfaces as one of `@effected/git`'s typed
 * errors ({@link ChangeDetectionFailure} carries `GitCommandError`,
 * `NotARepositoryError` and `UnknownRefError`) rather than being flattened into
 * this wrapper — a caller branches on git's taxonomy directly.
 *
 * @public
 */
declare class ChangeDetectionError extends ChangeDetectionError_base {
  /** Renders the failed operation into a one-line message. */
  get message(): string;
}
/**
 * Every failure the change-detection methods can surface.
 *
 * @remarks
 * `@effected/git`'s typed errors surface directly alongside
 * {@link ChangeDetectionError} and the discovery failures — a git command that
 * fails is reported as git classified it (`NotARepositoryError` for a
 * non-repository, `UnknownRefError` for a bad ref, `GitCommandError`
 * otherwise), not re-wrapped.
 *
 * @public
 */
type ChangeDetectionFailure = ChangeDetectionError | GitCommandError | NotARepositoryError | UnknownRefError | WorkspaceDiscoveryFailure;
/**
 * The {@link ChangeDetector} service shape.
 *
 * @public
 */
interface ChangeDetectorShape {
  /** The file paths (workspace-root-relative, as git reports them) changed in the range. */
  readonly changedFiles: (options?: ChangeDetectionOptions) => Effect.Effect<ReadonlyArray<string>, ChangeDetectionFailure>;
  /** The workspace packages owning those files. */
  readonly changedPackages: (options?: ChangeDetectionOptions) => Effect.Effect<ReadonlyArray<WorkspacePackage>, ChangeDetectionFailure>;
  /** Those packages plus every workspace package that transitively depends on one. */
  readonly affectedPackages: (options?: ChangeDetectionOptions) => Effect.Effect<ReadonlyArray<WorkspacePackage>, ChangeDetectionFailure>;
}
declare const ChangeDetector_base: Context.ServiceClass<ChangeDetector, "@effected/workspaces/ChangeDetector", ChangeDetectorShape>;
/**
 * Detects which workspace packages a git range touches.
 *
 * @remarks
 * Three depths on one service, cheapest first — raw file paths, the packages
 * owning them, and the transitive blast radius through the dependency graph.
 *
 * @example
 * ```ts
 * import { ChangeDetectionOptions, ChangeDetector } from "@effected/workspaces";
 * import { Effect } from "effect";
 *
 * const program = Effect.gen(function* () {
 *   const detector = yield* ChangeDetector;
 *   const affected = yield* detector.affectedPackages(
 *     ChangeDetectionOptions.make({ base: "origin/main" }),
 *   );
 *   return affected.map((pkg) => pkg.name);
 * });
 * ```
 *
 * @public
 */
declare class ChangeDetector extends ChangeDetector_base {
  /** Builds the service over `Git` and {@link WorkspaceDiscovery}. */
  static readonly make: Effect.Effect<ChangeDetectorShape, never, Git | WorkspaceDiscovery>;
  /** The live layer. */
  static readonly layer: Layer.Layer<ChangeDetector, never, Git | WorkspaceDiscovery>;
}
//#endregion
//#region src/ConfigDependencyHooks.d.ts
/**
 * pnpm's `peerDependencyRules` block — the suppression policy pnpm applies
 * **after** computing peer violations, in pnpm's own shape.
 *
 * @remarks
 * The shape is pnpm's rather than ours because that is what comes back off the
 * threaded config: measured against `@savvy-web/pnpm-plugin-silk@0.27.0`, a
 * replayed hook returns `{ allowedVersions, ignoreMissing, allowAny }` intact,
 * needing no reshaping.
 *
 * Two keys are **carried but not yet consumed**. `ignoreMissing` and
 * `allowAny` are separate suppression axes that have not been measured, and an
 * unmeasured suppression is precisely what produced the false positives this
 * seam exists to remove — so they travel through the seam and no kit code acts
 * on them. Only `allowedVersions` is consumed today.
 *
 * `allowedVersions` keys come in two spellings in the wild, and both must be
 * handled: parent-versioned (`"@effect/ai-anthropic@4.0.0-rc.109>effect"`, as
 * `pnpm:export` materializes them into `pnpm-workspace.yaml`) and unversioned
 * (`"@effect/vitest>vitest"`, as a config-dependency plugin injects them).
 *
 * @public
 */
interface PeerDependencyRules {
  /** `parent>peer` → the peer version or range the rule permits. */
  readonly allowedVersions: Readonly<Record<string, string>>;
  /** Peer names whose absence pnpm does not report. Carried, not consumed. */
  readonly ignoreMissing: ReadonlyArray<string>;
  /** Peer names for which any version is accepted. Carried, not consumed. */
  readonly allowAny: ReadonlyArray<string>;
}
/**
 * The empty {@link PeerDependencyRules}: every axis present and empty.
 *
 * @remarks
 * Exported so that "I assert this workspace's rules are empty" is **one token**
 * rather than three hand-written empty axes. That matters where the distinction
 * is load-bearing — supplying rules asserts they were looked up, while omitting
 * them asserts nothing — and a caller spelling the object out by hand will
 * eventually fill two of the three axes and mean the third.
 *
 * Frozen, since it is shared.
 *
 * @public
 */
declare const NoPeerDependencyRules: PeerDependencyRules;
/**
 * The result of replaying a workspace's `configDependencies` hooks: the catalogs
 * the hooks yield, and the release-age gate contribution they leave on the
 * config (pnpm's `minimumReleaseAge` / `minimumReleaseAgeExclude`).
 *
 * @remarks
 * `releaseAge` is a `PartialReleaseAgeGate` — the age, the exclude list,
 * both, or neither, depending on what the replayed hooks set. It is deliberately
 * a *partial* contribution: a consumer folds it into an effective gate with
 * `ReleaseAgeGate.combine` alongside inline `pnpm-workspace.yaml` values. Hooks
 * that set no release-age keys contribute an empty gate (`{}`).
 *
 * @public
 */
interface HookInjection {
  /** The catalogs the replayed hooks yield, as `catalog name → dependency → range`. */
  readonly catalogs: Readonly<Record<string, Readonly<Record<string, string>>>>;
  /** The release-age gate contribution the replayed hooks leave on the config. */
  readonly releaseAge: PartialReleaseAgeGate;
  /**
   * The **effective** peer-dependency rules: the seeded workspace-file rules
   * with every replayed hook's contribution threaded over them.
   *
   * @remarks
   * Effective rather than hook-only because the rules are **seeded** into the
   * threaded config and the hooks merge onto them, exactly as pnpm seeds its
   * own config and takes back what the hooks return. That is deliberate: a
   * kit-owned merge function would be a second implementation of a rule this
   * seam already enforces, and the two would drift the first time pnpm changed
   * its threading.
   *
   * Measured caveat, and **not a bug to fix**: this repo's plugin *merges*
   * onto the seeded rules; another plugin could overwrite them. Under seeding
   * that is pnpm's own behaviour reproduced — a hook that overwrites
   * overwrites for pnpm too — so do not "repair" it into a merger.
   */
  readonly peerDependencyRules: PeerDependencyRules;
}
/**
 * The {@link ConfigDependencyHooks} service shape.
 *
 * @remarks
 * `inject` is given the workspace root, the manifest's `configDependencies`
 * (name → version+integrity), and the inline-catalog seed as a plain
 * `catalog name → dependency name → range` record, and produces a
 * {@link HookInjection}: the catalogs the replayed hooks yield **and** the
 * release-age gate contribution they leave on the config. The default (no-op)
 * implementation returns the seed catalogs unchanged, contributes an empty
 * release-age gate, and loads nothing.
 *
 * @public
 */
interface ConfigDependencyHooksShape {
  /**
   * Replay each config dependency's `updateConfig` hook over `seed`, in
   * declaration order, and return both the resulting catalogs and the
   * release-age gate contribution the hooks leave behind.
   *
   * @remarks
   * The hooks are replayed once over a single threaded config object, exactly
   * as pnpm does — so catalogs and the release-age keys
   * (`minimumReleaseAge` / `minimumReleaseAgeExclude`) are both read off that
   * one final object, and the config-dependency code executes only once. When
   * two hooks both set a release-age key the **later hook wins** (it rewrites
   * the threaded value); a hook that returns a malformed value for a key leaves
   * the prior threaded value in place (tolerant threading, matching the catalog
   * slice). A hook failing to load or replay fails typed with a
   * `hooks`-source `CatalogAssemblyError`, never a silent skip.
   *
   * @param root - The workspace root; config dependencies resolve under
   *   `<root>/node_modules/.pnpm-config/<name>`.
   * @param configDependencies - The `configDependencies` map (name →
   *   version+integrity) declared in `pnpm-workspace.yaml`.
   * @param seed - The inline catalogs, as `catalog name → dependency → range`.
   * @param rules - The workspace file's `peerDependencyRules`, seeded into the
   *   threaded config so hooks merge onto them rather than replacing them.
   *   Omitted means "the workspace file declares none", which is different
   *   from "nobody looked" — the caller owns that distinction.
   */
  readonly inject: (root: string, configDependencies: Readonly<Record<string, string>>, seed: Readonly<Record<string, Readonly<Record<string, string>>>>, rules?: PeerDependencyRules) => Effect.Effect<HookInjection, CatalogAssemblyError>;
}
declare const ConfigDependencyHooks_base: Context.ServiceClass<ConfigDependencyHooks, "@effected/workspaces/ConfigDependencyHooks", ConfigDependencyHooksShape>;
/**
 * Replays a workspace's `configDependencies` `updateConfig` hooks over the inline
 * catalogs — the opt-in seam that lets hook-injected catalogs participate in
 * assembly.
 *
 * @remarks
 * A contract-only service: it declares the shape and ships two layers, never a
 * baked-in default. {@link ConfigDependencyHooks.layerNoop} executes no
 * config-dependency code (it returns the seed untouched) and is what the default
 * {@link WorkspaceCatalogs} layer wires; {@link ConfigDependencyHooks.layerLive}
 * dynamically imports each `pnpmfile.cjs` and replays it, and is wired only by the
 * explicit `WorkspaceCatalogs.layerWithConfigDependencies` opt-in.
 *
 * @public
 */
declare class ConfigDependencyHooks extends ConfigDependencyHooks_base {
  /**
   * The no-op layer: `inject` returns the seed unchanged and never touches a
   * config dependency. The default {@link WorkspaceCatalogs} layer wires this, so
   * the default catalog path provably executes no config-dependency code.
   */
  static readonly layerNoop: Layer.Layer<ConfigDependencyHooks>;
  /**
   * The live layer: dynamically imports each config dependency's `pnpmfile.cjs`
   * (in process, no subprocess) and replays its `updateConfig` hook over the
   * seed, in declaration order. A dependency without a `pnpmfile.cjs` contributes
   * nothing; a dependency whose file fails to load or replay fails typed with a
   * `hooks`-source `CatalogAssemblyError`, never a silent skip.
   *
   * @remarks
   * Runtime-coupled by design, not node-exclusive. The `import()` below loads
   * **and executes** a config dependency's pnpmfile in-process — code execution,
   * not IO, so no `FileSystem` / `Path` service abstracts it. The `node:path` and
   * `node:url` imports (`join`, `pathToFileURL`) exist only to build the URL that
   * `import()` consumes; node and bun both implement those builtins and dynamic
   * import, so this layer runs on either runtime. Only ever wired by
   * `WorkspaceCatalogs.layerWithConfigDependencies`.
   */
  static readonly layerLive: Layer.Layer<ConfigDependencyHooks>;
  /**
   * The subprocess layer: replays each config dependency's pnpmfile in a `node`
   * child process instead of an in-process dynamic `import()`, with identical
   * typed semantics to {@link ConfigDependencyHooks.layerLive} — the two are
   * drop-in interchangeable.
   *
   * @remarks
   * `layerLive` computes the `import()` path at runtime, and a bundler (rspack,
   * for one) compiles a *computed* dynamic import into a context module that
   * throws `Cannot find module 'file:///…'` at runtime — so in any bundled
   * consumer, a GitHub Action above all, the in-process replay is unreachable.
   * This layer keeps every computed load out of the bundle graph: the replay
   * program is a **static** string constant passed via argv
   * (`node --input-type=module -e <script> <root> <seed> <...names>`), and the
   * child process performs the computed imports where no bundler rewrote them.
   * A subprocess also keeps config-dependency code out of the consumer's own
   * process.
   *
   * The contract's semantics are unchanged, not the downstream fail-open shape:
   * an empty `configDependencies` returns the seed without spawning anything; a
   * `..` path segment in a dependency name fails typed **before** any spawn; a
   * missing pnpmfile (neither `.mjs` nor `.cjs`) is the one legitimate skip,
   * discriminated inside the child by `err.url` equality exactly as
   * `layerLive` discriminates in process; any other load failure — a syntax
   * error, a throwing top level, an `ERR_MODULE_NOT_FOUND` for a module the
   * pnpmfile itself imports — and a hook that throws when called are serialized
   * back per-name and surface typed as a `hooks`-source `CatalogAssemblyError`
   * naming that dependency. A hook's returned *data* stays tolerantly threaded
   * (last well-formed write wins), never fatal. Spawn and transport failures —
   * `node` absent, a non-zero exit without a result payload, unparseable
   * output — fail typed too, never a defect and never a silent skip.
   *
   * Two bounds this layer imposes that `layerLive` cannot: the replay is
   * given thirty seconds (a pnpmfile that loops or awaits forever fails typed
   * instead of hanging the memoized assemble pass — a subprocess is killable,
   * while `layerLive`'s in-process synchronous hook call is not interruptible
   * by any means, so the asymmetry is inherent, not a parity violation), and
   * the child's stdout is captured under `Run.jsonLine`'s 16 MiB default
   * ceiling (a hook that logs more than that fails typed as `tooLarge`, where
   * `layerLive` — which captures nothing — would succeed).
   *
   * Catalog folding and normalization stay in the **parent** (the same
   * `@pnpm/catalogs`-derived path `layerLive` uses); the child returns only the
   * raw threaded config slice, since the script cannot import kit code.
   *
   * Requires core's `ChildProcessSpawner`, resolved when the layer is built —
   * the consumer provides it once at the edge (`@effect/platform-node`'s
   * `NodeServices.layer`), the same discharge `@effected/git` uses. Wired by
   * `WorkspaceCatalogs.layerWithConfigDependenciesSubprocess` /
   * `Workspaces.layerWithConfigDependenciesSubprocess`.
   */
  static readonly layerSubprocess: Layer.Layer<ConfigDependencyHooks, never, ChildProcessSpawner.ChildProcessSpawner>;
}
//#endregion
//#region src/DependencyGraph.d.ts
declare const CyclicDependencyError_base: Schema.Class<CyclicDependencyError, Schema.TaggedStruct<"CyclicDependencyError", {
  /** The packages participating in the cycle. */
  readonly cycle: Schema.$Array<Schema.String>;
}>, import("effect/Cause").YieldableError>;
/**
 * Raised when the workspace dependency graph cannot be topologically ordered
 * because it contains a cycle.
 *
 * @remarks
 * `cycle` names the actual cycle members — the sorted union of every strongly
 * connected component with more than one package. Packages merely downstream
 * of a cycle are excluded, so it is exactly the set to break, not necessarily
 * a single ordered loop.
 *
 * @public
 */
declare class CyclicDependencyError extends CyclicDependencyError_base {
  /** Renders the cycle members into a one-line message. */
  get message(): string;
}
declare const DependencyGraph_base: Schema.Class<DependencyGraph, Schema.Struct<{
  /** The workspace packages the graph is drawn over. */
  readonly packages: Schema.$Array<typeof WorkspacePackage>;
}>, {}>;
/**
 * The directed graph of dependencies **between workspace packages**. External
 * npm dependencies are not nodes.
 *
 * @remarks
 * A pure value over the discovered package list, with the edge indexes built
 * lazily into `#private` fields the schema never encodes. Edges are drawn from
 * `dependencies`, `devDependencies`, `peerDependencies` and
 * `optionalDependencies`; a self-edge is dropped.
 *
 * Total accessors never fail; the four fallible operations are `Effect.fn`
 * boundaries.
 *
 * @example
 * ```ts
 * import { DependencyGraph, WorkspaceDiscovery } from "@effected/workspaces";
 * import { Effect } from "effect";
 *
 * const program = Effect.gen(function* () {
 *   const discovery = yield* WorkspaceDiscovery;
 *   const graph = DependencyGraph.make({ packages: yield* discovery.listPackages() });
 *   return yield* graph.levels();
 * });
 * ```
 *
 * @public
 */
declare class DependencyGraph extends DependencyGraph_base {
  #private;
  /** Every workspace package name, sorted. Total. */
  get names(): ReadonlyArray<string>;
  /** The adjacency map: name → the names it depends on. Total. */
  get adjacency(): ReadonlyMap<string, ReadonlySet<string>>;
  /**
   * Whether the graph contains a cycle. Total.
   *
   * @remarks
   * An explicit-stack DFS with an on-stack set — never recursive, so a long
   * dependency chain cannot overflow.
   */
  get hasCycle(): boolean;
  /** The workspace packages `name` depends on, sorted. */
  readonly dependenciesOf: (name: string) => Effect.Effect<readonly string[], PackageNotFoundError, never>;
  /** The workspace packages that depend on `name`, sorted. */
  readonly dependentsOf: (name: string) => Effect.Effect<readonly string[], PackageNotFoundError, never>;
  /**
   * `name` plus every package that transitively depends on it — the blast
   * radius of a change. Sorted; includes `name` itself.
   */
  readonly affectedBy: (names: readonly string[]) => Effect.Effect<readonly string[], never, never>;
  /**
   * Packages grouped into parallel build levels: level 0 depends on nothing in
   * the workspace, level *n* depends only on levels below it.
   *
   * @remarks
   * Kahn's algorithm over the reverse-edge index — linear, where v3's rescanned
   * the whole adjacency map per processed node. Each level is sorted
   * lexicographically, so the output is deterministic.
   */
  readonly levels: () => Effect.Effect<readonly (readonly string[])[], CyclicDependencyError, never>;
  /** The flattened topological order — `levels()` concatenated. */
  readonly sort: () => Effect.Effect<readonly string[], CyclicDependencyError, never>;
  /**
   * A topological order over `names` plus their transitive workspace
   * dependencies — the build order for a subset.
   */
  readonly sortSubset: (names: readonly string[]) => Effect.Effect<readonly string[], CyclicDependencyError | PackageNotFoundError, never>;
  /**
   * The graph rendered as a Mermaid `flowchart TD`. Total.
   *
   * @remarks
   * Renders through core's `Graph.toMermaid` over a transient graph built from
   * the edge index. Node IDs are numeric indexes assigned in sorted-name order
   * and package names appear only inside quoted labels, so scoped names
   * (`@scope/a`) never break Mermaid syntax. Nodes and each node's edges are
   * emitted in sorted order — the output is deterministic regardless of
   * manifest key order.
   */
  toMermaid(): string;
}
//#endregion
//#region src/PackageManagerName.d.ts
/**
 * The four package managers this package understands.
 *
 * @public
 */
declare const PackageManagerName: Schema.Literals<readonly ["npm", "pnpm", "yarn", "bun"]>;
/**
 * The decoded type of {@link (PackageManagerName:variable)}: `"npm" | "pnpm" | "yarn" | "bun"`.
 *
 * @public
 */
type PackageManagerName = typeof PackageManagerName.Type;
/**
 * The markers {@link PackageManagerDetector} probes, in the priority order it
 * probes them.
 *
 * @remarks
 * One vocabulary serves both halves of the detection contract: the failure path
 * reports every member as `PackageManagerDetectionError.checked`, and the
 * success path reports the one that fired as
 * `DetectedPackageManager.evidence`. A closed literal union rather than
 * free text, so a consumer logging *why* a workspace was classified asserts
 * against the kit's vocabulary instead of re-deriving the probe with its own
 * filesystem reads.
 *
 * The `package.json#…` spellings name manifest *fields*; the rest are marker
 * files at the workspace root.
 *
 * @public
 */
declare const PackageManagerEvidence: Schema.Literals<readonly ["pnpm-workspace.yaml", "bun.lock", "bun.lockb", "yarn.lock", "package.json#workspaces", "pnpm-lock.yaml", "package-lock.json", "package.json#devEngines.packageManager", "package.json#packageManager"]>;
/**
 * The decoded type of {@link (PackageManagerEvidence:variable)}: the marker
 * that decided a detection.
 *
 * @public
 */
type PackageManagerEvidence = typeof PackageManagerEvidence.Type;
declare const DetectedPackageManager_base: Schema.Class<DetectedPackageManager, Schema.Struct<{
  /** The detected manager. */
  readonly name: Schema.Literals<readonly ["npm", "pnpm", "yarn", "bun"]>;
  /** Its version, when a manifest field agrees on the manager and carries one. */
  readonly version: Schema.Option<Schema.String>;
  /** The JavaScript runtime the manager implies. */
  readonly runtime: Schema.Literals<readonly ["node", "bun"]>;
  /** The rung of the priority order that decided the name. */
  readonly evidence: Schema.Literals<readonly ["pnpm-workspace.yaml", "bun.lock", "bun.lockb", "yarn.lock", "package.json#workspaces", "pnpm-lock.yaml", "package-lock.json", "package.json#devEngines.packageManager", "package.json#packageManager"]>;
}>, {}>;
/**
 * The outcome of package-manager detection at a workspace root.
 *
 * @remarks
 * `version` is `Option.none()` unless a manifest field naming the *same* manager
 * that was detected also carries a version — a `packageManager: "yarn@4"` in a
 * pnpm workspace tells us nothing about pnpm's version, so it is not reported as
 * one. The two fields consulted are the corepack top-level `packageManager` and
 * `devEngines.packageManager`; see {@link PackageManagerDetector} for the
 * precedence between them.
 *
 * `evidence` is the rung of the priority order that decided the **name** — the
 * verdict's provenance, in the same vocabulary the failure path reports as
 * `PackageManagerDetectionError.checked`. For the bun and yarn rungs the
 * lockfile is the recorded signal even though the rung is a conjunction (the
 * lockfile *plus* a manifest field naming the manager): the manifest field alone
 * would have resolved in the declaration tier, so the lockfile is what this rung
 * added. The version's provenance is deliberately not carried — it follows the
 * two-field precedence above, which is a rule, not a probe.
 *
 * @public
 */
declare class DetectedPackageManager extends DetectedPackageManager_base {}
declare const PackageManagerDetectionError_base: Schema.Class<PackageManagerDetectionError, Schema.TaggedStruct<"PackageManagerDetectionError", {
  /** The workspace root that was probed. */
  readonly root: Schema.String;
  /** The marker files probed, in the order they were probed. */
  readonly checked: Schema.$Array<Schema.String>;
}>, import("effect/Cause").YieldableError>;
/**
 * Raised when a directory carries no lockfile and no workspace configuration,
 * so no package manager can be attributed to it.
 *
 * @public
 */
declare class PackageManagerDetectionError extends PackageManagerDetectionError_base {
  /** Renders the root and probed markers into a one-line message. */
  get message(): string;
}
/**
 * Every failure {@link PackageManagerDetector} can surface: no manager could be
 * attributed to the root, or the root's `package.json` exists but cannot be read
 * or parsed.
 *
 * @public
 */
type PackageManagerDetectionFailure = PackageManagerDetectionError | WorkspaceManifestError;
/**
 * The {@link PackageManagerDetector} service shape.
 *
 * @remarks
 * Exported so a consumer can type a bespoke double against the contract without
 * reaching into the class — the `WorkspaceDiscoveryShape` /
 * `PublishabilityDetectorShape` convention.
 *
 * @public
 */
interface PackageManagerDetectorShape {
  /** Detect the package manager at a workspace root. */
  readonly detect: (root: string) => Effect.Effect<DetectedPackageManager, PackageManagerDetectionFailure>;
}
declare const PackageManagerDetector_base: Context.ServiceClass<PackageManagerDetector, "@effected/workspaces/PackageManagerDetector", PackageManagerDetectorShape>;
/**
 * Detects which package manager owns a workspace root.
 *
 * @remarks
 * **Lockfile evidence is the primary signal** — it is what says which manager
 * actually ran. Priority, first match wins: a `pnpm-workspace.yaml` means pnpm;
 * a bun lockfile *plus* a manifest field naming bun means bun; a `yarn.lock`
 * *plus* a manifest field naming yarn means yarn; a root `package.json` with a
 * `workspaces` field falls back to npm.
 *
 * The manifest conjunction is deliberate: a stray `yarn.lock` in an npm repo is
 * common, and only a declared manager name disambiguates it.
 *
 * **Two manifest fields declare a manager, and they are not interchangeable.**
 * Corepack reads both, and this is the rule that falls out of how it treats
 * them:
 *
 * - `devEngines.packageManager.name` is authoritative for the **name**.
 *   Corepack *errors* when a top-level `packageManager` disagrees with it (per
 *   `devEngines.packageManager.onFail`), so where both are present and disagree,
 *   `devEngines` is the one to believe. When `devEngines` names a manager, the
 *   top-level field's name is not consulted as a disambiguator at all.
 * - The top-level `packageManager` is authoritative for the exact **version**:
 *   it is the field that carries the integrity hash. Where both name the same
 *   manager, its version wins; where it is absent, `devEngines.packageManager.version`
 *   supplies the version instead.
 *
 * A version is reported **only when the field it came from names the manager
 * that was actually detected**. A `packageManager: "yarn@4"` in a pnpm workspace
 * says nothing about pnpm's version, so no version is reported — and the same
 * discipline applies to `devEngines`.
 *
 * Malformed manifest *hints* are ignored rather than fatal, matching corepack: a
 * non-object or array `devEngines.packageManager`, a `name` containing `@`, or a
 * version that is not an exact version cannot turn a detectable workspace into a
 * detection failure. A manifest that exists but cannot be **read or parsed** is a
 * different thing entirely and fails with a `WorkspaceManifestError` — a corrupt
 * root manifest is a real problem, not a missing hint.
 *
 * @public
 */
declare class PackageManagerDetector extends PackageManagerDetector_base {
  /** Builds the service over core `FileSystem` and `Path`. */
  static readonly make: Effect.Effect<{
    readonly detect: (root: string) => Effect.Effect<DetectedPackageManager, PackageManagerDetectionFailure>;
  }, never, FileSystem.FileSystem | Path.Path>;
  /** The live layer. */
  static readonly layer: Layer.Layer<PackageManagerDetector, never, FileSystem.FileSystem | Path.Path>;
  /**
   * The sanctioned in-memory double.
   *
   * @remarks
   * **`detect` has no honest default, so an unstubbed call dies** — the
   * `WorkspaceDiscovery.info` posture, for the same reason. A stand-in that
   * answered `"pnpm"` would hand a consumer a fact nothing established, and it
   * would contradict the very service it stands in for: the live detector's
   * defining property is that it [refuses to
   * guess](https://github.com/spencerbeggs/effected) when no evidence matches.
   * A double that guesses is worse than no double.
   *
   * Failing typed would be the subtler mistake: `PackageManagerDetectionError`
   * reads as a legitimate "no manager here" answer, so a consumer would branch
   * on it and proceed, never learning that the test simply forgot to stub.
   *
   * The defect is also not absorbed by `Effect.catch` or any typed-error
   * handler — deliberately, so code under test with a best-effort `catch`
   * around detection cannot make the mandatory stub look optional; the
   * unstubbed call still fails the test.
   *
   * @param overrides - Members to supply; anything omitted dies on use.
   *
   * @example
   * ```ts
   * import { DetectedPackageManager, PackageManagerDetector } from "@effected/workspaces";
   * import { Effect, Option } from "effect";
   *
   * const TestDetector = PackageManagerDetector.layerTest({
   *   detect: () =>
   *     Effect.succeed(
   *       DetectedPackageManager.make({
   *         name: "pnpm",
   *         version: Option.none(),
   *         runtime: "node",
   *         evidence: "pnpm-workspace.yaml",
   *       }),
   *     ),
   * });
   * ```
   */
  static readonly makeTest: (overrides?: Partial<PackageManagerDetectorShape>) => PackageManagerDetectorShape;
  /**
   * {@link PackageManagerDetector.makeTest} behind `Layer.succeed`.
   *
   * @remarks
   * A parameterized layer factory mints a **fresh reference per call**, and
   * layers memoize by reference — bind the result to a `const` and reuse it
   * rather than calling `layerTest(...)` at each composition site.
   *
   * Pairs with `WorkspaceRoot.layerTest` and `WorkspaceDiscovery.layerTest` to
   * stand up the whole discovery path with no filesystem at all.
   */
  static readonly layerTest: (overrides?: Partial<PackageManagerDetectorShape>) => Layer.Layer<PackageManagerDetector>;
}
//#endregion
//#region src/LockfileReader.d.ts
declare const LockfileReadError_base: Schema.Class<LockfileReadError, Schema.TaggedStruct<"LockfileReadError", {
  /** Absolute path to the lockfile that could not be read. */
  readonly lockfilePath: Schema.String;
  /** The format the detected package manager implies. */
  readonly format: Schema.Literals<readonly ["bun", "npm", "pnpm", "yarn"]>;
  /** The originating failure. */
  readonly cause: Schema.Defect;
}>, import("effect/Cause").YieldableError>;
/**
 * Raised when the workspace's lockfile cannot be read off disk.
 *
 * @remarks
 * Parse failures are `@effected/lockfiles`' `LockfileParseError`, not this —
 * this is strictly the IO half.
 *
 * @public
 */
declare class LockfileReadError extends LockfileReadError_base {
  /** Renders the unreadable path into a one-line message. */
  get message(): string;
}
/**
 * Every failure the lockfile methods can surface — the exported init-error
 * union the review named best-in-class DX.
 *
 * @remarks
 * Layer construction does no IO, so every member surfaces from the *methods*
 * rather than from `Layer.build`: the root cannot be found, no package manager
 * can be attributed to it (or its manifest is corrupt), its lockfile cannot be
 * read, the lockfile is malformed, or the lockfile's YAML stream carries no
 * lockfile document.
 *
 * @public
 */
type LockfileReadFailure = WorkspaceRootNotFoundError | PackageManagerDetectionFailure | LockfileReadError | LockfileParseError | LockfileFramingError;
/**
 * The {@link LockfileReader} service shape.
 *
 * @public
 */
interface LockfileReaderShape {
  /** The parsed lockfile, with pnpm importer paths already resolved to real names. */
  readonly read: () => Effect.Effect<Lockfile, LockfileReadFailure>;
  /**
   * The lockfile's record of a package, when it records one.
   *
   * @remarks
   * A name can resolve at **several versions** in one lockfile (two members
   * depending on different majors of the same package). This returns the
   * **first** entry in lockfile order and does not attempt to rank them — there
   * is no single "the" version to return, and picking the highest semver would
   * imply a resolution decision this reader is not entitled to make. Callers
   * that must see every resolution should read `lockfile.packagesNamed(name)`
   * off `read()` directly.
   */
  readonly resolvedVersion: (packageName: string) => Effect.Effect<Option.Option<ResolvedPackage>, LockfileReadFailure>;
  /**
   * Whether the lockfile agrees with the workspace manifests on disk — the
   * pure `LockfileIntegrity.compare`, fed the manifests this package reads.
   */
  readonly integrity: () => Effect.Effect<LockfileIntegrity, LockfileReadFailure | WorkspaceDiscoveryFailure>;
  /** Drop the memoized read so the next call re-reads the lockfile. */
  readonly refresh: () => Effect.Effect<void>;
}
/**
 * Options for the {@link LockfileReader} layer.
 *
 * @public
 */
interface LockfileReaderOptions {
  /**
   * The directory the workspace root is resolved from.
   *
   * @defaultValue `process.cwd()`, read lazily on first use.
   */
  readonly cwd?: string;
}
declare const LockfileReader_base: Context.ServiceClass<LockfileReader, "@effected/workspaces/LockfileReader", LockfileReaderShape>;
/**
 * Reads and parses the workspace's lockfile.
 *
 * @remarks
 * Layer construction is O(1). The root walk, package-manager detection, file
 * read, parse and pnpm name resolution all happen on the first method call and
 * are memoized success-only for the lifetime of the layer.
 *
 * @example
 * ```ts
 * import { LockfileReader } from "@effected/workspaces";
 * import { Effect } from "effect";
 *
 * const program = Effect.gen(function* () {
 *   const reader = yield* LockfileReader;
 *   const lockfile = yield* reader.read();
 *   return lockfile.packages.length;
 * });
 * ```
 *
 * @public
 */
declare class LockfileReader extends LockfileReader_base {
  /** Builds the service. */
  static readonly make: (options?: LockfileReaderOptions) => Effect.Effect<LockfileReaderShape, never, WorkspaceRoot | PackageManagerDetector | WorkspaceDiscovery | FileSystem.FileSystem | Path.Path>;
  /**
   * The live layer.
   *
   * @remarks
   * Parameterized, so it mints a fresh reference per call — bind it to a
   * `const` and reuse it.
   */
  static readonly layer: (options?: LockfileReaderOptions) => Layer.Layer<LockfileReader, never, WorkspaceRoot | PackageManagerDetector | WorkspaceDiscovery | FileSystem.FileSystem | Path.Path>;
  /**
   * A test double satisfying the full {@link LockfileReaderShape} with no
   * filesystem, root walk, or package-manager detection.
   *
   * @remarks
   * There is **no honest default lockfile**: an empty one that looks like a
   * legitimate answer is indistinguishable from "this workspace resolves
   * nothing" — the silent-empty failure class this package documents on the
   * live paths — so `read` **dies** with an instructive defect until stubbed.
   *
   * The one derivation mirrors `WorkspaceDiscovery.makeTest`'s
   * derived-from-the-primary rule: when a `read` override is supplied,
   * `resolvedVersion` answers as the live service does — the **first** entry
   * of `lockfile.packagesNamed(name)` in lockfile order, `Option.none()` on a
   * miss — so the two stay consistent by construction. `integrity` is **not**
   * derivable: the live method compares the lockfile against the workspace
   * manifests discovery enumerates, and the double has no discovery to ask, so
   * it dies unless stubbed.
   *
   * `refresh` defaults to `Effect.void` honestly: the live contract is "drop
   * the memoized read so the next call re-reads", and this double memoizes
   * nothing — every `read()` call re-invokes the override — so there is
   * nothing to drop and the no-op is truthful, the same reasoning as
   * `WorkspaceDiscovery.makeTest`'s `refresh`.
   *
   * @example
   * ```ts
   * import { Lockfile } from "@effected/lockfiles";
   * import { LockfileReader } from "@effected/workspaces";
   * import { Effect } from "effect";
   *
   * const double = LockfileReader.makeTest({
   *   read: () =>
   *     Effect.succeed(
   *       Lockfile.make({ format: "pnpm", lockfileVersion: "9.0", packages: [], workspaceDependencies: [] }),
   *     ),
   * });
   * // `resolvedVersion` now answers consistently from that lockfile.
   * ```
   */
  static readonly makeTest: (overrides?: Partial<LockfileReaderShape>) => LockfileReaderShape;
  /**
   * The test layer: {@link LockfileReader.makeTest} behind `Layer.succeed`, so
   * a suite provides only the methods it exercises.
   *
   * @remarks
   * A parameterized layer factory mints a **fresh reference per call**, and
   * layers memoize by reference — bind the result to a `const` and reuse it
   * rather than calling `layerTest(...)` at each composition site.
   *
   * @example
   * ```ts
   * import { LockfileReader } from "@effected/workspaces";
   *
   * const TestLockfiles = LockfileReader.layerTest();
   * // program.pipe(Effect.provide(TestLockfiles)) — dies loudly if touched.
   * ```
   */
  static readonly layerTest: (overrides?: Partial<LockfileReaderShape>) => Layer.Layer<LockfileReader>;
}
//#endregion
//#region src/PeerCheck.d.ts
/**
 * Why a report is not a complete answer.
 *
 * @remarks
 * Closed at exactly two, by measurement rather than by guess:
 *
 * - `"peerRulesNotApplied"` — the effective suppression policy was not applied,
 *   so pnpm's post-hoc suppression could not be replicated and some reported
 *   rows may be ones pnpm hides. **Omitting the option always produces this**,
 *   because "nobody looked" and "I looked and there are none" are different
 *   facts. Supplied rules with a non-empty `ignoreMissing` or `allowAny` also
 *   produce it: only `allowedVersions` is applied, so an unimplemented axis
 *   degrades to fail-closed rather than to a wrong answer.
 * - `"unresolvedEdge"` — some instance records an edge this model could not
 *   name (`ResolvedPackage.unresolvedEdges`), so a peer that edge satisfies
 *   cannot be verified either way.
 *
 * Both mean **fail closed**: a gate should treat an unverified report as "not
 * proven clean" rather than as a pass.
 *
 * @public
 */
type UnverifiedReason = "peerRulesNotApplied" | "unresolvedEdge";
/**
 * Options for {@link PeerCheck.run}.
 *
 * @remarks
 * **Presence of `peerDependencyRules` is the assertion; its contents are the
 * value.** Supplying `NoPeerDependencyRules` asserts the workspace has none and
 * yields a verified report; omitting the key entirely says nothing was looked
 * up and always yields `"peerRulesNotApplied"`. The two are deliberately
 * different results, because a gate must be able to tell "clean" from
 * "unchecked".
 *
 * **Only `allowedVersions` is applied.** Rules whose `ignoreMissing` or
 * `allowAny` is non-empty describe a suppression policy this module does not
 * implement, so they also yield `"peerRulesNotApplied"` — the unimplemented
 * axes fail closed instead of being silently ignored.
 *
 * @public
 */
interface PeerCheckOptions {
  /** The workspace's effective rules, from `WorkspaceCatalogs.peerDependencyRules()`. */
  readonly peerDependencyRules?: PeerDependencyRules;
}
declare const PeerParent_base: Schema.Class<PeerParent, Schema.Struct<{
  /** The package name. */
  readonly name: Schema.NonEmptyString;
  /** The resolved version of that package. */
  readonly version: Schema.String;
}>, {}>;
/**
 * One link in the chain from an importer to the package that declared an
 * unsatisfied peer.
 *
 * @remarks
 * Mirrors the shape `pnpm peers check --json` reports, so the two can be
 * compared directly.
 *
 * @public
 */
declare class PeerParent extends PeerParent_base {}
declare const UnsatisfiedPeer_base: Schema.Class<UnsatisfiedPeer, Schema.Struct<{
  /** The importer path the problem belongs to (`"."` for the root). */
  readonly importer: Schema.NonEmptyString;
  /** The peer dependency's name. */
  readonly dependency: Schema.NonEmptyString;
  /** The range the declaring package asked for. */
  readonly wanted: Schema.String;
  /** The version that resolved, or `null` when nothing resolved. */
  readonly found: Schema.NullOr<Schema.String>;
  /** Whether the declaring package marked the peer optional. */
  readonly optional: Schema.Boolean;
  /** The path from the importer to the declaring package. */
  readonly parents: Schema.$Array<typeof PeerParent>;
}>, {}>;
/**
 * One peer dependency that is declared but not satisfied.
 *
 * @remarks
 * `found` carries the version that actually resolved, or `null` when nothing
 * resolved at all. There is deliberately **no separate discriminant** between
 * "missing" and "unmet": `found === null` is the whole distinction, and a
 * renderer reads it directly.
 *
 * `optional` must be respected by any gate — an unsatisfied *optional* peer is
 * normal and should not fail a build, which is why the flag travels with the
 * row rather than being filtered out here. {@link PeerCheck.required} is the
 * convenience for the common case.
 *
 * `parents` is the path from the importer down to the package that declared
 * the peer, nearest-to-the-importer first. It is a path rather than a single
 * package because a peer declared by a transitive dependency is still that
 * importer's problem, and the chain is what makes the report actionable.
 *
 * A package an importer reaches by more than one path yields **one** row, not
 * one per path, carrying the path the walk reached first — which is what
 * `pnpm peers check` reports for the same graph. Read `parents` as *a* route to
 * the declaring package, never as the complete set of them.
 *
 * @public
 */
declare class UnsatisfiedPeer extends UnsatisfiedPeer_base {}
declare const PeerCheck_base: Schema.Class<PeerCheck, Schema.Struct<{
  /**
   * Whether the lockfile's format records peer resolution at all.
   *
   * `false` for yarn: yarn resolves peers **virtually**, giving a
   * peer-bearing package one `@virtual:` locator per consumer, and the
   * lockfile does not record which virtual instance satisfied which peer.
   * The answer is not recoverable, so it is not fabricated — `unsatisfied`
   * is empty and this flag says why.
   */
  readonly supported: Schema.Boolean;
  /** Every unsatisfied peer found, optional ones included. */
  readonly unsatisfied: Schema.$Array<typeof UnsatisfiedPeer>;
  /**
   * Importers whose dependencies could not be resolved to instances, so no
   * verdict was reached for them.
   *
   * @remarks
   * In practice this is the **root importer under npm and bun**: neither
   * records a resolved version per importer dependency, and neither emits a
   * package row for the root, so there is nothing to join on. pnpm records a
   * version per importer dependency and is unaffected.
   *
   * Reported rather than silently skipped, for the same reason `supported`
   * exists: a gate that sees no rows is entitled to know whether that means
   * "clean" or "not looked at".
   */
  readonly unresolvedImporters: Schema.$Array<Schema.String>;
  /**
   * Why this report is not a complete answer, or empty when it is.
   *
   * @remarks
   * See {@link UnverifiedReason}. A gate must treat a non-empty `unverified`
   * as **not proven clean** rather than as a pass: both reasons mean some
   * finding may be missing or spurious, and failing closed is the requirement.
   */
  readonly unverified: Schema.$Array<Schema.Literals<readonly ["peerRulesNotApplied", "unresolvedEdge"]>>;
}>, {}>;
/**
 * The result of checking a lockfile for unsatisfied peer dependencies.
 *
 * @remarks
 * A report rather than a bare array, because an empty array is the most
 * dangerous success shape this domain has: it is indistinguishable from "this
 * format cannot be checked". `supported` and `unresolvedImporters` make the
 * difference legible, so a consumer cannot read a limitation as a clean bill
 * of health.
 *
 * Pure and total — construct it with {@link PeerCheck.run}, which never fails.
 *
 * @example
 * ```ts
 * import { PeerCheck } from "@effected/workspaces";
 * import { Lockfile } from "@effected/lockfiles";
 * import { Effect } from "effect";
 *
 * const program = Effect.gen(function* () {
 *   const lockfile = yield* Lockfile.parse(text, { format: "pnpm" });
 *   const report = PeerCheck.run(lockfile);
 *   return report.supported ? report.required : [];
 * });
 * ```
 *
 * @public
 */
declare class PeerCheck extends PeerCheck_base {
  /** The unsatisfied peers a gate should act on — the non-optional ones. */
  get required(): ReadonlyArray<UnsatisfiedPeer>;
  /**
   * Compute the unsatisfied peer dependencies of a parsed lockfile.
   *
   * @remarks
   * Pure, total and format-free: no IO, no error channel, and no knowledge of
   * which package manager wrote the file. Range satisfaction is
   * `@effected/semver`'s, never hand-rolled.
   *
   * The walk starts at each importer's resolved dependencies and follows
   * `resolved` edges, so a peer declared by a *transitive* dependency is
   * attributed to the importer that pulls it in, with the chain in
   * `parents` — matching how `pnpm peers check` attributes them.
   *
   * Three judgements are deliberate:
   *
   * - **A required peer with nothing resolved is reported** (`found: null`),
   *   whether or not the declared range is parseable — a peer with no
   *   provider is a fact about the graph that needs no range arithmetic.
   * - **An ABSENT optional peer is not reported at all**, because that is
   *   what optional means. An optional peer resolved at the *wrong* version
   *   still is, carrying `optional: true`. Both halves match
   *   `pnpm peers check`, whose `missing` section contains only required
   *   peers while its `bad` section carries optional ones.
   * - **An unparseable range or version with something resolved is skipped.**
   *   The check cannot judge it, and asserting "unsatisfied" on a comparison
   *   that was never performed would be a wrong answer rather than a gap.
   * - **A workspace-linked provider counts.** Resolution is followed through
   *   whatever the edge names, including a workspace row.
   *
   * Known limits it does not paper over: yarn (see `supported`), the npm and
   * bun root importer (see `unresolvedImporters`), and pnpm recording no peer
   * declarations for workspace projects themselves — under pnpm a workspace
   * package's *own* unsatisfied peers are not in the lockfile at all, and
   * `pnpm peers check` does not report them either.
   *
   * @param lockfile - a lockfile parsed by `@effected/lockfiles`
   * @returns the report; never fails
   */
  static run(lockfile: Lockfile, options?: PeerCheckOptions): PeerCheck;
}
//#endregion
//#region src/Publishability.d.ts
declare const PublishTarget_base: Schema.Class<PublishTarget, Schema.Struct<{
  /** The package name being published. */
  readonly name: Schema.NonEmptyString;
  /** The registry URL. */
  readonly registry: Schema.NonEmptyString;
  /** The directory to publish, relative to the package root; `"."` for the root itself. */
  readonly directory: Schema.String;
  /** Scoped-package visibility. */
  readonly access: Schema.Literals<readonly ["public", "restricted"]>;
  /** Whether to publish with a provenance attestation. */
  readonly provenance: Schema.withConstructorDefault<Schema.withDecodingDefaultKey<Schema.Boolean, never>>;
}>, {}>;
/**
 * A resolved publish destination for a workspace package.
 *
 * @public
 */
declare class PublishTarget extends PublishTarget_base {}
/**
 * The {@link PublishabilityDetector} service shape.
 *
 * @remarks
 * The error channel is deliberately `never`: every consumer of the service —
 * a release planner iterating a whole workspace — treats "does this publish"
 * as a total question, so an overriding layer whose lookup can fail must
 * **degrade or die**. Fold a recoverable failure into a safe answer (usually
 * the empty target list), or `Effect.orDie` it into the defect channel; it
 * cannot widen the channel the contract declares. See
 * {@link PublishabilityDetector} for the adapter an overriding consumer
 * writes.
 *
 * @public
 */
interface PublishabilityDetectorShape {
  /**
   * The publish targets for a package; empty means it does not publish.
   *
   * @remarks
   * `VersioningStrategy.detect` probes a whole workspace by invoking this
   * concurrently — up to ten packages in flight at once, in no guaranteed
   * order. An overriding implementation backed by shared mutable state or a
   * rate-limited client must tolerate that interleaving itself; the caller
   * does not serialize on its behalf.
   */
  readonly detect: (pkg: WorkspacePackage) => Effect.Effect<ReadonlyArray<PublishTarget>>;
}
declare const PublishabilityDetector_base: Context.ServiceClass<PublishabilityDetector, "@effected/workspaces/PublishabilityDetector", PublishabilityDetectorShape>;
/**
 * Decides whether a workspace package publishes, and to where.
 *
 * @remarks
 * The default layer implements standard npm semantics: a `private` package with
 * no `publishConfig.access` publishes nowhere; an explicit
 * `publishConfig.access` overrides `private`; anything else publishes to the
 * public registry with defaults.
 *
 * Those are *npm's* semantics, not necessarily yours. Swap the layer:
 *
 * @example
 * ```ts
 * import { PublishabilityDetector, PublishTarget } from "@effected/workspaces";
 * import { Effect, Layer } from "effect";
 *
 * const internalOnly = Layer.succeed(PublishabilityDetector, {
 *   detect: (pkg) =>
 *     Effect.succeed(
 *       pkg.name.startsWith("@acme/")
 *         ? [PublishTarget.make({
 *             name: pkg.name,
 *             registry: "https://npm.acme.internal/",
 *             directory: ".",
 *             access: "restricted",
 *           })]
 *         : [],
 *     ),
 * });
 * ```
 *
 * @example
 * The shape's error channel is `never` — **degrade or die**. An override
 * backed by something fallible (a policy service, a registry probe) folds its
 * failure structurally over `{ readonly message: string }` — matching every
 * `Error`, every Effect schema error class, and anything else carrying a
 * message — and either degrades to a safe answer or dies:
 *
 * ```ts
 * import { PublishabilityDetector, PublishTarget } from "@effected/workspaces";
 * import { Effect, Layer } from "effect";
 *
 * declare const lookupPolicy: (
 *   name: string,
 * ) => Effect.Effect<ReadonlyArray<PublishTarget>, { readonly message: string }>;
 *
 * const fromPolicyService = Layer.succeed(PublishabilityDetector, {
 *   detect: (pkg) =>
 *     lookupPolicy(pkg.name).pipe(
 *       Effect.catch((error) =>
 *         Effect.die(new Error(`publishability policy lookup failed for ${pkg.name}: ${error.message}`)),
 *       ),
 *     ),
 * });
 * ```
 *
 * A lookup failure that should *not* abort the run degrades instead —
 * `Effect.catch(() => Effect.succeed([]))` reads as "unknown means
 * unpublishable" — but pick one deliberately; silently swallowing the failure
 * into a wrong "publishes to npm" answer is the one option the contract
 * forbids.
 *
 * @public
 */
declare class PublishabilityDetector extends PublishabilityDetector_base {
  /**
   * Standard npm publishing semantics, **as a value**. Pure — no filesystem,
   * no platform services.
   *
   * @remarks
   * Exposed as a shape and not only as a layer, because a consumer composing
   * *around* these rules cannot reach them through a layer without re-entering
   * the very tag it is replacing. `@savvy-web/silk-effects` had to write
   * `Effect.provide(PublishabilityDetector, PublishabilityDetector.layer)`
   * **inside its own implementation of that tag** to get at this function for
   * its pass-through branch; with the value exposed that becomes
   * `PublishabilityDetector.npm.detect(pkg)`.
   *
   * @example
   * ```ts
   * import { PublishabilityDetector } from "@effected/workspaces";
   * import { Effect, Layer } from "effect";
   *
   * // A policy that defers to npm semantics for everything it does not veto.
   * const withVeto = Layer.succeed(PublishabilityDetector, {
   *   detect: (pkg) =>
   *     pkg.name.endsWith("-private")
   *       ? Effect.succeed([])
   *       : PublishabilityDetector.npm.detect(pkg),
   * });
   * ```
   */
  static readonly npm: PublishabilityDetectorShape;
  /** Nothing publishes. */
  static readonly none: PublishabilityDetectorShape;
  /**
   * {@link PublishabilityDetector.npm} as a layer.
   *
   * @remarks
   * Named for its policy rather than called `layer`, deliberately. **No
   * composite in this package provides a publishability detector**: a
   * `Workspaces.layer()` that quietly supplied npm semantics made the choice
   * invisible, and worse, made a naively-ordered override lose to it in
   * silence — `Layer.mergeAll(myDetector, Workspaces.layer())` resolved to the
   * default, because `mergeAll` is last-wins. For a service that decides
   * whether a package publishes and to which registry, that silent revert was
   * the worst available failure.
   *
   * The composites do not *require* a detector either — nothing inside them
   * asks a publishability question, so their `R` stays `FileSystem | Path`.
   * The requirement instead surfaces in the `R` of each operation that asks
   * (`VersioningStrategy.detect`, e.g.): a program that asks and never wires
   * a detector fails to compile where that operation's `R` must close — which
   * can be far from the layer-wiring site — and a program that never asks
   * never supplies a publish policy at all.
   */
  static readonly layerNpm: Layer.Layer<PublishabilityDetector>;
  /**
   * {@link PublishabilityDetector.none} as a layer: a workspace where nothing
   * publishes.
   *
   * @remarks
   * For dry runs, and for a release tool whose configuration disables
   * publishing wholesale — silk's changeset `mode: "none"` is exactly this.
   */
  static readonly layerNone: Layer.Layer<PublishabilityDetector>;
}
//#endregion
//#region src/ReleaseTag.d.ts
/**
 * Whether one shared tag names a whole release, or one tag names each package.
 *
 * @remarks
 * `single` is the shape of a single-package repo and of a monorepo whose
 * publishable packages all version in lockstep; `scoped` is the shape of
 * independent versioning, where a shared tag would be ambiguous.
 *
 * @public
 */
declare const TagStyle: Schema.Literals<readonly ["single", "scoped"]>;
/**
 * The decoded type of {@link (TagStyle:variable)}: `"single" | "scoped"`.
 *
 * @public
 */
type TagStyle = typeof TagStyle.Type;
/**
 * Formatting knobs for {@link ReleaseTag.single} and {@link ReleaseTag.scoped}.
 *
 * @public
 */
interface TagFormatOptions {
  /**
   * The prefix on the version segment.
   *
   * @remarks
   * Defaults to `""` uniformly, for both {@link ReleaseTag.single} and
   * {@link ReleaseTag.scoped} — strict SemVer, deliberately chosen. Pass
   * `"v"` for the GitHub release-tag convention (`v1.2.3`), which tools such
   * as `actions/checkout`'s ref resolution and third-party changelog
   * generators expect.
   */
  readonly versionPrefix?: string;
}
/**
 * Options for {@link TrackingTag.forVersion}.
 *
 * @public
 */
interface TrackingTagOptions {
  /**
   * Prefix the alias with a package name, for a monorepo that namespaces its
   * tags: `@scope/pkg@v1`. Omit it for a single-package repo's bare `v1`.
   */
  readonly packageName?: string;
  /**
   * Which aliases to derive. `"both"` (the default) gives `v1` and `v1.2`;
   * `"major"` gives only the broad `v1`.
   */
  readonly precision?: "major" | "both";
  /**
   * Derive aliases for a prerelease version too. **Off by default, and you
   * almost certainly want it off** — see {@link TrackingTag.forVersion}.
   */
  readonly includePrerelease?: boolean;
}
declare const TrackingTag_base: Schema.Class<TrackingTag, Schema.Struct<{
  /** The tag string exactly as it appears in git. */
  readonly value: Schema.NonEmptyString;
  /** The package the alias namespaces; absent on a bare `v1`. */
  readonly packageName: Schema.optionalKey<Schema.NonEmptyString>;
  /** The major version the alias tracks. */
  readonly major: Schema.Int;
  /** The minor version, on a `v1.2`-precision alias; absent on `v1`. */
  readonly minor: Schema.optionalKey<Schema.Int>;
}>, {}>;
/**
 * A floating alias tag — `v1`, `v1.2` — that a repo re-points at its newest
 * matching release.
 *
 * @remarks
 * This is the GitHub Actions distribution convention: a consumer writes
 * `uses: owner/repo@v1` and receives whatever 1.x the repo last pointed `v1` at.
 *
 * **Deliberately not SemVer, and deliberately not a {@link (TagStyle:variable)}.**
 * A release tag names one immutable version; a tracking tag is an alias derived
 * *from* a version, carrying a truncated number that is not a version at all.
 * Folding it into `ReleaseTag` as a third style would put a mutable pointer and
 * an immutable name behind one type.
 *
 * Everything here is derivation, formatting and parsing. **Actually moving a
 * git tag is not this package's business** — a consumer does that through git,
 * and the deliberate omission is what keeps this module a pure leaf.
 *
 * @example
 * ```ts
 * import { TrackingTag } from "@effected/workspaces";
 *
 * TrackingTag.forVersion("1.2.3").map((t) => t.value);        // ["v1", "v1.2"]
 * TrackingTag.forVersion("1.0.0-beta.3");                     // [] — never float onto a beta
 * TrackingTag.forVersion("1.2.3", { packageName: "@acme/cli" });
 * // ["@acme/cli@v1", "@acme/cli@v1.2"]
 * ```
 *
 * @public
 */
declare class TrackingTag extends TrackingTag_base {
  /** Whether this alias tracks a whole major line, or one minor line inside it. */
  get precision(): "major" | "minor";
  /**
   * The tracking tags a release of `version` should be pointed at.
   *
   * @remarks
   * **A prerelease derives nothing.** Anyone depending on `owner/repo@v1` is
   * asking for the newest *stable* 1.x, so re-pointing that alias at
   * `1.0.0-beta.3` would ship a prerelease to every such consumer with no
   * signal at all. `includePrerelease` exists for callers who genuinely mean
   * it — a prerelease-only distribution channel — and should be rare.
   *
   * **Total, never throwing.** A version that is not `X.Y.Z` derives nothing
   * rather than failing: this is a query about a version, not a validation of
   * one, and `WorkspacePackage.version` is deliberately tolerant, so odd
   * versions reach here routinely.
   *
   * 0.x versions DO derive aliases. Floating `v0` across 0.x minors is a real
   * hazard, but which aliases to publish is the caller's policy, decided where
   * the tags are moved — not something a derivation should quietly withhold.
   *
   * @param version - The version being released.
   * @param options - Package prefix, precision and the prerelease override.
   * @returns The aliases, broadest first; empty when none apply.
   */
  static forVersion(version: string, options?: TrackingTagOptions): ReadonlyArray<TrackingTag>;
}
/**
 * What an arbitrary tag string denotes.
 *
 * @remarks
 * `unrecognized` is a real answer, not a failure: a repository's tags include
 * branches-turned-tags, `latest`, and whatever else humans wrote, and forcing
 * those into a bucket is exactly what a classifier must not do.
 *
 * @public
 */
type TagClassification = {
  readonly kind: "release";
  readonly tag: ReleaseTag;
} | {
  readonly kind: "tracking";
  readonly tag: TrackingTag;
} | {
  readonly kind: "unrecognized";
};
/**
 * Decide whether a tag string is a release tag, a tracking alias, or neither.
 *
 * @remarks
 * The two families are told apart by **segment count**, not by the `v` prefix:
 * three numeric segments is a version (so `1.0.0` and `v1.0.0` are both release
 * tags), while one or two segments is a truncated alias. The `v` *is* required
 * on an alias — a bare `1` is neither valid SemVer nor the tracking convention,
 * and accepting it would make this function guess.
 *
 * The package prefix splits at the **last** `@`, so a leading npm scope
 * survives: `@scope/pkg@1.0.0` is package `@scope/pkg` at version `1.0.0`.
 *
 * Round-tripping is a tested property: every tag {@link ReleaseTag} and
 * {@link TrackingTag} format classifies back to the family that produced it,
 * with its fields intact.
 *
 * @param tag - Any tag string.
 * @returns The classification.
 *
 * @public
 */
declare const classifyTag: (tag: string) => TagClassification;
declare const ReleaseTag_base: Schema.Class<ReleaseTag, Schema.Struct<{
  /** The tag string exactly as it appears in git. */
  readonly value: Schema.NonEmptyString;
  /** The package the tag names; absent on a workspace-wide single tag. */
  readonly packageName: Schema.optionalKey<Schema.NonEmptyString>;
  /** The version the tag names, without any prefix. */
  readonly version: Schema.NonEmptyString;
  /** Which style produced it. */
  readonly style: Schema.Literals<readonly ["single", "scoped"]>;
}>, {}>;
/**
 * A git tag naming a release, and the parts it was built from.
 *
 * @remarks
 * `value` is the tag exactly as it appears in git; `version` stays **bare**
 * even when `value` carries a prefix, so a consumer comparing versions never
 * has to strip one back off.
 *
 * Formatting is **total**: there is no error channel, because the only failure
 * v3 modelled — an empty version — is caught by `Schema.NonEmptyString` when
 * the value is constructed. A bad version reaching these statics is developer
 * wiring rather than untrusted input, so it dies as a defect, the same posture
 * as an uncompilable glob literal in `WorkspacePackage.matchesDependency`.
 *
 * @example
 * ```ts
 * import { ReleaseTag } from "@effected/workspaces";
 *
 * ReleaseTag.single("1.2.3").value;               // "1.2.3"
 * ReleaseTag.scoped("@acme/cli", "1.2.3").value;  // "@acme/cli@1.2.3"
 * ReleaseTag.scoped("cli", "1.2.3").value;        // "cli@1.2.3"
 * ReleaseTag.scoped("cli", "1.2.3", { versionPrefix: "v" }).value; // "cli@v1.2.3"
 * ```
 *
 * @public
 */
declare class ReleaseTag extends ReleaseTag_base {
  /**
   * One shared tag for a whole release: `1.2.3`.
   *
   * @param version - The version being released. Must not be empty.
   * @param options - Formatting overrides.
   */
  static single(version: string, options?: TagFormatOptions): ReleaseTag;
  /**
   * A per-package tag: `<packageName>@<version>` — `@scope/pkg@1.2.3` for a
   * scoped name, `pkg@1.2.3` for an unscoped one, uniformly, unless
   * `options.versionPrefix` says otherwise.
   *
   * @param packageName - The package being released. Must not be empty.
   * @param version - The version being released. Must not be empty.
   * @param options - Formatting overrides.
   */
  static scoped(packageName: string, version: string, options?: TagFormatOptions): ReleaseTag;
}
//#endregion
//#region src/VersioningStrategy.d.ts
/**
 * How a workspace assigns versions across its publishable packages.
 *
 * @remarks
 * - `single` — zero or one publishable package, so one tag names the release.
 * - `fixed-group` — every publishable package sits inside one group that
 *   versions in lockstep, so one tag still names the release.
 * - `independent` — publishable packages version separately, so a shared tag
 *   would be ambiguous and each package needs its own.
 *
 * @public
 */
declare const VersioningStrategyType: Schema.Literals<readonly ["single", "fixed-group", "independent"]>;
/**
 * The decoded type of {@link (VersioningStrategyType:variable)}.
 *
 * @public
 */
type VersioningStrategyType = typeof VersioningStrategyType.Type;
/**
 * Arguments to {@link VersioningStrategy.classify}.
 *
 * @public
 */
interface ClassifyOptions {
  /** Publishable package names, in any order. Duplicates are collapsed. */
  readonly packages: ReadonlyArray<string>;
  /**
   * Groups of packages that version in lockstep.
   *
   * @remarks
   * A **plain argument, deliberately.** Fixed groups are a release tool's
   * concept — changesets writes them to `.changeset/config.json` — and a
   * workspace-model package that read that file would be taking on one tool's
   * schema and one tool's release policy. The caller reads its own tool's
   * config and hands the groups in. Groups may name packages that are not
   * publishable, or do not exist; only whether some single group covers the
   * whole publishable set matters.
   */
  readonly fixedGroups?: ReadonlyArray<ReadonlyArray<string>>;
}
/**
 * Arguments to {@link VersioningStrategy.detect}.
 *
 * @public
 */
interface VersioningDetectOptions {
  /** See {@link ClassifyOptions.fixedGroups}. Defaults to none. */
  readonly fixedGroups?: ReadonlyArray<ReadonlyArray<string>>;
}
/**
 * One entry in a release batch: which package went out, at which version.
 *
 * @remarks
 * Deliberately structural and minimal — a caller passes whatever it already
 * has (a publish result, a changeset plan row) without projecting it into a
 * package-specific type first.
 *
 * @public
 */
interface PackageRelease {
  /** The package that was released. */
  readonly name: string;
  /** The version it was released at. */
  readonly version: string;
}
declare const VersioningStrategy_base: Schema.Class<VersioningStrategy, Schema.Struct<{
  /** The classification. */
  readonly type: Schema.Literals<readonly ["single", "fixed-group", "independent"]>;
  /** The groups classification was performed against, as supplied. */
  readonly fixedGroups: Schema.$Array<Schema.$Array<Schema.String>>;
  /** The publishable package names, sorted and de-duplicated. */
  readonly publishablePackages: Schema.$Array<Schema.String>;
}>, {}>;
/**
 * How a workspace versions, and the tagging that follows from it.
 *
 * @remarks
 * Built either purely with {@link VersioningStrategy.classify}, or from a live
 * workspace with {@link VersioningStrategy.detect}.
 *
 * @example
 * ```ts
 * import { VersioningStrategy } from "@effected/workspaces";
 * import { Effect } from "effect";
 *
 * const program = Effect.gen(function* () {
 *   const strategy = yield* VersioningStrategy.detect({ fixedGroups });
 *   return strategy.tagsFor(released).map((tag) => tag.value);
 * });
 * ```
 *
 * @public
 */
declare class VersioningStrategy extends VersioningStrategy_base {
  /**
   * Whether a release needs one tag per package rather than one shared tag.
   */
  get perPackageTags(): boolean;
  /** The tag style this strategy implies. */
  get tagStyle(): TagStyle;
  /**
   * Classify a workspace from its publishable package names and fixed groups.
   *
   * @remarks
   * Pure and total — no IO, no error channel. `packages` is sorted and
   * de-duplicated first, so a name listed twice cannot inflate a one-package
   * repo into an independent one.
   */
  static classify(options: ClassifyOptions): VersioningStrategy;
  /**
   * Classify the ambient workspace: enumerate its packages, keep the ones the
   * {@link PublishabilityDetector} says publish somewhere, and classify those.
   *
   * @remarks
   * The publishability question is asked through the service precisely so a
   * consumer with its own rules — honouring a release tool's ignore list, say —
   * swaps the layer instead of filtering afterwards.
   */
  static readonly detect: (options?: VersioningDetectOptions | undefined) => Effect.Effect<VersioningStrategy, WorkspaceDiscoveryFailure, PublishabilityDetector | WorkspaceDiscovery>;
  /**
   * The tags a release of `releases` produces under this strategy.
   *
   * @remarks
   * Under `independent` this is one {@link ReleaseTag} per release, in the
   * order given. Under `single` and `fixed-group` it is exactly one shared tag
   * carrying the **first** release's version — every release in a lockstep
   * batch shares a version by construction, so the choice is only visible on a
   * batch that should not exist. Whether a batch actually agreed is a property
   * of that batch rather than of the workspace, so it stays the caller's
   * one-line check rather than a field here.
   *
   * An empty batch produces no tags under either style.
   */
  tagsFor(releases: ReadonlyArray<PackageRelease>, options?: TagFormatOptions): ReadonlyArray<ReleaseTag>;
}
//#endregion
//#region src/WorkspaceCatalogs.d.ts
/**
 * Each importer's dependency-name → resolved-version map, keyed by importer path
 * (`"."` for the root package — the same keys `WorkspaceDiscovery.importerMap()`
 * uses, and the same value `PackageStateSnapshot.relativePath` carries).
 *
 * @remarks
 * What a manager's lockfile records as actually installed, as opposed to what a
 * manifest declares. It answers a `catalog:` specifier no committed catalog
 * source declares — the shape a pnpm config-dependency pnpmfile hook produces —
 * which would otherwise resolve to nothing on both sides of a diff and hide a
 * real version movement.
 *
 * Versions are normalized: pnpm's peer-disambiguation suffix
 * (`1.2.3(effect@4.0.0)`) is stripped, and `link:` / `file:` entries are omitted
 * because a filesystem edge is not a version. Only pnpm records importer
 * versions; bun and npm yield an empty index.
 *
 * @public
 */
type ImporterVersions = Readonly<Record<string, Readonly<Record<string, string>>>>;
declare const CatalogSet_base: Schema.Class<CatalogSet, Schema.Struct<{
  /** Catalog name → dependency name → version range. */
  readonly entries: Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.String>>;
}>, {}>;
/**
 * An immutable, fully-normalized catalog collection — the one catalog
 * resolution semantic in the package.
 *
 * @remarks
 * `entries` is catalog name → dependency → range, with pnpm's unnamed
 * top-level `catalog:` block normalized under the key `"default"`. Lockfile
 * catalog entries, which pnpm records as `{ specifier, version }`, are
 * normalized to their `specifier` — the declared range, which is what a catalog
 * resolves to.
 *
 * @public
 */
declare class CatalogSet extends CatalogSet_base {
  /** The empty set — a workspace with no catalogs. */
  static empty(): CatalogSet;
  /** Wrap a pnpm `Catalogs` map, dropping unusable entries. */
  static fromCatalogs(catalogs: unknown): CatalogSet;
  /**
   * The `catalog:` and `catalogs:` blocks of a `pnpm-workspace.yaml` document.
   *
   * @param text - The raw YAML text.
   */
  static readonly fromWorkspaceYaml: (text: string) => Effect.Effect<CatalogSet, CatalogAssemblyError, never>;
  /**
   * The `catalogs:` section of a pnpm lockfile, whose entries are either a bare
   * range or a `{ specifier, version }` pair.
   */
  static fromLockfileCatalogs(raw: unknown): CatalogSet;
  /**
   * The catalog set a parsed lockfile records, PM-aware.
   *
   * @remarks
   * Both pnpm and bun record catalogs in the lockfile, in different shapes:
   * pnpm under `extension.catalogs`, bun under `extension.catalog` /
   * `extension.catalogs`. Assembly reads whichever the parsed lockfile carries
   * rather than assuming the pnpm extension. A lockfile with no extension, or a
   * pnpm one with no catalogs, yields the empty set.
   *
   * @param lockfile - A parsed lockfile from `@effected/lockfiles`.
   */
  static fromLockfile(lockfile: Lockfile): CatalogSet;
  /**
   * A catalog set from bun's `{ catalog, catalogs }` blocks — used for the
   * `bun.lock` extension and for the root `package.json` `workspaces` block. The
   * unnamed default catalog normalizes under `"default"`. Tolerant: unusable
   * values are dropped, never fatal.
   *
   * @param blocks - The `catalog` (default) and `catalogs` (named) blocks.
   */
  static fromBunBlocks(blocks: {
    readonly catalog?: unknown;
    readonly catalogs?: unknown;
  }): CatalogSet;
  /**
   * The `catalog` / `catalogs` blocks of a root `package.json` `workspaces` field
   * — bun's package.json analogue of pnpm's `pnpm-workspace.yaml` blocks.
   *
   * @remarks
   * **Hard-fail by design**, preserving the semantics catalog output is
   * load-bearing for: a present-but-malformed `workspaces` shape (a number, a
   * string, an object with a malformed `packages` / `catalog` / `catalogs`), or
   * the default catalog declared twice — once as `workspaces.catalog` and again
   * as `workspaces.catalogs.default` — fails with `CatalogAssemblyError`
   * naming what was wrong. An absent `workspaces` field, one explicitly `null`,
   * or the plain array form (npm/yarn patterns, which carry no catalogs) yields
   * the empty set. Presence is checked structurally, so an explicitly-declared
   * empty `catalog: {}` still counts as a declaration.
   *
   * @param text - The raw root `package.json` text.
   */
  static readonly fromManifestWorkspaces: (text: string) => Effect.Effect<CatalogSet, CatalogAssemblyError, never>;
  /** Merge sets. Later sets win per dependency within a catalog. */
  static merge(...sets: ReadonlyArray<CatalogSet>): CatalogSet;
  /** Whether any catalog declares anything. */
  get isEmpty(): boolean;
  /**
   * The range a `catalog:` specifier resolves to.
   *
   * @remarks
   * Total: an unmatched dependency, an unknown catalog name, or a non-catalog
   * specifier all yield `Option.none()`. A *malformed* catalog — one pnpm
   * itself rejects — also yields `Option.none()` here; the fallible surface is
   * {@link WorkspaceCatalogs}, which fails typed on assembly instead.
   *
   * @param dependency - The package name being resolved.
   * @param specifier - The declared specifier, e.g. `catalog:` or `catalog:build`.
   */
  resolveSpecifier(dependency: string, specifier: string): Option.Option<string>;
  /**
   * The range `dependency` carries in a named catalog, or in the default
   * catalog when `catalog` is `Option.none()`.
   *
   * @remarks
   * The shape `@effected/npm`'s `CatalogResolver` contract asks for.
   */
  rangeOf(dependency: string, catalog: Option.Option<string>): Option.Option<string>;
}
/**
 * Every failure catalog assembly can surface.
 *
 * @public
 */
type CatalogAssemblyFailure = CatalogAssemblyError | WorkspaceRootNotFoundError;
/**
 * The {@link WorkspaceCatalogs} service shape.
 *
 * @public
 */
interface WorkspaceCatalogsShape {
  /** The assembled catalog set for the workspace. Memoized after the first call. */
  readonly set: () => Effect.Effect<CatalogSet, CatalogAssemblyFailure>;
  /** Resolve one `catalog:` specifier; `Option.none()` when it names nothing. */
  readonly resolveSpecifier: (dependency: string, specifier: string) => Effect.Effect<Option.Option<string>, CatalogAssemblyFailure>;
  /**
   * The effective pnpm release-age gate for the workspace, combined
   * strictest-wins from the inline `pnpm-workspace.yaml` keys
   * (`minimumReleaseAge` / `minimumReleaseAgeExclude`) and the replayed
   * config-dependency hooks. Assembled from the same single read and hook
   * replay as `set`, and memoized with it.
   *
   * @remarks
   * Under the default layer (no-op hooks) only inline values contribute; under
   * {@link WorkspaceCatalogs.layerWithConfigDependencies} the replayed hooks
   * contribute too. A workspace with no pnpm-workspace.yaml (a bun/npm
   * workspace) has no release-age keys, so the gate is the inert zero gate.
   */
  readonly releaseAgeGate: () => Effect.Effect<ReleaseAgeGate, CatalogAssemblyFailure>;
  /**
   * The workspace's **effective** `peerDependencyRules` — pnpm's post-hoc
   * suppression policy, which the lockfile does not record at all.
   *
   * @remarks
   * Assembled from the same single read and hook replay as `set`, and memoized
   * with it. The `pnpm-workspace.yaml` block (what `pnpm:export` materializes)
   * is **seeded** into the replayed config and the config-dependency hooks
   * merge onto it, so one object carries both sources — the kit never merges
   * them itself, because that would be a second implementation of a rule the
   * hook seam already enforces.
   *
   * A consumer needs these to avoid **reporting** what pnpm suppresses: pnpm
   * computes the same peer violations and then hides the ones a rule allows,
   * so a checker without them reports findings pnpm calls clean.
   *
   * `ignoreMissing` and `allowAny` are carried but unmeasured — no kit code
   * acts on them today.
   */
  readonly peerDependencyRules: () => Effect.Effect<PeerDependencyRules, CatalogAssemblyFailure>;
  /**
   * Each importer's dependency-name → resolved-version map, as the manager's
   * lockfile records it. Read from the same single lockfile read as `set`, and
   * memoized with it.
   *
   * @remarks
   * Feeds `WorkspaceStateSnapshot`'s fallback for a `catalog:` specifier no
   * committed catalog source declares — the shape a config-dependency pnpmfile
   * hook produces. Only pnpm records importer versions; a bun or npm workspace
   * yields an empty index, and an absent or unreadable lockfile contributes
   * nothing rather than failing.
   */
  readonly importerVersions: () => Effect.Effect<ImporterVersions, CatalogAssemblyFailure>;
  /**
   * Discard the memoized assembly so the **next** read re-assembles — the same
   * single read and hook replay as the first, over the workspace as it stands
   * then.
   *
   * @remarks
   * The explicit memoization boundary for a tool that **mutates the workspace
   * mid-run** — installs, bumps a config dependency, regenerates the lockfile.
   * Release-age gating wants the before-state, a post-install peer check the
   * after-state, and one infinite memo cannot serve both without this call in
   * between; without it, `peerDependencyRules` keeps answering from the
   * pre-mutation hook replay and the checker reports findings the new rules
   * suppress.
   *
   * Unconditional and infallible: the memo is already success-only (a failed
   * or interrupted assembly retries by itself), so `refresh` exists solely to
   * discard a *successful* assembly that mutation has made stale. Calling it
   * before any read is harmless.
   */
  readonly refresh: () => Effect.Effect<void>;
}
/**
 * Options for the {@link WorkspaceCatalogs} layer.
 *
 * @public
 */
interface WorkspaceCatalogsOptions {
  /**
   * The directory the workspace root is resolved from.
   *
   * @defaultValue `process.cwd()`, read lazily on first use.
   */
  readonly cwd?: string;
}
declare const WorkspaceCatalogs_base: Context.ServiceClass<WorkspaceCatalogs, "@effected/workspaces/WorkspaceCatalogs", WorkspaceCatalogsShape>;
/**
 * Assembles a workspace's catalogs, package-manager-aware.
 *
 * @remarks
 * The inline source is picked by **file presence**, the same rule
 * `internal/patterns.ts` uses for globs: a `pnpm-workspace.yaml` selects the pnpm
 * path (its `catalog:` / `catalogs:` blocks); its absence selects the root
 * `package.json` `workspaces.catalog` / `workspaces.catalogs` (bun's analogue).
 * The lockfile source is PM-aware too — whichever extension the parsed lockfile
 * carries (pnpm or bun) contributes its recorded catalogs.
 *
 * Precedence, lowest first: catalogs recorded in the lockfile, then the inline
 * declaration, then — only under {@link WorkspaceCatalogs.layerWithConfigDependencies}
 * — the config-dependency `pnpmfile.cjs` hooks, each layer winning per dependency
 * within a catalog. An unreadable or absent lockfile degrades to no lockfile
 * catalogs rather than failing (the inline declaration is the source of truth, the
 * lockfile a record of what was installed); a malformed inline source **fails
 * typed** with `CatalogAssemblyError`, because a silently-empty catalog read
 * is the "every dependency looks newly added" bug.
 *
 * Assembly is deferred to the first call and memoized success-only, matching
 * {@link WorkspaceDiscovery}.
 *
 * @public
 */
declare class WorkspaceCatalogs extends WorkspaceCatalogs_base {
  /** Builds the service. */
  static readonly make: (options?: WorkspaceCatalogsOptions) => Effect.Effect<WorkspaceCatalogsShape, never, WorkspaceRoot | LockfileReader | ConfigDependencyHooks | FileSystem.FileSystem | Path.Path>;
  /**
   * The live layer — the default, which **never executes config-dependency
   * code**: it wires {@link ConfigDependencyHooks.layerNoop}, whose hooks return
   * the inline-catalog seed untouched.
   *
   * @remarks
   * Parameterized, so it mints a fresh reference per call — bind it to a
   * `const` and reuse it, or layer memoization does not apply.
   */
  static readonly layer: (options?: WorkspaceCatalogsOptions) => Layer.Layer<WorkspaceCatalogs, never, WorkspaceRoot | LockfileReader | FileSystem.FileSystem | Path.Path>;
  /**
   * The opt-in live layer that **does** replay config-dependency `pnpmfile.cjs`
   * hooks: it wires {@link ConfigDependencyHooks.layerLive}, which dynamically
   * imports and runs each config dependency's `updateConfig` in process.
   *
   * @remarks
   * Same output and requirement set as {@link WorkspaceCatalogs.layer} — the only
   * difference is that config-dependency code is executed. Use it deliberately;
   * the default catalog path stays free of any config-dependency execution.
   * Parameterized, so bind it to a `const` and reuse it.
   */
  static readonly layerWithConfigDependencies: (options?: WorkspaceCatalogsOptions) => Layer.Layer<WorkspaceCatalogs, never, WorkspaceRoot | LockfileReader | FileSystem.FileSystem | Path.Path>;
  /**
   * The opt-in layer that replays config-dependency `pnpmfile` hooks in a
   * `node` **child process**: it wires
   * {@link ConfigDependencyHooks.layerSubprocess} in place of the in-process
   * `layerLive`.
   *
   * @remarks
   * Same typed semantics as {@link WorkspaceCatalogs.layerWithConfigDependencies}
   * — the two hook layers are drop-in interchangeable — but the replay's
   * computed dynamic `import()` runs in the subprocess, so it survives bundling
   * (a bundler compiles a computed in-process `import()` into a context module
   * that cannot resolve at runtime — every bundled GitHub Action hits this).
   * The cost is one extra requirement: core's `ChildProcessSpawner`, provided
   * once at the edge (`@effect/platform-node`'s `NodeServices.layer`) — the
   * same sanctioned R-widening as `Workspaces.layerWithGit`. Parameterized, so
   * bind it to a `const` and reuse it.
   */
  static readonly layerWithConfigDependenciesSubprocess: (options?: WorkspaceCatalogsOptions) => Layer.Layer<WorkspaceCatalogs, never, WorkspaceRoot | LockfileReader | FileSystem.FileSystem | Path.Path | ChildProcessSpawner.ChildProcessSpawner>;
  /**
   * A test double satisfying the full {@link WorkspaceCatalogsShape} with no
   * filesystem, lockfile read, or hook replay.
   *
   * @remarks
   * There is **no honest default catalog set**: an empty `CatalogSet` that
   * looks like a legitimate answer is the "every dependency looks newly added"
   * failure class the live assembler hard-fails to prevent, so every method
   * **dies** with an instructive defect until stubbed — a test-wiring mistake
   * fails loudly as a defect rather than succeeding with a lie or failing with
   * a dishonest typed error.
   *
   * The one derivation mirrors `WorkspaceDiscovery.makeTest`'s
   * derived-from-the-primary rule: when a `set` override is supplied,
   * `resolveSpecifier` answers from that `CatalogSet`'s own
   * {@link CatalogSet.resolveSpecifier} — exactly what the live service runs
   * over its assembled set — so the two stay consistent by construction.
   * `releaseAgeGate` and `importerVersions` are **not** derivable from a
   * catalog set (the gate comes from release-age keys and hook contributions,
   * the importer index from the lockfile's importer blocks — neither is in a
   * `CatalogSet`) and always die unless stubbed.
   *
   * `refresh` defaults to `Effect.void` honestly: the double holds no memo,
   * so "drop the memoized assembly" is genuinely a no-op — the stubs answer
   * fresh on every call already. This mirrors `WorkspaceDiscovery.makeTest`'s
   * `refresh`.
   *
   * @example
   * ```ts
   * import { CatalogSet, WorkspaceCatalogs } from "@effected/workspaces";
   * import { Effect } from "effect";
   *
   * const double = WorkspaceCatalogs.makeTest({
   *   set: () => Effect.succeed(CatalogSet.fromCatalogs({ default: { effect: "4.0.0" } })),
   * });
   * // `resolveSpecifier` now answers consistently from that set.
   * ```
   */
  static readonly makeTest: (overrides?: Partial<WorkspaceCatalogsShape>) => WorkspaceCatalogsShape;
  /**
   * The test layer: {@link WorkspaceCatalogs.makeTest} behind `Layer.succeed`,
   * so a suite provides only the methods it exercises.
   *
   * @remarks
   * A parameterized layer factory mints a **fresh reference per call**, and
   * layers memoize by reference — bind the result to a `const` and reuse it
   * rather than calling `layerTest(...)` at each composition site.
   *
   * @example
   * ```ts
   * import { CatalogSet, WorkspaceCatalogs } from "@effected/workspaces";
   * import { Effect } from "effect";
   *
   * const TestCatalogs = WorkspaceCatalogs.layerTest({
   *   set: () => Effect.succeed(CatalogSet.empty()),
   * });
   * // program.pipe(Effect.provide(TestCatalogs))
   * ```
   */
  static readonly layerTest: (overrides?: Partial<WorkspaceCatalogsShape>) => Layer.Layer<WorkspaceCatalogs>;
  /**
   * The real implementation of `@effected/npm`'s `CatalogResolver` contract —
   * the one `@effected/package-json` declares but cannot fill.
   *
   * @remarks
   * `rangeOf` returns `Option.none()` for a dependency no catalog declares, per
   * the contract's convention. A failed catalog *assembly* — an unreadable or
   * malformed `pnpm-workspace.yaml`, a broken config-dependency hook — passes
   * through **typed** as the contract's `CatalogAssemblyError` (it used to be
   * folded into `DependencyResolutionError`'s defect `cause`, which forced
   * consumers to `_tag`-sniff `unknown`); only the remaining mechanism failure,
   * an unfindable workspace root, is wrapped as `DependencyResolutionError`.
   */
  static readonly catalogResolver: Layer.Layer<CatalogResolver, never, WorkspaceCatalogs>;
}
//#endregion
//#region src/WorkspaceStateSnapshot.d.ts
declare const PackageStateSnapshot_base: Schema.Class<PackageStateSnapshot, Schema.Struct<{
  /** The package name. */
  readonly name: Schema.NonEmptyString;
  /** The raw `version` string, as recorded at the captured moment. */
  readonly version: Schema.String;
  /** POSIX path relative to the workspace root; `"."` for the root package. */
  readonly relativePath: Schema.String;
  /** Production dependencies. */
  readonly dependencies: Schema.withConstructorDefault<Schema.withDecodingDefaultKey<Schema.$Record<Schema.String, Schema.String>, never>>;
  /** Development dependencies. */
  readonly devDependencies: Schema.withConstructorDefault<Schema.withDecodingDefaultKey<Schema.$Record<Schema.String, Schema.String>, never>>;
  /** Peer dependencies. */
  readonly peerDependencies: Schema.withConstructorDefault<Schema.withDecodingDefaultKey<Schema.$Record<Schema.String, Schema.String>, never>>;
  /** Optional dependencies. */
  readonly optionalDependencies: Schema.withConstructorDefault<Schema.withDecodingDefaultKey<Schema.$Record<Schema.String, Schema.String>, never>>;
}>, {}>;
/**
 * One workspace member as captured in a {@link WorkspaceStateSnapshot} — the
 * serializable slice a snapshot diff reads: identity, version, location, and the
 * four dependency records.
 *
 * @remarks
 * Deliberately narrower than {@link WorkspacePackage}: a snapshot is a value to
 * store and diff, not a located member to act on, so it carries no absolute
 * paths, `publishConfig`, or `private` flag. The four records are keyed by the
 * standard manifest field names, which are exactly `@effected/npm`'s
 * `DependencyField` values.
 *
 * @public
 */
declare class PackageStateSnapshot extends PackageStateSnapshot_base {
  /**
   * Every dependency, merged across the four kinds.
   *
   * @remarks
   * Precedence on a name declared in several kinds runs
   * `dependencies` \> `devDependencies` \> `peerDependencies` \>
   * `optionalDependencies`.
   */
  get allDependencies(): Record<string, string>;
}
declare const WorkspaceStateSnapshot_base: Schema.Class<WorkspaceStateSnapshot, Schema.Struct<{
  /** Every workspace package captured at this moment. */
  readonly packages: Schema.$Array<typeof PackageStateSnapshot>;
  /** The catalog set assembled at this moment. */
  readonly catalogs: typeof CatalogSet;
  /**
   * Each importer's dependency-name → resolved-version map, as the manager's
   * lockfile recorded it at this moment.
   *
   * @remarks
   * Defaults to `{}`, so a `WorkspaceStateSnapshot` serialized before this field
   * existed still decodes — and an empty index simply makes the `catalog:`
   * fallback in {@link WorkspaceStateSnapshot.resolve} inert, which is exactly
   * the behavior those older values were captured under. Only pnpm records
   * importer versions; bun and npm yield an empty index.
   */
  readonly importerVersions: Schema.optionalKey<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.String>>>;
  /**
   * Catalogs supplied from OUTSIDE this moment, consulted only when
   * `catalogs` cannot answer.
   *
   * @remarks
   * **This is deliberately not merged into `catalogs`.** That field means "the
   * catalog set assembled at this moment" and a snapshot is a serializable
   * value someone stores and diffs; blending an external set into it would
   * quietly make the field mean something else, and nothing downstream could
   * tell the two apart afterwards. Kept separate, the ref's own declaration
   * always wins and both halves stay readable.
   *
   * The motivating case is a catalog injected by a config-dependency
   * `pnpmfile` hook. It is recorded in no committed catalog source, so
   * `WorkspaceSnapshots.at(ref)` — which never replays hooks, by design — cannot
   * see it, and a `catalog:` specifier against it resolves to nothing on BOTH
   * sides of a diff. Seeding the live hook-injected set, or the other side's
   * set, restores a declared RANGE without executing any historical code.
   *
   * Defaults to absent, which makes the seed inert — exactly the behavior of
   * every snapshot captured before this field existed.
   */
  readonly seededCatalogs: Schema.optionalKey<typeof CatalogSet>;
}>, {}>;
/**
 * The state of a whole workspace at one moment — its packages and its assembled
 * catalog set — as a serializable value.
 *
 * @remarks
 * Produced by `WorkspaceSnapshots.at` (a git ref, read with no checkout)
 * or `WorkspaceSnapshots.worktree` (the live tree). The lookup and
 * resolution surfaces (`versions`, `package`, `resolve`, the resolver layers)
 * are backed by `#private` indexes built lazily on first use and never encoded —
 * the `DependencyGraph` edge-index precedent.
 *
 * `resolve` and the resolver layers answer specifiers against THIS snapshot's
 * own captured state, so a consumer can ask "what did `catalog:` /
 * `workspace:*` mean as of that ref". An unmatched specifier is always
 * `Option.none()`, never an error.
 *
 * @example
 * ```ts
 * import { WorkspaceSnapshots } from "@effected/workspaces";
 * import { Effect } from "effect";
 *
 * const program = Effect.gen(function* () {
 *   const snapshots = yield* WorkspaceSnapshots;
 *   const before = yield* snapshots.at("origin/main");
 *   return before.resolve("effect", "catalog:");
 * });
 * ```
 *
 * @public
 */
declare class WorkspaceStateSnapshot extends WorkspaceStateSnapshot_base {
  #private;
  /** Every captured package's name → version. Total; O(1) after the first call. */
  get versions(): ReadonlyMap<string, string>;
  /** A single captured package by name, or `Option.none()`. Total. */
  package(name: string): Option.Option<PackageStateSnapshot>;
  /**
   * The concrete range or version a specifier resolved to AS OF this snapshot.
   *
   * @remarks
   * The specifier is classified through `@effected/npm`'s
   * `DependencySpecifier.FromString` — never by prefix-sniffing.
   * A `workspace:` specifier resolves to the captured version of `dependency`; a
   * `catalog:` specifier resolves against the captured catalog set. Every other
   * form — a plain range, a dist-tag, a `file:`/git/url specifier, or an
   * unparseable string — is `Option.none()`, because there is no indirection to
   * resolve. Total.
   *
   * A `catalog:` specifier resolves in three steps, and the order is the
   * contract: this moment's own `catalogs` first,
   * then `seededCatalogs` if one was supplied,
   * then the `importerVersions` fallback below. The first two answer with a
   * declared RANGE and the third with a concrete version, so a seeded snapshot
   * reports a range change where an unseeded one could only report a version —
   * which is the difference between a diff row and no row when both refs
   * recorded the same installed version.
   *
   * A `catalog:` specifier neither catalog set can resolve falls back to this
   * snapshot's `importerVersions` — but only to a version
   * **every** importer recording that dependency agrees on. A catalog injected
   * by a config-dependency pnpmfile hook appears in no committed catalog source,
   * so without this fallback both sides of a before/after diff resolve it to the
   * same raw string and a real version movement produces no row. When importers
   * disagree there is no single correct answer, so this stays `Option.none()`
   * rather than inventing one; {@link WorkspaceStateSnapshot.resolveIn} answers
   * precisely for callers that know which importer is asking.
   *
   * @param dependency - The dependency's package name (what `workspace:` /
   *   `catalog:` resolve for).
   * @param specifier - The raw specifier string.
   */
  resolve(dependency: string, specifier: string): Option.Option<string>;
  /**
   * The concrete range or version a specifier resolved to AS OF this snapshot,
   * scoped to the importer that declared it.
   *
   * @remarks
   * Identical to {@link WorkspaceStateSnapshot.resolve} except in how an
   * unresolvable `catalog:` specifier falls back: this consults **only**
   * `importerPath`'s own recorded versions, so a monorepo whose packages hold
   * different versions of one dependency still gets an exact answer where
   * `resolve` must abstain. Prefer this whenever the caller knows the importer —
   * a consumer iterating `packages` has `relativePath` in hand, which is the
   * importer key (`"."` for the root package).
   *
   * An unknown `importerPath`, or one recording nothing for `dependency`, is
   * `Option.none()`. Total.
   *
   * @param importerPath - The importer's path relative to the workspace root,
   *   `"."` for the root package — `PackageStateSnapshot.relativePath`.
   * @param dependency - The dependency's package name.
   * @param specifier - The raw specifier string.
   */
  resolveIn(importerPath: string, dependency: string, specifier: string): Option.Option<string>;
  /**
   * This snapshot with `seed` as its `seededCatalogs`
   * — catalogs consulted only where this moment's own catalogs cannot answer.
   *
   * @remarks
   * Returns a NEW snapshot; the receiver is untouched, and the seed REPLACES
   * any seed already present rather than merging with it (a snapshot is a
   * value, and an accumulating seed would make precedence depend on call
   * order). {@link WorkspaceStateSnapshot.crossSeed} is the deliberate
   * exception: it composes the two seeds explicitly, precisely because a bare
   * replace would discard a layer-level seed. `catalogs`, `packages` and `importerVersions` are carried through
   * unchanged, so what the ref declared is still exactly what it declared.
   *
   * The two seeds worth reaching for: the LIVE hook-injected catalog set (from
   * a `WorkspaceCatalogs` built by one of the config-dependency layers), or the
   * other side of a two-ref diff — see
   * {@link WorkspaceStateSnapshot.crossSeed}.
   *
   * @param seed - The catalogs to consult as a fallback.
   *
   * @example
   * ```ts
   * import { WorkspaceCatalogs, WorkspaceSnapshots } from "@effected/workspaces";
   * import { Effect } from "effect";
   *
   * const program = Effect.gen(function* () {
   *   const snapshots = yield* WorkspaceSnapshots;
   *   const catalogs = yield* WorkspaceCatalogs;
   *   // The live set includes hook-injected catalogs under a config-dependency
   *   // layer; the ref's own set never can.
   *   const live = yield* catalogs.set();
   *   const before = (yield* snapshots.at("origin/main")).withSeededCatalogs(live);
   *   return before.resolve("effect", "catalog:");
   * });
   * ```
   */
  withSeededCatalogs(seed: CatalogSet): WorkspaceStateSnapshot;
  /**
   * Both sides of a diff, each seeded with the other's catalogs.
   *
   * @remarks
   * The two-ref symmetry the hook-catalog gap actually needs. A catalog
   * injected by a config-dependency hook is declared in no committed source,
   * so neither ref's snapshot can see it and a `catalog:` specifier against it
   * resolves to nothing on both sides — a real version movement then produces
   * no row. Cross-seeding restores a declared RANGE on whichever side is
   * missing it, at strictly lower precedence than that side's own catalogs, so
   * a genuine change between the refs still reads as a change.
   *
   * **The limitation is inherent and is not a defect to work around.** A range
   * change made purely by bumping the config dependency BETWEEN the two refs is
   * suppressed: neither committed source declares the catalog, so each side
   * falls back to the other's value and the two agree by construction. Seeding
   * the live hook-injected set via
   * {@link WorkspaceStateSnapshot.withSeededCatalogs} has the same blind spot
   * against history — recovering it would mean replaying each ref's pinned
   * config-dependency code, which `at(ref)` will not do. If that case must be
   * detected, diff `configDependencies` in `pnpm-workspace.yaml` directly; it
   * is the only committed evidence that the injection changed.
   *
   * **The seeding relationship is symmetric; the RETURN ORDER is not.** Each
   * snapshot is seeded with the other's catalogs, so neither argument is
   * privileged and swapping them produces the same two values — but they come
   * back mirroring the order they went in, so destructure in the order you
   * passed. The `before`/`after` names describe the intended calling
   * convention for a two-ref diff, not a constraint on what may be passed.
   *
   * **A seed already present on either snapshot is preserved**, beneath the
   * other side's catalogs — which matters because
   * `WorkspaceSnapshotsOptions.seedCatalogs` puts one there on every snapshot
   * the service returns. Composing the two surfaces is therefore safe: the
   * layer-level seed keeps answering what neither ref declared, while the
   * other ref's committed declaration wins where it has one.
   *
   * @param before - One snapshot, conventionally the earlier one.
   * @param after - The other snapshot, conventionally the later one.
   * @returns Both snapshots in the order given, each carrying the other's
   *   catalogs as its seed.
   *
   * @example
   * ```ts
   * import { WorkspaceSnapshots, WorkspaceStateSnapshot } from "@effected/workspaces";
   * import { Effect } from "effect";
   *
   * const program = Effect.gen(function* () {
   *   const snapshots = yield* WorkspaceSnapshots;
   *   const [before, after] = WorkspaceStateSnapshot.crossSeed(
   *     yield* snapshots.at("origin/main"),
   *     yield* snapshots.worktree(),
   *   );
   *   return { before: before.resolve("effect", "catalog:"), after: after.resolve("effect", "catalog:") };
   * });
   * ```
   */
  static crossSeed(before: WorkspaceStateSnapshot, after: WorkspaceStateSnapshot): readonly [WorkspaceStateSnapshot, WorkspaceStateSnapshot];
  /**
   * A `CatalogResolver` layer implementing `@effected/npm`'s contract against
   * THIS snapshot's catalog set — so code written to the contract resolves
   * `catalog:` specifiers as of this ref. Built once per instance and cached, so
   * it memoizes by reference.
   *
   * @remarks
   * The contract's error channel (`CatalogAssemblyError` /
   * `DependencyResolutionError`) is satisfied vacuously: a snapshot's catalogs
   * were already assembled when it was captured, so this resolver is total —
   * `rangeOf` never fails.
   */
  get catalogResolver(): Layer.Layer<CatalogResolver>;
  /**
   * A `WorkspaceResolver` layer implementing `@effected/npm`'s contract against
   * THIS snapshot's captured versions — so code written to the contract resolves
   * `workspace:` specifiers as of this ref. Built once per instance and cached.
   */
  get workspaceResolver(): Layer.Layer<WorkspaceResolver>;
  /** Both snapshot-scoped resolver layers merged. Built once per instance and cached. */
  get resolvers(): Layer.Layer<CatalogResolver | WorkspaceResolver>;
}
//#endregion
//#region src/WorkspaceSnapshots.d.ts
/**
 * Every failure `WorkspaceSnapshots.at` can surface: git's own typed
 * errors, a catalog-assembly failure from the inline config source at the ref,
 * or an unfindable workspace root.
 *
 * @remarks
 * Narrow by design. `at` reads through git and never enumerates the live
 * filesystem, so no `WorkspaceDiscoveryError` / `WorkspacePatternError` appears —
 * and a malformed *lockfile* at the ref degrades to no catalogs (a lockfile is a
 * record, not a source of truth), so only the inline source raises
 * `CatalogAssemblyError`.
 *
 * @public
 */
type WorkspaceSnapshotAtFailure = GitCommandError | NotARepositoryError | UnknownRefError | CatalogAssemblyError | WorkspaceRootNotFoundError;
/**
 * Every failure `WorkspaceSnapshots.worktree` can surface: the discovery
 * failures plus a catalog-assembly failure.
 *
 * @remarks
 * `worktree` never invokes git — it reads the live tree over
 * {@link WorkspaceDiscovery} and {@link WorkspaceCatalogs} — so no git error is
 * reachable.
 *
 * @public
 */
type WorkspaceSnapshotWorktreeFailure = WorkspaceDiscoveryFailure | CatalogAssemblyError;
/**
 * Options for the {@link WorkspaceSnapshots} layer.
 *
 * @public
 */
interface WorkspaceSnapshotsOptions {
  /**
   * The directory `at(ref)` resolves the workspace root from.
   *
   * @defaultValue `process.cwd()`, read lazily on first use inside
   *   `Effect.suspend`, so a `process.chdir` between providing the layer and the
   *   first call is honoured.
   */
  readonly cwd?: string;
  /**
   * Catalogs every snapshot this service produces carries as its
   * `seededCatalogs` — consulted only where the snapshot's own catalogs cannot
   * answer.
   *
   * @remarks
   * The layer-level spelling of `WorkspaceStateSnapshot.withSeededCatalogs`,
   * for the common case where the seed is the same for every read: a consumer
   * diffing many refs against one live workspace seeds once here instead of
   * remembering to call `withSeededCatalogs` at each site — and a forgotten
   * call is a silently missing diff row, not a type error.
   *
   * **This executes nothing.** The caller supplies the set; `at(ref)` still
   * never replays config-dependency hooks and still never fetches. The
   * deliberate at/worktree asymmetry is unchanged — this only lets a consumer
   * who has already paid for the live set share it with the ref side.
   *
   * Applied to `worktree()` too, for symmetry. There it is usually inert: a
   * live set assembled under a config-dependency layer already contains the
   * hook-injected catalogs at full precedence, so the seed answers nothing the
   * snapshot could not answer itself.
   *
   * @defaultValue absent — no seed, and resolution behaves exactly as before
   *   this option existed.
   */
  readonly seedCatalogs?: CatalogSet;
}
/**
 * The {@link WorkspaceSnapshots} service shape.
 *
 * @public
 */
interface WorkspaceSnapshotsShape {
  /** The workspace state at a git ref, read with no checkout. Cached per `(root, ref)`. */
  readonly at: (ref: string) => Effect.Effect<WorkspaceStateSnapshot, WorkspaceSnapshotAtFailure>;
  /** The live workspace state, over discovery and catalog assembly. Uncached. */
  readonly worktree: () => Effect.Effect<WorkspaceStateSnapshot, WorkspaceSnapshotWorktreeFailure>;
}
declare const WorkspaceSnapshots_base: Context.ServiceClass<WorkspaceSnapshots, "@effected/workspaces/WorkspaceSnapshots", WorkspaceSnapshotsShape>;
/**
 * Reads workspace state at a git ref with no checkout, and the live worktree.
 *
 * @remarks
 * `at(ref)` is cached per `(resolved root, ref)` via
 * `Effect.cachedInvalidateWithTTL` at `Duration.infinity`, invalidated on any
 * non-success exit — never bare `Effect.cached`, which would memoize an
 * interrupt. A failed `at(ref)` init is therefore retried on the next call, not
 * memoized.
 *
 * @example
 * ```ts
 * import { WorkspaceSnapshots } from "@effected/workspaces";
 * import { Effect } from "effect";
 *
 * const program = Effect.gen(function* () {
 *   const snapshots = yield* WorkspaceSnapshots;
 *   const before = yield* snapshots.at("origin/main");
 *   const after = yield* snapshots.worktree();
 *   return { before: before.versions, after: after.versions };
 * });
 * ```
 *
 * @public
 */
declare class WorkspaceSnapshots extends WorkspaceSnapshots_base {
  /** Builds the service over `Git`, {@link WorkspaceRoot}, {@link WorkspaceDiscovery} and {@link WorkspaceCatalogs}. */
  static readonly make: (options?: WorkspaceSnapshotsOptions) => Effect.Effect<WorkspaceSnapshotsShape, never, Git | WorkspaceRoot | WorkspaceDiscovery | WorkspaceCatalogs>;
  /**
   * The live layer.
   *
   * @remarks
   * Parameterized, so it mints a fresh reference per call — bind it to a
   * `const` and reuse it, or layer memoization does not apply.
   */
  static readonly layer: (options?: WorkspaceSnapshotsOptions) => Layer.Layer<WorkspaceSnapshots, never, Git | WorkspaceRoot | WorkspaceDiscovery | WorkspaceCatalogs>;
  /**
   * A test double satisfying the full {@link WorkspaceSnapshotsShape} with no
   * git, filesystem, discovery, or catalog assembly.
   *
   * @remarks
   * There are **no honest defaults and no derivations** here: `at(ref)` and
   * `worktree()` are two independent reads of two different sources (a git ref
   * vs. the live tree), so neither can be honestly derived from the other, and
   * a fabricated empty {@link WorkspaceStateSnapshot} on either side of a
   * before/after diff reads as every dependency newly added or removed — the
   * exact silent-empty failure class this package documents on the live paths.
   * Both methods therefore **die** with an instructive defect until stubbed; a
   * test-wiring mistake fails loudly as a defect rather than succeeding with a
   * lie.
   *
   * **A defect is not absorbed by `Effect.catch` or any typed-error handler**,
   * and that is the point: code under test with a best-effort `catch` around
   * its snapshot reads cannot make a mandatory stub look optional — the
   * unstubbed call still fails the test instead of quietly taking the catch
   * branch. Only defect-level combinators (`Effect.catchDefect`,
   * `Effect.exit`) would see it.
   *
   * @example
   * ```ts
   * import { CatalogSet, WorkspaceSnapshots, WorkspaceStateSnapshot } from "@effected/workspaces";
   * import { Effect } from "effect";
   *
   * const empty = WorkspaceStateSnapshot.make({
   *   packages: [],
   *   catalogs: CatalogSet.empty(),
   *   importerVersions: {},
   * });
   * const double = WorkspaceSnapshots.makeTest({
   *   at: () => Effect.succeed(empty),
   *   worktree: () => Effect.succeed(empty),
   * });
   * ```
   */
  static readonly makeTest: (overrides?: Partial<WorkspaceSnapshotsShape>) => WorkspaceSnapshotsShape;
  /**
   * The test layer: {@link WorkspaceSnapshots.makeTest} behind `Layer.succeed`,
   * so a suite provides only the methods it exercises.
   *
   * @remarks
   * A parameterized layer factory mints a **fresh reference per call**, and
   * layers memoize by reference — bind the result to a `const` and reuse it
   * rather than calling `layerTest(...)` at each composition site.
   *
   * @example
   * ```ts
   * import { CatalogSet, WorkspaceSnapshots, WorkspaceStateSnapshot } from "@effected/workspaces";
   * import { Effect } from "effect";
   *
   * const TestSnapshots = WorkspaceSnapshots.layerTest({
   *   worktree: () =>
   *     Effect.succeed(
   *       WorkspaceStateSnapshot.make({ packages: [], catalogs: CatalogSet.empty(), importerVersions: {} }),
   *     ),
   * });
   * // program.pipe(Effect.provide(TestSnapshots))
   * ```
   */
  static readonly layerTest: (overrides?: Partial<WorkspaceSnapshotsShape>) => Layer.Layer<WorkspaceSnapshots>;
}
//#endregion
//#region src/Workspaces.d.ts
/**
 * Options shared by the composite layers.
 *
 * @public
 */
interface WorkspacesOptions {
  /**
   * The directory every root-consuming service resolves the workspace root
   * from — one explicit concern, applied uniformly.
   *
   * @defaultValue `process.cwd()`, read lazily on first use.
   */
  readonly cwd?: string;
  /** Descent cap for segment-crossing `packages:` patterns. Defaults to 32. */
  readonly maxDepth?: number;
}
/**
 * Options for the composites that additionally provide {@link WorkspaceSnapshots}
 * — {@link Workspaces.layerWithGit} and the two config-dependency variants.
 *
 * @remarks
 * {@link WorkspacesOptions} plus whatever {@link WorkspaceSnapshotsOptions}
 * adds, so `seedCatalogs` reaches `at(ref)` through the composite instead of
 * forcing a consumer to hand-compose the graph just to pass one option. The
 * two interfaces agree on `cwd`, which stays one explicit concern applied
 * uniformly.
 *
 * @public
 */
interface WorkspacesGitOptions extends WorkspacesOptions, WorkspaceSnapshotsOptions {}
/**
 * Every service the git-free composite layer provides.
 *
 * @public
 */
type WorkspacesServices = WorkspaceRoot | PackageManagerDetector | WorkspaceDiscovery | LockfileReader | WorkspaceCatalogs;
/**
 * The composite layers.
 *
 * @public
 */
declare class Workspaces {
  private constructor();
  /**
   * Every service that needs only a filesystem: root, package-manager
   * detection, discovery, lockfile reading and catalogs.
   *
   * @remarks
   * Requires core `FileSystem` and `Path`, which the consumer provides at the
   * edge (`@effect/platform-node`, `@effect/platform-bun`, or a test's
   * `FileSystem.layerNoop`).
   *
   * **`PublishabilityDetector` is neither provided nor required here.** The
   * composite used to bake in npm semantics, which a naively-ordered override
   * silently lost to; now it supplies no default, and — because nothing inside
   * the composite asks a publishability question — it does not require one in
   * `R` either. The requirement surfaces in the `R` of each operation that
   * asks (`VersioningStrategy.detect`, e.g.), so a program that asks and never
   * wires a detector fails to compile at that operation, and a program that
   * never asks never supplies a publish policy. Wire one explicitly where
   * needed: `Layer.mergeAll(Workspaces.layer(), PublishabilityDetector.layerNpm)`.
   *
   * **Bind the result to a `const`.** This is a parameterized factory and
   * layers memoize by reference, so calling it twice builds everything twice.
   *
   * @example
   * ```ts
   * import { Workspaces } from "@effected/workspaces";
   * import { Layer } from "effect";
   *
   * const WorkspacesLayer = Workspaces.layer();
   * const AppLayer = Layer.provide(WorkspacesLayer, PlatformLayer);
   * ```
   */
  static readonly layer: (options?: WorkspacesOptions) => Layer.Layer<WorkspacesServices, never, FileSystem.FileSystem | Path.Path>;
  /**
   * The git-free composite, but with catalog assembly that **replays config
   * dependency `pnpmfile.cjs` hooks** —
   * {@link WorkspaceCatalogs.layerWithConfigDependencies} in place of the
   * default no-op catalogs layer.
   *
   * @remarks
   * Identical requirement set to {@link Workspaces.layer}; the only
   * difference is that config-dependency code is executed in process. Opt in
   * deliberately — the default {@link Workspaces.layer} never executes
   * config-dependency code.
   *
   * **Bind the result to a `const`.**
   */
  static readonly layerWithConfigDependencies: (options?: WorkspacesOptions) => Layer.Layer<WorkspacesServices, never, FileSystem.FileSystem | Path.Path>;
  /**
   * The git-free composite with config-dependency hook replay in a `node`
   * **child process** —
   * {@link WorkspaceCatalogs.layerWithConfigDependenciesSubprocess} in place of
   * the in-process replay.
   *
   * @remarks
   * Same typed semantics as {@link Workspaces.layerWithConfigDependencies}; the
   * difference is mechanism, and it matters in exactly one environment class: a
   * **bundled** consumer. The in-process replay's computed dynamic `import()`
   * is compiled by bundlers (rspack among them) into a context module that
   * throws `Cannot find module 'file:///…'` at runtime, which makes
   * `WorkspaceCatalogs.releaseAgeGate()` unreachable from any bundled GitHub
   * Action. Here the computed import runs inside a `node` child process whose
   * program text is a static string handed over argv, so nothing computed
   * enters the bundle graph.
   *
   * The extra requirement is core's `ChildProcessSpawner`, provided once at
   * the edge (`@effect/platform-node`'s `NodeServices.layer`) — the same
   * sanctioned R-widening as {@link Workspaces.layerWithGit}, and the reason
   * this is a separate composite rather than a flag: a consumer that keeps the
   * in-process replay should not have to be able to spawn a subprocess.
   *
   * **Bind the result to a `const`.**
   */
  static readonly layerWithConfigDependenciesSubprocess: (options?: WorkspacesOptions) => Layer.Layer<WorkspacesServices, never, FileSystem.FileSystem | Path.Path | ChildProcessSpawner.ChildProcessSpawner>;
  /**
   * The git-free composite plus {@link ChangeDetector} and
   * {@link WorkspaceSnapshots}, over `@effected/git`'s `Git` service.
   *
   * @remarks
   * The extra requirement is core's `ChildProcessSpawner` (behind `Git`),
   * which is why it is a separate layer rather than a flag: a consumer that
   * never detects changes or reads at a ref should not have to be able to
   * spawn a subprocess. The consumer provides `ChildProcessSpawner` once at
   * the edge (`@effect/platform-node`'s `NodeServices.layer`); a test
   * provides `Git.layerTest({ … })` — git's own shipped double, whose
   * unstubbed members die named — and needs no repository on disk.
   */
  static readonly layerWithGit: (options?: WorkspacesGitOptions) => Layer.Layer<WorkspacesServices | ChangeDetector | WorkspaceSnapshots | Git, never, FileSystem.FileSystem | Path.Path | ChildProcessSpawner.ChildProcessSpawner>;
  /**
   * {@link Workspaces.layerWithGit} over
   * {@link Workspaces.layerWithConfigDependencies} — snapshots, change
   * detection and git, with catalog assembly that **replays config dependency
   * `pnpmfile.cjs` hooks**.
   *
   * @remarks
   * The composite that did not exist. `layerWithGit` hard-wires the no-op
   * catalogs layer, so a consumer wanting snapshots + git + hook replay had to
   * rebuild the entire service graph by hand — which is exactly what
   * `@savvy-web/silk-effects` did, and the copy this static deletes.
   *
   * Requirements are unchanged from {@link Workspaces.layerWithGit}: a
   * filesystem, a path service, and core's `ChildProcessSpawner` (behind
   * `Git`). The in-process replay adds no requirement of its own — it is a
   * dynamic `import()`, not a subprocess. **If the consumer is bundled, reach
   * for {@link Workspaces.layerWithGitAndConfigDependenciesSubprocess}
   * instead**; the computed import does not survive a bundler, and the
   * `ChildProcessSpawner` the subprocess variant needs is already required
   * here for git, so on this composite the subprocess form costs nothing extra.
   *
   * Opt in deliberately: this executes config-dependency code in process, and
   * {@link Workspaces.layerWithGit} never does.
   *
   * **Bind the result to a `const`.** A parameterized factory mints a fresh
   * reference per call and layers memoize by reference.
   *
   * @example
   * ```ts
   * import { Workspaces } from "@effected/workspaces";
   *
   * const KitLayer = Workspaces.layerWithGitAndConfigDependencies();
   * ```
   */
  static readonly layerWithGitAndConfigDependencies: (options?: WorkspacesGitOptions) => Layer.Layer<WorkspacesServices | ChangeDetector | WorkspaceSnapshots | Git, never, FileSystem.FileSystem | Path.Path | ChildProcessSpawner.ChildProcessSpawner>;
  /**
   * {@link Workspaces.layerWithGitAndConfigDependencies}, with the hook replay
   * in a `node` **child process** rather than in process.
   *
   * @remarks
   * Same typed semantics; the difference is mechanism, and it decides whether
   * catalog assembly works at all in a **bundled** consumer — see
   * {@link Workspaces.layerWithConfigDependenciesSubprocess} for why the
   * in-process computed `import()` dies under a bundler.
   *
   * **This composite's requirement set is identical to the in-process one.**
   * The subprocess replay needs core's `ChildProcessSpawner`, which this
   * composite already requires for `Git` — so unlike the git-free pair, there
   * is no R-widening to weigh here and a bundled consumer pays nothing to be
   * correct. Prefer this variant whenever the program ships as a bundle.
   *
   * **Bind the result to a `const`.**
   *
   * @example
   * ```ts
   * import { Workspaces } from "@effected/workspaces";
   *
   * // A bundled CLI or MCP server: the computed import never enters the graph.
   * const KitLayer = Workspaces.layerWithGitAndConfigDependenciesSubprocess();
   * ```
   */
  static readonly layerWithGitAndConfigDependenciesSubprocess: (options?: WorkspacesGitOptions) => Layer.Layer<WorkspacesServices | ChangeDetector | WorkspaceSnapshots | Git, never, FileSystem.FileSystem | Path.Path | ChildProcessSpawner.ChildProcessSpawner>;
  /**
   * This package's implementation of `@effected/commands`' `LocalExec`
   * contract: how to run a project-local binary here.
   *
   * @remarks
   * **An inverted contract, the `@effected/npm` `CatalogResolver`
   * precedent.** Tool discovery needs package-manager detection and
   * workspace-root resolution, both of which live here — but a direct edge
   * from `@effected/commands` to this package would make that boundary-tier
   * package integrated, and through the planned `npm` → `commands` edge
   * would drag `npm`, `lockfiles` (pure!) and `package-json` up a tier with
   * it. So `commands` declares the narrow contract and we ship the layer.
   *
   * **The argv knowledge is not duplicated.** `LocalExec.prefixes(name)` is
   * the one home of the four managers' `exec`/`dlx`/script-runner prefixes;
   * this layer
   * detects *which* manager owns the directory and asks `commands` what that
   * manager's argv looks like. Neither package reimplements the other's
   * half.
   *
   * **`None` is success.** Outside any workspace — and inside one whose
   * manager cannot be identified — the answer is `Option.none()`: "there is
   * no project-local way to run tools here" is an ordinary fact, not an
   * exceptional one, and a consumer running in a bare directory should not
   * have to catch an error to learn it. The contract's typed
   * `LocalExecError` is reserved for **mechanism** failure — a manifest that
   * exists but cannot be read or parsed, which means something is broken
   * rather than absent. That is npm's resolver convention, adopted
   * verbatim.
   *
   * `directory` is the resolved **workspace root**, not the caller's cwd: a
   * project-local launcher has to run where the workspace is.
   *
   * A consumer with no monorepo never needs this layer, and therefore never
   * installs this package — `LocalExec.layerNone` and `LocalExec.layerFor`
   * are one-liners in `@effected/commands`.
   *
   * **Bind the result to a `const`** — a parameterized layer factory mints a
   * fresh reference per call and layers memoize by reference.
   *
   * @example
   * ```ts
   * import { ToolDiscovery } from "@effected/commands";
   * import { Workspaces } from "@effected/workspaces";
   * import { Layer } from "effect";
   *
   * // Bound to consts per the warning above: each factory call mints a
   * // fresh layer reference, and layers memoize by reference.
   * const LocalExecLayer = Workspaces.localExecLayer();
   * const WorkspacesLayer = Workspaces.layer();
   *
   * const AppLayer = ToolDiscovery.layer.pipe(
   *   Layer.provide(LocalExecLayer),
   *   Layer.provide(WorkspacesLayer),
   *   Layer.provide(NodeServices.layer),
   * );
   * ```
   */
  static readonly localExecLayer: (options?: {
    readonly cwd?: string;
  }) => Layer.Layer<LocalExec, never, PackageManagerDetector | WorkspaceRoot>;
  /**
   * Resolve every `catalog:` and `workspace:` specifier in one `Manifest`
   * against the real workspace, in one call — the 90% path. Decode stays at
   * the consumer's edge: build the `Manifest` with `Manifest.decode` (from
   * `@effected/npm`), hand it here, and get a new `Manifest` back with
   * concrete ranges; `toRecord()` returns to the wire shape.
   *
   * @remarks
   * Composes `manifest.resolve()` with a fresh {@link Workspaces.resolverLayer}
   * per call, so the workspace root is re-discovered from `options.cwd` (or
   * the current `process.cwd()`) on every invocation. Consumers processing
   * many manifests should check `manifest.needsResolution` first and skip
   * the call entirely when no dependency field carries a
   * `catalog:`/`workspace:` specifier — that predicate is pure and avoids
   * catalog assembly altogether.
   *
   * A specifier the workspace cannot answer fails typed as
   * `UnresolvedDependencyError`; assembly and mechanism failures surface as
   * `CatalogAssemblyError` / `DependencyResolutionError`.
   *
   * @example
   * ```ts
   * import { Manifest } from "@effected/npm";
   * import { Workspaces } from "@effected/workspaces";
   * import { Effect } from "effect";
   *
   * const program = Effect.gen(function* () {
   *   const manifest = yield* Manifest.decode({ dependencies: { effect: "catalog:" } });
   *   const resolved = manifest.needsResolution ? yield* Workspaces.resolveManifest(manifest) : manifest;
   *   return resolved.toRecord();
   * });
   * ```
   */
  static readonly resolveManifest: (manifest: Manifest, options?: WorkspacesOptions) => Effect.Effect<Manifest, CatalogAssemblyError | DependencyResolutionError | UnresolvedDependencyError, FileSystem.FileSystem | Path.Path>;
  /**
   * The one-call resolver factory: {@link Workspaces.resolvers} pre-wired
   * over {@link Workspaces.layerWithConfigDependencies}, so the two
   * `@effected/npm` contracts (`CatalogResolver`, `WorkspaceResolver`) need
   * only a platform (`FileSystem` + `Path`) from the consumer.
   *
   * @remarks
   * This is deliberately a **parameterized layer function, and the fresh
   * layer per call is the feature**: layers memoize by reference, so each
   * call mints an unmemoized layer whose root discovery re-runs — including
   * a per-call `process.cwd()` read when `options.cwd` is omitted. A build
   * tool that changes directory between manifests gets a correct
   * re-discovery each time precisely because nothing is shared across
   * calls. When you *want* sharing, bind one call's result to a `const` and
   * provide that; the memoization rule is unchanged, this factory just
   * refuses to hide it.
   *
   * Catalog assembly replays config-dependency `pnpmfile` hooks (the
   * `layerWithConfigDependencies` path) — the semantics a real pnpm install
   * has. Compose {@link Workspaces.resolvers} with {@link Workspaces.layer}
   * yourself if config-dependency code must not run in process.
   *
   * @example
   * ```ts
   * import { Workspaces } from "@effected/workspaces";
   * import { Effect } from "effect";
   *
   * const program = doSomethingWithResolvers.pipe(
   *   Effect.provide(Workspaces.resolverLayer()),
   * );
   * ```
   */
  static readonly resolverLayer: (options?: WorkspacesOptions) => Layer.Layer<CatalogResolver | WorkspaceResolver, never, FileSystem.FileSystem | Path.Path>;
  /**
   * The two `@effected/npm` resolver contracts, implemented for real.
   *
   * @remarks
   * Provide this alongside `@effected/package-json`'s `Package.resolve` and
   * a manifest's `catalog:` and `workspace:` specifiers resolve against the
   * actual workspace instead of the no-op layers' `Option.none()`.
   *
   * @example
   * ```ts
   * import { Package } from "@effected/package-json";
   * import { Workspaces } from "@effected/workspaces";
   * import { Layer } from "effect";
   *
   * const WorkspacesLayer = Workspaces.layer();
   * const Resolvers = Workspaces.resolvers.pipe(Layer.provide(WorkspacesLayer));
   * ```
   */
  static readonly resolvers: Layer.Layer<CatalogResolver | WorkspaceResolver, never, WorkspaceCatalogs | WorkspaceDiscovery>;
}
//#endregion
//#region src/WorkspacesSync.d.ts
/**
 * The synchronous file operations the sync entry points need, supplied by the
 * consumer. Node's built-ins satisfy it directly:
 *
 * ```ts
 * import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 *
 * const fileSystem: SyncFileSystem = {
 * 	exists: existsSync,
 * 	readFile: (p) => readFileSync(p, "utf8"),
 * 	readDirectory: (p) => readdirSync(p),
 * 	isDirectory: (p) => statSync(p).isDirectory(),
 * };
 * ```
 *
 * `exists` must return a boolean and not throw (Node's `existsSync` never
 * does). The other three may throw — `statSync` on a missing path, a
 * permission error mid-read — and every throw is absorbed into the documented
 * degraded-skip semantics: a throwing `readFile` reads as an unusable
 * manifest, a throwing `readDirectory` as an unreadable directory, a throwing
 * `isDirectory` as "not a directory". Nothing propagates.
 *
 * @public
 */
interface SyncFileSystem {
  /** Whether a file or directory exists at `path`. Must not throw. */
  readonly exists: (path: string) => boolean;
  /** Read the file at `path` as text. May throw; a throw degrades to a skip. */
  readonly readFile: (path: string) => string;
  /** The entry names inside the directory at `path`. May throw; a throw skips the directory. */
  readonly readDirectory: (path: string) => ReadonlyArray<string>;
  /** Whether `path` is a directory. May throw; a throw reads as `false`. */
  readonly isDirectory: (path: string) => boolean;
  /**
   * Optional fast path: the entries inside `path` with their types already
   * known, in ONE call.
   *
   * @remarks
   * Package enumeration otherwise costs a `readDirectory` plus one
   * `isDirectory` per entry — the readdir-then-stat-per-entry shape, which on
   * a large workspace is a syscall per file. Supplying this collapses that to
   * a single `readdirSync(path, { withFileTypes: true })`; `nodeFileSystem`
   * does. Omit it and enumeration falls back to the four required operations
   * with identical results, so this is purely a cost optimization and never a
   * behavior switch.
   *
   * May throw; a throw skips the directory, exactly like `readDirectory`.
   */
  readonly readDirectoryWithTypes?: ((path: string) => ReadonlyArray<SyncDirectoryEntry>) | undefined;
}
/**
 * One directory entry with its type resolved, as the optional
 * {@link SyncFileSystem.readDirectoryWithTypes} fast path reports it. Node's
 * `Dirent` satisfies it after mapping its predicate methods to booleans.
 *
 * @remarks
 * `isSymbolicLink` is not decoration. A `Dirent` describes the entry ITSELF, so
 * a symbolic link pointing at a directory reports `isDirectory: false` — while
 * the `stat`-based slow path, which resolves the link, calls the same entry a
 * directory. Enumeration therefore re-resolves links through `isDirectory`
 * rather than trusting `isDirectory` on a link, which is what keeps the fast
 * and slow paths in agreement on a workspace whose packages are symlinked.
 *
 * Which behavior is *correct* is domain-dependent, so the flag is reported
 * rather than resolved away. Enumeration follows links because a symlinked
 * package is still a package. A test-file discovery walk usually must NOT: in a
 * pnpm workspace `node_modules` is a farm of links into the content-addressed
 * store, and following them walks the whole store or hits a cycle. A consumer
 * building its own walker on this shape wants `isDirectory` verbatim — there,
 * not following is the requirement, not the hazard.
 *
 * @public
 */
interface SyncDirectoryEntry {
  /** The entry's own name, not a path. */
  readonly name: string;
  /** Whether the entry itself is a directory. `false` for a symbolic link, even one targeting a directory. */
  readonly isDirectory: boolean;
  /** Whether the entry itself is a symbolic link. */
  readonly isSymbolicLink: boolean;
}
/**
 * The synchronous path operations the sync entry points need, supplied by the
 * consumer. Deliberately a structural subset of `node:path`, so the built-in
 * module (and its `win32` / `posix` variants, or a Bun / Deno equivalent)
 * satisfies it verbatim:
 *
 * ```ts
 * import * as path from "node:path";
 *
 * const options: WorkspacesSyncOptions = {
 * 	fileSystem: { exists: existsSync, readFile: (p) => readFileSync(p, "utf8"), readDirectory: (p) => readdirSync(p), isDirectory: (p) => statSync(p).isDirectory() },
 * 	path, // node:path IS a SyncPath
 * };
 * ```
 *
 * These operations shape only the ABSOLUTE paths handed back to the consumer
 * (and to its own `fileSystem`); workspace-relative pattern matching is POSIX
 * by the `packages:` contract and never routes through here. Windows
 * correctness comes from supplying a win32-appropriate implementation, not
 * from anything in this module.
 *
 * @public
 */
interface SyncPath {
  /** Join segments with the implementation's separator (like `path.join`). */
  readonly join: (...segments: ReadonlyArray<string>) => string;
  /** The directory portion of `p` (like `path.dirname`). */
  readonly dirname: (p: string) => string;
  /** Resolve segments to an absolute path (rightmost-wins, like `path.resolve`). */
  readonly resolve: (...segments: ReadonlyArray<string>) => string;
}
/**
 * The consumer-supplied operations backing one sync call: the file operations
 * and the path implementation. Both are required — this package never imports
 * `node:*` and never assumes posix, so the platform binding is entirely the
 * caller's.
 *
 * @public
 */
interface WorkspacesSyncOptions {
  /** The synchronous file operations (Node: `existsSync` / `readFileSync` / `readdirSync` / `statSync`). */
  readonly fileSystem: SyncFileSystem;
  /** The synchronous path implementation (Node: the `node:path` module itself). */
  readonly path: SyncPath;
}
/**
 * The nearest workspace root at or above `cwd`, or `null`.
 *
 * @remarks
 * **Synchronous.** The Effect surface is `WorkspaceRoot`; reach for this one
 * only where you genuinely cannot run an Effect — a Vitest config being the
 * motivating case. The file and path operations are the caller's
 * ({@link WorkspacesSyncOptions}); this module imports no `node:*` and
 * assumes no posix.
 *
 * The signature is path-first, options second — the same shape as
 * {@link getWorkspacePackagesSync} and the rest of the kit's sync facades
 * (`TsconfigLoaderSync.load(configPath, options)`). `cwd` is required and
 * positional: the earlier options-bag form defaulted it to an ambient
 * `process.cwd()` read, which both broke the symmetry with its sibling and
 * was the module's one platform assumption.
 *
 * Markers match the async service exactly: a `pnpm-workspace.yaml`, or a
 * `package.json` carrying a `workspaces` field.
 *
 * @param cwd - Where to start the ascent (typically `process.cwd()`),
 *   matching the Effect layers' `{ cwd }` option.
 * @param options - The consumer-supplied file and path operations.
 *
 * @example
 * ```ts
 * import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 * import * as path from "node:path";
 * import { findWorkspaceRootSync } from "@effected/workspaces";
 *
 * const root = findWorkspaceRootSync(process.cwd(), {
 * 	fileSystem: {
 * 		exists: existsSync,
 * 		readFile: (p) => readFileSync(p, "utf8"),
 * 		readDirectory: (p) => readdirSync(p),
 * 		isDirectory: (p) => statSync(p).isDirectory(),
 * 	},
 * 	path,
 * });
 * ```
 *
 * @public
 */
declare const findWorkspaceRootSync: (cwd: string, options: WorkspacesSyncOptions) => string | null;
/**
 * Options for {@link getWorkspacePackagesSync}: the required consumer-supplied
 * operations plus the traversal bound.
 *
 * @public
 */
interface GetWorkspacePackagesSyncOptions extends WorkspacesSyncOptions {
  /**
   * Descent cap below a wildcard's enumeration prefix, mirroring
   * `WorkspaceDiscovery.layer({ maxDepth })`.
   *
   * @defaultValue 32
   */
  readonly maxDepth?: number;
}
/**
 * Every workspace package under `root`, root package first.
 *
 * @remarks
 * **Synchronous.** The Effect surface is `WorkspaceDiscovery`. The file and
 * path operations are the caller's ({@link GetWorkspacePackagesSyncOptions}
 * extends {@link WorkspacesSyncOptions}); this module imports no `node:*` and
 * assumes no posix.
 *
 * Pattern semantics are not merely "shared" with the Effect enumerator — both
 * drive the **same traversal state machine** (`internal/traverse.ts`), so the
 * dequeue order, the depth rule, the visit budget and the prune list cannot
 * drift apart. A `packages/**` finds exactly the same packages here as there,
 * including at the depth boundary.
 *
 * The one deliberate difference is what happens at a bound: the Effect surface
 * fails typed (`depthExceeded` / `budgetExceeded`), while this one is **total**
 * and truncates. An unenumerable pattern or an unreadable manifest is skipped,
 * not raised — a function with no error channel should not pretend to have one,
 * and a Vitest config has nowhere to put a failure. Totality covers *data*, not
 * caller mistakes: a `maxDepth` that is not a positive integer throws, matching
 * the enumerator's defect.
 *
 * @param root - The workspace root, from {@link findWorkspaceRootSync}.
 * @param options - The consumer-supplied operations and traversal bounds; see
 *   {@link GetWorkspacePackagesSyncOptions}.
 *
 * @example
 * ```ts
 * import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 * import * as path from "node:path";
 * import { findWorkspaceRootSync, getWorkspacePackagesSync } from "@effected/workspaces";
 *
 * const ops = {
 * 	fileSystem: {
 * 		exists: existsSync,
 * 		readFile: (p: string) => readFileSync(p, "utf8"),
 * 		readDirectory: (p: string) => readdirSync(p),
 * 		isDirectory: (p: string) => statSync(p).isDirectory(),
 * 	},
 * 	path,
 * };
 * const root = findWorkspaceRootSync(process.cwd(), ops);
 * const packages = root === null ? [] : getWorkspacePackagesSync(root, ops);
 * ```
 *
 * @public
 */
declare const getWorkspacePackagesSync: (root: string, options: GetWorkspacePackagesSyncOptions) => ReadonlyArray<WorkspacePackage>;
//#endregion
export { type CatalogAssemblyFailure, CatalogSet, ChangeDetectionError, type ChangeDetectionFailure, ChangeDetectionOptions, ChangeDetector, type ChangeDetectorShape, type ClassifyOptions, ConfigDependencyHooks, type ConfigDependencyHooksShape, CyclicDependencyError, type DependencyDiff, DependencyGraph, DetectedPackageManager, type FindWorkspaceRootOptions, type GetWorkspacePackagesSyncOptions, type HookInjection, type ImporterVersions, LockfileReadError, type LockfileReadFailure, LockfileReader, type LockfileReaderOptions, type LockfileReaderShape, NoPeerDependencyRules, PackageManagerDetectionError, type PackageManagerDetectionFailure, PackageManagerDetector, type PackageManagerDetectorShape, PackageManagerEvidence, PackageManagerName, PackageNotFoundError, type PackageRelease, PackageStateSnapshot, PeerCheck, type PeerCheckOptions, type PeerDependencyRules, PeerParent, PublishConfig, PublishTarget, PublishabilityDetector, type PublishabilityDetectorShape, ReleaseTag, type SyncDirectoryEntry, type SyncFileSystem, type SyncPath, type TagClassification, type TagFormatOptions, TagStyle, TrackingTag, type TrackingTagOptions, UnsatisfiedPeer, type UnverifiedReason, type VersioningDetectOptions, VersioningStrategy, VersioningStrategyType, WORKSPACE_MARKERS, WorkspaceCatalogs, type WorkspaceCatalogsOptions, type WorkspaceCatalogsShape, WorkspaceDiscovery, WorkspaceDiscoveryError, type WorkspaceDiscoveryFailure, type WorkspaceDiscoveryOptions, type WorkspaceDiscoveryShape, WorkspaceInfo, type WorkspaceLookupFailure, WorkspaceManifestError, WorkspacePackage, WorkspacePatternError, WorkspaceRoot, WorkspaceRootNotFoundError, type WorkspaceRootShape, type WorkspaceSnapshotAtFailure, type WorkspaceSnapshotWorktreeFailure, WorkspaceSnapshots, type WorkspaceSnapshotsOptions, type WorkspaceSnapshotsShape, WorkspaceStateSnapshot, Workspaces, type WorkspacesGitOptions, type WorkspacesOptions, type WorkspacesServices, type WorkspacesSyncOptions, classifyTag, findWorkspaceRootSync, getWorkspacePackagesSync };
//# sourceMappingURL=index.d.ts.map