@ghostry/fabricator 0.0.2 → 0.0.3

package/README.md

@@ -1,6 +1,20 @@
-# fabricator
+<div align="center">
 
-Fabricate typed data from composable schemas.
+<img src="https://docs.ghostry.dev/fabricator/logo.png" alt="fabricator" width="96" height="96">
+
+# @ghostry/fabricator
+
+**Fabricate typed data from composable schemas.**
+
+[![npm](https://img.shields.io/badge/npm-ffffff.svg?style=for-the-badge&color=000000&logo=npm&logoColor=CB3837)](https://www.npmjs.com/package/@ghostry/fabricator)
+[![npmx](https://img.shields.io/badge/npmx-ffffff.svg?style=for-the-badge&color=000000&logo=data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KPHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNTMiIGhlaWdodD0iMTUzIiB2ZXJzaW9uPSIxLjEiIHZpZXdCb3g9IjAgMCAxNTMgMTUzIj4KICA8ZyB0cmFuc2Zvcm09InRyYW5zbGF0ZSgxNi43MDQgOS45ODI3KSI+CiAgICA8cGF0aCBkPSJtMC45MzQ3NiA5Ny4yMDVoMjQuMDgxdjIzLjY5M2gtMjQuMDgxeiIgZmlsbD0iI2ZmZiI+PC9wYXRoPgogICAgPHBhdGggZD0ibTEwMy4xMi05LjIzMDctMy42MjExIDEwLjI0Ni00Ni4zMDkgMTMxLTMuNjIxMSAxMC4yNDZoMTUuNTM3bDMuNjIxMS0xMC4yNDYgMTEuNzE3LTMzLjE0OCAzOC4yMTEtMTA4LjF6IiBmaWxsPSIjNTFjOGZjIj48L3BhdGg+CiAgPC9nPgo8L3N2Zz4K&logoColor=51C8FC)](https://npmx.dev/package/@ghostry/fabricator)
+[![jsr](https://img.shields.io/badge/jsr-ffffff?style=for-the-badge&color=000000&logo=jsr&logoColor=F7DF1E)](https://jsr.io/@ghostry/fabricator)
+[![github](https://img.shields.io/badge/github-ffffff?style=for-the-badge&color=000000&logo=github&logoColor=ffffff)](https://github.com/ghostry-dev/fabricator)
+[![typescript](https://img.shields.io/badge/typescript-ffffff?style=for-the-badge&color=000000&logo=typescript&logoColor=3178C6)](#)
+[![bun](https://img.shields.io/badge/bun-ffffff?style=for-the-badge&color=000000&logo=bun&logoColor=FBF0DF)](#)
+[![node](https://img.shields.io/badge/node-ffffff?style=for-the-badge&color=000000&logo=nodedotjs&logoColor=5FA04E)](#)
+
+</div>
 
 ## Install
 
@@ -8,14 +22,12 @@ Fabricate typed data from composable schemas.
 npm install @ghostry/fabricator
 ```
 
-Also available via `bun add @ghostry/fabricator` or `bunx jsr add @ghostry/fabricator`.
-
 ## Example
 
 ```ts
 import { initialize } from "@ghostry/fabricator";
 
-const { T, Fabricator } = initialize({ seed: "1234" });
+const { T, Fabricator } = initialize();
 
 const ProductSchema = T.object({
   name: T.string.whereby({ length: { min: 1, max: 25 } }),
@@ -38,4 +50,4 @@ const item = Product.fabricate();
 const widget = Product.fabricate({ name: "Widget", inStock: true });
 ```
 
-`seed: "1234"` is an optional mixer; `clock` (the wall-clock instant of this call, by default) is the run's entropy. Pass the same seed and clock to replay. See the [docs site](https://docs.ghostry.dev/fabricator/) for the full guide: the mental model behind Schemas and Fabricators, composing and overriding schemas, custom types, distributions, and the [TypeBox adapter](https://www.npmjs.com/package/@ghostry/fabricator-adapter-typebox-v0).
+`initialize()` takes no required configuration. Its `clock` (by default, the wall-clock instant of the call) is the run's entropy, so every run differs, and passing that one number back as `clock` replays the run exactly. See the [docs site](https://docs.ghostry.dev/fabricator/) for the full guide: the mental model behind Schemas and Fabricators, composing and overriding schemas, custom types, distributions, and the [TypeBox adapter](https://www.npmjs.com/package/@ghostry/fabricator-adapter-typebox-v0).

package/dist/esm/Adapter/Core.js

@@ -38,10 +38,10 @@ function Core_layer(key, adaptation, prior) {
             [key]: prior
         }));
 }
-function drive(adapter, schema, context) {
+function walk(adapter, schema, context) {
     var _schema_Adaptation;
     const adaptation = null == (_schema_Adaptation = schema[Adaptation]) ? void 0 : _schema_Adaptation[adapter.key];
     if (adaptation) return adaptation(schema);
-    return adapter.convert(schema, (child, childContext)=>drive(adapter, child, childContext), context);
+    return adapter.convert(schema, (child, childContext)=>walk(adapter, child, childContext), context);
 }
-export { drive, mergeAdaptations, withAdaptations };
+export { mergeAdaptations, walk, withAdaptations };

package/dist/esm/Enumeration/Enumerate.js

@@ -34,19 +34,21 @@ function enumerables(source, limits, stack) {
         };
     }
     function combinatorial(schema) {
-        const combinatorialSeed = [
-            ...effectiveSource().seed,
+        const combinatorialSalt = [
+            ...effectiveSource().salt,
             "combinatorial"
         ];
         const probe = plan(new Fabricator(schema, {
-            seed: combinatorialSeed
+            salt: combinatorialSalt,
+            ordinal: null
         }), {
             strategy: "product"
         });
         if (probe.width > BigInt(limits.combinatorial)) throw new FabricatorError.CombinatorialLimitExceededError(probe.width, limits.combinatorial);
         return iterable(()=>{
             const built = new Fabricator(schema, {
-                seed: combinatorialSeed
+                salt: combinatorialSalt,
+                ordinal: null
             });
             return {
                 built,
@@ -58,24 +60,25 @@ function enumerables(source, limits, stack) {
     }
     function coverage(schema) {
         const base = effectiveSource();
-        const coverageSeed = [
-            ...base.seed,
+        const coverageSalt = [
+            ...base.salt,
             "coverage"
         ];
-        const orderSeed = [
-            ...base.seed,
+        const orderSalt = [
+            ...base.salt,
             "coverage",
             "order"
         ];
         return iterable(()=>{
             const built = new Fabricator(schema, {
-                seed: coverageSeed
+                salt: coverageSalt,
+                ordinal: null
             });
             return {
                 built,
                 axis: plan(built, {
                     strategy: "cycle",
-                    orderer: orderer(base, orderSeed)
+                    orderer: orderer(base, orderSalt)
                 })
             };
         });
@@ -85,9 +88,9 @@ function enumerables(source, limits, stack) {
         coverage
     };
 }
-function orderer(source, seed) {
-    const forked = source.fork(seed);
-    const root = forked.toRoot("unattributed");
+function orderer(source, salt) {
+    const forked = source.fork(salt);
+    const root = forked.toRoot();
     const stream = toStreamFromTrace(forked.algorithm, {
         ...root,
         path: [],

package/dist/esm/Error/index.js

@@ -31,14 +31,6 @@ class Error_FabricatorError extends Error {
         }
     }
     FabricatorError.InvalidCombinatorialLimitError = InvalidCombinatorialLimitError;
-    class InvalidAttributionRootError extends FabricatorError {
-        constructor(root){
-            super(), _define_property(this, "root", void 0), this.root = root;
-            this.name = "InvalidAttributionRootError";
-            this.message = `initialize({ attribution: { kind: "rooted", root } }) requires an absolute path or a "file://" URL; received "${root}".`;
-        }
-    }
-    FabricatorError.InvalidAttributionRootError = InvalidAttributionRootError;
     class DetachedSelfError extends FabricatorError {
         constructor(during){
             super(), _define_property(this, "during", void 0), this.during = during;
@@ -205,5 +197,13 @@ class Error_FabricatorError extends Error {
         }
     }
     FabricatorError.SynchronousStackError = SynchronousStackError;
+    class HarnessingProviderError extends FabricatorError {
+        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.";
+        }
+    }
+    FabricatorError.HarnessingProviderError = HarnessingProviderError;
 })(Error_FabricatorError || (Error_FabricatorError = {}));
 export { Error_FabricatorError as FabricatorError };

package/dist/esm/Fabricator/Constructor.js

@@ -1,6 +1,6 @@
 import { FabricatorError } from "../Error/index.js";
 import { Primitive } from "../Primitive/index.js";
-import { isLayered, normalizeSeed } from "../Random/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";
@@ -305,24 +305,22 @@ function resolveScope(source, options, stack) {
     var _ref;
     const frame = stack.current();
     const base = null != (_ref = null == frame ? void 0 : frame.source) ? _ref : source;
+    const salt = inline(()=>{
+        if (!options.salt) return;
+        if (isLayered(options.salt)) return [
+            ...base.salt,
+            ...normalizeSalt(options.salt[Layer])
+        ];
+        return normalizeSalt(options.salt);
+    });
     const pins = {
+        salt,
         clock: options.clock,
-        root: options.root,
-        file: options.file,
         ordinal: options.ordinal
     };
-    if (!options.seed) return {
-        source: base,
-        root: base.toRoot("attributed", pins)
-    };
-    const seed = isLayered(options.seed) ? [
-        ...base.seed,
-        ...normalizeSeed(options.seed[Layer])
-    ] : options.seed;
-    const forked = base.fork(seed);
     return {
-        source: forked,
-        root: forked.toRoot("unattributed", pins)
+        source: base,
+        root: base.toRoot(pins)
     };
 }
 export { Constructor };

package/dist/esm/Harnessing/Core.js

@@ -0,0 +1,30 @@
+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;
+            }
+        },
+        around (identity, body) {
+            const salt = index_js_layer(saltFor(identity));
+            return instance.wrap({
+                salt
+            }, (entered)=>{
+                const previous = scope;
+                scope = entered;
+                try {
+                    return body();
+                } finally{
+                    scope = previous;
+                }
+            });
+        }
+    };
+}
+export { integration };

package/dist/esm/Harnessing/Salt.js

@@ -0,0 +1,12 @@
+function saltFor(identity) {
+    const salt = [
+        identity.kind,
+        ...identity.path,
+        identity.name
+    ];
+    return "number" == typeof identity.row ? [
+        ...salt,
+        String(identity.row)
+    ] : salt;
+}
+export { saltFor };

package/dist/esm/Harnessing/Types.js

@@ -0,0 +1 @@
+export { };

package/dist/esm/Instance/Core.js

@@ -1,7 +1,7 @@
 import { enumerables } from "../Enumeration/Enumerate.js";
 import { FabricatorError } from "../Error/index.js";
 import { Constructor } from "../Fabricator/Constructor.js";
-import { defaultAlgorithm, deriveClock, isLayered, normalizeSeed, resolveAttribution, toRandomSource } from "../Random/index.js";
+import { defaultAlgorithm, deriveClock, isLayered, normalizeSalt, toRandomSource } from "../Random/index.js";
 import { registry } from "../Schema/Registry.js";
 import { Layer } from "../Types.js";
 import { inline, isThenable, noop } from "../Utility/Core.js";
@@ -12,30 +12,29 @@ function resolveCombinatorialLimit(limit) {
     return limit;
 }
 function resolveClock(config) {
-    return "number" == typeof config.clock ? config.clock : deriveClock(config.algorithm, normalizeSeed(config.seed));
+    return "number" == typeof config.clock ? config.clock : deriveClock(config.algorithm, normalizeSalt(config.salt));
 }
 function overlay(base, over) {
-    var _ref, _over_algorithm, _base_attribution, _ref1, _over_types, _over_limits;
+    var _ref, _over_algorithm, _ref1, _over_types, _over_limits;
     var _this;
-    const seed = inline(()=>{
-        if (void 0 === over.seed) return normalizeSeed(base.seed);
-        if (isLayered(over.seed)) return [
-            ...normalizeSeed(base.seed),
-            ...normalizeSeed(over.seed[Layer])
+    const salt = inline(()=>{
+        if (void 0 === over.salt) return normalizeSalt(base.salt);
+        if (isLayered(over.salt)) return [
+            ...normalizeSalt(base.salt),
+            ...normalizeSalt(over.salt[Layer])
         ];
-        return normalizeSeed(over.seed);
+        return normalizeSalt(over.salt);
     });
     const clock = inline(()=>{
         var _base_clock;
-        if ("seeded" === over.clock) return "seeded";
+        if ("derived" === over.clock) return "derived";
         if (void 0 !== over.clock) return over.clock.valueOf();
         return null != (_base_clock = base.clock) ? _base_clock : Date.now();
     });
     return {
-        seed,
+        salt,
         clock,
         algorithm: null != (_ref = null != (_over_algorithm = over.algorithm) ? _over_algorithm : base.algorithm) ? _ref : defaultAlgorithm,
-        attribution: over.attribution ? resolveAttribution(over.attribution) : null != (_base_attribution = base.attribution) ? _base_attribution : resolveAttribution(void 0),
         types: null != (_ref1 = null != (_over_types = over.types) ? _over_types : base.types) ? _ref1 : registry,
         limits: {
             combinatorial: resolveCombinatorialLimit(null == (_this = null != (_over_limits = over.limits) ? _over_limits : base.limits) ? void 0 : _this.combinatorial)
@@ -44,9 +43,8 @@ function overlay(base, over) {
 }
 function instantiate(config, stack) {
     const source = toRandomSource({
-        seed: config.seed,
+        salt: config.salt,
         algorithm: config.algorithm,
-        attribution: config.attribution,
         clock: resolveClock(config)
     });
     const Fabricator = Constructor(source, stack);
@@ -71,25 +69,20 @@ function instantiate(config, stack) {
         return result;
     }
     const context = {
-        get seed () {
+        get salt () {
             var _ref;
             var _stack_current;
-            return normalizeSeed((null != (_ref = null == (_stack_current = stack.current()) ? void 0 : _stack_current.config) ? _ref : config).seed);
+            return normalizeSalt((null != (_ref = null == (_stack_current = stack.current()) ? void 0 : _stack_current.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;
         },
-        get attribution () {
+        get clock () {
             var _ref2;
             var _stack_current2;
-            return (null != (_ref2 = null == (_stack_current2 = stack.current()) ? void 0 : _stack_current2.config) ? _ref2 : config).attribution;
-        },
-        get clock () {
-            var _ref3;
-            var _stack_current3;
-            return resolveClock(null != (_ref3 = null == (_stack_current3 = stack.current()) ? void 0 : _stack_current3.config) ? _ref3 : config);
+            return resolveClock(null != (_ref2 = null == (_stack_current2 = stack.current()) ? void 0 : _stack_current2.config) ? _ref2 : config);
         }
     };
     const instance = {
@@ -97,7 +90,7 @@ function instantiate(config, stack) {
         Fabricator,
         combinatorial,
         coverage,
-        seed: source.seed,
+        salt: source.salt,
         fork,
         wrap,
         context

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("counted");
+        const construction = privateSource.toRoot();
         const context = {
             toTrace: (path, kind)=>({
                     ...construction,

package/dist/esm/Random/index.js

@@ -1,85 +1,53 @@
-import { FabricatorError } from "../Error/index.js";
 import { Layer, MAX_TIME } from "../Types.js";
-import { inline } from "../Utility/Core.js";
 import { cyrb128 } from "../Utility/Digest.js";
-import { directoryOf, normalizeLocation, relativize, resolveCallerFile } from "./CallSite.js";
 import { sfc32 } from "./Generator/sfc32.js";
 function defaultAlgorithm(seed) {
     return sfc32(...cyrb128(seed));
 }
-function randomSeed() {
+function randomSalt() {
     return (0x100000000 * Math.random() >>> 0).toString(10);
 }
-function deriveClock(algorithm, seed) {
+function deriveClock(algorithm, salt) {
     const stream = toStream(algorithm, JSON.stringify([
-        seed,
+        salt,
         "clock"
     ]));
     return Math.trunc((2 * stream.next() - 1) * MAX_TIME);
 }
-function envSeed() {
-    var _ref, _ref1;
+function envSalt() {
     const env = "object" == typeof process ? process.env : void 0;
-    return null != (_ref = null != (_ref1 = null == env ? void 0 : env["FABRICATOR_SEED"]) ? _ref1 : null == env ? void 0 : env["SEED"]) ? _ref : null == env ? void 0 : env["RANDOM_SEED"];
+    return null == env ? void 0 : env["FABRICATOR_SALT"];
 }
 function encode(trace) {
     return JSON.stringify([
-        trace.seed,
+        trace.salt,
         trace.clock,
-        trace.root,
-        trace.file,
         trace.path,
         trace.kind,
         trace.ordinal
     ]);
 }
-function normalizeSeed(seed) {
-    if (void 0 === seed) {
-        const fromEnv = envSeed();
+function normalizeSalt(salt) {
+    if (void 0 === salt) {
+        const fromEnv = envSalt();
         return void 0 === fromEnv ? [] : [
             fromEnv
         ];
     }
-    return "string" == typeof seed ? [
-        seed
+    return "string" == typeof salt ? [
+        salt
     ] : [
-        ...seed
+        ...salt
     ];
 }
-function Random_layer(seed) {
+function Random_layer(salt) {
     return {
-        [Layer]: seed
+        [Layer]: salt
     };
 }
 function isLayered(value) {
     return "object" == typeof value && null !== value && Layer in value;
 }
-function resolveAttribution(attribution) {
-    const policy = null != attribution ? attribution : {
-        kind: "call site"
-    };
-    switch(policy.kind){
-        case "none":
-            return policy;
-        case "rooted":
-            {
-                const root = normalizeLocation(policy.root);
-                if (!root.startsWith("/")) throw new FabricatorError.InvalidAttributionRootError(policy.root);
-                return toRooted(root);
-            }
-        case "call site":
-            {
-                const root = directoryOf(resolveCallerFile());
-                return toRooted(root);
-            }
-    }
-}
-function toRooted(root) {
-    return {
-        kind: "rooted",
-        root: root.endsWith("/") ? root : `${root}/`
-    };
-}
 function toStream(algorithm, seed) {
     const generator = algorithm(seed);
     let iterations = 0;
@@ -99,53 +67,30 @@ function toStreamFromTrace(algorithm, trace) {
 }
 function toRandomSource(options) {
     var _options_algorithm;
-    let seed = normalizeSeed(options.seed);
+    let salt = normalizeSalt(options.salt);
     let algorithm = null != (_options_algorithm = options.algorithm) ? _options_algorithm : defaultAlgorithm;
-    let attribution = resolveAttribution(options.attribution);
     const clock = options.clock;
-    let constructionOrdinals = new Map();
-    function nextConstructionOrdinal(file) {
-        var _constructionOrdinals_get;
-        const ordinal = null != (_constructionOrdinals_get = constructionOrdinals.get(file)) ? _constructionOrdinals_get : 0;
-        constructionOrdinals.set(file, ordinal + 1);
-        return ordinal;
-    }
-    function toRoot(kind, pins = {}) {
-        var _pins_root, _pins_clock;
-        const replaying = void 0 !== pins.root;
-        const root = null != (_pins_root = pins.root) ? _pins_root : kind;
-        const file = replaying || void 0 !== pins.file ? pins.file : resolveRootFile(kind);
-        const ordinal = inline(()=>{
-            if (replaying || void 0 !== pins.ordinal) return pins.ordinal;
-            if ("unattributed" === root) return;
-            return nextConstructionOrdinal(file);
-        });
+    let constructionOrdinal = 0;
+    function toRoot(pins = {}) {
+        var _pins_salt, _pins_clock;
         return {
-            seed,
+            salt: null != (_pins_salt = pins.salt) ? _pins_salt : salt,
             clock: null != (_pins_clock = pins.clock) ? _pins_clock : clock,
-            root,
-            file,
-            ordinal
+            ordinal: void 0 !== pins.ordinal ? pins.ordinal : constructionOrdinal++
         };
     }
-    function resolveRootFile(kind) {
-        if ("attributed" !== kind) return;
-        if ("none" === attribution.kind) return;
-        return relativize(attribution.root, resolveCallerFile());
-    }
-    function fork(childSeed) {
+    function fork(childSalt) {
         return toRandomSource({
-            seed: childSeed,
+            salt: childSalt,
             algorithm,
-            attribution,
             clock
         });
     }
     return {
         toRoot,
         algorithm,
-        seed,
+        salt,
         fork
     };
 }
-export { Random_layer as layer, defaultAlgorithm, deriveClock, encode, isLayered, normalizeSeed, randomSeed, resolveAttribution, toRandomSource, toStream, toStreamFromTrace };
+export { Random_layer as layer, defaultAlgorithm, deriveClock, encode, isLayered, normalizeSalt, randomSalt, toRandomSource, toStream, toStreamFromTrace };

package/dist/esm/adapting.js

@@ -0,0 +1,2 @@
+export { walk } from "./Adapter/Core.js";
+export { Adaptation } from "./Types.js";

package/dist/esm/harnessing.js

@@ -0,0 +1 @@
+export { integration } from "./Harnessing/Core.js";

package/dist/esm/index.js

@@ -4,10 +4,9 @@ function initialize(config) {
     var _ref;
     return instantiate(overlay({}, null != config ? config : {}), null != (_ref = null == config ? void 0 : config.stack) ? _ref : toStack()).instance;
 }
-export { Adaptation, Omitted } from "./Types.js";
+export { Omitted } from "./Types.js";
 export { layer } from "./Random/index.js";
 export { FabricatorError } from "./Error/index.js";
-export { drive } from "./Adapter/Core.js";
 export { registry } from "./Schema/Registry.js";
 export { effectiveDiscrete, toBound } from "./Bound.js";
 export { initialize };

package/dist/esm/internal.js

@@ -1,6 +1,5 @@
 export { Children, Kind, Meta, Produces } from "./Types.js";
 export { isPlainObject } from "./Utility/Core.js";
 export { plan, resolve } from "./Enumeration/Plan.js";
-export { defaultAlgorithm, encode, randomSeed, toRandomSource, toStream, toStreamFromTrace } from "./Random/index.js";
-export { directoryOf, normalizeLocation, relativize, resolveCallerFile } from "./Random/CallSite.js";
+export { defaultAlgorithm, encode, randomSalt, toRandomSource, toStream, toStreamFromTrace } from "./Random/index.js";
 export { toStack as toSynchronousStack } from "./Instance/Stack/Sync.js";

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

@@ -55,7 +55,7 @@ export declare function mergeAdaptations<$Prior extends Adaptations, const $Adap
  * previous one into the argument. Splitting the two across packages is how they
  * drift.
  */
-export declare function drive<$Context, $Returnable>(adapter: Adapter<string, $Context, $Returnable>, schema: {
+export declare function walk<$Context, $Returnable>(adapter: Adapter<string, $Context, $Returnable>, schema: {
     [Adaptation]?: Adaptations;
 }, context: $Context): $Returnable;
 export {};

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

@@ -70,7 +70,7 @@ export type Patch = {
 };
 /**
  * How an adapter recurses into a nested schema — handed to
- * {@link Adapter.convert} by `Adapter/Core.ts`'s `drive` rather than being the
+ * {@link Adapter.convert} by `Adapter/Core.ts`'s `walk` rather than being the
  * adapter's own private recursion, so every nested node goes back through the
  * adaptation lookup, not only the outermost one.
  *

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

@@ -11,21 +11,23 @@ import type { Enumerable, Limits } from "./Types";
  * is the one precisely-typed layer, mirroring `Constructor.ts`'s `make`/
  * `construct` split.
  *
- * Two derived seeds — one per API — each an independent, deterministic fork off
- * the _effective_ source's seed (`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`). `new Fabricator(schema, { seed })` (see `Constructor.ts`'s
- * `construct()`) forks a fully isolated `RandomSource` and opens an
- * `"unattributed"` scope, so `resolveCallerFile()` is never called — the
- * lazy-generator attribution hazard a plain `function*` would invite simply
- * doesn't arise — the instance's construction counters are never touched, and
- * the same seed reproduces regardless of which file
- * `combinatorial(...)`/`coverage(...)` is called from. Each `fork()` starts
- * from a fresh source, so reusing one seed across many builds (different
- * schemas, or the same schema rebuilt per iteration) never lets one build's
- * draws leak into another's.
+ * 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.
+ *
+ * `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
+ * next ordinal from the effective source's counter — advancing it for every
+ * later construction, and giving each pass over the `Iterable` a different
+ * ordinal. A pinned ordinal is taken verbatim, so the counter is untouched,
+ * 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): {
     combinatorial: Enumerable;