typia 13.0.1-dev.20260703.1 → 13.0.2

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

@@ -1,519 +1,519 @@
-package main
-
-import (
-  "os"
-  "os/exec"
-  "path/filepath"
-  "strings"
-  "testing"
-)
-
-// TestPlainClassifyStrategyEdgesTransform covers two construction-strategy edges:
-//   - an ABSTRACT class must FIELD-COPY (a runtime `new AbstractClass(seed)` throws
-//     "Cannot create an instance of an abstract class"), and
-//   - a TUPLE-typed rest parameter `constructor(...args: [Seed, number?])` must
-//     build via `new` with the first tuple element as the seed (matching
-//     Classifiable's `[infer P, ...Rest]` rule).
-func TestPlainClassifyStrategyEdgesTransform(t *testing.T) {
-  project := plainClassifyStrategyEdgesProject(t)
-  out, errText, code := ttscTypiaTestCapture(func() int {
-    return runTransform([]string{
-      "--cwd", project,
-      "--tsconfig", "tsconfig.json",
-      "--file", "src/main.ts",
-      "--output", "js",
-    })
-  })
-  if code != 0 {
-    t.Fatalf("classify strategy-edges transform failed: code=%d stderr=\n%s", code, errText)
-  }
-  // the abstract class must NOT be constructed with `new Shape(`
-  if strings.Contains(out, "new Shape(") {
-    t.Fatalf("an abstract class must field-copy, never `new Shape(seed)`:\n%s", out)
-  }
-  if !strings.Contains(out, "Object.create(Shape.prototype)") {
-    t.Fatalf("the abstract class should field-copy via Object.create(Shape.prototype):\n%s", out)
-  }
-  // the tuple-rest ctor must build via `new Pair(`
-  if !strings.Contains(out, "new Pair(") {
-    t.Fatalf("the tuple-rest constructor should build via new Pair(seed):\n%s", out)
-  }
-  plainClassifyStrategyEdgesRun(t, project, out)
-}
-
-// TestPlainClassifyPrivateFieldRejected verifies that a class carrying ES
-// `#private` fields is REJECTED at a field-copied position (a nested class), at
-// transform time, rather than emitting field-copy code whose prototype methods
-// throw "Cannot read private member" at runtime.
-func TestPlainClassifyPrivateFieldRejected(t *testing.T) {
-  project := plainClassifyPrivateProject(t)
-  // Project mode (no --file/--output js): runTransformProject reports typia
-  // transform diagnostics and exits non-zero, the established pattern for
-  // asserting a transform-time rejection (see compare_equal_cover).
-  out, errText, code := ttscTypiaTestCapture(func() int {
-    return runTransform([]string{
-      "--cwd", project,
-      "--tsconfig", "tsconfig.json",
-    })
-  })
-  if code == 0 {
-    t.Fatalf("a nested #private-field class must be rejected at transform time, but the transform succeeded\nstdout=%s\nstderr=%s", out, errText)
-  }
-  if !strings.Contains(out, "typia transform error") {
-    t.Fatalf("the #private rejection diagnostic is missing:\nstdout=%s\nstderr=%s", out, errText)
-  }
-}
-
-func plainClassifyStrategyEdgesProject(t *testing.T) string {
-  t.Helper()
-  return plainClassifyWriteProject(t, "plain-classify-strategy-", plainClassifyStrategyEdgesSource)
-}
-
-func plainClassifyPrivateProject(t *testing.T) string {
-  t.Helper()
-  return plainClassifyWriteProject(t, "plain-classify-private-", plainClassifyPrivateSource)
-}
-
-// plainClassifyWriteProject stages a one-file fixture project reusing the
-// from/new tsconfig, returning the project dir.
-func plainClassifyWriteProject(t *testing.T, prefix string, source string) 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, prefix)
-  if err != nil {
-    t.Fatalf("create temp fixture: %v", err)
-  }
-  t.Cleanup(func() { _ = os.RemoveAll(dir) })
-  src := filepath.Join(dir, "src")
-  if err := os.MkdirAll(src, 0o755); err != nil {
-    t.Fatalf("mkdir fixture src: %v", err)
-  }
-  if err := os.WriteFile(filepath.Join(dir, "tsconfig.json"), []byte(plainClassifyFromNewTSConfig), 0o644); err != nil {
-    t.Fatalf("write tsconfig: %v", err)
-  }
-  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(source), 0o644); err != nil {
-    t.Fatalf("write source: %v", err)
-  }
-  return dir
-}
-
-func plainClassifyStrategyEdgesRun(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(plainClassifyStrategyEdgesRunner), 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 strategy-edges runtime cases failed: %v\n%s", err, output)
-  }
-}
-
-const plainClassifyStrategyEdgesSource = `import typia from "typia";
-
-// ABSTRACT class: typeof Shape has only an ` + "`abstract new`" + ` signature, which is
-// not runtime-newable, so classify must FIELD-COPY the instance shape.
-export abstract class Shape {
-  kind!: string;
-  describe(): string {
-    return "shape:" + this.kind;
-  }
-}
-
-// TUPLE-rest constructor: the seed is the FIRST tuple element { a; b }.
-export class Pair {
-  a!: number;
-  b!: number;
-  constructor(...args: [{ a: number; b: number }, number?]) {
-    this.a = args[0].a;
-    this.b = args[0].b;
-  }
-  sum(): number {
-    return this.a + this.b;
-  }
-}
-
-export const buildShape = typia.plain.createClassify<typeof Shape>();
-export const buildPair = typia.plain.createClassify<typeof Pair>();
-`
-
-const plainClassifyStrategyEdgesRunner = `const mod = require("./main.cjs");
-
-const assert = (cond, msg) => {
-  if (!cond) throw new Error(msg);
-};
-
-// abstract class field-copies into a real instance with a working prototype method
-const sh = mod.buildShape({ kind: "circle" });
-assert(sh instanceof mod.Shape, "abstract class should field-copy into a Shape instance");
-assert(sh.describe() === "shape:circle", "abstract class prototype method should work, got: " + sh.describe());
-
-// tuple-rest ctor builds via new with the first tuple element as the seed
-const pr = mod.buildPair({ a: 3, b: 4 });
-assert(pr instanceof mod.Pair, "tuple-rest ctor should build a Pair instance");
-assert(pr.sum() === 7, "tuple-rest construction should reconstruct, got: " + pr.sum());
-`
-
-const plainClassifyPrivateSource = `import typia from "typia";
-
-// A class with an ES #private field — its private slot is installed only by the
-// constructor, so a field-copy (Object.create + assign) cannot restore it.
-class Secret {
-  #token!: string;
-  reveal(): string {
-    return this.#token;
-  }
-}
-
-// Holder nests Secret at a field-copied position, so classify cannot soundly
-// reconstruct it and must reject at transform time.
-export class Holder {
-  secret!: Secret;
-}
-
-export const buildHolder = typia.plain.createClassify<Holder>();
-`
-
-// TestPlainClassifyStaticPrivateAllowed verifies that a class whose ONLY #private
-// member is STATIC is NOT rejected — a static `#x` lives on the constructor, not
-// on instances, so field-copy (Object.create(prototype) + assign) still yields a
-// sound instance.
-func TestPlainClassifyStaticPrivateAllowed(t *testing.T) {
-  project := plainClassifyWriteProject(t, "plain-classify-staticpriv-", plainClassifyStaticPrivateSource)
-  out, errText, code := ttscTypiaTestCapture(func() int {
-    return runTransform([]string{
-      "--cwd", project,
-      "--tsconfig", "tsconfig.json",
-      "--file", "src/main.ts",
-      "--output", "js",
-    })
-  })
-  if code != 0 {
-    t.Fatalf("a class with only a STATIC #private member must field-copy, not be rejected: code=%d\n%s", code, errText)
-  }
-  if !strings.Contains(out, "Object.create(Counter.prototype)") {
-    t.Fatalf("the static-#private class should field-copy onto Counter.prototype:\n%s", out)
-  }
-}
-
-// TestPlainClassifySelfRefPrivateRejected verifies that a SELF-REFERENTIAL
-// #private class is rejected: construction is root-only, so its nested
-// self-occurrences are field-copied (losing the #private slots), which the guard
-// must reject rather than emit code that throws at runtime.
-func TestPlainClassifySelfRefPrivateRejected(t *testing.T) {
-  project := plainClassifyWriteProject(t, "plain-classify-selfrefpriv-", plainClassifySelfRefPrivateSource)
-  out, errText, code := ttscTypiaTestCapture(func() int {
-    return runTransform([]string{
-      "--cwd", project,
-      "--tsconfig", "tsconfig.json",
-    })
-  })
-  if code == 0 {
-    t.Fatalf("a self-referential #private class field-copies its nested occurrences, so it must be rejected; the transform succeeded\nstdout=%s\nstderr=%s", out, errText)
-  }
-  if !strings.Contains(out, "typia transform error") {
-    t.Fatalf("the self-ref #private rejection diagnostic is missing:\nstdout=%s\nstderr=%s", out, errText)
-  }
-}
-
-const plainClassifyStaticPrivateSource = `import typia from "typia";
-
-// Only a STATIC #private member — it lives on the constructor, not instances, so
-// field-copy reconstructs a sound instance and classify must NOT reject it.
-export class Counter {
-  value = 0;
-  static #total = 0;
-  bump(): number {
-    this.value += 1;
-    Counter.#total += 1;
-    return this.value;
-  }
-}
-
-export const build = typia.plain.createClassify<Counter>();
-`
-
-const plainClassifySelfRefPrivateSource = `import typia from "typia";
-
-// A self-referential class with an INSTANCE #private field, built via new at the
-// root. Its nested self-occurrences (next) are field-copied — construction is
-// root-only — so the #private slot would be lost there: classify must reject.
-export class Node {
-  #id!: string;
-  next: Node | null = null;
-  constructor(seed: { id: string; next: Node | null }) {
-    this.#id = seed.id;
-    this.next = seed.next;
-  }
-  id(): string {
-    return this.#id;
-  }
-}
-
-export const build = typia.plain.createClassify<typeof Node>();
-`
-
-// TestPlainClassifyUnboundAnonymousClass verifies an anonymous class expression
-// with NO enclosing const binding field-copies as a plain {} instead of emitting
-// `Object.create(__class.prototype)` — the binder-internal __class name is not a
-// usable runtime binding (it would throw ReferenceError).
-func TestPlainClassifyUnboundAnonymousClass(t *testing.T) {
-  project := plainClassifyWriteProject(t, "plain-classify-anon-", plainClassifyUnboundAnonSource)
-  out, errText, code := ttscTypiaTestCapture(func() int {
-    return runTransform([]string{
-      "--cwd", project,
-      "--tsconfig", "tsconfig.json",
-      "--file", "src/main.ts",
-      "--output", "js",
-    })
-  })
-  if code != 0 {
-    t.Fatalf("unbound anonymous class transform failed: code=%d\n%s", code, errText)
-  }
-  if strings.Contains(out, "__class") {
-    t.Fatalf("an unbound anonymous class must NOT leak the binder-internal __class name:\n%s", out)
-  }
-  plainClassifyRunNode(t, project, out, plainClassifyUnboundAnonRunner)
-}
-
-// plainClassifyRunNode writes the rewritten module + a custom runner and runs it.
-func plainClassifyRunNode(t *testing.T, project string, js string, runnerSrc 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(runnerSrc), 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("runtime cases failed: %v\n%s", err, output)
-  }
-}
-
-const plainClassifyUnboundAnonSource = `import typia from "typia";
-
-// An anonymous class expression with NO enclosing const binding (returned from a
-// factory). Its binder-internal name is not a usable runtime binding, so classify
-// must field-copy a plain {} rather than reference that unbound name.
-const factory = () =>
-  class {
-    x!: number;
-    label(): string {
-      return "x=" + this.x;
-    }
-  };
-export type Widget = InstanceType<ReturnType<typeof factory>>;
-
-export const build = typia.plain.createClassify<Widget>();
-`
-
-// TestPlainClassifyInheritedPrivateRejected verifies that a class extending a
-// #private-bearing base is rejected: field-copying the subclass never installs
-// the inherited #private slot, so its prototype methods would throw at runtime.
-func TestPlainClassifyInheritedPrivateRejected(t *testing.T) {
-  project := plainClassifyWriteProject(t, "plain-classify-inheritedpriv-", plainClassifyInheritedPrivateSource)
-  out, errText, code := ttscTypiaTestCapture(func() int {
-    return runTransform([]string{
-      "--cwd", project,
-      "--tsconfig", "tsconfig.json",
-    })
-  })
-  if code == 0 {
-    t.Fatalf("a class extending a #private-bearing base must be rejected; the transform succeeded\nstdout=%s\nstderr=%s", out, errText)
-  }
-  if !strings.Contains(out, "typia transform error") {
-    t.Fatalf("the inherited-#private rejection diagnostic is missing:\nstdout=%s\nstderr=%s", out, errText)
-  }
-}
-
-const plainClassifyInheritedPrivateSource = `import typia from "typia";
-
-// A base class with an INSTANCE #private field; the subclass adds only public
-// data. Field-copying the subclass never installs the inherited #private slot, so
-// classify must reject it — the prototype chain matters.
-class Base {
-  #secret = 0;
-  bump(): number {
-    this.#secret += 1;
-    return this.#secret;
-  }
-}
-export class Derived extends Base {
-  name!: string;
-}
-
-export const build = typia.plain.createClassify<Derived>();
-`
-
-const plainClassifyUnboundAnonRunner = `const mod = require("./main.cjs");
-
-const assert = (cond, msg) => {
-  if (!cond) throw new Error(msg);
-};
-
-// must NOT throw "ReferenceError: __class is not defined"; field-copies the data
-const w = mod.build({ x: 5 });
-assert(w && w.x === 5, "unbound anonymous class should field-copy its data, got: " + JSON.stringify(w));
-`
-
-// TestPlainClassifyNamedInterfaceFieldCopy verifies that a named INTERFACE field
-// is field-copied as a plain {} — an interface has no runtime value, so emitting
-// Object.create(<Interface>.prototype) would throw ReferenceError.
-func TestPlainClassifyNamedInterfaceFieldCopy(t *testing.T) {
-  project := plainClassifyWriteProject(t, "plain-classify-iface-", plainClassifyInterfaceSource)
-  out, errText, code := ttscTypiaTestCapture(func() int {
-    return runTransform([]string{"--cwd", project, "--tsconfig", "tsconfig.json", "--file", "src/main.ts", "--output", "js"})
-  })
-  if code != 0 {
-    t.Fatalf("named-interface field transform failed: code=%d\n%s", code, errText)
-  }
-  if strings.Contains(out, "Object.create(Animal.prototype)") {
-    t.Fatalf("a named interface must NOT be field-copied via Object.create(Animal.prototype):\n%s", out)
-  }
-  if !strings.Contains(out, "Object.create(Zoo.prototype)") {
-    t.Fatalf("the enclosing class should still field-copy onto Zoo.prototype:\n%s", out)
-  }
-  plainClassifyRunNode(t, project, out, plainClassifyInterfaceRunner)
-}
-
-// TestPlainClassifyRecursiveAnonymousObject verifies a RECURSIVE anonymous object
-// type (whose IsLiteral() is false) field-copies as {} rather than emitting
-// Object.create(__type.prototype) (a ReferenceError).
-func TestPlainClassifyRecursiveAnonymousObject(t *testing.T) {
-  project := plainClassifyWriteProject(t, "plain-classify-recanon-", plainClassifyRecAnonSource)
-  out, errText, code := ttscTypiaTestCapture(func() int {
-    return runTransform([]string{"--cwd", project, "--tsconfig", "tsconfig.json", "--file", "src/main.ts", "--output", "js"})
-  })
-  if code != 0 {
-    t.Fatalf("recursive-anonymous-object transform failed: code=%d\n%s", code, errText)
-  }
-  if strings.Contains(out, "__type") {
-    t.Fatalf("a recursive anonymous object must NOT leak the binder-internal __type name:\n%s", out)
-  }
-  plainClassifyRunNode(t, project, out, plainClassifyRecAnonRunner)
-}
-
-// TestPlainClassifyGenericPrivateRejected verifies that a GENERIC class with its
-// own instance #private is rejected — its instantiation Gen<string> is a bare
-// TypeReference, but the member scan resolves the class declaration so the
-// #private is still detected.
-func TestPlainClassifyGenericPrivateRejected(t *testing.T) {
-  project := plainClassifyWriteProject(t, "plain-classify-genericpriv-", plainClassifyGenericPrivateSource)
-  out, errText, code := ttscTypiaTestCapture(func() int {
-    return runTransform([]string{"--cwd", project, "--tsconfig", "tsconfig.json"})
-  })
-  if code == 0 {
-    t.Fatalf("a generic class with its own #private must be rejected; the transform succeeded\nstdout=%s\nstderr=%s", out, errText)
-  }
-  if !strings.Contains(out, "typia transform error") {
-    t.Fatalf("the generic-#private rejection diagnostic is missing:\nstdout=%s\nstderr=%s", out, errText)
-  }
-}
-
-const plainClassifyInterfaceSource = `import typia from "typia";
-
-// A named INTERFACE — a type-only name with no runtime value.
-export interface Animal {
-  name: string;
-  legs: number;
-}
-
-// Zoo is a real class (field-copies onto its prototype); its animal field is
-// the interface, which must field-copy as a plain {}.
-export class Zoo {
-  label!: string;
-  animal!: Animal;
-  describe(): string {
-    return this.label + ":" + this.animal.name;
-  }
-}
-
-export const build = typia.plain.createClassify<Zoo>();
-`
-
-const plainClassifyInterfaceRunner = `const mod = require("./main.cjs");
-
-const assert = (cond, msg) => {
-  if (!cond) throw new Error(msg);
-};
-
-const z = mod.build({ label: "z", animal: { name: "fox", legs: 4 } });
-assert(z instanceof mod.Zoo, "Zoo should be a class instance");
-assert(z.describe() === "z:fox", "Zoo method should work, got: " + z.describe());
-assert(z.animal && z.animal.name === "fox" && z.animal.legs === 4, "interface field is a plain object");
-`
-
-const plainClassifyRecAnonSource = `import typia from "typia";
-
-// A RECURSIVE anonymous object type alias — no runtime value, IsLiteral() is
-// false because it is recursive, so classify must still field-copy a plain {}.
-export type Rec = { value: number; self: Rec | null };
-
-export const build = typia.plain.createClassify<Rec>();
-`
-
-const plainClassifyRecAnonRunner = `const mod = require("./main.cjs");
-
-const assert = (cond, msg) => {
-  if (!cond) throw new Error(msg);
-};
-
-// must NOT throw "ReferenceError: __type is not defined"
-const r = mod.build({ value: 1, self: { value: 2, self: null } });
-assert(r && r.value === 1, "recursive anonymous object should field-copy, got: " + JSON.stringify(r));
-assert(r.self && r.self.value === 2 && r.self.self === null, "nested recursion should field-copy");
-`
-
-const plainClassifyGenericPrivateSource = `import typia from "typia";
-
-// A GENERIC class with its OWN instance #private. classify<Gen<string>> emplaces
-// the Gen<string> instance (a bare TypeReference), but the member scan resolves
-// Gen's declaration, so the own #private is detected and the class is rejected.
-export class Gen<T> {
-  #secret = 0;
-  value!: T;
-  bump(): number {
-    this.#secret += 1;
-    return this.#secret;
-  }
-}
-
-export const build = typia.plain.createClassify<Gen<string>>();
-`
+package main
+
+import (
+  "os"
+  "os/exec"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestPlainClassifyStrategyEdgesTransform covers two construction-strategy edges:
+//   - an ABSTRACT class must FIELD-COPY (a runtime `new AbstractClass(seed)` throws
+//     "Cannot create an instance of an abstract class"), and
+//   - a TUPLE-typed rest parameter `constructor(...args: [Seed, number?])` must
+//     build via `new` with the first tuple element as the seed (matching
+//     Classifiable's `[infer P, ...Rest]` rule).
+func TestPlainClassifyStrategyEdgesTransform(t *testing.T) {
+  project := plainClassifyStrategyEdgesProject(t)
+  out, errText, code := ttscTypiaTestCapture(func() int {
+    return runTransform([]string{
+      "--cwd", project,
+      "--tsconfig", "tsconfig.json",
+      "--file", "src/main.ts",
+      "--output", "js",
+    })
+  })
+  if code != 0 {
+    t.Fatalf("classify strategy-edges transform failed: code=%d stderr=\n%s", code, errText)
+  }
+  // the abstract class must NOT be constructed with `new Shape(`
+  if strings.Contains(out, "new Shape(") {
+    t.Fatalf("an abstract class must field-copy, never `new Shape(seed)`:\n%s", out)
+  }
+  if !strings.Contains(out, "Object.create(Shape.prototype)") {
+    t.Fatalf("the abstract class should field-copy via Object.create(Shape.prototype):\n%s", out)
+  }
+  // the tuple-rest ctor must build via `new Pair(`
+  if !strings.Contains(out, "new Pair(") {
+    t.Fatalf("the tuple-rest constructor should build via new Pair(seed):\n%s", out)
+  }
+  plainClassifyStrategyEdgesRun(t, project, out)
+}
+
+// TestPlainClassifyPrivateFieldRejected verifies that a class carrying ES
+// `#private` fields is REJECTED at a field-copied position (a nested class), at
+// transform time, rather than emitting field-copy code whose prototype methods
+// throw "Cannot read private member" at runtime.
+func TestPlainClassifyPrivateFieldRejected(t *testing.T) {
+  project := plainClassifyPrivateProject(t)
+  // Project mode (no --file/--output js): runTransformProject reports typia
+  // transform diagnostics and exits non-zero, the established pattern for
+  // asserting a transform-time rejection (see compare_equal_cover).
+  out, errText, code := ttscTypiaTestCapture(func() int {
+    return runTransform([]string{
+      "--cwd", project,
+      "--tsconfig", "tsconfig.json",
+    })
+  })
+  if code == 0 {
+    t.Fatalf("a nested #private-field class must be rejected at transform time, but the transform succeeded\nstdout=%s\nstderr=%s", out, errText)
+  }
+  if !strings.Contains(out, "typia transform error") {
+    t.Fatalf("the #private rejection diagnostic is missing:\nstdout=%s\nstderr=%s", out, errText)
+  }
+}
+
+func plainClassifyStrategyEdgesProject(t *testing.T) string {
+  t.Helper()
+  return plainClassifyWriteProject(t, "plain-classify-strategy-", plainClassifyStrategyEdgesSource)
+}
+
+func plainClassifyPrivateProject(t *testing.T) string {
+  t.Helper()
+  return plainClassifyWriteProject(t, "plain-classify-private-", plainClassifyPrivateSource)
+}
+
+// plainClassifyWriteProject stages a one-file fixture project reusing the
+// from/new tsconfig, returning the project dir.
+func plainClassifyWriteProject(t *testing.T, prefix string, source string) 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, prefix)
+  if err != nil {
+    t.Fatalf("create temp fixture: %v", err)
+  }
+  t.Cleanup(func() { _ = os.RemoveAll(dir) })
+  src := filepath.Join(dir, "src")
+  if err := os.MkdirAll(src, 0o755); err != nil {
+    t.Fatalf("mkdir fixture src: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(dir, "tsconfig.json"), []byte(plainClassifyFromNewTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(source), 0o644); err != nil {
+    t.Fatalf("write source: %v", err)
+  }
+  return dir
+}
+
+func plainClassifyStrategyEdgesRun(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(plainClassifyStrategyEdgesRunner), 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 strategy-edges runtime cases failed: %v\n%s", err, output)
+  }
+}
+
+const plainClassifyStrategyEdgesSource = `import typia from "typia";
+
+// ABSTRACT class: typeof Shape has only an ` + "`abstract new`" + ` signature, which is
+// not runtime-newable, so classify must FIELD-COPY the instance shape.
+export abstract class Shape {
+  kind!: string;
+  describe(): string {
+    return "shape:" + this.kind;
+  }
+}
+
+// TUPLE-rest constructor: the seed is the FIRST tuple element { a; b }.
+export class Pair {
+  a!: number;
+  b!: number;
+  constructor(...args: [{ a: number; b: number }, number?]) {
+    this.a = args[0].a;
+    this.b = args[0].b;
+  }
+  sum(): number {
+    return this.a + this.b;
+  }
+}
+
+export const buildShape = typia.plain.createClassify<typeof Shape>();
+export const buildPair = typia.plain.createClassify<typeof Pair>();
+`
+
+const plainClassifyStrategyEdgesRunner = `const mod = require("./main.cjs");
+
+const assert = (cond, msg) => {
+  if (!cond) throw new Error(msg);
+};
+
+// abstract class field-copies into a real instance with a working prototype method
+const sh = mod.buildShape({ kind: "circle" });
+assert(sh instanceof mod.Shape, "abstract class should field-copy into a Shape instance");
+assert(sh.describe() === "shape:circle", "abstract class prototype method should work, got: " + sh.describe());
+
+// tuple-rest ctor builds via new with the first tuple element as the seed
+const pr = mod.buildPair({ a: 3, b: 4 });
+assert(pr instanceof mod.Pair, "tuple-rest ctor should build a Pair instance");
+assert(pr.sum() === 7, "tuple-rest construction should reconstruct, got: " + pr.sum());
+`
+
+const plainClassifyPrivateSource = `import typia from "typia";
+
+// A class with an ES #private field — its private slot is installed only by the
+// constructor, so a field-copy (Object.create + assign) cannot restore it.
+class Secret {
+  #token!: string;
+  reveal(): string {
+    return this.#token;
+  }
+}
+
+// Holder nests Secret at a field-copied position, so classify cannot soundly
+// reconstruct it and must reject at transform time.
+export class Holder {
+  secret!: Secret;
+}
+
+export const buildHolder = typia.plain.createClassify<Holder>();
+`
+
+// TestPlainClassifyStaticPrivateAllowed verifies that a class whose ONLY #private
+// member is STATIC is NOT rejected — a static `#x` lives on the constructor, not
+// on instances, so field-copy (Object.create(prototype) + assign) still yields a
+// sound instance.
+func TestPlainClassifyStaticPrivateAllowed(t *testing.T) {
+  project := plainClassifyWriteProject(t, "plain-classify-staticpriv-", plainClassifyStaticPrivateSource)
+  out, errText, code := ttscTypiaTestCapture(func() int {
+    return runTransform([]string{
+      "--cwd", project,
+      "--tsconfig", "tsconfig.json",
+      "--file", "src/main.ts",
+      "--output", "js",
+    })
+  })
+  if code != 0 {
+    t.Fatalf("a class with only a STATIC #private member must field-copy, not be rejected: code=%d\n%s", code, errText)
+  }
+  if !strings.Contains(out, "Object.create(Counter.prototype)") {
+    t.Fatalf("the static-#private class should field-copy onto Counter.prototype:\n%s", out)
+  }
+}
+
+// TestPlainClassifySelfRefPrivateRejected verifies that a SELF-REFERENTIAL
+// #private class is rejected: construction is root-only, so its nested
+// self-occurrences are field-copied (losing the #private slots), which the guard
+// must reject rather than emit code that throws at runtime.
+func TestPlainClassifySelfRefPrivateRejected(t *testing.T) {
+  project := plainClassifyWriteProject(t, "plain-classify-selfrefpriv-", plainClassifySelfRefPrivateSource)
+  out, errText, code := ttscTypiaTestCapture(func() int {
+    return runTransform([]string{
+      "--cwd", project,
+      "--tsconfig", "tsconfig.json",
+    })
+  })
+  if code == 0 {
+    t.Fatalf("a self-referential #private class field-copies its nested occurrences, so it must be rejected; the transform succeeded\nstdout=%s\nstderr=%s", out, errText)
+  }
+  if !strings.Contains(out, "typia transform error") {
+    t.Fatalf("the self-ref #private rejection diagnostic is missing:\nstdout=%s\nstderr=%s", out, errText)
+  }
+}
+
+const plainClassifyStaticPrivateSource = `import typia from "typia";
+
+// Only a STATIC #private member — it lives on the constructor, not instances, so
+// field-copy reconstructs a sound instance and classify must NOT reject it.
+export class Counter {
+  value = 0;
+  static #total = 0;
+  bump(): number {
+    this.value += 1;
+    Counter.#total += 1;
+    return this.value;
+  }
+}
+
+export const build = typia.plain.createClassify<Counter>();
+`
+
+const plainClassifySelfRefPrivateSource = `import typia from "typia";
+
+// A self-referential class with an INSTANCE #private field, built via new at the
+// root. Its nested self-occurrences (next) are field-copied — construction is
+// root-only — so the #private slot would be lost there: classify must reject.
+export class Node {
+  #id!: string;
+  next: Node | null = null;
+  constructor(seed: { id: string; next: Node | null }) {
+    this.#id = seed.id;
+    this.next = seed.next;
+  }
+  id(): string {
+    return this.#id;
+  }
+}
+
+export const build = typia.plain.createClassify<typeof Node>();
+`
+
+// TestPlainClassifyUnboundAnonymousClass verifies an anonymous class expression
+// with NO enclosing const binding field-copies as a plain {} instead of emitting
+// `Object.create(__class.prototype)` — the binder-internal __class name is not a
+// usable runtime binding (it would throw ReferenceError).
+func TestPlainClassifyUnboundAnonymousClass(t *testing.T) {
+  project := plainClassifyWriteProject(t, "plain-classify-anon-", plainClassifyUnboundAnonSource)
+  out, errText, code := ttscTypiaTestCapture(func() int {
+    return runTransform([]string{
+      "--cwd", project,
+      "--tsconfig", "tsconfig.json",
+      "--file", "src/main.ts",
+      "--output", "js",
+    })
+  })
+  if code != 0 {
+    t.Fatalf("unbound anonymous class transform failed: code=%d\n%s", code, errText)
+  }
+  if strings.Contains(out, "__class") {
+    t.Fatalf("an unbound anonymous class must NOT leak the binder-internal __class name:\n%s", out)
+  }
+  plainClassifyRunNode(t, project, out, plainClassifyUnboundAnonRunner)
+}
+
+// plainClassifyRunNode writes the rewritten module + a custom runner and runs it.
+func plainClassifyRunNode(t *testing.T, project string, js string, runnerSrc 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(runnerSrc), 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("runtime cases failed: %v\n%s", err, output)
+  }
+}
+
+const plainClassifyUnboundAnonSource = `import typia from "typia";
+
+// An anonymous class expression with NO enclosing const binding (returned from a
+// factory). Its binder-internal name is not a usable runtime binding, so classify
+// must field-copy a plain {} rather than reference that unbound name.
+const factory = () =>
+  class {
+    x!: number;
+    label(): string {
+      return "x=" + this.x;
+    }
+  };
+export type Widget = InstanceType<ReturnType<typeof factory>>;
+
+export const build = typia.plain.createClassify<Widget>();
+`
+
+// TestPlainClassifyInheritedPrivateRejected verifies that a class extending a
+// #private-bearing base is rejected: field-copying the subclass never installs
+// the inherited #private slot, so its prototype methods would throw at runtime.
+func TestPlainClassifyInheritedPrivateRejected(t *testing.T) {
+  project := plainClassifyWriteProject(t, "plain-classify-inheritedpriv-", plainClassifyInheritedPrivateSource)
+  out, errText, code := ttscTypiaTestCapture(func() int {
+    return runTransform([]string{
+      "--cwd", project,
+      "--tsconfig", "tsconfig.json",
+    })
+  })
+  if code == 0 {
+    t.Fatalf("a class extending a #private-bearing base must be rejected; the transform succeeded\nstdout=%s\nstderr=%s", out, errText)
+  }
+  if !strings.Contains(out, "typia transform error") {
+    t.Fatalf("the inherited-#private rejection diagnostic is missing:\nstdout=%s\nstderr=%s", out, errText)
+  }
+}
+
+const plainClassifyInheritedPrivateSource = `import typia from "typia";
+
+// A base class with an INSTANCE #private field; the subclass adds only public
+// data. Field-copying the subclass never installs the inherited #private slot, so
+// classify must reject it — the prototype chain matters.
+class Base {
+  #secret = 0;
+  bump(): number {
+    this.#secret += 1;
+    return this.#secret;
+  }
+}
+export class Derived extends Base {
+  name!: string;
+}
+
+export const build = typia.plain.createClassify<Derived>();
+`
+
+const plainClassifyUnboundAnonRunner = `const mod = require("./main.cjs");
+
+const assert = (cond, msg) => {
+  if (!cond) throw new Error(msg);
+};
+
+// must NOT throw "ReferenceError: __class is not defined"; field-copies the data
+const w = mod.build({ x: 5 });
+assert(w && w.x === 5, "unbound anonymous class should field-copy its data, got: " + JSON.stringify(w));
+`
+
+// TestPlainClassifyNamedInterfaceFieldCopy verifies that a named INTERFACE field
+// is field-copied as a plain {} — an interface has no runtime value, so emitting
+// Object.create(<Interface>.prototype) would throw ReferenceError.
+func TestPlainClassifyNamedInterfaceFieldCopy(t *testing.T) {
+  project := plainClassifyWriteProject(t, "plain-classify-iface-", plainClassifyInterfaceSource)
+  out, errText, code := ttscTypiaTestCapture(func() int {
+    return runTransform([]string{"--cwd", project, "--tsconfig", "tsconfig.json", "--file", "src/main.ts", "--output", "js"})
+  })
+  if code != 0 {
+    t.Fatalf("named-interface field transform failed: code=%d\n%s", code, errText)
+  }
+  if strings.Contains(out, "Object.create(Animal.prototype)") {
+    t.Fatalf("a named interface must NOT be field-copied via Object.create(Animal.prototype):\n%s", out)
+  }
+  if !strings.Contains(out, "Object.create(Zoo.prototype)") {
+    t.Fatalf("the enclosing class should still field-copy onto Zoo.prototype:\n%s", out)
+  }
+  plainClassifyRunNode(t, project, out, plainClassifyInterfaceRunner)
+}
+
+// TestPlainClassifyRecursiveAnonymousObject verifies a RECURSIVE anonymous object
+// type (whose IsLiteral() is false) field-copies as {} rather than emitting
+// Object.create(__type.prototype) (a ReferenceError).
+func TestPlainClassifyRecursiveAnonymousObject(t *testing.T) {
+  project := plainClassifyWriteProject(t, "plain-classify-recanon-", plainClassifyRecAnonSource)
+  out, errText, code := ttscTypiaTestCapture(func() int {
+    return runTransform([]string{"--cwd", project, "--tsconfig", "tsconfig.json", "--file", "src/main.ts", "--output", "js"})
+  })
+  if code != 0 {
+    t.Fatalf("recursive-anonymous-object transform failed: code=%d\n%s", code, errText)
+  }
+  if strings.Contains(out, "__type") {
+    t.Fatalf("a recursive anonymous object must NOT leak the binder-internal __type name:\n%s", out)
+  }
+  plainClassifyRunNode(t, project, out, plainClassifyRecAnonRunner)
+}
+
+// TestPlainClassifyGenericPrivateRejected verifies that a GENERIC class with its
+// own instance #private is rejected — its instantiation Gen<string> is a bare
+// TypeReference, but the member scan resolves the class declaration so the
+// #private is still detected.
+func TestPlainClassifyGenericPrivateRejected(t *testing.T) {
+  project := plainClassifyWriteProject(t, "plain-classify-genericpriv-", plainClassifyGenericPrivateSource)
+  out, errText, code := ttscTypiaTestCapture(func() int {
+    return runTransform([]string{"--cwd", project, "--tsconfig", "tsconfig.json"})
+  })
+  if code == 0 {
+    t.Fatalf("a generic class with its own #private must be rejected; the transform succeeded\nstdout=%s\nstderr=%s", out, errText)
+  }
+  if !strings.Contains(out, "typia transform error") {
+    t.Fatalf("the generic-#private rejection diagnostic is missing:\nstdout=%s\nstderr=%s", out, errText)
+  }
+}
+
+const plainClassifyInterfaceSource = `import typia from "typia";
+
+// A named INTERFACE — a type-only name with no runtime value.
+export interface Animal {
+  name: string;
+  legs: number;
+}
+
+// Zoo is a real class (field-copies onto its prototype); its animal field is
+// the interface, which must field-copy as a plain {}.
+export class Zoo {
+  label!: string;
+  animal!: Animal;
+  describe(): string {
+    return this.label + ":" + this.animal.name;
+  }
+}
+
+export const build = typia.plain.createClassify<Zoo>();
+`
+
+const plainClassifyInterfaceRunner = `const mod = require("./main.cjs");
+
+const assert = (cond, msg) => {
+  if (!cond) throw new Error(msg);
+};
+
+const z = mod.build({ label: "z", animal: { name: "fox", legs: 4 } });
+assert(z instanceof mod.Zoo, "Zoo should be a class instance");
+assert(z.describe() === "z:fox", "Zoo method should work, got: " + z.describe());
+assert(z.animal && z.animal.name === "fox" && z.animal.legs === 4, "interface field is a plain object");
+`
+
+const plainClassifyRecAnonSource = `import typia from "typia";
+
+// A RECURSIVE anonymous object type alias — no runtime value, IsLiteral() is
+// false because it is recursive, so classify must still field-copy a plain {}.
+export type Rec = { value: number; self: Rec | null };
+
+export const build = typia.plain.createClassify<Rec>();
+`
+
+const plainClassifyRecAnonRunner = `const mod = require("./main.cjs");
+
+const assert = (cond, msg) => {
+  if (!cond) throw new Error(msg);
+};
+
+// must NOT throw "ReferenceError: __type is not defined"
+const r = mod.build({ value: 1, self: { value: 2, self: null } });
+assert(r && r.value === 1, "recursive anonymous object should field-copy, got: " + JSON.stringify(r));
+assert(r.self && r.self.value === 2 && r.self.self === null, "nested recursion should field-copy");
+`
+
+const plainClassifyGenericPrivateSource = `import typia from "typia";
+
+// A GENERIC class with its OWN instance #private. classify<Gen<string>> emplaces
+// the Gen<string> instance (a bare TypeReference), but the member scan resolves
+// Gen's declaration, so the own #private is detected and the class is rejected.
+export class Gen<T> {
+  #secret = 0;
+  value!: T;
+  bump(): number {
+    this.#secret += 1;
+    return this.#secret;
+  }
+}
+
+export const build = typia.plain.createClassify<Gen<string>>();
+`