typia 13.1.19 → 13.3.0

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

@@ -0,0 +1,484 @@
+package main
+
+import (
+  "fmt"
+  "os"
+  "os/exec"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestUserGlobalNativeIdentityTransform keeps a user-authored global structural
+// while a runtime-provided global of the same name stays runtime-native (#2200).
+//
+// Winning the checker's global type table proves only that a declaration is
+// global. A project whose sole `File` or `Blob` declaration is its own `declare
+// global` block wins that same lookup, so a resolution-only identity gate erases
+// the user's members, emits `input instanceof File`, and throws `ReferenceError`
+// wherever no runtime supplies that constructor. Native classification therefore
+// has to ask which authority provides the constructor, and it must ask that
+// question without demoting the genuine default-library, Node bare-global, or
+// augmented natives that legitimately answer it.
+//
+//  1. Transform a project whose only File/Blob declarations are user globals in
+//     both the interface and the class spelling, one of them carrying its own
+//     `declare var` constructor binding, across is/assert/assertGuard/validate/
+//     equals/random, direct and factory forms, and alias, nested, intersection,
+//     union, and re-exported compositions.
+//  2. Transform that project's json, protobuf, and llm schema surfaces, which a
+//     native classification removes from those consumers entirely.
+//  3. Transform a global `type` alias spelling of the same collision in a second
+//     project, and near-miss control names in the first.
+//  4. Transform a third project where @types/node provides the runtime bridge
+//     and the user contributes only an empty augmentation, requiring every
+//     default-library and Node-provided native to keep its `instanceof` check.
+//  5. Execute every emitted validator in Node against structural user values and
+//     against the real runtime instances, requiring exact case counts so a
+//     dropped branch cannot pass silently.
+func TestUserGlobalNativeIdentityTransform(t *testing.T) {
+  project := userGlobalNativeIdentityProject(t)
+  aliasProject := userGlobalNativeIdentityAliasProject(t)
+  providedProject := userGlobalNativeIdentityProvidedProject(t)
+  transform := func(dir string, file string) string {
+    t.Helper()
+    js, errText, code := ttscTypiaTestCapture(func() int {
+      return runTransform([]string{
+        "--cwd", dir,
+        "--tsconfig", "tsconfig.json",
+        "--file", file,
+        "--output", "js",
+      })
+    })
+    if code != 0 {
+      t.Fatalf("user global native identity transform %s/%s failed: code=%d stderr=\n%s", dir, file, code, errText)
+    }
+    return js
+  }
+
+  js := transform(project, "src/input.ts")
+  schemasJS := transform(project, "src/schemas.ts")
+  controlsJS := transform(project, "src/controls.ts")
+  aliasJS := transform(aliasProject, "src/input.ts")
+  providedJS := transform(providedProject, "src/input.ts")
+
+  failures := []string{}
+  for _, native := range []string{"instanceof File", "instanceof Blob"} {
+    for name, emit := range map[string]string{
+      "validator emit":    js,
+      "schema emit":       schemasJS,
+      "type alias emit":   aliasJS,
+      "near-miss control": controlsJS,
+    } {
+      if strings.Contains(emit, native) {
+        failures = append(failures, fmt.Sprintf("%s promoted a user-authored global to %q", name, native))
+      }
+    }
+  }
+  for _, member := range []string{"userBlobBrand", "userFileBrand"} {
+    for name, emit := range map[string]string{
+      "validator emit":  js,
+      "schema emit":     schemasJS,
+      "type alias emit": aliasJS,
+    } {
+      if !strings.Contains(emit, member) {
+        failures = append(failures, fmt.Sprintf("%s dropped user-declared member %q", name, member))
+      }
+    }
+  }
+  for _, member := range []string{"intersectionBrand", "unionControl", "nestedHolder"} {
+    if !strings.Contains(js, member) {
+      failures = append(failures, fmt.Sprintf("validator emit dropped composition member %q", member))
+    }
+  }
+  for _, member := range []string{"nearMissBrand", "prefixBrand"} {
+    if !strings.Contains(controlsJS, member) {
+      failures = append(failures, fmt.Sprintf("near-miss control emit dropped member %q", member))
+    }
+  }
+  for _, kept := range []string{
+    "instanceof Date",
+    "instanceof RegExp",
+    "instanceof Uint8Array",
+    "instanceof Map",
+    "instanceof Set",
+    "instanceof WeakMap",
+    "instanceof WeakSet",
+    "instanceof File",
+    "instanceof Blob",
+  } {
+    if !strings.Contains(providedJS, kept) {
+      failures = append(failures, fmt.Sprintf("runtime-provided native lost %q", kept))
+    }
+  }
+
+  output, runtimeErr := userGlobalNativeIdentityRun(t, project, js, controlsJS)
+  if runtimeErr != nil {
+    failures = append(failures, fmt.Sprintf("user global runtime matrix failed: %v\n%s", runtimeErr, output))
+  }
+  // Counted from the runner's own table, which is the ground truth: 11 rows for
+  // the is/assert/assertGuard/validate/equals/random matrix, 15 for the
+  // createIs forms across direct, alias, re-export, branded intersection, union,
+  // and nested positions, and 2 near-miss name controls. The count is asserted
+  // rather than the exit code so a row that silently stops running cannot pass
+  // as a row that ran and agreed.
+  if expected := "RAN 28 USER GLOBAL CASES"; !strings.Contains(output, expected) {
+    failures = append(failures, fmt.Sprintf("user global runner did not report %q; got:\n%s", expected, output))
+  }
+  providedOutput, providedErr := userGlobalNativeIdentityProvidedRun(t, providedProject, providedJS)
+  if providedErr != nil {
+    failures = append(failures, fmt.Sprintf("runtime-provided matrix failed: %v\n%s", providedErr, providedOutput))
+  }
+  if expected := "RAN 18 PROVIDED CASES"; !strings.Contains(providedOutput, expected) {
+    failures = append(failures, fmt.Sprintf("provided runner did not report %q; got:\n%s", expected, providedOutput))
+  }
+
+  if len(failures) != 0 {
+    t.Fatalf(
+      "user global native identity mismatches:\n%s\n\nvalidator emit:\n%s\n\nschema emit:\n%s\n\nalias emit:\n%s\n\ncontrol emit:\n%s\n\nprovided emit:\n%s",
+      strings.Join(failures, "\n"),
+      js,
+      schemasJS,
+      aliasJS,
+      controlsJS,
+      providedJS,
+    )
+  }
+}
+
+func userGlobalNativeIdentityWriteProject(t *testing.T, prefix string, files map[string]string) string {
+  t.Helper()
+  root := ttscTypiaTestRepoRoot(t)
+  base := filepath.Join(root, "packages", "typia", "native", ".tmp-ttsc-typia-tests")
+  if err := os.MkdirAll(base, 0o755); err != nil {
+    t.Fatalf("mkdir temp base: %v", err)
+  }
+  dir, err := os.MkdirTemp(base, prefix)
+  if err != nil {
+    t.Fatalf("create temp fixture: %v", err)
+  }
+  t.Cleanup(func() {
+    _ = os.RemoveAll(dir)
+  })
+  for name, content := range files {
+    path := filepath.Join(dir, filepath.FromSlash(name))
+    if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+      t.Fatalf("mkdir fixture path %s: %v", filepath.Dir(path), err)
+    }
+    if err := os.WriteFile(path, []byte(content), 0o644); err != nil {
+      t.Fatalf("write fixture file %s: %v", path, err)
+    }
+  }
+  return dir
+}
+
+func userGlobalNativeIdentityProject(t *testing.T) string {
+  t.Helper()
+  return userGlobalNativeIdentityWriteProject(t, "user-global-native-identity-", map[string]string{
+    "tsconfig.json":     userGlobalNativeIdentityTSConfig,
+    "src/globals.d.ts":  userGlobalNativeIdentityGlobals,
+    "src/reexport.ts":   userGlobalNativeIdentityReexport,
+    "src/input.ts":      userGlobalNativeIdentitySource,
+    "src/schemas.ts":    userGlobalNativeIdentitySchemaSource,
+    "src/controls.ts":   userGlobalNativeIdentityControlSource,
+  })
+}
+
+func userGlobalNativeIdentityAliasProject(t *testing.T) string {
+  t.Helper()
+  return userGlobalNativeIdentityWriteProject(t, "user-global-native-identity-alias-", map[string]string{
+    "tsconfig.json":    userGlobalNativeIdentityTSConfig,
+    "src/globals.d.ts": userGlobalNativeIdentityAliasGlobals,
+    "src/input.ts":     userGlobalNativeIdentityAliasSource,
+  })
+}
+
+func userGlobalNativeIdentityProvidedProject(t *testing.T) string {
+  t.Helper()
+  return userGlobalNativeIdentityWriteProject(t, "user-global-native-identity-provided-", map[string]string{
+    "tsconfig.json":    userGlobalNativeIdentityProvidedTSConfig,
+    "src/globals.d.ts": userGlobalNativeIdentityProvidedGlobals,
+    "src/input.ts":     userGlobalNativeIdentityProvidedSource,
+  })
+}
+
+func userGlobalNativeIdentityRunner(t *testing.T, project string, modules map[string]string) (string, error) {
+  t.Helper()
+  node, err := exec.LookPath("node")
+  if err != nil {
+    t.Skip("node executable not found")
+    return "", nil
+  }
+  runtimeDir := filepath.Join(project, "runtime")
+  if err := os.MkdirAll(runtimeDir, 0o755); err != nil {
+    t.Fatalf("mkdir runtime dir: %v", err)
+  }
+  ttscTypiaTestWriteCommonRuntimeStubs(t, runtimeDir)
+  for name, content := range modules {
+    if err := os.WriteFile(filepath.Join(runtimeDir, name), []byte(content), 0o644); err != nil {
+      t.Fatalf("write runtime file %s: %v", name, err)
+    }
+  }
+  cmd := exec.Command(node, filepath.Join(runtimeDir, "run.cjs"))
+  cmd.Dir = runtimeDir
+  output, err := cmd.CombinedOutput()
+  return string(output), err
+}
+
+func userGlobalNativeIdentityRun(t *testing.T, project string, js string, controlsJS string) (string, error) {
+  t.Helper()
+  return userGlobalNativeIdentityRunner(t, project, map[string]string{
+    "input.cjs":    ttscTypiaTestRewriteCommonJS(t, js),
+    "controls.cjs": ttscTypiaTestRewriteCommonJS(t, controlsJS),
+    "run.cjs":      userGlobalNativeIdentityRuntimeRunner,
+  })
+}
+
+func userGlobalNativeIdentityProvidedRun(t *testing.T, project string, js string) (string, error) {
+  t.Helper()
+  return userGlobalNativeIdentityRunner(t, project, map[string]string{
+    "input.cjs": ttscTypiaTestRewriteCommonJS(t, js),
+    "run.cjs":   userGlobalNativeIdentityProvidedRuntimeRunner,
+  })
+}
+
+const userGlobalNativeIdentityTSConfig = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "moduleResolution": "bundler",
+    "ignoreDeprecations": "6.0",
+    "lib": ["ES2022"],
+    "types": [],
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}
+`
+
+const userGlobalNativeIdentityProvidedTSConfig = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "moduleResolution": "bundler",
+    "ignoreDeprecations": "6.0",
+    "lib": ["ES2022"],
+    "types": ["node"],
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}
+`
+
+// userGlobalNativeIdentityGlobals is the whole runtime-native declaration set of
+// its project: neither the DOM libraries nor @types/node is loaded, so Blob and
+// File exist only because this file declares them. Blob is the interface-only
+// spelling and File is the class spelling, which additionally gives File a
+// user-owned constructor binding — the one signal a runtime provider would
+// otherwise be recognized by.
+const userGlobalNativeIdentityGlobals = `export {};
+
+declare global {
+  interface Blob {
+    userBlobBrand: string;
+  }
+  class File {
+    userBlobBrand: string;
+    userFileBrand: string;
+  }
+}
+`
+
+const userGlobalNativeIdentityReexport = `export type ReexportedFile = File;
+`
+
+const userGlobalNativeIdentitySource = `import typia from "typia";
+import type { ReexportedFile } from "./reexport";
+
+type FileAlias = File;
+type BrandedFile = File & { intersectionBrand: string };
+type FileUnion = BrandedFile | { unionControl: boolean };
+type NestedFile = { nestedHolder: File };
+
+export const isFile = (input: unknown): boolean => typia.is<File>(input);
+export const assertFile = (input: unknown): File => typia.assert<File>(input);
+export const assertGuardFile = (input: unknown): void => typia.assertGuard<File>(input);
+export const validateFile = (input: unknown) => typia.validate<File>(input);
+export const equalsFile = (input: unknown): boolean => typia.equals<File>(input);
+export const randomBlob = (): Blob => typia.random<Blob>();
+
+export const createdIsBlob = typia.createIs<Blob>();
+export const createdIsFile = typia.createIs<File>();
+export const createdIsAlias = typia.createIs<FileAlias>();
+export const createdIsReexported = typia.createIs<ReexportedFile>();
+export const createdIsBranded = typia.createIs<BrandedFile>();
+export const createdIsUnion = typia.createIs<FileUnion>();
+export const createdIsNested = typia.createIs<NestedFile>();
+`
+
+const userGlobalNativeIdentitySchemaSource = `import typia from "typia";
+
+export const jsonSchema = typia.json.schema<File>();
+export const jsonStringify = typia.json.createStringify<File>();
+export const jsonIsStringify = typia.json.createIsStringify<File>();
+export const protobufMessage = typia.protobuf.message<Blob>();
+export const protobufEncode = typia.protobuf.createIsEncode<Blob>();
+export const llmSchema = typia.llm.schema<File>({});
+`
+
+const userGlobalNativeIdentityControlSource = `import typia from "typia";
+
+interface FileEntry {
+  nearMissBrand: string;
+}
+interface Blobby {
+  prefixBrand: string;
+}
+
+export const createdIsFileEntry = typia.createIs<FileEntry>();
+export const createdIsBlobby = typia.createIs<Blobby>();
+`
+
+// userGlobalNativeIdentityAliasGlobals spells the same collision as a global
+// `type` alias, whose symbol is an anonymous type literal rather than a named
+// declaration. It is the negative twin that proves the classification is decided
+// by declaration provenance rather than by the shape of the declaring node.
+const userGlobalNativeIdentityAliasGlobals = `export {};
+
+declare global {
+  type Blob = { userBlobBrand: string };
+  type File = { userBlobBrand: string; userFileBrand: string };
+}
+`
+
+const userGlobalNativeIdentityAliasSource = `import typia from "typia";
+
+export const isAliasFile = (input: unknown): boolean => typia.is<File>(input);
+export const createdIsAliasBlob = typia.createIs<Blob>();
+`
+
+// userGlobalNativeIdentityProvidedGlobals is the positive control: @types/node
+// bridges the node:buffer constructors to the bare globals, and the user adds
+// only an empty augmentation. Merging a declaration into a runtime-provided
+// global must not change what provides that global.
+const userGlobalNativeIdentityProvidedGlobals = `export {};
+
+declare global {
+  interface Blob {}
+  interface File {}
+}
+`
+
+const userGlobalNativeIdentityProvidedSource = `import typia from "typia";
+
+export const createdIsDate = typia.createIs<Date>();
+export const createdIsRegExp = typia.createIs<RegExp>();
+export const createdIsBytes = typia.createIs<Uint8Array>();
+export const createdIsMap = typia.createIs<Map<string, number>>();
+export const createdIsSet = typia.createIs<Set<string>>();
+export const createdIsWeakMap = typia.createIs<WeakMap<object, string>>();
+export const createdIsWeakSet = typia.createIs<WeakSet<object>>();
+export const createdIsFile = typia.createIs<File>();
+export const createdIsBlob = typia.createIs<Blob>();
+`
+
+const userGlobalNativeIdentityRuntimeRunner = `const validators = require("./input.cjs");
+const controls = require("./controls.cjs");
+
+let ran = 0;
+const failures = [];
+const eq = (name, actual, expected) => {
+  ran += 1;
+  if (actual !== expected) {
+    failures.push(name + ": expected " + expected + " but got " + actual);
+  }
+};
+const throws = (name, run) => {
+  ran += 1;
+  try {
+    run();
+    failures.push(name + ": expected a throw but none happened");
+  } catch {}
+};
+
+const userBlob = { userBlobBrand: "user" };
+const userFile = { userBlobBrand: "user", userFileBrand: "user" };
+const realBlob = new Blob(["x"]);
+const realFile = new File(["x"], "x.txt");
+
+eq("is user File", validators.isFile(userFile), true);
+eq("is real File", validators.isFile(realFile), false);
+eq("assert user File", validators.assertFile(userFile), userFile);
+throws("assert real File", () => validators.assertFile(realFile));
+eq("assertGuard user File", validators.assertGuardFile(userFile), undefined);
+throws("assertGuard real File", () => validators.assertGuardFile(realFile));
+eq("validate user File", validators.validateFile(userFile).success, true);
+eq("validate real File", validators.validateFile(realFile).success, false);
+eq("equals user File", validators.equalsFile(userFile), true);
+eq("equals real File", validators.equalsFile(realFile), false);
+eq("random Blob brand", typeof validators.randomBlob().userBlobBrand, "string");
+
+eq("createIs user Blob", validators.createdIsBlob(userBlob), true);
+eq("createIs real Blob", validators.createdIsBlob(realBlob), false);
+eq("createIs user File", validators.createdIsFile(userFile), true);
+eq("createIs real File", validators.createdIsFile(realFile), false);
+eq("alias user File", validators.createdIsAlias(userFile), true);
+eq("alias real File", validators.createdIsAlias(realFile), false);
+eq("re-export user File", validators.createdIsReexported(userFile), true);
+eq("re-export real File", validators.createdIsReexported(realFile), false);
+eq("branded user File", validators.createdIsBranded({ ...userFile, intersectionBrand: "x" }), true);
+eq("branded user File without brand", validators.createdIsBranded(userFile), false);
+eq("union branded arm", validators.createdIsUnion({ ...userFile, intersectionBrand: "x" }), true);
+eq("union control arm", validators.createdIsUnion({ unionControl: true }), true);
+eq("union rejects real File", validators.createdIsUnion(realFile), false);
+eq("nested user File", validators.createdIsNested({ nestedHolder: userFile }), true);
+eq("nested real File", validators.createdIsNested({ nestedHolder: realFile }), false);
+
+eq("near-miss FileEntry", controls.createdIsFileEntry({ nearMissBrand: "x" }), true);
+eq("prefix Blobby", controls.createdIsBlobby({ prefixBrand: "x" }), true);
+
+console.log("RAN " + ran + " USER GLOBAL CASES");
+if (failures.length !== 0) {
+  throw new Error("MISMATCHES:\n" + failures.join("\n"));
+}
+`
+
+const userGlobalNativeIdentityProvidedRuntimeRunner = `const validators = require("./input.cjs");
+
+let ran = 0;
+const failures = [];
+const eq = (name, actual, expected) => {
+  ran += 1;
+  if (actual !== expected) {
+    failures.push(name + ": expected " + expected + " but got " + actual);
+  }
+};
+
+eq("Date real", validators.createdIsDate(new Date()), true);
+eq("Date plain", validators.createdIsDate({}), false);
+eq("RegExp real", validators.createdIsRegExp(/x/), true);
+eq("RegExp plain", validators.createdIsRegExp({}), false);
+eq("Uint8Array real", validators.createdIsBytes(new Uint8Array(1)), true);
+eq("Uint8Array plain", validators.createdIsBytes({}), false);
+eq("Map real", validators.createdIsMap(new Map([["x", 1]])), true);
+eq("Map plain", validators.createdIsMap({}), false);
+eq("Set real", validators.createdIsSet(new Set(["x"])), true);
+eq("Set plain", validators.createdIsSet({}), false);
+eq("WeakMap real", validators.createdIsWeakMap(new WeakMap()), true);
+eq("WeakMap plain", validators.createdIsWeakMap({}), false);
+eq("WeakSet real", validators.createdIsWeakSet(new WeakSet()), true);
+eq("WeakSet plain", validators.createdIsWeakSet({}), false);
+eq("File real", validators.createdIsFile(new File(["x"], "x.txt")), true);
+eq("File plain", validators.createdIsFile({ name: "x.txt", size: 1 }), false);
+eq("Blob real", validators.createdIsBlob(new Blob(["x"])), true);
+eq("Blob plain", validators.createdIsBlob({ size: 1, type: "text/plain" }), false);
+
+console.log("RAN " + ran + " PROVIDED CASES");
+if (failures.length !== 0) {
+  throw new Error("MISMATCHES:\n" + failures.join("\n"));
+}
+`

package/native/core/factories/FormatCheatSheet.go

@@ -45,7 +45,7 @@ var FormatCheatSheet = map[string]string{
   "email":                 "/^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i.test($input)",
   "hostname":              "/^(?=.{1,253}\\.?$)[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\\.[a-z0-9](?:[-0-9a-z]{0,61}[0-9a-z])?)*\\.?$/i.test($input)",
   "idn-email":             "/^(([^<>()[\\]\\.,;:\\s@\\\"]+(\\.[^<>()[\\]\\.,;:\\s@\\\"]+)*)|(\\\".+\\\"))@(([^<>()[\\]\\.,;:\\s@\\\"]+\\.)+[^<>()[\\]\\.,;:\\s@\\\"]{2,})$/i.test($input)",
-  "idn-hostname":          "/^([a-z0-9\\u00a1-\\uffff0-9]+(-[a-z0-9\\u00a1-\\uffff0-9]+)*\\.)+[a-z\\u00a1-\\uffff]{2,}$/i.test($input)",
+  "idn-hostname":          "/^(?=.{1,253}\\.?$)[a-z0-9\\u00a1-\\uffff](?:[a-z0-9\\u00a1-\\uffff-]{0,61}[a-z0-9\\u00a1-\\uffff])?(?:\\.[a-z0-9\\u00a1-\\uffff](?:[a-z0-9\\u00a1-\\uffff-]{0,61}[a-z0-9\\u00a1-\\uffff])?)*\\.?$/i.test($input)",
   "iri":                   `(() => !/[\u0000-\u0020\u007f-\u009f\ud800-\udfff"<>\\^\x60{|}]/u.test($input) && !/%(?![0-9A-Fa-f]{2})/u.test($input) && /^[A-Za-z][A-Za-z0-9+.-]*:/u.test($input))()`,
   "iri-reference":         `(() => { if (/[\u0000-\u0020\u007f-\u009f\ud800-\udfff"<>\\^\x60{|}]/u.test($input) || /%(?![0-9A-Fa-f]{2})/u.test($input)) return false; const colon = $input.indexOf(":"); const boundary = $input.search(/[/?#]/u); return colon === -1 || (boundary !== -1 && boundary < colon) || /^[A-Za-z][A-Za-z0-9+.-]*:/u.test($input); })()`,
   "ipv4":                  "/^(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)\\.){3}(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)$/.test($input)",
@@ -56,7 +56,7 @@ var FormatCheatSheet = map[string]string{
   "url":                   "/^(?:https?|ftp):\\/\\/(?:[^\\s/?#@]+(?::[^\\s/?#@]*)?@)?(?:(?!(?:10|127)(?:\\.\\d{1,3}){3})(?!(?:169\\.254|192\\.168)(?:\\.\\d{1,3}){2})(?!172\\.(?:1[6-9]|2\\d|3[0-1])(?:\\.\\d{1,3}){2})(?:[1-9]\\d?|1\\d\\d|2[01]\\d|22[0-3])(?:\\.(?:1?\\d{1,2}|2[0-4]\\d|25[0-5])){2}(?:\\.(?:[1-9]\\d?|1\\d\\d|2[0-4]\\d|25[0-4]))|(?=.{1,253}(?::\\d{2,5})?(?:\\/[^\\s]*)?$)(?:[a-z0-9\\u00a1-\\uffff](?:[-a-z0-9\\u00a1-\\uffff]{0,61}[a-z0-9\\u00a1-\\uffff])?\\.)+(?:[a-z\\u00a1-\\uffff](?:[-a-z0-9\\u00a1-\\uffff]{0,61}[a-z0-9\\u00a1-\\uffff])))(?::\\d{2,5})?(?:\\/[^\\s]*)?$/iu.test($input)",
   "date-time":             `(() => { const match = /^([0-9]{4})-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])[Tt]((?:[01][0-9]|2[0-3])):([0-5][0-9]):([0-5][0-9]|60)(?:\.[0-9]+)?(?:[Zz]|([+-])((?:[01][0-9]|2[0-3])):([0-5][0-9]))$/.exec($input); if (match === null) return false; const year = Number(match[1]); const month = Number(match[2]); const day = Number(match[3]); if (day > [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][month - 1] + (month === 2 && (year % 400 === 0 || (year % 4 === 0 && year % 100 !== 0)) ? 1 : 0)) return false; if (match[6] !== "60") return true; const instant = new Date(0); instant.setUTCFullYear(year, month - 1, day); instant.setUTCHours(Number(match[4]), Number(match[5]), 0, 0); const offset = match[7] === undefined ? 0 : (match[7] === "+" ? 1 : -1) * (Number(match[8]) * 60 + Number(match[9])); instant.setUTCMinutes(instant.getUTCMinutes() - offset); return instant.getUTCHours() === 23 && instant.getUTCMinutes() === 59 && ((instant.getUTCMonth() === 5 && instant.getUTCDate() === 30) || (instant.getUTCMonth() === 11 && instant.getUTCDate() === 31)); })()`,
   "date":                  `(() => { const match = /^([0-9]{4})-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])$/.exec($input); if (match === null) return false; const year = Number(match[1]); const month = Number(match[2]); const day = Number(match[3]); return day <= [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][month - 1] + (month === 2 && (year % 400 === 0 || (year % 4 === 0 && year % 100 !== 0)) ? 1 : 0); })()`,
-  "time":                  "/^([01][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9](?:\\.[0-9]{1,9})?(Z|[+-]([01][0-9]|2[0-3]):[0-5][0-9])$/i.test($input)",
+  "time":                  `(() => { const match = /^([01][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9]|60)(?:\.[0-9]+)?(?:[Zz]|([+-])((?:[01][0-9]|2[0-3])):([0-5][0-9]))$/.exec($input); if (match === null) return false; if (match[3] !== "60") return true; const offset = match[4] === undefined ? 0 : (match[4] === "+" ? 1 : -1) * (Number(match[5]) * 60 + Number(match[6])); const minutes = Number(match[1]) * 60 + Number(match[2]) - offset; return ((minutes % 1440) + 1440) % 1440 === 1439; })()`,
   "duration":              "/^P(?!$)((\\d+Y)?(\\d+M)?(\\d+D)?(T(?=\\d)(\\d+H)?(\\d+M)?(\\d+S)?)?|(\\d+W)?)$/.test($input)",
   "json-pointer":          "/^(?:\\/(?:[^~/]|~0|~1)*)*$/.test($input)",
   "relative-json-pointer": "/^(?:0|[1-9][0-9]*)(?:#|(?:\\/(?:[^~/]|~0|~1)*)*)$/.test($input)",

package/native/core/factories/MetadataCommentTagFactory.go

@@ -268,7 +268,7 @@ var metadataCommentTagFactory_PARSER = map[string]metadataCommentTagFactory_pars
     Report func(msg string) any
     Value  string
   }) metadataCommentTagFactory_TagRecord {
-    return metadataCommentTagFactory_numeric(props, "MultipleOf", "multipleOf", "$importInternal(\"_isMultipleOf\")($input, "+props.Value+")", "$input % "+props.Value+"n === 0n")
+    return metadataCommentTagFactory_numeric(props, "MultipleOf", "multipleOf", "$input % "+props.Value+" === 0", "$input % "+props.Value+"n === 0n")
   },
   "format": func(props struct {
     Report func(msg string) any
@@ -292,8 +292,8 @@ var metadataCommentTagFactory_PARSER = map[string]metadataCommentTagFactory_pars
   }) metadataCommentTagFactory_TagRecord {
     value := metadataCommentTagFactory_parse_number(props)
     return metadataCommentTagFactory_TagRecord{"string": {
-      {Name: "MinLength<" + props.Value + ">", Target: "string", Kind: "minLength", Value: value, Validate: props.Value + " <= $importInternal(\"_stringLength\")($input)", Exclusive: metadataCommentTagFactory_exclusive("minLength"), Schema: map[string]any{"minLength": value}},
-      {Name: "MaxLength<" + props.Value + ">", Target: "string", Kind: "maxLength", Value: value, Validate: "$importInternal(\"_stringLength\")($input) <= " + props.Value, Exclusive: metadataCommentTagFactory_exclusive("maxLength"), Schema: map[string]any{"maxLength": value}},
+      {Name: "MinLength<" + props.Value + ">", Target: "string", Kind: "minLength", Value: value, Validate: props.Value + " <= $input.length", Exclusive: metadataCommentTagFactory_exclusive("minLength"), Schema: map[string]any{"minLength": value}},
+      {Name: "MaxLength<" + props.Value + ">", Target: "string", Kind: "maxLength", Value: value, Validate: "$input.length <= " + props.Value, Exclusive: metadataCommentTagFactory_exclusive("maxLength"), Schema: map[string]any{"maxLength": value}},
     }}
   },
   "minLength": func(props struct {
@@ -301,14 +301,14 @@ var metadataCommentTagFactory_PARSER = map[string]metadataCommentTagFactory_pars
     Value  string
   }) metadataCommentTagFactory_TagRecord {
     value := metadataCommentTagFactory_parse_number(props)
-    return metadataCommentTagFactory_TagRecord{"string": {{Name: "MinLength<" + props.Value + ">", Target: "string", Kind: "minLength", Value: value, Validate: props.Value + " <= $importInternal(\"_stringLength\")($input)", Exclusive: metadataCommentTagFactory_exclusive("minLength"), Schema: map[string]any{"minLength": value}}}}
+    return metadataCommentTagFactory_TagRecord{"string": {{Name: "MinLength<" + props.Value + ">", Target: "string", Kind: "minLength", Value: value, Validate: props.Value + " <= $input.length", Exclusive: metadataCommentTagFactory_exclusive("minLength"), Schema: map[string]any{"minLength": value}}}}
   },
   "maxLength": func(props struct {
     Report func(msg string) any
     Value  string
   }) metadataCommentTagFactory_TagRecord {
     value := metadataCommentTagFactory_parse_number(props)
-    return metadataCommentTagFactory_TagRecord{"string": {{Name: "MaxLength<" + props.Value + ">", Target: "string", Kind: "maxLength", Value: value, Validate: "$importInternal(\"_stringLength\")($input) <= " + props.Value, Exclusive: metadataCommentTagFactory_exclusive("maxLength"), Schema: map[string]any{"maxLength": value}}}}
+    return metadataCommentTagFactory_TagRecord{"string": {{Name: "MaxLength<" + props.Value + ">", Target: "string", Kind: "maxLength", Value: value, Validate: "$input.length <= " + props.Value, Exclusive: metadataCommentTagFactory_exclusive("maxLength"), Schema: map[string]any{"maxLength": value}}}}
   },
 }
 
@@ -407,13 +407,28 @@ func metadataCommentTagFactory_parse_type(props struct {
     "number": {{Name: "Type<" + strconv.Quote(value) + ">", Target: "number", Kind: "type", Value: value, Validate: validate, Exclusive: metadataCommentTagFactory_exclusive("type"), Schema: numberSchema}},
   }
   if value == "int64" || value == "uint64" {
-    // The bigint form used to emit `true` for int64 and a lower bound only for
-    // uint64, so `bigint & Type<"int64">` -- the spelling the documentation
-    // recommends -- certified any magnitude at all. Both now delegate to the
-    // helper that holds the exact inclusive bound a bigint can represent.
-    bigintValidate := "$importInternal(\"isTypeUint64Bigint\")($input)"
+    // Both checks stay inline, spelled exactly as `Type<"int64">` and
+    // `Type<"uint64">` declare them, because `@type int64` and
+    // `bigint & Type<"int64">` are two spellings of one constraint.
+    //
+    // That declaration must not name a runtime helper the way the `number` arms
+    // above do. A `$importInternal(...)` in a tag template makes the emitted
+    // validator import a `typia/lib/internal/*` module, and the declaration
+    // lives in `@typia/interface`, which `typia` depends on through a caret
+    // range that only floats upward -- so an older `typia` installs a newer
+    // `@typia/interface` and emits an import its own runtime never shipped
+    // (#2330). `isTypeInt64` and `isTypeUint64` are safe there because
+    // `@typia/interface` 13.0.0 already named them and `typia` 13.0.0 already
+    // shipped them; a helper introduced later is not, and inside one major
+    // there is no range that prevents the pairing.
+    //
+    // The bound this leaves unenforced is real: int64 accepts any magnitude and
+    // uint64 only rejects negatives. #2338 owns restoring it, and only a major
+    // can carry it -- an inline exact comparison would name no helper, but
+    // tightening an accepted range rejects data that passes today.
+    bigintValidate := "BigInt(0) <= $input"
     if value == "int64" {
-      bigintValidate = "$importInternal(\"isTypeInt64Bigint\")($input)"
+      bigintValidate = "true"
     }
     record["bigint"] = []schemametadata.IMetadataTypeTag{
       {Name: "Type<" + strconv.Quote(value) + ">", Target: "bigint", Kind: "type", Value: value, Validate: bigintValidate, Exclusive: metadataCommentTagFactory_exclusive("type"), Schema: bigintSchema},

package/native/core/factories/ProtobufFactory.go

@@ -17,6 +17,11 @@ type protobufFactoryNamespace struct{}
 var ProtobufFactory = protobufFactoryNamespace{}
 
 type ProtobufFactory_IProps struct {
+  // Method is the fully qualified typia API the call site invoked, exactly as
+  // it must appear in the diagnostic code (`typia.protobuf.encode`). It is the
+  // sole source of that code: composing the code here from a shorter spelling
+  // let the encode and decode programmers, which already pass the whole call
+  // accessor, report `typia.protobuf.typia.protobuf.encode`.
   Method     string
   Checker    *shimchecker.Checker
   Components *schemametadata.MetadataCollection
@@ -40,7 +45,7 @@ func (protobufFactoryNamespace) Metadata(props ProtobufFactory_IProps) *schemame
       Code   string
       Errors []nativecontext.TransformerError_MetadataFactory_IError
     }{
-      Code:   "typia.protobuf." + props.Method,
+      Code:   props.Method,
       Errors: protobufFactory_errors(result.Errors),
     }))
   }