typia 14.0.6 → 15.0.0

package/native/cmd/ttsc-typia/transform_helpers_test.go

@@ -155,6 +155,8 @@ func ttscTypiaTestRewriteCommonJS(t *testing.T, js string) string {
   runtimeJS = strings.ReplaceAll(runtimeJS, `require("typia/lib/internal/_functionalTypeGuardErrorFactory")`, `require("./functional-error-stub.cjs")`)
   runtimeJS = strings.ReplaceAll(runtimeJS, `require("typia/lib/internal/_accessExpressionAsString")`, `require("./access-expression-stub.cjs")`)
   runtimeJS = strings.ReplaceAll(runtimeJS, `require("typia/lib/internal/_stringLength")`, `require("./string-length-stub.cjs")`)
+  runtimeJS = strings.ReplaceAll(runtimeJS, `require("typia/lib/internal/_stringLengthGte")`, `require("./string-length-stub.cjs")`)
+  runtimeJS = strings.ReplaceAll(runtimeJS, `require("typia/lib/internal/_stringLengthLte")`, `require("./string-length-stub.cjs")`)
   runtimeJS = strings.ReplaceAll(runtimeJS, `require("typia/lib/internal/_jsonStringifyArray")`, `require("./json-stringify-array-stub.cjs")`)
   runtimeJS = strings.ReplaceAll(runtimeJS, `require("typia/lib/internal/_jsonStringifyProperty")`, `require("./json-stringify-property-stub.cjs")`)
   runtimeJS = strings.ReplaceAll(runtimeJS, `require("typia/lib/internal/_jsonStringifyElement")`, `require("./json-stringify-element-stub.cjs")`)
@@ -292,14 +294,26 @@ const ttscTypiaTestRandomStringStub = `module.exports._randomString = (props) =>
 };
 `
 
-// A double for packages/typia/src/internal/_stringLength.ts: the string
-// iterator walks code points, so a surrogate pair counts once, which is what
-// `MinLength` and `MaxLength` now mean.
+// Doubles for the string-length helpers. The string iterator walks code points,
+// so a surrogate pair counts once; the comparisons stop as soon as their
+// boundary determines the answer.
 const ttscTypiaTestStringLengthStub = `module.exports._stringLength = (value) => {
   let count = 0;
   for (const _ of value) ++count;
   return count;
 };
+module.exports._stringLengthGte = (value, length) => {
+  let count = 0;
+  if (length <= count) return true;
+  for (const _ of value) if (length <= ++count) return true;
+  return false;
+};
+module.exports._stringLengthLte = (value, length) => {
+  let count = 0;
+  if (!(count <= length)) return false;
+  for (const _ of value) if (!(++count <= length)) return false;
+  return true;
+};
 `
 
 const ttscTypiaTestAccessExpressionStub = `const reserved = new Set([

package/native/core/context/ITypiaContext.go

@@ -1,6 +1,8 @@
 package context
 
 import (
+  "sync"
+
   shimast "github.com/microsoft/typescript-go/shim/ast"
   shimchecker "github.com/microsoft/typescript-go/shim/checker"
   shimcore "github.com/microsoft/typescript-go/shim/core"
@@ -21,10 +23,12 @@ type ITypiaContext struct {
   Emit     *shimprinter.EmitContext
   Importer *ImportProgrammer
   Extras   ITypiaContext_Extras
+  Shared   *sync.Map
 }
 
 type ITypiaContext_Extras struct {
   AddDiagnostic func(diag *ITypiaDiagnostic) int
+  Shared        *sync.Map
 }
 
 type ITypiaDiagnostic struct {

package/native/core/factories/IdentifierFactory.go

@@ -94,6 +94,16 @@ func (identifierFactoryNamespace) Postfix(str string) string {
   return identifierFactory_source("[" + identifierFactory_json(str) + "]")
 }
 
+// PathPostfix returns the accessor text `_accessExpressionAsString` builds at
+// runtime for the same key: `.key` for an identifier, `["key"]` otherwise. It
+// is the path text itself, not a JavaScript literal that spells it.
+func (identifierFactoryNamespace) PathPostfix(str string) string {
+  if identifierFactory_variable(str) {
+    return "." + str
+  }
+  return "[" + identifierFactory_json(str) + "]"
+}
+
 // identifierFactory_json renders `str` as JSON text, matching JSON.stringify so
 // that the path this lands in is the one _accessExpressionAsString builds for
 // the same key at runtime, and so JSON.parse in _createStandardSchema reads the

package/native/core/factories/LiteralFactory.go

@@ -18,6 +18,19 @@ type literalFactoryNamespace struct{}
 
 var LiteralFactory = literalFactoryNamespace{}
 
+// LiteralFactory_Null is an explicit JSON `null` value.
+//
+// Object writers treat a Go `nil` value as absent and skip it, which is what
+// most schema builders mean by it, so a real `null`, such as the value of
+// `tags.Example<null>`, needs its own marker to survive into the emitted
+// literal and into encoding/json output (samchon/typia#2403).
+type LiteralFactory_Null struct{}
+
+// MarshalJSON writes the marker as JSON `null`.
+func (LiteralFactory_Null) MarshalJSON() ([]byte, error) {
+  return []byte("null"), nil
+}
+
 // LiteralFactory_OrderedObject is an object literal whose property order is
 // fixed by Keys rather than inferred from a Go map's (unordered) iteration or
 // from propertyRank sorting. Use it for objects whose insertion order is
@@ -71,6 +84,9 @@ func (literalFactoryNamespace) Write(input any, emit ...*shimprinter.EmitContext
   if input == nil {
     return f.NewKeywordExpression(shimast.KindNullKeyword)
   }
+  if _, ok := input.(LiteralFactory_Null); ok {
+    return f.NewKeywordExpression(shimast.KindNullKeyword)
+  }
   if node, ok := input.(*shimast.Node); ok {
     if node.Kind == shimast.KindArrowFunction || node.Kind == shimast.KindCallExpression || node.Kind == shimast.KindIdentifier {
       return node

package/native/core/factories/MetadataCommentTagFactory.go

@@ -216,11 +216,12 @@ func (metadataCommentTagFactoryNamespace) Get(props struct {
 // The rule: a template may name only a helper that every `typia` inside the
 // caret range already ships. `isTypeInt8` and its siblings satisfy it --
 // `@typia/interface` 13.0.0 named them and `typia` 13.0.0 shipped them. The
-// four this file and `Type.ts` now name do not: `_stringLength`, `_isMultipleOf`
-// (both first published in 13.1.19), `_isTypeInt64Bigint`, and
-// `_isTypeUint64Bigint` (13.1.19). They are safe only because the release that
-// carries them is a major, where the caret cannot reach a `typia` that predates
-// them. A minor or patch release of this tree reopens #2330.
+// helpers this file and the tag declarations now name do not:
+// `_stringLengthGte`, `_stringLengthLte`, `_isMultipleOf`,
+// `_isTypeInt64Bigint`, and `_isTypeUint64Bigint`. They are safe only because
+// the release that carries them is a major, where the caret cannot reach a
+// `typia` that predates them. A minor or patch release of this tree reopens
+// #2330.
 //
 // Nothing here can enforce that; the release version is the maintainer's, and a
 // campaign pull request never assigns one. This comment is the record.
@@ -331,10 +332,11 @@ var metadataCommentTagFactory_PARSER = map[string]metadataCommentTagFactory_pars
     // `$input.length` counts UTF-16 code units, while the `minLength` and
     // `maxLength` keywords these tags emit count characters, so one astral
     // character would measure 2 against a schema that measures 1.
-    // `_stringLength` first shipped in 13.1.19; see the doc comment above.
+    // The comparison helpers keep that code-point walk but stop when the
+    // declared boundary already determines the answer.
     return metadataCommentTagFactory_TagRecord{"string": {
-      {Name: "MinLength<" + props.Value + ">", Target: "string", Kind: "minLength", Value: value, Validate: props.Value + " <= $importInternal(\"_stringLength\")($input)", Exclusive: metadataCommentTagFactory_exclusive("minLength"), Schema: map[string]any{"minLength": value}},
-      {Name: "MaxLength<" + props.Value + ">", Target: "string", Kind: "maxLength", Value: value, Validate: "$importInternal(\"_stringLength\")($input) <= " + props.Value, Exclusive: metadataCommentTagFactory_exclusive("maxLength"), Schema: map[string]any{"maxLength": value}},
+      {Name: "MinLength<" + props.Value + ">", Target: "string", Kind: "minLength", Value: value, Validate: "$importInternal(\"_stringLengthGte\")($input, " + props.Value + ")", Exclusive: metadataCommentTagFactory_exclusive("minLength"), Schema: map[string]any{"minLength": value}},
+      {Name: "MaxLength<" + props.Value + ">", Target: "string", Kind: "maxLength", Value: value, Validate: "$importInternal(\"_stringLengthLte\")($input, " + props.Value + ")", Exclusive: metadataCommentTagFactory_exclusive("maxLength"), Schema: map[string]any{"maxLength": value}},
     }}
   },
   "minLength": func(props struct {
@@ -342,14 +344,14 @@ var metadataCommentTagFactory_PARSER = map[string]metadataCommentTagFactory_pars
     Value  string
   }) metadataCommentTagFactory_TagRecord {
     value := metadataCommentTagFactory_parse_number(props)
-    return metadataCommentTagFactory_TagRecord{"string": {{Name: "MinLength<" + props.Value + ">", Target: "string", Kind: "minLength", Value: value, Validate: props.Value + " <= $importInternal(\"_stringLength\")($input)", Exclusive: metadataCommentTagFactory_exclusive("minLength"), Schema: map[string]any{"minLength": value}}}}
+    return metadataCommentTagFactory_TagRecord{"string": {{Name: "MinLength<" + props.Value + ">", Target: "string", Kind: "minLength", Value: value, Validate: "$importInternal(\"_stringLengthGte\")($input, " + props.Value + ")", Exclusive: metadataCommentTagFactory_exclusive("minLength"), Schema: map[string]any{"minLength": value}}}}
   },
   "maxLength": func(props struct {
     Report func(msg string) any
     Value  string
   }) metadataCommentTagFactory_TagRecord {
     value := metadataCommentTagFactory_parse_number(props)
-    return metadataCommentTagFactory_TagRecord{"string": {{Name: "MaxLength<" + props.Value + ">", Target: "string", Kind: "maxLength", Value: value, Validate: "$importInternal(\"_stringLength\")($input) <= " + props.Value, Exclusive: metadataCommentTagFactory_exclusive("maxLength"), Schema: map[string]any{"maxLength": value}}}}
+    return metadataCommentTagFactory_TagRecord{"string": {{Name: "MaxLength<" + props.Value + ">", Target: "string", Kind: "maxLength", Value: value, Validate: "$importInternal(\"_stringLengthLte\")($input, " + props.Value + ")", Exclusive: metadataCommentTagFactory_exclusive("maxLength"), Schema: map[string]any{"maxLength": value}}}}
   },
 }
 

package/native/core/factories/MetadataTypeTagFactory.go

@@ -141,7 +141,9 @@ func (metadataTypeTagFactoryNamespace) Analyze(props struct {
     }
   }
   if len(filtered) == 0 {
-    return []schemametadata.IMetadataTypeTag{}
+    // every tag object was malformed: their messages must still be reported,
+    // exactly as when a valid tag accompanies them (samchon/typia#2400)
+    return metadataTypeTagFactory_flush(props.Errors, props.Type, props.Objects, props.Explore, messages, []schemametadata.IMetadataTypeTag{})
   }
 
   tagList := []*metadataTypeTagFactory_ITypeTag{}
@@ -193,21 +195,35 @@ func (metadataTypeTagFactoryNamespace) Analyze(props struct {
     Tags:   output,
   })
 
-  if len(messages) > 0 {
-    if props.Errors != nil {
-      names := []string{props.Type}
-      for _, object := range props.Objects {
-        names = append(names, object.Name)
-      }
-      metadataTypeTagFactory_append_error(props.Errors, MetadataFactory_IError{
-        Name:     strings.Join(names, " & "),
-        Explore:  props.Explore,
-        Messages: messages,
-      })
+  return metadataTypeTagFactory_flush(props.Errors, props.Type, props.Objects, props.Explore, messages, output)
+}
+
+// metadataTypeTagFactory_flush reports the collected tag messages as one
+// error named after the tagged type, and then yields no tags; without
+// messages it yields the analyzed tags.
+func metadataTypeTagFactory_flush(
+  errors *[]MetadataFactory_IError,
+  typ string,
+  objects []*schemametadata.MetadataObjectType,
+  explore MetadataFactory_IExplore,
+  messages []string,
+  output []schemametadata.IMetadataTypeTag,
+) []schemametadata.IMetadataTypeTag {
+  if len(messages) == 0 {
+    return output
+  }
+  if errors != nil {
+    names := []string{typ}
+    for _, object := range objects {
+      names = append(names, object.Name)
     }
-    return []schemametadata.IMetadataTypeTag{}
+    metadataTypeTagFactory_append_error(errors, MetadataFactory_IError{
+      Name:     strings.Join(names, " & "),
+      Explore:  explore,
+      Messages: messages,
+    })
   }
-  return output
+  return []schemametadata.IMetadataTypeTag{}
 }
 
 func (metadataTypeTagFactoryNamespace) Validate(props struct {
@@ -315,12 +331,18 @@ func metadataTypeTagFactory_validate_property(props struct {
       Message  string
     }{Property: property, Message: "must be a string literal type"})
   }
-  if props.Key == "value" && !((props.Value.Size() == 0 && props.Value.IsRequired() == false) ||
-    (props.Value.Size() == 1 && (len(props.Value.Objects) == 1 || len(props.Value.Constants) == 1))) {
-    return props.Report(struct {
-      Property *string
-      Message  string
-    }{Property: property, Message: "must be a literal type or undefined value"})
+  // the value must be one concrete literal shape that the tag schema factory
+  // can materialize: a constant, `null`, a tuple of such values, or an object
+  // whose content reaches the schema through `schema`. `tags.Default` reads
+  // the value back, while `tags.Example` and `tags.Examples` only need the
+  // shape to be accepted (samchon/typia#2400, samchon/typia#2403)
+  if props.Key == "value" {
+    if _, ok := metadataTypeTagFactory_get_value(props.Value); ok == false {
+      return props.Report(struct {
+        Property *string
+        Message  string
+      }{Property: property, Message: "must be a literal, literal tuple, object, or undefined type"})
+    }
   }
   if props.Key == "exclusive" {
     return metadataTypeTagFactory_get_exclusive(struct {
@@ -344,11 +366,13 @@ func metadataTypeTagFactory_validate_property(props struct {
     }
     target := []string{}
     if len(props.Value.Objects) == 0 {
-      targetProperty := "target"
+      // `validate` itself is malformed here, e.g. a template literal built from
+      // a non-literal tag value, so name it rather than `target`
+      validateProperty := "validate"
       return props.Report(struct {
         Property *string
         Message  string
-      }{Property: &targetProperty, Message: "must be one of 'boolean', 'bigint', 'number', 'string', 'array', 'object"})
+      }{Property: &validateProperty, Message: "must be a string literal, or an object whose keys are 'boolean', 'bigint', 'number', 'string', 'array', or 'object'"})
     }
     for _, property := range props.Value.Objects[0].Type.Properties {
       if lit := property.Key.GetSoleLiteral(); lit != nil {
@@ -415,8 +439,8 @@ func metadataTypeTagFactory_create_metadata_type_tag(props struct {
   kind := fmt.Sprint(kindProperty.Value.Constants[0].Values[0].Value)
 
   var value any
-  if valueProperty := find("value"); valueProperty != nil && len(valueProperty.Value.Constants) != 0 && len(valueProperty.Value.Constants[0].Values) != 0 {
-    value = valueProperty.Value.Constants[0].Values[0].Value
+  if valueProperty := find("value"); valueProperty != nil {
+    value, _ = metadataTypeTagFactory_get_value(valueProperty.Value)
   }
   exclusive := metadataTypeTagFactory_get_exclusive(struct {
     Report func(struct {
@@ -490,6 +514,55 @@ func metadataTypeTagFactory_create_metadata_type_tag(props struct {
   }
 }
 
+// metadataTypeTagFactory_get_value reads a tag's `value` as one concrete
+// literal value, and reports whether the metadata names one at all. The
+// accepted shapes mirror what metadataTypeTagSchemaFactory_iterate can
+// materialize: `undefined`, `null`, a single constant, a fixed tuple of such
+// values, or an object. `null` and an object yield a Go nil value; a tuple
+// yields its members in order.
+func metadataTypeTagFactory_get_value(metadata *schemametadata.MetadataSchema) (any, bool) {
+  if metadata == nil {
+    return nil, false
+  }
+  if metadata.Size() == 0 {
+    // `null` is one literal value; a missing value is the optional `undefined`
+    return nil, metadata.Nullable || metadata.IsRequired() == false
+  }
+  if metadata.Size() != 1 || metadata.Nullable {
+    return nil, false
+  }
+  if len(metadata.Constants) == 1 && len(metadata.Constants[0].Values) == 1 {
+    return metadata.Constants[0].Values[0].Value, true
+  }
+  if metadata.Any || len(metadata.Arrays) != 0 || len(metadata.Atomics) != 0 || len(metadata.Natives) != 0 || len(metadata.Functions) != 0 {
+    return nil, false
+  }
+  if len(metadata.Tuples) == 1 {
+    tuple := metadata.Tuples[0].Type
+    if tuple.Recursive || tuple.IsRest() {
+      return nil, false
+    }
+    output := make([]any, 0, len(tuple.Elements))
+    for _, elem := range tuple.Elements {
+      if elem.IsRequired() == false {
+        return nil, false
+      }
+      value, ok := metadataTypeTagFactory_get_value(elem)
+      if ok == false {
+        return nil, false
+      }
+      output = append(output, value)
+    }
+    return output, true
+  }
+  if len(metadata.Objects) == 1 {
+    // Object-valued metadata predates tuple support. Its concrete value is
+    // carried by the tag's schema object rather than IMetadataTypeTag.Value.
+    return nil, true
+  }
+  return nil, false
+}
+
 func metadataTypeTagFactory_get_exclusive(props struct {
   Report func(struct {
     Property *string

package/native/core/factories/MetadataTypeTagSchemaFactory.go

@@ -33,6 +33,11 @@ func (metadataTypeTagSchemaFactoryNamespace) Object(props struct {
       metadata: property.Value,
     })
     if ok {
+      // a property literally typed `null` keeps its value; a Go nil would read
+      // as absent to every object writer (samchon/typia#2403)
+      if value == nil && property.Value.Nullable && property.Value.Size() == 0 {
+        value = LiteralFactory_Null{}
+      }
       output[*key] = value
     }
   }

package/native/core/factories/internal/metadata/IMetadataIteratorProps.go

@@ -14,8 +14,12 @@ type MetadataFactory_IOptions struct {
   // method) into the collected properties as function-typed values, without
   // switching on full Functional analysis. Used by the compare programmers to
   // detect user-defined comparison methods.
-  Methods  bool
-  Validate func(props struct {
+  Methods bool
+  // StrictObjectMembers is for consumers whose emitted value promises to
+  // satisfy the entire input type. Include accessors and methods in the
+  // structural shape and diagnose members that have no JSON representation.
+  StrictObjectMembers bool
+  Validate            func(props struct {
     Metadata *schemametadata.MetadataSchema
     Explore  MetadataFactory_IExplore
     Top      *schemametadata.MetadataSchema

package/native/core/factories/internal/metadata/emplace_metadata_object.go

@@ -89,8 +89,40 @@ func Emplace_metadata_object(props IMetadataIteratorProps) *schemametadata.Metad
   }
 
   isClass := props.Type != nil && props.Type.IsClass()
-  isProperty := emplace_metadata_object_significant(props.Options.Functional, props.Options.Methods)
+  isProperty := emplace_metadata_object_significant(props.Options.Functional, props.Options.Methods, props.Options.StrictObjectMembers)
+  rejectMember := func(name string, message string) {
+    if props.Options.StrictObjectMembers == false || props.Errors == nil {
+      return
+    }
+    explore := props.Explore
+    explore.Top = false
+    explore.Object = obj
+    explore.Property = name
+    *props.Errors = append(*props.Errors, MetadataFactory_IError{
+      Name:     obj.Name,
+      Explore:  explore,
+      Messages: []string{message},
+    })
+  }
+  if props.Options.StrictObjectMembers && props.Checker != nil && props.Type != nil {
+    if len(props.Checker.GetSignaturesOfType(props.Type, nativechecker.SignatureKindCall)) != 0 {
+      rejectMember("[call]", "LLM evaluation does not support callable object types.")
+    }
+    if len(props.Checker.GetSignaturesOfType(props.Type, nativechecker.SignatureKindConstruct)) != 0 {
+      rejectMember("[construct]", "LLM evaluation does not support constructable object types.")
+    }
+  }
   pred := func(symbol *nativeast.Symbol, node *nativeast.Node) bool {
+    name := "<anonymous>"
+    if symbol != nil {
+      name = symbol.Name
+    }
+    // Diagnose ES #private before the symbol-key filter so JEV reports the
+    // nominal member rather than its compiler-generated mangled name.
+    if node != nil && (isClass || props.Options.StrictObjectMembers) && node.Name() != nil && node.Name().Kind == nativeast.KindPrivateIdentifier {
+      rejectMember(name, "LLM evaluation does not support private class members.")
+      return false
+    }
     // A `symbol`-keyed member (`[uniqueSymbol]: T`, `[Symbol.toStringTag]: T`,
     // ...) is not a string / number key: it is unreachable through the string
     // index access typia emits, `JSON.stringify` ignores it, and JSON Schema has
@@ -104,25 +136,21 @@ func Emplace_metadata_object(props IMetadataIteratorProps) *schemametadata.Metad
     // SYMBOL rather than a declaration node so a late-bound member with no
     // reachable declaration is excluded too.
     if symbol != nil && iterate_metadata_intersection_is_symbol_name(symbol.Name) {
+      rejectMember(name, "LLM evaluation does not support symbol-keyed properties.")
       return false
     }
     if node == nil {
       return true
     }
-    if isClass && node.ModifierFlags()&(nativeast.ModifierFlagsPrivate|nativeast.ModifierFlagsProtected) != 0 {
+    if (isClass || props.Options.StrictObjectMembers) && node.ModifierFlags()&(nativeast.ModifierFlagsPrivate|nativeast.ModifierFlagsProtected) != 0 {
+      rejectMember(name, "LLM evaluation does not support private or protected class members.")
       return false
     }
-    // An ES `#private` member (field, method, or accessor) carries no
-    // Private/Protected modifier — its identity is a KindPrivateIdentifier name.
-    // It is installed only by the constructor and is unreachable via index
-    // access, so it is not part of the structural shape; exclude it exactly as a
-    // `private`/`protected` keyword member (see ClassNonPublic). ApparentProperties
-    // otherwise surfaces it as a mangled key that no runtime object carries, so
-    // every real instance would fail its own guard (#2213).
-    if isClass && node.Name() != nil && node.Name().Kind == nativeast.KindPrivateIdentifier {
+    if isProperty(node) == false {
+      rejectMember(name, "LLM evaluation does not support this object member.")
       return false
     }
-    return isProperty(node)
+    return true
   }
 
   insert := func(next emplace_metadata_object_insert) *schemametadata.MetadataProperty {
@@ -135,7 +163,9 @@ func Emplace_metadata_object(props IMetadataIteratorProps) *schemametadata.Metad
   }
 
   for _, symbol := range props.Components.ApparentProperties(props.Checker, props.Type) {
-    if metadata_is_internal(symbol) {
+    // A complete-shape decoder must see even @internal members so its
+    // programmer can reject them; the ordinary structural consumers omit them.
+    if metadata_is_internal(symbol) && props.Options.StrictObjectMembers == false {
       continue
     }
     var node *nativeast.Node
@@ -188,6 +218,7 @@ func Emplace_metadata_object(props IMetadataIteratorProps) *schemametadata.Metad
     // intersections so every symbol-only form stays outside typia's structural
     // JSON shape, just like an explicit symbol-keyed member (#2240).
     if emplace_metadata_object_is_symbol_index_key(index.KeyType()) {
+      rejectMember("[symbol]", "LLM evaluation does not support symbol-keyed properties.")
       continue
     }
     analyzer := func(typ *nativechecker.Type) func(any) *schemametadata.MetadataSchema {
@@ -546,7 +577,7 @@ func emplace_metadata_object_intersection_append(
     return false
   }
   for _, symbol := range props.Components.ApparentProperties(props.Checker, child) {
-    if metadata_is_internal(symbol) {
+    if metadata_is_internal(symbol) && props.Options.StrictObjectMembers == false {
       continue
     }
     var node *nativeast.Node
@@ -652,10 +683,10 @@ func emplace_metadata_object_clone_property(property *schemametadata.MetadataPro
   })
 }
 
-func emplace_metadata_object_significant(functional bool, methods bool) func(node *nativeast.Node) bool {
+func emplace_metadata_object_significant(functional bool, methods bool, strict bool) func(node *nativeast.Node) bool {
   if functional {
     return func(node *nativeast.Node) bool {
-      return node.Kind != nativeast.KindGetAccessor && node.Kind != nativeast.KindSetAccessor
+      return strict || (node.Kind != nativeast.KindGetAccessor && node.Kind != nativeast.KindSetAccessor)
     }
   }
   return func(node *nativeast.Node) bool {
@@ -670,6 +701,9 @@ func emplace_metadata_object_significant(functional bool, methods bool) func(nod
     case nativeast.KindMethodDeclaration,
       nativeast.KindMethodSignature:
       return methods
+    case nativeast.KindGetAccessor,
+      nativeast.KindSetAccessor:
+      return strict
     default:
       return false
     }

package/native/core/factories/literal_factory_null_survives_objects_test.go

@@ -0,0 +1,43 @@
+package factories
+
+import (
+  "encoding/json"
+  "testing"
+)
+
+// TestLiteralFactoryNullSurvivesObjects verifies an explicit JSON null is kept
+// where a Go nil is dropped.
+//
+// Object writers treat a nil value as absent, so a tag schema holding a real
+// `null` (`tags.Example<null>`) lost it on emission (samchon/typia#2403). The
+// LiteralFactory_Null marker must survive encoding/json, which `typia.reflect`
+// metadata goes through, including inside an ordered object, and must not be
+// classified as nil-like, while a plain nil keeps meaning absent. The printed
+// literal path is covered by `test_json_schema_example_tuple_and_null`.
+//
+//  1. Marshal a map and an ordered object holding the marker and a plain nil.
+//  2. Assert the marker is written as null and the plain nil is omitted where
+//     the writer omits it.
+//  3. Assert the marker is not nil-like.
+func TestLiteralFactoryNullSurvivesObjects(t *testing.T) {
+  encoded, err := json.Marshal(map[string]any{"example": LiteralFactory_Null{}})
+  if err != nil || string(encoded) != `{"example":null}` {
+    t.Fatalf("map marker should marshal as null, got %s (%v)", encoded, err)
+  }
+  ordered, err := json.Marshal(LiteralFactory_OrderedObject{
+    Keys: []string{"kept", "absent"},
+    Values: map[string]any{
+      "kept":   LiteralFactory_Null{},
+      "absent": nil,
+    },
+  })
+  if err != nil || string(ordered) != `{"kept":null}` {
+    t.Fatalf("ordered object should keep the marker and drop nil, got %s (%v)", ordered, err)
+  }
+  if literalFactory_isNilLike(LiteralFactory_Null{}) {
+    t.Fatal("the null marker must not be nil-like")
+  }
+  if literalFactory_isNilLike(nil) == false {
+    t.Fatal("a plain nil must stay nil-like")
+  }
+}

package/native/core/factories/metadata_comment_tag_factory_string_length_helpers_test.go

@@ -0,0 +1,55 @@
+package factories
+
+import (
+  "testing"
+
+  schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+)
+
+// TestMetadataCommentTagFactoryStringLengthHelpers verifies every JSDoc length
+// spelling emits the same short-circuiting predicates as the public type tags.
+//
+// The type-tag declarations and JSDoc parser are independent metadata sources.
+// Updating only one would preserve schema output while making runtime behavior
+// and helper imports depend on which spelling a user chose.
+//
+//  1. Parse @length and require both comparison helpers at the same boundary.
+//  2. Parse @minLength and @maxLength and require their corresponding helper.
+func TestMetadataCommentTagFactoryStringLengthHelpers(t *testing.T) {
+  parse := func(name string, value string) []schemametadata.IMetadataTypeTag {
+    t.Helper()
+    reports := []string{}
+    record := metadataCommentTagFactory_parse(struct {
+      Report func(msg string) any
+      Tag    schemametadata.IJsDocTagInfo
+    }{
+      Report: func(msg string) any {
+        reports = append(reports, msg)
+        return nil
+      },
+      Tag: schemametadata.IJsDocTagInfo{
+        Name: name,
+        Text: []schemametadata.IJsDocTagInfo_IText{{Text: value}},
+      },
+    })
+    if len(reports) != 0 {
+      t.Fatalf("@%s %s reported errors: %#v", name, value, reports)
+    }
+    return record["string"]
+  }
+
+  length := parse("length", "3")
+  if len(length) != 2 ||
+    length[0].Validate != `$importInternal("_stringLengthGte")($input, 3)` ||
+    length[1].Validate != `$importInternal("_stringLengthLte")($input, 3)` {
+    t.Fatalf("@length must emit both comparison helpers: %#v", length)
+  }
+  minimum := parse("minLength", "2")
+  if len(minimum) != 1 || minimum[0].Validate != `$importInternal("_stringLengthGte")($input, 2)` {
+    t.Fatalf("@minLength must emit the lower-bound helper: %#v", minimum)
+  }
+  maximum := parse("maxLength", "4")
+  if len(maximum) != 1 || maximum[0].Validate != `$importInternal("_stringLengthLte")($input, 4)` {
+    t.Fatalf("@maxLength must emit the upper-bound helper: %#v", maximum)
+  }
+}