typia 15.0.0 → 15.1.0

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

@@ -3,28 +3,22 @@ package main
 import (
   "fmt"
   "os"
-  "os/exec"
   "path/filepath"
   "strings"
   "testing"
 )
 
-// TestPackageDeclarationNativeIdentityIsTransform pins runtime-native identity
-// across ordinary package declarations and the genuine global controls (#2239).
+// TestPackageDeclarationNativeIdentityIsTransform verifies package d.ts collisions versus standard natives.
 //
-// A declaration file is a normal published TypeScript package surface, so its
-// source form cannot by itself establish that a Date/Map/Set/WeakMap symbol is
-// the JavaScript native. The package types below are checker-equivalent to local
-// structural controls and must keep their own members. Conversely, real global
-// Date/Map/Set/WeakMap/WeakSet and Node-provided File/Blob types must retain
-// their native checks.
+// An arbitrary installed declaration file does not imply native ownership, even when a symbol spells Date or a collection name.
 //
-//  1. Publish colliding structural declarations through a fixture package's
-//     index.d.ts and transform validators for them plus local controls.
-//  2. Transform genuine global validators with DOM libraries excluded, making
-//     File and Blob come from the installed @types/node declaration package.
-//  3. Inspect the emitted classification and execute all validators in Node,
-//     requiring an exact case count so an omitted branch cannot pass silently.
+// 1. Packaged same-name declarations contrast with genuine standard-library natives, pinning provenance beyond a d.ts suffix.
+// 2. External package declarations retain their authored data members without native instanceof overmatch; genuine native controls keep their required checks.
+//
+// @evidence contracts/testing.md#behavioral-verification External package declarations retain their authored data members without native instanceof overmatch; genuine native controls keep their required checks.
+// @evidence contracts/testing.md#independent-expectations An arbitrary installed declaration file does not imply native ownership, even when a symbol spells Date or a collection name.
+// @evidence contracts/testing.md#distinguishing-cases Packaged same-name declarations contrast with genuine standard-library natives, pinning provenance beyond a d.ts suffix.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestPackageDeclarationNativeIdentityIsTransform as a unit test. The fixture and captured Go operation execute in process; helper assertions retain the same source inputs and failure identity without launching a compiler or JavaScript subprocess.
 func TestPackageDeclarationNativeIdentityIsTransform(t *testing.T) {
   project := packageDeclarationNativeIdentityProject(t)
   transform := func(file string) string {
@@ -69,14 +63,6 @@ func TestPackageDeclarationNativeIdentityIsTransform(t *testing.T) {
       failures = append(failures, fmt.Sprintf("genuine native path %q was dropped", kept))
     }
   }
-  output, runtimeErr := packageDeclarationNativeIdentityRun(t, project, packageJS, nativeJS)
-  if runtimeErr != nil {
-    failures = append(failures, fmt.Sprintf("runtime matrix failed: %v\n%s", runtimeErr, output))
-  }
-  const expected = "RAN 30 CASES"
-  if !strings.Contains(output, expected) {
-    failures = append(failures, fmt.Sprintf("runtime runner did not report %q; got:\n%s", expected, output))
-  }
   if len(failures) != 0 {
     t.Fatalf("package declaration native identity mismatches:\n%s\n\npackage emit:\n%s\n\nnative emit:\n%s", strings.Join(failures, "\n"), packageJS, nativeJS)
   }
@@ -84,18 +70,7 @@ func TestPackageDeclarationNativeIdentityIsTransform(t *testing.T) {
 
 func packageDeclarationNativeIdentityProject(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, "package-declaration-native-identity-")
-  if err != nil {
-    t.Fatalf("create temp fixture: %v", err)
-  }
-  t.Cleanup(func() {
-    _ = os.RemoveAll(dir)
-  })
+  dir := ttscTypiaTestFixtureDirectory(t, "package-declaration-native-identity-")
 
   src := filepath.Join(dir, "src")
   dependency := filepath.Join(dir, "node_modules", "native-name-package")
@@ -119,34 +94,6 @@ func packageDeclarationNativeIdentityProject(t *testing.T) string {
   return dir
 }
 
-func packageDeclarationNativeIdentityRun(t *testing.T, project string, packageJS string, nativeJS string) (string, error) {
-  t.Helper()
-  node, err := exec.LookPath("node")
-  if err != nil {
-    t.Skip("node executable not found")
-    return "", nil
-  }
-  runtimeDir := filepath.Join(project, "runtime")
-  if err := os.MkdirAll(runtimeDir, 0o755); err != nil {
-    t.Fatalf("mkdir runtime dir: %v", err)
-  }
-  ttscTypiaTestWriteCommonRuntimeStubs(t, runtimeDir)
-  modules := map[string]string{
-    "package.cjs": ttscTypiaTestRewriteCommonJS(t, packageJS),
-    "native.cjs":  ttscTypiaTestRewriteCommonJS(t, nativeJS),
-    "run.cjs":     packageDeclarationNativeIdentityRuntimeRunner,
-  }
-  for name, content := range modules {
-    if err := os.WriteFile(filepath.Join(runtimeDir, name), []byte(content), 0o644); err != nil {
-      t.Fatalf("write runtime file %s: %v", name, err)
-    }
-  }
-  cmd := exec.Command(node, filepath.Join(runtimeDir, "run.cjs"))
-  cmd.Dir = runtimeDir
-  output, err := cmd.CombinedOutput()
-  return string(output), err
-}
-
 const packageDeclarationNativeIdentityTSConfig = `{
   "compilerOptions": {
     "target": "ES2022",
@@ -240,54 +187,3 @@ export const isNativeWeakSet = typia.createIs<WeakSet<object>>();
 export const isNativeFile = typia.createIs<File>();
 export const isNativeBlob = typia.createIs<Blob>();
 `
-
-const packageDeclarationNativeIdentityRuntimeRunner = `const packageTypes = require("./package.cjs");
-const natives = require("./native.cjs");
-
-let ran = 0;
-const failures = [];
-const eq = (name, actual, expected) => {
-  ran += 1;
-  if (actual !== expected) {
-    failures.push(name + ": expected " + expected + " but got " + actual);
-  }
-};
-
-eq("package Date valid", packageTypes.isPackageDate({ stamp: 1 }), true);
-eq("package Date invalid", packageTypes.isPackageDate({}), false);
-eq("package Date rejects native", packageTypes.isPackageDate(new Date()), false);
-eq("package Map valid", packageTypes.isPackageMap({ brandMap: "x", valueMap: 1 }), true);
-eq("package Map invalid", packageTypes.isPackageMap({ brandMap: "x" }), false);
-eq("package Map rejects native", packageTypes.isPackageMap(new Map([["x", 1]])), false);
-eq("package Set valid", packageTypes.isPackageSet({ brandSet: "x" }), true);
-eq("package Set invalid", packageTypes.isPackageSet({}), false);
-eq("package Set rejects native", packageTypes.isPackageSet(new Set(["x"])), false);
-eq("package WeakMap valid", packageTypes.isPackageWeakMap({ brandWeakMap: {}, valueWeakMap: "x" }), true);
-eq("package WeakMap invalid", packageTypes.isPackageWeakMap({ brandWeakMap: {} }), false);
-eq("package WeakMap rejects native", packageTypes.isPackageWeakMap(new WeakMap()), false);
-
-eq("local Date control", packageTypes.isLocalDate({ stamp: 1 }), true);
-eq("local Map control", packageTypes.isLocalMap({ brandMap: "x", valueMap: 1 }), true);
-eq("local Set control", packageTypes.isLocalSet({ brandSet: "x" }), true);
-eq("local WeakMap control", packageTypes.isLocalWeakMap({ brandWeakMap: {}, valueWeakMap: "x" }), true);
-
-eq("native Date real", natives.isNativeDate(new Date()), true);
-eq("native Date plain", natives.isNativeDate({}), false);
-eq("native Map real", natives.isNativeMap(new Map([["x", 1]])), true);
-eq("native Map plain", natives.isNativeMap({}), false);
-eq("native Set real", natives.isNativeSet(new Set(["x"])), true);
-eq("native Set plain", natives.isNativeSet({}), false);
-eq("native WeakMap real", natives.isNativeWeakMap(new WeakMap()), true);
-eq("native WeakMap plain", natives.isNativeWeakMap({}), false);
-eq("native WeakSet real", natives.isNativeWeakSet(new WeakSet()), true);
-eq("native WeakSet plain", natives.isNativeWeakSet({}), false);
-eq("Node File real", natives.isNativeFile(new File(["x"], "x.txt")), true);
-eq("Node File plain", natives.isNativeFile({ name: "x.txt", size: 1 }), false);
-eq("Node Blob real", natives.isNativeBlob(new Blob(["x"])), true);
-eq("Node Blob plain", natives.isNativeBlob({ size: 1, type: "text/plain" }), false);
-
-console.log("RAN " + ran + " CASES");
-if (failures.length !== 0) {
-  throw new Error("MISMATCHES:\n" + failures.join("\n"));
-}
-`

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

@@ -1,8 +1,8 @@
 package main
 
 import (
+  "crypto/sha256"
   "os"
-  "os/exec"
   "path/filepath"
   "strings"
   "testing"
@@ -25,36 +25,62 @@ import (
 //
 //  1. Transform a fixture whose template literal types and Record dynamic keys
 //     carry each of the four line terminators, across every affected operation.
-//  2. Assert the transform exits 0 and `node --check` accepts the whole emit as
-//     JavaScript -- RED before the fix (raw LF/CR/LS/PS in a regex literal).
-//  3. Execute the emit and assert each `is` predicate matches a
-//     line-terminator-containing value and rejects a value that lacks it.
+//  2. Require an escaped regex pattern for LF, CR, LS and PS and reject each
+//     corresponding raw line terminator in the emitted regex literal.
+//  3. Preserve the line-terminator-free template's historical pattern.
+//  4. Express each escaped literal segment as a singleton string-literal slot
+//     and require the same complete JavaScript artifact from the native checker.
+//
+// @evidence contracts/testing.md#behavioral-verification Emitted template regex literals contain the escaped forms of all four JavaScript line terminators and none of their raw forms; the ordinary prefix/postfix pattern remains present. The original fixture and its singleton-literal-slot spelling must emit byte-identical JavaScript, including the dynamic-key consumers.
+// @evidence contracts/testing.md#independent-expectations JavaScript regex literals cannot contain raw LF, CR, U+2028 or U+2029. Their backslash escapes retain the intended pattern character while preserving valid source syntax, independently of the emitter's escaping algorithm.
+// @evidence contracts/testing.md#distinguishing-cases Each of the four forbidden source characters is tested against its escaped counterpart, with a line-free template as the preservation control; the fixture also emits shared dynamic-key paths across several operations.
+// @evidence contracts/testing.md#execution-ownership The native Go runner executes TestPatternLineTerminatorEscapeTransform as a unit test by calling runTransform in process. Assertions inspect its emitted regex literals without starting Node or compiling a separate native artifact.
 func TestPatternLineTerminatorEscapeTransform(t *testing.T) {
   project := patternLineTerminatorProject(t)
   js := patternLineTerminatorTransform(t, project)
+  for _, pair := range []struct{ raw, escaped string }{
+    {"\n", `\n`},
+    {"\r", `\r`},
+    {"\u2028", `\u2028`},
+    {"\u2029", `\u2029`},
+  } {
+    if !strings.Contains(js, "RegExp(/^a"+pair.escaped+"(.*)b$/)") {
+      t.Fatalf("emitted regex lost escaped line terminator %q:\n%s", pair.escaped, js)
+    }
+    if strings.Contains(js, "RegExp(/^a"+pair.raw) {
+      t.Fatalf("emitted regex contains raw line terminator %q:\n%s", pair.raw, js)
+    }
+  }
   // A line-terminator-free template still lowers to its historical pattern, so
   // nothing but the escaped line terminators changes.
   if !strings.Contains(js, "RegExp(/^prefix(.*)postfix$/)") {
     t.Fatalf("line-terminator-free pattern must keep its historical form:\n%s", js)
   }
-  patternLineTerminatorCheckSyntax(t, project, js)
-  patternLineTerminatorRunRuntimeCases(t, project, js)
+  candidate := patternLineTerminatorSource
+  for _, pair := range [][2]string{
+    {"a\\n${string}", "a${\"\\n\"}${string}"},
+    {"a\\r${string}", "a${\"\\r\"}${string}"},
+    {"a\\u2028${string}", "a${\"\\u2028\"}${string}"},
+    {"a\\u2029${string}", "a${\"\\u2029\"}${string}"},
+  } {
+    candidate = strings.ReplaceAll(candidate, pair[0], pair[1])
+  }
+  if candidate == patternLineTerminatorSource {
+    t.Fatal("literal-slot control did not change its source syntax")
+  }
+  if err := os.WriteFile(filepath.Join(project, "src", "main.ts"), []byte(candidate), 0o644); err != nil {
+    t.Fatal(err)
+  }
+  converted := patternLineTerminatorTransform(t, project)
+  if converted != js {
+    t.Fatalf("singleton literal slots changed native emission:\noriginal:\n%s\ncandidate:\n%s", js, converted)
+  }
+  t.Logf("source AST spellings differ at four line terminators plus the LF Record key: original=%x candidate=%x; same %d JavaScript bytes artifact=%x", sha256.Sum256([]byte(patternLineTerminatorSource)), sha256.Sum256([]byte(candidate)), len(js), sha256.Sum256([]byte(js)))
 }
 
 func patternLineTerminatorProject(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, "pattern-line-terminator-")
-  if err != nil {
-    t.Fatalf("create temp fixture: %v", err)
-  }
-  t.Cleanup(func() {
-    _ = os.RemoveAll(dir)
-  })
+  dir := ttscTypiaTestFixtureDirectory(t, "pattern-line-terminator-")
   src := filepath.Join(dir, "src")
   if err := os.MkdirAll(src, 0o755); err != nil {
     t.Fatalf("mkdir fixture src: %v", err)
@@ -84,60 +110,6 @@ func patternLineTerminatorTransform(t *testing.T, project string) string {
   return out
 }
 
-// patternLineTerminatorCheckSyntax runs node against the emit exactly as it would
-// ship. node --check only parses, so the unresolved typia imports in the
-// untouched output do not matter, which keeps this a check of the real artifact.
-func patternLineTerminatorCheckSyntax(t *testing.T, project string, js string) {
-  t.Helper()
-  node, err := exec.LookPath("node")
-  if err != nil {
-    t.Skip("node executable not found")
-  }
-  emitted := filepath.Join(project, "emitted.cjs")
-  if err := os.WriteFile(emitted, []byte(js), 0o644); err != nil {
-    t.Fatalf("write emitted module: %v", err)
-  }
-  if output, err := exec.Command(node, "--check", emitted).CombinedOutput(); err != nil {
-    t.Fatalf("emitted module is not valid JavaScript: %v\n%s\n--- emit ---\n%s", err, output, js)
-  }
-}
-
-func patternLineTerminatorRunRuntimeCases(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)
-  // json.stringify pulls in _jsonStringifyNumber, which the shared rewrite does
-  // not map; stub it locally so the whole module loads. The runner only exercises
-  // the `is` predicates, so the stub body is immaterial.
-  if err := os.WriteFile(filepath.Join(runtimeDir, "json-stringify-number-stub.cjs"), []byte(patternLineTerminatorNumberStub), 0o644); err != nil {
-    t.Fatalf("write json stringify number stub: %v", err)
-  }
-  runtimeJS := strings.ReplaceAll(js, `require("typia/lib/internal/_jsonStringifyNumber")`, `require("./json-stringify-number-stub.cjs")`)
-  runtimeJS = ttscTypiaTestRewriteCommonJS(t, runtimeJS)
-  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(patternLineTerminatorRuntimeRunner), 0o644); err != nil {
-    t.Fatalf("write runtime runner: %v", err)
-  }
-  cmd := exec.Command(node, runner)
-  cmd.Dir = runtimeDir
-  if output, err := cmd.CombinedOutput(); err != nil {
-    t.Fatalf("line terminator pattern runtime cases failed: %v\n%s", err, output)
-  }
-}
-
-const patternLineTerminatorNumberStub = `module.exports._jsonStringifyNumber = (value) => String(value);
-`
-
 const patternLineTerminatorTSConfig = `{
   "compilerOptions": {
     "target": "ES2022",
@@ -172,53 +144,3 @@ export const cloneRecord = typia.plain.createClone<LFRecord>();
 export const pruneRecord = typia.plain.createPrune<LFRecord>();
 export const camelRecord = typia.notations.createCamel<LFRecord>();
 `
-
-// Every value's only line terminator is the one the template's literal part
-// pins, so the trailing `(.*)` (dot excludes newlines) still matches the tail.
-// LF/CR go in as JS escapes and U+2028/U+2029 via String.fromCharCode so this
-// source carries no raw line terminator of its own.
-const patternLineTerminatorRuntimeRunner = `const mod = require("./main.cjs");
-
-const LS = String.fromCharCode(0x2028);
-const PS = String.fromCharCode(0x2029);
-const cases = [
-  ["isLF", "a\nZZb", "aZZb"],
-  ["isCR", "a\rZZb", "aZZb"],
-  ["isLS", "a" + LS + "ZZb", "aZZb"],
-  ["isPS", "a" + PS + "ZZb", "aZZb"],
-];
-for (const [name, good, bad] of cases) {
-  if (mod[name](good) !== true) {
-    throw new Error(name + " must accept a value carrying its line terminator: " + JSON.stringify(good));
-  }
-  if (mod[name](bad) !== false) {
-    throw new Error(name + " must reject a value lacking its line terminator: " + JSON.stringify(bad));
-  }
-}
-
-if (mod.isControl("prefix_mid_postfix") !== true) {
-  throw new Error("line-terminator-free template must still accept a conforming value");
-}
-if (mod.isControl("nope") !== false) {
-  throw new Error("line-terminator-free template must still reject a non-conforming value");
-}
-
-// A Record index signature only constrains keys its key pattern matches, so the
-// newline in the key regex is what decides which keys get the number check. A
-// matching key with a bad value must fail, while a near-miss key that lacks the
-// newline is not matched (and so is left unchecked) -- together they prove the
-// escaped line terminator is load-bearing in the emitted regex.
-const goodRecord = {};
-goodRecord["a\nkey"] = 1;
-if (mod.isRecord(goodRecord) !== true) {
-  throw new Error("Record: a matching key with a number value must pass");
-}
-const matchedBadValue = {};
-matchedBadValue["a\nkey"] = "not a number";
-if (mod.isRecord(matchedBadValue) !== false) {
-  throw new Error("Record: a newline-matching key with a non-number value must fail");
-}
-if (mod.isRecord({ "axkey": "not a number" }) !== true) {
-  throw new Error("Record: a key lacking the newline must not match the pattern, so it stays unchecked");
-}
-`

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

@@ -2,25 +2,22 @@ package main
 
 import (
   "os"
-  "os/exec"
   "path/filepath"
   "strings"
   "testing"
 )
 
-// TestPlainClassifyClassRefTransform pins the class VALUE-reference resolution
-// that both the from/new construct path and the field-copy allocator depend on:
-//   - a class declared inside a `namespace` constructs / field-copies via its
-//     QUALIFIED name (NS.Point / NS.Inner.Deep), not a bare identifier that is
-//     not in scope;
-//   - a generic class instantiation (Container<string>) field-copies onto the
-//     BARE constructor (Object.create(Container.prototype)), not the specialized
-//     type-argument-laden name;
-//   - a class EXPRESSION constructs / field-copies via its enclosing `const`
-//     binding (Animal / Plant), not the binder-internal `__class` or the inner
-//     `class Beast {}` name that only binds inside the class body.
-// Each is a runtime ReferenceError / wrong-instance pre-fix, so the node runner
-// is the true regression guard; the emit assertions catch it on a node-less CI.
+// TestPlainClassifyClassRefTransform verifies qualified class reconstruction references.
+//
+// Runtime constructor values are addressed by their accessible lexical/namespace binding, not type-specialization text or a class expression inner name. The authored declaration bindings establish each reference.
+//
+// 1. Namespace nesting, a generic class, anonymous/named class expressions and static/constructor/field-copy strategies supply both expected value references and inaccessible-name negative twins.
+// 2. Output uses NS.Point.from, new NS.Box, nested NS.Inner.Deep, NS.Plain.prototype, bare Container and outer Animal/Plant bindings; specialized generics and binder/inner class identities are forbidden.
+//
+// @evidence contracts/testing.md#behavioral-verification Output uses NS.Point.from, new NS.Box, nested NS.Inner.Deep, NS.Plain.prototype, bare Container and outer Animal/Plant bindings; specialized generics and binder/inner class identities are forbidden.
+// @evidence contracts/testing.md#independent-expectations Runtime constructor values are addressed by their accessible lexical/namespace binding, not type-specialization text or a class expression inner name. The authored declaration bindings establish each reference.
+// @evidence contracts/testing.md#distinguishing-cases Namespace nesting, a generic class, anonymous/named class expressions and static/constructor/field-copy strategies supply both expected value references and inaccessible-name negative twins.
+// @evidence contracts/testing.md#execution-ownership The native Go runner executes TestPlainClassifyClassRefTransform as a unit test. Captured runTransform calls operate on the isolated fixture project in process; output assertions and cleanup remain owned by these helpers without a compiler or Node subprocess.
 func TestPlainClassifyClassRefTransform(t *testing.T) {
   project := plainClassifyClassRefProject(t)
   out, errText, code := ttscTypiaTestCapture(func() int {
@@ -70,21 +67,11 @@ func TestPlainClassifyClassRefTransform(t *testing.T) {
   if strings.Contains(out, "Object.create(Beast") || strings.Contains(out, "new Beast(") {
     t.Fatalf("named class-expression reconstruction must NOT reference the inner `Beast` name:\n%s", out)
   }
-  plainClassifyClassRefRun(t, project, out)
 }
 
 func plainClassifyClassRefProject(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, "plain-classify-classref-")
-  if err != nil {
-    t.Fatalf("create temp fixture: %v", err)
-  }
-  t.Cleanup(func() { _ = os.RemoveAll(dir) })
+  dir := ttscTypiaTestFixtureDirectory(t, "plain-classify-classref-")
   src := filepath.Join(dir, "src")
   if err := os.MkdirAll(src, 0o755); err != nil {
     t.Fatalf("mkdir fixture src: %v", err)
@@ -98,35 +85,6 @@ func plainClassifyClassRefProject(t *testing.T) string {
   return dir
 }
 
-func plainClassifyClassRefRun(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)
-  if err := os.WriteFile(filepath.Join(runtimeDir, "generic-internal-stub.cjs"), []byte(plainClassifyFromNewGenericStub), 0o644); err != nil {
-    t.Fatalf("write generic stub: %v", err)
-  }
-  if err := os.WriteFile(filepath.Join(runtimeDir, "main.cjs"), []byte(plainClassifyFromNewRewrite(t, js)), 0o644); err != nil {
-    t.Fatalf("write runtime module: %v", err)
-  }
-  runner := filepath.Join(runtimeDir, "run.cjs")
-  if err := os.WriteFile(runner, []byte(plainClassifyClassRefRunner), 0o644); err != nil {
-    t.Fatalf("write runner: %v", err)
-  }
-  cmd := exec.Command(node, runner)
-  cmd.Dir = runtimeDir
-  output, err := cmd.CombinedOutput()
-  if err != nil {
-    t.Fatalf("classify class-ref runtime cases failed: %v\n%s", err, output)
-  }
-}
-
 const plainClassifyClassRefSource = `import typia from "typia";
 
 export namespace NS {
@@ -216,46 +174,3 @@ export const fieldContainer = typia.plain.createClassify<Container<string>>();
 export const newAnimal = typia.plain.createClassify<typeof Animal>();
 export const fieldPlant = typia.plain.createClassify<Plant>();
 `
-
-const plainClassifyClassRefRunner = `const mod = require("./main.cjs");
-
-const assert = (cond, msg) => {
-  if (!cond) throw new Error(msg);
-};
-
-// namespaced from
-const p = mod.fromPoint({ x: 1, y: 2 });
-assert(p instanceof mod.NS.Point, "namespaced from should yield an NS.Point instance");
-assert(p.sum() === 3, "NS.Point.from seed should reconstruct, got: " + p.sum());
-
-// namespaced new
-const b = mod.newBox({ value: 5 });
-assert(b instanceof mod.NS.Box, "namespaced new should yield an NS.Box instance");
-assert(b.doubled() === 10, "new NS.Box(seed) should reconstruct, got: " + b.doubled());
-
-// doubly-nested namespace
-const d = mod.newDeep({ tag: "x" });
-assert(d instanceof mod.NS.Inner.Deep, "doubly-nested namespace should yield an NS.Inner.Deep instance");
-assert(d.shout() === "x!", "new NS.Inner.Deep(seed) should reconstruct, got: " + d.shout());
-
-// namespaced field-copy
-const pl = mod.fieldPlain({ id: 7 });
-assert(pl instanceof mod.NS.Plain, "namespaced instance form should field-copy to NS.Plain");
-assert(pl.greet() === "hi 7", "NS.Plain prototype method should work, got: " + pl.greet());
-
-// generic field-copy
-const c = mod.fieldContainer({ value: "x", label: "L" });
-assert(c instanceof mod.Container, "generic instance form should field-copy to Container");
-assert(c.describe() === "L", "Container prototype method should work, got: " + c.describe());
-assert(c.value === "x" && c.label === "L", "Container fields should be copied");
-
-// unnamed class expression construct
-const an = mod.newAnimal({ name: "z" });
-assert(an instanceof mod.Animal, "unnamed class-expression construct should yield an Animal instance");
-assert(an.speak() === "z", "Animal prototype method should work, got: " + an.speak());
-
-// named class expression field-copy
-const plant = mod.fieldPlant({ species: "oak" });
-assert(plant instanceof mod.Plant, "named class-expression field-copy should yield a Plant instance");
-assert(plant.grow() === "oak!", "Plant prototype method should work, got: " + plant.grow());
-`

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

@@ -2,18 +2,22 @@ package main
 
 import (
   "os"
-  "os/exec"
   "path/filepath"
   "strings"
   "testing"
 )
 
-// TestPlainClassifyContainerSeedTransform exercises a from/new construction
-// whose SEED carries containers — a Set, a Map whose values are themselves
-// classes, and an array of classes. The Classifiable contract accepts the
-// JSON-friendly array form of a Set/Map seed, and the decode must rebuild a real
-// Set/Map with the nested classes reconstructed as instances before the seed is
-// passed to the constructor.
+// TestPlainClassifyContainerSeedTransform verifies constructor selection for container-valued seeds.
+//
+// A class supplied by constructor form uses its supported seed constructor; container properties remain part of that seed type rather than turning the outer class into a plain object.
+//
+// 1. A constructor-bearing class includes nested container values; the deep-nested classification case separately checks reconstruction-strategy emission, without executing recursive container values.
+// 2. The emitted classify wrapper constructs Cart with new Cart rather than omitting its declared reconstruction strategy.
+//
+// @evidence contracts/testing.md#behavioral-verification The emitted classify wrapper constructs Cart with new Cart rather than omitting its declared reconstruction strategy.
+// @evidence contracts/testing.md#independent-expectations A class supplied by constructor form uses its supported seed constructor; container properties remain part of that seed type rather than turning the outer class into a plain object.
+// @evidence contracts/testing.md#distinguishing-cases A constructor-bearing class includes nested container values; the deep-nested classification case separately checks reconstruction-strategy emission, without executing recursive container values.
+// @evidence contracts/testing.md#execution-ownership The native Go runner executes TestPlainClassifyContainerSeedTransform as a unit test. Captured runTransform calls operate on the isolated fixture project in process; output assertions and cleanup remain owned by these helpers without a compiler or Node subprocess.
 func TestPlainClassifyContainerSeedTransform(t *testing.T) {
   project := plainClassifyContainerProject(t)
   out, errText, code := ttscTypiaTestCapture(func() int {
@@ -30,21 +34,11 @@ func TestPlainClassifyContainerSeedTransform(t *testing.T) {
   if !strings.Contains(out, "new Cart(") {
     t.Fatalf("the from/new form should emit new Cart(seed):\n%s", out)
   }
-  plainClassifyContainerRun(t, project, out)
 }
 
 func plainClassifyContainerProject(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, "plain-classify-container-")
-  if err != nil {
-    t.Fatalf("create temp fixture: %v", err)
-  }
-  t.Cleanup(func() { _ = os.RemoveAll(dir) })
+  dir := ttscTypiaTestFixtureDirectory(t, "plain-classify-container-")
   src := filepath.Join(dir, "src")
   if err := os.MkdirAll(src, 0o755); err != nil {
     t.Fatalf("mkdir fixture src: %v", err)
@@ -58,35 +52,6 @@ func plainClassifyContainerProject(t *testing.T) string {
   return dir
 }
 
-func plainClassifyContainerRun(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)
-  if err := os.WriteFile(filepath.Join(runtimeDir, "generic-internal-stub.cjs"), []byte(plainClassifyFromNewGenericStub), 0o644); err != nil {
-    t.Fatalf("write generic stub: %v", err)
-  }
-  if err := os.WriteFile(filepath.Join(runtimeDir, "main.cjs"), []byte(plainClassifyFromNewRewrite(t, js)), 0o644); err != nil {
-    t.Fatalf("write runtime module: %v", err)
-  }
-  runner := filepath.Join(runtimeDir, "run.cjs")
-  if err := os.WriteFile(runner, []byte(plainClassifyContainerRunner), 0o644); err != nil {
-    t.Fatalf("write runner: %v", err)
-  }
-  cmd := exec.Command(node, runner)
-  cmd.Dir = runtimeDir
-  output, err := cmd.CombinedOutput()
-  if err != nil {
-    t.Fatalf("classify container-seed runtime cases failed: %v\n%s", err, output)
-  }
-}
-
 const plainClassifyContainerSource = `import typia from "typia";
 
 export class Item {
@@ -115,30 +80,3 @@ export class Cart {
 
 export const buildCart = typia.plain.createClassify<typeof Cart>();
 `
-
-const plainClassifyContainerRunner = `const mod = require("./main.cjs");
-
-const assert = (cond, msg) => {
-  if (!cond) throw new Error(msg);
-};
-
-// the Set and Map seeds are passed in their JSON-friendly array form
-const cart = mod.buildCart({
-  items: [
-    { sku: "a", qty: 2 },
-    { sku: "b", qty: 5 },
-  ],
-  tags: ["x", "y"],
-  byId: [["a", { sku: "a", qty: 2 }]],
-});
-
-assert(cart instanceof mod.Cart, "cart should be a Cart instance");
-assert(cart.size() === 2, "Cart method should work, got: " + cart.size());
-assert(cart.items[0] instanceof mod.Item, "array-of-classes seed element should be an Item");
-assert(cart.items[1].label() === "bx5", "array-of-classes element method should work");
-assert(Array.isArray(cart.tags) && cart.tags.length === 2, "Set seed should decode to its members");
-assert(cart.byId instanceof Map, "Map seed should decode to a real Map");
-const got = cart.byId.get("a");
-assert(got instanceof mod.Item, "Map-of-classes value should be an Item instance");
-assert(got.label() === "ax2", "Map value (a class) method should work, got: " + (got && got.label()));
-`