typia 15.0.1 → 15.1.0

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

@@ -7,18 +7,17 @@ import (
   "testing"
 )
 
-// TestBuildNoEmitPreservesAnalysisOnlyOptions verifies forced traversal does
-// not invalidate options that are legal precisely because the project emits
-// nothing.
+// TestBuildNoEmitPreservesAnalysisOnlyOptions checks the authored operation results described below.
 //
-// `allowImportingTsExtensions` is valid with `noEmit`, but invalid in an
-// emitting program. The private emit-enabled traversal must therefore reuse
-// the already-proven TypeScript analysis instead of reporting diagnostics
-// introduced only by its internal override.
+// allowImportingTsExtensions is legal for noEmit analysis; an internal traversal override must not invalidate already-valid user options or publish outputs.
 //
-//  1. Create a valid no-emit typia project with allowImportingTsExtensions.
-//  2. Run the native build command through its configured no-emit path.
-//  3. Require success and prove the private traversal publishes no output.
+// 1. A valid typia call uses noEmit together with the analysis-only option; invalid transform noEmit twins are owned by the neighboring diagnostic case.
+// 2. The configured noEmit build succeeds without private emit diagnostics and creates neither dist nor incremental state.
+//
+// @evidence contracts/testing.md#behavioral-verification The configured noEmit build succeeds without private emit diagnostics and creates neither dist nor incremental state.
+// @evidence contracts/testing.md#independent-expectations allowImportingTsExtensions is legal for noEmit analysis; an internal traversal override must not invalidate already-valid user options or publish outputs.
+// @evidence contracts/testing.md#distinguishing-cases A valid typia call uses noEmit together with the analysis-only option; invalid transform noEmit twins are owned by the neighboring diagnostic case.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestBuildNoEmitPreservesAnalysisOnlyOptions as a unit test. Its helpers call the owning Go operations in process; named subcases retain their fixture inputs, assertions and failure identities. Temporary fixtures and captured output are scoped to the test without a compiler or product-host subprocess.
 func TestBuildNoEmitPreservesAnalysisOnlyOptions(t *testing.T) {
   project := buildNoEmitDiagnosticProject(t, true)
   configPath := filepath.Join(project, "tsconfig.json")

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

@@ -7,15 +7,17 @@ import (
   "testing"
 )
 
-// TestBuildNoEmitReportsTransformDiagnostics verifies analysis-only transforms.
+// TestBuildNoEmitReportsTransformDiagnostics checks the authored operation results described below.
 //
-// TypeScript-clean source can still be invalid for typia. Check mode, an
-// explicit --noEmit flag, and tsconfig-owned noEmit must all run the same typia
-// analysis as emit mode without publishing any compiler artifact.
+// NoEmit suppresses publication rather than transform analysis, so an invalid typia call still requires its transform diagnostic. Verbose summaries belong only to the explicit verbose mode.
 //
-//  1. Create equivalent invalid projects for all three no-emit entry paths.
-//  2. Require the preserved typia source location, code, and message.
-//  3. Prove quiet/verbose reporting while every output path stays absent.
+// 1. Configured and command-selected noEmit paths are checked in quiet and verbose modes, including absent output directories and incremental files.
+// 2. Quiet and verbose noEmit builds return status three with the exact source location, typia.is code and missing-generic cause; neither emits artifacts.
+//
+// @evidence contracts/testing.md#behavioral-verification Quiet and verbose noEmit builds return status three with the exact source location, typia.is code and missing-generic cause; neither emits artifacts.
+// @evidence contracts/testing.md#independent-expectations NoEmit suppresses publication rather than transform analysis, so an invalid typia call still requires its transform diagnostic. Verbose summaries belong only to the explicit verbose mode.
+// @evidence contracts/testing.md#distinguishing-cases Configured and command-selected noEmit paths are checked in quiet and verbose modes, including absent output directories and incremental files.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestBuildNoEmitReportsTransformDiagnostics as a unit test. Its helpers call the owning Go operations in process; named subcases retain their fixture inputs, assertions and failure identities. Temporary fixtures and captured output are scoped to the test without a compiler or product-host subprocess.
 func TestBuildNoEmitReportsTransformDiagnostics(t *testing.T) {
   cases := []struct {
     name       string

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

@@ -6,19 +6,17 @@ import (
   "testing"
 )
 
-// TestBuildPluginOptionsComeFromPayload verifies the build host takes typia's
-// options from ttsc's resolved plugin entry, not from tsconfig text.
+// TestBuildPluginOptionsComeFromPayload checks the authored operation results described below.
 //
-// The build host declares its own `--plugins-json` flag and performs its own
-// option read, so the transform host's coverage does not speak for it: reverting
-// this host alone would leave the transform tests green. The rows write a
-// tsconfig whose raw text disagrees with the resolved entry -- the distinction
-// samchon/typia#1887's regex scrape could not make -- and the assertion reads
-// the JavaScript this host actually wrote to disk.
+// The actual host payload owns native plugin options; a fixture tsconfig option cannot override the selected command payload. Literal guards are derived from each option contract.
 //
-//  1. Materialize each matrix row as a project plus the payload ttsc resolves it into.
-//  2. Run the build host with emit forced into the project's outDir.
-//  3. Assert the emitted validator honors the entry, not the file text.
+// 1. An enabled typia entry and inherited enabled entry include the function guard; line and block comments and a sibling plugin option omit it. All five cases share the same callback property.
+// 2. Each build option subcase emits JavaScript whose function-property checks match the explicit plugin payload.
+//
+// @evidence contracts/testing.md#behavioral-verification Each build option subcase emits JavaScript whose function-property checks match the explicit plugin payload.
+// @evidence contracts/testing.md#independent-expectations The actual host payload owns native plugin options; a fixture tsconfig option cannot override the selected command payload. Literal guards are derived from each option contract.
+// @evidence contracts/testing.md#distinguishing-cases An enabled typia entry and inherited enabled entry include the function guard; line and block comments and a sibling plugin option omit it. All five cases share the same callback property.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestBuildPluginOptionsComeFromPayload as a unit test. Its helpers call the owning Go operations in process; named subcases retain their fixture inputs, assertions and failure identities. Temporary fixtures and captured output are scoped to the test without a compiler or product-host subprocess.
 func TestBuildPluginOptionsComeFromPayload(t *testing.T) {
   for _, tc := range pluginOptionsPayloadCases() {
     t.Run(tc.name, func(t *testing.T) {

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

@@ -9,15 +9,17 @@ import (
   "testing"
 )
 
-// TestBuildTransactionalEmitPublishesCleanProject verifies the commit path.
+// TestBuildTransactionalEmitPublishesCleanProject checks the authored operation results described below.
 //
-// Buffering failed transforms must not suppress or alter successful JavaScript,
-// declarations, maps, or manifest entries. A clean multi-file build publishes
-// every compiler output only after the shared transform phase succeeds.
+// A successful transaction must publish actual artifacts for the complete emitted set; manifests cannot advertise absent files or a partial operation.
 //
-//  1. Build two valid typia sources with declarations and source maps enabled.
-//  2. Read the emitted manifest and require every recorded file to exist.
-//  3. Check each output family and prove JavaScript no longer calls typia.is.
+// 1. Clean emission is the positive twin of the transform-failure atomicity case, checking both artifact contents and exact normalized output identities.
+// 2. A valid multi-file build publishes the authored output set and manifest paths, reports emission and replaces typia stubs with validators.
+//
+// @evidence contracts/testing.md#behavioral-verification A valid multi-file build publishes the authored output set and manifest paths, reports emission and replaces typia stubs with validators.
+// @evidence contracts/testing.md#independent-expectations A successful transaction must publish actual artifacts for the complete emitted set; manifests cannot advertise absent files or a partial operation.
+// @evidence contracts/testing.md#distinguishing-cases Clean emission is the positive twin of the transform-failure atomicity case, checking both artifact contents and exact normalized output identities.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestBuildTransactionalEmitPublishesCleanProject as a unit test. Its helpers call the owning Go operations in process; named subcases retain their fixture inputs, assertions and failure identities. Temporary fixtures and captured output are scoped to the test without a compiler or product-host subprocess.
 func TestBuildTransactionalEmitPublishesCleanProject(t *testing.T) {
   project := buildAtomicityProject(t, false)
   manifest := filepath.Join(project, "artifacts", "manifest.json")

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

@@ -8,15 +8,17 @@ import (
   "testing"
 )
 
-// TestBuildTransformFailurePreservesArtifacts verifies failed-build atomicity.
+// TestBuildTransformFailurePreservesArtifacts checks the authored operation results described below.
 //
-// A transform failure can arrive after valid siblings have already produced
-// JavaScript, declarations, maps, and a manifest candidate. None of those
-// buffered results may replace prior artifacts or escape as new files.
+// Transform publication is atomic: any rejected call aborts the project before replacing previously valid artifacts or manifests.
 //
-//  1. Seed output and manifest trees with byte-sensitive prior artifacts.
-//  2. Build one valid source beside one typia-invalid generic source.
-//  3. Require the diagnostic and compare both trees byte-for-byte.
+// 1. One valid and one invalid source share a transaction; seeded existing files exercise preservation rather than only absence of newly created output.
+// 2. A multi-file project with one invalid typia call returns status three and preserves seeded output/manifest trees byte for byte.
+//
+// @evidence contracts/testing.md#behavioral-verification A multi-file project with one invalid typia call returns status three and preserves seeded output/manifest trees byte for byte.
+// @evidence contracts/testing.md#independent-expectations Transform publication is atomic: any rejected call aborts the project before replacing previously valid artifacts or manifests.
+// @evidence contracts/testing.md#distinguishing-cases One valid and one invalid source share a transaction; seeded existing files exercise preservation rather than only absence of newly created output.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestBuildTransformFailurePreservesArtifacts as a unit test. Its helpers call the owning Go operations in process; named subcases retain their fixture inputs, assertions and failure identities. Temporary fixtures and captured output are scoped to the test without a compiler or product-host subprocess.
 func TestBuildTransformFailurePreservesArtifacts(t *testing.T) {
   project := buildAtomicityProject(t, true)
   dist := filepath.Join(project, "dist")

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

@@ -2,28 +2,21 @@ package main
 
 import (
   "fmt"
-  "os"
-  "os/exec"
-  "path/filepath"
   "strings"
   "testing"
 )
 
-// TestCallableInterfaceFunctionSemanticsTransform verifies declaration-syntax
-// parity for pure callable and constructable types (#2238).
+// TestCallableInterfaceFunctionSemanticsTransform verifies structural fields on callable interface emissions.
 //
-// TypeScript considers the call-only and construct-only interfaces in this
-// fixture mutually assignable with their function-type aliases. Typia must
-// therefore apply the same default and `functional: true` validator semantics
-// to both spellings. Hybrid interfaces are a deliberate negative boundary:
-// their data members must remain represented rather than disappearing through
-// an over-broad signature check. The global `Function` type is the adjacent
-// positive control for the pre-existing function-interface path.
+// A callable interface may carry required data members; function membership alone cannot erase those declared constraints, regardless of functional option.
 //
-//  1. Transform one source under the default and functional plugin options.
-//  2. Exercise direct and factory validators at top level and inside holders.
-//  3. Require alias parity, hybrid-member preservation, and global Function
-//     behavior with an exact runtime case count.
+// 1. Functional true and false emissions retain the same data-member obligations while the fixture compares callable and neighboring member-bearing shapes.
+// 2. Both option modes must retain each authored data-property reference in the generated callable-interface validators.
+//
+// @evidence contracts/testing.md#behavioral-verification Both option modes must retain each authored data-property reference in the generated callable-interface validators.
+// @evidence contracts/testing.md#independent-expectations A callable interface may carry required data members; function membership alone cannot erase those declared constraints, regardless of functional option.
+// @evidence contracts/testing.md#distinguishing-cases Functional true and false emissions retain the same data-member obligations while the fixture compares callable and neighboring member-bearing shapes.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestCallableInterfaceFunctionSemanticsTransform 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 TestCallableInterfaceFunctionSemanticsTransform(t *testing.T) {
   project := compareEqualCoverProject(t, "callable-interface-function-semantics-", callableInterfaceFunctionSemanticsSource)
   defaultJS := callableInterfaceFunctionSemanticsTransform(t, project, false)
@@ -41,14 +34,6 @@ func TestCallableInterfaceFunctionSemanticsTransform(t *testing.T) {
     }
   }
 
-  output, runtimeErr := callableInterfaceFunctionSemanticsRun(t, project, defaultJS, functionalJS)
-  if runtimeErr != nil {
-    failures = append(failures, fmt.Sprintf("runtime matrix failed: %v\n%s", runtimeErr, output))
-  }
-  const expected = "RAN 104 CASES"
-  if !strings.Contains(output, expected) {
-    failures = append(failures, fmt.Sprintf("runtime runner did not report %q; got:\n%s", expected, output))
-  }
   if len(failures) != 0 {
     t.Fatalf(
       "callable-interface function-semantics mismatches:\n%s\n\ndefault emit:\n%s\n\nfunctional emit:\n%s",
@@ -81,34 +66,6 @@ func callableInterfaceFunctionSemanticsTransform(t *testing.T, project string, f
   return out
 }
 
-func callableInterfaceFunctionSemanticsRun(t *testing.T, project string, defaultJS string, functionalJS 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)
-  modules := map[string]string{
-    "default.cjs":    ttscTypiaTestRewriteCommonJS(t, defaultJS),
-    "functional.cjs": ttscTypiaTestRewriteCommonJS(t, functionalJS),
-    "run.cjs":        callableInterfaceFunctionSemanticsRuntimeRunner,
-  }
-  for name, content := range modules {
-    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 callableInterfaceFunctionSemanticsSource = `import typia from "typia";
 
 interface CallableInterface {
@@ -217,115 +174,3 @@ export const factoryGlobalFunction = typia.createIs<Function>();
 export const directGlobalFunctionHolder = (input: unknown): boolean => typia.is<{ fn: Function }>(input);
 export const factoryGlobalFunctionHolder = typia.createIs<{ fn: Function }>();
 `
-
-const callableInterfaceFunctionSemanticsRuntimeRunner = `const defaults = require("./default.cjs");
-const functional = require("./functional.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 callable = (value) => String(value);
-class Constructable {
-  constructor(value) {
-    this.value = value;
-  }
-}
-const holder = { callable, constructable: Constructable };
-const placeholders = { callable: {}, constructable: {} };
-
-const topLevelRows = [
-  ["directCallableInterface", callable, {}],
-  ["factoryCallableInterface", callable, {}],
-  ["directConstructableInterface", Constructable, {}],
-  ["factoryConstructableInterface", Constructable, {}],
-  ["directCallableAlias", callable, {}],
-  ["factoryCallableAlias", callable, {}],
-  ["directConstructableAlias", Constructable, {}],
-  ["factoryConstructableAlias", Constructable, {}],
-];
-for (const [name, real, placeholder] of topLevelRows) {
-  eq("default " + name + " real", defaults[name](real), true);
-  eq("default " + name + " placeholder", defaults[name](placeholder), true);
-  eq("functional " + name + " real", functional[name](real), true);
-  eq("functional " + name + " placeholder", functional[name](placeholder), false);
-}
-
-for (const name of [
-  "directInterfaceHolder",
-  "factoryInterfaceHolder",
-  "directAliasHolder",
-  "factoryAliasHolder",
-]) {
-  eq("default " + name + " real", defaults[name](holder), true);
-  eq("default " + name + " placeholders", defaults[name](placeholders), true);
-  eq("functional " + name + " real", functional[name](holder), true);
-  eq("functional " + name + " placeholders", functional[name](placeholders), false);
-}
-
-// Hybrid interfaces stay outside the pure-function classification. A real
-// function or constructor missing the declared data member and a plain object
-// carrying only that member are both incomplete values. Keeping both negative
-// twins prevents a signature-based fix from erasing the member or the callable
-// side of the TypeScript shape.
-for (const mod of [defaults, functional]) {
-  for (const name of ["directHybridCallable", "factoryHybridCallable"]) {
-    eq(name + " callable missing data member", mod[name](callable), false);
-    eq(name + " data member without callability", mod[name]({ label: "kept" }), false);
-  }
-  for (const name of ["directHybridConstructable", "factoryHybridConstructable"]) {
-    eq(name + " constructor missing data member", mod[name](Constructable), false);
-    eq(name + " data member without constructability", mod[name]({ kind: "kept" }), false);
-  }
-}
-
-// Index signatures are an independent hybrid boundary, and both named and
-// indexed boundaries can arrive through interface inheritance. These valid
-// function/class values intentionally omit the full hybrid shape, so existing
-// structural handling rejects them. If either boundary is erased and the type
-// is over-classified as a pure function, default mode skips it and functional
-// mode accepts its typeof-function value.
-const hybridBoundaryRows = [
-  ["directIndexedCallable", callable],
-  ["factoryIndexedCallable", callable],
-  ["directIndexedConstructable", Constructable],
-  ["factoryIndexedConstructable", Constructable],
-  ["directInheritedNamedCallable", callable],
-  ["factoryInheritedNamedCallable", callable],
-  ["directInheritedNamedConstructable", Constructable],
-  ["factoryInheritedNamedConstructable", Constructable],
-  ["directInheritedIndexedCallable", callable],
-  ["factoryInheritedIndexedCallable", callable],
-  ["directInheritedIndexedConstructable", Constructable],
-  ["factoryInheritedIndexedConstructable", Constructable],
-];
-for (const [mode, mod] of [["default", defaults], ["functional", functional]]) {
-  for (const [name, value] of hybridBoundaryRows) {
-    eq(mode + " " + name + " incomplete hybrid", mod[name](value), false);
-  }
-}
-
-// The existing global Function path remains the positive interface control.
-for (const name of ["directGlobalFunction", "factoryGlobalFunction"]) {
-  eq("default " + name + " real", defaults[name](callable), true);
-  eq("default " + name + " placeholder", defaults[name]({}), true);
-  eq("functional " + name + " real", functional[name](callable), true);
-  eq("functional " + name + " placeholder", functional[name]({}), false);
-}
-for (const name of ["directGlobalFunctionHolder", "factoryGlobalFunctionHolder"]) {
-  eq("default " + name + " real", defaults[name]({ fn: callable }), true);
-  eq("default " + name + " placeholder", defaults[name]({ fn: {} }), true);
-  eq("functional " + name + " real", functional[name]({ fn: callable }), true);
-  eq("functional " + name + " placeholder", functional[name]({ fn: {} }), false);
-}
-
-console.log("RAN " + ran + " CASES");
-if (failures.length !== 0) {
-  throw new Error("MISMATCHES:\n" + failures.join("\n"));
-}
-`