@ghostry/fabricator 0.0.2 → 0.0.3

package/dist/types/Error/index.d.ts

@@ -45,25 +45,6 @@ export declare namespace FabricatorError {
          */
         limit: unknown);
     }
-    /**
-     * `initialize({ attribution: { kind: "rooted", root } })` when `root` is not
-     * an absolute path or a `file://` URL. A relative root can never prefix a
-     * resolved caller file, so `relativize` would leave every file unchanged —
-     * the option would look configured while silently doing nothing. Thrown
-     * eagerly at `initialize()`, not deferred to wherever that would first become
-     * observable.
-     */
-    class InvalidAttributionRootError extends FabricatorError {
-        /**
-         * The rejected root, as given.
-         */
-        readonly root: string;
-        constructor(
-        /**
-         * The rejected root, as given.
-         */
-        root: string);
-    }
     /**
      * A `self` placeholder resolved with no `T.recursive` expanding around it —
      * only reachable by holding a `self` reference outside the `T.recursive(...)`
@@ -556,4 +537,19 @@ export declare namespace FabricatorError {
     class SynchronousStackError extends FabricatorError {
         constructor();
     }
+    /**
+     * The `fabricator` provider of `integration(instance)`
+     * (`@ghostry/fabricator/harnessing`) was called outside that integration's
+     * own `around`.
+     *
+     * The provider hands back the per-test scope `around` just entered, so there
+     * is no scope for it to return anywhere else. `@ghostry/harness` never does
+     * this — it runs each provider inside its integration's `around` — so this
+     * means a composer that breaks the contract. Raised rather than returning the
+     * base instance, which would draw plausible data from the wrong configuration
+     * with no signal.
+     */
+    class HarnessingProviderError extends FabricatorError {
+        constructor();
+    }
 }

package/dist/types/Fabricator/Constructor.d.ts

@@ -11,9 +11,9 @@ import { type AsFabricator } from "./Types";
  * `function` that explicitly returns an object, so `new construct(schema)`
  * behaves identically to `construct(schema)` — a `new` call's returned object
  * always replaces the freshly-created `this`. The construct signature lets
- * callers spell `new T.Fabricator(schema)` — or `new Fabricator(schema, { seed
- * })` to pin this one build to an explicit seed, independent of the file it's
- * constructed in (see `construct()` for what `options.seed` does).
+ * callers spell `new T.Fabricator(schema)` — or `new Fabricator(schema, { salt
+ * })` to pin this one build's salt slot, leaving every other slot to resolve as
+ * usual (see `construct()` for what `options.salt` does).
  */
 export type Constructor = {
     new <const $Schema extends Buildable>(schema: $Schema, options?: ConstructorOptions): AsFabricator<$Schema>;
@@ -23,7 +23,7 @@ export type Constructor = {
  * internal `convert(schema: any)` — and the precisely-typed `construct()`
  * boundary around it, both closed over a single instance's `source` so every
  * fabricator this `construct()` produces draws from that instance's own
- * seed/streams and never another instance's.
+ * salt/streams and never another instance's.
  *
  * `stack` is the instance's own lineage-wide ambient stack
  * (`Instance/Core.ts`'s `toStack()`) — passed straight through to

package/dist/types/Harnessing/Core.d.ts

@@ -0,0 +1,43 @@
+import type { Instance } from "../Instance/Types";
+import type { PlainObject } from "../Utility/Types";
+import type { FabricatorTestContext, Integration } from "./Types";
+/**
+ * Decorate an existing `Instance` as a `@ghostry/harness` integration.
+ * `around(identity, body)` is `instance.wrap({ salt: layer(saltFor(identity))
+ * })` — one line of real work. Construction ordinals therefore restart per test
+ * (each `wrap` re-instantiates), which is what makes `.only`, filters, shards,
+ * and `.concurrent` unable to shift a neighbor's data. That per-test
+ * partitioning is also why the salt needs no file in it; see `saltFor`
+ * (`Harnessing/Salt.ts`).
+ *
+ * `around`, not `setup`: the ambient frame has to enclose the body, and only
+ * `around` does. Its `finally` running at the call boundary rather than at test
+ * settlement costs nothing here — there is no teardown, and the
+ * `AsyncLocalStorage` carrier keeps the frame alive across the body's `await`s
+ * regardless of when `wrap` returns. On the synchronous carrier an async body
+ * still raises `SynchronousStackError` from `wrap`. Declaring no `setup` also
+ * keeps `@ghostry/harness` on its uninstrumented path, where a synchronous
+ * assertion failure is reported at the user's own line.
+ *
+ * `provides.fabricator` hands back the scope `wrap` gave its block, not the
+ * base instance, so `context.fabricator.salt` is the per-test salt and
+ * `.fork()` forks from the test's configuration. The two calls meet through
+ * `scope`: set just before `body()`, read by the provider, restored in a
+ * `finally`. That is safe under `.concurrent` because `@ghostry/harness` runs a
+ * provider synchronously inside its own integration's `around` — no other test
+ * can enter between the write and the read, and the context object already
+ * holds the scope by the body's first `await`. Restoring rather than clearing
+ * keeps a nested `around` from dropping its parent's scope. A provider reached
+ * with no scope is a composer breaking that contract, and raises
+ * `HarnessingProviderError` rather than quietly providing the base instance.
+ *
+ * Nothing here reads `instance.context`. The integration is a pure function of
+ * the `Identity` it is handed and the instance it decorates, and never sets
+ * `clock`. A pinned `Date` (the recommended setup) and the wall-clock default
+ * are already concrete numbers by the time `overlay()` sees them, so they
+ * inherit through every `wrap` unchanged: salt varies per test, "now" does not.
+ * `clock: "derived"` is left alone on purpose — that policy's documented
+ * meaning is that the salt _is_ the reproducibility unit, so per-test clocks
+ * are the request honored, not a bug to override.
+ */
+export declare function integration<$Registry extends PlainObject>(instance: Instance<$Registry>): Integration<FabricatorTestContext<$Registry>>;

package/dist/types/Harnessing/Salt.d.ts

@@ -0,0 +1,31 @@
+import type { Identity } from "./Types";
+/**
+ * The salt `integration` layers onto the instance for one `Identity`.
+ *
+ *     [ <kind>, ...<describe names>, <name>, <row?> ]
+ *
+ * **No file, deliberately.** Every test body runs inside its own
+ * `instance.wrap`, which builds a fresh `RandomSource` with a fresh
+ * construction counter, so constructions are already partitioned per test.
+ * Identity comes from a path, never from an execution counter or a location
+ * that moves when a file does.
+ *
+ * The accepted cost: two tests with the same `kind`, describe path, and name in
+ * _different files_ share a salt and therefore draw the same data. Each is
+ * still deterministic. That is the same trade already made in dropping
+ * duplicate-path detection, and the fix is the ordinary one — give them
+ * distinguishable names.
+ *
+ * `kind` leads. Without it, an empty-named test collides with its enclosing
+ * suite scope: `path` never carries a leaf's own name, only its describes, and
+ * `name` is `""` for both a `"suite"` identity (by design — see `Identity`) and
+ * any test a user happens to name `""`, so at the same `path` the two arrays
+ * would otherwise be identical. `kind` does not disambiguate two suite
+ * identities that share a `path` (a `beforeAll` and an `afterAll` in one
+ * `describe`, say) — that collision is intentional, a suite's setup and
+ * teardown sharing one deterministic scope, and a caller who wants otherwise
+ * already has `instance.wrap(...)` inside the hook body.
+ *
+ * The row is appended only for `.each`.
+ */
+export declare function saltFor(identity: Identity): ReadonlyArray<string>;

package/dist/types/Harnessing/Types.d.ts

@@ -0,0 +1,79 @@
+import type { Instance } from "../Instance/Types";
+import type { PlainObject } from "../Utility/Types";
+/**
+ * What identifies one registered test or suite — the material a salt is derived
+ * from. Named to match how this codebase already talks about the concept:
+ * fabricator's own reproducibility guide reaches for `layer(...)` for "a tenant
+ * id, a test's own name" — this is that identity, structured.
+ *
+ * Declared here rather than imported from `@ghostry/harness`, so neither
+ * package depends on the other — the same arrangement `Adapter`/`walk` already
+ * uses for schema adapters. Satisfied structurally.
+ *
+ * **Carries no file, deliberately.** Nothing here identifies where the test was
+ * registered, which is what lets `@ghostry/harness` skip stack walking entirely
+ * — see `saltFor` (`Harnessing/Salt.ts`) for why the file turned out to be
+ * redundant against per-test `wrap` partitioning. The consequence for the
+ * contract: an integration that genuinely needs the registering file cannot get
+ * it from here, and adding it back means solving the frame-skip problem for
+ * every wrapper between the user's `it(...)` and the integration. Worth
+ * revisiting only against a real requirement, not speculatively.
+ */
+export type Identity = {
+    /**
+     * Disambiguates an empty-named test from its enclosing suite scope — `name`
+     * is `""` for both, and `path` never carries a leaf's own name. Two suite
+     * identities that share a `path` (`beforeAll` and `afterAll` in one
+     * `describe`) are not disambiguated by this: that collision is intentional
+     * (see `saltFor`, `Harnessing/Salt.ts`).
+     */
+    readonly kind: "test" | "suite";
+    /** Enclosing describe names, outer → inner. */
+    readonly path: ReadonlyArray<string>;
+    /** The test name; empty for a suite-scoped callback. */
+    readonly name: string;
+    /** `.each` row index (0-based), `undefined` when the test is not from `.each`. */
+    readonly row: number | undefined;
+};
+/**
+ * One context key's value, as a function of the test's `Identity` rather than a
+ * fixed value.
+ */
+export type Provider<$Value> = (identity: Identity) => $Value;
+/**
+ * The keys an integration contributes, and how each is produced. Homomorphic
+ * over `$Context`, so the context an integration contributes is read back out
+ * of this object's shape with no separate key declaration to keep in sync.
+ */
+export type Provides<$Context extends object> = {
+    readonly [$Key in keyof $Context]: Provider<$Context[$Key]>;
+};
+/**
+ * What `integration(instance)` is, as `@ghostry/harness`'s `initialize` sees
+ * it. The subset of that package's contract this integration actually uses, not
+ * a copy of all of it: `@ghostry/harness` also accepts an optional `setup`,
+ * which fabricator has no teardown to put in, and an object lacking an optional
+ * member still satisfies the contract structurally. `around` is required here,
+ * though optional there, because this integration always declares it.
+ *
+ * `provides` is the _only_ source of context keys; `initialize` rejects a
+ * collision across integrations by reading `Object.keys(provides)`. Each
+ * provider runs inside its integration's `around`. `around` is generic in its
+ * return and must return the body's value unchanged: that is what makes async
+ * work and what lets frames nest.
+ */
+export type Integration<$Context extends object> = {
+    readonly name: string;
+    readonly provides: Provides<$Context>;
+    around<$Return>(identity: Identity, body: () => $Return): $Return;
+};
+/**
+ * The slice of the test context `integration(instance)` contributes — one key,
+ * `fabricator`, holding the per-test scoped `Instance`. The same instance is
+ * also ambient for the body's duration (`instance.wrap`), so a body that
+ * ignores this and uses the caller's own `instance` still sees the per-test
+ * salt.
+ */
+export type FabricatorTestContext<$Registry extends PlainObject = PlainObject> = {
+    readonly fabricator: Instance<$Registry>;
+};

package/dist/types/Instance/Core.d.ts

@@ -11,36 +11,19 @@ export declare const DEFAULT_COMBINATORIAL_LIMIT = 1024;
 /**
  * The single place a `Config` inherits from a base — `initialize` lays its own
  * config over an empty `{}` base (nothing to inherit, so every field falls
- * through to a hardcoded default: an empty seed, wall-clock `clock`, the
- * built-in algorithm, `resolveAttribution(undefined)`'s `"call site"`
- * resolution, the default registry, the default combinatorial limit), and
- * `fork` lays its overlay over the instance it was called on (a full,
+ * through to a hardcoded default: an empty salt, wall-clock `clock`, the
+ * built-in algorithm, the default registry, the default combinatorial limit),
+ * and `fork` lays its overlay over the instance it was called on (a full,
  * already-resolved `Config`, so every field has a real value to fall back to).
  * `base` is typed `Partial<Config<PlainObject>>` rather than `Config`
  * specifically so both calls go through the same function.
  *
- * `seed` composes onto the base rather than replacing it only when tagged with
- * `layer(...)` (`{@link isLayered}`) — a bare `seed` (the ordinary meaning
+ * `salt` composes onto the base rather than replacing it only when tagged with
+ * `layer(...)` (`{@link isLayered}`) — a bare `salt` (the ordinary meaning
  * everywhere else in this library) replaces the base's outright, and an omitted
- * `seed` inherits the base's unchanged (or, at the root, an empty mixer via
- * `normalizeSeed(undefined)`, unless an env var supplies one). Wall-clock
- * `clock` is the default entropy; `seed` is an optional mixer.
- *
- * `attribution` resolves through `resolveAttribution` at most once per call,
- * and only when it's actually needed:
- *
- * - an explicit `over.attribution` always wins (resolved fresh, so `fork({
- *   attribution: { kind: "call site" } })` roots at _that_ call);
- * - otherwise an already-resolved `base.attribution` is reused as-is — never
- *   re-resolved, which keeps a fork from silently re-rooting `"call site"` at
- *   wherever `fork()` itself happens to be called (`resolveCallerFile()` skips
- *   this library's own frames, so calling it from here still lands on the
- *   user's call site either way);
- * - only when neither is available (the root case, `base.attribution` absent)
- *   does this fall back to resolving the `"call site"` default. That also keeps
- *   `initialize({ attribution: { kind: "none" } })` — or any other explicit
- *   override — from paying for a stack walk whose result would be immediately
- *   discarded.
+ * `salt` inherits the base's unchanged (or, at the root, an empty mixer via
+ * `normalizeSalt(undefined)`, unless an env var supplies one). Wall-clock
+ * `clock` is the default entropy; `salt` is an optional mixer.
  *
  * `algorithm`/`types`: wholesale replacement when given, matching how
  * `initialize({ types })` already behaves — no deep merge;
@@ -49,13 +32,13 @@ export declare const DEFAULT_COMBINATORIAL_LIMIT = 1024;
  * inherited, or defaulted), so a bad limit fails at `fork()`/`initialize()`
  * time rather than at first use. `clock` follows the given → inherited →
  * default shape `algorithm` does, but stays _unresolved_ only for the explicit
- * `"seeded"` sentinel: an explicit `Date` and the unconfigured wall-clock
+ * `"derived"` sentinel: an explicit `Date` and the unconfigured wall-clock
  * default are stored as epoch milliseconds (a stated instant, inherited as-is
- * from then on), while `"seeded"` is left as the sentinel rather than collapsed
- * to a number, so `resolveClock` can re-derive it from whichever `seed` is
- * actually in effect at read time. An omitted `clock` on a `fork`/`wrap` whose
- * seed changed therefore keeps the parent's instant unless that parent was
- * itself `"seeded"`.
+ * from then on), while `"derived"` is left as the sentinel rather than
+ * collapsed to a number, so `resolveClock` can re-derive it from whichever
+ * `salt` is actually in effect at read time. An omitted `clock` on a
+ * `fork`/`wrap` whose salt changed therefore keeps the parent's instant unless
+ * that parent was itself `"derived"`.
  */
 export declare function overlay<$Registry extends PlainObject>(base: Partial<Config<PlainObject>>, over: Overlay<$Registry>): Config<$Registry>;
 /**

package/dist/types/Instance/Types.d.ts

@@ -1,56 +1,51 @@
 import type { Enumerable, Limits } from "../Enumeration/Types";
 import type { Constructor } from "../Fabricator/Constructor";
-import type { Algorithm, Attribution, Layered, RandomSource, Seed } from "../Random/Types";
+import type { Algorithm, Layered, RandomSource, Salt } from "../Random/Types";
 import type { PlainObject } from "../Utility/Types";
 /**
  * A fully resolved instance configuration — every field present, nothing left
  * to default. `Overlay` is what `fork` accepts; `overlay()`
  * (`Instance/Core.ts`) is the only thing producing a complete `Config`.
  *
- * Two fields are declared at their caller-facing type but always hold their
- * resolved form once `overlay()` has run: `seed` is `Seed` because that is what
- * a caller may supply, but always holds the normalized array (`Instance.seed`
- * is the authoritative read); `attribution` is `Attribution` for the same
- * reason but always holds a `ResolvedAttribution`, a subtype. `clock` is
- * different from both: unlike `seed`/`attribution`, it holds _either_ a
- * resolved instant (epoch milliseconds) or the unresolved `"seeded"` policy —
- * never collapsed to a number by `overlay()` when `"seeded"`, because that
- * policy must re-derive whenever the seed it composes changes (a `fork({ seed:
- * layer(...) })`). The unconfigured default is a wall- clock number, inherited
- * as-is like an explicit `Date`. `resolveClock` (`Instance/Core.ts`) is the one
- * place that resolves `"seeded"` to a number, called fresh wherever the clock
- * actually matters (`instantiate`, the `context.clock` getter) rather than once
- * here.
+ * `salt` is declared at its caller-facing `Salt` type but always holds the
+ * normalized array once `overlay()` has run (`Instance.salt` is the
+ * authoritative read). `clock` holds _either_ a resolved instant (epoch
+ * milliseconds) or the unresolved `"derived"` policy — never collapsed to a
+ * number by `overlay()` when `"derived"`, because that policy must re-derive
+ * whenever the salt it composes changes (a `fork({ salt: layer(...) })`). The
+ * unconfigured default is a wall- clock number, inherited as-is like an
+ * explicit `Date`. `resolveClock` (`Instance/Core.ts`) is the one place that
+ * resolves `"derived"` to a number, called fresh wherever the clock actually
+ * matters (`instantiate`, the `context.clock` getter) rather than once here.
  */
 export type Config<$Registry extends PlainObject> = {
-    readonly seed: Seed;
+    readonly salt: Salt;
     readonly algorithm: Algorithm;
-    readonly attribution: Attribution;
     readonly types: $Registry;
     readonly limits: Limits;
-    readonly clock: number | "seeded";
+    readonly clock: number | "derived";
 };
 /**
  * What `fork` accepts — a `Config` to lay over a base, every field optional.
- * Identical to `Partial<Config>` but for `seed`, which additionally accepts a
- * {@link Layered}: a bare `Seed` replaces the base's seed outright (what `seed`
- * means everywhere else in this library), `layer(seed)` appends onto it
- * (`[...base.seed, ...seed]`) — the shape a wrapping integration wants, and
+ * Identical to `Partial<Config>` but for `salt`, which additionally accepts a
+ * {@link Layered}: a bare `Salt` replaces the base's salt outright (what `salt`
+ * means everywhere else in this library), `layer(salt)` appends onto it
+ * (`[...base.salt, ...salt]`) — the shape a wrapping integration wants, and
  * what `ConstructorOptions`' layered form is for a single construction.
- * Omitting `seed` inherits the base's unchanged. `clock` similarly accepts the
- * caller-facing `Date | "seeded"` rather than `Config`'s own resolved `number |
- * "seeded"`, so a caller can hand in a literal instant without converting it to
- * epoch milliseconds themselves. `"seeded"` is the explicit opt-in that derives
- * "now" from the instance seed; omitting `clock` at the root captures
+ * Omitting `salt` inherits the base's unchanged. `clock` similarly accepts the
+ * caller-facing `Date | "derived"` rather than `Config`'s own resolved `number
+ * | "derived"`, so a caller can hand in a literal instant without converting it
+ * to epoch milliseconds themselves. `"derived"` is the explicit opt-in that
+ * derives "now" from the instance salt; omitting `clock` at the root captures
  * wall-clock time instead.
  *
- * `initialize`'s own parameter keeps a plain `seed?: Seed`, so passing
+ * `initialize`'s own parameter keeps a plain `salt?: Salt`, so passing
  * `layer(...)` there is a compile error: there is no base to layer onto at the
  * root.
  */
-export type Overlay<$Registry extends PlainObject> = Partial<Omit<Config<$Registry>, "seed" | "clock">> & {
-    readonly seed?: Seed | Layered;
-    readonly clock?: Date | "seeded" | undefined;
+export type Overlay<$Registry extends PlainObject> = Partial<Omit<Config<$Registry>, "salt" | "clock">> & {
+    readonly salt?: Salt | Layered;
+    readonly clock?: Date | "derived" | undefined;
 };
 /**
  * One active `wrap` — its resolved config plus the single `RandomSource` every
@@ -100,24 +95,23 @@ export type Stack = {
  * in effect."
  */
 export type Context = {
-    readonly seed: ReadonlyArray<string>;
+    readonly salt: ReadonlyArray<string>;
     readonly algorithm: Algorithm;
-    readonly attribution: Attribution;
     readonly clock: number;
 };
 /**
  * A single initialized library instance: the registry it was given, and a
- * `construct()` bound to its own isolated randomness — its own seed, builder,
- * and per-file overrides/streams, held internally and never shared with any
+ * `construct()` bound to its own isolated randomness — its own salt, builder,
+ * and construction counter/streams, held internally and never shared with any
  * other `initialize()` call. Independently initialized instances (e.g. parallel
  * tests) can never perturb each other.
  */
-export interface Instance<$Registry extends PlainObject> extends Pick<RandomSource, "seed"> {
+export interface Instance<$Registry extends PlainObject> extends Pick<RandomSource, "salt"> {
     /** The registry of type definers this instance was initialized with. */
     readonly T: $Registry;
     /**
      * Turn a Schema built from `T` into a live Fabricator, deriving fresh
-     * randomness from this instance's own seed for whichever leaves actually need
+     * randomness from this instance's own salt for whichever leaves actually need
      * it.
      */
     Fabricator: Constructor;
@@ -138,8 +132,8 @@ export interface Instance<$Registry extends PlainObject> extends Pick<RandomSour
     coverage: Enumerable;
     /**
      * Derive a new instance laid over this one: anything the overlay names
-     * overrides, anything it omits inherits. A bare `seed` replaces this
-     * instance's seed; `seed: layer(...)` appends onto it. A peer of an
+     * overrides, anything it omits inherits. A bare `salt` replaces this
+     * instance's salt; `salt: layer(...)` appends onto it. A peer of an
      * `initialize()` return value in every respect, including its own `fork`.
      */
     fork<const $ForkRegistry extends PlainObject = $Registry>(overlay?: Overlay<$ForkRegistry>): Instance<$ForkRegistry>;
@@ -154,8 +148,8 @@ export interface Instance<$Registry extends PlainObject> extends Pick<RandomSour
      * configuration again, not the wrap's.
      *
      * A nested `wrap` lays over whichever frame is currently active, not over the
-     * instance it was called on — so `overlay.seed: layer(...)` accumulates with
-     * nesting depth while a bare `seed` still replaces outright, discarding every
+     * instance it was called on — so `overlay.salt: layer(...)` accumulates with
+     * nesting depth while a bare `salt` still replaces outright, discarding every
      * enclosing layer.
      */
     wrap<$Return, const $WrapRegistry extends PlainObject = $Registry>(overlay: Overlay<$WrapRegistry>, block: (scope: Instance<$WrapRegistry>) => $Return): $Return;

package/dist/types/Primitive/opaque/Registry.d.ts

@@ -6,7 +6,7 @@ import { Schema } from "./Schema";
  * `T.opaque((random) => new Map<string, number>())` needs no annotation.
  *
  * `produce` receives this schema's own seeded stream, so an opaque value still
- * replays from a seed; see `Types.ts`'s `Produce`. No bare form and no `.as()`
+ * replays from a salt; see `Types.ts`'s `Produce`. No bare form and no `.as()`
  * — `produce` is the whole schema.
  */
 export default function <$T>(produce: Produce<$T>): Schema<$T>;

package/dist/types/Primitive/recursive/Fabricator.d.ts

@@ -29,13 +29,13 @@ export type Fabricator<$Schema extends {
  * sibling expansions at the same depth (an `array` of three `self` children
  * calls `fabricateAt` three times on one shared element Fabricator; the schema
  * does not tell them apart). Each expansion gets its own _root_: `forkSource`
- * mints an isolated `RandomSource` seeded from this node's draw, and each
- * `fabricateAt` opens a `"counted"` scope on it (`Random/Types.ts`'s `RootKind`
- * — recorded on each expansion's `trace`, not chosen at `ConstructorOptions`).
- * The private source's construction counter orders expansions; nothing to
- * increment here. Isolation also keeps this node's data-dependent draws from
- * perturbing (or being perturbed by) an unrelated Fabricator from the same
- * `initialize()` instance.
+ * mints an isolated `RandomSource` salted from this node's draw, and each
+ * `fabricateAt` resolves an ordinary construction root on it
+ * (`RandomSource.toRoot`), recorded on each expansion's `trace`. The private
+ * source's construction counter orders expansions; nothing to increment here.
+ * Isolation also keeps this node's data-dependent draws from perturbing (or
+ * being perturbed by) an unrelated Fabricator from the same `initialize()`
+ * instance.
  *
  * Each `self` gets its own independently-dispatched expansion — calling
  * `context.self` twice (two array slots) is two `fabricateAt` calls, each with
@@ -43,4 +43,4 @@ export type Fabricator<$Schema extends {
  * shared-element one. Sibling tree branches therefore draw independently, not a
  * correlated shared sequence.
  */
-export declare function Fabricator<$Body>(context: FabricatorContext<Schema<$Body>>, forkSource: (seed: string) => RandomSource, make: (schema: unknown, path: ReadonlyArray<string>, context: ConstructionContext) => NaiveFabricator<unknown>): Fabricator<Schema<$Body>>;
+export declare function Fabricator<$Body>(context: FabricatorContext<Schema<$Body>>, forkSource: (salt: string) => RandomSource, make: (schema: unknown, path: ReadonlyArray<string>, context: ConstructionContext) => NaiveFabricator<unknown>): Fabricator<Schema<$Body>>;