typia 13.1.1 → 13.2.0

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

@@ -0,0 +1,224 @@
+package main
+
+import (
+  "os"
+  "os/exec"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestPatternLineTerminatorEscapeTransform verifies that a line terminator in a
+// structural (template-literal-type or dynamic-key) pattern is escaped before it
+// is spliced into an emitted `RegExp(/.../)` literal.
+//
+// A JavaScript regex literal cannot contain a raw line terminator, so a template
+// literal type or dynamic key whose literal part holds one of the four
+// ECMAScript LineTerminators (LF, CR, U+2028, U+2029) produced an unparsable
+// module while the transform still exited 0 (a false-green). `PatternUtil.Escape`
+// escaped the regex metacharacters but not the line terminators, and it is the
+// single source feeding every regex-literal sink (`check_template`,
+// `stringify_dynamic_properties`, `prune_object_properties`, and the
+// clone/prune/classify/notation joiners), so one fixture that drives `is`,
+// `json.stringify`, `clone`, `prune`, and `notations` over line-terminator
+// patterns exercises them all (#2211).
+//
+//  1. Transform a fixture whose template literal types and Record dynamic keys
+//     carry each of the four line terminators, across every affected operation.
+//  2. Assert the transform exits 0 and `node --check` accepts the whole emit as
+//     JavaScript -- RED before the fix (raw LF/CR/LS/PS in a regex literal).
+//  3. Execute the emit and assert each `is` predicate matches a
+//     line-terminator-containing value and rejects a value that lacks it.
+func TestPatternLineTerminatorEscapeTransform(t *testing.T) {
+  project := patternLineTerminatorProject(t)
+  js := patternLineTerminatorTransform(t, project)
+  // A line-terminator-free template still lowers to its historical pattern, so
+  // nothing but the escaped line terminators changes.
+  if !strings.Contains(js, "RegExp(/^prefix(.*)postfix$/)") {
+    t.Fatalf("line-terminator-free pattern must keep its historical form:\n%s", js)
+  }
+  patternLineTerminatorCheckSyntax(t, project, js)
+  patternLineTerminatorRunRuntimeCases(t, project, js)
+}
+
+func patternLineTerminatorProject(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, "pattern-line-terminator-")
+  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(patternLineTerminatorTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(patternLineTerminatorSource), 0o644); err != nil {
+    t.Fatalf("write source: %v", err)
+  }
+  return dir
+}
+
+func patternLineTerminatorTransform(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("line terminator pattern transform failed: code=%d stderr=\n%s", code, errText)
+  }
+  return out
+}
+
+// patternLineTerminatorCheckSyntax 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, which keeps this a check of the real artifact.
+func patternLineTerminatorCheckSyntax(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 patternLineTerminatorRunRuntimeCases(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)
+  // json.stringify pulls in _jsonStringifyNumber, which the shared rewrite does
+  // not map; stub it locally so the whole module loads. The runner only exercises
+  // the `is` predicates, so the stub body is immaterial.
+  if err := os.WriteFile(filepath.Join(runtimeDir, "json-stringify-number-stub.cjs"), []byte(patternLineTerminatorNumberStub), 0o644); err != nil {
+    t.Fatalf("write json stringify number stub: %v", err)
+  }
+  runtimeJS := strings.ReplaceAll(js, `require("typia/lib/internal/_jsonStringifyNumber")`, `require("./json-stringify-number-stub.cjs")`)
+  runtimeJS = ttscTypiaTestRewriteCommonJS(t, runtimeJS)
+  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(patternLineTerminatorRuntimeRunner), 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("line terminator pattern runtime cases failed: %v\n%s", err, output)
+  }
+}
+
+const patternLineTerminatorNumberStub = `module.exports._jsonStringifyNumber = (value) => String(value);
+`
+
+const patternLineTerminatorTSConfig = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "moduleResolution": "bundler",
+    "ignoreDeprecations": "6.0",
+    "types": ["*"],
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}
+`
+
+// The template literal types embed the line terminators as TypeScript escapes
+// (backslash n, backslash r, backslash u2028, backslash u2029), which the
+// compiler folds into real line terminator characters in the literal type --
+// the exact trigger.
+const patternLineTerminatorSource = `import typia from "typia";
+
+export const isLF = typia.createIs<` + "`a\\n${string}b`" + `>();
+export const isCR = typia.createIs<` + "`a\\r${string}b`" + `>();
+export const isLS = typia.createIs<` + "`a\\u2028${string}b`" + `>();
+export const isPS = typia.createIs<` + "`a\\u2029${string}b`" + `>();
+export const isControl = typia.createIs<` + "`prefix${string}postfix`" + `>();
+
+type LFRecord = Record<` + "`a\\n${string}`" + `, number>;
+export const isRecord = typia.createIs<LFRecord>();
+export const stringifyRecord = typia.json.createStringify<LFRecord>();
+export const cloneRecord = typia.plain.createClone<LFRecord>();
+export const pruneRecord = typia.plain.createPrune<LFRecord>();
+export const camelRecord = typia.notations.createCamel<LFRecord>();
+`
+
+// Every value's only line terminator is the one the template's literal part
+// pins, so the trailing `(.*)` (dot excludes newlines) still matches the tail.
+// LF/CR go in as JS escapes and U+2028/U+2029 via String.fromCharCode so this
+// source carries no raw line terminator of its own.
+const patternLineTerminatorRuntimeRunner = `const mod = require("./main.cjs");
+
+const LS = String.fromCharCode(0x2028);
+const PS = String.fromCharCode(0x2029);
+const cases = [
+  ["isLF", "a\nZZb", "aZZb"],
+  ["isCR", "a\rZZb", "aZZb"],
+  ["isLS", "a" + LS + "ZZb", "aZZb"],
+  ["isPS", "a" + PS + "ZZb", "aZZb"],
+];
+for (const [name, good, bad] of cases) {
+  if (mod[name](good) !== true) {
+    throw new Error(name + " must accept a value carrying its line terminator: " + JSON.stringify(good));
+  }
+  if (mod[name](bad) !== false) {
+    throw new Error(name + " must reject a value lacking its line terminator: " + JSON.stringify(bad));
+  }
+}
+
+if (mod.isControl("prefix_mid_postfix") !== true) {
+  throw new Error("line-terminator-free template must still accept a conforming value");
+}
+if (mod.isControl("nope") !== false) {
+  throw new Error("line-terminator-free template must still reject a non-conforming value");
+}
+
+// A Record index signature only constrains keys its key pattern matches, so the
+// newline in the key regex is what decides which keys get the number check. A
+// matching key with a bad value must fail, while a near-miss key that lacks the
+// newline is not matched (and so is left unchecked) -- together they prove the
+// escaped line terminator is load-bearing in the emitted regex.
+const goodRecord = {};
+goodRecord["a\nkey"] = 1;
+if (mod.isRecord(goodRecord) !== true) {
+  throw new Error("Record: a matching key with a number value must pass");
+}
+const matchedBadValue = {};
+matchedBadValue["a\nkey"] = "not a number";
+if (mod.isRecord(matchedBadValue) !== false) {
+  throw new Error("Record: a newline-matching key with a non-number value must fail");
+}
+if (mod.isRecord({ "axkey": "not a number" }) !== true) {
+  throw new Error("Record: a key lacking the newline must not match the pattern, so it stays unchecked");
+}
+`

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

@@ -0,0 +1,219 @@
+package main
+
+import (
+  "os"
+  "os/exec"
+  "path/filepath"
+  "testing"
+)
+
+// TestPlainPruneUnionObjectOvermatchTransform pins prune over mixed unions.
+//
+// PlainPruneProgrammer emits one independent `if` per union member, and the
+// object arm's guard is `IsObject` with `CheckArray:false`, which also matches
+// arrays and native instances. With no `else` the array/native arm AND the
+// object arm both run, so `Object.keys(input)` on a value another arm already
+// owns gets its slots deleted: a typed array throws on `delete input[0]`, a
+// plain array collapses to holes, and a native's own properties are stripped.
+// clone/classify resolve the same unions with a mutually exclusive ladder, so
+// the object arm is only reached when the value is a plain object. This test
+// drives every native kind unioned with an object in both orders, plus an
+// object∪tuple, and requires the native/array/tuple value to survive intact.
+//
+//  1. Transform prune factories over native|object, object|native, array|object
+//     and object|tuple unions.
+//  2. Execute prune against a typed array, Date, Map, Set, RegExp, plain array,
+//     and tuple, requiring each to keep its identity and own state.
+//  3. Require the object arm still prunes an ordinary object member.
+func TestPlainPruneUnionObjectOvermatchTransform(t *testing.T) {
+  project := plainPruneUnionObjectOvermatchProject(t)
+  out, errText, code := ttscTypiaTestCapture(func() int {
+    return runTransform([]string{
+      "--cwd", project,
+      "--tsconfig", "tsconfig.json",
+      "--file", "src/main.ts",
+      "--output", "js",
+    })
+  })
+  if code != 0 {
+    t.Fatalf("prune union/object over-match transform failed: code=%d stderr=\n%s", code, errText)
+  }
+  plainPruneUnionObjectOvermatchRunRuntimeCases(t, project, out)
+}
+
+func plainPruneUnionObjectOvermatchProject(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, "plain-prune-union-object-")
+  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(plainPruneUnionObjectOvermatchTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(plainPruneUnionObjectOvermatchSource), 0o644); err != nil {
+    t.Fatalf("write source: %v", err)
+  }
+  return dir
+}
+
+func plainPruneUnionObjectOvermatchRunRuntimeCases(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(plainPruneUnionObjectOvermatchRuntimeRunner), 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("prune union/object over-match runtime cases failed: %v\n%s", err, output)
+  }
+}
+
+const plainPruneUnionObjectOvermatchTSConfig = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "moduleResolution": "bundler",
+    "ignoreDeprecations": "6.0",
+    "types": ["*"],
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}
+`
+
+const plainPruneUnionObjectOvermatchSource = `import typia from "typia";
+
+interface IBox {
+  x: number;
+}
+interface IElem {
+  y: number;
+}
+
+export const pruneBytesFirst = typia.plain.createPrune<Uint8Array | IBox>();
+export const pruneBytesLast = typia.plain.createPrune<IBox | Uint8Array>();
+export const pruneDateFirst = typia.plain.createPrune<Date | IBox>();
+export const pruneDateLast = typia.plain.createPrune<IBox | Date>();
+export const pruneMap = typia.plain.createPrune<Map<string, number> | IBox>();
+export const pruneSet = typia.plain.createPrune<IBox | Set<number>>();
+export const pruneRegExp = typia.plain.createPrune<RegExp | IBox>();
+export const pruneArray = typia.plain.createPrune<IElem[] | IBox>();
+export const pruneTuple = typia.plain.createPrune<IBox | [IElem, IElem]>();
+`
+
+const plainPruneUnionObjectOvermatchRuntimeRunner = `const mod = require("./main.cjs");
+
+const fail = (label, detail) => {
+  throw new Error(label + ": " + detail);
+};
+
+// 1. A typed array must survive prune untouched (the buggy object arm throws
+//    "Cannot delete property '0'" while deleting its integer-indexed slots).
+for (const [label, prune] of [
+  ["Uint8Array | IBox", mod.pruneBytesFirst],
+  ["IBox | Uint8Array", mod.pruneBytesLast],
+]) {
+  const bytes = new Uint8Array([1, 2, 3]);
+  prune(bytes);
+  if (!(bytes instanceof Uint8Array) || bytes.length !== 3 || bytes[0] !== 1 || bytes[1] !== 2 || bytes[2] !== 3)
+    fail(label, "typed array corrupted -> " + JSON.stringify(Array.from(bytes)));
+}
+
+// 2. A Date must keep its time and its own state; the object arm strips own keys.
+for (const [label, prune] of [
+  ["Date | IBox", mod.pruneDateFirst],
+  ["IBox | Date", mod.pruneDateLast],
+]) {
+  const date = new Date(1000);
+  date.tag = "keep";
+  prune(date);
+  if (!(date instanceof Date) || date.getTime() !== 1000)
+    fail(label, "Date time corrupted -> " + date.getTime());
+  if (date.tag !== "keep")
+    fail(label, "Date own property stripped");
+}
+
+// 3. A Map / Set must keep their contents and own state.
+{
+  const map = new Map([["a", 1]]);
+  map.tag = "keep";
+  mod.pruneMap(map);
+  if (!(map instanceof Map) || map.size !== 1 || map.get("a") !== 1 || map.tag !== "keep")
+    fail("Map<string,number> | IBox", "Map corrupted");
+}
+{
+  const set = new Set([7]);
+  set.tag = "keep";
+  mod.pruneSet(set);
+  if (!(set instanceof Set) || set.size !== 1 || set.has(7) === false || set.tag !== "keep")
+    fail("IBox | Set<number>", "Set corrupted");
+}
+
+// 4. A RegExp with equal source but its own state must survive.
+{
+  const re = /abc/gi;
+  re.tag = "keep";
+  mod.pruneRegExp(re);
+  if (!(re instanceof RegExp) || re.source !== "abc" || re.flags !== "gi" || re.tag !== "keep")
+    fail("RegExp | IBox", "RegExp corrupted");
+}
+
+// 5. A plain array must be pruned element-by-element, not deleted to holes.
+{
+  const arr = [{ y: 1, extra: 2 }, { y: 3, extra: 4 }];
+  mod.pruneArray(arr);
+  if (!Array.isArray(arr) || arr.length !== 2)
+    fail("IElem[] | IBox", "array shape corrupted -> " + JSON.stringify(arr));
+  if (arr[0] === undefined || arr[1] === undefined)
+    fail("IElem[] | IBox", "array slot deleted -> " + JSON.stringify(arr));
+  if (arr[0].y !== 1 || arr[1].y !== 3 || "extra" in arr[0] || "extra" in arr[1])
+    fail("IElem[] | IBox", "array elements not pruned as objects -> " + JSON.stringify(arr));
+}
+
+// 6. An object∪tuple must prune the tuple positionally, not delete its slots.
+{
+  const tuple = [{ y: 1, extra: 2 }, { y: 3, extra: 4 }];
+  mod.pruneTuple(tuple);
+  if (!Array.isArray(tuple) || tuple.length !== 2 || tuple[0] === undefined || tuple[1] === undefined)
+    fail("IBox | [IElem, IElem]", "tuple slot deleted -> " + JSON.stringify(tuple));
+  if (tuple[0].y !== 1 || tuple[1].y !== 3 || "extra" in tuple[0] || "extra" in tuple[1])
+    fail("IBox | [IElem, IElem]", "tuple elements not pruned -> " + JSON.stringify(tuple));
+}
+
+// 7. The object arm must still prune an ordinary object member (nothing lost).
+{
+  const box = { x: 1, junk: "drop" };
+  mod.pruneBytesFirst(box);
+  if (box.x !== 1 || "junk" in box)
+    fail("Uint8Array | IBox", "object member not pruned -> " + JSON.stringify(box));
+}
+`

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

@@ -0,0 +1,181 @@
+package main
+
+import (
+  "os"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// pluginOptionsPayloadCase is one row of the #1887 regression matrix: a project
+// whose tsconfig the user wrote a particular way, the payload ttsc resolves that
+// tsconfig into and hands the plugin, and whether typia's `functional` option is
+// on as a result.
+//
+// `functional` is the probe because its effect is visible in the transform's own
+// output: with the option on, a function-typed property becomes significant and
+// the emitted validator checks it; with the option off, the property is skipped.
+type pluginOptionsPayloadCase struct {
+  name string
+  // base is a base tsconfig the leaf `extends`, or "" for a single-file project.
+  base string
+  // leafPlugins is the `compilerOptions.plugins` text of the leaf tsconfig, or
+  // "" when the leaf declares no plugins at all.
+  leafPlugins string
+  // payload is the `--plugins-json` manifest ttsc sends for this project.
+  payload string
+  // functional is whether the emitted validator must check the function-typed
+  // property.
+  functional bool
+}
+
+// pluginOptionsPayloadCases returns the matrix every host must satisfy.
+//
+// Each row pairs the tsconfig the user wrote with the payload the host resolves
+// it into, so the oracle is ttsc's plugin contract rather than typia's current
+// output. The rows are the reproduction table of samchon/typia#1887: the
+// comment and sibling-entry rows prove typia no longer matches option names
+// against raw tsconfig text, and the `extends` row proves it no longer ignores
+// the entry that loaded it.
+func pluginOptionsPayloadCases() []pluginOptionsPayloadCase {
+  return []pluginOptionsPayloadCase{
+    {
+      // The documented shape, and the only one the old scrape read correctly.
+      // Pins behavior that must not change.
+      name:        "option inline on typia's entry",
+      leafPlugins: `[{ "transform": "typia/lib/transform", "functional": true }]`,
+      payload:     `[{"config":{"transform":"typia/lib/transform","functional":true},"name":"typia","stage":"transform"}]`,
+      functional:  true,
+    },
+    {
+      // The user disabled the option. tsconfig is JSONC, so the host drops the
+      // comment and typia's entry carries nothing.
+      name: "option commented out with a line comment",
+      leafPlugins: `[{
+        "transform": "typia/lib/transform"
+        // "functional": true
+      }]`,
+      payload:    `[{"config":{"transform":"typia/lib/transform"},"name":"typia","stage":"transform"}]`,
+      functional: false,
+    },
+    {
+      name: "option commented out with a block comment",
+      leafPlugins: `[{
+        "transform": "typia/lib/transform"
+        /* "functional": true */
+      }]`,
+      payload:    `[{"config":{"transform":"typia/lib/transform"},"name":"typia","stage":"transform"}]`,
+      functional: false,
+    },
+    {
+      // A transform host carries every transform-stage plugin's entry. The
+      // option belongs to the sibling, and reading it would be reading someone
+      // else's configuration.
+      name: "option owned by another plugin's entry",
+      leafPlugins: `[
+        { "transform": "other/lib/transform", "functional": true },
+        { "transform": "typia/lib/transform" }
+      ]`,
+      payload: `[
+        {"config":{"transform":"other/lib/transform","functional":true},"name":"other","stage":"transform"},
+        {"config":{"transform":"typia/lib/transform"},"name":"typia","stage":"transform"}
+      ]`,
+      functional: false,
+    },
+    {
+      // The standard monorepo layout: a shared base declares the plugin and its
+      // options, the leaf only extends it. The host resolved the chain and sent
+      // the merged entry -- which is why the plugin is running at all.
+      name: "option declared in a base tsconfig the leaf extends",
+      base: `{
+  "compilerOptions": {
+    "plugins": [{ "transform": "typia/lib/transform", "functional": true }]
+  }
+}
+`,
+      payload:    `[{"config":{"transform":"typia/lib/transform","functional":true},"name":"typia","stage":"transform"}]`,
+      functional: true,
+    },
+  }
+}
+
+// pluginOptionsPayloadProject materializes one matrix row as a real project: the
+// tsconfig exactly as the user wrote it (comments, sibling entries, `extends`
+// chain and all), a typia stub to resolve the import against, and a source file
+// with a function-typed property for the option to act on.
+func pluginOptionsPayloadProject(t *testing.T, tc pluginOptionsPayloadCase) string {
+  t.Helper()
+  project := t.TempDir()
+  src := filepath.Join(project, "src")
+  if err := os.MkdirAll(src, 0o755); err != nil {
+    t.Fatalf("mkdir fixture src: %v", err)
+  }
+
+  extends := ""
+  if tc.base != "" {
+    if err := os.WriteFile(filepath.Join(project, "tsconfig.base.json"), []byte(tc.base), 0o644); err != nil {
+      t.Fatalf("write base tsconfig: %v", err)
+    }
+    extends = `"extends": "./tsconfig.base.json",
+  `
+  }
+  plugins := ""
+  if tc.leafPlugins != "" {
+    plugins = `,
+    "plugins": ` + tc.leafPlugins
+  }
+  config := `{
+  ` + extends + `"compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "moduleResolution": "bundler",
+    "ignoreDeprecations": "6.0",
+    "types": ["*"],
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "rootDir": "src",
+    "outDir": "dist"` + plugins + `
+  },
+  "include": ["src"]
+}
+`
+  if err := os.WriteFile(filepath.Join(project, "tsconfig.json"), []byte(config), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  transformDiagnosticWriteTypiaStub(t, project)
+  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(pluginOptionsPayloadSource), 0o644); err != nil {
+    t.Fatalf("write source: %v", err)
+  }
+  return project
+}
+
+// pluginOptionsPayloadAssert checks one host's output against the row's expected
+// option state.
+func pluginOptionsPayloadAssert(t *testing.T, tc pluginOptionsPayloadCase, output string) {
+  t.Helper()
+  checked := pluginOptionsPayloadFunctionalCheck(output)
+  if checked == tc.functional {
+    return
+  }
+  if tc.functional {
+    t.Fatalf("functional is configured on but the validator skipped the function property:\n%s", output)
+  }
+  t.Fatalf("functional is not configured but the validator checked the function property:\n%s", output)
+}
+
+func pluginOptionsPayloadFunctionalCheck(output string) bool {
+  return strings.Contains(output, pluginOptionsPayloadFunctionalNeedle)
+}
+
+// pluginOptionsPayloadFunctionalNeedle is the guard typia emits for the
+// function-typed property only when `functional` is enabled.
+const pluginOptionsPayloadFunctionalNeedle = `"function" === typeof input.cb`
+
+const pluginOptionsPayloadSource = `import typia from "typia";
+export interface IX {
+  value: number;
+  cb: () => void;
+}
+export const check = (input: unknown): boolean => typia.is<IX>(input);
+`