@savvy-web/silk 3.4.1 → 3.4.2

package/changesets-changelog.d.cts

@@ -4395,9 +4395,9 @@ declare class UnsatisfiableConstraintError extends UnsatisfiableConstraintError_
   get message(): string;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@effected+npm@0.8.2_@effected+semver@0.3.2_effect@4.0.0-beta.101__effect@4.0.0-beta.101/node_modules/@effected/npm/index.d.ts
+//#region ../../node_modules/.pnpm/@effected+npm@0.8.3_@effected+semver@0.3.2_effect@4.0.0-beta.101__effect@4.0.0-beta.101/node_modules/@effected/npm/index.d.ts
 //#region src/CatalogAssemblyError.d.ts
-declare const CatalogAssemblyError_base: Schema.Class<CatalogAssemblyError, Schema.TaggedStruct<"CatalogAssemblyError", {
+declare const CatalogAssemblyError_base$1: Schema.Class<CatalogAssemblyError$1, Schema.TaggedStruct<"CatalogAssemblyError", {
   /**
    * Which input failed: `manifest` for a file-level or top-level shape problem,
    * `catalog` for a malformed catalog block or the double-default duplication,
@@ -4430,13 +4430,13 @@ declare const CatalogAssemblyError_base: Schema.Class<CatalogAssemblyError, Sche
  *
  * @public
  */
-declare class CatalogAssemblyError extends CatalogAssemblyError_base {
+declare class CatalogAssemblyError$1 extends CatalogAssemblyError_base$1 {
   /** Renders the failing source into a one-line message. */
   get message(): string;
 }
 //#endregion
 //#region src/WorkspaceResolver.d.ts
-declare const DependencyResolutionError_base: Schema.Class<DependencyResolutionError, Schema.TaggedStruct<"DependencyResolutionError", {
+declare const DependencyResolutionError_base$1: Schema.Class<DependencyResolutionError$1, Schema.TaggedStruct<"DependencyResolutionError", {
   readonly specifier: Schema.String;
   readonly cause: Schema.Defect;
 }>, import("effect/Cause").YieldableError>;
@@ -4453,12 +4453,12 @@ declare const DependencyResolutionError_base: Schema.Class<DependencyResolutionE
  *
  * @public
  */
-declare class DependencyResolutionError extends DependencyResolutionError_base {
+declare class DependencyResolutionError$1 extends DependencyResolutionError_base$1 {
   /** Renders `specifier` into a one-line failure message. */
   get message(): string;
 }
-declare const WorkspaceResolver_base: Context.ServiceClass<WorkspaceResolver, "@effected/npm/WorkspaceResolver", {
-  readonly versionOf: (packageName: string) => Effect.Effect<Option.Option<string>, DependencyResolutionError>;
+declare const WorkspaceResolver_base$1: Context.ServiceClass<WorkspaceResolver$1, "@effected/npm/WorkspaceResolver", {
+  readonly versionOf: (packageName: string) => Effect.Effect<Option.Option<string>, DependencyResolutionError$1>;
 }>;
 /**
  * Contract for resolving pnpm `workspace:` dependency specifiers to concrete
@@ -4489,18 +4489,18 @@ declare const WorkspaceResolver_base: Context.ServiceClass<WorkspaceResolver, "@
  *
  * @public
  */
-declare class WorkspaceResolver extends WorkspaceResolver_base {
+declare class WorkspaceResolver$1 extends WorkspaceResolver_base$1 {
   /**
    * No-op default: `versionOf` always succeeds with `Option.none()`, never
    * consulting an actual workspace. A pure `Layer.succeed`, bound to a
    * const so it memoizes by reference.
    */
-  static readonly noop: Layer.Layer<WorkspaceResolver>;
+  static readonly noop: Layer.Layer<WorkspaceResolver$1>;
 }
 //#endregion
 //#region src/CatalogResolver.d.ts
-declare const CatalogResolver_base: Context.ServiceClass<CatalogResolver, "@effected/npm/CatalogResolver", {
-  readonly rangeOf: (packageName: string, catalog: Option.Option<string>) => Effect.Effect<Option.Option<string>, CatalogAssemblyError | DependencyResolutionError>;
+declare const CatalogResolver_base$1: Context.ServiceClass<CatalogResolver$1, "@effected/npm/CatalogResolver", {
+  readonly rangeOf: (packageName: string, catalog: Option.Option<string>) => Effect.Effect<Option.Option<string>, CatalogAssemblyError$1 | DependencyResolutionError$1>;
 }>;
 /**
  * Contract for resolving pnpm `catalog:` dependency specifiers to concrete
@@ -4537,21 +4537,15 @@ declare const CatalogResolver_base: Context.ServiceClass<CatalogResolver, "@effe
  *
  * @public
  */
-declare class CatalogResolver extends CatalogResolver_base {
+declare class CatalogResolver$1 extends CatalogResolver_base$1 {
   /**
    * No-op default: `rangeOf` always succeeds with `Option.none()`, never
    * consulting an actual catalog. A pure `Layer.succeed`, bound to a const
    * so it memoizes by reference — the layer is built once, not once per
    * reference to `CatalogResolver.noop`.
    */
-  static readonly noop: Layer.Layer<CatalogResolver>;
+  static readonly noop: Layer.Layer<CatalogResolver$1>;
 }
-/**
- * The classification of a dependency specifier's protocol.
- *
- * @public
- */
-type DependencyProtocol = "range" | "tag" | "git" | "url" | "npm" | "file" | "link" | "portal" | "catalog" | "workspace" | "unknown";
 declare const CatalogSpecifier_base: Schema.Class<CatalogSpecifier, Schema.TaggedStruct<"catalog", {
   /** The original specifier string. */
   readonly raw: Schema.String;
@@ -4969,7 +4963,7 @@ declare class GlobPattern extends GlobPattern_base {
   static readonly FromString: Schema.Codec<GlobPattern, string>;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@effected+lockfiles@0.3.2_@effected+jsonc@0.5.2_effect@4.0.0-beta.101__@effected+npm@0._ff048038a9678f5144f817ad24d8f96e/node_modules/@effected/lockfiles/index.d.ts
+//#region ../../node_modules/.pnpm/@effected+lockfiles@0.3.2_@effected+jsonc@0.5.2_effect@4.0.0-beta.101__@effected+npm@0._3c1784fba62fde9a5bac4cf15387fd04/node_modules/@effected/lockfiles/index.d.ts
 //#region src/BunExtension.d.ts
 declare const BunExtension_base: Schema.Class<BunExtension, Schema.Struct<{
   readonly _tag: Schema.tag<"bun">;
@@ -5399,6 +5393,164 @@ declare class LockfileIntegrity extends LockfileIntegrity_base {
   static compare(lockfile: Lockfile, manifests: ReadonlyArray<WorkspaceManifest>): LockfileIntegrity;
 }
 //#endregion
+//#region ../../node_modules/.pnpm/@effected+npm@0.8.2_@effected+semver@0.3.2_effect@4.0.0-beta.101__effect@4.0.0-beta.101/node_modules/@effected/npm/index.d.ts
+//#region src/CatalogAssemblyError.d.ts
+declare const CatalogAssemblyError_base: Schema.Class<CatalogAssemblyError, Schema.TaggedStruct<"CatalogAssemblyError", {
+  /**
+   * Which input failed: `manifest` for a file-level or top-level shape problem,
+   * `catalog` for a malformed catalog block or the double-default duplication,
+   * `hooks` for a config-dependency `pnpmfile.cjs` load or replay failure.
+   */
+  readonly source: Schema.Literals<readonly ["manifest", "catalog", "hooks"]>;
+  /** The file, the catalog name, or the config dependency name. */
+  readonly path: Schema.String;
+  /** The originating failure. */
+  readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Raised when a workspace's catalogs cannot be assembled — a `pnpm-workspace.yaml`
+ * that is unreadable or not valid YAML, a root `package.json` `workspaces` field
+ * whose shape or catalog blocks are malformed in a way pnpm itself rejects
+ * (including the default catalog declared twice), or a config dependency whose
+ * `pnpmfile.cjs` cannot be loaded or replayed.
+ *
+ * @remarks
+ * A *missing* `pnpm-workspace.yaml`, an *absent* `workspaces` field, or one
+ * explicitly `null` is not an error: there is simply nothing to misread, so
+ * assembly yields the empty set. The reader is otherwise **hard-fail by design** —
+ * a silently-empty catalog read is the "every dependency looks newly added" bug,
+ * because catalog output is load-bearing for snapshot diffing.
+ *
+ * Defined here, next to the {@link CatalogResolver} contract that raises it,
+ * rather than in the implementing package (`@effected/workspaces`): folding it
+ * into `DependencyResolutionError`'s defect `cause` forced every consumer to
+ * `_tag`-sniff `unknown` to tell an assembly failure from a resolution failure.
+ *
+ * @public
+ */
+declare class CatalogAssemblyError extends CatalogAssemblyError_base {
+  /** Renders the failing source into a one-line message. */
+  get message(): string;
+}
+//#endregion
+//#region src/WorkspaceResolver.d.ts
+declare const DependencyResolutionError_base: Schema.Class<DependencyResolutionError, Schema.TaggedStruct<"DependencyResolutionError", {
+  readonly specifier: Schema.String;
+  readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Raised when a `catalog:` or `workspace:` specifier cannot be resolved
+ * because the resolution mechanism itself failed — not for an ordinary
+ * unmatched specifier, which resolves to `Option.none()` instead. Both
+ * {@link CatalogResolver} and {@link WorkspaceResolver} fail with it.
+ *
+ * `cause` preserves the originating failure on a structured `Schema.Defect`
+ * field rather than folding it into a string, so callers can branch on the
+ * original value (an `Error`, a parsed diagnostic, anything); `specifier`
+ * records the specifier string that failed to resolve.
+ *
+ * @public
+ */
+declare class DependencyResolutionError extends DependencyResolutionError_base {
+  /** Renders `specifier` into a one-line failure message. */
+  get message(): string;
+}
+declare const WorkspaceResolver_base: Context.ServiceClass<WorkspaceResolver, "@effected/npm/WorkspaceResolver", {
+  readonly versionOf: (packageName: string) => Effect.Effect<Option.Option<string>, DependencyResolutionError>;
+}>;
+/**
+ * Contract for resolving pnpm `workspace:` dependency specifiers to concrete
+ * versions.
+ *
+ * `versionOf` takes a workspace package name and returns its concrete
+ * version (the range modifier stripped) as `Option.some`, or
+ * `Option.none()` when the name is not a known workspace member.
+ *
+ * This is a contract-only service: {@link WorkspaceResolver.noop} is the
+ * sole implementation this package ships, and it resolves nothing. Real
+ * consumers (e.g. `@effected/workspaces`) provide a working implementation
+ * at the application boundary.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect";
+ * import { WorkspaceResolver } from "@effected/npm";
+ *
+ * const program = Effect.gen(function* () {
+ *   const resolver = yield* WorkspaceResolver;
+ *   return yield* resolver.versionOf("@effected/semver");
+ * });
+ *
+ * Effect.runPromise(Effect.provide(program, WorkspaceResolver.noop));
+ * // => Option.none()
+ * ```
+ *
+ * @public
+ */
+declare class WorkspaceResolver extends WorkspaceResolver_base {
+  /**
+   * No-op default: `versionOf` always succeeds with `Option.none()`, never
+   * consulting an actual workspace. A pure `Layer.succeed`, bound to a
+   * const so it memoizes by reference.
+   */
+  static readonly noop: Layer.Layer<WorkspaceResolver>;
+}
+//#endregion
+//#region src/CatalogResolver.d.ts
+declare const CatalogResolver_base: Context.ServiceClass<CatalogResolver, "@effected/npm/CatalogResolver", {
+  readonly rangeOf: (packageName: string, catalog: Option.Option<string>) => Effect.Effect<Option.Option<string>, CatalogAssemblyError | DependencyResolutionError>;
+}>;
+/**
+ * Contract for resolving pnpm `catalog:` dependency specifiers to concrete
+ * version ranges.
+ *
+ * `rangeOf` takes a package name and an optional catalog name
+ * (`Option.none()` selects the default catalog) and returns the configured
+ * range as `Option.some`, or `Option.none()` when the specifier is absent
+ * from the catalog. By convention the error channel is reserved for a
+ * failure in the resolution mechanism itself — an unmatched package or
+ * catalog name is an `Option.none()` success, never an error. A failure to
+ * *assemble* the catalogs (an unreadable or malformed catalog source)
+ * surfaces typed as a {@link CatalogAssemblyError}; any other mechanism
+ * failure is a {@link DependencyResolutionError}.
+ *
+ * This is a contract-only service: {@link CatalogResolver.noop} is the sole
+ * implementation this package ships, and it resolves nothing. Real consumers
+ * (e.g. `@effected/workspaces`) provide a working implementation at the
+ * application boundary.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Option } from "effect";
+ * import { CatalogResolver } from "@effected/npm";
+ *
+ * const program = Effect.gen(function* () {
+ *   const resolver = yield* CatalogResolver;
+ *   return yield* resolver.rangeOf("effect", Option.none());
+ * });
+ *
+ * Effect.runPromise(Effect.provide(program, CatalogResolver.noop));
+ * // => Option.none()
+ * ```
+ *
+ * @public
+ */
+declare class CatalogResolver extends CatalogResolver_base {
+  /**
+   * No-op default: `rangeOf` always succeeds with `Option.none()`, never
+   * consulting an actual catalog. A pure `Layer.succeed`, bound to a const
+   * so it memoizes by reference — the layer is built once, not once per
+   * reference to `CatalogResolver.noop`.
+   */
+  static readonly noop: Layer.Layer<CatalogResolver>;
+}
+/**
+ * The classification of a dependency specifier's protocol.
+ *
+ * @public
+ */
+type DependencyProtocol = "range" | "tag" | "git" | "url" | "npm" | "file" | "link" | "portal" | "catalog" | "workspace" | "unknown";
+//#endregion
 //#region ../../node_modules/.pnpm/@effected+package-json@0.7.3_effect@4.0.0-beta.101/node_modules/@effected/package-json/index.d.ts
 //#region src/Dependency.d.ts
 declare const Dependency_base: Schema.Class<Dependency, Schema.Struct<{
@@ -5981,7 +6133,7 @@ declare class Package extends Package_base {
   toJsonString(options?: PackageFormatOptions): string;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@effected+workspaces@0.9.5_@effected+jsonc@0.5.2_effect@4.0.0-beta.101__effect@4.0.0-beta.101/node_modules/@effected/workspaces/index.d.ts
+//#region ../../node_modules/.pnpm/@effected+workspaces@0.10.0_@effected+jsonc@0.5.2_effect@4.0.0-beta.101__effect@4.0.0-beta.101/node_modules/@effected/workspaces/index.d.ts
 //#region src/WorkspacePackage.d.ts
 declare const PublishConfig_base: Schema.Class<PublishConfig, Schema.Struct<{
   /** Scoped-package visibility. Its presence overrides `private`. */
@@ -6645,7 +6797,7 @@ declare class WorkspaceDiscovery extends WorkspaceDiscovery_base {
    * // `Package.resolve` now resolves `workspace:*` for real.
    * ```
    */
-  static readonly workspaceResolver: Layer.Layer<WorkspaceResolver, never, WorkspaceDiscovery>;
+  static readonly workspaceResolver: Layer.Layer<WorkspaceResolver$1, never, WorkspaceDiscovery>;
 }
 //#endregion
 //#region src/ConfigDependencyHooks.d.ts
@@ -6706,7 +6858,7 @@ interface ConfigDependencyHooksShape {
    *   version+integrity) declared in `pnpm-workspace.yaml`.
    * @param seed - The inline catalogs, as `catalog name → dependency → range`.
    */
-  readonly inject: (root: string, configDependencies: Readonly<Record<string, string>>, seed: Readonly<Record<string, Readonly<Record<string, string>>>>) => Effect.Effect<HookInjection, CatalogAssemblyError>;
+  readonly inject: (root: string, configDependencies: Readonly<Record<string, string>>, seed: Readonly<Record<string, Readonly<Record<string, string>>>>) => Effect.Effect<HookInjection, CatalogAssemblyError$1>;
 }
 declare const ConfigDependencyHooks_base: Context.ServiceClass<ConfigDependencyHooks, "@effected/workspaces/ConfigDependencyHooks", ConfigDependencyHooksShape>;
 /**
@@ -6748,6 +6900,58 @@ declare class ConfigDependencyHooks extends ConfigDependencyHooks_base {
    * `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>;
 }
 declare const DetectedPackageManager_base: Schema.Class<DetectedPackageManager, Schema.Struct<{
   /** The detected manager. */
@@ -7297,7 +7501,7 @@ declare class CatalogSet extends CatalogSet_base {
    *
    * @param text - The raw YAML text.
    */
-  static readonly fromWorkspaceYaml: (text: string) => Effect.Effect<CatalogSet, CatalogAssemblyError, never>;
+  static readonly fromWorkspaceYaml: (text: string) => Effect.Effect<CatalogSet, CatalogAssemblyError$1, never>;
   /**
    * The `catalogs:` section of a pnpm lockfile, whose entries are either a bare
    * range or a `{ specifier, version }` pair.
@@ -7345,7 +7549,7 @@ declare class CatalogSet extends CatalogSet_base {
    *
    * @param text - The raw root `package.json` text.
    */
-  static readonly fromManifestWorkspaces: (text: string) => Effect.Effect<CatalogSet, CatalogAssemblyError, never>;
+  static readonly fromManifestWorkspaces: (text: string) => Effect.Effect<CatalogSet, CatalogAssemblyError$1, never>;
   /** Merge sets. Later sets win per dependency within a catalog. */
   static merge(...sets: ReadonlyArray<CatalogSet>): CatalogSet;
   /** Whether any catalog declares anything. */
@@ -7377,7 +7581,7 @@ declare class CatalogSet extends CatalogSet_base {
  *
  * @public
  */
-type CatalogAssemblyFailure = CatalogAssemblyError | WorkspaceRootNotFoundError;
+type CatalogAssemblyFailure = CatalogAssemblyError$1 | WorkspaceRootNotFoundError;
 /**
  * The {@link WorkspaceCatalogs} service shape.
  *
@@ -7480,6 +7684,24 @@ declare class WorkspaceCatalogs extends WorkspaceCatalogs_base {
    * 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.
@@ -7548,7 +7770,7 @@ declare class WorkspaceCatalogs extends WorkspaceCatalogs_base {
    * 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>;
+  static readonly catalogResolver: Layer.Layer<CatalogResolver$1, never, WorkspaceCatalogs>;
 }
 //#endregion
 //#region src/WorkspaceStateSnapshot.d.ts
@@ -7708,15 +7930,15 @@ declare class WorkspaceStateSnapshot extends WorkspaceStateSnapshot_base {
    * were already assembled when it was captured, so this resolver is total —
    * `rangeOf` never fails.
    */
-  get catalogResolver(): Layer.Layer<CatalogResolver>;
+  get catalogResolver(): Layer.Layer<CatalogResolver$1>;
   /**
    * 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>;
+  get workspaceResolver(): Layer.Layer<WorkspaceResolver$1>;
   /** Both snapshot-scoped resolver layers merged. Built once per instance and cached. */
-  get resolvers(): Layer.Layer<CatalogResolver | WorkspaceResolver>;
+  get resolvers(): Layer.Layer<CatalogResolver$1 | WorkspaceResolver$1>;
 }
 //#endregion
 //#region src/WorkspaceSnapshots.d.ts
@@ -7734,7 +7956,7 @@ declare class WorkspaceStateSnapshot extends WorkspaceStateSnapshot_base {
  *
  * @public
  */
-type WorkspaceSnapshotAtFailure = GitCommandError | NotARepositoryError | UnknownRefError | CatalogAssemblyError | WorkspaceRootNotFoundError;
+type WorkspaceSnapshotAtFailure = GitCommandError | NotARepositoryError | UnknownRefError | CatalogAssemblyError$1 | WorkspaceRootNotFoundError;
 /**
  * Every failure `WorkspaceSnapshots.worktree` can surface: the discovery
  * failures plus a catalog-assembly failure.
@@ -7746,7 +7968,7 @@ type WorkspaceSnapshotAtFailure = GitCommandError | NotARepositoryError | Unknow
  *
  * @public
  */
-type WorkspaceSnapshotWorktreeFailure = WorkspaceDiscoveryFailure | CatalogAssemblyError;
+type WorkspaceSnapshotWorktreeFailure = WorkspaceDiscoveryFailure | CatalogAssemblyError$1;
 /**
  * Options for the {@link WorkspaceSnapshots} layer.
  *