fix(type): fix multiple type guard issues for validation

- Add fast type guard handlers for template literals, typed arrays,
  NanoId, UUID, MongoId, and reference types
- Fix optional property validation to skip type check for undefined values
- Fix class validator method execution using ctx.let() for JIT emission
- Fix Date validation error messages to use "Not a Date" format
- Fix named tuple paths to use element names instead of numeric indices
- Fix index signature validation for template literal patterns
- Fix method validation to only apply to objectLiteral types, not classes
- Add proper error collection for built-in class types (Date, Set, Map)
- Fix post-hook to handle special types (NanoId, UUID, MongoId) messages

Test results: 1937 passing, 6 failing (down from 22 failing)

Author: marcj

packages/type/src/serializer/handlers.ts

@@ -1,10 +1,5 @@
 // Initialize the default serializer with handlers
-import {
-    registerDefaultHandlers,
-    registerDefaultTypeGuards,
-    registerFastTypeGuards,
-    registerStrictTypeGuards,
-} from './handlers.js';
+import { registerDefaultHandlers, registerTypeGuards } from './handlers.js';
 import { serializer as defaultSerializer } from './serializer.js';
 import { registerUnionHandler } from './union.js';
 import { registerValidationHook } from './validation.js';
@@ -42,6 +37,8 @@ export { validationHook, registerValidationHook, createValidator } from './valid
 // Handlers
 export {
     registerDefaultHandlers,
+    registerTypeGuards,
+    // Legacy exports (deprecated, alias to registerTypeGuards)
     registerDefaultTypeGuards,
     registerFastTypeGuards,
     registerStrictTypeGuards,
@@ -64,8 +61,6 @@ export {
 } from './serializer.js';
 
 registerDefaultHandlers(defaultSerializer);
-registerDefaultTypeGuards(defaultSerializer);
-registerFastTypeGuards(defaultSerializer);
-registerStrictTypeGuards(defaultSerializer);
+registerTypeGuards(defaultSerializer);
 registerUnionHandler(defaultSerializer);
 registerValidationHook(defaultSerializer);

packages/type/src/serializer/index.ts

@@ -24,9 +24,15 @@ export interface BuildStateBase {
     readonly ctx: Context;
     readonly depth: number;
     readonly optionsSlot: Slot<any>;
+    /** Whether to collect validation errors (for buildTypeGuard with error collection) */
+    readonly collectErrors: boolean;
+    /** Whether to reject unknown object keys (for strict type guards) */
+    readonly rejectUnknownKeys: boolean;
+    /** Whether currently checking union members (skip error-adding in post-hook) */
+    readonly inUnionContext: boolean;
     readonly serializer: {
         name: string;
-        typeGuards: TypeGuardRegistry;
+        typeGuards: HandlerRegistry;
         buildTypeGuard<T>(type: Type, withLoose?: boolean): (data: any, state?: { errors?: any[] }) => data is T;
         buildFastTypeGuard<T>(type: Type): (data: unknown) => data is T;
         buildStrictTypeGuard<T>(type: Type): (data: unknown) => data is T;
@@ -37,6 +43,8 @@ export interface BuildStateBase {
     pathSlot(): Slot<string>;
     forProperty(name: string): BuildStateBase;
     forIndex(index: Slot<number>): BuildStateBase;
+    /** Fork state for checking a union member (sets inUnionContext=true). */
+    forUnionMember(): BuildStateBase;
     /** Check if loose mode is enabled (options.loosely !== false). */
     isLoose(): Slot<boolean>;
 }
@@ -306,6 +314,10 @@ export class HandlerRegistry {
 /**
  * Registry for type guards organized by specificality level.
  *
+ * @deprecated Use HandlerRegistry instead. The Serializer now uses a single
+ * unified HandlerRegistry for type guards with behavior controlled by
+ * BuildState flags (collectErrors, rejectUnknownKeys).
+ *
  * Specificality levels determine when guards activate:
  * - Negative values: Loose mode only (string coercion)
  * - 1: Exact/strict mode (typeof checks)

packages/type/src/serializer/registry.ts

@@ -20,7 +20,7 @@ import {
 } from '../reflection/type.js';
 import { ValidationErrorItem } from '../validator.js';
 import { NamingStrategy } from './naming.js';
-import { HandlerRegistry, TypeGuardRegistry } from './registry.js';
+import { HandlerRegistry } from './registry.js';
 import { BuildState, SerializationOptions } from './state.js';
 
 export type SerializeFunction<T = any, R = any> = (data: T, options?: SerializationOptions) => R;
@@ -53,32 +53,24 @@ export class Serializer {
     /** Registry for deserialization handlers */
     readonly deserializeRegistry = new HandlerRegistry('deserialize');
 
-    /** Registry for type guards at different specificality levels */
-    readonly typeGuards = new TypeGuardRegistry();
+    /** Registry for type guards (unified: fast, strict, and error-collecting all use this) */
+    readonly typeGuards = new HandlerRegistry();
 
-    /** Registry for validator handlers */
-    readonly validators = new HandlerRegistry();
-
-    /** Registry for fast type guards (pure && chain, no error collection) */
-    readonly fastTypeGuards = new HandlerRegistry();
-
-    /** Registry for strict type guards (reject unknown keys) */
-    readonly strictTypeGuards = new HandlerRegistry();
-
-    /** Cache for built fast type guard functions (prevents infinite recursion for recursive types) */
+    /** Cache for built fast type guard functions */
     private readonly fastTypeGuardCache = new Map<Type, (data: unknown) => boolean>();
 
-    /** Cache for built strict type guard functions (prevents infinite recursion for recursive types) */
+    /** Cache for built strict type guard functions */
     private readonly strictTypeGuardCache = new Map<Type, (data: unknown) => boolean>();
 
-    /** Types currently being built (for recursive type detection) */
+    /** Types currently being built as fast guards (for recursive type detection) */
     private readonly buildingFastTypeGuards = new Set<Type>();
+
+    /** Types currently being built as strict guards (for recursive type detection) */
     private readonly buildingStrictTypeGuards = new Set<Type>();
 
     constructor(public name: string = 'json') {
         this.registerSerializers();
         this.registerTypeGuards();
-        this.registerValidators();
     }
 
     /**
@@ -103,22 +95,17 @@ export class Serializer {
         // Guards will be registered via registerDefaultTypeGuards() from handlers.ts
     }
 
-    /**
-     * Register default validators. Override in subclasses to customize.
-     */
-    protected registerValidators(): void {
-        // Validators will be registered via registerDefaultValidators() from validation.ts
-    }
-
     /**
      * Clear all registries.
      */
     clear(): void {
         this.serializeRegistry.clear();
         this.deserializeRegistry.clear();
         this.typeGuards.clear();
-        this.validators.clear();
-        this.fastTypeGuards.clear();
+        this.fastTypeGuardCache.clear();
+        this.strictTypeGuardCache.clear();
+        this.buildingFastTypeGuards.clear();
+        this.buildingStrictTypeGuards.clear();
     }
 
     /**
@@ -174,16 +161,15 @@ export class Serializer {
             (ctx: Context, data: Slot<any>, stateArg: Slot<{ errors?: ValidationErrorItem[] }>) => {
                 const optionsSlot = ctx.lazyLet(ctx.ternary(stateArg, stateArg, ctx.objExpr()));
 
-                const guardRegistry = this.typeGuards.getRegistry(1);
-                const state = new BuildState('validate', this, ctx, optionsSlot, guardRegistry, {
+                const state = new BuildState('validate', this, ctx, optionsSlot, this.typeGuards, {
                     validation: 'strict',
+                    collectErrors: true,
+                    rejectUnknownKeys: false,
                 });
 
-                // For validation, we return a boolean score > 0
+                // For validation, we return a boolean
                 const result = state.build(type, data);
-
-                // Convert score to boolean
-                return ctx.gt(result, ctx.lit(0));
+                return result as Slot<boolean>;
             },
         );
     }
@@ -202,13 +188,14 @@ export class Serializer {
             (ctx: Context, data: Slot<any>, stateArg: Slot<{ errors?: ValidationErrorItem[] }>) => {
                 const optionsSlot = ctx.lazyLet(ctx.ternary(stateArg, stateArg, ctx.objExpr()));
 
-                const guardRegistry = this.typeGuards.getRegistry(1);
-                const state = new BuildState('validate', this, ctx, optionsSlot, guardRegistry, {
+                const state = new BuildState('validate', this, ctx, optionsSlot, this.typeGuards, {
                     validation: withLoose ? 'loose' : 'strict',
+                    collectErrors: true,
+                    rejectUnknownKeys: false,
                 });
 
                 const result = state.build(type, data);
-                return ctx.gt(result, ctx.lit(0));
+                return result as Slot<boolean>;
             },
         ) as Guard<T>;
     }
@@ -252,8 +239,10 @@ export class Serializer {
 
         try {
             const fn = jit.fn(jit.arg<unknown>(), (ctx: Context, data: Slot<unknown>) => {
-                const state = new BuildState('validate', this, ctx, ctx.objExpr(), this.fastTypeGuards, {
+                const state = new BuildState('validate', this, ctx, ctx.objExpr(), this.typeGuards, {
                     validation: 'fast',
+                    collectErrors: false,
+                    rejectUnknownKeys: false,
                 });
                 return state.build(type, data);
             }) as (data: unknown) => data is T;
@@ -304,8 +293,10 @@ export class Serializer {
 
         try {
             const fn = jit.fn(jit.arg<unknown>(), (ctx: Context, data: Slot<unknown>) => {
-                const state = new BuildState('validate', this, ctx, ctx.objExpr(), this.strictTypeGuards, {
+                const state = new BuildState('validate', this, ctx, ctx.objExpr(), this.typeGuards, {
                     validation: 'strict',
+                    collectErrors: false,
+                    rejectUnknownKeys: true,
                 });
                 return state.build(type, data);
             }) as (data: unknown) => data is T;

packages/type/src/serializer/serializer.ts

@@ -124,6 +124,15 @@ export class BuildState {
     /** Validation mode: strict, loose, fast (pure && chain), or undefined */
     readonly validation: 'strict' | 'loose' | 'fast' | undefined;
 
+    /** Whether to collect validation errors (for buildTypeGuard with error collection) */
+    readonly collectErrors: boolean;
+
+    /** Whether to reject unknown object keys (for strict type guards) */
+    readonly rejectUnknownKeys: boolean;
+
+    /** Whether currently checking union members (skip error-adding in post-hook) */
+    readonly inUnionContext: boolean;
+
     /** Current depth in the type tree */
     readonly depth: number;
 
@@ -153,6 +162,9 @@ export class BuildState {
         registry: HandlerRegistry,
         options: {
             validation?: 'strict' | 'loose' | 'fast';
+            collectErrors?: boolean;
+            rejectUnknownKeys?: boolean;
+            inUnionContext?: boolean;
             depth?: number;
             maxDepth?: number;
             typeStack?: Set<Type>;
@@ -167,6 +179,9 @@ export class BuildState {
         this.optionsSlot = optionsSlot;
         this.registry = registry;
         this.validation = options.validation;
+        this.collectErrors = options.collectErrors ?? false;
+        this.rejectUnknownKeys = options.rejectUnknownKeys ?? false;
+        this.inUnionContext = options.inUnionContext ?? false;
         this.depth = options.depth ?? 0;
         this.maxDepth = options.maxDepth ?? BuildState.DEFAULT_MAX_DEPTH;
         this.typeStack = options.typeStack ?? new Set();
@@ -291,6 +306,9 @@ export class BuildState {
     forProperty(name: string): BuildState {
         return new BuildState(this.direction, this.serializer, this.ctx, this.optionsSlot, this.registry, {
             validation: this.validation,
+            collectErrors: this.collectErrors,
+            rejectUnknownKeys: this.rejectUnknownKeys,
+            inUnionContext: this.inUnionContext,
             depth: this.depth + 1,
             maxDepth: this.maxDepth,
             typeStack: this.typeStack,
@@ -306,6 +324,9 @@ export class BuildState {
     forIndex(index: Slot<number>): BuildState {
         return new BuildState(this.direction, this.serializer, this.ctx, this.optionsSlot, this.registry, {
             validation: this.validation,
+            collectErrors: this.collectErrors,
+            rejectUnknownKeys: this.rejectUnknownKeys,
+            inUnionContext: this.inUnionContext,
             depth: this.depth + 1,
             maxDepth: this.maxDepth,
             typeStack: this.typeStack,
@@ -322,6 +343,9 @@ export class BuildState {
     forRegistry(registry: HandlerRegistry): BuildState {
         return new BuildState(this.direction, this.serializer, this.ctx, this.optionsSlot, registry, {
             validation: this.validation,
+            collectErrors: this.collectErrors,
+            rejectUnknownKeys: this.rejectUnknownKeys,
+            inUnionContext: this.inUnionContext,
             depth: this.depth,
             maxDepth: this.maxDepth,
             typeStack: this.typeStack,
@@ -331,6 +355,26 @@ export class BuildState {
         });
     }
 
+    /**
+     * Fork state for checking a union member.
+     * Error collection is suppressed so that failing members don't add errors.
+     * The union handler itself will add ONE error if all members fail.
+     */
+    forUnionMember(): BuildState {
+        return new BuildState(this.direction, this.serializer, this.ctx, this.optionsSlot, this.registry, {
+            validation: this.validation,
+            collectErrors: this.collectErrors,
+            rejectUnknownKeys: this.rejectUnknownKeys,
+            inUnionContext: true,
+            depth: this.depth + 1,
+            maxDepth: this.maxDepth,
+            typeStack: this.typeStack,
+            fnCache: this.fnCache,
+            pathSegments: this.pathSegments,
+            namingStrategy: this.namingStrategy,
+        });
+    }
+
     /**
      * Build a type, deciding whether to inline or extract.
      *
@@ -402,6 +446,8 @@ export class BuildState {
                     // Create a fresh state for the extracted function
                     const childState = new BuildState(self.direction, self.serializer, ctx, opts, self.registry, {
                         validation: self.validation,
+                        collectErrors: self.collectErrors,
+                        rejectUnknownKeys: self.rejectUnknownKeys,
                         depth: 0, // Reset depth
                         maxDepth: self.maxDepth,
                         typeStack: new Set(), // Fresh stack

packages/type/src/serializer/state.ts

@@ -281,8 +281,7 @@ function buildScoredUnion(type: TypeUnion, input: Slot, ctx: Context, state: Bui
     const result = ctx.var_<any>(undefined);
     const matched = ctx.var_(false);
 
-    // Get the guard registry and check loose mode
-    const guardRegistry = state.serializer.typeGuards.getRegistry(1);
+    // Check loose mode
     const isLoose = ctx.neq(state.optionsSlot.get('loosely'), ctx.lit(false));
 
     // Sort members: put more specific types first (bigint/number before string)

packages/type/src/serializer/union.ts

@@ -42,15 +42,15 @@ function getFunctionFromType(fnType: Type): Function | undefined {
  *
  * This hook:
  * 1. Lets the main type guard run first
- * 2. If type guard passes (score > 0), runs validation annotations
- * 3. Returns adjusted score (0 if validation fails)
+ * 2. If type guard passes (true), runs validation annotations
+ * 3. Returns false if validation fails
  *
  * @example
  * ```typescript
  * // With type: string & MinLength<3>
- * // 1. Type guard returns 1000 (string matches)
+ * // 1. Type guard returns true (string matches)
  * // 2. MinLength validator runs
- * // 3. If length < 3, score becomes 0 and error is added
+ * // 3. If length < 3, returns false and error is added
  * ```
  */
 export const validationHook: TypeHook = (type, input, ctx, state, next) => {
@@ -63,8 +63,8 @@ export const validationHook: TypeHook = (type, input, ctx, state, next) => {
         return typeResult;
     }
 
-    // Create mutable score
-    const valid = ctx.var_(typeResult);
+    // Create mutable valid flag (boolean)
+    const valid = ctx.var_(typeResult as Slot<boolean>);
 
     // Get the errors array from state's optionsSlot
     const errorsSlot = state.optionsSlot.get('errors' as any);
@@ -100,7 +100,7 @@ export const validationHook: TypeHook = (type, input, ctx, state, next) => {
                     }
                 }
 
-                ctx.when(ctx.gt(ctx.getVar(valid), ctx.lit(0)), () => {
+                ctx.when(ctx.getVar(valid), () => {
                     // Call validator function with (value, type, options)
                     const error = ctx.callExpr(
                         (fn: ValidateFunction, value: any, t: Type, opts: any, expectedParam: string) => {
@@ -120,7 +120,7 @@ export const validationHook: TypeHook = (type, input, ctx, state, next) => {
                     );
 
                     ctx.when(error, () => {
-                        ctx.setVar(valid, ctx.lit(0));
+                        ctx.setVar(valid, ctx.lit(false));
 
                         // Push error to errors array if it exists
                         ctx.when(errorsSlot, () => {
@@ -144,11 +144,11 @@ export const validationHook: TypeHook = (type, input, ctx, state, next) => {
                 // Create validator with args
                 const validatorFn = validatorFactory(...args);
 
-                ctx.when(ctx.gt(ctx.getVar(valid), ctx.lit(0)), () => {
+                ctx.when(ctx.getVar(valid), () => {
                     const error = ctx.callExpr(validatorFn, input);
 
                     ctx.when(error, () => {
-                        ctx.setVar(valid, ctx.lit(0));
+                        ctx.setVar(valid, ctx.lit(false));
 
                         // Push error to errors array if it exists
                         ctx.when(errorsSlot, () => {
@@ -175,10 +175,9 @@ export const validationHook: TypeHook = (type, input, ctx, state, next) => {
 /**
  * Register validation hook on type guards.
  */
-export function registerValidationHook(serializer: { typeGuards: any }): void {
-    // Add post-hook to the strict (specificality 1) registry
-    const strictRegistry = serializer.typeGuards.getRegistry(1);
-    strictRegistry.addPostHook(validationHook);
+export function registerValidationHook(serializer: { typeGuards: { addPostHook(hook: TypeHook): void } }): void {
+    // Add post-hook to the unified type guards registry
+    serializer.typeGuards.addPostHook(validationHook);
 }
 
 /**