@ghostry/fabricator 0.0.1 → 0.0.3

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

@@ -8,10 +8,10 @@ export type Definition<$Schema = AnySchema> = {
     [_ in string]: $Schema;
 };
 /**
- * Constraint for a refinement's values. The source schema differs per
- * property, so it must be `any` (not `AnySchema`) to stay assignable across
- * every property's own `$Source`. Constraint only: precise types still flow
- * via `$Refinement`.
+ * Constraint for a refinement's values. The source schema differs per property,
+ * so it must be `any` (not `AnySchema`) to stay assignable across every
+ * property's own `$Source`. Constraint only: precise types still flow via
+ * `$Refinement`.
  */
 export type Refinement<$Definition extends Definition> = Definition<ComputeSchema<Fabricated<$Definition>, any>>;
 export type Extender<$Definition extends Definition, $Extension extends Definition> = (params: {
@@ -21,12 +21,11 @@ export type Refinements = ReadonlyArray<Definition>;
 /**
  * Every `object.omittable`- or `object.optional`-kind field's key, so
  * `Fabricated` can mark exactly those `?:` instead of required — matching
- * runtime, where a field whose roll lands on omission never has its key
- * appear (`object/omittable/Fabricator.ts`, `object/optional/Fabricator.ts`).
+ * runtime, where a field whose roll lands on omission never has its key appear
+ * (`object/omittable/Fabricator.ts`, `object/optional/Fabricator.ts`).
  * `object.optional`'s `ValueOf` already carries `| undefined` (its
- * `Fabricated`), so combined with the `?:` here a field lands on
- * `{ a?: T | undefined }` — omitted, present-as-`undefined`, or
- * present-with-a-value.
+ * `Fabricated`), so combined with the `?:` here a field lands on `{ a?: T |
+ * undefined }` — omitted, present-as-`undefined`, or present-with-a-value.
  */
 type OmittableKeys<$Definition extends Definition> = {
     [$K in keyof $Definition]: $Definition[$K] extends {
@@ -39,19 +38,18 @@ export type Fabricated<$Definition extends Definition, $Bindings extends unknown
     [$K in OmittableKeys<$Definition>]?: ValueOf<$Definition[$K], $Bindings>;
 }>;
 /**
- * The shape `.override()` accepts: every field optional, so a present key
- * skips generation for that field. A nested `object`-kind field recurses
- * into its own `Override` (deep-merge); an `object.omittable` or
- * `object.optional` field additionally accepts `Omitted`, to force that
- * field off rather than only forcing a value on (`object.optional` already
- * accepts `undefined` via `ValueOf`); every other field — including
- * `object.compute` — is a full-replacement leaf, typed as whatever it
- * fabricates to (`ValueOf`).
+ * The shape `.override()` accepts: every field optional, so a present key skips
+ * generation for that field. A nested `object`-kind field recurses into its own
+ * `Override` (deep-merge); an `object.omittable` or `object.optional` field
+ * additionally accepts `Omitted`, to force that field off rather than only
+ * forcing a value on (`object.optional` already accepts `undefined` via
+ * `ValueOf`); every other field — including `object.compute` — is a
+ * full-replacement leaf, typed as whatever it fabricates to (`ValueOf`).
  *
  * Checked via a bare structural `[Kind]`/`[Meta]` shape, never `Schema`/
- * `Fabricator` — either carries `refine`'s contravariant use of
- * `$Definition`, and referencing it here would leak that contravariance
- * into every recursive `Override` instantiation.
+ * `Fabricator` — either carries `refine`'s contravariant use of `$Definition`,
+ * and referencing it here would leak that contravariance into every recursive
+ * `Override` instantiation.
  */
 export type Override<$Definition extends Definition> = Pretty<{
     [$K in keyof $Definition]?: $Definition[$K] extends {
@@ -64,8 +62,8 @@ export type Override<$Definition extends Definition> = Pretty<{
     } ? ValueOf<$Definition[$K]> | typeof Omitted : ValueOf<$Definition[$K]>;
 }>;
 /**
- * `definition`/`refinements` stay required regardless of `produce` — an
- * opaque `as` production layers on top rather than replacing them, so
+ * `definition`/`refinements` stay required regardless of `produce` — an opaque
+ * `as` production layers on top rather than replacing them, so
  * `extend`/`refine`/`override` and `ToTypeBox`'s structural derivation keep
  * working, and a prior definition survives `as` for future validation of
  * `produce`.

package/dist/types/Primitive/object/compute/Fabricator.d.ts

@@ -22,10 +22,9 @@ export type Fabricator<$Fabricated, $Source extends Source, $Adaptations extends
 export declare function isObjectComputeFabricator(candidate: BaseFabricator<unknown>): candidate is Fabricator<unknown, Source>;
 /**
  * Turn an `object.compute` Schema into a live Fabricator. Unlike every other
- * kind, there's nothing of `source` to build here — a computed field's
- * value comes entirely from `resolve`, given the rest of the object. The
- * node still records `trace` so it can be rebuilt from a parent field's
- * captured trace; `.fabricate()` without the parent object throws
- * `DetachedComputeError`.
+ * kind, there's nothing of `source` to build here — a computed field's value
+ * comes entirely from `resolve`, given the rest of the object. The node still
+ * records `trace` so it can be rebuilt from a parent field's captured trace;
+ * `.fabricate()` without the parent object throws `DetachedComputeError`.
  */
 export declare function Fabricator<$Fabricated, $Source extends Source>(context: FabricatorContext<Schema<$Fabricated, $Source>>): Fabricator<$Fabricated, $Source>;

package/dist/types/Primitive/object/compute/Schema.d.ts

@@ -10,10 +10,10 @@ export type Computer<$Definition extends object.Definition> = <const $Source ext
 };
 export interface Schema<$Fabricated, $Source extends Source, $Adaptations extends Adaptations = {}> extends Core<$Fabricated, $Source, $Adaptations> {
     /**
-     * Override what this schema maps to in one or more external schema
-     * libraries — see `string/Schema.ts`'s `adapt` for the full contract.
-     * Adapting the computed field itself, rather than the `source` it derives
-     * its shape from, is the way to say the two differ.
+     * Override what this schema maps to in one or more external schema libraries
+     * — see `string/Schema.ts`'s `adapt` for the full contract. Adapting the
+     * computed field itself, rather than the `source` it derives its shape from,
+     * is the way to say the two differ.
      */
     adapt: <const $Adapter extends Adapter, $Returnable extends ReturnType<$Adapter["convert"]>>(adapter: $Adapter, produce: (adapting: Adapting<Schema<$Fabricated, $Source, $Adaptations>>) => $Returnable) => Schema<$Fabricated, $Source, WithAdaptations<$Adaptations, AdaptationEntry<$Adapter, $Returnable>>>;
 }

package/dist/types/Primitive/object/compute/Types.d.ts

@@ -3,22 +3,22 @@ import type { AnySchema, ValueOf } from "../../../Schema/Types";
 import { Kind, type Adaptation, type Meta, type Produces } from "../../../Types";
 /**
  * A builder that can mint a Schema via `as` — e.g. `T.string`, `T.bigint`.
- * `compute` accepts one alongside a plain Schema so a caller needn't
- * satisfy a `whereby` just to name a computed field's type: the resolver
- * supplies the value, so the field's length/range is irrelevant.
+ * `compute` accepts one alongside a plain Schema so a caller needn't satisfy a
+ * `whereby` just to name a computed field's type: the resolver supplies the
+ * value, so the field's length/range is irrelevant.
  */
 export type Builder<$Schema extends AnySchema = AnySchema> = {
     [Kind]: $Schema[typeof Kind];
     as: (produce: () => any) => $Schema;
 };
 /**
- * A `compute` source: the Schema whose value and shape a computed field
- * adopts, or a builder that denotes one.
+ * A `compute` source: the Schema whose value and shape a computed field adopts,
+ * or a builder that denotes one.
  */
 export type Source = AnySchema | Builder;
 /**
- * The Schema a source denotes: a plain Schema is itself; a builder is
- * the Schema its `as` mints.
+ * The Schema a source denotes: a plain Schema is itself; a builder is the
+ * Schema its `as` mints.
  */
 export type Denoted<$Source> = $Source extends AnySchema ? $Source : $Source extends Builder<infer $Schema> ? $Schema : never;
 /**
@@ -26,20 +26,19 @@ export type Denoted<$Source> = $Source extends AnySchema ? $Source : $Source ext
  */
 export type Resolved<$Source, $Bindings extends unknown[] = []> = ValueOf<Denoted<$Source>, $Bindings>;
 /**
- * Source and resolver are stored raw — the source whether a Schema or a
- * builder (both carry a `[Kind]`, which is all schema derivation needs),
- * and the resolver as plain data from the moment
- * `compute(source).as(resolve)` is called: `compute` never builds anything,
- * so unlike a Fabricator's closure there's nothing lossy about storing it.
- * `source` is only used for its shape/type (`Adapter/TypeBox` reflects a
- * computed field as its source's shape, unless the field itself is
- * adapted) — the resolver draws entirely from `fabricated`, never from
- * `source`, which may not even have a buildable recipe (a bare
- * `T.string`/`T.bigint`).
+ * Source and resolver are stored raw — the source whether a Schema or a builder
+ * (both carry a `[Kind]`, which is all schema derivation needs), and the
+ * resolver as plain data from the moment `compute(source).as(resolve)` is
+ * called: `compute` never builds anything, so unlike a Fabricator's closure
+ * there's nothing lossy about storing it. `source` is only used for its
+ * shape/type (`Adapter/TypeBox` reflects a computed field as its source's
+ * shape, unless the field itself is adapted) — the resolver draws entirely from
+ * `fabricated`, never from `source`, which may not even have a buildable recipe
+ * (a bare `T.string`/`T.bigint`).
  *
- * Unlike every other kind's `Meta`, this one is generic over the *enclosing
- * object's* fabricated type as well as the source — that is what the
- * resolver is handed.
+ * Unlike every other kind's `Meta`, this one is generic over the _enclosing
+ * object's_ fabricated type as well as the source — that is what the resolver
+ * is handed.
  */
 export type Meta<$Fabricated, $Source extends Source> = {
     source: $Source;

package/dist/types/Primitive/object/omittable/Fabricator.d.ts

@@ -16,22 +16,22 @@ export type Fabricator<$Schema extends {
     [Children]: BaseFabricator<any>;
     readonly [Adaptation]?: AdaptationsOf<$Schema>;
     /**
-     * `Omitted` on the empty roll (or when an `.as(...)` producer returns it)
-     * — read only by `object/Fabricator.ts`'s fabricate loop, which omits the
-     * key entirely rather than writing `undefined`. Fabricating this outside
-     * a parent `object` hands the sentinel straight back.
+     * `Omitted` on the empty roll (or when an `.as(...)` producer returns it) —
+     * read only by `object/Fabricator.ts`'s fabricate loop, which omits the key
+     * entirely rather than writing `undefined`. Fabricating this outside a parent
+     * `object` hands the sentinel straight back.
      */
     fabricate: () => Resolved<$Schema[typeof Meta]["definition"]>;
 };
 export declare function isObjectOmittableFabricator(candidate: BaseFabricator<unknown>): candidate is Fabricator;
 /**
- * A presence roll on this field's private stream, drawn only when present
- * is decided — an omission roll never advances `source`'s stream, and since
+ * A presence roll on this field's private stream, drawn only when present is
+ * decided — an omission 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 (`Random/index.ts`'s
+ * `Constructor.ts` regardless of this roll, skipping its draw here can never
+ * perturb any other field's reproducibility (`Random/index.ts`'s
  * `toStreamFromTrace`: every field's stream is private from the moment it's
- * minted). 50/50 by default; `.weighted(...)` (`Schema.ts`) reweights
- * either outcome relative to that same default of `1`.
+ * minted). 50/50 by 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/object/omittable/Outcomes.d.ts

@@ -1,6 +1,6 @@
 /**
- * The two outcomes an omittable field's presence roll can land on. Also
- * the key space `.weighted(...)` weighs — see `Types.ts`'s `Weights`.
+ * The two outcomes an omittable field's presence roll can land on. Also the key
+ * space `.weighted(...)` weighs — see `Types.ts`'s `Weights`.
  *
  * Lives here rather than `Types.ts` so that file stays type-only (see
  * `boolean/Outcomes.ts`).

package/dist/types/Primitive/object/omittable/Schema.d.ts

@@ -6,25 +6,25 @@ import type { Core, Definition, Resolved, Weights } from "./Types";
 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 `Omitted`, so custom presence 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 `Omitted`, so custom presence logic composes the same way the
+     * built-in roll does.
      */
     as: (produce: Produce<Resolved<$Definition>>) => Schema<$Definition, $Adaptations>;
     /**
      * Reweight the built-in presence 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
+     * 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({ omitted: 0.1 })` shifts both outcomes' shares, not just
-     * `omitted`'s (see `Types.ts`'s `Weights`). Chaining `.weighted(...)`
-     * merges into previous weights rather than replacing them, the same
-     * layering `.as(...)` uses for `produce`.
+     * `omitted`'s (see `Types.ts`'s `Weights`). Chaining `.weighted(...)` 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/object/omittable/Types.d.ts

@@ -3,32 +3,31 @@ import type { Produce } from "../../../Random/Types";
 import type { AnySchema, ValueOf } from "../../../Schema/Types";
 import { Kind, Meta, Omitted, type Adaptation, type Produces } from "../../../Types";
 /**
- * The wrapped field's own Schema — the value type an omittable field
- * produces when its presence roll comes up present.
+ * The wrapped field's own Schema — the value type an omittable field produces
+ * when its presence roll comes up present.
  */
 export type Definition = AnySchema;
 export type Fabricated<$Definition extends Definition, $Bindings extends unknown[] = []> = ValueOf<$Definition, $Bindings>;
 /**
- * What an omittable field's Fabricator returns: the wrapped value, or
- * `Omitted` when it should not appear — whether from the built-in presence
- * roll or, via `.as(...)`, an opaque producer.
+ * What an omittable field's Fabricator returns: the wrapped value, or `Omitted`
+ * when it should not appear — whether from the built-in presence roll or, via
+ * `.as(...)`, an opaque producer.
  */
 export type Resolved<$Definition extends Definition> = Fabricated<$Definition> | typeof Omitted;
 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({ omitted: 0.1 })`
- * is not "10% omitted, 90% present" — with `value` at default `1`, the
- * split is `0.1 / 1.1 ≈ 9.1%` omitted, `≈90.9%` present. 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({ omitted: 0.1 })` is not
+ * "10% omitted, 90% present" — with `value` at default `1`, the split is `0.1 /
+ * 1.1 ≈ 9.1%` omitted, `≈90.9%` present. No independent "absolute probability"
+ * mode; weights are only meaningful relative to the full set in play.
  */
 export type Weights = {
     omitted: number;

package/dist/types/Primitive/object/optional/Fabricator.d.ts

@@ -17,29 +17,27 @@ export type Fabricator<$Schema extends {
     readonly [Adaptation]?: AdaptationsOf<$Schema>;
     /**
      * `Omitted` on the omission roll (or when an `.as(...)` producer returns it)
-     * — read only by `object/Fabricator.ts`'s fabricate loop, which omits the
-     * key entirely rather than writing `undefined`. A "present as `undefined`"
-     * roll returns `undefined` directly, which the loop assigns like any
-     * ordinary value — the difference from `object.omittable`. Fabricating this
-     * outside a parent `object` hands whichever of the three results back
-     * verbatim.
+     * — read only by `object/Fabricator.ts`'s fabricate loop, which omits the key
+     * entirely rather than writing `undefined`. A "present as `undefined`" roll
+     * returns `undefined` directly, which the loop assigns like any ordinary
+     * value — the difference from `object.omittable`. Fabricating this outside a
+     * parent `object` hands whichever of the three results back verbatim.
      */
     fabricate: () => Resolved<$Schema[typeof Meta]["definition"]>;
 };
 export declare function isObjectOptionalFabricator(candidate: BaseFabricator<unknown>): candidate is Fabricator;
 /**
- * Three-way roll: omitted, present-as-`undefined`, or the wrapped value —
- * on this field's private stream; `source` is drawn only when "value" wins.
+ * Three-way roll: omitted, present-as-`undefined`, or the wrapped value — on
+ * this field's private stream; `source` is drawn only when "value" wins.
  * Uniform (1/3 each) by default; not achievable by composing
- * `object.omittable(T.undefinable(inner))`'s two independent 50/50 rolls
- * (that is 50/25/25, not 33/33/33), hence the dedicated three-way
- * `weighted()` here — see CLAUDE.md's "Why `T.optional` isn't
- * `omittable(undefinable(inner))`" under "Compound / field-only kinds".
- * `.weighted(...)` (`Schema.ts`) reweights individual outcomes relative to
- * that same default of `1`; an unspecified outcome keeps it. Skipping
- * `source`'s draw on the two non-"value" outcomes is safe for the same
- * reason as `object/omittable/Fabricator.ts`: `source` already has its own
- * independent stream, minted at build time regardless of this roll (see
- * CLAUDE.md's "Randomness").
+ * `object.omittable(T.undefinable(inner))`'s two independent 50/50 rolls (that
+ * is 50/25/25, not 33/33/33), hence the dedicated three-way `weighted()` here —
+ * see CLAUDE.md's "Why `T.optional` isn't `omittable(undefinable(inner))`"
+ * under "Compound / field-only kinds". `.weighted(...)` (`Schema.ts`) reweights
+ * individual outcomes relative to that same default of `1`; an unspecified
+ * outcome keeps it. Skipping `source`'s draw on the two non-"value" outcomes is
+ * safe for the same reason as `object/omittable/Fabricator.ts`: `source`
+ * already has its own independent stream, minted at build time regardless of
+ * this roll (see CLAUDE.md's "Randomness").
  */
 export declare function Fabricator<$Definition extends Definition>(context: FabricatorContext<Schema<$Definition>>, source: BaseFabricator<any>): Fabricator<Schema<$Definition>>;

package/dist/types/Primitive/object/optional/Outcomes.d.ts

@@ -1,6 +1,6 @@
 /**
- * The three outcomes an optional field's roll can land on. Also the key
- * space `.weighted(...)` weighs — see `Types.ts`'s `Weights`.
+ * The three outcomes an optional field's roll can land on. Also the key space
+ * `.weighted(...)` weighs — see `Types.ts`'s `Weights`.
  *
  * Lives here rather than `Types.ts` so that file stays type-only (see
  * `boolean/Outcomes.ts`).

package/dist/types/Primitive/object/optional/Schema.d.ts

@@ -8,8 +8,8 @@ export interface Schema<$Definition extends Definition = Definition, $Adaptation
      * 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` or `Omitted`, so custom logic composes the same way
-     * the built-in three-way roll does.
+     * return `undefined` or `Omitted`, so custom logic composes the same way the
+     * built-in three-way roll does.
      */
     as: (produce: Produce<Resolved<$Definition>>) => Schema<$Definition, $Adaptations>;
     /**
@@ -23,8 +23,8 @@ export interface Schema<$Definition extends Definition = Definition, $Adaptation
      */
     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/object/optional/Types.d.ts

@@ -11,33 +11,33 @@ export type Definition = AnySchema;
  * The value an optional field's key holds when present at all — the wrapped
  * value, or `undefined` (present-as-`undefined` is one of three outcomes,
  * distinct from the key not appearing). Flows through `[Produces]` into
- * `object/Types.ts`'s per-field type, so a `T.optional`-wrapped field types
- * as `{ a?: T | undefined }` — a real `?:` (from `OmittableKeys`, which also
- * covers this kind) *and* a real `| undefined`.
+ * `object/Types.ts`'s per-field type, so a `T.optional`-wrapped field types as
+ * `{ a?: T | undefined }` — a real `?:` (from `OmittableKeys`, which also
+ * covers this kind) _and_ a real `| undefined`.
  */
 export type Fabricated<$Definition extends Definition, $Bindings extends unknown[] = []> = ValueOf<$Definition, $Bindings> | undefined;
 /**
- * What an optional field's Fabricator returns: the wrapped value,
- * `undefined`, or `Omitted` when the key should not appear — whether from
- * the built-in three-way roll or, via `.as(...)`, an opaque producer.
+ * What an optional field's Fabricator returns: the wrapped value, `undefined`,
+ * or `Omitted` when the key should not appear — whether from the built-in
+ * three-way roll or, via `.as(...)`, an opaque producer.
  */
 export type Resolved<$Definition extends Definition> = Fabricated<$Definition> | typeof Omitted;
 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 uniform
- * 1/3 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 uniform 1/3 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 *every* outcome's resulting
- * probability, not just the named one — unspecified ones stay at weight `1`
- * but their share of the total still moves, since the total changed.
- * `.weighted({ omitted: 0.1 })` on `T.optional` is not "10% omitted, other
- * two still 33%" — with `undefined`/`value` at default `1`, the split is
- * `0.1 / 2.1 ≈ 4.8%` omitted and `≈47.6%` each for the other two. No
- * independent "absolute probability" mode; weights are only meaningful
- * relative to the full set in play.
+ * Specifying one outcome's weight shifts _every_ outcome's resulting
+ * probability, not just the named one — unspecified ones stay at weight `1` but
+ * their share of the total still moves, since the total changed. `.weighted({
+ * omitted: 0.1 })` on `T.optional` is not "10% omitted, other two still 33%" —
+ * with `undefined`/`value` at default `1`, the split is `0.1 / 2.1 ≈ 4.8%`
+ * omitted and `≈47.6%` each for the other two. No independent "absolute
+ * probability" mode; weights are only meaningful relative to the full set in
+ * play.
  */
 export type Weights = {
     omitted: number;

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

@@ -5,8 +5,8 @@ import { Schema } from "./Schema";
  * instance — produced by `produce` and typed as whatever it returns, so
  * `T.opaque((random) => new Map<string, number>())` needs no annotation.
  *
- * `produce` receives this schema's own seeded stream, so an opaque value
- * still replays from a seed; see `Types.ts`'s `Produce`. No bare form and
- * no `.as()` — `produce` is the whole schema.
+ * `produce` receives this schema's own seeded stream, so an opaque value still
+ * replays from a salt; see `Types.ts`'s `Produce`. No bare form and no `.as()`
+ * — `produce` is the whole schema.
  */
 export default function <$T>(produce: Produce<$T>): Schema<$T>;

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

@@ -2,20 +2,19 @@ import { type AdaptationEntry } from "../../Adapter/Core";
 import type { Adaptations, Adapter, Adapting, WithAdaptations } from "../../Adapter/Types";
 import type { Core } from "./Types";
 /**
- * Escape hatch for values no kind models — a `Map`, a `Set`, a `URL`, a
- * class instance, a branded type. `produce` is supplied at construction and
- * receives the schema's own seeded stream (`Types.ts`'s `Produce`).
+ * Escape hatch for values no kind models — a `Map`, a `Set`, a `URL`, a class
+ * instance, a branded type. `produce` is supplied at construction and receives
+ * the schema's own seeded stream (`Types.ts`'s `Produce`).
  *
  * No `.as()`, for `always`'s reason: the constructor argument already fully
- * determines production. `adapt` matters more here than for any other kind
- * — an opaque value maps to TypeBox's `Unknown`, which is honest but
- * maximally imprecise, and `.adapt(typebox, ...)` is the only way to say
- * more.
+ * determines production. `adapt` matters more here than for any other kind — an
+ * opaque value maps to TypeBox's `Unknown`, which is honest but maximally
+ * imprecise, and `.adapt(typebox, ...)` is the only way to say more.
  */
 export interface Schema<$T = unknown, $Adaptations extends Adaptations = {}> extends Core<$T, $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<$T, $Adaptations>>) => $Returnable) => Schema<$T, WithAdaptations<$Adaptations, AdaptationEntry<$Adapter, $Returnable>>>;
 }

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

@@ -1,17 +1,19 @@
 import type { Produce } from "../../Random/Types";
 import { Schema } from "./Schema";
 import type { Fabricated, Key, Value, Whereby } from "./Types";
-export default function <const $Key extends Key, const $Value extends Value>(key: $Key, value: $Value): {
+type ThisRegistry<$Key extends Key, $Value extends Value> = {
     /**
      * A record of `value` keyed by `key`, attempted `whereby.size` times —
-     * uniformly across `[size.minTried, size.max]` (with `minTried`
-     * defaulting to 0). Colliding keys collapse, so the result holds *at
-     * most* that many entries; see `Types.ts`'s `Whereby`.
+     * uniformly across `[size.minTried, size.max]` (with `minTried` defaulting to
+     * 0). Colliding keys collapse, so the result holds _at most_ that many
+     * entries; see `Types.ts`'s `Whereby`.
      */
     whereby: (whereby: Whereby) => Schema<$Key, $Value>;
     /**
-     * A record whose production is `produce`, in full, instead of drawn
-     * entry by entry.
+     * A record whose production is `produce`, in full, instead of drawn entry by
+     * entry.
      */
     as: (produce: Produce<Fabricated<$Key, $Value>>) => Schema<$Key, $Value>;
 };
+export default function <const $Key extends Key, const $Value extends Value>(key: $Key, value: $Value): ThisRegistry<$Key, $Value>;
+export {};

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

@@ -3,24 +3,22 @@ import type { Adaptations, Adapter, Adapting, WithAdaptations } from "../../Adap
 import type { Produce } from "../../Random/Types";
 import type { Core, Fabricated, Key, Value } from "./Types";
 /**
- * The buildable recipe for a `record`: a key Schema and a value Schema,
- * drawn `whereby.size` times. `array`'s sibling — one repeated value shape
- * and a fuzzed count — but keyed rather than indexed.
+ * The buildable recipe for a `record`: a key Schema and a value Schema, drawn
+ * `whereby.size` times. `array`'s sibling — one repeated value shape and a
+ * fuzzed count — but keyed rather than indexed.
  */
 export interface Schema<$Key extends Key = Key, $Value extends Value = Value, $Adaptations extends Adaptations = {}> extends Core<$Key, $Value, $Adaptations> {
     /**
      * Layer an opaque production on this schema's existing `[Meta]` — carrying
-     * `whereby`/`key`/`value` forward, not discarding them, so a later
-     * `.as(...)` (or future validation of `produce`) still has them to check
-     * against.
+     * `whereby`/`key`/`value` forward, not discarding them, so a later `.as(...)`
+     * (or future validation of `produce`) still has them to check against.
      */
     as: (produce: Produce<Fabricated<$Key, $Value>>) => Schema<$Key, $Value, $Adaptations>;
     /**
-     * Override what this schema maps to in one or more external schema
-     * libraries — see `string/Schema.ts`'s `adapt`. Particularly relevant
-     * here: a symbol-keyed record has no TypeBox counterpart
-     * (`Adapter/TypeBox`'s `record` case), so this is the only way to give
-     * one a mapping.
+     * Override what this schema maps to in one or more external schema libraries
+     * — see `string/Schema.ts`'s `adapt`. Particularly relevant here: a
+     * symbol-keyed record has no TypeBox counterpart (`Adapter/TypeBox`'s
+     * `record` case), so this is the only way to give one a mapping.
      */
     adapt: <const $Adapter extends Adapter, $Returnable extends ReturnType<$Adapter["convert"]>>(adapter: $Adapter, produce: (adapting: Adapting<Schema<$Key, $Value, $Adaptations>>) => $Returnable) => Schema<$Key, $Value, WithAdaptations<$Adaptations, AdaptationEntry<$Adapter, $Returnable>>>;
 }