typia 13.1.1 → 13.2.0

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

@@ -0,0 +1,216 @@
+package main
+
+import (
+  "fmt"
+  "os"
+  "os/exec"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestDefaultLibrarySpoofNativeIdentityTransform keeps a declaration package out
+// of the runtime-native authority even when its file is named like a TypeScript
+// default library (#2200).
+//
+// Runtime-native identity admits a global whose constructor a default library
+// provides, so how "default library" is decided is the whole boundary. `lib.d.ts`
+// is an ordinary published file name, so a base-name test makes that authority
+// claimable by any package a project pulls in through `typeRoots` — the forged
+// declarations below are a full-member copy of the DOM `File` and `Blob`,
+// including their `declare var` constructor bindings, and nothing but the
+// containing directory distinguishes them from the real thing.
+//
+//  1. Publish `lib.dom.d.ts` and `lib.es5.d.ts` from a fixture `@types` package
+//     that declares global File and Blob with their constructors.
+//  2. Transform validators for those globals with no DOM library and no Node
+//     types loaded, so the forged package is their only declaration source.
+//  3. Require the emit to keep the forged members instead of an `instanceof`.
+//  4. Execute the validators in Node against the forged structural values and
+//     against the real runtime instances, requiring an exact case count.
+func TestDefaultLibrarySpoofNativeIdentityTransform(t *testing.T) {
+  project := defaultLibrarySpoofNativeIdentityProject(t)
+  js, errText, code := ttscTypiaTestCapture(func() int {
+    return runTransform([]string{
+      "--cwd", project,
+      "--tsconfig", "tsconfig.json",
+      "--file", "src/input.ts",
+      "--output", "js",
+    })
+  })
+  if code != 0 {
+    t.Fatalf("default library spoof transform failed: code=%d stderr=\n%s", code, errText)
+  }
+
+  failures := []string{}
+  for _, native := range []string{"instanceof File", "instanceof Blob"} {
+    if strings.Contains(js, native) {
+      failures = append(failures, fmt.Sprintf("a lib.*.d.ts named package declaration was promoted to %q", native))
+    }
+  }
+  for _, member := range []string{"spoofBlobBrand", "spoofFileBrand"} {
+    if !strings.Contains(js, member) {
+      failures = append(failures, fmt.Sprintf("emit dropped forged declaration member %q", member))
+    }
+  }
+
+  output, runtimeErr := defaultLibrarySpoofNativeIdentityRun(t, project, js)
+  if runtimeErr != nil {
+    failures = append(failures, fmt.Sprintf("runtime matrix failed: %v\n%s", runtimeErr, output))
+  }
+  if expected := "RAN 6 SPOOF CASES"; !strings.Contains(output, expected) {
+    failures = append(failures, fmt.Sprintf("spoof runner did not report %q; got:\n%s", expected, output))
+  }
+  if len(failures) != 0 {
+    t.Fatalf("default library spoof mismatches:\n%s\n\nemit:\n%s", strings.Join(failures, "\n"), js)
+  }
+}
+
+func defaultLibrarySpoofNativeIdentityProject(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, "default-library-spoof-native-identity-")
+  if err != nil {
+    t.Fatalf("create temp fixture: %v", err)
+  }
+  t.Cleanup(func() {
+    _ = os.RemoveAll(dir)
+  })
+  for name, content := range map[string]string{
+    "tsconfig.json": defaultLibrarySpoofNativeIdentityTSConfig,
+    "node_modules/@types/spoof-lib/package.json": defaultLibrarySpoofNativeIdentityPackageJSON,
+    "node_modules/@types/spoof-lib/lib.dom.d.ts": defaultLibrarySpoofNativeIdentityDeclarations,
+    "node_modules/@types/spoof-lib/lib.es5.d.ts": defaultLibrarySpoofNativeIdentityExtraDeclarations,
+    "src/input.ts": defaultLibrarySpoofNativeIdentitySource,
+  } {
+    path := filepath.Join(dir, filepath.FromSlash(name))
+    if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+      t.Fatalf("mkdir fixture path %s: %v", filepath.Dir(path), err)
+    }
+    if err := os.WriteFile(path, []byte(content), 0o644); err != nil {
+      t.Fatalf("write fixture file %s: %v", path, err)
+    }
+  }
+  return dir
+}
+
+func defaultLibrarySpoofNativeIdentityRun(t *testing.T, project string, js string) (string, error) {
+  t.Helper()
+  node, err := exec.LookPath("node")
+  if err != nil {
+    t.Skip("node executable not found")
+    return "", nil
+  }
+  runtimeDir := filepath.Join(project, "runtime")
+  if err := os.MkdirAll(runtimeDir, 0o755); err != nil {
+    t.Fatalf("mkdir runtime dir: %v", err)
+  }
+  ttscTypiaTestWriteCommonRuntimeStubs(t, runtimeDir)
+  for name, content := range map[string]string{
+    "input.cjs": ttscTypiaTestRewriteCommonJS(t, js),
+    "run.cjs":   defaultLibrarySpoofNativeIdentityRuntimeRunner,
+  } {
+    if err := os.WriteFile(filepath.Join(runtimeDir, name), []byte(content), 0o644); err != nil {
+      t.Fatalf("write runtime file %s: %v", name, err)
+    }
+  }
+  cmd := exec.Command(node, filepath.Join(runtimeDir, "run.cjs"))
+  cmd.Dir = runtimeDir
+  output, err := cmd.CombinedOutput()
+  return string(output), err
+}
+
+const defaultLibrarySpoofNativeIdentityTSConfig = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "moduleResolution": "bundler",
+    "ignoreDeprecations": "6.0",
+    "lib": ["ES2022"],
+    "types": ["spoof-lib"],
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}
+`
+
+const defaultLibrarySpoofNativeIdentityPackageJSON = `{
+  "name": "@types/spoof-lib",
+  "version": "1.0.0",
+  "types": "lib.dom.d.ts"
+}
+`
+
+const defaultLibrarySpoofNativeIdentityDeclarations = `/// <reference path="./lib.es5.d.ts" />
+
+interface Blob {
+  readonly size: number;
+  readonly type: string;
+  spoofBlobBrand: string;
+}
+declare var Blob: {
+  prototype: Blob;
+  new (parts?: unknown[], options?: unknown): Blob;
+};
+`
+
+const defaultLibrarySpoofNativeIdentityExtraDeclarations = `interface File extends Blob {
+  readonly lastModified: number;
+  readonly name: string;
+  readonly webkitRelativePath: string;
+  spoofFileBrand: string;
+}
+declare var File: {
+  prototype: File;
+  new (parts: unknown[], name: string, options?: unknown): File;
+};
+`
+
+const defaultLibrarySpoofNativeIdentitySource = `import typia from "typia";
+
+export const createdIsBlob = typia.createIs<Blob>();
+export const createdIsFile = typia.createIs<File>();
+`
+
+const defaultLibrarySpoofNativeIdentityRuntimeRunner = `const validators = require("./input.cjs");
+
+let ran = 0;
+const failures = [];
+const eq = (name, actual, expected) => {
+  ran += 1;
+  if (actual !== expected) {
+    failures.push(name + ": expected " + expected + " but got " + actual);
+  }
+};
+
+const spoofBlob = {
+  size: 1,
+  type: "text/plain",
+  spoofBlobBrand: "spoof",
+};
+const spoofFile = {
+  ...spoofBlob,
+  lastModified: 0,
+  name: "x.txt",
+  webkitRelativePath: "",
+  spoofFileBrand: "spoof",
+};
+
+eq("spoof Blob structural", validators.createdIsBlob(spoofBlob), true);
+eq("spoof Blob rejects runtime instance", validators.createdIsBlob(new Blob(["x"])), false);
+eq("spoof Blob missing brand", validators.createdIsBlob({ size: 1, type: "text/plain" }), false);
+eq("spoof File structural", validators.createdIsFile(spoofFile), true);
+eq("spoof File rejects runtime instance", validators.createdIsFile(new File(["x"], "x.txt")), false);
+eq("spoof File missing brand", validators.createdIsFile({ ...spoofFile, spoofFileBrand: undefined }), false);
+
+console.log("RAN " + ran + " SPOOF CASES");
+if (failures.length !== 0) {
+  throw new Error("MISMATCHES:\n" + failures.join("\n"));
+}
+`

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

@@ -0,0 +1,193 @@
+package main
+
+import (
+  "os"
+  "os/exec"
+  "path/filepath"
+  "testing"
+)
+
+// TestEscapedPropertyKeyPathTransform verifies emits with hostile keys parse.
+//
+// Sole-literal property keys are folded into the emit as accessor path text, and
+// no build step reads the file back, so a wrongly escaped key shipped as a
+// broken artifact while ttsc still exited 0. A `"` in a key terminated the path
+// string early and the emitted module stopped being JavaScript; a control
+// character stayed raw and the reported path could not be parsed. Only running
+// node against a real emit can catch that, which is why this asserts on the
+// transform output rather than on the factory in isolation.
+//
+//  1. Transform a fixture whose keys carry quotes, backslashes, and control
+//     characters.
+//  2. Assert node --check accepts the emitted module as JavaScript.
+//  3. Execute it and assert each reported path is the accessor JSON.stringify
+//     defines for that key, which is what the runtime helper produces for
+//     dynamic keys.
+func TestEscapedPropertyKeyPathTransform(t *testing.T) {
+  project := escapedPropertyKeyPathProject(t)
+  js := escapedPropertyKeyPathTransform(t, project)
+  escapedPropertyKeyPathCheckSyntax(t, project, js)
+  escapedPropertyKeyPathRunRuntimeCases(t, project, js)
+}
+
+func escapedPropertyKeyPathProject(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, "escaped-property-key-path-")
+  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(escapedPropertyKeyPathTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(escapedPropertyKeyPathSource), 0o644); err != nil {
+    t.Fatalf("write source: %v", err)
+  }
+  return dir
+}
+
+func escapedPropertyKeyPathTransform(t *testing.T, project string) string {
+  t.Helper()
+  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("escaped property key transform failed: code=%d stderr=\n%s", code, errText)
+  }
+  return out
+}
+
+// escapedPropertyKeyPathCheckSyntax runs node against the emit exactly as it
+// would ship. node --check only parses, so the unresolved typia imports in the
+// untouched output do not matter, and that keeps this a check of the real
+// artifact rather than of a rewritten copy.
+func escapedPropertyKeyPathCheckSyntax(t *testing.T, project string, js string) {
+  t.Helper()
+  node, err := exec.LookPath("node")
+  if err != nil {
+    t.Skip("node executable not found")
+  }
+  emitted := filepath.Join(project, "emitted.cjs")
+  if err := os.WriteFile(emitted, []byte(js), 0o644); err != nil {
+    t.Fatalf("write emitted module: %v", err)
+  }
+  if output, err := exec.Command(node, "--check", emitted).CombinedOutput(); err != nil {
+    t.Fatalf("emitted module is not valid JavaScript: %v\n%s\n--- emit ---\n%s", err, output, js)
+  }
+}
+
+func escapedPropertyKeyPathRunRuntimeCases(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(escapedPropertyKeyPathRuntimeRunner), 0o644); err != nil {
+    t.Fatalf("write runtime runner: %v", err)
+  }
+  cmd := exec.Command(node, runner)
+  cmd.Dir = project
+  if output, err := cmd.CombinedOutput(); err != nil {
+    t.Fatalf("escaped property key runtime cases failed: %v\n%s", err, output)
+  }
+}
+
+const escapedPropertyKeyPathTSConfig = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "moduleResolution": "bundler",
+    "ignoreDeprecations": "6.0",
+    "types": ["*"],
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}
+`
+
+const escapedPropertyKeyPathSource = `import typia from "typia";
+
+interface IHostileKeys {
+  "quote\"key": number;
+  "back\\slash": number;
+  "line\nbreak": number;
+  "tab\tkey": number;
+  "bell\u0007key": number;
+  "nul\u0000key": number;
+  "sep\u2028key": number;
+  "plain-key": number;
+  plainIdentifier: number;
+}
+
+export const KEYS: string[] = [
+  "quote\"key",
+  "back\\slash",
+  "line\nbreak",
+  "tab\tkey",
+  "bell\u0007key",
+  "nul\u0000key",
+  "sep\u2028key",
+  "plain-key",
+];
+
+const validateHostile = typia.createValidate<IHostileKeys>();
+
+export const run = () => {
+  const input: Record<string, unknown> = { plainIdentifier: 1 };
+  for (const key of KEYS) input[key] = "not a number";
+  return validateHostile(input);
+};
+`
+
+// The expected path is rebuilt with JSON.stringify rather than written out
+// literally, because that is the contract _accessExpressionAsString implements
+// for dynamic keys and the compile-time fold must agree with it.
+const escapedPropertyKeyPathRuntimeRunner = `const mod = require("./main.cjs");
+const result = mod.run();
+
+if (result.success !== false) {
+  throw new Error("validate accepted non-number values");
+}
+for (const key of mod.KEYS) {
+  const expected = "$input[" + JSON.stringify(key) + "]";
+  const found = result.errors.find((error) => error.path === expected);
+  if (!found) {
+    throw new Error(
+      "missing path for key " + JSON.stringify(key) +
+        ": expected " + JSON.stringify(expected) +
+        ", got " + JSON.stringify(result.errors.map((error) => error.path)),
+    );
+  }
+}
+if (result.errors.some((error) => error.path === "$input.plainIdentifier")) {
+  throw new Error("identifier fast path reported an error for a valid value");
+}
+`

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 })),
+});
+`