fix(experimental): keep bare null/literals in v.union inference

FieldOut/FieldIn fell through to never for non-schema arms, so
v.union([user, null]) typed as User only. Preserve F, and map bare
literals through asType so runtime validation matches.

Author: ping-maxwell

packages/experimental/src/schema-dx.test.ts

@@ -208,4 +208,46 @@ describe("v.union", () => {
 			expect(err.issues.length).toBeGreaterThanOrEqual(2);
 		}
 	});
+
+	it("preserves bare null (and other literals) in the inferred union", () => {
+		const user = v.var("union_user", {
+			schema: v.object({ id: v.string(), name: v.string() }),
+		});
+		const field = v.union([user, null]);
+		expectTypeOf<InferOutput<typeof field>>().toEqualTypeOf<{
+			id: string;
+			name: string;
+		} | null>();
+		expectTypeOf<InferArgs<typeof field>>().toEqualTypeOf<{
+			id: string;
+			name: string;
+		} | null>();
+		expect(validate(field, null, "x")).toBeNull();
+		expect(validate(field, { id: "1", name: "a" }, "x")).toEqual({
+			id: "1",
+			name: "a",
+		});
+
+		const literals = v.union([null, "idle", 0] as const);
+		expectTypeOf<InferOutput<typeof literals>>().toEqualTypeOf<
+			null | "idle" | 0
+		>();
+		expect(validate(literals, null, "x")).toBeNull();
+		expect(validate(literals, "idle", "x")).toBe("idle");
+		expect(validate(literals, 0, "x")).toBe(0);
+		expect(() => validate(literals, "busy", "x")).toThrow(/expected/);
+	});
+
+	it("fn output: v.union([var, null]) accepts a handler that returns null", () => {
+		const user = v.var("union_out_user", {
+			schema: v.object({ id: v.string() }),
+		});
+		const find = v.fn(
+			"union.find",
+			{ output: v.union([user, null]) },
+			(_c) => null,
+		);
+		expectTypeOf(find).returns.toEqualTypeOf<{ id: string } | null>();
+		expect(find()).toBeNull();
+	});
 });

packages/experimental/src/schema.ts

@@ -229,14 +229,16 @@ export const outputContract = (
 };
 
 /**
- * One input field, in four flavours:
+ * One input field, in five flavours:
  *  - a `v.var()`, whose shape comes from the var's own `schema`
  *  - a handler-less `v.fn(...)` builder, which types the field as a FN
  *  - a type from `v.string()` / `v.object()` / ...
  *  - a bare nested record, which recurses
+ *  - anything else (e.g. `null`, `"lit"`) kept as itself - so
+ *    `v.union([user, null])` infers `User | null`, not just `User`
  *
- * The record case has to come last: a TypeDefination is itself a record,
- * and so is a builder.
+ * The record case has to come after TypeDefination: a TypeDefination is
+ * itself a record, and so is a builder.
  */
 type FieldOut<F> = F extends { $var: true; schema?: infer S }
 	? InferInput<NonNullable<S>>
@@ -246,7 +248,7 @@ type FieldOut<F> = F extends { $var: true; schema?: infer S }
 			? OutputOf<F>
 			: F extends Record<string, unknown>
 				? Prettify<{ [K in keyof F]: FieldOut<F[K]> }>
-				: never;
+				: F;
 
 type FieldIn<F> = F extends { $var: true; schema?: infer S }
 	? InferArgs<NonNullable<S>>
@@ -256,7 +258,7 @@ type FieldIn<F> = F extends { $var: true; schema?: infer S }
 			? T
 			: F extends Record<string, unknown>
 				? ArgsShape<F>
-				: never;
+				: F;
 
 /**
  * `optional: true` on `v.fn.type` widens the same way a type's `optional`
@@ -359,7 +361,21 @@ export const asType = (value: any): TypeDefination<any, any> =>
 				} as TypeDefination<any, any>)
 			: isType(value)
 				? value
-				: { name: "object", shape: value };
+				: // Bare literals in `v.union([schema, null])` / `["a", "b"]`:
+					// map to a type whose `name` matches `typeOf`, with `enum`
+					// pinning the exact value for string/number/boolean.
+					value === null
+					? ({ name: "null" } as TypeDefination<null, null>)
+					: value === undefined
+						? ({ name: "undefined" } as TypeDefination<undefined, undefined>)
+						: typeof value === "string" ||
+								typeof value === "number" ||
+								typeof value === "boolean"
+							? ({
+									name: typeof value,
+									enum: [value],
+								} as TypeDefination<any, any>)
+							: { name: "object", shape: value };
 
 /**
  * Replace the whole `$attrs` bag. On a var, rebinds `customize` so a later