@ghostry/fabricator 0.0.3 → 0.0.5

package/dist/esm/Enumeration/Enumerate.js

@@ -1,14 +1,15 @@
 import { shuffle } from "../Distribution/index.js";
 import { FabricatorError } from "../Error/index.js";
 import { Constructor } from "../Fabricator/Constructor.js";
+import { toInnermostFrame } from "../Instance/Stack/Visible.js";
 import { toStreamFromTrace } from "../Random/index.js";
 import { plan, resolve } from "./Plan.js";
-function enumerables(source, limits, stack) {
-    const Fabricator = Constructor(source, stack);
+function enumerables(source, limits, stack, ancestry) {
+    const Fabricator = Constructor(source, stack, ancestry);
     function effectiveSource() {
         var _ref;
-        var _stack_current;
-        return null != (_ref = null == (_stack_current = stack.current()) ? void 0 : _stack_current.source) ? _ref : source;
+        var _toInnermostFrame;
+        return null != (_ref = null == (_toInnermostFrame = toInnermostFrame(stack, ancestry)) ? void 0 : _toInnermostFrame.source) ? _ref : source;
     }
     function iterable(rebuild) {
         return {
@@ -90,9 +91,9 @@ function enumerables(source, limits, stack) {
 }
 function orderer(source, salt) {
     const forked = source.fork(salt);
-    const root = forked.toRoot();
+    const trace = forked.toConstructionTrace();
     const stream = toStreamFromTrace(forked.algorithm, {
-        ...root,
+        ...trace,
         path: [],
         kind: "order"
     });

package/dist/esm/Error/index.js

@@ -201,7 +201,7 @@ class Error_FabricatorError extends Error {
         constructor(){
             super();
             this.name = "HarnessingProviderError";
-            this.message = "The `fabricator` provider was called outside its integration's `around`, so there is no per-test scope to provide. A composer must run each integration's providers inside that integration's `around` frame, as `@ghostry/harness` does.";
+            this.message = "The `fabricator` provider was called outside its integration's frame, so there is no per-test scope to provide. A composer must run each integration's providers inside the frame it opened, passing forward what that frame's wrapper established, as `@ghostry/harness` does.";
         }
     }
     FabricatorError.HarnessingProviderError = HarnessingProviderError;

package/dist/esm/Fabricator/Constructor.js

@@ -1,10 +1,11 @@
 import { FabricatorError } from "../Error/index.js";
+import { toInnermostFrame } from "../Instance/Stack/Visible.js";
 import { Primitive } from "../Primitive/index.js";
 import { isLayered, normalizeSalt } from "../Random/index.js";
 import { toSchema } from "../Schema/Core.js";
 import { Adaptation, Fixed, Kind, Layer, Meta } from "../Types.js";
 import { inline } from "../Utility/Core.js";
-function Constructor(source, stack) {
+function Constructor(source, stack, ancestry) {
     function make(schema, path, context) {
         schema = toSchema(schema);
         const kind = schema[Kind];
@@ -280,7 +281,7 @@ function Constructor(source, stack) {
     function construct(schema, options = {}) {
         var _options_path;
         if ("string" == typeof options.kind && options.kind !== schema[Kind]) throw new FabricatorError.TraceKindMismatchError(schema[Kind], options.kind);
-        const context = toConstructionContext(source, options, stack);
+        const context = toConstructionContext(source, options, stack, ancestry);
         const made = make(schema, null != (_options_path = options.path) ? _options_path : [], context);
         const adaptations = schema[Adaptation];
         return adaptations ? {
@@ -290,21 +291,21 @@ function Constructor(source, stack) {
     }
     return construct;
 }
-function toConstructionContext(source, options, stack) {
-    const { source: rooted, root: construction } = resolveScope(source, options, stack);
+function toConstructionContext(source, options, stack, ancestry) {
+    const { source: resolved, trace } = resolveScope(source, options, stack, ancestry);
     return {
         toTrace: (path, kind)=>({
-                ...construction,
+                ...trace,
                 path,
                 kind
             }),
-        algorithm: rooted.algorithm
+        algorithm: resolved.algorithm
     };
 }
-function resolveScope(source, options, stack) {
+function resolveScope(source, options, stack, ancestry) {
     var _ref;
-    const frame = stack.current();
-    const base = null != (_ref = null == frame ? void 0 : frame.source) ? _ref : source;
+    var _toInnermostFrame;
+    const base = null != (_ref = null == (_toInnermostFrame = toInnermostFrame(stack, ancestry)) ? void 0 : _toInnermostFrame.source) ? _ref : source;
     const salt = inline(()=>{
         if (!options.salt) return;
         if (isLayered(options.salt)) return [
@@ -320,7 +321,7 @@ function resolveScope(source, options, stack) {
     };
     return {
         source: base,
-        root: base.toRoot(pins)
+        trace: base.toConstructionTrace(pins)
     };
 }
 export { Constructor };

package/dist/esm/Harnessing/Core.js

@@ -2,28 +2,19 @@ import { FabricatorError } from "../Error/index.js";
 import { layer as index_js_layer } from "../Random/index.js";
 import { saltFor } from "./Salt.js";
 function integration(instance) {
-    let scope;
     return {
         name: "@ghostry/fabricator",
         provides: {
-            fabricator: ()=>{
-                if (void 0 === scope) throw new FabricatorError.HarnessingProviderError();
-                return scope;
+            fabricator: ({ established })=>{
+                if (void 0 === established) throw new FabricatorError.HarnessingProviderError();
+                return established;
             }
         },
-        around (identity, body) {
+        *frame ({ identity }) {
             const salt = index_js_layer(saltFor(identity));
-            return instance.wrap({
-                salt
-            }, (entered)=>{
-                const previous = scope;
-                scope = entered;
-                try {
-                    return body();
-                } finally{
-                    scope = previous;
-                }
-            });
+            yield (body)=>instance.wrap({
+                    salt
+                }, body);
         }
     };
 }

package/dist/esm/Instance/Core.js

@@ -5,6 +5,7 @@ import { defaultAlgorithm, deriveClock, isLayered, normalizeSalt, toRandomSource
 import { registry } from "../Schema/Registry.js";
 import { Layer } from "../Types.js";
 import { inline, isThenable, noop } from "../Utility/Core.js";
+import { toInnermostFrame } from "./Stack/Visible.js";
 const DEFAULT_COMBINATORIAL_LIMIT = 1024;
 function resolveCombinatorialLimit(limit) {
     if (void 0 === limit) return DEFAULT_COMBINATORIAL_LIMIT;
@@ -14,6 +15,9 @@ function resolveCombinatorialLimit(limit) {
 function resolveClock(config) {
     return "number" == typeof config.clock ? config.clock : deriveClock(config.algorithm, normalizeSalt(config.salt));
 }
+function mint() {
+    return Symbol("fabricator.instance");
+}
 function overlay(base, over) {
     var _ref, _over_algorithm, _ref1, _over_types, _over_limits;
     var _this;
@@ -41,26 +45,40 @@ function overlay(base, over) {
         }
     };
 }
-function instantiate(config, stack) {
+function instantiate(config, stack, parent) {
+    const ancestry = void 0 === parent ? [
+        mint()
+    ] : [
+        ...parent.ancestry,
+        mint()
+    ];
     const source = toRandomSource({
         salt: config.salt,
         algorithm: config.algorithm,
         clock: resolveClock(config)
     });
-    const Fabricator = Constructor(source, stack);
-    const { combinatorial, coverage } = enumerables(source, config.limits, stack);
+    const Fabricator = Constructor(source, stack, ancestry);
+    const { combinatorial, coverage } = enumerables(source, config.limits, stack, ancestry);
+    function derive(over) {
+        const derived = overlay(config, over);
+        return {
+            ...instantiate(derived, stack, {
+                ancestry,
+                root: instance.root
+            }),
+            config: derived
+        };
+    }
     function fork(forkOverlay = {}) {
-        return instantiate(overlay(config, forkOverlay), stack).instance;
+        return derive(forkOverlay).instance;
     }
     function wrap(wrapOverlay, block) {
-        var _ref;
-        var _stack_current;
-        const base = null != (_ref = null == (_stack_current = stack.current()) ? void 0 : _stack_current.config) ? _ref : config;
-        const scopedConfig = overlay(base, wrapOverlay);
-        const scoped = instantiate(scopedConfig, stack);
+        const scoped = derive(wrapOverlay);
         const result = stack.enter({
-            config: scopedConfig,
-            source: scoped.source
+            config: scoped.config,
+            source: scoped.source,
+            instance: scoped.instance,
+            ancestry
         }, ()=>block(scoped.instance));
         if (!stack.asynchronous && isThenable(result)) {
             result.then(noop, noop);
@@ -68,25 +86,41 @@ function instantiate(config, stack) {
         }
         return result;
     }
+    function visibleFrame() {
+        return toInnermostFrame(stack, ancestry);
+    }
     const context = {
         get salt () {
             var _ref;
-            var _stack_current;
-            return normalizeSalt((null != (_ref = null == (_stack_current = stack.current()) ? void 0 : _stack_current.config) ? _ref : config).salt);
+            var _visibleFrame;
+            return normalizeSalt((null != (_ref = null == (_visibleFrame = visibleFrame()) ? void 0 : _visibleFrame.config) ? _ref : config).salt);
         },
         get algorithm () {
             var _ref1;
-            var _stack_current1;
-            return (null != (_ref1 = null == (_stack_current1 = stack.current()) ? void 0 : _stack_current1.config) ? _ref1 : config).algorithm;
+            var _visibleFrame1;
+            return (null != (_ref1 = null == (_visibleFrame1 = visibleFrame()) ? void 0 : _visibleFrame1.config) ? _ref1 : config).algorithm;
         },
         get clock () {
             var _ref2;
-            var _stack_current2;
-            return resolveClock(null != (_ref2 = null == (_stack_current2 = stack.current()) ? void 0 : _stack_current2.config) ? _ref2 : config);
+            var _visibleFrame2;
+            return resolveClock(null != (_ref2 = null == (_visibleFrame2 = visibleFrame()) ? void 0 : _visibleFrame2.config) ? _ref2 : config);
+        },
+        scope: ()=>{
+            var _ref;
+            var _visibleFrame;
+            return null != (_ref = null == (_visibleFrame = visibleFrame()) ? void 0 : _visibleFrame.instance) ? _ref : instance;
+        },
+        get depth () {
+            return stack.visible(ancestry).length;
         }
     };
     const instance = {
         T: config.types,
+        ancestry,
+        get root () {
+            var _ref3;
+            return null != (_ref3 = null == parent ? void 0 : parent.root) ? _ref3 : instance;
+        },
         Fabricator,
         combinatorial,
         coverage,

package/dist/esm/Instance/Stack/Async.js

@@ -1,10 +1,18 @@
 import { AsyncLocalStorage } from "async_hooks";
+import { toVisible } from "./Visible.js";
 function toStack() {
     const store = new AsyncLocalStorage();
+    const getFrames = ()=>{
+        var _store_getStore;
+        return null != (_store_getStore = store.getStore()) ? _store_getStore : [];
+    };
     return {
         asynchronous: true,
-        current: ()=>store.getStore(),
-        enter: (frame, block)=>store.run(frame, block)
+        visible: (ancestry)=>toVisible(getFrames(), ancestry),
+        enter: (frame, block)=>store.run([
+                ...getFrames(),
+                frame
+            ], block)
     };
 }
 export { toStack };

package/dist/esm/Instance/Stack/Sync.js

@@ -1,8 +1,9 @@
+import { toVisible } from "./Visible.js";
 function toStack() {
     const frames = [];
     return {
         asynchronous: false,
-        current: ()=>frames[frames.length - 1],
+        visible: (ancestry)=>toVisible(frames, ancestry),
         enter: (frame, block)=>{
             frames.push(frame);
             try {

package/dist/esm/Instance/Stack/Visible.js

@@ -0,0 +1,13 @@
+function onDirectLine(a, b) {
+    const shared = Math.min(a.length, b.length);
+    for(let index = 0; index < shared; index++)if (a[index] !== b[index]) return false;
+    return true;
+}
+function toVisible(frames, ancestry) {
+    return frames.filter((frame)=>onDirectLine(frame.ancestry, ancestry));
+}
+function toInnermostFrame(stack, ancestry) {
+    const frames = stack.visible(ancestry);
+    return frames[frames.length - 1];
+}
+export { toInnermostFrame, toVisible };

package/dist/esm/Primitive/recursive/Fabricator.js

@@ -10,7 +10,7 @@ function Fabricator(context, forkSource, make) {
     function fabricateAt(depth) {
         const atMax = depth >= meta.depth.max;
         const target = atMax ? meta.terminal : meta.body;
-        const construction = privateSource.toRoot();
+        const construction = privateSource.toConstructionTrace();
         const context = {
             toTrace: (path, kind)=>({
                     ...construction,

package/dist/esm/Random/index.js

@@ -71,7 +71,7 @@ function toRandomSource(options) {
     let algorithm = null != (_options_algorithm = options.algorithm) ? _options_algorithm : defaultAlgorithm;
     const clock = options.clock;
     let constructionOrdinal = 0;
-    function toRoot(pins = {}) {
+    function toConstructionTrace(pins = {}) {
         var _pins_salt, _pins_clock;
         return {
             salt: null != (_pins_salt = pins.salt) ? _pins_salt : salt,
@@ -87,7 +87,7 @@ function toRandomSource(options) {
         });
     }
     return {
-        toRoot,
+        toConstructionTrace,
         algorithm,
         salt,
         fork

package/dist/types/Enumeration/Enumerate.d.ts

@@ -1,25 +1,25 @@
-import type { Stack } from "../Instance/Types";
+import type { Ancestry, Stack } from "../Instance/Types";
 import type { RandomSource } from "../Random/Types";
 import type { Enumerable, Limits } from "./Types";
 /**
  * Typed `combinatorial`/`coverage` boundary, closing over one instance's
  * `source` and its already-validated `limits` — same shape as
- * `Constructor(source, stack)`. No separate `clock`: `source` already carries
+ * `Constructor(source, stack, ancestry)`. No separate `clock`: `source` carries
  * its resolved clock (`Random/Types.ts`'s `Options.clock`), so `Constructor`'s
- * `toConstructionContext` reads it off whichever root a construction resolves
- * against. `plan`/ `resolve` (`./Plan.ts`) do the untyped recursive work; this
- * is the one precisely-typed layer, mirroring `Constructor.ts`'s `make`/
- * `construct` split.
+ * `toConstructionContext` reads it off the resolved `ConstructionTrace`.
+ * `plan`/ `resolve` (`./Plan.ts`) do the untyped recursive work; this is the
+ * one precisely-typed layer, mirroring `Constructor.ts`'s `make`/`construct`
+ * split.
  *
  * Two derived salts — one per API — each composed from the _effective_ source's
- * salt (`effectiveSource()` below — the active `wrap` frame's, or this
- * instance's `source`; read fresh on every `combinatorial(...)`/`coverage(...)`
- * call, not once when `enumerables()` was built, so the same `combinatorial`
- * reference behaves differently inside an active `wrap`). Each build pins that
- * salt via `new Fabricator(schema, { salt })` (see `Constructor.ts`'s
- * `construct()`) — a pin, not a fork — so every rebuild of one schema draws
- * from the same universe, distinct from anything built under the instance's own
- * salt.
+ * salt (`effectiveSource()` below — the innermost visible `wrap` frame's, or
+ * this instance's `source`; read fresh on every
+ * `combinatorial(...)`/`coverage(...)` call, not once when `enumerables()` was
+ * built, so the same `combinatorial` reference behaves differently inside a
+ * `wrap` this instance can see). Each build pins that salt via `new
+ * Fabricator(schema, { salt })` (see `Constructor.ts`'s `construct()`) — a pin,
+ * not a fork — so every rebuild of one schema draws from the same universe,
+ * distinct from anything built under the instance's own salt.
  *
  * `ordinal: null` is pinned alongside it, and is not incidental: a salt says
  * nothing about ordering, so without this pin each lazy rebuild would take the
@@ -29,7 +29,7 @@ import type { Enumerable, Limits } from "./Types";
  * every iteration rebuilds from the same explicit identity, and the `null` can
  * never coincide with a counted construction.
  */
-export declare function enumerables(source: RandomSource, limits: Limits, stack: Stack): {
+export declare function enumerables(source: RandomSource, limits: Limits, stack: Stack, ancestry: Ancestry): {
     combinatorial: Enumerable;
     coverage: Enumerable;
 };

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

@@ -7,7 +7,7 @@ import type { PlainObject } from "../Utility/Types";
  * is the cartesian product — width is the product of every child's width;
  * `at(index)` mixed-radix decodes to a full combination (`combinatorial`).
  * `"cycle"` (`coverage`) takes the widest child as the composite's width,
- * cycling narrower children to fill it — see CLAUDE.md's "sum vs product" note
+ * cycling narrower children to fill it — see AGENTS.md's "sum vs product" note
  * for why cycling only ever applies to `object`/`tuple` and never to a sum node
  * (`choice`, the presence wrappers), which always total their children's widths
  * regardless of strategy.
@@ -17,7 +17,7 @@ export type Strategy = "product" | "cycle";
  * A fresh, reproducible permutation of `0..width-1` each call — one per
  * width-`>1` node `plan()` visits, in walk order, so two nodes of the same
  * width never receive the same permutation (which would otherwise iterate them
- * in lockstep — see CLAUDE.md's note on why a constant phase offset isn't
+ * in lockstep — see AGENTS.md's note on why a constant phase offset isn't
  * enough). Only consulted under `"cycle"`; `"product"`'s mixed-radix decode
  * already visits every combination, so permuting there would only reorder
  * identical output. Built in `Enumerate.ts` (which can reach `Random/`), then

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

@@ -540,14 +540,15 @@ export declare namespace FabricatorError {
     /**
      * The `fabricator` provider of `integration(instance)`
      * (`@ghostry/fabricator/harnessing`) was called outside that integration's
-     * own `around`.
+     * own frame.
      *
-     * 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.
+     * The provider hands back the per-test scope the frame's wrapper established,
+     * which reaches it as the provider's second argument, so there is no scope
+     * for it to return anywhere else. `@ghostry/harness` never does this — it
+     * runs each provider inside the frame it opened and passes that scope forward
+     * — 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

@@ -1,4 +1,4 @@
-import type { Stack } from "../Instance/Types";
+import type { Ancestry, Stack } from "../Instance/Types";
 import type { ConstructorOptions, RandomSource } from "../Random/Types";
 import { type Buildable } from "../Types";
 import { type AsFabricator } from "./Types";
@@ -25,17 +25,20 @@ export type Constructor = {
  * fabricator this `construct()` produces draws from that instance's own
  * 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
+ * `stack` is the ambient carrier and `ancestry` is this instance's position in
+ * its lineage (`Instance/Core.ts`) — both passed straight through to
  * `resolveScope` on every `construct()` call, never read here directly, so a
- * build reached inside an active `wrap` resolves against that frame
- * automatically, with nothing threaded through by the caller.
+ * build reached inside a `wrap` this instance can see resolves against that
+ * frame automatically, with nothing threaded through by the caller. `ancestry`
+ * is what decides "can see": a frame entered on a sibling instance is not one
+ * this `construct()` will ever resolve against.
  *
  * No separate `clock` parameter: `source` already carries its own resolved
  * clock intrinsically (`Random/Types.ts`'s `Options.clock`, baked in when the
  * source was built), and `resolveScope`'s chosen source — the active `wrap`
  * frame's, or this one — is exactly the source whose clock a construction
  * should resolve "now" against. `toConstructionContext` reads it straight off
- * the resolved root rather than threading a second value alongside `source`.
+ * the resolved construction trace rather than threading a second value
+ * alongside `source`.
  */
-export declare function Constructor(source: RandomSource, stack: Stack): Constructor;
+export declare function Constructor(source: RandomSource, stack: Stack, ancestry: Ancestry): Constructor;

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

@@ -14,19 +14,20 @@ import type { PlainObject } from "../Utility/Types";
  * `toTrace` records this node's {@link Trace} — a plain object literal, no
  * hashing. Hashing is paid only where a kind actually calls
  * `toStreamFromTrace(algorithm, trace)`. Bound once in `construct()` to this
- * one construction's already-resolved `RandomSource`/ `ConstructionTrace` pair
+ * one construction's already-resolved `RandomSource`/`ConstructionTrace` pair
  * (see `Constructor.ts`'s `resolveScope`) — every leaf calls `toTrace` with
  * only its own structural `path` and kind, never re-resolving the
- * construction's root itself. `T.recursive` is the one kind that rebinds
- * `toTrace`: each lazy expansion opens its own scope on the node's own private
- * forked `RandomSource` (see `recursive/Fabricator.ts`), so a data-dependent
- * expansion count can never perturb, or be perturbed by, anything else built
- * from the same `initialize()` instance — `RandomSource.fork`
- * (`Random/Types.ts`) is the isolation primitive.
+ * construction-owned slots itself. `T.recursive` is the one kind that rebinds
+ * `toTrace`: each lazy expansion resolves its construction trace on the node's
+ * own private forked `RandomSource` (see `recursive/Fabricator.ts`), so a
+ * data-dependent expansion count can never perturb, or be perturbed by,
+ * anything else built from the same `initialize()` instance —
+ * `RandomSource.fork` (`Random/Types.ts`) is the isolation primitive.
  *
  * `algorithm` rather than the `RandomSource` itself: stream derivation depends
- * on no per-source state, and a leaf has no business with `toRoot`/`fork`.
- * `clock` is not a field of its own — it is always `trace.clock`.
+ * on no per-source state, and a leaf has no business with
+ * `toConstructionTrace`/`fork`. `clock` is not a field of its own — it is
+ * always `trace.clock`.
  *
  * `self` is what makes `case "recursive.self"` resolve to "recurse one level
  * deeper, right now" — absent outside any active recursion, which is how `case
@@ -47,11 +48,11 @@ export type ConstructionContext = {
  * `toStreamFromTrace(algorithm, trace)`. The guard is the call site's own `if
  * (meta.produce)` branch (or the equivalent drawing path), not an unevaluated
  * closure. `algorithm` rather than the `RandomSource`: derivation depends on no
- * per-source state, and a leaf has no business with `toRoot`/`fork`. No
- * `clock`: it is `trace.clock`, always. A kind-specific extra — an array's
- * `element`, an object's `fields`, a choice's `weightings` — still follows as
- * its own trailing parameter: those vary per kind and were never part of the
- * shared prefix this replaces.
+ * per-source state, and a leaf has no business with
+ * `toConstructionTrace`/`fork`. No `clock`: it is `trace.clock`, always. A
+ * kind-specific extra — an array's `element`, an object's `fields`, a choice's
+ * `weightings` — still follows as its own trailing parameter: those vary per
+ * kind and were never part of the shared prefix this replaces.
  */
 export type FabricatorContext<$Schema> = {
     schema: $Schema;

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

@@ -2,33 +2,33 @@ 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`
+ * Decorate an existing `Instance` as a `@ghostry/harness` integration. The
+ * whole of it 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.
+ * `frame` is a generator so that `yield` can be both where the body runs and
+ * where this hook waits. There is nothing after the `yield` here: fabricator
+ * has no teardown, and the `AsyncLocalStorage` carrier keeps the ambient frame
+ * alive across the body's `await`s on its own. What the `yield` carries is the
+ * wrapper, because the ambient frame has to _enclose_ the body rather than
+ * merely precede it. On the synchronous carrier an async body still raises
+ * `SynchronousStackError` from `wrap`.
  *
- * `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
+ * `instance.wrap` is handed to the wrapper directly rather than called inside a
+ * closure. `wrap(overlay, block)` already takes `(scope) => $Return`, which is
+ * exactly the wrapper's own `(established) => $Return`, so the scope `wrap`
+ * opens _is_ the established value with nothing in between to adapt it.
+ *
+ * `provides.fabricator` is then that scope — the instance `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. Nothing mediates
+ * between the two: the wrapper hands the scope forward and the provider
+ * receives it. A provider reached with no established scope is a composer
+ * running providers outside the frame it opened, and raises
  * `HarnessingProviderError` rather than quietly providing the base instance.
  *
  * Nothing here reads `instance.context`. The integration is a pure function of
@@ -40,4 +40,4 @@ import type { FabricatorTestContext, Integration } from "./Types";
  * 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>>;
+export declare function integration<$Registry extends PlainObject>(instance: Instance<$Registry>): Integration<FabricatorTestContext<$Registry>, Instance<$Registry>>;