@amritk/generate-examples 0.5.2 → 0.5.4

package/dist/generators/generate-arbitrary.js

@@ -1,506 +1,351 @@
-import { getMjstInstanceOf, getMjstPrimitive } from '@amritk/helpers/mjst-extension';
-import { refToFilename } from '@amritk/helpers/ref-to-filename';
-import { refToName } from '@amritk/helpers/ref-to-name';
-import { hasAdditionalProperties, hasAllOf, hasAnyOf, hasConst, hasContains, hasDependentRequired, hasDependentSchemas, hasEnum, hasExclusiveMaximum, hasExclusiveMinimum, hasFormat, hasItems, hasMaxItems, hasMaximum, hasMaxLength, hasMaxProperties, hasMinItems, hasMinimum, hasMinLength, hasMinProperties, hasMultipleOf, hasOneOf, hasPattern, hasPatternProperties, hasProperties, hasPropertyNames, hasRef, hasRequired, hasType, hasUniqueItems, isSchemaObject, } from '@amritk/helpers/schema-guards';
-import { mergeAllOf } from './derive-example.js';
-import { needsValidationFilter, withResolvableDefs } from './schema-validation.js';
-/**
- * Derives the arbitrary const name from a type name.
- * e.g. "User" → "UserArbitrary"
- */
+import { getMjstInstanceOf, getMjstPrimitive } from "@amritk/helpers/mjst-extension";
+import { refToFilename } from "@amritk/helpers/ref-to-filename";
+import { refToName } from "@amritk/helpers/ref-to-name";
+import { hasAdditionalProperties, hasAllOf, hasAnyOf, hasConst, hasContains, hasDependentRequired, hasDependentSchemas, hasEnum, hasExclusiveMaximum, hasExclusiveMinimum, hasFormat, hasItems, hasMaxItems, hasMaximum, hasMaxLength, hasMaxProperties, hasMinItems, hasMinimum, hasMinLength, hasMinProperties, hasMultipleOf, hasOneOf, hasPattern, hasPatternProperties, hasProperties, hasPropertyNames, hasRef, hasRequired, hasType, hasUniqueItems, isSchemaObject } from "@amritk/helpers/schema-guards";
+import { mergeAllOf } from "./derive-example.js";
+import { needsValidationFilter, withResolvableDefs } from "./schema-validation.js";
 const arbitraryName = (typeName) => `${typeName}Arbitrary`;
-/**
- * Local alias the generated file binds `@amritk/runtime-validators`' `validate`
- * to. Namespaced (leading underscores) so it can't collide with a schema-derived
- * type name. {@link generateArbitrary} emits references to it; the file assembler
- * adds the matching import when any arbitrary uses it.
- */
-export const VALIDATE_IMPORT_NAME = '__mjstValidate';
-/**
- * The import line the generated file needs when an arbitrary embeds a validating
- * filter. Emitted by the file assembler only when {@link VALIDATE_IMPORT_NAME}
- * appears in the generated source.
- */
-export const VALIDATE_IMPORT_STATEMENT = `import { validate as ${VALIDATE_IMPORT_NAME} } from '@amritk/runtime-validators'`;
-/**
- * Wraps a cross-module arbitrary reference so the imported binding is read at
- * generation time rather than at module-init time. `fc.constant(null).chain`
- * stores the thunk and only invokes it when a value is generated — by which
- * point every module in the cycle has finished initializing — so the otherwise
- * eager identifier never touches a `const` in its TDZ.
- */
+const VALIDATE_IMPORT_NAME = "__mjstValidate";
+const VALIDATE_IMPORT_STATEMENT = `import { validate as ${VALIDATE_IMPORT_NAME} } from '@amritk/runtime-validators'`;
 const lazyRef = (arbName) => `fc.constant(null).chain(() => ${arbName})`;
-/** The letrec key used for a type's own (self-referential) arbitrary. */
-const SELF_KEY = 'self';
-/** Builds a `fc.string({ ... })` expression honouring format and length constraints. */
+const SELF_KEY = "self";
 const stringExpr = (schema) => {
-    if (hasFormat(schema)) {
-        switch (schema.format) {
-            case 'email':
-                return 'fc.emailAddress()';
-            case 'uuid':
-                return 'fc.uuid()';
-            case 'uri':
-            case 'url':
-                return 'fc.webUrl()';
-            case 'date-time':
-                return 'fc.date({ noInvalidDate: true }).map((d) => d.toISOString())';
-            case 'date':
-                return 'fc.date({ noInvalidDate: true }).map((d) => d.toISOString().slice(0, 10))';
-            case 'time':
-                return 'fc.date({ noInvalidDate: true }).map((d) => d.toISOString().slice(11))';
-            case 'hostname':
-                return 'fc.domain()';
-            case 'ipv4':
-                return 'fc.ipV4()';
-            case 'ipv6':
-                return 'fc.ipV6()';
-        }
-    }
-    if (hasPattern(schema)) {
-        // Build the regex via `new RegExp(<json-string>)` rather than inlining the
-        // pattern into a `/.../ ` literal: a pattern containing `/` (e.g. `^/api/v\d+$`)
-        // would otherwise close the literal early and emit invalid TypeScript.
-        const base = `fc.stringMatching(new RegExp(${JSON.stringify(schema.pattern)}))`;
-        // `stringMatching` takes no length bounds, so honour any min/maxLength with a
-        // filter instead of silently dropping them. Only emit it when a bound exists.
-        const checks = [];
-        if (hasMinLength(schema))
-            checks.push(`s.length >= ${schema.minLength}`);
-        if (hasMaxLength(schema))
-            checks.push(`s.length <= ${schema.maxLength}`);
-        return checks.length > 0 ? `${base}.filter((s) => ${checks.join(' && ')})` : base;
+  if (hasFormat(schema)) {
+    switch (schema.format) {
+      case "email":
+        return "fc.emailAddress()";
+      case "uuid":
+        return "fc.uuid()";
+      case "uri":
+      case "url":
+        return "fc.webUrl()";
+      case "date-time":
+        return "fc.date({ noInvalidDate: true }).map((d) => d.toISOString())";
+      case "date":
+        return "fc.date({ noInvalidDate: true }).map((d) => d.toISOString().slice(0, 10))";
+      case "time":
+        return "fc.date({ noInvalidDate: true }).map((d) => d.toISOString().slice(11))";
+      case "hostname":
+        return "fc.domain()";
+      case "ipv4":
+        return "fc.ipV4()";
+      case "ipv6":
+        return "fc.ipV6()";
     }
-    const opts = [];
+  }
+  if (hasPattern(schema)) {
+    const base = `fc.stringMatching(new RegExp(${JSON.stringify(schema.pattern)}))`;
+    const checks = [];
     if (hasMinLength(schema))
-        opts.push(`minLength: ${schema.minLength}`);
+      checks.push(`s.length >= ${schema.minLength}`);
     if (hasMaxLength(schema))
-        opts.push(`maxLength: ${schema.maxLength}`);
-    return opts.length > 0 ? `fc.string({ ${opts.join(', ')} })` : 'fc.string()';
+      checks.push(`s.length <= ${schema.maxLength}`);
+    return checks.length > 0 ? `${base}.filter((s) => ${checks.join(" && ")})` : base;
+  }
+  const opts = [];
+  if (hasMinLength(schema))
+    opts.push(`minLength: ${schema.minLength}`);
+  if (hasMaxLength(schema))
+    opts.push(`maxLength: ${schema.maxLength}`);
+  return opts.length > 0 ? `fc.string({ ${opts.join(", ")} })` : "fc.string()";
 };
-/** Builds a `fc.integer({ ... })` expression honouring range and multiple-of constraints. */
 const integerExpr = (schema) => {
-    const opts = [];
-    // With both `minimum` and `exclusiveMinimum` present the effective lower bound
-    // is the tighter (larger) of the two, so combine them rather than letting one
-    // shadow the other via else-if. `fc.integer` also requires integral bounds, but
-    // the schema keywords may be fractional (`minimum: 2.5`, `exclusiveMinimum: 5.5`),
-    // so round each toward the satisfiable side: the smallest integer that still
-    // meets the lower bound, and the largest that still meets the upper.
-    // `Math.floor(x) + 1` is the smallest integer strictly greater than `x` (so it
-    // also handles integral exclusives); `Math.ceil(x) - 1` is the largest strictly less.
-    const mins = [];
-    if (hasMinimum(schema))
-        mins.push(Math.ceil(Number(schema.minimum)));
-    if (hasExclusiveMinimum(schema))
-        mins.push(Math.floor(Number(schema.exclusiveMinimum)) + 1);
-    if (mins.length > 0)
-        opts.push(`min: ${Math.max(...mins)}`);
-    const maxs = [];
-    if (hasMaximum(schema))
-        maxs.push(Math.floor(Number(schema.maximum)));
-    if (hasExclusiveMaximum(schema))
-        maxs.push(Math.ceil(Number(schema.exclusiveMaximum)) - 1);
-    if (maxs.length > 0)
-        opts.push(`max: ${Math.min(...maxs)}`);
-    const base = opts.length > 0 ? `fc.integer({ ${opts.join(', ')} })` : 'fc.integer()';
-    return hasMultipleOf(schema) ? `${base}.filter((n) => n % ${schema.multipleOf} === 0)` : base;
+  const opts = [];
+  const mins = [];
+  if (hasMinimum(schema))
+    mins.push(Math.ceil(Number(schema.minimum)));
+  if (hasExclusiveMinimum(schema))
+    mins.push(Math.floor(Number(schema.exclusiveMinimum)) + 1);
+  if (mins.length > 0)
+    opts.push(`min: ${Math.max(...mins)}`);
+  const maxs = [];
+  if (hasMaximum(schema))
+    maxs.push(Math.floor(Number(schema.maximum)));
+  if (hasExclusiveMaximum(schema))
+    maxs.push(Math.ceil(Number(schema.exclusiveMaximum)) - 1);
+  if (maxs.length > 0)
+    opts.push(`max: ${Math.min(...maxs)}`);
+  const base = opts.length > 0 ? `fc.integer({ ${opts.join(", ")} })` : "fc.integer()";
+  return hasMultipleOf(schema) ? `${base}.filter((n) => n % ${schema.multipleOf} === 0)` : base;
 };
-/**
- * Builds a multiple-of-respecting number arbitrary analytically: pick an integer
- * `k` whose multiple `k * multipleOf` lands inside the (possibly exclusive)
- * bounds, then emit that product. Random doubles essentially never satisfy
- * `n % m === 0`, so a `.filter` here starves fast-check ("too many filtered
- * values") at sample time; deriving the multiple directly cannot fail. This
- * mirrors the static path's `deriveNumber`.
- *
- * The trailing `.map` clamps `k * m` back inside the finite bounds to absorb
- * floating-point drift (e.g. `3 * 0.1 === 0.30000000000000004`, which would
- * otherwise slip just past a `maximum` of `0.3`).
- */
 const numberMultipleOfExpr = (schema) => {
-    const m = Number(schema.multipleOf);
-    const EPS = 1e-9;
-    // Effective lower bound: the tighter (larger) of minimum / exclusiveMinimum,
-    // tracking whether the binding bound is exclusive.
-    let lo = Number.NEGATIVE_INFINITY;
-    let loExclusive = false;
-    if (hasMinimum(schema))
-        lo = Number(schema.minimum);
-    if (hasExclusiveMinimum(schema) && Number(schema.exclusiveMinimum) >= lo) {
-        lo = Number(schema.exclusiveMinimum);
-        loExclusive = true;
-    }
-    // Effective upper bound: the tighter (smaller) of maximum / exclusiveMaximum.
-    let hi = Number.POSITIVE_INFINITY;
-    let hiExclusive = false;
-    if (hasMaximum(schema))
-        hi = Number(schema.maximum);
-    if (hasExclusiveMaximum(schema) && Number(schema.exclusiveMaximum) <= hi) {
-        hi = Number(schema.exclusiveMaximum);
-        hiExclusive = true;
-    }
-    // Translate value bounds into integer-`k` bounds, where the emitted value is
-    // `k * m`. An exclusive bound must be strictly cleared, so a `k` landing exactly
-    // on it is nudged one step inward; `EPS` keeps a mathematically-integer ratio
-    // (e.g. `0.3 / 0.1`) from being mis-rounded by floating-point error.
-    let kMin;
-    let kMax;
-    if (Number.isFinite(lo)) {
-        const raw = lo / m;
-        kMin = loExclusive ? Math.floor(raw + EPS) + 1 : Math.ceil(raw - EPS);
-    }
-    if (Number.isFinite(hi)) {
-        const raw = hi / m;
-        kMax = hiExclusive ? Math.ceil(raw - EPS) - 1 : Math.floor(raw + EPS);
-    }
-    // An unsatisfiable range (no multiple fits) would make `fc.integer` throw on
-    // `min > max`; collapse to a single best-effort value instead.
-    if (kMin !== undefined && kMax !== undefined && kMin > kMax)
-        kMax = kMin;
-    const kOpts = [];
-    if (kMin !== undefined)
-        kOpts.push(`min: ${kMin}`);
-    if (kMax !== undefined)
-        kOpts.push(`max: ${kMax}`);
-    const k = kOpts.length > 0 ? `fc.integer({ ${kOpts.join(', ')} })` : 'fc.integer()';
-    let value = `k * ${m}`;
-    if (Number.isFinite(lo))
-        value = `Math.max(${value}, ${lo})`;
-    if (Number.isFinite(hi))
-        value = `Math.min(${value}, ${hi})`;
-    return `${k}.map((k) => ${value})`;
+  const m = Number(schema.multipleOf);
+  const EPS = 1e-9;
+  let lo = Number.NEGATIVE_INFINITY;
+  let loExclusive = false;
+  if (hasMinimum(schema))
+    lo = Number(schema.minimum);
+  if (hasExclusiveMinimum(schema) && Number(schema.exclusiveMinimum) >= lo) {
+    lo = Number(schema.exclusiveMinimum);
+    loExclusive = true;
+  }
+  let hi = Number.POSITIVE_INFINITY;
+  let hiExclusive = false;
+  if (hasMaximum(schema))
+    hi = Number(schema.maximum);
+  if (hasExclusiveMaximum(schema) && Number(schema.exclusiveMaximum) <= hi) {
+    hi = Number(schema.exclusiveMaximum);
+    hiExclusive = true;
+  }
+  let kMin;
+  let kMax;
+  if (Number.isFinite(lo)) {
+    const raw = lo / m;
+    kMin = loExclusive ? Math.floor(raw + EPS) + 1 : Math.ceil(raw - EPS);
+  }
+  if (Number.isFinite(hi)) {
+    const raw = hi / m;
+    kMax = hiExclusive ? Math.ceil(raw - EPS) - 1 : Math.floor(raw + EPS);
+  }
+  if (kMin !== void 0 && kMax !== void 0 && kMin > kMax)
+    kMax = kMin;
+  const kOpts = [];
+  if (kMin !== void 0)
+    kOpts.push(`min: ${kMin}`);
+  if (kMax !== void 0)
+    kOpts.push(`max: ${kMax}`);
+  const k = kOpts.length > 0 ? `fc.integer({ ${kOpts.join(", ")} })` : "fc.integer()";
+  let value = `k * ${m}`;
+  if (Number.isFinite(lo))
+    value = `Math.max(${value}, ${lo})`;
+  if (Number.isFinite(hi))
+    value = `Math.min(${value}, ${hi})`;
+  return `${k}.map((k) => ${value})`;
 };
-/** Builds a `fc.double({ ... })` expression honouring range and multiple-of constraints. */
 const numberExpr = (schema) => {
-    // A positive `multipleOf` is satisfied analytically rather than by filtering
-    // random doubles, which would starve fast-check at sample time.
-    if (hasMultipleOf(schema) && schema.multipleOf > 0)
-        return numberMultipleOfExpr(schema);
-    const opts = ['noNaN: true', 'noDefaultInfinity: true'];
-    // With both an inclusive and an exclusive bound on the same side, honour the
-    // tighter one instead of letting `minimum`/`maximum` shadow the exclusive via
-    // else-if (which would emit values that violate the exclusive bound). The
-    // exclusive bound wins ties, since it additionally excludes the endpoint.
-    if (hasMinimum(schema) &&
-        (!hasExclusiveMinimum(schema) || Number(schema.minimum) > Number(schema.exclusiveMinimum))) {
-        opts.push(`min: ${schema.minimum}`);
-    }
-    else if (hasExclusiveMinimum(schema)) {
-        opts.push(`min: ${schema.exclusiveMinimum}`, 'minExcluded: true');
-    }
-    if (hasMaximum(schema) &&
-        (!hasExclusiveMaximum(schema) || Number(schema.maximum) < Number(schema.exclusiveMaximum))) {
-        opts.push(`max: ${schema.maximum}`);
-    }
-    else if (hasExclusiveMaximum(schema)) {
-        opts.push(`max: ${schema.exclusiveMaximum}`, 'maxExcluded: true');
-    }
-    return `fc.double({ ${opts.join(', ')} })`;
+  if (hasMultipleOf(schema) && schema.multipleOf > 0)
+    return numberMultipleOfExpr(schema);
+  const opts = ["noNaN: true", "noDefaultInfinity: true"];
+  if (hasMinimum(schema) && (!hasExclusiveMinimum(schema) || Number(schema.minimum) > Number(schema.exclusiveMinimum))) {
+    opts.push(`min: ${schema.minimum}`);
+  } else if (hasExclusiveMinimum(schema)) {
+    opts.push(`min: ${schema.exclusiveMinimum}`, "minExcluded: true");
+  }
+  if (hasMaximum(schema) && (!hasExclusiveMaximum(schema) || Number(schema.maximum) < Number(schema.exclusiveMaximum))) {
+    opts.push(`max: ${schema.maximum}`);
+  } else if (hasExclusiveMaximum(schema)) {
+    opts.push(`max: ${schema.exclusiveMaximum}`, "maxExcluded: true");
+  }
+  return `fc.double({ ${opts.join(", ")} })`;
 };
-/** Builds a `fc.array(...)` / `fc.uniqueArray(...)` / `fc.tuple(...)` expression for an array schema. */
 const arrayExpr = (schema, ctx) => {
-    const raw = schema;
-    // A tuple is `prefixItems` (2020-12) or the draft-07 array-form `items`. Both
-    // describe one schema per position, so map them to `fc.tuple(...)`. Extra items
-    // beyond the prefix are unconstrained (or forbidden by `items: false`); the
-    // minimal tuple is schema-valid either way.
-    const prefixItems = raw['prefixItems'];
-    const tuple = Array.isArray(prefixItems)
-        ? prefixItems
-        : Array.isArray(raw['items'])
-            ? raw['items']
-            : undefined;
-    if (tuple) {
-        const exprs = tuple.map((item) => arbitraryExpr(item, ctx));
-        return `fc.tuple(${exprs.join(', ')})`;
-    }
-    // With no `items`, a `contains` subschema is the only element constraint, so
-    // generate from it (and guarantee at least one such element via `minLength`) —
-    // otherwise an empty array would fail `contains`.
-    const containsSchema = hasContains(schema) && isSchemaObject(schema.contains) ? schema.contains : undefined;
-    const items = hasItems(schema) && isSchemaObject(schema.items)
-        ? arbitraryExpr(schema.items, ctx)
-        : containsSchema
-            ? arbitraryExpr(containsSchema, ctx)
-            : 'fc.anything()';
-    const minContains = containsSchema !== undefined && typeof raw['minContains'] === 'number' ? raw['minContains'] : 1;
-    const minLength = Math.max(hasMinItems(schema) ? schema.minItems : 0, containsSchema !== undefined ? Math.max(1, minContains) : 0);
-    const opts = [];
-    if (minLength > 0)
-        opts.push(`minLength: ${minLength}`);
-    if (hasMaxItems(schema))
-        opts.push(`maxLength: ${schema.maxItems}`);
-    const fn = hasUniqueItems(schema) && schema.uniqueItems === true ? 'fc.uniqueArray' : 'fc.array';
-    return opts.length > 0 ? `${fn}(${items}, { ${opts.join(', ')} })` : `${fn}(${items})`;
+  const raw = schema;
+  const prefixItems = raw["prefixItems"];
+  const tuple = Array.isArray(prefixItems) ? prefixItems : Array.isArray(raw["items"]) ? raw["items"] : void 0;
+  if (tuple) {
+    const exprs = tuple.map((item) => arbitraryExpr(item, ctx));
+    return `fc.tuple(${exprs.join(", ")})`;
+  }
+  const containsSchema = hasContains(schema) && isSchemaObject(schema.contains) ? schema.contains : void 0;
+  const items = hasItems(schema) && isSchemaObject(schema.items) ? arbitraryExpr(schema.items, ctx) : containsSchema ? arbitraryExpr(containsSchema, ctx) : "fc.anything()";
+  const minContains = containsSchema !== void 0 && typeof raw["minContains"] === "number" ? raw["minContains"] : 1;
+  const minLength = Math.max(hasMinItems(schema) ? schema.minItems : 0, containsSchema !== void 0 ? Math.max(1, minContains) : 0);
+  const opts = [];
+  if (minLength > 0)
+    opts.push(`minLength: ${minLength}`);
+  if (hasMaxItems(schema))
+    opts.push(`maxLength: ${schema.maxItems}`);
+  const fn = hasUniqueItems(schema) && schema.uniqueItems === true ? "fc.uniqueArray" : "fc.array";
+  return opts.length > 0 ? `${fn}(${items}, { ${opts.join(", ")} })` : `${fn}(${items})`;
 };
-/** The arbitrary for keys of the open-map (extra-property) part of an object. */
 const extraKeyArb = (schema, firstPatternSource) => {
-    // Keys must satisfy `patternProperties` (so the value schema applies) or, failing
-    // that, a `propertyNames` pattern. Both map onto `fc.stringMatching`.
-    if (firstPatternSource !== undefined)
-        return `fc.stringMatching(new RegExp(${JSON.stringify(firstPatternSource)}))`;
-    const propertyNames = hasPropertyNames(schema) ? schema.propertyNames : undefined;
-    if (propertyNames !== undefined && isSchemaObject(propertyNames) && hasPattern(propertyNames)) {
-        return `fc.stringMatching(new RegExp(${JSON.stringify(propertyNames.pattern)}))`;
-    }
-    return 'fc.string()';
+  if (firstPatternSource !== void 0)
+    return `fc.stringMatching(new RegExp(${JSON.stringify(firstPatternSource)}))`;
+  const propertyNames = hasPropertyNames(schema) ? schema.propertyNames : void 0;
+  if (propertyNames !== void 0 && isSchemaObject(propertyNames) && hasPattern(propertyNames)) {
+    return `fc.stringMatching(new RegExp(${JSON.stringify(propertyNames.pattern)}))`;
+  }
+  return "fc.string()";
 };
-/** Builds a `fc.record(...)` / `fc.dictionary(...)` expression for an object schema. */
 const objectExpr = (schema, ctx) => {
-    // The `additionalProperties` value schema (when it constrains extra keys with a
-    // real subschema rather than the boolean true/false form).
-    const additional = hasAdditionalProperties(schema) ? schema.additionalProperties : false;
-    const additionalArb = isSchemaObject(additional) ? arbitraryExpr(additional, ctx) : undefined;
-    const additionalClosed = hasAdditionalProperties(schema) && schema.additionalProperties === false;
-    // The first `patternProperties` entry drives the open-map value/key shape.
-    const patternEntries = hasPatternProperties(schema) ? Object.entries(schema.patternProperties) : [];
-    const firstPattern = patternEntries[0];
-    const patternValueArb = firstPattern && isSchemaObject(firstPattern[1]) ? arbitraryExpr(firstPattern[1], ctx) : undefined;
-    // Extra keys are allowed unless a fully closed object (no `additionalProperties`
-    // and no `patternProperties` outlet) forbids them.
-    const extrasAllowed = !additionalClosed || patternEntries.length > 0;
-    const extraValueArb = additionalArb ?? patternValueArb;
-    const keyArb = extraKeyArb(schema, firstPattern?.[0]);
-    const minProps = hasMinProperties(schema) ? schema.minProperties : undefined;
-    const maxProps = hasMaxProperties(schema) ? schema.maxProperties : undefined;
-    const dictKeyOpts = (minKeys, maxKeys) => {
-        const opts = [];
-        if (minKeys !== undefined && minKeys > 0)
-            opts.push(`minKeys: ${minKeys}`);
-        if (maxKeys !== undefined)
-            opts.push(`maxKeys: ${maxKeys}`);
-        return opts.length > 0 ? `, { ${opts.join(', ')} }` : '';
-    };
-    // Each declared key maps to the arbitrary that generates its value.
-    const propArbs = new Map();
-    if (hasProperties(schema)) {
-        for (const [key, propSchema] of Object.entries(schema.properties))
-            propArbs.set(key, arbitraryExpr(propSchema, ctx));
-    }
-    const required = new Set(hasRequired(schema) ? schema.required : []);
-    // The value arbitrary for a key not declared in `properties` (a dependency key).
-    const openValueArb = extraValueArb ?? 'fc.anything()';
-    // Fold presence-gated dependency keywords into the always-present set. Requiring
-    // a dependency (or a `dependentSchemas` shape) unconditionally is stricter than
-    // the keyword — but a value that always carries the dependency is always valid,
-    // and it keeps the generated candidate from being rejected by the filter.
-    if (hasDependentRequired(schema)) {
-        for (const [, deps] of Object.entries(schema.dependentRequired)) {
-            for (const dep of deps) {
-                if (!propArbs.has(dep))
-                    propArbs.set(dep, openValueArb);
-                required.add(dep);
-            }
-        }
-    }
-    if (hasDependentSchemas(schema)) {
-        for (const [, sub] of Object.entries(schema.dependentSchemas)) {
-            if (!isSchemaObject(sub))
-                continue;
-            if (hasProperties(sub)) {
-                for (const [key, propSchema] of Object.entries(sub.properties)) {
-                    if (!propArbs.has(key))
-                        propArbs.set(key, arbitraryExpr(propSchema, ctx));
-                }
-            }
-            if (hasRequired(sub))
-                for (const key of sub.required)
-                    required.add(key);
-        }
+  const additional = hasAdditionalProperties(schema) ? schema.additionalProperties : false;
+  const additionalArb = isSchemaObject(additional) ? arbitraryExpr(additional, ctx) : void 0;
+  const additionalClosed = hasAdditionalProperties(schema) && schema.additionalProperties === false;
+  const patternEntries = hasPatternProperties(schema) ? Object.entries(schema.patternProperties) : [];
+  const firstPattern = patternEntries[0];
+  const patternValueArb = firstPattern && isSchemaObject(firstPattern[1]) ? arbitraryExpr(firstPattern[1], ctx) : void 0;
+  const extrasAllowed = !additionalClosed || patternEntries.length > 0;
+  const extraValueArb = additionalArb ?? patternValueArb;
+  const keyArb = extraKeyArb(schema, firstPattern?.[0]);
+  const minProps = hasMinProperties(schema) ? schema.minProperties : void 0;
+  const maxProps = hasMaxProperties(schema) ? schema.maxProperties : void 0;
+  const dictKeyOpts = (minKeys, maxKeys) => {
+    const opts = [];
+    if (minKeys !== void 0 && minKeys > 0)
+      opts.push(`minKeys: ${minKeys}`);
+    if (maxKeys !== void 0)
+      opts.push(`maxKeys: ${maxKeys}`);
+    return opts.length > 0 ? `, { ${opts.join(", ")} }` : "";
+  };
+  const propArbs = /* @__PURE__ */ new Map();
+  if (hasProperties(schema)) {
+    for (const [key, propSchema] of Object.entries(schema.properties))
+      propArbs.set(key, arbitraryExpr(propSchema, ctx));
+  }
+  const required = new Set(hasRequired(schema) ? schema.required : []);
+  const openValueArb = extraValueArb ?? "fc.anything()";
+  if (hasDependentRequired(schema)) {
+    for (const [, deps] of Object.entries(schema.dependentRequired)) {
+      for (const dep of deps) {
+        if (!propArbs.has(dep))
+          propArbs.set(dep, openValueArb);
+        required.add(dep);
+      }
     }
-    // A `dependentSchemas`/`dependentRequired` key may be required without a declared
-    // value schema; give it the open-map value arbitrary.
-    for (const key of required)
-        if (!propArbs.has(key))
-            propArbs.set(key, openValueArb);
-    const keys = [...propArbs.keys()];
-    // A map-style object (no declared keys) is a dictionary; its bounds come from
-    // `min`/`maxProperties` and its value/key shape from `additionalProperties` /
-    // `patternProperties` / `propertyNames`.
-    if (keys.length === 0) {
-        if (extraValueArb)
-            return `fc.dictionary(${keyArb}, ${extraValueArb}${dictKeyOpts(minProps, maxProps)})`;
-        if (minProps !== undefined || maxProps !== undefined) {
-            return `fc.dictionary(${keyArb}, fc.anything()${dictKeyOpts(minProps, maxProps)})`;
+  }
+  if (hasDependentSchemas(schema)) {
+    for (const [, sub] of Object.entries(schema.dependentSchemas)) {
+      if (!isSchemaObject(sub))
+        continue;
+      if (hasProperties(sub)) {
+        for (const [key, propSchema] of Object.entries(sub.properties)) {
+          if (!propArbs.has(key))
+            propArbs.set(key, arbitraryExpr(propSchema, ctx));
         }
-        return 'fc.object()';
+      }
+      if (hasRequired(sub))
+        for (const key of sub.required)
+          required.add(key);
     }
-    const entries = keys.map((key) => `${JSON.stringify(key)}: ${propArbs.get(key)}`);
-    const model = `{ ${entries.join(', ')} }`;
-    // fc.record treats all keys as required by default. Only emit requiredKeys
-    // when at least one property is optional.
-    const record = keys.every((key) => required.has(key))
-        ? `fc.record(${model})`
-        : `fc.record(${model}, { requiredKeys: [${[...required].map((key) => JSON.stringify(key)).join(', ')}] })`;
-    // Fold in a dictionary of extra keys when the open-map part is typed, or when
-    // `minProperties` needs more keys than the declared set guarantees. `minKeys`
-    // fills only the gap above the always-present (required) keys so the floor is met
-    // without overshooting. Declared keys win on collision (merged last).
-    const needExtras = extrasAllowed && (extraValueArb !== undefined || (minProps !== undefined && minProps > required.size));
-    if (needExtras) {
-        const valueArb = extraValueArb ?? 'fc.anything()';
-        const minKeys = minProps !== undefined ? Math.max(0, minProps - required.size) : undefined;
-        return `fc.tuple(${record}, fc.dictionary(${keyArb}, ${valueArb}${dictKeyOpts(minKeys, undefined)})).map(([base, extra]) => ({ ...extra, ...base }))`;
+  }
+  for (const key of required)
+    if (!propArbs.has(key))
+      propArbs.set(key, openValueArb);
+  const keys = [...propArbs.keys()];
+  if (keys.length === 0) {
+    if (extraValueArb)
+      return `fc.dictionary(${keyArb}, ${extraValueArb}${dictKeyOpts(minProps, maxProps)})`;
+    if (minProps !== void 0 || maxProps !== void 0) {
+      return `fc.dictionary(${keyArb}, fc.anything()${dictKeyOpts(minProps, maxProps)})`;
     }
-    return record;
+    return "fc.object()";
+  }
+  const entries = keys.map((key) => `${JSON.stringify(key)}: ${propArbs.get(key)}`);
+  const model = `{ ${entries.join(", ")} }`;
+  const record = keys.every((key) => required.has(key)) ? `fc.record(${model})` : `fc.record(${model}, { requiredKeys: [${[...required].map((key) => JSON.stringify(key)).join(", ")}] })`;
+  const needExtras = extrasAllowed && (extraValueArb !== void 0 || minProps !== void 0 && minProps > required.size);
+  if (needExtras) {
+    const valueArb = extraValueArb ?? "fc.anything()";
+    const minKeys = minProps !== void 0 ? Math.max(0, minProps - required.size) : void 0;
+    return `fc.tuple(${record}, fc.dictionary(${keyArb}, ${valueArb}${dictKeyOpts(minKeys, void 0)})).map(([base, extra]) => ({ ...extra, ...base }))`;
+  }
+  return record;
 };
-/** Builds a `fc.oneof(...)` expression from a list of branch schemas. */
 const oneofExpr = (branches, ctx) => {
-    const exprs = branches.map((branch) => arbitraryExpr(branch, ctx));
-    return `fc.oneof(${exprs.join(', ')})`;
+  const exprs = branches.map((branch) => arbitraryExpr(branch, ctx));
+  return `fc.oneof(${exprs.join(", ")})`;
 };
-/** Builds the fast-check expression for a single (non-union) JSON Schema type. */
 const scalarExpr = (type, schema, ctx) => {
-    switch (type) {
-        case 'string':
-            return stringExpr(schema);
-        case 'integer':
-            return integerExpr(schema);
-        case 'number':
-            return numberExpr(schema);
-        case 'boolean':
-            return 'fc.boolean()';
-        case 'null':
-            return 'fc.constant(null)';
-        case 'array':
-            return arrayExpr(schema, ctx);
-        case 'object':
-            return objectExpr(schema, ctx);
-        default:
-            return 'fc.anything()';
-    }
+  switch (type) {
+    case "string":
+      return stringExpr(schema);
+    case "integer":
+      return integerExpr(schema);
+    case "number":
+      return numberExpr(schema);
+    case "boolean":
+      return "fc.boolean()";
+    case "null":
+      return "fc.constant(null)";
+    case "array":
+      return arrayExpr(schema, ctx);
+    case "object":
+      return objectExpr(schema, ctx);
+    default:
+      return "fc.anything()";
+  }
 };
-/** True when an `enum` member satisfies the node's sibling length/range/pattern constraints. */
 const enumMemberFits = (schema, value) => {
-    if (typeof value === 'string') {
-        if (hasMinLength(schema) && value.length < schema.minLength)
-            return false;
-        if (hasMaxLength(schema) && value.length > schema.maxLength)
-            return false;
-        if (hasPattern(schema)) {
-            try {
-                if (!new RegExp(schema.pattern).test(value))
-                    return false;
-            }
-            catch {
-                // An invalid pattern can't reject anything.
-            }
-        }
-    }
-    else if (typeof value === 'number') {
-        if (hasMinimum(schema) && value < schema.minimum)
-            return false;
-        if (hasMaximum(schema) && value > schema.maximum)
-            return false;
-        if (hasExclusiveMinimum(schema) && value <= schema.exclusiveMinimum)
-            return false;
-        if (hasExclusiveMaximum(schema) && value >= schema.exclusiveMaximum)
-            return false;
-        if (hasMultipleOf(schema) && schema.multipleOf > 0 && value % schema.multipleOf !== 0)
-            return false;
+  if (typeof value === "string") {
+    if (hasMinLength(schema) && value.length < schema.minLength)
+      return false;
+    if (hasMaxLength(schema) && value.length > schema.maxLength)
+      return false;
+    if (hasPattern(schema)) {
+      try {
+        if (!new RegExp(schema.pattern).test(value))
+          return false;
+      } catch {
+      }
     }
-    return true;
+  } else if (typeof value === "number") {
+    if (hasMinimum(schema) && value < schema.minimum)
+      return false;
+    if (hasMaximum(schema) && value > schema.maximum)
+      return false;
+    if (hasExclusiveMinimum(schema) && value <= schema.exclusiveMinimum)
+      return false;
+    if (hasExclusiveMaximum(schema) && value >= schema.exclusiveMaximum)
+      return false;
+    if (hasMultipleOf(schema) && schema.multipleOf > 0 && value % schema.multipleOf !== 0)
+      return false;
+  }
+  return true;
 };
-/**
- * Recursively builds the fast-check arbitrary expression for a schema node.
- * `$ref`s resolve to the referenced file's exported arbitrary; a self-`$ref`
- * resolves to `tie('self')` so recursive schemas tie lazily via `fc.letrec`.
- * Everything else maps to the appropriate `fc.*` combinator.
- */
 const arbitraryExpr = (schema, ctx) => {
-    if (!isSchemaObject(schema))
-        return 'fc.anything()';
-    if (hasRef(schema)) {
-        const name = arbitraryName(refToName(schema.$ref, ctx.suffix));
-        // A reference back to the type being generated must be tied lazily; an eager
-        // identifier would touch a still-uninitialized const (TDZ) at import time.
-        if (name === ctx.selfArbName) {
-            ctx.usedTie.value = true;
-            return `tie(${JSON.stringify(SELF_KEY)})`;
-        }
-        // A reference to a sibling this type shares a cross-file cycle with is the
-        // same TDZ hazard one module over, and `tie` cannot reach across modules —
-        // defer the imported binding until generation time instead.
-        if (ctx.lazyRefFilenames.has(refToFilename(schema.$ref))) {
-            return lazyRef(name);
-        }
-        return name;
-    }
-    if (hasConst(schema))
-        return `fc.constant(${JSON.stringify(schema.const)})`;
-    if (hasEnum(schema)) {
-        // Drop enum members that violate a sibling length/range/pattern constraint so
-        // the arbitrary never emits an out-of-range member. Keep all when none fit
-        // (an unsatisfiable schema) rather than emitting an empty `constantFrom`.
-        const members = schema.enum;
-        const fitting = members.filter((value) => enumMemberFits(schema, value));
-        const chosen = fitting.length > 0 ? fitting : members;
-        const values = chosen.map((value) => JSON.stringify(value)).join(', ');
-        return `fc.constantFrom(${values})`;
+  if (!isSchemaObject(schema))
+    return "fc.anything()";
+  if (hasRef(schema)) {
+    const name = arbitraryName(refToName(schema.$ref, ctx.suffix));
+    if (name === ctx.selfArbName) {
+      ctx.usedTie.value = true;
+      return `tie(${JSON.stringify(SELF_KEY)})`;
     }
-    const instanceOf = getMjstInstanceOf(schema);
-    if (instanceOf === 'Date')
-        return 'fc.date({ noInvalidDate: true })';
-    if (instanceOf)
-        return 'fc.anything()';
-    const primitive = getMjstPrimitive(schema);
-    if (primitive === 'bigint')
-        return 'fc.bigInt()';
-    if (primitive)
-        return 'fc.anything()';
-    // `allOf` must satisfy every branch at once. fast-check has no generic
-    // intersection combinator, so flatten the branches into one merged schema
-    // (tightest bounds, unioned required, merged properties) and generate from it.
-    if (hasAllOf(schema))
-        return arbitraryExpr(mergeAllOf(schema), ctx);
-    if (hasOneOf(schema))
-        return oneofExpr(schema.oneOf, ctx);
-    if (hasAnyOf(schema))
-        return oneofExpr(schema.anyOf, ctx);
-    if (hasType(schema))
-        return scalarExpr(schema.type, schema, ctx);
-    // Multi-type schemas (`type: ['string', 'null']`) become a oneof over each
-    // member type; `hasType` only matches a single string `type`.
-    if (Array.isArray(schema.type)) {
-        const exprs = schema.type.map((type) => scalarExpr(type, schema, ctx));
-        return exprs.length === 1 ? exprs[0] : `fc.oneof(${exprs.join(', ')})`;
+    if (ctx.lazyRefFilenames.has(refToFilename(schema.$ref))) {
+      return lazyRef(name);
     }
-    return 'fc.anything()';
+    return name;
+  }
+  if (hasConst(schema))
+    return `fc.constant(${JSON.stringify(schema.const)})`;
+  if (hasEnum(schema)) {
+    const members = schema.enum;
+    const fitting = members.filter((value) => enumMemberFits(schema, value));
+    const chosen = fitting.length > 0 ? fitting : members;
+    const values = chosen.map((value) => JSON.stringify(value)).join(", ");
+    return `fc.constantFrom(${values})`;
+  }
+  const instanceOf = getMjstInstanceOf(schema);
+  if (instanceOf === "Date")
+    return "fc.date({ noInvalidDate: true })";
+  if (instanceOf)
+    return "fc.anything()";
+  const primitive = getMjstPrimitive(schema);
+  if (primitive === "bigint")
+    return "fc.bigInt()";
+  if (primitive)
+    return "fc.anything()";
+  if (hasAllOf(schema))
+    return arbitraryExpr(mergeAllOf(schema), ctx);
+  if (hasOneOf(schema))
+    return oneofExpr(schema.oneOf, ctx);
+  if (hasAnyOf(schema))
+    return oneofExpr(schema.anyOf, ctx);
+  if (hasType(schema))
+    return scalarExpr(schema.type, schema, ctx);
+  if (Array.isArray(schema.type)) {
+    const exprs = schema.type.map((type) => scalarExpr(type, schema, ctx));
+    return exprs.length === 1 ? exprs[0] : `fc.oneof(${exprs.join(", ")})`;
+  }
+  return "fc.anything()";
 };
-/**
- * Generates a `fast-check` arbitrary that produces schema-valid values.
- *
- * A schema that references itself is wrapped in `fc.letrec` so the recursion is
- * tied lazily — a plain `const NodeArbitrary = fc.record({ next: NodeArbitrary })`
- * would throw a TDZ `ReferenceError` the moment the module is imported.
- *
- * `lazyRefFilenames` names the sibling files this type shares a cross-file `$ref`
- * cycle with; references to those are deferred so mutually recursive modules do
- * not read each other's `const` before it is initialized (see {@link ExprCtx}).
- *
- * @example
- * ```typescript
- * generateArbitrary({ type: 'object', properties: { name: { type: 'string' } }, required: ['name'] }, 'Info')
- * // export const InfoArbitrary: fc.Arbitrary<Info> = fc.record({ "name": fc.string() })
- * ```
- */
-export const generateArbitrary = (schema, typeName, suffix = '', lazyRefFilenames = new Set(), rootSchema) => {
-    const selfArbName = arbitraryName(typeName);
-    const ctx = { suffix, selfArbName, usedTie: { value: false }, lazyRefFilenames };
-    const expr = arbitraryExpr(schema, ctx);
-    const body = ctx.usedTie.value
-        ? `fc.letrec<{ ${SELF_KEY}: ${typeName} }>((tie) => ({\n  ${SELF_KEY}: ${expr},\n})).${SELF_KEY}`
-        : expr;
-    // Keywords no `fc.*` combinator captures on its own (`if`/`then`/`else`, `not`,
-    // `oneOf` exclusivity, the presence-gated object keywords) are enforced by a
-    // post-generation filter: the arbitrary samples a candidate and rejects it
-    // unless a runtime validator built from the same schema accepts it.
-    if (needsValidationFilter(schema)) {
-        const validatorName = `${selfArbName}Validator`;
-        const embedded = JSON.stringify(withResolvableDefs(schema, rootSchema));
-        return (`const ${validatorName} = ${VALIDATE_IMPORT_NAME}(${embedded})\n` +
-            `export const ${selfArbName}: fc.Arbitrary<${typeName}> = (${body}).filter((value) => ${validatorName}(value) === true)`);
-    }
-    return `export const ${selfArbName}: fc.Arbitrary<${typeName}> = ${body}`;
+const generateArbitrary = (schema, typeName, suffix = "", lazyRefFilenames = /* @__PURE__ */ new Set(), rootSchema) => {
+  const selfArbName = arbitraryName(typeName);
+  const ctx = { suffix, selfArbName, usedTie: { value: false }, lazyRefFilenames };
+  const expr = arbitraryExpr(schema, ctx);
+  const body = ctx.usedTie.value ? `fc.letrec<{ ${SELF_KEY}: ${typeName} }>((tie) => ({
+  ${SELF_KEY}: ${expr},
+})).${SELF_KEY}` : expr;
+  if (needsValidationFilter(schema)) {
+    const validatorName = `${selfArbName}Validator`;
+    const embedded = JSON.stringify(withResolvableDefs(schema, rootSchema));
+    return `const ${validatorName} = ${VALIDATE_IMPORT_NAME}(${embedded})
+export const ${selfArbName}: fc.Arbitrary<${typeName}> = (${body}).filter((value) => ${validatorName}(value) === true)`;
+  }
+  return `export const ${selfArbName}: fc.Arbitrary<${typeName}> = ${body}`;
+};
+export {
+  VALIDATE_IMPORT_NAME,
+  VALIDATE_IMPORT_STATEMENT,
+  generateArbitrary
 };