@ghostry/fabricator 0.0.1 → 0.0.3

package/dist/types/Primitive/symbol/Registry.d.ts

@@ -1,16 +1,9 @@
 import type { Adaptations } from "../../Adapter/Types";
-import { Adaptation, Kind, Meta, Produces } from "../../Types";
 import { Schema } from "./Schema";
-import type { Fabricated } from "./Types";
-declare const _default: {
-    [Kind]: "symbol";
-    [Meta]: {};
-    [Produces]?: Fabricated;
-    [Adaptation]?: Adaptations;
-    as: (produce: import("../../Random/Types").Produce<Fabricated>) => Schema<{}, Adaptations>;
-    adapt: <const $Adapter extends import("../..").Adapter, $Returnable extends ReturnType<$Adapter["convert"]>>(adapter: $Adapter, produce: (adapting: import("../..").Adapting<Schema<{}, Adaptations>>) => $Returnable) => Schema<{}, import("../../Adapter/Types").WithAdaptations<Adaptations, import("../../Adapter/Core").AdaptationEntry<$Adapter, $Returnable>>>;
+type ThisRegistry = Schema<{}, Adaptations> & {
     keyed: (key: string) => Schema<{
         key: string;
-    }, {}>;
+    }>;
 };
-export default _default;
+declare const registry: ThisRegistry;
+export default registry;

package/dist/types/Primitive/symbol/Schema.d.ts

@@ -3,10 +3,10 @@ import type { Adaptations, Adapter, Adapting, WithAdaptations } from "../../Adap
 import type { Produce } from "../../Random/Types";
 import type { Core, Fabricated, Meta as ThisMeta } from "./Types";
 /**
- * `$Meta` is generic (defaulting to the full `Meta` union) so builder
- * return types stay narrow — see `number/Schema.ts`. `$Adaptations` is
- * threaded through every builder method for the same reason — see
- * `string/Schema.ts`'s `adapt`.
+ * `$Meta` is generic (defaulting to the full `Meta` union) so builder return
+ * types stay narrow — see `number/Schema.ts`. `$Adaptations` is threaded
+ * through every builder method for the same reason — see `string/Schema.ts`'s
+ * `adapt`.
  */
 export interface Schema<$Meta extends ThisMeta = ThisMeta, $Adaptations extends Adaptations = {}> extends Core<$Meta, $Adaptations> {
     /**
@@ -16,8 +16,8 @@ export interface Schema<$Meta extends ThisMeta = ThisMeta, $Adaptations extends
      */
     as: (produce: Produce<Fabricated>) => Schema<$Meta, $Adaptations>;
     /**
-     * Override what this schema maps to in one or more external schema
-     * libraries — see `string/Schema.ts`'s `adapt` for the full contract.
+     * Override what this schema maps to in one or more external schema libraries
+     * — see `string/Schema.ts`'s `adapt` for the full contract.
      */
     adapt: <const $Adapter extends Adapter, $Returnable extends ReturnType<$Adapter["convert"]>>(adapter: $Adapter, produce: (adapting: Adapting<Schema<$Meta, $Adaptations>>) => $Returnable) => Schema<$Meta, WithAdaptations<$Adaptations, AdaptationEntry<$Adapter, $Returnable>>>;
 }

package/dist/types/Primitive/symbol/Types.d.ts

@@ -4,8 +4,8 @@ import type { Adaptation, Kind, Meta, Produces } from "../../Types";
 export type Fabricated = symbol;
 /**
  * A symbol keyed via `keyed`, or unkeyed if `key` is absent, optionally
- * overridden by an opaque `as` production — carried alongside `key` rather
- * than replacing it, so a prior keying survives `as` for future validation.
+ * overridden by an opaque `as` production — carried alongside `key` rather than
+ * replacing it, so a prior keying survives `as` for future validation.
  */
 export type Meta = {
     key?: string;

package/dist/types/Primitive/tuple/Fabricator.d.ts

@@ -20,18 +20,17 @@ export type Fabricator<$Schema extends {
     schema: Schema<$Schema[typeof Meta]["items"], AdaptationsOf<$Schema>>;
 };
 /**
- * `elements` are each slot's *already-dispatched* Fabricator, one per
+ * `elements` are each slot's _already-dispatched_ Fabricator, one per
  * `[Meta].items` entry, built by `Constructor.ts`'s `make` before this call —
  * mirrors `choice.Fabricator`'s `weightings`, one per option, rather than
  * `array.Fabricator`'s single shared `element`. The `array`/`tuple`
- * distinction: each slot gets its own private stream, so
- * `T.tuple([T.number, T.number])` behaves like a two-field `object` of
- * numbers, not a length-2 `array` of numbers (every element drawn
- * sequentially off one shared stream).
+ * distinction: each slot gets its own private stream, so `T.tuple([T.number,
+ * T.number])` behaves like a two-field `object` of numbers, not a length-2
+ * `array` of numbers (every element drawn sequentially off one shared stream).
  *
  * `toStreamFromTrace` is only consulted on the `.as(...)`-overridden path: an
- * ordinary tuple draws no randomness of its own — every draw belongs to a
- * slot, exactly like `object`. `trace` is still recorded so a nested
- * tuple can be replayed from its own schema.
+ * ordinary tuple draws no randomness of its own — every draw belongs to a slot,
+ * exactly like `object`. `trace` is still recorded so a nested tuple can be
+ * replayed from its own schema.
  */
 export declare function Fabricator<$Items extends Items>(context: FabricatorContext<Schema<$Items>>, elements: ReadonlyArray<NaiveFabricator<any>>): Fabricator<Schema<$Items>>;

package/dist/types/Primitive/tuple/Schema.d.ts

@@ -4,9 +4,9 @@ import type { Produce } from "../../Random/Types";
 import type { Core, Fabricated, Items } from "./Types";
 /**
  * Buildable `tuple` recipe: a fixed-length list of slot schemas, each
- * fabricated independently — see `Fabricator.ts` for why that independence
- * (one Fabricator per slot, not one reused across slots like `array`'s
- * single element) is the defining difference from `array`.
+ * fabricated independently — see `Fabricator.ts` for why that independence (one
+ * Fabricator per slot, not one reused across slots like `array`'s single
+ * element) is the defining difference from `array`.
  */
 export interface Schema<$Items extends Items = Items, $Adaptations extends Adaptations = {}> extends Core<$Items, $Adaptations> {
     /**
@@ -16,8 +16,8 @@ export interface Schema<$Items extends Items = Items, $Adaptations extends Adapt
      */
     as: (produce: Produce<Fabricated<$Items>>) => Schema<$Items, $Adaptations>;
     /**
-     * Override what this schema maps to in one or more external schema
-     * libraries — see `string/Schema.ts`'s `adapt` for the full contract.
+     * Override what this schema maps to in one or more external schema libraries
+     * — see `string/Schema.ts`'s `adapt` for the full contract.
      */
     adapt: <const $Adapter extends Adapter, $Returnable extends ReturnType<$Adapter["convert"]>>(adapter: $Adapter, produce: (adapting: Adapting<Schema<$Items, $Adaptations>>) => $Returnable) => Schema<$Items, WithAdaptations<$Adaptations, AdaptationEntry<$Adapter, $Returnable>>>;
 }

package/dist/types/Primitive/tuple/Types.d.ts

@@ -5,40 +5,39 @@ import type { Adaptation, Kind, Meta, Produces } from "../../Types";
 /** The schema occupying a single tuple slot. */
 export type Item = AnySchema;
 /**
- * A *tuple* of schemas, one per slot — not a flattened `ReadonlyArray`, for
- * the same reason `choice.Items` isn't (see its doc): a widened array
- * remembers only the union of every slot's type and loses arity and which
- * slot held what. The real tuple is what lets `Fabricated` resolve to
- * positional `[A, B]` rather than `(A | B)[]`, and `Adapter/TypeBox` produce
- * a `TTuple` of the right length.
+ * A _tuple_ of schemas, one per slot — not a flattened `ReadonlyArray`, for the
+ * same reason `choice.Items` isn't (see its doc): a widened array remembers
+ * only the union of every slot's type and loses arity and which slot held what.
+ * The real tuple is what lets `Fabricated` resolve to positional `[A, B]`
+ * rather than `(A | B)[]`, and `Adapter/TypeBox` produce a `TTuple` of the
+ * right length.
  */
 export type Items = ReadonlyArray<Item>;
 /**
- * Head/tail recursion, not a homomorphic `{ [$K in keyof $Items]: ... }`
- * mapped type — the same trap `Adapter/TypeBox`'s `ChoiceOptions`/
- * `TupleItems` avoid: `keyof` a still-abstract `ReadonlyArray<Item>` (this
- * type's default, and what a kind-local `Fabrication<$Fabricator>` resolves
- * against for the *bare*, unparameterized `Fabricator`) pulls in
- * `"length"`/method keys that don't resolve to a sensible `ValueOf`. A
- * homomorphic version type-checks for any concrete tuple but silently
- * produces a malformed bare type, which then fails `.schema.as`'s
- * contravariant parameter check against any concrete instantiation
- * (`Fabrication.types.test.ts`). Matching a fixed-length tuple pattern at
- * every step avoids it, as `TupleItems` does for `ToTypeBox`. The fallback
- * (a genuinely widened, arity-less array) is a plain `Array<...>`, mirroring
- * `array.Fabricated` for the same bare case.
+ * Head/tail recursion, not a homomorphic `{ [$K in keyof $Items]: ... }` mapped
+ * type — the same trap `Adapter/TypeBox`'s `ChoiceOptions`/ `TupleItems` avoid:
+ * `keyof` a still-abstract `ReadonlyArray<Item>` (this type's default, and what
+ * a kind-local `Fabrication<$Fabricator>` resolves against for the _bare_,
+ * unparameterized `Fabricator`) pulls in `"length"`/method keys that don't
+ * resolve to a sensible `ValueOf`. A homomorphic version type-checks for any
+ * concrete tuple but silently produces a malformed bare type, which then fails
+ * `.schema.as`'s contravariant parameter check against any concrete
+ * instantiation (`Fabrication.types.test.ts`). Matching a fixed-length tuple
+ * pattern at every step avoids it, as `TupleItems` does for `ToTypeBox`. The
+ * fallback (a genuinely widened, arity-less array) is a plain `Array<...>`,
+ * mirroring `array.Fabricated` for the same bare case.
  */
 export type Fabricated<$Items extends Items = Items, $Bindings extends unknown[] = []> = $Items extends readonly [] ? [] : $Items extends readonly [
     infer $Head extends Item,
     ...infer $Rest extends Items
 ] ? [ValueOf<$Head, $Bindings>, ...Fabricated<$Rest, $Bindings>] : Array<ValueOf<$Items[number], $Bindings>>;
 /**
- * No `whereby`: arity is fixed at `T.tuple([...])` and there is nothing left
- * to configure. Unlike `array`'s two-variant union this needs no
- * "config or produce" split — `produce` is a plain optional layered on top,
- * and `items` stays required so `extend`-less kinds still have the per-slot
- * shapes `ToTypeBox` derives from (and future validation of `produce` would
- * check against).
+ * No `whereby`: arity is fixed at `T.tuple([...])` and there is nothing left to
+ * configure. Unlike `array`'s two-variant union this needs no "config or
+ * produce" split — `produce` is a plain optional layered on top, and `items`
+ * stays required so `extend`-less kinds still have the per-slot shapes
+ * `ToTypeBox` derives from (and future validation of `produce` would check
+ * against).
  */
 export type Meta<$Items extends Items = Items> = {
     items: $Items;

package/dist/types/Primitive/undefinable/Fabricator.d.ts

@@ -19,13 +19,13 @@ export type Fabricator<$Schema extends {
     fabricate: () => Fabricated<$Schema[typeof Meta]["definition"]>;
 };
 /**
- * A presence roll on this field's private stream, drawn only when the
- * wrapped value is needed — an `undefined` roll never advances `source`'s
- * stream, and since `source` is already dispatched into its own independent
- * stream by `Constructor.ts` regardless of this roll, skipping its draw
- * here can never perturb any other field's reproducibility (see
+ * A presence roll on this field's private stream, drawn only when the wrapped
+ * value is needed — an `undefined` roll never advances `source`'s stream, and
+ * since `source` is already dispatched into its own independent stream by
+ * `Constructor.ts` regardless of this roll, skipping its draw here can never
+ * perturb any other field's reproducibility (see
  * `object/omittable/Fabricator.ts`, and CLAUDE.md's "Randomness"). 50/50 by
- * default; `.weighted(...)` (`Schema.ts`) reweights either outcome relative
- * to that same default of `1`.
+ * default; `.weighted(...)` (`Schema.ts`) reweights either outcome relative to
+ * that same default of `1`.
  */
 export declare function Fabricator<$Definition extends Definition>(context: FabricatorContext<Schema<$Definition>>, source: BaseFabricator<any>): Fabricator<Schema<$Definition>>;

package/dist/types/Primitive/undefinable/Schema.d.ts

@@ -4,31 +4,31 @@ import type { Produce } from "../../Random/Types";
 import type { AnySchema } from "../../Schema/Types";
 import type { Core, Definition, Fabricated, Weights } from "./Types";
 /**
- * The buildable recipe for an `undefinable`: a single wrapped Schema, drawn
- * (or not) each fabrication.
+ * The buildable recipe for an `undefinable`: a single wrapped Schema, drawn (or
+ * not) each fabrication.
  */
 export interface Schema<$Definition extends Definition = Definition, $Adaptations extends Adaptations = {}> extends Core<$Definition, $Adaptations> {
     /**
      * Layer an opaque production on this schema's existing `[Meta]` — carrying
-     * `definition` forward, not discarding it, so a later `.as(...)` (or
-     * future validation of `produce`) still has it to check against.
-     * `produce` may return `undefined`, so custom logic composes the same way
-     * the built-in roll does.
+     * `definition` forward, not discarding it, so a later `.as(...)` (or future
+     * validation of `produce`) still has it to check against. `produce` may
+     * return `undefined`, so custom logic composes the same way the built-in roll
+     * does.
      */
     as: (produce: Produce<Fabricated<$Definition>>) => Schema<$Definition, $Adaptations>;
     /**
-     * Reweight the built-in 50/50 roll. Keys are optional — an omitted key
-     * keeps baseline weight `1`, the same weight the 50/50 split already uses
-     * — but that baseline is still relative to whatever else is specified, so
+     * Reweight the built-in 50/50 roll. Keys are optional — an omitted key keeps
+     * baseline weight `1`, the same weight the 50/50 split already uses — but
+     * that baseline is still relative to whatever else is specified, so
      * `.weighted({ undefined: 0.1 })` shifts both outcomes' shares, not just
      * `undefined`'s (see `Types.ts`'s `Weights`). Chaining `.weighted(...)`
-     * merges into previous weights rather than replacing them, the same
-     * layering `.as(...)` uses for `produce`.
+     * merges into previous weights rather than replacing them, the same layering
+     * `.as(...)` uses for `produce`.
      */
     weighted: (weights: Weights) => Schema<$Definition, $Adaptations>;
     /**
-     * Override what this schema maps to in one or more external schema
-     * libraries — see `string/Schema.ts`'s `adapt` for the full contract.
+     * Override what this schema maps to in one or more external schema libraries
+     * — see `string/Schema.ts`'s `adapt` for the full contract.
      */
     adapt: <const $Adapter extends Adapter, $Returnable extends ReturnType<$Adapter["convert"]>>(adapter: $Adapter, produce: (adapting: Adapting<Schema<$Definition, $Adaptations>>) => $Returnable) => Schema<$Definition, WithAdaptations<$Adaptations, AdaptationEntry<$Adapter, $Returnable>>>;
 }

package/dist/types/Primitive/undefinable/Types.d.ts

@@ -7,19 +7,19 @@ export type Definition = AnySchema;
 export type Fabricated<$Definition extends Definition, $Bindings extends unknown[] = []> = ValueOf<$Definition, $Bindings> | undefined;
 export type { Outcome } from "./Outcomes";
 /**
- * Relative weights for `.weighted(...)`, keyed by `Outcome`. Keys optional —
- * an omitted key falls back to baseline `1`, the same weight the 50/50
- * split already uses. Values are relative, exactly like `weighted()`
+ * Relative weights for `.weighted(...)`, keyed by `Outcome`. Keys optional — an
+ * omitted key falls back to baseline `1`, the same weight the 50/50 split
+ * already uses. Values are relative, exactly like `weighted()`
  * (`Distribution/index.ts`) — they need not sum to one, and are fed to
  * `weighted()` unchanged alongside each unspecified key's baseline `1`.
  *
- * Specifying one outcome's weight shifts the *other* outcome's resulting
- * probability too, even though its weight stays at `1` — its share of the
- * total still moves, since the total changed. `.weighted({ undefined: 0.1 })`
- * is not "10% undefined, 90% present" — with `value` at default `1`, the
- * split is `0.1 / 1.1 ≈ 9.1%` undefined, `≈90.9%` value. No independent
- * "absolute probability" mode; weights are only meaningful relative to the
- * full set in play.
+ * Specifying one outcome's weight shifts the _other_ outcome's resulting
+ * probability too, even though its weight stays at `1` — its share of the total
+ * still moves, since the total changed. `.weighted({ undefined: 0.1 })` is not
+ * "10% undefined, 90% present" — with `value` at default `1`, the split is `0.1
+ * / 1.1 ≈ 9.1%` undefined, `≈90.9%` value. No independent "absolute
+ * probability" mode; weights are only meaningful relative to the full set in
+ * play.
  */
 export type Weights = {
     undefined: number;

package/dist/types/Primitive/undefined/Registry.d.ts

@@ -1,3 +1,3 @@
 import { Schema } from "./Schema";
-declare const _default: Schema<{}>;
-export default _default;
+declare const registry: Schema;
+export default registry;

package/dist/types/Primitive/undefined/Schema.d.ts

@@ -3,13 +3,13 @@ import type { Adaptations, Adapter, Adapting, WithAdaptations } from "../../Adap
 import type { Core, Meta as ThisMeta } from "./Types";
 /**
  * Nothing to configure (see `Types.ts`'s `Meta`), so `adapt` is this kind's
- * only builder method — an external library that spells "undefined"
- * differently still needs a way to say so.
+ * only builder method — an external library that spells "undefined" differently
+ * still needs a way to say so.
  */
 export interface Schema<$Adaptations extends Adaptations = {}> extends Core<ThisMeta, $Adaptations> {
     /**
-     * Override what this schema maps to in one or more external schema
-     * libraries — see `string/Schema.ts`'s `adapt` for the full contract.
+     * Override what this schema maps to in one or more external schema libraries
+     * — see `string/Schema.ts`'s `adapt` for the full contract.
      */
     adapt: <const $Adapter extends Adapter, $Returnable extends ReturnType<$Adapter["convert"]>>(adapter: $Adapter, produce: (adapting: Adapting<Schema<$Adaptations>>) => $Returnable) => Schema<WithAdaptations<$Adaptations, AdaptationEntry<$Adapter, $Returnable>>>;
 }

package/dist/types/Primitive/undefined/Types.d.ts

@@ -2,9 +2,9 @@ import type { Adaptations } from "../../Adapter/Types";
 import type { Adaptation, Kind, Meta, Produces } from "../../Types";
 export type Fabricated = undefined;
 /**
- * Nothing to configure: `undefined` has exactly one possible value, so
- * there is no `.as()` (see `always/Types.ts` for the same reasoning) and
- * no other knob to carry.
+ * Nothing to configure: `undefined` has exactly one possible value, so there is
+ * no `.as()` (see `always/Types.ts` for the same reasoning) and no other knob
+ * to carry.
  */
 export type Meta = Record<string, never>;
 export type Core<$Meta extends Meta = Meta, $Adaptations extends Adaptations = {}> = {

package/dist/types/Random/Generator/sfc32.d.ts

@@ -1,9 +1,9 @@
 import type { NumberGenerator } from "../Types";
 /**
- * sfc32 ("Small Fast Counter"): a 128-bit-state PRNG that is fast, compact,
- * and statistically strong (passes both PractRand and TestU01 BigCrush).
- * Each call advances the state and returns the top 32 bits scaled into
- * `[0, 1)`. Non-cryptographic: never use this for secrets or tokens.
+ * sfc32 ("Small Fast Counter"): a 128-bit-state PRNG that is fast, compact, and
+ * statistically strong (passes both PractRand and TestU01 BigCrush). Each call
+ * advances the state and returns the top 32 bits scaled into `[0, 1)`.
+ * Non-cryptographic: never use this for secrets or tokens.
  *
  * @see https://stackoverflow.com/a/47593316
  */