@ghostry/fabricator 0.0.7 → 0.0.9

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

@@ -0,0 +1,44 @@
+import type { AdaptationsOf } from "../../Adapter/Types";
+import type { FabricatorContext, NaiveFabricator } from "../../Fabricator/Types";
+import type { Trace } from "../../Random/Types";
+import { Children, Kind, Meta, type Adaptation } from "../../Types";
+import type { Fabricated as FromValues } from "../tuple/Types";
+import { Schema } from "./Schema";
+import type { From, Meta as ThisMeta, Resolved, Source } from "./Types";
+export type Fabrication<$Fabricator extends Fabricator> = $Fabricator extends Fabricator<infer $Schema extends {
+    [Meta]: ThisMeta;
+}> ? Resolved<$Schema[typeof Meta]["to"]> : never;
+export type Fabricator<$Schema extends {
+    [Meta]: ThisMeta;
+} = {
+    [Meta]: ThisMeta;
+}> = NaiveFabricator<Resolved<$Schema[typeof Meta]["to"]>> & {
+    [Kind]: "derive";
+    [Meta]: $Schema[typeof Meta];
+    readonly trace: Trace;
+    [Children]: ReadonlyArray<NaiveFabricator<any>>;
+    readonly [Adaptation]?: AdaptationsOf<$Schema>;
+    /**
+     * Given `from`, resolves those values instead of fabricating each slot.
+     * Enumeration uses this to pin `from` slots and still run `resolve` on them
+     * (see `Enumeration/Plan.ts`).
+     */
+    fabricate: (params?: {
+        from: FromValues<$Schema[typeof Meta]["from"]>;
+    }) => Resolved<$Schema[typeof Meta]["to"]>;
+    schema: Schema<$Schema[typeof Meta]["from"], $Schema[typeof Meta]["to"], AdaptationsOf<$Schema>>;
+};
+/**
+ * `from` are each input slot's _already-dispatched_ Fabricator, one per
+ * `[Meta].from` entry, built by `Constructor.ts`'s `make` before this call —
+ * the same shape `tuple.Fabricator`'s `elements` take. Each slot gets its own
+ * private stream, so two same-kind inputs produce independent sequences rather
+ * than a correlated shared one.
+ *
+ * `toStreamFromTrace` is always consulted: `resolve` is required (there is no
+ * bare path) and is handed this node's `ProduceContext`, so any extra
+ * randomness it draws still replays under a salt. Don't collapse that into a
+ * conditional — `resolve` is the equivalent of every other kind's `produce`,
+ * and here it is always present.
+ */
+export declare function Fabricator<$From extends From, $To extends Source>(context: FabricatorContext<Schema<$From, $To>>, from: ReadonlyArray<NaiveFabricator<any>>): Fabricator<Schema<$From, $To>>;

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

@@ -0,0 +1,6 @@
+import { type Deriver } from "./Schema";
+import type { From, Source } from "./Types";
+export default function <const $From extends From, const $To extends Source>({ to, from, }: {
+    to: $To;
+    from: $From;
+}): Deriver<$From, $To>;

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

@@ -0,0 +1,44 @@
+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";
+/**
+ * What `T.derive({ to, from })` returns: not yet a Schema — `.as(resolve)` is
+ * what produces one, matching `compute(source).as(resolve)`. There is no
+ * re-`.as()` on the Schema; the resolver fully determines production.
+ */
+export type Deriver<$From extends From, $To extends Source> = {
+    /**
+     * Supply the function that turns `from`'s fabricated values into the result
+     * `to` names. `values` is the positional tuple of those values; `context` is
+     * this node's own `{ random, clock }`, so any extra draw still replays under
+     * a salt.
+     */
+    as: (resolve: (values: tuple.Fabricated<$From>, context: ProduceContext) => NoInfer<Resolved<$To>>) => Schema<$From, $To>;
+};
+/**
+ * Buildable `derive` recipe: a value computed from other schemas' fabricated
+ * output. `from` is fabricated independently (one Fabricator per slot, like
+ * `tuple`); `to` declares only the result's type and shape. See `Fabricator.ts`
+ * 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
+     * derive maps to whatever `to` maps to, honoring any adaptation already on
+     * `to`. Adapting the derive itself overrides that, which is how to say the
+     * derive's mapping differs from `to`'s.
+     */
+    adapt: <const $Adapter extends Adapter, $Returnable extends ReturnType<$Adapter["convert"]>>(adapter: $Adapter, produce: (adapting: Adapting<Schema<$From, $To, $Adaptations>>) => $Returnable) => Schema<$From, $To, WithAdaptations<$Adaptations, AdaptationEntry<$Adapter, $Returnable>>>;
+}
+export declare function Schema<$From extends From, $To extends Source, $Adaptations extends Adaptations = {}>(schema: Core<$From, $To, $Adaptations>): Schema<$From, $To, $Adaptations>;

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

@@ -0,0 +1,38 @@
+import type { Adaptations } from "../../Adapter/Types";
+import type { ProduceContext } from "../../Random/Types";
+import type { Adaptation, Kind, Meta, Produces } from "../../Types";
+import type { Resolved, Source } from "../object/compute/Types";
+import type * as tuple from "../tuple/Types";
+/**
+ * `from` is a tuple of schemas, one per input slot — the same shape
+ * `tuple.Items` already is, so `tuple.Fabricated` can type `resolve`'s `values`
+ * as a positional `[A, B]` rather than `(A | B)[]`.
+ */
+export type From = tuple.Items;
+/**
+ * Re-exported so this kind's other files (and `Primitive.derive.Source`) name
+ * the same `to` contract `object.compute` uses, rather than restating it.
+ */
+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`).
+ */
+export type Meta<$From extends From = From, $To extends Source = Source> = {
+    from: $From;
+    to: $To;
+    resolve: (values: tuple.Fabricated<$From>, context: ProduceContext) => Resolved<$To>;
+};
+export interface Core<$From extends From = From, $To extends Source = Source, $Adaptations extends Adaptations = {}> {
+    [Kind]: "derive";
+    [Meta]: Meta<$From, $To>;
+    bindings?: unknown[];
+    readonly [Produces]?: Resolved<$To, NonNullable<this["bindings"]>>;
+    readonly [Adaptation]?: $Adaptations;
+}

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

@@ -0,0 +1,5 @@
+export * from "./Types";
+export * from "./Schema";
+export * from "./Fabricator";
+export * from "./Registry";
+export { default } from "./Registry";

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

@@ -13,14 +13,24 @@ type Weighted<$Items extends ReadonlyArray<Item>> = {
     [$K in keyof $Items]: readonly [number, $Items[$K]];
 };
 /**
- * At least one element — an empty `enum` has no member to draw, which would
- * otherwise fail inside `weighted()` (`Distribution/index.ts`) with an opaque
- * `TypeError` at fabricate time (weight sum is `0`, so `.find` returns
- * `undefined` and `chosen![1]` throws). Rejecting emptiness here is a
- * construction-time compile error; the runtime check below is the backstop for
- * an `as any` call that bypasses it.
+ * At least one element — an `enum` with no member has nothing to draw, which
+ * would otherwise fail inside `weighted()` (`Distribution/index.ts`) with an
+ * opaque `TypeError` at fabricate time (weight sum is `0`, so `.find` returns
+ * `undefined` and `chosen![1]` throws).
+ *
+ * Only a _statically_ empty tuple (a literal `[]`) is a compile error. A
+ * dynamically built array — e.g. `.map()` over an `as const` array — is
+ * accepted: its element union survives but its arity doesn't, so it can't be
+ * proven non-empty and a tuple-shaped `readonly [$T, ...$T[]]` constraint would
+ * wrongly reject it. The runtime check below is the backstop for that case, and
+ * for an `as any` call.
+ *
+ * Intersected onto the parameter (`items: $Items & NonEmpty<$Items>`) rather
+ * than written as a conditional parameter type (`$Items extends readonly [] ?
+ * never : $Items`): the latter blocks `const` inference, widening `["a", "b"]`
+ * to `string[]` and losing the tuple `Weighted` depends on.
  */
-type NonEmpty<$T> = readonly [$T, ...$T[]];
+type NonEmpty<$Items extends ReadonlyArray<unknown>> = $Items extends readonly [] ? never : unknown;
 declare const _default: {
     /**
      * Equal probability across every member. Delegates to `weighted` with a
@@ -28,12 +38,12 @@ declare const _default: {
      * uniform draw when every weight is equal, so there is no separate unweighted
      * code path to keep in sync.
      */
-    uniform: <const $Items extends NonEmpty<Item>>(items: $Items) => Schema<Weighted<$Items>>;
+    uniform: <const $Items extends ReadonlyArray<Item>>(items: $Items & NonEmpty<$Items>) => Schema<Weighted<$Items>>;
     /**
      * Relative probability across members, given as `[weight, item]` pairs — the
      * same tuple shape `weighted()` (`Distribution/index.ts`) itself accepts, not
      * an object keyed by member.
      */
-    weighted: <const $Items extends NonEmpty<Items[number]>>(items: $Items) => Schema<$Items>;
+    weighted: <const $Items extends Items>(items: $Items & NonEmpty<$Items>) => Schema<$Items>;
 };
 export default _default;

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/index.d.ts

@@ -6,6 +6,7 @@ export { default as bigint } from "./bigint";
 export { default as boolean } from "./boolean";
 export { default as choice } from "./choice";
 export { default as date } from "./date";
+export { default as derive } from "./derive";
 export { default as enum } from "./enum";
 export { default as null } from "./null";
 export { default as nullable } from "./nullable";
@@ -23,6 +24,6 @@ export { default as tuple } from "./tuple";
 export { default as undefinable } from "./undefinable";
 export { default as undefined } from "./undefined";
 export { Primitive };
-export type Fabricator = Primitive.always.Fabricator<any> | Primitive.array.Fabricator<any> | Primitive.bigint.Fabricator | Primitive.boolean.Fabricator | Primitive.choice.Fabricator<any> | Primitive.date.Fabricator | Primitive.enum.Fabricator<any> | Primitive.null.Fabricator | Primitive.nullable.Fabricator<any> | Primitive.nullish.Fabricator<any> | Primitive.number.Fabricator | Primitive.object.Fabricator<any> | Primitive.object.compute.Fabricator<any, any> | Primitive.object.omittable.Fabricator<any> | Primitive.object.optional.Fabricator<any> | Primitive.opaque.Fabricator<any> | Primitive.record.Fabricator<any> | Primitive.recursive.Fabricator<any> | Primitive.recursive.self.Fabricator<any> | Primitive.string.Fabricator | Primitive.symbol.Fabricator | Primitive.tuple.Fabricator<any> | Primitive.undefined.Fabricator | Primitive.undefinable.Fabricator<any>;
-export type Schema = Primitive.always.Schema<any> | Primitive.array.Schema<any> | Primitive.bigint.Schema | Primitive.boolean.Schema | Primitive.choice.Schema<any> | Primitive.date.Schema | Primitive.enum.Schema<any> | Primitive.null.Schema | Primitive.nullable.Schema<any> | Primitive.nullish.Schema<any> | Primitive.number.Schema | Primitive.object.Schema<any> | Primitive.object.compute.Schema<any, any> | Primitive.object.omittable.Schema<any> | Primitive.object.optional.Schema<any> | Primitive.opaque.Schema<any> | Primitive.record.Schema<any, any> | Primitive.recursive.Schema<any> | Primitive.recursive.self.Schema<any> | Primitive.string.Schema | Primitive.symbol.Schema | Primitive.tuple.Schema<any> | Primitive.undefined.Schema | Primitive.undefinable.Schema<any>;
+export type Fabricator = Primitive.always.Fabricator<any> | Primitive.array.Fabricator<any> | Primitive.bigint.Fabricator | Primitive.boolean.Fabricator | Primitive.choice.Fabricator<any> | Primitive.date.Fabricator | Primitive.derive.Fabricator<any> | Primitive.enum.Fabricator<any> | Primitive.null.Fabricator | Primitive.nullable.Fabricator<any> | Primitive.nullish.Fabricator<any> | Primitive.number.Fabricator | Primitive.object.Fabricator<any> | Primitive.object.compute.Fabricator<any, any> | Primitive.object.omittable.Fabricator<any> | Primitive.object.optional.Fabricator<any> | Primitive.opaque.Fabricator<any> | Primitive.record.Fabricator<any> | Primitive.recursive.Fabricator<any> | Primitive.recursive.self.Fabricator<any> | Primitive.string.Fabricator | Primitive.symbol.Fabricator | Primitive.tuple.Fabricator<any> | Primitive.undefined.Fabricator | Primitive.undefinable.Fabricator<any>;
+export type Schema = Primitive.always.Schema<any> | Primitive.array.Schema<any> | Primitive.bigint.Schema | Primitive.boolean.Schema | Primitive.choice.Schema<any> | Primitive.date.Schema | Primitive.derive.Schema<any, any> | Primitive.enum.Schema<any> | Primitive.null.Schema | Primitive.nullable.Schema<any> | Primitive.nullish.Schema<any> | Primitive.number.Schema | Primitive.object.Schema<any> | Primitive.object.compute.Schema<any, any> | Primitive.object.omittable.Schema<any> | Primitive.object.optional.Schema<any> | Primitive.opaque.Schema<any> | Primitive.record.Schema<any, any> | Primitive.recursive.Schema<any> | Primitive.recursive.self.Schema<any> | Primitive.string.Schema | Primitive.symbol.Schema | Primitive.tuple.Schema<any> | Primitive.undefined.Schema | Primitive.undefinable.Schema<any>;
 export type Kind = Schema[typeof Kind];

package/dist/types/Primitive/namespace.d.ts

@@ -22,6 +22,7 @@ export * as bigint from "./bigint";
 export * as boolean from "./boolean";
 export * as choice from "./choice";
 export * as date from "./date";
+export * as derive from "./derive";
 export * as enum from "./enum";
 export * as null from "./null";
 export * as nullable from "./nullable";

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