effect 4.0.0-rc.112 → 4.0.0-rc.113

package/dist/internal/schema/toArbitrary.js

@@ -1,705 +0,0 @@
-import * as Array from "../../Array.js";
-import * as Boolean from "../../Boolean.js";
-import * as Equal from "../../Equal.js";
-import { memoize } from "../../Function.js";
-import * as Number from "../../Number.js";
-import * as Option from "../../Option.js";
-import * as Order from "../../Order.js";
-import * as Predicate from "../../Predicate.js";
-import * as SchemaAST from "../../SchemaAST.js";
-import * as Struct from "../../Struct.js";
-import * as UndefinedOr from "../../UndefinedOr.js";
-import { errorWithPath } from "../errors.js";
-import * as InternalRecord from "../record.js";
-import * as InternalAnnotations from "./annotations.js";
-const arbitraryMemoMap = /*#__PURE__*/new WeakMap();
-const suspendDepthIdentifierMap = /*#__PURE__*/new WeakMap();
-const emptyRecursionStack = [];
-function arbitraryError(what) {
-  return new Error(`Unable to derive an arbitrary for ${what}`);
-}
-const entryComparator = ([a], [b]) => Equal.equals(a, b);
-function applyChecks(ast, filters, arbitrary) {
-  return filters.reduce((acc, filter) => acc.filter(a => filter.run(a, ast, SchemaAST.defaultParseOptions) === undefined), arbitrary);
-}
-function validateArrayConstraints(constraint, label) {
-  if (constraint?.minLength !== undefined && constraint.maxLength !== undefined && constraint.minLength > constraint.maxLength) {
-    throw arbitraryError(`${label} constraints`);
-  }
-}
-function lengthToFastCheckConstraints(constraint) {
-  return constraint === undefined || constraint.minLength === undefined && constraint.maxLength === undefined ? undefined : {
-    ...(constraint.minLength !== undefined ? {
-      minLength: constraint.minLength
-    } : {}),
-    ...(constraint.maxLength !== undefined ? {
-      maxLength: constraint.maxLength
-    } : {})
-  };
-}
-function arrayWithConstraints(fc, item, constraint, comparator) {
-  return comparator ? fc.uniqueArray(item, {
-    ...constraint,
-    comparator
-  }) : fc.array(item, constraint);
-}
-function array(fc, ctx, item, terminal = false) {
-  const constraint = ctx.constraint;
-  const arrayConstraints = lengthToFastCheckConstraints(constraint);
-  validateArrayConstraints(arrayConstraints, "array");
-  return arrayWithConstraints(fc, item, terminal ? {
-    ...arrayConstraints,
-    maxLength: arrayConstraints?.minLength ?? 0
-  } : arrayConstraints, constraint?.unique ? Equal.equals : undefined);
-}
-function appendArray(fc, out, len, rest) {
-  return out.chain(as => as.length < len ? fc.constant(as) : rest.map(rest => [...as, ...rest]));
-}
-function appendObjectEntries(out, entries) {
-  return out.chain(o => entries.map(entries => ({
-    ...Object.fromEntries(entries),
-    ...o
-  })));
-}
-const max = /*#__PURE__*/UndefinedOr.makeReducer(Number.ReducerMax);
-const min = /*#__PURE__*/UndefinedOr.makeReducer(Number.ReducerMin);
-const or = /*#__PURE__*/UndefinedOr.makeReducer(Boolean.ReducerOr);
-const concat = /*#__PURE__*/UndefinedOr.makeReducer(/*#__PURE__*/Array.makeReducerConcat());
-const combiner = /*#__PURE__*/Struct.makeCombiner({
-  integer: or,
-  maxLength: min,
-  minLength: max,
-  noInfinity: or,
-  noNaN: or,
-  patterns: concat,
-  unique: or
-}, {
-  omitKeyWhen: Predicate.isUndefined
-});
-function mergeOrderedBound(order, self, selfExclusive, that, thatExclusive, takeComparison) {
-  if (that === undefined || self === undefined) {
-    return that === undefined ? [self, selfExclusive] : [that, thatExclusive];
-  }
-  const comparison = order(self, that);
-  return comparison === takeComparison ? [that, thatExclusive] : comparison === 0 ? [self, selfExclusive || thatExclusive] : [self, selfExclusive];
-}
-function mergeOrderedConstraints(self, that) {
-  if (self === undefined) {
-    return that;
-  }
-  if (self.order !== that.order) {
-    throw new Error("Cannot merge ordered arbitrary constraints with different Order instances");
-  }
-  const [minimum, exclusiveMinimum] = mergeOrderedBound(self.order, self.minimum, self.exclusiveMinimum, that.minimum, that.exclusiveMinimum, -1);
-  const [maximum, exclusiveMaximum] = mergeOrderedBound(self.order, self.maximum, self.exclusiveMaximum, that.maximum, that.exclusiveMaximum, 1);
-  return {
-    order: self.order,
-    ...(minimum !== undefined ? {
-      minimum
-    } : {}),
-    ...(exclusiveMinimum !== undefined ? {
-      exclusiveMinimum
-    } : {}),
-    ...(maximum !== undefined ? {
-      maximum
-    } : {}),
-    ...(exclusiveMaximum !== undefined ? {
-      exclusiveMaximum
-    } : {})
-  };
-}
-function mergeConstraint(self, that) {
-  const {
-    ordered: selfOrdered,
-    ...selfRest
-  } = self ?? {};
-  const {
-    ordered: thatOrdered,
-    ...thatRest
-  } = that;
-  const ordered = thatOrdered === undefined ? selfOrdered : mergeOrderedConstraints(selfOrdered, thatOrdered);
-  const out = combiner.combine(selfRest, thatRest);
-  return {
-    ...out,
-    ...(ordered === undefined ? {} : {
-      ordered
-    })
-  };
-}
-function collectChecks(checks) {
-  const filters = [];
-  const arbitraries = [];
-  function visit(check) {
-    if (check.annotations?.arbitrary) {
-      arbitraries.push(check.annotations.arbitrary);
-    }
-    if (check._tag !== "Filter") {
-      for (const child of check.checks) {
-        visit(child);
-      }
-    } else {
-      filters.push(check);
-    }
-  }
-  checks?.forEach(visit);
-  return {
-    filters,
-    arbitraries
-  };
-}
-function constraintContext(arbitraries) {
-  const constraintAnnotations = arbitraries.map(({
-    constraint
-  }) => constraint).filter(Predicate.isNotUndefined);
-  return ctx => {
-    const constraint = constraintAnnotations.reduce((acc, c) => mergeConstraint(acc, c), ctx.constraint);
-    return {
-      ...ctx,
-      constraint
-    };
-  };
-}
-function resetContext(ctx) {
-  return {
-    ...ctx,
-    constraint: undefined
-  };
-}
-function objectEntriesConstraints(ast, constraint, requiredKeys) {
-  if (constraint === undefined || constraint.minLength === undefined && constraint.maxLength === undefined) {
-    return undefined;
-  }
-  if (constraint.minLength !== undefined && ast.indexSignatures.length === 0 && constraint.minLength > ast.propertySignatures.length) {
-    throw arbitraryError("object property constraints");
-  }
-  const out = {};
-  if (constraint.minLength !== undefined) {
-    out.minLength = Math.max(0, constraint.minLength - requiredKeys);
-  }
-  if (constraint.maxLength !== undefined) {
-    out.maxLength = constraint.maxLength - requiredKeys;
-    if (out.maxLength < 0) {
-      throw arbitraryError("object property constraints");
-    }
-  }
-  validateArrayConstraints(out, "object property");
-  return out;
-}
-function objectWithOptionalCount(fc, pss, orderedNames, requiredKeys, optionalNames, constraint) {
-  const requiredCount = requiredKeys.length;
-  if (constraint.maxLength !== undefined && constraint.maxLength < requiredCount) {
-    throw arbitraryError("object property constraints");
-  }
-  const minOptional = constraint.minLength === undefined ? 0 : Math.max(0, constraint.minLength - requiredCount);
-  const maxOptional = constraint.maxLength === undefined ? optionalNames.length : Math.min(optionalNames.length, constraint.maxLength - requiredCount);
-  if (minOptional > maxOptional) {
-    throw arbitraryError("object property constraints");
-  }
-  const full = fc.record(pss, {
-    requiredKeys: [...requiredKeys, ...optionalNames]
-  });
-  const chosen = fc.shuffledSubarray([...optionalNames], {
-    minLength: minOptional,
-    maxLength: maxOptional
-  });
-  return fc.tuple(full, chosen).map(([base, names]) => {
-    const keep = new Set([...requiredKeys, ...names]);
-    const out = {};
-    for (const name of orderedNames) {
-      if (keep.has(name)) {
-        InternalRecord.assignProperty(out, name, base[name]);
-      }
-    }
-    return out;
-  });
-}
-function toRangeConstraints(ordered, min, max, error) {
-  const out = {};
-  if (ordered?.minimum !== undefined) {
-    out.min = min(ordered.minimum, ordered.exclusiveMinimum === true);
-  }
-  if (ordered?.maximum !== undefined) {
-    out.max = max(ordered.maximum, ordered.exclusiveMaximum === true);
-  }
-  if (out.min !== undefined && out.max !== undefined && out.min > out.max) {
-    throw arbitraryError(error);
-  }
-  return out;
-}
-function toIntegerConstraints(ordered) {
-  return toRangeConstraints(ordered, (minimum, excluded) => excluded ? Math.floor(minimum) + 1 : Math.ceil(minimum), (maximum, excluded) => excluded ? Math.ceil(maximum) - 1 : Math.floor(maximum), "integer constraints");
-}
-function toFloatConstraints(constraint, ordered) {
-  const out = {
-    ...(constraint?.noInfinity ? {
-      noDefaultInfinity: true
-    } : {}),
-    ...(constraint?.noNaN ? {
-      noNaN: true
-    } : {}),
-    ...(ordered?.minimum !== undefined ? {
-      min: ordered.minimum
-    } : {}),
-    ...(ordered?.exclusiveMinimum !== undefined ? {
-      minExcluded: ordered.exclusiveMinimum
-    } : {}),
-    ...(ordered?.maximum !== undefined ? {
-      max: ordered.maximum
-    } : {}),
-    ...(ordered?.exclusiveMaximum !== undefined ? {
-      maxExcluded: ordered.exclusiveMaximum
-    } : {})
-  };
-  if (out.min !== undefined && out.max !== undefined && (out.min > out.max || out.min === out.max && (out.minExcluded || out.maxExcluded))) {
-    throw arbitraryError("number constraints");
-  }
-  return out;
-}
-function toBigIntConstraints(ordered) {
-  return toRangeConstraints(ordered, (minimum, excluded) => excluded ? minimum + BigInt(1) : minimum, (maximum, excluded) => excluded ? maximum - BigInt(1) : maximum, "the ordered bigint constraints");
-}
-function makeLazy(normal, terminal) {
-  const out = (fc, ctx, recursionStack = emptyRecursionStack) => normal(fc, ctx, recursionStack);
-  out.terminal = (fc, ctx, recursionStack = emptyRecursionStack) => terminal(fc, ctx, recursionStack);
-  return out;
-}
-function same(f) {
-  return makeLazy(f, f);
-}
-function getSuspendRecursion(fc, ast) {
-  const depthIdentifier = suspendDepthIdentifierMap.get(ast) ?? fc.createDepthIdentifier();
-  suspendDepthIdentifierMap.set(ast, depthIdentifier);
-  return {
-    maxDepth: 2,
-    depthIdentifier
-  };
-}
-function oneOf(fc, arbitraries) {
-  return arbitraries.length === 0 ? undefined : arbitraries.length === 1 ? arbitraries[0] : fc.oneof(...arbitraries);
-}
-const finiteNumberConstraint = {
-  noInfinity: true,
-  noNaN: true
-};
-function finiteNumberContext(ctx) {
-  return {
-    ...ctx,
-    constraint: finiteNumberConstraint
-  };
-}
-function applyCandidates(fc, ctx, arbitraries, base) {
-  const weighted = base === undefined ? [] : [{
-    arbitrary: base,
-    weight: 1
-  }];
-  for (const {
-    candidate
-  } of arbitraries) {
-    if (!candidate) {
-      continue;
-    }
-    const arbitrary = candidate.make(fc, ctx);
-    if (arbitrary === undefined) {
-      continue;
-    }
-    const weight = candidate.weight ?? 1;
-    if (!globalThis.Number.isInteger(weight) || weight <= 0) {
-      throw arbitraryError("a candidate with an invalid weight");
-    }
-    weighted.push({
-      arbitrary,
-      weight
-    });
-  }
-  return weighted.length === 0 ? undefined : weighted.length === 1 ? weighted[0].arbitrary : fc.oneof(...weighted);
-}
-function applyFilterLayer(ast, checks, fc, ctx, base) {
-  const out = applyCandidates(fc, ctx, checks.arbitraries, base);
-  return out === undefined ? undefined : applyChecks(ast, checks.filters, out);
-}
-function normalizeDerivation(output, hasTypeParameters) {
-  if (!(typeof output === "object" && output !== null && "arbitrary" in output)) {
-    return {
-      arbitrary: output,
-      terminal: hasTypeParameters ? undefined : output
-    };
-  }
-  const terminal = "terminal" in output ? output.terminal : hasTypeParameters ? undefined : output.arbitrary;
-  return {
-    arbitrary: output.arbitrary,
-    terminal
-  };
-}
-function makeTypeParameters(typeParameters, fc, ctx, recursionStack, lazyNormal) {
-  return typeParameters.map(tp => ({
-    arbitrary: lazyNormal ? fc.constant(null).chain(() => tp(fc, ctx, recursionStack)) : tp(fc, ctx, recursionStack),
-    terminal: tp.terminal(fc, ctx, recursionStack)
-  }));
-}
-function filterLayer(ast, checks, normalBase, terminalBase) {
-  const f = constraintContext(checks.arbitraries);
-  return makeLazy((fc, ctx, recursionStack) => {
-    const nextCtx = f(ctx);
-    return applyFilterLayer(ast, checks, fc, nextCtx, normalBase(fc, ctx, nextCtx, recursionStack));
-  }, (fc, ctx, recursionStack) => {
-    const nextCtx = f(ctx);
-    return applyFilterLayer(ast, checks, fc, nextCtx, terminalBase(fc, ctx, nextCtx, recursionStack));
-  });
-}
-/** @internal */
-export const memoized = /*#__PURE__*/memoize(ast => recur(ast, []));
-function recur(ast, path) {
-  // ---------------------------------------------
-  // handle annotations
-  // ---------------------------------------------
-  const annotation = InternalAnnotations.resolve(ast)?.toArbitrary;
-  if (annotation) {
-    const typeParameters = SchemaAST.isDeclaration(ast) ? ast.typeParameters.map(tp => recur(tp, path)) : [];
-    const checks = collectChecks(ast.checks);
-    const derive = lazyNormal => (fc, ctx, nextCtx, recursionStack) => normalizeDerivation(annotation(makeTypeParameters(typeParameters, fc, resetContext(ctx), recursionStack, lazyNormal))(fc, nextCtx), typeParameters.length > 0)[lazyNormal ? "terminal" : "arbitrary"];
-    return filterLayer(ast, checks, derive(false), derive(true));
-  }
-  if (ast.checks) {
-    const checks = collectChecks(ast.checks);
-    const lawc = recur(SchemaAST.replaceChecks(ast, undefined), path);
-    return filterLayer(ast, checks, (fc, _ctx, nextCtx, recursionStack) => lawc(fc, nextCtx, recursionStack), (fc, _ctx, nextCtx, recursionStack) => lawc.terminal(fc, nextCtx, recursionStack));
-  }
-  return base(ast, path);
-}
-function base(ast, path) {
-  switch (ast._tag) {
-    case "Never":
-    case "Declaration":
-      throw errorWithPath(`Unsupported AST ${ast._tag}`, path);
-    case "Null":
-      return same(fc => fc.constant(null));
-    case "Void":
-    case "Undefined":
-      return same(fc => fc.constant(undefined));
-    case "Unknown":
-    case "Any":
-      return same(fc => fc.anything());
-    case "String":
-      return same((fc, ctx) => {
-        const constraint = ctx.constraint;
-        const patterns = constraint?.patterns;
-        return patterns ? fc.oneof(...patterns.map(pattern => fc.stringMatching(new RegExp(pattern)))) : fc.string(lengthToFastCheckConstraints(constraint));
-      });
-    case "Number":
-      return same((fc, ctx) => {
-        const constraint = ctx.constraint;
-        const ordered = constraint?.ordered?.order === Order.Number ? constraint.ordered : undefined;
-        return constraint?.integer ? fc.integer(toIntegerConstraints(ordered)) : fc.float(toFloatConstraints(constraint, ordered));
-      });
-    case "Boolean":
-      return same(fc => fc.boolean());
-    case "BigInt":
-      return same((fc, ctx) => {
-        const ordered = ctx.constraint?.ordered?.order === Order.BigInt ? ctx.constraint.ordered : undefined;
-        return fc.bigInt(toBigIntConstraints(ordered));
-      });
-    case "Symbol":
-      return same(fc => fc.string().map(Symbol.for));
-    case "Literal":
-      return same(fc => fc.constant(ast.literal));
-    case "UniqueSymbol":
-      return same(fc => fc.constant(ast.symbol));
-    case "ObjectKeyword":
-      return same(fc => fc.oneof(fc.object(), fc.array(fc.anything())));
-    case "Enum":
-      return recur(SchemaAST.enumsToLiterals(ast), path);
-    case "TemplateLiteral":
-      {
-        const parts = ast.parts.map((part, i) => recur(SchemaAST.toEncoded(part), [...path, i]));
-        return same((fc, ctx, recursionStack) => fc.tuple(...parts.map(part => part(fc, finiteNumberContext(ctx), recursionStack))).map(segments => segments.map(segment => globalThis.String(segment)).join("")));
-      }
-    case "Arrays":
-      {
-        const elements = ast.elements.map((ast, i) => ({
-          ast,
-          arbitrary: recur(ast, [...path, i])
-        }));
-        const len = ast.elements.length;
-        const rest = ast.rest.map((ast, i) => ({
-          ast,
-          arbitrary: recur(ast, [...path, len + i])
-        }));
-        const terminal = (fc, ctx, recursionStack) => {
-          const reset = resetContext(ctx);
-          const elementArbitraries = [];
-          const optionals = [];
-          let length = 0;
-          for (const element of elements) {
-            const out = element.arbitrary.terminal(fc, reset, recursionStack);
-            if (SchemaAST.isOptional(element.ast)) {
-              optionals.push(out);
-              continue;
-            }
-            if (out === undefined) {
-              return undefined;
-            }
-            length++;
-            elementArbitraries.push(out.map(Option.some));
-          }
-          const minLength = ctx.constraint?.minLength ?? 0;
-          const needsRest = Array.isReadonlyArrayNonEmpty(rest) && minLength > length + optionals.length;
-          const optionalTarget = needsRest ? optionals.length : Math.max(0, minLength - length);
-          let includedOptionals = 0;
-          for (const out of optionals) {
-            if (includedOptionals >= optionalTarget || out === undefined) {
-              elementArbitraries.push(fc.constant(Option.none()));
-              continue;
-            }
-            includedOptionals++;
-            length++;
-            elementArbitraries.push(out.map(Option.some));
-          }
-          if (includedOptionals < optionalTarget) {
-            return undefined;
-          }
-          let out = fc.tuple(...elementArbitraries).map(Array.getSomes);
-          if (Array.isReadonlyArrayNonEmpty(rest)) {
-            const [head, ...tail] = rest;
-            const restCtx = ast.elements.length === 0 ? ctx : reset;
-            const minRestLength = Math.max(0, minLength - length - tail.length);
-            const headArbitrary = minRestLength === 0 ? undefined : head.arbitrary.terminal(fc, reset, recursionStack);
-            if (minRestLength > 0 && headArbitrary === undefined) {
-              return undefined;
-            }
-            const restArbitrary = minRestLength === 0 ? fc.constant([]) : array(fc, {
-              ...restCtx,
-              constraint: {
-                ...restCtx.constraint,
-                minLength: minRestLength
-              }
-            }, headArbitrary, true);
-            out = appendArray(fc, out, len, restArbitrary);
-            if (tail.length > 0) {
-              const tailArbitraries = [];
-              for (const element of tail) {
-                const out = element.arbitrary.terminal(fc, reset, recursionStack);
-                if (out === undefined) {
-                  return undefined;
-                }
-                tailArbitraries.push(out);
-              }
-              const t = fc.tuple(...tailArbitraries);
-              out = appendArray(fc, out, len, t);
-            }
-          }
-          return out;
-        };
-        return makeLazy((fc, ctx, recursionStack) => {
-          const reset = resetContext(ctx);
-          // ---------------------------------------------
-          // handle elements
-          // ---------------------------------------------
-          const elementArbitraries = elements.map(({
-            ast,
-            arbitrary
-          }) => {
-            const out = arbitrary(fc, reset, recursionStack);
-            return SchemaAST.isOptional(ast) ? out.chain(a => fc.boolean().map(b => b ? Option.some(a) : Option.none())) : out.map(Option.some);
-          });
-          let out = fc.tuple(...elementArbitraries).map(elements => Array.getSomes(Array.takeWhile(elements, Option.isSome)));
-          // ---------------------------------------------
-          // handle rest element
-          // ---------------------------------------------
-          if (Array.isReadonlyArrayNonEmpty(rest)) {
-            const [head, ...tail] = rest.map(({
-              arbitrary
-            }) => arbitrary(fc, reset, recursionStack));
-            const restArbitrary = array(fc, ast.elements.length === 0 ? ctx : reset, head);
-            out = appendArray(fc, out, len, restArbitrary);
-            // ---------------------------------------------
-            // handle post rest elements
-            // ---------------------------------------------
-            if (tail.length > 0) {
-              const t = fc.tuple(...tail);
-              out = appendArray(fc, out, len, t);
-            }
-          }
-          if (ctx.recursion) {
-            const terminalOut = terminal(fc, ctx, recursionStack);
-            if (terminalOut !== undefined) {
-              return fc.oneof(ctx.recursion, terminalOut, out);
-            }
-          }
-          return out;
-        }, terminal);
-      }
-    case "Objects":
-      {
-        const propertySignatures = ast.propertySignatures.map(ps => ({
-          ps,
-          arbitrary: recur(ps.type, [...path, ps.name])
-        }));
-        const indexSignatures = ast.indexSignatures.map(is => ({
-          is,
-          parameter: recur(is.parameter, path),
-          type: recur(is.type, path)
-        }));
-        const terminal = (fc, ctx, recursionStack) => {
-          const reset = resetContext(ctx);
-          const pss = {};
-          const requiredKeys = [];
-          const optionals = [];
-          for (const {
-            ps,
-            arbitrary
-          } of propertySignatures) {
-            const name = ps.name;
-            const out = arbitrary.terminal(fc, reset, recursionStack);
-            if (SchemaAST.isOptional(ps.type)) {
-              if (out !== undefined) {
-                optionals.push([name, out]);
-              }
-              continue;
-            }
-            if (out === undefined) {
-              return undefined;
-            }
-            requiredKeys.push(name);
-            InternalRecord.assignProperty(pss, name, out);
-          }
-          let optionalCount = Math.max(0, (ctx.constraint?.minLength ?? 0) - requiredKeys.length);
-          for (const [name, out] of optionals) {
-            if (optionalCount === 0) {
-              break;
-            }
-            optionalCount--;
-            requiredKeys.push(name);
-            InternalRecord.assignProperty(pss, name, out);
-          }
-          if (optionalCount > 0 && ast.indexSignatures.length === 0) {
-            return undefined;
-          }
-          let out = fc.record(pss, {
-            requiredKeys
-          });
-          const entriesConstraints = objectEntriesConstraints(ast, ctx.constraint, requiredKeys.length);
-          const minEntries = entriesConstraints?.minLength ?? 0;
-          for (const {
-            parameter,
-            type
-          } of indexSignatures) {
-            let entries;
-            if (minEntries === 0) {
-              entries = fc.constant([]);
-            } else {
-              const key = parameter.terminal(fc, reset, recursionStack);
-              const value = type.terminal(fc, reset, recursionStack);
-              if (key === undefined || value === undefined) {
-                return undefined;
-              }
-              entries = arrayWithConstraints(fc, fc.tuple(key, value), {
-                ...entriesConstraints,
-                maxLength: minEntries
-              }, entryComparator);
-            }
-            out = appendObjectEntries(out, entries);
-          }
-          return out;
-        };
-        return makeLazy((fc, ctx, recursionStack) => {
-          const reset = resetContext(ctx);
-          // ---------------------------------------------
-          // handle property signatures
-          // ---------------------------------------------
-          const pss = {};
-          const orderedNames = [];
-          const requiredKeys = [];
-          const optionalNames = [];
-          for (const {
-            ps,
-            arbitrary
-          } of propertySignatures) {
-            const name = ps.name;
-            orderedNames.push(name);
-            if (SchemaAST.isOptional(ps.type)) {
-              optionalNames.push(name);
-            } else {
-              requiredKeys.push(name);
-            }
-            InternalRecord.assignProperty(pss, name, arbitrary(fc, reset, recursionStack));
-          }
-          // When property-count constraints must be satisfied by selecting
-          // optional keys (no index signatures are available to fill the gap),
-          // generate a count-controlled subset of optional keys instead of
-          // relying on fast-check's independent inclusion plus discards. This
-          // enforces both bounds precisely while still varying which optionals
-          // appear.
-          const constraint = ctx.constraint;
-          if (optionalNames.length > 0 && indexSignatures.length === 0 && constraint !== undefined && (constraint.minLength !== undefined || constraint.maxLength !== undefined)) {
-            return objectWithOptionalCount(fc, pss, orderedNames, requiredKeys, optionalNames, constraint);
-          }
-          let out = fc.record(pss, {
-            requiredKeys
-          });
-          const entriesConstraints = objectEntriesConstraints(ast, ctx.constraint, requiredKeys.length);
-          // ---------------------------------------------
-          // handle index signatures
-          // ---------------------------------------------
-          for (const {
-            parameter,
-            type
-          } of indexSignatures) {
-            const entry = fc.tuple(parameter(fc, reset, recursionStack), type(fc, reset, recursionStack));
-            const entries = arrayWithConstraints(fc, entry, entriesConstraints, entryComparator);
-            out = appendObjectEntries(out, entries);
-          }
-          return out;
-        }, terminal);
-      }
-    case "Union":
-      {
-        const types = ast.types.map(ast => recur(ast, path));
-        const terminal = (fc, ctx, recursionStack) => oneOf(fc, types.map(type => type.terminal(fc, ctx, recursionStack)).filter(Predicate.isNotUndefined));
-        return makeLazy((fc, ctx, recursionStack) => {
-          const arbitraries = types.map(type => type(fc, ctx, recursionStack));
-          if (ctx.recursion) {
-            const terminalOut = terminal(fc, ctx, recursionStack);
-            if (terminalOut !== undefined) {
-              return fc.oneof(ctx.recursion, terminalOut, ...arbitraries);
-            }
-          }
-          const out = oneOf(fc, arbitraries);
-          if (out === undefined) {
-            throw arbitraryError("a union with no members");
-          }
-          return out;
-        }, terminal);
-      }
-    case "Suspend":
-      {
-        const memo = arbitraryMemoMap.get(ast);
-        if (memo) return memo;
-        const get = SchemaAST.memoizeThunk(() => recur(ast.thunk(), path));
-        const out = makeLazy((fc, ctx, recursionStack) => {
-          const recursion = getSuspendRecursion(fc, ast);
-          const nextCtx = {
-            ...ctx,
-            recursion
-          };
-          const nextStack = recursionStack.includes(ast) ? recursionStack : [...recursionStack, ast];
-          const terminal = get().terminal(fc, nextCtx, nextStack);
-          if (terminal === undefined) {
-            throw errorWithPath("Unable to derive an arbitrary for a recursive schema without a finite generation path", path);
-          }
-          return fc.oneof(recursion, terminal, fc.constant(null).chain(() => get()(fc, nextCtx, nextStack)));
-        }, (fc, ctx, recursionStack) => {
-          if (recursionStack.includes(ast)) {
-            return undefined;
-          }
-          const recursion = getSuspendRecursion(fc, ast);
-          return get().terminal(fc, {
-            ...ctx,
-            recursion
-          }, [...recursionStack, ast]);
-        });
-        arbitraryMemoMap.set(ast, out);
-        return out;
-      }
-  }
-}
-//# sourceMappingURL=toArbitrary.js.map