my  function for traversal:
```
/**
 * Recursively makes all fields of an ArkType schema:
 *  - As Optional.
 *  - As Nullable if marked with `keepNull`.
 *  - And allow undefined as valid field value.
 *
 * Special handling:
 *  - Fields marked as discriminators (via `discriminatorHint`) remain required and are not made optional or nullable directly,
 *    but their nested fields are still transformed appropriately.
 *
 * Implementation Note:
 * TODO: split it up into multiple passes (problem -> avoid looses metadata on discrimination hints)
 *  - This logic is done in a single pass because ArkType metadata (such as discriminator hints)
 *    is lost or altered when schema transformations occur across multiple passes or separate helper methods.
 *  - Each transformation step (`partial`, `nullable`, `undefined`) rebuilds schema nodes, and doing so separately
 *    would cause loss of crucial metadata.
 *  - Therefore, transformations must be combined in a single recursive traversal to preserve metadata consistency throughout the schema.
 */
export function applyDeepPartialSchemaRules<o extends type<object | null | undefined>>(
  o: o,
): type<RecursivePartial<o["t"]> | null | undefined>;
export function applyDeepPartialSchemaRules(o: type<Record<string, unknown> | unknown[]>): unknown {
  // biome-ignore lint/suspicious/noExplicitAny: complex type structure, simplified intentionally
  function transformField(o: type<object>, prop: any): any {
    const discriminatorHint = o.meta?.discriminatorHint;

    // Fields marked as discriminators remain unchanged (but nested fields still processed)
    if (prop.key === discriminatorHint) {
      return prop;
    }

    let processedValue = prop.value;

    if (prop.value.extends("object")) {
      processedValue = applyDeepPartialSchemaRules(prop.value as never);
    }

    const keepNull = prop.value.meta?.options?.keepNull;

    if (keepNull) {
      processedValue = processedValue.or(type.null).configure(prop.value.meta);
    }

    if (prop.value.meta?.options?.allowUndefinedOnSkip) {
      processedValue = processedValue.or(type.undefined).configure(prop.value.meta);
    }

    return {
      ...prop,
      kind: "optional",
      value: processedValue,
    };
  }

  if (o.extends("Array")) {
    const objType = o.select({
      kind: "sequence",
      method: "assertFind",
      boundary: "shallow",
    }).variadic;

    if (objType?.extends("object")) {
      return objType?.map((prop) => transformField(objType as unknown as type<object>, prop)).array();
    }

    return transformField(objType as unknown as type<object>, o);
  }

  return o.map((prop) => transformField(o, prop));
}
```