@amritk/generate-examples 0.6.4 → 0.8.0

package/dist/generators/generate-arbitrary.js

@@ -1,15 +1,40 @@
 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 { resolveRef } from "@amritk/helpers/resolve-ref";
 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 { assertGeneratorDepth } from "./assert-generator-depth.js";
+import { closedValueSet } from "./closed-value-set.js";
 import { mergeAllOf } from "./derive-example.js";
-import { needsValidationFilter, withResolvableDefs } from "./schema-validation.js";
+import { declaresOwnShape, isObjectLike, typesConflict } from "./is-object-like.js";
+import { satisfiesScalarConstraints } from "./satisfies-scalar-constraints.js";
+import { canBuildGuard, needsValidationFilter, withResolvableDefs } from "./schema-validation.js";
 const arbitraryName = (typeName) => `${typeName}Arbitrary`;
 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})`;
 const SELF_KEY = "self";
 const safeLiteralKey = (key) => key === "__proto__" ? '["__proto__"]' : JSON.stringify(key);
+const finiteNumber = (value) => value !== void 0 && Number.isFinite(value) ? value : void 0;
+const countBound = (value, side) => {
+  const finite = finiteNumber(value);
+  if (finite === void 0)
+    return void 0;
+  return Math.max(0, side === "lower" ? Math.ceil(finite) : Math.floor(finite));
+};
+const usableMultipleOf = (schema) => hasMultipleOf(schema) && Number.isFinite(schema.multipleOf) && schema.multipleOf > 0 ? schema.multipleOf : void 0;
+const clampLow = (low, high) => low !== void 0 && high !== void 0 && low > high ? high : low;
+const UNSUPPORTED_ASSERTION = /\(\?<?[=!]/;
+const usablePattern = (pattern) => {
+  if (UNSUPPORTED_ASSERTION.test(pattern))
+    return void 0;
+  try {
+    new RegExp(pattern);
+    return pattern;
+  } catch {
+    return void 0;
+  }
+};
 const stringExpr = (schema) => {
   if (hasFormat(schema)) {
     switch (schema.format) {
@@ -34,43 +59,67 @@ const stringExpr = (schema) => {
         return "fc.ipV6()";
     }
   }
-  if (hasPattern(schema)) {
-    const base = `fc.stringMatching(new RegExp(${JSON.stringify(schema.pattern)}))`;
+  const maxLength = countBound(hasMaxLength(schema) ? schema.maxLength : void 0, "upper");
+  const minLength = clampLow(countBound(hasMinLength(schema) ? schema.minLength : void 0, "lower"), maxLength);
+  const pattern = hasPattern(schema) ? usablePattern(schema.pattern) : void 0;
+  if (pattern !== void 0) {
+    const base = `fc.stringMatching(new RegExp(${JSON.stringify(pattern)}))`;
     const checks = [];
-    if (hasMinLength(schema))
-      checks.push(`s.length >= ${schema.minLength}`);
-    if (hasMaxLength(schema))
-      checks.push(`s.length <= ${schema.maxLength}`);
+    if (minLength !== void 0)
+      checks.push(`s.length >= ${minLength}`);
+    if (maxLength !== void 0)
+      checks.push(`s.length <= ${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}`);
+  if (minLength !== void 0)
+    opts.push(`minLength: ${minLength}`);
+  if (maxLength !== void 0)
+    opts.push(`maxLength: ${maxLength}`);
   return opts.length > 0 ? `fc.string({ ${opts.join(", ")} })` : "fc.string()";
 };
-const integerExpr = (schema) => {
-  const opts = [];
+const integerBounds = (schema) => {
+  const minimum = finiteNumber(hasMinimum(schema) ? Number(schema.minimum) : void 0);
+  const exclusiveMinimum = finiteNumber(hasExclusiveMinimum(schema) ? Number(schema.exclusiveMinimum) : void 0);
+  const maximum = finiteNumber(hasMaximum(schema) ? Number(schema.maximum) : void 0);
+  const exclusiveMaximum = finiteNumber(hasExclusiveMaximum(schema) ? Number(schema.exclusiveMaximum) : void 0);
   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)}`);
+  if (minimum !== void 0)
+    mins.push(Math.ceil(minimum));
+  if (exclusiveMinimum !== void 0)
+    mins.push(Math.floor(exclusiveMinimum) + 1);
   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)}`);
+  if (maximum !== void 0)
+    maxs.push(Math.floor(maximum));
+  if (exclusiveMaximum !== void 0)
+    maxs.push(Math.ceil(exclusiveMaximum) - 1);
+  const max = clampIntegerBound(maxs.length > 0 ? Math.min(...maxs) : void 0);
+  const min = clampIntegerBound(mins.length > 0 ? Math.max(...mins) : void 0);
+  return { min: clampLow(min, max), max };
+};
+const DEFAULT_INTEGER_MAGNITUDE = 2 ** 31;
+const clampIntegerBound = (value) => value === void 0 ? void 0 : Math.max(-DEFAULT_INTEGER_MAGNITUDE, Math.min(DEFAULT_INTEGER_MAGNITUDE - 1, value));
+const integerMultipleOfExpr = (m, min, max) => {
+  const bound = Math.max(1, Math.floor((DEFAULT_INTEGER_MAGNITUDE - 1) / m));
+  const kMin = min !== void 0 ? Math.ceil(min / m) : -bound;
+  const kMax = Math.max(kMin, max !== void 0 ? Math.floor(max / m) : bound);
+  return `fc.integer({ min: ${kMin}, max: ${kMax} }).map((k) => k * ${m})`;
+};
+const integerExpr = (schema) => {
+  const { min, max } = integerBounds(schema);
+  const multipleOf = usableMultipleOf(schema);
+  if (multipleOf !== void 0 && Number.isInteger(multipleOf)) {
+    return integerMultipleOfExpr(multipleOf, min, max);
+  }
+  const opts = [];
+  if (min !== void 0)
+    opts.push(`min: ${min}`);
+  if (max !== void 0)
+    opts.push(`max: ${max}`);
   const base = opts.length > 0 ? `fc.integer({ ${opts.join(", ")} })` : "fc.integer()";
-  return hasMultipleOf(schema) ? `${base}.filter((n) => n % ${schema.multipleOf} === 0)` : base;
+  return multipleOf !== void 0 ? `${base}.filter((n) => n % ${multipleOf} === 0)` : base;
 };
-const numberMultipleOfExpr = (schema) => {
-  const m = Number(schema.multipleOf);
+const numberMultipleOfExpr = (schema, m) => {
   const EPS = 1e-9;
   let lo = Number.NEGATIVE_INFINITY;
   let loExclusive = false;
@@ -114,19 +163,39 @@ const numberMultipleOfExpr = (schema) => {
   return `${k}.map((k) => ${value})`;
 };
 const numberExpr = (schema) => {
-  if (hasMultipleOf(schema) && schema.multipleOf > 0)
-    return numberMultipleOfExpr(schema);
+  const multipleOf = usableMultipleOf(schema);
+  if (multipleOf !== void 0)
+    return numberMultipleOfExpr(schema, multipleOf);
   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");
+  const minimum = finiteNumber(hasMinimum(schema) ? Number(schema.minimum) : void 0);
+  const exclusiveMinimum = finiteNumber(hasExclusiveMinimum(schema) ? Number(schema.exclusiveMinimum) : void 0);
+  const maximum = finiteNumber(hasMaximum(schema) ? Number(schema.maximum) : void 0);
+  const exclusiveMaximum = finiteNumber(hasExclusiveMaximum(schema) ? Number(schema.exclusiveMaximum) : void 0);
+  let low;
+  let lowExcluded = false;
+  if (minimum !== void 0 && (exclusiveMinimum === void 0 || minimum > exclusiveMinimum)) {
+    low = minimum;
+  } else if (exclusiveMinimum !== void 0) {
+    low = exclusiveMinimum;
+    lowExcluded = true;
+  }
+  let high;
+  let highExcluded = false;
+  if (maximum !== void 0 && (exclusiveMaximum === void 0 || maximum < exclusiveMaximum)) {
+    high = maximum;
+  } else if (exclusiveMaximum !== void 0) {
+    high = exclusiveMaximum;
+    highExcluded = 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");
+  low = clampLow(low, high);
+  if (low !== void 0 && low === high) {
+    lowExcluded = false;
+    highExcluded = false;
   }
+  if (low !== void 0)
+    opts.push(`min: ${low}`, ...lowExcluded ? ["minExcluded: true"] : []);
+  if (high !== void 0)
+    opts.push(`max: ${high}`, ...highExcluded ? ["maxExcluded: true"] : []);
   return `fc.double({ ${opts.join(", ")} })`;
 };
 const arrayExpr = (schema, ctx) => {
@@ -138,26 +207,36 @@ const arrayExpr = (schema, 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 unique = hasUniqueItems(schema) && schema.uniqueItems === true;
+  const containsExpr = containsSchema !== void 0 ? arbitraryExpr(containsSchema, ctx) : void 0;
+  const items = hasItems(schema) && isSchemaObject(schema.items) ? arbitraryExpr(schema.items, ctx) : containsExpr === void 0 ? "fc.anything()" : unique ? `fc.oneof(${containsExpr}, fc.anything())` : containsExpr;
+  const minContains = countBound(typeof raw["minContains"] === "number" ? raw["minContains"] : void 0, "lower") ?? 1;
+  const minLength = Math.max(countBound(hasMinItems(schema) ? schema.minItems : void 0, "lower") ?? 0, containsSchema !== void 0 ? Math.max(1, minContains) : 0);
+  const distinctCap = unique && containsSchema === void 0 ? closedValueSet(hasItems(schema) && isSchemaObject(schema.items) ? schema.items : void 0)?.length : void 0;
+  const declaredMax = countBound(hasMaxItems(schema) ? schema.maxItems : void 0, "upper");
+  const maxLength = distinctCap !== void 0 ? Math.min(declaredMax ?? distinctCap, distinctCap) : declaredMax;
+  const clampedMin = clampLow(minLength, maxLength) ?? minLength;
   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";
+  if (clampedMin > 0)
+    opts.push(`minLength: ${clampedMin}`);
+  if (maxLength !== void 0)
+    opts.push(`maxLength: ${maxLength}`);
+  const fn = unique ? "fc.uniqueArray" : "fc.array";
   return opts.length > 0 ? `${fn}(${items}, { ${opts.join(", ")} })` : `${fn}(${items})`;
 };
 const extraKeyArb = (schema, firstPatternSource) => {
-  if (firstPatternSource !== void 0)
-    return `fc.stringMatching(new RegExp(${JSON.stringify(firstPatternSource)}))`;
+  const fromPattern = firstPatternSource !== void 0 ? usablePattern(firstPatternSource) : void 0;
+  if (fromPattern !== void 0)
+    return `fc.stringMatching(new RegExp(${JSON.stringify(fromPattern)}))`;
   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)}))`;
+    const fromNames = usablePattern(propertyNames.pattern);
+    if (fromNames !== void 0)
+      return `fc.stringMatching(new RegExp(${JSON.stringify(fromNames)}))`;
   }
   return "fc.string()";
 };
+const requiredKeyNames = (schema) => hasRequired(schema) ? schema.required.filter((key) => typeof key === "string") : [];
 const objectExpr = (schema, ctx) => {
   const additional = hasAdditionalProperties(schema) ? schema.additionalProperties : false;
   const additionalArb = isSchemaObject(additional) ? arbitraryExpr(additional, ctx) : void 0;
@@ -168,12 +247,13 @@ const objectExpr = (schema, ctx) => {
   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 minProps = countBound(hasMinProperties(schema) ? schema.minProperties : void 0, "lower");
+  const maxProps = countBound(hasMaxProperties(schema) ? schema.maxProperties : void 0, "upper");
   const dictKeyOpts = (minKeys, maxKeys) => {
+    const low = clampLow(minKeys, maxKeys);
     const opts = [];
-    if (minKeys !== void 0 && minKeys > 0)
-      opts.push(`minKeys: ${minKeys}`);
+    if (low !== void 0 && low > 0)
+      opts.push(`minKeys: ${low}`);
     if (maxKeys !== void 0)
       opts.push(`maxKeys: ${maxKeys}`);
     return opts.length > 0 ? `, { ${opts.join(", ")} }` : "";
@@ -183,7 +263,7 @@ const objectExpr = (schema, ctx) => {
     for (const [key, propSchema] of Object.entries(schema.properties))
       propArbs.set(key, arbitraryExpr(propSchema, ctx));
   }
-  const required = new Set(hasRequired(schema) ? schema.required : []);
+  const required = new Set(requiredKeyNames(schema));
   const openValueArb = extraValueArb ?? "fc.anything()";
   if (hasDependentRequired(schema)) {
     for (const [, deps] of Object.entries(schema.dependentRequired)) {
@@ -204,9 +284,8 @@ const objectExpr = (schema, ctx) => {
             propArbs.set(key, arbitraryExpr(propSchema, ctx));
         }
       }
-      if (hasRequired(sub))
-        for (const key of sub.required)
-          required.add(key);
+      for (const key of requiredKeyNames(sub))
+        required.add(key);
     }
   }
   for (const key of required)
@@ -232,8 +311,12 @@ const objectExpr = (schema, ctx) => {
   }
   return record;
 };
-const oneofExpr = (branches, ctx) => {
-  const exprs = branches.map((branch) => arbitraryExpr(branch, ctx));
+const oneofExpr = (branches, ctx) => chooseExpr(branches.map((branch) => arbitraryExpr(branch, ctx)));
+const chooseExpr = (exprs) => {
+  if (exprs.length === 0)
+    return "fc.anything()";
+  if (exprs.length === 1)
+    return exprs[0];
   return `fc.oneof(${exprs.join(", ")})`;
 };
 const scalarExpr = (type, schema, ctx) => {
@@ -256,37 +339,21 @@ const scalarExpr = (type, schema, ctx) => {
       return "fc.anything()";
   }
 };
-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 {
-      }
-    }
-  } 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;
-};
 const arbitraryExpr = (schema, ctx) => {
+  assertGeneratorDepth(ctx.depth.value, "generateArbitrary");
   if (!isSchemaObject(schema))
     return "fc.anything()";
+  ctx.depth.value++;
+  try {
+    return arbitraryExprAtDepth(schema, ctx);
+  } finally {
+    ctx.depth.value--;
+  }
+};
+const arbitraryExprAtDepth = (schema, ctx) => {
   if (hasRef(schema)) {
+    if (ctx.rootSchema !== void 0 && !resolveRef(schema.$ref, ctx.rootSchema))
+      return "fc.anything()";
     const name = arbitraryName(refToName(schema.$ref, ctx.suffix));
     if (name === ctx.selfArbName) {
       ctx.usedTie.value = true;
@@ -301,8 +368,10 @@ const arbitraryExpr = (schema, ctx) => {
     return `fc.constant(${JSON.stringify(schema.const)})`;
   if (hasEnum(schema)) {
     const members = schema.enum;
-    const fitting = members.filter((value) => enumMemberFits(schema, value));
+    const fitting = members.filter((value) => satisfiesScalarConstraints(schema, value));
     const chosen = fitting.length > 0 ? fitting : members;
+    if (chosen.length === 0)
+      return "fc.anything()";
     const values = chosen.map((value) => JSON.stringify(value)).join(", ");
     const literalSafe = chosen.every((value) => value === null || typeof value !== "object");
     return literalSafe ? `fc.constantFrom(...([${values}] as const))` : `fc.constantFrom(${values})`;
@@ -319,30 +388,52 @@ const arbitraryExpr = (schema, ctx) => {
     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);
+  const branches = hasOneOf(schema) ? schema.oneOf : hasAnyOf(schema) ? schema.anyOf : void 0;
+  if (branches !== void 0) {
+    const rest = withoutCombinators(schema);
+    if (!declaresOwnShape(rest))
+      return oneofExpr(branches, ctx);
+    const viable = branches.filter((branch) => !typesConflict(rest, branch));
+    const kept = viable.length > 0 ? viable : branches;
+    return chooseExpr(kept.map((branch) => arbitraryExpr({ allOf: [rest, branch] }, ctx)));
+  }
+  if (isObjectLike(schema))
+    return objectExpr(schema, 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 chooseExpr(schema.type.map((type) => scalarExpr(type, schema, ctx)));
   }
   return "fc.anything()";
 };
+const withoutCombinators = (schema) => {
+  const rest = { ...schema };
+  delete rest["oneOf"];
+  delete rest["anyOf"];
+  return rest;
+};
 const generateArbitrary = (schema, typeName, suffix = "", lazyRefFilenames = /* @__PURE__ */ new Set(), rootSchema) => {
   const selfArbName = arbitraryName(typeName);
-  const ctx = { suffix, selfArbName, usedTie: { value: false }, lazyRefFilenames };
+  const ctx = {
+    suffix,
+    selfArbName,
+    usedTie: { value: false },
+    lazyRefFilenames,
+    depth: { value: 0 },
+    rootSchema
+  };
   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)) {
+  if (needsValidationFilter(schema) && canBuildGuard(schema, rootSchema)) {
     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): value is ${typeName} => ${validatorName}(value) === true)`;
+export const ${selfArbName}: fc.Arbitrary<${typeName}> = (${body} as fc.Arbitrary<unknown>).filter((value): value is ${typeName} => ${validatorName}(value) === true)`;
+  }
+  if (schema === false) {
+    return `export const ${selfArbName}: fc.Arbitrary<${typeName}> = ${body} as fc.Arbitrary<${typeName}>`;
   }
   return `export const ${selfArbName}: fc.Arbitrary<${typeName}> = ${body}`;
 };

package/dist/generators/generate-files.js

@@ -1,7 +1,8 @@
 import { generateTypeDefinition } from "@amritk/helpers/generate-type-definition";
 import { collectExampleImports } from "./collect-example-imports.js";
 import { generateExampleConst } from "./derive-example.js";
-import { generateArbitrary, VALIDATE_IMPORT_NAME, VALIDATE_IMPORT_STATEMENT } from "./generate-arbitrary.js";
+import { generateArbitrary, VALIDATE_IMPORT_STATEMENT } from "./generate-arbitrary.js";
+import { canBuildGuard, needsValidationFilter } from "./schema-validation.js";
 const generateExampleFile = (schema, typeName, options) => {
   const typeSuffix = options?.typeSuffix ?? "";
   const refImports = collectExampleImports(schema, {
@@ -17,7 +18,7 @@ const generateExampleFile = (schema, typeName, options) => {
   const example = generateExampleConst(schema, typeName, options?.rootSchema);
   let result = `import * as fc from 'fast-check'
 `;
-  if (arbitrary.includes(`${VALIDATE_IMPORT_NAME}(`)) {
+  if (needsValidationFilter(schema) && canBuildGuard(schema, options?.rootSchema)) {
     result += VALIDATE_IMPORT_STATEMENT + "\n";
   }
   for (const imp of refImports) {

package/dist/generators/is-object-like.d.ts

@@ -0,0 +1,47 @@
+import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
+/**
+ * True when a schema describes an object even though it never says `type:
+ * 'object'`.
+ *
+ * This mirrors `isObjectLikeSchema` in `@amritk/helpers/generate-type-definition`
+ * — deliberately, and it has to keep mirroring it *exactly*. That function
+ * decides the *type* a generated file declares; this one decides the arbitrary
+ * and the example. Wherever they disagree, the file does not compile.
+ *
+ * So the tests below are the presence of the key, not the shape of its value:
+ * the helper asks `'patternProperties' in schema`, so a malformed
+ * `"patternProperties": null` still makes the type an object, and answering "not
+ * object-like" here emitted `null` against it. Likewise `properties` wins over
+ * `type`, so `{ type: 'string', properties: … }` is typed as an object however
+ * odd that reads — matching it is what keeps the file compiling.
+ *
+ * The helper is not exported, so the rule is restated here rather than
+ * duplicated by accident — the same arrangement `schema-validation.ts` has with
+ * that package's keyword sets.
+ */
+export declare const isObjectLike: (schema: JSONSchema) => boolean;
+/**
+ * True when a schema says something about its own value, rather than delegating
+ * entirely to a combinator.
+ *
+ * `oneOf`/`anyOf` are constraints that sit *alongside* the node's other
+ * keywords, not replacements for them, so a node that also declares a `type` or
+ * an object shape has to contribute that to whatever branch is chosen. Reading
+ * the branch on its own dropped the node's own `properties`, and the example
+ * came out `null` against an object type.
+ */
+export declare const declaresOwnShape: (schema: JSONSchema) => boolean;
+/**
+ * True when two schemas declare `type`s no single value can satisfy at once.
+ *
+ * Merging a node's own keywords into each `oneOf`/`anyOf` branch can produce a
+ * branch that contradicts them — `{ anyOf: [integer, null], type: 'integer' }`
+ * arises whenever an `allOf` narrows a property that carried a nullable union.
+ * `mergeAllOf` resolves a clash by letting the later branch win, so the `null`
+ * branch survived as `fc.constant(null)` under a type the intersection had
+ * already narrowed to `number`. A branch that cannot be satisfied is not a
+ * choice; dropping it is what makes the union match the declared type.
+ *
+ * `integer` and `number` are not a clash — every integer is a number.
+ */
+export declare const typesConflict: (a: JSONSchema, b: JSONSchema) => boolean;

package/dist/generators/is-object-like.js

@@ -0,0 +1,23 @@
+import { hasType, isSchemaObject } from "@amritk/helpers/schema-guards";
+const isObjectLike = (schema) => {
+  if (!isSchemaObject(schema))
+    return false;
+  const raw = schema;
+  if (raw["type"] === "object" || Object.hasOwn(raw, "properties"))
+    return true;
+  if (Object.hasOwn(raw, "patternProperties") || Object.hasOwn(raw, "additionalProperties"))
+    return true;
+  return Object.hasOwn(raw, "if") && Object.hasOwn(raw, "then");
+};
+const declaresOwnShape = (schema) => hasType(schema) || Array.isArray(schema.type) || isObjectLike(schema);
+const typesConflict = (a, b) => {
+  if (!hasType(a) || !hasType(b) || a.type === b.type)
+    return false;
+  const numeric = /* @__PURE__ */ new Set(["integer", "number"]);
+  return !(numeric.has(a.type) && numeric.has(b.type));
+};
+export {
+  declaresOwnShape,
+  isObjectLike,
+  typesConflict
+};

package/dist/generators/satisfies-scalar-constraints.d.ts

@@ -0,0 +1,17 @@
+import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
+/**
+ * True when an already-chosen scalar value satisfies the node's own
+ * length/range/pattern keywords.
+ *
+ * Both generators face the same question from opposite directions: the deriver
+ * picks the first `enum`/`const` member that fits a sibling `minLength`, and the
+ * arbitrary drops the members that do not fit before handing the rest to
+ * `fc.constantFrom`. Answering it in two places let the two drift — the
+ * arbitrary learned about `pattern` and the deriver did not, so the same schema
+ * could yield an example the arbitrary would have rejected.
+ *
+ * Only *scalar* keywords are checked. A value that is neither a string nor a
+ * number has nothing here to violate, so it passes; the full judgement is the
+ * validator's job (see `makeInstanceCheck`).
+ */
+export declare const satisfiesScalarConstraints: (schema: JSONSchema, value: unknown) => boolean;

package/dist/generators/satisfies-scalar-constraints.js

@@ -0,0 +1,34 @@
+import { hasExclusiveMaximum, hasExclusiveMinimum, hasMaximum, hasMaxLength, hasMinimum, hasMinLength, hasMultipleOf, hasPattern } from "@amritk/helpers/schema-guards";
+const satisfiesScalarConstraints = (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 {
+        return true;
+      }
+    }
+    return true;
+  }
+  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;
+};
+export {
+  satisfiesScalarConstraints
+};

package/dist/generators/schema-validation.d.ts

@@ -33,6 +33,18 @@ export declare const withResolvableDefs: (schema: JSONSchema, rootSchema?: Recor
 export type InstanceCheckOptions = {
     readonly checkFormats?: boolean;
 };
+/**
+ * Whether a runtime validator can be built for `schema` at all.
+ *
+ * The arbitrary generator embeds `__mjstValidate(<schema>)` as a top-level
+ * `const` in the file it emits, and nothing there catches a throw — so a schema
+ * the interpreter refuses would kill the module at import rather than at the one
+ * call site that wanted an opinion. Asking first turns that into a warning and an
+ * unfiltered arbitrary. Failures are reported once by {@link tryGuard}, and the
+ * built guard is cached on the schema object, so asking costs nothing the
+ * eventual validation would not have paid anyway.
+ */
+export declare const canBuildGuard: (schema: JSONSchema, rootSchema?: Record<string, unknown>) => boolean;
 /**
  * Compiles a boolean validator for `schema` (with the definitions its `$ref`s
  * need spliced in). Used at generation time to accept/reject candidate example

package/dist/generators/schema-validation.js

@@ -162,6 +162,7 @@ const spliceDefs = (schema, rootSchema) => {
 };
 const WARNING_SCHEMA_LIMIT = 240;
 const reportedGuardFailures = /* @__PURE__ */ new Set();
+const MAX_REPORTED_GUARD_FAILURES = 1e3;
 const describeSchema = (schema) => {
   const serialized = (() => {
     try {
@@ -179,6 +180,8 @@ const warnUndecidableSchema = (schema, reason) => {
 ${described}`;
   if (reportedGuardFailures.has(key))
     return;
+  if (reportedGuardFailures.size >= MAX_REPORTED_GUARD_FAILURES)
+    reportedGuardFailures.clear();
   reportedGuardFailures.add(key);
   console.warn(`Warning: cannot validate generated values against ${described} \u2014 ${message}. Every candidate value is accepted for this subschema, so constraints only the validator enforces (\`oneOf\`, \`not\`, \`pattern\`, \`if\`/\`then\`, \u2026) go unchecked there and the emitted example may not satisfy its own schema. Generation continues regardless; the usual causes are a \`$ref\` pointing outside this fragment and a \`pattern\` the ReDoS screen rejects.`);
 };
@@ -190,6 +193,39 @@ const tryGuard = (schema, checkFormats) => {
     return void 0;
   }
 };
+const everyPatternCompiles = (node) => {
+  if (node === null || typeof node !== "object")
+    return true;
+  if (Array.isArray(node))
+    return node.every(everyPatternCompiles);
+  const compiles = (source) => {
+    try {
+      new RegExp(source);
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  for (const [key, value] of Object.entries(node)) {
+    if (key === "pattern" && typeof value === "string" && !compiles(value))
+      return false;
+    if (key === "patternProperties" && value !== null && typeof value === "object") {
+      if (!Object.keys(value).every(compiles))
+        return false;
+    }
+    if (!everyPatternCompiles(value))
+      return false;
+  }
+  return true;
+};
+const canBuildGuard = (schema, rootSchema) => {
+  const resolved = withResolvableDefs(schema, rootSchema);
+  if (!everyPatternCompiles(resolved)) {
+    warnUndecidableSchema(resolved, "the schema carries a `pattern` that is not a valid regular expression");
+    return false;
+  }
+  return tryGuard(resolved, false) !== void 0;
+};
 const makeInstanceCheck = (schema, rootSchema, options) => {
   const resolved = withResolvableDefs(schema, rootSchema);
   const guard = tryGuard(resolved, options?.checkFormats === true);
@@ -205,6 +241,7 @@ const makeInstanceCheck = (schema, rootSchema, options) => {
   };
 };
 export {
+  canBuildGuard,
   makeInstanceCheck,
   needsValidationFilter,
   withResolvableDefs

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/generate-examples",
-  "version": "0.6.4",
+  "version": "0.8.0",
   "description": "Generate fast-check arbitraries and example values from JSON Schemas.",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -55,8 +55,8 @@
   },
   "dependencies": {
     "json-schema-typed": "^8.0.1",
-    "@amritk/helpers": "^0.15.4",
-    "@amritk/runtime-validators": "^0.11.0"
+    "@amritk/helpers": "^0.17.0",
+    "@amritk/runtime-validators": "^0.12.1"
   },
   "devDependencies": {
     "ajv": "^8.17.1"