typia 15.0.0 → 15.1.0

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

@@ -2,25 +2,22 @@ package main
 
 import (
   "os"
-  "os/exec"
   "path/filepath"
   "strings"
   "testing"
 )
 
-// TestExcludeTypeTagTransform verifies the exclude type tag.
+// TestExcludeTypeTagTransform verifies excluded literal predicates and JSON schema negation.
 //
-// `tags.Exclude<Values>` rejects listed literal values. The excluded
-// literals travel in the tag's JSON schema fragment (`not.enum`) because a
-// tuple of values cannot be templated into a single validate literal, so the
-// checker synthesizes the `!==` chain itself and the JSON schema emitter
-// merges the fragment untouched (#1630).
+// Exclude forbids the authored literals while retaining other base-type values; JSON Schema expresses the same finite exclusion through not.enum.
 //
-//  1. Transform a fixture excluding number, string, bigint, and
-//     template-literal values.
-//  2. Require the emitted JSON schema to carry `not: { enum: [...] }`.
-//  3. Execute is/validate runtime cases: excluded values fail with the tag
-//     named in the error, all other values of the base type pass.
+// 1. Number, string, bigint and template-literal fixtures exercise the tag; the owned assertions distinguish numeric/string exclusions and schema negation without claiming runtime acceptance tests.
+// 2. The output contains not/enum schema metadata and explicit port/name excluded-value comparisons.
+//
+// @evidence contracts/testing.md#behavioral-verification The output contains not/enum schema metadata and explicit port/name excluded-value comparisons.
+// @evidence contracts/testing.md#independent-expectations Exclude forbids the authored literals while retaining other base-type values; JSON Schema expresses the same finite exclusion through not.enum.
+// @evidence contracts/testing.md#distinguishing-cases Number, string, bigint and template-literal fixtures exercise the tag; the owned assertions distinguish numeric/string exclusions and schema negation without claiming runtime acceptance tests.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestExcludeTypeTagTransform 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 TestExcludeTypeTagTransform(t *testing.T) {
   project := excludeTypeTagProject(t)
   out, errText, code := ttscTypiaTestCapture(func() int {
@@ -39,23 +36,11 @@ func TestExcludeTypeTagTransform(t *testing.T) {
       t.Fatalf("emitted output should contain %q:\n%s", needle, out)
     }
   }
-  excludeTypeTagRunRuntimeCases(t, project, out)
 }
 
 func excludeTypeTagProject(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, "exclude-tag-")
-  if err != nil {
-    t.Fatalf("create temp fixture: %v", err)
-  }
-  t.Cleanup(func() {
-    _ = os.RemoveAll(dir)
-  })
+  dir := ttscTypiaTestFixtureDirectory(t, "exclude-tag-")
   src := filepath.Join(dir, "src")
   if err := os.MkdirAll(src, 0o755); err != nil {
     t.Fatalf("mkdir fixture src: %v", err)
@@ -69,33 +54,6 @@ func excludeTypeTagProject(t *testing.T) string {
   return dir
 }
 
-func excludeTypeTagRunRuntimeCases(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(excludeTypeTagRuntimeRunner), 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("exclude tag runtime cases failed: %v\n%s", err, output)
-  }
-}
-
 const excludeTypeTagTSConfig = `{
   "compilerOptions": {
     "target": "ES2022",
@@ -124,53 +82,3 @@ export const isConfig = typia.createIs<IConfig>();
 export const validateConfig = typia.createValidate<IConfig>();
 export const schema = typia.json.schemas<[{ port: number & tags.Exclude<[0, 22, 80]> }]>();
 `
-
-const excludeTypeTagRuntimeRunner = `const mod = require("./main.cjs");
-
-const valid = { port: 8080, name: "user", serial: 1n, account: "user-one" };
-if (mod.isConfig(valid) !== true) {
-  throw new Error("non-excluded values should pass is");
-}
-for (const port of [0, 22, 80]) {
-  if (mod.isConfig({ ...valid, port }) !== false) {
-    throw new Error("excluded port " + port + " should fail is");
-  }
-}
-for (const name of ["admin", "root"]) {
-  if (mod.isConfig({ ...valid, name }) !== false) {
-    throw new Error("excluded name " + name + " should fail is");
-  }
-}
-if (mod.isConfig({ ...valid, serial: 0n }) !== false) {
-  throw new Error("excluded bigint serial should fail is");
-}
-if (mod.isConfig({ ...valid, serial: 2n }) !== true) {
-  throw new Error("non-excluded bigint serial should pass is");
-}
-if (mod.isConfig({ ...valid, account: "user-admin" }) !== false) {
-  throw new Error("excluded template literal value should fail is");
-}
-if (mod.isConfig({ ...valid, account: "nomatch" }) !== false) {
-  throw new Error("template pattern should still be enforced next to exclude");
-}
-
-const failure = mod.validateConfig({ ...valid, port: 22 });
-if (failure.success !== false) {
-  throw new Error("excluded port should fail validate");
-}
-if (!failure.errors.some((e) => e.path === "$input.port" && e.expected.includes("Exclude"))) {
-  throw new Error("validate error should name the exclude tag: " + JSON.stringify(failure.errors));
-}
-if (mod.validateConfig(valid).success !== true) {
-  throw new Error("valid input should pass validate");
-}
-
-const unit = mod.schema.schemas[0];
-const resolved = unit.$ref
-  ? mod.schema.components.schemas[unit.$ref.split("/").pop()]
-  : unit;
-const port = resolved.properties.port;
-if (!port.not || JSON.stringify(port.not["enum"]) !== "[0,22,80]") {
-  throw new Error("JSON schema should carry not.enum: " + JSON.stringify(port));
-}
-`

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

@@ -0,0 +1,154 @@
+package main
+
+import (
+  "fmt"
+  "os"
+  "path/filepath"
+  "sync"
+  "testing"
+)
+
+var fixtureDependencies struct {
+  sync.Once
+  root string
+  err  error
+}
+
+// TestMain releases the shared declaration inputs after all command tests finish.
+// Fixtures have separate writable directories and never modify the dependency
+// copies. This is the runner's lifecycle hook, not an additional regression case.
+//
+//  1. Run the command test population through testing.M.Run.
+//  2. Remove the process-owned dependency directory and return the runner status,
+//     promoting a cleanup failure to a failing exit status.
+//
+// @evidence contracts/testing.md#behavioral-verification The hook runs existing Test functions through M.Run and preserves their failure status. Its additional observable responsibility is removal of shared dependency inputs; removal errors fail the process. It owns no independent semantic assertion.
+// @evidence contracts/testing.md#independent-expectations Go testing defines M.Run as the owner of the population's exit status. Dependency inputs come from current source and installed manifests and supply no expected transform results; individual cases retain their authored expectations.
+// @evidence contracts/testing.md#distinguishing-cases The hook retains successful and failing runner statuses and makes cleanup failure observable. Semantic positive, negative and boundary distinctions remain with the existing Test functions; this hook adds no semantic case.
+// @evidence contracts/testing.md#execution-ownership Go invokes TestMain once for this command package. Fixtures call Go operations in process, use separate writable directories with t.Cleanup, and share declaration inputs copied once. No compiler subprocess or native artifact build is introduced.
+func TestMain(m *testing.M) {
+  code := m.Run()
+  if fixtureDependencies.root != "" {
+    if err := os.RemoveAll(fixtureDependencies.root); err != nil {
+      fmt.Fprintf(os.Stderr, "remove command test dependencies: %v\n", err)
+      code = 1
+    }
+  }
+  os.Exit(code)
+}
+
+// ttscTypiaTestFixtureDirectory creates an isolated project beside declaration
+// inputs copied once for this Go test process. Ordinary node_modules resolution
+// reaches current workspace sources, while a fixture's own package remains
+// nearer and can deliberately replace them. No symlink privilege or repository
+// ancestor layout is required on Windows or POSIX.
+func ttscTypiaTestFixtureDirectory(t *testing.T, prefix string) string {
+  t.Helper()
+  fixtureDependencies.Do(func() {
+    fixtureDependencies.root, fixtureDependencies.err = os.MkdirTemp("", "typia-command-tests-")
+    if fixtureDependencies.err != nil {
+      return
+    }
+    repo := ttscTypiaTestRepoRoot(t)
+    modules := filepath.Join(fixtureDependencies.root, "node_modules")
+    for _, entry := range []struct{ source, name string }{
+      {filepath.Join(repo, "packages", "typia"), "typia"},
+      {filepath.Join(repo, "packages", "interface"), filepath.Join("@typia", "interface")},
+      {filepath.Join(repo, "packages", "utils"), filepath.Join("@typia", "utils")},
+    } {
+      target := filepath.Join(modules, entry.name)
+      if err := os.CopyFS(filepath.Join(target, "src"), os.DirFS(filepath.Join(entry.source, "src"))); err != nil {
+        fixtureDependencies.err = err
+        return
+      }
+      manifest, err := os.ReadFile(filepath.Join(entry.source, "package.json"))
+      if err == nil {
+        err = os.WriteFile(filepath.Join(target, "package.json"), manifest, 0o644)
+      }
+      if err != nil {
+        fixtureDependencies.err = err
+        return
+      }
+    }
+    dependencyRoots := []string{
+      filepath.Join(repo, "packages", "typia", "node_modules"),
+      filepath.Join(repo, "node_modules"),
+    }
+    for _, name := range []string{filepath.Join("@types", "node"), "randexp"} {
+      source, err := ttscTypiaTestDependencyPath(filepath.Join(dependencyRoots[0], name))
+      if err != nil {
+        fixtureDependencies.err = err
+        return
+      }
+      parent := filepath.Dir(source)
+      if filepath.Base(parent) == "@types" {
+        parent = filepath.Dir(parent)
+      }
+      dependencyRoots = append(dependencyRoots, parent)
+    }
+    for _, name := range []string{filepath.Join("@types", "node"), "undici-types", "randexp", "ret", "drange"} {
+      var source string
+      for _, root := range dependencyRoots {
+        candidate := filepath.Join(root, name)
+        if _, err := os.Stat(candidate); err == nil {
+          source = candidate
+          break
+        }
+      }
+      if source == "" {
+        fixtureDependencies.err = fmt.Errorf("command test dependency %s is not installed in %v", name, dependencyRoots)
+        return
+      }
+      source, err := ttscTypiaTestDependencyPath(source)
+      if err != nil {
+        fixtureDependencies.err = err
+        return
+      }
+      if err := os.CopyFS(filepath.Join(modules, name), os.DirFS(source)); err != nil {
+        fixtureDependencies.err = err
+        return
+      }
+    }
+  })
+  if fixtureDependencies.err != nil {
+    t.Fatalf("prepare command test declaration dependencies: %v", fixtureDependencies.err)
+  }
+  dir, err := os.MkdirTemp(fixtureDependencies.root, prefix)
+  if err != nil {
+    t.Fatalf("create command fixture: %v", err)
+  }
+  t.Cleanup(func() {
+    if err := os.RemoveAll(dir); err != nil {
+      t.Errorf("remove command fixture: %v", err)
+    }
+  })
+  return dir
+}
+
+// ttscTypiaTestDependencyPath resolves both symlinks and directory junctions.
+// EvalSymlinks preserves Windows junction spellings, whereas Readlink exposes
+// their target so the installed package's sibling dependencies can be found.
+func ttscTypiaTestDependencyPath(source string) (string, error) {
+  source, err := filepath.EvalSymlinks(source)
+  if err != nil {
+    return "", err
+  }
+  seen := map[string]bool{}
+  for {
+    if seen[source] {
+      return "", fmt.Errorf("cyclic dependency link at %s", source)
+    }
+    seen[source] = true
+    target, err := os.Readlink(source)
+    if err != nil {
+      return source, nil
+    }
+    if !filepath.IsAbs(target) {
+      target = filepath.Join(filepath.Dir(source), target)
+    }
+    source, err = filepath.EvalSymlinks(target)
+    if err != nil {
+      return "", err
+    }
+  }
+}

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

@@ -1,23 +1,22 @@
 package main
 
 import (
-  "os"
-  "os/exec"
-  "path/filepath"
+  "regexp"
   "strings"
   "testing"
 )
 
-// TestFunctionalPromisedTypeTransform verifies semantic async wrappers.
+// TestFunctionalPromisedTypeTransform verifies async and dynamic receiver forwarding in promised wrappers.
 //
-// Every functional family shares the return-type classifier. A derived Promise
-// must produce an async wrapper that validates the fulfilled value, while a
-// non-thenable class merely named Promise must remain synchronous.
+// A promised functional wrapper must await the invoked result before validating its resolved value, and method invocation must retain this binding rather than call the function detached.
 //
-//  1. Transform all assert, is/equals, and validate function variants.
-//  2. Exercise derived class/interface and branded Promise results.
-//  3. Pin invalid parameters, invalid fulfilled values, rejection, and the
-//     shadowed-name negative control without regressing receiver forwarding.
+// 1. Promised assertion/validation wrappers and receiver-bearing declarations are combined; synchronous wrappers are owned by the functional receiver case.
+// 2. Emission contains async functions, awaited Reflect.apply calls and dynamic receiver forwarding.
+//
+// @evidence contracts/testing.md#behavioral-verification Emission contains async functions, awaited Reflect.apply calls and dynamic receiver forwarding.
+// @evidence contracts/testing.md#independent-expectations A promised functional wrapper must await the invoked result before validating its resolved value, and method invocation must retain this binding rather than call the function detached.
+// @evidence contracts/testing.md#distinguishing-cases Promised assertion/validation wrappers and receiver-bearing declarations are combined; synchronous wrappers are owned by the functional receiver case.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestFunctionalPromisedTypeTransform 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 TestFunctionalPromisedTypeTransform(t *testing.T) {
   project := compareEqualCoverProject(t, "functional-promised-type-", functionalPromisedTypeSource)
   ttscTypiaTestTypecheck(t, project)
@@ -25,31 +24,10 @@ func TestFunctionalPromisedTypeTransform(t *testing.T) {
   if !strings.Contains(js, "async function") || !strings.Contains(js, "await Reflect.apply") {
     t.Fatalf("promised wrappers do not emit async/await:\n%s", js)
   }
-  if !strings.Contains(js, "Reflect.apply") {
+  if !regexp.MustCompile(`await Reflect\.apply\([^,]+,\s*this,\s*\[`).MatchString(js) {
     t.Fatalf("promised wrappers do not preserve receiver forwarding:\n%s", js)
   }
 
-  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, "main.cjs"), []byte(ttscTypiaTestRewriteCommonJS(t, js)), 0o644); err != nil {
-    t.Fatalf("write runtime module: %v", err)
-  }
-  runner := filepath.Join(runtimeDir, "run.cjs")
-  if err := os.WriteFile(runner, []byte(functionalPromisedTypeRuntime), 0o644); err != nil {
-    t.Fatalf("write runtime runner: %v", err)
-  }
-  cmd := exec.Command(node, runner)
-  cmd.Dir = runtimeDir
-  if output, err := cmd.CombinedOutput(); err != nil {
-    t.Fatalf("functional promised-type runtime cases failed: %v\n%s", err, output)
-  }
 }
 
 const functionalPromisedTypeSource = `import typia from "typia";
@@ -147,74 +125,3 @@ export type PromisedWrapperCases = [
   Assert<Equal<ReturnType<typeof shadowed.validateReturn>, typia.IValidation<Shadow.Promise<Output>>>>,
 ];
 `
-
-const functionalPromisedTypeRuntime = `const mod = require("./main.cjs");
-
-const expect = (label, actual, expected) => {
-  if (actual !== expected) throw new Error(label + ": expected " + expected + ", got " + actual);
-};
-const assertNames = new Set([
-  "assertFunction", "assertParameters", "assertReturn",
-  "assertEqualsFunction", "assertEqualsParameters", "assertEqualsReturn",
-]);
-const validateNames = new Set([
-  "validateFunction", "validateParameters", "validateReturn",
-  "validateEqualsFunction", "validateEqualsParameters", "validateEqualsReturn",
-]);
-
-(async () => {
-  for (const [name, wrapped] of Object.entries(mod.promised)) {
-    const pending = wrapped.call({ base: 40 }, { value: 2 });
-    expect("promised " + name + " returns Promise", pending instanceof Promise, true);
-    const result = await pending;
-    if (validateNames.has(name)) {
-      expect("promised " + name + " succeeds", result.success, true);
-      expect("promised " + name + " fulfilled total", result.data.total, 42);
-    } else {
-      expect("promised " + name + " is non-null", result === null, false);
-      expect("promised " + name + " fulfilled total", result.total, 42);
-    }
-
-    const invalid = wrapped.call({ base: 40 }, { value: "bad" });
-    expect("invalid " + name + " keeps Promise shape", invalid instanceof Promise, true);
-    if (assertNames.has(name)) {
-      let error;
-      try { await invalid; } catch (exp) { error = exp; }
-      expect("invalid " + name + " rejects", Boolean(error), true);
-    } else {
-      const failure = await invalid;
-      if (validateNames.has(name)) expect("invalid " + name + " validation fails", failure.success, false);
-      else expect("invalid " + name + " returns null", failure, null);
-    }
-  }
-
-  for (const [name, wrapped] of Object.entries(mod.semanticShapes)) {
-    const pending = wrapped({ value: 7 });
-    expect(name + " returns Promise", pending instanceof Promise, true);
-    const result = await pending;
-    if (name.endsWith("Validate")) {
-      expect(name + " succeeds", result.success, true);
-      expect(name + " total", result.data.total, 7);
-    } else expect(name + " total", result.total, 7);
-  }
-
-  for (const [name, wrapped] of Object.entries(mod.shadowed)) {
-    const result = wrapped({ value: 9 });
-    expect("shadowed " + name + " stays synchronous", result instanceof Promise, false);
-    if (validateNames.has(name)) {
-      expect("shadowed " + name + " succeeds", result.success, true);
-      expect("shadowed " + name + " value", result.data.value.total, 9);
-    } else {
-      expect("shadowed " + name + " is non-null", result === null, false);
-      expect("shadowed " + name + " value", result.value.total, 9);
-    }
-  }
-
-  let rejection;
-  try { await mod.rejecting(); } catch (error) { rejection = error; }
-  expect("rejection propagates", rejection && rejection.message, "promised rejection");
-})().catch((error) => {
-  console.error(error);
-  process.exitCode = 1;
-});
-`

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

@@ -1,52 +1,33 @@
 package main
 
 import (
-  "os"
-  "os/exec"
-  "path/filepath"
-  "strings"
+  "regexp"
   "testing"
 )
 
-// TestFunctionalReceiverTransform verifies dynamic receiver preservation.
+// TestFunctionalReceiverTransform verifies dynamic receiver forwarding in functional wrapper emission.
 //
-// Functional wrappers advertise the target function's receiver contract, so
-// the emitted wrapper must be an ordinary function and must invoke the captured
-// target with the wrapper's call-site `this`. Arrow wrappers and bare calls
-// silently discard that contract.
+// JavaScript method meaning depends on this at invocation; Reflect.apply with the runtime receiver preserves that meaning across the validation wrapper.
 //
-//  1. Transform all assert, is/equals, and validate parameter/return variants.
-//  2. Exercise sync, async, bound, and receiver-free targets.
-//  3. Preserve validation failures, thrown errors, and receiver-dependent data.
+// 1. The authored fixture contains receiver-using wrappers across functional families; promised async forwarding is asserted separately.
+// 2. The output retains Reflect.apply rather than dropping the method receiver during wrapping.
+//
+// @evidence contracts/testing.md#behavioral-verification The output retains Reflect.apply rather than dropping the method receiver during wrapping.
+// @evidence contracts/testing.md#independent-expectations JavaScript method meaning depends on this at invocation; Reflect.apply with the runtime receiver preserves that meaning across the validation wrapper.
+// @evidence contracts/testing.md#distinguishing-cases The authored fixture contains receiver-using wrappers across functional families; promised async forwarding is asserted separately.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestFunctionalReceiverTransform 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 TestFunctionalReceiverTransform(t *testing.T) {
   project := compareEqualCoverProject(t, "functional-receiver-", functionalReceiverSource)
   ttscTypiaTestTypecheck(t, project)
   js := compareEqualCoverTransform(t, project)
-  if !strings.Contains(js, "Reflect.apply") {
-    t.Fatalf("functional output does not forward the dynamic receiver:\n%s", js)
-  }
-
-  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, "main.cjs"), []byte(ttscTypiaTestRewriteCommonJS(t, js)), 0o644); err != nil {
-    t.Fatalf("write runtime module: %v", err)
-  }
-  runner := filepath.Join(runtimeDir, "run.cjs")
-  if err := os.WriteFile(runner, []byte(functionalReceiverRuntime), 0o644); err != nil {
-    t.Fatalf("write runtime runner: %v", err)
+  applications := regexp.MustCompile(`Reflect\.apply\([^,]+,\s*this,\s*\[`).FindAllString(js, -1)
+  if len(applications) != 40 {
+    t.Fatalf("expected all 40 functional wrappers to pass their invocation receiver to Reflect.apply; got %d:\n%s", len(applications), js)
   }
-  cmd := exec.Command(node, runner)
-  cmd.Dir = runtimeDir
-  if output, err := cmd.CombinedOutput(); err != nil {
-    t.Fatalf("functional receiver runtime cases failed: %v\n%s", err, output)
+  if regexp.MustCompile(`typia_1\.default\.functional\.`).MatchString(js) {
+    t.Fatalf("functional output retains an untransformed wrapper call:\n%s", js)
   }
+
 }
 
 const functionalReceiverSource = `import typia from "typia";
@@ -141,92 +122,3 @@ export type ReceiverCases = [
   Assert<Equal<ThisParameterType<typeof asynchronous.validateFunction>, Receiver>>,
 ];
 `
-
-const functionalReceiverRuntime = `const mod = require("./main.cjs");
-
-const expect = (label, actual, expected) => {
-  if (actual !== expected) throw new Error(label + ": expected " + expected + ", got " + actual);
-};
-const assertNames = new Set([
-  "assertFunction", "assertParameters", "assertReturn",
-  "assertEqualsFunction", "assertEqualsParameters", "assertEqualsReturn",
-]);
-const validateNames = new Set([
-  "validateFunction", "validateParameters", "validateReturn",
-  "validateEqualsFunction", "validateEqualsParameters", "validateEqualsReturn",
-]);
-const checkResult = (label, name, result) => {
-  if (validateNames.has(name)) {
-    expect(label + " success", result.success, true);
-    expect(label + " total", result.data.total, 42);
-  } else {
-    expect(label + " non-null", result === null, false);
-    expect(label + " total", result.total, 42);
-  }
-};
-
-(async () => {
-  for (const [name, wrapped] of Object.entries(mod.sync)) {
-    const receiver = { base: 40, calls: 0 };
-    const result = wrapped.call(receiver, { value: 2 });
-    checkResult("sync " + name, name, result);
-    expect("sync " + name + " receiver calls", receiver.calls, 1);
-  }
-  for (const [name, wrapped] of Object.entries(mod.asynchronous)) {
-    const receiver = { base: 40, calls: 0 };
-    const result = await wrapped.call(receiver, { value: 2 });
-    checkResult("async " + name, name, result);
-    expect("async " + name + " receiver calls", receiver.calls, 1);
-  }
-
-  const ignored = { base: 100, calls: 0 };
-  const bound = mod.boundAssert.call(ignored, { value: 2 });
-  expect("bound wrapper keeps bound receiver", bound.total, 22);
-  expect("bound wrapper ignores call receiver", ignored.calls, 0);
-  expect("receiver-free arrow remains directly callable", mod.receiverFreeResult.total, 2);
-
-  const receiver = { base: 40, calls: 0 };
-  let thrown;
-  try {
-    mod.throwing.call(receiver, { value: 2 });
-  } catch (error) {
-    thrown = error;
-  }
-  expect("thrown target error", thrown && thrown.message, "42");
-
-  for (const name of ["assertFunction", "isFunction", "validateFunction"]) {
-    const receiver = { base: 40, calls: 0 };
-    let result;
-    let error;
-    try {
-      result = mod.sync[name].call(receiver, { value: "bad" });
-    } catch (exp) {
-      error = exp;
-    }
-    if (assertNames.has(name)) {
-      expect("assert invalid throws", Boolean(error), true);
-      expect("assert invalid path", error.path, "$input.parameters[0].value");
-    } else if (validateNames.has(name)) {
-      expect("validate invalid fails", result.success, false);
-      expect("validate invalid path", result.errors[0].path, "$input.parameters[0].value");
-    } else {
-      expect("is invalid returns null", result, null);
-    }
-    expect(name + " invalid does not invoke target", receiver.calls, 0);
-  }
-
-  const customReceiver = { base: 40, calls: 0 };
-  let customError;
-  try {
-    mod.customAssert.call(customReceiver, { value: "bad" });
-  } catch (error) {
-    customError = error;
-  }
-  expect("custom error factory message", customError && customError.message, "custom receiver");
-  expect("custom error factory path", customError && customError.path, "$input.parameters[0].value");
-  expect("custom error does not invoke target", customReceiver.calls, 0);
-})().catch((error) => {
-  console.error(error);
-  process.exitCode = 1;
-});
-`