typia 13.1.1 → 13.1.19

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

@@ -0,0 +1,240 @@
+package main
+
+import (
+  "fmt"
+  "os"
+  "os/exec"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestFiniteOptionNumberLeafTransform pins the finite/numeric option matrix for a
+// bare `number` leaf across typia.is, typia.assert, and typia.validate (#2196).
+//
+// The `finite` option is documented as an independent flag that rejects both NaN
+// and Infinity, yet it was inert unless `numeric` was also set: typia.is dropped
+// `finite` when it built its number gate, and assert/validate gate their verdict
+// on that same is-checker, so all three accepted NaN and Infinity under
+// `finite:true` alone. The other three rows are regression guards that must not
+// move:
+//
+//   - finite alone   -> reject NaN, Infinity, -Infinity (the #2196 red case)
+//   - numeric alone  -> reject NaN, ACCEPT Infinity/-Infinity (numeric != finite)
+//   - finite+numeric -> reject NaN, Infinity, -Infinity (already worked)
+//   - neither option -> ACCEPT everything (the documented default)
+//
+//  1. Transform the same `number`-leaf fixture once per option row, injecting the
+//     row's options through the resolved --plugins-json payload (the only option
+//     source runTransform reads).
+//  2. Execute the emitted validators in Node against a finite value plus NaN,
+//     Infinity, and -Infinity, requiring is/assert/validate to agree with the row.
+//  3. Require the runner to report the exact executed case count so a runner that
+//     silently exercised nothing cannot pass as green.
+func TestFiniteOptionNumberLeafTransform(t *testing.T) {
+  for _, tc := range finiteOptionNumberLeafCases() {
+    t.Run(tc.name, func(t *testing.T) {
+      project := finiteOptionNumberLeafProject(t)
+      js := finiteOptionNumberLeafTransform(t, project, tc.payload())
+      finiteOptionNumberLeafRunRuntimeCases(t, project, js, tc)
+    })
+  }
+}
+
+type finiteOptionNumberLeafCase struct {
+  name string
+  // config is the JSON fragment appended to typia's resolved plugin entry, e.g.
+  // `,"finite":true`. Empty means typia's documented defaults.
+  config string
+  // acceptNaN and acceptInfinity are the expected verdicts for the non-finite
+  // inputs; a finite value is always accepted.
+  acceptNaN      bool
+  acceptInfinity bool
+}
+
+func (tc finiteOptionNumberLeafCase) payload() string {
+  return `[{"config":{"transform":"typia/lib/transform"` + tc.config + `},"name":"typia","stage":"transform"}]`
+}
+
+func finiteOptionNumberLeafCases() []finiteOptionNumberLeafCase {
+  return []finiteOptionNumberLeafCase{
+    {
+      name:           "finite alone rejects NaN and Infinity",
+      config:         `,"finite":true`,
+      acceptNaN:      false,
+      acceptInfinity: false,
+    },
+    {
+      name:           "numeric alone rejects NaN but accepts Infinity",
+      config:         `,"numeric":true`,
+      acceptNaN:      false,
+      acceptInfinity: true,
+    },
+    {
+      name:           "finite and numeric together reject NaN and Infinity",
+      config:         `,"finite":true,"numeric":true`,
+      acceptNaN:      false,
+      acceptInfinity: false,
+    },
+    {
+      name:           "neither option accepts NaN and Infinity",
+      config:         ``,
+      acceptNaN:      true,
+      acceptInfinity: true,
+    },
+  }
+}
+
+func finiteOptionNumberLeafProject(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, "finite-option-number-leaf-")
+  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(finiteOptionNumberLeafTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(finiteOptionNumberLeafSource), 0o644); err != nil {
+    t.Fatalf("write source: %v", err)
+  }
+  return dir
+}
+
+func finiteOptionNumberLeafTransform(t *testing.T, project string, payload string) string {
+  t.Helper()
+  out, errText, code := ttscTypiaTestCapture(func() int {
+    return runTransform([]string{
+      "--cwd", project,
+      "--tsconfig", "tsconfig.json",
+      "--file", "src/main.ts",
+      "--output", "js",
+      "--plugins-json", payload,
+    })
+  })
+  if code != 0 {
+    t.Fatalf("finite option transform failed: code=%d stderr=\n%s", code, errText)
+  }
+  return out
+}
+
+func finiteOptionNumberLeafRunRuntimeCases(t *testing.T, project string, js string, tc finiteOptionNumberLeafCase) {
+  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(finiteOptionNumberLeafRuntimeRunner(tc)), 0o644); err != nil {
+    t.Fatalf("write runtime runner: %v", err)
+  }
+  cmd := exec.Command(node, runner)
+  cmd.Dir = project
+  output, err := cmd.CombinedOutput()
+  if err != nil {
+    t.Fatalf("finite option runtime cases failed: %v\n%s", err, output)
+  }
+  // Every input drives is, validate, and assert, so the runner must report one
+  // executed assertion per (input, function) pair. Pinning the count keeps a
+  // runner that short-circuited or skipped cases from passing as a false green.
+  const expected = "RAN 12 CASES"
+  if !strings.Contains(string(output), expected) {
+    t.Fatalf("finite option runner did not report %q; got:\n%s", expected, output)
+  }
+}
+
+func finiteOptionNumberLeafRuntimeRunner(tc finiteOptionNumberLeafCase) string {
+  return fmt.Sprintf(`const mod = require("./main.cjs");
+
+const cases = [
+  { name: "finite 1", value: 1, accept: true },
+  { name: "NaN", value: Number.NaN, accept: %[1]t },
+  { name: "Infinity", value: Number.POSITIVE_INFINITY, accept: %[2]t },
+  { name: "-Infinity", value: Number.NEGATIVE_INFINITY, accept: %[2]t },
+];
+
+let ran = 0;
+for (const c of cases) {
+  const result = mod.run(c.value);
+
+  ran += 1;
+  if (result.is !== c.accept) {
+    throw new Error(c.name + ": typia.is expected " + c.accept + " but got " + result.is);
+  }
+
+  ran += 1;
+  if (result.validate !== c.accept) {
+    throw new Error(c.name + ": typia.validate.success expected " + c.accept + " but got " + result.validate);
+  }
+
+  ran += 1;
+  const assertAccepted = result.assertThrew === false;
+  if (assertAccepted !== c.accept) {
+    throw new Error(c.name + ": typia.assert accepted=" + assertAccepted + " but expected " + c.accept);
+  }
+}
+
+console.log("RAN " + ran + " CASES");
+`, tc.acceptNaN, tc.acceptInfinity)
+}
+
+const finiteOptionNumberLeafTSConfig = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "moduleResolution": "bundler",
+    "ignoreDeprecations": "6.0",
+    "types": ["*"],
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}
+`
+
+const finiteOptionNumberLeafSource = `import typia from "typia";
+
+interface FiniteBox {
+  value: number;
+}
+
+const check = typia.createIs<FiniteBox>();
+const validate = typia.createValidate<FiniteBox>();
+const assert = typia.createAssert<FiniteBox>();
+
+const captureThrow = (task: () => void): boolean => {
+  try {
+    task();
+    return false;
+  } catch {
+    return true;
+  }
+};
+
+export const run = (value: number) => ({
+  is: check({ value }),
+  validate: validate({ value }).success,
+  assertThrew: captureThrow(() => assert({ value })),
+});
+`

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

@@ -0,0 +1,220 @@
+package main
+
+import (
+  "os"
+  "os/exec"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestFunctionalPromisedTypeTransform verifies semantic async 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.
+//
+//  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.
+func TestFunctionalPromisedTypeTransform(t *testing.T) {
+  project := compareEqualCoverProject(t, "functional-promised-type-", functionalPromisedTypeSource)
+  ttscTypiaTestTypecheck(t, project)
+  js := compareEqualCoverTransform(t, project)
+  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") {
+    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";
+
+export interface Receiver { base: number; }
+export interface Input { value: number; }
+export interface Output { total: number; }
+
+export class DerivedPromise<T> extends Promise<T> {}
+export interface InterfacePromise<T> extends Promise<T> {}
+export type BrandedPromise<T> = Promise<T> & { readonly __brand: unique symbol };
+export namespace Shadow {
+  export class Promise<T> {
+    public constructor(public value: T) {}
+  }
+}
+
+export function promisedTarget(this: Receiver, input: Input): DerivedPromise<Output> {
+  return new DerivedPromise((resolve) => resolve({ total: this.base + input.value }));
+}
+export function interfaceTarget(input: Input): InterfacePromise<Output> {
+  return Promise.resolve({ total: input.value }) as InterfacePromise<Output>;
+}
+export function brandedTarget(input: Input): BrandedPromise<Output> {
+  return Promise.resolve({ total: input.value }) as BrandedPromise<Output>;
+}
+export function shadowedTarget(input: Input): Shadow.Promise<Output> {
+  return new Shadow.Promise({ total: input.value });
+}
+export function rejectingTarget(): DerivedPromise<Output> {
+  return new DerivedPromise((_resolve, reject) => reject(new Error("promised rejection")));
+}
+
+export const promised = {
+  assertFunction: typia.functional.assertFunction(promisedTarget),
+  assertParameters: typia.functional.assertParameters(promisedTarget),
+  assertReturn: typia.functional.assertReturn(promisedTarget),
+  assertEqualsFunction: typia.functional.assertEqualsFunction(promisedTarget),
+  assertEqualsParameters: typia.functional.assertEqualsParameters(promisedTarget),
+  assertEqualsReturn: typia.functional.assertEqualsReturn(promisedTarget),
+  isFunction: typia.functional.isFunction(promisedTarget),
+  isParameters: typia.functional.isParameters(promisedTarget),
+  isReturn: typia.functional.isReturn(promisedTarget),
+  equalsFunction: typia.functional.equalsFunction(promisedTarget),
+  equalsParameters: typia.functional.equalsParameters(promisedTarget),
+  equalsReturn: typia.functional.equalsReturn(promisedTarget),
+  validateFunction: typia.functional.validateFunction(promisedTarget),
+  validateParameters: typia.functional.validateParameters(promisedTarget),
+  validateReturn: typia.functional.validateReturn(promisedTarget),
+  validateEqualsFunction: typia.functional.validateEqualsFunction(promisedTarget),
+  validateEqualsParameters: typia.functional.validateEqualsParameters(promisedTarget),
+  validateEqualsReturn: typia.functional.validateEqualsReturn(promisedTarget),
+};
+
+export const shadowed = {
+  assertFunction: typia.functional.assertFunction(shadowedTarget),
+  assertParameters: typia.functional.assertParameters(shadowedTarget),
+  assertReturn: typia.functional.assertReturn(shadowedTarget),
+  assertEqualsFunction: typia.functional.assertEqualsFunction(shadowedTarget),
+  assertEqualsParameters: typia.functional.assertEqualsParameters(shadowedTarget),
+  assertEqualsReturn: typia.functional.assertEqualsReturn(shadowedTarget),
+  isFunction: typia.functional.isFunction(shadowedTarget),
+  isParameters: typia.functional.isParameters(shadowedTarget),
+  isReturn: typia.functional.isReturn(shadowedTarget),
+  equalsFunction: typia.functional.equalsFunction(shadowedTarget),
+  equalsParameters: typia.functional.equalsParameters(shadowedTarget),
+  equalsReturn: typia.functional.equalsReturn(shadowedTarget),
+  validateFunction: typia.functional.validateFunction(shadowedTarget),
+  validateParameters: typia.functional.validateParameters(shadowedTarget),
+  validateReturn: typia.functional.validateReturn(shadowedTarget),
+  validateEqualsFunction: typia.functional.validateEqualsFunction(shadowedTarget),
+  validateEqualsParameters: typia.functional.validateEqualsParameters(shadowedTarget),
+  validateEqualsReturn: typia.functional.validateEqualsReturn(shadowedTarget),
+};
+
+export const semanticShapes = {
+  interfaceAssert: typia.functional.assertReturn<(input: Input) => InterfacePromise<Output>>(interfaceTarget),
+  interfaceIs: typia.functional.isReturn(interfaceTarget),
+  interfaceValidate: typia.functional.validateReturn(interfaceTarget),
+  brandedAssert: typia.functional.assertReturn(brandedTarget),
+  brandedIs: typia.functional.isReturn<(input: Input) => BrandedPromise<Output>>(brandedTarget),
+  brandedValidate: typia.functional.validateReturn(brandedTarget),
+};
+export const rejecting = typia.functional.assertReturn(rejectingTarget);
+
+type Equal<X, Y> =
+  (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2
+    ? true
+    : false;
+type Assert<T extends true> = T;
+export type PromisedWrapperCases = [
+  Assert<Equal<ReturnType<typeof promised.isFunction>, Promise<Output | null>>>,
+  Assert<Equal<ReturnType<typeof promised.validateReturn>, Promise<typia.IValidation<Output>>>>,
+  Assert<Equal<ReturnType<typeof shadowed.isFunction>, Shadow.Promise<Output> | null>>,
+  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

@@ -0,0 +1,232 @@
+package main
+
+import (
+  "os"
+  "os/exec"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestFunctionalReceiverTransform verifies dynamic receiver preservation.
+//
+// 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.
+//
+//  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.
+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)
+  }
+  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)
+  }
+}
+
+const functionalReceiverSource = `import typia from "typia";
+
+export interface Receiver {
+  base: number;
+  calls: number;
+}
+export interface Input {
+  value: number;
+}
+export interface Output {
+  total: number;
+}
+
+export function syncTarget(this: Receiver, input: Input): Output {
+  this.calls += 1;
+  return { total: this.base + input.value };
+}
+export async function asyncTarget(this: Receiver, input: Input): Promise<Output> {
+  this.calls += 1;
+  return { total: this.base + input.value };
+}
+
+export const sync = {
+  assertFunction: typia.functional.assertFunction(syncTarget),
+  assertParameters: typia.functional.assertParameters(syncTarget),
+  assertReturn: typia.functional.assertReturn(syncTarget),
+  assertEqualsFunction: typia.functional.assertEqualsFunction(syncTarget),
+  assertEqualsParameters: typia.functional.assertEqualsParameters(syncTarget),
+  assertEqualsReturn: typia.functional.assertEqualsReturn(syncTarget),
+  isFunction: typia.functional.isFunction(syncTarget),
+  isParameters: typia.functional.isParameters(syncTarget),
+  isReturn: typia.functional.isReturn(syncTarget),
+  equalsFunction: typia.functional.equalsFunction(syncTarget),
+  equalsParameters: typia.functional.equalsParameters(syncTarget),
+  equalsReturn: typia.functional.equalsReturn(syncTarget),
+  validateFunction: typia.functional.validateFunction(syncTarget),
+  validateParameters: typia.functional.validateParameters(syncTarget),
+  validateReturn: typia.functional.validateReturn(syncTarget),
+  validateEqualsFunction: typia.functional.validateEqualsFunction(syncTarget),
+  validateEqualsParameters: typia.functional.validateEqualsParameters(syncTarget),
+  validateEqualsReturn: typia.functional.validateEqualsReturn(syncTarget),
+};
+
+export const asynchronous = {
+  assertFunction: typia.functional.assertFunction(asyncTarget),
+  assertParameters: typia.functional.assertParameters(asyncTarget),
+  assertReturn: typia.functional.assertReturn(asyncTarget),
+  assertEqualsFunction: typia.functional.assertEqualsFunction(asyncTarget),
+  assertEqualsParameters: typia.functional.assertEqualsParameters(asyncTarget),
+  assertEqualsReturn: typia.functional.assertEqualsReturn(asyncTarget),
+  isFunction: typia.functional.isFunction(asyncTarget),
+  isParameters: typia.functional.isParameters(asyncTarget),
+  isReturn: typia.functional.isReturn(asyncTarget),
+  equalsFunction: typia.functional.equalsFunction(asyncTarget),
+  equalsParameters: typia.functional.equalsParameters(asyncTarget),
+  equalsReturn: typia.functional.equalsReturn(asyncTarget),
+  validateFunction: typia.functional.validateFunction(asyncTarget),
+  validateParameters: typia.functional.validateParameters(asyncTarget),
+  validateReturn: typia.functional.validateReturn(asyncTarget),
+  validateEqualsFunction: typia.functional.validateEqualsFunction(asyncTarget),
+  validateEqualsParameters: typia.functional.validateEqualsParameters(asyncTarget),
+  validateEqualsReturn: typia.functional.validateEqualsReturn(asyncTarget),
+};
+
+const boundReceiver: Receiver = { base: 20, calls: 0 };
+export const boundAssert = typia.functional.assertFunction(syncTarget).bind(boundReceiver);
+export const customAssert = typia.functional.assertParameters(
+  syncTarget,
+  (props) => Object.assign(new Error("custom receiver"), props),
+);
+export const receiverFree = typia.functional.isFunction((input: Input): Output => ({ total: input.value }));
+export const receiverFreeResult = receiverFree({ value: 2 });
+export const throwing = typia.functional.assertParameters(function (this: Receiver, input: Input): Output {
+  throw new Error(String(this.base + input.value));
+});
+
+type Equal<X, Y> =
+  (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2
+    ? true
+    : false;
+type Assert<T extends true> = T;
+export type ReceiverCases = [
+  Assert<Equal<ThisParameterType<typeof sync.assertFunction>, Receiver>>,
+  Assert<Equal<ThisParameterType<typeof sync.isFunction>, Receiver>>,
+  Assert<Equal<ThisParameterType<typeof sync.equalsParameters>, Receiver>>,
+  Assert<Equal<ThisParameterType<typeof sync.validateReturn>, Receiver>>,
+  Assert<Equal<ThisParameterType<typeof sync.validateEqualsFunction>, Receiver>>,
+  Assert<Equal<ThisParameterType<typeof asynchronous.assertReturn>, Receiver>>,
+  Assert<Equal<ThisParameterType<typeof asynchronous.isParameters>, Receiver>>,
+  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;
+});
+`