typia 13.1.19 → 13.3.0

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

@@ -0,0 +1,44 @@
+package iterate
+
+import (
+  "slices"
+  "testing"
+
+  nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+)
+
+// TestJsonSchemaPatternPropertyOrderPreservesFirstPosition verifies repeated patterns keep one ordered slot.
+//
+// The legacy TypeScript producer stored pairs in a plain object: assigning an
+// existing pattern replaced its value without moving or duplicating its first
+// insertion position. The Go order record must preserve that overwrite contract.
+//
+//  1. Insert two patterns, then replace the first pattern with new metadata and schema values.
+//  2. Assert the ordered keys remain unique and the map retains the replacement pair.
+func TestJsonSchemaPatternPropertyOrderPreservesFirstPosition(t *testing.T) {
+  first := &nativemetadata.MetadataSchema{}
+  replacement := &nativemetadata.MetadataSchema{}
+  extra := json_schema_superfluous{
+    patternProperties: map[string]json_schema_metadata_schema_pair{},
+  }
+  extra.setPatternProperty("first", json_schema_metadata_schema_pair{
+    metadata: first,
+    schema:   JsonSchema{"type": "string"},
+  })
+  extra.setPatternProperty("second", json_schema_metadata_schema_pair{
+    metadata: &nativemetadata.MetadataSchema{},
+    schema:   JsonSchema{"type": "boolean"},
+  })
+  extra.setPatternProperty("first", json_schema_metadata_schema_pair{
+    metadata: replacement,
+    schema:   JsonSchema{"type": "number"},
+  })
+
+  if slices.Equal(extra.patternPropertyKeys, []string{"first", "second"}) == false {
+    t.Fatalf("pattern property order was %v", extra.patternPropertyKeys)
+  }
+  pair := extra.patternProperties["first"]
+  if pair.metadata != replacement || pair.schema["type"] != "number" {
+    t.Fatalf("replacement pair was not retained: %#v", pair)
+  }
+}

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

@@ -454,7 +454,40 @@ func openApiV3Downgrader_omit_examples(schema JsonSchema) JsonSchema {
     }
     output[key] = value
   }
-  return output
+  return openApiV3Downgrader_exclusive_bounds(output)
+}
+
+// openApiV3Downgrader_exclusive_bounds rewrites an exclusive numeric bound into
+// the form the 3.0 dialect defines.
+//
+// 3.0's Schema Object descends from JSON Schema draft-04, where
+// `exclusiveMinimum` and `exclusiveMaximum` are booleans qualifying `minimum`
+// and `maximum`; the numeric spelling belongs to 3.1. Carrying the number
+// through left a document that declares itself 3.0 with a 3.1 keyword, and a
+// 3.0 reader taking the value as the boolean its dialect declares finds no
+// `minimum` beside it and drops the bound entirely (#2300).
+//
+// The upgrader already performs the inverse — a boolean `exclusiveMinimum: true`
+// becomes the numeric bound and the redundant `minimum` is dropped — so this
+// makes the pair a round trip.
+func openApiV3Downgrader_exclusive_bounds(schema JsonSchema) JsonSchema {
+  for _, pair := range [][2]string{
+    {"exclusiveMinimum", "minimum"},
+    {"exclusiveMaximum", "maximum"},
+  } {
+    value, ok := schema[pair[0]]
+    if ok == false {
+      continue
+    }
+    if _, boolean := value.(bool); boolean {
+      continue
+    }
+    if openApiV3Downgrader_is_nil(value) == false {
+      schema[pair[1]] = value
+      schema[pair[0]] = true
+    }
+  }
+  return schema
 }
 
 // openApiV3Downgrader_shallow_clone copies a schema's own keys, leaving nested

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.

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

@@ -240,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 {

package/native/core/programmers/protobuf/ProtobufMessageProgrammer.go

@@ -35,7 +35,7 @@ func (protobufMessageProgrammerNamespace) Write(props ProtobufMessageProgrammer_
   f := nativecontext.EmitFactoryOf(protobufMessageProgrammer_factory, props.Context.Emit)
   collection := schemametadata.NewMetadataCollection()
   nativefactories.ProtobufFactory.Metadata(nativefactories.ProtobufFactory_IProps{
-    Method:     "message",
+    Method:     "typia.protobuf.message",
     Checker:    props.Context.Checker,
     Components: collection,
     Type:       props.Type,

package/native/core/schemas/metadata/MetadataCollection.go

@@ -784,15 +784,6 @@ func metadataCollection_isOpenApiNameRune(ch rune) bool {
     ch == '_'
 }
 
-func MetadataCollection_escape(str string) string {
-  for _, pair := range metadataCollection_replacers {
-    if pair.After != "" {
-      str = strings.ReplaceAll(str, pair.After, pair.Before)
-    }
-  }
-  return str
-}
-
 type metadataCollection_replacer struct {
   Before string
   After  string
@@ -819,11 +810,31 @@ var metadataCollection_replacers = []metadataCollection_replacer{
 }
 
 func metadataCollection_getFullName(checker *nativechecker.Checker, typ *nativechecker.Type) string {
+  return metadataCollection_getFullNameOf(checker, typ, nil)
+}
+
+// metadataCollection_getFullNameOf carries the types whose name is still being
+// composed on the current path. A recursive type graph reaches the same *Type
+// again before its name is finished: `type Rec<T> = T extends Date ? string : T
+// extends (infer U)[] ? Rec<U>[] : never` instantiated at `Date | Node[]`
+// resolves to the union `string | Rec<Node>[]`, whose array member is a
+// reference whose sole type argument is that very union. Walking union member ->
+// array reference -> type argument returns to the union, so the unguarded walk
+// never terminates and overflows the plugin's stack instead of naming the type
+// (#2331). A type reached a second time on one path is therefore named by its
+// own symbol with its arguments left unexpanded -- the recursion's placeholder,
+// `Array<string | Array>` for the example above -- and a symbol-less one by the
+// anonymous marker the collection already allocates unique names from. Expanding
+// the checker's elided rendering there instead would name every such component
+// after a several-hundred-character structural dump.
+func metadataCollection_getFullNameOf(
+  checker *nativechecker.Checker,
+  typ *nativechecker.Type,
+  visiting map[*nativechecker.Type]bool,
+) string {
   if checker == nil || typ == nil {
     return "__type"
   }
-  rendered := metadataCollection_sanitizeName(checker.TypeToString(typ))
-
   // Mirror TypeFactory.getFullName: prefer the alias symbol, then the type's
   // own symbol. getTypeNameSymbol already returns t.alias.symbol first (the
   // alias symbol), so a non-nil result that differs from typ.Symbol() means the
@@ -835,6 +846,13 @@ func metadataCollection_getFullName(checker *nativechecker.Checker, typ *nativec
   if symbol == nil {
     symbol = rawSymbol
   }
+  if visiting[typ] {
+    if symbol != nil {
+      return metadataCollection_getName(symbol)
+    }
+    return "__type"
+  }
+  rendered := metadataCollection_sanitizeName(checker.TypeToString(typ))
   if symbol == nil {
     if typ.IsUnion() || typ.IsIntersection() {
       joiner := " | "
@@ -843,9 +861,11 @@ func metadataCollection_getFullName(checker *nativechecker.Checker, typ *nativec
       }
       children := typ.Types()
       names := make([]string, 0, len(children))
+      visiting = metadataCollection_markVisiting(visiting, typ)
       for _, child := range children {
-        names = append(names, metadataCollection_getFullName(checker, child))
+        names = append(names, metadataCollection_getFullNameOf(checker, child, visiting))
       }
+      delete(visiting, typ)
       return strings.Join(names, joiner)
     }
     if rendered != "" {
@@ -873,16 +893,29 @@ func metadataCollection_getFullName(checker *nativechecker.Checker, typ *nativec
     }
     return name
   }
+  visiting = metadataCollection_markVisiting(visiting, typ)
+  defer delete(visiting, typ)
   if name == "Promise" {
-    return metadataCollection_getFullName(checker, generic[0])
+    return metadataCollection_getFullNameOf(checker, generic[0], visiting)
   }
   names := make([]string, 0, len(generic))
   for _, child := range generic {
-    names = append(names, metadataCollection_getFullName(checker, child))
+    names = append(names, metadataCollection_getFullNameOf(checker, child, visiting))
   }
   return name + "<" + strings.Join(names, ", ") + ">"
 }
 
+func metadataCollection_markVisiting(
+  visiting map[*nativechecker.Type]bool,
+  typ *nativechecker.Type,
+) map[*nativechecker.Type]bool {
+  if visiting == nil {
+    visiting = map[*nativechecker.Type]bool{}
+  }
+  visiting[typ] = true
+  return visiting
+}
+
 func metadataCollection_getName(symbol *nativeast.Symbol) string {
   if symbol == nil || len(symbol.Declarations) == 0 || symbol.Declarations[0].Parent == nil {
     return "__type"

package/native/core/schemas/metadata/MetadataDefaultLibrary.go

@@ -0,0 +1,81 @@
+package metadata
+
+import (
+  "strings"
+  "sync"
+
+  nativeast "github.com/microsoft/typescript-go/shim/ast"
+  nativechecker "github.com/microsoft/typescript-go/shim/checker"
+)
+
+// MetadataDefaultLibrary routes the compiler's own default-library
+// classification to metadata analysis, which decides runtime-native identity
+// from it: a global is the JavaScript built-in only when a runtime authority —
+// a TypeScript default library, or Node's `buffer` core module — declares it
+// (#2200).
+//
+// Only the program knows which files those are. `bundled:///libs/lib.es2022.d.ts`
+// under the embedded default, an on-disk path under `noembed`, and
+// `node_modules/@typescript/lib-es2022/index.d.ts` under `libReplacement` are
+// all the same authority, and none of them is recognizable from the file name:
+// the last one does not even start with `lib.`, while `lib.d.ts` is an ordinary
+// published file name that any dependency or `typeRoots` package may use
+// (samchon/typia#2108 recorded the same lesson for dependency reporting).
+//
+// The registry is keyed by checker for the same reason MetadataDependency is:
+// analysis code deep inside the metadata iterators holds the checker but no
+// transform context, while one transform host drives one program at a time. A
+// sync.Map keeps unrelated programs in the same process (tests) isolated.
+//
+// When no classifier is registered the file name is the only evidence left, so
+// the fallback is the historical `lib.*.d.ts` base-name test. That keeps a host
+// that never registers on exactly the behavior this package had before the
+// registry existed rather than silently classifying every real native as a
+// user declaration.
+var metadataDefaultLibrary_classifiers sync.Map
+
+// MetadataDefaultLibrary_register records the program-level classifier for
+// `checker`. Register it once per loaded program, before any transform runs.
+func MetadataDefaultLibrary_register(checker *nativechecker.Checker, classifier func(*nativeast.SourceFile) bool) {
+  if checker == nil || classifier == nil {
+    return
+  }
+  metadataDefaultLibrary_classifiers.Store(checker, classifier)
+}
+
+// MetadataDefaultLibrary_release removes the classifier registered for
+// `checker`.
+func MetadataDefaultLibrary_release(checker *nativechecker.Checker) {
+  if checker == nil {
+    return
+  }
+  metadataDefaultLibrary_classifiers.Delete(checker)
+}
+
+// MetadataDefaultLibrary_is reports whether `source` is one of the program's
+// default library files.
+func MetadataDefaultLibrary_is(checker *nativechecker.Checker, source *nativeast.SourceFile) bool {
+  if source == nil {
+    return false
+  }
+  if checker != nil {
+    if stored, ok := metadataDefaultLibrary_classifiers.Load(checker); ok {
+      if classifier, ok := stored.(func(*nativeast.SourceFile) bool); ok {
+        return classifier(source)
+      }
+    }
+  }
+  return MetadataDefaultLibrary_isFileNamed(source.FileName())
+}
+
+// MetadataDefaultLibrary_isFileNamed is the registry's file-name fallback,
+// exported so the one predicate that still answers without a checker keeps
+// using the same rule.
+func MetadataDefaultLibrary_isFileNamed(fileName string) bool {
+  slash := strings.ReplaceAll(fileName, "\\", "/")
+  base := slash
+  if index := strings.LastIndex(slash, "/"); index >= 0 {
+    base = slash[index+1:]
+  }
+  return strings.HasPrefix(base, "lib.") && strings.HasSuffix(base, ".d.ts")
+}

package/native/core/schemas/metadata/MetadataObjectType.go

@@ -13,25 +13,25 @@ type IMetadataSchema_IObjectType struct {
 }
 
 type MetadataObjectType struct {
-  Name              string
-  DisplayName       string
+  Name        string
+  DisplayName string
   // Source is the absolute-or-as-declared path of the file declaring a named
   // class, captured at analysis time so plain.classify can value-import a
   // cross-module class it reconstructs (Object.create / new / from). nil for
   // anonymous/literal shapes and types with no locatable declaration. Read
   // in-process by the classify programmer; not serialized (classify is
   // single-pass), and ignored by clone/prune.
-  Source            *string
+  Source *string
   // SourceDefault is true when the class is the default export of Source, so a
   // cross-module classify value-import uses a default (not named) import.
-  SourceDefault     bool
+  SourceDefault bool
   // PrivateFields is true when the named class declaration carries at least one
   // ES `#private` member (a member named with a PrivateIdentifier). Such slots
   // are installed only by running the constructor; plain.classify's field-copy
   // (Object.create + assign) cannot restore them, so classify rejects any such
   // class at a field-copied position. Read in-process by the classify
   // programmer; ignored by clone/prune, not serialized.
-  PrivateFields     bool
+  PrivateFields bool
   // IsClass is true when this object's declaration is a `class` (declaration or
   // expression), so it has a runtime VALUE binding plain.classify can
   // `Object.create(<name>.prototype)`/`new` against. False for an interface, a
@@ -39,7 +39,7 @@ type MetadataObjectType struct {
   // value, so classify field-copies a plain {} instead of referencing a
   // type-only name. Read in-process by the classify programmer; ignored by
   // clone/prune, not serialized.
-  IsClass           bool
+  IsClass bool
   // ValueRef overrides the runtime VALUE-binding name plain.classify uses when
   // the class's metadata Name is not a usable runtime constructor reference —
   // namely a NAMED class EXPRESSION (`const X = class Beast {...}`), whose Name
@@ -56,7 +56,7 @@ type MetadataObjectType struct {
   Validated         bool
   Recursive         bool
   Nullables         []bool
-  Parent_objects_  []*MetadataObject
+  Parent_objects_   []*MetadataObject
   Check_properties_ []*MetadataProperty
   Tagged_           bool
   literal_          *bool
@@ -205,17 +205,6 @@ func (obj *MetadataObjectType) ToJSON() IMetadataSchema_IObjectType {
   }
 }
 
-func MetadataObjectType_intersects(x *MetadataObjectType, y *MetadataObjectType) bool {
-  for _, prop := range x.Properties {
-    for _, oppo := range y.Properties {
-      if prop.Key.GetName() == oppo.Key.GetName() {
-        return true
-      }
-    }
-  }
-  return false
-}
-
 func MetadataObjectType_covers(x *MetadataObjectType, y *MetadataObjectType) bool {
   if len(x.Properties) < len(y.Properties) {
     return false

package/native/go.mod

@@ -5,10 +5,10 @@ go 1.26
 // Build-time floor: the driver reference-graph SDK
 // (driver.NewTransformGraph / driver.TransformGraph / driver.TransformOutputKey)
 // this plugin consumes exists only in ttsc >= 0.19.2. That floor is enforced
-// through typia's package.json peerDependencies (ttsc / @ttsc/unplugin), not
-// here: ttsc builds this plugin from source on the user's machine and its
-// buildSourcePlugin generates `replace github.com/samchon/ttsc/packages/ttsc
-// v0.0.0 => <installed ttsc root>`, so the require below must stay v0.0.0 or the
+// through typia's package.json `ttsc` peerDependency, not here: ttsc builds
+// this plugin from source on the user's machine and its buildSourcePlugin
+// generates `replace github.com/samchon/ttsc/packages/ttsc v0.0.0 =>
+// <installed ttsc root>`, so the require below must stay v0.0.0 or the
 // generated replace no longer matches and the plugin build fails to resolve.
 require (
 	github.com/microsoft/typescript-go/shim/ast v0.0.0

package/native/transform/CallExpressionTransformer.go

@@ -63,6 +63,7 @@ func (callExpressionTransformerNamespace) Transform(props CallExpressionTransfor
   location, _ := filepath.Abs(sourceFile.FileName())
   module, ok := callExpressionTransformer_targetModule(location)
   if ok == false {
+    callExpressionTransformer_rejectShadowedTypia(props, location)
     return props.Expression.AsNode()
   }
   typ := props.Context.Checker.GetTypeAtLocation(declaration)
@@ -127,6 +128,172 @@ func callExpressionTransformer_targetModule(location string) (string, bool) {
   return "", false
 }
 
+// callExpressionTransformer_rejectShadowedTypia raises a diagnostic when a call
+// the file-path identity test rejected is nevertheless a typia call the author
+// expects to be transformed, and names the file that declared it instead.
+//
+// Attribution by declaration file is deliberate: accepting a callee declared
+// anywhere else would let any package claim typia's transform, which is the
+// boundary default_library_spoof_native_identity_transform_test.go and
+// lib_replacement_native_identity_transform_test.go protect. That check is not
+// relaxed here. Silence is what needs correcting. A project-local `declare
+// module "typia"` moves the resolved signature's declaration out of typia's own
+// files, so the call is left untransformed with no diagnostic at all and the
+// failure surfaces only at run time as `no transform has been configured`
+// (samchon/typia#2328).
+//
+// Three conditions have to hold together, so an unrelated local function that
+// happens to share a name with a typia operation cannot trip this:
+//
+//  1. the callee spells an operation this transformer owns, in the namespace it
+//     actually lives in — `typia.json.assertParse`, never `typia.assertParse`;
+//  2. the root of the callee expression resolves to an import binding; and
+//  3. that import's module specifier is typia's own.
+//
+// Known gap: an alias chain is not followed, so a project that re-exports typia
+// through its own barrel and then shadows it is still silent. The specifier of
+// the import the call actually reads is the only evidence this collects.
+func callExpressionTransformer_rejectShadowedTypia(props CallExpressionTransformer_TransformProps, location string) {
+  code, ok := callExpressionTransformer_calleeOperation(props.Expression.Expression)
+  if ok == false {
+    return
+  }
+  root := callExpressionTransformer_calleeRoot(props.Expression.Expression)
+  if root == nil || root.Kind != shimast.KindIdentifier {
+    return
+  }
+  symbol := props.Context.Checker.GetSymbolAtLocation(root)
+  if symbol == nil || symbol.Flags&shimast.SymbolFlagsAlias == 0 {
+    return
+  }
+  for _, declaration := range symbol.Declarations {
+    if callExpressionTransformer_importsTypia(declaration) == false {
+      continue
+    }
+    // State only what was observed. The declaration file is the fact; a
+    // `declare module "typia"` is the usual cause but not the only way to move
+    // a declaration, and naming it as the cause would misdirect anyone whose
+    // build got here another way.
+    panic(nativecontext.NewTransformerError(nativecontext.TransformerError_IProps{
+      Code: code,
+      Message: "this call was declared in " +
+        filepath.ToSlash(location) +
+        ", not in typia's own module, so no transform was applied. A project-local `declare module \"typia\"` is the usual cause; remove it, or give the redeclaration another module name.",
+    }))
+  }
+}
+
+// callExpressionTransformer_calleeOperation answers whether a callee expression
+// spells one of this transformer's operations, and returns the diagnostic code
+// for it — the written spelling, qualified as `typia.json.assertParse`.
+//
+// The namespace is part of the spelling. `typia.json.assertParse` names the
+// `json` table, while `typia.createAssert` and a bare named import name the root
+// `module` table; a root-level `typia.assertParse` matches nothing, because that
+// operation does not live there. Matching a flat union of every table's names
+// instead would report a module augmentation that adds an unrelated `parse` or
+// `schema` to typia, which is a build that works today.
+//
+// Known gap: taking the namespace from the spelling means a renamed binding
+// (`import { json as j } from "typia"; j.assertParse(...)`) is not recognized.
+func callExpressionTransformer_calleeOperation(callee *shimast.Node) (string, bool) {
+  method := ""
+  first := true
+  // Segments to the left of the method, nearest first: `typia.json.assertParse`
+  // collects ["json", "typia"].
+  parts := []string{}
+  for current := callee; current != nil; {
+    if len(parts) > 2 {
+      return "", false
+    }
+    segment := ""
+    switch current.Kind {
+    case shimast.KindPropertyAccessExpression:
+      access := current.AsPropertyAccessExpression()
+      name := access.Name()
+      if name == nil || name.Kind != shimast.KindIdentifier {
+        return "", false
+      }
+      segment = name.Text()
+      current = access.Expression
+    case shimast.KindIdentifier:
+      segment = current.Text()
+      current = nil
+    default:
+      return "", false
+    }
+    if first {
+      method = segment
+      first = false
+    } else {
+      parts = append(parts, segment)
+    }
+  }
+  if method == "" || len(parts) > 2 {
+    return "", false
+  }
+  functors := callExpressionTransformer_FUNCTORS()
+  // `typia.json.assertParse` and `json.assertParse` both name the `json` table
+  // through the segment directly left of the method.
+  if len(parts) != 0 {
+    if _, found := functors[parts[0]][method]; found {
+      return "typia." + parts[0] + "." + method, true
+    }
+  }
+  // `typia.createAssert` and a bare `createAssert` name the root table. The
+  // qualifier, when present, is the imported binding rather than a namespace.
+  if len(parts) <= 1 {
+    if _, found := functors["module"][method]; found {
+      return "typia." + method, true
+    }
+  }
+  return "", false
+}
+
+// callExpressionTransformer_calleeRoot walks a property-access chain down to the
+// expression it starts from, which is the binding that has to come from typia.
+func callExpressionTransformer_calleeRoot(callee *shimast.Node) *shimast.Node {
+  current := callee
+  for current != nil && current.Kind == shimast.KindPropertyAccessExpression {
+    current = current.AsPropertyAccessExpression().Expression
+  }
+  return current
+}
+
+// callExpressionTransformer_importsTypia answers whether an alias declaration
+// belongs to an import whose module specifier is typia's own. Both `import ...
+// from "typia"` and `import typia = require("typia")` are matched; the walk
+// stops at the source file so a local declaration can never reach an unrelated
+// import above it.
+func callExpressionTransformer_importsTypia(declaration *shimast.Node) bool {
+  for node := declaration; node != nil; node = node.Parent {
+    switch node.Kind {
+    case shimast.KindImportDeclaration:
+      return callExpressionTransformer_isTypiaSpecifier(node.ModuleSpecifier())
+    case shimast.KindImportEqualsDeclaration:
+      reference := node.AsImportEqualsDeclaration().ModuleReference
+      if reference == nil || reference.Kind != shimast.KindExternalModuleReference {
+        return false
+      }
+      return callExpressionTransformer_isTypiaSpecifier(reference.AsExternalModuleReference().Expression)
+    case shimast.KindSourceFile:
+      return false
+    }
+  }
+  return false
+}
+
+// callExpressionTransformer_isTypiaSpecifier accepts typia's own package name
+// and its subpaths, and nothing that merely begins with those letters: a
+// `typia-codegen` package is a different package.
+func callExpressionTransformer_isTypiaSpecifier(specifier *shimast.Node) bool {
+  if specifier == nil || specifier.Kind != shimast.KindStringLiteral {
+    return false
+  }
+  text := specifier.AsStringLiteral().Text
+  return text == "typia" || strings.HasPrefix(text, "typia/")
+}
+
 func callExpressionTransformer_sourceFile(node *shimast.Node) *shimast.SourceFile {
   for current := node; current != nil; current = current.Parent {
     if current.Kind == shimast.KindSourceFile {