@workerstack/testing 0.0.0-stage → 0.31.0

package/dist/api/runtime/generate/identifiers.d.ts

@@ -0,0 +1,14 @@
+/** Values a probe sends where a record would be named or filtered on, chosen to name nothing. */
+import type { Generated } from "./types.ts";
+/**
+ * An identifier that is well-formed for `schema` and names nothing: a UUID where the API takes
+ * UUIDs, an integer where it takes integers. Comparing a malformed probe against a real one
+ * compares a 400 with a 404 and reads the difference as a leak.
+ */
+export declare function absentIdentifier(schema: unknown, nonce: string): Generated;
+/**
+ * A value of the field's own type that no record is likely to hold — the probe for "is this
+ * declared filter accepted at all". A string where the field is a string, a number where it is one.
+ */
+export declare function filterSentinel(schema: unknown, nonce: string): Generated;
+//# sourceMappingURL=identifiers.d.ts.map

package/dist/api/runtime/generate/identifiers.js

@@ -0,0 +1,64 @@
+/** Values a probe sends where a record would be named or filtered on, chosen to name nothing. */
+import { isObject, typesOf } from "./algebra.js";
+import { uuidFrom } from "./format.js";
+import { generate } from "./generate.js";
+import { nonceNumber } from "./nonce.js";
+function tokenFits(token, schema) {
+    if (typeof schema.minLength === "number" && token.length < schema.minLength)
+        return false;
+    if (typeof schema.maxLength === "number" && token.length > schema.maxLength)
+        return false;
+    if (typeof schema.pattern !== "string")
+        return true;
+    try {
+        return new RegExp(schema.pattern, "u").test(token);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * An identifier that is well-formed for `schema` and names nothing: a UUID where the API takes
+ * UUIDs, an integer where it takes integers. Comparing a malformed probe against a real one
+ * compares a 400 with a 404 and reads the difference as a leak.
+ */
+export function absentIdentifier(schema, nonce) {
+    const s = isObject(schema) ? schema : {};
+    const types = typesOf(s);
+    if (types.includes("integer") || types.includes("number")) {
+        const hi = typeof s.maximum === "number" ? s.maximum : 2_147_483_647;
+        const value = Math.max(typeof s.minimum === "number" ? s.minimum : 1, hi - (nonceNumber(nonce) % 1000));
+        return { ok: true, value: Number.isInteger(value) ? value : Math.floor(value) };
+    }
+    const format = typeof s.format === "string" ? s.format : undefined;
+    if (format === "uuid")
+        return { ok: true, value: uuidFrom(`absent:${nonce}`) };
+    /* A string identity with a format of its own (an email, a date) is made in that format. */
+    if (format !== undefined)
+        return generate({ ...s, format }, { distinct: new Set(), index: 9001, nonce });
+    /* Otherwise one token, plainly the API tester's: a value made to look like data (`Quarterly Report 9001`)
+     * is no identifier anyone issues. A schema the token cannot meet leaves the probe without one. */
+    if (Array.isArray(s.enum))
+        return { ok: false, pointer: "/", reason: "an enumerated identity names only records that may exist" };
+    const token = `testing-absent-${nonceNumber(nonce).toString(36)}`;
+    return tokenFits(token, s)
+        ? { ok: true, value: token }
+        : { ok: false, pointer: "/", reason: "no single token meets the identity's pattern or length" };
+}
+/**
+ * A value of the field's own type that no record is likely to hold — the probe for "is this
+ * declared filter accepted at all". A string where the field is a string, a number where it is one.
+ */
+export function filterSentinel(schema, nonce) {
+    const s = isObject(schema) ? schema : {};
+    if (Array.isArray(s.enum) && s.enum.length > 0)
+        return { ok: true, value: s.enum.at(-1) };
+    const types = typesOf(s);
+    if (types.includes("boolean"))
+        return { ok: true, value: true };
+    if (types.includes("integer") || types.includes("number"))
+        return absentIdentifier(s, nonce);
+    const wrapped = generate({ properties: { value: s }, required: ["value"], type: "object" }, { distinct: new Set(["value"]), index: 4242, nonce, variant: "lexical-last" });
+    return wrapped.ok ? { ok: true, value: wrapped.value["value"] } : wrapped;
+}
+//# sourceMappingURL=identifiers.js.map

package/dist/api/runtime/generate/instance.d.ts

@@ -0,0 +1,4 @@
+/** The walk: one value for a schema, descending through its keywords. */
+import type { At } from "./types.ts";
+export declare function instance(raw: unknown, at: At): unknown;
+//# sourceMappingURL=instance.d.ts.map

package/dist/api/runtime/generate/instance.js

@@ -0,0 +1,59 @@
+/** The walk: one value for a schema, descending through its keywords. */
+import { isObject, isVacuous, mergeAll, typesOf } from "./algebra.js";
+import { arrayFor } from "./array.js";
+import { enumOf, unionOf, viaRef } from "./branches.js";
+import { numberFor } from "./number.js";
+import { objectFor } from "./object.js";
+import { stringFor } from "./string.js";
+import { text } from "./text.js";
+import { Unconstructible } from "./unconstructible.js";
+const MAX_DEPTH = 12;
+/** A value of the schema's first non-null type. */
+function typed(schema, at) {
+    const { ctx, pointer } = at;
+    const types = typesOf(schema);
+    if (ctx.variant === "null-heavy" && types.includes("null"))
+        return null;
+    const type = types.find((item) => item !== "null");
+    if (type === undefined)
+        return null;
+    const next = { ...ctx, depth: ctx.depth + 1 };
+    switch (type) {
+        case "string":
+            return stringFor(schema, at);
+        case "integer":
+        case "number":
+            return numberFor(schema, at, type === "integer");
+        case "boolean":
+            return ctx.index % 2 === 0;
+        case "array":
+            return arrayFor(schema, { ...at, ctx: next }, instance);
+        case "object":
+            return objectFor(schema, { ...at, ctx: next }, instance);
+        default:
+            throw new Unconstructible(`unknown type "${type}"`, pointer);
+    }
+}
+export function instance(raw, at) {
+    const { ctx, distinct, pointer } = at;
+    if (ctx.depth > MAX_DEPTH)
+        throw new Unconstructible("the schema nests too deeply to generate", pointer);
+    if (raw === false)
+        throw new Unconstructible("the schema admits no value (false)", pointer);
+    if (raw === true || isVacuous(raw))
+        return text(ctx, distinct);
+    if (!isObject(raw))
+        throw new Unconstructible("the schema is not an object", pointer);
+    if (typeof raw.$ref === "string")
+        return viaRef(raw, at, instance);
+    const schema = raw.allOf === undefined ? raw : mergeAll(raw, pointer);
+    if ("const" in schema)
+        return schema.const;
+    const union = (schema.oneOf ?? schema.anyOf);
+    if (Array.isArray(union) && union.length > 0)
+        return unionOf(schema, at, instance);
+    if (Array.isArray(schema.enum))
+        return enumOf(schema.enum, ctx, pointer);
+    return typed(schema, at);
+}
+//# sourceMappingURL=instance.js.map

package/dist/api/runtime/generate/nonce.d.ts

@@ -0,0 +1,3 @@
+/** A nonce folded into a non-negative 32-bit number, for values that must be numeric. */
+export declare function nonceNumber(nonce: string): number;
+//# sourceMappingURL=nonce.d.ts.map

package/dist/api/runtime/generate/nonce.js

@@ -0,0 +1,8 @@
+/** A nonce folded into a non-negative 32-bit number, for values that must be numeric. */
+export function nonceNumber(nonce) {
+    let h = 0;
+    for (const ch of nonce)
+        h = (Math.imul(h, 31) + ch.charCodeAt(0)) >>> 0;
+    return h;
+}
+//# sourceMappingURL=nonce.js.map

package/dist/api/runtime/generate/number.d.ts

@@ -0,0 +1,5 @@
+/** A number or integer within the schema's bounds and step. */
+import type { JsonSchema } from "../../spec/types.ts";
+import type { At } from "./types.ts";
+export declare function numberFor(schema: JsonSchema, at: At, integer: boolean): number;
+//# sourceMappingURL=number.d.ts.map

package/dist/api/runtime/generate/number.js

@@ -0,0 +1,64 @@
+/** A number or integer within the schema's bounds and step. */
+import { nonceNumber } from "./nonce.js";
+import { Unconstructible } from "./unconstructible.js";
+function boundsOf(schema, integer) {
+    const step = typeof schema.multipleOf === "number" && schema.multipleOf > 0 ? schema.multipleOf : integer ? 1 : 0;
+    const exclusiveLo = typeof schema.exclusiveMinimum === "number" ? schema.exclusiveMinimum : undefined;
+    const exclusiveHi = typeof schema.exclusiveMaximum === "number" ? schema.exclusiveMaximum : undefined;
+    const lo = Math.max(typeof schema.minimum === "number" ? schema.minimum : Number.NEGATIVE_INFINITY, exclusiveLo ?? Number.NEGATIVE_INFINITY);
+    const hi = Math.min(typeof schema.maximum === "number" ? schema.maximum : Number.POSITIVE_INFINITY, exclusiveHi ?? Number.POSITIVE_INFINITY);
+    return { exclusiveHi, exclusiveLo, hi, integer, lo, step };
+}
+function admits(b, value) {
+    return (value >= b.lo &&
+        value <= b.hi &&
+        (b.exclusiveLo === undefined || value > b.exclusiveLo) &&
+        (b.exclusiveHi === undefined || value < b.exclusiveHi) &&
+        (!b.integer || Number.isInteger(value)) &&
+        (b.step === 0 || Math.abs(value / b.step - Math.round(value / b.step)) < 1e-9));
+}
+function snap(step, value, direction) {
+    if (step === 0)
+        return value;
+    const units = direction === "up" ? Math.ceil(value / step - 1e-9) : Math.floor(value / step + 1e-9);
+    return Number((units * step).toFixed(10));
+}
+/* A ladder whose lexical order differs from its numeric order (1, 10, 100, 2, 20, 5, 50 as
+ * text), so a backend comparing numbers as strings is visibly wrong. */
+const LADDER = [1, 2, 5, 10, 20, 50, 100];
+function preferredOf(b, at) {
+    const { ctx, distinct } = at;
+    const rung = LADDER[ctx.index % LADDER.length] ?? 1;
+    const origin = Number.isFinite(b.lo) ? b.lo : 0;
+    const fraction = b.integer ? 0 : Math.round(ctx.rand() * 9) / 10;
+    const offset = distinct && ctx.nonce !== undefined ? nonceNumber(ctx.nonce) % 997 : 0;
+    if (ctx.variant === "boundary" && Number.isFinite(b.hi))
+        return b.hi;
+    if (ctx.variant === "boundary" && Number.isFinite(b.lo))
+        return b.lo;
+    return origin + rung + fraction + offset * Math.max(b.step, 1);
+}
+export function numberFor(schema, at, integer) {
+    const b = boundsOf(schema, integer);
+    const preferred = preferredOf(b, at);
+    const { lo, hi, step } = b;
+    const clamped = Math.min(Math.max(preferred, lo), hi);
+    const base = Number.isFinite(lo) ? lo : 0;
+    const candidates = [
+        snap(step, clamped, "up"),
+        snap(step, clamped, "down"),
+        snap(step, lo, "up"),
+        snap(step, hi, "down"),
+        snap(step, base + (Number.isFinite(hi) ? (hi - base) / 2 : 1), "up"),
+    ];
+    /* An integer always has a step (1 at least), so only a number is nudged by a half. */
+    const nudge = step || 0.5;
+    for (const candidate of candidates) {
+        if (Number.isFinite(candidate) && admits(b, candidate))
+            return candidate;
+        if (Number.isFinite(candidate) && admits(b, candidate + nudge))
+            return candidate + nudge;
+    }
+    throw new Unconstructible(`no ${integer ? "integer" : "number"} satisfies the bounds`, at.pointer);
+}
+//# sourceMappingURL=number.js.map

package/dist/api/runtime/generate/object.d.ts

@@ -0,0 +1,4 @@
+import type { JsonSchema } from "../../spec/types.ts";
+import type { At, Walk } from "./types.ts";
+export declare function objectFor(schema: JsonSchema, at: At, walk: Walk): Record<string, unknown>;
+//# sourceMappingURL=object.d.ts.map

package/dist/api/runtime/generate/object.js

@@ -0,0 +1,31 @@
+import { isObject } from "./algebra.js";
+import { text } from "./text.js";
+import { Unconstructible } from "./unconstructible.js";
+export function objectFor(schema, at, walk) {
+    const { ctx, pointer } = at;
+    const properties = isObject(schema.properties) ? schema.properties : {};
+    const required = new Set(Array.isArray(schema.required) ? schema.required : []);
+    const out = {};
+    for (const [name, sub] of Object.entries(properties)) {
+        if (!required.has(name) && ctx.optional === "none")
+            continue;
+        const child = `${pointer}/${name.replace(/~/g, "~0").replace(/\//g, "~1")}`;
+        const distinct = pointer === "" && ctx.distinct.has(name);
+        try {
+            out[name] = walk(sub, { ctx, distinct, pointer: child });
+        }
+        catch (error) {
+            /* An optional property that cannot be made is left out; a required one cannot be. */
+            if (!(error instanceof Unconstructible) || required.has(name))
+                throw error;
+        }
+    }
+    for (const name of required) {
+        if (Object.hasOwn(out, name))
+            continue;
+        /* Required but undescribed: any value satisfies the schema. */
+        out[name] = text(ctx, false);
+    }
+    return out;
+}
+//# sourceMappingURL=object.js.map

package/dist/api/runtime/generate/pattern.d.ts

@@ -0,0 +1,9 @@
+/** Strings for a documented `pattern`: a bounded search over likely candidates. */
+import type { At } from "./types.ts";
+export declare function matches(pattern: string, value: string): boolean;
+/** A bounded search for a string the documented pattern accepts. */
+export declare function matching(pattern: string, length: {
+    min: number;
+    max: number;
+}, at: At): string | undefined;
+//# sourceMappingURL=pattern.d.ts.map

package/dist/api/runtime/generate/pattern.js

@@ -0,0 +1,46 @@
+/** Strings for a documented `pattern`: a bounded search over likely candidates. */
+import { codePointCount } from "../payloads.js";
+import { expand } from "./expand.js";
+import { uuidFrom } from "./format.js";
+import { slug } from "./text.js";
+export function matches(pattern, value) {
+    try {
+        return new RegExp(pattern, "u").test(value);
+    }
+    catch {
+        return false;
+    }
+}
+/** A bounded search for a string the documented pattern accepts. */
+export function matching(pattern, length, at) {
+    const { ctx, distinct } = at;
+    const { min, max } = length;
+    const suffix = distinct && ctx.nonce !== undefined ? ctx.nonce : String(ctx.index);
+    const fromPattern = expand(pattern, ctx.index);
+    const candidates = [
+        fromPattern === undefined ? undefined : `${fromPattern}${suffix}`,
+        fromPattern,
+        `testing${suffix}`,
+        `a${suffix}`,
+        suffix,
+        `testing-${suffix}`,
+        `testing_${suffix}`,
+        `TESTING_API${suffix}`,
+        "a",
+        "abc",
+        `testing-${slug(ctx.variant)}-${suffix}@example.test`,
+        `https://example.test/${suffix}`,
+        uuidFrom(`${ctx.variant}:${suffix}`),
+    ];
+    for (const candidate of candidates) {
+        if (candidate === undefined)
+            continue;
+        for (const sized of [candidate, candidate.slice(0, max), candidate.padEnd(min, candidate.at(-1) ?? "a")]) {
+            const n = codePointCount(sized);
+            if (n >= min && n <= max && matches(pattern, sized))
+                return sized;
+        }
+    }
+    return undefined;
+}
+//# sourceMappingURL=pattern.js.map

package/dist/api/runtime/generate/probes.d.ts

@@ -0,0 +1,9 @@
+/** Values a write probe sends: another valid value, or one just outside what the schema allows. */
+import type { GenerateOptions, Generated } from "./types.ts";
+/** A valid value that differs from `other` — the value a write probe changes a field to. */
+export declare function distinctValue(schema: unknown, other: unknown, options?: GenerateOptions): Generated;
+/** A value of the right type outside the declared enum, or why there is none. */
+export declare function outsideEnum(schema: unknown): Generated;
+/** A string one character longer than `maxLength` allows, or why there is none. */
+export declare function overMaxLength(schema: unknown): Generated;
+//# sourceMappingURL=probes.d.ts.map

package/dist/api/runtime/generate/probes.js

@@ -0,0 +1,36 @@
+/** Values a write probe sends: another valid value, or one just outside what the schema allows. */
+import { isObject } from "./algebra.js";
+import { generate } from "./generate.js";
+/** A valid value that differs from `other` — the value a write probe changes a field to. */
+export function distinctValue(schema, other, options = {}) {
+    const base = options.index ?? 0;
+    for (let index = base + 1; index < base + 12; index++) {
+        const result = generate(schema, { ...options, index });
+        if (!result.ok)
+            return result;
+        if (JSON.stringify(result.value) !== JSON.stringify(other))
+            return result;
+    }
+    return { ok: false, pointer: "/", reason: "the schema admits no value different from the current one" };
+}
+/** A value of the right type outside the declared enum, or why there is none. */
+export function outsideEnum(schema) {
+    if (!isObject(schema) || !Array.isArray(schema.enum))
+        return { ok: false, pointer: "/", reason: "no enum declared" };
+    const values = schema.enum;
+    if (values.every((value) => typeof value === "number")) {
+        return { ok: true, value: Math.max(...values) + 1 };
+    }
+    let candidate = "testing-not-in-enum";
+    while (values.includes(candidate))
+        candidate = `${candidate}-x`;
+    return { ok: true, value: candidate };
+}
+/** A string one character longer than `maxLength` allows, or why there is none. */
+export function overMaxLength(schema) {
+    if (!isObject(schema) || typeof schema.maxLength !== "number") {
+        return { ok: false, pointer: "/", reason: "no maxLength declared" };
+    }
+    return { ok: true, value: "x".repeat(schema.maxLength + 1) };
+}
+//# sourceMappingURL=probes.js.map

package/dist/api/runtime/generate/string-constraints.d.ts

@@ -0,0 +1,19 @@
+/**
+ * What a string schema asks of a value, `allOf` and a nullable union folded in, and whether a value
+ * meets it. The one answer generation, the self probe and the concurrency check give to "does this
+ * field take this string": a guard pattern a document sets on every string costs nothing when the
+ * value meets it.
+ */
+import type { JsonSchema } from "../../spec/types.ts";
+export interface StringConstraints {
+    minLength: number;
+    maxLength: number;
+    /** Every pattern the value must match, each unanchored and compiled with the `u` flag. */
+    patterns: string[];
+    format?: string;
+    enum?: unknown[];
+}
+export declare function stringConstraints(schema: JsonSchema): StringConstraints;
+/** Whether `value` is within the lengths, in code points, and matches every pattern. */
+export declare function admits(constraints: StringConstraints, value: string): boolean;
+//# sourceMappingURL=string-constraints.d.ts.map

package/dist/api/runtime/generate/string-constraints.js

@@ -0,0 +1,48 @@
+/**
+ * What a string schema asks of a value, `allOf` and a nullable union folded in, and whether a value
+ * meets it. The one answer generation, the self probe and the concurrency check give to "does this
+ * field take this string": a guard pattern a document sets on every string costs nothing when the
+ * value meets it.
+ */
+import { codePointCount } from "../payloads.js";
+import { isObject, merge, mergeAll } from "./algebra.js";
+import { matches } from "./pattern.js";
+/* A union whose one branch is not `null` is that branch, with what sits beside the union. */
+function nonNull(schema) {
+    const branches = Array.isArray(schema.anyOf) ? schema.anyOf : Array.isArray(schema.oneOf) ? schema.oneOf : null;
+    if (branches === null)
+        return schema;
+    const kept = branches.filter((branch) => isObject(branch) && branch.type !== "null");
+    const only = kept.length === 1 ? kept[0] : undefined;
+    if (!isObject(only))
+        return schema;
+    const { anyOf: _anyOf, oneOf: _oneOf, ...beside } = schema;
+    return nonNull(merge(beside, only));
+}
+function folded(schema) {
+    const one = nonNull(schema);
+    return Array.isArray(one.allOf) ? mergeAll(one, "") : one;
+}
+export function stringConstraints(schema) {
+    const flat = folded(schema);
+    const residual = Array.isArray(flat.allOf) ? flat.allOf : [];
+    const patterns = [flat.pattern, ...residual.filter(isObject).map((branch) => branch.pattern)];
+    const out = {
+        maxLength: typeof flat.maxLength === "number" ? flat.maxLength : Number.POSITIVE_INFINITY,
+        minLength: typeof flat.minLength === "number" ? flat.minLength : 0,
+        patterns: patterns.filter((pattern) => typeof pattern === "string"),
+    };
+    if (typeof flat.format === "string")
+        out.format = flat.format;
+    if (Array.isArray(flat.enum))
+        out.enum = flat.enum;
+    return out;
+}
+/** Whether `value` is within the lengths, in code points, and matches every pattern. */
+export function admits(constraints, value) {
+    const length = codePointCount(value);
+    if (length < constraints.minLength || length > constraints.maxLength)
+        return false;
+    return constraints.patterns.every((pattern) => matches(pattern, value));
+}
+//# sourceMappingURL=string-constraints.js.map

package/dist/api/runtime/generate/string.d.ts

@@ -0,0 +1,5 @@
+/** A string value within the schema's length, format and pattern. */
+import type { JsonSchema } from "../../spec/types.ts";
+import type { At } from "./types.ts";
+export declare function stringFor(schema: JsonSchema, at: At): string;
+//# sourceMappingURL=string.d.ts.map

package/dist/api/runtime/generate/string.js

@@ -0,0 +1,80 @@
+/** A string value within the schema's length, format and pattern. */
+import { codePointCount, sliceCodePoints } from "../payloads.js";
+import { formatted } from "./format.js";
+import { matching } from "./pattern.js";
+import { admits, stringConstraints } from "./string-constraints.js";
+import { text } from "./text.js";
+import { Unconstructible } from "./unconstructible.js";
+function padFormatted(format, value, min) {
+    const short = min - codePointCount(value);
+    if (short <= 0)
+        return value;
+    if (format === "email" || format === "idn-email")
+        return value.replace("@", `${"x".repeat(short)}@`);
+    if (format.startsWith("uri") || format.startsWith("iri") || format === "url")
+        return `${value}${"x".repeat(short)}`;
+    if (format === "hostname" || format === "idn-hostname")
+        return `${"x".repeat(Math.min(short, 60))}${value}`;
+    return value;
+}
+/* A short address or URL can be lengthened without leaving its format; a date cannot. */
+function inFormat(format, constraints, at) {
+    const unpadded = formatted(format, at.ctx, at.distinct);
+    if (unpadded === undefined)
+        return undefined;
+    const { minLength: min, maxLength: max, patterns } = constraints;
+    const known = padFormatted(format, unpadded, min);
+    if (codePointCount(known) > max || codePointCount(known) < min) {
+        throw new Unconstructible(`a ${format} cannot fit length ${min}–${max}`, at.pointer);
+    }
+    if (!admits(constraints, known)) {
+        throw new Unconstructible(`a ${format} cannot match pattern ${patterns.join(" and ")}`, at.pointer);
+    }
+    return known;
+}
+/* The first string some pattern's search finds that every pattern and both lengths admit. */
+function searched(constraints, at) {
+    const length = { max: constraints.maxLength, min: constraints.minLength };
+    for (const pattern of constraints.patterns) {
+        const candidate = matching(pattern, length, at);
+        if (candidate !== undefined && admits(constraints, candidate))
+            return candidate;
+    }
+    return undefined;
+}
+/** The variant's text, cut to `max` or padded to `min`. */
+function plain(min, max, at) {
+    const { ctx, distinct } = at;
+    let value = ctx.variant === "boundary" ? "B".repeat(Math.max(1, Math.min(max, 512))) : text(ctx, distinct);
+    if (codePointCount(value) > max) {
+        /* Keep the distinguishing tail when shortening: the index and nonce are what make it unique. */
+        const tail = distinct && ctx.nonce !== undefined ? ` ${ctx.nonce}` : ` ${ctx.index}`;
+        value =
+            codePointCount(tail) < max
+                ? sliceCodePoints(value, max - codePointCount(tail)) + tail
+                : sliceCodePoints(value, max);
+    }
+    if (codePointCount(value) < min)
+        value = value + "x".repeat(min - codePointCount(value));
+    return value;
+}
+export function stringFor(schema, at) {
+    const constraints = stringConstraints(schema);
+    const { minLength: min, maxLength: max, patterns } = constraints;
+    if (min > max)
+        throw new Unconstructible(`minLength ${min} exceeds maxLength ${max}`, at.pointer);
+    const format = typeof schema.format === "string" ? schema.format.toLowerCase() : undefined;
+    const known = format === undefined ? undefined : inFormat(format, constraints, at);
+    if (known !== undefined)
+        return known;
+    /* Realistic text first: a pattern that admits it, such as a guard on every string, changes nothing. */
+    const realistic = plain(min, max, at);
+    if (admits(constraints, realistic))
+        return realistic;
+    const candidate = searched(constraints, at);
+    if (candidate === undefined) {
+        throw new Unconstructible(`no string found for pattern ${patterns.join(" and ")}`, at.pointer);
+    }
+    return candidate;
+}
+//# sourceMappingURL=string.js.map

package/dist/api/runtime/generate/text.d.ts

@@ -0,0 +1,6 @@
+import type { Context, Variant } from "./types.ts";
+/** A variant's name as a URL- and address-safe token. */
+export declare function slug(variant: Variant): string;
+/** The variant's text with the cohort index, and the nonce when the value must be distinct. */
+export declare function text(ctx: Context, distinct: boolean): string;
+//# sourceMappingURL=text.d.ts.map

package/dist/api/runtime/generate/text.js

@@ -0,0 +1,20 @@
+import { UNICODE_COHORT_STRING } from "../payloads.js";
+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,
+};
+/** A variant's name as a URL- and address-safe token. */
+export function slug(variant) {
+    return variant.replace(/[^a-z0-9]+/gi, "-").toLowerCase();
+}
+/** The variant's text with the cohort index, and the nonce when the value must be distinct. */
+export function text(ctx, distinct) {
+    const base = `${STRINGS[ctx.variant]} ${ctx.index}`;
+    return distinct && ctx.nonce !== undefined ? `${base} ${ctx.nonce}` : base;
+}
+//# sourceMappingURL=text.js.map

package/dist/api/runtime/generate/types.d.ts

@@ -0,0 +1,45 @@
+/** The shapes value generation works in: schemas, cohort variants, options, results and the walk. */
+import type { JsonSchema } from "../../spec/types.ts";
+export type Variant = "baseline" | "lexical-first" | "lexical-last" | "null-heavy" | "unicode" | "metacharacter" | "boundary";
+export interface GenerateOptions {
+    variant?: Variant;
+    /** Position in a cohort. Different indexes give different values wherever the schema allows. */
+    index?: number;
+    rand?: () => number;
+    /** Recursive schemas a document refers to as `testing-defs#/$defs/<name>`. */
+    defs?: Record<string, JsonSchema>;
+    /** Per-run token mixed into values that must not collide with an earlier run's. */
+    nonce?: string;
+    /** Property names, at the top level, whose values must be distinct across runs too. */
+    distinct?: ReadonlySet<string>;
+    /** Optional properties to leave out. A cohort sends them; a probe built on top need not. */
+    optional?: "all" | "none";
+}
+export type Generated = {
+    ok: true;
+    value: unknown;
+} | {
+    ok: false;
+    reason: string;
+    pointer: string;
+};
+export interface Context {
+    variant: Variant;
+    index: number;
+    rand: () => number;
+    defs: Record<string, JsonSchema>;
+    nonce: string | undefined;
+    distinct: ReadonlySet<string>;
+    optional: "all" | "none";
+    refs: string[];
+    depth: number;
+}
+/** Where the walk stands: its context, the JSON pointer it is at, and whether the value must be distinct. */
+export interface At {
+    ctx: Context;
+    pointer: string;
+    distinct: boolean;
+}
+/** The walk itself, handed to the parts that recurse so none of them imports it back. */
+export type Walk = (raw: unknown, at: At) => unknown;
+//# sourceMappingURL=types.d.ts.map

package/dist/api/runtime/generate/types.js

@@ -0,0 +1,3 @@
+/** The shapes value generation works in: schemas, cohort variants, options, results and the walk. */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/api/runtime/generate/unconstructible.d.ts

@@ -0,0 +1,7 @@
+/** Why no value can be made for a schema, and where in it: the one failure generation reports. */
+export declare class Unconstructible extends Error {
+    readonly reason: string;
+    readonly pointer: string;
+    constructor(reason: string, pointer: string);
+}
+//# sourceMappingURL=unconstructible.d.ts.map

package/dist/api/runtime/generate/unconstructible.js

@@ -0,0 +1,11 @@
+/** Why no value can be made for a schema, and where in it: the one failure generation reports. */
+export class Unconstructible extends Error {
+    reason;
+    pointer;
+    constructor(reason, pointer) {
+        super(reason);
+        this.reason = reason;
+        this.pointer = pointer;
+    }
+}
+//# sourceMappingURL=unconstructible.js.map