@ghostry/fabricator 0.0.6 → 0.0.8

package/dist/esm/Distribution/index.js

@@ -135,6 +135,7 @@ function normalInv(p) {
     return -(((((-0.007784894002430293 * q - 3.223964580411365e-1) * q - 2.400758277161838) * q - 2.549732539343734) * q + 4.374664141464968) * q + 2.938163982698783) / ((((7.784695709041462e-3 * q + 3.224671290700398e-1) * q + 2.445134137142996) * q + 3.754408661907416) * q + 1);
 }
 function sample(list, stream) {
+    if (0 === list.length) throw new FabricatorError.EmptyItemsError("sample", "item");
     const index = Math.floor(stream.next() * list.length);
     const item = list[index];
     return item;

package/dist/esm/Enumeration/Plan.js

@@ -186,6 +186,14 @@ function axisFor(node, planning) {
                         slots
                     }));
             }
+        case "derive":
+            {
+                const from = node[Children];
+                const axes = from.map((slot)=>plan(slot, planning));
+                return productAxis(planning.strategy, axes, (slots)=>({
+                        slots
+                    }));
+            }
         case "object":
             {
                 const definition = node[Meta].definition;
@@ -271,6 +279,14 @@ function resolve(node, pin) {
                 const elements = node[Children];
                 return elements.map((element, i)=>resolve(element, p.slots[i]));
             }
+        case "derive":
+            {
+                const p = pin;
+                const from = node[Children];
+                return node.fabricate({
+                    from: from.map((slot, i)=>resolve(slot, p.slots[i]))
+                });
+            }
         case "object":
             {
                 const p = pin;

package/dist/esm/Error/index.js

@@ -88,6 +88,14 @@ class Error_FabricatorError extends Error {
         }
     }
     FabricatorError.ComputeResultMismatchError = ComputeResultMismatchError;
+    class DeriveResultMismatchError extends FabricatorError {
+        constructor(kind, value){
+            super(), _define_property(this, "kind", void 0), _define_property(this, "value", void 0), this.kind = kind, this.value = value;
+            this.name = "DeriveResultMismatchError";
+            this.message = `A T.derive resolver returned a value of type ${typeof value} that does not match its \`to\` schema ("${kind}").`;
+        }
+    }
+    FabricatorError.DeriveResultMismatchError = DeriveResultMismatchError;
     class UnknownOverrideFieldError extends FabricatorError {
         constructor(field, available){
             super(), _define_property(this, "field", void 0), _define_property(this, "available", void 0), this.field = field, this.available = available;

package/dist/esm/Fabricator/Constructor.js

@@ -209,6 +209,19 @@ function Constructor(source, stack, ancestry) {
                         schema: s
                     }, elements);
                 }
+            case "derive":
+                {
+                    const s = schema;
+                    const from = s[Meta].from.map((item, i)=>make(item, [
+                            ...path,
+                            "from",
+                            i.toString(10)
+                        ], context));
+                    return Primitive.derive.Fabricator({
+                        ...common,
+                        schema: s
+                    }, from);
+                }
             case "object.compute":
                 {
                     const s = schema;

package/dist/esm/Instance/Stack/Visible.js

@@ -1,10 +1,10 @@
-function onDirectLine(a, b) {
-    const shared = Math.min(a.length, b.length);
-    for(let index = 0; index < shared; index++)if (a[index] !== b[index]) return false;
+function governs(receiver, reader) {
+    if (reader.length > receiver.length) return false;
+    for(let index = 0; index < reader.length; index++)if (reader[index] !== receiver[index]) return false;
     return true;
 }
 function toVisible(frames, ancestry) {
-    return frames.filter((frame)=>onDirectLine(frame.ancestry, ancestry));
+    return frames.filter((frame)=>governs(frame.ancestry, ancestry));
 }
 function toInnermostFrame(stack, ancestry) {
     const frames = stack.visible(ancestry);

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

@@ -0,0 +1,31 @@
+import { FabricatorError } from "../../Error/index.js";
+import { toStreamFromTrace } from "../../Random/index.js";
+import { toValueKind, violatesKind } from "../../Schema/Core.js";
+import { Children, Kind, Meta } from "../../Types.js";
+import { Schema } from "./Schema.js";
+function Fabricator(context, from) {
+    const { schema, algorithm, trace } = context;
+    const meta = schema[Meta];
+    const rehydrated = Schema(schema);
+    const stream = toStreamFromTrace(algorithm, trace);
+    const resolve = meta.resolve;
+    const toKind = toValueKind(meta.to);
+    return {
+        [Kind]: "derive",
+        [Meta]: meta,
+        trace,
+        [Children]: from,
+        fabricate: (params)=>{
+            var _ref;
+            const values = null != (_ref = null == params ? void 0 : params.from) ? _ref : from.map((slot)=>slot.fabricate());
+            const result = resolve(values, {
+                random: stream,
+                clock: trace.clock
+            });
+            if (violatesKind(toKind, result)) throw new FabricatorError.DeriveResultMismatchError(toKind, result);
+            return result;
+        },
+        schema: rehydrated
+    };
+}
+export { Fabricator };

package/dist/esm/Primitive/derive/Registry.js

@@ -0,0 +1,17 @@
+import { toSchema } from "../../Schema/Core.js";
+import { Kind, Meta } from "../../Types.js";
+import { Schema } from "./Schema.js";
+function Registry({ to, from }) {
+    const normalized = from.map((item)=>toSchema(item));
+    return {
+        as: (resolve)=>Schema({
+                [Kind]: "derive",
+                [Meta]: {
+                    from: normalized,
+                    to,
+                    resolve
+                }
+            })
+    };
+}
+export default Registry;

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

@@ -0,0 +1,10 @@
+import { withAdaptations } from "../../Adapter/Core.js";
+import { Kind } from "../../Types.js";
+function Schema(schema) {
+    return {
+        ...schema,
+        [Kind]: "derive",
+        adapt: (adapter, produce)=>Schema(withAdaptations(schema, adapter, produce))
+    };
+}
+export { Schema };

package/dist/esm/Primitive/derive/Types.js

@@ -0,0 +1 @@
+export { };

package/dist/esm/Primitive/derive/index.js

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

package/dist/esm/Primitive/index.js

@@ -5,6 +5,7 @@ export { default as bigint } from "./bigint/index.js";
 export { default as boolean } from "./boolean/index.js";
 export { default as choice } from "./choice/index.js";
 export { default as date } from "./date/index.js";
+export { default as derive } from "./derive/index.js";
 export { default as enum } from "./enum/index.js";
 export { default as null } from "./null/index.js";
 export { default as nullable } from "./nullable/index.js";

package/dist/esm/Primitive/namespace.js

@@ -4,6 +4,7 @@ import * as __rspack_external__bigint_index_js_adedcded from "./bigint/index.js"
 import * as __rspack_external__boolean_index_js_0a69a391 from "./boolean/index.js";
 import * as __rspack_external__choice_index_js_ce126df9 from "./choice/index.js";
 import * as __rspack_external__date_index_js_99c830c9 from "./date/index.js";
+import * as __rspack_external__derive_index_js_be41c87a from "./derive/index.js";
 import * as __rspack_external__enum_index_js_39677e4c from "./enum/index.js";
 import * as __rspack_external__null_index_js_b154bd62 from "./null/index.js";
 import * as __rspack_external__nullable_index_js_a31c5679 from "./nullable/index.js";
@@ -18,4 +19,4 @@ import * as __rspack_external__symbol_index_js_65f53bf7 from "./symbol/index.js"
 import * as __rspack_external__tuple_index_js_fe5f0f11 from "./tuple/index.js";
 import * as __rspack_external__undefinable_index_js_01dfdeb8 from "./undefinable/index.js";
 import * as __rspack_external__undefined_index_js_b61f9fc3 from "./undefined/index.js";
-export { __rspack_external__always_index_js_5b7da93f as always, __rspack_external__array_index_js_e390953b as array, __rspack_external__bigint_index_js_adedcded as bigint, __rspack_external__boolean_index_js_0a69a391 as boolean, __rspack_external__choice_index_js_ce126df9 as choice, __rspack_external__date_index_js_99c830c9 as date, __rspack_external__enum_index_js_39677e4c as enum, __rspack_external__null_index_js_b154bd62 as null, __rspack_external__nullable_index_js_a31c5679 as nullable, __rspack_external__nullish_index_js_03ff6564 as nullish, __rspack_external__number_index_js_b8c783ea as number, __rspack_external__object_index_js_53384658 as object, __rspack_external__opaque_index_js_0795d628 as opaque, __rspack_external__record_index_js_120e2811 as record, __rspack_external__recursive_index_js_3c8bba6b as recursive, __rspack_external__string_index_js_18f2393a as string, __rspack_external__symbol_index_js_65f53bf7 as symbol, __rspack_external__tuple_index_js_fe5f0f11 as tuple, __rspack_external__undefinable_index_js_01dfdeb8 as undefinable, __rspack_external__undefined_index_js_b61f9fc3 as undefined };
+export { __rspack_external__always_index_js_5b7da93f as always, __rspack_external__array_index_js_e390953b as array, __rspack_external__bigint_index_js_adedcded as bigint, __rspack_external__boolean_index_js_0a69a391 as boolean, __rspack_external__choice_index_js_ce126df9 as choice, __rspack_external__date_index_js_99c830c9 as date, __rspack_external__derive_index_js_be41c87a as derive, __rspack_external__enum_index_js_39677e4c as enum, __rspack_external__null_index_js_b154bd62 as null, __rspack_external__nullable_index_js_a31c5679 as nullable, __rspack_external__nullish_index_js_03ff6564 as nullish, __rspack_external__number_index_js_b8c783ea as number, __rspack_external__object_index_js_53384658 as object, __rspack_external__opaque_index_js_0795d628 as opaque, __rspack_external__record_index_js_120e2811 as record, __rspack_external__recursive_index_js_3c8bba6b as recursive, __rspack_external__string_index_js_18f2393a as string, __rspack_external__symbol_index_js_65f53bf7 as symbol, __rspack_external__tuple_index_js_fe5f0f11 as tuple, __rspack_external__undefinable_index_js_01dfdeb8 as undefinable, __rspack_external__undefined_index_js_b61f9fc3 as undefined };

package/dist/esm/Primitive/object/Registry.js

@@ -1,13 +1,13 @@
 import { mergeAdaptations } from "../../Adapter/Core.js";
 import { FabricatorError } from "../../Error/index.js";
-import { toSchema, violatesKind } from "../../Schema/Core.js";
+import { toSchema, toValueKind, violatesKind } from "../../Schema/Core.js";
 import { Adaptation, Fixed, Kind, Meta, Omitted } from "../../Types.js";
 import { isPlainObject } from "../../Utility/Core.js";
 import { shallowMerge } from "../../Utility/ShallowMerge.js";
 import { isNullableSchema } from "../nullable/Schema.js";
 import { isNullishSchema } from "../nullish/Schema.js";
 import { isUndefinableSchema } from "../undefinable/Schema.js";
-import compute_0, { isObjectComputeSchema } from "./compute/index.js";
+import compute_0 from "./compute/index.js";
 import { isObjectOmittableSchema } from "./omittable/Schema.js";
 import { isObjectOptionalSchema } from "./optional/Schema.js";
 import { Schema, isObjectSchema } from "./Schema.js";
@@ -67,7 +67,7 @@ function make(definition, refinements, adaptations) {
                         };
                         continue;
                     }
-                    const innerKind = fieldSchema[Meta].definition[Kind];
+                    const innerKind = toValueKind(fieldSchema[Meta].definition);
                     if (violatesKind(innerKind, value)) throw new FabricatorError.InvalidOverrideValueError(key, innerKind, value);
                     overridden[key] = {
                         ...toSchema(fieldSchema),
@@ -83,7 +83,7 @@ function make(definition, refinements, adaptations) {
                         };
                         continue;
                     }
-                    const innerKind = fieldSchema[Meta].definition[Kind];
+                    const innerKind = toValueKind(fieldSchema[Meta].definition);
                     if (violatesKind(innerKind, value)) throw new FabricatorError.InvalidOverrideValueError(key, innerKind, value);
                     overridden[key] = {
                         ...toSchema(fieldSchema),
@@ -93,7 +93,7 @@ function make(definition, refinements, adaptations) {
                 }
                 if (isUndefinableSchema(fieldSchema)) {
                     if (void 0 !== value) {
-                        const innerKind = fieldSchema[Meta].definition[Kind];
+                        const innerKind = toValueKind(fieldSchema[Meta].definition);
                         if (violatesKind(innerKind, value)) throw new FabricatorError.InvalidOverrideValueError(key, innerKind, value);
                     }
                     overridden[key] = {
@@ -104,7 +104,7 @@ function make(definition, refinements, adaptations) {
                 }
                 if (isNullableSchema(fieldSchema)) {
                     if (null !== value) {
-                        const innerKind = fieldSchema[Meta].definition[Kind];
+                        const innerKind = toValueKind(fieldSchema[Meta].definition);
                         if (violatesKind(innerKind, value)) throw new FabricatorError.InvalidOverrideValueError(key, innerKind, value);
                     }
                     overridden[key] = {
@@ -115,7 +115,7 @@ function make(definition, refinements, adaptations) {
                 }
                 if (isNullishSchema(fieldSchema)) {
                     if (null != value) {
-                        const innerKind = fieldSchema[Meta].definition[Kind];
+                        const innerKind = toValueKind(fieldSchema[Meta].definition);
                         if (violatesKind(innerKind, value)) throw new FabricatorError.InvalidOverrideValueError(key, innerKind, value);
                     }
                     overridden[key] = {
@@ -125,7 +125,7 @@ function make(definition, refinements, adaptations) {
                     continue;
                 }
                 if (value === Omitted) throw new FabricatorError.IllegalOmittedOverrideError(key, fieldSchema[Kind]);
-                const kind = isObjectComputeSchema(fieldSchema) ? fieldSchema[Meta].source[Kind] : fieldSchema[Kind];
+                const kind = toValueKind(fieldSchema);
                 if (violatesKind(kind, value)) throw new FabricatorError.InvalidOverrideValueError(key, kind, value);
                 overridden[key] = {
                     ...toSchema(fieldSchema),

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/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/index.js

@@ -9,4 +9,5 @@ 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 { initialize };

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

@@ -96,6 +96,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,35 @@ 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 +191,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

@@ -34,12 +34,15 @@ import type { FabricatorTestContext, Integration } from "./Types";
  * `scope` is a function so that capturing it captures the lookup, where a
  * captured result would pin one frame.
  *
- * The frame that `wrap` pushes is keyed on the receiver's ancestry, so under
- * composition the per-test frame belongs to the enclosing scope's line: a
- * collateral `fork()` taken inside a test resolves against the outermost frame
- * on its own line instead. That is the ordinary ancestry rule — siblings never
- * see each other's frames, and the outward walk supplies the outer ones — not a
- * special case here.
+ * 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
+ * `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
+ * which tests ran before it.
  *
  * `provides.fabricator` is then that scope — the instance `wrap` gave its
  * block, not the base instance — so `context.fabricator.salt` is the per-test

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

@@ -3,8 +3,8 @@ import type { PlainObject } from "../Utility/Types";
 /**
  * What identifies one registered test or suite — the material a salt is derived
  * from. Named to match how this codebase already talks about the concept:
- * fabricator's own reproducibility guide reaches for `layer(...)` for "a tenant
- * id, a test's own name" — this is that identity, structured.
+ * fabricator's own reproducibility guide reaches for `layer(...)` for "a test's
+ * own name" — this is that identity, structured.
  *
  * Declared here rather than imported from `@ghostry/harness`, so neither
  * package depends on the other — the same arrangement `Adapter`/`walk` already

package/dist/types/Instance/Stack/Visible.d.ts

@@ -5,12 +5,16 @@ import type { Ancestry, Frame, Stack } from "../Types";
  * delegate to so neither can drift from the other. A carrier's own job is
  * reduced to holding the chain in whatever way its runtime allows.
  *
+ * A wrap governs the instance it was called on and that instance's ancestors,
+ * never its descendants: `governs` is a prefix test in that one direction.
  * Order is preserved rather than reduced to the innermost match, because the
  * count is `context.depth` and the innermost is just the last element.
- * Skipping, rather than stopping at, the first invisible frame is the outward
- * walk: with a parent's `wrap` open and a child's nested inside it, that
- * child's sibling must pass over the inner frame and still resolve against the
- * outer one.
+ *
+ * It filters the whole chain rather than walking in from the innermost frame
+ * and stopping at the first that does not govern the reader, because a
+ * governing frame can sit beneath one that does not: with `B`'s wrap open and
+ * `C`'s nested inside it, `B` must pass over `C`'s frame and still resolve
+ * against its own.
  */
 export declare function toVisible(frames: ReadonlyArray<Frame>, ancestry: Ancestry): ReadonlyArray<Frame>;
 /**

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

@@ -69,19 +69,19 @@ export type Token = symbol & {
  * over that instance's `config`. One rule, so an instance's position and its
  * configuration always agree about who its parent is.
  *
- * Two chains describe instances on the same ancestral line when either is a
- * prefix of the other, which is what {@link Stack.visible} tests. That relation
- * decides whose calls resolve against whose frames: a parent's calls resolve
- * against a child's frame and a child's against a parent's, while two siblings
- * resolve against neither's. Note this never crosses lineages, and not for want
- * of identity — two roots hold two separate carriers, so a `wrap` on one pushes
- * where the other's reads never look.
+ * {@link Stack.visible} tests whether the reader is the wrap's receiver or one
+ * of that receiver's ancestors — the reader's chain a prefix of the frame's. A
+ * parent's constructions resolve against a wrap entered on a child; a child's
+ * constructions do not resolve against a wrap entered on a parent. Two siblings
+ * resolve against neither's. The relation never crosses lineages, and not for
+ * want of identity — two roots hold two separate carriers, so a `wrap` on one
+ * pushes where the other's reads never look.
  */
 export type Ancestry = readonly [Token, ...ReadonlyArray<Token>];
 /**
  * One active `wrap` — its resolved config plus the single `RandomSource` every
- * build reached inside that `wrap` shares, whether reached implicitly (any
- * instance on the origin's ancestral line consulting the frame) or explicitly
+ * build reached inside that `wrap` shares, whether reached implicitly (the
+ * receiver and its ancestors consulting the frame) or explicitly
  * (`scope.Fabricator`, the `Instance` passed to the block). Storing the scope's
  * own already-built `source` here, rather than each consumer re-deriving one
  * from `config`, keeps the two routes resolving against the _same_ source —
@@ -93,11 +93,12 @@ export type Ancestry = readonly [Token, ...ReadonlyArray<Token>];
  * separate `salt`/`algorithm`/`clock` fields.
  *
  * `ancestry` is the **origin's** — the instance `wrap` was called on — not the
- * scope's. The scope is a fresh child of the origin, so keying on it would make
- * every `fork` taken off that origin a _sibling_ of the scope, and calls on
- * those forks would stop resolving against the frame. Keying on the origin
- * keeps everything on the origin's own line resolving against it, which is the
- * whole point of entering one.
+ * scope's, and {@link Stack.visible} governs that origin and its ancestors. Not
+ * load-bearing for who is governed: keyed on the scope, the frame would govern
+ * the same instances plus the scope itself, which resolves against this very
+ * `source` either way. What it decides is the scope's own `context.depth` — 0,
+ * since the scope is a descendant of the origin and not among those the frame
+ * governs.
  */
 export type Frame = {
     readonly config: Config<PlainObject>;
@@ -132,23 +133,21 @@ export type Stack = {
     readonly asynchronous: boolean;
     /**
      * Every open frame `ancestry` may resolve against, outermost first: those
-     * whose own `ancestry` is a prefix of this one or has this one as a prefix.
-     * The innermost visible frame — what a build or a `context` read actually
-     * resolves against — is the last element, and the count is `context.depth`.
+     * whose receiver this instance is, or is an ancestor of — this chain a prefix
+     * of the frame's. The innermost visible frame — what a build or a `context`
+     * read actually resolves against — is the last element, and the count is
+     * `context.depth`.
      *
-     * Filtering, rather than simply reporting the innermost frame, is what makes
-     * the outward walk possible: with a parent's `wrap` open and a child's nested
-     * inside it, the child's _sibling_ must skip the inner frame and still find
-     * the outer one. Callers never filter themselves — `toVisible`
-     * (`Instance/Stack/Visible.ts`) is the single definition both carriers
-     * delegate to, so the rule cannot drift between them.
+     * Callers never filter themselves — `toVisible` (`Instance/Stack/Visible.ts`)
+     * is the single definition both carriers delegate to, so the rule cannot
+     * drift between them.
      */
     visible(ancestry: Ancestry): ReadonlyArray<Frame>;
     /**
      * Append `frame`, run `block`, remove it in a `finally`, so a frame unwinds
-     * correctly even if `block` throws. Appends rather than replaces: the chain
-     * has to stay intact for {@link visible} to walk outward past a frame this
-     * reader cannot see.
+     * correctly even if `block` throws. Appends rather than replaces: nested
+     * wraps are a chain, and {@link visible} reports every frame this reader is
+     * governed by, not only the innermost.
      */
     enter<$Return>(frame: Frame, block: () => $Return): $Return;
 };
@@ -188,11 +187,13 @@ export type Context = {
      */
     scope(): Instance<PlainObject>;
     /**
-     * How many frames are currently visible to this instance — 0 outside any.
-     * Genuine dynamic nesting depth, counted off the carrier rather than inferred
-     * from {@link Ancestry}: a frame a sibling cannot see is not counted for that
-     * sibling, and entering two `wrap`s on one instance reads as 2 even though
-     * neither deepened anyone's ancestry.
+     * How many frames currently govern this instance — 0 outside any. Genuine
+     * dynamic nesting depth, counted off the carrier rather than inferred from
+     * {@link Ancestry}: a wrap entered on a descendant is counted (this instance
+     * is an ancestor of that receiver), a wrap entered on a sibling or an
+     * ancestor is not, and entering two `wrap`s on one instance reads as 2 even
+     * though neither deepened anyone's ancestry. A wrap's own `scope` is a
+     * descendant of the receiver, so its depth inside that wrap is 0.
      */
     readonly depth: number;
 };
@@ -280,7 +281,7 @@ export interface Instance<$Registry extends PlainObject> extends Pick<RandomSour
     /**
      * `fork(overlay)`, made ambient for the synchronous extent of `block`: every
      * `new Fabricator(...)`, `combinatorial(...)`, and `coverage(...)` reached
-     * inside — on this instance or any other in the same lineage — resolves
+     * inside — on this instance, and on this instance's ancestors — resolves
      * against the fork instead, with nothing threaded through. The fork is also
      * passed to `block`: use it explicitly where that reads better, and
      * _necessarily_ for any async work, which the ambient frame does not survive
@@ -294,11 +295,11 @@ export interface Instance<$Registry extends PlainObject> extends Pick<RandomSour
      * bound outside, as a destructured `wrap` is. To compose onto whatever is
      * active regardless of receiver, go through `context.scope().wrap(...)`.
      *
-     * While the block runs, calls made on this instance's ancestral line resolve
-     * against the scope — its forks, their forks, and its own ancestors up to the
-     * root. Calls on a _sibling_ do not: a frame entered on one `fork` is not one
-     * that another `fork` of the same parent can resolve against, which keeps two
-     * unrelated derivations from drawing each other's data. See
+     * While the block runs, calls on this instance and its ancestors resolve
+     * against the scope. Calls on a descendant — a fork of this instance, or the
+     * wrap's own scope — draw that instance's own configuration; so does a
+     * sibling. The scope still shares one `RandomSource` with this instance
+     * inside the wrap, so ambient and explicit construction agree. See
      * {@link Ancestry}.
      */
     wrap<$Return, const $WrapRegistry extends PlainObject = $Registry>(overlay: Overlay<$WrapRegistry>, block: (scope: Instance<$WrapRegistry>) => $Return): $Return;

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/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,36 @@
+import { type AdaptationEntry } from "../../Adapter/Core";
+import type { Adaptations, Adapter, Adapting, WithAdaptations } from "../../Adapter/Types";
+import type { ProduceContext } from "../../Random/Types";
+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> {
+    /**
+     * 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,39 @@
+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/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/Schema/Core.d.ts

@@ -32,6 +32,19 @@ export declare function toSchema<$Kind extends string, $Meta extends PlainObject
     readonly [Produces]?: $Produces;
     readonly [Adaptation]?: $Adaptations;
 };
+/**
+ * The `[Kind]` a schema's fabricated value should be checked against with
+ * {@link violatesKind}. For most kinds that is its own `[Kind]`, but
+ * `object.compute` and `derive` only declare their value's shape, through
+ * `source` and `to`. Those resolve to that schema's kind, recursively, so a
+ * `to` that is itself a `derive` still reaches a checkable kind. Without this,
+ * an override of a derive-valued field would be checked against `"derive"`,
+ * which accepts anything.
+ */
+export declare function toValueKind(schema: {
+    [Kind]: SchemaKind;
+    [Meta]?: any;
+}): SchemaKind;
 /**
  * Whether `value`'s basic JS shape is compatible with `kind` (one of this
  * library's `[Kind]` literals, e.g. `"string"`, `"object"`, `"date"`). Stops at

package/dist/types/Types.d.ts

@@ -19,9 +19,10 @@ export declare const Layer: unique symbol;
  * already constructed for this node's nested schemas before handing them to the
  * kind's own `Fabricator()` factory. Every composite kind whose construction
  * receives already-dispatched Fabricators carries this: `object` (its `Fields`
- * map), `tuple` (`elements`, in slot order), `choice` (the dispatched options,
- * in `[Meta].items` order — weights stay in `[Meta]`), `array` (the single
- * shared `element`), `record` (`{ key, value }`), and each of
+ * map), `tuple` (`elements`, in slot order), `derive` (the dispatched `from`
+ * slots, in `[Meta].from` order), `choice` (the dispatched options, in
+ * `[Meta].items` order — weights stay in `[Meta]`), `array` (the single shared
+ * `element`), `record` (`{ key, value }`), and each of
  * `nullable`/`nullish`/`undefinable`/`object.omittable`/`object.optional` (the
  * single wrapped `source`).
  *

package/dist/types/index.d.ts

@@ -103,6 +103,15 @@ export type { Bound, InputBound } from "./Bound";
  * handed — so a caller writing either as a named function can name it.
  */
 export type { Stream } from "./Random/Types";
+/**
+ * Uniform pick and Fisher–Yates shuffle over a caller-held list, each taking
+ * the `Stream` a producer is already handed. Exported so a caller writing
+ * `.as(produce)`, `T.opaque`, or a `T.derive` resolver can draw from a list
+ * they already have — the same rationale as the `Stream` export. Prefer
+ * `T.enum` when the pick can be a schema: it is enumerable and path-keyed;
+ * these helpers are for the cases that cannot.
+ */
+export { sample, shuffle } from "./Distribution";
 /**
  * What every kind's `.as(produce)` producer is called with — a single curated
  * object rather than a positional argument list, so a caller writing the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ghostry/fabricator",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "license": "MIT",
   "description": "Fabricate typed data from composable schemas.",
   "keywords": [