@effected/workspaces 0.30.4 → 0.32.0

package/internal/importerVersions.js

@@ -3,7 +3,7 @@
 * Strip pnpm's peer-disambiguation suffix from a recorded importer version.
 *
 * pnpm records an importer version as the resolved version followed by the peer
-* context it was resolved under — `4.0.0-beta.101(effect@4.0.0-beta.101)(ioredis@5.11.1(supports-color@8.1.1))`.
+* context it was resolved under — `4.0.0(effect@4.0.0)(ioredis@5.11.1(supports-color@8.1.1))`.
 * `@effected/lockfiles` stores that string verbatim (its `packages:` key parser
 * strips the suffix; the importer entries deliberately keep it), so the raw
 * value must never reach a consumer's dependency table — it would render the

package/node-sync.d.ts

@@ -92,7 +92,9 @@ interface SyncDirectoryEntry {
  * satisfies it verbatim:
  *
  * ```ts
+ * import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
  * import * as path from "node:path";
+ * import type { WorkspacesSyncOptions } from "@effected/workspaces";
  *
  * const options: WorkspacesSyncOptions = {
  * 	fileSystem: { exists: existsSync, readFile: (p) => readFileSync(p, "utf8"), readDirectory: (p) => readdirSync(p), isDirectory: (p) => statSync(p).isDirectory() },

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@effected/workspaces",
-	"version": "0.30.4",
+	"version": "0.32.0",
 	"private": false,
 	"description": "Monorepo workspace tooling as Effect services — root discovery, package enumeration, the dependency graph, package-manager detection, pnpm catalog resolution, lockfile IO and git-based change detection.",
 	"keywords": [
@@ -51,23 +51,23 @@
 		"./package.json": "./package.json"
 	},
 	"dependencies": {
-		"@effected/commands": "^0.10.0",
-		"@effected/git": "^0.19.0",
-		"@effected/glob": "^0.9.0",
-		"@effected/jsonc": "^0.14.0",
-		"@effected/lockfiles": "^0.14.0",
-		"@effected/npm": "^0.19.1",
-		"@effected/package-json": "^0.19.1",
-		"@effected/semver": "^0.10.1",
-		"@effected/walker": "^0.14.1",
-		"@effected/yaml": "^0.18.0",
+		"@effected/commands": "^0.11.0",
+		"@effected/git": "^0.20.0",
+		"@effected/glob": "^0.10.0",
+		"@effected/jsonc": "^0.15.1",
+		"@effected/lockfiles": "^0.15.0",
+		"@effected/npm": "^0.20.0",
+		"@effected/package-json": "^0.20.0",
+		"@effected/semver": "^0.11.0",
+		"@effected/walker": "^0.15.0",
+		"@effected/yaml": "^0.19.1",
 		"@pnpm/catalogs.config": "^1100.0.5",
 		"@pnpm/catalogs.protocol-parser": "^1100.0.0",
 		"@pnpm/catalogs.resolver": "^1100.0.0",
 		"@pnpm/catalogs.types": "^1100.0.0"
 	},
 	"peerDependencies": {
-		"effect": "4.0.0-rc.118"
+		"effect": "^4.0.0"
 	},
 	"engines": {
 		"node": ">=24.11.0"

package/testing.d.ts

@@ -1,5 +1,5 @@
 import { DependencyField, WorkspaceResolver } from "@effected/npm";
-import { Context, Duration, Effect, FileSystem, Layer, Option, Path, Schema } from "effect";
+import { Context, Duration, Effect, FileSystem, Layer, Option, Path, PlatformError, Schema, Stream } from "effect";
 import { GlobPattern } from "@effected/glob";
 import { WorkspaceManifest } from "@effected/lockfiles";
 import { Package } from "@effected/package-json";
@@ -57,7 +57,7 @@ declare const LayerPolicy_base: Schema.Class<LayerPolicy, Schema.Struct<{
  * message names every such key. A typo on an optional key would otherwise be
  * silently dropped: `requiredEdge` would remove the non-vacuity guard and
  * leave the report green. `$schema` is always accepted. A file that carries
- * keys of its own, such as systems' `harness`, passes them in `allowKeys`.
+ * keys of its own, such as a `harness` block, passes them in `allowKeys`.
  *
  * @example
  * ```ts
@@ -136,7 +136,7 @@ interface DependencyDiff {
   readonly added: Record<string, string>;
   /** Present in the other, absent from the receiver. */
   readonly removed: Record<string, string>;
-  /** Present in both at different specifiers. */
+  /** Present in both at different specifiers: `from` is the other package's, `to` the receiver's. */
   readonly changed: Record<string, {
     readonly from: string;
     readonly to: string;
@@ -196,13 +196,9 @@ declare const WorkspacePackage_base: Schema.Class<WorkspacePackage, Schema.Struc
    * 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.
+   * Carried, not derived: `WorkspaceDiscovery` resolves the root before
+   * enumerating, so every package arrives with it and consumers need no
+   * per-package root arithmetic over `relativePath`.
    *
    * For the root package this equals `path`, and `relativePath` is `"."`.
    */
@@ -229,8 +225,7 @@ declare const WorkspacePackage_base: Schema.Class<WorkspacePackage, Schema.Struc
    * 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.
+   * values constructed or decoded without the field.
    */
   readonly manifestRecord: Schema.withConstructorDefault<Schema.withDecodingDefaultKey<Schema.$Record<Schema.String, Schema.Unknown>, never>>;
 }>, {}>;
@@ -293,8 +288,8 @@ export declare class WorkspacePackage extends WorkspacePackage_base {
   /** 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.
+   * Whether any dependency name (across all four kinds) matches the glob
+   * `pattern`, using `@effected/glob`.
    *
    * @remarks
    * A `GlobPattern` is total and free to test. A `string` is compiled on every
@@ -307,7 +302,12 @@ export declare class WorkspacePackage extends WorkspacePackage_base {
    * @param pattern - A compiled pattern, or a source string to compile.
    */
   matchesDependency(pattern: GlobPattern | string): boolean;
-  /** Compare this package's dependencies against `other`'s. */
+  /**
+   * Compare this package's dependencies against `other`'s, treating `other` as
+   * the baseline: what this package added, removed or re-specified.
+   *
+   * @param other - The package to compare against.
+   */
   dependencyDiff(other: WorkspacePackage): DependencyDiff;
   /**
    * Project to `@effected/lockfiles`' `WorkspaceManifest` — the input shape of
@@ -318,6 +318,10 @@ export declare class WorkspacePackage extends WorkspacePackage_base {
    * 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.
+   *
+   * @remarks
+   * Fails with {@link WorkspaceManifestError} (`kind: "read"` or `"decode"`) and
+   * requires core `FileSystem`.
    */
   static readonly manifest: (self: WorkspacePackage) => Effect.Effect<Package, WorkspaceManifestError, FileSystem.FileSystem>;
   /** Instance form of `WorkspacePackage.manifest`. */
@@ -462,12 +466,10 @@ export declare class WorkspaceRoot extends WorkspaceRoot_base {
    * 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
+   * Stands in for a hand-written `Layer.succeed` over a `find` that ignores its
+   * arguments. Unlike that, this double **honours `stopAt`**: a `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}.
    *
@@ -541,7 +543,7 @@ declare const WorkspaceDiscoveryError_base: Schema.Class<WorkspaceDiscoveryError
  * A manifest with no `version` is NOT a failure: pnpm accepts a version-less
  * private package and a private monorepo root without one is the ordinary
  * shape, so the member is discovered with `WorkspacePackage.version` absent.
- * The former `missingVersion` kind is retired. Only ABSENCE is tolerated: a
+ * Only ABSENCE is tolerated: a
  * `version` that is present but not a string — or present and `""`, which pnpm
  * never wrote and which would resolve `workspace:^` to a bare `"^"` — is the
  * manifest's shape being wrong and reports `invalidShape`.
@@ -650,11 +652,10 @@ interface WorkspaceDiscoveryOptions {
    * `importerMap`, `getPackage`, `resolveFile`, `resolveFiles`). The per-call
    * `infoIn`, `listPackagesIn` and `refreshIn` resolve from an arbitrary
    * directory the caller names, which a single layer-level ceiling cannot
-   * sensibly bound, so they ascend unbounded as before.
+   * sensibly bound, so they ascend unbounded.
    *
    * `LockfileReader`, `WorkspaceCatalogs` and `WorkspaceSnapshots` each
-   * take the same option; give them the same
-   * value when wiring by hand, or let a `Workspaces.*` composite forward one
+   * take the same option; give them the same value when wiring by hand, or let a `Workspaces.*` composite forward one
    * `stopAt` to all of them, so no service adopts a root another refused.
    *
    * @defaultValue no ceiling — the ascent runs to the filesystem root.
@@ -751,11 +752,9 @@ declare const WorkspaceDiscovery_base: Context.ServiceClass<WorkspaceDiscovery,
  * 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.
+ * The memo is **success-only**: a failure or interrupt is not cached, so an
+ * init interrupted by an unrelated timeout cannot brick the layer, and the next
+ * call retries.
  *
  * @example
  * ```ts
@@ -778,12 +777,14 @@ export declare class WorkspaceDiscovery extends WorkspaceDiscovery_base {
    */
   static readonly make: (options?: WorkspaceDiscoveryOptions) => Effect.Effect<WorkspaceDiscoveryShape, never, WorkspaceRoot | FileSystem.FileSystem | Path.Path>;
   /**
-   * The live layer.
+   * The live layer, discovering the workspace from `options.cwd`.
    *
    * @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.
+   *
+   * @param options - Root resolution and enumeration bounds.
    */
   static readonly layer: (options?: WorkspaceDiscoveryOptions) => Layer.Layer<WorkspaceDiscovery, never, WorkspaceRoot | FileSystem.FileSystem | Path.Path>;
   /**
@@ -894,12 +895,12 @@ export declare class WorkspaceDiscovery extends WorkspaceDiscovery_base {
  * @remarks
  * `{ directory }` runs `npm pack` in that subdirectory of each package, whose
  * manifest must already be publish-ready. The default,
- * `{ directory: "dist/prod/npm/pkg" }`, is the effected bundler's prod npm
+ * `{ directory: "dist/prod/npm/pkg" }`, is `@savvy-web/bundler`'s prod npm
  * output: the same file list a release publishes.
  *
  * `"source"` runs `pnpm pack` in the package directory: pnpm honours
  * `publishConfig.directory` and rewrites `workspace:` and `catalog:`
- * specifiers. Two costs. Under the effected bundler `publishConfig.directory`
+ * specifiers. Two costs. Under `@savvy-web/bundler`, `publishConfig.directory`
  * names the DEV build, so source mode proves the dev artifact, not the
  * published one. And pnpm can rewrite a `workspace:` specifier only in a
  * workspace that has been `pnpm install`ed: in a never-installed one the pack
@@ -937,10 +938,10 @@ interface PackedInstallClosureOptions {
    * `.tgz`, with or without a `file:` prefix.
    *
    * @remarks
-   * The dogfood case: a closure member imports a surface of a dependency
-   * that exists only in a sibling checkout's unreleased build, and the
-   * registry's copy lacks it. A directory is `npm pack`ed, so it must be
-   * publish-ready (for an effected-bundled package, its
+   * For a closure member that imports a surface of a dependency existing
+   * only in a sibling checkout's unreleased build, which the registry's copy
+   * lacks. A directory is `npm pack`ed, so it must be
+   * publish-ready (for a package built by `@savvy-web/bundler`, its
    * `dist/prod/npm/pkg`); a `.tgz` is used as it is. Either way the packed
    * manifest must be named as its key, carry no specifier only a workspace
    * could resolve, and it joins `PackedInstallResult.tarballs`. Each
@@ -957,9 +958,9 @@ interface PackedInstallClosureOptions {
   readonly overrides?: Readonly<Record<string, string>> | undefined;
   /**
    * Also read the workspace root's `pnpm-workspace.yaml` and take every
-   * `overrides:` entry of the dogfood link shape,
-   * `"@scope/name": "file:<dir>"`, as if passed through `overrides`: the
-   * linked sibling builds the workspace itself installs. Entries that are not `file:`, or
+   * `overrides:` entry of the link shape `"@scope/name": "file:<dir>"` as if
+   * passed through `overrides`: the linked sibling builds the workspace itself
+   * installs. Entries that are not `file:`, or
    * whose key carries a selector (`a>b`, `a@1`), are left out. A root with
    * no readable `pnpm-workspace.yaml`, or one that is not YAML, fails
    * `InvalidOverride`.
@@ -1029,7 +1030,12 @@ interface PackedInstallOptions extends PackedInstallClosureOptions {
    * `false`, so sharing is an explicit choice.
    */
   readonly allowSharedBins?: boolean | undefined;
-  /** The environment for every spawn: pass `process.env` from the test file. The parent manager's context is stripped. */
+  /**
+   * The environment for every spawn: pass `process.env` from the test file, the edge that supplies the host
+   * environment. It is taken whole because the parent manager's context is stripped by prefix (`npm_*`,
+   * `pnpm_config_*`, `yarn_*`), which `Config`, reading keys by name, cannot enumerate; read single keys such as
+   * `CI` through `Config`.
+   */
   readonly env: Readonly<Record<string, string | undefined>>;
   /**
    * Extra consumer dependencies, name to range or `file:` tarball spec.
@@ -1106,6 +1112,22 @@ interface BinCommandOptions {
 interface RunBinOptions extends BinCommandOptions {
   /** Ceiling on the run. Defaults to one minute. Expiry fails `BinFailed` with a message naming the bin and this duration. */
   readonly timeout?: Duration.Input | undefined;
+  /**
+   * What to write to the bin's stdin, which is then closed: a string (UTF-8
+   * encoded), bytes, or a byte stream for input that must arrive in pieces,
+   * such as a framed LSP session.
+   *
+   * @remarks
+   * Omitted or `""`, the bin's stdin is the null device: it reads end of
+   * input immediately, never an open pipe, so a bin that reads stdin exits
+   * instead of hanging until the ceiling. Empty bytes and an empty stream
+   * are sent as given: the bin sees an ended, empty input. A bin that answers
+   * only after the input is complete is driven by this option; one that must
+   * be interleaved with its output is driven through
+   * {@link InstalledConsumer.command} or {@link InstalledConsumer.carrierCommand},
+   * which leave stdin open.
+   */
+  readonly stdin?: string | Uint8Array | Stream.Stream<Uint8Array, PlatformError.PlatformError> | undefined;
 }
 /**
  * Which installed package a `node_modules/.bin` symlink resolves into.
@@ -1208,7 +1230,9 @@ export declare class InstalledConsumer extends InstalledConsumer_base {
    * Run the installed bin `name` to completion and collect what it wrote.
    *
    * @remarks
-   * Spawns {@link InstalledConsumer.command} with stdin ignored: the bin
+   * Spawns {@link InstalledConsumer.command} with `options.stdin` as its
+   * input (the null device when omitted, so a bin never waits on an open
+   * pipe): the bin
    * from the consumer's directory, under the install's scrubbed environment
    * with `options.env` layered over it after the scrub, and nothing
    * inherited beyond that. A
@@ -1220,7 +1244,7 @@ export declare class InstalledConsumer extends InstalledConsumer_base {
    *
    * @param name - The bin, as named in `node_modules/.bin`.
    * @param args - Its arguments.
-   * @param options - Extra environment, working directory and ceiling.
+   * @param options - Extra environment, working directory, ceiling and stdin.
    */
   runBin(name: string, args?: ReadonlyArray<string>, options?: RunBinOptions): Effect.Effect<CommandOutput, PackedInstallError, ChildProcessSpawner.ChildProcessSpawner>;
   /**
@@ -1260,7 +1284,8 @@ export declare class InstalledConsumer extends InstalledConsumer_base {
    * the `node_modules/.bin` slot.
    *
    * @remarks
-   * Spawns {@link InstalledConsumer.carrierCommand} with stdin ignored, and
+   * Spawns {@link InstalledConsumer.carrierCommand} with `options.stdin` as
+   * its input (the null device when omitted), and
    * reports as {@link InstalledConsumer.runBin} does: a non-zero exit is a
    * result, and a bin that cannot spawn or outlives `options.timeout` (one
    * minute by default) fails `BinFailed`. Use it beside `runBin` under
@@ -1271,7 +1296,7 @@ export declare class InstalledConsumer extends InstalledConsumer_base {
    *
    * @param name - The bin, as the carrier's `bin` map names it.
    * @param args - Its arguments.
-   * @param options - Extra environment, working directory and ceiling.
+   * @param options - Extra environment, working directory, ceiling and stdin.
    */
   runCarrierBin(name: string, args?: ReadonlyArray<string>, options?: RunBinOptions): Effect.Effect<CommandOutput, PackedInstallError, FileSystem.FileSystem | Path.Path | ChildProcessSpawner.ChildProcessSpawner>;
 }
@@ -1322,6 +1347,43 @@ interface PackedInstallBudget {
    */
   readonly perConsumer?: Duration.Input | undefined;
 }
+/**
+ * Options for {@link PackedInstall.preflight}: the run's closure and pack
+ * source, so the check answers for exactly the run those options describe.
+ *
+ * @public
+ */
+interface PackedInstallPreflightOptions extends PackedInstallClosureOptions {
+  /** The carrier, as the run's `carrier`. */
+  readonly carrier: string;
+  /** Where the run packs from; defaults as the run's does, to `{ directory: "dist/prod/npm/pkg" }`. */
+  readonly packFrom?: PackSource | undefined;
+}
+/**
+ * Whether the pack source a run needs is on disk.
+ *
+ * @public
+ */
+interface PackedInstallPreflight {
+  /** `true` when every package the run packs has its pack source in place. */
+  readonly ready: boolean;
+  /** The absolute `package.json` paths that do not exist, in pack order; empty exactly when `ready`. */
+  readonly missing: ReadonlyArray<string>;
+}
+/**
+ * What a test suite should do about a {@link PackedInstallPreflight}.
+ *
+ * @public
+ */
+interface PackedInstallGate {
+  /**
+   * `"run"` when the pack source is there; `"skip"` when it is missing and
+   * the run is not under CI; `"fail"` when it is missing under CI.
+   */
+  readonly action: "run" | "skip" | "fail";
+  /** Why, naming the missing paths and the build to run. Empty when `action` is `"run"`. */
+  readonly message: string;
+}
 /**
  * Prove a carrier's bins reach a consumer that is not part of the workspace,
  * once per available package manager.
@@ -1489,6 +1551,76 @@ export declare class PackedInstall {
   static readonly timeoutBudgetFor: (options: PackedInstallOptions, extra?: {
     readonly perConsumer?: Duration.Input | undefined;
   }) => Effect.Effect<Duration.Duration, PackedInstallError, WorkspaceDiscovery | FileSystem.FileSystem | Path.Path>;
+  /**
+   * Whether the pack source {@link PackedInstall.run} would read is on disk,
+   * before any package manager is spawned.
+   *
+   * @remarks
+   * Plans the closure as the run does (`PackedInstall.closure`'s planner) and
+   * checks the `package.json` of each closure package under `packFrom`
+   * (default `{ directory: "dist/prod/npm/pkg" }`), the same file whose
+   * absence makes the run fail `PackSourceMissing`. Under `packFrom: "source"`
+   * the packer builds nothing of its own, so nothing is checked and the
+   * result is ready. A package a bundler's dev build produced is no
+   * substitute: the prod output exists only after the prod build, which a
+   * test job's usual `build:dev` pre-step does not run. Pair it with
+   * {@link PackedInstall.gate} to skip locally and fail under CI.
+   *
+   * Fails as `closure` does, plus `Io` when a path cannot be inspected.
+   *
+   * @example
+   * ```ts
+   * import { NodeServices } from "@effect/platform-node";
+   * import { Workspaces } from "@effected/workspaces";
+   * import { PackedInstall } from "@effected/workspaces/testing";
+   * import { Effect, Layer } from "effect";
+   *
+   * const Live = Workspaces.layer({ cwd: "/repo" }).pipe(Layer.provideMerge(NodeServices.layer));
+   * const preflight = await Effect.runPromise(
+   *   PackedInstall.preflight({ carrier: "my-tool", closure: "auto" }).pipe(Effect.provide(Live)),
+   * );
+   * console.log(preflight.ready, preflight.missing);
+   * ```
+   *
+   * @param options - The run's carrier, closure, overrides and pack source.
+   */
+  static readonly preflight: (options: PackedInstallPreflightOptions) => Effect.Effect<PackedInstallPreflight, PackedInstallError, WorkspaceDiscovery | FileSystem.FileSystem | Path.Path>;
+  /**
+   * Turns a {@link PackedInstallPreflight} into the suite's decision: run,
+   * skip locally, or fail under CI.
+   *
+   * @remarks
+   * `CI` is read through `Config`, so the ambient `ConfigProvider` decides —
+   * the process environment at a test file's top level, and whatever a test
+   * provides in a test; nothing here reads `process`. `CI` counts as set when
+   * it is present and not `""`, `"0"` or `"false"` (case-insensitive), and an
+   * unreadable `CI` counts as unset. Ready is always `"run"`;
+   * missing is `"skip"` off CI and `"fail"` on it, so a CI job that never ran
+   * the prod build cannot pass by silently skipping the proof. The message
+   * names every missing path. The test job must run the prod build
+   * (`build:prod` for a `@savvy-web/bundler` package) before the packed-install
+   * tests: a dev build leaves `dist/prod` absent.
+   *
+   * @example
+   * ```ts
+   * import { assert, describe, it } from "@effect/vitest";
+   * import { PackedInstall } from "@effected/workspaces/testing";
+   * import { Effect } from "effect";
+   *
+   * declare const preflight: { readonly ready: boolean; readonly missing: ReadonlyArray<string> };
+   * const gate = Effect.runSync(PackedInstall.gate(preflight));
+   *
+   * describe.runIf(gate.action === "run")("packed install", () => {
+   *   it("installs", () => {});
+   * });
+   * describe.runIf(gate.action === "fail")("packed install prod build", () => {
+   *   it("exists", () => assert.fail(gate.message));
+   * });
+   * ```
+   *
+   * @param preflight - What {@link PackedInstall.preflight} answered.
+   */
+  static readonly gate: (preflight: PackedInstallPreflight) => Effect.Effect<PackedInstallGate>;
   /** Pack, then install under every available manager. */
   static readonly run: (options: PackedInstallOptions) => Effect.Effect<PackedInstallResult, PackedInstallError, ChildProcessSpawner.ChildProcessSpawner | FileSystem.FileSystem | Path.Path | import("effect/Scope").Scope | WorkspaceDiscovery>;
 }
@@ -1761,7 +1893,7 @@ export declare class SourceBoundary {
   static readonly scan: (options: ScanOptions) => Effect.Effect<SourceScan, import("@effected/glob").GlobPatternError | import("effect/PlatformError").PlatformError, FileSystem.FileSystem | Path.Path>;
   /** The shipped positive- and negative-control snippets, at least one of each per rule kind. */
   static readonly fixtures: ReadonlyArray<BoundaryFixture>;
-  /** The names of shipped fixtures the scanner now gets wrong; `[]` means it still flags and spares what it must. */
+  /** The names of shipped fixtures the scanner gets wrong; `[]` means it still flags and spares what it must. */
   static readonly verifyFixtures: () => ReadonlyArray<string>;
 }
 //#endregion
@@ -1860,5 +1992,5 @@ export declare class WorkspaceLayering {
   static readonly checkWorkspace: (policy: LayerPolicy) => Effect.Effect<LayeringReport, WorkspaceDiscoveryFailure, WorkspaceDiscovery>;
 }
 //#endregion
-export type { BinCommandOptions, BinProvenance, BoundaryFixture, BoundaryRule, DependencyDiff, FindWorkspaceRootOptions, LayeringGraph, OffenceRule, PackSource, PackedInstallBudget, PackedInstallClosureOptions, PackedInstallOptions, ReferenceOptions, RunBinOptions, ScanOptions, WorkspaceDiscoveryFailure, WorkspaceDiscoveryOptions, WorkspaceDiscoveryShape, WorkspaceLookupFailure, WorkspaceRootShape };
+export type { BinCommandOptions, BinProvenance, BoundaryFixture, BoundaryRule, DependencyDiff, FindWorkspaceRootOptions, LayeringGraph, OffenceRule, PackSource, PackedInstallBudget, PackedInstallClosureOptions, PackedInstallGate, PackedInstallOptions, PackedInstallPreflight, PackedInstallPreflightOptions, ReferenceOptions, RunBinOptions, ScanOptions, WorkspaceDiscoveryFailure, WorkspaceDiscoveryOptions, WorkspaceDiscoveryShape, WorkspaceLookupFailure, WorkspaceRootShape };
 //# sourceMappingURL=testing.d.ts.map