@ghostry/fabricator 0.0.1 → 0.0.3

package/dist/esm/Random/index.js

@@ -1,85 +1,53 @@
-import { FabricatorError } from "../Error/index.js";
 import { Layer, MAX_TIME } from "../Types.js";
-import { inline } from "../Utility/Core.js";
 import { cyrb128 } from "../Utility/Digest.js";
-import { directoryOf, normalizeLocation, relativize, resolveCallerFile } from "./CallSite.js";
 import { sfc32 } from "./Generator/sfc32.js";
 function defaultAlgorithm(seed) {
     return sfc32(...cyrb128(seed));
 }
-function randomSeed() {
+function randomSalt() {
     return (0x100000000 * Math.random() >>> 0).toString(10);
 }
-function deriveClock(algorithm, seed) {
+function deriveClock(algorithm, salt) {
     const stream = toStream(algorithm, JSON.stringify([
-        seed,
+        salt,
         "clock"
     ]));
     return Math.trunc((2 * stream.next() - 1) * MAX_TIME);
 }
-function envSeed() {
-    var _ref, _ref1;
+function envSalt() {
     const env = "object" == typeof process ? process.env : void 0;
-    return null != (_ref = null != (_ref1 = null == env ? void 0 : env["FABRICATOR_SEED"]) ? _ref1 : null == env ? void 0 : env["SEED"]) ? _ref : null == env ? void 0 : env["RANDOM_SEED"];
+    return null == env ? void 0 : env["FABRICATOR_SALT"];
 }
 function encode(trace) {
     return JSON.stringify([
-        trace.seed,
+        trace.salt,
         trace.clock,
-        trace.root,
-        trace.file,
         trace.path,
         trace.kind,
         trace.ordinal
     ]);
 }
-function normalizeSeed(seed) {
-    if (void 0 === seed) {
-        const fromEnv = envSeed();
+function normalizeSalt(salt) {
+    if (void 0 === salt) {
+        const fromEnv = envSalt();
         return void 0 === fromEnv ? [] : [
             fromEnv
         ];
     }
-    return "string" == typeof seed ? [
-        seed
+    return "string" == typeof salt ? [
+        salt
     ] : [
-        ...seed
+        ...salt
     ];
 }
-function Random_layer(seed) {
+function Random_layer(salt) {
     return {
-        [Layer]: seed
+        [Layer]: salt
     };
 }
 function isLayered(value) {
     return "object" == typeof value && null !== value && Layer in value;
 }
-function resolveAttribution(attribution) {
-    const policy = null != attribution ? attribution : {
-        kind: "call site"
-    };
-    switch(policy.kind){
-        case "none":
-            return policy;
-        case "rooted":
-            {
-                const root = normalizeLocation(policy.root);
-                if (!root.startsWith("/")) throw new FabricatorError.InvalidAttributionRootError(policy.root);
-                return toRooted(root);
-            }
-        case "call site":
-            {
-                const root = directoryOf(resolveCallerFile());
-                return toRooted(root);
-            }
-    }
-}
-function toRooted(root) {
-    return {
-        kind: "rooted",
-        root: root.endsWith("/") ? root : `${root}/`
-    };
-}
 function toStream(algorithm, seed) {
     const generator = algorithm(seed);
     let iterations = 0;
@@ -99,53 +67,30 @@ function toStreamFromTrace(algorithm, trace) {
 }
 function toRandomSource(options) {
     var _options_algorithm;
-    let seed = normalizeSeed(options.seed);
+    let salt = normalizeSalt(options.salt);
     let algorithm = null != (_options_algorithm = options.algorithm) ? _options_algorithm : defaultAlgorithm;
-    let attribution = resolveAttribution(options.attribution);
     const clock = options.clock;
-    let constructionOrdinals = new Map();
-    function nextConstructionOrdinal(file) {
-        var _constructionOrdinals_get;
-        const ordinal = null != (_constructionOrdinals_get = constructionOrdinals.get(file)) ? _constructionOrdinals_get : 0;
-        constructionOrdinals.set(file, ordinal + 1);
-        return ordinal;
-    }
-    function toRoot(kind, pins = {}) {
-        var _pins_root, _pins_clock;
-        const replaying = void 0 !== pins.root;
-        const root = null != (_pins_root = pins.root) ? _pins_root : kind;
-        const file = replaying || void 0 !== pins.file ? pins.file : resolveRootFile(kind);
-        const ordinal = inline(()=>{
-            if (replaying || void 0 !== pins.ordinal) return pins.ordinal;
-            if ("unattributed" === root) return;
-            return nextConstructionOrdinal(file);
-        });
+    let constructionOrdinal = 0;
+    function toRoot(pins = {}) {
+        var _pins_salt, _pins_clock;
         return {
-            seed,
+            salt: null != (_pins_salt = pins.salt) ? _pins_salt : salt,
             clock: null != (_pins_clock = pins.clock) ? _pins_clock : clock,
-            root,
-            file,
-            ordinal
+            ordinal: void 0 !== pins.ordinal ? pins.ordinal : constructionOrdinal++
         };
     }
-    function resolveRootFile(kind) {
-        if ("attributed" !== kind) return;
-        if ("none" === attribution.kind) return;
-        return relativize(attribution.root, resolveCallerFile());
-    }
-    function fork(childSeed) {
+    function fork(childSalt) {
         return toRandomSource({
-            seed: childSeed,
+            salt: childSalt,
             algorithm,
-            attribution,
             clock
         });
     }
     return {
         toRoot,
         algorithm,
-        seed,
+        salt,
         fork
     };
 }
-export { Random_layer as layer, defaultAlgorithm, deriveClock, encode, isLayered, normalizeSeed, randomSeed, resolveAttribution, toRandomSource, toStream, toStreamFromTrace };
+export { Random_layer as layer, defaultAlgorithm, deriveClock, encode, isLayered, normalizeSalt, randomSalt, toRandomSource, toStream, toStreamFromTrace };

package/dist/esm/Utility/Core.js

@@ -3,6 +3,11 @@ function inline(fn) {
     return fn();
 }
 function never(_) {}
+function noop() {}
+function isThenable(value) {
+    if ("object" != typeof value || null === value) return false;
+    return "function" == typeof value.then;
+}
 function isArray(candidate) {
     return Array.isArray(candidate);
 }
@@ -33,4 +38,4 @@ function replace(value) {
         [Replace]: true
     };
 }
-export { inline, isArray, isPlainObject, isPollutionKey, mergeableKeys, never, replace };
+export { inline, isArray, isPlainObject, isPollutionKey, isThenable, mergeableKeys, never, noop, replace };

package/dist/esm/adapting.js

@@ -0,0 +1,2 @@
+export { walk } from "./Adapter/Core.js";
+export { Adaptation } from "./Types.js";

package/dist/esm/harnessing.js

@@ -0,0 +1 @@
+export { integration } from "./Harnessing/Core.js";

package/dist/esm/index.js

@@ -1,11 +1,12 @@
-import { instantiate, overlay, toStack } from "./Instance/Core.js";
+import { toStack } from "#stack";
+import { instantiate, overlay } from "./Instance/Core.js";
 function initialize(config) {
-    return instantiate(overlay({}, null != config ? config : {}), toStack()).instance;
+    var _ref;
+    return instantiate(overlay({}, null != config ? config : {}), null != (_ref = null == config ? void 0 : config.stack) ? _ref : toStack()).instance;
 }
-export { Adaptation, Omitted } from "./Types.js";
+export { Omitted } from "./Types.js";
 export { layer } from "./Random/index.js";
 export { FabricatorError } from "./Error/index.js";
-export { drive } from "./Adapter/Core.js";
 export { registry } from "./Schema/Registry.js";
 export { effectiveDiscrete, toBound } from "./Bound.js";
 export { initialize };

package/dist/esm/internal.js

@@ -1,5 +1,5 @@
 export { Children, Kind, Meta, Produces } from "./Types.js";
 export { isPlainObject } from "./Utility/Core.js";
 export { plan, resolve } from "./Enumeration/Plan.js";
-export { defaultAlgorithm, encode, randomSeed, toRandomSource, toStream, toStreamFromTrace } from "./Random/index.js";
-export { directoryOf, normalizeLocation, relativize } from "./Random/CallSite.js";
+export { defaultAlgorithm, encode, randomSalt, toRandomSource, toStream, toStreamFromTrace } from "./Random/index.js";
+export { toStack as toSynchronousStack } from "./Instance/Stack/Sync.js";

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

@@ -4,61 +4,58 @@ type OverrideSchemaAdaptation<$Schema extends object, $Map extends Adaptations>
     readonly [Adaptation]?: WithAdaptations<AdaptationsOf<$Schema>, $Map>;
 };
 /**
- * One adapter's entry, keyed by `$Adapter["key"]`. Written as a mapped
- * type rather than built inline: a computed key in an object literal
- * (`{ [adapter.key]: produce }`) widens to a `string` index signature,
- * which no adapter's literal-keyed dispatch matches.
+ * One adapter's entry, keyed by `$Adapter["key"]`. Written as a mapped type
+ * rather than built inline: a computed key in an object literal (`{
+ * [adapter.key]: produce }`) widens to a `string` index signature, which no
+ * adapter's literal-keyed dispatch matches.
  */
 export type AdaptationEntry<$Adapter extends Adapter, $Returnable> = {
     readonly [$K in $Adapter["key"]]: (schema: any) => $Returnable;
 };
 /**
- * A copy of `schema` carrying `produce` as `adapter`'s adaptation:
- * that adapter's prior entry is replaced (via {@link layer}), every
- * other adapter's is carried forward. Every kind's `.adapt(...)` is a
- * call to this, re-typed to that kind's own
- * `Schema<..., WithAdaptations<...>>`.
+ * A copy of `schema` carrying `produce` as `adapter`'s adaptation: that
+ * adapter's prior entry is replaced (via {@link layer}), every other adapter's
+ * is carried forward. Every kind's `.adapt(...)` is a call to this, re-typed to
+ * that kind's own `Schema<..., WithAdaptations<...>>`.
  *
- * Takes the adapter and producer separately rather than a prebuilt map
- * so the key stays a literal, per {@link AdaptationEntry}. The return
- * type mirrors the merge (rather than handing back `$Schema`) so call
- * sites need no cast: `AdaptationsOf<$Schema>` recovers the prior map
- * from whichever kind's `Core` was passed in.
+ * Takes the adapter and producer separately rather than a prebuilt map so the
+ * key stays a literal, per {@link AdaptationEntry}. The return type mirrors the
+ * merge (rather than handing back `$Schema`) so call sites need no cast:
+ * `AdaptationsOf<$Schema>` recovers the prior map from whichever kind's `Core`
+ * was passed in.
  */
 export declare function withAdaptations<const $Schema extends object, const $Adapter extends Adapter, $Returnable>(schema: $Schema, adapter: $Adapter, produce: (adapting: Adapting<any>) => $Returnable): OverrideSchemaAdaptation<$Schema, AdaptationEntry<$Adapter, $Returnable>>;
 /**
  * {@link withAdaptations} at the map level, for a kind that keeps its
  * adaptations beside its schema rather than on it — `object`, whose
  * `extend`/`refine`/`override` each rebuild the schema from scratch, so
- * `Registry.ts`'s `make` has to thread the map through explicitly (see
- * its `adapt`).
+ * `Registry.ts`'s `make` has to thread the map through explicitly (see its
+ * `adapt`).
  *
- * `undefined` rather than an empty map when there is nothing to carry,
- * for the same reason `patched` drops the symbol: an absent map and an
- * empty one mean the same thing, and only one of them should exist at
- * runtime.
+ * `undefined` rather than an empty map when there is nothing to carry, for the
+ * same reason `patched` drops the symbol: an absent map and an empty one mean
+ * the same thing, and only one of them should exist at runtime.
  */
 export declare function mergeAdaptations<$Prior extends Adaptations, const $Adapter extends Adapter, $Returnable>(prior: $Prior | undefined, adapter: $Adapter, produce: (adapting: Adapting<any>) => $Returnable): WithAdaptations<$Prior, AdaptationEntry<$Adapter, $Returnable>> | undefined;
 /**
  * Walk `schema` with `adapter`, resolving each node to its external
  * counterpart. Every adapter's entry point is a call to this.
  *
- * The adaptation lookup lives here, ahead of the adapter's own
- * per-kind dispatch, so an explicit adaptation wins over the kind's
- * mapping — and here rather than in each adapter so it applies at
- * *every* node the walk reaches, not just the one it started from.
- * That is why an adapter recurses through the {@link Recurse} it is
- * handed rather than calling its own `convert` again: a nested
- * `object` field, `array` element, or `choice` option gets the same
+ * The adaptation lookup lives here, ahead of the adapter's own per-kind
+ * dispatch, so an explicit adaptation wins over the kind's mapping — and here
+ * rather than in each adapter so it applies at _every_ node the walk reaches,
+ * not just the one it started from. That is why an adapter recurses through the
+ * {@link Recurse} it is handed rather than calling its own `convert` again: a
+ * nested `object` field, `array` element, or `choice` option gets the same
  * treatment as the root.
  *
- * Paired with {@link layer}: together they make `toTypeBox(schema)`
- * *inside* an adaptation resolve to the layer that adaptation replaced
- * instead of re-entering itself. This reads the entry; `layer` already
- * substituted the previous one into the argument. Splitting the two
- * across packages is how they drift.
+ * Paired with {@link layer}: together they make `toTypeBox(schema)` _inside_ an
+ * adaptation resolve to the layer that adaptation replaced instead of
+ * re-entering itself. This reads the entry; `layer` already substituted the
+ * previous one into the argument. Splitting the two across packages is how they
+ * drift.
  */
-export declare function drive<$Context, $Returnable>(adapter: Adapter<string, $Context, $Returnable>, schema: {
+export declare function walk<$Context, $Returnable>(adapter: Adapter<string, $Context, $Returnable>, schema: {
     [Adaptation]?: Adaptations;
 }, context: $Context): $Returnable;
 export {};

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

@@ -1,43 +1,41 @@
 import type { Adaptation, Meta } from "../Types";
 /**
- * One adapter's override for one schema, *as stored* in `[Adaptation]` —
- * the loosest signature the mechanism needs. An adapter states its real
- * return type on {@link Adapter.convert}, and `.adapt(...)` checks a
- * supplied adaptation against that; nothing here reads either end.
+ * One adapter's override for one schema, _as stored_ in `[Adaptation]` — the
+ * loosest signature the mechanism needs. An adapter states its real return type
+ * on {@link Adapter.convert}, and `.adapt(...)` checks a supplied adaptation
+ * against that; nothing here reads either end.
  *
- * Not the shape a caller writes: a kind's `.adapt(...)` takes a producer
- * of {@link Adapting}, which `Adapter/Core.ts`'s `withAdaptations`/
- * `mergeAdaptations` wrap into this one entry point-side. The stored
- * form stays schema-taking so `patched`/`layer` treat an incoming
- * producer and a prior layered entry as one type, and so
- * `AdaptationEntry`'s `(schema: any) => $Returnable` is an accurate
- * account of what a schema carries.
+ * Not the shape a caller writes: a kind's `.adapt(...)` takes a producer of
+ * {@link Adapting}, which `Adapter/Core.ts`'s `withAdaptations`/
+ * `mergeAdaptations` wrap into this one entry point-side. The stored form stays
+ * schema-taking so `patched`/`layer` treat an incoming producer and a prior
+ * layered entry as one type, and so `AdaptationEntry`'s `(schema: any) =>
+ * $Returnable` is an accurate account of what a schema carries.
  */
 export type SchemaAdaptation = (schema: any) => unknown;
 /**
- * What a kind's `.adapt(adapter, produce)` hands its producer: the schema
- * being adapted, and that schema's `[Meta]` — one object rather than two
- * parameters, so destructuring picks whichever half is needed and neither
- * is reachable only through a well-known symbol.
+ * What a kind's `.adapt(adapter, produce)` hands its producer: the schema being
+ * adapted, and that schema's `[Meta]` — one object rather than two parameters,
+ * so destructuring picks whichever half is needed and neither is reachable only
+ * through a well-known symbol.
  *
- * `schema` carries whichever adaptation for this same adapter it
- * replaced, absent at the bottom of the stack (see `Adapter/Core.ts`'s
- * `layer`) — so `toTypeBox(schema)` inside a producer resolves to the
- * previous layer, or to the kind's ordinary mapping when there is none.
- * `meta` is read off that same substituted schema, so the two keys
- * describe one object.
+ * `schema` carries whichever adaptation for this same adapter it replaced,
+ * absent at the bottom of the stack (see `Adapter/Core.ts`'s `layer`) — so
+ * `toTypeBox(schema)` inside a producer resolves to the previous layer, or to
+ * the kind's ordinary mapping when there is none. `meta` is read off that same
+ * substituted schema, so the two keys describe one object.
  *
- * `meta`'s shape is the kind's own config blob, derived by indexed
- * access rather than named separately so no kind states its own `Meta`
- * twice in an `adapt` signature. **Readable but not stabilized**: an
- * adaptation may read it; a kind stays free to restructure it — nothing
- * outside a kind's own files should *interpret* another kind's `[Meta]`.
+ * `meta`'s shape is the kind's own config blob, derived by indexed access
+ * rather than named separately so no kind states its own `Meta` twice in an
+ * `adapt` signature. **Readable but not stabilized**: an adaptation may read
+ * it; a kind stays free to restructure it — nothing outside a kind's own files
+ * should _interpret_ another kind's `[Meta]`.
  *
  * A kind with no bare-form default carries no `[Meta]` at runtime until
  * configured (`string`/`bigint`'s registry exports — see "Anatomy of a
- * primitive"), so `meta` can be `undefined` there despite this type.
- * Same imprecision `Schema<$Meta>` already states, and why the TypeBox
- * adapter reads `[Meta]` defensively for those kinds.
+ * primitive"), so `meta` can be `undefined` there despite this type. Same
+ * imprecision `Schema<$Meta>` already states, and why the TypeBox adapter reads
+ * `[Meta]` defensively for those kinds.
  */
 export type Adapting<$Schema extends {
     [Meta]: unknown;
@@ -46,70 +44,64 @@ export type Adapting<$Schema extends {
     readonly meta: $Schema[typeof Meta];
 };
 /**
- * What a Schema's `[Adaptation]` holds: each adapter's override, under
- * that adapter's own key.
+ * What a Schema's `[Adaptation]` holds: each adapter's override, under that
+ * adapter's own key.
  *
- * Open rather than a closed registry of known libraries: an adapter is
- * a value (see {@link Adapter}), not a name this package knows. Nothing
- * has to be declared for a third party's adapter to work, and two
- * adapters for different versions of the same library collide with
- * nothing.
+ * Open rather than a closed registry of known libraries: an adapter is a value
+ * (see {@link Adapter}), not a name this package knows. Nothing has to be
+ * declared for a third party's adapter to work, and two adapters for different
+ * versions of the same library collide with nothing.
  */
 export type Adaptations = {
     readonly [key: string]: SchemaAdaptation;
 };
 /**
  * An {@link Adaptations} update as `withAdaptations` accepts it. Identical
- * except that an explicitly-`undefined` entry *removes* that adapter's
- * override — how the layering hands an adaptation the schema it is
- * adapting with its own entry replaced by the previous one, or absent
- * at the bottom of the stack.
+ * except that an explicitly-`undefined` entry _removes_ that adapter's override
+ * — how the layering hands an adaptation the schema it is adapting with its own
+ * entry replaced by the previous one, or absent at the bottom of the stack.
  *
- * Not what a kind's `.adapt(...)` accepts: removal is an internal need
- * of the layering, and letting a caller express it would produce a
- * `[Adaptation]` type that `exactOptionalPropertyTypes` rejects against
- * {@link Adaptations}.
+ * Not what a kind's `.adapt(...)` accepts: removal is an internal need of the
+ * layering, and letting a caller express it would produce a `[Adaptation]` type
+ * that `exactOptionalPropertyTypes` rejects against {@link Adaptations}.
  */
 export type Patch = {
     readonly [key: string]: SchemaAdaptation | undefined;
 };
 /**
  * How an adapter recurses into a nested schema — handed to
- * {@link Adapter.convert} by `Adapter/Core.ts`'s `drive` rather than
- * being the adapter's own private recursion, so every nested node goes
- * back through the adaptation lookup, not only the outermost one.
+ * {@link Adapter.convert} by `Adapter/Core.ts`'s `walk` rather than being the
+ * adapter's own private recursion, so every nested node goes back through the
+ * adaptation lookup, not only the outermost one.
  *
- * `$Context` is the adapter's own, and opaque here: an adapter that
- * needs to carry something down its recursion (the enclosing
- * `T.recursive`'s placeholder, say) threads it through unchanged.
- * `$Returnable` is likewise the adapter's own — stated so a nested
- * node's result drops straight into a composite
- * (`Type.Array(recurse(element, context))`) with no cast at any call
+ * `$Context` is the adapter's own, and opaque here: an adapter that needs to
+ * carry something down its recursion (the enclosing `T.recursive`'s
+ * placeholder, say) threads it through unchanged. `$Returnable` is likewise the
+ * adapter's own — stated so a nested node's result drops straight into a
+ * composite (`Type.Array(recurse(element, context))`) with no cast at any call
  * site.
  */
 export type Recurse<$Context, $Returnable> = (schema: any, context: $Context) => $Returnable;
 /**
- * An adapter to one external schema library: a plain value, imported
- * directly by whoever adapts a schema (`schema.adapt(typebox, ...)`)
- * and by whoever converts one. Nothing to register — no global
- * interface to declaration-merge, and no name chosen anywhere but here.
+ * An adapter to one external schema library: a plain value, imported directly
+ * by whoever adapts a schema (`schema.adapt(typebox, ...)`) and by whoever
+ * converts one. Nothing to register — no global interface to declaration-merge,
+ * and no name chosen anywhere but here.
  *
- * `key` is the adapter's `[Adaptation]` namespace. Read off the value
- * as a literal type, so a wrong one is an import error rather than an
- * entry nothing looks up. Give it something collision-proof — a package
- * specifier, versioned when a library's major rewrite means two
- * adapters can coexist.
+ * `key` is the adapter's `[Adaptation]` namespace. Read off the value as a
+ * literal type, so a wrong one is an import error rather than an entry nothing
+ * looks up. Give it something collision-proof — a package specifier, versioned
+ * when a library's major rewrite means two adapters can coexist.
  *
- * `convert`'s declared return type is this adapter's external bound:
- * the type every `.adapt(...)` against it must produce, and why an
- * adaptation that returns the wrong thing fails at the call site.
+ * `convert`'s declared return type is this adapter's external bound: the type
+ * every `.adapt(...)` against it must produce, and why an adaptation that
+ * returns the wrong thing fails at the call site.
  *
- * Deliberately *not* carrying the adapter's type-level mapping. An
- * adapter package declares its own conversion entry point with its own
- * return type (`toTypeBox<$S>(schema: $S): ToTypeBox<$S>`), so nothing
- * has to compute a type-level mapping out of a stored value — which
- * would need the interface-member-lookup encoding `ValueOf`'s
- * `$Bindings` uses, for no gain.
+ * Deliberately _not_ carrying the adapter's type-level mapping. An adapter
+ * package declares its own conversion entry point with its own return type
+ * (`toTypeBox<$S>(schema: $S): ToTypeBox<$S>`), so nothing has to compute a
+ * type-level mapping out of a stored value — which would need the
+ * interface-member-lookup encoding `ValueOf`'s `$Bindings` uses, for no gain.
  */
 export interface Adapter<$Key extends string = string, $Context = unknown, $Returnable = unknown> {
     readonly key: $Key;
@@ -119,27 +111,25 @@ export interface Adapter<$Key extends string = string, $Context = unknown, $Retu
  * The adaptations a Schema (or a built Fabricator, which carries them
  * identically) declares, or `{}` for one that declares none.
  *
- * The two steps — extract the map, then match against it — are
- * load-bearing, and why no adapter matches
- * `{ [Adaptation]?: Record<Key, ...> }` directly. Every kind's `Core`
- * declares `[Adaptation]` as *optional*, and a conditional matching an
- * optional property against a schema that lacks it entirely still
- * *succeeds*, inferring `unknown` (the same behavior `ValueOf` relies
- * on for `[Produces]`) — so a direct match would resolve every
- * unadapted schema to whatever the adapter's adaptation branch
- * produces. Constraining the `infer` sends that case here, to `{}`,
- * which then fails each adapter's `Record<Key, ...>` check as it
- * should.
+ * The two steps — extract the map, then match against it — are load-bearing,
+ * and why no adapter matches `{ [Adaptation]?: Record<Key, ...> }` directly.
+ * Every kind's `Core` declares `[Adaptation]` as _optional_, and a conditional
+ * matching an optional property against a schema that lacks it entirely still
+ * _succeeds_, inferring `unknown` (the same behavior `ValueOf` relies on for
+ * `[Produces]`) — so a direct match would resolve every unadapted schema to
+ * whatever the adapter's adaptation branch produces. Constraining the `infer`
+ * sends that case here, to `{}`, which then fails each adapter's `Record<Key,
+ * ...>` check as it should.
  */
 export type AdaptationsOf<$Schema> = $Schema extends {
     [Adaptation]?: infer $Adaptations extends Adaptations;
 } ? $Adaptations : {};
 /**
- * `$Prior` with `$Map` applied: an adapter named in `$Map` takes its new
- * entry; one it doesn't name is carried forward. `Omit` first (rather
- * than a plain `$Prior & $Map`) so a replaced entry is genuinely
- * replaced — intersecting two call signatures for the same adapter
- * would produce an overload, from which an adapter's `infer` would
- * read whichever member TypeScript happens to resolve last.
+ * `$Prior` with `$Map` applied: an adapter named in `$Map` takes its new entry;
+ * one it doesn't name is carried forward. `Omit` first (rather than a plain
+ * `$Prior & $Map`) so a replaced entry is genuinely replaced — intersecting two
+ * call signatures for the same adapter would produce an overload, from which an
+ * adapter's `infer` would read whichever member TypeScript happens to resolve
+ * last.
  */
 export type WithAdaptations<$Prior extends Adaptations, $Map extends Adaptations> = Omit<$Prior, keyof $Map> & $Map;

package/dist/types/Bound.d.ts

@@ -1,16 +1,16 @@
 /**
  * Canonical endpoint stored on `[Meta].whereby`. Call sites still accept a
- * scalar (inclusive) via {@link InputBound}; `.whereby()` runs {@link toBound}
- * so adapters always see this shape — never a scalar/object union.
+ * scalar (inclusive) via {@link InputBound}; `.whereby()` runs {@link toBound} so
+ * adapters always see this shape — never a scalar/object union.
  */
 export type Bound<$T> = {
     value: $T;
     exclusive: boolean;
 };
 /**
- * What `.whereby({ min, max })` accepts: a scalar is inclusive, an object
- * names an endpoint policy. `exclusive` is required on the object form so
- * that form exists only to state one.
+ * What `.whereby({ min, max })` accepts: a scalar is inclusive, an object names
+ * an endpoint policy. `exclusive` is required on the object form so that form
+ * exists only to state one.
  */
 export type InputBound<$T> = $T | Bound<$T>;
 /**
@@ -20,8 +20,8 @@ export type InputBound<$T> = $T | Bound<$T>;
  */
 export declare function toBound<$T>(input: InputBound<$T>): Bound<$T>;
 /**
- * Inclusive integer interval implied by a discrete Bound pair. Exclusive min
- * is `value + 1`, exclusive max is `value - 1` — the same unit the length/
+ * Inclusive integer interval implied by a discrete Bound pair. Exclusive min is
+ * `value + 1`, exclusive max is `value - 1` — the same unit the length/
  * integer/bigint draws already use. Empty iff `min > max`.
  */
 export declare function effectiveDiscrete(min: Bound<number>, max: Bound<number>): {
@@ -37,15 +37,15 @@ export declare function assertNonemptyDiscreteBigint(label: string, min: Bound<b
 /**
  * Continuous emptiness: inverted bounds, a point range with either end
  * exclusive, or both ends exclusive with no float strictly between them.
- * Sampling still uses the closed interval and {@link constrainContinuous}
- * steps off an exclusive endpoint — this check is what makes that step
- * always have somewhere to land.
+ * Sampling still uses the closed interval and {@link constrainContinuous} steps
+ * off an exclusive endpoint — this check is what makes that step always have
+ * somewhere to land.
  */
 export declare function assertNonemptyContinuous(label: string, min: Bound<number>, max: Bound<number>): void;
 /**
- * One ulp toward `toward` from `value`. Approximate, and enough to leave
- * an exclusive endpoint without rejection-looping a truncated distribution
- * that clamped onto it.
+ * One ulp toward `toward` from `value`. Approximate, and enough to leave an
+ * exclusive endpoint without rejection-looping a truncated distribution that
+ * clamped onto it.
  */
 export declare function towardInterior(value: number, toward: number): number;
 /**
@@ -56,8 +56,8 @@ 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.
+ * 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.
  */
 export declare function toLengthRange(length: number | {
     max: InputBound<number>;