@ghostry/fabricator 0.0.1 → 0.0.2

package/dist/types/Primitive/recursive/self/Types.d.ts

@@ -2,15 +2,14 @@ import type { Adaptations } from "../../../Adapter/Types";
 import { Produces, type Adaptation, type Kind, type Meta } from "../../../Types";
 /**
  * The value a `self` reference resolves to at this position — whatever the
- * enclosing `T.recursive`'s current expansion binds it to. Reads
- * `bindings[0]`, the analogue of TypeBox's `TThis` reading
- * `this['params'][0]`; see `Schema/Types.ts`'s `ValueOf` for what
- * `bindings` is and why it's a tuple.
+ * enclosing `T.recursive`'s current expansion binds it to. Reads `bindings[0]`,
+ * the analogue of TypeBox's `TThis` reading `this['params'][0]`; see
+ * `Schema/Types.ts`'s `ValueOf` for what `bindings` is and why it's a tuple.
  *
- * Unlike every other kind, `self` has no type parameter of its own — its
- * whole value comes from outside, threaded in structurally by whatever
- * composite kinds wrap it (`recursive/Types.ts`'s `RecursiveValue` is what
- * ultimately supplies `bindings[0]`).
+ * Unlike every other kind, `self` has no type parameter of its own — its whole
+ * value comes from outside, threaded in structurally by whatever composite
+ * kinds wrap it (`recursive/Types.ts`'s `RecursiveValue` is what ultimately
+ * supplies `bindings[0]`).
  */
 export type Fabricated<$Bindings extends unknown[] = []> = $Bindings[0];
 export type Meta = Record<string, never>;

package/dist/types/Primitive/string/Constants.d.ts

@@ -1,14 +1,13 @@
 import type { CodepointRange } from "./Types";
 /**
- * Unicode code point ranges for spanning the codespace — a fuzzing aid
- * for exercising input far outside ordinary text. Use a preset or build
- * an arbitrary inclusive range with `range(from, to)`.
+ * Unicode code point ranges for spanning the codespace — a fuzzing aid for
+ * exercising input far outside ordinary text. Use a preset or build an
+ * arbitrary inclusive range with `range(from, to)`.
  *
- * Lives here rather than `Types.ts` so that file stays type-only. A
- * value export alongside `export type Fabricated = string` makes the
- * module a value module, and `export * as string` in
- * `Primitive/namespace.ts` then resolves `string` to the namespace —
- * a cycle that drops `[Kind]`/`[Meta]` off `Core`.
+ * Lives here rather than `Types.ts` so that file stays type-only. A value
+ * export alongside `export type Fabricated = string` makes the module a value
+ * module, and `export * as string` in `Primitive/namespace.ts` then resolves
+ * `string` to the namespace — a cycle that drops `[Kind]`/`[Meta]` off `Core`.
  */
 export declare const unicode: {
     /**
@@ -24,8 +23,8 @@ export declare const unicode: {
     }[];
     /**
      * The entire Unicode codespace, U+0000–U+10FFFF, including the surrogate
-     * block — so it can yield lone surrogates and thus ill-formed UTF-16.
-     * Opt in for lone surrogates and other ill-formed UTF-16 when fuzzing.
+     * block — so it can yield lone surrogates and thus ill-formed UTF-16. Opt in
+     * for lone surrogates and other ill-formed UTF-16 when fuzzing.
      */
     codespace: {
         from: number;
@@ -45,9 +44,9 @@ export declare const unicode: {
     range: (from: number, to: number) => CodepointRange;
 };
 /**
- * The built-in character classes as code point ranges, each an alias for
- * the code point ranges it spans. For use in the `[weight, source]` form
- * of `composition` (e.g. mixing a class with a Unicode range).
+ * The built-in character classes as code point ranges, each an alias for the
+ * code point ranges it spans. For use in the `[weight, source]` form of
+ * `composition` (e.g. mixing a class with a Unicode range).
  */
 export declare const classes: {
     lowercase: ReadonlyArray<CodepointRange>;

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

@@ -18,7 +18,7 @@ export type Fabricator<$Schema extends {
 };
 /**
  * Turn a `string` Schema into a live Fabricator — the one place this kind's
- * character-generation logic actually runs. `Constructor.ts` calls this once per
- * `construct()`, never from inside the returned `fabricate`.
+ * character-generation logic actually runs. `Constructor.ts` calls this once
+ * per `construct()`, never from inside the returned `fabricate`.
  */
 export declare function Fabricator(context: FabricatorContext<Schema>): Fabricator;

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

@@ -1,12 +1,12 @@
 import type { Produce } from "../../Random/Types";
 import { Kind } from "../../Types";
 import { Schema } from "./Schema";
-import type { Fabricated, InputWhereby, JsonSchema } from "./Types";
+import type { Fabricated, InputWhereby, JsonSchema, Whereby } from "./Types";
 declare const _default: {
     /**
-     * The builder carries the primitive's `[Kind]` so it can be named directly
-     * as a `compute` source — which derives its schema by kind — without
-     * first satisfying a `whereby`.
+     * The builder carries the primitive's `[Kind]` so it can be named directly as
+     * a `compute` source — which derives its schema by kind — without first
+     * satisfying a `whereby`.
      */
     [Kind]: "string";
     /**
@@ -15,9 +15,9 @@ declare const _default: {
      * (e.g. `toTypeBox`) read.
      */
     as: (produce: Produce<Fabricated>, hints?: JsonSchema) => Schema<{
-        produce: Produce<string>;
+        produce: Produce<Fabricated>;
         hints: JsonSchema | undefined;
-    }, {}>;
+    }>;
     /**
      * A string whose length falls uniformly within `[length.min, length.max]`;
      * `length.min` defaults to inclusive 0. Exclusive ends use a Bound object.
@@ -28,17 +28,11 @@ declare const _default: {
      * `length` counts UTF-16 code units, so the result's `.length` equals the
      * chosen length exactly. When the composition cannot fill the final code
      * units — e.g. only astral, two-unit characters remain for a one-unit gap —
-     * the gap is topped up with a well-formed BMP character outside the
-     * requested `composition`, inserted at a random character boundary.
+     * the gap is topped up with a well-formed BMP character outside the requested
+     * `composition`, inserted at a random character boundary.
      */
     whereby: (whereby: InputWhereby) => Schema<{
-        whereby: {
-            length: {
-                min: import("../..").Bound<number>;
-                max: import("../..").Bound<number>;
-            };
-            composition?: import("./Types").Composition;
-        };
-    }, {}>;
+        whereby: Whereby;
+    }>;
 };
 export default _default;

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

@@ -4,13 +4,13 @@ import type { Produce } from "../../Random/Types";
 import type { Core, Fabricated, JsonSchema, Meta as ThisMeta } from "./Types";
 /**
  * Buildable `string` recipe: length/composition (`whereby` — required, unlike
- * `number`/`date`; no natural bound to fuzz a length to), or opaque
- * production via `as`.
+ * `number`/`date`; no natural bound to fuzz a length to), or opaque production
+ * via `as`.
  *
  * `$Meta` is generic (defaulting to the full `Meta` union) so builder return
- * types stay narrow — see `number/Schema.ts`. `$Adaptations` is generic for
- * the same reason, threaded through every builder method so an adaptation
- * survives chaining (see `adapt`).
+ * types stay narrow — see `number/Schema.ts`. `$Adaptations` is generic for the
+ * same reason, threaded through every builder method so an adaptation survives
+ * chaining (see `adapt`).
  */
 export interface Schema<$Meta extends ThisMeta = ThisMeta, $Adaptations extends Adaptations = {}> extends Core<$Meta, $Adaptations> {
     /**

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

@@ -9,19 +9,19 @@ export type CodepointRange = {
     to: number;
 };
 /**
- * The single mechanism every character is drawn from: one or more code
- * point ranges. A literal string is accepted as shorthand for the ranges
- * of its individual characters, so custom pools, the built-in classes, and
- * the Unicode codespace are all the same thing under the hood.
+ * The single mechanism every character is drawn from: one or more code point
+ * ranges. A literal string is accepted as shorthand for the ranges of its
+ * individual characters, so custom pools, the built-in classes, and the Unicode
+ * codespace are all the same thing under the hood.
  */
 export type CharacterSource = string | CodepointRange | ReadonlyArray<CodepointRange>;
 export type CharacterClass = keyof typeof classes;
 /**
- * How a string's characters should be composed: a weighting over the
- * built-in classes by name, or explicit `[weight, source]` pairs over
- * arbitrary character sources. Each character independently picks a source
- * by weight, then a code point uniformly across that source's ranges — so
- * the weights describe expected composition, not per-character uniformity.
+ * How a string's characters should be composed: a weighting over the built-in
+ * classes by name, or explicit `[weight, source]` pairs over arbitrary
+ * character sources. Each character independently picks a source by weight,
+ * then a code point uniformly across that source's ranges — so the weights
+ * describe expected composition, not per-character uniformity.
  */
 export type Composition = Partial<Record<CharacterClass, number>> | ReadonlyArray<[number, CharacterSource]>;
 export type InputWhereby = {
@@ -41,9 +41,9 @@ export type Whereby = {
 export type Fabricated = string;
 /**
  * JSON-Schema keywords that constrain a string value — carried as neutral,
- * schema-library-agnostic hints (see the builder's `as`). Adapters forward
- * them to their target: `toTypeBox` to `Type.String(...)`, a future `toZod`
- * to `z.string()` refinements, etc.
+ * schema-library-agnostic hints (see the builder's `as`). Adapters forward them
+ * to their target: `toTypeBox` to `Type.String(...)`, a future `toZod` to
+ * `z.string()` refinements, etc.
  *
  * Length lives on `whereby` as Bound pairs, which adapters forward as
  * `minLength`/`maxLength`; `hints` never duplicates it — these are the
@@ -54,11 +54,11 @@ export type JsonSchema = {
     pattern?: string;
 };
 /**
- * A length/composition, drawn via `whereby` — no natural bound to fuzz to,
- * so unlike `number`/`date` there's no bare form — optionally overridden
- * by an opaque `as` production, carried alongside `whereby` rather than
- * replacing it (when `whereby` was already set) so a prior
- * length/composition survives `as` for future validation.
+ * A length/composition, drawn via `whereby` — no natural bound to fuzz to, so
+ * unlike `number`/`date` there's no bare form — optionally overridden by an
+ * opaque `as` production, carried alongside `whereby` rather than replacing it
+ * (when `whereby` was already set) so a prior length/composition survives `as`
+ * for future validation.
  */
 export type Meta = {
     whereby: Whereby;

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

@@ -18,7 +18,7 @@ export type Fabricator<$Schema extends {
 };
 /**
  * A bare symbol draws no randomness at all — `Symbol(meta.key)` is
- * deterministic — so only the `.as(...)`-overridden path ever obtains a
- * stream. The bare path still records `trace`, like every other node.
+ * deterministic — so only the `.as(...)`-overridden path ever obtains a stream.
+ * The bare path still records `trace`, like every other node.
  */
 export declare function Fabricator(context: FabricatorContext<Schema>): Fabricator;

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 = {}> = {