typia 13.1.1 → 13.1.19

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

@@ -84,10 +84,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 +137,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 +178,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 +208,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/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)...)

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)
+    }
+  }
+}