@ghostry/fabricator 0.0.1 → 0.0.2

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

@@ -1,43 +1,41 @@
 import type { Adaptation, Meta } from "../Types";
 /**
- * One adapter's override for one schema, *as stored* in `[Adaptation]` —
- * the loosest signature the mechanism needs. An adapter states its real
- * return type on {@link Adapter.convert}, and `.adapt(...)` checks a
- * supplied adaptation against that; nothing here reads either end.
+ * One adapter's override for one schema, _as stored_ in `[Adaptation]` — the
+ * loosest signature the mechanism needs. An adapter states its real return type
+ * on {@link Adapter.convert}, and `.adapt(...)` checks a supplied adaptation
+ * against that; nothing here reads either end.
  *
- * Not the shape a caller writes: a kind's `.adapt(...)` takes a producer
- * of {@link Adapting}, which `Adapter/Core.ts`'s `withAdaptations`/
- * `mergeAdaptations` wrap into this one entry point-side. The stored
- * form stays schema-taking so `patched`/`layer` treat an incoming
- * producer and a prior layered entry as one type, and so
- * `AdaptationEntry`'s `(schema: any) => $Returnable` is an accurate
- * account of what a schema carries.
+ * Not the shape a caller writes: a kind's `.adapt(...)` takes a producer of
+ * {@link Adapting}, which `Adapter/Core.ts`'s `withAdaptations`/
+ * `mergeAdaptations` wrap into this one entry point-side. The stored form stays
+ * schema-taking so `patched`/`layer` treat an incoming producer and a prior
+ * layered entry as one type, and so `AdaptationEntry`'s `(schema: any) =>
+ * $Returnable` is an accurate account of what a schema carries.
  */
 export type SchemaAdaptation = (schema: any) => unknown;
 /**
- * What a kind's `.adapt(adapter, produce)` hands its producer: the schema
- * being adapted, and that schema's `[Meta]` — one object rather than two
- * parameters, so destructuring picks whichever half is needed and neither
- * is reachable only through a well-known symbol.
+ * What a kind's `.adapt(adapter, produce)` hands its producer: the schema being
+ * adapted, and that schema's `[Meta]` — one object rather than two parameters,
+ * so destructuring picks whichever half is needed and neither is reachable only
+ * through a well-known symbol.
  *
- * `schema` carries whichever adaptation for this same adapter it
- * replaced, absent at the bottom of the stack (see `Adapter/Core.ts`'s
- * `layer`) — so `toTypeBox(schema)` inside a producer resolves to the
- * previous layer, or to the kind's ordinary mapping when there is none.
- * `meta` is read off that same substituted schema, so the two keys
- * describe one object.
+ * `schema` carries whichever adaptation for this same adapter it replaced,
+ * absent at the bottom of the stack (see `Adapter/Core.ts`'s `layer`) — so
+ * `toTypeBox(schema)` inside a producer resolves to the previous layer, or to
+ * the kind's ordinary mapping when there is none. `meta` is read off that same
+ * substituted schema, so the two keys describe one object.
  *
- * `meta`'s shape is the kind's own config blob, derived by indexed
- * access rather than named separately so no kind states its own `Meta`
- * twice in an `adapt` signature. **Readable but not stabilized**: an
- * adaptation may read it; a kind stays free to restructure it — nothing
- * outside a kind's own files should *interpret* another kind's `[Meta]`.
+ * `meta`'s shape is the kind's own config blob, derived by indexed access
+ * rather than named separately so no kind states its own `Meta` twice in an
+ * `adapt` signature. **Readable but not stabilized**: an adaptation may read
+ * it; a kind stays free to restructure it — nothing outside a kind's own files
+ * should _interpret_ another kind's `[Meta]`.
  *
  * A kind with no bare-form default carries no `[Meta]` at runtime until
  * configured (`string`/`bigint`'s registry exports — see "Anatomy of a
- * primitive"), so `meta` can be `undefined` there despite this type.
- * Same imprecision `Schema<$Meta>` already states, and why the TypeBox
- * adapter reads `[Meta]` defensively for those kinds.
+ * primitive"), so `meta` can be `undefined` there despite this type. Same
+ * imprecision `Schema<$Meta>` already states, and why the TypeBox adapter reads
+ * `[Meta]` defensively for those kinds.
  */
 export type Adapting<$Schema extends {
     [Meta]: unknown;
@@ -46,70 +44,64 @@ export type Adapting<$Schema extends {
     readonly meta: $Schema[typeof Meta];
 };
 /**
- * What a Schema's `[Adaptation]` holds: each adapter's override, under
- * that adapter's own key.
+ * What a Schema's `[Adaptation]` holds: each adapter's override, under that
+ * adapter's own key.
  *
- * Open rather than a closed registry of known libraries: an adapter is
- * a value (see {@link Adapter}), not a name this package knows. Nothing
- * has to be declared for a third party's adapter to work, and two
- * adapters for different versions of the same library collide with
- * nothing.
+ * Open rather than a closed registry of known libraries: an adapter is a value
+ * (see {@link Adapter}), not a name this package knows. Nothing has to be
+ * declared for a third party's adapter to work, and two adapters for different
+ * versions of the same library collide with nothing.
  */
 export type Adaptations = {
     readonly [key: string]: SchemaAdaptation;
 };
 /**
  * An {@link Adaptations} update as `withAdaptations` accepts it. Identical
- * except that an explicitly-`undefined` entry *removes* that adapter's
- * override — how the layering hands an adaptation the schema it is
- * adapting with its own entry replaced by the previous one, or absent
- * at the bottom of the stack.
+ * except that an explicitly-`undefined` entry _removes_ that adapter's override
+ * — how the layering hands an adaptation the schema it is adapting with its own
+ * entry replaced by the previous one, or absent at the bottom of the stack.
  *
- * Not what a kind's `.adapt(...)` accepts: removal is an internal need
- * of the layering, and letting a caller express it would produce a
- * `[Adaptation]` type that `exactOptionalPropertyTypes` rejects against
- * {@link Adaptations}.
+ * Not what a kind's `.adapt(...)` accepts: removal is an internal need of the
+ * layering, and letting a caller express it would produce a `[Adaptation]` type
+ * that `exactOptionalPropertyTypes` rejects against {@link Adaptations}.
  */
 export type Patch = {
     readonly [key: string]: SchemaAdaptation | undefined;
 };
 /**
  * How an adapter recurses into a nested schema — handed to
- * {@link Adapter.convert} by `Adapter/Core.ts`'s `drive` rather than
- * being the adapter's own private recursion, so every nested node goes
- * back through the adaptation lookup, not only the outermost one.
+ * {@link Adapter.convert} by `Adapter/Core.ts`'s `drive` rather than being the
+ * adapter's own private recursion, so every nested node goes back through the
+ * adaptation lookup, not only the outermost one.
  *
- * `$Context` is the adapter's own, and opaque here: an adapter that
- * needs to carry something down its recursion (the enclosing
- * `T.recursive`'s placeholder, say) threads it through unchanged.
- * `$Returnable` is likewise the adapter's own — stated so a nested
- * node's result drops straight into a composite
- * (`Type.Array(recurse(element, context))`) with no cast at any call
+ * `$Context` is the adapter's own, and opaque here: an adapter that needs to
+ * carry something down its recursion (the enclosing `T.recursive`'s
+ * placeholder, say) threads it through unchanged. `$Returnable` is likewise the
+ * adapter's own — stated so a nested node's result drops straight into a
+ * composite (`Type.Array(recurse(element, context))`) with no cast at any call
  * site.
  */
 export type Recurse<$Context, $Returnable> = (schema: any, context: $Context) => $Returnable;
 /**
- * An adapter to one external schema library: a plain value, imported
- * directly by whoever adapts a schema (`schema.adapt(typebox, ...)`)
- * and by whoever converts one. Nothing to register — no global
- * interface to declaration-merge, and no name chosen anywhere but here.
+ * An adapter to one external schema library: a plain value, imported directly
+ * by whoever adapts a schema (`schema.adapt(typebox, ...)`) and by whoever
+ * converts one. Nothing to register — no global interface to declaration-merge,
+ * and no name chosen anywhere but here.
  *
- * `key` is the adapter's `[Adaptation]` namespace. Read off the value
- * as a literal type, so a wrong one is an import error rather than an
- * entry nothing looks up. Give it something collision-proof — a package
- * specifier, versioned when a library's major rewrite means two
- * adapters can coexist.
+ * `key` is the adapter's `[Adaptation]` namespace. Read off the value as a
+ * literal type, so a wrong one is an import error rather than an entry nothing
+ * looks up. Give it something collision-proof — a package specifier, versioned
+ * when a library's major rewrite means two adapters can coexist.
  *
- * `convert`'s declared return type is this adapter's external bound:
- * the type every `.adapt(...)` against it must produce, and why an
- * adaptation that returns the wrong thing fails at the call site.
+ * `convert`'s declared return type is this adapter's external bound: the type
+ * every `.adapt(...)` against it must produce, and why an adaptation that
+ * returns the wrong thing fails at the call site.
  *
- * Deliberately *not* carrying the adapter's type-level mapping. An
- * adapter package declares its own conversion entry point with its own
- * return type (`toTypeBox<$S>(schema: $S): ToTypeBox<$S>`), so nothing
- * has to compute a type-level mapping out of a stored value — which
- * would need the interface-member-lookup encoding `ValueOf`'s
- * `$Bindings` uses, for no gain.
+ * Deliberately _not_ carrying the adapter's type-level mapping. An adapter
+ * package declares its own conversion entry point with its own return type
+ * (`toTypeBox<$S>(schema: $S): ToTypeBox<$S>`), so nothing has to compute a
+ * type-level mapping out of a stored value — which would need the
+ * interface-member-lookup encoding `ValueOf`'s `$Bindings` uses, for no gain.
  */
 export interface Adapter<$Key extends string = string, $Context = unknown, $Returnable = unknown> {
     readonly key: $Key;
@@ -119,27 +111,25 @@ export interface Adapter<$Key extends string = string, $Context = unknown, $Retu
  * The adaptations a Schema (or a built Fabricator, which carries them
  * identically) declares, or `{}` for one that declares none.
  *
- * The two steps — extract the map, then match against it — are
- * load-bearing, and why no adapter matches
- * `{ [Adaptation]?: Record<Key, ...> }` directly. Every kind's `Core`
- * declares `[Adaptation]` as *optional*, and a conditional matching an
- * optional property against a schema that lacks it entirely still
- * *succeeds*, inferring `unknown` (the same behavior `ValueOf` relies
- * on for `[Produces]`) — so a direct match would resolve every
- * unadapted schema to whatever the adapter's adaptation branch
- * produces. Constraining the `infer` sends that case here, to `{}`,
- * which then fails each adapter's `Record<Key, ...>` check as it
- * should.
+ * The two steps — extract the map, then match against it — are load-bearing,
+ * and why no adapter matches `{ [Adaptation]?: Record<Key, ...> }` directly.
+ * Every kind's `Core` declares `[Adaptation]` as _optional_, and a conditional
+ * matching an optional property against a schema that lacks it entirely still
+ * _succeeds_, inferring `unknown` (the same behavior `ValueOf` relies on for
+ * `[Produces]`) — so a direct match would resolve every unadapted schema to
+ * whatever the adapter's adaptation branch produces. Constraining the `infer`
+ * sends that case here, to `{}`, which then fails each adapter's `Record<Key,
+ * ...>` check as it should.
  */
 export type AdaptationsOf<$Schema> = $Schema extends {
     [Adaptation]?: infer $Adaptations extends Adaptations;
 } ? $Adaptations : {};
 /**
- * `$Prior` with `$Map` applied: an adapter named in `$Map` takes its new
- * entry; one it doesn't name is carried forward. `Omit` first (rather
- * than a plain `$Prior & $Map`) so a replaced entry is genuinely
- * replaced — intersecting two call signatures for the same adapter
- * would produce an overload, from which an adapter's `infer` would
- * read whichever member TypeScript happens to resolve last.
+ * `$Prior` with `$Map` applied: an adapter named in `$Map` takes its new entry;
+ * one it doesn't name is carried forward. `Omit` first (rather than a plain
+ * `$Prior & $Map`) so a replaced entry is genuinely replaced — intersecting two
+ * call signatures for the same adapter would produce an overload, from which an
+ * adapter's `infer` would read whichever member TypeScript happens to resolve
+ * last.
  */
 export type WithAdaptations<$Prior extends Adaptations, $Map extends Adaptations> = Omit<$Prior, keyof $Map> & $Map;

package/dist/types/Bound.d.ts

@@ -1,16 +1,16 @@
 /**
  * Canonical endpoint stored on `[Meta].whereby`. Call sites still accept a
- * scalar (inclusive) via {@link InputBound}; `.whereby()` runs {@link toBound}
- * so adapters always see this shape — never a scalar/object union.
+ * scalar (inclusive) via {@link InputBound}; `.whereby()` runs {@link toBound} so
+ * adapters always see this shape — never a scalar/object union.
  */
 export type Bound<$T> = {
     value: $T;
     exclusive: boolean;
 };
 /**
- * What `.whereby({ min, max })` accepts: a scalar is inclusive, an object
- * names an endpoint policy. `exclusive` is required on the object form so
- * that form exists only to state one.
+ * What `.whereby({ min, max })` accepts: a scalar is inclusive, an object names
+ * an endpoint policy. `exclusive` is required on the object form so that form
+ * exists only to state one.
  */
 export type InputBound<$T> = $T | Bound<$T>;
 /**
@@ -20,8 +20,8 @@ export type InputBound<$T> = $T | Bound<$T>;
  */
 export declare function toBound<$T>(input: InputBound<$T>): Bound<$T>;
 /**
- * Inclusive integer interval implied by a discrete Bound pair. Exclusive min
- * is `value + 1`, exclusive max is `value - 1` — the same unit the length/
+ * Inclusive integer interval implied by a discrete Bound pair. Exclusive min is
+ * `value + 1`, exclusive max is `value - 1` — the same unit the length/
  * integer/bigint draws already use. Empty iff `min > max`.
  */
 export declare function effectiveDiscrete(min: Bound<number>, max: Bound<number>): {
@@ -37,15 +37,15 @@ export declare function assertNonemptyDiscreteBigint(label: string, min: Bound<b
 /**
  * Continuous emptiness: inverted bounds, a point range with either end
  * exclusive, or both ends exclusive with no float strictly between them.
- * Sampling still uses the closed interval and {@link constrainContinuous}
- * steps off an exclusive endpoint — this check is what makes that step
- * always have somewhere to land.
+ * Sampling still uses the closed interval and {@link constrainContinuous} steps
+ * off an exclusive endpoint — this check is what makes that step always have
+ * somewhere to land.
  */
 export declare function assertNonemptyContinuous(label: string, min: Bound<number>, max: Bound<number>): void;
 /**
- * One ulp toward `toward` from `value`. Approximate, and enough to leave
- * an exclusive endpoint without rejection-looping a truncated distribution
- * that clamped onto it.
+ * One ulp toward `toward` from `value`. Approximate, and enough to leave an
+ * exclusive endpoint without rejection-looping a truncated distribution that
+ * clamped onto it.
  */
 export declare function towardInterior(value: number, toward: number): number;
 /**
@@ -56,8 +56,8 @@ 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.
+ * 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.
  */
 export declare function toLengthRange(length: number | {
     max: InputBound<number>;

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

@@ -1,13 +1,12 @@
 import type { Stream } from "../Random/Types";
 /**
- * How randomly generated values cluster within a `{ min, max }` range.
- * Without one, generation is uniform — every value in the range is
- * equally likely.
+ * How randomly generated values cluster within a `{ min, max }` range. Without
+ * one, generation is uniform — every value in the range is equally likely.
  *
- * Each variant is a tagged object so distributions stay
- * introspectable and serializable. The `custom` variant is the escape
- * hatch: a shaping function `(u) => p` mapping a uniform draw in
- * `[0, 1)` to a position in `[0, 1)` within the range.
+ * Each variant is a tagged object so distributions stay introspectable and
+ * serializable. The `custom` variant is the escape hatch: a shaping function
+ * `(u) => p` mapping a uniform draw in `[0, 1)` to a position in `[0, 1)`
+ * within the range.
  */
 export type Distribution = Distribution.Uniform | Distribution.Normal | Distribution.Skew | Distribution.Triangular | Distribution.Logarithmic | Distribution.Multi | Distribution.Custom;
 export type Range = {
@@ -25,9 +24,9 @@ export declare namespace Distribution {
         spread?: number | undefined;
     };
     /**
-     * Bell curve truncated to the range. `mean` defaults to the range's
-     * center; `spread` (standard deviation) defaults to a sixth of the
-     * span, placing the bounds at roughly ±3σ before truncation.
+     * Bell curve truncated to the range. `mean` defaults to the range's center;
+     * `spread` (standard deviation) defaults to a sixth of the span, placing the
+     * bounds at roughly ±3σ before truncation.
      */
     const normal: (params?: {
         mean?: number;
@@ -38,8 +37,8 @@ export declare namespace Distribution {
         exponent: number;
     };
     /**
-     * Power curve. `exponent > 1` biases toward `min`, `exponent < 1`
-     * biases toward `max`, and `exponent === 1` is uniform.
+     * Power curve. `exponent > 1` biases toward `min`, `exponent < 1` biases
+     * toward `max`, and `exponent === 1` is uniform.
      */
     const skew: (exponent: number) => Distribution;
     type Triangular = {
@@ -56,10 +55,9 @@ export declare namespace Distribution {
         kind: "logarithmic";
     };
     /**
-     * Log-uniform (reciprocal): density proportional to `1/x`, so values
-     * spread evenly across orders of magnitude and cluster toward `min`.
-     * Requires a strictly positive range — the logarithm is undefined at
-     * or below zero.
+     * Log-uniform (reciprocal): density proportional to `1/x`, so values spread
+     * evenly across orders of magnitude and cluster toward `min`. Requires a
+     * strictly positive range — the logarithm is undefined at or below zero.
      */
     const logarithmic: () => Distribution;
     type Multi = {
@@ -70,11 +68,10 @@ export declare namespace Distribution {
         }>;
     };
     /**
-     * A weighted blend of component distributions, each drawn over the
-     * same range. Localized components with distinct centers (e.g. two
-     * `normal`s at different means) produce the separate peaks of a
-     * multimodal distribution. Weights are relative — they need not sum
-     * to 1.
+     * A weighted blend of component distributions, each drawn over the same
+     * range. Localized components with distinct centers (e.g. two `normal`s at
+     * different means) produce the separate peaks of a multimodal distribution.
+     * Weights are relative — they need not sum to 1.
      */
     const multi: (components: ReadonlyArray<{
         weight: number;
@@ -85,73 +82,69 @@ export declare namespace Distribution {
         shape: (u: number) => number;
     };
     /**
-     * Escape hatch: `shape` maps a uniform draw in `[0, 1)` to a
-     * position in `[0, 1)` within the range (an inverse CDF). The output
-     * is clamped to `[0, 1]` so the result always lands within the
-     * bounds.
+     * Escape hatch: `shape` maps a uniform draw in `[0, 1)` to a position in `[0,
+     * 1)` within the range (an inverse CDF). The output is clamped to `[0, 1]` so
+     * the result always lands within the bounds.
      */
     const custom: (shape: (u: number) => number) => Distribution;
 }
 /**
- * Build a sampler that draws values within `range` following
- * `distribution`. Each call consumes one fresh uniform draw and, by
- * construction, returns a value within `[min, max]` — distributions
- * with mass outside the range (e.g. a normal's tails) are truncated
- * via their inverse CDF rather than rejected or clamped.
+ * Build a sampler that draws values within `range` following `distribution`.
+ * Each call consumes one fresh uniform draw and, by construction, returns a
+ * value within `[min, max]` — distributions with mass outside the range (e.g. a
+ * normal's tails) are truncated via their inverse CDF rather than rejected or
+ * clamped.
  */
 export declare function sampler(distribution: Distribution, range: Range, stream: Stream): () => number;
 export declare function sample<$T>(list: ReadonlyArray<$T>, stream: Stream): $T;
 /**
  * Fisher–Yates (Durstenfeld) shuffle: a new array holding `items` in a
- * uniformly random order — every permutation is equally likely. Does
- * not mutate `items`, matching `sample`/`weighted`'s read-only
- * convention.
+ * uniformly random order — every permutation is equally likely. Does not mutate
+ * `items`, matching `sample`/`weighted`'s read-only convention.
  */
 export declare function shuffle<$T>(items: ReadonlyArray<$T>, stream: Stream): $T[];
 /**
- * `weighted()`'s own inclusion rule: whether this entry stays in the
- * draw table. `0` is valid and disables the outcome; negative/`NaN`
- * are rejected earlier by {@link isValidWeight}. Exposed so
- * `Enumeration/Plan.ts` and the construction guards share one
- * definition of "will this be drawn" rather than each writing
- * `weight > 0`.
+ * `weighted()`'s own inclusion rule: whether this entry stays in the draw
+ * table. `0` is valid and disables the outcome; negative/`NaN` are rejected
+ * earlier by {@link isValidWeight}. Exposed so `Enumeration/Plan.ts` and the
+ * construction guards share one definition of "will this be drawn" rather than
+ * each writing `weight > 0`.
  */
 export declare function isDrawable(weight: number): boolean;
 /**
- * Whether a weight is *expressible* at all, as opposed to whether it is
- * drawable. `0` is valid and disables the outcome; a negative weight or
- * `NaN` is a mistake. `Infinity` is rejected because it cannot be summed
- * into a usable draw table — every cumulative bound becomes `Infinity`,
- * so `weighted()`'s `x < weight` scan matches nothing.
+ * Whether a weight is _expressible_ at all, as opposed to whether it is
+ * drawable. `0` is valid and disables the outcome; a negative weight or `NaN`
+ * is a mistake. `Infinity` is rejected because it cannot be summed into a
+ * usable draw table — every cumulative bound becomes `Infinity`, so
+ * `weighted()`'s `x < weight` scan matches nothing.
  */
 export declare function isValidWeight(weight: number): boolean;
 /**
- * Outcomes that still have a positive weight after applying the
- * baseline of `1` for any unspecified (missing or explicitly
- * `undefined`) key. The one home of that `?? 1` default, so
- * `assertDrawableKeyedWeights` and `Enumeration/Plan.ts` cannot drift.
+ * Outcomes that still have a positive weight after applying the baseline of `1`
+ * for any unspecified (missing or explicitly `undefined`) key. The one home of
+ * that `?? 1` default, so `assertDrawableKeyedWeights` and
+ * `Enumeration/Plan.ts` cannot drift.
  */
 export declare function drawableOutcomes<$Outcome extends string>(outcomes: ReadonlyArray<$Outcome>, weights: Readonly<Record<string, number | undefined>> | undefined): ReadonlyArray<$Outcome>;
 /**
- * Two-stage guard for a `[weight, item]` list (`enum`/`choice`'s
- * `.weighted()` registries). Stage 1 rejects any entry that is not
- * {@link isValidWeight}; stage 2 rejects a list with no
- * {@link isDrawable} entry left. `label` names the call site
- * (`"T.enum.weighted"`/`"T.choice.weighted"`), `noun` the kind of
+ * Two-stage guard for a `[weight, item]` list (`enum`/`choice`'s `.weighted()`
+ * registries). Stage 1 rejects any entry that is not {@link isValidWeight};
+ * stage 2 rejects a list with no {@link isDrawable} entry left. `label` names
+ * the call site (`"T.enum.weighted"`/`"T.choice.weighted"`), `noun` the kind of
  * entry (`"member"`/`"option"`).
  */
 export declare function assertDrawableWeights(label: string, noun: string, items: ReadonlyArray<readonly [number, unknown]>): void;
 /**
- * The same two-stage guard as {@link assertDrawableWeights}, for the
- * kinds whose `.weighted(...)` weighs a *fixed, named* outcome set
- * (`boolean`'s `true`/`false`; `nullable`/`nullish`/`undefinable`/
+ * The same two-stage guard as {@link assertDrawableWeights}, for the kinds
+ * whose `.weighted(...)` weighs a _fixed, named_ outcome set (`boolean`'s
+ * `true`/`false`; `nullable`/`nullish`/`undefinable`/
  * `object.omittable`/`object.optional`'s presence outcomes) rather than a
- * caller-supplied list. Stage 2 must see the kind's **full** outcome list
- * — an omitted key still defaults to `1` — hence `outcomes`.
+ * caller-supplied list. Stage 2 must see the kind's **full** outcome list — an
+ * omitted key still defaults to `1` — hence `outcomes`.
  *
- * An explicitly-`undefined` value means "unspecified" — `Weights`'
- * keys are all optional and fall back to a baseline of `1` — so it is
- * skipped in stage 1 and defaulted in stage 2.
+ * An explicitly-`undefined` value means "unspecified" — `Weights`' keys are all
+ * optional and fall back to a baseline of `1` — so it is skipped in stage 1 and
+ * defaulted in stage 2.
  */
 export declare function assertDrawableKeyedWeights<$Outcome extends string>(label: string, outcomes: ReadonlyArray<$Outcome>, weights: Readonly<Record<string, number | undefined>>): void;
 export declare function weighted<const $Item>(weights: ReadonlyArray<readonly [number, $Item]>, stream: Stream, label: string): () => $Item;

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

@@ -2,32 +2,30 @@ import type { 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 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`/
+ * 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
+ * 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.
  *
- * 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
+ * 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.
+ * `"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.
  */
 export declare function enumerables(source: RandomSource, limits: Limits, stack: Stack): {
     combinatorial: Enumerable;

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

@@ -7,38 +7,34 @@ type Planning = {
     orderer: Orderer;
 };
 /**
- * Enumerable shape of a built Fabricator tree: how many distinct
- * combinations, and how to reproduce the `index`-th as a `Pin`.
- * Exhaustive kind dispatch lives in `axisFor`; this wrapper applies
- * `"cycle"` permutation uniformly, once, to whatever axis `axisFor`
- * computes — so every recursive call (`axisFor` cases call back into
- * `plan`, never `axisFor` directly) gets its *own* independent
- * permutation, decorrelating equal-width siblings without any
- * per-kind case needing to know strategy beyond `Strategy`'s own
- * widen/narrow rules.
+ * Enumerable shape of a built Fabricator tree: how many distinct combinations,
+ * and how to reproduce the `index`-th as a `Pin`. Exhaustive kind dispatch
+ * lives in `axisFor`; this wrapper applies `"cycle"` permutation uniformly,
+ * once, to whatever axis `axisFor` computes — so every recursive call
+ * (`axisFor` cases call back into `plan`, never `axisFor` directly) gets its
+ * _own_ independent permutation, decorrelating equal-width siblings without any
+ * per-kind case needing to know strategy beyond `Strategy`'s own widen/narrow
+ * rules.
  *
- * Width is a function of schema shape *and* weights: a zero-weighted
- * outcome is not fabricable, so `axisFor` filters through `isDrawable`
- * / `drawableOutcomes` rather than treating the declared branch set as
- * the axis. Without that, `coverage()` would pin a value `fabricate()`
- * can never produce. Defaulting of unspecified keyed weights goes
- * through `drawableOutcomes` so the `?? 1` baseline is never
- * re-implemented here.
+ * Width is a function of schema shape _and_ weights: a zero-weighted outcome is
+ * not fabricable, so `axisFor` filters through `isDrawable` /
+ * `drawableOutcomes` rather than treating the declared branch set as the axis.
+ * Without that, `coverage()` would pin a value `fabricate()` can never produce.
+ * Defaulting of unspecified keyed weights goes through `drawableOutcomes` so
+ * the `?? 1` baseline is never re-implemented here.
  *
  * Skipped for width-1 axes (nothing to permute) and under `"product"`
- * (mixed-radix decode already visits every combination, so permuting
- * would only reorder identical output — see `Orderer`). `orders` is
- * therefore only ever read when `strategy === "cycle"` and is safe to
- * omit otherwise.
+ * (mixed-radix decode already visits every combination, so permuting would only
+ * reorder identical output — see `Orderer`). `orders` is therefore only ever
+ * read when `strategy === "cycle"` and is safe to omit otherwise.
  */
 export declare function plan(node: Resolvable, planning: Planning): Axis;
 /**
- * Reproduce the value a `Pin` describes against the built Fabricator
- * it was planned from. `pin === undefined` is universal — `plan()`
- * gave this node a width-1 axis, so there is nothing to pin and it
- * fabricates normally. Every other case only arises for kinds
- * `plan()` treats as enumerable axes, so this switch does not need to
- * be exhaustive the way `plan()`'s is.
+ * Reproduce the value a `Pin` describes against the built Fabricator it was
+ * planned from. `pin === undefined` is universal — `plan()` gave this node a
+ * width-1 axis, so there is nothing to pin and it fabricates normally. Every
+ * other case only arises for kinds `plan()` treats as enumerable axes, so this
+ * switch does not need to be exhaustive the way `plan()`'s is.
  */
 export declare function resolve(node: Resolvable, pin: Pin): unknown;
 export {};