typia 13.1.1 → 13.2.0

package/native/core/programmers/iterate/openapi_v3_downgrader_boolean_default_test.go

@@ -0,0 +1,95 @@
+package iterate
+
+import (
+  "testing"
+)
+
+// TestOpenApiV3DowngraderCarriesBooleanKeywords verifies the 3.0 downgrade keeps
+// a boolean's declared keywords instead of rebuilding a bare `{"type":
+// "boolean"}`.
+//
+// The boolean branch used to append `{"type": "boolean"}` from scratch, dropping
+// `default` and every other keyword, while the number/string/reference branch
+// carried theirs through `omit_examples`. So a `boolean & Default<true>` kept
+// `default` under 3.1 but lost it under 3.0, contradicting
+// `OpenApiV3.IJsonSchema.IBoolean`, which declares `default` (and the shared
+// `title`/`description`/`deprecated` attributes). The expectations below come
+// from that declared type: only keys it allows may survive, and `examples` — the
+// one 3.0 does not define — must not.
+//
+// 1. Downgrade a boolean carrying `default`, and one also carrying attributes.
+// 2. Assert each keeps every declared keyword and drops only `examples`.
+// 3. Assert a keyword-less boolean still degrades to a bare `{"type": "boolean"}`
+//    and that a boolean inside a union keeps its `default`.
+func TestOpenApiV3DowngraderCarriesBooleanKeywords(t *testing.T) {
+  collection := OpenApiV3Downgrader_downgrade_components(&OpenApi_IComponents{})
+
+  cases := []struct {
+    label    string
+    input    JsonSchema
+    expected JsonSchema
+  }{
+    {
+      label:    "boolean carries its default",
+      input:    JsonSchema{"type": "boolean", "default": true},
+      expected: JsonSchema{"type": "boolean", "default": true},
+    },
+    {
+      label: "boolean carries default:false and shared attributes",
+      input: JsonSchema{
+        "type":        "boolean",
+        "default":     false,
+        "title":       "Enabled",
+        "description": "Whether the feature is enabled.",
+        "deprecated":  true,
+      },
+      expected: JsonSchema{
+        "type":        "boolean",
+        "default":     false,
+        "title":       "Enabled",
+        "description": "Whether the feature is enabled.",
+        "deprecated":  true,
+      },
+    },
+    {
+      // `examples` is the one attribute 3.0 does not define; the downgrade must
+      // drop it while keeping `default`.
+      label: "boolean drops examples but keeps default",
+      input: JsonSchema{
+        "type":     "boolean",
+        "default":  true,
+        "examples": map[string]any{"on": true},
+      },
+      expected: JsonSchema{"type": "boolean", "default": true},
+    },
+    {
+      label:    "keyword-less boolean stays bare",
+      input:    JsonSchema{"type": "boolean"},
+      expected: JsonSchema{"type": "boolean"},
+    },
+    {
+      label: "boolean default survives inside a union",
+      input: JsonSchema{
+        "oneOf": []JsonSchema{
+          {"type": "boolean", "default": true},
+          {"type": "number"},
+        },
+      },
+      expected: JsonSchema{
+        "oneOf": []JsonSchema{
+          {"type": "boolean", "default": true},
+          {"type": "number"},
+        },
+      },
+    },
+  }
+
+  for _, tc := range cases {
+    actual := OpenApiV3Downgrader_downgrade_schema(collection, tc.input)
+    if openApiV3DowngraderTestJSON(t, actual) != openApiV3DowngraderTestJSON(t, tc.expected) {
+      t.Fatalf("%s: got %s, want %s", tc.label,
+        openApiV3DowngraderTestJSON(t, actual),
+        openApiV3DowngraderTestJSON(t, tc.expected))
+    }
+  }
+}

package/native/core/programmers/iterate/openapi_v3_downgrader_test.go

@@ -0,0 +1,123 @@
+package iterate
+
+import (
+  "encoding/json"
+  "strings"
+  "testing"
+)
+
+// TestOpenApiV3DowngraderRewritesDialect verifies the 3.0 downgrade rewrites the
+// three constructs the emended 3.1 writer emits that OpenAPI 3.0 does not define.
+//
+// json_schema_station speaks 3.1 only: a nullable type is a `{"type": "null"}`
+// union member, a literal is `const`, and a tuple is `prefixItems`. The "3.0"
+// entry points used to relabel that document without rewriting it, so a document
+// declaring 3.0 carried keywords no conformant 3.0 consumer can read. The
+// expected shapes below come from the OpenAPI 3.0 specification, not from what
+// the downgrader happens to produce.
+//
+// 1. Downgrade a nullable atomic, a literal union, and a tuple.
+// 2. Assert each uses the 3.0 spelling: nullable flag, enum, bounded array.
+// 3. Assert no 3.1-only keyword (`const`, `prefixItems`, a null union member)
+//    survives.
+func TestOpenApiV3DowngraderRewritesDialect(t *testing.T) {
+  collection := OpenApiV3Downgrader_downgrade_components(&OpenApi_IComponents{})
+
+  cases := []struct {
+    label    string
+    input    JsonSchema
+    expected JsonSchema
+  }{
+    {
+      label: "nullable atomic uses the nullable flag",
+      input: JsonSchema{
+        "oneOf": []JsonSchema{
+          {"type": "null"},
+          {"type": "string"},
+        },
+      },
+      expected: JsonSchema{"type": "string", "nullable": true},
+    },
+    {
+      label: "literal union collapses to enum",
+      input: JsonSchema{
+        "oneOf": []JsonSchema{
+          {"const": "alpha"},
+          {"const": "beta"},
+        },
+      },
+      expected: JsonSchema{"type": "string", "enum": []any{"alpha", "beta"}},
+    },
+    {
+      // A numeric literal reaches the downgrader as the compiler's named
+      // `jsnum.Number` (underlying float64), so classifying constants by
+      // concrete type mislabels the numeric branch `object`. The named type
+      // below stands in for it.
+      label: "mixed literal union labels the numeric branch number",
+      input: JsonSchema{
+        "oneOf": []JsonSchema{
+          {"const": "three"},
+          {"const": openApiV3DowngraderTestNumber(1)},
+          {"const": openApiV3DowngraderTestNumber(2)},
+        },
+      },
+      expected: JsonSchema{
+        "oneOf": []JsonSchema{
+          {"type": "string", "enum": []any{"three"}},
+          {"type": "number", "enum": []any{openApiV3DowngraderTestNumber(1), openApiV3DowngraderTestNumber(2)}},
+        },
+      },
+    },
+    {
+      label: "tuple degrades to a bounded array",
+      input: JsonSchema{
+        "type": "array",
+        "prefixItems": []JsonSchema{
+          {"type": "string"},
+          {"type": "number"},
+        },
+        "additionalItems": false,
+      },
+      expected: JsonSchema{
+        "type": "array",
+        "items": JsonSchema{
+          "oneOf": []JsonSchema{
+            {"type": "string"},
+            {"type": "number"},
+          },
+        },
+        "minItems": 2,
+        "maxItems": 2,
+      },
+    },
+  }
+
+  for _, tc := range cases {
+    actual := OpenApiV3Downgrader_downgrade_schema(collection, tc.input)
+    if openApiV3DowngraderTestJSON(t, actual) != openApiV3DowngraderTestJSON(t, tc.expected) {
+      t.Fatalf("%s: got %s, want %s", tc.label,
+        openApiV3DowngraderTestJSON(t, actual),
+        openApiV3DowngraderTestJSON(t, tc.expected))
+    }
+    serialized := openApiV3DowngraderTestJSON(t, actual)
+    for _, keyword := range []string{`"const"`, `"prefixItems"`, `"type":"null"`} {
+      if strings.Contains(serialized, keyword) {
+        t.Fatalf("%s: 3.1-only keyword %s leaked into 3.0 output: %s", tc.label, keyword, serialized)
+      }
+    }
+  }
+}
+
+// openApiV3DowngraderTestNumber is a named float64 type standing in for the
+// compiler's `jsnum.Number`, so the test exercises the reflected-kind path
+// rather than the plain `float64` a literal never actually carries.
+type openApiV3DowngraderTestNumber float64
+
+func openApiV3DowngraderTestJSON(t *testing.T, schema JsonSchema) string {
+  t.Helper()
+  bytes, err := json.Marshal(schema)
+  if err != nil {
+    t.Fatalf("marshal failed: %v", err)
+  }
+  return string(bytes)
+}

package/native/core/programmers/iterate/template_interpolation_tags_test.go

@@ -141,10 +141,10 @@ func TestTemplateConstrainedCapture(t *testing.T) {
 //
 //  1. A leading literal plus a constrained number captures at index 1.
 //  2. `${n}-${n}` keeps both numbers ("-" is not number-extendable) at 1 and 2;
-//     a string with a sibling absorbs the separator and falls back entirely.
+//     a string with a sibling absorbs the separator and has no direct capture.
 //  3. A sole constrained string lowers to `([\s\S]*)`, anchored.
 //  4. A constrained bigint lowers to the integer-only `([+-]?\d+)`, anchored.
-//  5. A constrained placeholder adjacent to a variable-width neighbor falls back.
+//  5. An ambiguous placeholder has no direct capture; backtracking owns it.
 //  6. A template with no constrained placeholder yields no captures and the
 //     historical pattern.
 func TestTemplateRuntimePattern(t *testing.T) {
@@ -169,10 +169,10 @@ func TestTemplateRuntimePattern(t *testing.T) {
   }
 
   // A string with a sibling absorbs the "-" (greedy `[\s\S]*`), unpinning both
-  // itself and the number, so the whole template falls back to no captures.
+  // itself and the number, so the direct-capture path stays empty.
   _, captures = template_runtime_pattern([]*nativemetadata.MetadataSchema{str, iterateLiteral("-"), numberB})
   if len(captures) != 0 {
-    t.Fatalf("string-with-sibling template must fall back, got %#v", captures)
+    t.Fatalf("string-with-sibling template must not capture directly, got %#v", captures)
   }
 
   // A constrained string captures every character (newlines included) via
@@ -197,15 +197,15 @@ func TestTemplateRuntimePattern(t *testing.T) {
 
   // A constrained placeholder adjacent to a variable-width neighbor (here an
   // unconstrained string before the number, with no literal between) is
-  // ambiguous under greedy matching, so it falls back to structural-only
-  // matching with no capture — rather than risking a false negative.
+  // ambiguous under greedy matching, so it has no direct capture; the checker
+  // routes the template to existential backtracking instead.
   _, captures = template_runtime_pattern([]*nativemetadata.MetadataSchema{iterateAtomic("string"), number})
   if len(captures) != 0 {
     t.Fatalf("number adjacent to a variable-width neighbor must not be captured, got %#v", captures)
   }
   _, captures = template_runtime_pattern([]*nativemetadata.MetadataSchema{str, numberB})
   if len(captures) != 0 {
-    t.Fatalf("two adjacent constrained placeholders must both fall back, got %#v", captures)
+    t.Fatalf("two adjacent constrained placeholders must not capture directly, got %#v", captures)
   }
 
   pattern, captures = template_runtime_pattern([]*nativemetadata.MetadataSchema{iterateLiteral("plain"), iterateAtomic("string")})
@@ -217,11 +217,43 @@ func TestTemplateRuntimePattern(t *testing.T) {
   }
 }
 
+// TestTemplateRequiresBacktracking separates unique captures from ambiguous
+// boundary searches and keeps each searched placeholder's standalone pattern
+// faithful to its runtime base type.
+func TestTemplateRequiresBacktracking(t *testing.T) {
+  number := iterateTemplateAtomic("number", [][]nativemetadata.IMetadataTypeTag{{{Name: "Minimum<10>", Validate: "10 <= $input"}}})
+  str := iterateTemplateAtomic("string", [][]nativemetadata.IMetadataTypeTag{{{Name: "MinLength<3>", Validate: "$input.length >= 3"}}})
+
+  cases := []struct {
+    name string
+    row  []*nativemetadata.MetadataSchema
+    want bool
+  }{
+    {"unique suffix", []*nativemetadata.MetadataSchema{iterateLiteral("v"), number}, false},
+    {"adjacent placeholders", []*nativemetadata.MetadataSchema{iterateAtomic("string"), number}, true},
+    {"safe numeric fence", []*nativemetadata.MetadataSchema{number, iterateLiteral("-"), number}, false},
+    {"decimal fence", []*nativemetadata.MetadataSchema{number, iterateLiteral("."), iterateAtomic("number")}, true},
+    {"repeated string fence", []*nativemetadata.MetadataSchema{iterateAtomic("string"), iterateLiteral("X"), str}, true},
+  }
+  for _, tc := range cases {
+    if got := template_requires_backtracking(tc.row); got != tc.want {
+      t.Fatalf("template_requires_backtracking(%s) = %v, want %v", tc.name, got, tc.want)
+    }
+  }
+
+  if got := template_backtracking_pattern(str); got != "^[\\s\\S]*$" {
+    t.Fatalf("constrained string backtracking pattern = %q", got)
+  }
+  if got := template_backtracking_pattern(iterateAtomic("bigint")); got != "^[+-]?\\d+$" {
+    t.Fatalf("bigint backtracking pattern = %q", got)
+  }
+}
+
 // TestTemplateClearBoundary gates capture on boundaries the greedy regex pins.
 //
 // A placeholder is captured only when, on each side, the template edge or a
 // literal whose first character its relevant variable neighbor cannot absorb
-// pins it; otherwise the split can slide and it falls back.
+// pins it; otherwise the split can slide and requires backtracking.
 //
 //  1. A single literal segment is a boundary; an atomic, a multi-value constant,
 //     and nil are not.

package/native/core/programmers/iterate/template_runtime_pattern.go

@@ -25,6 +25,17 @@ type templateCapture struct {
   Atomic *nativemetadata.MetadataAtomic
 }
 
+// TemplateRuntimePattern returns the structural regular-expression pattern the
+// runtime template checker uses for one template-literal row.
+//
+// Consumers that only need template membership can share the checker's exact
+// pattern without duplicating its lowering. Runtime tag conditions remain owned
+// by Check_template because they require the checker context and capture map.
+func TemplateRuntimePattern(row []*nativemetadata.MetadataSchema) string {
+  pattern, _ := template_runtime_pattern(row)
+  return pattern
+}
+
 // template_runtime_pattern builds the structural regex of a template literal for
 // the runtime checker and, alongside it, the capture map of every constrained
 // interpolation placeholder.
@@ -84,10 +95,47 @@ func template_runtime_pattern(row []*nativemetadata.MetadataSchema) (string, []t
   return nativeutils.PatternUtil.Fix(strings.Join(parts, "")), captures
 }
 
+// template_requires_backtracking reports whether a constrained placeholder has
+// an ambiguous boundary. Such a template cannot validate tags from the single
+// greedy capture selected by RegExp.exec; the checker must instead search the
+// possible placeholder boundaries and accept when any complete split satisfies
+// every structural and tag predicate.
+func template_requires_backtracking(row []*nativemetadata.MetadataSchema) bool {
+  for i, meta := range row {
+    if _, _, ok := template_constrained_capture(meta); ok && template_clear_boundary(row, i) == false {
+      return true
+    }
+  }
+  return false
+}
+
+// template_backtracking_pattern is the whole-substring structural predicate
+// used for one placeholder during existential boundary search. Constrained
+// string and bigint placeholders retain the runtime capture semantics from
+// template_runtime_pattern: strings include newlines and bigints are integers.
+func template_backtracking_pattern(meta *nativemetadata.MetadataSchema) string {
+  sub := metadata_to_pattern(struct {
+    top      bool
+    metadata *nativemetadata.MetadataSchema
+  }{
+    top:      false,
+    metadata: meta,
+  })
+  if meta != nil && meta.Bucket() == 1 && len(meta.Atomics) == 1 && meta.Atomics[0].Type == "bigint" {
+    sub = "[+-]?\\d+"
+  } else if _, kind, ok := template_constrained_capture(meta); ok {
+    switch kind {
+    case "string":
+      sub = "[\\s\\S]*"
+    }
+  }
+  return nativeutils.PatternUtil.Fix(sub)
+}
+
 // template_clear_boundary reports whether the placeholder at row[i] is delimited
 // strongly enough that the greedy structural regex assigns it a unique — hence
-// correct — substring. An ambiguous placeholder falls back to structural-only
-// matching (tag unenforced, as before) rather than risking a false negative.
+// correct — substring. Ambiguous placeholders skip direct capture and are
+// validated by the existential matcher in check_template_backtracking.
 //
 // Two adjacent variable-width placeholders slide their shared boundary iff the
 // left one can extend over the first character of the literal between them: a
@@ -100,9 +148,9 @@ func template_runtime_pattern(row []*nativemetadata.MetadataSchema) (string, []t
 //   - `${n}-${n}` (#1965): "-" is not in a number's right-extension set, so both
 //     numbers are pinned and enforced.
 //   - `${number}.${number}` / IP grids: "." extends a number (decimal), so the
-//     split slides ("5.9.1.1.1" splits as 5.9|… or 5|9.1|…) — fall back.
+//     split slides ("5.9.1.1.1" splits as 5.9|… or 5|9.1|…) — backtrack.
 //   - `${string}-${number}` / `${string}X${string}`: a string absorbs any
-//     character, so a string with any sibling falls back.
+//     character, so a string with any sibling needs backtracking.
 //   - `a${string}b` / `prefix${string}suffix` / `${number}%` / `CODE-${string}`:
 //     sole placeholder, the `^`/`$` anchors pin both ends — enforced.
 func template_clear_boundary(row []*nativemetadata.MetadataSchema, i int) bool {
@@ -141,7 +189,7 @@ func template_boundary_safe(row []*nativemetadata.MetadataSchema, i int, dir int
 
 // template_variable_kind returns the base type a variable placeholder matches:
 // "number", "bigint", or "string". Anything else (boolean, unions, constants)
-// is treated as "string" — conservatively absorbing, so its neighbor falls back.
+// is treated as "string" — conservatively absorbing, so its neighbor backtracks.
 func template_variable_kind(meta *nativemetadata.MetadataSchema) string {
   if meta != nil && meta.Bucket() == 1 && len(meta.Atomics) == 1 {
     switch meta.Atomics[0].Type {
@@ -171,16 +219,24 @@ func template_right_extends(kind string, ch rune) bool {
 
 // template_literal_first returns the first character of a literal segment's text.
 func template_literal_first(meta *nativemetadata.MetadataSchema) (rune, bool) {
-  if meta == nil || len(meta.Constants) == 0 || len(meta.Constants[0].Values) == 0 {
+  value, ok := template_literal_value(meta)
+  if ok == false {
     return 0, false
   }
-  runes := []rune(fmt.Sprint(meta.Constants[0].Values[0].Value))
+  runes := []rune(value)
   if len(runes) == 0 {
     return 0, false
   }
   return runes[0], true
 }
 
+func template_literal_value(meta *nativemetadata.MetadataSchema) (string, bool) {
+  if template_is_literal(meta) == false || len(meta.Constants) == 0 || len(meta.Constants[0].Values) == 0 {
+    return "", false
+  }
+  return fmt.Sprint(meta.Constants[0].Values[0].Value), true
+}
+
 // template_is_literal reports whether a row element is a single fixed literal
 // segment (exactly one constant value), i.e. a fixed-width boundary between
 // placeholders.

package/native/core/programmers/json/JsonApplicationProgrammer.go

@@ -51,19 +51,31 @@ func (jsonApplicationProgrammerNamespace) Validate(props struct {
     }
     least := false
     for _, p := range object.Properties {
-      value := p.Value
+      // Resolve the function through any `type` alias exactly as
+      // WriteApplication does, so an aliased function is recognized as a
+      // function property here too. Otherwise `p.Value.Functions` is empty for
+      // an aliased member and every check below is skipped, letting
+      // WriteApplication silently drop the malformed function (issue #2216,
+      // reopening #2195 for aliased members).
+      value := jsonApplicationProgrammer_unaliasFunctions(p.Value)
       if len(value.Functions) != 0 {
         least = true
-        if valid == false {
-          if len(value.Functions) != 1 || value.Size() != 1 {
-            output = append(output, "JSON application's function type does not allow union type.")
-          }
-          if value.IsRequired() == false {
-            output = append(output, "JSON application's function type must be required.")
-          }
-          if value.Nullable == true {
-            output = append(output, "JSON application's function type must not be nullable.")
-          }
+        // These per-function shape checks must run for every function
+        // property, independent of the top-level `valid`: otherwise a
+        // malformed function (union/optional/nullable) is silently dropped by
+        // WriteApplication with no diagnostic at all (issue #2195). The union
+        // shape comes from the unaliased value, while the reference-site
+        // optional/nullable modifiers stay on the raw property value: an
+        // optional or nullable alias is not unwrapped by MetadataSchema_unalias,
+        // so those two checks must read `p.Value`, not the unaliased schema.
+        if len(value.Functions) != 1 || value.Size() != 1 {
+          output = append(output, "JSON application's function type does not allow union type.")
+        }
+        if p.Value.IsRequired() == false {
+          output = append(output, "JSON application's function type must be required.")
+        }
+        if p.Value.Nullable == true {
+          output = append(output, "JSON application's function type must not be nullable.")
         }
       }
     }
@@ -370,6 +382,28 @@ func jsonApplicationProgrammer_descriptionFromParam(tags []nativemetadata.IJsDoc
   return &text
 }
 
+// jsonApplicationProgrammer_unaliasFunctions resolves the metadata schema whose
+// `Functions` decide whether a property is a function slot and how that function
+// is shaped. WriteApplication reads `len(MetadataSchema_unalias(value).Functions)`
+// for the same decision, but MetadataSchema_unalias preserves a reference-site
+// optional or nullable modifier and so stops before an optional/nullable alias.
+// This peels a pure single-alias chain past those modifiers too (guarded by
+// Size == 1 so a union stays visible), so an aliased function that is optional,
+// nullable, or a union of functions is still recognized and reported instead of
+// being silently dropped (issue #2216). A non-function alias resolves to a
+// schema with no functions and is therefore ignored, exactly as before.
+func jsonApplicationProgrammer_unaliasFunctions(value *nativemetadata.MetadataSchema) *nativemetadata.MetadataSchema {
+  visited := map[*nativemetadata.MetadataSchema]struct{}{}
+  for len(value.Functions) == 0 && len(value.Aliases) == 1 && value.Size() == 1 {
+    if _, ok := visited[value]; ok {
+      break
+    }
+    visited[value] = struct{}{}
+    value = value.Aliases[0].Type.Value
+  }
+  return value
+}
+
 func jsonApplicationProgrammer_hidden(tags []nativemetadata.IJsDocTagInfo) bool {
   for _, tag := range tags {
     if tag.Name == "hidden" || tag.Name == "ignore" || tag.Name == "internal" {

package/native/core/programmers/json/JsonSchemasProgrammer.go

@@ -102,12 +102,22 @@ func (jsonSchemasProgrammerNamespace) WriteSchemas(props struct {
   return jsonSchemasProgrammer_writeV3_1(props.Metadatas)
 }
 
+// jsonSchemasProgrammer_writeV3_0 builds the emended 3.1 document and rewrites
+// it into the OpenAPI 3.0 dialect. The version string is a claim about the
+// content, so relabeling the 3.1 document alone would emit `const`,
+// `prefixItems`, and 3.1 nullable type unions under a "3.0" banner that no
+// conformant 3.0 consumer can read.
 func jsonSchemasProgrammer_writeV3_0(metadataList []*nativemetadata.MetadataSchema) JsonSchemasProgrammer_IJsonSchemaCollection {
   collection := jsonSchemasProgrammer_writeV3_1(metadataList)
+  downgrader := nativeiterate.OpenApiV3Downgrader_downgrade_components(collection.Components)
+  schemas := make([]nativeiterate.JsonSchema, 0, len(collection.Schemas))
+  for _, schema := range collection.Schemas {
+    schemas = append(schemas, nativeiterate.OpenApiV3Downgrader_downgrade_schema(downgrader, schema))
+  }
   return JsonSchemasProgrammer_IJsonSchemaCollection{
     Version:    "3.0",
-    Components: collection.Components,
-    Schemas:    collection.Schemas,
+    Components: downgrader.Downgraded,
+    Schemas:    schemas,
   }
 }
 

package/native/core/programmers/json/JsonStringifyProgrammer.go

@@ -278,7 +278,34 @@ func jsonStringifyProgrammer_decode(props struct {
       Value: func() *shimast.Node {
         next := props
         next.Metadata = metadata
-        return jsonStringifyProgrammer_decode_to_json(next)
+        resolved := jsonStringifyProgrammer_decode_to_json(next)
+        if isDate {
+          return resolved
+        }
+        // The arm's own test is `typeof input.toJSON === "function"`, but an arm
+        // test is not always emitted — a sole arm needs no choice, and a final
+        // arm is the else — while this value *calls* `toJSON`. Leaving the call
+        // to be guarded by the arm meant a value whose `toJSON` is not callable
+        // threw `input.toJSON is not a function` from inside the serializer,
+        // including under `isStringify` and `validateStringify`, whose contract
+        // is to answer rather than throw (samchon/typia#2271).
+        //
+        // The guard therefore belongs to the call. `JSON.stringify` ignores a
+        // non-callable `toJSON` and serializes the object itself, and the
+        // metadata already carries that shape, so the fallback describes the
+        // original rather than inventing an answer. `Date` keeps the plain form:
+        // its arm is `instanceof Date`, and a real Date's `toJSON` is callable.
+        original := props
+        original.Metadata = props.Metadata.Escaped.Original
+        return nativefactories.ExpressionFactory.Conditional(
+          nativeprogrammers.IsProgrammer.Decode_to_json(struct {
+            Input     *shimast.Expression
+            CheckNull bool
+          }{Input: props.Input, CheckNull: false}),
+          resolved,
+          jsonStringifyProgrammer_decode(original),
+          props.Context.Emit,
+        )
       },
     })
   } else if len(props.Metadata.Functions) != 0 {
@@ -697,9 +724,10 @@ func jsonStringifyProgrammer_decode_array_inline(props jsonStringifyProgrammer_d
       Arrow *shimast.Node
     }) *shimast.Node {
       return nativehelpers.StringifyJoiner.Array(nativehelpers.StringifyJoiner_ArrayProps{
-        Input: next.Input,
-        Arrow: next.Arrow,
-        Emit:  props.Context.Emit,
+        Context: props.Context,
+        Input:   next.Input,
+        Arrow:   next.Arrow,
+        Emit:    props.Context.Emit,
       })
     },
     Array:   props.Array,
@@ -772,7 +800,7 @@ func jsonStringifyProgrammer_decode_tuple_inline(props jsonStringifyProgrammer_d
     } else {
       explore.Postfix = fmt.Sprintf("\"[%d]\"", index)
     }
-    elements = append(elements, jsonStringifyProgrammer_decode(struct {
+    code := jsonStringifyProgrammer_decode(struct {
       Context   nativecontext.ITypiaContext
       Config    nativeinternal.FeatureProgrammer_IConfig
       Functor   *nativehelpers.FunctionProgrammer
@@ -788,7 +816,20 @@ func jsonStringifyProgrammer_decode_tuple_inline(props jsonStringifyProgrammer_d
       Metadata:  elem,
       Explore:   explore,
       Validated: props.Validated,
-    }))
+    })
+    if nativehelpers.StringifyJoiner_ResultUndefinable(elem) {
+      // A tuple slot holds its position, so an element that serializes to
+      // nothing is `null` rather than omitted; without this its text was the
+      // literal `undefined` (#2253).
+      code = f.NewCallExpression(
+        jsonStringifyProgrammer_internal(props.Context, "jsonStringifyElement"),
+        nil,
+        nil,
+        f.NewNodeList([]*shimast.Node{code}),
+        shimast.NodeFlagsNone,
+      )
+    }
+    elements = append(elements, code)
   }
   var rest *shimast.Node
   if len(props.Tuple.Elements) != 0 {

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

@@ -139,16 +139,18 @@ func (llmApplicationProgrammerNamespace) Validate(props struct {
       }
       least = true
       name := fmt.Sprintf("%q", *rawName)
-      if isValidType == false {
-        if len(value.Functions) != 1 || value.Size() != 1 {
-          output = append(output, "LLM application's function ("+name+") type does not allow union type.")
-        }
-        if value.IsRequired() == false {
-          output = append(output, "LLM application's function ("+name+") type must be required.")
-        }
-        if value.Nullable {
-          output = append(output, "LLM application's function ("+name+") type must not be nullable.")
-        }
+      // These per-function shape checks must run for every function property,
+      // independent of the top-level `isValidType`: otherwise a malformed
+      // function (union/optional/nullable) is silently dropped by
+      // WriteApplication with no diagnostic at all (issue #2195).
+      if len(value.Functions) != 1 || value.Size() != 1 {
+        output = append(output, "LLM application's function ("+name+") type does not allow union type.")
+      }
+      if value.IsRequired() == false {
+        output = append(output, "LLM application's function ("+name+") type must be required.")
+      }
+      if value.Nullable {
+        output = append(output, "LLM application's function ("+name+") type must not be nullable.")
       }
       prefix := "LLM application's function (" + name + ")"
       output = append(output, llmApplicationProgrammer_validateName(prefix, *rawName)...)
@@ -238,7 +240,15 @@ func (llmApplicationProgrammerNamespace) WriteApplication(props struct {
       functions = append(functions, written)
     }
   }
-  result := map[string]any{"functions": functions}
+  // The call site's schema configuration is resolved here and nowhere else, so
+  // it travels with the emitted application; the runtime finalizer only adds
+  // the validate hook to it. Rebuilding it at runtime reported `strict: false`
+  // for a strict build (issue #2293).
+  strict, _ := props.Config["strict"].(bool)
+  result := map[string]any{
+    "config":    map[string]any{"strict": strict},
+    "functions": functions,
+  }
   if len(metadata.Objects) != 0 {
     if object := metadata.Objects[0].Type; object != nil {
       if description := llmApplicationProgrammer_describe(object.Description, object.JsDocTags); description != nil && len(*description) != 0 {