typia 15.2.0 → 15.2.2

package/lib/internal/_stringLengthGte.d.ts

@@ -1,12 +1,16 @@
 /**
  * Test whether a string has at least the given number of code points.
  *
- * Iteration stops as soon as the count is reached, so a long string is not
- * scanned to its end.
+ * Twice the requested minimum in UTF-16 units guarantees enough code points.
+ * Other inputs are counted only until the minimum is reached.
  *
- * @evidence contracts/common.md#principled-implementation The iterator is consumed only until the count reaches the requested minimum, which decides the lower bound without scanning the whole string; a minimum of zero is true at once.
+ * @evidence contracts/common.md#principled-implementation Each code point occupies at most two UTF-16 units, so code-unit length at least twice the minimum proves the code-point bound. Otherwise iteration stops at the minimum; nonpositive minima remain true and NaN remains false.
  * @evidence contracts/common.md#clear-and-simple-design One loop with an early return.
  * @evidence contracts/common.md#prohibited-implementation-shortcuts The unit is code points.
  * @evidence contracts/common.md#meaningful-documentation The doc states the early return and the code point unit.
+ * @evidence contracts/performance.md#efficient-algorithms The code-unit lower bound accepts in constant time without allocating an iterator; ambiguous inputs retain the bounded code-point walk and constant auxiliary space.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Each call depends on its own primitive string and bound; this predicate coordinates no repeated requests or shared computation.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The predicate retains no state or handles after returning; iteration and scalar counters are call-local.
  */
 export declare const _stringLengthGte: (value: string, length: number) => boolean;

package/lib/internal/_stringLengthGte.js

@@ -4,15 +4,21 @@ exports._stringLengthGte = void 0;
 /**
  * Test whether a string has at least the given number of code points.
  *
- * Iteration stops as soon as the count is reached, so a long string is not
- * scanned to its end.
+ * Twice the requested minimum in UTF-16 units guarantees enough code points.
+ * Other inputs are counted only until the minimum is reached.
  *
- * @evidence contracts/common.md#principled-implementation The iterator is consumed only until the count reaches the requested minimum, which decides the lower bound without scanning the whole string; a minimum of zero is true at once.
+ * @evidence contracts/common.md#principled-implementation Each code point occupies at most two UTF-16 units, so code-unit length at least twice the minimum proves the code-point bound. Otherwise iteration stops at the minimum; nonpositive minima remain true and NaN remains false.
  * @evidence contracts/common.md#clear-and-simple-design One loop with an early return.
  * @evidence contracts/common.md#prohibited-implementation-shortcuts The unit is code points.
  * @evidence contracts/common.md#meaningful-documentation The doc states the early return and the code point unit.
+ * @evidence contracts/performance.md#efficient-algorithms The code-unit lower bound accepts in constant time without allocating an iterator; ambiguous inputs retain the bounded code-point walk and constant auxiliary space.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Each call depends on its own primitive string and bound; this predicate coordinates no repeated requests or shared computation.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The predicate retains no state or handles after returning; iteration and scalar counters are call-local.
  */
 const _stringLengthGte = (value, length) => {
+    if (value.length >= length * 2)
+        return true;
     let count = 0;
     if (length <= count)
         return true;

package/lib/internal/_stringLengthGte.js.map

@@ -1 +1 @@
-{"version":3,"file":"_stringLengthGte.js","sources":["../../src/internal/_stringLengthGte.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;GAUG;AACI,MAAM,gBAAgB,GAAG,CAAC,KAAa,EAAE,MAAc,EAAW,EAAE;IACzE,IAAI,KAAK,GAAW,CAAC,CAAC;IACtB,IAAI,MAAM,IAAI,KAAK;QAAE,OAAO,IAAI,CAAC;IACjC,KAAK,MAAM,GAAG,IAAI,KAAK;QAAE,IAAI,MAAM,IAAI,EAAE,KAAK;YAAE,OAAO,IAAI,CAAC;IAC5D,OAAO,KAAK,CAAC;AACf,CAAC,CAAC;AALW,QAAA,gBAAgB,GAAhB,gBAAgB,CAK3B"}
+{"version":3,"file":"_stringLengthGte.js","sources":["../../src/internal/_stringLengthGte.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;;;;;GAcG;AACI,MAAM,gBAAgB,GAAG,CAAC,KAAa,EAAE,MAAc,EAAW,EAAE;IACzE,IAAI,KAAK,CAAC,MAAM,IAAI,MAAM,GAAG,CAAC;QAAE,OAAO,IAAI,CAAC;IAC5C,IAAI,KAAK,GAAW,CAAC,CAAC;IACtB,IAAI,MAAM,IAAI,KAAK;QAAE,OAAO,IAAI,CAAC;IACjC,KAAK,MAAM,GAAG,IAAI,KAAK;QAAE,IAAI,MAAM,IAAI,EAAE,KAAK;YAAE,OAAO,IAAI,CAAC;IAC5D,OAAO,KAAK,CAAC;AACf,CAAC,CAAC;AANW,QAAA,gBAAgB,GAAhB,gBAAgB,CAM3B"}

package/lib/internal/_stringLengthGte.mjs

@@ -2,15 +2,20 @@
 /**
 * Test whether a string has at least the given number of code points.
 *
-* Iteration stops as soon as the count is reached, so a long string is not
-* scanned to its end.
+* Twice the requested minimum in UTF-16 units guarantees enough code points.
+* Other inputs are counted only until the minimum is reached.
 *
-* @evidence contracts/common.md#principled-implementation The iterator is consumed only until the count reaches the requested minimum, which decides the lower bound without scanning the whole string; a minimum of zero is true at once.
+* @evidence contracts/common.md#principled-implementation Each code point occupies at most two UTF-16 units, so code-unit length at least twice the minimum proves the code-point bound. Otherwise iteration stops at the minimum; nonpositive minima remain true and NaN remains false.
 * @evidence contracts/common.md#clear-and-simple-design One loop with an early return.
 * @evidence contracts/common.md#prohibited-implementation-shortcuts The unit is code points.
 * @evidence contracts/common.md#meaningful-documentation The doc states the early return and the code point unit.
+* @evidence contracts/performance.md#efficient-algorithms The code-unit lower bound accepts in constant time without allocating an iterator; ambiguous inputs retain the bounded code-point walk and constant auxiliary space.
+*
+* @evidenceExclude contracts/performance.md#reuse-equivalent-work Each call depends on its own primitive string and bound; this predicate coordinates no repeated requests or shared computation.
+* @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The predicate retains no state or handles after returning; iteration and scalar counters are call-local.
 */
 const _stringLengthGte = (value, length) => {
+	if (value.length >= length * 2) return true;
 	let count = 0;
 	if (length <= count) return true;
 	for (const _ch of value) if (length <= ++count) return true;

package/lib/internal/_stringLengthGte.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"_stringLengthGte.mjs","names":[],"sources":["../../src/internal/_stringLengthGte.ts"],"sourcesContent":["/**\n * Test whether a string has at least the given number of code points.\n *\n * Iteration stops as soon as the count is reached, so a long string is not\n * scanned to its end.\n *\n * @evidence contracts/common.md#principled-implementation The iterator is consumed only until the count reaches the requested minimum, which decides the lower bound without scanning the whole string; a minimum of zero is true at once.\n * @evidence contracts/common.md#clear-and-simple-design One loop with an early return.\n * @evidence contracts/common.md#prohibited-implementation-shortcuts The unit is code points.\n * @evidence contracts/common.md#meaningful-documentation The doc states the early return and the code point unit.\n */\nexport const _stringLengthGte = (value: string, length: number): boolean => {\n  let count: number = 0;\n  if (length <= count) return true;\n  for (const _ch of value) if (length <= ++count) return true;\n  return false;\n};\n"],"mappings":";;;;;;;;;;;;AAWA,MAAa,oBAAoB,OAAe,WAA4B;CAC1E,IAAI,QAAgB;CACpB,IAAI,UAAU,OAAO,OAAO;CAC5B,KAAK,MAAM,OAAO,OAAO,IAAI,UAAU,EAAE,OAAO,OAAO;CACvD,OAAO;AACT"}
+{"version":3,"file":"_stringLengthGte.mjs","names":[],"sources":["../../src/internal/_stringLengthGte.ts"],"sourcesContent":["/**\n * Test whether a string has at least the given number of code points.\n *\n * Twice the requested minimum in UTF-16 units guarantees enough code points.\n * Other inputs are counted only until the minimum is reached.\n *\n * @evidence contracts/common.md#principled-implementation Each code point occupies at most two UTF-16 units, so code-unit length at least twice the minimum proves the code-point bound. Otherwise iteration stops at the minimum; nonpositive minima remain true and NaN remains false.\n * @evidence contracts/common.md#clear-and-simple-design One loop with an early return.\n * @evidence contracts/common.md#prohibited-implementation-shortcuts The unit is code points.\n * @evidence contracts/common.md#meaningful-documentation The doc states the early return and the code point unit.\n * @evidence contracts/performance.md#efficient-algorithms The code-unit lower bound accepts in constant time without allocating an iterator; ambiguous inputs retain the bounded code-point walk and constant auxiliary space.\n *\n * @evidenceExclude contracts/performance.md#reuse-equivalent-work Each call depends on its own primitive string and bound; this predicate coordinates no repeated requests or shared computation.\n * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The predicate retains no state or handles after returning; iteration and scalar counters are call-local.\n */\nexport const _stringLengthGte = (value: string, length: number): boolean => {\n  if (value.length >= length * 2) return true;\n  let count: number = 0;\n  if (length <= count) return true;\n  for (const _ch of value) if (length <= ++count) return true;\n  return false;\n};\n"],"mappings":";;;;;;;;;;;;;;;;AAeA,MAAa,oBAAoB,OAAe,WAA4B;CAC1E,IAAI,MAAM,UAAU,SAAS,GAAG,OAAO;CACvC,IAAI,QAAgB;CACpB,IAAI,UAAU,OAAO,OAAO;CAC5B,KAAK,MAAM,OAAO,OAAO,IAAI,UAAU,EAAE,OAAO,OAAO;CACvD,OAAO;AACT"}

package/lib/internal/_stringLengthLte.d.ts

@@ -1,12 +1,16 @@
 /**
  * Test whether a string has at most the given number of code points.
  *
- * Iteration stops as soon as the count is exceeded, so a long string is not
- * scanned to its end.
+ * UTF-16 length decides inputs whose code units already fit the bound. Other
+ * inputs are counted only until the maximum is exceeded.
  *
- * @evidence contracts/common.md#principled-implementation The iterator is consumed until the count exceeds the maximum, which decides the upper bound without scanning past it; a negative maximum is false at once.
+ * @evidence contracts/common.md#principled-implementation Each code point occupies one or two UTF-16 units, so code-unit length at most the maximum proves the code-point bound. Otherwise iteration stops once the maximum is exceeded; negative and NaN maxima remain false.
  * @evidence contracts/common.md#clear-and-simple-design One loop with an early return.
  * @evidence contracts/common.md#prohibited-implementation-shortcuts The unit is code points.
  * @evidence contracts/common.md#meaningful-documentation The doc states the early return and the code point unit.
+ * @evidence contracts/performance.md#efficient-algorithms The code-unit upper bound accepts in constant time without allocating an iterator; ambiguous inputs retain the bounded code-point walk and constant auxiliary space.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Each call depends on its own primitive string and bound; this predicate coordinates no repeated requests or shared computation.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The predicate retains no state or handles after returning; iteration and scalar counters are call-local.
  */
 export declare const _stringLengthLte: (value: string, length: number) => boolean;

package/lib/internal/_stringLengthLte.js

@@ -4,15 +4,21 @@ exports._stringLengthLte = void 0;
 /**
  * Test whether a string has at most the given number of code points.
  *
- * Iteration stops as soon as the count is exceeded, so a long string is not
- * scanned to its end.
+ * UTF-16 length decides inputs whose code units already fit the bound. Other
+ * inputs are counted only until the maximum is exceeded.
  *
- * @evidence contracts/common.md#principled-implementation The iterator is consumed until the count exceeds the maximum, which decides the upper bound without scanning past it; a negative maximum is false at once.
+ * @evidence contracts/common.md#principled-implementation Each code point occupies one or two UTF-16 units, so code-unit length at most the maximum proves the code-point bound. Otherwise iteration stops once the maximum is exceeded; negative and NaN maxima remain false.
  * @evidence contracts/common.md#clear-and-simple-design One loop with an early return.
  * @evidence contracts/common.md#prohibited-implementation-shortcuts The unit is code points.
  * @evidence contracts/common.md#meaningful-documentation The doc states the early return and the code point unit.
+ * @evidence contracts/performance.md#efficient-algorithms The code-unit upper bound accepts in constant time without allocating an iterator; ambiguous inputs retain the bounded code-point walk and constant auxiliary space.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Each call depends on its own primitive string and bound; this predicate coordinates no repeated requests or shared computation.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The predicate retains no state or handles after returning; iteration and scalar counters are call-local.
  */
 const _stringLengthLte = (value, length) => {
+    if (value.length <= length)
+        return true;
     let count = 0;
     if (!(count <= length))
         return false;

package/lib/internal/_stringLengthLte.js.map

@@ -1 +1 @@
-{"version":3,"file":"_stringLengthLte.js","sources":["../../src/internal/_stringLengthLte.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;GAUG;AACI,MAAM,gBAAgB,GAAG,CAAC,KAAa,EAAE,MAAc,EAAW,EAAE;IACzE,IAAI,KAAK,GAAW,CAAC,CAAC;IACtB,IAAI,CAAC,CAAC,KAAK,IAAI,MAAM,CAAC;QAAE,OAAO,KAAK,CAAC;IACrC,KAAK,MAAM,GAAG,IAAI,KAAK;QAAE,IAAI,CAAC,CAAC,EAAE,KAAK,IAAI,MAAM,CAAC;YAAE,OAAO,KAAK,CAAC;IAChE,OAAO,IAAI,CAAC;AACd,CAAC,CAAC;AALW,QAAA,gBAAgB,GAAhB,gBAAgB,CAK3B"}
+{"version":3,"file":"_stringLengthLte.js","sources":["../../src/internal/_stringLengthLte.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;;;;;GAcG;AACI,MAAM,gBAAgB,GAAG,CAAC,KAAa,EAAE,MAAc,EAAW,EAAE;IACzE,IAAI,KAAK,CAAC,MAAM,IAAI,MAAM;QAAE,OAAO,IAAI,CAAC;IACxC,IAAI,KAAK,GAAW,CAAC,CAAC;IACtB,IAAI,CAAC,CAAC,KAAK,IAAI,MAAM,CAAC;QAAE,OAAO,KAAK,CAAC;IACrC,KAAK,MAAM,GAAG,IAAI,KAAK;QAAE,IAAI,CAAC,CAAC,EAAE,KAAK,IAAI,MAAM,CAAC;YAAE,OAAO,KAAK,CAAC;IAChE,OAAO,IAAI,CAAC;AACd,CAAC,CAAC;AANW,QAAA,gBAAgB,GAAhB,gBAAgB,CAM3B"}

package/lib/internal/_stringLengthLte.mjs

@@ -2,15 +2,20 @@
 /**
 * Test whether a string has at most the given number of code points.
 *
-* Iteration stops as soon as the count is exceeded, so a long string is not
-* scanned to its end.
+* UTF-16 length decides inputs whose code units already fit the bound. Other
+* inputs are counted only until the maximum is exceeded.
 *
-* @evidence contracts/common.md#principled-implementation The iterator is consumed until the count exceeds the maximum, which decides the upper bound without scanning past it; a negative maximum is false at once.
+* @evidence contracts/common.md#principled-implementation Each code point occupies one or two UTF-16 units, so code-unit length at most the maximum proves the code-point bound. Otherwise iteration stops once the maximum is exceeded; negative and NaN maxima remain false.
 * @evidence contracts/common.md#clear-and-simple-design One loop with an early return.
 * @evidence contracts/common.md#prohibited-implementation-shortcuts The unit is code points.
 * @evidence contracts/common.md#meaningful-documentation The doc states the early return and the code point unit.
+* @evidence contracts/performance.md#efficient-algorithms The code-unit upper bound accepts in constant time without allocating an iterator; ambiguous inputs retain the bounded code-point walk and constant auxiliary space.
+*
+* @evidenceExclude contracts/performance.md#reuse-equivalent-work Each call depends on its own primitive string and bound; this predicate coordinates no repeated requests or shared computation.
+* @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The predicate retains no state or handles after returning; iteration and scalar counters are call-local.
 */
 const _stringLengthLte = (value, length) => {
+	if (value.length <= length) return true;
 	let count = 0;
 	if (!(count <= length)) return false;
 	for (const _ch of value) if (!(++count <= length)) return false;

package/lib/internal/_stringLengthLte.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"_stringLengthLte.mjs","names":[],"sources":["../../src/internal/_stringLengthLte.ts"],"sourcesContent":["/**\n * Test whether a string has at most the given number of code points.\n *\n * Iteration stops as soon as the count is exceeded, so a long string is not\n * scanned to its end.\n *\n * @evidence contracts/common.md#principled-implementation The iterator is consumed until the count exceeds the maximum, which decides the upper bound without scanning past it; a negative maximum is false at once.\n * @evidence contracts/common.md#clear-and-simple-design One loop with an early return.\n * @evidence contracts/common.md#prohibited-implementation-shortcuts The unit is code points.\n * @evidence contracts/common.md#meaningful-documentation The doc states the early return and the code point unit.\n */\nexport const _stringLengthLte = (value: string, length: number): boolean => {\n  let count: number = 0;\n  if (!(count <= length)) return false;\n  for (const _ch of value) if (!(++count <= length)) return false;\n  return true;\n};\n"],"mappings":";;;;;;;;;;;;AAWA,MAAa,oBAAoB,OAAe,WAA4B;CAC1E,IAAI,QAAgB;CACpB,IAAI,EAAE,SAAS,SAAS,OAAO;CAC/B,KAAK,MAAM,OAAO,OAAO,IAAI,EAAE,EAAE,SAAS,SAAS,OAAO;CAC1D,OAAO;AACT"}
+{"version":3,"file":"_stringLengthLte.mjs","names":[],"sources":["../../src/internal/_stringLengthLte.ts"],"sourcesContent":["/**\n * Test whether a string has at most the given number of code points.\n *\n * UTF-16 length decides inputs whose code units already fit the bound. Other\n * inputs are counted only until the maximum is exceeded.\n *\n * @evidence contracts/common.md#principled-implementation Each code point occupies one or two UTF-16 units, so code-unit length at most the maximum proves the code-point bound. Otherwise iteration stops once the maximum is exceeded; negative and NaN maxima remain false.\n * @evidence contracts/common.md#clear-and-simple-design One loop with an early return.\n * @evidence contracts/common.md#prohibited-implementation-shortcuts The unit is code points.\n * @evidence contracts/common.md#meaningful-documentation The doc states the early return and the code point unit.\n * @evidence contracts/performance.md#efficient-algorithms The code-unit upper bound accepts in constant time without allocating an iterator; ambiguous inputs retain the bounded code-point walk and constant auxiliary space.\n *\n * @evidenceExclude contracts/performance.md#reuse-equivalent-work Each call depends on its own primitive string and bound; this predicate coordinates no repeated requests or shared computation.\n * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The predicate retains no state or handles after returning; iteration and scalar counters are call-local.\n */\nexport const _stringLengthLte = (value: string, length: number): boolean => {\n  if (value.length <= length) return true;\n  let count: number = 0;\n  if (!(count <= length)) return false;\n  for (const _ch of value) if (!(++count <= length)) return false;\n  return true;\n};\n"],"mappings":";;;;;;;;;;;;;;;;AAeA,MAAa,oBAAoB,OAAe,WAA4B;CAC1E,IAAI,MAAM,UAAU,QAAQ,OAAO;CACnC,IAAI,QAAgB;CACpB,IAAI,EAAE,SAAS,SAAS,OAAO;CAC/B,KAAK,MAAM,OAAO,OAAO,IAAI,EAAE,EAAE,SAAS,SAAS,OAAO;CAC1D,OAAO;AACT"}

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

@@ -0,0 +1,79 @@
+package main
+
+import (
+  "os"
+  "path/filepath"
+  "testing"
+)
+
+// TestJsonSchemaRecursiveArrayAliasTransform verifies recursive arrays survive
+// analysis and produce finite, repeatable schema literals.
+//
+// The alias and array metadata may share an identity; constructed metadata alone
+// cannot establish which names the TypeScript checker actually supplies.
+//
+// 1. Transform recursive, constrained and nonrecursive declarations together.
+// 2. Compare named structural bodies and distinct use-site constraints.
+// 3. Repeat emission and require identical complete JavaScript bytes.
+//
+// @evidence contracts/testing.md#behavioral-verification Runs the native transform in process, decodes emitted schema literals and compares array bodies and tagged properties; complete output equality pins deterministic emission.
+// @evidence contracts/testing.md#independent-expectations The authored recursive type requires an array whose items reference the value union. Explicit max/min tags constrain different properties and must not modify an untagged sibling.
+// @evidence contracts/testing.md#distinguishing-cases Union-root and array-root traversal, two tagged sibling uses and an untagged sibling coexist with an ordinary array control; emitted identity and constraint placement are asserted separately.
+// @evidence contracts/testing.md#execution-ownership pnpm test:go:native discovers this test; runTransform and AST decoding execute in process using one fixture project, without compiler or JavaScript subprocesses.
+func TestJsonSchemaRecursiveArrayAliasTransform(t *testing.T) {
+  dir := ttscTypiaTestFixtureDirectory(t, "recursive-array-schema-")
+  if err := os.MkdirAll(filepath.Join(dir, "src"), 0o755); err != nil {
+    t.Fatal(err)
+  }
+  for name, source := range map[string]string{
+    "tsconfig.json": atomicIntersectionSchemaTSConfig,
+    "src/main.ts": `import typia, { tags } from "typia";
+type JsonArray = JsonValue[];
+type JsonObject = { [key: string]: JsonValue };
+type JsonValue = string | number | boolean | null | JsonArray | JsonObject;
+interface Constrained {
+  small: JsonArray & tags.MaxItems<1>;
+  many: JsonArray & tags.MinItems<2>;
+  plain: JsonArray;
+}
+export const schemas = typia.json.schemas<[JsonValue, JsonArray, Constrained, string[]]>();
+`,
+  } {
+    if err := os.WriteFile(filepath.Join(dir, filepath.FromSlash(name)), []byte(source), 0o644); err != nil {
+      t.Fatal(err)
+    }
+  }
+  var previous string
+  for i := 0; i < 3; i++ {
+    output, stderr, code := ttscTypiaTestCapture(func() int {
+      return runTransform([]string{"--cwd", dir, "--tsconfig", "tsconfig.json", "--file", "src/main.ts", "--output", "js"})
+    })
+    if code != 0 {
+      t.Fatalf("transform failed (%d): %s", code, stderr)
+    }
+    unit := ttscTypiaTestSchemaLiteral(t, output)
+    if i != 0 && output != previous {
+      t.Error("unchanged source produced different bytes")
+    }
+    previous = output
+    schemas := ttscTypiaTestSchemaPath(t, unit, "components", "schemas").(map[string]any)
+    body := schemas["JsonArray"].(map[string]any)
+    ttscTypiaTestSchemaEqual(t, body, map[string]any{"type": "array", "items": map[string]any{"$ref": "#/components/schemas/JsonValue"}})
+    properties := ttscTypiaTestSchemaPath(t, unit, "components", "schemas", "Constrained", "properties").(map[string]any)
+    for _, sample := range []struct {
+      name       string
+      constraint string
+      value      any
+    }{
+      {"small", "maxItems", float64(1)}, {"many", "minItems", float64(2)}, {"plain", "", nil},
+    } {
+      ref := properties[sample.name].(map[string]any)["$ref"].(string)
+      target := schemas[ref[len("#/components/schemas/"):]].(map[string]any)
+      expected := map[string]any{"type": "array", "items": map[string]any{"$ref": "#/components/schemas/JsonValue"}}
+      if sample.constraint != "" {
+        expected[sample.constraint] = sample.value
+      }
+      ttscTypiaTestSchemaEqual(t, target, expected)
+    }
+  }
+}

package/native/core/context/ImportProgrammer.go

@@ -9,7 +9,7 @@ import (
 )
 
 // ImportProgrammer collects the imports that generated code needs and builds the
-// references to them.
+// references to them. It also collects lazily initialized pattern slots.
 //
 // In its default mode references are plain identifiers and ToStatements writes
 // named, default and namespace imports. After SetEmitContext, every file becomes
@@ -17,14 +17,16 @@ import (
 // name, so the compiler's module transform binds them. It is not safe for
 // concurrent use.
 //
-// @evidence contracts/common.md#principled-implementation Requests are recorded per file with their insertion order and each file is emitted once, either as named, default and namespace imports in the legacy mode or as one namespace import with member accesses on a generated unique name in emit-context mode, so the compiler's module transform decides the final CommonJS aliasing. Internal helpers are always imported from the typia package's internal folder under prefixed aliases.
+// @evidence contracts/common.md#principled-implementation Requests are recorded per file with their insertion order and each file is emitted once, either as named, default and namespace imports in the legacy mode or as one namespace import with member accesses on a generated unique name in emit-context mode, so the compiler's module transform decides the final CommonJS aliasing. Internal helpers use typia's internal folder. Static pattern sources share file-local lazy slots only when the compiler can allocate collision-safe names.
 // @evidence contracts/common.md#clear-and-simple-design One type with private asset records and helpers for module identifiers, ranks, member construction and aliases; the two emission modes share the recording code.
 // @evidence contracts/common.md#prohibited-implementation-shortcuts Ordering uses a rank table over internal helper names and first use, not special-casing of a consumer. It is not safe for concurrent use, which the doc states.
 // @evidence contracts/common.md#meaningful-documentation The doc describes both modes and the concurrency limit, and the field comment explains emit mode.
 type ImportProgrammer struct {
-  assets_  map[string]*importProgrammer_asset
-  order_   []string
-  options_ ImportProgrammer_IOptions
+  assets_       map[string]*importProgrammer_asset
+  order_        []string
+  options_      ImportProgrammer_IOptions
+  patterns_     map[string]*shimast.Node
+  patternOrder_ []string
   // emit_ switches import emission to AST-integration mode. When set, imports
   // become namespace imports created by emit_.Factory, and every reference is a
   // member access on a cloned unique name so tsgo's module transform owns the
@@ -332,14 +334,15 @@ func (p *ImportProgrammer) GetInternalText(name string) string {
   return alias
 }
 
-// ToStatements returns the import statements for everything requested. Files are
-// ordered by rank, with the internal helper files grouped by kind, and by first
-// use within a rank.
+// ToStatements returns the requested imports followed by lazy pattern slots.
+// Import files are ordered by rank, with internal helpers grouped by kind, and
+// by first use within a rank.
 //
-// @evidence contracts/common.md#principled-implementation Files are stable-sorted by a rank that groups internal helpers by kind and keeps insertion order within a rank, then emitted as one namespace import with optional constants in emit mode, or as namespace, default and named imports in the legacy mode, where a type-only default gets the type keyword.
+// @evidence contracts/common.md#principled-implementation Files are stable-sorted by a rank that groups internal helpers by kind and keeps insertion order within a rank, then emitted as one namespace import with optional constants in emit mode, or as namespace, default and named imports in the legacy mode, where a type-only default gets the type keyword. Pattern slots follow as uninitialized var declarations in first-use order.
 // @evidence contracts/common.md#clear-and-simple-design One method with the two mode branches and the rank helper.
 // @evidence contracts/common.md#prohibited-implementation-shortcuts The ranking is a fixed table and the order is deterministic.
 // @evidence contracts/common.md#meaningful-documentation The doc states the order and the two forms.
+// @evidence contracts/performance.md#efficient-algorithms Sorting A import assets costs O(A log A); pattern declarations follow in one O(P) first-use walk. Output allocation is proportional to the declarations that must be emitted, without scanning authored input strings or allocating a runtime lookup table.
 func (p *ImportProgrammer) ToStatements() []*shimast.Node {
   f := NodeFactoryOf(p.emit_)
   statements := []*shimast.Node{}
@@ -448,6 +451,13 @@ func (p *ImportProgrammer) ToStatements() []*shimast.Node {
       ))
     }
   }
+  for _, source := range p.patternOrder_ {
+    statements = append(statements, f.NewVariableStatement(nil,
+      f.NewVariableDeclarationList(f.NewNodeList([]*shimast.Node{
+        f.NewVariableDeclaration(p.patterns_[source].Clone(f), nil, nil, nil),
+      }), shimast.NodeFlagsNone),
+    ))
+  }
   return statements
 }
 

package/native/core/context/ImportProgrammerPattern.go

@@ -0,0 +1,36 @@
+package context
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+// Pattern reuses a flag-free RegExp after its first successful construction.
+// The constructor stays at the check site, so invalid sources still throw only
+// when the string check is reached. File-scoped var slots also work when a
+// circular import invokes a hoisted function before this module's body runs.
+// Without an emit context, retain the constructor: the standalone factory has
+// no compiler name-collision information for a file-scoped generated slot.
+//
+// @evidence contracts/common.md#principled-implementation A flag-free RegExp test does not advance lastIndex, so checks with the same source can share the compiled object. Nullish assignment records only successful construction and preserves lazy SyntaxError timing. Uninitialized var declarations are hoisted and do not reset an early circular-import initialization. The compiler supplies collision-safe names; without that capability, the original constructor is returned without introducing a binding.
+// @evidence contracts/common.md#clear-and-simple-design The file's existing statement collector owns one generated slot per distinct source and returns its lazy initialization expression.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts Only the caller's verified static flag-free pattern expressions use this method; arbitrary custom validators remain untouched.
+// @evidence contracts/common.md#meaningful-documentation The comment explains reuse, lazy construction and the var declaration.
+// @evidence contracts/performance.md#efficient-algorithms Source lookup uses the file's map and each generated check performs one nullish guard instead of constructing another RegExp.
+// @evidence contracts/performance.md#reuse-equivalent-work Standard JavaScript RegExp objects with identical source and no flags have equivalent stateless test behavior; the importer is scoped to one transformed source file and not shared between programs.
+// @evidence contracts/performance.md#bound-retention-and-release-resources Generation retains one slot per distinct authored pattern until the file transform ends; runtime retains at most one RegExp per slot for the containing module's lifetime, with no runtime-keyed cache.
+func (p *ImportProgrammer) Pattern(source string, constructor *shimast.Node) *shimast.Node {
+  if p.emit_ == nil {
+    return constructor
+  }
+  f := NodeFactoryOf(p.emit_)
+  name := p.patterns_[source]
+  if name == nil {
+    if p.patterns_ == nil {
+      p.patterns_ = map[string]*shimast.Node{}
+    }
+    name = p.emit_.Factory.NewUniqueName("__" + p.options_.InternalPrefix + "pattern")
+    p.patterns_[source] = name
+    p.patternOrder_ = append(p.patternOrder_, source)
+  }
+  return f.NewParenthesizedExpression(f.NewBinaryExpression(nil,
+    name.Clone(f), nil, f.NewToken(shimast.KindQuestionQuestionEqualsToken), constructor,
+  ))
+}

package/native/core/factories/internal/metadata/iterate_metadata_intersection.go

@@ -327,7 +327,10 @@ func Iterate_metadata_intersection(props IMetadataIteratorProps) bool {
   options := props.Options
   options.Functional = false
   explore := props.Explore
-  explore.Aliased = false
+  // Attach tags to the surviving structure, not to a new alias wrapper whose
+  // array/object bucket would be empty here. Nested members clear Aliased again
+  // when they descend, so recursive references still retain their aliases.
+  explore.Aliased = true
   explore.Escaped = false
   // Re-explore the surviving base alone (`Intersected: true` short-circuits the
   // intersection handler at the top of this function). TypeScript flattens nested

package/native/core/programmers/RandomProgrammer.go

@@ -806,7 +806,7 @@ func randomProgrammer_decode_array(props randomProgrammer_decodeArrayProps) []*s
     Components: components,
     Array:      props.Array,
   })
-  schemaList = randomProgrammer_array_schema_list(props.Array, components, schemaList)
+  schemaList = randomProgrammer_array_schema_list(components, schemaList)
   f := nativecontext.NodeFactoryOf(props.Context.Emit)
   output := make([]*shimast.Node, 0, len(schemaList))
   if props.Array.Type.Recursive {
@@ -1414,25 +1414,30 @@ func randomProgrammer_schema_without_items(schema nativeiterate.JsonSchema, emit
 }
 
 func randomProgrammer_array_schema_list(
-  array *schemametadata.MetadataArray,
   components *nativeiterate.OpenApi_IComponents,
   schemaList []nativeiterate.JsonSchema,
 ) []nativeiterate.JsonSchema {
-  if array == nil ||
-    array.Type == nil ||
-    array.Type.Recursive == false ||
-    components == nil ||
-    components.Schemas == nil {
+  if components == nil || components.Schemas == nil {
     return schemaList
   }
-  schema, ok := components.Schemas[array.Type.Name]
-  if ok == false || len(schema) == 0 {
-    return schemaList
-  }
-  if oneOf, ok := schema["oneOf"].([]nativeiterate.JsonSchema); ok {
-    return oneOf
+  output := make([]nativeiterate.JsonSchema, 0, len(schemaList))
+  for _, schema := range schemaList {
+    // The producer's reference identifies this use's component, which can
+    // differ from the underlying array type when schema tags are present.
+    ref, isReference := schema["$ref"].(string)
+    key, isLocal := strings.CutPrefix(ref, "#/components/schemas/")
+    target, exists := components.Schemas[key]
+    if !isReference || !isLocal || !exists || len(target) == 0 {
+      output = append(output, schema)
+      continue
+    }
+    if oneOf, ok := target["oneOf"].([]nativeiterate.JsonSchema); ok {
+      output = append(output, oneOf...)
+    } else {
+      output = append(output, target)
+    }
   }
-  return []nativeiterate.JsonSchema{schema}
+  return output
 }
 
 func randomProgrammer_internal(context nativecontext.ITypiaContext, name string) *shimast.Node {

package/native/core/programmers/internal/CheckerProgrammer.go

@@ -1240,7 +1240,7 @@ func checkerProgrammer_decode_array(props checkerProgrammer_decodeArrayProps) *s
   if props.Array.Type.Index != nil {
     index = *props.Array.Type.Index
   }
-  return checkerProgrammer_or(
+  main := checkerProgrammer_or(
     f.NewCallExpression(
       f.NewIdentifier(props.Functor.UseLocal(fmt.Sprintf("%sa%d", props.Config.Prefix, index))),
       nil,
@@ -1260,14 +1260,12 @@ func checkerProgrammer_decode_array(props checkerProgrammer_decodeArrayProps) *s
     }),
     props.Context.Emit,
   )
+  // Structural traversal is shared and visit-guarded, but this use's tags must
+  // be checked even when that helper has already visited the same array value.
+  return checkerProgrammer_check_array(props, main)
 }
 
 func checkerProgrammer_decode_array_inline(props checkerProgrammer_decodeArrayInlineProps) *shimast.Node {
-  length := nativeiterate.Check_array_length(nativeiterate.Check_array_lengthProps{
-    Context: props.Context,
-    Array:   props.Array,
-    Input:   props.Input,
-  })
   main := FeatureProgrammer.Decode_array(FeatureProgrammer_DecodeArrayProps{
     Config: FeatureProgrammer_DecodeArrayConfig{
       Prefix: props.Config.Prefix,
@@ -1299,6 +1297,15 @@ func checkerProgrammer_decode_array_inline(props checkerProgrammer_decodeArrayIn
     Explore: props.Explore,
     Emit:    props.Context.Emit,
   })
+  return checkerProgrammer_check_array(props, main)
+}
+
+func checkerProgrammer_check_array(props checkerProgrammer_decodeArrayProps, main *shimast.Node) *shimast.Node {
+  length := nativeiterate.Check_array_length(nativeiterate.Check_array_lengthProps{
+    Context: props.Context,
+    Array:   props.Array,
+    Input:   props.Input,
+  })
   if length.Expression == nil && len(length.Conditions) == 0 {
     return main
   }

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

@@ -24,7 +24,7 @@ type Check_stringProps struct {
 // Check_string builds the check entry of a string atomic: a `typeof input ===
 // "string"` guard plus the atomic's type-tag conditions.
 //
-// @evidence contracts/common.md#principled-implementation It builds the check entry of a string atomic: a `typeof input === "string"` guard plus the atomic's type-tag conditions.
+// @evidence contracts/common.md#principled-implementation It builds the string guard and type-tag conditions. A static flag-free RegExp(source).test(input) whose source agrees with pattern metadata uses the file's lazy reusable slot; other validation expressions retain their authored AST.
 // @evidence contracts/common.md#clear-and-simple-design One exported function; the pieces that repeat live in private helpers of the same file.
 // @evidence contracts/common.md#prohibited-implementation-shortcuts Its inputs are its arguments and the context they carry, and it keeps no state of its own.
 // @evidence contracts/common.md#meaningful-documentation The doc states what it builds.
@@ -50,9 +50,10 @@ func check_string_type_tags(props Check_stringProps) [][]nativehelpers.ICheckEnt
     tags := check_string_filter_validate(row)
     conditions := make([]nativehelpers.ICheckEntry_ICondition, 0, len(tags))
     for _, tag := range tags {
+      expression := check_string_transpile(props.Context, tag)(props.Input)
       conditions = append(conditions, nativehelpers.ICheckEntry_ICondition{
         Expected:   "string & " + tag.Name,
-        Expression: check_string_transpile(props.Context, tag.Validate)(props.Input),
+        Expression: expression,
       })
     }
     for _, tag := range row {
@@ -68,6 +69,36 @@ func check_string_type_tags(props Check_stringProps) [][]nativehelpers.ICheckEnt
   return output
 }
 
+// Recognize only the standard flag-free RegExp(source).test(input) form. A
+// custom pattern-kind tag may supply arbitrary validation code or flags, and
+// must retain that code and its state rather than being lowered from value alone.
+func check_string_pattern(context nativecontext.ITypiaContext, tag nativemetadata.IMetadataTypeTag, input *shimast.Expression, expression *shimast.Node) *shimast.Node {
+  source, ok := tag.Value.(string)
+  if !ok || tag.Kind != "pattern" || context.Importer == nil || expression.Kind != shimast.KindCallExpression {
+    return expression
+  }
+  test := expression.AsCallExpression()
+  if test.Arguments == nil || len(test.Arguments.Nodes) != 1 || test.Arguments.Nodes[0] != input || test.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return expression
+  }
+  member := test.Expression.AsPropertyAccessExpression()
+  if member.Name().Text() != "test" || member.Expression.Kind != shimast.KindCallExpression {
+    return expression
+  }
+  constructor := member.Expression.AsCallExpression()
+  if constructor.Expression.Kind != shimast.KindIdentifier || constructor.Expression.Text() != "RegExp" || constructor.Arguments == nil || len(constructor.Arguments.Nodes) != 1 {
+    return expression
+  }
+  argument := constructor.Arguments.Nodes[0]
+  if !shimast.IsStringLiteral(argument) || argument.Text() != source {
+    return expression
+  }
+  f := nativecontext.NodeFactoryOf(context.Emit)
+  return f.NewCallExpression(f.NewPropertyAccessExpression(
+    context.Importer.Pattern(source, member.Expression), nil, f.NewIdentifier("test"), shimast.NodeFlagsNone,
+  ), nil, nil, test.Arguments, shimast.NodeFlagsNone)
+}
+
 func check_string_filter_validate(row []nativemetadata.IMetadataTypeTag) []nativemetadata.IMetadataTypeTag {
   tags := []nativemetadata.IMetadataTypeTag{}
   for _, tag := range row {
@@ -78,13 +109,18 @@ func check_string_filter_validate(row []nativemetadata.IMetadataTypeTag) []nativ
   return tags
 }
 
-func check_string_transpile(context nativecontext.ITypiaContext, script string) func(input *shimast.Expression) *shimast.Node {
+// The same lowering serves ordinary strings, whole-template tags and captured
+// placeholder/backtracking checks, so every standard Pattern shares the cache.
+func check_string_transpile(context nativecontext.ITypiaContext, tag nativemetadata.IMetadataTypeTag) func(input *shimast.Expression) *shimast.Node {
   var importer nativefactories.ExpressionFactory_Importer
   if v := context.Importer; v != nil {
     importer = v
   }
-  return nativefactories.ExpressionFactory.Transpile(nativefactories.ExpressionFactory_TranspileProps{
+  transpile := nativefactories.ExpressionFactory.Transpile(nativefactories.ExpressionFactory_TranspileProps{
     Importer: importer,
-    Script:   script,
+    Script:   tag.Validate,
   }, context.Emit)
+  return func(input *shimast.Expression) *shimast.Node {
+    return check_string_pattern(context, tag, input, transpile(input))
+  }
 }