typia 13.1.1 → 13.2.0

package/native/core/programmers/llm/LlmSchemaProgrammer.go

@@ -154,8 +154,9 @@ func (llmSchemaProgrammerNamespace) Validate(props struct {
         }
       }
     }
-    // OpenAI strict structured outputs cannot express the `not` keyword the
-    // exclude tag compiles to (supported subset: types, enum, anyOf, $defs).
+    // The strict schema subset typia emits has no `not` keyword, which is what
+    // the exclude tag compiles to, so an exclude tag has no representation here
+    // and is rejected.
     excluded := false
     scan := func(matrix [][]schemametadata.IMetadataTypeTag) {
       for _, row := range matrix {
@@ -318,7 +319,7 @@ func llmSchemaProgrammer_convert_schema_config(schema nativeiterate.JsonSchema,
           defs[key] = llmSchemaProgrammer_convert_schema_config(target, components, defs, config)
         }
       }
-      union = append(union, map[string]any{"$ref": "#/$defs/" + key})
+      union = append(union, map[string]any{"$ref": llmSchemaProgrammer_encode_reference(key)})
       return
     }
     if input["type"] == "object" {
@@ -643,6 +644,23 @@ func llmSchemaProgrammer_ref_key(ref string) string {
   return ref[index+1:]
 }
 
+func llmSchemaProgrammer_encode_reference(key string) string {
+  token := strings.NewReplacer("~", "~0", "/", "~1").Replace(key)
+  var output strings.Builder
+  output.WriteString("#/$defs/")
+  for _, value := range []byte(token) {
+    if (value >= 'A' && value <= 'Z') ||
+      (value >= 'a' && value <= 'z') ||
+      (value >= '0' && value <= '9') ||
+      strings.ContainsRune("-_.!~*'()", rune(value)) {
+      output.WriteByte(value)
+    } else {
+      fmt.Fprintf(&output, "%%%02X", value)
+    }
+  }
+  return output.String()
+}
+
 func llmSchemaProgrammer_component(components *nativeiterate.OpenApi_IComponents, key string) (nativeiterate.JsonSchema, bool) {
   if components == nil || components.Schemas == nil {
     return nil, false
@@ -677,7 +695,7 @@ func llmSchemaProgrammer_discriminator(schema nativeiterate.JsonSchema, union []
   if rawMapping, ok := llmSchemaProgrammer_schema_map(discriminator["mapping"]); ok {
     mapping := map[string]any{}
     for key, value := range rawMapping {
-      mapping[key] = "#/$defs/" + llmSchemaProgrammer_ref_key(fmt.Sprint(value))
+      mapping[key] = llmSchemaProgrammer_encode_reference(llmSchemaProgrammer_ref_key(fmt.Sprint(value)))
     }
     output["mapping"] = mapping
   }
@@ -712,14 +730,13 @@ func llmSchemaProgrammer_shift_numeric(schema map[string]any) map[string]any {
   output := llmSchemaProgrammer_clone(schema)
   llmSchemaProgrammer_emend_exclusive(output)
   tags := []string{}
-  for _, key := range []string{"minimum", "maximum", "exclusiveMinimum", "exclusiveMaximum", "multipleOf"} {
+  for _, key := range []string{"minimum", "maximum", "exclusiveMinimum", "exclusiveMaximum", "multipleOf", "default"} {
     if value, ok := output[key]; ok {
       tags = append(tags, "@"+key+" "+fmt.Sprint(value))
       delete(output, key)
     }
   }
   llmSchemaProgrammer_write_tag_with_description(output, tags)
-  delete(output, "default")
   return output
 }
 

package/native/core/programmers/llm/llm_reference_codec_test.go

@@ -0,0 +1,24 @@
+package llm
+
+import "testing"
+
+// TestLlmReferenceCodec locks JSON Pointer token escaping before URI-fragment encoding.
+func TestLlmReferenceCodec(t *testing.T) {
+  t.Parallel()
+  cases := map[string]string{
+    "Plain": "#/$defs/Plain",
+    "":      "#/$defs/",
+    "A/B":   "#/$defs/A~1B",
+    "T~N":   "#/$defs/T~0N",
+    "A~/B":  "#/$defs/A~0~1B",
+    "~1":    "#/$defs/~01",
+    "A B":   "#/$defs/A%20B",
+    "C%D":   "#/$defs/C%25D",
+    "Café":  "#/$defs/Caf%C3%A9",
+  }
+  for key, expected := range cases {
+    if actual := llmSchemaProgrammer_encode_reference(key); actual != expected {
+      t.Fatalf("encode %q: expected %q, got %q", key, expected, actual)
+    }
+  }
+}

package/native/core/programmers/notations/NotationGeneralProgrammer.go

@@ -3,6 +3,7 @@ package notations
 import (
   "fmt"
   "strings"
+  "unicode/utf8"
 
   shimast "github.com/microsoft/typescript-go/shim/ast"
   shimchecker "github.com/microsoft/typescript-go/shim/checker"
@@ -14,6 +15,8 @@ import (
   nativeinternal "github.com/samchon/typia/packages/typia/native/core/programmers/internal"
   nativeiterate "github.com/samchon/typia/packages/typia/native/core/programmers/iterate"
   schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+  "golang.org/x/text/cases"
+  "golang.org/x/text/language"
 )
 
 type notationGeneralProgrammerNamespace struct{}
@@ -1017,7 +1020,26 @@ func notationGeneralProgrammer_configure(props struct {
       },
       Joiner: func(next nativeinternal.FeatureProgrammer_ObjectorJoinerProps) *shimast.Node {
         return nativehelpers.NotationJoiner.Object(nativehelpers.NotationJoiner_ObjectProps{
-          Rename:  props.Rename.Func,
+          Rename: props.Rename.Func,
+          DynamicRename: func() *shimast.Node {
+            return notationGeneralProgrammer_internal(props.Context, "notation"+notationGeneralProgrammer_capitalize(props.Rename.Name))
+          },
+          DynamicAssign: func() *shimast.Node {
+            return notationGeneralProgrammer_internal(props.Context, "notationAssign")
+          },
+          ThrowCollision: func(first string, second string, destination string) *shimast.Node {
+            return f.NewCallExpression(
+              notationGeneralProgrammer_internal(props.Context, "notationKeyCollision"),
+              nil,
+              nil,
+              f.NewNodeList([]*shimast.Node{
+                f.NewStringLiteral(first, shimast.TokenFlagsNone),
+                f.NewStringLiteral(second, shimast.TokenFlagsNone),
+                f.NewStringLiteral(destination, shimast.TokenFlagsNone),
+              }),
+              shimast.NodeFlagsNone,
+            )
+          },
           Input:   next.Input,
           Entries: next.Entries,
           Emit:    props.Context.Emit,
@@ -1320,51 +1342,154 @@ var NotationGeneralProgrammer_Pascal = NotationGeneralProgrammer_IRename{Name: "
 var NotationGeneralProgrammer_Snake = NotationGeneralProgrammer_IRename{Name: "snake", Func: notationGeneralProgrammer_snake}
 var NotationGeneralProgrammer_Kebab = NotationGeneralProgrammer_IRename{Name: "kebab", Func: notationGeneralProgrammer_kebab}
 
-func notationGeneralProgrammer_camel(str string) string {
-  return notationGeneralProgrammer_unsnake(str, func(value string) string {
-    if value == "" {
-      return value
-    }
-    if value == strings.ToUpper(value) {
-      return strings.ToLower(value)
-    }
-    return strings.ToLower(value[:1]) + value[1:]
-  }, func(value string, index int) string {
-    if index == 0 {
-      return strings.ToLower(value)
-    }
-    return notationGeneralProgrammer_capitalize(strings.ToLower(value))
-  })
+// notationGeneralProgrammer_toUpper and notationGeneralProgrammer_toLower
+// reproduce JavaScript's `String.prototype.toUpperCase` / `toLowerCase`, which
+// is the case operation the runtime helpers (`_notationCamel`,
+// `_notationPascal`, `_notationSnake`) and the `CamelCase<T>` / `PascalCase<T>`
+// typings both apply. JavaScript performs Unicode *full* case conversion, while
+// `strings.ToUpper` / `strings.ToLower` perform the *simple* per-rune mapping,
+// so the two disagree wherever a code point maps to a different number of code
+// points or depends on context: `ß` -> `SS`, `İ` -> `i` + U+0307, `fi` -> `FI`,
+// and the word-final sigma `ΑΣ` -> `ας`. Emitting a key through the simple
+// mapping would make the compile-time emit disagree with the runtime helper and
+// with the declared `*Case<T>` return type. `language.Und` selects the
+// locale-independent root mapping, matching JavaScript's locale-independent
+// `toUpperCase` / `toLowerCase` (as opposed to `toLocaleUpperCase`).
+//
+// A `cases.Caser` carries mutable state and must not be shared across
+// goroutines, so each call builds its own; notation renaming runs once per
+// object key at compile time, not on a hot path.
+func notationGeneralProgrammer_toUpper(str string) string {
+  return cases.Upper(language.Und).String(str)
 }
 
-func notationGeneralProgrammer_pascal(str string) string {
-  return notationGeneralProgrammer_unsnake(str, func(value string) string {
-    if value == "" {
-      return value
-    }
-    return strings.ToUpper(value[:1]) + value[1:]
-  }, func(value string, index int) string {
-    return notationGeneralProgrammer_capitalize(value)
-  })
+func notationGeneralProgrammer_toLower(str string) string {
+  return cases.Lower(language.Und).String(str)
 }
 
-func notationGeneralProgrammer_snake(str string) string {
-  if str == "" {
-    return str
+// notationGeneralProgrammer_head splits str after the character a JavaScript
+// `str[0]` expression addresses, returning that head and the remainder.
+//
+// The runtime helpers and the `*Case<T>` typings capitalize a key by indexing
+// its first character, so the emit has to slice at the same boundary. Slicing
+// by byte (`str[:1]`) instead splits a multi-byte UTF-8 rune and hands a lone
+// lead byte to the case operation, which cannot decode it and substitutes
+// U+FFFD — `École` was emitted as `��cole`.
+func notationGeneralProgrammer_head(str string) (string, string) {
+  _, size := utf8.DecodeRuneInString(str)
+  return str[:size], str[size:]
+}
+
+// notationGeneralProgrammer_upperHead and notationGeneralProgrammer_lowerHead
+// case-convert a head produced by notationGeneralProgrammer_head the way
+// `str[0].toUpperCase()` / `str[0].toLowerCase()` does.
+//
+// JavaScript indexes a string by UTF-16 code unit, so `str[0]` of an astral
+// character is its lone high surrogate, and no case mapping applies to an
+// unpaired surrogate. Such a head is therefore returned verbatim rather than
+// case-mapped, which is what keeps a Deseret or Adlam key stable across the
+// emit, the runtime helper, and the type.
+func notationGeneralProgrammer_upperHead(head string) string {
+  if r, _ := utf8.DecodeRuneInString(head); r > 0xFFFF {
+    return head
+  }
+  return notationGeneralProgrammer_toUpper(head)
+}
+
+func notationGeneralProgrammer_lowerHead(head string) string {
+  if r, _ := utf8.DecodeRuneInString(head); r > 0xFFFF {
+    return head
   }
+  return notationGeneralProgrammer_toLower(head)
+}
+
+// notationGeneralProgrammer_rename is the shared outer walk for the
+// camel/pascal notations. It mirrors the `CamelCase<T>` / `PascalCase<T>`
+// typings: leading underscores are preserved verbatim, an all-underscore key
+// stays untouched, and the presence of any remaining underscore — not the
+// number of non-empty segments — selects the snake conversion. Routing on
+// underscore presence keeps a trailing or doubled underscore (`fooBar_`) on the
+// same path the type takes, instead of collapsing it to the plain path.
+func notationGeneralProgrammer_rename(str string, plain func(string) string, snake func(string) string) string {
   prefix := ""
   for len(str) != 0 && str[0] == '_' {
     prefix += "_"
     str = str[1:]
   }
-  out := func(value string) string { return prefix + value }
-  items := strings.Split(str, "_")
-  if len(items) > 1 {
-    for i, item := range items {
-      items[i] = strings.ToLower(item)
+  if str == "" {
+    return prefix
+  }
+  if strings.Contains(str, "_") {
+    return prefix + snake(str)
+  }
+  return prefix + plain(str)
+}
+
+func notationGeneralProgrammer_camel(str string) string {
+  return notationGeneralProgrammer_rename(str, func(value string) string {
+    if value == notationGeneralProgrammer_toUpper(value) {
+      return notationGeneralProgrammer_toLower(value)
     }
-    return out(strings.Join(items, "_"))
+    head, tail := notationGeneralProgrammer_head(value)
+    return notationGeneralProgrammer_lowerHead(head) + tail
+  }, notationGeneralProgrammer_camel_snake)
+}
+
+// notationGeneralProgrammer_camel_snake mirrors `CamelizeSnakeString`: the
+// character after each underscore is uppercased and everything else lowercased.
+// A trailing underscore leaves no character to uppercase, so the whole key is
+// lowercased; a doubled underscore collapses to a single one before continuing.
+func notationGeneralProgrammer_camel_snake(str string) string {
+  for len(str) != 0 && str[0] == '_' {
+    str = str[1:]
+  }
+  if str == "" {
+    return ""
   }
+  index := strings.IndexByte(str, '_')
+  if index < 0 || index+1 >= len(str) {
+    return notationGeneralProgrammer_toLower(str)
+  }
+  if str[index+1] == '_' {
+    return notationGeneralProgrammer_camel_snake(str[:index] + "_" + str[index+2:])
+  }
+  // The character after the underscore is one whole rune, not one byte; `_` is
+  // ASCII so it never falls inside a multi-byte sequence and `index` stays a
+  // valid boundary.
+  middle, rest := notationGeneralProgrammer_head(str[index+1:])
+  return notationGeneralProgrammer_toLower(str[:index]) + notationGeneralProgrammer_upperHead(middle) + notationGeneralProgrammer_camel_snake(rest)
+}
+
+func notationGeneralProgrammer_pascal(str string) string {
+  return notationGeneralProgrammer_rename(str, func(value string) string {
+    head, tail := notationGeneralProgrammer_head(value)
+    return notationGeneralProgrammer_upperHead(head) + tail
+  }, notationGeneralProgrammer_pascal_snake)
+}
+
+// notationGeneralProgrammer_pascal_snake mirrors `PascalizeSnakeString`: each
+// underscore-delimited segment is capitalized and its tail lowercased
+// (`MAX_COUNT` -> `MaxCount`), with a trailing underscore dropped.
+func notationGeneralProgrammer_pascal_snake(str string) string {
+  for len(str) != 0 && str[0] == '_' {
+    str = str[1:]
+  }
+  if str == "" {
+    return ""
+  }
+  head, tail := notationGeneralProgrammer_head(str)
+  index := strings.IndexByte(str, '_')
+  if index < 0 {
+    return notationGeneralProgrammer_upperHead(head) + notationGeneralProgrammer_toLower(tail)
+  }
+  // `index` counts bytes from the start of `str`; the tail it delimits starts
+  // after the whole leading rune, hence the `len(head)` offset.
+  return notationGeneralProgrammer_upperHead(head) + notationGeneralProgrammer_toLower(tail[:index-len(head)]) + notationGeneralProgrammer_pascal_snake(str[index+1:])
+}
+
+// notationGeneralProgrammer_snake_word runs the case-boundary walk over one
+// underscore-free segment, inserting a separator at every camelCase boundary.
+func notationGeneralProgrammer_snake_word(str string) string {
   indexes := []int{}
   for i := 0; i < len(str); i++ {
     code := str[i]
@@ -1383,7 +1508,7 @@ func notationGeneralProgrammer_snake(str string) string {
     indexes = indexes[1:]
   }
   if len(indexes) == 0 {
-    return out(strings.ToLower(str))
+    return notationGeneralProgrammer_toLower(str)
   }
   ret := ""
   for i, last := range indexes {
@@ -1391,11 +1516,31 @@ func notationGeneralProgrammer_snake(str string) string {
     if i != 0 {
       first = indexes[i-1]
     }
-    ret += strings.ToLower(str[first:last])
+    ret += notationGeneralProgrammer_toLower(str[first:last])
     ret += "_"
   }
-  ret += strings.ToLower(str[indexes[len(indexes)-1]:])
-  return out(ret)
+  ret += notationGeneralProgrammer_toLower(str[indexes[len(indexes)-1]:])
+  return ret
+}
+
+func notationGeneralProgrammer_snake(str string) string {
+  if str == "" {
+    return str
+  }
+  prefix := ""
+  for len(str) != 0 && str[0] == '_' {
+    prefix += "_"
+    str = str[1:]
+  }
+  // Run the case-boundary walk within each underscore-delimited segment, not
+  // over the whole segment at once. Lowercasing a segment atomically would drop
+  // the camelCase boundary inside it (`fooBar_baz` -> `foobar_baz`), diverging
+  // from `SnakeCase<T>`; the per-segment walk keeps it (`foo_bar_baz`).
+  segments := strings.Split(str, "_")
+  for i, segment := range segments {
+    segments[i] = notationGeneralProgrammer_snake_word(segment)
+  }
+  return prefix + strings.Join(segments, "_")
 }
 
 // notationGeneralProgrammer_kebab derives the snake_case form first and then
@@ -1410,32 +1555,3 @@ func notationGeneralProgrammer_kebab(str string) string {
   }
   return prefix + strings.ReplaceAll(snaked, "_", "-")
 }
-
-func notationGeneralProgrammer_unsnake(str string, plain func(string) string, snake func(string, int) string) string {
-  prefix := ""
-  for len(str) != 0 && str[0] == '_' {
-    prefix += "_"
-    str = str[1:]
-  }
-  out := func(value string) string { return prefix + value }
-  if str == "" {
-    return out("")
-  }
-  raw := strings.Split(str, "_")
-  items := []string{}
-  for _, item := range raw {
-    if item != "" {
-      items = append(items, item)
-    }
-  }
-  if len(items) == 0 {
-    return out("")
-  }
-  if len(items) == 1 {
-    return out(plain(items[0]))
-  }
-  for i, item := range items {
-    items[i] = snake(item, i)
-  }
-  return out(strings.Join(items, ""))
-}

package/native/core/programmers/notations/notation_general_helpers_test.go

@@ -43,9 +43,7 @@ func TestNotationGeneralHelpers(t *testing.T) {
 		{NotationGeneralProgrammer_Snake.Func("helloWorldAgain"), "hello_world_again"},
 		{NotationGeneralProgrammer_Snake.Func("XMLHttp"), "xmlhttp"},
 		{NotationGeneralProgrammer_Snake.Func("__"), "__"},
-		{notationGeneralProgrammer_unsnake("__", strings.ToLower, func(value string, _ int) string {
-			return strings.ToUpper(value)
-		}), "__"},
+		{notationGeneralProgrammer_rename("__", strings.ToLower, strings.ToUpper), "__"},
 	}
 	for _, c := range cases {
 		if c.actual != c.expected {

package/native/core/programmers/notations/notation_general_programmer_pascal_multiword_test.go

@@ -0,0 +1,72 @@
+package notations
+
+import "testing"
+
+// TestNotationGeneralProgrammerPascalMultiword verifies pascal tail lowercasing.
+//
+// Issue #2183: the pascal multi-word callback capitalized each word without
+// first lowercasing its tail, so a word carrying uppercase inner characters
+// (`MAX`, `HTTP`) kept them and `MAX_COUNT` emitted `MAXCOUNT`. That diverged
+// from the runtime `_notationPascal` helper (`__notationCapitalize` = upper
+// first character, lowercase the rest) and from the declared `PascalCase<T>`
+// type, leaving `.MaxCount` undefined on the compile-time result. The sibling
+// `camel` callback already lowercased the tail, so pascal was the sole outlier.
+// The single-word `plain` path (`userID` -> `UserID`, `ID` -> `ID`, tail kept)
+// must stay untouched, because single words are dispatched to `plain` rather
+// than the multi-word callback.
+//
+//  1. Pascalize multi-word keys whose non-leading words carry uppercase or
+//     mixed-case characters, plus digits and a leading underscore, and match
+//     the `PascalCase<T>` / `_notationPascal` oracle.
+//  2. Confirm single-word keys still route through `plain` unchanged.
+//  3. Confirm camel, snake, and kebab of the same keys are unaffected.
+func TestNotationGeneralProgrammerPascalMultiword(t *testing.T) {
+  pascal := []struct{ input, expected string }{
+    // Multi-word: every word becomes upper-first + lower-rest, byte-equal to
+    // `_notationPascal` and assignable to `PascalCase<T>`.
+    {"MAX_COUNT", "MaxCount"},
+    {"HTTP_PORT", "HttpPort"},
+    {"USER_ID", "UserId"},
+    {"user_name", "UserName"},
+    {"fooBar_baz", "FoobarBaz"},
+    {"HTTP2_PORT", "Http2Port"},
+    {"MAX_COUNT_2", "MaxCount2"},
+    {"_MAX_COUNT", "_MaxCount"},
+    {"a_b_c", "ABC"},
+    // Single word: routed through `plain`, tail preserved — unchanged by the fix.
+    {"userID", "UserID"},
+    {"ID", "ID"},
+    {"MAX", "MAX"},
+    {"html5Parser", "Html5Parser"},
+    {"FirstName", "FirstName"},
+    {"_internal", "_Internal"},
+    {"XMLParser", "XMLParser"},
+  }
+  for _, c := range pascal {
+    if actual := NotationGeneralProgrammer_Pascal.Func(c.input); actual != c.expected {
+      t.Errorf("pascal(%q) == %q, expected %q", c.input, actual, c.expected)
+    }
+  }
+
+  // The fix touches pascal only; camel/snake/kebab of the same multi-word
+  // witnesses already lowercased the tail and must stay byte-for-byte the same.
+  siblings := []struct {
+    input, camel, snake, kebab string
+  }{
+    {"MAX_COUNT", "maxCount", "max_count", "max-count"},
+    {"HTTP_PORT", "httpPort", "http_port", "http-port"},
+    {"USER_ID", "userId", "user_id", "user-id"},
+    {"_MAX_COUNT", "_maxCount", "_max_count", "_max-count"},
+  }
+  for _, c := range siblings {
+    if actual := NotationGeneralProgrammer_Camel.Func(c.input); actual != c.camel {
+      t.Errorf("camel(%q) == %q, expected %q", c.input, actual, c.camel)
+    }
+    if actual := NotationGeneralProgrammer_Snake.Func(c.input); actual != c.snake {
+      t.Errorf("snake(%q) == %q, expected %q", c.input, actual, c.snake)
+    }
+    if actual := NotationGeneralProgrammer_Kebab.Func(c.input); actual != c.kebab {
+      t.Errorf("kebab(%q) == %q, expected %q", c.input, actual, c.kebab)
+    }
+  }
+}

package/native/core/programmers/notations/notation_general_programmer_underscore_boundary_test.go

@@ -0,0 +1,68 @@
+package notations
+
+import "testing"
+
+// TestNotationGeneralProgrammerUnderscoreBoundary pins the snake/kebab/camel/
+// pascal compile-time emit against the `SnakeCase`/`KebabCase`/`CamelCase`/
+// `PascalCase` type oracle on keys that mix an underscore with a case boundary.
+//
+// Issue #2190: when a key combined an internal or trailing underscore with a
+// camelCase boundary, `snake`/`kebab` lowercased each underscore-delimited
+// segment atomically (`fooBar_baz` -> `foobar_baz`) instead of walking the case
+// boundary inside the segment, and `camel`/`pascal` collapsed a trailing
+// underscore onto the underscore-free path (`fooBar_` -> `FooBar`). Both
+// disagreed with the declared `*Case<T>` type, so reading the declared key was
+// `undefined`. The expected values below are the type-oracle output, obtained by
+// revealing `keyof *Case<{ key: 1 }>` through the compiler.
+//
+//  1. Convert the underscore+case-boundary witnesses under every notation.
+//  2. Assert each equals the `*Case<T>` value byte for byte.
+//  3. Re-cover underscore-free and all-caps-segment keys so the boundary walk
+//     did not regress them (`userID`, `XMLParser`, `MAX_COUNT`, #2186's pascal).
+func TestNotationGeneralProgrammerUnderscoreBoundary(t *testing.T) {
+  type row struct {
+    input  string
+    snake  string
+    kebab  string
+    camel  string
+    pascal string
+  }
+  rows := []row{
+    // issue matrix
+    {"fooBar_baz", "foo_bar_baz", "foo-bar-baz", "foobarBaz", "FoobarBaz"},
+    {"openAI_key", "open_ai_key", "open-ai-key", "openaiKey", "OpenaiKey"},
+    {"HTTP_fooBar", "http_foo_bar", "http-foo-bar", "httpFoobar", "HttpFoobar"},
+    {"fooBar", "foo_bar", "foo-bar", "fooBar", "FooBar"},
+    {"fooBar_", "foo_bar_", "foo-bar-", "foobar_", "Foobar"},
+    {"_fooBar", "_foo_bar", "_foo-bar", "_fooBar", "_FooBar"},
+    {"userID", "user_id", "user-id", "userID", "UserID"},
+    {"a_b_c", "a_b_c", "a-b-c", "aBc", "ABC"},
+    {"MAX_COUNT", "max_count", "max-count", "maxCount", "MaxCount"},
+    // boundary edges
+    {"_fooBar_", "_foo_bar_", "_foo-bar-", "_foobar_", "_Foobar"},
+    {"fooBarBaz_", "foo_bar_baz_", "foo-bar-baz-", "foobarbaz_", "Foobarbaz"},
+    {"foo__bar", "foo__bar", "foo--bar", "fooBar", "FooBar"},
+    {"userID_", "user_id_", "user-id-", "userid_", "Userid"},
+    {"HTTP_", "http_", "http-", "http_", "Http"},
+    // regressions that must stay unchanged (no underscore / all-caps segment)
+    {"XMLParser", "xmlparser", "xmlparser", "xMLParser", "XMLParser"},
+    {"toHTML", "to_html", "to-html", "toHTML", "ToHTML"},
+    {"html5Parser", "html5_parser", "html5-parser", "html5Parser", "Html5Parser"},
+    {"iOS", "i_os", "i-os", "iOS", "IOS"},
+    {"HTTP_PORT", "http_port", "http-port", "httpPort", "HttpPort"},
+  }
+  for _, c := range rows {
+    if actual := NotationGeneralProgrammer_Snake.Func(c.input); actual != c.snake {
+      t.Errorf("snake(%q) == %q, expected %q", c.input, actual, c.snake)
+    }
+    if actual := NotationGeneralProgrammer_Kebab.Func(c.input); actual != c.kebab {
+      t.Errorf("kebab(%q) == %q, expected %q", c.input, actual, c.kebab)
+    }
+    if actual := NotationGeneralProgrammer_Camel.Func(c.input); actual != c.camel {
+      t.Errorf("camel(%q) == %q, expected %q", c.input, actual, c.camel)
+    }
+    if actual := NotationGeneralProgrammer_Pascal.Func(c.input); actual != c.pascal {
+      t.Errorf("pascal(%q) == %q, expected %q", c.input, actual, c.pascal)
+    }
+  }
+}

package/native/core/programmers/plain/PlainClassifyProgrammer.go

@@ -571,7 +571,7 @@ func plainClassifyProgrammer_decode_tuple_inline(props plainClassifyProgrammer_d
     explore := props.Explore
     explore.From = "array"
     explore.Postfix = postfix
-    elements = append(elements, plainClassifyProgrammer_decode(struct {
+    value := plainClassifyProgrammer_decode(struct {
       Context  nativecontext.ITypiaContext
       Config   nativeinternal.FeatureProgrammer_IConfig
       Functor  *nativehelpers.FunctionProgrammer
@@ -585,7 +585,18 @@ func plainClassifyProgrammer_decode_tuple_inline(props plainClassifyProgrammer_d
       Input:    f.NewElementAccessExpression(props.Input, nil, nativefactories.ExpressionFactory.Number(index, props.Context.Emit), shimast.NodeFlagsNone),
       Metadata: elem,
       Explore:  explore,
-    }))
+    })
+    if elem.Optional {
+      // An omitted optional trailing element must not become a phantom
+      // `undefined`; gate it on presence so `classify(["a"])` stays `["a"]`.
+      value = nativehelpers.CloneJoiner.OptionalTupleElement(nativehelpers.CloneJoiner_OptionalElementProps{
+        Input: props.Input,
+        Value: value,
+        Index: index,
+        Emit:  props.Context.Emit,
+      })
+    }
+    elements = append(elements, value)
   }
   var rest *shimast.Node
   if len(props.Tuple.Elements) != 0 {
@@ -631,7 +642,7 @@ func plainClassifyProgrammer_decode_native(props struct {
 }) *shimast.Node {
   f := nativecontext.EmitFactoryOf(plainClassifyProgrammer_factory, props.Context.Emit)
   switch props.Type {
-  case "Date", "Uint8Array", "Uint8ClampedArray", "Uint16Array", "Uint32Array", "BigUint64Array", "Int8Array", "Int16Array", "Int32Array", "BigInt64Array", "Float32Array", "Float64Array", "RegExp":
+  case "Date", "Uint8Array", "Uint8ClampedArray", "Uint16Array", "Uint32Array", "BigUint64Array", "Int8Array", "Int16Array", "Int32Array", "BigInt64Array", "Float32Array", "Float64Array":
     return f.NewNewExpression(
       f.NewIdentifier(props.Type),
       nil,
@@ -639,11 +650,13 @@ func plainClassifyProgrammer_decode_native(props struct {
     )
   case "ArrayBuffer", "SharedArrayBuffer":
     return plainClassifyProgrammer_decode_native_buffer(props.Type, props.Input, props.Context.Emit)
-  case "DataView":
-    return f.NewNewExpression(
-      f.NewIdentifier("DataView"),
+  case "DataView", "Blob", "File", "RegExp":
+    return f.NewCallExpression(
+      plainClassifyProgrammer_internal(props.Context, "plainCloneAny"),
+      nil,
       nil,
-      f.NewNodeList([]*shimast.Node{nativefactories.IdentifierFactory.Access(props.Context.Emit, props.Input, "buffer")}),
+      f.NewNodeList([]*shimast.Node{props.Input}),
+      shimast.NodeFlagsNone,
     )
   default:
     return f.NewCallExpression(
@@ -1571,14 +1584,9 @@ func plainClassifyProgrammer_seed_type(checker *shimchecker.Checker, sig *shimch
 // the tuple is rejected (nil = field-copy) when it is empty or any element after
 // index 0 is REQUIRED — then `[] extends Rest` fails and ClassifiableSeed is
 // `never`. GetTypeArguments / TargetTupleType require an object reference; the
-// IsTupleType caller guarantees that, but a recover degrades a surprise panic to
-// field-copy (the same safe fallback as a failed seed analysis).
-func plainClassifyProgrammer_tuple_seed(checker *shimchecker.Checker, restParamT *shimchecker.Type) (seed *shimchecker.Type) {
-  defer func() {
-    if recover() != nil {
-      seed = nil
-    }
-  }()
+// IsTupleType caller guarantees that capability. Any failure after that
+// precondition is an internal invariant violation and remains observable.
+func plainClassifyProgrammer_tuple_seed(checker *shimchecker.Checker, restParamT *shimchecker.Type) *shimchecker.Type {
   args := checker.GetTypeArguments(restParamT)
   if len(args) == 0 {
     return nil // `[]` -> ClassifiableSeed is never -> field-copy