@savvy-web/silk 3.2.1 → 3.2.3

package/changesets-changelog.d.ts

@@ -3296,7 +3296,7 @@ type Label = Label$1;
 type Severity = Severity$1;
 type Plugin<Tree extends Node$3 = Node$3, Option extends unknown = unknown> = (config?: [level: Label | Severity | boolean, option?: Option] | Label | Option | Severity) => ((tree: Tree, file: VFile, next: TransformCallback<Tree>) => undefined) | undefined;
 //#endregion
-//#region ../../node_modules/.pnpm/@effected+git@0.4.2_effect@4.0.0-beta.101/node_modules/@effected/git/index.d.ts
+//#region ../../node_modules/.pnpm/@effected+git@0.5.0_effect@4.0.0-beta.101/node_modules/@effected/git/index.d.ts
 //#region src/Git.d.ts
 declare const GitCommandError_base: Schema.Class<GitCommandError, Schema.TaggedStruct<"GitCommandError", {
   /**
@@ -3648,6 +3648,65 @@ declare const Git_base: Context.ServiceClass<Git, "@effected/git/Git", GitShape>
 declare class Git extends Git_base {
   /** Resolves `ChildProcessSpawner` once, at construction — every method's `R` is `never`. */
   static readonly layer: Layer.Layer<Git, never, ChildProcessSpawner.ChildProcessSpawner>;
+  /**
+   * An in-memory test double of the service shape: stub only the methods the
+   * test exercises, every other method **dies** with a defect naming itself.
+   *
+   * @remarks
+   * Unlike `WorkspaceDiscovery.makeTest`, **no method here has an honest
+   * default** — the shape is twenty-six unrelated git operations, and a
+   * fabricated answer for any of them (an empty tree, a made-up sha, a silent
+   * no-op `checkout`) would leak into consumer logic as fact. So every
+   * unstubbed method fails loudly as a defect
+   * (`Git.makeTest: <name>() was called but not stubbed`) rather than
+   * succeeding with a lie or failing with a dishonest typed error — which is
+   * also what makes the double a proof that a test touches *nothing but* the
+   * methods it stubbed.
+   *
+   * The double deliberately models **none** of the live service's semantics:
+   * no stderr classification, no option-injection guard (an option-like ref a
+   * stub accepts would be refused live), no `LC_ALL=C` pinning, no timeout,
+   * and no `./`-vs-bare path resolution on `show` — a stub answers exactly
+   * what it is told and nothing else. A suite exercising any of those wants
+   * `Git.layer` over a mocked `ChildProcessSpawner` (or real git) instead.
+   *
+   * @example
+   * ```ts
+   * import { Git } from "@effected/git";
+   * import { Effect, Option } from "effect";
+   *
+   * const double = Git.makeTest({
+   *   show: (_cwd, _ref, path) =>
+   *     Effect.succeed(path === "./package.json" ? Option.some("{}") : Option.none()),
+   * });
+   * // `double.show(...)` answers; `double.status(...)` dies, named.
+   * ```
+   */
+  static readonly makeTest: (overrides?: Partial<GitShape>) => GitShape;
+  /**
+   * The test layer: {@link Git.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 { Git, LsTreeEntry } from "@effected/git";
+   * import { Effect } from "effect";
+   *
+   * const TestGit = Git.layerTest({
+   *   lsTree: () =>
+   *     Effect.succeed([
+   *       LsTreeEntry.make({ mode: "100644", type: "blob", oid: "0".repeat(40), path: "package.json" }),
+   *     ]),
+   * });
+   * // program.pipe(Effect.provide(TestGit))
+   * ```
+   */
+  static readonly layerTest: (overrides?: Partial<GitShape>) => Layer.Layer<Git>;
 }
 //#endregion
 //#region ../../node_modules/.pnpm/@effected+semver@0.2.1_effect@4.0.0-beta.101/node_modules/@effected/semver/index.d.ts
@@ -4225,7 +4284,7 @@ declare class UnsatisfiableConstraintError extends UnsatisfiableConstraintError_
   get message(): string;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@effected+npm@0.3.1_@effected+semver@0.2.1_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.4.0_@effected+semver@0.2.1_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", {
   /**
@@ -4567,7 +4626,9 @@ declare class ReleaseAgeGate extends ReleaseAgeGate_base {
    * Combine partial contributions from multiple sources into one effective
    * gate: **strictest age wins** (the maximum of the contributed ages,
    * clamped to be non-negative) and the exclude sets **union** (deduplicated,
-   * insertion order preserved). A contribution's absent field adds nothing; a
+   * lexicographically sorted — a canonical wire form, so the combined gate is
+   * deterministic regardless of the order contributions arrive in). A
+   * contribution's absent field adds nothing; a
    * negative or non-finite contributed age is ignored by the clamp. With no
    * contributions (or only empty ones) the result is the inert zero gate
    * (`ageMinutes: 0`, `exclude: []`).
@@ -4791,7 +4852,7 @@ declare class GlobPattern extends GlobPattern_base {
   static readonly FromString: Schema.Codec<GlobPattern, string>;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@effected+lockfiles@0.1.10_@effected+jsonc@0.5.1_effect@4.0.0-beta.101__@effected+npm@0_baf93f2c33d0504f713f685ac5710e50/node_modules/@effected/lockfiles/index.d.ts
+//#region ../../node_modules/.pnpm/@effected+lockfiles@0.2.0_@effected+jsonc@0.5.1_effect@4.0.0-beta.101__@effected+npm@0._bb7f362bdd42193e6ed4fc5154b217f4/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">;
@@ -4819,6 +4880,7 @@ declare const ImporterDependency_base: Schema.Class<ImporterDependency, Schema.S
   readonly name: Schema.NonEmptyString;
   readonly specifier: Schema.Codec<ClassifiedSpecifier, string, never, never>;
   readonly version: Schema.optionalKey<Schema.String>;
+  readonly peerSuffix: Schema.optionalKey<Schema.String>;
   readonly depType: Schema.Literals<readonly ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"]>;
 }>, {}>;
 /**
@@ -4831,11 +4893,20 @@ declare const ImporterDependency_base: Schema.Class<ImporterDependency, Schema.S
  *   `ClassifiedSpecifier` (`catalog:` / `workspace:` / range / dist-tag / raw),
  *   while encoding round-trips the **exact original string byte-for-byte** — the
  *   guarantee a before/after lockfile diff relies on.
- * - `version` — the concrete resolved version, **populated by pnpm only**. pnpm
- *   records `{ specifier, version }` per importer dependency; bun and npm record
- *   resolved versions on their package entries instead, so for those formats
- *   `version` is absent and a consumer joins by `name` against
- *   `Lockfile.packages`.
+ * - `version` — the concrete resolved version, **populated by pnpm only**:
+ *   comparable across refs and printable. pnpm records `{ specifier, version }`
+ *   per importer dependency, and the parser splits pnpm's peer-disambiguation
+ *   suffix off into `peerSuffix`, so `version` is always the plain version — or
+ *   a non-registry resolution (`link:../utils`, `file:...`), passed through
+ *   verbatim. bun and npm record resolved versions on their package entries
+ *   instead, so for those formats `version` is absent and a consumer joins by
+ *   `name` against `Lockfile.packages`.
+ * - `peerSuffix` — pnpm's peer-disambiguation context: the raw parenthesized
+ *   chain the lockfile recorded after the version, e.g.
+ *   `(effect@4.0.0-beta.101)(ioredis@5.11.1(supports-color@8.1.1))`. Present
+ *   only when the lockfile recorded one — never for suffix-free pnpm entries,
+ *   and never for the other formats, which do not record peer context per
+ *   importer dependency.
  * - `depType` — which dependency map declared it, spelled with `@effected/npm`'s
  *   kit-wide `DependencyField` vocabulary.
  *
@@ -5211,7 +5282,7 @@ declare class LockfileIntegrity extends LockfileIntegrity_base {
   static compare(lockfile: Lockfile, manifests: ReadonlyArray<WorkspaceManifest>): LockfileIntegrity;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@effected+package-json@0.5.1_effect@4.0.0-beta.101/node_modules/@effected/package-json/index.d.ts
+//#region ../../node_modules/.pnpm/@effected+package-json@0.5.2_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<{
   /** The package name. */
@@ -5659,7 +5730,7 @@ declare class Package extends Package_base {
   toJsonString(options?: PackageFormatOptions): string;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@effected+workspaces@0.6.2_@effected+jsonc@0.5.1_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.8.0_@effected+jsonc@0.5.1_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`. */
@@ -6636,6 +6707,65 @@ declare class LockfileReader extends LockfileReader_base {
    * `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/Publishability.d.ts
@@ -6747,6 +6877,26 @@ declare class PublishabilityDetector extends PublishabilityDetector_base {
 }
 //#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>>;
@@ -6879,6 +7029,19 @@ interface WorkspaceCatalogsShape {
    * workspace) has no release-age keys, so the gate is the inert zero gate.
    */
   readonly releaseAgeGate: () => Effect.Effect<ReleaseAgeGate, 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>;
 }
 /**
  * Options for the {@link WorkspaceCatalogs} layer.
@@ -6944,6 +7107,61 @@ 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>;
+  /**
+   * 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.
+   *
+   * @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.
@@ -7007,6 +7225,18 @@ declare const WorkspaceStateSnapshot_base: Schema.Class<WorkspaceStateSnapshot,
   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>>>;
 }>, {}>;
 /**
  * The state of a whole workspace at one moment — its packages and its assembled
@@ -7056,11 +7286,43 @@ declare class WorkspaceStateSnapshot extends WorkspaceStateSnapshot_base {
    * unparseable string — is `Option.none()`, because there is no indirection to
    * resolve. Total.
    *
+   * A `catalog:` specifier the catalog set cannot 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>;
   /**
    * A `CatalogResolver` layer implementing `@effected/npm`'s contract against
    * THIS snapshot's catalog set — so code written to the contract resolves
@@ -7175,6 +7437,62 @@ declare class WorkspaceSnapshots extends WorkspaceSnapshots_base {
    * `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.
+   *
+   * @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