typia 13.2.0 → 14.0.0

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

@@ -0,0 +1,206 @@
+package main
+
+import (
+  "os"
+  "os/exec"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestDynamicKeyTagsTransform verifies a type tag on a dynamic key is enforced.
+//
+// `Check_dynamic_key` has always held a complete implementation: it filters the
+// key's tag rows through `check_dynamic_key_fully_validated_tag_rows` and routes
+// a tagged string atomic into `Check_string`, a tagged numeric one into
+// `Check_number`. Nothing reached it, so `[key: string & tags.MinLength<3>]`
+// accepted a two-character key and every other key tag was equally inert
+// (#2347).
+//
+// Values were always checked, which is what made this invisible: the
+// `@typia/template` `DynamicTag` fixture declares exactly this shape and every
+// one of its spoilers corrupts a value, never a key.
+//
+//  1. Transform a fixture whose index signatures carry a pattern, a length, and
+//     a numeric range on the key.
+//  2. Require the emitted checker to contain a key predicate at all.
+//  3. Execute runtime cases: a key violating its tag must be rejected, a key
+//     satisfying it accepted, and neither a plain `[key: string]` signature nor
+//     a template literal one may become constrained.
+//
+// The two negative controls carry the boundary. What the fix makes binding is a
+// broken *tag* on a key the declaration covers; a key no signature's *type*
+// covers is declared nowhere, which is what a surplus property is, and stays
+// accepted. `test_validate_dynamic_key_surplus` pins that distinction against
+// both spellings of the same predicate.
+//
+// The report such a key produces is its own concern. `Superfluous`, the report
+// an extra property already used, says the property is not defined in the object
+// type and advises removing it -- false and unhelpful when the property is
+// declared and only its key broke a constraint. `InvalidKey` names the key type
+// instead, and `test_validate_dynamic_key_report` covers the wording.
+func TestDynamicKeyTagsTransform(t *testing.T) {
+  project := dynamicKeyTagsProject(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("dynamic key tags transform failed: code=%d stderr=\n%s", code, errText)
+  }
+  // The key is read into a local before it is tested, so its predicate is the
+  // one place the emitted text can show the check exists at all.
+  if !strings.Contains(out, "RegExp(") || !strings.Contains(out, "_stringLength") {
+    t.Fatalf("emitted checker should test the dynamic key, not only its value:\n%s", out)
+  }
+  dynamicKeyTagsRunRuntimeCases(t, project, out)
+}
+
+func dynamicKeyTagsProject(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, "dynamic-key-tags-")
+  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(dynamicKeyTagsTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(dynamicKeyTagsSource), 0o644); err != nil {
+    t.Fatalf("write source: %v", err)
+  }
+  return dir
+}
+
+func dynamicKeyTagsRunRuntimeCases(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(dynamicKeyTagsRuntimeRunner), 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("dynamic key tags runtime cases failed: %v\n%s", err, output)
+  }
+}
+
+const dynamicKeyTagsTSConfig = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "moduleResolution": "bundler",
+    "ignoreDeprecations": "6.0",
+    "types": ["*"],
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}
+`
+
+const dynamicKeyTagsSource = `import typia, { tags } from "typia";
+
+interface IPatternKey {
+  [key: string & tags.Pattern<"^ab+$">]: string;
+}
+interface ILengthKey {
+  [key: string & tags.MinLength<3>]: string;
+}
+interface INumericKey {
+  [key: number & tags.Minimum<0> & tags.Maximum<9>]: string;
+}
+interface IPlainKey {
+  [key: string]: string;
+}
+interface ITemplateKey {
+  [key: ` + "`" + `prefix_${string}` + "`" + `]: string;
+}
+
+export const isPatternKey = typia.createIs<IPatternKey>();
+export const isLengthKey = typia.createIs<ILengthKey>();
+export const isNumericKey = typia.createIs<INumericKey>();
+export const isPlainKey = typia.createIs<IPlainKey>();
+export const isTemplateKey = typia.createIs<ITemplateKey>();
+`
+
+const dynamicKeyTagsRuntimeRunner = `const assert = require("assert");
+const main = require("./main.cjs");
+
+// A key that satisfies its tag is accepted; one that violates it is not. Both
+// directions matter: before the fix every one of these returned true.
+assert.strictEqual(main.isPatternKey({ abb: "x" }), true, "pattern key accepted");
+assert.strictEqual(main.isPatternKey({ zzz: "x" }), false, "non-pattern key rejected");
+
+assert.strictEqual(main.isLengthKey({ abc: "x" }), true, "long enough key accepted");
+assert.strictEqual(main.isLengthKey({ ab: "x" }), false, "too short key rejected");
+
+// The length is counted in characters, as MinLength means everywhere else: two
+// astral characters are four code units but two characters, so they are short.
+assert.strictEqual(
+  main.isLengthKey({ "\u{1f600}\u{1f600}\u{1f600}": "x" }),
+  true,
+  "three astral characters accepted",
+);
+assert.strictEqual(
+  main.isLengthKey({ "\u{1f600}\u{1f600}": "x" }),
+  false,
+  "two astral characters rejected",
+);
+
+assert.strictEqual(main.isNumericKey({ 5: "x" }), true, "in-range numeric key accepted");
+assert.strictEqual(main.isNumericKey({ 10: "x" }), false, "out-of-range numeric key rejected");
+assert.strictEqual(main.isNumericKey({ "-1": "x" }), false, "negative numeric key rejected");
+
+// NEGATIVE CONTROL: an untagged signature stays unconstrained, so the fix
+// constrains only what was declared.
+assert.strictEqual(main.isPlainKey({ "anything at all": "x" }), true, "plain key accepted");
+assert.strictEqual(main.isPlainKey({ "": "x" }), true, "empty plain key accepted");
+
+// NEGATIVE CONTROL: a template literal constrains the key's *type*, not a tag on
+// it, so a key outside it is declared nowhere -- a surplus property, which "is"
+// accepts as it accepts any surplus property. Rejecting this one alongside a
+// broken tag is what the first attempt at the fix did, and it made the
+// equals-mode surplus report unreachable for the DynamicTemplate, DynamicUnion,
+// and DynamicComposite shapes.
+assert.strictEqual(main.isTemplateKey({ prefix_a: "x" }), true, "matching template key accepted");
+assert.strictEqual(main.isTemplateKey({ prefix_a: 1 }), false, "matching template key with a wrong value rejected");
+assert.strictEqual(
+  main.isTemplateKey({ prefix_a: "x", wrong: "y" }),
+  true,
+  "a key outside the template is surplus, not a violation",
+);
+
+// The value is still checked, which it always was.
+assert.strictEqual(main.isLengthKey({ abc: 1 }), false, "wrong value type rejected");
+`

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

@@ -0,0 +1,185 @@
+package main
+
+import (
+  "encoding/json"
+  "os"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestLocalFunctionNamedLikeTypiaOperationTransform verifies the shadowed-typia
+// diagnostic does not fire on a name collision (#2328).
+//
+// The diagnostic that reports a redeclared typia call keys off the called name,
+// and those names are ordinary words: a project may well own its own
+// `createAssert`, import one from an unrelated package, or augment typia with a
+// name that only exists under one of its namespaces. Reporting any of them
+// would break builds that are correct today, so the name alone must never be
+// enough — the callee has to reach typia through typia's own module specifier
+// and spell the operation in the namespace it lives in.
+//
+//  1. Build a project that defines a local `createAssert`, imports a `createIs`
+//     from a relative module and a `createValidate` from a package whose name
+//     merely begins with "typia", and augments typia with a root `parse` — an
+//     operation name that exists only under a namespace.
+//  2. Require a clean no-emit build, which proves every decoy really resolves,
+//     and a project transform with no diagnostic.
+//  3. Require the one genuine `typia.createIs` call in the same file to still
+//     be rewritten, so silence is not the transform giving up on the file.
+func TestLocalFunctionNamedLikeTypiaOperationTransform(t *testing.T) {
+  project := localTypiaNameCollisionProject(t)
+
+  // A no-emit build reports semantic diagnostics as well as typia's own, so a
+  // decoy that silently stopped resolving fails here instead of turning the
+  // rest of this test into a tautology.
+  out, errText, code := ttscTypiaTestCapture(func() int {
+    return runBuild([]string{
+      "--cwd", project,
+      "--tsconfig", "tsconfig.json",
+      "--noEmit",
+    })
+  })
+  if code != 0 {
+    t.Fatalf("name collision fixture is not clean, got %d\nstdout=%s\nstderr=%s", code, out, errText)
+  }
+
+  out, errText, code = ttscTypiaTestCapture(func() int {
+    return runTransform([]string{
+      "--cwd", project,
+      "--tsconfig", "tsconfig.json",
+    })
+  })
+  if code != 0 {
+    t.Fatalf("name collisions must not fail the transform, got %d\nstdout=%s\nstderr=%s", code, out, errText)
+  }
+  var result transformProjectOutput
+  if err := json.Unmarshal([]byte(out), &result); err != nil {
+    t.Fatalf("decode transform output: %v\n%s", err, out)
+  }
+  if len(result.Diagnostics) != 0 {
+    t.Fatalf("name collisions produced diagnostics: %+v", result.Diagnostics)
+  }
+
+  js, errText, code := ttscTypiaTestCapture(func() int {
+    return runTransform([]string{
+      "--cwd", project,
+      "--tsconfig", "tsconfig.json",
+      "--file", "src/main.ts",
+      "--output", "js",
+    })
+  })
+  if code != 0 {
+    t.Fatalf("name collision fixture failed to emit: code=%d stderr=\n%s", code, errText)
+  }
+  // The genuine call becomes an inline validator; the decoys stay ordinary
+  // calls. Type arguments are erased either way, so the emitted body is the
+  // only evidence that the transform ran on one and not the others.
+  if !strings.Contains(js, `"number" === typeof`) {
+    t.Fatalf("the genuine typia call did not emit its validator:\n%s", js)
+  }
+  for _, decoy := range []string{"createAssert()", "createIs)()", "createValidate)()", "parse)(\"{}\")"} {
+    if !strings.Contains(js, decoy) {
+      t.Fatalf("decoy call %q was rewritten or lost:\n%s", decoy, js)
+    }
+  }
+}
+
+func localTypiaNameCollisionProject(t *testing.T) string {
+  t.Helper()
+  dir := t.TempDir()
+  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(transformDiagnosticTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  ttscTypiaTestWriteFactoryStub(t, dir)
+  localTypiaNameCollisionWriteNeighborStub(t, dir)
+  for name, body := range map[string]string{
+    "helpers.ts":      localTypiaNameCollisionHelpers,
+    "augmentation.ts": localTypiaNameCollisionAugmentation,
+    "main.ts":         localTypiaNameCollisionSource,
+  } {
+    if err := os.WriteFile(filepath.Join(src, name), []byte(body), 0o644); err != nil {
+      t.Fatalf("write fixture %s: %v", name, err)
+    }
+  }
+  return dir
+}
+
+// localTypiaNameCollisionWriteNeighborStub installs a package whose name merely
+// begins with "typia" and exports an operation name typia owns. It pins the
+// one-past-boundary of the specifier test: the call reaches the specifier check
+// under a name that matches, and only the specifier can reject it.
+func localTypiaNameCollisionWriteNeighborStub(t *testing.T, project string) {
+  t.Helper()
+  root := filepath.Join(project, "node_modules", "typia-neighbor")
+  if err := os.MkdirAll(root, 0o755); err != nil {
+    t.Fatalf("mkdir typia-neighbor stub: %v", err)
+  }
+  files := map[string]string{
+    "package.json": `{
+  "name": "typia-neighbor",
+  "version": "0.0.0-test",
+  "main": "./index.js",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    }
+  }
+}
+`,
+    "index.d.ts": "export declare function createValidate<T>(): (input: unknown) => T;\n",
+    "index.js":   "exports.createValidate = () => (input) => input;\n",
+  }
+  for name, body := range files {
+    if err := os.WriteFile(filepath.Join(root, name), []byte(body), 0o644); err != nil {
+      t.Fatalf("write typia-neighbor stub %s: %v", name, err)
+    }
+  }
+}
+
+const localTypiaNameCollisionHelpers = `export const createIs =
+  <T,>() =>
+  (input: unknown): input is T =>
+    input !== undefined;
+`
+
+// A module augmentation that adds a root-level `parse` to typia. The leading
+// `import "typia"` makes this file a module, so the block merges with the
+// installed typia instead of replacing it. `parse` is an operation name under
+// the `llm` namespace and nowhere else, so a gate that matched a flat union of
+// every namespace's names would report this call — a build that works today.
+const localTypiaNameCollisionAugmentation = `import "typia";
+
+declare module "typia" {
+  export function parse(text: string): unknown;
+}
+`
+
+const localTypiaNameCollisionSource = `import { createValidate } from "typia-neighbor";
+import { parse } from "typia";
+import typia from "typia";
+
+import "./augmentation";
+import { createIs } from "./helpers";
+
+export interface User {
+  id: number;
+}
+
+const createAssert =
+  <T,>() =>
+  (input: unknown): T =>
+    input as T;
+
+export const localAssert = createAssert<User>();
+export const relativeIs = createIs<User>();
+export const neighborValidate = createValidate<User>();
+export const augmented = parse("{}");
+export const genuineIs = typia.createIs<User>();
+`

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

@@ -18,8 +18,8 @@ import (
 //  1. Transform a fixture covering camelCase, snake_case, leading-underscore,
 //     consecutive-uppercase (the acronym run collapses, so `XMLParser` becomes
 //     `xmlparser`), and nested property names. The matching compile-time
-//     `KebabCase<T>` assertions live in the test-typia-generate fixture, where
-//     ttsc enforces type diagnostics.
+//     `KebabCase<T>` assertions live in the test-interface fixture, where ttsc
+//     enforces type diagnostics.
 //  2. Require the emitted converter to reference the kebab-case keys.
 //  3. Execute kebab, isKebab, assertKebab, and validateKebab runtime cases
 //     over valid and invalid inputs.

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

@@ -4,16 +4,16 @@
 package main
 
 import (
-	"encoding/json"
-	"path/filepath"
-	"strings"
-	"testing"
+  "encoding/json"
+  "path/filepath"
+  "strings"
+  "testing"
 )
 
 // TestProjectCatalogTransformCoverage reuses broad TypeScript test projects.
 //
 // The focused ttsc fixtures are intentionally small, but the repository already
-// has schema and generation projects that exercise many more typia API shapes.
+// has feature projects that exercise many more typia API shapes.
 // Running them through the same project transform mode gives Go coverage for
 // those native branches without duplicating that TypeScript corpus here.
 //
@@ -31,89 +31,88 @@ import (
 // 3. Require JSON project output to include a TypeScript map.
 // 4. Hold each project to its own purpose's diagnostic contract.
 func TestProjectCatalogTransformCoverage(t *testing.T) {
-	root := transformCoverageRepoRoot(t)
-	for _, project := range []string{
-		"template",
-		"test-langchain",
-		"test-mcp",
-		"test-typia-automated",
-		"test-typia-generate",
-		"test-typia-schema",
-		"test-utils",
-		"test-utils-automated",
-		"test-vercel",
-	} {
-		project := project
-		t.Run(project, func(t *testing.T) {
-			out, errText, code := transformCatalogProject(root, project)
-			if code != 0 {
-				t.Fatalf("%s transform failed: code=%d stderr=\n%s", project, code, errText)
-			}
-			if !strings.Contains(out, `"typescript"`) {
-				t.Fatalf("%s project output should include TypeScript map:\n%s", project, out)
-			}
-		})
-	}
-	// tests/test-error compiles deliberately invalid call sites, and reporting them
-	// is that workspace's entire reason to exist. Its diagnostics are a contract,
-	// not an accident of what it currently holds.
-	t.Run("test-error", func(t *testing.T) {
-		out, _, code := transformCatalogProject(root, "test-error")
-		if code != 3 {
-			t.Fatalf("test-error transform should report diagnostics with code 3, got %d", code)
-		}
-		if !strings.Contains(out, `"diagnostics"`) || !strings.Contains(out, `"typescript"`) {
-			t.Fatalf("test-error output should include diagnostics and TypeScript map:\n%s", out)
-		}
-	})
-	// tests/debug is a one-off repro scratchpad, so nothing about its sources is
-	// promised: it holds valid code between investigations and invalid code during
-	// one. What survives both states is the project transform's own envelope
-	// contract, so that is what this pins. The project must resolve and reach a
-	// transform decision rather than fail to load (exit 2), it must still
-	// contribute transformed sources, and its exit code must agree with the
-	// envelope it published.
-	//
-	// Accepting either 0 or 3 is derived, not observed: transform mode never
-	// typechecks, so exit 2 is reachable only from a flag, cwd, or tsconfig-load
-	// failure (semantic diagnostics belong to the build route). No source content a
-	// repro leaves behind can produce it -- even an outright type error still exits
-	// 0 here -- which is what makes the band content-agnostic.
-	//
-	// The envelope is decoded rather than substring-matched because `"typescript"`
-	// carries no `omitempty` and runTransformProject initializes the map before its
-	// source loop: the key is present even when the workspace resolved no source at
-	// all. That empty envelope is the shape a `rootDir` or `include` rot leaves
-	// behind, and this workspace is the one that already shipped such a rot
-	// (samchon/typia#2132), so a key-presence check would pass over the one failure
-	// worth catching here.
-	t.Run("debug", func(t *testing.T) {
-		out, errText, code := transformCatalogProject(root, "debug")
-		if code != 0 && code != 3 {
-			t.Fatalf("debug transform should load and transform the project, got code=%d stderr=\n%s", code, errText)
-		}
-		var envelope transformProjectOutput
-		if err := json.Unmarshal([]byte(out), &envelope); err != nil {
-			t.Fatalf("debug project output should be a transform envelope: %v\n%s", err, out)
-		}
-		if len(envelope.TypeScript) == 0 {
-			t.Fatalf("debug project should contribute transformed sources, got an empty TypeScript map:\n%s", out)
-		}
-		if diagnosed := len(envelope.Diagnostics) > 0; diagnosed != (code == 3) {
-			t.Fatalf("debug exit code %d disagrees with its envelope (diagnostics present: %v):\n%s", code, diagnosed, out)
-		}
-	})
+  root := transformCoverageRepoRoot(t)
+  for _, project := range []string{
+    "template",
+    "test-langchain",
+    "test-mcp",
+    "test-typia-automated",
+    "test-typia-schema",
+    "test-utils",
+    "test-utils-automated",
+    "test-vercel",
+  } {
+    project := project
+    t.Run(project, func(t *testing.T) {
+      out, errText, code := transformCatalogProject(root, project)
+      if code != 0 {
+        t.Fatalf("%s transform failed: code=%d stderr=\n%s", project, code, errText)
+      }
+      if !strings.Contains(out, `"typescript"`) {
+        t.Fatalf("%s project output should include TypeScript map:\n%s", project, out)
+      }
+    })
+  }
+  // tests/test-error compiles deliberately invalid call sites, and reporting them
+  // is that workspace's entire reason to exist. Its diagnostics are a contract,
+  // not an accident of what it currently holds.
+  t.Run("test-error", func(t *testing.T) {
+    out, _, code := transformCatalogProject(root, "test-error")
+    if code != 3 {
+      t.Fatalf("test-error transform should report diagnostics with code 3, got %d", code)
+    }
+    if !strings.Contains(out, `"diagnostics"`) || !strings.Contains(out, `"typescript"`) {
+      t.Fatalf("test-error output should include diagnostics and TypeScript map:\n%s", out)
+    }
+  })
+  // tests/debug is a one-off repro scratchpad, so nothing about its sources is
+  // promised: it holds valid code between investigations and invalid code during
+  // one. What survives both states is the project transform's own envelope
+  // contract, so that is what this pins. The project must resolve and reach a
+  // transform decision rather than fail to load (exit 2), it must still
+  // contribute transformed sources, and its exit code must agree with the
+  // envelope it published.
+  //
+  // Accepting either 0 or 3 is derived, not observed: transform mode never
+  // typechecks, so exit 2 is reachable only from a flag, cwd, or tsconfig-load
+  // failure (semantic diagnostics belong to the build route). No source content a
+  // repro leaves behind can produce it -- even an outright type error still exits
+  // 0 here -- which is what makes the band content-agnostic.
+  //
+  // The envelope is decoded rather than substring-matched because `"typescript"`
+  // carries no `omitempty` and runTransformProject initializes the map before its
+  // source loop: the key is present even when the workspace resolved no source at
+  // all. That empty envelope is the shape a `rootDir` or `include` rot leaves
+  // behind, and this workspace is the one that already shipped such a rot
+  // (samchon/typia#2132), so a key-presence check would pass over the one failure
+  // worth catching here.
+  t.Run("debug", func(t *testing.T) {
+    out, errText, code := transformCatalogProject(root, "debug")
+    if code != 0 && code != 3 {
+      t.Fatalf("debug transform should load and transform the project, got code=%d stderr=\n%s", code, errText)
+    }
+    var envelope transformProjectOutput
+    if err := json.Unmarshal([]byte(out), &envelope); err != nil {
+      t.Fatalf("debug project output should be a transform envelope: %v\n%s", err, out)
+    }
+    if len(envelope.TypeScript) == 0 {
+      t.Fatalf("debug project should contribute transformed sources, got an empty TypeScript map:\n%s", out)
+    }
+    if diagnosed := len(envelope.Diagnostics) > 0; diagnosed != (code == 3) {
+      t.Fatalf("debug exit code %d disagrees with its envelope (diagnostics present: %v):\n%s", code, diagnosed, out)
+    }
+  })
 }
 
 // transformCatalogProject runs project transform mode over one repository test
 // project and returns its captured stdout, stderr, and exit code.
 func transformCatalogProject(root string, project string) (string, string, int) {
-	cwd := filepath.Join(root, "tests", project)
-	return transformCoverageCapture(func() int {
-		return runTransform([]string{
-			"--cwd", cwd,
-			"--tsconfig", "tsconfig.json",
-			"--output", "ts",
-		})
-	})
+  cwd := filepath.Join(root, "tests", project)
+  return transformCoverageCapture(func() int {
+    return runTransform([]string{
+      "--cwd", cwd,
+      "--tsconfig", "tsconfig.json",
+      "--output", "ts",
+    })
+  })
 }