typia 15.0.0 → 15.1.0

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

@@ -2,21 +2,22 @@ package main
 
 import (
   "os"
-  "os/exec"
   "path/filepath"
   "strings"
   "testing"
 )
 
-// TestCompareEqualCoverTransform verifies type-directed structural comparison.
+// TestCompareEqualCoverTransform verifies comparison native content helpers and unsupported-type diagnostics.
 //
-// Issue #1497 adds `typia.compare.equals` and `typia.compare.cover`:
+// Structural comparison reads native content rather than object identity, while unsupported domains must diagnose instead of inventing equality. Expected native operations and rejected type categories come from the public compare contract.
 //
-//  1. Transform direct and factory calls for equal/cover.
-//  2. Execute object, partial-object, array-length, native, dynamic-key,
-//     union, and recursive pair-tracking cases.
-//  3. Reject unsupported any, function, Set, Map, WeakSet, and WeakMap types
-//     at transform time.
+// 1. Direct/factory equals and cover inputs include natives and recursive structures; unsupported any, function, Set, Map and weak collections are negative twins. Runtime comparison outcomes are not asserted here.
+// 2. Emission contains Date timestamps, RegExp source/flags, byte views and recursive pair context; helper rejection cases require unsupported any/function/collection diagnostics.
+//
+// @evidence contracts/testing.md#behavioral-verification Emission contains Date timestamps, RegExp source/flags, byte views and recursive pair context; helper rejection cases require unsupported any/function/collection diagnostics.
+// @evidence contracts/testing.md#independent-expectations Structural comparison reads native content rather than object identity, while unsupported domains must diagnose instead of inventing equality. Expected native operations and rejected type categories come from the public compare contract.
+// @evidence contracts/testing.md#distinguishing-cases Direct/factory equals and cover inputs include natives and recursive structures; unsupported any, function, Set, Map and weak collections are negative twins. Runtime comparison outcomes are not asserted here.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestCompareEqualCoverTransform 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 TestCompareEqualCoverTransform(t *testing.T) {
   project := compareEqualCoverProject(t, "compare-equal-cover-", compareEqualCoverSource)
   js := compareEqualCoverTransform(t, project)
@@ -25,24 +26,12 @@ func TestCompareEqualCoverTransform(t *testing.T) {
       t.Fatalf("compare equal/cover output is missing %q:\n%s", needle, js)
     }
   }
-  compareEqualCoverRunRuntimeCases(t, project, js)
   compareEqualCoverRejectsUnsupported(t)
 }
 
 func compareEqualCoverProject(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)
-  })
+  dir := ttscTypiaTestFixtureDirectory(t, prefix)
   src := filepath.Join(dir, "src")
   if err := os.MkdirAll(src, 0o755); err != nil {
     t.Fatalf("mkdir fixture src: %v", err)
@@ -72,33 +61,6 @@ func compareEqualCoverTransform(t *testing.T, project string) string {
   return out
 }
 
-func compareEqualCoverRunRuntimeCases(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(compareEqualCoverRuntimeRunner), 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("compare equal/cover runtime cases failed: %v\n%s", err, output)
-  }
-}
-
 func compareEqualCoverRejectsUnsupported(t *testing.T) {
   t.Helper()
   cases := []struct {
@@ -190,82 +152,3 @@ interface INode {
 export const equalNode = typia.compare.createEquals<INode>();
 export const coverNode = typia.compare.createCover<INode>();
 `
-
-const compareEqualCoverRuntimeRunner = `const mod = require("./main.cjs");
-
-const expect = (label, actual, expected) => {
-  if (actual !== expected) {
-    throw new Error(label + ": expected " + expected + ", got " + actual);
-  }
-};
-
-const user = {
-  name: "ivan",
-  age: 19,
-  address: {
-    street: "Ivanovskaya",
-    city: "Berlin",
-  },
-  tags: ["a", "b"],
-  created: new Date("2026-06-11T00:00:00.000Z"),
-  pattern: /^ivan$/gi,
-  bytes: new Uint8Array([1, 2, 3]),
-};
-const same = {
-  name: "ivan",
-  age: 19,
-  address: {
-    street: "Ivanovskaya",
-    city: "Berlin",
-  },
-  tags: ["a", "b"],
-  created: new Date("2026-06-11T00:00:00.000Z"),
-  pattern: /^ivan$/gi,
-  bytes: new Uint8Array([1, 2, 3]),
-};
-const different = {
-  ...same,
-  address: { ...same.address, city: "Seoul" },
-};
-
-expect("equal user", mod.equalUser(user, same), true);
-expect("equal user direct", mod.equalUserDirect(user, same), true);
-expect("equal nested mismatch", mod.equalUser(user, different), false);
-expect("equal regexp mismatch", mod.equalUser(user, { ...same, pattern: /^ivan$/g }), false);
-expect("equal bytes mismatch", mod.equalUser(user, { ...same, bytes: new Uint8Array([1, 2, 4]) }), false);
-expect("cover nested partial", mod.coverUser(user, { address: { city: "Berlin" } }), true);
-expect("cover direct", mod.coverUserDirect(user, { name: "ivan", bytes: new Uint8Array([1, 2, 3]) }), true);
-expect("cover nested mismatch", mod.coverUser(user, { address: { city: "Seoul" } }), false);
-expect("cover array same length", mod.coverUser(user, { tags: ["a", "b"] }), true);
-expect("cover array length mismatch", mod.coverUser(user, { tags: ["a"] }), false);
-expect("cover extra key", mod.coverUser(user, { unknown: 1 }), false);
-
-expect("dictionary equal", mod.equalDictionary({ fixed: "f", extra: "x" }, { fixed: "f", extra: "x" }), true);
-expect("dictionary equal missing key", mod.equalDictionary({ fixed: "f", extra: "x" }, { fixed: "f" }), false);
-expect("dictionary cover dynamic", mod.coverDictionary({ fixed: "f", extra: "x" }, { extra: "x" }), true);
-expect("dictionary cover dynamic mismatch", mod.coverDictionary({ fixed: "f", extra: "x" }, { extra: "y" }), false);
-
-const circle = { kind: "circle", radius: 5, nested: { label: "round" } };
-const circleSame = { kind: "circle", radius: 5, nested: { label: "round" } };
-const square = { kind: "square", size: 5, nested: { label: "round" } };
-expect("union equal same branch", mod.equalShape(circle, circleSame), true);
-expect("union equal different branch", mod.equalShape(circle, square), false);
-expect("union cover branch", mod.coverShape(circle, { kind: "circle", nested: { label: "round" } }), true);
-expect("union cover wrong branch", mod.coverShape(circle, { kind: "square" }), false);
-
-const a = { id: 1, next: null, children: [] };
-const b = { id: 1, next: null, children: [] };
-a.next = a;
-b.next = b;
-a.children.push(a);
-b.children.push(b);
-expect("recursive equal", mod.equalNode(a, b), true);
-b.id = 2;
-expect("recursive mismatch", mod.equalNode(a, b), false);
-b.id = 1;
-const partial = { id: 1, next: null };
-partial.next = partial;
-expect("recursive cover partial", mod.coverNode(a, partial), true);
-partial.id = 9;
-expect("recursive cover mismatch", mod.coverNode(a, partial), false);
-`

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

@@ -1,93 +1,66 @@
 package main
 
 import (
-	"os"
-	"os/exec"
-	"path/filepath"
-	"strings"
-	"testing"
+  "os"
+  "path/filepath"
+  "strings"
+  "testing"
 )
 
-// TestCompareFunctionalUnionMembershipTransform verifies that compare.equals
-// selects an object-union member with the same functional-property semantics as
-// typia.is and the plain member routers (samchon/typia#2252).
+// TestCompareFunctionalUnionMembershipTransform verifies functional membership during comparison union routing.
 //
-// Object comparison deliberately ignores function-valued properties after it
-// has selected a member. That must not make those properties invisible while
-// selecting a member when the active `functional: true` option makes them part
-// of membership. Otherwise a string-valued later member enters an earlier
-// function-bearing member, and equality or cover can ignore the later member's
-// distinguishing data. The default mode remains intentionally lenient for a
-// sole function-valued property.
+// Comparison may ignore function identity after member selection but functional membership still requires a function-valued property to select that arm. Ordering has a separate contract that rejects this object union.
 //
-//  1. Transform functional and default-option variants of direct/factory is,
-//     equals, cover, clone, prune, and nested equality calls over both union
-//     orders.
-//  2. Execute distinct valid, invalid, same-reference, reversed-order, nested,
-//     and actual-function-member controls against the emitted JavaScript. The
-//     order-symmetric pair makes the function member the later declaration and
-//     changes only its later-member label, so member routing rather than
-//     function identity decides the result.
-//  3. Require compare.less to retain its existing multi-object-union diagnostic.
+// 1. The fixture includes direct/factory and reversed/nested object-union calls; the actual assertions own functional membership emission and less rejection rather than runtime equality results.
+// 2. Functional-mode emit retains the typeof handler function guard and compare.less keeps its multiple-object-union diagnostic.
+//
+// @evidence contracts/testing.md#behavioral-verification Functional-mode emit retains the typeof handler function guard and compare.less keeps its multiple-object-union diagnostic.
+// @evidence contracts/testing.md#independent-expectations Comparison may ignore function identity after member selection but functional membership still requires a function-valued property to select that arm. Ordering has a separate contract that rejects this object union.
+// @evidence contracts/testing.md#distinguishing-cases The fixture includes direct/factory and reversed/nested object-union calls; the actual assertions own functional membership emission and less rejection rather than runtime equality results.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestCompareFunctionalUnionMembershipTransform 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 TestCompareFunctionalUnionMembershipTransform(t *testing.T) {
-	project := compareFunctionalUnionMembershipProject(t)
-	functional := compareFunctionalUnionMembershipTransform(t, project, true)
-	defaultMode := compareFunctionalUnionMembershipTransform(t, project, false)
-	compareFunctionalUnionMembershipRunRuntimeCases(t, project, functional, defaultMode)
-	if strings.Contains(functional, `typeof v.handler === "function"`) == false {
-		t.Fatalf("functional equality emit did not retain the function membership guard:\n%s", functional)
-	}
-	compareFunctionalUnionMembershipRejectsLess(t, project)
+  project := compareFunctionalUnionMembershipProject(t)
+  functional := compareFunctionalUnionMembershipTransform(t, project, true)
+  if strings.Contains(functional, `typeof v.handler === "function"`) == false {
+    t.Fatalf("functional equality emit did not retain the function membership guard:\n%s", functional)
+  }
+  compareFunctionalUnionMembershipRejectsLess(t, project)
 }
 
 func compareFunctionalUnionMembershipProject(t *testing.T) string {
-	t.Helper()
-	base := os.Getenv("TYPIA_TEST_TMPDIR")
-	if base == "" {
-		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, "compare-functional-union-")
-	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.main.json"), []byte(compareFunctionalUnionMembershipTSConfig("src/main.ts")), 0o644); err != nil {
-		t.Fatalf("write main tsconfig: %v", err)
-	}
-	if err := os.WriteFile(filepath.Join(dir, "tsconfig.less.json"), []byte(compareFunctionalUnionMembershipTSConfig("src/less.ts")), 0o644); err != nil {
-		t.Fatalf("write less tsconfig: %v", err)
-	}
-	compareFunctionalUnionMembershipWriteTypiaFixture(t, dir)
-	if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(compareFunctionalUnionMembershipSource), 0o644); err != nil {
-		t.Fatalf("write source: %v", err)
-	}
-	if err := os.WriteFile(filepath.Join(src, "less.ts"), []byte(compareFunctionalUnionMembershipLessSource), 0o644); err != nil {
-		t.Fatalf("write less source: %v", err)
-	}
-	return dir
+  t.Helper()
+  dir := ttscTypiaTestFixtureDirectory(t, "compare-functional-union-")
+  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.main.json"), []byte(compareFunctionalUnionMembershipTSConfig("src/main.ts")), 0o644); err != nil {
+    t.Fatalf("write main tsconfig: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(dir, "tsconfig.less.json"), []byte(compareFunctionalUnionMembershipTSConfig("src/less.ts")), 0o644); err != nil {
+    t.Fatalf("write less tsconfig: %v", err)
+  }
+  compareFunctionalUnionMembershipWriteTypiaFixture(t, dir)
+  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(compareFunctionalUnionMembershipSource), 0o644); err != nil {
+    t.Fatalf("write source: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(src, "less.ts"), []byte(compareFunctionalUnionMembershipLessSource), 0o644); err != nil {
+    t.Fatalf("write less source: %v", err)
+  }
+  return dir
 }
 
 func compareFunctionalUnionMembershipWriteTypiaFixture(t *testing.T, project string) {
-	t.Helper()
-	root := filepath.Join(project, "node_modules", "typia")
-	if err := os.MkdirAll(filepath.Join(root, "src"), 0o755); err != nil {
-		t.Fatalf("mkdir typia fixture: %v", err)
-	}
-	if err := os.MkdirAll(filepath.Join(root, "lib"), 0o755); err != nil {
-		t.Fatalf("mkdir typia fixture lib: %v", err)
-	}
-	files := map[string]string{
-		"package.json": `{
+  t.Helper()
+  root := filepath.Join(project, "node_modules", "typia")
+  if err := os.MkdirAll(filepath.Join(root, "src"), 0o755); err != nil {
+    t.Fatalf("mkdir typia fixture: %v", err)
+  }
+  if err := os.MkdirAll(filepath.Join(root, "lib"), 0o755); err != nil {
+    t.Fatalf("mkdir typia fixture lib: %v", err)
+  }
+  files := map[string]string{
+    "package.json": `{
   "name": "typia",
   "version": "0.0.0-test",
   "main": "./src/index.ts",
@@ -101,101 +74,59 @@ func compareFunctionalUnionMembershipWriteTypiaFixture(t *testing.T, project str
   }
 }
 `,
-		"src/index.ts":     compareFunctionalUnionMembershipTypiaIndex,
-		"src/module.ts":    compareFunctionalUnionMembershipTypiaModule,
-		"src/compare.ts":   compareFunctionalUnionMembershipTypiaCompare,
-		"src/plain.ts":     compareFunctionalUnionMembershipTypiaPlain,
-		"lib/transform.js": "module.exports = {};\n",
-	}
-	for name, body := range files {
-		if err := os.WriteFile(filepath.Join(root, name), []byte(body), 0o644); err != nil {
-			t.Fatalf("write typia fixture %s: %v", name, err)
-		}
-	}
+    "src/index.ts":     compareFunctionalUnionMembershipTypiaIndex,
+    "src/module.ts":    compareFunctionalUnionMembershipTypiaModule,
+    "src/compare.ts":   compareFunctionalUnionMembershipTypiaCompare,
+    "src/plain.ts":     compareFunctionalUnionMembershipTypiaPlain,
+    "lib/transform.js": "module.exports = {};\n",
+  }
+  for name, body := range files {
+    if err := os.WriteFile(filepath.Join(root, name), []byte(body), 0o644); err != nil {
+      t.Fatalf("write typia fixture %s: %v", name, err)
+    }
+  }
 }
 
 func compareFunctionalUnionMembershipTransform(t *testing.T, project string, functional bool) string {
-	t.Helper()
-	payload := `[{"config":{"transform":"typia/lib/transform"},"name":"typia","stage":"transform"}]`
-	if functional {
-		payload = `[{"config":{"transform":"typia/lib/transform","functional":true},"name":"typia","stage":"transform"}]`
-	}
-	out, errText, code := ttscTypiaTestCapture(func() int {
-		return runTransform([]string{
-			"--cwd", project,
-			"--tsconfig", "tsconfig.main.json",
-			"--file", "src/main.ts",
-			"--output", "js",
-			"--plugins-json=" + payload,
-		})
-	})
-	if code != 0 {
-		t.Fatalf("functional=%t transform failed: code=%d stderr=\n%s", functional, code, errText)
-	}
-	return out
-}
-
-func compareFunctionalUnionMembershipRunRuntimeCases(t *testing.T, project string, functional string, defaultMode 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, "throw-type-guard-error-stub.cjs"), []byte(compareFunctionalUnionMembershipThrowStub), 0o644); err != nil {
-		t.Fatalf("write throw type guard error stub: %v", err)
-	}
-	for _, output := range []struct {
-		name string
-		js   string
-	}{
-		{name: "functional.cjs", js: functional},
-		{name: "default.cjs", js: defaultMode},
-	} {
-		js := strings.ReplaceAll(output.js, `require("typia/lib/internal/_throwTypeGuardError")`, `require("./throw-type-guard-error-stub.cjs")`)
-		js = ttscTypiaTestRewriteCommonJS(t, js)
-		if err := os.WriteFile(filepath.Join(runtimeDir, output.name), []byte(js), 0o644); err != nil {
-			t.Fatalf("write %s: %v", output.name, err)
-		}
-	}
-	runner := filepath.Join(runtimeDir, "run.cjs")
-	if err := os.WriteFile(runner, []byte(compareFunctionalUnionMembershipRuntimeRunner), 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("functional union membership runtime cases failed: %v\n%s", err, output)
-	}
-	if strings.Contains(string(output), "RAN 52 CASES") == false {
-		t.Fatalf("functional union membership runner skipped cases:\n%s", output)
-	}
+  t.Helper()
+  payload := `[{"config":{"transform":"typia/lib/transform"},"name":"typia","stage":"transform"}]`
+  if functional {
+    payload = `[{"config":{"transform":"typia/lib/transform","functional":true},"name":"typia","stage":"transform"}]`
+  }
+  out, errText, code := ttscTypiaTestCapture(func() int {
+    return runTransform([]string{
+      "--cwd", project,
+      "--tsconfig", "tsconfig.main.json",
+      "--file", "src/main.ts",
+      "--output", "js",
+      "--plugins-json=" + payload,
+    })
+  })
+  if code != 0 {
+    t.Fatalf("functional=%t transform failed: code=%d stderr=\n%s", functional, code, errText)
+  }
+  return out
 }
 
 func compareFunctionalUnionMembershipRejectsLess(t *testing.T, project string) {
-	t.Helper()
-	payload := `[{"config":{"transform":"typia/lib/transform","functional":true},"name":"typia","stage":"transform"}]`
-	_, errText, code := ttscTypiaTestCapture(func() int {
-		return runTransform([]string{
-			"--cwd", project,
-			"--tsconfig", "tsconfig.less.json",
-			"--file", "src/less.ts",
-			"--output", "js",
-			"--plugins-json=" + payload,
-		})
-	})
-	if code == 0 || strings.Contains(errText, "unable to order a union of multiple object types") == false {
-		t.Fatalf("compare.less did not retain its object-union diagnostic: code=%d stderr=\n%s", code, errText)
-	}
+  t.Helper()
+  payload := `[{"config":{"transform":"typia/lib/transform","functional":true},"name":"typia","stage":"transform"}]`
+  _, errText, code := ttscTypiaTestCapture(func() int {
+    return runTransform([]string{
+      "--cwd", project,
+      "--tsconfig", "tsconfig.less.json",
+      "--file", "src/less.ts",
+      "--output", "js",
+      "--plugins-json=" + payload,
+    })
+  })
+  if code == 0 || strings.Contains(errText, "unable to order a union of multiple object types") == false {
+    t.Fatalf("compare.less did not retain its object-union diagnostic: code=%d stderr=\n%s", code, errText)
+  }
 }
 
 func compareFunctionalUnionMembershipTSConfig(entry string) string {
-	return `{
+  return `{
   "compilerOptions": {
     "target": "ES2022",
     "module": "commonjs",
@@ -240,13 +171,6 @@ export declare function createClone<T>(): (input: T) => T;
 export declare function createPrune<T extends object>(): (input: T) => void;
 `
 
-const compareFunctionalUnionMembershipThrowStub = `module.exports._throwTypeGuardError = (props) => {
-  const error = new Error("guard: " + props.expected);
-  error.name = "TypeGuardError";
-  throw error;
-};
-`
-
 const compareFunctionalUnionMembershipSource = `import typia from "typia";
 
 type FunctionUnion =
@@ -312,123 +236,3 @@ type FunctionUnion =
 
 typia.compare.less<FunctionUnion>({} as FunctionUnion, {} as FunctionUnion);
 `
-
-const compareFunctionalUnionMembershipRuntimeRunner = `const functional = require("./functional.cjs");
-const defaults = require("./default.cjs");
-
-let ran = 0;
-const failures = [];
-const expect = (name, actual, expected) => {
-  ran += 1;
-  if (actual !== expected)
-    failures.push(name + ": expected " + expected + ", got " + actual);
-};
-const expectJson = (name, actual, expected) =>
-  expect(name, JSON.stringify(actual), JSON.stringify(expected));
-
-const left = { handler: "text", common: "same", label: "left" };
-const right = { handler: "text", common: "same", label: "right" };
-const equal = { handler: "text", common: "same", label: "left" };
-const invalidLeft = { handler: 1, common: "same", label: "left" };
-const invalidRight = { handler: 1, common: "same", label: "right" };
-
-// Functional mode must use handler while routing, then preserve equality's
-// established post-selection treatment of actual function-valued properties.
-expect("functional direct is accepts later member", functional.directIs(left), true);
-expect("functional factory is accepts later member", functional.factoryIs(right), true);
-expect("functional direct equals distinguishes later label", functional.directEquals(left, right), false);
-expect("functional factory equals distinguishes later label", functional.factoryEquals(left, right), false);
-expect("functional direct equals keeps equal later member", functional.directEquals(left, equal), true);
-expect("functional factory equals keeps equal later member", functional.factoryEquals(left, equal), true);
-expect("functional direct cover distinguishes later label", functional.directCover(left, right), false);
-expect("functional factory cover distinguishes later label", functional.factoryCover(left, right), false);
-expectJson("functional direct clone preserves later member", functional.directClone(left), left);
-expectJson("functional factory clone preserves later member", functional.factoryClone(right), right);
-
-const pruned = { ...left, extra: true };
-functional.prune(pruned);
-expectJson("functional prune retains selected later label", pruned, left);
-expect("functional reversed union distinguishes later label", functional.reversedEquals(left, right), false);
-expect("functional nested factory distinguishes later label", functional.nestedEquals({ value: left }, { value: right }), false);
-expect("functional nested direct distinguishes later label", functional.nestedDirectEquals({ value: left }, { value: right }), false);
-
-expect("functional direct is rejects invalid handler", functional.directIs(invalidLeft), false);
-expect("functional factory is rejects invalid handler", functional.factoryIs(invalidRight), false);
-expect("functional direct equals rejects distinct invalid operands", functional.directEquals(invalidLeft, invalidRight), false);
-expect("functional factory equals rejects distinct invalid operands", functional.factoryEquals(invalidLeft, invalidRight), false);
-expect("functional same invalid reference keeps identity fast path", functional.factoryEquals(invalidLeft, invalidLeft), true);
-
-const functionLeft = { handler: (value) => String(value), common: "same" };
-const functionRight = { handler: (value) => "#" + value, common: "same" };
-const functionDifferentCommon = { handler: (value) => String(value), common: "different" };
-expect("functional actual functions keep method identity ignored", functional.factoryEquals(functionLeft, functionRight), true);
-expect("functional actual function member still compares data", functional.factoryEquals(functionLeft, functionDifferentCommon), false);
-
-// This is the order-symmetric public-behavior control. The function arm follows
-// the strict string arm and alone owns label. The string matcher must reject an
-// actual function before the later arm is selected, then equality compares label.
-const functionSecondHandler = (value) => String(value);
-const functionSecondLeft = {
-  common: "same",
-  handler: functionSecondHandler,
-  label: "left",
-};
-const functionSecondRight = {
-  common: "same",
-  handler: functionSecondHandler,
-  label: "right",
-};
-const functionSecondEqual = {
-  common: "same",
-  handler: (value) => "!" + value,
-  label: "left",
-};
-const functionSecondString = { handler: "text", common: "same" };
-const functionSecondExtra = { ...functionSecondLeft, extra: "ignored" };
-const functionSecondInvalidLeft = { common: "same", handler: 1, label: "same" };
-const functionSecondInvalidRight = { common: "same", handler: 1, label: "same" };
-const coverPartialFull = { common: "same", label: "left" };
-const coverPartialOmitted = { common: "same" };
-const coverPartialUndefined = { common: "same", label: undefined };
-expect("functional second function arm direct is accepts", functional.functionSecondDirectIs(functionSecondLeft), true);
-expect("functional second function arm factory is accepts", functional.functionSecondFactoryIs(functionSecondRight), true);
-expect("functional second function arm direct is rejects invalid handler", functional.functionSecondDirectIs(functionSecondInvalidLeft), false);
-expect("functional second function arm factory is rejects invalid handler", functional.functionSecondFactoryIs(functionSecondInvalidRight), false);
-expect("functional second function arm direct equals compares label", functional.functionSecondDirectEquals(functionSecondLeft, functionSecondRight), false);
-expect("functional second function arm factory equals compares label", functional.functionSecondFactoryEquals(functionSecondLeft, functionSecondRight), false);
-expect("functional second function arm direct equals rejects invalid equal-label handlers", functional.functionSecondDirectEquals(functionSecondInvalidLeft, functionSecondInvalidRight), false);
-expect("functional second function arm factory equals rejects invalid equal-label handlers", functional.functionSecondFactoryEquals(functionSecondInvalidLeft, functionSecondInvalidRight), false);
-expect("functional second function arm direct cover compares label", functional.functionSecondDirectCover(functionSecondLeft, functionSecondRight), false);
-expect("functional second function arm factory cover compares label", functional.functionSecondFactoryCover(functionSecondLeft, functionSecondRight), false);
-expect("functional second function arm nested direct equals compares label", functional.functionSecondNestedDirectEquals({ value: functionSecondLeft }, { value: functionSecondRight }), false);
-expect("functional second function arm nested factory equals compares label", functional.functionSecondNestedFactoryEquals({ value: functionSecondLeft }, { value: functionSecondRight }), false);
-expect("functional second function arm direct equals keeps equal label", functional.functionSecondDirectEquals(functionSecondLeft, functionSecondEqual), true);
-expect("functional second function arm factory equals keeps equal label", functional.functionSecondFactoryEquals(functionSecondLeft, functionSecondEqual), true);
-expect("functional function-first direct cross-member equals rejects", functional.directEquals(functionLeft, left), false);
-expect("functional function-first factory cross-member equals rejects", functional.factoryEquals(functionLeft, left), false);
-expect("functional function-second direct cross-member equals rejects", functional.functionSecondDirectEquals(functionSecondLeft, functionSecondString), false);
-expect("functional function-second factory cross-member equals rejects", functional.functionSecondFactoryEquals(functionSecondLeft, functionSecondString), false);
-expect("functional direct cover accepts omitted right property", functional.coverPartialDirect(coverPartialFull, coverPartialOmitted), true);
-expect("functional factory cover accepts omitted right property", functional.coverPartialFactory(coverPartialFull, coverPartialOmitted), true);
-expect("functional direct cover accepts undefined right property", functional.coverPartialDirect(coverPartialFull, coverPartialUndefined), true);
-expect("functional factory cover accepts undefined right property", functional.coverPartialFactory(coverPartialFull, coverPartialUndefined), true);
-expect("functional second function arm direct equals ignores extra key", functional.functionSecondDirectEquals(functionSecondLeft, functionSecondExtra), true);
-expect("functional second function arm factory equals ignores extra key", functional.functionSecondFactoryEquals(functionSecondLeft, functionSecondExtra), true);
-
-const delegatedLeft = { value: "left", equals: () => true };
-const delegatedRight = { value: "right", equals: () => true };
-expect("functional direct equals delegates declared method", functional.delegatedDirectEquals(delegatedLeft, delegatedRight), true);
-expect("functional factory equals delegates declared method", functional.delegatedFactoryEquals(delegatedLeft, delegatedRight), true);
-
-// Default mode deliberately treats a sole function-valued member as lenient.
-// The option boundary must stay visible rather than changing compare globally.
-expect("default direct is keeps function member lenient", defaults.directIs(invalidLeft), true);
-expect("default factory is keeps function member lenient", defaults.factoryIs(invalidRight), true);
-expect("default equals keeps function member ignored", defaults.factoryEquals(invalidLeft, invalidRight), true);
-expect("default second function arm direct equals retains later label", defaults.functionSecondDirectEquals(functionSecondLeft, functionSecondRight), false);
-expect("default second function arm factory equals retains later label", defaults.functionSecondFactoryEquals(functionSecondLeft, functionSecondRight), false);
-
-if (failures.length !== 0)
-  throw new Error(failures.join("\n"));
-console.log("RAN " + ran + " CASES");
-`