@ghostry/fabricator 0.0.7 → 0.0.9

package/dist/esm/Primitive/recursive/Schema.js

@@ -1,9 +1,11 @@
 import { withAdaptations } from "../../Adapter/Core.js";
+import { schemaSatisfies } from "../../Schema/Satisfies.js";
 import { Kind } from "../../Types.js";
 function Schema(schema) {
     return {
         ...schema,
         [Kind]: "recursive",
+        satisfies: schemaSatisfies,
         adapt: (adapter, produce)=>Schema(withAdaptations(schema, adapter, produce))
     };
 }

package/dist/esm/Primitive/recursive/Terminate.js

@@ -80,6 +80,18 @@ function terminateAt(schema, path) {
                         ]))
                 });
             }
+        case "derive":
+            {
+                const s = schema;
+                return withMeta(s, {
+                    ...s[Meta],
+                    from: s[Meta].from.map((item, i)=>terminateAt(item, [
+                            ...path,
+                            "from",
+                            String(i)
+                        ]))
+                });
+            }
         case "object.compute":
             {
                 const s = schema;
@@ -164,6 +176,11 @@ function containsSelf(schema) {
                 const s = schema;
                 return s[Meta].items.some((item)=>containsSelf(item));
             }
+        case "derive":
+            {
+                const s = schema;
+                return s[Meta].from.some((item)=>containsSelf(item));
+            }
         case "object.compute":
             {
                 const s = schema;

package/dist/esm/Primitive/recursive/self/Schema.js

@@ -1,9 +1,11 @@
 import { withAdaptations } from "../../../Adapter/Core.js";
+import { schemaSatisfies } from "../../../Schema/Satisfies.js";
 import { Kind } from "../../../Types.js";
 function Schema(schema) {
     return {
         ...schema,
         [Kind]: "recursive.self",
+        satisfies: schemaSatisfies,
         adapt: (adapter, produce)=>Schema(withAdaptations(schema, adapter, produce))
     };
 }

package/dist/esm/Primitive/string/Fabricator.js

@@ -1,5 +1,5 @@
 import { effectiveDiscrete } from "../../Bound.js";
-import { weighted } from "../../Distribution/index.js";
+import { discreteSampler, weighted } from "../../Distribution/index.js";
 import { toStreamFromTrace } from "../../Random/index.js";
 import { Kind, Meta } from "../../Types.js";
 import { inline } from "../../Utility/Core.js";
@@ -26,6 +26,10 @@ function Fabricator(context) {
     const stream = toStreamFromTrace(algorithm, trace);
     const whereby = meta.whereby;
     const { min, max } = effectiveDiscrete(whereby.length.min, whereby.length.max);
+    const drawLength = discreteSampler(whereby.length.distribution, {
+        min,
+        max
+    }, stream);
     const sources = inline(()=>{
         const composition = whereby.composition;
         if (void 0 === composition) return [
@@ -46,7 +50,7 @@ function Fabricator(context) {
         ]), stream, "T.string.whereby.composition");
     const fill = compiler(bmpScalars, stream);
     const fabricate = ()=>{
-        const length = min + Math.floor(stream.next() * (max - min + 1));
+        const length = drawLength();
         const pieces = [];
         let remaining = length;
         while(remaining > 0){

package/dist/esm/Primitive/string/Schema.js

@@ -1,4 +1,5 @@
 import { withAdaptations } from "../../Adapter/Core.js";
+import { schemaSatisfies } from "../../Schema/Satisfies.js";
 import { Kind, Meta } from "../../Types.js";
 function Schema(schema) {
     return {
@@ -12,6 +13,7 @@ function Schema(schema) {
                     hints
                 }
             }),
+        satisfies: schemaSatisfies,
         adapt: (adapter, produce)=>Schema(withAdaptations(schema, adapter, produce))
     };
 }

package/dist/esm/Primitive/symbol/Schema.js

@@ -1,4 +1,5 @@
 import { withAdaptations } from "../../Adapter/Core.js";
+import { schemaSatisfies } from "../../Schema/Satisfies.js";
 import { Kind, Meta } from "../../Types.js";
 function Schema(schema) {
     return {
@@ -11,6 +12,7 @@ function Schema(schema) {
                     produce
                 }
             }),
+        satisfies: schemaSatisfies,
         adapt: (adapter, produce)=>Schema(withAdaptations(schema, adapter, produce))
     };
 }

package/dist/esm/Primitive/tuple/Schema.js

@@ -1,4 +1,5 @@
 import { withAdaptations } from "../../Adapter/Core.js";
+import { schemaSatisfies } from "../../Schema/Satisfies.js";
 import { Kind, Meta } from "../../Types.js";
 function Schema(schema) {
     return {
@@ -11,6 +12,7 @@ function Schema(schema) {
                     produce
                 }
             }),
+        satisfies: schemaSatisfies,
         adapt: (adapter, produce)=>Schema(withAdaptations(schema, adapter, produce))
     };
 }

package/dist/esm/Primitive/undefinable/Schema.js

@@ -1,5 +1,6 @@
 import { withAdaptations } from "../../Adapter/Core.js";
 import { assertDrawableKeyedWeights } from "../../Distribution/index.js";
+import { schemaSatisfies } from "../../Schema/Satisfies.js";
 import { Kind, Meta } from "../../Types.js";
 import { outcomes } from "./Outcomes.js";
 function Schema(schema) {
@@ -13,6 +14,7 @@ function Schema(schema) {
                     produce
                 }
             }),
+        satisfies: schemaSatisfies,
         weighted: (weights)=>{
             const merged = {
                 ...schema[Meta].weights,

package/dist/esm/Primitive/undefined/Schema.js

@@ -1,9 +1,11 @@
 import { withAdaptations } from "../../Adapter/Core.js";
+import { schemaSatisfies } from "../../Schema/Satisfies.js";
 import { Kind } from "../../Types.js";
 function Schema(schema) {
     return {
         ...schema,
         [Kind]: "undefined",
+        satisfies: schemaSatisfies,
         adapt: (adapter, produce)=>Schema(withAdaptations(schema, adapter, produce))
     };
 }

package/dist/esm/Schema/Core.js

@@ -11,6 +11,16 @@ function toSchema(value) {
         [Meta]: value[Meta]
     };
 }
+function toValueKind(schema) {
+    switch(schema[Kind]){
+        case "object.compute":
+            return toValueKind(schema[Meta].source);
+        case "derive":
+            return toValueKind(schema[Meta].to);
+        default:
+            return schema[Kind];
+    }
+}
 function violatesKind(kind, value) {
     switch(kind){
         case "object":
@@ -55,6 +65,8 @@ function violatesKind(kind, value) {
             return false;
         case "object.compute":
             return false;
+        case "derive":
+            return false;
         case "object.omittable":
             return false;
         case "object.optional":
@@ -65,4 +77,4 @@ function violatesKind(kind, value) {
             return never(kind);
     }
 }
-export { toSchema, violatesKind };
+export { toSchema, toValueKind, violatesKind };

package/dist/esm/Schema/Satisfies.js

@@ -0,0 +1,5 @@
+function schemaSatisfies() {
+    return this;
+}
+function satisfies(buildable) {}
+export { satisfies, schemaSatisfies };

package/dist/esm/index.js

@@ -9,4 +9,6 @@ export { layer } from "./Random/index.js";
 export { FabricatorError } from "./Error/index.js";
 export { registry } from "./Schema/Registry.js";
 export { effectiveDiscrete, toBound } from "./Bound.js";
+export { sample, shuffle } from "./Distribution/index.js";
+export { satisfies } from "./Schema/Satisfies.js";
 export { initialize };

package/dist/types/Bound.d.ts

@@ -1,3 +1,4 @@
+import type { Distribution } from "./Distribution";
 /**
  * Canonical endpoint stored on `[Meta].whereby`. Call sites still accept a
  * scalar (inclusive) via {@link InputBound}; `.whereby()` runs {@link toBound} so
@@ -56,13 +57,28 @@ export declare function towardInterior(value: number, toward: number): number;
 export declare function constrainContinuous(next: () => number, min: Bound<number>, max: Bound<number>): () => number;
 export declare function epochBound(bound: Bound<Date>): Bound<number>;
 /**
- * Array/string `length`: a bare number is an exact count; an omitted `min` is
- * inclusive `0`. Always stored as a Bound pair so adapters have one path.
+ * Call-site `length` for `string` and `array`: a bare number is an exact count,
+ * and `{ max, min?, distribution? }` is a range. A scalar end is inclusive.
  */
-export declare function toLengthRange(length: number | {
+export type InputLength = number | {
     max: InputBound<number>;
     min?: InputBound<number> | undefined;
-}, label: string): {
+    distribution?: Distribution | undefined;
+};
+/**
+ * Stored `length`: both ends are canonical {@link Bound}s. `distribution` is
+ * present only when the caller set one, so a bare count and an unspecified
+ * distribution stay off the stored object.
+ */
+export type Length = {
     min: Bound<number>;
     max: Bound<number>;
+    distribution?: Distribution | undefined;
 };
+/**
+ * Array/string `length`: a bare number is an exact count (no distribution); an
+ * omitted `min` is inclusive `0`. Always stored as a Bound pair so adapters
+ * have one path. `distribution` is copied only when the caller set one,
+ * matching `date/Registry.ts`'s `toWhereby`, so stored meta stays minimal.
+ */
+export declare function toLengthRange(length: InputLength, label: string): Length;

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

@@ -88,6 +88,20 @@ export declare namespace Distribution {
      */
     const custom: (shape: (u: number) => number) => Distribution;
 }
+/**
+ * Integer draw over the inclusive `[min, max]` of `range`. Samples `[min, max +
+ * 1)` and floors, so each integer owns a full-width bucket — avoiding the
+ * half-width endpoint bias that rounding a `[min, max]` draw would produce. An
+ * omitted `distribution` is uniform. `range` is already the effective inclusive
+ * interval; exclusive ends are the caller's to resolve (`effectiveDiscrete`).
+ *
+ * The `Math.min(max, …)` clamp is load-bearing, not defensive. `max + 1` is
+ * exact even at `Number.MAX_SAFE_INTEGER` (it is 2^53), but near there doubles
+ * are spaced 1 apart, so `sampler`'s `(1 - u) * min + u * (max + 1)` can round
+ * up to exactly `max + 1` — e.g. `[MAX_SAFE_INTEGER - 10, MAX_SAFE_INTEGER]` —
+ * which would floor to one past `max`.
+ */
+export declare function discreteSampler(distribution: Distribution | undefined, range: Range, stream: Stream): () => number;
 /**
  * Build a sampler that draws values within `range` following `distribution`.
  * Each call consumes one fresh uniform draw and, by construction, returns a
@@ -96,6 +110,11 @@ export declare namespace Distribution {
  * clamped.
  */
 export declare function sampler(distribution: Distribution, range: Range, stream: Stream): () => number;
+/**
+ * A uniform pick from `list`. One `stream.next()` per call; `list` is not
+ * mutated. An empty list throws {@link FabricatorError.EmptyItemsError} — there
+ * is no member to return.
+ */
 export declare function sample<$T>(list: ReadonlyArray<$T>, stream: Stream): $T;
 /**
  * Fisher–Yates (Durstenfeld) shuffle: a new array holding `items` in a

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

@@ -29,9 +29,10 @@ export type Orderer = (width: bigint) => ReadonlyArray<bigint>;
  * Recipe for one enumerated combination against a built Fabricator tree:
  * `undefined` for a drawn (not chosen) node — fabricate normally; `{ value }`
  * for a literal (enum member, boolean, `null`, `undefined`, `Omitted`); `{
- * slots }`/`{ fields }` for a tuple/object, recursing per position/key; `{
- * branch, inner }` for a choice's chosen option, or a presence wrapper's
- * "present" arm, recursing into whichever child was picked.
+ * slots }` for a tuple or a derive's `from`, recursing per position; `{ fields
+ * }` for an object, recursing per key; `{ branch, inner }` for a choice's
+ * chosen option, or a presence wrapper's "present" arm, recursing into
+ * whichever child was picked.
  */
 export type Pin = undefined | {
     value: unknown;

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

@@ -112,26 +112,33 @@ export declare namespace FabricatorError {
         during: Phase);
     }
     /**
-     * `T.enum`/`T.choice` given no items. An empty draw table has nothing to
-     * select, which would otherwise surface as an opaque `TypeError` inside
-     * `weighted()` at fabricate time rather than here.
+     * A pick with nothing to pick from: `T.enum`/`T.choice` given no items, or
+     * `sample()` (`Distribution/index.ts`) given an empty list. Emptiness is
+     * otherwise only discovered mid-draw, and opaquely — as a `TypeError` inside
+     * `weighted()` for the registries, whose empty draw table makes `.find`
+     * return `undefined`, and as an out-of-range element read for `sample`.
+     *
+     * The registries throw at construction, where the mistake is; `sample` can
+     * only throw at fabricate time, since a producer is the only place it runs.
      */
     class EmptyItemsError extends FabricatorError {
         /**
-         * The registry entry that was called, e.g. `"T.enum.uniform"`.
+         * The registry entry or helper that was called, e.g. `"T.enum"` or
+         * `"sample"`.
          */
         readonly label: string;
         /**
-         * What the kind calls its items, e.g. `"member"`/`"option"`.
+         * What the caller calls its items, e.g. `"member"`/`"option"`/`"item"`.
          */
         readonly noun: string;
         constructor(
         /**
-         * The registry entry that was called, e.g. `"T.enum.uniform"`.
+         * The registry entry or helper that was called, e.g. `"T.enum"` or
+         * `"sample"`.
          */
         label: string, 
         /**
-         * What the kind calls its items, e.g. `"member"`/`"option"`.
+         * What the caller calls its items, e.g. `"member"`/`"option"`/`"item"`.
          */
         noun: string);
     }
@@ -182,6 +189,29 @@ export declare namespace FabricatorError {
          */
         value: unknown);
     }
+    /**
+     * A `T.derive` resolver returned a value of the wrong shape for the `to`
+     * schema it was declared against.
+     */
+    class DeriveResultMismatchError extends FabricatorError {
+        /**
+         * The `[Kind]` of the derive's `to` schema.
+         */
+        readonly kind: string;
+        /**
+         * What the resolver actually returned.
+         */
+        readonly value: unknown;
+        constructor(
+        /**
+         * The `[Kind]` of the derive's `to` schema.
+         */
+        kind: string, 
+        /**
+         * What the resolver actually returned.
+         */
+        value: unknown);
+    }
     /**
      * An override names a field the object schema does not define — most often a
      * typo, which is why the known fields are listed.

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

@@ -138,6 +138,6 @@ $Schema extends Primitive.object.Core ? Primitive.object.Fabricator<$Schema> : $
  * `Constructor.ts`'s `make` context, not through this boundary. `[]`
  * (unbound) is the same default `self.Core` itself falls back to.
  */
-$Schema extends Primitive.recursive.self.Core ? Primitive.recursive.self.Fabricator<[]> : $Schema extends Primitive.tuple.Core ? Primitive.tuple.Fabricator<$Schema> : $Schema extends Primitive.always.Core ? Primitive.always.Fabricator<$Schema> : $Schema extends Primitive.bigint.Core ? Primitive.bigint.Fabricator<$Schema> : $Schema extends Primitive.boolean.Core ? Primitive.boolean.Fabricator<$Schema> : $Schema extends Primitive.choice.Core ? Primitive.choice.Fabricator<$Schema> : $Schema extends Primitive.enum.Core ? Primitive.enum.Fabricator<$Schema> : $Schema extends Primitive.date.Core ? Primitive.date.Fabricator<$Schema> : $Schema extends Primitive.number.Core ? Primitive.number.Fabricator<$Schema> : $Schema extends Primitive.string.Core ? Primitive.string.Fabricator<$Schema> : $Schema extends Primitive.symbol.Core ? Primitive.symbol.Fabricator<$Schema> : $Schema extends Primitive.undefined.Core ? Primitive.undefined.Fabricator<$Schema> : $Schema extends Primitive.undefinable.Core ? Primitive.undefinable.Fabricator<$Schema> : $Schema extends Primitive.null.Core ? Primitive.null.Fabricator<$Schema> : $Schema extends Primitive.nullable.Core ? Primitive.nullable.Fabricator<$Schema> : $Schema extends Primitive.nullish.Core ? Primitive.nullish.Fabricator<$Schema> : $Schema extends {
+$Schema extends Primitive.recursive.self.Core ? Primitive.recursive.self.Fabricator<[]> : $Schema extends Primitive.tuple.Core ? Primitive.tuple.Fabricator<$Schema> : $Schema extends Primitive.derive.Core ? Primitive.derive.Fabricator<$Schema> : $Schema extends Primitive.always.Core ? Primitive.always.Fabricator<$Schema> : $Schema extends Primitive.bigint.Core ? Primitive.bigint.Fabricator<$Schema> : $Schema extends Primitive.boolean.Core ? Primitive.boolean.Fabricator<$Schema> : $Schema extends Primitive.choice.Core ? Primitive.choice.Fabricator<$Schema> : $Schema extends Primitive.enum.Core ? Primitive.enum.Fabricator<$Schema> : $Schema extends Primitive.date.Core ? Primitive.date.Fabricator<$Schema> : $Schema extends Primitive.number.Core ? Primitive.number.Fabricator<$Schema> : $Schema extends Primitive.string.Core ? Primitive.string.Fabricator<$Schema> : $Schema extends Primitive.symbol.Core ? Primitive.symbol.Fabricator<$Schema> : $Schema extends Primitive.undefined.Core ? Primitive.undefined.Fabricator<$Schema> : $Schema extends Primitive.undefinable.Core ? Primitive.undefinable.Fabricator<$Schema> : $Schema extends Primitive.null.Core ? Primitive.null.Fabricator<$Schema> : $Schema extends Primitive.nullable.Core ? Primitive.nullable.Fabricator<$Schema> : $Schema extends Primitive.nullish.Core ? Primitive.nullish.Fabricator<$Schema> : $Schema extends {
     readonly [Produces]?: unknown;
 } ? Fabricator<ValueOf<$Schema>> : Fabricator<unknown>;

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

@@ -35,10 +35,10 @@ import type { FabricatorTestContext, Integration } from "./Types";
  * captured result would pin one frame.
  *
  * The per-test wrap is entered on `context.scope()`, so it governs that
- * instance and its ancestors: the integrated instance when nothing encloses
- * it, and that instance as an ancestor of the enclosing scope when something
- * does. It does not govern forks of the integrated instance. Per-test data
- * therefore comes from the instance handed to `integration(...)`, from
+ * instance and its ancestors: the integrated instance when nothing encloses it,
+ * and that instance as an ancestor of the enclosing scope when something does.
+ * It does not govern forks of the integrated instance. Per-test data therefore
+ * comes from the instance handed to `integration(...)`, from
  * `context.fabricator`, or from a fork of that scope — a module-level fork of
  * the integrated instance draws the same data in every test, and because its
  * construction counter runs across tests, which values a test gets depends on

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

@@ -15,11 +15,21 @@ type Weighted<$Items extends ReadonlyArray<Item>> = {
  * At least one element — a `choice` with no option 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). Rejecting emptiness here is a
- * construction-time compile error; the runtime check below is the backstop for
- * an `as any` call that bypasses it.
+ * `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 option. Delegates to `weighted` with a
@@ -27,12 +37,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 options, given as `[weight, schema]` pairs —
      * the same tuple shape `weighted()` (`Distribution/index.ts`) itself accepts,
      * not an object keyed by option.
      */
-    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/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.