@ghostry/fabricator 0.0.1 → 0.0.2

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

@@ -1,107 +1,100 @@
 import type { Algorithm, Attribution, Layered, NumberGenerator, Options, RandomSource, ResolvedAttribution, Seed, Stream, Trace } from "./Types";
 /**
- * Build the library's built-in PRNG from a seed. The same seed always
- * yields the same stream. Seeds may be numbers or strings; both are
- * stringified and hashed to fully seed sfc32's state.
+ * Build the library's built-in PRNG from a seed. The same seed always yields
+ * the same stream. Seeds may be numbers or strings; both are stringified and
+ * hashed to fully seed sfc32's state.
  */
 export declare function defaultAlgorithm(seed: string): NumberGenerator;
 /**
- * Mint a fresh seed value — a uint32 label. Not used as
- * `initialize()`'s default (an omitted seed is empty; wall-clock
- * `clock` is the default entropy); kept for callers that want a
- * generated mixer, and for tests that need one.
+ * Mint a fresh seed value — a uint32 label. Not used as `initialize()`'s
+ * default (an omitted seed is empty; wall-clock `clock` is the default
+ * entropy); kept for callers that want a generated mixer, and for tests that
+ * need one.
  */
 export declare function randomSeed(): string;
 /**
- * Derive the explicit `"seeded"` clock — an epoch-millisecond instant,
- * drawn across the full representable `Date` span — from an instance's
- * own `algorithm`/`seed`. The unconfigured default is wall-clock time
- * (`Instance/Core.ts`'s `overlay`); this is the opt-in that makes
- * `seed` alone the reproducibility unit, at the cost of an implausible
- * "now". A throwaway two-element encoding
- * (`JSON.stringify([seed, "clock"])`), *not* routed through
- * `RandomSource`/`Trace`: after the clock is folded into stream
- * derivation, a forked source's own stream derivation requires a clock,
- * so deriving the clock from a fork would be circular. Kept below that
- * layer, which also keeps this collision-free with every leaf's
- * `encode(trace)` — that encoding is always seven elements, this is
- * always two, and the two can never produce the same JSON array.
- * `Math.trunc`ed because a `Date`'s precision is whole milliseconds.
+ * Derive the explicit `"seeded"` clock — an epoch-millisecond instant, drawn
+ * across the full representable `Date` span — from an instance's own
+ * `algorithm`/`seed`. The unconfigured default is wall-clock time
+ * (`Instance/Core.ts`'s `overlay`); this is the opt-in that makes `seed` alone
+ * the reproducibility unit, at the cost of an implausible "now". A throwaway
+ * two-element encoding (`JSON.stringify([seed, "clock"])`), _not_ routed
+ * through `RandomSource`/`Trace`: after the clock is folded into stream
+ * derivation, a forked source's own stream derivation requires a clock, so
+ * deriving the clock from a fork would be circular. Kept below that layer,
+ * which also keeps this collision-free with every leaf's `encode(trace)` — that
+ * encoding is always seven elements, this is always two, and the two can never
+ * produce the same JSON array. `Math.trunc`ed because a `Date`'s precision is
+ * whole milliseconds.
  */
 export declare function deriveClock(algorithm: Algorithm, seed: ReadonlyArray<string>): number;
 /**
  * Collapse a {@link Trace} into one string to hash — and, since
- * `toStreamFromTrace` hashes exactly this output, the *definition* of
- * that leaf's stream seed. Concatenating fields with a delimiter would
- * collide when a path/kind/seed part contains that delimiter
- * (`file="a b", kind="c"` vs `file="a", kind="b c"`) — silently: two
- * leaves that should draw independently would share one stream.
- * `JSON.stringify` as an array makes every field's and slot's
- * boundaries unambiguous regardless of content or nesting depth.
- * `undefined` (`file`, `ordinal`) is the right "this slot doesn't
- * apply" rather than a sentinel string: `JSON.stringify` writes it as
- * `null` in an array position, one unambiguous value, with no chance
- * of colliding with a real file path or index.
+ * `toStreamFromTrace` hashes exactly this output, the _definition_ of that
+ * leaf's stream seed. Concatenating fields with a delimiter would collide when
+ * a path/kind/seed part contains that delimiter (`file="a b", kind="c"` vs
+ * `file="a", kind="b c"`) — silently: two leaves that should draw independently
+ * would share one stream. `JSON.stringify` as an array makes every field's and
+ * slot's boundaries unambiguous regardless of content or nesting depth.
+ * `undefined` (`file`, `ordinal`) is the right "this slot doesn't apply" rather
+ * than a sentinel string: `JSON.stringify` writes it as `null` in an array
+ * position, one unambiguous value, with no chance of colliding with a real file
+ * path or index.
  */
 export declare function encode(trace: Trace): string;
 /**
- * Normalize a caller-supplied {@link Seed} to its parts: a single string
- * becomes a one-element array, an array passes through unchanged, and a
- * missing seed is empty — unless {@link envSeed} supplies one. No
- * generated fallback: an omitted seed is not a second source of
- * entropy beside the instance clock.
+ * Normalize a caller-supplied {@link Seed} to its parts: a single string becomes
+ * a one-element array, an array passes through unchanged, and a missing seed is
+ * empty — unless {@link envSeed} supplies one. No generated fallback: an omitted
+ * seed is not a second source of entropy beside the instance clock.
  */
 export declare function normalizeSeed(seed: Seed | undefined): ReadonlyArray<string>;
 /**
  * Tag a seed as composing onto whatever base is in effect, rather than
- * replacing it — the reading a bare `seed` has everywhere else in this
- * library. Mirrors `replace()`'s `[Replace]` tagging: the `[Layer]`
- * directive is read (and, at every level that accepts one, consumed) by
- * whoever resolves the seed against its base, so a caller never names
- * the symbol.
+ * replacing it — the reading a bare `seed` has everywhere else in this library.
+ * Mirrors `replace()`'s `[Replace]` tagging: the `[Layer]` directive is read
+ * (and, at every level that accepts one, consumed) by whoever resolves the seed
+ * against its base, so a caller never names the symbol.
  */
 export declare function layer(seed: Seed): Layered;
 export declare function isLayered(value: unknown): value is Layered;
 /**
  * Collapse a caller-facing {@link Attribution} to the
- * {@link ResolvedAttribution} the stream machinery uses. `"call site"`
- * must resolve *here*, and only here: `resolveCallerFile()` reads the
- * live stack, and `toRandomSource` runs synchronously inside
- * `initialize()`, so this is the one moment the first external frame
- * genuinely is the file that called `initialize()`. Resolving lazily —
- * on first construction, or again inside `fork` — would capture
- * whichever file happened to call `new Fabricator(...)`, or whichever
- * internal mechanism happened to trigger a fork.
+ * {@link ResolvedAttribution} the stream machinery uses. `"call site"` must
+ * resolve _here_, and only here: `resolveCallerFile()` reads the live stack,
+ * and `toRandomSource` runs synchronously inside `initialize()`, so this is the
+ * one moment the first external frame genuinely is the file that called
+ * `initialize()`. Resolving lazily — on first construction, or again inside
+ * `fork` — would capture whichever file happened to call `new Fabricator(...)`,
+ * or whichever internal mechanism happened to trigger a fork.
  *
- * A directory, not the file itself, becomes the root: rooting at the
- * file would relativize that one file to `""` while every sibling still
- * carried a full relative path from a directory one level up, an
- * arbitrary asymmetry with no reason to prefer it.
+ * A directory, not the file itself, becomes the root: rooting at the file would
+ * relativize that one file to `""` while every sibling still carried a full
+ * relative path from a directory one level up, an arbitrary asymmetry with no
+ * reason to prefer it.
  */
 export declare function resolveAttribution(attribution: Attribution | undefined): ResolvedAttribution;
 export declare function toStream(algorithm: Algorithm, seed: string): Stream;
 /**
  * A leaf's stream: `toStream(algorithm, encode(trace))`. This is the
- * composition that *defines* a leaf's stream seed — the invariant
+ * composition that _defines_ a leaf's stream seed — the invariant
  * `toStream(algorithm, encode(trace)).seed === stream.seed`. Not a
- * {@link RandomSource} member: derivation depends on no per-source
- * state (a fork shares only the algorithm), so it is a free function
- * of `(algorithm, trace)`. `toRoot` is the only stateful member.
+ * {@link RandomSource} member: derivation depends on no per-source state (a
+ * fork shares only the algorithm), so it is a free function of `(algorithm,
+ * trace)`. `toRoot` is the only stateful member.
  *
- * {@link deriveClock} cannot route through this: a {@link Trace}
- * carries `clock`, and `deriveClock` is what produces it. That
- * circularity is why `deriveClock` stays below the
- * `RandomSource`/`Trace` layer, with a two-element encoding that can
- * never collide with `encode`'s seven.
+ * {@link deriveClock} cannot route through this: a {@link Trace} carries
+ * `clock`, and `deriveClock` is what produces it. That circularity is why
+ * `deriveClock` stays below the `RandomSource`/`Trace` layer, with a
+ * two-element encoding that can never collide with `encode`'s seven.
  */
 export declare function toStreamFromTrace(algorithm: Algorithm, trace: Trace): Stream;
 /**
- * Create a fresh, self-contained {@link RandomSource} — the randomness
- * state a single `initialize()` instance owns for its lifetime.
- * `options.clock` is baked in here, once, as a plain number — the
- * `"seeded"` policy is already resolved by the caller
- * (`Instance/Core.ts`'s `resolveClock`) before a source is ever built,
- * so every root this source resolves carries the identical instant, and
- * `fork` threads it forward unchanged.
+ * Create a fresh, self-contained {@link RandomSource} — the randomness state a
+ * single `initialize()` instance owns for its lifetime. `options.clock` is
+ * baked in here, once, as a plain number — the `"seeded"` policy is already
+ * resolved by the caller (`Instance/Core.ts`'s `resolveClock`) before a source
+ * is ever built, so every root this source resolves carries the identical
+ * instant, and `fork` threads it forward unchanged.
  */
 export declare function toRandomSource(options: Options): RandomSource;

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

@@ -3,25 +3,23 @@ import type { Kind as SchemaKind } from "../Primitive";
 import { Adaptation, Kind, Meta, type Produces } from "../Types";
 import { type PlainObject } from "../Utility/Types";
 /**
- * Normalize a Schema, a builder namespace, or an already-built
- * Fabricator into a clean, storable Schema — keeping only `[Kind]`/
- * `[Meta]`/`[Adaptation]` and discarding `fabricate` and any
- * builder-method properties. This is what lets `object`/`array` fields,
- * and registry `.extend()` registrations, accept any of the three
- * interchangeably while only ever storing inert data: a built
+ * Normalize a Schema, a builder namespace, or an already-built Fabricator into
+ * a clean, storable Schema — keeping only `[Kind]`/ `[Meta]`/`[Adaptation]` and
+ * discarding `fabricate` and any builder-method properties. This is what lets
+ * `object`/`array` fields, and registry `.extend()` registrations, accept any
+ * of the three interchangeably while only ever storing inert data: a built
  * Fabricator's `[Meta]` is exactly the Schema it came from.
  *
- * `[Adaptation]` is carried rather than dropped because it is a
- * property of the schema itself, not of the builder that produced it:
- * a field adapted with `.adapt(adapter, produce)` has to still be
- * adapted once normalized into its enclosing `object`/`array`, which
- * is where every adapter actually reads it from (see
- * `Adapter/TypeBox`'s `build`, which walks `[Meta].definition`).
+ * `[Adaptation]` is carried rather than dropped because it is a property of the
+ * schema itself, not of the builder that produced it: a field adapted with
+ * `.adapt(adapter, produce)` has to still be adapted once normalized into its
+ * enclosing `object`/`array`, which is where every adapter actually reads it
+ * from (see `Adapter/TypeBox`'s `build`, which walks `[Meta].definition`).
  *
- * `$SchemaProduces` is threaded through in the type only (never read
- * or written at runtime) so `ValueOf` stays precise across a
- * `toSchema` call — dropping it would make every normalized field
- * (e.g. every `object`/`array` element) fall back to `unknown`.
+ * `$SchemaProduces` is threaded through in the type only (never read or written
+ * at runtime) so `ValueOf` stays precise across a `toSchema` call — dropping it
+ * would make every normalized field (e.g. every `object`/`array` element) fall
+ * back to `unknown`.
  */
 export declare function toSchema<$Kind extends string, $Meta extends PlainObject, $Produces = unknown, $Adaptations extends Adaptations = Adaptations>(value: {
     [Kind]: $Kind;
@@ -35,10 +33,10 @@ export declare function toSchema<$Kind extends string, $Meta extends PlainObject
     readonly [Adaptation]?: $Adaptations;
 };
 /**
- * Whether `value`'s basic JS shape is compatible with `kind` (one of
- * this library's `[Kind]` literals, e.g. `"string"`, `"object"`,
- * `"date"`). Stops at "is this the right *kind of value*" (right JS
- * type/shape), not deeper schema constraints like a number's `whereby`
- * range, a string's length, or a weighted-enum's member set.
+ * Whether `value`'s basic JS shape is compatible with `kind` (one of this
+ * library's `[Kind]` literals, e.g. `"string"`, `"object"`, `"date"`). Stops at
+ * "is this the right _kind of value_" (right JS type/shape), not deeper schema
+ * constraints like a number's `whereby` range, a string's length, or a
+ * weighted-enum's member set.
  */
 export declare function violatesKind(kind: SchemaKind, value: unknown): boolean;

package/dist/types/Schema/Registry.d.ts

@@ -2,9 +2,9 @@ import * as primitives from "../Primitive";
 import { deepMerge, type DeepMerge } from "../Utility/DeepMerge";
 import { type PlainObject } from "../Utility/Types";
 /**
- * `Primitive/index.ts` also exports the kind-module namespace as
- * `Primitive` (`Primitive.boolean.Schema`, …). That is not a builder —
- * omitting it here is what keeps `T.Primitive` from existing.
+ * `Primitive/index.ts` also exports the kind-module namespace as `Primitive`
+ * (`Primitive.boolean.Schema`, …). That is not a builder — omitting it here is
+ * what keeps `T.Primitive` from existing.
  */
 type Builders = Omit<typeof primitives, "Primitive">;
 type RegistryInterface<$Registry> = {

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

@@ -3,13 +3,12 @@ import type { Kind as SchemaKind } from "../Primitive";
 import type { Adaptation, Kind, Meta, Produces } from "../Types";
 import type { PlainObject } from "../Utility/Types";
 /**
- * The broadest Schema constraint: some kind, some config. Used by
- * compound kinds (`object`/`array`) for their nested fields instead of
- * the library-wide Schema union `Primitive/index.ts` assembles — that
- * union imports every kind's `Core.ts`, so importing it back from
- * within a kind's own `Core.ts` would cycle. Mirrors how
- * `array.Definition` uses the equally generic `NaiveFabricator<any>`
- * for the same reason.
+ * The broadest Schema constraint: some kind, some config. Used by compound
+ * kinds (`object`/`array`) for their nested fields instead of the library-wide
+ * Schema union `Primitive/index.ts` assembles — that union imports every kind's
+ * `Core.ts`, so importing it back from within a kind's own `Core.ts` would
+ * cycle. Mirrors how `array.Definition` uses the equally generic
+ * `NaiveFabricator<any>` for the same reason.
  */
 export type AnySchema = {
     [Kind]: SchemaKind;
@@ -17,51 +16,45 @@ export type AnySchema = {
     [Adaptation]?: Adaptations;
 };
 /**
- * Extract the value a Schema fabricates to, via the phantom,
- * runtime-absent `[Produces]` marker every kind's `Schema` carries.
- * This is what lets `object`/`array`'s per-field type extraction work
- * uniformly across every kind without importing and enumerating them
- * (which would cycle, since `object`/`array` can nest any kind,
- * including each other) — the same role `fabricate: () => $T` already
- * plays for `NaiveFabricator<infer $T>`, one step earlier, before a
- * Schema has been built. `[Produces]` is always optional (never
- * assigned at runtime — see `DeepMerge`'s handling of optional-only
- * keys for why that matters).
+ * Extract the value a Schema fabricates to, via the phantom, runtime-absent
+ * `[Produces]` marker every kind's `Schema` carries. This is what lets
+ * `object`/`array`'s per-field type extraction work uniformly across every kind
+ * without importing and enumerating them (which would cycle, since
+ * `object`/`array` can nest any kind, including each other) — the same role
+ * `fabricate: () => $T` already plays for `NaiveFabricator<infer $T>`, one step
+ * earlier, before a Schema has been built. `[Produces]` is always optional
+ * (never assigned at runtime — see `DeepMerge`'s handling of optional-only keys
+ * for why that matters).
  *
- * `$Bindings` is threaded down into every composite kind's children
- * (each `Core` is an `interface` carrying an optional `bindings`, and
- * forwards `NonNullable<this["bindings"]>` into its own `[Produces]`).
- * It is a substitution slot for a self-reference, not a parameter of
- * the schema the way `$Definition`/`$Value` are — every composite
- * forwards it unread, so whatever `self` node is buried arbitrarily
- * deep still receives it. A node whose `[Produces]` reads
- * `bindings[0]` (`recursive.self.Core`) can then close a type-level
- * fixed point, which is what makes a self-referential schema resolve
- * rather than collapse to `unknown`. Mirrors TypeBox's
- * `Static<T, P> = (T & { params: P })['static']`, renamed because
- * "params" reads as configuration and this is closer to a
- * de-Bruijn-style resolution environment — kept as a tuple, as
- * TypeBox's is, so a second bound self-reference could occupy index 1
- * later without restructuring, though nothing today defines what that
- * would mean. `test/ValueOfBindings.types.test.ts` is the only thing
- * asserting any of it.
+ * `$Bindings` is threaded down into every composite kind's children (each
+ * `Core` is an `interface` carrying an optional `bindings`, and forwards
+ * `NonNullable<this["bindings"]>` into its own `[Produces]`). It is a
+ * substitution slot for a self-reference, not a parameter of the schema the way
+ * `$Definition`/`$Value` are — every composite forwards it unread, so whatever
+ * `self` node is buried arbitrarily deep still receives it. A node whose
+ * `[Produces]` reads `bindings[0]` (`recursive.self.Core`) can then close a
+ * type-level fixed point, which is what makes a self-referential schema resolve
+ * rather than collapse to `unknown`. Mirrors TypeBox's `Static<T, P> = (T & {
+ * params: P })['static']`, renamed because "params" reads as configuration and
+ * this is closer to a de-Bruijn-style resolution environment — kept as a tuple,
+ * as TypeBox's is, so a second bound self-reference could occupy index 1 later
+ * without restructuring, though nothing today defines what that would mean.
+ * `test/ValueOfBindings.types.test.ts` is the only thing asserting any of it.
  *
  * Three details here are load-bearing, and each looks simplifiable:
  *
- * - **Indexed access, not a conditional `infer`.** Writing this as
- *   `($Schema & { bindings: $Bindings }) extends { [Produces]?: infer $T } ? ...`
- *   fails with `TS2615` — the bindings do not collapse, and the error
- *   surfaces as `unknown[] & [...]`.
- * - **`Required<>`, never `Exclude<..., undefined>`.** Both strip the
- *   `| undefined` that indexing an optional property adds, but
- *   `Exclude` also strips the *legitimate* `undefined` out of
- *   `nullish`/`undefinable`/`object.optional`/`undefined`'s own value
- *   types.
- * - **The `extends` guard belongs inside, not on the parameter.**
- *   Constraining `$Schema` instead would force `[Produces]` onto
- *   `AnySchema` (which deliberately omits it), and that shifts
- *   variance enough to break `.as`'s contravariant parameter check in
- *   `Fabrication.types.test.ts`.
+ * - **Indexed access, not a conditional `infer`.** Writing this as `($Schema & {
+ *   bindings: $Bindings }) extends { [Produces]?: infer $T } ? ...` fails with
+ *   `TS2615` — the bindings do not collapse, and the error surfaces as
+ *   `unknown[] & [...]`.
+ * - **`Required<>`, never `Exclude<..., undefined>`.** Both strip the `|
+ *   undefined` that indexing an optional property adds, but `Exclude` also
+ *   strips the _legitimate_ `undefined` out of
+ *   `nullish`/`undefinable`/`object.optional`/`undefined`'s own value types.
+ * - **The `extends` guard belongs inside, not on the parameter.** Constraining
+ *   `$Schema` instead would force `[Produces]` onto `AnySchema` (which
+ *   deliberately omits it), and that shifts variance enough to break `.as`'s
+ *   contravariant parameter check in `Fabrication.types.test.ts`.
  */
 export type ValueOf<$Schema, $Bindings extends unknown[] = []> = $Schema extends {
     readonly [Produces]?: unknown;

package/dist/types/Types.d.ts

@@ -6,60 +6,55 @@ export declare const Produces: unique symbol;
 export declare const Replace: unique symbol;
 export declare const Fixed: unique symbol;
 /**
- * Tags a `Seed` as composing onto whatever base is in effect, rather
- * than replacing it — the reading a bare `seed` has everywhere else in
- * this library. `layer()` (`Random/index.ts`) is the only producer; a
- * caller never names this symbol, mirroring `[Replace]`. Unlike every
- * other symbol in this file, it tags a config value (a `Seed`), not a
- * Schema or Fabricator — see `Random/Types.ts`'s `Layered`.
+ * Tags a `Seed` as composing onto whatever base is in effect, rather than
+ * replacing it — the reading a bare `seed` has everywhere else in this library.
+ * `layer()` (`Random/index.ts`) is the only producer; a caller never names this
+ * symbol, mirroring `[Replace]`. Unlike every other symbol in this file, it
+ * tags a config value (a `Seed`), not a Schema or Fabricator — see
+ * `Random/Types.ts`'s `Layered`.
  */
 export declare const Layer: unique symbol;
 /**
- * The Fabricators that exist at build time — whatever
- * `Constructor.ts`'s `make` already constructed for this node's nested
- * schemas before handing them to the kind's own `Fabricator()` factory.
- * Every composite kind whose construction receives already-dispatched
- * Fabricators carries this: `object` (its `Fields` map), `tuple`
- * (`elements`, in slot order), `choice` (the dispatched options, in
- * `[Meta].items` order — weights stay in `[Meta]`), `array` (the single
+ * The Fabricators that exist at build time — whatever `Constructor.ts`'s `make`
+ * already constructed for this node's nested schemas before handing them to the
+ * kind's own `Fabricator()` factory. Every composite kind whose construction
+ * receives already-dispatched Fabricators carries this: `object` (its `Fields`
+ * map), `tuple` (`elements`, in slot order), `choice` (the dispatched options,
+ * in `[Meta].items` order — weights stay in `[Meta]`), `array` (the single
  * shared `element`), `record` (`{ key, value }`), and each of
- * `nullable`/`nullish`/`undefinable`/`object.omittable`/`object.optional`
- * (the single wrapped `source`).
+ * `nullable`/`nullish`/`undefinable`/`object.omittable`/`object.optional` (the
+ * single wrapped `source`).
  *
- * The payload shape is kind-private, exactly as `[Meta]` is — nothing
- * outside a kind's own files interprets another kind's `[Children]`
- * shape.
+ * The payload shape is kind-private, exactly as `[Meta]` is — nothing outside a
+ * kind's own files interprets another kind's `[Children]` shape.
  *
- * `recursive` carries none: its expansions are a function of draws
- * made *during* `fabricate()` (`recursive/Fabricator.ts`), one
- * throwaway Fabricator per `self` occurrence, so there is no stable
- * child at build time to point at. `body`/`terminal` are already on
- * `[Meta]` as ordinary sub-Schemas for anything that needs to
- * introspect them.
+ * `recursive` carries none: its expansions are a function of draws made
+ * _during_ `fabricate()` (`recursive/Fabricator.ts`), one throwaway Fabricator
+ * per `self` occurrence, so there is no stable child at build time to point at.
+ * `body`/`terminal` are already on `[Meta]` as ordinary sub-Schemas for
+ * anything that needs to introspect them.
  */
 export declare const Children: unique symbol;
 /**
- * A per-library map of external-schema overrides
- * (`{ typebox: (schema) => TSchema }`), written by every kind's
- * `.adapt(adapter, produce)` builder method and read only by
- * `src/Adapter/*` — completely inert for fabrication, which never
- * looks at it. A map rather than a single function so one schema can
- * map to several external libraries at once; see `Adapter/Types.ts`
- * for the registry of supported libraries, and `Adapter/TypeBox`'s
+ * A per-library map of external-schema overrides (`{ typebox: (schema) =>
+ * TSchema }`), written by every kind's `.adapt(adapter, produce)` builder
+ * method and read only by `src/Adapter/*` — completely inert for fabrication,
+ * which never looks at it. A map rather than a single function so one schema
+ * can map to several external libraries at once; see `Adapter/Types.ts` for the
+ * registry of supported libraries, and `Adapter/TypeBox`'s
  * `ToTypeBox`/`convert` for the reading end.
  */
 export declare const Adaptation: unique symbol;
 /**
- * A public sentinel with two uses that share one meaning — "this key
- * does not appear in the fabricated object": `object.omittable`'s and
- * `object.optional`'s Fabricators return it internally when their roll
- * lands on absence (read by `object/Fabricator.ts`'s fabricate loop,
- * never surfaced to a caller fabricating normally), and it is also the
- * value a caller passes in `.override(...)`/`.fabricate(overrides)` to
- * force an omittable or optional field off — `{ a: undefined }`
- * present-as-`undefined` is not expressible this way, since that would
- * conflate with a genuinely present-but-`undefined` value (see
- * `Primitive/undefined`, and `Primitive/object/optional`, which
+ * A public sentinel with two uses that share one meaning — "this key does not
+ * appear in the fabricated object": `object.omittable`'s and
+ * `object.optional`'s Fabricators return it internally when their roll lands on
+ * absence (read by `object/Fabricator.ts`'s fabricate loop, never surfaced to a
+ * caller fabricating normally), and it is also the value a caller passes in
+ * `.override(...)`/`.fabricate(overrides)` to force an omittable or optional
+ * field off — `{ a: undefined }` present-as-`undefined` is not expressible this
+ * way, since that would conflate with a genuinely present-but-`undefined` value
+ * (see `Primitive/undefined`, and `Primitive/object/optional`, which
  * distinguishes the two outcomes).
  */
 export declare const Omitted: unique symbol;
@@ -70,9 +65,8 @@ export declare const Omitted: unique symbol;
 export type Buildable = AnySchema | Fabricator<any>;
 /**
  * The span of valid `Date` time values: ±8.64e15 ms from the epoch. An
- * ECMAScript spec fact (`Date`'s own representable range), not a
- * `date`-kind detail — lives here rather than in `Primitive/date/` so
- * `Random/index.ts`'s `deriveClock` can use it without importing from
- * `Primitive/`.
+ * ECMAScript spec fact (`Date`'s own representable range), not a `date`-kind
+ * detail — lives here rather than in `Primitive/date/` so `Random/index.ts`'s
+ * `deriveClock` can use it without importing from `Primitive/`.
  */
 export declare const MAX_TIME = 8640000000000000;

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

@@ -5,30 +5,39 @@ import { type PlainObject } from "./Types";
  */
 export declare function inline<$T>(fn: () => $T): $T;
 export declare function never(_: never): never;
+/**
+ * Does nothing, deliberately. For attaching a settled handler to a promise
+ * being abandoned, so it cannot surface as an unhandled rejection.
+ */
+export declare function noop(): void;
+/**
+ * Whether a value is thenable — the structural test, not `instanceof Promise`,
+ * since an `async` function's return may be any conforming implementation.
+ */
+export declare function isThenable(value: unknown): value is PromiseLike<unknown>;
 /**
  * @see https://github.com/microsoft/TypeScript/issues/17002
  */
 export declare function isArray(candidate: unknown): candidate is Array<unknown> | ReadonlyArray<unknown>;
 export declare function isPollutionKey(key: string): boolean;
 /**
- * A plain `{}`/`Object.create(null)` object — not an array, `Date`,
- * class instance, etc.
+ * A plain `{}`/`Object.create(null)` object — not an array, `Date`, class
+ * instance, etc.
  */
 export declare function isPlainObject(value: unknown): value is PlainObject;
 /**
  * Keys worth carrying across a merge. String keys are subject to the
  * prototype-pollution guard; symbol keys (e.g. a fabricator's
  * `[Kind]`/`[Meta]`) are carried through — dropping them would strip a
- * primitive's identity when it is extended — except `Replace`, which is
- * a directive consumed here rather than data to propagate.
+ * primitive's identity when it is extended — except `Replace`, which is a
+ * directive consumed here rather than data to propagate.
  */
 export declare function mergeableKeys(source: PlainObject): Array<string | symbol>;
 /**
- * Tag an object so a subsequent deep or shallow merge replaces the
- * left-hand operand wholesale instead of merging into it. The
- * `[Replace]` directive is consumed by the merge and does not appear
- * on the result, so callers can wrap a replacement value without ever
- * naming the symbol.
+ * Tag an object so a subsequent deep or shallow merge replaces the left-hand
+ * operand wholesale instead of merging into it. The `[Replace]` directive is
+ * consumed by the merge and does not appear on the result, so callers can wrap
+ * a replacement value without ever naming the symbol.
  */
 export declare function replace<$T extends PlainObject>(value: $T): $T & {
     [Replace]: true;