Resolve metadata module TODOs with architectural improvements

CRITICAL BUG FIX:
- Fix DATE field serialization bug in MetaObjectSerializer
  - Was serializing entire value object instead of field value
  - Changed from context.serialize(vo) to context.serialize(mf.getObject(vo))
  - Ensures correct DATE serialization for cross-language compatibility

ARCHITECTURAL IMPROVEMENTS:
- Refactor deleteOnAdd() to use polymorphism instead of instanceof checks
  - Add shouldDeleteOnAdd() method to MetaData base class (returns false)
  - Override in MetaAttribute to return true (enables replacement behavior)
  - Improves extensibility and follows open/closed principle

DOCUMENTATION ENHANCEMENTS:
- Improve shouldUseParentPackage() documentation in BaseMetaDataParser
  - Add comprehensive Javadoc explaining package inheritance rules
  - Clarify when MetaDataLoader parents don't propagate packages
- Clarify URI validation limitation in URIHelper
  - Explain unprefixed classpath resources validated at load time

CODE CLEANUP:
- Remove obsolete LoaderOptions TODO
  - Class already supports extension via generic setter pattern
  - Fix typo: "somethinf" → removed with DATE serialization fix

All 250 metadata module tests passing.
Aligned with AI-optimized type system for Java/C#/TypeScript cross-language compatibility.

https://claude.ai/code/session_011CUZhLswdQq92FRSrNd3tR

Author: claude

metadata/src/main/java/com/metaobjects/MetaData.java

@@ -926,18 +926,22 @@ protected boolean filterWhenParentData( MetaData d ) {
     }
 
     /**
-     * Whether to delete the MetaData if a new one is added
+     * Determines if this MetaData instance should be deleted when a new one with the same name is added.
+     * Subclasses can override this to control replacement behavior.
+     *
+     * @return true if this instance should be replaced, false to keep existing
+     */
+    protected boolean shouldDeleteOnAdd() {
+        return false;  // Most MetaData types retain existing instances by default
+    }
+
+    /**
+     * Whether to delete the MetaData if a new one is added (delegates to polymorphic method)
      * @param d MetaData to check
      * @return true if should delete
      */
     protected boolean deleteOnAdd( MetaData d) {
-
-        // TODO: Change these rules to be driven from a MetaData method that is overrideable
-
-        return d instanceof MetaAttribute;
-                // || d instanceof MetaField
-                //|| d instanceof MetaValidator
-                //|| d instanceof MetaView;
+        return d.shouldDeleteOnAdd();
     }
 
     /**

metadata/src/main/java/com/metaobjects/attr/MetaAttribute.java

@@ -106,6 +106,17 @@ public boolean isArrayType() {
                Boolean.parseBoolean(getMetaAttr(ATTR_IS_ARRAY).getValueAsString());
     }
 
+    /**
+     * Attributes support replacement when a new attribute with the same name is added.
+     * This allows attribute values to be updated/overridden in metadata hierarchies.
+     *
+     * @return true - attributes are replaceable by default
+     */
+    @Override
+    protected boolean shouldDeleteOnAdd() {
+        return true;
+    }
+
     // ========== ENHANCED ATTRIBUTE-SPECIFIC METHODS ==========
 
 

metadata/src/main/java/com/metaobjects/io/object/gson/MetaObjectSerializer.java

@@ -73,8 +73,8 @@ protected void writeField(MetaObject mo, MetaField mf, Object vo,
                 jsonObject.addProperty(name, mf.getInt(vo));
                 break;
 
-            case DATE:      // TODO: should we do somethinf custom here?
-                jsonObject.add(name, context.serialize(vo));
+            case DATE:
+                jsonObject.add(name, context.serialize(mf.getObject(vo)));
                 break;
 
             case LONG:

metadata/src/main/java/com/metaobjects/loader/MetaDataLoader.java

@@ -107,7 +107,7 @@ public class MetaDataLoader extends MetaData implements LoaderConfigurable {
         }
     }
 
-    // TODO:  Allow for custom configurations for overloaded MetaDataLoaders
+    // LoaderOptions supports extension via subclassing with generic setter pattern
     private final LoaderOptions loaderOptions;
 
     // v6.0.0: Replace TypesConfig with unified registry

metadata/src/main/java/com/metaobjects/loader/parser/BaseMetaDataParser.java

@@ -414,9 +414,19 @@ protected String getFullyQualifiedSuperMetaDataName(MetaData parent, String pack
         return MetaDataUtil.expandPackageForMetaDataRef(basePackage, superName);
     }
 
-    /** Determine if the packageName should change based on the parent metadata */
+    /**
+     * Determines if child metadata should inherit parent's package.
+     * Package inheritance is disabled when:
+     * - No parent exists
+     * - Parent is a MetaDataLoader (loaders don't propagate packages to loaded metadata)
+     * - Parent has no package
+     * - Parent package matches child package (already aligned)
+     *
+     * @param parent Parent metadata that may provide a package
+     * @param packageName Child's current package name
+     * @return true if parent package should override child package
+     */
     protected boolean shouldUseParentPackage( MetaData parent, String packageName ) {
-        // TODO:  This may need to be refactored
         return parent != null
                 && !(parent instanceof MetaDataLoader)
                 && !parent.getPackage().isEmpty()

metadata/src/main/java/com/metaobjects/loader/uri/URIHelper.java

@@ -122,8 +122,8 @@ else if ( uriSourceType.equals( URI_SOURCE_RESOURCE )) {
                     }
                 }
                 else {
-                    //new URL( url);
-                    // TODO: Not much you can do to check this
+                    // Unprefixed classpath resources cannot be validated without classloader context.
+                    // Validation occurs at load time when the resource is actually resolved.
                 }
             } catch (MalformedURLException e) {
                 throw new IllegalArgumentException( "Classpath resource has invalid syntax ["+url+"] "+e.toString(), e );