@amritk/generate-examples 0.6.4 → 0.7.0

package/AI.md

@@ -47,6 +47,25 @@ const files = await buildExampleSchema(schema, 'User') // → user.ts, index.ts
 5. **`deriveExample` memoizes each `$ref` per root document**, so the returned
    value can share sub-objects with the value derived for a sibling schema.
    Treat it as read-only.
+6. **`fooExample` is sometimes emitted as `… as Foo`.** A schema can require a
+   key the generated type never declares (`required` naming something absent from
+   `properties`, a `dependentRequired`/`dependentSchemas` dependency, a
+   `minProperties` filler on an object with no index signature). The value keeps
+   the key — dropping it would ship a fixture missing what its schema demands —
+   so the assertion is what lets the file compile. Do not "clean it up" into a
+   bare literal; TypeScript rejects the excess property, and `satisfies` runs the
+   very same check.
+7. **Derived values are capped at 10,000** characters / elements / keys, so a
+   schema with an enormous `minLength`/`minItems`/`minProperties` gets a
+   short value plus a `console.warn` rather than a file nobody can open.
+   `FooArbitrary` still honours the real bound — reach for it when the exact size
+   matters.
+
+8. **A `default`/`examples` hint that contradicts its own schema is ignored.**
+   The generated type follows the schema, so emitting the hint verbatim produced
+   a file that would not compile (`const fooExample: string = 42`). `const` is
+   always honoured — the type is its literal type. Do not "restore" a mismatched
+   hint; fix the schema instead.
 
 Exports: `buildExampleSchema`, `generateArbitrary`, `generateExampleConst`,
 `deriveExample`, `serializeValue`, `GeneratedFile`. Only the `.` entry.

package/README.md

@@ -163,7 +163,7 @@ compiles — but the generator prints a `console.warn` naming the type. Reach fo
 `FooArbitrary` in those cases: the arbitrary carries a runtime validating filter
 and stays correct where the static value cannot.
 
-The value falls short for two reasons:
+The value falls short for three reasons:
 
 - **The schema has no instance.** `{ pattern: '^ab$', minLength: 5 }`,
   `uniqueItems` over booleans with `minItems: 3`, a `required` key that
@@ -173,6 +173,61 @@ The value falls short for two reasons:
 - **The constraint is beyond the deriver.** `pattern` is sampled by a
   best-effort recursive-descent walk of the regex, so lookarounds and
   backreferences fall back to `"string"`; an unrecognized `format` does the same.
+- **The bound is larger than any fixture should be.** A derived string, array, or
+  object stops growing at 10,000 characters / elements / keys, so a document
+  asking for `minLength: 50000000` yields a capped value and a warning rather than
+  a 50 MB literal. `FooArbitrary` still honours the real bound.
+
+Two more shapes worth knowing about, both of which keep the generated file
+compiling rather than making it correct:
+
+- A schema can require a key its **generated type never declares** — `required`
+  naming something absent from `properties`, a `dependentRequired` /
+  `dependentSchemas` dependency, or a `minProperties` filler on an object with no
+  index signature. The example keeps the key (a fixture missing what its schema
+  demands is broken data) and is emitted as `… as Foo`, since a bare object
+  literal with an excess property fails to compile.
+- An authored `default` or `examples[0]` is used **only when it satisfies its own
+  schema**. A hint that does not (`{ type: 'string', default: 42 }` — common in
+  documents whose field types changed after the hint was written) is ignored in
+  favour of a structurally derived value, because the generated type follows the
+  schema and would reject the hint outright. `const` is always honoured: the type
+  is the const's own literal type, so the two cannot disagree.
+- An **unsatisfiable range** (`minLength: 10, maxLength: 2`) collapses onto its
+  upper bound in the arbitrary. Every bounded `fc.*` combinator asserts
+  `min <= max` and throws at *import*, which would take down every other export in
+  the file alongside it. Integer bounds are also confined to fast-check's own
+  32-bit range, and length/count bounds to non-negative integers.
+- A **recursive definition's** example has to stop somewhere and stops with
+  `null`, which the non-nullable type does not admit — so it is emitted as
+  `… as unknown as Node`. `NodeArbitrary` ties the recursion properly through
+  `fc.letrec` and needs no such escape.
+- A `pattern` that is **not a valid JavaScript regex**, or that uses a lookahead
+  or lookbehind, falls back to a plain `fc.string()`. `fc.stringMatching` compiles
+  the pattern at module scope and cannot generate from an assertion, so honouring
+  it would throw where the whole file becomes unusable rather than just that one
+  arbitrary being loose.
+- **Nesting deeper than 400 levels** is refused with an error naming the limit.
+  Building an arbitrary costs several stack frames per schema level, so a deeper
+  document exhausts the stack — the cap turns that into a message that says what
+  is wrong.
+
+Two shapes stay impossible to generate from, and the arbitrary will retry
+forever if you sample it. Both are schemas with no instance, and the example
+warns:
+
+- A `pattern` no string of the required length can match
+  (`{ pattern: '^[a-z]{2}$', minLength: 5 }`). A satisfiable-but-narrow pairing
+  (`{ pattern: '^[a-f0-9]+$', minLength: 32, maxLength: 32 }`) is slow for the
+  same reason — `fc.stringMatching` rarely lands on the exact length.
+- A `minLength`/`minItems` so large that no value of that size can be built.
+
+One more gap is not this package's to close: a `$ref` that resolves nowhere in
+the document is typed by its name (`Nope`) but never imported, because it was
+never generated as a file. The arbitrary degrades to `fc.anything()`, but the
+type still names it, so the file does not compile. Same for `{ "type": [] }`,
+which types as `export type Foo = ;`. Both come from
+`@amritk/helpers/generate-type-definition`.
 
 > [!TIP]
 > The example for a `$ref` is inlined by value, so a definition graph with wide

package/dist/generators/assert-generator-depth.d.ts

@@ -0,0 +1,28 @@
+/**
+ * How deep a schema may nest before the two generator recursions give up.
+ *
+ * Lower than `@amritk/helpers`' `MAX_SCHEMA_DEPTH` of 2000, and deliberately so.
+ * That cap suits the helpers' walkers, which spend roughly two stack frames per
+ * schema level. Building an arbitrary or deriving a value costs far more —
+ * `derive` → `deriveBase` → `deriveForType` → `deriveObject` → `derive` is five
+ * frames before the next level even starts, plus whatever `needsValidationFilter`
+ * adds — so the real stack runs out first: measured, the arbitrary generator dies
+ * somewhere between 500 and 1000 levels and the deriver between 1000 and 1500,
+ * both well under 2000. A cap the stack beats to the punch is no cap at all.
+ *
+ * 400 sits inside the range both were measured to handle, with room for a
+ * shallower stack than this one, and it is still an order of magnitude past
+ * anything a real document nests — hand-written schemas rarely pass ten levels,
+ * and generated ones rarely pass fifty.
+ */
+export declare const MAX_GENERATOR_DEPTH = 400;
+/**
+ * Throws a message naming the nesting limit once a generator recursion passes it.
+ *
+ * Call this at the top of each recursive step with the *current* depth. Without
+ * it a pathologically nested document — a fuzz case, or a document that lost a
+ * closing brace — died with a bare `RangeError: Maximum call stack size exceeded`
+ * pointing at whichever helper happened to be deepest, which says nothing about
+ * the input that caused it.
+ */
+export declare const assertGeneratorDepth: (depth: number, generator: string) => void;

package/dist/generators/assert-generator-depth.js

@@ -0,0 +1,10 @@
+const MAX_GENERATOR_DEPTH = 400;
+const assertGeneratorDepth = (depth, generator) => {
+  if (depth > MAX_GENERATOR_DEPTH) {
+    throw new Error(`Schema nesting exceeds ${MAX_GENERATOR_DEPTH} levels while running ${generator}. Flatten the document (or split the deepest subschema into a $defs entry and $ref it) and try again.`);
+  }
+};
+export {
+  MAX_GENERATOR_DEPTH,
+  assertGeneratorDepth
+};

package/dist/generators/closed-value-set.d.ts

@@ -0,0 +1,14 @@
+import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
+/**
+ * The complete set of values an item schema admits, when that set is finite and
+ * small enough to enumerate: `const`, `enum`, `boolean`, `null`. `uniqueItems`
+ * needs distinct elements, and for these schemas perturbing one value would step
+ * straight out of the schema, so the deriver walks this set instead of nudging.
+ * `undefined` means the value space is open and perturbing is fine.
+ *
+ * The arbitrary generator asks the same question for a different reason: a set
+ * of N values cannot fill a `uniqueArray` of more than N slots, and fast-check
+ * retries forever rather than admitting it — so `{ items: { type: 'boolean' },
+ * minItems: 5, uniqueItems: true }` produced an arbitrary that hung when sampled.
+ */
+export declare const closedValueSet: (schema: JSONSchema | undefined) => unknown[] | undefined;

package/dist/generators/closed-value-set.js

@@ -0,0 +1,20 @@
+import { hasConst, hasEnum, hasType, isSchemaObject } from "@amritk/helpers/schema-guards";
+import { satisfiesScalarConstraints } from "./satisfies-scalar-constraints.js";
+const closedValueSet = (schema) => {
+  if (schema === void 0 || !isSchemaObject(schema))
+    return void 0;
+  if (hasConst(schema))
+    return [schema.const];
+  if (hasEnum(schema)) {
+    const fitting = schema.enum.filter((value) => satisfiesScalarConstraints(schema, value));
+    return fitting.length > 0 ? fitting : [...schema.enum];
+  }
+  if (hasType(schema) && schema.type === "boolean")
+    return [true, false];
+  if (hasType(schema) && schema.type === "null")
+    return [null];
+  return void 0;
+};
+export {
+  closedValueSet
+};

package/dist/generators/collect-example-imports.js

@@ -1,20 +1,22 @@
 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, hasOneOf, hasProperties, hasRef, isSchemaObject } from "@amritk/helpers/schema-guards";
+import { hasAdditionalProperties, hasAllOf, hasAnyOf, hasContains, hasDependentSchemas, hasOneOf, hasProperties, hasRef, isSchemaObject } from "@amritk/helpers/schema-guards";
+import { assertGeneratorDepth } from "./assert-generator-depth.js";
 const buildImport = (ref, suffix) => {
   const filename = refToFilename(ref);
   const typeName = refToName(ref, suffix);
   return `import { type ${typeName}, ${typeName}Arbitrary } from './${filename}.js'`;
 };
-const collectRefs = (schema) => {
+const collectRefs = (schema, depth = 0) => {
+  assertGeneratorDepth(depth, "collectExampleImports");
   if (!isSchemaObject(schema))
     return [];
   if (hasRef(schema))
     return [schema.$ref];
   const refs = [];
   const visit = (sub) => {
-    refs.push(...collectRefs(sub));
+    refs.push(...collectRefs(sub, depth + 1));
   };
   if (hasOneOf(schema))
     schema.oneOf.forEach(visit);
@@ -32,6 +34,8 @@ const collectRefs = (schema) => {
   if (hasAdditionalProperties(schema) && isSchemaObject(schema.additionalProperties)) {
     visit(schema.additionalProperties);
   }
+  if (hasDependentSchemas(schema))
+    Object.values(schema.dependentSchemas).forEach(visit);
   const prefixItems = raw["prefixItems"];
   if (Array.isArray(prefixItems))
     prefixItems.forEach(visit);
@@ -40,6 +44,8 @@ const collectRefs = (schema) => {
     items.forEach(visit);
   else if (isSchemaObject(items))
     visit(items);
+  if (hasContains(schema) && isSchemaObject(schema.contains))
+    visit(schema.contains);
   return refs;
 };
 const collectExampleImports = (schema, options) => {

package/dist/generators/derive-example.js

@@ -2,6 +2,10 @@ import { getMjstInstanceOf, getMjstPrimitive } from "@amritk/helpers/mjst-extens
 import { readKey } from "@amritk/helpers/read-key";
 import { resolveRef } from "@amritk/helpers/resolve-ref";
 import { hasAdditionalProperties, hasAllOf, hasAnyOf, hasConst, hasDefault, hasDependentRequired, hasDependentSchemas, hasEnum, hasExamples, 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 { declaresOwnShape, isObjectLike, typesConflict } from "./is-object-like.js";
+import { satisfiesScalarConstraints } from "./satisfies-scalar-constraints.js";
 import { makeInstanceCheck, needsValidationFilter } from "./schema-validation.js";
 const lowerFirst = (name) => name.charAt(0).toLowerCase() + name.slice(1);
 const exampleName = (typeName) => `${lowerFirst(typeName)}Example`;
@@ -186,13 +190,14 @@ const FORMAT_EXAMPLES = {
   // The `regex` format asks for a string that *compiles* as a regular expression.
   regex: "^example$"
 };
+const MAX_DERIVED_SIZE = 1e4;
 const exampleString = (schema) => {
   if (hasFormat(schema)) {
     const formatted = readKey(FORMAT_EXAMPLES, schema.format);
     if (formatted !== void 0)
       return formatted;
   }
-  const minLength = hasMinLength(schema) ? schema.minLength : 0;
+  const minLength = Math.min(hasMinLength(schema) ? schema.minLength : 0, MAX_DERIVED_SIZE);
   if (hasPattern(schema)) {
     const sampled = sampleFromPattern(schema.pattern, minLength);
     if (sampled !== void 0 && sampled.length >= minLength && matchesPattern(schema.pattern, sampled)) {
@@ -212,7 +217,9 @@ const newContext = (rootSchema) => ({
   rootSchema,
   values: /* @__PURE__ */ new Map(),
   active: /* @__PURE__ */ new Set(),
-  cycleBroken: false
+  cycleBroken: false,
+  needsAssertion: false,
+  depth: 0
 });
 const contextFor = (rootSchema) => {
   if (rootSchema === void 0)
@@ -224,52 +231,76 @@ const contextFor = (rootSchema) => {
   contexts.set(rootSchema, created);
   return created;
 };
-const deriveExample = (schema, rootSchema) => {
+const deriveExample = (schema, rootSchema) => deriveReported(schema, rootSchema).value;
+const deriveReported = (schema, rootSchema) => {
   const ctx = contextFor(rootSchema);
   ctx.active.clear();
   ctx.cycleBroken = false;
-  return derive(schema, ctx);
+  ctx.needsAssertion = false;
+  ctx.depth = 0;
+  const value = derive(schema, ctx);
+  return { value, needsAssertion: ctx.needsAssertion, cycleBroken: ctx.cycleBroken };
 };
 const derive = (schema, ctx) => {
+  assertGeneratorDepth(ctx.depth, "deriveExample");
   if (!isSchemaObject(schema))
     return null;
-  const base = deriveBase(schema, ctx);
-  return needsValidationFilter(schema) ? refineExample(schema, base, ctx) : base;
+  ctx.depth++;
+  try {
+    const base = deriveBase(schema, ctx);
+    return needsValidationFilter(schema) ? refineExample(schema, base, ctx) : base;
+  } finally {
+    ctx.depth--;
+  }
 };
 const deriveRef = (ref, ctx) => {
   if (ctx.active.has(ref)) {
     ctx.cycleBroken = true;
     return null;
   }
-  if (ctx.values.has(ref))
-    return ctx.values.get(ref);
+  const memoized = ctx.values.get(ref);
+  if (memoized !== void 0) {
+    if (memoized.needsAssertion)
+      ctx.needsAssertion = true;
+    return memoized.value;
+  }
   if (!ctx.rootSchema)
     return null;
   const resolved = resolveRef(ref, ctx.rootSchema);
   if (!resolved)
     return null;
   const outerBroken = ctx.cycleBroken;
+  const outerUndeclared = ctx.needsAssertion;
   ctx.cycleBroken = false;
+  ctx.needsAssertion = false;
   ctx.active.add(ref);
   try {
     const value = derive(resolved, ctx);
     if (!ctx.cycleBroken)
-      ctx.values.set(ref, value);
+      ctx.values.set(ref, { value, needsAssertion: ctx.needsAssertion });
     ctx.cycleBroken = outerBroken || ctx.cycleBroken;
+    ctx.needsAssertion = outerUndeclared || ctx.needsAssertion;
     return value;
   } finally {
     ctx.active.delete(ref);
   }
 };
+const authoredHint = (schema) => {
+  if (hasExamples(schema) && Array.isArray(schema.examples) && schema.examples.length > 0) {
+    return { value: schema.examples[0] };
+  }
+  if (hasDefault(schema))
+    return { value: schema.default };
+  return void 0;
+};
 const deriveBase = (schema, ctx) => {
   if (!isSchemaObject(schema))
     return null;
   if (hasConst(schema))
     return schema.const;
-  if (hasExamples(schema) && Array.isArray(schema.examples) && schema.examples.length > 0)
-    return schema.examples[0];
-  if (hasDefault(schema))
-    return schema.default;
+  const hint = authoredHint(schema);
+  if (hint !== void 0 && makeInstanceCheck(schema, ctx.rootSchema)(hint.value))
+    return hint.value;
   if (hasEnum(schema) && schema.enum.length > 0) {
     const fitting = schema.enum.find((value) => satisfiesScalarConstraints(schema, value));
     return fitting !== void 0 ? fitting : schema.enum[0];
@@ -284,10 +315,16 @@ const deriveBase = (schema, ctx) => {
     return 0n;
   if (hasAllOf(schema))
     return derive(mergeAllOf(schema), ctx);
-  if (hasOneOf(schema) && schema.oneOf[0] !== void 0)
-    return derive(schema.oneOf[0], ctx);
-  if (hasAnyOf(schema) && schema.anyOf[0] !== void 0)
-    return derive(schema.anyOf[0], ctx);
+  const branches = hasOneOf(schema) ? schema.oneOf : hasAnyOf(schema) ? schema.anyOf : void 0;
+  if (branches !== void 0 && branches.length > 0) {
+    const rest = withoutCombinators(schema);
+    if (!declaresOwnShape(rest))
+      return derive(branches[0], ctx);
+    const chosen = branches.find((branch) => !typesConflict(rest, branch)) ?? branches[0];
+    return derive({ allOf: [rest, chosen] }, ctx);
+  }
+  if (isObjectLike(schema))
+    return deriveObject(schema, ctx);
   if (hasType(schema))
     return deriveForType(schema.type, schema, ctx);
   if (Array.isArray(schema.type) && schema.type.length > 0) {
@@ -295,6 +332,12 @@ const deriveBase = (schema, ctx) => {
   }
   return null;
 };
+const withoutCombinators = (schema) => {
+  const rest = { ...schema };
+  delete rest["oneOf"];
+  delete rest["anyOf"];
+  return rest;
+};
 const REFINED_APPLICATORS = ["if", "then", "else", "not", "oneOf"];
 const structuralOnly = (schema) => {
   const clone = { ...schema };
@@ -344,26 +387,6 @@ const refineExample = (schema, base, ctx) => {
       return candidate;
   return base;
 };
-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;
-  } 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 deriveForType = (type, schema, ctx) => {
   switch (type) {
     case "string":
@@ -404,6 +427,15 @@ const deriveObject = (schema, ctx) => {
   const additionalClosed = hasAdditionalProperties(schema) && schema.additionalProperties === false;
   const extrasAllowed = !additionalClosed || patternEntries.length > 0;
   const nameCheck = hasPropertyNames(schema) ? makeInstanceCheck(schema.propertyNames, ctx.rootSchema) : void 0;
+  const declaredKeys = new Set(hasProperties(schema) ? Object.keys(schema.properties) : []);
+  const hasIndexSignature = additionalSchema !== void 0 || hasPatternProperties(schema) && Object.keys(schema.patternProperties).length > 0;
+  const noteKey = (key) => {
+    if (!hasIndexSignature && !declaredKeys.has(key))
+      ctx.needsAssertion = true;
+  };
+  const raw = schema;
+  if (Object.hasOwn(raw, "if") && Object.hasOwn(raw, "then"))
+    ctx.needsAssertion = true;
   const valueSchemaFor = (key) => {
     const matches = patternEntries.filter(([re]) => re.test(key)).map(([, sub]) => sub);
     if (matches.length === 1)
@@ -416,6 +448,7 @@ const deriveObject = (schema, ctx) => {
     const sub = valueSchemaFor(key);
     if (sub === void 0 && additionalClosed)
       return;
+    noteKey(key);
     setProperty(out, key, sub !== void 0 ? derive(sub, ctx) : null);
   };
   if (hasProperties(schema)) {
@@ -424,9 +457,10 @@ const deriveObject = (schema, ctx) => {
     }
   }
   if (hasRequired(schema)) {
-    for (const key of schema.required)
-      if (!Object.hasOwn(out, key))
+    for (const key of schema.required) {
+      if (typeof key === "string" && !Object.hasOwn(out, key))
         addKey(key);
+    }
   }
   if (hasDependentRequired(schema)) {
     for (const [trigger, deps] of Object.entries(schema.dependentRequired)) {
@@ -440,63 +474,78 @@ const deriveObject = (schema, ctx) => {
   if (hasDependentSchemas(schema)) {
     for (const [trigger, sub] of Object.entries(schema.dependentSchemas)) {
       if (Object.hasOwn(out, trigger) && isSchemaObject(sub))
-        applyDependentSchema(out, sub, ctx);
+        applyDependentSchema(out, sub, ctx, noteKey);
     }
   }
   if (hasMinProperties(schema) && extrasAllowed) {
+    const target = Math.min(schema.minProperties, MAX_DERIVED_SIZE);
+    let count = Object.keys(out).length;
     let n = 0;
-    let guard = 0;
-    while (Object.keys(out).length < schema.minProperties && guard++ < schema.minProperties + 50) {
+    let attempts = 0;
+    while (count < target && attempts++ < target + 50) {
       const key = synthKey(n++, patternEntries, schema, nameCheck);
-      if (key === void 0 || Object.hasOwn(out, key))
+      if (key === void 0)
+        break;
+      if (Object.hasOwn(out, key))
         continue;
       addKey(key);
+      if (Object.hasOwn(out, key))
+        count++;
     }
   }
   if (hasMaxProperties(schema))
     enforceMaxProperties(out, schema, schema.maxProperties);
   return out;
 };
-const applyDependentSchema = (out, sub, ctx) => {
+const applyDependentSchema = (out, sub, ctx, noteKey) => {
+  const add = (key, propSchema) => {
+    noteKey(key);
+    setProperty(out, key, propSchema !== void 0 ? derive(propSchema, ctx) : null);
+  };
   if (hasProperties(sub)) {
     for (const [key, propSchema] of Object.entries(sub.properties)) {
       if (!Object.hasOwn(out, key))
-        setProperty(out, key, derive(propSchema, ctx));
+        add(key, propSchema);
     }
   }
   if (hasRequired(sub)) {
     const propSchemas = hasProperties(sub) ? sub.properties : {};
     for (const key of sub.required) {
-      if (Object.hasOwn(out, key))
+      if (typeof key !== "string" || Object.hasOwn(out, key))
         continue;
-      const propSchema = propSchemas[key];
-      setProperty(out, key, propSchema !== void 0 ? derive(propSchema, ctx) : null);
+      add(key, propSchemas[key]);
     }
   }
 };
+const MAX_SYNTH_KEY_LENGTH = 64;
 const synthKey = (i, patternEntries, schema, nameCheck) => {
-  const vary = (seed) => seed.repeat(i + 1);
+  const variants = (seed) => i === 0 ? [seed] : [`${seed}${i}`, seed.repeat(i + 1)].filter((key) => key.length <= MAX_SYNTH_KEY_LENGTH);
   const seeds = [];
   for (const [re] of patternEntries) {
     const sampled = sampleFromPattern(re.source, 0);
-    if (sampled !== void 0 && sampled.length > 0)
-      seeds.push(vary(sampled));
+    if (sampled !== void 0 && sampled.length > 0) {
+      seeds.push({ seed: sampled, matches: (key) => re.test(key) });
+    }
   }
   const propertyNames = isSchemaObject(schema) && hasPropertyNames(schema) ? schema.propertyNames : void 0;
   if (propertyNames !== void 0 && isSchemaObject(propertyNames) && hasPattern(propertyNames)) {
     const sampled = sampleFromPattern(propertyNames.pattern, 0);
     if (sampled !== void 0 && sampled.length > 0)
-      seeds.push(vary(sampled));
+      seeds.push({ seed: sampled, matches: () => true });
   }
-  seeds.push(vary("extra"));
-  for (const seed of seeds) {
-    if (!nameCheck || nameCheck(seed))
-      return seed;
+  seeds.push({ seed: "extra", matches: () => true });
+  for (const { seed, matches } of seeds) {
+    for (const key of variants(seed)) {
+      if (matches(key) && (!nameCheck || nameCheck(key)))
+        return key;
+    }
   }
   return void 0;
 };
 const enforceMaxProperties = (out, schema, max) => {
-  if (Object.keys(out).length <= max)
+  const keys = Object.keys(out);
+  let count = keys.length;
+  if (count <= max)
     return;
   const protectedKeys = new Set(hasRequired(schema) ? schema.required : []);
   if (hasDependentRequired(schema)) {
@@ -506,11 +555,13 @@ const enforceMaxProperties = (out, schema, max) => {
           protectedKeys.add(dep);
     }
   }
-  for (const key of Object.keys(out)) {
-    if (Object.keys(out).length <= max)
+  for (const key of keys) {
+    if (count <= max)
       break;
-    if (!protectedKeys.has(key))
-      delete out[key];
+    if (protectedKeys.has(key))
+      continue;
+    delete out[key];
+    count--;
   }
 };
 const deriveNumber = (schema, isInteger) => {
@@ -524,7 +575,7 @@ const deriveNumber = (schema, isInteger) => {
   let value = Number.isFinite(lo) ? lo : Number.isFinite(hi) ? Math.min(0, hi) : 0;
   if (isInteger)
     value = Math.ceil(value);
-  if (hasMultipleOf(schema) && schema.multipleOf > 0) {
+  if (hasMultipleOf(schema) && Number.isFinite(schema.multipleOf) && schema.multipleOf > 0) {
     const m = schema.multipleOf;
     value = Math.ceil(value / m - 1e-9) * m;
     if (value > hi && Number.isFinite(hi))
@@ -559,35 +610,27 @@ const deriveArray = (schema, ctx) => {
   const unique = hasUniqueItems(schema) && schema.uniqueItems === true;
   const elem = rest ?? contains;
   const choices = unique && contains === void 0 ? closedValueSet(elem) : void 0;
-  const wanted = Math.min(Math.max(min, minContains, max === 0 ? 0 : 1), max);
+  const wanted = Math.min(Math.max(min, minContains, max === 0 ? 0 : 1), max, MAX_DERIVED_SIZE);
   const count = choices !== void 0 ? Math.min(wanted, choices.length) : wanted;
+  const itemsCheck = rest !== void 0 && contains !== void 0 ? makeInstanceCheck(rest, ctx.rootSchema) : void 0;
   const result = [];
   for (let i = 0; i < count; i++) {
     if (choices !== void 0) {
       result.push(choices[i]);
       continue;
     }
-    const itemSchema = contains !== void 0 && i < minContains ? contains : elem;
-    const base = itemSchema !== void 0 ? derive(itemSchema, ctx) : null;
-    result.push(unique ? distinctify(base, i, itemSchema) : base);
+    const useContains = contains !== void 0 && i < minContains;
+    const itemSchema = useContains ? contains : elem;
+    let chosen = itemSchema;
+    let base = itemSchema !== void 0 ? derive(itemSchema, ctx) : null;
+    if (useContains && itemsCheck !== void 0 && !itemsCheck(base)) {
+      chosen = rest;
+      base = rest !== void 0 ? derive(rest, ctx) : null;
+    }
+    result.push(unique ? distinctify(base, i, chosen) : base);
   }
   return result;
 };
-const closedValueSet = (schema) => {
-  if (schema === void 0 || !isSchemaObject(schema))
-    return void 0;
-  if (hasConst(schema))
-    return [schema.const];
-  if (hasEnum(schema)) {
-    const fitting = schema.enum.filter((value) => satisfiesScalarConstraints(schema, value));
-    return fitting.length > 0 ? fitting : [...schema.enum];
-  }
-  if (hasType(schema) && schema.type === "boolean")
-    return [true, false];
-  if (hasType(schema) && schema.type === "null")
-    return [null];
-  return void 0;
-};
 const distinctify = (base, i, itemSchema) => {
   if (i === 0)
     return base;
@@ -613,10 +656,20 @@ const TIGHTEST = /* @__PURE__ */ new Map([
   ["maxItems", "min"],
   ["maxProperties", "min"]
 ]);
+const flattenBranches = (nodes, depth = 0) => {
+  assertGeneratorDepth(depth, "mergeAllOf");
+  return nodes.flatMap((node) => {
+    if (!isSchemaObject(node) || !hasAllOf(node))
+      return [node];
+    const own = { ...node };
+    delete own["allOf"];
+    return [...flattenBranches(node.allOf, depth + 1), own];
+  });
+};
 const mergeAllOf = (schema) => {
-  const branches = hasAllOf(schema) ? schema.allOf : [];
-  const merged = {};
-  const properties = {};
+  const branches = hasAllOf(schema) ? flattenBranches(schema.allOf) : [];
+  const merged = /* @__PURE__ */ Object.create(null);
+  const properties = /* @__PURE__ */ Object.create(null);
   const required = /* @__PURE__ */ new Set();
   for (const branch of [...branches, schema]) {
     if (!isSchemaObject(branch))
@@ -644,7 +697,7 @@ const mergeAllOf = (schema) => {
       }
     }
   }
-  const mergedProps = {};
+  const mergedProps = /* @__PURE__ */ Object.create(null);
   for (const [prop, schemas] of Object.entries(properties)) {
     mergedProps[prop] = schemas.length === 1 ? schemas[0] : { allOf: schemas };
   }
@@ -679,9 +732,13 @@ const warnInvalidExample = (schema, typeName, value, rootSchema) => {
   console.warn(`Warning: the derived example for ${typeName} does not validate against its own schema \u2014 ${quoted}. It is emitted anyway so the file still compiles, but treat it as a placeholder: either the schema has no instance, or it uses a constraint the deriver cannot satisfy structurally (see the README's "Known limits"). ${arbitraryName(typeName)} is unaffected.`);
 };
 const generateExampleConst = (schema, typeName, rootSchema) => {
-  const value = deriveExample(schema, rootSchema);
+  const { value, needsAssertion, cycleBroken } = deriveReported(schema, rootSchema);
   warnInvalidExample(schema, typeName, value, rootSchema);
-  return `export const ${exampleName(typeName)}: ${typeName} = ${serializeValue(value)}`;
+  const literal = serializeValue(value);
+  const admitsNothing = schema === false;
+  const assertion = cycleBroken || admitsNothing ? ` as unknown as ${typeName}` : needsAssertion ? ` as ${typeName}` : "";
+  const expression = `${literal}${assertion}`;
+  return `export const ${exampleName(typeName)}: ${typeName} = ${expression}`;
 };
 export {
   deriveExample,