@fuzdev/fuz_app 0.147.0 → 0.149.0

package/dist/testing/schema_generators.js

@@ -12,34 +12,78 @@ import { z } from 'zod';
 import { zod_unwrap_def, zod_get_base_type, zod_unwrap_to_object, zod_extract_fields } from '../zod.js';
 import { is_null_schema } from '../http/schema_helpers.js';
 /**
- * Detect format constraints on a field by converting to JSON Schema.
- * Returns format string (e.g. 'uuid', 'email') or null.
+ * The JSON Schema of a field's input side — where its format, pattern and
+ * bounds live — or `null` when JSON Schema can't render the field or any part
+ * of it (`z.date()`, `z.custom()`, a union with a `z.date()` branch).
+ *
+ * Rendered with `io: 'input'`, so a field carrying a `.transform()` or a pipe
+ * (`Username`) still yields the constraints its input is checked against;
+ * the default output side throws on a transform. A pipe yields its input
+ * side only, so constraints of the stage after it are not here. A
+ * `.nullable()` / `.nullish()` field renders as
+ * `anyOf: [{…}, {type: 'null'}]`; its one non-null branch is returned, so
+ * the bounds and pattern read the same as on the bare field. A union of two
+ * or more non-null branches returns the whole schema — its branches' bounds
+ * are no single field's bounds.
+ *
+ * A `.refine()` is never here: JSON Schema can't express one, so a bound a
+ * refinement enforces (a code-point length, a cross-field rule) generates no
+ * boundary case.
+ *
+ * @param field_schema - the field to read
+ * @returns the field's input-side JSON Schema, or `null` when it can't be rendered
  */
-export const detect_format = (field_schema) => {
+export const to_field_json_schema = (field_schema) => {
+    let json;
     try {
-        const json = z.toJSONSchema(field_schema);
-        if (typeof json.format === 'string')
-            return json.format;
-        if (typeof json.pattern === 'string')
-            return 'pattern';
-        // `.nullish()` / `.nullable()` produce `anyOf: [{format, …}, {type: 'null'}]`
-        // — descend into the first non-null branch so format/pattern surface.
-        if (Array.isArray(json.anyOf)) {
-            for (const branch of json.anyOf) {
-                if (branch.type === 'null')
-                    continue;
-                if (typeof branch.format === 'string')
-                    return branch.format;
-                if (typeof branch.pattern === 'string')
-                    return 'pattern';
-            }
-        }
+        json = z.toJSONSchema(field_schema, { io: 'input' });
     }
     catch {
-        // schema can't be converted, no format
+        return null; // a type JSON Schema can't represent
+    }
+    if (Array.isArray(json.anyOf)) {
+        const branches = json.anyOf.filter((branch) => branch.type !== 'null');
+        if (branches.length === 1)
+            return branches[0];
+    }
+    return json;
+};
+/**
+ * The format constraint a field's input-side JSON Schema carries: its
+ * `format` (e.g. `'uuid'`, `'email'`), `'pattern'` for a regex, or `null`.
+ * A union (`anyOf` of several non-null branches) answers its first branch
+ * carrying one — a value violating every branch is what the caller needs,
+ * and the generators check the field refuses the candidate.
+ *
+ * @param json - a field's JSON Schema, as `to_field_json_schema` returns it
+ * @returns the format, `'pattern'`, or `null`
+ */
+export const detect_json_schema_format = (json) => {
+    if (typeof json.format === 'string')
+        return json.format;
+    if (typeof json.pattern === 'string')
+        return 'pattern';
+    if (Array.isArray(json.anyOf)) {
+        for (const branch of json.anyOf) {
+            if (branch.type === 'null')
+                continue;
+            if (typeof branch.format === 'string')
+                return branch.format;
+            if (typeof branch.pattern === 'string')
+                return 'pattern';
+        }
     }
     return null;
 };
+/**
+ * Detect format constraints on a field from its input-side JSON Schema
+ * (`to_field_json_schema`). Returns the format string (e.g. `'uuid'`,
+ * `'email'`), `'pattern'` for a regex, or `null`.
+ */
+export const detect_format = (field_schema) => {
+    const json = to_field_json_schema(field_schema);
+    return json && detect_json_schema_format(json);
+};
 /**
  * Extract a candidate value from a JSON Schema `pattern` when the shape is a
  * fixed-length hex character class, optionally behind a literal prefix —
@@ -110,8 +154,8 @@ const generate_valid_string = (field_schema) => {
     let min_length = 0;
     let max_length = Infinity;
     let pattern = null;
-    try {
-        const json = z.toJSONSchema(field_schema);
+    const json = to_field_json_schema(field_schema);
+    if (json) {
         if (typeof json.minLength === 'number')
             min_length = json.minLength;
         if (typeof json.maxLength === 'number')
@@ -119,9 +163,6 @@ const generate_valid_string = (field_schema) => {
         if (typeof json.pattern === 'string')
             pattern = json.pattern;
     }
-    catch {
-        // no constraints
-    }
     const target = Math.max(min_length, Math.min(10, max_length));
     const base = 'x'.repeat(target) || 'test_value';
     // Validate against the full schema (including refinements/brands).
@@ -155,6 +196,10 @@ const generate_valid_string = (field_schema) => {
     const as_url = 'https://example.com/' + base;
     if (field_schema.safeParse(as_url).success)
         return as_url;
+    // Two-segment path refinement (an `owner/name` repo slug)
+    const segments = `${base}/${base}`;
+    if (field_schema.safeParse(segments).success)
+        return segments;
     return base; // fall through — generate_valid_body will report the failure
 };
 /** Generate a valid-ish value for a field based on its base type. */
@@ -174,20 +219,30 @@ export const generate_valid_value = (field, field_schema) => {
                 return '2020-01-01T00:00:00.000Z';
             return generate_valid_string(field_schema);
         case 'number':
-        case 'int':
-            return 1;
+        case 'int': {
+            // 1, unless the schema's bounds rule it out (`.negative()`, `.min(10)`)
+            for (const candidate of [1, -1, 0]) {
+                if (field_schema.safeParse(candidate).success)
+                    return candidate;
+            }
+            const json = to_field_json_schema(field_schema);
+            if (json) {
+                if (typeof json.minimum === 'number')
+                    return Math.ceil(json.minimum);
+                if (typeof json.exclusiveMinimum === 'number')
+                    return Math.floor(json.exclusiveMinimum) + 1;
+                if (typeof json.maximum === 'number')
+                    return Math.floor(json.maximum);
+                if (typeof json.exclusiveMaximum === 'number')
+                    return Math.ceil(json.exclusiveMaximum) - 1;
+            }
+            return 1; // fall through — generate_valid_body will report the failure
+        }
         case 'boolean':
             return true;
         case 'array': {
-            let min_items = 0;
-            try {
-                const json = z.toJSONSchema(field_schema);
-                if (typeof json.minItems === 'number')
-                    min_items = json.minItems;
-            }
-            catch {
-                // no constraint
-            }
+            const json = to_field_json_schema(field_schema);
+            const min_items = typeof json?.minItems === 'number' ? json.minItems : 0;
             if (min_items === 0)
                 return [];
             const def = zod_unwrap_def(field_schema);
@@ -202,18 +257,13 @@ export const generate_valid_value = (field, field_schema) => {
             return Array.from({ length: min_items }, () => item);
         }
         case 'object': {
-            // Recursively generate valid nested objects
+            // recurse with the same optional-field fallback as the top level, so a
+            // nested `.refine()` over optional fields (exactly-one-of) is satisfied;
+            // a nested object that still fails is returned as built, and the
+            // top-level parse reports it
             const nested_schema = zod_unwrap_to_object(field_schema);
-            if (nested_schema) {
-                const nested_fields = zod_extract_fields(nested_schema);
-                const nested = {};
-                for (const nf of nested_fields) {
-                    if (!nf.required && !nf.has_default)
-                        continue;
-                    nested[nf.name] = generate_valid_value(nf, nested_schema.shape[nf.name]);
-                }
-                return nested;
-            }
+            if (nested_schema)
+                return generate_valid_object(nested_schema, field_schema).value;
             return {};
         }
         case 'null':
@@ -264,6 +314,166 @@ export const generate_valid_value = (field, field_schema) => {
             return 'test_value';
     }
 };
+/**
+ * Generate a valid object for an object schema: its required and defaulted
+ * fields first; when `schema` still refuses it, each optional field alone on
+ * top of those, in declaration order, taking the first that parses; and
+ * failing that, the optional fields added one at a time, in declaration
+ * order, until it parses. The fill covers a `.refine()` over optional fields
+ * (at least one of, exactly one of, both of), which the required-only object
+ * can't satisfy, and the single-field pass keeps an unrelated optional field
+ * declared ahead of the refined ones (an `acting`, a note) out of the object.
+ *
+ * Shared by the top-level body generators and `generate_valid_value`'s
+ * nested-object case, so a refined object validates the same way at any depth.
+ *
+ * @param object_schema - the unwrapped object whose fields are generated
+ * @param schema - the schema the object must satisfy, refinements included
+ *   (`object_schema` or a schema wrapping it)
+ * @returns the generated object and its last `safeParse` result — the caller
+ *   decides whether a failure throws
+ */
+export const generate_valid_object = (object_schema, schema) => {
+    const base = {};
+    const optional = [];
+    for (const field of zod_extract_fields(object_schema)) {
+        const value = generate_valid_value(field, object_schema.shape[field.name]);
+        if (is_optional_field(field))
+            optional.push([field.name, value]);
+        else
+            base[field.name] = value;
+    }
+    return fill_optional_fields(schema, base, optional);
+};
+/** A field the object may omit — optional and without a default Zod fills. */
+const is_optional_field = (field) => !field.required && !field.has_default;
+/**
+ * `start` as is when `schema` accepts it; else `start` plus each candidate
+ * alone, in order, taking the first that parses; else the candidates added
+ * one at a time, in order, until it parses.
+ *
+ * @param schema - the schema the object must satisfy
+ * @param start - the fields every result keeps
+ * @param candidates - optional fields and their values, in declaration order
+ * @returns the object and its last `safeParse` result
+ */
+const fill_optional_fields = (schema, start, candidates) => {
+    let result = schema.safeParse(start);
+    if (result.success)
+        return { value: start, result };
+    // each optional field alone, so one the refinement doesn't need stays out
+    for (const [name, field_value] of candidates) {
+        const value = { ...start, [name]: field_value };
+        const single_result = schema.safeParse(value);
+        if (single_result.success)
+            return { value, result: single_result };
+    }
+    // then cumulatively, for a refinement needing several
+    const value = { ...start };
+    for (const [name, field_value] of candidates) {
+        value[name] = field_value;
+        result = schema.safeParse(value);
+        if (result.success)
+            break;
+    }
+    return { value, result };
+};
+/**
+ * A valid object that carries `field`, built from `base`, a valid object of
+ * `object_schema` — the body a case breaking `field` changes, so the case
+ * breaks that field and nothing else. `base` itself when it carries the
+ * field. Otherwise the field takes a generated value and joins `base`, with
+ * the optional fields `base` omits filled as `generate_valid_object` fills
+ * them (a pair rule: adding `scope_kind` needs `scope_id`); failing that, it
+ * replaces `base`'s optional fields, refilled the same way around it (an
+ * exactly-one-of rule: adding `slug` means dropping `id`).
+ *
+ * @param object_schema - the unwrapped object `base` is an instance of
+ * @param schema - the schema the object must satisfy, refinements included
+ * @param base - a valid object, the generated or seeded base
+ * @param field - the field the object must carry
+ * @returns the object, or `null` when no object the generator can build
+ *   carries the field and passes `schema`
+ */
+export const generate_valid_object_with_field = (object_schema, schema, base, field) => {
+    if (Object.hasOwn(base, field.name))
+        return base;
+    const fields = zod_extract_fields(object_schema);
+    const value_of = (f) => Object.hasOwn(base, f.name)
+        ? base[f.name]
+        : generate_valid_value(f, object_schema.shape[f.name]);
+    const field_value = value_of(field);
+    // the field joins the base, which keeps its optional fields
+    const absent = fields
+        .filter((f) => f.name !== field.name && is_optional_field(f) && !Object.hasOwn(base, f.name))
+        .map((f) => [f.name, value_of(f)]);
+    const joined = fill_optional_fields(schema, { ...base, [field.name]: field_value }, absent);
+    if (joined.result.success)
+        return joined.value;
+    // the field in place of the base's optional fields, which are refilled around it
+    const optional_names = new Set(fields.filter(is_optional_field).map((f) => f.name));
+    const core = {};
+    for (const [k, v] of Object.entries(base)) {
+        if (!optional_names.has(k))
+            core[k] = v;
+    }
+    core[field.name] = field_value;
+    const others = fields
+        .filter((f) => f.name !== field.name && is_optional_field(f))
+        .map((f) => [f.name, value_of(f)]);
+    const replaced = fill_optional_fields(schema, core, others);
+    return replaced.result.success ? replaced.value : null;
+};
+const NIL_UUID = '00000000-0000-0000-0000-000000000000';
+/**
+ * A string a URL-sourced field accepts — a route param or a query value, which
+ * arrive as strings whatever the schema parses them into. The nil UUID for a
+ * UUID field; else the first the field accepts of `test_value`, the generated
+ * valid value written as a string, `1`, `0`, `true` and `false`, the field's
+ * JSON Schema `default` or lower bound written as a string (a preprocessed
+ * integer whose minimum is above one), and a string synthesized from the
+ * field's constraints.
+ *
+ * @param field - the field's info, from `zod_extract_fields`
+ * @param field_schema - the field's schema
+ * @returns the string, or `null` when no candidate passes
+ */
+export const generate_valid_string_param = (field, field_schema) => {
+    const candidates = [];
+    if (field.base_type === 'uuid' || detect_format(field_schema) === 'uuid') {
+        candidates.push(NIL_UUID);
+    }
+    candidates.push('test_value');
+    const generated = generate_valid_value(field, field_schema);
+    if (typeof generated === 'string' ||
+        typeof generated === 'number' ||
+        typeof generated === 'boolean') {
+        candidates.push(String(generated));
+    }
+    candidates.push('1', '0', 'true', 'false');
+    // a number the URL string is preprocessed into: its default or its lower bound
+    const json = to_field_json_schema(field_schema);
+    if (json) {
+        const fallback = json.default;
+        if (typeof fallback === 'number' || typeof fallback === 'string') {
+            candidates.push(String(fallback));
+        }
+        if (typeof json.minimum === 'number')
+            candidates.push(String(Math.ceil(json.minimum)));
+        if (typeof json.exclusiveMinimum === 'number') {
+            candidates.push(String(Math.floor(json.exclusiveMinimum) + 1));
+        }
+    }
+    candidates.push(generate_valid_string(field_schema));
+    return candidates.find((c) => field_schema.safeParse(c).success) ?? null;
+};
+/**
+ * Format Zod issues as `path: message` pairs for a generator's error message.
+ *
+ * @param error - the failed parse's error
+ * @returns the issues, comma-separated
+ */
+export const format_zod_issues = (error) => error.issues.map((i) => `${i.path.join('.')}: ${i.message}`).join(', ');
 /**
  * The `Content-Type` a well-formed request to a route sends: `application/json`,
  * or `application/octet-stream` for a `raw_body` route. Every `POST` route
@@ -331,32 +541,10 @@ export const generate_valid_body = (input_schema) => {
     const object_schema = zod_unwrap_to_object(input_schema);
     if (!object_schema)
         return undefined;
-    const fields = zod_extract_fields(object_schema);
-    const body = {};
-    for (const field of fields) {
-        if (!field.required && !field.has_default)
-            continue;
-        body[field.name] = generate_valid_value(field, object_schema.shape[field.name]);
-    }
-    let result = input_schema.safeParse(body);
-    if (!result.success) {
-        // Fallback for schemas with a top-level `.refine()` that requires at
-        // least one of N optional fields. Fill optional fields until the body
-        // satisfies validation.
-        for (const field of fields) {
-            if (field.required || field.has_default || field.name in body)
-                continue;
-            body[field.name] = generate_valid_value(field, object_schema.shape[field.name]);
-            result = input_schema.safeParse(body);
-            if (result.success)
-                break;
-        }
-    }
+    const { value, result } = generate_valid_object(object_schema, input_schema);
     if (!result.success) {
         throw new Error(`generate_valid_body: generated body fails validation — ` +
-            `fix generate_valid_value for: ${result.error.issues
-                .map((i) => `${i.path.join('.')}: ${i.message}`)
-                .join(', ')}`);
+            `fix generate_valid_value for: ${format_zod_issues(result.error)}`);
     }
-    return body;
+    return value;
 };

package/dist/testing/standard.d.ts

@@ -21,6 +21,7 @@ import type { RoleSchemaResult } from '../auth/role_schema.js';
 import type { BootstrapServerOptions } from '../server/app_server.js';
 import type { AppServerContext } from '../server/app_server_context.js';
 import type { RouteSpec } from '../http/route_spec.js';
+import { type RpcSuccessFixtures } from './rpc_round_trip.js';
 import type { RpcEndpointsSuiteOption } from './rpc_helpers.js';
 import type { BackendCapabilities } from './cross_backend/capabilities.js';
 import type { SetupTest } from './cross_backend/setup.js';
@@ -85,6 +86,31 @@ export interface StandardTestOptions {
     error_coverage_min?: number;
     /** Override the bootstrap-success suite's synthetic token. */
     bootstrap_token?: string;
+    /**
+     * Forwarded to `describe_rpc_round_trip_tests` as `success_fixtures`
+     * (method name → async params factory) — drives a populated **success**
+     * body for methods that act on an existing row, validated against the
+     * method's `output` schema. `create_spine_rpc_success_fixtures`
+     * (`cross_backend/rpc_success_fixtures.ts`) builds the map for the
+     * standard spine methods. See `RpcRoundTripTestOptions.success_fixtures`.
+     */
+    rpc_success_fixtures?: RpcSuccessFixtures;
+    /**
+     * Forwarded to `describe_rpc_round_trip_tests` as `skip_methods` — the
+     * consumer escape hatch for a method the generic round-trip can't drive at
+     * all (a handler whose test wiring stubs out the deps it reaches, or reads
+     * tables the suite's database doesn't migrate). Each entry hides the
+     * method from both the crash check and the envelope check, so name the
+     * reason beside it.
+     */
+    rpc_skip_methods?: Array<string>;
+    /**
+     * Forwarded to `describe_rpc_round_trip_tests` as `input_overrides`
+     * (method name → params) — for a method whose generated params can't
+     * reach its handler cleanly. The response is held to the same rules as a
+     * generated one.
+     */
+    rpc_input_overrides?: Map<string, Record<string, unknown>>;
 }
 /**
  * Run the full standard test bundle — integration, admin (when `roles`

package/dist/testing/standard.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"standard.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/testing/standard.ts"],"names":[],"mappings":"AAAA,OAAO,qBAAqB,CAAC;AAE7B;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAChE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAC;AACtE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AACxE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AASvD,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,kBAAkB,CAAC;AAChE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AAC3E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAEvD;;GAEG;AACH,MAAM,WAAW,mBAAmB;IACnC,2CAA2C;IAC3C,UAAU,EAAE,SAAS,CAAC;IACtB;;;OAGG;IACH,cAAc,EAAE,cAAc,CAAC;IAC/B;;;;OAIG;IACH,YAAY,EAAE,mBAAmB,CAAC;IAClC,uFAAuF;IACvF,eAAe,EAAE,cAAc,CAAC,MAAM,CAAC,CAAC;IACxC;;;;;OAKG;IACH,kBAAkB,EAAE,CAAC,GAAG,EAAE,gBAAgB,KAAK,KAAK,CAAC,SAAS,CAAC,CAAC;IAChE;;;;;OAKG;IACH,aAAa,EAAE,uBAAuB,CAAC;IACvC;;;OAGG;IACH,KAAK,CAAC,EAAE,gBAAgB,CAAC;IACzB;;;;OAIG;IACH,SAAS,CAAC,EAAE,sBAAsB,CAAC;IACnC,sEAAsE;IACtE,yBAAyB,CAAC,EAAE,eAAe,CAAC;IAC5C;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,8DAA8D;IAC9D,eAAe,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,GAAI,SAAS,mBAAmB,KAAG,IAsDtE,CAAC"}
+{"version":3,"file":"standard.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/testing/standard.ts"],"names":[],"mappings":"AAAA,OAAO,qBAAqB,CAAC;AAE7B;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAChE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAC;AACtE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AACxE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAKvD,OAAO,EAAiC,KAAK,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAI7F,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,kBAAkB,CAAC;AAChE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AAC3E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAEvD;;GAEG;AACH,MAAM,WAAW,mBAAmB;IACnC,2CAA2C;IAC3C,UAAU,EAAE,SAAS,CAAC;IACtB;;;OAGG;IACH,cAAc,EAAE,cAAc,CAAC;IAC/B;;;;OAIG;IACH,YAAY,EAAE,mBAAmB,CAAC;IAClC,uFAAuF;IACvF,eAAe,EAAE,cAAc,CAAC,MAAM,CAAC,CAAC;IACxC;;;;;OAKG;IACH,kBAAkB,EAAE,CAAC,GAAG,EAAE,gBAAgB,KAAK,KAAK,CAAC,SAAS,CAAC,CAAC;IAChE;;;;;OAKG;IACH,aAAa,EAAE,uBAAuB,CAAC;IACvC;;;OAGG;IACH,KAAK,CAAC,EAAE,gBAAgB,CAAC;IACzB;;;;OAIG;IACH,SAAS,CAAC,EAAE,sBAAsB,CAAC;IACnC,sEAAsE;IACtE,yBAAyB,CAAC,EAAE,eAAe,CAAC;IAC5C;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,8DAA8D;IAC9D,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;;;;;OAOG;IACH,oBAAoB,CAAC,EAAE,kBAAkB,CAAC;IAC1C;;;;;;;OAOG;IACH,gBAAgB,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACjC;;;;;OAKG;IACH,mBAAmB,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CAC3D;AAED;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,GAAI,SAAS,mBAAmB,KAAG,IAyDtE,CAAC"}

package/dist/testing/standard.js

@@ -30,7 +30,10 @@ export const describe_standard_tests = (options) => {
         setup_test: options.setup_test,
         surface_source: options.surface_source,
         session_options: options.session_options,
-        rpc_endpoints: options.rpc_endpoints
+        rpc_endpoints: options.rpc_endpoints,
+        skip_methods: options.rpc_skip_methods,
+        input_overrides: options.rpc_input_overrides,
+        success_fixtures: options.rpc_success_fixtures
     });
     describe_data_exposure_tests({
         setup_test: options.setup_test,

package/dist/testing/stubs.d.ts

@@ -64,9 +64,10 @@ export declare const stub_mw: (_c: any, next: any) => Promise<void>;
  * wires a listener fails loudly instead of silently never firing
  * (`create_recording_audit_emitter` accepts listeners); `listener_count`
  * returns 0; `drain_inflight` resolves immediately, since nothing is ever
- * written. Tests asserting on real audit-row persistence (or on listener
- * fan-out) build a real emitter via `create_audit_emitter` against a stub or
- * real DB — `create_test_app` already does this on the test backend.
+ * written, and `is_tracking_inflight` answers `false`. Tests asserting on
+ * real audit-row persistence (or on listener fan-out) build a real emitter
+ * via `create_audit_emitter` against a stub or real DB — `create_test_app`
+ * already does this on the test backend.
  */
 export declare const create_test_audit_emitter: () => AuditEmitter;
 /**

package/dist/testing/stubs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stubs.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/testing/stubs.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"stubs.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/testing/stubs.ts"],"names":[],"mappings":"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"}

package/dist/testing/stubs.js

@@ -102,9 +102,10 @@ const stub_db = create_noop_stub('stub_db');
  * wires a listener fails loudly instead of silently never firing
  * (`create_recording_audit_emitter` accepts listeners); `listener_count`
  * returns 0; `drain_inflight` resolves immediately, since nothing is ever
- * written. Tests asserting on real audit-row persistence (or on listener
- * fan-out) build a real emitter via `create_audit_emitter` against a stub or
- * real DB — `create_test_app` already does this on the test backend.
+ * written, and `is_tracking_inflight` answers `false`. Tests asserting on
+ * real audit-row persistence (or on listener fan-out) build a real emitter
+ * via `create_audit_emitter` against a stub or real DB — `create_test_app`
+ * already does this on the test backend.
  */
 export const create_test_audit_emitter = () => ({
     emit: () => { },
@@ -115,7 +116,8 @@ export const create_test_audit_emitter = () => ({
         throw new Error('create_test_audit_emitter accepts no listeners — use create_recording_audit_emitter');
     },
     listener_count: () => 0,
-    drain_inflight: async () => { }
+    drain_inflight: async () => { },
+    is_tracking_inflight: () => false
 });
 /**
  * Build a no-op `AuditLogSse` for tests that wire `audit_sse` into the

package/dist/testing/transports/raw_http.d.ts

@@ -1,4 +1,11 @@
 import '../assert_dev_env.js';
+/**
+ * The read window a raw exchange gets by default in the cross suites. The
+ * server holds every byte it will get when the wait starts, so a backend that
+ * answers on what it has answers at once, and one that waits for more runs the
+ * whole window.
+ */
+export declare const RAW_HTTP_READ_TIMEOUT_MS = 2000;
 /** What a raw exchange read back, and how it ended. */
 export interface RawHttpExchange {
     /** Every byte the server sent, `latin1`-decoded. */
@@ -53,6 +60,20 @@ export interface RawHttpResponse {
  * @param request_bytes - the bytes to send, `latin1`-encoded
  */
 export declare const raw_http_exchange: (base_url: string, request_bytes: string, options: RawHttpExchangeOptions) => Promise<RawHttpExchange>;
+/**
+ * Render request headers as raw HTTP/1.1 header lines, each ending in CRLF.
+ *
+ * @param headers - header names to values, sent in iteration order
+ * @returns the lines, concatenated
+ */
+export declare const raw_http_header_lines: (headers: Record<string, string>) => string;
+/**
+ * Parse a response body as JSON.
+ *
+ * @param body - the body text
+ * @returns the parsed value, or `undefined` when the body is not JSON
+ */
+export declare const raw_http_parse_json: (body: string) => unknown;
 /**
  * Count HTTP response status lines in a raw byte stream. Deliberately
  * **unanchored** (no `^`/`m`): a second pipelined response is concatenated

package/dist/testing/transports/raw_http.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"raw_http.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/transports/raw_http.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAuB9B,uDAAuD;AACvD,MAAM,WAAW,eAAe;IAC/B,oDAAoD;IACpD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B;;;;OAIG;IACH,QAAQ,CAAC,gBAAgB,EAAE,OAAO,CAAC;CACnC;AAED,uCAAuC;AACvC,MAAM,WAAW,sBAAsB;IACtC,uDAAuD;IACvD,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,GAAG,UAAU,CAAC;CACtC;AAED,oCAAoC;AACpC,MAAM,WAAW,eAAe;IAC/B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,gFAAgF;IAChF,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACnD,2DAA2D;IAC3D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,iBAAiB,GAC7B,UAAU,MAAM,EAChB,eAAe,MAAM,EACrB,SAAS,sBAAsB,KAC7B,OAAO,CAAC,eAAe,CAwBvB,CAAC;AAEJ;;;;;;;GAOG;AACH,eAAO,MAAM,wBAAwB,GAAI,KAAK,MAAM,KAAG,MACN,CAAC;AAElD,0FAA0F;AAC1F,eAAO,MAAM,qBAAqB,GAAI,KAAK,MAAM,KAAG,MAAM,GAAG,IAG5D,CAAC;AAyBF;;;;;;;;;GASG;AACH,eAAO,MAAM,uBAAuB,GAAI,KAAK,MAAM,KAAG,eAAe,GAAG,IAyBvE,CAAC"}
+{"version":3,"file":"raw_http.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/transports/raw_http.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAuB9B;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,OAAO,CAAC;AAE7C,uDAAuD;AACvD,MAAM,WAAW,eAAe;IAC/B,oDAAoD;IACpD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B;;;;OAIG;IACH,QAAQ,CAAC,gBAAgB,EAAE,OAAO,CAAC;CACnC;AAED,uCAAuC;AACvC,MAAM,WAAW,sBAAsB;IACtC,uDAAuD;IACvD,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,GAAG,UAAU,CAAC;CACtC;AAED,oCAAoC;AACpC,MAAM,WAAW,eAAe;IAC/B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,gFAAgF;IAChF,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACnD,2DAA2D;IAC3D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,iBAAiB,GAC7B,UAAU,MAAM,EAChB,eAAe,MAAM,EACrB,SAAS,sBAAsB,KAC7B,OAAO,CAAC,eAAe,CAwBvB,CAAC;AAEJ;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,GAAI,SAAS,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAG,MAG7D,CAAC;AAEZ;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,GAAI,MAAM,MAAM,KAAG,OAMlD,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,wBAAwB,GAAI,KAAK,MAAM,KAAG,MACN,CAAC;AAElD,0FAA0F;AAC1F,eAAO,MAAM,qBAAqB,GAAI,KAAK,MAAM,KAAG,MAAM,GAAG,IAG5D,CAAC;AAyBF;;;;;;;;;GASG;AACH,eAAO,MAAM,uBAAuB,GAAI,KAAK,MAAM,KAAG,eAAe,GAAG,IAyBvE,CAAC"}

package/dist/testing/transports/raw_http.js

@@ -18,6 +18,13 @@ import '../assert_dev_env.js';
  * @module
  */
 import { connect } from 'node:net';
+/**
+ * The read window a raw exchange gets by default in the cross suites. The
+ * server holds every byte it will get when the wait starts, so a backend that
+ * answers on what it has answers at once, and one that waits for more runs the
+ * whole window.
+ */
+export const RAW_HTTP_READ_TIMEOUT_MS = 2000;
 /**
  * Open a raw TCP socket to `base_url`, write `request_bytes` once, and collect
  * what the server sends back until it closes the connection, a whole response
@@ -59,6 +66,29 @@ export const raw_http_exchange = (base_url, request_bytes, options) => new Promi
     socket.on('error', () => { }); // EPIPE/ECONNRESET on a mid-write close is expected
     socket.on('close', () => finish(true));
 });
+/**
+ * Render request headers as raw HTTP/1.1 header lines, each ending in CRLF.
+ *
+ * @param headers - header names to values, sent in iteration order
+ * @returns the lines, concatenated
+ */
+export const raw_http_header_lines = (headers) => Object.entries(headers)
+    .map(([name, value]) => `${name}: ${value}\r\n`)
+    .join('');
+/**
+ * Parse a response body as JSON.
+ *
+ * @param body - the body text
+ * @returns the parsed value, or `undefined` when the body is not JSON
+ */
+export const raw_http_parse_json = (body) => {
+    try {
+        return JSON.parse(body);
+    }
+    catch {
+        return undefined;
+    }
+};
 /**
  * Count HTTP response status lines in a raw byte stream. Deliberately
  * **unanchored** (no `^`/`m`): a second pipelined response is concatenated

package/dist/zod.d.ts

@@ -30,6 +30,15 @@ export declare const zod_get_base_type: (schema: z.ZodType) => string;
  * @returns the innermost non-wrapper schema
  */
 export declare const zod_get_innermost_type: (schema: z.ZodType) => z.ZodType;
+/**
+ * Every layer of a schema, from the schema itself through each wrapper
+ * (optional, nullable, default, transform, pipe, prefault) to the innermost
+ * non-wrapper — for reading `.meta()` a wrapper does not carry over from the
+ * schema it wraps.
+ *
+ * @returns the layers, outermost first, ending at `zod_get_innermost_type(schema)`
+ */
+export declare const zod_get_schema_layers: (schema: z.ZodType) => Array<z.ZodType>;
 /**
  * Get all property keys from an object schema, unwrapping wrappers.
  * Returns an empty array if the innermost type is not an object.

package/dist/zod.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"zod.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/zod.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAgC7B;;;;;GAKG;AACH,eAAO,MAAM,cAAc,GAAI,QAAQ,CAAC,CAAC,OAAO,KAAG,CAAC,CAAC,IAAI,CAAC,WAOzD,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,GAAI,QAAQ,CAAC,CAAC,OAAO,KAAG,MAAqC,CAAC;AAgC5F;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,GAAI,QAAQ,CAAC,CAAC,OAAO,KAAG,CAAC,CAAC,OAM5D,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,GAAI,CAAC,SAAS,CAAC,CAAC,OAAO,EACtD,QAAQ,CAAC,KACP,KAAK,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,MAAM,CAGjC,CAAC;AAaF;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,GAAI,QAAQ,CAAC,CAAC,OAAO,EAAE,KAAK,MAAM,KAAG,CAAC,CAAC,OAIvE,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,oBAAoB,GAAI,QAAQ,CAAC,CAAC,OAAO,KAAG,CAAC,CAAC,SAAS,GAAG,IAUtE,CAAC;AAIF,qEAAqE;AACrE,MAAM,WAAW,YAAY;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,OAAO,CAAC;IACrB,QAAQ,EAAE,OAAO,CAAC;CAClB;AAED;;GAEG;AACH,eAAO,MAAM,kBAAkB,GAAI,QAAQ,CAAC,CAAC,SAAS,KAAG,KAAK,CAAC,YAAY,CAa1E,CAAC"}
+{"version":3,"file":"zod.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/zod.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAgC7B;;;;;GAKG;AACH,eAAO,MAAM,cAAc,GAAI,QAAQ,CAAC,CAAC,OAAO,KAAG,CAAC,CAAC,IAAI,CAAC,WAOzD,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,GAAI,QAAQ,CAAC,CAAC,OAAO,KAAG,MAAqC,CAAC;AAgC5F;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,GAAI,QAAQ,CAAC,CAAC,OAAO,KAAG,CAAC,CAAC,OAM5D,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,GAAI,QAAQ,CAAC,CAAC,OAAO,KAAG,KAAK,CAAC,CAAC,CAAC,OAAO,CAUxE,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,GAAI,CAAC,SAAS,CAAC,CAAC,OAAO,EACtD,QAAQ,CAAC,KACP,KAAK,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,MAAM,CAGjC,CAAC;AAaF;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,GAAI,QAAQ,CAAC,CAAC,OAAO,EAAE,KAAK,MAAM,KAAG,CAAC,CAAC,OAIvE,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,oBAAoB,GAAI,QAAQ,CAAC,CAAC,OAAO,KAAG,CAAC,CAAC,SAAS,GAAG,IAUtE,CAAC;AAIF,qEAAqE;AACrE,MAAM,WAAW,YAAY;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,OAAO,CAAC;IACrB,QAAQ,EAAE,OAAO,CAAC;CAClB;AAED;;GAEG;AACH,eAAO,MAAM,kBAAkB,GAAI,QAAQ,CAAC,CAAC,SAAS,KAAG,KAAK,CAAC,YAAY,CAa1E,CAAC"}

package/dist/zod.js

@@ -104,6 +104,26 @@ export const zod_get_innermost_type = (schema) => {
     }
     return schema;
 };
+/**
+ * Every layer of a schema, from the schema itself through each wrapper
+ * (optional, nullable, default, transform, pipe, prefault) to the innermost
+ * non-wrapper — for reading `.meta()` a wrapper does not carry over from the
+ * schema it wraps.
+ *
+ * @returns the layers, outermost first, ending at `zod_get_innermost_type(schema)`
+ */
+export const zod_get_schema_layers = (schema) => {
+    const layers = [schema];
+    let s = schema;
+    while (ZOD_WRAPPER_TYPES.has(s.def.type)) {
+        const sub = zod_to_subschema(s.def);
+        if (!sub)
+            break;
+        layers.push(sub);
+        s = sub;
+    }
+    return layers;
+};
 /**
  * Get all property keys from an object schema, unwrapping wrappers.
  * Returns an empty array if the innermost type is not an object.