@ghostry/fabricator 0.0.8 → 0.0.9

package/dist/esm/Bound.js

@@ -76,6 +76,11 @@ function toLengthRange(length, label) {
         max: toBound(length.max)
     };
     assertNonemptyDiscrete(label, range.min, range.max);
-    return range;
+    if ("number" == typeof length || void 0 === length.distribution) return range;
+    return {
+        min: range.min,
+        max: range.max,
+        distribution: length.distribution
+    };
 }
 export { assertNonemptyContinuous, assertNonemptyDiscrete, assertNonemptyDiscreteBigint, constrainContinuous, effectiveDiscrete, effectiveDiscreteBigint, epochBound, toBound, toLengthRange, towardInterior };

package/dist/esm/Distribution/index.js

@@ -42,6 +42,14 @@ function unitPosition(x, min, max) {
     if (!Number.isFinite(ratio)) return 0;
     return 1 / (1 + ratio);
 }
+function discreteSampler(distribution, range, stream) {
+    const { min, max } = range;
+    const draw = sampler(null != distribution ? distribution : Distribution_Distribution.uniform(), {
+        min,
+        max: max + 1
+    }, stream);
+    return ()=>Math.min(max, Math.floor(draw()));
+}
 function sampler(distribution, range, stream) {
     const { min, max } = range;
     const span = max - min;
@@ -198,4 +206,4 @@ function weighted(weights, stream, label) {
     };
 }
 var Distribution_Distribution;
-export { Distribution_Distribution as Distribution, assertDrawableKeyedWeights, assertDrawableWeights, drawableOutcomes, isDrawable, isValidWeight, sample, sampler, shuffle, weighted };
+export { Distribution_Distribution as Distribution, assertDrawableKeyedWeights, assertDrawableWeights, discreteSampler, drawableOutcomes, isDrawable, isValidWeight, sample, sampler, shuffle, weighted };

package/dist/esm/Instance/Core.js

@@ -96,14 +96,14 @@ function instantiate(config, stack, parent) {
             return normalizeSalt((null != (_ref = null == (_visibleFrame = visibleFrame()) ? void 0 : _visibleFrame.config) ? _ref : config).salt);
         },
         get algorithm () {
-            var _ref1;
-            var _visibleFrame1;
-            return (null != (_ref1 = null == (_visibleFrame1 = visibleFrame()) ? void 0 : _visibleFrame1.config) ? _ref1 : config).algorithm;
+            var _ref;
+            var _visibleFrame;
+            return (null != (_ref = null == (_visibleFrame = visibleFrame()) ? void 0 : _visibleFrame.config) ? _ref : config).algorithm;
         },
         get clock () {
-            var _ref2;
-            var _visibleFrame2;
-            return resolveClock(null != (_ref2 = null == (_visibleFrame2 = visibleFrame()) ? void 0 : _visibleFrame2.config) ? _ref2 : config);
+            var _ref;
+            var _visibleFrame;
+            return resolveClock(null != (_ref = null == (_visibleFrame = visibleFrame()) ? void 0 : _visibleFrame.config) ? _ref : config);
         },
         scope: ()=>{
             var _ref;
@@ -118,8 +118,8 @@ function instantiate(config, stack, parent) {
         T: config.types,
         ancestry,
         get root () {
-            var _ref3;
-            return null != (_ref3 = null == parent ? void 0 : parent.root) ? _ref3 : instance;
+            var _ref;
+            return null != (_ref = null == parent ? void 0 : parent.root) ? _ref : instance;
         },
         Fabricator,
         combinatorial,

package/dist/esm/Primitive/always/Schema.js

@@ -1,9 +1,11 @@
 import { withAdaptations } from "../../Adapter/Core.js";
+import { schemaSatisfies } from "../../Schema/Satisfies.js";
 import { Kind } from "../../Types.js";
 function Schema(schema) {
     return {
         ...schema,
         [Kind]: "always",
+        satisfies: schemaSatisfies,
         adapt: (adapter, produce)=>Schema(withAdaptations(schema, adapter, produce))
     };
 }

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

@@ -1,7 +1,7 @@
 import { effectiveDiscrete } from "../../Bound.js";
+import { discreteSampler } from "../../Distribution/index.js";
 import { toStreamFromTrace } from "../../Random/index.js";
 import { Children, Kind, Meta } from "../../Types.js";
-import { inline } from "../../Utility/Core.js";
 import { Schema } from "./Schema.js";
 function Fabricator(context, element) {
     const { schema, algorithm, trace } = context;
@@ -24,15 +24,10 @@ function Fabricator(context, element) {
     }
     const stream = toStreamFromTrace(algorithm, trace);
     const whereby = meta.whereby;
-    const fabricate = ()=>{
-        const length = inline(()=>{
-            const { min, max } = effectiveDiscrete(whereby.length.min, whereby.length.max);
-            return min + Math.floor(stream.next() * (max - min + 1));
-        });
-        return Array.from({
-            length
+    const drawLength = discreteSampler(whereby.length.distribution, effectiveDiscrete(whereby.length.min, whereby.length.max), stream);
+    const fabricate = ()=>Array.from({
+            length: drawLength()
         }, ()=>element.fabricate());
-    };
     return {
         [Kind]: "array",
         [Meta]: meta,

package/dist/esm/Primitive/array/Schema.js

@@ -1,4 +1,5 @@
 import { withAdaptations } from "../../Adapter/Core.js";
+import { schemaSatisfies } from "../../Schema/Satisfies.js";
 import { Kind, Meta } from "../../Types.js";
 function Schema(schema) {
     return {
@@ -11,6 +12,7 @@ function Schema(schema) {
                     produce
                 }
             }),
+        satisfies: schemaSatisfies,
         adapt: (adapter, produce)=>Schema(withAdaptations(schema, adapter, produce))
     };
 }

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

@@ -1,4 +1,5 @@
 import { withAdaptations } from "../../Adapter/Core.js";
+import { schemaSatisfies } from "../../Schema/Satisfies.js";
 import { Kind, Meta } from "../../Types.js";
 function Schema(schema) {
     return {
@@ -11,6 +12,7 @@ function Schema(schema) {
                     produce
                 }
             }),
+        satisfies: schemaSatisfies,
         adapt: (adapter, produce)=>Schema(withAdaptations(schema, adapter, produce))
     };
 }

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

@@ -1,5 +1,6 @@
 import { withAdaptations } from "../../Adapter/Core.js";
 import { assertDrawableKeyedWeights } from "../../Distribution/index.js";
+import { schemaSatisfies } from "../../Schema/Satisfies.js";
 import { Kind, Meta } from "../../Types.js";
 import { outcomes } from "./Outcomes.js";
 function Schema(schema) {
@@ -13,6 +14,7 @@ function Schema(schema) {
                     produce
                 }
             }),
+        satisfies: schemaSatisfies,
         weighted: (weights)=>{
             const merged = {
                 ...schema[Meta].weights,

package/dist/esm/Primitive/choice/Schema.js

@@ -1,4 +1,5 @@
 import { withAdaptations } from "../../Adapter/Core.js";
+import { schemaSatisfies } from "../../Schema/Satisfies.js";
 import { Kind, Meta } from "../../Types.js";
 function Schema(schema) {
     return {
@@ -11,6 +12,7 @@ function Schema(schema) {
                     produce
                 }
             }),
+        satisfies: schemaSatisfies,
         adapt: (adapter, produce)=>Schema(withAdaptations(schema, adapter, produce))
     };
 }

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

@@ -1,4 +1,5 @@
 import { withAdaptations } from "../../Adapter/Core.js";
+import { schemaSatisfies } from "../../Schema/Satisfies.js";
 import { Kind, Meta } from "../../Types.js";
 function Schema(schema) {
     return {
@@ -11,6 +12,7 @@ function Schema(schema) {
                     produce
                 }
             }),
+        satisfies: schemaSatisfies,
         adapt: (adapter, produce)=>Schema(withAdaptations(schema, adapter, produce))
     };
 }

package/dist/esm/Primitive/derive/Schema.js

@@ -1,9 +1,11 @@
 import { withAdaptations } from "../../Adapter/Core.js";
+import { schemaSatisfies } from "../../Schema/Satisfies.js";
 import { Kind } from "../../Types.js";
 function Schema(schema) {
     return {
         ...schema,
         [Kind]: "derive",
+        satisfies: schemaSatisfies,
         adapt: (adapter, produce)=>Schema(withAdaptations(schema, adapter, produce))
     };
 }

package/dist/esm/Primitive/enum/Schema.js

@@ -1,4 +1,5 @@
 import { withAdaptations } from "../../Adapter/Core.js";
+import { schemaSatisfies } from "../../Schema/Satisfies.js";
 import { Kind, Meta } from "../../Types.js";
 function Schema(schema) {
     return {
@@ -11,6 +12,7 @@ function Schema(schema) {
                     produce
                 }
             }),
+        satisfies: schemaSatisfies,
         adapt: (adapter, produce)=>Schema(withAdaptations(schema, adapter, produce))
     };
 }

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

@@ -1,9 +1,11 @@
 import { withAdaptations } from "../../Adapter/Core.js";
+import { schemaSatisfies } from "../../Schema/Satisfies.js";
 import { Kind } from "../../Types.js";
 function Schema(schema) {
     return {
         ...schema,
         [Kind]: "null",
+        satisfies: schemaSatisfies,
         adapt: (adapter, produce)=>Schema(withAdaptations(schema, adapter, produce))
     };
 }

package/dist/esm/Primitive/nullable/Schema.js

@@ -1,5 +1,6 @@
 import { withAdaptations } from "../../Adapter/Core.js";
 import { assertDrawableKeyedWeights } from "../../Distribution/index.js";
+import { schemaSatisfies } from "../../Schema/Satisfies.js";
 import { Kind, Meta } from "../../Types.js";
 import { outcomes } from "./Outcomes.js";
 function Schema(schema) {
@@ -13,6 +14,7 @@ function Schema(schema) {
                     produce
                 }
             }),
+        satisfies: schemaSatisfies,
         weighted: (weights)=>{
             const merged = {
                 ...schema[Meta].weights,

package/dist/esm/Primitive/nullish/Schema.js

@@ -1,5 +1,6 @@
 import { withAdaptations } from "../../Adapter/Core.js";
 import { assertDrawableKeyedWeights } from "../../Distribution/index.js";
+import { schemaSatisfies } from "../../Schema/Satisfies.js";
 import { Kind, Meta } from "../../Types.js";
 import { outcomes } from "./Outcomes.js";
 function Schema(schema) {
@@ -13,6 +14,7 @@ function Schema(schema) {
                     produce
                 }
             }),
+        satisfies: schemaSatisfies,
         weighted: (weights)=>{
             const merged = {
                 ...schema[Meta].weights,

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

@@ -1,5 +1,5 @@
 import { constrainContinuous, effectiveDiscrete } from "../../Bound.js";
-import { Distribution, sampler } from "../../Distribution/index.js";
+import { Distribution, discreteSampler, sampler } from "../../Distribution/index.js";
 import { toStreamFromTrace } from "../../Random/index.js";
 import { Kind, Meta } from "../../Types.js";
 import { unboundedContinuous, unboundedDiscrete } from "./defaults.js";
@@ -46,16 +46,12 @@ function Fabricator(context) {
     };
     const distribution = null != (_range_distribution = range.distribution) ? _range_distribution : Distribution.uniform();
     if (meta.integer) {
-        const { min, max } = effectiveDiscrete(range.min, range.max);
-        const draw = sampler(distribution, {
-            min,
-            max: max + 1
-        }, stream);
+        const draw = discreteSampler(distribution, effectiveDiscrete(range.min, range.max), stream);
         return {
             [Kind]: "number",
             [Meta]: meta,
             trace,
-            fabricate: ()=>Math.min(max, Math.floor(draw())),
+            fabricate: ()=>draw(),
             schema: rehydrated
         };
     }

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

@@ -1,4 +1,5 @@
 import { withAdaptations } from "../../Adapter/Core.js";
+import { schemaSatisfies } from "../../Schema/Satisfies.js";
 import { Kind, Meta } from "../../Types.js";
 function Schema(schema) {
     return {
@@ -12,6 +13,7 @@ function Schema(schema) {
                     hints
                 }
             }),
+        satisfies: schemaSatisfies,
         adapt: (adapter, produce)=>Schema(withAdaptations(schema, adapter, produce))
     };
 }

package/dist/esm/Primitive/object/Schema.js

@@ -1,3 +1,4 @@
+import { schemaSatisfies } from "../../Schema/Satisfies.js";
 import { Kind, Meta } from "../../Types.js";
 function Schema(schema) {
     return {
@@ -9,7 +10,8 @@ function Schema(schema) {
                     ...schema[Meta],
                     produce
                 }
-            })
+            }),
+        satisfies: schemaSatisfies
     };
 }
 function isObjectSchema(candidate) {

package/dist/esm/Primitive/object/compute/Schema.js

@@ -1,9 +1,11 @@
 import { withAdaptations } from "../../../Adapter/Core.js";
+import { schemaSatisfies } from "../../../Schema/Satisfies.js";
 import { Kind } from "../../../Types.js";
 function Schema(schema) {
     return {
         ...schema,
         [Kind]: "object.compute",
+        satisfies: schemaSatisfies,
         adapt: (adapter, produce)=>Schema(withAdaptations(schema, adapter, produce))
     };
 }

package/dist/esm/Primitive/object/omittable/Schema.js

@@ -1,5 +1,6 @@
 import { withAdaptations } from "../../../Adapter/Core.js";
 import { assertDrawableKeyedWeights } from "../../../Distribution/index.js";
+import { schemaSatisfies } from "../../../Schema/Satisfies.js";
 import { Kind, Meta } from "../../../Types.js";
 import { outcomes } from "./Outcomes.js";
 function Schema(schema) {
@@ -13,6 +14,7 @@ function Schema(schema) {
                     produce
                 }
             }),
+        satisfies: schemaSatisfies,
         weighted: (weights)=>{
             const merged = {
                 ...schema[Meta].weights,

package/dist/esm/Primitive/object/optional/Schema.js

@@ -1,5 +1,6 @@
 import { withAdaptations } from "../../../Adapter/Core.js";
 import { assertDrawableKeyedWeights } from "../../../Distribution/index.js";
+import { schemaSatisfies } from "../../../Schema/Satisfies.js";
 import { Kind, Meta } from "../../../Types.js";
 import { outcomes } from "./Outcomes.js";
 function Schema(schema) {
@@ -13,6 +14,7 @@ function Schema(schema) {
                     produce
                 }
             }),
+        satisfies: schemaSatisfies,
         weighted: (weights)=>{
             const merged = {
                 ...schema[Meta].weights,

package/dist/esm/Primitive/opaque/Schema.js

@@ -1,9 +1,11 @@
 import { withAdaptations } from "../../Adapter/Core.js";
+import { schemaSatisfies } from "../../Schema/Satisfies.js";
 import { Kind } from "../../Types.js";
 function Schema(schema) {
     return {
         ...schema,
         [Kind]: "opaque",
+        satisfies: schemaSatisfies,
         adapt: (adapter, produce)=>Schema(withAdaptations(schema, adapter, produce))
     };
 }

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

@@ -1,3 +1,4 @@
+import { discreteSampler } from "../../Distribution/index.js";
 import { toStreamFromTrace } from "../../Random/index.js";
 import { Children, Kind, Meta } from "../../Types.js";
 import { Schema } from "./Schema.js";
@@ -25,8 +26,12 @@ function Fabricator(context, key, value) {
     }
     const stream = toStreamFromTrace(algorithm, trace);
     const { max, minTried = 0 } = meta.whereby.size;
+    const drawSize = discreteSampler(void 0, {
+        min: minTried,
+        max
+    }, stream);
     const fabricate = ()=>{
-        const size = minTried + Math.floor(stream.next() * (max - minTried + 1));
+        const size = drawSize();
         const fabricated = {};
         for(let i = 0; i < size; i++){
             const k = key.fabricate();

package/dist/esm/Primitive/record/Schema.js

@@ -1,4 +1,5 @@
 import { withAdaptations } from "../../Adapter/Core.js";
+import { schemaSatisfies } from "../../Schema/Satisfies.js";
 import { Kind, Meta } from "../../Types.js";
 function Schema(schema) {
     return {
@@ -11,6 +12,7 @@ function Schema(schema) {
                     produce
                 }
             }),
+        satisfies: schemaSatisfies,
         adapt: (adapter, produce)=>Schema(withAdaptations(schema, adapter, produce))
     };
 }

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

@@ -1,9 +1,11 @@
 import { withAdaptations } from "../../Adapter/Core.js";
+import { schemaSatisfies } from "../../Schema/Satisfies.js";
 import { Kind } from "../../Types.js";
 function Schema(schema) {
     return {
         ...schema,
         [Kind]: "recursive",
+        satisfies: schemaSatisfies,
         adapt: (adapter, produce)=>Schema(withAdaptations(schema, adapter, produce))
     };
 }

package/dist/esm/Primitive/recursive/self/Schema.js

@@ -1,9 +1,11 @@
 import { withAdaptations } from "../../../Adapter/Core.js";
+import { schemaSatisfies } from "../../../Schema/Satisfies.js";
 import { Kind } from "../../../Types.js";
 function Schema(schema) {
     return {
         ...schema,
         [Kind]: "recursive.self",
+        satisfies: schemaSatisfies,
         adapt: (adapter, produce)=>Schema(withAdaptations(schema, adapter, produce))
     };
 }

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

@@ -1,5 +1,5 @@
 import { effectiveDiscrete } from "../../Bound.js";
-import { weighted } from "../../Distribution/index.js";
+import { discreteSampler, weighted } from "../../Distribution/index.js";
 import { toStreamFromTrace } from "../../Random/index.js";
 import { Kind, Meta } from "../../Types.js";
 import { inline } from "../../Utility/Core.js";
@@ -26,6 +26,10 @@ function Fabricator(context) {
     const stream = toStreamFromTrace(algorithm, trace);
     const whereby = meta.whereby;
     const { min, max } = effectiveDiscrete(whereby.length.min, whereby.length.max);
+    const drawLength = discreteSampler(whereby.length.distribution, {
+        min,
+        max
+    }, stream);
     const sources = inline(()=>{
         const composition = whereby.composition;
         if (void 0 === composition) return [
@@ -46,7 +50,7 @@ function Fabricator(context) {
         ]), stream, "T.string.whereby.composition");
     const fill = compiler(bmpScalars, stream);
     const fabricate = ()=>{
-        const length = min + Math.floor(stream.next() * (max - min + 1));
+        const length = drawLength();
         const pieces = [];
         let remaining = length;
         while(remaining > 0){

package/dist/esm/Primitive/string/Schema.js

@@ -1,4 +1,5 @@
 import { withAdaptations } from "../../Adapter/Core.js";
+import { schemaSatisfies } from "../../Schema/Satisfies.js";
 import { Kind, Meta } from "../../Types.js";
 function Schema(schema) {
     return {
@@ -12,6 +13,7 @@ function Schema(schema) {
                     hints
                 }
             }),
+        satisfies: schemaSatisfies,
         adapt: (adapter, produce)=>Schema(withAdaptations(schema, adapter, produce))
     };
 }

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

@@ -1,4 +1,5 @@
 import { withAdaptations } from "../../Adapter/Core.js";
+import { schemaSatisfies } from "../../Schema/Satisfies.js";
 import { Kind, Meta } from "../../Types.js";
 function Schema(schema) {
     return {
@@ -11,6 +12,7 @@ function Schema(schema) {
                     produce
                 }
             }),
+        satisfies: schemaSatisfies,
         adapt: (adapter, produce)=>Schema(withAdaptations(schema, adapter, produce))
     };
 }

package/dist/esm/Primitive/tuple/Schema.js

@@ -1,4 +1,5 @@
 import { withAdaptations } from "../../Adapter/Core.js";
+import { schemaSatisfies } from "../../Schema/Satisfies.js";
 import { Kind, Meta } from "../../Types.js";
 function Schema(schema) {
     return {
@@ -11,6 +12,7 @@ function Schema(schema) {
                     produce
                 }
             }),
+        satisfies: schemaSatisfies,
         adapt: (adapter, produce)=>Schema(withAdaptations(schema, adapter, produce))
     };
 }

package/dist/esm/Primitive/undefinable/Schema.js

@@ -1,5 +1,6 @@
 import { withAdaptations } from "../../Adapter/Core.js";
 import { assertDrawableKeyedWeights } from "../../Distribution/index.js";
+import { schemaSatisfies } from "../../Schema/Satisfies.js";
 import { Kind, Meta } from "../../Types.js";
 import { outcomes } from "./Outcomes.js";
 function Schema(schema) {
@@ -13,6 +14,7 @@ function Schema(schema) {
                     produce
                 }
             }),
+        satisfies: schemaSatisfies,
         weighted: (weights)=>{
             const merged = {
                 ...schema[Meta].weights,

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

@@ -1,9 +1,11 @@
 import { withAdaptations } from "../../Adapter/Core.js";
+import { schemaSatisfies } from "../../Schema/Satisfies.js";
 import { Kind } from "../../Types.js";
 function Schema(schema) {
     return {
         ...schema,
         [Kind]: "undefined",
+        satisfies: schemaSatisfies,
         adapt: (adapter, produce)=>Schema(withAdaptations(schema, adapter, produce))
     };
 }

package/dist/esm/Schema/Satisfies.js

@@ -0,0 +1,5 @@
+function schemaSatisfies() {
+    return this;
+}
+function satisfies(buildable) {}
+export { satisfies, schemaSatisfies };

package/dist/esm/index.js

@@ -10,4 +10,5 @@ export { FabricatorError } from "./Error/index.js";
 export { registry } from "./Schema/Registry.js";
 export { effectiveDiscrete, toBound } from "./Bound.js";
 export { sample, shuffle } from "./Distribution/index.js";
+export { satisfies } from "./Schema/Satisfies.js";
 export { initialize };

package/dist/types/Bound.d.ts

@@ -1,3 +1,4 @@
+import type { Distribution } from "./Distribution";
 /**
  * Canonical endpoint stored on `[Meta].whereby`. Call sites still accept a
  * scalar (inclusive) via {@link InputBound}; `.whereby()` runs {@link toBound} so
@@ -56,13 +57,28 @@ export declare function towardInterior(value: number, toward: number): number;
 export declare function constrainContinuous(next: () => number, min: Bound<number>, max: Bound<number>): () => number;
 export declare function epochBound(bound: Bound<Date>): Bound<number>;
 /**
- * Array/string `length`: a bare number is an exact count; an omitted `min` is
- * inclusive `0`. Always stored as a Bound pair so adapters have one path.
+ * Call-site `length` for `string` and `array`: a bare number is an exact count,
+ * and `{ max, min?, distribution? }` is a range. A scalar end is inclusive.
  */
-export declare function toLengthRange(length: number | {
+export type InputLength = number | {
     max: InputBound<number>;
     min?: InputBound<number> | undefined;
-}, label: string): {
+    distribution?: Distribution | undefined;
+};
+/**
+ * Stored `length`: both ends are canonical {@link Bound}s. `distribution` is
+ * present only when the caller set one, so a bare count and an unspecified
+ * distribution stay off the stored object.
+ */
+export type Length = {
     min: Bound<number>;
     max: Bound<number>;
+    distribution?: Distribution | undefined;
 };
+/**
+ * Array/string `length`: a bare number is an exact count (no distribution); an
+ * omitted `min` is inclusive `0`. Always stored as a Bound pair so adapters
+ * have one path. `distribution` is copied only when the caller set one,
+ * matching `date/Registry.ts`'s `toWhereby`, so stored meta stays minimal.
+ */
+export declare function toLengthRange(length: InputLength, label: string): Length;

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

@@ -88,6 +88,20 @@ export declare namespace Distribution {
      */
     const custom: (shape: (u: number) => number) => Distribution;
 }
+/**
+ * Integer draw over the inclusive `[min, max]` of `range`. Samples `[min, max +
+ * 1)` and floors, so each integer owns a full-width bucket — avoiding the
+ * half-width endpoint bias that rounding a `[min, max]` draw would produce. An
+ * omitted `distribution` is uniform. `range` is already the effective inclusive
+ * interval; exclusive ends are the caller's to resolve (`effectiveDiscrete`).
+ *
+ * The `Math.min(max, …)` clamp is load-bearing, not defensive. `max + 1` is
+ * exact even at `Number.MAX_SAFE_INTEGER` (it is 2^53), but near there doubles
+ * are spaced 1 apart, so `sampler`'s `(1 - u) * min + u * (max + 1)` can round
+ * up to exactly `max + 1` — e.g. `[MAX_SAFE_INTEGER - 10, MAX_SAFE_INTEGER]` —
+ * which would floor to one past `max`.
+ */
+export declare function discreteSampler(distribution: Distribution | undefined, range: Range, stream: Stream): () => number;
 /**
  * Build a sampler that draws values within `range` following `distribution`.
  * Each call consumes one fresh uniform draw and, by construction, returns a

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

@@ -128,8 +128,7 @@ export declare namespace FabricatorError {
          */
         readonly label: string;
         /**
-         * What the caller calls its items, e.g.
-         * `"member"`/`"option"`/`"item"`.
+         * What the caller calls its items, e.g. `"member"`/`"option"`/`"item"`.
          */
         readonly noun: string;
         constructor(
@@ -139,8 +138,7 @@ export declare namespace FabricatorError {
          */
         label: string, 
         /**
-         * What the caller calls its items, e.g.
-         * `"member"`/`"option"`/`"item"`.
+         * What the caller calls its items, e.g. `"member"`/`"option"`/`"item"`.
          */
         noun: string);
     }

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

@@ -35,10 +35,10 @@ import type { FabricatorTestContext, Integration } from "./Types";
  * captured result would pin one frame.
  *
  * The per-test wrap is entered on `context.scope()`, so it governs that
- * instance and its ancestors: the integrated instance when nothing encloses
- * it, and that instance as an ancestor of the enclosing scope when something
- * does. It does not govern forks of the integrated instance. Per-test data
- * therefore comes from the instance handed to `integration(...)`, from
+ * instance and its ancestors: the integrated instance when nothing encloses it,
+ * and that instance as an ancestor of the enclosing scope when something does.
+ * It does not govern forks of the integrated instance. Per-test data therefore
+ * comes from the instance handed to `integration(...)`, from
  * `context.fabricator`, or from a fork of that scope — a module-level fork of
  * the integrated instance draws the same data in every test, and because its
  * construction counter runs across tests, which values a test gets depends on