typia 13.3.0 → 14.0.0

package/lib/internal/_randomPattern.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports._randomPattern = void 0;
 const randexp_1 = __importDefault(require("randexp"));
+const _stringLength_1 = require("./_stringLength");
 const _randomPattern = (regex, props) => {
     const r = new randexp_1.default(regex);
     const min = props === null || props === void 0 ? void 0 : props.minLength;
@@ -16,13 +17,29 @@ const _randomPattern = (regex, props) => {
         r.max = max;
     else if (min !== undefined && min * 2 > r.max)
         r.max = min * 2;
+    // The verification counts characters, not UTF-16 code units, because that is
+    // what `MinLength` and `MaxLength` compare against. `Pattern` compiles to a
+    // flagless `RegExp`, so a quantifier binds one code unit wherever its atom is
+    // a bare astral character: under `^😀+$` the `+` repeats the trailing low
+    // surrogate alone, and RandExp draws `\ud83d` + k * `\ude00` -- k characters
+    // in k + 1 code units. Measuring in code units accepted a two-character draw
+    // for `MinLength<3>` and handed back a value the generated validator rejects.
+    // Group the atom (`^(?:😀)+$`) and the arithmetic changes to 2k units for k
+    // characters; the two counts still differ, which is the point.
+    //
+    // The count is taken only after the pattern matches, and only when a bound
+    // exists, so an unbounded draw still walks nothing.
     const bounded = min !== undefined || max !== undefined;
     const limit = bounded ? 1024 : 10;
     for (let i = 0; i < limit; ++i) {
         const str = r.gen();
-        if (regex.test(str) &&
-            (min === undefined || str.length >= min) &&
-            (max === undefined || str.length <= max))
+        if (regex.test(str) === false)
+            continue;
+        if (bounded === false)
+            return str;
+        const length = (0, _stringLength_1._stringLength)(str);
+        if ((min === undefined || length >= min) &&
+            (max === undefined || length <= max))
             return str;
     }
     throw new Error(bounded

package/lib/internal/_randomPattern.js.map

@@ -1 +1 @@
-{"version":3,"file":"_randomPattern.js","sourceRoot":"","sources":["../../src/internal/_randomPattern.ts"],"names":[],"mappings":";;;;;;AAAA,sDAA8B;AAIvB,MAAM,cAAc,GAAG,CAC5B,KAAa,EACb,KAAqB,EACb,EAAE;IACV,MAAM,CAAC,GAAY,IAAI,iBAAO,CAAC,KAAK,CAAC,CAAC;IACtC,MAAM,GAAG,GAAuB,KAAK,aAAL,KAAK,uBAAL,KAAK,CAAE,SAAS,CAAC;IACjD,MAAM,GAAG,GAAuB,KAAK,aAAL,KAAK,uBAAL,KAAK,CAAE,SAAS,CAAC;IAEjD,6EAA6E;IAC7E,8EAA8E;IAC9E,6EAA6E;IAC7E,IAAI,GAAG,KAAK,SAAS;QAAE,CAAC,CAAC,GAAG,GAAG,GAAG,CAAC;SAC9B,IAAI,GAAG,KAAK,SAAS,IAAI,GAAG,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG;QAAE,CAAC,CAAC,GAAG,GAAG,GAAG,GAAG,CAAC,CAAC;IAE/D,MAAM,OAAO,GAAY,GAAG,KAAK,SAAS,IAAI,GAAG,KAAK,SAAS,CAAC;IAChE,MAAM,KAAK,GAAW,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC;IAC1C,KAAK,IAAI,CAAC,GAAW,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,EAAE,CAAC,EAAE,CAAC;QACvC,MAAM,GAAG,GAAW,CAAC,CAAC,GAAG,EAAE,CAAC;QAC5B,IACE,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC;YACf,CAAC,GAAG,KAAK,SAAS,IAAI,GAAG,CAAC,MAAM,IAAI,GAAG,CAAC;YACxC,CAAC,GAAG,KAAK,SAAS,IAAI,GAAG,CAAC,MAAM,IAAI,GAAG,CAAC;YAExC,OAAO,GAAG,CAAC;IACf,CAAC;IACD,MAAM,IAAI,KAAK,CACb,OAAO;QACL,CAAC,CAAC,kFAAkF;QACpF,CAAC,CAAC,0DAA0D,CAC/D,CAAC;AACJ,CAAC,CAAC;AA9BW,QAAA,cAAc,GAAd,cAAc,CA8BzB"}
+{"version":3,"file":"_randomPattern.js","sourceRoot":"","sources":["../../src/internal/_randomPattern.ts"],"names":[],"mappings":";;;;;;AAAA,sDAA8B;AAG9B,mDAAgD;AAEzC,MAAM,cAAc,GAAG,CAC5B,KAAa,EACb,KAAqB,EACb,EAAE;IACV,MAAM,CAAC,GAAY,IAAI,iBAAO,CAAC,KAAK,CAAC,CAAC;IACtC,MAAM,GAAG,GAAuB,KAAK,aAAL,KAAK,uBAAL,KAAK,CAAE,SAAS,CAAC;IACjD,MAAM,GAAG,GAAuB,KAAK,aAAL,KAAK,uBAAL,KAAK,CAAE,SAAS,CAAC;IAEjD,6EAA6E;IAC7E,8EAA8E;IAC9E,6EAA6E;IAC7E,IAAI,GAAG,KAAK,SAAS;QAAE,CAAC,CAAC,GAAG,GAAG,GAAG,CAAC;SAC9B,IAAI,GAAG,KAAK,SAAS,IAAI,GAAG,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG;QAAE,CAAC,CAAC,GAAG,GAAG,GAAG,GAAG,CAAC,CAAC;IAE/D,6EAA6E;IAC7E,4EAA4E;IAC5E,8EAA8E;IAC9E,0EAA0E;IAC1E,6EAA6E;IAC7E,6EAA6E;IAC7E,8EAA8E;IAC9E,4EAA4E;IAC5E,+DAA+D;IAC/D,EAAE;IACF,2EAA2E;IAC3E,oDAAoD;IACpD,MAAM,OAAO,GAAY,GAAG,KAAK,SAAS,IAAI,GAAG,KAAK,SAAS,CAAC;IAChE,MAAM,KAAK,GAAW,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC;IAC1C,KAAK,IAAI,CAAC,GAAW,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,EAAE,CAAC,EAAE,CAAC;QACvC,MAAM,GAAG,GAAW,CAAC,CAAC,GAAG,EAAE,CAAC;QAC5B,IAAI,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,KAAK;YAAE,SAAS;QACxC,IAAI,OAAO,KAAK,KAAK;YAAE,OAAO,GAAG,CAAC;QAClC,MAAM,MAAM,GAAW,IAAA,6BAAa,EAAC,GAAG,CAAC,CAAC;QAC1C,IACE,CAAC,GAAG,KAAK,SAAS,IAAI,MAAM,IAAI,GAAG,CAAC;YACpC,CAAC,GAAG,KAAK,SAAS,IAAI,MAAM,IAAI,GAAG,CAAC;YAEpC,OAAO,GAAG,CAAC;IACf,CAAC;IACD,MAAM,IAAI,KAAK,CACb,OAAO;QACL,CAAC,CAAC,kFAAkF;QACpF,CAAC,CAAC,0DAA0D,CAC/D,CAAC;AACJ,CAAC,CAAC;AA5CW,QAAA,cAAc,GAAd,cAAc,CA4CzB"}

package/lib/internal/_randomPattern.mjs

@@ -1,3 +1,4 @@
+import { _stringLength } from "./_stringLength.mjs";
 import RandExp from "randexp";
 //#region src/internal/_randomPattern.ts
 const _randomPattern = (regex, props) => {
@@ -10,7 +11,10 @@ const _randomPattern = (regex, props) => {
 	const limit = bounded ? 1024 : 10;
 	for (let i = 0; i < limit; ++i) {
 		const str = r.gen();
-		if (regex.test(str) && (min === void 0 || str.length >= min) && (max === void 0 || str.length <= max)) return str;
+		if (regex.test(str) === false) continue;
+		if (bounded === false) return str;
+		const length = _stringLength(str);
+		if ((min === void 0 || length >= min) && (max === void 0 || length <= max)) return str;
 	}
 	throw new Error(bounded ? "unable to generate a random string matching the pattern within the length range." : "unable to generate a random string matching the pattern.");
 };

package/lib/internal/_randomPattern.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"_randomPattern.mjs","names":[],"sources":["../../src/internal/_randomPattern.ts"],"sourcesContent":["import RandExp from \"randexp\";\n\nimport { _ILengthProps } from \"./_randomStringLength\";\n\nexport const _randomPattern = (\n  regex: RegExp,\n  props?: _ILengthProps,\n): string => {\n  const r: RandExp = new RandExp(regex);\n  const min: number | undefined = props?.minLength;\n  const max: number | undefined = props?.maxLength;\n\n  // RandExp expands an unbounded quantifier to `randInt(token.min, token.min +\n  // r.max)`, so steering `r.max` biases the generated length toward the window.\n  // There is no matching floor control, so the length is still verified below.\n  if (max !== undefined) r.max = max;\n  else if (min !== undefined && min * 2 > r.max) r.max = min * 2;\n\n  const bounded: boolean = min !== undefined || max !== undefined;\n  const limit: number = bounded ? 1024 : 10;\n  for (let i: number = 0; i < limit; ++i) {\n    const str: string = r.gen();\n    if (\n      regex.test(str) &&\n      (min === undefined || str.length >= min) &&\n      (max === undefined || str.length <= max)\n    )\n      return str;\n  }\n  throw new Error(\n    bounded\n      ? \"unable to generate a random string matching the pattern within the length range.\"\n      : \"unable to generate a random string matching the pattern.\",\n  );\n};\n"],"mappings":";;AAIA,MAAa,kBACX,OACA,UACW;CACX,MAAM,IAAa,IAAI,QAAQ,KAAK;CACpC,MAAM,MAA0B,OAAO;CACvC,MAAM,MAA0B,OAAO;CAKvC,IAAI,QAAQ,KAAA,GAAW,EAAE,MAAM;MAC1B,IAAI,QAAQ,KAAA,KAAa,MAAM,IAAI,EAAE,KAAK,EAAE,MAAM,MAAM;CAE7D,MAAM,UAAmB,QAAQ,KAAA,KAAa,QAAQ,KAAA;CACtD,MAAM,QAAgB,UAAU,OAAO;CACvC,KAAK,IAAI,IAAY,GAAG,IAAI,OAAO,EAAE,GAAG;EACtC,MAAM,MAAc,EAAE,IAAI;EAC1B,IACE,MAAM,KAAK,GAAG,MACb,QAAQ,KAAA,KAAa,IAAI,UAAU,SACnC,QAAQ,KAAA,KAAa,IAAI,UAAU,MAEpC,OAAO;CACX;CACA,MAAM,IAAI,MACR,UACI,qFACA,0DACN;AACF"}
+{"version":3,"file":"_randomPattern.mjs","names":[],"sources":["../../src/internal/_randomPattern.ts"],"sourcesContent":["import RandExp from \"randexp\";\n\nimport { _ILengthProps } from \"./_randomStringLength\";\nimport { _stringLength } from \"./_stringLength\";\n\nexport const _randomPattern = (\n  regex: RegExp,\n  props?: _ILengthProps,\n): string => {\n  const r: RandExp = new RandExp(regex);\n  const min: number | undefined = props?.minLength;\n  const max: number | undefined = props?.maxLength;\n\n  // RandExp expands an unbounded quantifier to `randInt(token.min, token.min +\n  // r.max)`, so steering `r.max` biases the generated length toward the window.\n  // There is no matching floor control, so the length is still verified below.\n  if (max !== undefined) r.max = max;\n  else if (min !== undefined && min * 2 > r.max) r.max = min * 2;\n\n  // The verification counts characters, not UTF-16 code units, because that is\n  // what `MinLength` and `MaxLength` compare against. `Pattern` compiles to a\n  // flagless `RegExp`, so a quantifier binds one code unit wherever its atom is\n  // a bare astral character: under `^😀+$` the `+` repeats the trailing low\n  // surrogate alone, and RandExp draws `\\ud83d` + k * `\\ude00` -- k characters\n  // in k + 1 code units. Measuring in code units accepted a two-character draw\n  // for `MinLength<3>` and handed back a value the generated validator rejects.\n  // Group the atom (`^(?:😀)+$`) and the arithmetic changes to 2k units for k\n  // characters; the two counts still differ, which is the point.\n  //\n  // The count is taken only after the pattern matches, and only when a bound\n  // exists, so an unbounded draw still walks nothing.\n  const bounded: boolean = min !== undefined || max !== undefined;\n  const limit: number = bounded ? 1024 : 10;\n  for (let i: number = 0; i < limit; ++i) {\n    const str: string = r.gen();\n    if (regex.test(str) === false) continue;\n    if (bounded === false) return str;\n    const length: number = _stringLength(str);\n    if (\n      (min === undefined || length >= min) &&\n      (max === undefined || length <= max)\n    )\n      return str;\n  }\n  throw new Error(\n    bounded\n      ? \"unable to generate a random string matching the pattern within the length range.\"\n      : \"unable to generate a random string matching the pattern.\",\n  );\n};\n"],"mappings":";;;AAKA,MAAa,kBACX,OACA,UACW;CACX,MAAM,IAAa,IAAI,QAAQ,KAAK;CACpC,MAAM,MAA0B,OAAO;CACvC,MAAM,MAA0B,OAAO;CAKvC,IAAI,QAAQ,KAAA,GAAW,EAAE,MAAM;MAC1B,IAAI,QAAQ,KAAA,KAAa,MAAM,IAAI,EAAE,KAAK,EAAE,MAAM,MAAM;CAc7D,MAAM,UAAmB,QAAQ,KAAA,KAAa,QAAQ,KAAA;CACtD,MAAM,QAAgB,UAAU,OAAO;CACvC,KAAK,IAAI,IAAY,GAAG,IAAI,OAAO,EAAE,GAAG;EACtC,MAAM,MAAc,EAAE,IAAI;EAC1B,IAAI,MAAM,KAAK,GAAG,MAAM,OAAO;EAC/B,IAAI,YAAY,OAAO,OAAO;EAC9B,MAAM,SAAiB,cAAc,GAAG;EACxC,KACG,QAAQ,KAAA,KAAa,UAAU,SAC/B,QAAQ,KAAA,KAAa,UAAU,MAEhC,OAAO;CACX;CACA,MAAM,IAAI,MACR,UACI,qFACA,0DACN;AACF"}

package/lib/internal/_randomStringLength.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports._randomFormatLength = exports._randomLengthPick = exports._randomLengthWindow = exports._randomSegmentLength = exports._RANDOM_LENGTH_ERROR = void 0;
 const _randomInteger_1 = require("./_randomInteger");
 const _randomString_1 = require("./_randomString");
+const _stringLength_1 = require("./_stringLength");
 exports._RANDOM_LENGTH_ERROR = "unable to generate a random string satisfying both the format and the length constraints.";
 /**
  * Builds the variable segment of a fixed-shape format string so that the total
@@ -74,8 +75,14 @@ const _randomFormatLength = (props, generate) => {
         return generate();
     for (let i = 0; i < 256; ++i) {
         const value = generate();
-        if ((props.minLength === undefined || value.length >= props.minLength) &&
-            (props.maxLength === undefined || value.length <= props.maxLength))
+        // Characters, not UTF-16 code units: `minLength` and `maxLength` are the
+        // bounds the generated validator compares in characters. `uuid` and `date`,
+        // the only two shapes routed through here, are ASCII, so the two counts
+        // agree for them today -- this keeps one measure so a later non-ASCII
+        // format cannot reintroduce the divergence unnoticed.
+        const length = (0, _stringLength_1._stringLength)(value);
+        if ((props.minLength === undefined || length >= props.minLength) &&
+            (props.maxLength === undefined || length <= props.maxLength))
             return value;
     }
     throw new Error(exports._RANDOM_LENGTH_ERROR);

package/lib/internal/_randomStringLength.js.map

@@ -1 +1 @@
-{"version":3,"file":"_randomStringLength.js","sourceRoot":"","sources":["../../src/internal/_randomStringLength.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"_randomStringLength.js","sourceRoot":"","sources":["../../src/internal/_randomStringLength.ts"],"names":[],"mappings":"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"}

package/lib/internal/_randomStringLength.mjs

@@ -1,5 +1,6 @@
 import { _randomInteger } from "./_randomInteger.mjs";
 import { _randomString } from "./_randomString.mjs";
+import { _stringLength } from "./_stringLength.mjs";
 //#region src/internal/_randomStringLength.ts
 const _RANDOM_LENGTH_ERROR = "unable to generate a random string satisfying both the format and the length constraints.";
 /**
@@ -69,7 +70,8 @@ const _randomFormatLength = (props, generate) => {
 	if (props?.minLength === void 0 && props?.maxLength === void 0) return generate();
 	for (let i = 0; i < 256; ++i) {
 		const value = generate();
-		if ((props.minLength === void 0 || value.length >= props.minLength) && (props.maxLength === void 0 || value.length <= props.maxLength)) return value;
+		const length = _stringLength(value);
+		if ((props.minLength === void 0 || length >= props.minLength) && (props.maxLength === void 0 || length <= props.maxLength)) return value;
 	}
 	throw new Error(_RANDOM_LENGTH_ERROR);
 };

package/lib/internal/_randomStringLength.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"_randomStringLength.mjs","names":[],"sources":["../../src/internal/_randomStringLength.ts"],"sourcesContent":["import { _randomInteger } from \"./_randomInteger\";\nimport { _randomString } from \"./_randomString\";\n\nexport const _RANDOM_LENGTH_ERROR =\n  \"unable to generate a random string satisfying both the format and the length constraints.\";\n\n/**\n * Length bounds forwarded to a string format or pattern generator.\n *\n * `typia.random<T>()` passes this object to the `_randomFormat*` and\n * `_randomPattern` helpers whenever the string leaf also carries a `MinLength`\n * or `MaxLength` tag, so a constrained format or pattern is generated at a\n * length its own validator accepts (issue #2189).\n */\nexport interface _ILengthProps {\n  minLength?: number;\n  maxLength?: number;\n}\n\n/**\n * Builds the variable segment of a fixed-shape format string so that the total\n * length `fixed + segment.length` lands inside the requested window.\n *\n * `fixed` is the number of characters the format always contributes around the\n * segment, `fallback` is the segment length used when the leaf is unconstrained\n * on that side, and `minimum` is the smallest segment the format still\n * validates with. Throws when the window cannot be satisfied by this format's\n * shape (e.g. `Format<\"email\"> & MaxLength<3>`).\n */\nexport const _randomSegmentLength = (\n  props: _ILengthProps | undefined,\n  fixed: number,\n  fallback: number,\n  minimum: number,\n): string => {\n  let low: number =\n    props?.minLength === undefined ? minimum : props.minLength - fixed;\n  if (low < minimum) low = minimum;\n  // With only a lower bound, spread the segment across `fallback` extra\n  // characters so the generated length varies, mirroring `_randomString`.\n  const high: number =\n    props?.maxLength === undefined ? low + fallback : props.maxLength - fixed;\n  if (high < low || high < minimum) throw new Error(_RANDOM_LENGTH_ERROR);\n  return _randomString({ type: \"string\", minLength: low, maxLength: high });\n};\n\n/**\n * Intersects the requested length window with the lengths a format's grammar\n * can express, and draws one of them.\n *\n * `minimum` and `maximum` are the shortest and longest values the format admits\n * — omit `maximum` when the grammar is open above — and `spread` is how far\n * past the floor an unbounded request may reach, so an open side still varies\n * the way `_randomString` does. The caller draws from the returned window and\n * applies whatever step its grammar has (base64 lengths are multiples of four,\n * a fractional second needs at least one digit).\n *\n * Throws only when the window and the grammar do not overlap at all. That is\n * the distinction the retry driver below cannot make: it redraws one shape, so\n * it gives up on every length that shape never emits even when the format\n * itself accepts one (issue #2284).\n */\nexport const _randomLengthWindow = (\n  props: _ILengthProps | undefined,\n  format: { minimum: number; maximum?: number; spread?: number },\n): { low: number; high: number } => {\n  const ceiling: number = format.maximum ?? Number.MAX_SAFE_INTEGER;\n  const low: number = Math.max(\n    props?.minLength ?? format.minimum,\n    format.minimum,\n  );\n  const high: number = Math.min(\n    props?.maxLength ?? low + (format.spread ?? 0),\n    ceiling,\n  );\n  if (low > high) throw new Error(_RANDOM_LENGTH_ERROR);\n  return { low, high };\n};\n\n/** Draws a length inside a window produced by {@link _randomLengthWindow}. */\nexport const _randomLengthPick = (window: {\n  low: number;\n  high: number;\n}): number =>\n  _randomInteger({\n    type: \"integer\",\n    minimum: window.low,\n    maximum: window.high,\n  });\n\n/**\n * Wraps a fixed-length format generator (uuid, date) with the requested length\n * window.\n *\n * Use it only where the grammar admits exactly one length, so a window that\n * excludes it is genuinely unsatisfiable. A format that can express more than\n * one length must build its value at a length drawn from\n * {@link _randomLengthWindow} instead; redrawing one shape cannot reach a length\n * that shape never emits.\n */\nexport const _randomFormatLength = (\n  props: _ILengthProps | undefined,\n  generate: () => string,\n): string => {\n  if (props?.minLength === undefined && props?.maxLength === undefined)\n    return generate();\n  for (let i: number = 0; i < 256; ++i) {\n    const value: string = generate();\n    if (\n      (props.minLength === undefined || value.length >= props.minLength) &&\n      (props.maxLength === undefined || value.length <= props.maxLength)\n    )\n      return value;\n  }\n  throw new Error(_RANDOM_LENGTH_ERROR);\n};\n"],"mappings":";;;AAGA,MAAa,uBACX;;;;;;;;;;;AAyBF,MAAa,wBACX,OACA,OACA,UACA,YACW;CACX,IAAI,MACF,OAAO,cAAc,KAAA,IAAY,UAAU,MAAM,YAAY;CAC/D,IAAI,MAAM,SAAS,MAAM;CAGzB,MAAM,OACJ,OAAO,cAAc,KAAA,IAAY,MAAM,WAAW,MAAM,YAAY;CACtE,IAAI,OAAO,OAAO,OAAO,SAAS,MAAM,IAAI,MAAM,oBAAoB;CACtE,OAAO,cAAc;EAAE,MAAM;EAAU,WAAW;EAAK,WAAW;CAAK,CAAC;AAC1E;;;;;;;;;;;;;;;;;AAkBA,MAAa,uBACX,OACA,WACkC;CAClC,MAAM,UAAkB,OAAO,WAAW,OAAO;CACjD,MAAM,MAAc,KAAK,IACvB,OAAO,aAAa,OAAO,SAC3B,OAAO,OACT;CACA,MAAM,OAAe,KAAK,IACxB,OAAO,aAAa,OAAO,OAAO,UAAU,IAC5C,OACF;CACA,IAAI,MAAM,MAAM,MAAM,IAAI,MAAM,oBAAoB;CACpD,OAAO;EAAE;EAAK;CAAK;AACrB;;AAGA,MAAa,qBAAqB,WAIhC,eAAe;CACb,MAAM;CACN,SAAS,OAAO;CAChB,SAAS,OAAO;AAClB,CAAC;;;;;;;;;;;AAYH,MAAa,uBACX,OACA,aACW;CACX,IAAI,OAAO,cAAc,KAAA,KAAa,OAAO,cAAc,KAAA,GACzD,OAAO,SAAS;CAClB,KAAK,IAAI,IAAY,GAAG,IAAI,KAAK,EAAE,GAAG;EACpC,MAAM,QAAgB,SAAS;EAC/B,KACG,MAAM,cAAc,KAAA,KAAa,MAAM,UAAU,MAAM,eACvD,MAAM,cAAc,KAAA,KAAa,MAAM,UAAU,MAAM,YAExD,OAAO;CACX;CACA,MAAM,IAAI,MAAM,oBAAoB;AACtC"}
+{"version":3,"file":"_randomStringLength.mjs","names":[],"sources":["../../src/internal/_randomStringLength.ts"],"sourcesContent":["import { _randomInteger } from \"./_randomInteger\";\nimport { _randomString } from \"./_randomString\";\nimport { _stringLength } from \"./_stringLength\";\n\nexport const _RANDOM_LENGTH_ERROR =\n  \"unable to generate a random string satisfying both the format and the length constraints.\";\n\n/**\n * Length bounds forwarded to a string format or pattern generator.\n *\n * `typia.random<T>()` passes this object to the `_randomFormat*` and\n * `_randomPattern` helpers whenever the string leaf also carries a `MinLength`\n * or `MaxLength` tag, so a constrained format or pattern is generated at a\n * length its own validator accepts (issue #2189).\n */\nexport interface _ILengthProps {\n  minLength?: number;\n  maxLength?: number;\n}\n\n/**\n * Builds the variable segment of a fixed-shape format string so that the total\n * length `fixed + segment.length` lands inside the requested window.\n *\n * `fixed` is the number of characters the format always contributes around the\n * segment, `fallback` is the segment length used when the leaf is unconstrained\n * on that side, and `minimum` is the smallest segment the format still\n * validates with. Throws when the window cannot be satisfied by this format's\n * shape (e.g. `Format<\"email\"> & MaxLength<3>`).\n */\nexport const _randomSegmentLength = (\n  props: _ILengthProps | undefined,\n  fixed: number,\n  fallback: number,\n  minimum: number,\n): string => {\n  let low: number =\n    props?.minLength === undefined ? minimum : props.minLength - fixed;\n  if (low < minimum) low = minimum;\n  // With only a lower bound, spread the segment across `fallback` extra\n  // characters so the generated length varies, mirroring `_randomString`.\n  const high: number =\n    props?.maxLength === undefined ? low + fallback : props.maxLength - fixed;\n  if (high < low || high < minimum) throw new Error(_RANDOM_LENGTH_ERROR);\n  return _randomString({ type: \"string\", minLength: low, maxLength: high });\n};\n\n/**\n * Intersects the requested length window with the lengths a format's grammar\n * can express, and draws one of them.\n *\n * `minimum` and `maximum` are the shortest and longest values the format admits\n * — omit `maximum` when the grammar is open above — and `spread` is how far\n * past the floor an unbounded request may reach, so an open side still varies\n * the way `_randomString` does. The caller draws from the returned window and\n * applies whatever step its grammar has (base64 lengths are multiples of four,\n * a fractional second needs at least one digit).\n *\n * Throws only when the window and the grammar do not overlap at all. That is\n * the distinction the retry driver below cannot make: it redraws one shape, so\n * it gives up on every length that shape never emits even when the format\n * itself accepts one (issue #2284).\n */\nexport const _randomLengthWindow = (\n  props: _ILengthProps | undefined,\n  format: { minimum: number; maximum?: number; spread?: number },\n): { low: number; high: number } => {\n  const ceiling: number = format.maximum ?? Number.MAX_SAFE_INTEGER;\n  const low: number = Math.max(\n    props?.minLength ?? format.minimum,\n    format.minimum,\n  );\n  const high: number = Math.min(\n    props?.maxLength ?? low + (format.spread ?? 0),\n    ceiling,\n  );\n  if (low > high) throw new Error(_RANDOM_LENGTH_ERROR);\n  return { low, high };\n};\n\n/** Draws a length inside a window produced by {@link _randomLengthWindow}. */\nexport const _randomLengthPick = (window: {\n  low: number;\n  high: number;\n}): number =>\n  _randomInteger({\n    type: \"integer\",\n    minimum: window.low,\n    maximum: window.high,\n  });\n\n/**\n * Wraps a fixed-length format generator (uuid, date) with the requested length\n * window.\n *\n * Use it only where the grammar admits exactly one length, so a window that\n * excludes it is genuinely unsatisfiable. A format that can express more than\n * one length must build its value at a length drawn from\n * {@link _randomLengthWindow} instead; redrawing one shape cannot reach a length\n * that shape never emits.\n */\nexport const _randomFormatLength = (\n  props: _ILengthProps | undefined,\n  generate: () => string,\n): string => {\n  if (props?.minLength === undefined && props?.maxLength === undefined)\n    return generate();\n  for (let i: number = 0; i < 256; ++i) {\n    const value: string = generate();\n    // Characters, not UTF-16 code units: `minLength` and `maxLength` are the\n    // bounds the generated validator compares in characters. `uuid` and `date`,\n    // the only two shapes routed through here, are ASCII, so the two counts\n    // agree for them today -- this keeps one measure so a later non-ASCII\n    // format cannot reintroduce the divergence unnoticed.\n    const length: number = _stringLength(value);\n    if (\n      (props.minLength === undefined || length >= props.minLength) &&\n      (props.maxLength === undefined || length <= props.maxLength)\n    )\n      return value;\n  }\n  throw new Error(_RANDOM_LENGTH_ERROR);\n};\n"],"mappings":";;;;AAIA,MAAa,uBACX;;;;;;;;;;;AAyBF,MAAa,wBACX,OACA,OACA,UACA,YACW;CACX,IAAI,MACF,OAAO,cAAc,KAAA,IAAY,UAAU,MAAM,YAAY;CAC/D,IAAI,MAAM,SAAS,MAAM;CAGzB,MAAM,OACJ,OAAO,cAAc,KAAA,IAAY,MAAM,WAAW,MAAM,YAAY;CACtE,IAAI,OAAO,OAAO,OAAO,SAAS,MAAM,IAAI,MAAM,oBAAoB;CACtE,OAAO,cAAc;EAAE,MAAM;EAAU,WAAW;EAAK,WAAW;CAAK,CAAC;AAC1E;;;;;;;;;;;;;;;;;AAkBA,MAAa,uBACX,OACA,WACkC;CAClC,MAAM,UAAkB,OAAO,WAAW,OAAO;CACjD,MAAM,MAAc,KAAK,IACvB,OAAO,aAAa,OAAO,SAC3B,OAAO,OACT;CACA,MAAM,OAAe,KAAK,IACxB,OAAO,aAAa,OAAO,OAAO,UAAU,IAC5C,OACF;CACA,IAAI,MAAM,MAAM,MAAM,IAAI,MAAM,oBAAoB;CACpD,OAAO;EAAE;EAAK;CAAK;AACrB;;AAGA,MAAa,qBAAqB,WAIhC,eAAe;CACb,MAAM;CACN,SAAS,OAAO;CAChB,SAAS,OAAO;AAClB,CAAC;;;;;;;;;;;AAYH,MAAa,uBACX,OACA,aACW;CACX,IAAI,OAAO,cAAc,KAAA,KAAa,OAAO,cAAc,KAAA,GACzD,OAAO,SAAS;CAClB,KAAK,IAAI,IAAY,GAAG,IAAI,KAAK,EAAE,GAAG;EACpC,MAAM,QAAgB,SAAS;EAM/B,MAAM,SAAiB,cAAc,KAAK;EAC1C,KACG,MAAM,cAAc,KAAA,KAAa,UAAU,MAAM,eACjD,MAAM,cAAc,KAAA,KAAa,UAAU,MAAM,YAElD,OAAO;CACX;CACA,MAAM,IAAI,MAAM,oBAAoB;AACtC"}

package/lib/transform.mjs

@@ -1,5 +1,5 @@
-import path from "node:path";
 import { createRequire } from "node:module";
+import path from "node:path";
 //#region src/transform.ts
 function createTtscPlugin(context) {
 	const requireFrom = createRequire(path.join(context.projectRoot, "package.json"));

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

@@ -0,0 +1,206 @@
+package main
+
+import (
+  "os"
+  "os/exec"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestDynamicKeyTagsTransform verifies a type tag on a dynamic key is enforced.
+//
+// `Check_dynamic_key` has always held a complete implementation: it filters the
+// key's tag rows through `check_dynamic_key_fully_validated_tag_rows` and routes
+// a tagged string atomic into `Check_string`, a tagged numeric one into
+// `Check_number`. Nothing reached it, so `[key: string & tags.MinLength<3>]`
+// accepted a two-character key and every other key tag was equally inert
+// (#2347).
+//
+// Values were always checked, which is what made this invisible: the
+// `@typia/template` `DynamicTag` fixture declares exactly this shape and every
+// one of its spoilers corrupts a value, never a key.
+//
+//  1. Transform a fixture whose index signatures carry a pattern, a length, and
+//     a numeric range on the key.
+//  2. Require the emitted checker to contain a key predicate at all.
+//  3. Execute runtime cases: a key violating its tag must be rejected, a key
+//     satisfying it accepted, and neither a plain `[key: string]` signature nor
+//     a template literal one may become constrained.
+//
+// The two negative controls carry the boundary. What the fix makes binding is a
+// broken *tag* on a key the declaration covers; a key no signature's *type*
+// covers is declared nowhere, which is what a surplus property is, and stays
+// accepted. `test_validate_dynamic_key_surplus` pins that distinction against
+// both spellings of the same predicate.
+//
+// The report such a key produces is its own concern. `Superfluous`, the report
+// an extra property already used, says the property is not defined in the object
+// type and advises removing it -- false and unhelpful when the property is
+// declared and only its key broke a constraint. `InvalidKey` names the key type
+// instead, and `test_validate_dynamic_key_report` covers the wording.
+func TestDynamicKeyTagsTransform(t *testing.T) {
+  project := dynamicKeyTagsProject(t)
+  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("dynamic key tags transform failed: code=%d stderr=\n%s", code, errText)
+  }
+  // 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") {
+    t.Fatalf("emitted checker should test the dynamic key, not only its value:\n%s", out)
+  }
+  dynamicKeyTagsRunRuntimeCases(t, project, out)
+}
+
+func dynamicKeyTagsProject(t *testing.T) 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, "dynamic-key-tags-")
+  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(dynamicKeyTagsTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(dynamicKeyTagsSource), 0o644); err != nil {
+    t.Fatalf("write source: %v", err)
+  }
+  return dir
+}
+
+func dynamicKeyTagsRunRuntimeCases(t *testing.T, project string, js string) {
+  t.Helper()
+  node, err := exec.LookPath("node")
+  if err != nil {
+    t.Skip("node executable not found")
+  }
+  runtimeDir := filepath.Join(project, "runtime")
+  if err := os.MkdirAll(runtimeDir, 0o755); err != nil {
+    t.Fatalf("mkdir runtime dir: %v", err)
+  }
+  ttscTypiaTestWriteCommonRuntimeStubs(t, runtimeDir)
+  runtimeJS := ttscTypiaTestRewriteCommonJS(t, js)
+  if err := os.WriteFile(filepath.Join(runtimeDir, "main.cjs"), []byte(runtimeJS), 0o644); err != nil {
+    t.Fatalf("write runtime module: %v", err)
+  }
+  runner := filepath.Join(runtimeDir, "run.cjs")
+  if err := os.WriteFile(runner, []byte(dynamicKeyTagsRuntimeRunner), 0o644); err != nil {
+    t.Fatalf("write runtime runner: %v", err)
+  }
+  cmd := exec.Command(node, runner)
+  cmd.Dir = runtimeDir
+  output, err := cmd.CombinedOutput()
+  if err != nil {
+    t.Fatalf("dynamic key tags runtime cases failed: %v\n%s", err, output)
+  }
+}
+
+const dynamicKeyTagsTSConfig = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "moduleResolution": "bundler",
+    "ignoreDeprecations": "6.0",
+    "types": ["*"],
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}
+`
+
+const dynamicKeyTagsSource = `import typia, { tags } from "typia";
+
+interface IPatternKey {
+  [key: string & tags.Pattern<"^ab+$">]: string;
+}
+interface ILengthKey {
+  [key: string & tags.MinLength<3>]: string;
+}
+interface INumericKey {
+  [key: number & tags.Minimum<0> & tags.Maximum<9>]: string;
+}
+interface IPlainKey {
+  [key: string]: string;
+}
+interface ITemplateKey {
+  [key: ` + "`" + `prefix_${string}` + "`" + `]: string;
+}
+
+export const isPatternKey = typia.createIs<IPatternKey>();
+export const isLengthKey = typia.createIs<ILengthKey>();
+export const isNumericKey = typia.createIs<INumericKey>();
+export const isPlainKey = typia.createIs<IPlainKey>();
+export const isTemplateKey = typia.createIs<ITemplateKey>();
+`
+
+const dynamicKeyTagsRuntimeRunner = `const assert = require("assert");
+const main = require("./main.cjs");
+
+// A key that satisfies its tag is accepted; one that violates it is not. Both
+// directions matter: before the fix every one of these returned true.
+assert.strictEqual(main.isPatternKey({ abb: "x" }), true, "pattern key accepted");
+assert.strictEqual(main.isPatternKey({ zzz: "x" }), false, "non-pattern key rejected");
+
+assert.strictEqual(main.isLengthKey({ abc: "x" }), true, "long enough key accepted");
+assert.strictEqual(main.isLengthKey({ ab: "x" }), false, "too short key rejected");
+
+// The length is counted in characters, as MinLength means everywhere else: two
+// astral characters are four code units but two characters, so they are short.
+assert.strictEqual(
+  main.isLengthKey({ "\u{1f600}\u{1f600}\u{1f600}": "x" }),
+  true,
+  "three astral characters accepted",
+);
+assert.strictEqual(
+  main.isLengthKey({ "\u{1f600}\u{1f600}": "x" }),
+  false,
+  "two astral characters rejected",
+);
+
+assert.strictEqual(main.isNumericKey({ 5: "x" }), true, "in-range numeric key accepted");
+assert.strictEqual(main.isNumericKey({ 10: "x" }), false, "out-of-range numeric key rejected");
+assert.strictEqual(main.isNumericKey({ "-1": "x" }), false, "negative numeric key rejected");
+
+// NEGATIVE CONTROL: an untagged signature stays unconstrained, so the fix
+// constrains only what was declared.
+assert.strictEqual(main.isPlainKey({ "anything at all": "x" }), true, "plain key accepted");
+assert.strictEqual(main.isPlainKey({ "": "x" }), true, "empty plain key accepted");
+
+// NEGATIVE CONTROL: a template literal constrains the key's *type*, not a tag on
+// it, so a key outside it is declared nowhere -- a surplus property, which "is"
+// accepts as it accepts any surplus property. Rejecting this one alongside a
+// broken tag is what the first attempt at the fix did, and it made the
+// equals-mode surplus report unreachable for the DynamicTemplate, DynamicUnion,
+// and DynamicComposite shapes.
+assert.strictEqual(main.isTemplateKey({ prefix_a: "x" }), true, "matching template key accepted");
+assert.strictEqual(main.isTemplateKey({ prefix_a: 1 }), false, "matching template key with a wrong value rejected");
+assert.strictEqual(
+  main.isTemplateKey({ prefix_a: "x", wrong: "y" }),
+  true,
+  "a key outside the template is surplus, not a violation",
+);
+
+// The value is still checked, which it always was.
+assert.strictEqual(main.isLengthKey({ abc: 1 }), false, "wrong value type rejected");
+`

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

@@ -18,8 +18,8 @@ import (
 //  1. Transform a fixture covering camelCase, snake_case, leading-underscore,
 //     consecutive-uppercase (the acronym run collapses, so `XMLParser` becomes
 //     `xmlparser`), and nested property names. The matching compile-time
-//     `KebabCase<T>` assertions live in the test-typia-generate fixture, where
-//     ttsc enforces type diagnostics.
+//     `KebabCase<T>` assertions live in the test-interface fixture, where ttsc
+//     enforces type diagnostics.
 //  2. Require the emitted converter to reference the kebab-case keys.
 //  3. Execute kebab, isKebab, assertKebab, and validateKebab runtime cases
 //     over valid and invalid inputs.

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

@@ -4,16 +4,16 @@
 package main
 
 import (
-	"encoding/json"
-	"path/filepath"
-	"strings"
-	"testing"
+  "encoding/json"
+  "path/filepath"
+  "strings"
+  "testing"
 )
 
 // TestProjectCatalogTransformCoverage reuses broad TypeScript test projects.
 //
 // The focused ttsc fixtures are intentionally small, but the repository already
-// has schema and generation projects that exercise many more typia API shapes.
+// has feature projects that exercise many more typia API shapes.
 // Running them through the same project transform mode gives Go coverage for
 // those native branches without duplicating that TypeScript corpus here.
 //
@@ -31,89 +31,88 @@ import (
 // 3. Require JSON project output to include a TypeScript map.
 // 4. Hold each project to its own purpose's diagnostic contract.
 func TestProjectCatalogTransformCoverage(t *testing.T) {
-	root := transformCoverageRepoRoot(t)
-	for _, project := range []string{
-		"template",
-		"test-langchain",
-		"test-mcp",
-		"test-typia-automated",
-		"test-typia-generate",
-		"test-typia-schema",
-		"test-utils",
-		"test-utils-automated",
-		"test-vercel",
-	} {
-		project := project
-		t.Run(project, func(t *testing.T) {
-			out, errText, code := transformCatalogProject(root, project)
-			if code != 0 {
-				t.Fatalf("%s transform failed: code=%d stderr=\n%s", project, code, errText)
-			}
-			if !strings.Contains(out, `"typescript"`) {
-				t.Fatalf("%s project output should include TypeScript map:\n%s", project, out)
-			}
-		})
-	}
-	// tests/test-error compiles deliberately invalid call sites, and reporting them
-	// is that workspace's entire reason to exist. Its diagnostics are a contract,
-	// not an accident of what it currently holds.
-	t.Run("test-error", func(t *testing.T) {
-		out, _, code := transformCatalogProject(root, "test-error")
-		if code != 3 {
-			t.Fatalf("test-error transform should report diagnostics with code 3, got %d", code)
-		}
-		if !strings.Contains(out, `"diagnostics"`) || !strings.Contains(out, `"typescript"`) {
-			t.Fatalf("test-error output should include diagnostics and TypeScript map:\n%s", out)
-		}
-	})
-	// tests/debug is a one-off repro scratchpad, so nothing about its sources is
-	// promised: it holds valid code between investigations and invalid code during
-	// one. What survives both states is the project transform's own envelope
-	// contract, so that is what this pins. The project must resolve and reach a
-	// transform decision rather than fail to load (exit 2), it must still
-	// contribute transformed sources, and its exit code must agree with the
-	// envelope it published.
-	//
-	// Accepting either 0 or 3 is derived, not observed: transform mode never
-	// typechecks, so exit 2 is reachable only from a flag, cwd, or tsconfig-load
-	// failure (semantic diagnostics belong to the build route). No source content a
-	// repro leaves behind can produce it -- even an outright type error still exits
-	// 0 here -- which is what makes the band content-agnostic.
-	//
-	// The envelope is decoded rather than substring-matched because `"typescript"`
-	// carries no `omitempty` and runTransformProject initializes the map before its
-	// source loop: the key is present even when the workspace resolved no source at
-	// all. That empty envelope is the shape a `rootDir` or `include` rot leaves
-	// behind, and this workspace is the one that already shipped such a rot
-	// (samchon/typia#2132), so a key-presence check would pass over the one failure
-	// worth catching here.
-	t.Run("debug", func(t *testing.T) {
-		out, errText, code := transformCatalogProject(root, "debug")
-		if code != 0 && code != 3 {
-			t.Fatalf("debug transform should load and transform the project, got code=%d stderr=\n%s", code, errText)
-		}
-		var envelope transformProjectOutput
-		if err := json.Unmarshal([]byte(out), &envelope); err != nil {
-			t.Fatalf("debug project output should be a transform envelope: %v\n%s", err, out)
-		}
-		if len(envelope.TypeScript) == 0 {
-			t.Fatalf("debug project should contribute transformed sources, got an empty TypeScript map:\n%s", out)
-		}
-		if diagnosed := len(envelope.Diagnostics) > 0; diagnosed != (code == 3) {
-			t.Fatalf("debug exit code %d disagrees with its envelope (diagnostics present: %v):\n%s", code, diagnosed, out)
-		}
-	})
+  root := transformCoverageRepoRoot(t)
+  for _, project := range []string{
+    "template",
+    "test-langchain",
+    "test-mcp",
+    "test-typia-automated",
+    "test-typia-schema",
+    "test-utils",
+    "test-utils-automated",
+    "test-vercel",
+  } {
+    project := project
+    t.Run(project, func(t *testing.T) {
+      out, errText, code := transformCatalogProject(root, project)
+      if code != 0 {
+        t.Fatalf("%s transform failed: code=%d stderr=\n%s", project, code, errText)
+      }
+      if !strings.Contains(out, `"typescript"`) {
+        t.Fatalf("%s project output should include TypeScript map:\n%s", project, out)
+      }
+    })
+  }
+  // tests/test-error compiles deliberately invalid call sites, and reporting them
+  // is that workspace's entire reason to exist. Its diagnostics are a contract,
+  // not an accident of what it currently holds.
+  t.Run("test-error", func(t *testing.T) {
+    out, _, code := transformCatalogProject(root, "test-error")
+    if code != 3 {
+      t.Fatalf("test-error transform should report diagnostics with code 3, got %d", code)
+    }
+    if !strings.Contains(out, `"diagnostics"`) || !strings.Contains(out, `"typescript"`) {
+      t.Fatalf("test-error output should include diagnostics and TypeScript map:\n%s", out)
+    }
+  })
+  // tests/debug is a one-off repro scratchpad, so nothing about its sources is
+  // promised: it holds valid code between investigations and invalid code during
+  // one. What survives both states is the project transform's own envelope
+  // contract, so that is what this pins. The project must resolve and reach a
+  // transform decision rather than fail to load (exit 2), it must still
+  // contribute transformed sources, and its exit code must agree with the
+  // envelope it published.
+  //
+  // Accepting either 0 or 3 is derived, not observed: transform mode never
+  // typechecks, so exit 2 is reachable only from a flag, cwd, or tsconfig-load
+  // failure (semantic diagnostics belong to the build route). No source content a
+  // repro leaves behind can produce it -- even an outright type error still exits
+  // 0 here -- which is what makes the band content-agnostic.
+  //
+  // The envelope is decoded rather than substring-matched because `"typescript"`
+  // carries no `omitempty` and runTransformProject initializes the map before its
+  // source loop: the key is present even when the workspace resolved no source at
+  // all. That empty envelope is the shape a `rootDir` or `include` rot leaves
+  // behind, and this workspace is the one that already shipped such a rot
+  // (samchon/typia#2132), so a key-presence check would pass over the one failure
+  // worth catching here.
+  t.Run("debug", func(t *testing.T) {
+    out, errText, code := transformCatalogProject(root, "debug")
+    if code != 0 && code != 3 {
+      t.Fatalf("debug transform should load and transform the project, got code=%d stderr=\n%s", code, errText)
+    }
+    var envelope transformProjectOutput
+    if err := json.Unmarshal([]byte(out), &envelope); err != nil {
+      t.Fatalf("debug project output should be a transform envelope: %v\n%s", err, out)
+    }
+    if len(envelope.TypeScript) == 0 {
+      t.Fatalf("debug project should contribute transformed sources, got an empty TypeScript map:\n%s", out)
+    }
+    if diagnosed := len(envelope.Diagnostics) > 0; diagnosed != (code == 3) {
+      t.Fatalf("debug exit code %d disagrees with its envelope (diagnostics present: %v):\n%s", code, diagnosed, out)
+    }
+  })
 }
 
 // transformCatalogProject runs project transform mode over one repository test
 // project and returns its captured stdout, stderr, and exit code.
 func transformCatalogProject(root string, project string) (string, string, int) {
-	cwd := filepath.Join(root, "tests", project)
-	return transformCoverageCapture(func() int {
-		return runTransform([]string{
-			"--cwd", cwd,
-			"--tsconfig", "tsconfig.json",
-			"--output", "ts",
-		})
-	})
+  cwd := filepath.Join(root, "tests", project)
+  return transformCoverageCapture(func() int {
+    return runTransform([]string{
+      "--cwd", cwd,
+      "--tsconfig", "tsconfig.json",
+      "--output", "ts",
+    })
+  })
 }

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

@@ -34,7 +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, "length <= 30") || !strings.Contains(out, "RegExp(/^prefix(.*)postfix$/)") {
+  if !strings.Contains(out, `require("typia/lib/internal/_stringLength")`) ||
+    !strings.Contains(out, "._stringLength(input) <= 30") ||
+    !strings.Contains(out, "RegExp(/^prefix(.*)postfix$/)") {
     t.Fatalf("emitted checker should combine the template pattern with its tags:\n%s", out)
   }
   templateLiteralTypeTagsRunRuntimeCases(t, project, out)

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

@@ -20,8 +20,8 @@ import (
   nativetransform "github.com/samchon/typia/packages/typia/native/transform"
 )
 
-// runTransform is the source-to-source host the ttsc transform stage and the
-// `typia generate` wizard drive. Unlike `build` (which emits .js), it returns
+// runTransform is the source-to-source host that drives the ttsc transform
+// stage. Unlike `build` (which emits .js), it returns
 // transformed TypeScript: typia's per-file node transformer runs in an
 // EmitContext and the result SourceFile is printed back as TS (no JS script
 // transformers), so injected namespace imports stay as ES imports the caller