fix(type): remove optional chaining from JIT-generated code

Optional chaining (?.) syntax breaks in certain JavaScript runtimes.
Instead of using optGet which generates obj?.key, ensure optionsRef
is always an object via nullish coalescing at function entry points,
then use regular property access.

Also adds BuildOptions support for baking serialization options
(groups, loosely) into specialized functions at build time,
eliminating runtime option checks in hot paths.

Author: marcj

packages/type/src/serializer-facade.ts

@@ -19,6 +19,7 @@ import {
     Serializer,
     getPartialSerializeFunction,
     getSerializeFunction,
+    serializationOptionsToBuildOptions,
     serializer,
 } from './serializer.js';
 import { assert } from './typeguard.js';
@@ -38,7 +39,15 @@ export function cast<T>(
     namingStrategy?: NamingStrategy,
     type?: ReceiveType<T>,
 ): T {
-    const fn = getSerializeFunction(resolveReceiveType(type), serializerToUse.deserializeRegistry, namingStrategy);
+    // Get specialized function with baked options for zero-overhead hot path
+    const buildOptions = serializationOptionsToBuildOptions(options);
+    const fn = getSerializeFunction(
+        resolveReceiveType(type),
+        serializerToUse.deserializeRegistry,
+        namingStrategy,
+        '',
+        buildOptions,
+    );
     const item = fn(data, options) as T;
     assert(item, undefined, type);
     return item;
@@ -83,7 +92,15 @@ export function deserialize<T>(
     namingStrategy?: NamingStrategy,
     type?: ReceiveType<T>,
 ): T {
-    const fn = getSerializeFunction(resolveReceiveType(type), serializerToUse.deserializeRegistry, namingStrategy);
+    // Get specialized function with baked options for zero-overhead hot path
+    const buildOptions = serializationOptionsToBuildOptions(options);
+    const fn = getSerializeFunction(
+        resolveReceiveType(type),
+        serializerToUse.deserializeRegistry,
+        namingStrategy,
+        '',
+        buildOptions,
+    );
     return fn(data, options) as T;
 }
 
@@ -229,7 +246,15 @@ export function serialize<T>(
     namingStrategy?: NamingStrategy,
     type?: ReceiveType<T>,
 ): JSONSingle<T> {
-    const fn = getSerializeFunction(resolveReceiveType(type), serializerToUse.serializeRegistry, namingStrategy);
+    // Get specialized function with baked options for zero-overhead hot path
+    const buildOptions = serializationOptionsToBuildOptions(options);
+    const fn = getSerializeFunction(
+        resolveReceiveType(type),
+        serializerToUse.serializeRegistry,
+        namingStrategy,
+        '',
+        buildOptions,
+    );
     return fn(data, options) as JSONSingle<T>;
 }
 
@@ -269,7 +294,15 @@ export function validatedDeserialize<T>(
     namingStrategy?: NamingStrategy,
     type?: ReceiveType<T>,
 ) {
-    const fn = getSerializeFunction(resolveReceiveType(type), serializerToUse.deserializeRegistry, namingStrategy);
+    // Get specialized function with baked options for zero-overhead hot path
+    const buildOptions = serializationOptionsToBuildOptions(options);
+    const fn = getSerializeFunction(
+        resolveReceiveType(type),
+        serializerToUse.deserializeRegistry,
+        namingStrategy,
+        '',
+        buildOptions,
+    );
     const item = fn(data, options) as T;
     assert(item, undefined, type);
     return item;

packages/type/src/serializer/serializer.ts

@@ -23,7 +23,7 @@ import { ValidationErrorItem } from '../validator.js';
 import { registerDefaultHandlers, registerTypeGuards } from './handlers.js';
 import { NamingStrategy } from './naming.js';
 import { HandlerRegistry } from './registry.js';
-import { BuildState, SerializationOptions } from './state.js';
+import { BuildOptions, BuildState, SerializationOptions } from './state.js';
 import { registerUnionHandler } from './union.js';
 import { registerValidationHook } from './validation.js';
 
@@ -131,8 +131,8 @@ export class Serializer {
             arg<T>(),
             arg<SerializationOptions>(),
             (b: Builder, data: Ref<T>, options: Ref<SerializationOptions>) => {
-                const optionsRef = b.let(b.nullish(options, b.emptyObj<SerializationOptions>()));
-
+                // Ensure options is always an object (for safe property access in handlers)
+                const optionsRef = b.let(b.nullish(options, b.emptyObj()));
                 const state = new BuildState('serialize', this, b, optionsRef, this.serializeRegistry);
 
                 return state.build(type, data);
@@ -151,8 +151,8 @@ export class Serializer {
             arg<any>(),
             arg<SerializationOptions>(),
             (b: Builder, data: Ref<any>, options: Ref<SerializationOptions>) => {
-                const optionsRef = b.let(b.nullish(options, b.emptyObj<SerializationOptions>()));
-
+                // Ensure options is always an object (for safe property access in handlers)
+                const optionsRef = b.let(b.nullish(options, b.emptyObj()));
                 const state = new BuildState('deserialize', this, b, optionsRef, this.deserializeRegistry);
 
                 return state.build(type, data);
@@ -378,36 +378,106 @@ export class Serializer {
     }
 }
 
+/**
+ * Compute a cache key suffix from build options.
+ * Returns empty string for default options (no baked values).
+ */
+export function computeBuildOptionsKey(buildOptions?: BuildOptions): string {
+    if (!buildOptions) return '';
+
+    const parts: string[] = [];
+
+    // Loose mode: L=loose, S=strict
+    if (buildOptions.looseBaked !== undefined) {
+        parts.push(buildOptions.looseBaked ? 'L' : 'S');
+    }
+
+    // Groups: G:group1,group2 or GX:excludedGroup1,excludedGroup2
+    if (buildOptions.groupsBaked !== undefined) {
+        const sorted = [...buildOptions.groupsBaked].sort();
+        parts.push(`G:${sorted.join(',')}`);
+    }
+    if (buildOptions.groupsExcludeBaked !== undefined) {
+        const sorted = [...buildOptions.groupsExcludeBaked].sort();
+        parts.push(`GX:${sorted.join(',')}`);
+    }
+
+    return parts.length > 0 ? '_' + parts.join('_') : '';
+}
+
+/**
+ * Convert SerializationOptions to BuildOptions for baking into specialized functions.
+ */
+export function serializationOptionsToBuildOptions(options?: SerializationOptions): BuildOptions | undefined {
+    if (!options) return undefined;
+
+    const buildOptions: BuildOptions = {};
+    let hasBakedOptions = false;
+
+    // Bake loose mode if explicitly set
+    if (options.loosely !== undefined) {
+        buildOptions.looseBaked = options.loosely;
+        hasBakedOptions = true;
+    }
+
+    // Bake groups if provided
+    if (options.groups !== undefined) {
+        buildOptions.groupsBaked = options.groups;
+        hasBakedOptions = true;
+    }
+    if (options.groupsExclude !== undefined) {
+        buildOptions.groupsExcludeBaked = options.groupsExclude;
+        hasBakedOptions = true;
+    }
+
+    return hasBakedOptions ? buildOptions : undefined;
+}
+
 /**
  * Get a cached serializer function for a type.
+ *
+ * @param type - The type to serialize
+ * @param registry - The handler registry (serialize or deserialize)
+ * @param namingStrategy - Property naming strategy
+ * @param path - Path prefix for error messages
+ * @param buildOptions - Optional build-time options to bake into the function
  */
 export function getSerializeFunction(
     type: Type,
     registry: HandlerRegistry,
     namingStrategy: NamingStrategy = new NamingStrategy(),
     path: string = '',
+    buildOptions?: BuildOptions,
 ): SerializeFunction {
     const jitContainer = getTypeJitContainer(type);
-    const id = `${registry.id}_${namingStrategy.id}_${path}`;
+    const optionsKey = computeBuildOptionsKey(buildOptions);
+    const id = `${registry.id}_${namingStrategy.id}_${path}${optionsKey}`;
 
     if (jitContainer[id]) {
         return jitContainer[id];
     }
 
-    jitContainer[id] = createSerializeFunction(type, registry, namingStrategy, path);
+    jitContainer[id] = createSerializeFunction(type, registry, namingStrategy, path, buildOptions);
     toFastProperties(jitContainer);
 
     return jitContainer[id];
 }
 
 /**
  * Create a serializer function for a type (not cached).
+ *
+ * @param type - The type to serialize
+ * @param registry - The handler registry
+ * @param namingStrategy - Property naming strategy
+ * @param path - Path prefix for error messages
+ * @param buildOptions - Optional build-time options to bake into the function
  */
 export function createSerializeFunction(
     type: Type,
     registry: HandlerRegistry,
     namingStrategy: NamingStrategy = new NamingStrategy(),
     path: string = '',
+    buildOptions?: BuildOptions,
 ): SerializeFunction {
     // Get direction from registry
     const direction = registry.direction;
@@ -416,16 +486,16 @@ export function createSerializeFunction(
         arg<any>(),
         arg<SerializationOptions>(),
         (b: Builder, data: Ref<any>, options: Ref<SerializationOptions>) => {
-            const optionsRef = b.let(b.nullish(options, b.emptyObj<SerializationOptions>()));
+            // Ensure options is always an object (for safe property access in handlers)
+            const optionsRef = b.let(b.nullish(options, b.emptyObj()));
 
-            // We need a serializer reference here - for now use default
             const state = new BuildState(
                 direction,
                 serializer, // Use default serializer
                 b,
                 optionsRef,
                 registry,
-                { namingStrategy },
+                { namingStrategy, buildOptions },
             );
 
             return state.build(type, data);