typia 14.0.6 → 15.0.0

package/lib/llm.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"llm.mjs","names":[],"sources":["../src/llm.ts"],"sourcesContent":["import {\n  IJsonParseResult,\n  ILlmApplication,\n  ILlmController,\n  ILlmSchema,\n  ILlmStructuredOutput,\n} from \"@typia/interface\";\n\nimport { NoTransformConfigurationError } from \"./transformers/NoTransformConfigurationError\";\n\n/* -----------------------------------------------------------\n  FUNCTION CALLING\n----------------------------------------------------------- */\n/**\n * Creates LLM function calling controller.\n *\n * @danger You must configure the generic argument `Class`\n */\nexport function controller(\n  name: string,\n  execute: object,\n  config?: Partial<Pick<ILlmApplication.IConfig<any>, \"validate\">>,\n): never;\n\n/**\n * Creates LLM function calling controller from class/interface.\n *\n * Generates {@link ILlmController} from a TypeScript class or interface,\n * containing both function calling schemas ({@link ILlmFunction}) and an\n * executor ({@link ILlmController.execute}).\n *\n * Each {@link ILlmFunction} includes a built-in {@link ILlmFunction.validate}\n * function that validates LLM-generated arguments before execution. When\n * validation fails, use `LlmJson.stringify()` from `@typia/utils` to format\n * errors for LLM feedback, enabling auto-correction.\n *\n * When passed to LLM providers (ChatGPT, Claude, Gemini, etc.), the LLM\n * automatically selects functions and fills arguments from conversation.\n * Execute the selected function via {@link ILlmController.execute}.\n *\n * Related functions:\n *\n * - {@link application} — Schemas only, without executor\n * - {@link parameters} — Single parameters schema for structured output\n * - {@link schema} — Single type schema\n *\n * @template Class Target class or interface type\n * @template Config LLM schema configuration\n * @param name Controller identifier name\n * @param execute Executor instance\n * @param config LLM application options\n * @returns LLM function calling controller\n */\nexport function controller<\n  Class extends Record<string, any>,\n  Config extends Partial<\n    ILlmSchema.IConfig & {\n      /**\n       * Whether to disallow superfluous properties or not.\n       *\n       * If configure as `true`, {@link validateEquals} function would be used\n       * for validation feedback, which is more strict than {@link validate}\n       * function.\n       *\n       * @default false\n       */\n      equals: boolean;\n    }\n  > = {},\n>(\n  name: string,\n  execute: Class,\n  config?: Partial<Pick<ILlmApplication.IConfig<Class>, \"validate\">>,\n): ILlmController<Class>;\n\n/** @internal */\nexport function controller(..._args: any[]): never {\n  NoTransformConfigurationError(\"llm.controller\");\n}\n\n/**\n * Creates LLM function calling application.\n *\n * @danger You must configure the generic argument `Class`\n */\nexport function application(\n  config?: Partial<Pick<ILlmApplication.IConfig<any>, \"validate\">>,\n): never;\n\n/**\n * Creates LLM function calling application from class/interface.\n *\n * Generates {@link ILlmApplication} from a TypeScript class or interface,\n * containing function calling schemas ({@link ILlmFunction}). Does not include\n * an executor—use {@link controller} if you need execution capability.\n *\n * Each {@link ILlmFunction} includes a built-in {@link ILlmFunction.validate}\n * function that validates LLM-generated arguments before execution. When\n * validation fails, use `LlmJson.stringify()` from `@typia/utils` to format\n * errors for LLM feedback, enabling auto-correction.\n *\n * When passed to LLM providers (ChatGPT, Claude, Gemini, etc.), the LLM\n * automatically selects functions and fills arguments from conversation. You\n * execute the function manually with the LLM-prepared arguments.\n *\n * Related functions:\n *\n * - {@link controller} — Includes executor alongside schemas\n * - {@link parameters} — Single parameters schema for structured output\n * - {@link schema} — Single type schema\n *\n * @template Class Target class or interface type\n * @template Config LLM schema configuration\n * @param config LLM application options\n * @returns LLM function calling application\n */\nexport function application<\n  Class extends Record<string, any>,\n  Config extends Partial<\n    ILlmSchema.IConfig & {\n      /**\n       * Whether to disallow superfluous properties or not.\n       *\n       * If configure as `true`, {@link validateEquals} function would be used\n       * for validation feedback, which is more strict than {@link validate}\n       * function.\n       *\n       * @default false\n       */\n      equals: boolean;\n    }\n  > = {},\n>(\n  config?: Partial<Pick<ILlmApplication.IConfig<Class>, \"validate\">>,\n): ILlmApplication<Class>;\n\n/** @internal */\nexport function application(): never {\n  NoTransformConfigurationError(\"llm.application\");\n}\n\n/**\n * Creates LLM structured output interface.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function structuredOutput(): never;\n\n/**\n * Creates LLM structured output interface from TypeScript object type.\n *\n * Generates {@link ILlmStructuredOutput} containing everything needed for\n * handling LLM structured outputs: the JSON schema for prompting, and functions\n * for parsing, coercing, and validating responses.\n *\n * Structured outputs allow LLMs to generate data conforming to a predefined\n * schema instead of free-form text. This is useful for:\n *\n * - Extracting structured data from conversations\n * - Generating typed responses for downstream processing\n * - Ensuring consistent output formats across LLM calls\n *\n * Workflow:\n *\n * 1. Pass {@link ILlmStructuredOutput.parameters} schema to LLM provider\n * 2. Receive LLM response (JSON string or pre-parsed object)\n * 3. Use {@link ILlmStructuredOutput.parse} for raw strings or\n *    {@link ILlmStructuredOutput.coerce} for pre-parsed objects\n * 4. Use {@link ILlmStructuredOutput.validate} to check the result\n *\n * Related functions:\n *\n * - {@link parameters} — Schema only, without parse/coerce/validate\n * - {@link application} — Multiple function schemas from class/interface\n * - {@link controller} — Application with executor\n *\n * @template T Target output type (object with static properties)\n * @template Config LLM schema configuration\n * @returns LLM structured output interface\n */\nexport function structuredOutput<\n  T extends Record<string, any>,\n  Config extends Partial<\n    ILlmSchema.IConfig & {\n      /**\n       * Whether to disallow superfluous properties or not.\n       *\n       * If configure as `true`, {@link validateEquals} function would be used\n       * for validation feedback, which is more strict than {@link validate}\n       * function.\n       *\n       * @default false\n       */\n      equals: boolean;\n    }\n  > = {},\n>(): ILlmStructuredOutput<T>;\n\n/** @internal */\nexport function structuredOutput(): never {\n  NoTransformConfigurationError(\"llm.structuredOutput\");\n}\n\n/* -----------------------------------------------------------\n  RAW SCHEMAS\n----------------------------------------------------------- */\n/**\n * Creates LLM parameters schema.\n *\n * @danger You must configure the generic argument `Parameters`\n */\nexport function parameters(): never;\n\n/**\n * Creates LLM parameters schema from TypeScript object type.\n *\n * Generates {@link ILlmSchema.IParameters} for LLM function calling or\n * structured outputs. LLMs use keyworded arguments only, so the type must be an\n * object with static properties (no dynamic properties allowed).\n *\n * Use cases:\n *\n * - Function calling: LLM fills parameters from conversation\n * - Structured outputs: LLM generates structured data, not plain text\n *\n * Related functions:\n *\n * - {@link application} — Multiple function schemas from class/interface\n * - {@link controller} — Application with executor\n * - {@link schema} — Single type schema (not parameters-specific)\n *\n * @template Parameters Target parameters type (object with static properties)\n * @template Config LLM schema configuration\n * @returns LLM parameters schema\n */\nexport function parameters<\n  Parameters extends Record<string, any>,\n  Config extends Partial<ILlmSchema.IConfig> = {},\n>(): ILlmSchema.IParameters;\n\n/** @internal */\nexport function parameters(): never {\n  NoTransformConfigurationError(\"llm.parameters\");\n}\n\n/**\n * Creates LLM type schema.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function schema(): never;\n\n/**\n * Creates LLM type schema from TypeScript type.\n *\n * Generates {@link ILlmSchema} for use in LLM function calling. For actual\n * function calling with TypeScript functions, use {@link application}. For\n * structured output generation, use {@link parameters}.\n *\n * LLM function calling flow:\n *\n * 1. LLM selects function and fills arguments from conversation\n * 2. You execute the function with LLM-prepared arguments\n * 3. Return value is passed back to LLM via system prompt\n * 4. LLM continues conversation based on return value\n *\n * Related functions:\n *\n * - {@link application} — Multiple function schemas from class/interface\n * - {@link controller} — Application with executor\n * - {@link parameters} — Parameters schema for structured output\n *\n * @template T Target type\n * @template Config LLM schema configuration\n * @param $defs Shared schema definitions for `$ref` referencing\n * @returns LLM type schema\n */\nexport function schema<T, Config = {}>(\n  $defs: Record<string, ILlmSchema>,\n): ILlmSchema;\n\n/** @internal */\nexport function schema(): never {\n  NoTransformConfigurationError(\"llm.schema\");\n}\n\n/* -----------------------------------------------------------\n  UTILITY FUNCTIONS\n----------------------------------------------------------- */\n/**\n * Parse LLM response JSON with type coercion.\n *\n * @danger You must configure the generic argument `Parameters`\n */\nexport function parse(input: string): never;\n\n/**\n * Parse lenient JSON with schema-based type coercion.\n *\n * Handles incomplete or malformed JSON commonly produced by LLMs:\n *\n * - Unclosed brackets, strings, trailing commas\n * - JavaScript-style comments (`//` and multi-line)\n * - Unquoted object keys, incomplete keywords (`tru`, `fal`, `nul`)\n * - Markdown code block extraction, junk prefix skipping\n *\n * Also coerces double-stringified values based on the `Parameters` schema:\n *\n * - `\"42\"` → `42` (when schema expects number)\n * - `\"true\"` → `true` (when schema expects boolean)\n * - `\"null\"` → `null` (when schema expects null)\n * - `\"{...}\"` → `{...}` (when schema expects object)\n * - `\"[...]\"` → `[...]` (when schema expects array)\n *\n * Type validation is NOT performed—use {@link ILlmFunction.validate} or\n * `typia.validate()` for that.\n *\n * For repeated parsing, use {@link createParse} to avoid regenerating the schema\n * each time.\n *\n * Related functions:\n *\n * - {@link createParse} — Create reusable parser function\n * - {@link coerce} — Type coercion for already-parsed objects\n * - {@link parameters} — Generate parameters schema from type\n *\n * @template Parameters Target parameters type (object with static properties)\n * @template Config LLM schema configuration\n * @param input Raw JSON string (potentially incomplete or malformed)\n * @returns Parse result with typed data on success, or partial data with errors\n */\nexport function parse<\n  Parameters extends Record<string, any>,\n  Config extends Partial<ILlmSchema.IConfig> = {},\n>(input: string): IJsonParseResult<Parameters>;\n\n/** @internal */\nexport function parse(): never {\n  NoTransformConfigurationError(\"llm.parse\");\n}\n\n/**\n * Coerce LLM arguments to match expected schema types.\n *\n * LLMs often return values with incorrect types (e.g., numbers as strings).\n * This function recursively coerces values based on the `Parameters` schema:\n *\n * - `\"42\"` → `42` (when schema expects number)\n * - `\"true\"` → `true` (when schema expects boolean)\n * - `\"null\"` → `null` (when schema expects null)\n * - `\"{...}\"` → `{...}` (when schema expects object)\n * - `\"[...]\"` → `[...]` (when schema expects array)\n *\n * Use this when your SDK provides already-parsed objects but values may have\n * wrong types. For raw JSON strings, use {@link parse} instead.\n *\n * For repeated coercion, use {@link createCoerce} to avoid regenerating the\n * schema each time.\n *\n * Type validation is NOT performed—use {@link ILlmFunction.validate} or\n * `typia.validate()` for that.\n *\n * Related functions:\n *\n * - {@link createCoerce} — Create reusable coercer function\n * - {@link parse} — Parse and coerce raw JSON strings\n * - {@link parameters} — Generate parameters schema from type\n *\n * @template Parameters Target parameters type (object with static properties)\n * @template Config LLM schema configuration\n * @param input Parsed arguments object from LLM (with potentially wrong types)\n * @returns Coerced arguments with corrected types\n */\nexport function coerce<\n  Parameters extends Record<string, any>,\n  Config extends Partial<ILlmSchema.IConfig> = {},\n>(input: Parameters): Parameters;\n\n/** @internal */\nexport function coerce(): never {\n  NoTransformConfigurationError(\"llm.coerce\");\n}\n\n/**\n * Create reusable LLM JSON parser with type coercion.\n *\n * @danger You must configure the generic argument `Parameters`\n */\nexport function createParse(): never;\n\n/**\n * Create reusable lenient JSON parser with schema-based type coercion.\n *\n * Returns a parser function that handles incomplete or malformed JSON commonly\n * produced by LLMs:\n *\n * - Unclosed brackets, strings, trailing commas\n * - JavaScript-style comments (`//` and multi-line)\n * - Unquoted object keys, incomplete keywords (`tru`, `fal`, `nul`)\n * - Markdown code block extraction, junk prefix skipping\n *\n * Also coerces double-stringified values based on the `Parameters` schema:\n *\n * - `\"42\"` → `42` (when schema expects number)\n * - `\"true\"` → `true` (when schema expects boolean)\n * - `\"null\"` → `null` (when schema expects null)\n * - `\"{...}\"` → `{...}` (when schema expects object)\n * - `\"[...]\"` → `[...]` (when schema expects array)\n *\n * Use this instead of {@link parse} when parsing multiple inputs to avoid\n * regenerating the schema each time.\n *\n * Type validation is NOT performed—use {@link ILlmFunction.validate} or\n * `typia.validate()` for that.\n *\n * Related functions:\n *\n * - {@link parse} — One-shot parsing (regenerates schema each call)\n * - {@link createCoerce} — Create reusable coercer function\n * - {@link parameters} — Generate parameters schema from type\n *\n * @template Parameters Target parameters type (object with static properties)\n * @template Config LLM schema configuration\n * @returns Reusable parser function\n */\nexport function createParse<\n  Parameters extends Record<string, any>,\n  Config extends Partial<ILlmSchema.IConfig> = {},\n>(): (input: string) => IJsonParseResult<Parameters>;\n\n/** @internal */\nexport function createParse(): never {\n  NoTransformConfigurationError(\"llm.createParse\");\n}\n\n/**\n * Create reusable LLM arguments coercer.\n *\n * @danger You must configure the generic argument `Parameters`\n */\nexport function createCoerce(): never;\n\n/**\n * Create reusable coercer for LLM arguments.\n *\n * Returns a coercer function that fixes incorrect types commonly returned by\n * LLMs (e.g., numbers as strings). Coerces values based on the `Parameters`\n * schema:\n *\n * - `\"42\"` → `42` (when schema expects number)\n * - `\"true\"` → `true` (when schema expects boolean)\n * - `\"null\"` → `null` (when schema expects null)\n * - `\"{...}\"` → `{...}` (when schema expects object)\n * - `\"[...]\"` → `[...]` (when schema expects array)\n *\n * Use this instead of {@link coerce} when coercing multiple inputs to avoid\n * regenerating the schema each time.\n *\n * Type validation is NOT performed—use {@link ILlmFunction.validate} or\n * `typia.validate()` for that.\n *\n * Related functions:\n *\n * - {@link coerce} — One-shot coercion (regenerates schema each call)\n * - {@link createParse} — Create reusable parser function\n * - {@link parameters} — Generate parameters schema from type\n *\n * @template Parameters Target parameters type (object with static properties)\n * @template Config LLM schema configuration\n * @returns Reusable coercer function\n */\nexport function createCoerce<\n  Parameters extends Record<string, any>,\n  Config extends Partial<ILlmSchema.IConfig> = {},\n>(): (input: Parameters) => Parameters;\n\n/** @internal */\nexport function createCoerce(): never {\n  NoTransformConfigurationError(\"llm.createCoerce\");\n}\n"],"mappings":";;;;;;;;;;;;;;;AA4EA,SAAgB,WAAW,GAAG,OAAqB;CACjD,8BAA8B,gBAAgB;AAChD;;AA2DA,SAAgB,cAAqB;CACnC,8BAA8B,iBAAiB;AACjD;;AA4DA,SAAgB,mBAA0B;CACxC,8BAA8B,sBAAsB;AACtD;;AAwCA,SAAgB,aAAoB;CAClC,8BAA8B,gBAAgB;AAChD;;AAuCA,SAAgB,SAAgB;CAC9B,8BAA8B,YAAY;AAC5C;;AAqDA,SAAgB,QAAe;CAC7B,8BAA8B,WAAW;AAC3C;;AAwCA,SAAgB,SAAgB;CAC9B,8BAA8B,YAAY;AAC5C;;AAkDA,SAAgB,cAAqB;CACnC,8BAA8B,iBAAiB;AACjD;;AA4CA,SAAgB,eAAsB;CACpC,8BAA8B,kBAAkB;AAClD"}
+{"version":3,"file":"llm.mjs","names":[],"sources":["../src/llm.ts"],"sourcesContent":["import {\n  IJsonParseResult,\n  ILlmApplication,\n  ILlmController,\n  ILlmEvaluation,\n  ILlmSchema,\n  ILlmStructuredOutput,\n} from \"@typia/interface\";\n\nimport { NoTransformConfigurationError } from \"./transformers/NoTransformConfigurationError\";\n\n/* -----------------------------------------------------------\n  FUNCTION CALLING\n----------------------------------------------------------- */\n/**\n * Creates LLM function calling controller.\n *\n * @danger You must configure the generic argument `Class`\n */\nexport function controller(\n  name: string,\n  execute: object,\n  config?: Partial<Pick<ILlmApplication.IConfig<any>, \"validate\">>,\n): never;\n\n/**\n * Creates LLM function calling controller from class/interface.\n *\n * Generates {@link ILlmController} from a TypeScript class or interface,\n * containing both function calling schemas ({@link ILlmFunction}) and an\n * executor ({@link ILlmController.execute}).\n *\n * Each {@link ILlmFunction} includes a built-in {@link ILlmFunction.validate}\n * function that validates LLM-generated arguments before execution. When\n * validation fails, use `LlmJson.stringify()` from `@typia/utils` to format\n * errors for LLM feedback, enabling auto-correction.\n *\n * When passed to LLM providers (ChatGPT, Claude, Gemini, etc.), the LLM\n * automatically selects functions and fills arguments from conversation.\n * Execute the selected function via {@link ILlmController.execute}.\n *\n * Related functions:\n *\n * - {@link application} — Schemas only, without executor\n * - {@link parameters} — Single parameters schema for structured output\n * - {@link schema} — Single type schema\n *\n * @template Class Target class or interface type\n * @template Config LLM schema configuration\n * @param name Controller identifier name\n * @param execute Executor instance\n * @param config LLM application options\n * @returns LLM function calling controller\n */\nexport function controller<\n  Class extends Record<string, any>,\n  Config extends Partial<\n    ILlmSchema.IConfig & {\n      /**\n       * Whether to disallow superfluous properties or not.\n       *\n       * If configure as `true`, {@link validateEquals} function would be used\n       * for validation feedback, which is more strict than {@link validate}\n       * function.\n       *\n       * @default false\n       */\n      equals: boolean;\n    }\n  > = {},\n>(\n  name: string,\n  execute: Class,\n  config?: Partial<Pick<ILlmApplication.IConfig<Class>, \"validate\">>,\n): ILlmController<Class>;\n\n/** @internal */\nexport function controller(..._args: any[]): never {\n  NoTransformConfigurationError(\"llm.controller\");\n}\n\n/**\n * Creates LLM function calling application.\n *\n * @danger You must configure the generic argument `Class`\n */\nexport function application(\n  config?: Partial<Pick<ILlmApplication.IConfig<any>, \"validate\">>,\n): never;\n\n/**\n * Creates LLM function calling application from class/interface.\n *\n * Generates {@link ILlmApplication} from a TypeScript class or interface,\n * containing function calling schemas ({@link ILlmFunction}). Does not include\n * an executor—use {@link controller} if you need execution capability.\n *\n * Each {@link ILlmFunction} includes a built-in {@link ILlmFunction.validate}\n * function that validates LLM-generated arguments before execution. When\n * validation fails, use `LlmJson.stringify()` from `@typia/utils` to format\n * errors for LLM feedback, enabling auto-correction.\n *\n * When passed to LLM providers (ChatGPT, Claude, Gemini, etc.), the LLM\n * automatically selects functions and fills arguments from conversation. You\n * execute the function manually with the LLM-prepared arguments.\n *\n * Related functions:\n *\n * - {@link controller} — Includes executor alongside schemas\n * - {@link parameters} — Single parameters schema for structured output\n * - {@link schema} — Single type schema\n *\n * @template Class Target class or interface type\n * @template Config LLM schema configuration\n * @param config LLM application options\n * @returns LLM function calling application\n */\nexport function application<\n  Class extends Record<string, any>,\n  Config extends Partial<\n    ILlmSchema.IConfig & {\n      /**\n       * Whether to disallow superfluous properties or not.\n       *\n       * If configure as `true`, {@link validateEquals} function would be used\n       * for validation feedback, which is more strict than {@link validate}\n       * function.\n       *\n       * @default false\n       */\n      equals: boolean;\n    }\n  > = {},\n>(\n  config?: Partial<Pick<ILlmApplication.IConfig<Class>, \"validate\">>,\n): ILlmApplication<Class>;\n\n/** @internal */\nexport function application(): never {\n  NoTransformConfigurationError(\"llm.application\");\n}\n\n/**\n * Creates LLM structured output interface.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function structuredOutput(): never;\n\n/**\n * Creates LLM structured output interface from TypeScript object type.\n *\n * Generates {@link ILlmStructuredOutput} containing everything needed for\n * handling LLM structured outputs: the JSON schema for prompting, and functions\n * for parsing, coercing, and validating responses.\n *\n * Structured outputs allow LLMs to generate data conforming to a predefined\n * schema instead of free-form text. This is useful for:\n *\n * - Extracting structured data from conversations\n * - Generating typed responses for downstream processing\n * - Ensuring consistent output formats across LLM calls\n *\n * Workflow:\n *\n * 1. Pass {@link ILlmStructuredOutput.parameters} schema to LLM provider\n * 2. Receive LLM response (JSON string or pre-parsed object)\n * 3. Use {@link ILlmStructuredOutput.parse} for raw strings or\n *    {@link ILlmStructuredOutput.coerce} for pre-parsed objects\n * 4. Use {@link ILlmStructuredOutput.validate} to check the result\n *\n * Related functions:\n *\n * - {@link parameters} — Schema only, without parse/coerce/validate\n * - {@link application} — Multiple function schemas from class/interface\n * - {@link controller} — Application with executor\n *\n * @template T Target output type (object with static properties)\n * @template Config LLM schema configuration\n * @returns LLM structured output interface\n */\nexport function structuredOutput<\n  T extends Record<string, any>,\n  Config extends Partial<\n    ILlmSchema.IConfig & {\n      /**\n       * Whether to disallow superfluous properties or not.\n       *\n       * If configure as `true`, {@link validateEquals} function would be used\n       * for validation feedback, which is more strict than {@link validate}\n       * function.\n       *\n       * @default false\n       */\n      equals: boolean;\n    }\n  > = {},\n>(): ILlmStructuredOutput<T>;\n\n/** @internal */\nexport function structuredOutput(): never {\n  NoTransformConfigurationError(\"llm.structuredOutput\");\n}\n\n/* -----------------------------------------------------------\n  EVALUATION\n----------------------------------------------------------- */\n/**\n * Creates LLM evaluation questions.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function evaluation(): never;\n\n/**\n * Creates LLM evaluation questions from TypeScript object type.\n *\n * Generates {@link ILlmEvaluation} for evaluation models, which answer typed\n * questions about a shared state with probabilities instead of generating text:\n * TypeSafe's Jev natively, and OpenAI, Anthropic, and Google through Vercel AI\n * SDK's `experimental_evaluate()`.\n *\n * Every leaf property of `T` becomes one question, and its JSDoc description\n * becomes the question text:\n *\n * - `boolean` → boolean question\n * - String enum or string literal union → choice question\n * - Numeric enum or numeric literal union → score question\n * - Array of a string literal union or string enum → one boolean question per\n *   member\n * - Nested object → flattened, one question per leaf\n *\n * Types an evaluation model cannot answer, such as `string`, `number`, optional\n * properties, or a leaf without a JSDoc description, are compile errors. Use\n * `tags.Probability<N>` or `@probability N` to set decision thresholds and\n * acceptance minimums. Once one choice, score, or set member declares a\n * requirement, every member must declare one or inherit the property's\n * `@probability` default. A nested object's own JSDoc description is not sent\n * to the model; only the leaves' descriptions become question text. Other\n * validation refinements that the answer decoder cannot enforce are compile\n * errors.\n *\n * This feature is experimental. It follows Vercel AI SDK's evaluation model\n * specification, which is itself experimental and may change in patch\n * releases.\n *\n * Workflow:\n *\n * 1. Pass {@link ILlmEvaluation.questions} to the evaluation model\n * 2. Receive the answer map keyed by the same question IDs\n * 3. Use {@link ILlmEvaluation.decode} to fold the answers back into `T`; pass the\n *    model's declared rounding precision when available\n *\n * Related functions:\n *\n * - {@link structuredOutput} — Structured output generated as text by an LLM\n *\n * @template T Target decision type (object with static properties)\n * @returns LLM evaluation questions with a checked answer decoder\n */\nexport function evaluation<T extends Record<string, any>>(): ILlmEvaluation<T>;\n\n/** @internal */\nexport function evaluation(): never {\n  NoTransformConfigurationError(\"llm.evaluation\");\n}\n\n/* -----------------------------------------------------------\n  RAW SCHEMAS\n----------------------------------------------------------- */\n/**\n * Creates LLM parameters schema.\n *\n * @danger You must configure the generic argument `Parameters`\n */\nexport function parameters(): never;\n\n/**\n * Creates LLM parameters schema from TypeScript object type.\n *\n * Generates {@link ILlmSchema.IParameters} for LLM function calling or\n * structured outputs. LLMs use keyworded arguments only, so the type must be an\n * object with static properties (no dynamic properties allowed).\n *\n * Use cases:\n *\n * - Function calling: LLM fills parameters from conversation\n * - Structured outputs: LLM generates structured data, not plain text\n *\n * Related functions:\n *\n * - {@link application} — Multiple function schemas from class/interface\n * - {@link controller} — Application with executor\n * - {@link schema} — Single type schema (not parameters-specific)\n *\n * @template Parameters Target parameters type (object with static properties)\n * @template Config LLM schema configuration\n * @returns LLM parameters schema\n */\nexport function parameters<\n  Parameters extends Record<string, any>,\n  Config extends Partial<ILlmSchema.IConfig> = {},\n>(): ILlmSchema.IParameters;\n\n/** @internal */\nexport function parameters(): never {\n  NoTransformConfigurationError(\"llm.parameters\");\n}\n\n/**\n * Creates LLM type schema.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function schema(): never;\n\n/**\n * Creates LLM type schema from TypeScript type.\n *\n * Generates {@link ILlmSchema} for use in LLM function calling. For actual\n * function calling with TypeScript functions, use {@link application}. For\n * structured output generation, use {@link parameters}.\n *\n * LLM function calling flow:\n *\n * 1. LLM selects function and fills arguments from conversation\n * 2. You execute the function with LLM-prepared arguments\n * 3. Return value is passed back to LLM via system prompt\n * 4. LLM continues conversation based on return value\n *\n * Related functions:\n *\n * - {@link application} — Multiple function schemas from class/interface\n * - {@link controller} — Application with executor\n * - {@link parameters} — Parameters schema for structured output\n *\n * @template T Target type\n * @template Config LLM schema configuration\n * @param $defs Shared schema definitions for `$ref` referencing\n * @returns LLM type schema\n */\nexport function schema<T, Config = {}>(\n  $defs: Record<string, ILlmSchema>,\n): ILlmSchema;\n\n/** @internal */\nexport function schema(): never {\n  NoTransformConfigurationError(\"llm.schema\");\n}\n\n/* -----------------------------------------------------------\n  UTILITY FUNCTIONS\n----------------------------------------------------------- */\n/**\n * Parse LLM response JSON with type coercion.\n *\n * @danger You must configure the generic argument `Parameters`\n */\nexport function parse(input: string): never;\n\n/**\n * Parse lenient JSON with schema-based type coercion.\n *\n * Handles incomplete or malformed JSON commonly produced by LLMs:\n *\n * - Unclosed brackets, strings, trailing commas\n * - JavaScript-style comments (`//` and multi-line)\n * - Unquoted object keys, incomplete keywords (`tru`, `fal`, `nul`)\n * - Markdown code block extraction, junk prefix skipping\n *\n * Also coerces double-stringified values based on the `Parameters` schema:\n *\n * - `\"42\"` → `42` (when schema expects number)\n * - `\"true\"` → `true` (when schema expects boolean)\n * - `\"null\"` → `null` (when schema expects null)\n * - `\"{...}\"` → `{...}` (when schema expects object)\n * - `\"[...]\"` → `[...]` (when schema expects array)\n *\n * Type validation is NOT performed—use {@link ILlmFunction.validate} or\n * `typia.validate()` for that.\n *\n * For repeated parsing, use {@link createParse} to avoid regenerating the schema\n * each time.\n *\n * Related functions:\n *\n * - {@link createParse} — Create reusable parser function\n * - {@link coerce} — Type coercion for already-parsed objects\n * - {@link parameters} — Generate parameters schema from type\n *\n * @template Parameters Target parameters type (object with static properties)\n * @template Config LLM schema configuration\n * @param input Raw JSON string (potentially incomplete or malformed)\n * @returns Parse result with typed data on success, or partial data with errors\n */\nexport function parse<\n  Parameters extends Record<string, any>,\n  Config extends Partial<ILlmSchema.IConfig> = {},\n>(input: string): IJsonParseResult<Parameters>;\n\n/** @internal */\nexport function parse(): never {\n  NoTransformConfigurationError(\"llm.parse\");\n}\n\n/**\n * Coerce LLM arguments to match expected schema types.\n *\n * LLMs often return values with incorrect types (e.g., numbers as strings).\n * This function recursively coerces values based on the `Parameters` schema:\n *\n * - `\"42\"` → `42` (when schema expects number)\n * - `\"true\"` → `true` (when schema expects boolean)\n * - `\"null\"` → `null` (when schema expects null)\n * - `\"{...}\"` → `{...}` (when schema expects object)\n * - `\"[...]\"` → `[...]` (when schema expects array)\n *\n * Use this when your SDK provides already-parsed objects but values may have\n * wrong types. For raw JSON strings, use {@link parse} instead.\n *\n * For repeated coercion, use {@link createCoerce} to avoid regenerating the\n * schema each time.\n *\n * Type validation is NOT performed—use {@link ILlmFunction.validate} or\n * `typia.validate()` for that.\n *\n * Related functions:\n *\n * - {@link createCoerce} — Create reusable coercer function\n * - {@link parse} — Parse and coerce raw JSON strings\n * - {@link parameters} — Generate parameters schema from type\n *\n * @template Parameters Target parameters type (object with static properties)\n * @template Config LLM schema configuration\n * @param input Parsed arguments object from LLM (with potentially wrong types)\n * @returns Coerced arguments with corrected types\n */\nexport function coerce<\n  Parameters extends Record<string, any>,\n  Config extends Partial<ILlmSchema.IConfig> = {},\n>(input: Parameters): Parameters;\n\n/** @internal */\nexport function coerce(): never {\n  NoTransformConfigurationError(\"llm.coerce\");\n}\n\n/**\n * Create reusable LLM JSON parser with type coercion.\n *\n * @danger You must configure the generic argument `Parameters`\n */\nexport function createParse(): never;\n\n/**\n * Create reusable lenient JSON parser with schema-based type coercion.\n *\n * Returns a parser function that handles incomplete or malformed JSON commonly\n * produced by LLMs:\n *\n * - Unclosed brackets, strings, trailing commas\n * - JavaScript-style comments (`//` and multi-line)\n * - Unquoted object keys, incomplete keywords (`tru`, `fal`, `nul`)\n * - Markdown code block extraction, junk prefix skipping\n *\n * Also coerces double-stringified values based on the `Parameters` schema:\n *\n * - `\"42\"` → `42` (when schema expects number)\n * - `\"true\"` → `true` (when schema expects boolean)\n * - `\"null\"` → `null` (when schema expects null)\n * - `\"{...}\"` → `{...}` (when schema expects object)\n * - `\"[...]\"` → `[...]` (when schema expects array)\n *\n * Use this instead of {@link parse} when parsing multiple inputs to avoid\n * regenerating the schema each time.\n *\n * Type validation is NOT performed—use {@link ILlmFunction.validate} or\n * `typia.validate()` for that.\n *\n * Related functions:\n *\n * - {@link parse} — One-shot parsing (regenerates schema each call)\n * - {@link createCoerce} — Create reusable coercer function\n * - {@link parameters} — Generate parameters schema from type\n *\n * @template Parameters Target parameters type (object with static properties)\n * @template Config LLM schema configuration\n * @returns Reusable parser function\n */\nexport function createParse<\n  Parameters extends Record<string, any>,\n  Config extends Partial<ILlmSchema.IConfig> = {},\n>(): (input: string) => IJsonParseResult<Parameters>;\n\n/** @internal */\nexport function createParse(): never {\n  NoTransformConfigurationError(\"llm.createParse\");\n}\n\n/**\n * Create reusable LLM arguments coercer.\n *\n * @danger You must configure the generic argument `Parameters`\n */\nexport function createCoerce(): never;\n\n/**\n * Create reusable coercer for LLM arguments.\n *\n * Returns a coercer function that fixes incorrect types commonly returned by\n * LLMs (e.g., numbers as strings). Coerces values based on the `Parameters`\n * schema:\n *\n * - `\"42\"` → `42` (when schema expects number)\n * - `\"true\"` → `true` (when schema expects boolean)\n * - `\"null\"` → `null` (when schema expects null)\n * - `\"{...}\"` → `{...}` (when schema expects object)\n * - `\"[...]\"` → `[...]` (when schema expects array)\n *\n * Use this instead of {@link coerce} when coercing multiple inputs to avoid\n * regenerating the schema each time.\n *\n * Type validation is NOT performed—use {@link ILlmFunction.validate} or\n * `typia.validate()` for that.\n *\n * Related functions:\n *\n * - {@link coerce} — One-shot coercion (regenerates schema each call)\n * - {@link createParse} — Create reusable parser function\n * - {@link parameters} — Generate parameters schema from type\n *\n * @template Parameters Target parameters type (object with static properties)\n * @template Config LLM schema configuration\n * @returns Reusable coercer function\n */\nexport function createCoerce<\n  Parameters extends Record<string, any>,\n  Config extends Partial<ILlmSchema.IConfig> = {},\n>(): (input: Parameters) => Parameters;\n\n/** @internal */\nexport function createCoerce(): never {\n  NoTransformConfigurationError(\"llm.createCoerce\");\n}\n"],"mappings":";;;;;;;;;;;;;;;;AA6EA,SAAgB,WAAW,GAAG,OAAqB;CACjD,8BAA8B,gBAAgB;AAChD;;AA2DA,SAAgB,cAAqB;CACnC,8BAA8B,iBAAiB;AACjD;;AA4DA,SAAgB,mBAA0B;CACxC,8BAA8B,sBAAsB;AACtD;;AA6DA,SAAgB,aAAoB;CAClC,8BAA8B,gBAAgB;AAChD;;AAwCA,SAAgB,aAAoB;CAClC,8BAA8B,gBAAgB;AAChD;;AAuCA,SAAgB,SAAgB;CAC9B,8BAA8B,YAAY;AAC5C;;AAqDA,SAAgB,QAAe;CAC7B,8BAA8B,WAAW;AAC3C;;AAwCA,SAAgB,SAAgB;CAC9B,8BAA8B,YAAY;AAC5C;;AAkDA,SAAgB,cAAqB;CACnC,8BAA8B,iBAAiB;AACjD;;AA4CA,SAAgB,eAAsB;CACpC,8BAA8B,kBAAkB;AAClD"}

package/lib/re-exports.d.ts

@@ -1,2 +1,2 @@
-export type { AssertionGuard, IJsonParseResult, IValidation, IRandomGenerator, StandardSchemaV1, OpenApi, IJsonSchemaApplication, IJsonSchemaCollection, IJsonSchemaUnit, ILlmController, ILlmApplication, ILlmFunction, ILlmStructuredOutput, ILlmSchema, IMetadataSchema, IMetadataSchemaCollection, IMetadataSchemaUnit, IMetadataComponents, IMetadataTypeTag, IJsDocTagInfo, Atomic, Classifiable, ClassifyResult, Primitive, Resolved, CamelCase, KebabCase, PascalCase, SnakeCase, IReadableURLSearchParams, } from "@typia/interface";
+export type { AssertionGuard, IJsonParseResult, IValidation, IRandomGenerator, StandardSchemaV1, OpenApi, IJsonSchemaApplication, IJsonSchemaCollection, IJsonSchemaUnit, ILlmController, ILlmApplication, ILlmFunction, ILlmStructuredOutput, ILlmEvaluation, ILlmSchema, IMetadataSchema, IMetadataSchemaCollection, IMetadataSchemaUnit, IMetadataComponents, IMetadataTypeTag, IJsDocTagInfo, Atomic, Classifiable, ClassifyResult, Primitive, Resolved, CamelCase, KebabCase, PascalCase, SnakeCase, IReadableURLSearchParams, } from "@typia/interface";
 export { tags } from "@typia/interface";

package/lib/re-exports.js.map

@@ -1 +1 @@
-{"version":3,"file":"re-exports.js","sourceRoot":"","sources":["../src/re-exports.ts"],"names":[],"mappings":";;;AAiDA,0EAA0E;AAC1E,sEAAsE;AACtE,0EAA0E;AAC1E,mEAAmE;AACnE,sBAAsB;AACtB,8CAAwC;AAA/B,iGAAA,IAAI,OAAA"}
+{"version":3,"file":"re-exports.js","sourceRoot":"","sources":["../src/re-exports.ts"],"names":[],"mappings":";;;AAkDA,0EAA0E;AAC1E,sEAAsE;AACtE,0EAA0E;AAC1E,mEAAmE;AACnE,sBAAsB;AACtB,8CAAwC;AAA/B,iGAAA,IAAI,OAAA"}

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

@@ -7,6 +7,7 @@ import (
   "io"
   "os"
   "path/filepath"
+  "sync"
 
   shimast "github.com/microsoft/typescript-go/shim/ast"
   shimcompiler "github.com/microsoft/typescript-go/shim/compiler"
@@ -114,6 +115,7 @@ func runBuild(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)

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

@@ -54,7 +54,7 @@ func TestDynamicKeyTagsTransform(t *testing.T) {
   }
   // The key is read into a local before it is tested, so its predicate is the
   // one place the emitted text can show the check exists at all.
-  if !strings.Contains(out, "RegExp(") || !strings.Contains(out, "_stringLength") {
+  if !strings.Contains(out, "RegExp(") || !strings.Contains(out, "_stringLengthGte") {
     t.Fatalf("emitted checker should test the dynamic key, not only its value:\n%s", out)
   }
   dynamicKeyTagsRunRuntimeCases(t, project, out)

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

@@ -0,0 +1,27 @@
+package main
+
+import "testing"
+
+// TestLlmEvaluationAcceptsPropertyAndEnumMemberProbability verifies both
+// supported JSDoc placements compile with the upper probability boundary.
+//
+// Primitive aliases may erase their name, but a final decision property's
+// comment and enum members' comments remain attached to their declarations.
+//
+//  1. Declare an aliased boolean and a probability-annotated enum.
+//  2. Put probability one on the final boolean decision property.
+//  3. Require successful compilation.
+func TestLlmEvaluationAcceptsPropertyAndEnumMemberProbability(t *testing.T) {
+  llmEvaluationAccepts(t, "property-probability-valid", `import typia from "typia";
+
+type Urgency = boolean;
+enum Choice {
+  /** @probability 1 */ yes = "yes",
+  /** @probability 0.2 */ no = "no",
+}
+typia.llm.evaluation<{
+  /** Urgent? @probability 1 */ urgent: Urgency;
+  /** Choice? */ choice: Choice;
+}>();
+`)
+}

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

@@ -0,0 +1,26 @@
+package main
+
+import "testing"
+
+// TestLlmEvaluationAcceptsUnselectedSourceProbability verifies a comment on
+// an unrelated property does not constrain an indexed-access decision.
+//
+// Indexed access extracts a property type, not its JSDoc. An annotation on a
+// different source property must not reject an otherwise valid evaluation.
+//
+//  1. Declare an annotated and an unannotated source property.
+//  2. Extract the unannotated property's type for an evaluation decision.
+//  3. Require successful compilation.
+func TestLlmEvaluationAcceptsUnselectedSourceProbability(t *testing.T) {
+  llmEvaluationAccepts(t, "unselected-source-probability", `import typia from "typia";
+interface Source {
+  /** @probability 0.8 */ ignored: boolean;
+  selected: boolean;
+}
+type Value = Source["selected"];
+typia.llm.evaluation<{
+  /** Is it urgent? */
+  urgent: Value;
+}>();
+`)
+}

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

@@ -0,0 +1,96 @@
+package main
+
+import (
+  "strings"
+  "testing"
+)
+
+// Evaluation promises to decode the entire T. Every required member must
+// become a question or fail compilation, including inherited/nested members.
+func TestLlmEvaluationCompleteObjectShape(t *testing.T) {
+  accepted := map[string]string{
+    "getter only": `class Decision {
+      /** Is it urgent? @probability 1 */ get urgent(): boolean { return true; }
+    }`,
+    "class getter": `class Decision {
+      /** Is it active? */ active!: boolean;
+      /** Is it urgent? @probability 1 */ get urgent(): boolean { return true; }
+    }`,
+    "inherited getter": `class Base {
+      /** Is it urgent? @probability 1 */ get urgent(): boolean { return true; }
+    }
+    class Decision extends Base {
+      /** Is it active? */
+      active!: boolean;
+    }`,
+    "interface getter": `interface Decision {
+      /** Is it active? */ active: boolean;
+      /** Is it urgent? @probability 1 */ get urgent(): boolean;
+    }`,
+    "nested getter": `class Child {
+      /** Is it urgent? @probability 1 */ get urgent(): boolean { return true; }
+    }
+    interface Decision { child: Child; }`,
+    "setter": `class Decision {
+      /** Is it active? */ active!: boolean;
+      /** Is it urgent? @probability 1 */ set urgent(value: boolean) {}
+    }`,
+  }
+  for name, declaration := range accepted {
+    t.Run(name, func(t *testing.T) {
+      source := `import typia from "typia";` + declaration + `
+        export const evaluation = typia.llm.evaluation<Decision>();`
+      project := llmEvaluationProject(t, "complete-"+strings.ReplaceAll(name, " ", "-"), source)
+      out, diagnostic, code := ttscTypiaTestCapture(func() int {
+        return runTransform([]string{"--cwd", project, "--tsconfig", "tsconfig.json", "--file", "src/main.ts", "--output", "js"})
+      })
+      if code != 0 || !strings.Contains(out, "threshold: 1") || !strings.Contains(out, `"urgent"`) {
+        t.Fatalf("getter is not in the plan: code=%d threshold=%t urgent=%t diagnostic=%s", code, strings.Contains(out, "threshold: 1"), strings.Contains(out, `"urgent"`), diagnostic)
+      }
+    })
+  }
+
+  rejected := map[string]struct{ declaration, diagnostic string }{
+    "method":        {`interface Decision { /** Is it active? */ active: boolean; execute(): void; }`, "function"},
+    "private":       {`class Decision { /** Is it active? */ active!: boolean; private token = 1; }`, "private"},
+    "protected":     {`class Decision { /** Is it active? */ active!: boolean; protected token = 1; }`, "protected"},
+    "sharp private": {`class Decision { /** Is it active? */ active!: boolean; #token = 1; }`, "private"},
+    "symbol":        {`declare const token: unique symbol; interface Decision { /** Is it active? */ active: boolean; [token]: boolean; }`, "symbol-keyed"},
+    "symbol index":  {`interface Decision { /** Is it active? */ active: boolean; [key: symbol]: boolean; }`, "symbol-keyed"},
+    "call":          {`interface Decision { /** Is it active? */ active: boolean; (): void; }`, "callable"},
+    "construct":     {`interface Decision { /** Is it active? */ active: boolean; new(): Decision; }`, "constructable"},
+    "nested method": {`interface Child { /** Is it urgent? */ urgent: boolean; execute(): void; }
+      interface Decision { child: Child; }`, "function"},
+    "inherited private": {`class Base { private token = 1; }
+      class Decision extends Base { /** Is it active? */ active!: boolean; }`, "private"},
+    "generic private": {`class Base<T> { private token!: T; }
+      class Decision extends Base<boolean> { /** Is it active? */ active!: boolean; }`, "private"},
+    "generic sharp private": {`class Base<T> { #token!: T; }
+      class Decision extends Base<boolean> { /** Is it active? */ active!: boolean; }`, "private"},
+    "interface extends private class": {`class Base { private token!: boolean; }
+      interface Decision extends Base { active: boolean; }`, "private"},
+    "internal": {`interface Decision {
+      /** Is it active? */ active: boolean;
+      /** @internal */ secret: boolean;
+    }`, "hidden properties"},
+    "intersection internal": {`type Decision = {
+      /** Is it active? */ active: boolean;
+    } & {
+      /** @internal */ secret: boolean;
+    };`, "hidden properties"},
+    "overlapping intersection internal": {`type Decision = {
+      /** Is it active? */ active: boolean;
+      /** @internal */ secret: boolean;
+    } & { secret: boolean };`, "hidden properties"},
+  }
+  for name, testcase := range rejected {
+    t.Run(name, func(t *testing.T) {
+      source := `import typia from "typia";` + testcase.declaration + `
+        export const evaluation = typia.llm.evaluation<Decision>();`
+      diagnostic := llmEvaluationDiagnosticsBuild(t, "complete-"+strings.ReplaceAll(name, " ", "-"), source)
+      if !strings.Contains(diagnostic, testcase.diagnostic) {
+        t.Fatalf("missing %q diagnostic: %s", testcase.diagnostic, diagnostic)
+      }
+    })
+  }
+}

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

@@ -0,0 +1,18 @@
+package main
+
+import "testing"
+
+// TestLlmEvaluationIgnoresDeclarationProbabilityWithoutCall verifies a
+// program without evaluation calls does not trigger JEV-specific diagnostics.
+//
+// The placement scanner is owned by the evaluation transformer, so merely
+// declaring a JSDoc tag must not alter ordinary TypeScript compilation.
+//
+//  1. Declare a tagged primitive alias.
+//  2. Omit every evaluation call.
+//  3. Require successful compilation.
+func TestLlmEvaluationIgnoresDeclarationProbabilityWithoutCall(t *testing.T) {
+  llmEvaluationAccepts(t, "no-evaluation-call", `/** @probability 0.8 */
+export type Urgency = boolean;
+`)
+}

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

@@ -0,0 +1,90 @@
+package main
+
+import (
+  "strings"
+  "testing"
+)
+
+// TestLlmEvaluationPlanEmissionTransform verifies typia.llm.evaluation emits
+// one deterministic plan call with the documented description sources.
+//
+// The transform replaces the call with `_createLlmEvaluation(plan)`, whose
+// plan carries every question's text. A property or enum member `@description`
+// tag overrides its summary, as it does in typia's JSON schemas, and repository
+// formatting rewrites that tag in TypeScript sources, so this fixture pins it
+// here. The same source must also emit byte-identical output on every run,
+// because the plan feeds build caches and published bundles.
+//
+//  1. Transform a decision type with `@description` overrides on a property and
+//     an enum member, a threshold, and a member minimum.
+//  2. Transform the same project again.
+//  3. Assert the runtime helper call, the overridden texts, the requirements,
+//     and identical output across runs.
+func TestLlmEvaluationPlanEmissionTransform(t *testing.T) {
+  project := llmEvaluationProject(t, "emission", llmEvaluationEmissionSource)
+  transform := func() string {
+    out, errText, code := ttscTypiaTestCapture(func() int {
+      return runTransform([]string{
+        "--cwd", project,
+        "--tsconfig", "tsconfig.json",
+        "--file", "src/main.ts",
+        "--output", "js",
+      })
+    })
+    if code != 0 {
+      t.Fatalf("llm.evaluation transform failed: code=%d stderr=\n%s", code, errText)
+    }
+    return out
+  }
+  first := transform()
+  for _, expected := range []string{
+    "_createLlmEvaluation",
+    `instructions: "Overridden question"`,
+    `description: "Overridden member"`,
+    `description: "Plain member"`,
+    "threshold: 0.8",
+    "minimum: 0.75",
+  } {
+    if !strings.Contains(first, expected) {
+      t.Fatalf("llm.evaluation emission missing %q:\n%s", expected, first)
+    }
+  }
+  for _, unexpected := range []string{`instructions: "Summary`, `description: "Summary`, "typia.llm.evaluation"} {
+    if strings.Contains(first, unexpected) {
+      t.Fatalf("llm.evaluation emission must not contain %q:\n%s", unexpected, first)
+    }
+  }
+  if second := transform(); second != first {
+    t.Fatalf("llm.evaluation emission is not deterministic:\n--- first\n%s\n--- second\n%s", first, second)
+  }
+}
+
+const llmEvaluationEmissionSource = `import typia, { tags } from "typia";
+
+enum Team {
+  /**
+   * Plain member
+   *
+   * @probability 0.5
+   */
+  billing = "billing",
+  /**
+   * Summary to be overridden
+   *
+   * @description Overridden member
+   * @probability 0.75
+   */
+  technical = "technical",
+}
+
+export const evaluation = typia.llm.evaluation<{
+  /**
+   * Summary to be overridden
+   *
+   * @description Overridden question
+   */
+  team: Team;
+  /** Is a refund requested? */
+  refund: boolean & tags.Probability<0.8>;
+}>();
+`

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

@@ -0,0 +1,69 @@
+package main
+
+import (
+  "encoding/json"
+  "os"
+  "path/filepath"
+  "slices"
+  "strings"
+  "testing"
+)
+
+// TestLlmEvaluationProgramScanDependencies verifies a successful evaluation
+// transform watches source files used by its program-wide placement check.
+//
+// An unrelated source has no tag today but may gain an illegal declaration
+// tag tomorrow. A complete dependency list must then invalidate the old emit.
+//
+//  1. Transform a decision beside an unrelated, untagged source module.
+//  2. Require the decision's complete dependency list to include that module.
+//  3. Add an illegal tag in that module and require a new diagnostic.
+func TestLlmEvaluationProgramScanDependencies(t *testing.T) {
+  dir := llmEvaluationProject(t, "program-scan-dependencies", `import typia from "typia";
+interface IDecision {
+  /** Is it urgent? */
+  urgent: boolean;
+}
+typia.llm.evaluation<IDecision>();
+`)
+  unused := `export type Unused = boolean;
+`
+  if err := os.WriteFile(filepath.Join(dir, "src", "unused.ts"), []byte(unused), 0o644); err != nil {
+    t.Fatal(err)
+  }
+  output, diagnostics, code := ttscTypiaTestCapture(func() int {
+    return runTransform([]string{"--cwd", dir, "--tsconfig", "tsconfig.json"})
+  })
+  var result transformProjectOutput
+  if err := json.Unmarshal([]byte(output), &result); err != nil {
+    t.Fatal(err)
+  }
+  if code != 0 {
+    t.Fatalf("valid project must transform: code=%d\ndiagnostics=%+v\nstderr=%s", code, result.Diagnostics, diagnostics)
+  }
+  if !slices.Contains(result.DependenciesComplete, "src/main.ts") {
+    t.Fatalf("decision transform unexpectedly lacks complete dependencies: %+v", result.DependenciesComplete)
+  }
+  if !slices.Contains(result.Dependencies["src/main.ts"], "src/unused.ts") {
+    t.Fatalf("program-wide scan dependency is missing: %+v", result.Dependencies["src/main.ts"])
+  }
+  tagged := `/** @probability 0.8 */
+export type Unused = boolean;
+`
+  if err := os.WriteFile(filepath.Join(dir, "src", "unused.ts"), []byte(tagged), 0o644); err != nil {
+    t.Fatal(err)
+  }
+  output, diagnostics, code = ttscTypiaTestCapture(func() int {
+    return runTransform([]string{"--cwd", dir, "--tsconfig", "tsconfig.json"})
+  })
+  if code != 3 {
+    t.Fatalf("new invalid tag must fail: code=%d\nstderr=%s", code, diagnostics)
+  }
+  result = transformProjectOutput{}
+  if err := json.Unmarshal([]byte(output), &result); err != nil {
+    t.Fatal(err)
+  }
+  if len(result.Diagnostics) != 1 || !strings.Contains(result.Diagnostics[0].MessageText, "type alias Unused") {
+    t.Fatalf("changed source must affect evaluation diagnostic: %+v", result.Diagnostics)
+  }
+}

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

@@ -0,0 +1,44 @@
+package main
+
+import (
+  "strings"
+  "testing"
+)
+
+// TestLlmEvaluationRejectsDeclarationProbability verifies JSDoc on a type
+// declaration cannot silently become a decision requirement.
+//
+// A primitive alias resolves to the same primitive as an unannotated alias,
+// so the compiler must reject unsupported declaration-level placements.
+//
+//  1. Annotate several declaration kinds, including unused declarations.
+//  2. Compile a neighboring evaluation call.
+//  3. Require a normal diagnostic for every invalid placement.
+func TestLlmEvaluationRejectsDeclarationProbability(t *testing.T) {
+  diagnostics := llmEvaluationDiagnosticsBuild(t, "declaration-probability", `import typia from "typia";
+
+/** @probability 0.8 */
+type Urgency = boolean;
+/** @probability invalid */
+type Unused = boolean;
+/** @probability 0.6 */
+interface Nested { /** Answer? */ answer: boolean }
+/** @probability 0.7 */
+enum Choice { yes = "yes", no = "no" }
+/** @probability 0.4 */
+class Container { /** Answer? */ answer = true; }
+/** @probability 0.3 */
+function unrelated(): boolean { return true; }
+
+typia.llm.evaluation<{
+  /** Urgent? */ urgent: Urgency;
+  /** Nested? */ nested: Nested;
+  /** Choice? */ choice: Choice;
+}>();
+`)
+  for _, name := range []string{"type alias Urgency", "type alias Unused", "interface Nested", "enum Choice", "class Container", "declaration unrelated"} {
+    if !strings.Contains(diagnostics, name) {
+      t.Fatalf("misplaced declaration tag %q was not diagnosed:\n%s", name, diagnostics)
+    }
+  }
+}

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

@@ -0,0 +1,45 @@
+package main
+
+import (
+  "strings"
+  "testing"
+)
+
+// TestLlmEvaluationRejectsAliasRefinement verifies a named alias cannot hide
+// a validation tag from the evaluation compiler.
+//
+// An alias of a boolean refinement still denotes a constrained boolean. The
+// decoder does not enforce that constraint, while an annotation-only alias is
+// safe and must remain accepted.
+//
+//  1. Declare a validation refinement behind a named alias.
+//  2. Require a decision-path diagnostic.
+//  3. Accept a neighboring annotation-only alias.
+func TestLlmEvaluationRejectsAliasRefinement(t *testing.T) {
+  errText := llmEvaluationDiagnosticsBuild(t, "alias-refinement", `import typia, { tags } from "typia";
+
+type TrueOnly = tags.TagBase<{
+  target: "boolean";
+  kind: "trueOnly";
+  value: undefined;
+  validate: "$input === true";
+}>;
+type Guarded = boolean & TrueOnly;
+typia.llm.evaluation<{
+  /** Is it allowed? */
+  allowed: Guarded;
+}>();
+`)
+  expected := "- $input.allowed\n  - LLM evaluation does not support type tag \"trueOnly\", because decode() cannot enforce its constraint."
+  if !strings.Contains(errText, expected) {
+    t.Fatalf("missing aliased refinement diagnostic:\n%s", errText)
+  }
+  llmEvaluationAccepts(t, "alias-refinement-control", `import typia, { tags } from "typia";
+
+type Annotated = boolean & tags.Default<true>;
+typia.llm.evaluation<{
+  /** Is it allowed? */
+  allowed: Annotated;
+}>();
+`)
+}

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

@@ -0,0 +1,30 @@
+package main
+
+import (
+  "strings"
+  "testing"
+)
+
+// TestLlmEvaluationRejectsComputedMethodProbability verifies an unsupported
+// computed method annotation produces a diagnostic instead of a panic.
+//
+// A computed property name is not a text-bearing identifier in the parser.
+// Reading its name as plain text used to crash the compiler's diagnostic path.
+//
+//  1. Annotate a computed class method with @probability.
+//  2. Build an otherwise valid evaluation call.
+//  3. Require a normal transform diagnostic.
+func TestLlmEvaluationRejectsComputedMethodProbability(t *testing.T) {
+  diagnostics := llmEvaluationDiagnosticsBuild(t, "computed-method-probability", `import typia from "typia";
+class Source {
+  /** @probability 0.8 */ [Symbol.iterator]() { return []; }
+}
+typia.llm.evaluation<{
+  /** Is it urgent? */
+  urgent: boolean;
+}>();
+`)
+  if !strings.Contains(diagnostics, "@probability") {
+    t.Fatalf("computed method tag must produce a diagnostic:\n%s", diagnostics)
+  }
+}

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

@@ -0,0 +1,48 @@
+package main
+
+import (
+  "os"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestLlmEvaluationRejectsImportedDeclarationProbability verifies the
+// placement diagnostic crosses an imported source-file boundary.
+//
+// A local-only syntax scan would miss an alias declared in another file while
+// the checker still resolves that alias at the evaluation decision.
+//
+//  1. Define an annotated primitive alias in an imported module.
+//  2. Use it in evaluation calls in two source files.
+//  3. Require the imported declaration's diagnostic from both CLI paths.
+func TestLlmEvaluationRejectsImportedDeclarationProbability(t *testing.T) {
+  dir := llmEvaluationProject(t, "imported-declaration-probability", `import typia from "typia";
+import type { Urgency } from "./urgency";
+typia.llm.evaluation<{ /** Urgent? */ urgent: Urgency }>();
+`)
+  source := `/** @probability 0.8 */
+export type Urgency = boolean;
+`
+  if err := os.WriteFile(filepath.Join(dir, "src", "urgency.ts"), []byte(source), 0o644); err != nil {
+    t.Fatal(err)
+  }
+  second := `import typia from "typia";
+typia.llm.evaluation<{ /** Is it urgent? */ urgent: boolean }>();
+`
+  if err := os.WriteFile(filepath.Join(dir, "src", "second.ts"), []byte(second), 0o644); err != nil {
+    t.Fatal(err)
+  }
+  _, diagnostics, code := ttscTypiaTestCapture(func() int {
+    return runBuild([]string{"--cwd", dir, "--tsconfig", "tsconfig.json", "--emit", "--outDir", filepath.Join(dir, "dist")})
+  })
+  if code != 3 || strings.Count(diagnostics, "type alias Urgency") != 2 {
+    t.Fatalf("imported declaration tag must fail in both files: code=%d\n%s", code, diagnostics)
+  }
+  output, errText, code := ttscTypiaTestCapture(func() int {
+    return runTransform([]string{"--cwd", dir, "--tsconfig", "tsconfig.json"})
+  })
+  if code != 3 || strings.Count(output, "type alias Urgency") != 2 {
+    t.Fatalf("transform path must diagnose both files: code=%d\nstdout=%s\nstderr=%s", code, output, errText)
+  }
+}