@ghostry/fabricator 0.0.1 → 0.0.2

package/README.md

@@ -38,10 +38,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://ghostry-dev.github.io/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).
-
-## Similar
-
-https://www.npmjs.com/package/@anatine/zod-mock
-
-https://www.npmjs.com/package/@travelperksl/fabricator
+`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).

package/dist/esm/Error/index.js

@@ -197,5 +197,13 @@ class Error_FabricatorError extends Error {
         }
     }
     FabricatorError.TraceKindMismatchError = TraceKindMismatchError;
+    class SynchronousStackError extends FabricatorError {
+        constructor(){
+            super();
+            this.name = "SynchronousStackError";
+            this.message = "`wrap` received an async block, but this instance's ambient stack cannot carry a frame across `await` — a build after the first `await` would silently resolve against the base instance. This runtime has no `node:async_hooks`, so `#stack` resolved to the synchronous carrier; either keep the block synchronous, or pass an async-capable carrier as `initialize({ stack })`.";
+        }
+    }
+    FabricatorError.SynchronousStackError = SynchronousStackError;
 })(Error_FabricatorError || (Error_FabricatorError = {}));
 export { Error_FabricatorError as FabricatorError };

package/dist/esm/Instance/Core.js

@@ -4,7 +4,7 @@ import { Constructor } from "../Fabricator/Constructor.js";
 import { defaultAlgorithm, deriveClock, isLayered, normalizeSeed, resolveAttribution, toRandomSource } from "../Random/index.js";
 import { registry } from "../Schema/Registry.js";
 import { Layer } from "../Types.js";
-import { inline } from "../Utility/Core.js";
+import { inline, isThenable, noop } from "../Utility/Core.js";
 const DEFAULT_COMBINATORIAL_LIMIT = 1024;
 function resolveCombinatorialLimit(limit) {
     if (void 0 === limit) return DEFAULT_COMBINATORIAL_LIMIT;
@@ -42,20 +42,6 @@ function overlay(base, over) {
         }
     };
 }
-function toStack() {
-    const frames = [];
-    return {
-        current: ()=>frames[frames.length - 1],
-        enter: (frame, block)=>{
-            frames.push(frame);
-            try {
-                return block();
-            } finally{
-                frames.pop();
-            }
-        }
-    };
-}
 function instantiate(config, stack) {
     const source = toRandomSource({
         seed: config.seed,
@@ -74,10 +60,15 @@ function instantiate(config, stack) {
         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);
-        return stack.enter({
+        const result = stack.enter({
             config: scopedConfig,
             source: scoped.source
         }, ()=>block(scoped.instance));
+        if (!stack.asynchronous && isThenable(result)) {
+            result.then(noop, noop);
+            throw new FabricatorError.SynchronousStackError();
+        }
+        return result;
     }
     const context = {
         get seed () {
@@ -116,4 +107,4 @@ function instantiate(config, stack) {
         source
     };
 }
-export { DEFAULT_COMBINATORIAL_LIMIT, instantiate, overlay, toStack };
+export { DEFAULT_COMBINATORIAL_LIMIT, instantiate, overlay };

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

@@ -0,0 +1,10 @@
+import { AsyncLocalStorage } from "async_hooks";
+function toStack() {
+    const store = new AsyncLocalStorage();
+    return {
+        asynchronous: true,
+        current: ()=>store.getStore(),
+        enter: (frame, block)=>store.run(frame, block)
+    };
+}
+export { toStack };

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

@@ -0,0 +1,16 @@
+function toStack() {
+    const frames = [];
+    return {
+        asynchronous: false,
+        current: ()=>frames[frames.length - 1],
+        enter: (frame, block)=>{
+            frames.push(frame);
+            try {
+                return block();
+            } finally{
+                frames.pop();
+            }
+        }
+    };
+}
+export { toStack };

package/dist/esm/Primitive/bigint/Registry.js

@@ -1,18 +1,6 @@
 import { assertNonemptyDiscreteBigint, toBound } from "../../Bound.js";
 import { Kind, Meta } from "../../Types.js";
 import { Schema } from "./Schema.js";
-function toWhereby(input) {
-    const max = toBound(input.max);
-    const min = void 0 === input.min ? {
-        value: -max.value,
-        exclusive: false
-    } : toBound(input.min);
-    assertNonemptyDiscreteBigint("T.bigint.whereby", min, max);
-    return {
-        min,
-        max
-    };
-}
 const Registry = {
     [Kind]: "bigint",
     whereby: (whereby)=>Schema({
@@ -28,4 +16,16 @@ const Registry = {
             }
         })
 };
+function toWhereby(input) {
+    const max = toBound(input.max);
+    const min = void 0 === input.min ? {
+        value: -max.value,
+        exclusive: false
+    } : toBound(input.min);
+    assertNonemptyDiscreteBigint("T.bigint.whereby", min, max);
+    return {
+        min,
+        max
+    };
+}
 export default Registry;

package/dist/esm/Primitive/boolean/Registry.js

@@ -1,6 +1,6 @@
 import { Adaptation, Kind, Meta, Produces } from "../../Types.js";
 import { Schema } from "./Schema.js";
-const Registry = {
+const registry = {
     ...Schema({
         [Kind]: "boolean",
         [Meta]: {},
@@ -8,4 +8,5 @@ const Registry = {
         [Adaptation]: void 0
     })
 };
+const Registry = registry;
 export default Registry;

package/dist/esm/Primitive/date/Registry.js

@@ -1,20 +1,7 @@
 import { assertNonemptyDiscrete, epochBound, toBound } from "../../Bound.js";
 import { Adaptation, Kind, Meta, Produces } from "../../Types.js";
 import { Schema } from "./Schema.js";
-function toWhereby(input) {
-    const min = void 0 === input.min ? void 0 : toBound(input.min);
-    const max = void 0 === input.max ? void 0 : toBound(input.max);
-    if (void 0 !== min && void 0 !== max) assertNonemptyDiscrete("T.date.whereby", epochBound(min), epochBound(max));
-    return void 0 === input.distribution ? {
-        min,
-        max
-    } : {
-        min,
-        max,
-        distribution: input.distribution
-    };
-}
-const Registry = {
+const registry = {
     ...Schema({
         [Kind]: "date",
         [Meta]: {},
@@ -58,4 +45,18 @@ const Registry = {
             })
     }
 };
+const Registry = registry;
+function toWhereby(input) {
+    const min = void 0 === input.min ? void 0 : toBound(input.min);
+    const max = void 0 === input.max ? void 0 : toBound(input.max);
+    if (void 0 !== min && void 0 !== max) assertNonemptyDiscrete("T.date.whereby", epochBound(min), epochBound(max));
+    return void 0 === input.distribution ? {
+        min,
+        max
+    } : {
+        min,
+        max,
+        distribution: input.distribution
+    };
+}
 export default Registry;

package/dist/esm/Primitive/null/Registry.js

@@ -1,8 +1,9 @@
 import { Kind, Meta, Produces } from "../../Types.js";
 import { Schema } from "./Schema.js";
-const Registry = Schema({
+const registry = Schema({
     [Kind]: "null",
     [Meta]: {},
     [Produces]: null
 });
+const Registry = registry;
 export default Registry;

package/dist/esm/Primitive/number/Registry.js

@@ -3,23 +3,7 @@ import { Adaptation, Kind, Meta, Produces } from "../../Types.js";
 import bigint from "../bigint/index.js";
 import { unboundedContinuous, unboundedDiscrete } from "./defaults.js";
 import { Schema } from "./Schema.js";
-function toWhereby(input, integer) {
-    const min = void 0 === input.min ? void 0 : toBound(input.min);
-    const max = void 0 === input.max ? void 0 : toBound(input.max);
-    const defaults = integer ? unboundedDiscrete : unboundedContinuous;
-    const label = integer ? "T.number.integer.whereby" : "T.number.whereby";
-    if (integer) assertNonemptyDiscrete(label, null != min ? min : defaults.min, null != max ? max : defaults.max);
-    else assertNonemptyContinuous(label, null != min ? min : defaults.min, null != max ? max : defaults.max);
-    return void 0 === input.distribution ? {
-        min,
-        max
-    } : {
-        min,
-        max,
-        distribution: input.distribution
-    };
-}
-const Registry = {
+const registry = {
     ...Schema({
         [Kind]: "number",
         [Meta]: {},
@@ -56,4 +40,21 @@ const Registry = {
         big: bigint
     }
 };
+const Registry = registry;
+function toWhereby(input, integer) {
+    const min = void 0 === input.min ? void 0 : toBound(input.min);
+    const max = void 0 === input.max ? void 0 : toBound(input.max);
+    const defaults = integer ? unboundedDiscrete : unboundedContinuous;
+    const label = integer ? "T.number.integer.whereby" : "T.number.whereby";
+    if (integer) assertNonemptyDiscrete(label, null != min ? min : defaults.min, null != max ? max : defaults.max);
+    else assertNonemptyContinuous(label, null != min ? min : defaults.min, null != max ? max : defaults.max);
+    return void 0 === input.distribution ? {
+        min,
+        max
+    } : {
+        min,
+        max,
+        distribution: input.distribution
+    };
+}
 export default Registry;

package/dist/esm/Primitive/symbol/Registry.js

@@ -1,6 +1,6 @@
 import { Adaptation, Kind, Meta, Produces } from "../../Types.js";
 import { Schema } from "./Schema.js";
-const Registry = {
+const registry = {
     ...Schema({
         [Kind]: "symbol",
         [Meta]: {},
@@ -14,4 +14,5 @@ const Registry = {
             }
         })
 };
+const Registry = registry;
 export default Registry;

package/dist/esm/Primitive/undefined/Registry.js

@@ -1,8 +1,9 @@
 import { Kind, Meta, Produces } from "../../Types.js";
 import { Schema } from "./Schema.js";
-const Registry = Schema({
+const registry = Schema({
     [Kind]: "undefined",
     [Meta]: {},
     [Produces]: void 0
 });
+const Registry = registry;
 export default Registry;

package/dist/esm/Random/CallSite.js

@@ -35,22 +35,36 @@ function relativize(root, file) {
         ...to.slice(shared)
     ].join("/");
 }
-function isOwnFrame(location) {
-    return location.startsWith(OWN_ROOT);
+function isInternalFrame(location, otherInternals = []) {
+    if (location.startsWith(OWN_ROOT)) return true;
+    return otherInternals.some((skip)=>location.startsWith(skip));
 }
-function firstExternalFrame(stack) {
+function firstExternalFrame(stack, otherInternals = []) {
     var _ref, _locations_find;
     const locations = stack.split("\n").filter((line)=>line.trim().startsWith("at ")).map(extractLocation).map(normalizeLocation);
-    return null != (_ref = null != (_locations_find = locations.find((location)=>!isOwnFrame(location))) ? _locations_find : locations[locations.length - 1]) ? _ref : stack;
-}
-function resolveCallerFile() {
-    var _stack;
-    if ("function" == typeof Error.captureStackTrace) {
-        var _captured_stack;
-        const captured = {};
-        Error.captureStackTrace(captured);
-        return stripPosition(firstExternalFrame(null != (_captured_stack = captured.stack) ? _captured_stack : ""));
+    return null != (_ref = null != (_locations_find = locations.find((location)=>!isInternalFrame(location, otherInternals))) ? _locations_find : locations[locations.length - 1]) ? _ref : stack;
+}
+function resolveCallerFile(options) {
+    var _options_skip;
+    const skip = null == options ? void 0 : null == (_options_skip = options.skip) ? void 0 : _options_skip.map(normalizeLocation);
+    const stack = captureRawStack();
+    const location = stripPosition(stack.walkable ? firstExternalFrame(stack.text, skip) : stack.text);
+    return (null == options ? void 0 : options.root) === void 0 ? location : relativize(normalizeLocation(options.root), location);
+}
+function captureRawStack() {
+    var _captured_stack;
+    if ("function" != typeof Error.captureStackTrace) {
+        var _stack;
+        return {
+            text: null != (_stack = new Error().stack) ? _stack : "",
+            walkable: false
+        };
     }
-    return stripPosition(null != (_stack = new Error().stack) ? _stack : "");
+    const captured = {};
+    Error.captureStackTrace(captured);
+    return {
+        text: null != (_captured_stack = captured.stack) ? _captured_stack : "",
+        walkable: true
+    };
 }
 export { directoryOf, normalizeLocation, relativize, resolveCallerFile };

package/dist/esm/Utility/Core.js

@@ -3,6 +3,11 @@ function inline(fn) {
     return fn();
 }
 function never(_) {}
+function noop() {}
+function isThenable(value) {
+    if ("object" != typeof value || null === value) return false;
+    return "function" == typeof value.then;
+}
 function isArray(candidate) {
     return Array.isArray(candidate);
 }
@@ -33,4 +38,4 @@ function replace(value) {
         [Replace]: true
     };
 }
-export { inline, isArray, isPlainObject, isPollutionKey, mergeableKeys, never, replace };
+export { inline, isArray, isPlainObject, isPollutionKey, isThenable, mergeableKeys, never, noop, replace };

package/dist/esm/index.js

@@ -1,6 +1,8 @@
-import { instantiate, overlay, toStack } from "./Instance/Core.js";
+import { toStack } from "#stack";
+import { instantiate, overlay } from "./Instance/Core.js";
 function initialize(config) {
-    return instantiate(overlay({}, null != config ? config : {}), toStack()).instance;
+    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 { layer } from "./Random/index.js";

package/dist/esm/internal.js

@@ -2,4 +2,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 } from "./Random/CallSite.js";
+export { directoryOf, normalizeLocation, relativize, resolveCallerFile } from "./Random/CallSite.js";
+export { toStack as toSynchronousStack } from "./Instance/Stack/Sync.js";

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

@@ -4,59 +4,56 @@ type OverrideSchemaAdaptation<$Schema extends object, $Map extends Adaptations>
     readonly [Adaptation]?: WithAdaptations<AdaptationsOf<$Schema>, $Map>;
 };
 /**
- * One adapter's entry, keyed by `$Adapter["key"]`. Written as a mapped
- * type rather than built inline: a computed key in an object literal
- * (`{ [adapter.key]: produce }`) widens to a `string` index signature,
- * which no adapter's literal-keyed dispatch matches.
+ * One adapter's entry, keyed by `$Adapter["key"]`. Written as a mapped type
+ * rather than built inline: a computed key in an object literal (`{
+ * [adapter.key]: produce }`) widens to a `string` index signature, which no
+ * adapter's literal-keyed dispatch matches.
  */
 export type AdaptationEntry<$Adapter extends Adapter, $Returnable> = {
     readonly [$K in $Adapter["key"]]: (schema: any) => $Returnable;
 };
 /**
- * A copy of `schema` carrying `produce` as `adapter`'s adaptation:
- * that adapter's prior entry is replaced (via {@link layer}), every
- * other adapter's is carried forward. Every kind's `.adapt(...)` is a
- * call to this, re-typed to that kind's own
- * `Schema<..., WithAdaptations<...>>`.
+ * A copy of `schema` carrying `produce` as `adapter`'s adaptation: that
+ * adapter's prior entry is replaced (via {@link layer}), every other adapter's
+ * is carried forward. Every kind's `.adapt(...)` is a call to this, re-typed to
+ * that kind's own `Schema<..., WithAdaptations<...>>`.
  *
- * Takes the adapter and producer separately rather than a prebuilt map
- * so the key stays a literal, per {@link AdaptationEntry}. The return
- * type mirrors the merge (rather than handing back `$Schema`) so call
- * sites need no cast: `AdaptationsOf<$Schema>` recovers the prior map
- * from whichever kind's `Core` was passed in.
+ * Takes the adapter and producer separately rather than a prebuilt map so the
+ * key stays a literal, per {@link AdaptationEntry}. The return type mirrors the
+ * merge (rather than handing back `$Schema`) so call sites need no cast:
+ * `AdaptationsOf<$Schema>` recovers the prior map from whichever kind's `Core`
+ * was passed in.
  */
 export declare function withAdaptations<const $Schema extends object, const $Adapter extends Adapter, $Returnable>(schema: $Schema, adapter: $Adapter, produce: (adapting: Adapting<any>) => $Returnable): OverrideSchemaAdaptation<$Schema, AdaptationEntry<$Adapter, $Returnable>>;
 /**
  * {@link withAdaptations} at the map level, for a kind that keeps its
  * adaptations beside its schema rather than on it — `object`, whose
  * `extend`/`refine`/`override` each rebuild the schema from scratch, so
- * `Registry.ts`'s `make` has to thread the map through explicitly (see
- * its `adapt`).
+ * `Registry.ts`'s `make` has to thread the map through explicitly (see its
+ * `adapt`).
  *
- * `undefined` rather than an empty map when there is nothing to carry,
- * for the same reason `patched` drops the symbol: an absent map and an
- * empty one mean the same thing, and only one of them should exist at
- * runtime.
+ * `undefined` rather than an empty map when there is nothing to carry, for the
+ * same reason `patched` drops the symbol: an absent map and an empty one mean
+ * the same thing, and only one of them should exist at runtime.
  */
 export declare function mergeAdaptations<$Prior extends Adaptations, const $Adapter extends Adapter, $Returnable>(prior: $Prior | undefined, adapter: $Adapter, produce: (adapting: Adapting<any>) => $Returnable): WithAdaptations<$Prior, AdaptationEntry<$Adapter, $Returnable>> | undefined;
 /**
  * Walk `schema` with `adapter`, resolving each node to its external
  * counterpart. Every adapter's entry point is a call to this.
  *
- * The adaptation lookup lives here, ahead of the adapter's own
- * per-kind dispatch, so an explicit adaptation wins over the kind's
- * mapping — and here rather than in each adapter so it applies at
- * *every* node the walk reaches, not just the one it started from.
- * That is why an adapter recurses through the {@link Recurse} it is
- * handed rather than calling its own `convert` again: a nested
- * `object` field, `array` element, or `choice` option gets the same
+ * The adaptation lookup lives here, ahead of the adapter's own per-kind
+ * dispatch, so an explicit adaptation wins over the kind's mapping — and here
+ * rather than in each adapter so it applies at _every_ node the walk reaches,
+ * not just the one it started from. That is why an adapter recurses through the
+ * {@link Recurse} it is handed rather than calling its own `convert` again: a
+ * nested `object` field, `array` element, or `choice` option gets the same
  * treatment as the root.
  *
- * Paired with {@link layer}: together they make `toTypeBox(schema)`
- * *inside* an adaptation resolve to the layer that adaptation replaced
- * instead of re-entering itself. This reads the entry; `layer` already
- * substituted the previous one into the argument. Splitting the two
- * across packages is how they drift.
+ * Paired with {@link layer}: together they make `toTypeBox(schema)` _inside_ an
+ * adaptation resolve to the layer that adaptation replaced instead of
+ * re-entering itself. This reads the entry; `layer` already substituted the
+ * 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: {
     [Adaptation]?: Adaptations;