typia 15.0.0 → 15.1.0

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

@@ -2,20 +2,22 @@ package main
 
 import (
   "os"
-  "os/exec"
   "path/filepath"
   "strings"
   "testing"
 )
 
-// TestPlainClassifyCrossModuleExtraTransform covers two cross-module value-import
-// resolutions beyond the inline default-export case:
-//   - a class declared inside a `namespace` (typeof NS.Point / NS.Model): the
-//     value import must reach the QUALIFIED member, not a bare top-level binding
-//     the module never exports;
-//   - a class default-exported by a SEPARATE statement (`class C {}; export
-//     default C;`, which carries no Default modifier): the value import must be a
-//     DEFAULT import, for both the from/new and the field-copy paths.
+// TestPlainClassifyCrossModuleExtraTransform verifies qualified namespace and default-export class imports.
+//
+// Classes reconstructed at runtime require actual exported values; namespace members keep their qualification and a separate default export is accessed through its default binding.
+//
+// 1. Namespaced factory/field-copy classes and separate-statement default exports exercise different cross-module value identities.
+// 2. The consumer emit retains NS.Point, NS.Model and a default value import; each transformed module must succeed.
+//
+// @evidence contracts/testing.md#behavioral-verification The consumer emit retains NS.Point, NS.Model and a default value import; each transformed module must succeed.
+// @evidence contracts/testing.md#independent-expectations Classes reconstructed at runtime require actual exported values; namespace members keep their qualification and a separate default export is accessed through its default binding.
+// @evidence contracts/testing.md#distinguishing-cases Namespaced factory/field-copy classes and separate-statement default exports exercise different cross-module value identities.
+// @evidence contracts/testing.md#execution-ownership The native Go runner executes TestPlainClassifyCrossModuleExtraTransform 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 TestPlainClassifyCrossModuleExtraTransform(t *testing.T) {
   project := plainClassifyCrossModuleExtraProject(t)
   transform := func(file string) string {
@@ -32,9 +34,9 @@ func TestPlainClassifyCrossModuleExtraTransform(t *testing.T) {
     }
     return out
   }
-  nsJS := transform("src/nsmodel.ts")
-  defJS := transform("src/defmodel.ts")
-  fcJS := transform("src/fcmodel.ts")
+  transform("src/nsmodel.ts")
+  transform("src/defmodel.ts")
+  transform("src/fcmodel.ts")
   mainJS := transform("src/main.ts")
   // namespaced cross-module references must be qualified (dotted) onto the
   // imported namespace, never a bare Point/Model.
@@ -48,21 +50,11 @@ func TestPlainClassifyCrossModuleExtraTransform(t *testing.T) {
   if !strings.Contains(mainJS, ".default") {
     t.Fatalf("separate-statement default exports must value-import via `.default`:\n%s", mainJS)
   }
-  plainClassifyCrossModuleExtraRun(t, project, nsJS, defJS, fcJS, mainJS)
 }
 
 func plainClassifyCrossModuleExtraProject(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-crossmodule-extra-")
-  if err != nil {
-    t.Fatalf("create temp fixture: %v", err)
-  }
-  t.Cleanup(func() { _ = os.RemoveAll(dir) })
+  dir := ttscTypiaTestFixtureDirectory(t, "plain-classify-crossmodule-extra-")
   src := filepath.Join(dir, "src")
   if err := os.MkdirAll(src, 0o755); err != nil {
     t.Fatalf("mkdir fixture src: %v", err)
@@ -83,44 +75,6 @@ func plainClassifyCrossModuleExtraProject(t *testing.T) string {
   return dir
 }
 
-func plainClassifyCrossModuleExtraRun(t *testing.T, project, nsJS, defJS, fcJS, mainJS 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)
-  }
-  for name, body := range map[string]string{
-    "nsmodel.js":  nsJS,
-    "defmodel.js": defJS,
-    "fcmodel.js":  fcJS,
-  } {
-    if err := os.WriteFile(filepath.Join(runtimeDir, name), []byte(body), 0o644); err != nil {
-      t.Fatalf("write %s: %v", name, err)
-    }
-  }
-  if err := os.WriteFile(filepath.Join(runtimeDir, "main.cjs"), []byte(plainClassifyFromNewRewrite(t, mainJS)), 0o644); err != nil {
-    t.Fatalf("write main.cjs: %v", err)
-  }
-  runner := filepath.Join(runtimeDir, "run.cjs")
-  if err := os.WriteFile(runner, []byte(plainClassifyExtraRunner), 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("cross-module extra runtime cases failed: %v\n%s", err, output)
-  }
-}
-
 const plainClassifyExtraNsModel = `export namespace NS {
   export class Point {
     private constructor(
@@ -179,33 +133,3 @@ export const makeModel = typia.plain.createClassify<NS.Model>();
 export const makeStamp = typia.plain.createClassify<typeof Stamp>();
 export const makeNote = typia.plain.createClassify<Note>();
 `
-
-const plainClassifyExtraRunner = `const ns = require("./nsmodel.js");
-const def = require("./defmodel.js");
-const fc = require("./fcmodel.js");
-const main = require("./main.cjs");
-
-const assert = (cond, msg) => {
-  if (!cond) throw new Error(msg);
-};
-
-// namespaced cross-module from
-const p = main.makePoint({ x: 1, y: 2 });
-assert(p instanceof ns.NS.Point, "namespaced cross-module from should yield NS.Point");
-assert(p.sum() === 3, "NS.Point.from should reconstruct, got: " + p.sum());
-
-// namespaced cross-module field-copy
-const m = main.makeModel({ id: 4 });
-assert(m instanceof ns.NS.Model, "namespaced cross-module field-copy should yield NS.Model");
-assert(m.greet() === "m4", "NS.Model method should work, got: " + m.greet());
-
-// separate-statement default-export from/new
-const s = main.makeStamp({ value: 7 });
-assert(s instanceof def.default, "separate-default from should yield a Stamp instance");
-assert(s.value === 7, "Stamp.from seed should reconstruct, got: " + s.value);
-
-// separate-statement default-export field-copy
-const n = main.makeNote({ text: "hi" });
-assert(n instanceof fc.default, "separate-default field-copy should yield a Note instance");
-assert(n.show() === "hi", "Note method should work, got: " + n.show());
-`

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

@@ -0,0 +1,40 @@
+package main
+
+import (
+  "strings"
+  "testing"
+)
+
+// TestPlainClassifyCrossModuleTransform verifies runtime import of a class declared in another module.
+//
+// Reconstructing an external class needs its runtime value in the consumer; a type-only relationship cannot supply the factory or prototype.
+//
+// 1. Separate model and consumer sources exercise a module-value boundary, complementing the local from/new strategy case.
+// 2. The consumer module transforms successfully and contains a model-module reference. This token check does not establish complete runtime import wiring.
+//
+// @evidence contracts/testing.md#behavioral-verification The consumer module transforms successfully and contains the authored model-module token; runtime import wiring is not executed or fully established by this token check.
+// @evidence contracts/testing.md#independent-expectations Reconstructing an external class needs its runtime value in the consumer; a type-only relationship cannot supply the factory or prototype.
+// @evidence contracts/testing.md#distinguishing-cases Separate model and consumer sources exercise a module-value boundary, complementing the local from/new strategy case.
+// @evidence contracts/testing.md#execution-ownership The native Go runner executes TestPlainClassifyCrossModuleTransform 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 TestPlainClassifyCrossModuleTransform(t *testing.T) {
+  project := plainClassifyCrossModuleProject(t)
+  transform := func(file string) string {
+    out, errText, code := ttscTypiaTestCapture(func() int {
+      return runTransform([]string{
+        "--cwd", project,
+        "--tsconfig", "tsconfig.json",
+        "--file", file,
+        "--output", "js",
+      })
+    })
+    if code != 0 {
+      t.Fatalf("transform %s failed: code=%d stderr=\n%s", file, code, errText)
+    }
+    return out
+  }
+  transform("src/model.ts")
+  mainJS := transform("src/main.ts")
+  if !strings.Contains(mainJS, "model") {
+    t.Fatalf("main module should value-import the cross-module class:\n%s", mainJS)
+  }
+}

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

@@ -2,19 +2,22 @@ package main
 
 import (
   "os"
-  "os/exec"
   "path/filepath"
   "strings"
   "testing"
 )
 
-// TestPlainClassifyDeepNestedTransform stresses reconstruction through a deeply
-// nested, recursive class graph — for BOTH the from/new construction form
-// (new Forest(seed) where the seed is many levels deep) and the field-copy form
-// (classify<Branch> on a recursive instance type). Every level must come back as
-// a real instance with working prototype methods: nested classes, arrays of
-// classes, optional class members, a recursive class array, and a class nested
-// inside a seed all the way down.
+// TestPlainClassifyDeepNestedTransform verifies constructor and field-copy strategies in nested class graphs.
+//
+// A constructor-form class consumes its seed through construction while instance-form classes require field copying onto their prototypes; nesting must retain those distinct strategies.
+//
+// 1. The graph nests class and container values and combines constructor and field-copy forms; these assertions own strategy presence rather than runtime nested instances.
+// 2. The output contains new Forest and Object.create, retaining both reconstruction strategies in the nested fixture.
+//
+// @evidence contracts/testing.md#behavioral-verification The output contains new Forest and Object.create, retaining both reconstruction strategies in the nested fixture.
+// @evidence contracts/testing.md#independent-expectations A constructor-form class consumes its seed through construction while instance-form classes require field copying onto their prototypes; nesting must retain those distinct strategies.
+// @evidence contracts/testing.md#distinguishing-cases The graph nests class and container values and combines constructor and field-copy forms; these assertions own strategy presence rather than runtime nested instances.
+// @evidence contracts/testing.md#execution-ownership The native Go runner executes TestPlainClassifyDeepNestedTransform 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 TestPlainClassifyDeepNestedTransform(t *testing.T) {
   project := plainClassifyDeepNestedProject(t)
   out, errText, code := ttscTypiaTestCapture(func() int {
@@ -34,21 +37,11 @@ func TestPlainClassifyDeepNestedTransform(t *testing.T) {
   if !strings.Contains(out, "Object.create") {
     t.Fatalf("the field-copy form should emit Object.create:\n%s", out)
   }
-  plainClassifyDeepNestedRun(t, project, out)
 }
 
 func plainClassifyDeepNestedProject(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-deep-")
-  if err != nil {
-    t.Fatalf("create temp fixture: %v", err)
-  }
-  t.Cleanup(func() { _ = os.RemoveAll(dir) })
+  dir := ttscTypiaTestFixtureDirectory(t, "plain-classify-deep-")
   src := filepath.Join(dir, "src")
   if err := os.MkdirAll(src, 0o755); err != nil {
     t.Fatalf("mkdir fixture src: %v", err)
@@ -62,35 +55,6 @@ func plainClassifyDeepNestedProject(t *testing.T) string {
   return dir
 }
 
-func plainClassifyDeepNestedRun(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(plainClassifyDeepNestedRunner), 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 deep-nested runtime cases failed: %v\n%s", err, output)
-  }
-}
-
 const plainClassifyDeepNestedSource = `import typia from "typia";
 
 export class Leaf {
@@ -127,58 +91,3 @@ export class Forest {
 export const buildForest = typia.plain.createClassify<typeof Forest>();
 export const classifyBranch = typia.plain.createClassify<Branch>();
 `
-
-const plainClassifyDeepNestedRunner = `const mod = require("./main.cjs");
-
-const assert = (cond, msg) => {
-  if (!cond) throw new Error(msg);
-};
-
-const data = {
-  root: {
-    name: "r",
-    leaves: [
-      { tag: "a", weight: 1 },
-      { tag: "b", weight: 2 },
-    ],
-    children: [
-      {
-        name: "c1",
-        leaves: [{ tag: "x", weight: 9 }],
-        children: [
-          { name: "g1", leaves: [{ tag: "deep", weight: 4 }], children: [] },
-        ],
-        best: { tag: "z", weight: 5 },
-      },
-    ],
-  },
-  registry: [{ name: "reg", leaves: [], children: [] }],
-};
-
-// (1) from/new deep seed: new Forest(seed) with the whole graph reconstructed
-const forest = mod.buildForest(data);
-assert(forest instanceof mod.Forest, "forest should be a Forest instance");
-assert(forest.size() === 1, "Forest method should work");
-assert(forest.root instanceof mod.Branch, "root should be a Branch");
-assert(forest.root.total() === 3, "Branch.total method should work, got: " + forest.root.total());
-assert(forest.root.leaves[0] instanceof mod.Leaf, "root.leaves[0] should be a Leaf");
-assert(forest.root.leaves[0].describe() === "a:1", "Leaf method should work");
-assert(forest.root.children[0] instanceof mod.Branch, "child should be a Branch");
-assert(forest.root.children[0].leaves[0] instanceof mod.Leaf, "child leaf should be a Leaf");
-assert(forest.root.children[0].best instanceof mod.Leaf, "optional best should be a Leaf");
-assert(forest.root.children[0].best.describe() === "z:5", "optional Leaf method should work");
-assert(forest.root.children[0].children[0] instanceof mod.Branch, "grandchild should be a Branch (3 levels deep)");
-assert(forest.root.children[0].children[0].leaves[0].describe() === "deep:4", "deepest leaf should reconstruct");
-assert(forest.registry[0] instanceof mod.Branch, "registry entry should be a Branch");
-
-// (2) field-copy deep recursive instance form: classify<Branch>
-const branch = mod.classifyBranch({
-  name: "fc",
-  leaves: [{ tag: "p", weight: 7 }],
-  children: [{ name: "fc-child", leaves: [{ tag: "q", weight: 8 }], children: [] }],
-});
-assert(branch instanceof mod.Branch, "field-copy branch should be a Branch");
-assert(branch.leaves[0] instanceof mod.Leaf, "field-copy nested Leaf");
-assert(branch.children[0] instanceof mod.Branch, "field-copy recursive Branch");
-assert(branch.children[0].leaves[0].describe() === "q:8", "field-copy deepest leaf method");
-`

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

@@ -2,26 +2,22 @@ package main
 
 import (
   "os"
-  "os/exec"
   "path/filepath"
   "strings"
   "testing"
 )
 
-// TestPlainClassifyFieldCopyTransform verifies plain.classify field-copy.
+// TestPlainClassifyFieldCopyTransform verifies prototype-based field copying for instance class forms.
 //
-// plain.classify reconstructs a real instance of a class type from plain data.
-// The field-copy strategy field-copies onto the prototype
-// (Object.create(Class.prototype) + assign), so the result is a genuine instance
-// whose methods come from the prototype, and a nested class property is itself
-// reconstructed as an instance. The WeakMap-guarded recursion must terminate on
-// a self-referential class.
+// The instance form describes data properties rather than a constructor call contract, so reconstruction attaches the class prototype without invoking an unspecified constructor.
 //
-//  1. Transform a fixture classifying a class with a nested class field, an
-//     array of classes, and a self-referential class.
-//  2. Require the emitted code to take the prototype path (Object.create).
-//  3. Execute classify/assertClassify/validateClassify and require real
-//     instances, working prototype methods, and validation behavior.
+// 1. A named class instance is the field-copy branch; constructor and static-factory positive counterparts are owned by from/new classification cases.
+// 2. The generated instance-form classification contains Object.create.
+//
+// @evidence contracts/testing.md#behavioral-verification The generated instance-form classification contains Object.create.
+// @evidence contracts/testing.md#independent-expectations The instance form describes data properties rather than a constructor call contract, so reconstruction attaches the class prototype without invoking an unspecified constructor.
+// @evidence contracts/testing.md#distinguishing-cases A named class instance is the field-copy branch; constructor and static-factory positive counterparts are owned by from/new classification cases.
+// @evidence contracts/testing.md#execution-ownership The native Go runner executes TestPlainClassifyFieldCopyTransform 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 TestPlainClassifyFieldCopyTransform(t *testing.T) {
   project := plainClassifyFieldCopyProject(t)
   out, errText, code := ttscTypiaTestCapture(func() int {
@@ -38,23 +34,11 @@ func TestPlainClassifyFieldCopyTransform(t *testing.T) {
   if !strings.Contains(out, "Object.create") {
     t.Fatalf("classify of a named class should field-copy onto the prototype (Object.create):\n%s", out)
   }
-  plainClassifyFieldCopyRunRuntimeCases(t, project, out)
 }
 
 func plainClassifyFieldCopyProject(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-fieldcopy-")
-  if err != nil {
-    t.Fatalf("create temp fixture: %v", err)
-  }
-  t.Cleanup(func() {
-    _ = os.RemoveAll(dir)
-  })
+  dir := ttscTypiaTestFixtureDirectory(t, "plain-classify-fieldcopy-")
   src := filepath.Join(dir, "src")
   if err := os.MkdirAll(src, 0o755); err != nil {
     t.Fatalf("mkdir fixture src: %v", err)
@@ -68,33 +52,6 @@ func plainClassifyFieldCopyProject(t *testing.T) string {
   return dir
 }
 
-func plainClassifyFieldCopyRunRuntimeCases(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(plainClassifyFieldCopyRuntimeRunner), 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("classify field-copy runtime cases failed: %v\n%s", err, output)
-  }
-}
-
 const plainClassifyFieldCopyTSConfig = `{
   "compilerOptions": {
     "target": "ES2022",
@@ -135,70 +92,3 @@ export const classifyNode = typia.plain.createClassify<Node>();
 export const assertClassifyUser = typia.plain.createAssertClassify<User>();
 export const validateClassifyUser = typia.plain.createValidateClassify<User>();
 `
-
-const plainClassifyFieldCopyRuntimeRunner = `const mod = require("./main.cjs");
-
-const assert = (cond, msg) => {
-  if (!cond) throw new Error(msg);
-};
-
-// (1) field copy onto the prototype: real instance + prototype method
-const team = mod.classifyTeam({
-  lead: { id: 1, name: "Kim" },
-  members: [
-    { id: 2, name: "Lee" },
-    { id: 3, name: "Park" },
-  ],
-});
-assert(team instanceof mod.Team, "team should be a Team instance");
-assert(team.lead instanceof mod.User, "team.lead should be a User instance");
-assert(
-  team.lead.greet() === "hi Kim",
-  "prototype method should work, got: " + team.lead.greet(),
-);
-assert(team.members[0] instanceof mod.User, "team.members[0] should be a User instance");
-assert(
-  team.members[1].greet() === "hi Park",
-  "array element prototype method should work",
-);
-
-// (2) WeakMap-guarded recursion terminates on a finite self-referential chain
-const node = mod.classifyNode({ value: 1, next: { value: 2, next: { value: 3 } } });
-assert(node instanceof mod.Node, "node should be a Node instance");
-assert(node.next instanceof mod.Node, "node.next should be a Node instance");
-assert(node.next.next.value === 3, "deep recursion should preserve the leaf value");
-
-// (2b) a TRUE self-cycle rebuilds as a cyclic instance graph: the WeakMap-
-// registered allocator must be the prototyped instance, else either instanceof
-// fails or the back-reference does not close the cycle.
-const cyclic = { value: 7 };
-cyclic.next = cyclic;
-const rebuilt = mod.classifyNode(cyclic);
-assert(rebuilt instanceof mod.Node, "cyclic node should be a Node instance");
-assert(rebuilt.next === rebuilt, "self-cycle should rebuild as a self-reference");
-assert(rebuilt.value === 7, "cyclic node value should be preserved");
-
-// (3) assertClassify throws on invalid input
-let threw = false;
-try {
-  mod.assertClassifyUser({ id: "not-a-number", name: "x" });
-} catch (e) {
-  threw = true;
-}
-assert(threw, "assertClassifyUser should throw on invalid input");
-assert(
-  mod.assertClassifyUser({ id: 9, name: "Han" }) instanceof mod.User,
-  "assertClassifyUser should return a User instance on valid input",
-);
-
-// (4) validateClassify success / failure
-const ok = mod.validateClassifyUser({ id: 5, name: "Choi" });
-assert(ok.success === true, "validateClassifyUser should succeed on valid input");
-assert(ok.data instanceof mod.User, "validateClassifyUser data should be a User instance");
-const bad = mod.validateClassifyUser({ id: "nope" });
-assert(bad.success === false, "validateClassifyUser should fail on invalid input");
-assert(
-  Array.isArray(bad.errors) && bad.errors.length > 0,
-  "validateClassifyUser failure should populate errors",
-);
-`