defer a self-naming untagged newtype member behind z.lazy, where the eager read cycled

[eburgos]

render_untagged_tuple_single took self_type_name and discarded it, so a newtype member naming the union itself was written straight into the const that declares that name. A self-recursive untagged union — the plain-JSON value shape, B(bool) | L(Vec<Self>) | M(HashMap<String, Self>) | N(f64) | S(String) — therefore emitted

const V$RawSchema = z.union([z.boolean(), z.array(V$Schema), z.record(z.string(), V$Schema), z.number(), z.string()]);
export const V$Schema: ZodType<V> = V$RawSchema;

which reads V$Schema inside its own initializer. Importing the generated bundle throws ReferenceError: Cannot access 'V$Schema' before initialization before a single value is ever parsed.

The fix

The sibling render_untagged_named already defers such a member, with a get key() { … } getter hung off the key its struct variant spells. A newtype variant carries no key to hang one off, so the deferral is the thunk the rest of the crate already answers the same problem with: the member's zod slot is wrapped by deferred_zod_operand — z.lazy(() => …) — whenever the member's type names the union itself, and left eager whenever it does not, so the indirection is paid only where the cycle is.

const V$RawSchema = z.union([z.boolean(), z.lazy(() => z.array(V$Schema)), z.lazy(() => z.record(z.string(), V$Schema)), z.number(), z.string()]);

TypeScript and the JSON document do not move: a TypeScript type names itself wherever it likes, and JSON Schema defers through $ref. The externally tagged form was never affected either — its recursion already sat inside a z.strictObject({ get … }), which is exactly the deferral a bare union member had no place to write. The #[cfg(not(feature = "zod"))] branch keeps discarding self_type_name, the way the named renderer's already does.

Coverage

A new JsonValueUnion fixture in tests/untagged_tests/tests.rs — the plain-JSON value shape — with four tests asserting:

• both recursive members render behind z.lazy (the array and the record);
• the three scalar members stay eager, with no z.lazy(() => z.string()) and friends anywhere;
• the TypeScript definition is the flat union and carries no trace of the thunk;
• a nested value ({"items":["a",true,1.5]}) round-trips through serde.

The two zod assertions were confirmed to fail with the deferral disabled and pass with it on.

Gates

just fmt, just check, just lint-all across all 68 toggles, and just test across the full feature powerset — all green. No suppressions.