typia 14.0.6 → 15.0.0

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

@@ -0,0 +1,199 @@
+package main
+
+import (
+  "strings"
+  "testing"
+)
+
+// TestLlmEvaluationRejectsInvalidProbability verifies typia.llm.evaluation
+// rejects every malformed or misplaced probability requirement.
+//
+// A requirement is a probability, so anything outside `[0, 1]` or not a
+// number is a compile error; two requirements on one target are ambiguous
+// rather than silently resolved; and `@probability` on an object has no
+// decision to govern. Once one choice, score, or set member declares a
+// requirement, every member must be covered directly or by a property default.
+// Each case pins the accessor and, for members, the member literal, so a
+// rejection lands on the declaration the author must fix. A valid requirement
+// of every spelling, in a separate project, is the positive twin.
+//
+//  1. Build one project with one call per invalid requirement, and a separate
+//     project with valid requirements.
+//  2. Require the first build to fail through the transform-diagnostic path.
+//  3. Require each rejected accessor with its message, and the valid project
+//     to compile.
+func TestLlmEvaluationRejectsInvalidProbability(t *testing.T) {
+  errText := llmEvaluationDiagnosticsBuild(t, "probability", llmEvaluationProbabilitySource)
+  for _, expected := range []string{
+    "- $input.tagOver\n  - LLM evaluation tags.Probability must be in [0, 1], but got 1.5.",
+    "- $input.tagUnder\n  - LLM evaluation tags.Probability must be in [0, 1], but got -0.1.",
+    "- $input.commentText\n  - LLM evaluation @probability must be a number in [0, 1], but got \"high\".",
+    "- $input.commentEmpty\n  - LLM evaluation @probability must be a number in [0, 1], but got \"\".",
+    "- $input.commentOver\n  - LLM evaluation @probability must be in [0, 1], but got 2.",
+    "- $input.commentTwice\n  - LLM evaluation @probability is declared more than once; keep only one.",
+    "- $input.both\n  - LLM evaluation boolean has both tags.Probability and @probability; keep only one.",
+    "- $input.memberTag\n  - LLM evaluation tags.Probability must be in [0, 1], but got 1.2. (member \"risky\")",
+    "- $input.memberComment\n  - LLM evaluation @probability must be in [0, 1], but got 3. (member \"bad\")",
+    "- $input.scoreComment\n  - LLM evaluation @probability must be a number in [0, 1], but got \"x\". (member 1)",
+    "- $input.setMember\n  - LLM evaluation tags.Probability must be in [0, 1], but got 7. (member \"card\")",
+    "- $input.partialTag\n  - LLM evaluation probability requirements must cover every member once one member declares one; add tags.Probability or @probability to member \"plain\", or add a property @probability default.",
+    "- $input.partialComment\n  - LLM evaluation probability requirements must cover every member once one member declares one; add tags.Probability or @probability to member \"plain\", or add a property @probability default.",
+    "- $input.nested\n  - LLM evaluation @probability must be on a boolean, choice, score, or set property, not on an object.",
+    // two tags on one member fail typia's generic exclusive-tag check first
+    "- __type.tagTwice: string & Probability0.5 & Probability0.6\n  - the property [\"typia.tag\"] kind 'probability' can't be duplicated.",
+    // a non-literal value fails typia's generic tag check (samchon/typia#2400)
+    "- __type.tagWide: boolean & Probabilitynumber\n  - the property [\"typia.tag.value\"] must be a literal, literal tuple, object, or undefined type.",
+  } {
+    if !strings.Contains(errText, expected) {
+      t.Fatalf("llm.evaluation probability diagnostic missing %q:\n%s", expected, errText)
+    }
+  }
+  llmEvaluationAccepts(t, "probability-valid", llmEvaluationProbabilityValidSource)
+}
+
+const llmEvaluationProbabilityValidSource = `import typia, { tags } from "typia";
+
+enum Team {
+  /**
+   * Payments
+   *
+   * @probability 0.5
+   */
+  billing = "billing",
+  /**
+   * Outages
+   *
+   * @probability 0.75
+   */
+  technical = "technical",
+}
+
+typia.llm.evaluation<IValid>();
+
+interface IValid {
+  /** Tagged? */
+  tagged: boolean & tags.Probability<0>;
+  /** Tagged at one? */
+  taggedOne: boolean & tags.Probability<1>;
+  /**
+   * Commented?
+   *
+   * @probability 1
+   */
+  commented: boolean;
+  /** Team? */
+  team: Team;
+  /** Action? */
+  action:
+    | ("risky" & tags.Probability<0.9>)
+    | ("safe" & tags.Probability<0>);
+  /**
+   * Products?
+   *
+   * @probability 0.7
+   */
+  products: Array<("card" & tags.Probability<0.9>) | "loan">;
+}
+`
+
+const llmEvaluationProbabilitySource = `import typia, { tags } from "typia";
+
+enum Bad {
+  /** Fine */
+  fine = "fine",
+  /**
+   * Broken
+   *
+   * @probability 3
+   */
+  bad = "bad",
+}
+
+enum Level {
+  /**
+   * Low
+   *
+   * @probability x
+   */
+  low = 1,
+  /** High */
+  high = 2,
+}
+
+enum Partial {
+  /**
+   * Gated
+   *
+   * @probability 0.8
+   */
+  gated = "gated",
+  /** Plain */
+  plain = "plain",
+}
+
+typia.llm.evaluation<{
+  /** Wide? */ tagWide: boolean & tags.Probability<number>;
+}>();
+
+typia.llm.evaluation<{
+  /** Over? */ tagOver: boolean & tags.Probability<1.5>;
+  /** Under? */ tagUnder: boolean & tags.Probability<-0.1>;
+  /**
+   * Text?
+   *
+   * @probability high
+   */
+  commentText: boolean;
+  /**
+   * Empty?
+   *
+   * @probability
+   */
+  commentEmpty: boolean;
+  /**
+   * Over?
+   *
+   * @probability 2
+   */
+  commentOver: boolean;
+  /**
+   * Twice?
+   *
+   * @probability 0.5
+   * @probability 0.6
+   */
+  commentTwice: boolean;
+  /**
+   * Both?
+   *
+   * @probability 0.7
+   */
+  both: boolean & tags.Probability<0.8>;
+  /** Member tag? */
+  memberTag: ("risky" & tags.Probability<1.2>) | "safe";
+  /** Member comment? */
+  memberComment: Bad;
+  /** Score comment? */
+  scoreComment: Level;
+  /** Set member? */
+  setMember: Array<("card" & tags.Probability<7>) | "loan">;
+  /** Partial tag? */
+  partialTag: ("gated" & tags.Probability<0.8>) | "plain";
+  /** Partial comment? */
+  partialComment: Partial;
+  /**
+   * Nested?
+   *
+   * @probability 0.5
+   */
+  nested: {
+    /** Inner? */
+    inner: boolean;
+  };
+}>();
+
+typia.llm.evaluation<{
+  /** Twice? */
+  tagTwice: ("a" & tags.Probability<0.5> & tags.Probability<0.6>) | "b";
+}>();
+`

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

@@ -0,0 +1,94 @@
+package main
+
+import (
+  "strings"
+  "testing"
+)
+
+// TestLlmEvaluationRejectsUnsupportedRefinements verifies every validation
+// tag outside the decoder's contract is a compile error.
+//
+// A decoded decision must satisfy every constraint in T. The evaluator cannot
+// turn a selected literal into one satisfying an unrelated refinement.
+//
+//  1. Declare invalid string, number, boolean, and object refinements.
+//  2. Require a transform diagnostic at each decision path.
+//  3. Accept neighboring annotation-only tags.
+func TestLlmEvaluationRejectsUnsupportedRefinements(t *testing.T) {
+  errText := llmEvaluationDiagnosticsBuild(t, "refinements", `import typia, { tags } from "typia";
+
+typia.llm.evaluation<{
+  /** Which team? */
+  team: ("a" & tags.MinLength<2>) | "b";
+  /** Which level? */
+  level: (0 & tags.Minimum<1>) | 2;
+  /** Which product? */
+  products: Array<( "a" & tags.MinLength<2>) | "b">;
+  nested: {
+    /** Which status? */
+    status: ("old" & tags.Pattern<"^new$">) | "new";
+  };
+}>();
+
+type TrueOnly = tags.TagBase<{
+  target: "boolean";
+  kind: "trueOnly";
+  value: undefined;
+  validate: "$input === true";
+}>;
+typia.llm.evaluation<{
+  /** Is it permitted? */
+  permitted: boolean & TrueOnly;
+}>();
+
+type GuardedProbability = tags.TagBase<{
+  target: "boolean";
+  kind: "probability";
+  value: 0.8;
+  validate: "$input === true";
+}>;
+typia.llm.evaluation<{
+  /** Is it allowed? */
+  allowed: boolean & GuardedProbability;
+}>();
+
+type ObjectOnly = tags.TagBase<{
+  target: "object";
+  kind: "objectOnly";
+  value: undefined;
+  validate: "true";
+}>;
+typia.llm.evaluation<{
+  child: ({ /** Is it active? */ active: boolean } & ObjectOnly);
+}>();
+
+interface IRoot {
+  /** Is it active? */
+  active: boolean;
+}
+typia.llm.evaluation<IRoot & ObjectOnly>();
+`)
+  for _, expected := range []string{
+    "- $input.team\n  - LLM evaluation does not support",
+    "- $input.level\n  - LLM evaluation does not support",
+    "- $input.products\n  - LLM evaluation does not support",
+    "- $input.nested.status\n  - LLM evaluation does not support",
+    "- $input.permitted\n  - LLM evaluation does not support",
+    "- $input.allowed\n  - LLM evaluation does not support",
+    "- $input.child\n  - LLM evaluation does not support",
+    "- $input\n  - LLM evaluation does not support",
+  } {
+    if !strings.Contains(errText, expected) {
+      t.Fatalf("missing unsupported refinement diagnostic %q:\n%s", expected, errText)
+    }
+  }
+  llmEvaluationAccepts(t, "annotation-refinements", `import typia, { tags } from "typia";
+
+typia.llm.evaluation<{
+  /** Is it urgent? */
+  urgent: boolean & tags.Default<true>;
+  /** Which level? */
+  level: (0 & tags.Example<0>) | 1;
+}>();
+`)
+}

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

@@ -0,0 +1,232 @@
+package main
+
+import (
+  "os"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestLlmEvaluationRejectsUndecidableTypes verifies typia.llm.evaluation
+// rejects every position an evaluation model cannot answer.
+//
+// An evaluation model answers only closed sets: booleans, one option of a
+// literal union, a level of a numeric union, and membership in a literal set.
+// Every other shape, a leaf without the JSDoc text that becomes its question,
+// and a decision type that asks nothing must fail at compile time on the exact
+// accessor, instead of emitting a question the model cannot receive or a value
+// decode() can never produce. A valid neighbor type in the same project is
+// the positive twin that must keep compiling.
+//
+//  1. Build one project with one call per rejected shape, and a separate
+//     project with a valid decision type.
+//  2. Require the first build to fail through the transform-diagnostic path.
+//  3. Require each rejected accessor with its message, and the valid project
+//     to compile.
+func TestLlmEvaluationRejectsUndecidableTypes(t *testing.T) {
+  errText := llmEvaluationDiagnosticsBuild(t, "undecidable", llmEvaluationUndecidableSource)
+  for _, expected := range []string{
+    "- $input\n  - LLM evaluation type must be an object type.",
+    "- $input\n  - LLM evaluation type must be a single object type.",
+    "- $input\n  - LLM evaluation type must have at least one decision property.",
+    "- $input\n  - LLM evaluation does not support dynamic keys.",
+    "- $input.text\n  - LLM evaluation supports only boolean",
+    "- $input.count\n  - LLM evaluation supports only boolean",
+    "- $input.big\n  - LLM evaluation supports only boolean",
+    "- $input.template\n  - LLM evaluation supports only boolean",
+    "- $input.date\n  - LLM evaluation supports only boolean",
+    "- $input.tuple\n  - LLM evaluation supports only boolean",
+    "- $input.map\n  - LLM evaluation supports only boolean",
+    "- $input.sole\n  - LLM evaluation does not support a single literal value, because it decides nothing.",
+    "- $input.yes\n  - LLM evaluation does not support a single literal value, because it decides nothing.",
+    "- $input.mixed\n  - LLM evaluation does not support union types mixing different question kinds.",
+    "- $input.flagOrLabel\n  - LLM evaluation does not support union types mixing different question kinds.",
+    "- $input.bigints\n  - LLM evaluation does not support bigint literal types.",
+    "- $input.nullable\n  - LLM evaluation does not support nullable properties.",
+    "- $input.optional\n  - LLM evaluation does not support optional, undefined, void, or never properties, because every property of the result needs an answer.",
+    "- $input.undefinable\n  - LLM evaluation does not support optional, undefined, void, or never properties, because every property of the result needs an answer.",
+    "- $input.voided\n  - LLM evaluation does not support optional, undefined, void, or never properties, because every property of the result needs an answer.",
+    "- $input.impossible\n  - LLM evaluation does not support optional, undefined, void, or never properties, because every property of the result needs an answer.",
+    "- $input.objects\n  - LLM evaluation does not support union types.",
+    "- $input.rows\n  - LLM evaluation supports only arrays of a string literal union or string enum.",
+    "- $input.levels\n  - LLM evaluation supports only arrays of a string literal union or string enum.",
+    "- $input.tagged\n  - LLM evaluation does not support array type tags, because the answered members decide the array.",
+    "- $input.record\n  - LLM evaluation does not support dynamic keys.",
+    "- $input.empty\n  - LLM evaluation object must have at least one decision property.",
+    "- $input.node.child\n  - LLM evaluation does not support recursive types.",
+    "- $input.undocumented\n  - LLM evaluation property must have a JSDoc description, because it is the question text.",
+    "- $input.blank\n  - LLM evaluation property must have a JSDoc description, because it is the question text.",
+    "- $input.nbsp\n  - LLM evaluation property must have a JSDoc description, because it is the question text.",
+    "- $input.tagOnly\n  - LLM evaluation property must have a JSDoc description, because it is the question text.",
+    "- $input.secret\n  - LLM evaluation does not support hidden properties, because every property of the result needs an answer.",
+    "- $input.method\n  - LLM evaluation does not support function properties.",
+    "- $input.anything\n  - LLM evaluation does not support any or unknown types, because an evaluation model answers only closed sets.",
+    "- $input.opaque\n  - LLM evaluation does not support any or unknown types, because an evaluation model answers only closed sets.",
+  } {
+    if !strings.Contains(errText, expected) {
+      t.Fatalf("llm.evaluation diagnostic missing %q:\n%s", expected, errText)
+    }
+  }
+  llmEvaluationAccepts(t, "undecidable-valid", llmEvaluationUndecidableValidSource)
+}
+
+// llmEvaluationDiagnosticsBuild builds a fixture project that must fail through
+// the transform-diagnostic path and returns its normalized stderr.
+func llmEvaluationDiagnosticsBuild(t *testing.T, name string, source string) string {
+  t.Helper()
+  dir := llmEvaluationProject(t, name, source)
+  _, errText, code := ttscTypiaTestCapture(func() int {
+    return runBuild([]string{
+      "--cwd", dir,
+      "--tsconfig", "tsconfig.json",
+      "--emit",
+      "--outDir", filepath.Join(dir, "dist"),
+    })
+  })
+  if code != 3 {
+    t.Fatalf("%s llm.evaluation build should fail with code 3, got %d\nstderr=%s", name, code, errText)
+  }
+  normalized := strings.ReplaceAll(filepath.ToSlash(errText), "\r\n", "\n")
+  if !strings.Contains(normalized, "error TS(typia.llm.evaluation):") {
+    t.Fatalf("%s llm.evaluation diagnostic code missing:\n%s", name, errText)
+  }
+  return normalized
+}
+
+// llmEvaluationAccepts builds a fixture project that must compile without any
+// diagnostic. A positive twin lives in its own project because diagnostic
+// line numbers are not a reliable way to prove a call stayed quiet.
+func llmEvaluationAccepts(t *testing.T, name string, source string) {
+  t.Helper()
+  dir := llmEvaluationProject(t, name, source)
+  _, errText, code := ttscTypiaTestCapture(func() int {
+    return runBuild([]string{
+      "--cwd", dir,
+      "--tsconfig", "tsconfig.json",
+      "--emit",
+      "--outDir", filepath.Join(dir, "dist"),
+    })
+  })
+  if code != 0 {
+    t.Fatalf("%s positive twin must compile, got code %d\nstderr=%s", name, code, errText)
+  }
+}
+
+// llmEvaluationProject writes a single-file fixture project and returns its
+// directory, removed when the test ends.
+func llmEvaluationProject(t *testing.T, name string, source 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, "llm-evaluation-"+name+"-")
+  if err != nil {
+    t.Fatalf("create temp fixture: %v", err)
+  }
+  t.Cleanup(func() {
+    _ = os.RemoveAll(dir)
+  })
+  src := filepath.Join(dir, "src")
+  if err := os.MkdirAll(src, 0o755); err != nil {
+    t.Fatalf("mkdir fixture src: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(dir, "tsconfig.json"), []byte(llmEvaluationDiagnosticsTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(source), 0o644); err != nil {
+    t.Fatalf("write source: %v", err)
+  }
+  return dir
+}
+
+const llmEvaluationDiagnosticsTSConfig = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "moduleResolution": "bundler",
+    "ignoreDeprecations": "6.0",
+    "types": ["*"],
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "include": ["src"]
+}
+`
+
+const llmEvaluationUndecidableValidSource = `import typia from "typia";
+
+interface IValid {
+  /** Is it urgent? */
+  urgent: boolean;
+  /** Which team? */
+  team: "billing" | "technical";
+}
+typia.llm.evaluation<IValid>();
+`
+
+const llmEvaluationUndecidableSource = `import typia, { tags } from "typia";
+
+interface IFlag {
+  /** Is it urgent? */
+  urgent: boolean;
+}
+interface IOther {
+  /** Is it late? */
+  late: boolean;
+}
+typia.llm.evaluation<any>();
+typia.llm.evaluation<IFlag | IOther>();
+typia.llm.evaluation<{}>();
+typia.llm.evaluation<Record<string, boolean>>();
+
+interface INode {
+  /** Is it a leaf? */
+  leaf: boolean;
+  child: INode;
+}
+
+typia.llm.evaluation<{
+  /** Text? */ text: string;
+  /** Count? */ count: number;
+  /** Big? */ big: bigint;
+  /** Template? */ template: ` + "`id-${string}`" + `;
+  /** Date? */ date: Date;
+  /** Tuple? */ tuple: [boolean];
+  /** Map? */ map: Map<string, boolean>;
+  /** Sole? */ sole: "only";
+  /** Yes? */ yes: true;
+  /** Mixed? */ mixed: "one" | 2;
+  /** Flag or label? */ flagOrLabel: boolean | "label";
+  /** Bigints? */ bigints: 1n | 2n;
+  /** Nullable? */ nullable: boolean | null;
+  /** Optional? */ optional?: boolean;
+  /** Undefinable? */ undefinable: boolean | undefined;
+  /** Voided? */ voided: void;
+  /** Impossible? */ impossible: never;
+  objects: { /** A? */ a: boolean } | { /** B? */ b: boolean };
+  /** Rows? */ rows: Array<{ /** Row? */ row: boolean }>;
+  /** Levels? */ levels: Array<1 | 2>;
+  /** Tagged? */ tagged: Array<"a" | "b"> & tags.MinItems<1>;
+  record: Record<string, boolean>;
+  empty: {};
+  node: INode;
+  undocumented: boolean;
+  /**   */ blank: boolean;
+  /** @probability 0.5 */ tagOnly: boolean;
+  /**   */ nbsp: boolean;
+  /**
+   * Secret?
+   *
+   * @hidden
+   */
+  secret: boolean;
+  /** Method? */ method: () => boolean;
+  /** Anything? */ anything: any;
+  /** Opaque? */ opaque: unknown;
+}>();
+`

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

@@ -0,0 +1,94 @@
+package main
+
+import (
+  "os"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestMetadataTypeTagSoleMalformedDiagnostic verifies a malformed type tag is
+// reported even when no valid tag accompanies it.
+//
+// MetadataTypeTagFactory.Analyze collects a message for every malformed tag
+// object, but returned early when no tag object survived, before those messages
+// reached the error list. A sole malformed tag therefore vanished: the
+// constraint its author wrote was enforced nowhere, while the same tag beside a
+// valid one was reported (samchon/typia#2400). The now-visible message must
+// also name the malformed `validate` property instead of blaming `target`.
+// The accompanied case keeps its message, and a valid sole tag is the negative
+// twin that must keep compiling.
+//
+//  1. Build one project whose calls carry a sole non-literal tag value, the
+//     same value beside a valid tag, and the same value through
+//     `typia.llm.evaluation`, and a separate project with a valid sole tag.
+//  2. Require the first build to fail through the transform-diagnostic path.
+//  3. Require every malformed call's messages, and the valid project to
+//     compile.
+func TestMetadataTypeTagSoleMalformedDiagnostic(t *testing.T) {
+  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, "sole-malformed-tag-")
+  if err != nil {
+    t.Fatalf("create temp fixture: %v", err)
+  }
+  t.Cleanup(func() {
+    _ = os.RemoveAll(dir)
+  })
+  if err := os.MkdirAll(filepath.Join(dir, "src"), 0o755); err != nil {
+    t.Fatalf("mkdir fixture src: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(dir, "tsconfig.json"), []byte(llmEvaluationDiagnosticsTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(dir, "src", "main.ts"), []byte(metadataTypeTagSoleMalformedSource), 0o644); err != nil {
+    t.Fatalf("write source: %v", err)
+  }
+  _, errText, code := ttscTypiaTestCapture(func() int {
+    return runBuild([]string{
+      "--cwd", dir,
+      "--tsconfig", "tsconfig.json",
+      "--emit",
+      "--outDir", filepath.Join(dir, "dist"),
+    })
+  })
+  if code != 3 {
+    t.Fatalf("sole malformed tag build should fail with code 3, got %d\nstderr=%s", code, errText)
+  }
+  normalized := strings.ReplaceAll(filepath.ToSlash(errText), "\r\n", "\n")
+  const value = "  - the property [\"typia.tag.value\"] must be a literal, literal tuple, object, or undefined type."
+  const validate = "  - the property [\"typia.tag.validate\"] must be a string literal, or an object whose keys are 'boolean', 'bigint', 'number', 'string', 'array', or 'object'."
+  for _, expected := range []string{
+    "- number & Minimum<number>\n" + value + "\n" + validate,
+    "- number & Minimum<number> & Maximum<10>\n" + value + "\n" + validate,
+    "- Probe.flag: boolean & Probabilitynumber\n" + value,
+  } {
+    if !strings.Contains(normalized, expected) {
+      t.Fatalf("sole malformed tag diagnostic missing %q:\n%s", expected, errText)
+    }
+  }
+  if strings.Contains(normalized, "typia.tag.target") {
+    t.Fatalf("a malformed validate must not be reported as target:\n%s", errText)
+  }
+  llmEvaluationAccepts(t, "sole-valid-tag", metadataTypeTagSoleValidSource)
+}
+
+const metadataTypeTagSoleValidSource = `import typia, { tags } from "typia";
+
+typia.is<number & tags.Minimum<0>>(1);
+`
+
+const metadataTypeTagSoleMalformedSource = `import typia, { tags } from "typia";
+
+type Probe = {
+  /** Is it flagged? */
+  flag: boolean & tags.Probability<number>;
+};
+
+typia.is<number & tags.Minimum<number>>(1);
+typia.is<number & tags.Minimum<number> & tags.Maximum<10>>(1);
+typia.llm.evaluation<Probe>();
+`

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

@@ -34,8 +34,9 @@ func TestTemplateLiteralTypeTagsTransform(t *testing.T) {
   if code != 0 {
     t.Fatalf("template literal tags transform failed: code=%d stderr=\n%s", code, errText)
   }
-  if !strings.Contains(out, `require("typia/lib/internal/_stringLength")`) ||
-    !strings.Contains(out, "._stringLength(input) <= 30") ||
+  if !strings.Contains(out, `require("typia/lib/internal/_stringLengthLte")`) ||
+    !strings.Contains(out, "._stringLengthLte(input, 30)") ||
+    !strings.Contains(out, `require("typia/lib/internal/_stringLengthGte")`) ||
     !strings.Contains(out, "RegExp(/^prefix(.*)postfix$/)") {
     t.Fatalf("emitted checker should combine the template pattern with its tags:\n%s", out)
   }

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

@@ -9,6 +9,7 @@ import (
   "path/filepath"
   "sort"
   "strings"
+  "sync"
 
   shimast "github.com/microsoft/typescript-go/shim/ast"
   shimcompiler "github.com/microsoft/typescript-go/shim/compiler"
@@ -86,6 +87,7 @@ func runTransform(args []string) int {
   transformDiags := []typiaTransformDiagnostic{}
   transformOptions := pluginOptions.TransformOptions()
   extras := nativecontext.ITypiaContext_Extras{
+    Shared: &sync.Map{},
     AddDiagnostic: func(diag *nativecontext.ITypiaDiagnostic) int {
       transformDiags = append(transformDiags, typiaTransformDiagnosticFrom(diag))
       return len(transformDiags)