@ghostry/fabricator 0.0.8 → 0.0.9

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

@@ -1,6 +1,7 @@
 import { type AdaptationEntry } from "../../Adapter/Core";
 import type { Adaptations, Adapter, Adapting, WithAdaptations } from "../../Adapter/Types";
-import type { Core, Value } from "./Types";
+import { type SatisfiesThis } from "../../Schema/Satisfies";
+import type { Core, Fabricated, Value } from "./Types";
 /**
  * A fixed value, so unlike every other kind there is no `.as()` — nothing left
  * to override about producing it. `adapt` still applies: what a value _means_
@@ -10,6 +11,12 @@ import type { Core, Value } from "./Types";
  * close the gap.
  */
 export interface Schema<$Value extends Value = Value, $Adaptations extends Adaptations = {}> extends Core<$Value, $Adaptations> {
+    /**
+     * Check that this schema's fabricated value type is assignable to `$Target`.
+     * Identity at runtime; the target is not carried into later chained calls —
+     * see `object/Schema.ts`'s `satisfies`.
+     */
+    satisfies<$Target>(this: this & SatisfiesThis<Fabricated<$Value>, $Target>): Schema<$Value, $Adaptations>;
     /**
      * Override what this schema maps to in one or more external schema libraries
      * — see `string/Schema.ts`'s `adapt` for the full contract.

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

@@ -3,11 +3,13 @@ import { Schema } from "./Schema";
 import type { Definition, Fabricated, InputWhereby } from "./Types";
 type ThisRegistry<$Definition extends Definition> = {
     /**
-     * An array of `definition`, repeated `whereby.length` times — either a fixed
-     * count, or uniformly across `[length.min, length.max]` with `length.min`
-     * defaulting to inclusive 0, so an empty array is a legitimate outcome when
-     * no `min` is given. Exclusive ends use a Bound object; a bare `length: N` is
-     * stored as min = max = N inclusive.
+     * An array of `definition`, repeated `length` times. `length` is a bare `N`
+     * (exactly N) or `{ min?, max, distribution? }`. `min` defaults to inclusive
+     * 0, so an empty array is a legitimate outcome when no `min` is given.
+     * Exclusive ends use a Bound object. A bare `N` is stored as min = max = N
+     * inclusive and carries no distribution. Without `distribution`, the length
+     * is drawn uniformly across the inclusive interval; `distribution` shapes
+     * that draw the same way it does for `T.number.integer`.
      */
     whereby: (whereby: InputWhereby) => Schema<$Definition>;
     /**

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

@@ -1,6 +1,7 @@
 import { type AdaptationEntry } from "../../Adapter/Core";
 import type { Adaptations, Adapter, Adapting, WithAdaptations } from "../../Adapter/Types";
 import type { Produce } from "../../Random/Types";
+import { type SatisfiesThis } from "../../Schema/Satisfies";
 import type { Core, Definition, Fabricated } from "./Types";
 /**
  * The buildable recipe for an `array`: a single element Schema, repeated
@@ -13,6 +14,12 @@ export interface Schema<$Definition extends Definition = Definition, $Adaptation
      * (or future validation of `produce`) still has them to check against.
      */
     as: (produce: Produce<Fabricated<$Definition>>) => Schema<$Definition, $Adaptations>;
+    /**
+     * Check that this schema's fabricated value type is assignable to `$Target`.
+     * Identity at runtime; the target is not carried into later chained calls —
+     * see `object/Schema.ts`'s `satisfies`.
+     */
+    satisfies<$Target>(this: this & SatisfiesThis<Fabricated<$Definition>, $Target>): 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.

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

@@ -1,21 +1,15 @@
 import type { Adaptations } from "../../Adapter/Types";
-import type { Bound, InputBound } from "../../Bound";
+import type { InputLength, Length } from "../../Bound";
 import type { Produce } from "../../Random/Types";
 import type { AnySchema, ValueOf } from "../../Schema/Types";
 import type { Adaptation, Kind, Meta, Produces } from "../../Types";
 export type Definition = AnySchema;
 export type Fabricated<$Definition extends Definition, $Bindings extends unknown[] = []> = Array<ValueOf<$Definition, $Bindings>>;
 export type InputWhereby = {
-    length: number | {
-        max: InputBound<number>;
-        min?: InputBound<number> | undefined;
-    };
+    length: InputLength;
 };
 export type Whereby = {
-    length: {
-        min: Bound<number>;
-        max: Bound<number>;
-    };
+    length: Length;
 };
 /**
  * `whereby` (a length spec — no natural bound to fuzz to, so unlike

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

@@ -1,6 +1,7 @@
 import { type AdaptationEntry } from "../../Adapter/Core";
 import type { Adaptations, Adapter, Adapting, WithAdaptations } from "../../Adapter/Types";
 import type { Produce } from "../../Random/Types";
+import { type SatisfiesThis } from "../../Schema/Satisfies";
 import type { Core, Fabricated, Meta as ThisMeta } from "./Types";
 /**
  * Buildable `bigint` recipe: a range (`whereby` — required, like `string`; no
@@ -18,6 +19,12 @@ export interface Schema<$Meta extends ThisMeta = ThisMeta, $Adaptations extends
      * validation of `produce`) still has it to check against.
      */
     as: (produce: Produce<Fabricated>) => Schema<$Meta, $Adaptations>;
+    /**
+     * Check that this schema's fabricated value type is assignable to `$Target`.
+     * Identity at runtime; the target is not carried into later chained calls —
+     * see `object/Schema.ts`'s `satisfies`.
+     */
+    satisfies<$Target>(this: this & SatisfiesThis<Fabricated, $Target>): 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.

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

@@ -1,6 +1,7 @@
 import { type AdaptationEntry } from "../../Adapter/Core";
 import type { Adaptations, Adapter, Adapting, WithAdaptations } from "../../Adapter/Types";
 import type { Produce } from "../../Random/Types";
+import { type SatisfiesThis } from "../../Schema/Satisfies";
 import type { Core, Fabricated, Meta as ThisMeta, Weights } from "./Types";
 /**
  * Buildable `boolean` recipe: an even coin flip, a weighted one (`weights`), or
@@ -18,6 +19,12 @@ export interface Schema<$Meta extends ThisMeta = ThisMeta, $Adaptations extends
      * validation of `produce`) still has it to check against.
      */
     as: (produce: Produce<Fabricated>) => Schema<$Meta, $Adaptations>;
+    /**
+     * Check that this schema's fabricated value type is assignable to `$Target`.
+     * Identity at runtime; the target is not carried into later chained calls —
+     * see `object/Schema.ts`'s `satisfies`.
+     */
+    satisfies<$Target>(this: this & SatisfiesThis<Fabricated, $Target>): Schema<$Meta, $Adaptations>;
     weighted: (weights: Weights) => Schema<$Meta, $Adaptations>;
     /**
      * Override what this schema maps to in one or more external schema libraries

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

@@ -1,6 +1,7 @@
 import { type AdaptationEntry } from "../../Adapter/Core";
 import type { Adaptations, Adapter, Adapting, WithAdaptations } from "../../Adapter/Types";
 import type { Produce } from "../../Random/Types";
+import { type SatisfiesThis } from "../../Schema/Satisfies";
 import type { Core, Fabricated, Items } from "./Types";
 /**
  * Buildable `choice` recipe: a weighted set of option Schemas, one of which is
@@ -15,6 +16,12 @@ export interface Schema<$Items extends Items = Items, $Adaptations extends Adapt
      * validation of `produce`) still has it to check against.
      */
     as: (produce: Produce<Fabricated<$Items>>) => Schema<$Items, $Adaptations>;
+    /**
+     * Check that this schema's fabricated value type is assignable to `$Target`.
+     * Identity at runtime; the target is not carried into later chained calls —
+     * see `object/Schema.ts`'s `satisfies`.
+     */
+    satisfies<$Target>(this: this & SatisfiesThis<Fabricated<$Items>, $Target>): 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.

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

@@ -1,6 +1,7 @@
 import { type AdaptationEntry } from "../../Adapter/Core";
 import type { Adaptations, Adapter, Adapting, WithAdaptations } from "../../Adapter/Types";
 import type { Produce } from "../../Random/Types";
+import { type SatisfiesThis } from "../../Schema/Satisfies";
 import type { Core, Fabricated, Meta as ThisMeta } from "./Types";
 /**
  * Buildable `Date` recipe: a range/distribution (`whereby`, absent for the
@@ -18,6 +19,12 @@ export interface Schema<$Meta extends ThisMeta = ThisMeta, $Adaptations extends
      * future validation of `produce`) still has them to check against.
      */
     as: (produce: Produce<Fabricated>) => Schema<$Meta, $Adaptations>;
+    /**
+     * Check that this schema's fabricated value type is assignable to `$Target`.
+     * Identity at runtime; the target is not carried into later chained calls —
+     * see `object/Schema.ts`'s `satisfies`.
+     */
+    satisfies<$Target>(this: this & SatisfiesThis<Fabricated, $Target>): 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.

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

@@ -1,6 +1,7 @@
 import { type AdaptationEntry } from "../../Adapter/Core";
 import type { Adaptations, Adapter, Adapting, WithAdaptations } from "../../Adapter/Types";
 import type { ProduceContext } from "../../Random/Types";
+import { type SatisfiesThis } from "../../Schema/Satisfies";
 import type * as tuple from "../tuple/Types";
 import type { Core, From, Resolved, Source } from "./Types";
 /**
@@ -24,6 +25,13 @@ export type Deriver<$From extends From, $To extends Source> = {
  * for the mismatch check against `to`.
  */
 export interface Schema<$From extends From = From, $To extends Source = Source, $Adaptations extends Adaptations = {}> extends Core<$From, $To, $Adaptations> {
+    /**
+     * Check that this schema's fabricated value type is assignable to `$Target`.
+     * Identity at runtime; the target is not carried into later chained calls —
+     * see `object/Schema.ts`'s `satisfies`. The produced type is `to`'s
+     * (`Resolved<$To>`), not `from`'s.
+     */
+    satisfies<$Target>(this: this & SatisfiesThis<Resolved<$To>, $Target>): Schema<$From, $To, $Adaptations>;
     /**
      * Override what this schema maps to in one or more external schema libraries
      * — see `string/Schema.ts`'s `adapt` for the full contract. An unadapted

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

@@ -18,12 +18,11 @@ export type { Denoted, Resolved, Source } from "../object/compute/Types";
  * `from` is stored after `toSchema` (inert per-slot schemas, same as `tuple`).
  * `to` is stored exactly as given, whether a Schema or a builder, so its
  * `[Meta]` and `[Adaptation]` survive: adapters convert it as a nested schema
- * (honoring its own adaptation unless the derive is adapted), and
- * `toValueKind` follows it to the kind a result or override is checked
- * against. `resolve` is plain data from the moment `.as(resolve)` is called.
- * `to` is only used for its shape/type — the value comes entirely from
- * `resolve`, which is why `to` may not even have a buildable recipe (a bare
- * `T.string`/`T.bigint`).
+ * (honoring its own adaptation unless the derive is adapted), and `toValueKind`
+ * follows it to the kind a result or override is checked against. `resolve` is
+ * plain data from the moment `.as(resolve)` is called. `to` is only used for
+ * its shape/type — the value comes entirely from `resolve`, which is why `to`
+ * may not even have a buildable recipe (a bare `T.string`/`T.bigint`).
  */
 export type Meta<$From extends From = From, $To extends Source = Source> = {
     from: $From;

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

@@ -1,6 +1,7 @@
 import { type AdaptationEntry } from "../../Adapter/Core";
 import type { Adaptations, Adapter, Adapting, WithAdaptations } from "../../Adapter/Types";
 import type { Produce } from "../../Random/Types";
+import { type SatisfiesThis } from "../../Schema/Satisfies";
 import type { Core, Fabricated, Items } from "./Types";
 /**
  * The buildable recipe for an `enum`: a weighted set of member values, one of
@@ -14,6 +15,12 @@ export interface Schema<$Items extends Items = Items, $Adaptations extends Adapt
      * validation of `produce`) still has it to check against.
      */
     as: (produce: Produce<Fabricated<$Items>>) => Schema<$Items, $Adaptations>;
+    /**
+     * Check that this schema's fabricated value type is assignable to `$Target`.
+     * Identity at runtime; the target is not carried into later chained calls —
+     * see `object/Schema.ts`'s `satisfies`.
+     */
+    satisfies<$Target>(this: this & SatisfiesThis<Fabricated<$Items>, $Target>): 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.

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

@@ -1,12 +1,19 @@
 import { type AdaptationEntry } from "../../Adapter/Core";
 import type { Adaptations, Adapter, Adapting, WithAdaptations } from "../../Adapter/Types";
-import type { Core, Meta as ThisMeta } from "./Types";
+import { type SatisfiesThis } from "../../Schema/Satisfies";
+import type { Core, Fabricated, 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 "null" differently
+ * only mapping method — an external library that spells "null" differently
  * still needs a way to say so.
  */
 export interface Schema<$Adaptations extends Adaptations = {}> extends Core<ThisMeta, $Adaptations> {
+    /**
+     * Check that this schema's fabricated value type is assignable to `$Target`.
+     * Identity at runtime; the target is not carried into later chained calls —
+     * see `object/Schema.ts`'s `satisfies`.
+     */
+    satisfies<$Target>(this: this & SatisfiesThis<Fabricated, $Target>): Schema<$Adaptations>;
     /**
      * Override what this schema maps to in one or more external schema libraries
      * — see `string/Schema.ts`'s `adapt` for the full contract.

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

@@ -1,6 +1,7 @@
 import { type AdaptationEntry } from "../../Adapter/Core";
 import type { Adaptations, Adapter, Adapting, WithAdaptations } from "../../Adapter/Types";
 import type { Produce } from "../../Random/Types";
+import { type SatisfiesThis } from "../../Schema/Satisfies";
 import type { AnySchema } from "../../Schema/Types";
 import type { Core, Definition, Fabricated, Weights } from "./Types";
 /**
@@ -16,6 +17,12 @@ export interface Schema<$Definition extends Definition = Definition, $Adaptation
      * does.
      */
     as: (produce: Produce<Fabricated<$Definition>>) => Schema<$Definition, $Adaptations>;
+    /**
+     * Check that this schema's fabricated value type is assignable to `$Target`.
+     * Identity at runtime; the target is not carried into later chained calls —
+     * see `object/Schema.ts`'s `satisfies`.
+     */
+    satisfies<$Target>(this: this & SatisfiesThis<Fabricated<$Definition>, $Target>): 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

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

@@ -1,6 +1,7 @@
 import { type AdaptationEntry } from "../../Adapter/Core";
 import type { Adaptations, Adapter, Adapting, WithAdaptations } from "../../Adapter/Types";
 import type { Produce } from "../../Random/Types";
+import { type SatisfiesThis } from "../../Schema/Satisfies";
 import type { AnySchema } from "../../Schema/Types";
 import type { Core, Definition, Fabricated, Weights } from "./Types";
 /**
@@ -16,6 +17,12 @@ export interface Schema<$Definition extends Definition = Definition, $Adaptation
      * built-in three-way roll does.
      */
     as: (produce: Produce<Fabricated<$Definition>>) => Schema<$Definition, $Adaptations>;
+    /**
+     * Check that this schema's fabricated value type is assignable to `$Target`.
+     * Identity at runtime; the target is not carried into later chained calls —
+     * see `object/Schema.ts`'s `satisfies`.
+     */
+    satisfies<$Target>(this: this & SatisfiesThis<Fabricated<$Definition>, $Target>): Schema<$Definition, $Adaptations>;
     /**
      * Reweight the built-in three-way roll. Keys are optional — an omitted key
      * keeps baseline weight `1`, the same weight the uniform 1/3 split already

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

@@ -1,6 +1,7 @@
 import { type AdaptationEntry } from "../../Adapter/Core";
 import type { Adaptations, Adapter, Adapting, WithAdaptations } from "../../Adapter/Types";
 import type { Produce } from "../../Random/Types";
+import { type SatisfiesThis } from "../../Schema/Satisfies";
 import type { Core, Fabricated, JsonSchema, Meta as ThisMeta } from "./Types";
 /**
  * Buildable `number` recipe: a range/distribution (`whereby`, absent for the
@@ -22,6 +23,12 @@ export interface Schema<$Meta extends ThisMeta = ThisMeta, $Adaptations extends
      * against.
      */
     as: (produce: Produce<Fabricated>, hints?: JsonSchema) => Schema<$Meta, $Adaptations>;
+    /**
+     * Check that this schema's fabricated value type is assignable to `$Target`.
+     * Identity at runtime; the target is not carried into later chained calls —
+     * see `object/Schema.ts`'s `satisfies`.
+     */
+    satisfies<$Target>(this: this & SatisfiesThis<Fabricated, $Target>): 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.

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

@@ -1,6 +1,7 @@
 import type { AdaptationEntry } from "../../Adapter/Core";
 import type { Adaptations, Adapter, Adapting, WithAdaptations } from "../../Adapter/Types";
 import type { Produce } from "../../Random/Types";
+import { type SatisfiesThis } from "../../Schema/Satisfies";
 import type { AnySchema } from "../../Schema/Types";
 import type { ShallowMerge } from "../../Utility/ShallowMerge";
 import type { Computer } from "./compute/Schema";
@@ -22,6 +23,14 @@ export interface Schema<$Definition extends Definition = Definition, $Adaptation
      * against.
      */
     as: (produce: Produce<Fabricated<$Definition>>) => Schema<$Definition, $Adaptations>;
+    /**
+     * Check that this schema's fabricated value type is assignable to `$Target`.
+     * Identity at runtime; the target is not carried into later chained calls.
+     * Canonical `.satisfies`; every other kind's method is the same and points
+     * here. See `Schema/Satisfies.ts` for the `this`-param signature and why the
+     * alternatives fail.
+     */
+    satisfies<$Target>(this: this & SatisfiesThis<Fabricated<$Definition>, $Target>): 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. Carried through
@@ -35,7 +44,8 @@ export interface Schema<$Definition extends Definition = Definition, $Adaptation
  * `make` alongside `extend`/`refine`/`override`: those three rebuild from
  * `definition`/`refinements` rather than deriving from this object, so the
  * adaptation map has to be threaded through `make` itself or chaining one of
- * them would drop it (see `make`'s `adapt`).
+ * them would drop it (see `make`'s `adapt`). `as` and `satisfies` are the
+ * methods this factory attaches, so they are what the parameter omits.
  */
-export declare function Schema<$Definition extends Definition, $Adaptations extends Adaptations = {}>(schema: Omit<Schema<$Definition, $Adaptations>, "as">): Schema<$Definition, $Adaptations>;
+export declare function Schema<$Definition extends Definition, $Adaptations extends Adaptations = {}>(schema: Omit<Schema<$Definition, $Adaptations>, "as" | "satisfies">): Schema<$Definition, $Adaptations>;
 export declare function isObjectSchema(candidate: AnySchema): candidate is Schema;

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

@@ -1,6 +1,7 @@
 import { type AdaptationEntry } from "../../../Adapter/Core";
 import type { Adaptations, Adapter, Adapting, WithAdaptations } from "../../../Adapter/Types";
 import type { AnySchema } from "../../../Schema/Types";
+import { type SatisfiesThis } from "../../../Schema/Satisfies";
 import type * as object from "../Types";
 import type { Core, Resolved, Source } from "./Types";
 export type Computer<$Definition extends object.Definition> = <const $Source extends Source>(source: $Source) => {
@@ -9,6 +10,13 @@ export type Computer<$Definition extends object.Definition> = <const $Source ext
     }) => NoInfer<Resolved<$Source>>) => Schema<object.Fabricated<$Definition>, $Source>;
 };
 export interface Schema<$Fabricated, $Source extends Source, $Adaptations extends Adaptations = {}> extends Core<$Fabricated, $Source, $Adaptations> {
+    /**
+     * Check that this schema's fabricated value type is assignable to `$Target`.
+     * Identity at runtime; the target is not carried into later chained calls —
+     * see `object/Schema.ts`'s `satisfies`. The produced type is `source`'s
+     * (`Resolved<$Source>`), not the enclosing object's.
+     */
+    satisfies<$Target>(this: this & SatisfiesThis<Resolved<$Source>, $Target>): Schema<$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

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

@@ -1,8 +1,9 @@
 import { type AdaptationEntry } from "../../../Adapter/Core";
 import type { Adaptations, Adapter, Adapting, WithAdaptations } from "../../../Adapter/Types";
 import type { Produce } from "../../../Random/Types";
+import { type SatisfiesThis } from "../../../Schema/Satisfies";
 import type { AnySchema } from "../../../Schema/Types";
-import type { Core, Definition, Resolved, Weights } from "./Types";
+import type { Core, Definition, Fabricated, 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
@@ -12,6 +13,14 @@ export interface Schema<$Definition extends Definition = Definition, $Adaptation
      * built-in roll does.
      */
     as: (produce: Produce<Resolved<$Definition>>) => Schema<$Definition, $Adaptations>;
+    /**
+     * Check that this schema's fabricated value type is assignable to `$Target`.
+     * Identity at runtime; the target is not carried into later chained calls —
+     * see `object/Schema.ts`'s `satisfies`. The produced type is the wrapped
+     * value (not `Omitted`); omission is a fact about the enclosing object's
+     * keys, which is why this check lives more usefully on the object.
+     */
+    satisfies<$Target>(this: this & SatisfiesThis<Fabricated<$Definition>, $Target>): 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 —

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

@@ -1,8 +1,9 @@
 import { type AdaptationEntry } from "../../../Adapter/Core";
 import type { Adaptations, Adapter, Adapting, WithAdaptations } from "../../../Adapter/Types";
 import type { Produce } from "../../../Random/Types";
+import { type SatisfiesThis } from "../../../Schema/Satisfies";
 import type { AnySchema } from "../../../Schema/Types";
-import type { Core, Definition, Resolved, Weights } from "./Types";
+import type { Core, Definition, Fabricated, 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
@@ -12,6 +13,13 @@ export interface Schema<$Definition extends Definition = Definition, $Adaptation
      * built-in three-way roll does.
      */
     as: (produce: Produce<Resolved<$Definition>>) => Schema<$Definition, $Adaptations>;
+    /**
+     * Check that this schema's fabricated value type is assignable to `$Target`.
+     * Identity at runtime; the target is not carried into later chained calls —
+     * see `object/Schema.ts`'s `satisfies`. The produced type includes `|
+     * undefined`; omission is a fact about the enclosing object's keys.
+     */
+    satisfies<$Target>(this: this & SatisfiesThis<Fabricated<$Definition>, $Target>): Schema<$Definition, $Adaptations>;
     /**
      * Reweight the built-in three-way roll. Keys are optional — an omitted key
      * keeps baseline weight `1`, the same weight the uniform 1/3 split already

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

@@ -1,6 +1,7 @@
 import { type AdaptationEntry } from "../../Adapter/Core";
 import type { Adaptations, Adapter, Adapting, WithAdaptations } from "../../Adapter/Types";
-import type { Core } from "./Types";
+import { type SatisfiesThis } from "../../Schema/Satisfies";
+import type { Core, Fabricated } 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
@@ -12,6 +13,12 @@ import type { Core } from "./Types";
  * imprecise, and `.adapt(typebox, ...)` is the only way to say more.
  */
 export interface Schema<$T = unknown, $Adaptations extends Adaptations = {}> extends Core<$T, $Adaptations> {
+    /**
+     * Check that this schema's fabricated value type is assignable to `$Target`.
+     * Identity at runtime; the target is not carried into later chained calls —
+     * see `object/Schema.ts`'s `satisfies`.
+     */
+    satisfies<$Target>(this: this & SatisfiesThis<Fabricated<$T>, $Target>): Schema<$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.

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

@@ -1,6 +1,7 @@
 import { type AdaptationEntry } from "../../Adapter/Core";
 import type { Adaptations, Adapter, Adapting, WithAdaptations } from "../../Adapter/Types";
 import type { Produce } from "../../Random/Types";
+import { type SatisfiesThis } from "../../Schema/Satisfies";
 import type { Core, Fabricated, Key, Value } from "./Types";
 /**
  * The buildable recipe for a `record`: a key Schema and a value Schema, drawn
@@ -14,6 +15,12 @@ export interface Schema<$Key extends Key = Key, $Value extends Value = Value, $A
      * (or future validation of `produce`) still has them to check against.
      */
     as: (produce: Produce<Fabricated<$Key, $Value>>) => Schema<$Key, $Value, $Adaptations>;
+    /**
+     * Check that this schema's fabricated value type is assignable to `$Target`.
+     * Identity at runtime; the target is not carried into later chained calls —
+     * see `object/Schema.ts`'s `satisfies`.
+     */
+    satisfies<$Target>(this: this & SatisfiesThis<Fabricated<$Key, $Value>, $Target>): 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

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

@@ -48,8 +48,8 @@ export type Fabricated<$Key extends Key = Key, $Value extends Value = Value, $Bi
  * so. `minTried` is optional, default `0`, matching `string`'s
  * `whereby.length.min`.
  *
- * No bare-number form (unlike `array`'s `length`): "exactly N" is a promise a
- * collapsing key set cannot keep.
+ * No bare-number form (unlike `string`'s and `array`'s `length`): "exactly N"
+ * is a promise a collapsing key set cannot keep.
  */
 export type Whereby = {
     size: {

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

@@ -1,6 +1,7 @@
 import { type AdaptationEntry } from "../../Adapter/Core";
 import type { Adaptations, Adapter, Adapting, WithAdaptations } from "../../Adapter/Types";
-import type { Core } from "./Types";
+import { type SatisfiesThis } from "../../Schema/Satisfies";
+import type { Core, Fabricated } from "./Types";
 /**
  * A recursive schema, produced by `.whereby({ depth })` — see `Registry.ts` for
  * the builder `T.recursive(body)` itself returns. `terminal` is optional there;
@@ -12,6 +13,12 @@ import type { Core } from "./Types";
  * out, since adding it later is non-breaking.
  */
 export interface Schema<$Body = unknown, $Adaptations extends Adaptations = {}> extends Core<$Body, $Adaptations> {
+    /**
+     * Check that this schema's fabricated value type is assignable to `$Target`.
+     * Identity at runtime; the target is not carried into later chained calls —
+     * see `object/Schema.ts`'s `satisfies`.
+     */
+    satisfies<$Target>(this: this & SatisfiesThis<Fabricated<$Body>, $Target>): Schema<$Body, $Adaptations>;
     /**
      * Override what this schema maps to in one or more external schema libraries
      * — see `string/Schema.ts`'s `adapt` for the full contract.

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

@@ -1,6 +1,7 @@
 import { type AdaptationEntry } from "../../../Adapter/Core";
 import type { Adaptations, Adapter, Adapting, WithAdaptations } from "../../../Adapter/Types";
-import type { Core } from "./Types";
+import { type SatisfiesThis } from "../../../Schema/Satisfies";
+import type { Core, Fabricated } from "./Types";
 /**
  * The placeholder `T.recursive`'s body callback receives in place of the schema
  * being defined — everywhere `self` appears, it stands for "recurse one level
@@ -15,6 +16,15 @@ import type { Core } from "./Types";
  * other kind.
  */
 export interface Schema<$Adaptations extends Adaptations = {}> extends Core<$Adaptations> {
+    /**
+     * Check that this schema's fabricated value type is assignable to `$Target`.
+     * Identity at runtime; the target is not carried into later chained calls —
+     * see `object/Schema.ts`'s `satisfies`. Outside `ValueOf`'s `$Bindings`,
+     * `Fabricated` is `unknown` — a `self` has no value of its own. Put
+     * `.satisfies` on the enclosing `T.recursive(...).whereby(...)` to check the
+     * tree.
+     */
+    satisfies<$Target>(this: this & SatisfiesThis<Fabricated, $Target>): Schema<$Adaptations>;
     adapt: <const $Adapter extends Adapter, $Returnable extends ReturnType<$Adapter["convert"]>>(adapter: $Adapter, produce: (adapting: Adapting<Schema<$Adaptations>>) => $Returnable) => Schema<WithAdaptations<$Adaptations, AdaptationEntry<$Adapter, $Returnable>>>;
 }
 export declare function Schema<$Adaptations extends Adaptations = {}>(schema: Core<$Adaptations>): Schema<$Adaptations>;

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

@@ -19,17 +19,21 @@ declare const _default: {
         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.
+     * A string of `length` UTF-16 code units. `length` is a bare `N` (exactly N)
+     * or `{ min?, max, distribution? }`. `min` defaults to inclusive 0. Exclusive
+     * ends use a Bound object. A bare `N` is stored as min = max = N inclusive
+     * and carries no distribution. Without `distribution`, the length is drawn
+     * uniformly across the inclusive interval; `distribution` shapes that draw
+     * the same way it does for `T.number.integer`.
+     *
      * Pass `composition` to control which characters appear and in what
      * proportion; without one, characters span all Unicode scalar values (the
-     * codespace minus surrogates, so always well-formed UTF-16).
-     *
-     * `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.
+     * codespace minus surrogates, so always well-formed UTF-16). 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.
      */
     whereby: (whereby: InputWhereby) => Schema<{
         whereby: Whereby;

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

@@ -1,6 +1,7 @@
 import { type AdaptationEntry } from "../../Adapter/Core";
 import type { Adaptations, Adapter, Adapting, WithAdaptations } from "../../Adapter/Types";
 import type { Produce } from "../../Random/Types";
+import { type SatisfiesThis } from "../../Schema/Satisfies";
 import type { Core, Fabricated, JsonSchema, Meta as ThisMeta } from "./Types";
 /**
  * Buildable `string` recipe: length/composition (`whereby` — required, unlike
@@ -19,6 +20,12 @@ export interface Schema<$Meta extends ThisMeta = ThisMeta, $Adaptations extends
      * validation of `produce`) still has it to check against.
      */
     as: (produce: Produce<Fabricated>, hints?: JsonSchema) => Schema<$Meta, $Adaptations>;
+    /**
+     * Check that this schema's fabricated value type is assignable to `$Target`.
+     * Identity at runtime; the target is not carried into later chained calls —
+     * see `object/Schema.ts`'s `satisfies`.
+     */
+    satisfies<$Target>(this: this & SatisfiesThis<Fabricated, $Target>): Schema<$Meta, $Adaptations>;
     /**
      * Override what this schema maps to in one external schema library, for a
      * contract no native kind expresses — a `string` that is really an email, a