@lovrozagar/oat 0.9.1 → 0.11.0

package/dist/runtime/fixture.js

@@ -1,16 +1,20 @@
 /**
- * Schema-driven fixture generation.
+ * Schema-driven fixture generation: the discriminating cohort.
  *
  * Valid-random data cannot test a query engine: `ilike` needs a substring, `order` needs a total
- * order, escaping needs metacharacters. oat seeds a *discriminating cohort* — instances shaped so
- * that every query assertion has signal — and derives everything from a seed so a failing run is
+ * order, escaping needs metacharacters. oat seeds a *cohort* — one record per variant, each shaped
+ * so some query assertion has signal — and derives everything from a seed so a failing run is
  * exactly reproducible.
  *
- * After `$ref` inlining the same object identity can cycle, and empty schemas (`{}`, `true`,
- * `additionalProperties: {}`) mean "any value", not "walk this object again". Generation therefore
- * keys a WeakSet on every node and treats those open shapes as a scalar or `{}`.
+ * The values themselves come from `generate.ts`, the one place oat invents data, from the request
+ * schema as `spec/schema.ts` normalizes it. Every body is checked against that schema before it
+ * leaves; one that cannot be made valid is a gap naming the operation and the field, never a
+ * request the document forbids.
  */
-import { UNICODE_COHORT_STRING, codePointCount, sliceCodePoints } from "./payloads.js";
+import { normalizeSchema } from "../spec/schema.js";
+import { generate, isVacuous } from "./generate.js";
+import { instanceErrors } from "./validate.js";
+export { isVacuous } from "./generate.js";
 export const COHORT = [
     "baseline",
     "lexical-first",
@@ -30,32 +34,27 @@ export function mulberry32(seed) {
         return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
     };
 }
-const STRINGS = {
-    baseline: "Quarterly Report",
-    boundary: "",
-    "lexical-first": "aaa first alphabetically",
-    "lexical-last": "zzz last alphabetically",
-    metacharacter: "100% _off_ *everything*",
-    "null-heavy": "null heavy record",
-    unicode: UNICODE_COHORT_STRING,
-};
-const EMAIL_RE = /^[^@]+@[^@]+\.[^@]+$/;
-const MAX_DEPTH = 8;
-const PATTERN_ATTEMPTS = 48;
-/** Thrown when a walk still overflows; the pointer names the node that blew the stack. */
+/**
+ * Thrown when no valid body can be built for an operation. The pointer names the field; the
+ * reason says why — and the fix is `hooks.resolveInput`, which can supply what the schema cannot.
+ */
 export class FixtureOverflow extends Error {
     operationId;
     pointer;
-    constructor(operationId, pointer) {
-        super(`fixture generation overflow on ${operationId} (${pointer})`);
+    reason;
+    constructor(operationId, pointer, reason) {
+        super(reason === undefined
+            ? `fixture generation overflow on ${operationId} (${pointer})`
+            : `cannot generate a valid body for ${operationId} at ${pointer}: ${reason} — supply one with hooks.resolveInput`);
         this.operationId = operationId;
         this.pointer = pointer;
+        this.reason = reason;
         this.name = "FixtureOverflow";
     }
 }
 export function overflowFrom(error, operationId, pointer = "/") {
     if (error instanceof FixtureOverflow) {
-        return new FixtureOverflow(operationId, error.pointer === "/" ? pointer : error.pointer);
+        return new FixtureOverflow(operationId, error.pointer === "/" ? pointer : error.pointer, error.reason);
     }
     return new FixtureOverflow(operationId, pointer);
 }
@@ -64,28 +63,85 @@ export function isOverflowError(error) {
         return true;
     return error instanceof RangeError;
 }
+function requestSchema(schema) {
+    return typeof schema === "object" && schema !== null ? normalizeSchema(schema, { direction: "request" }) : schema;
+}
+/** One body per variant, each valid for the schema — or a `FixtureOverflow` naming what is not. */
+export function buildCohort(bodySchema, seed, variants = COHORT, operationId = "unknown", options = {}) {
+    const schema = requestSchema(bodySchema);
+    return variants.map((variant, index) => {
+        const result = generate(schema, {
+            ...(options.defs === undefined ? {} : { defs: options.defs }),
+            ...(options.distinct === undefined ? {} : { distinct: options.distinct }),
+            ...(options.nonce === undefined ? {} : { nonce: options.nonce }),
+            index,
+            rand: mulberry32(seed + index * 7919),
+            variant,
+        });
+        if (!result.ok)
+            throw new FixtureOverflow(operationId, result.pointer, result.reason);
+        const body = isObject(result.value) ? result.value : {};
+        /* The self-check: a body oat invented must satisfy the document before it is sent. */
+        if (typeof schema === "object" && !isVacuous(schema)) {
+            const errors = instanceErrors(schema, body, options.defs);
+            if (errors.length > 0)
+                throw new FixtureOverflow(operationId, "/", errors.slice(0, 3).join("; "));
+        }
+        return { body, variant };
+    });
+}
 /**
- * Makes unique-set tuples differ across cohort members without relaxing `maxLength` / `pattern`.
- *
- * When the document cannot express two distinct values, extra variants are dropped and the
- * caller records a gap.
+ * One body, with the required fields that could not be made rather than an exception — for
+ * callers that report each gap themselves. Optional fields that cannot be made are left out.
  */
-export function ensureDistinctUniqueValues(members, sets, schema) {
+export function generateBody(bodySchema, variant, rand, index, operationId = "unknown") {
+    void operationId;
+    const schema = requestSchema(bodySchema);
+    const result = generate(schema, { index, rand, variant });
+    if (result.ok)
+        return { body: isObject(result.value) ? result.value : {}, missingRequired: [] };
+    /* Without the failing field, the rest may still be made: drop it from `required` and retry. */
+    const field = result.pointer.split("/")[1];
+    if (field !== undefined && field !== "" && typeof schema === "object") {
+        const required = Array.isArray(schema.required) ? schema.required.filter((name) => name !== field) : [];
+        const properties = { ...schema.properties };
+        delete properties[field];
+        const rest = generateBody({ ...schema, properties, required }, variant, rand, index, operationId);
+        return { body: rest.body, missingRequired: [result.pointer, ...rest.missingRequired] };
+    }
+    return { body: {}, missingRequired: [result.pointer] };
+}
+function isObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+/**
+ * Makes unique-set tuples differ across cohort members, by drawing new values from each
+ * column's schema. When the document cannot express two distinct values — a two-value enum and
+ * seven members — the extra members are dropped and the caller records a gap.
+ */
+export function ensureDistinctUniqueValues(members, sets, schema, options = {}) {
     if (sets.length === 0 || members.length <= 1)
         return { gap: null, members };
-    const schemaObj = schema !== null && typeof schema === "object" ? schema : null;
+    const normalized = requestSchema(schema);
+    const properties = typeof normalized === "object" && isObject(normalized.properties) ? normalized.properties : {};
     const kept = [];
     for (const member of members) {
         const body = { ...member.body };
         let ok = true;
         for (const set of sets) {
-            let attempts = 0;
-            while (kept.some((prior) => sameUniqueTuple(prior.body, body, set)) && attempts < 16) {
-                if (!nudgeUniqueSet(body, set, schemaObj, kept.length + attempts + 1)) {
-                    ok = false;
+            for (let attempt = 0; kept.some((prior) => sameUniqueTuple(prior.body, body, set)) && attempt < 16; attempt++) {
+                const col = set.find((name) => Object.hasOwn(body, name) && isObject(properties[name]));
+                if (col === undefined)
                     break;
-                }
-                attempts++;
+                const redrawn = generate({ properties: { [col]: properties[col] }, required: [col], type: "object" }, {
+                    ...(options.defs === undefined ? {} : { defs: options.defs }),
+                    distinct: new Set([col]),
+                    index: kept.length * 17 + attempt + 1,
+                    nonce: `${options.nonce ?? ""}${attempt}`,
+                });
+                if (!redrawn.ok)
+                    break;
+                body[col] = redrawn.value[col];
             }
             if (kept.some((prior) => sameUniqueTuple(prior.body, body, set)))
                 ok = false;
@@ -103,8 +159,7 @@ export function ensureDistinctUniqueValues(members, sets, schema) {
 }
 function uniqueDistinctGap(sets) {
     const shown = sets.map((set) => `[${set.join(", ")}]`).join("; ");
-    return (`x-unique cannot express two distinct values for ${shown} without weakening ` +
-        "maxLength/pattern; extra variants skipped");
+    return `x-unique cannot express distinct values for ${shown} within the schema; extra variants skipped`;
 }
 function sameUniqueTuple(a, b, set) {
     const cols = set.filter((col) => Object.hasOwn(a, col) || Object.hasOwn(b, col));
@@ -112,698 +167,4 @@ function sameUniqueTuple(a, b, set) {
         return false;
     return cols.every((col) => JSON.stringify(a[col]) === JSON.stringify(b[col]));
 }
-function nudgeUniqueSet(body, set, schema, token) {
-    for (const col of set) {
-        if (!Object.hasOwn(body, col))
-            continue;
-        const current = body[col];
-        const field = propertySchema(schema, col);
-        if (typeof current === "number" && Number.isFinite(current)) {
-            body[col] = current + token;
-            return true;
-        }
-        if (Array.isArray(field?.enum) && field.enum.length > 1) {
-            const next = field.enum[token % field.enum.length];
-            if (next !== current) {
-                body[col] = next;
-                return true;
-            }
-            continue;
-        }
-        if (typeof current !== "string")
-            continue;
-        const nudged = suffixWithinConstraints(current, String(token), field);
-        if (nudged !== current) {
-            body[col] = nudged;
-            return true;
-        }
-    }
-    return false;
-}
-function propertySchema(schema, name) {
-    if (schema === null)
-        return undefined;
-    const props = schema.properties;
-    if (props === null || typeof props !== "object")
-        return undefined;
-    const value = props[name];
-    return value !== null && typeof value === "object" ? value : undefined;
-}
-function suffixWithinConstraints(value, token, schema) {
-    const max = typeof schema?.maxLength === "number" ? schema.maxLength : undefined;
-    const pattern = typeof schema?.pattern === "string" ? schema.pattern : undefined;
-    const suffix = `-${token}`;
-    let next = `${value}${suffix}`;
-    if (max !== undefined && next.length > max) {
-        const keep = Math.max(0, max - suffix.length);
-        next = `${value.slice(0, keep)}${suffix}`;
-        if (next.length > max)
-            return value;
-    }
-    if (pattern !== undefined) {
-        try {
-            if (!new RegExp(pattern, "u").test(next))
-                return value;
-        }
-        catch {
-            return value;
-        }
-    }
-    return next;
-}
-export function buildCohort(bodySchema, seed, variants = COHORT, operationId = "unknown") {
-    try {
-        return variants.map((variant, index) => ({
-            body: generateObject(bodySchema, variant, mulberry32(seed + index * 7919), index, 0, "/", new WeakSet(), operationId),
-            variant,
-        }));
-    }
-    catch (error) {
-        if (isOverflowError(error))
-            throw overflowFrom(error, operationId);
-        throw error;
-    }
-}
-/**
- * One create body, or a gap if a required field cannot be honoured.
- *
- * Optional fields that cannot match `format`/`pattern` are omitted. Required ones must not fall
- * back to `"Quarterly Report N"` — that is what 400s every email/handle/url field.
- */
-export function generateBody(bodySchema, variant, rand, index, operationId = "unknown") {
-    const missingRequired = [];
-    const body = generateObject(bodySchema, variant, rand, index, 0, "/", new WeakSet(), operationId, missingRequired);
-    return { body, missingRequired };
-}
-function generateObject(schema, variant, rand, index, depth, pointer, seen, operationId, missingRequired = []) {
-    try {
-        if (depth > MAX_DEPTH)
-            return {};
-        if (isVacuous(schema))
-            return {};
-        if (schema === false)
-            return {};
-        if (typeof schema !== "object" || schema === null)
-            return {};
-        if (seen.has(schema))
-            return {};
-        seen.add(schema);
-        const concrete = concreteBranch(schema, depth, pointer, seen, operationId);
-        if (isVacuous(concrete) || typeof concrete !== "object" || concrete === null)
-            return {};
-        if (seen.has(concrete) && concrete !== schema)
-            return {};
-        const properties = concrete.properties;
-        if (properties === null || typeof properties !== "object")
-            return {};
-        const required = Array.isArray(concrete.required) ? concrete.required : [];
-        const out = {};
-        for (const [name, raw] of Object.entries(properties)) {
-            const child = `${pointer === "/" ? "" : pointer}/${escapePointer(name)}`;
-            const value = generateValue(name, raw, variant, rand, index, depth + 1, child, seen, operationId);
-            if (value === undefined) {
-                if (required.includes(name)) {
-                    const fallback = requiredFallback(raw, variant, index);
-                    if (fallback === undefined)
-                        missingRequired.push(child);
-                    else
-                        out[name] = fallback;
-                }
-                continue;
-            }
-            out[name] = value;
-        }
-        return out;
-    }
-    catch (error) {
-        if (isOverflowError(error))
-            throw overflowFrom(error, operationId, pointer);
-        throw error;
-    }
-}
-function generateValue(name, raw, variant, rand, index, depth, pointer, seen, operationId) {
-    try {
-        if (depth > MAX_DEPTH)
-            return undefined;
-        if (isVacuous(raw))
-            return scalarFor(name, variant, index, undefined);
-        if (raw === false)
-            return undefined;
-        if (typeof raw !== "object" || raw === null)
-            return undefined;
-        if (seen.has(raw))
-            return {};
-        const schema = raw;
-        const nullable = isNullable(schema);
-        if (variant === "null-heavy" && nullable)
-            return null;
-        if (schema.readOnly === true)
-            return undefined;
-        const followed = followRef(schema, depth, pointer, seen, operationId);
-        if (followed === "cycle")
-            return {};
-        const concrete = concreteBranch(followed === null ? schema : followed, depth, pointer, seen, operationId);
-        if (isVacuous(concrete))
-            return scalarFor(name, variant, index, undefined);
-        if (typeof concrete !== "object" || concrete === null)
-            return scalarFor(name, variant, index, undefined);
-        if (seen.has(concrete) && concrete !== schema)
-            return {};
-        if (Array.isArray(concrete.enum) && concrete.enum.length > 0) {
-            return concrete.enum[index % concrete.enum.length];
-        }
-        const type = typeOf(concrete);
-        switch (type) {
-            case "string":
-                return generateString(name, concrete, variant, index);
-            case "integer":
-            case "number": {
-                if (variant === "boundary" && typeof concrete.maximum === "number")
-                    return concrete.maximum;
-                const min = typeof concrete.minimum === "number" ? concrete.minimum : 0;
-                /*
-                 * A ladder whose lexical order differs from its numeric order: as text these sort
-                 * 1, 10, 100, 2, 20, 5, 50 — nothing like their numeric order.
-                 *
-                 * An evenly spaced sequence (10, 20, 30…) sorts identically either way, so a backend
-                 * comparing numbers as strings would look correct. Values have to disagree for the
-                 * assertion to carry any signal.
-                 */
-                const ladder = [1, 2, 5, 10, 20, 50, 100];
-                const step = ladder[index % ladder.length] ?? 1;
-                return type === "integer" ? min + step : min + step + Math.round(rand() * 9) / 10;
-            }
-            case "boolean":
-                return index % 2 === 0;
-            case "array": {
-                /* An empty array is not a safe default: `minItems` is common on required collections
-                 * (column definitions, line items), and sending [] fails validation on exactly the
-                 * endpoints most worth testing. */
-                const min = typeof concrete.minItems === "number" ? concrete.minItems : 0;
-                const count = Math.max(min, 1);
-                const prefix = concrete.prefixItems;
-                if (Array.isArray(prefix)) {
-                    return prefix.map((item, position) => generateValue(`${name}_${position}`, item, variant, rand, index + position, depth + 1, `${pointer}/prefixItems/${position}`, seen, operationId));
-                }
-                const items = concrete.items;
-                if (isVacuous(items) || items === false)
-                    return Array.from({ length: count }, () => ({}));
-                if (items === null || typeof items !== "object")
-                    return [];
-                return Array.from({ length: count }, (_, position) => generateValue(`${name}_item`, items, variant, rand, index + position, depth + 1, `${pointer}/items`, seen, operationId));
-            }
-            case "object":
-                return generateObject(concrete, variant, rand, index, depth + 1, pointer, seen, operationId);
-            default:
-                return undefined;
-        }
-    }
-    catch (error) {
-        if (isOverflowError(error))
-            throw overflowFrom(error, operationId, pointer);
-        throw error;
-    }
-}
-function generateString(name, schema, variant, index) {
-    const maxLength = typeof schema.maxLength === "number" ? schema.maxLength : undefined;
-    const minLength = typeof schema.minLength === "number" ? schema.minLength : undefined;
-    if (minLength !== undefined && maxLength !== undefined && minLength > maxLength)
-        return undefined;
-    const max = maxLength ?? Math.max(64, minLength ?? 0);
-    const format = typeof schema.format === "string" ? schema.format.toLowerCase() : "";
-    const pattern = typeof schema.pattern === "string" ? schema.pattern : undefined;
-    let text;
-    if (format === "email")
-        text = emailOf(variant, index);
-    else if (format === "uri" || format === "url")
-        text = uriOf(variant, index);
-    else if (format === "uuid")
-        text = uuidOf(variant, index);
-    else if (pattern !== undefined)
-        text = stringMatching(pattern, max, variant, index, minLength);
-    else if (variant === "boundary")
-        text = "B".repeat(Math.max(1, Math.min(max, 512)));
-    else {
-        const base = STRINGS[variant];
-        text = `${base} ${index}`;
-    }
-    if (text === undefined)
-        return undefined;
-    if (codePointCount(text) > max) {
-        if (format === "email" || format === "uri" || format === "url" || format === "uuid" || pattern !== undefined) {
-            const trimmed = fitMax(text, max, format, pattern, variant, index, minLength);
-            if (trimmed === undefined)
-                return undefined;
-            text = trimmed;
-        }
-        else {
-            text = sliceCodePoints(text, max);
-        }
-    }
-    if (minLength !== undefined && codePointCount(text) < minLength) {
-        const padded = padToMin(text, minLength, max, pattern);
-        if (padded !== undefined)
-            text = padded;
-        else if (pattern !== undefined)
-            text = stringMatching(pattern, max, variant, index, minLength);
-        else
-            return undefined;
-        if (text === undefined)
-            return undefined;
-    }
-    if (pattern !== undefined && !safeTest(pattern, text)) {
-        return stringMatching(pattern, max, variant, index, minLength);
-    }
-    if (format === "email" && !EMAIL_RE.test(text))
-        return undefined;
-    void name;
-    return text;
-}
-function padToMin(text, min, max, pattern) {
-    const n = codePointCount(text);
-    if (n >= min)
-        return text;
-    if (min > max)
-        return undefined;
-    const last = n === 0 ? "a" : ([...text].at(-1) ?? "a");
-    const need = min - n;
-    if (n + need > max)
-        return undefined;
-    const padded = text + last.repeat(need);
-    if (pattern !== undefined && !safeTest(pattern, padded))
-        return undefined;
-    return padded;
-}
-function requiredFallback(raw, variant, index) {
-    if (isVacuous(raw) || raw === false || raw === null || typeof raw !== "object")
-        return scalarFor("field", variant, index, undefined);
-    const schema = raw;
-    const format = typeof schema.format === "string" ? schema.format.toLowerCase() : "";
-    const pattern = typeof schema.pattern === "string" ? schema.pattern : undefined;
-    if (format === "email" || format === "uri" || format === "url" || format === "uuid" || pattern !== undefined) {
-        return generateString("field", schema, variant, index);
-    }
-    switch (typeOf(concreteBranch(schema, 0, "/", new WeakSet(), "unknown"))) {
-        case "integer":
-        case "number":
-            return 0;
-        case "boolean":
-            return false;
-        case "array":
-            return [];
-        case "object":
-            return {};
-        default: {
-            const generated = generateString("field", schema, variant, index);
-            if (generated !== undefined)
-                return generated;
-            const min = typeof schema.minLength === "number" ? schema.minLength : undefined;
-            const max = typeof schema.maxLength === "number" ? schema.maxLength : undefined;
-            if (min !== undefined && max !== undefined && min > max)
-                return undefined;
-            return "value";
-        }
-    }
-}
-function emailOf(variant, index) {
-    const slug = slugVariant(variant);
-    return `oat-${slug}-${index}@example.test`;
-}
-function uriOf(variant, index) {
-    return `https://example.test/${slugVariant(variant)}-${index}`;
-}
-function uuidOf(variant, index) {
-    const n = (slugVariant(variant).length * 17 + index * 7919) >>> 0;
-    const hex = (offset, width) => {
-        let out = "";
-        let x = (n + offset * 0x9e3779b9) >>> 0;
-        for (let i = 0; i < width; i++) {
-            out += (x & 0xf).toString(16);
-            x = (Math.imul(x, 1664525) + 1013904223) >>> 0;
-        }
-        return out;
-    };
-    return `${hex(1, 8)}-${hex(2, 4)}-4${hex(3, 3)}-8${hex(4, 3)}-${hex(5, 12)}`;
-}
-function slugVariant(variant) {
-    return variant
-        .replace(/[^a-z0-9]+/gi, "-")
-        .replace(/^-|-$/g, "")
-        .toLowerCase();
-}
-function fitMax(text, max, format, pattern, variant, index, minLength) {
-    if (format === "email") {
-        const short = `o${index}@e.t`;
-        if (short.length <= max && EMAIL_RE.test(short))
-            return short;
-        return undefined;
-    }
-    if (format === "uri" || format === "url") {
-        const short = "https://e.t/x";
-        if (short.length <= max)
-            return short;
-        return undefined;
-    }
-    if (format === "uuid")
-        return undefined;
-    if (pattern !== undefined)
-        return stringMatching(pattern, max, variant, index, minLength);
-    return text.slice(0, max);
-}
-/** Bounded attempt at a string the documented regex will accept. */
-function stringMatching(pattern, max, variant, index, minLength) {
-    const min = minLength ?? 0;
-    const candidates = [
-        expandPattern(pattern, max, variant, index, min),
-        emailOf(variant, index),
-        uriOf(variant, index),
-        uuidOf(variant, index),
-        slugVariant(variant),
-        `oat${index}`,
-        `h${index}`,
-        "a",
-        "ab",
-        "abc",
-        "handle",
-        `handle${index}`,
-        "https://example.test/x",
-        "oat@example.test",
-    ];
-    for (const candidate of candidates) {
-        if (candidate === undefined)
-            continue;
-        const text = honourBounds(candidate, min, max, pattern);
-        if (text !== undefined)
-            return text;
-    }
-    for (let attempt = 0; attempt < PATTERN_ATTEMPTS; attempt++) {
-        const text = brutePattern(pattern, max, variant, index + attempt, min);
-        if (text !== undefined) {
-            const honoured = honourBounds(text, min, max, pattern);
-            if (honoured !== undefined)
-                return honoured;
-        }
-    }
-    return undefined;
-}
-function honourBounds(candidate, min, max, pattern) {
-    let text = candidate.length > max ? candidate.slice(0, max) : candidate;
-    if (min > 0 && text.length < min) {
-        const padded = padToMin(text, min, max, pattern);
-        if (padded === undefined)
-            return undefined;
-        text = padded;
-    }
-    if (text.length < min || text.length > max)
-        return undefined;
-    if (!safeTest(pattern, text))
-        return undefined;
-    return text;
-}
-function safeTest(pattern, text) {
-    try {
-        return new RegExp(pattern).test(text);
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Expand a small, common subset of regexes (`[a-z0-9_]+`, `^handle$`, optional groups). Anything
- * we cannot expand is left for the candidate list — better to omit than to send a junk string.
- */
-function expandPattern(pattern, max, variant, index, min) {
-    let source = pattern;
-    if (source.startsWith("^"))
-        source = source.slice(1);
-    if (source.endsWith("$"))
-        source = source.slice(0, -1);
-    try {
-        let built = expandAtoms(source, max, variant, index);
-        if (min > 0 && built.length < min) {
-            const padded = padToMin(built, min, max, undefined);
-            if (padded !== undefined)
-                built = padded;
-        }
-        if (built.length > max)
-            return built.slice(0, max);
-        return built;
-    }
-    catch {
-        return undefined;
-    }
-}
-function expandAtoms(source, max, variant, index) {
-    let i = 0;
-    let out = "";
-    const takeQuantifier = () => {
-        if (source[i] === "+") {
-            i++;
-            return { max: 3, min: 1 };
-        }
-        if (source[i] === "*") {
-            i++;
-            return { max: 2, min: 0 };
-        }
-        if (source[i] === "?") {
-            i++;
-            return { max: 1, min: 0 };
-        }
-        if (source[i] === "{") {
-            const close = source.indexOf("}", i);
-            if (close < 0)
-                return { max: 1, min: 1 };
-            const spec = source.slice(i + 1, close);
-            i = close + 1;
-            const [lo, hi] = spec.split(",");
-            const min = Number.parseInt(lo ?? "1", 10);
-            const upper = hi === undefined ? min : hi === "" ? min + 2 : Number.parseInt(hi, 10);
-            if (!Number.isFinite(min) || !Number.isFinite(upper))
-                return { max: 1, min: 1 };
-            return { max: Math.min(upper, 16), min: Math.max(0, min) };
-        }
-        return { max: 1, min: 1 };
-    };
-    const emit = (atom, times) => {
-        for (let n = 0; n < times && out.length < max; n++)
-            out += atom;
-    };
-    while (i < source.length && out.length < max) {
-        const ch = source[i];
-        if (ch === undefined)
-            break;
-        if (ch === "(") {
-            const close = matchingParen(source, i);
-            if (close < 0)
-                break;
-            const inner = source.slice(i + 1, close).replace(/^\?:/, "");
-            i = close + 1;
-            const q = takeQuantifier();
-            const piece = expandAtoms(inner.split("|")[0] ?? inner, max, variant, index);
-            emit(piece, Math.max(q.min, Math.min(q.max, q.min === 0 ? 0 : 1)));
-            continue;
-        }
-        if (ch === "[") {
-            const close = source.indexOf("]", i + 1);
-            if (close < 0)
-                break;
-            const atom = firstClassChar(source.slice(i + 1, close));
-            i = close + 1;
-            const q = takeQuantifier();
-            emit(atom, Math.max(q.min, 1));
-            continue;
-        }
-        if (ch === "\\") {
-            const next = source[i + 1];
-            i += 2;
-            const atom = next === "d" ? "0" : next === "w" ? "a" : next === "s" ? " " : (next ?? "a");
-            const q = takeQuantifier();
-            emit(atom, Math.max(q.min, 1));
-            continue;
-        }
-        if (ch === ".") {
-            i++;
-            const q = takeQuantifier();
-            emit("a", Math.max(q.min, 1));
-            continue;
-        }
-        if (ch === "|" || ch === ")" || ch === "^" || ch === "$") {
-            i++;
-            continue;
-        }
-        i++;
-        const q = takeQuantifier();
-        emit(ch, Math.max(q.min, 1));
-    }
-    void variant;
-    void index;
-    return out;
-}
-function matchingParen(source, start) {
-    let depth = 0;
-    for (let i = start; i < source.length; i++) {
-        if (source[i] === "(")
-            depth++;
-        else if (source[i] === ")") {
-            depth--;
-            if (depth === 0)
-                return i;
-        }
-    }
-    return -1;
-}
-function firstClassChar(body) {
-    let i = 0;
-    if (body[0] === "^")
-        i = 1;
-    while (i < body.length) {
-        const ch = body[i];
-        if (ch === undefined)
-            break;
-        if (ch === "\\" && body[i + 1] !== undefined) {
-            const next = body[i + 1];
-            if (next === "d")
-                return "0";
-            if (next === "w")
-                return "a";
-            return next ?? "a";
-        }
-        if (body[i + 1] === "-" && body[i + 2] !== undefined) {
-            return ch === "^" ? (body[i + 2] ?? "a") : ch;
-        }
-        if (ch !== "^")
-            return ch;
-        i++;
-    }
-    return "a";
-}
-function brutePattern(pattern, max, variant, salt, min = 0) {
-    const alphabet = "abcdefghijklmnopqrstuvwxyz0123456789_-";
-    const len = Math.min(Math.max(Math.max(3, min), (salt % 8) + 3), max);
-    let text = "";
-    let x = (salt * 1664525 + slugVariant(variant).length) >>> 0;
-    for (let i = 0; i < len; i++) {
-        text += alphabet[x % alphabet.length];
-        x = (Math.imul(x, 22695477) + 1) >>> 0;
-    }
-    return text;
-}
-function scalarFor(name, variant, index, schema) {
-    if (schema !== undefined) {
-        const generated = generateString(name, schema, variant, index);
-        if (generated !== undefined)
-            return generated;
-    }
-    const base = STRINGS[variant];
-    return `${base} ${index}`;
-}
-/**
- * `{}` / `true` / a lone `additionalProperties: {}` is "any JSON", not an object to descend.
- * Walking it again is what turns `z.unknown()` into a stack overflow.
- */
-export function isVacuous(schema) {
-    if (schema === true)
-        return true;
-    if (schema === false || schema === null || typeof schema !== "object")
-        return false;
-    if (Array.isArray(schema))
-        return false;
-    const keys = Object.keys(schema).filter((key) => !isAnnotation(key));
-    if (keys.length === 0)
-        return true;
-    if (keys.length === 1 && (keys[0] === "additionalProperties" || keys[0] === "unevaluatedProperties")) {
-        return isVacuous(schema[keys[0]]);
-    }
-    if (keys.length === 1 && keys[0] === "default") {
-        const value = schema.default;
-        return (value !== null && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length === 0);
-    }
-    return false;
-}
-function isAnnotation(key) {
-    return (key === "description" ||
-        key === "title" ||
-        key === "deprecated" ||
-        key === "example" ||
-        key === "examples" ||
-        key === "nullable" ||
-        key === "readOnly" ||
-        key === "writeOnly" ||
-        key === "xml" ||
-        key === "externalDocs");
-}
-/** `oneOf: [{type: string}, {type: null}]` is the nullable idiom; pick the non-null branch. */
-function concreteBranch(schema, depth, pointer, seen, operationId) {
-    if (depth > MAX_DEPTH)
-        return {};
-    const followed = followRef(schema, depth, pointer, seen, operationId);
-    const base = followed === "cycle" ? {} : (followed ?? schema);
-    if (typeof base !== "object" || base === null)
-        return {};
-    const union = base.oneOf ?? base.anyOf;
-    if (!Array.isArray(union))
-        return base;
-    const branch = union.find((candidate) => {
-        if (candidate === null || typeof candidate !== "object")
-            return candidate !== null;
-        return candidate.type !== "null";
-    });
-    if (branch === null || typeof branch !== "object")
-        return base;
-    if (seen.has(branch))
-        return {};
-    return concreteBranch(branch, depth + 1, `${pointer}/oneOf`, seen, operationId);
-}
-function followRef(schema, depth, pointer, seen, operationId) {
-    void pointer;
-    void operationId;
-    if (depth > MAX_DEPTH)
-        return "cycle";
-    const ref = schema.$ref;
-    if (typeof ref !== "string")
-        return null;
-    /* After inlining, leftover `$ref: "#"` (or any self-ref) is the same node. Do not follow. */
-    if (ref === "#" || ref === "#/" || seen.has(schema))
-        return "cycle";
-    return "cycle";
-}
-function isNullable(schema) {
-    if (schema.nullable === true)
-        return true;
-    const type = schema.type;
-    if (Array.isArray(type))
-        return type.includes("null");
-    const union = schema.oneOf ?? schema.anyOf;
-    if (!Array.isArray(union))
-        return false;
-    return union.some((candidate) => candidate !== null && typeof candidate === "object" && candidate.type === "null");
-}
-function typeOf(schema) {
-    if (isVacuous(schema))
-        return "string";
-    const add = schema.additionalProperties;
-    const uneval = schema.unevaluatedProperties;
-    if (schema.type === undefined &&
-        schema.properties === undefined &&
-        schema.items === undefined &&
-        (isVacuous(add) || isVacuous(uneval))) {
-        return "object";
-    }
-    const type = schema.type;
-    if (typeof type === "string")
-        return type;
-    if (Array.isArray(type)) {
-        const concrete = type.find((t) => t !== "null");
-        if (typeof concrete === "string")
-            return concrete;
-    }
-    if (schema.properties !== undefined)
-        return "object";
-    if (schema.items !== undefined || schema.prefixItems !== undefined)
-        return "array";
-    return "string";
-}
-function escapePointer(name) {
-    return name.replace(/~/g, "~0").replace(/\//g, "~1");
-}
 //# sourceMappingURL=fixture.js.map