@ttsc/lint 0.33.0-next.1 → 0.33.1

package/linthost/config.go

@@ -6,6 +6,7 @@ import (
   "crypto/sha256"
   "encoding/hex"
   "encoding/json"
+  "errors"
   "fmt"
   "io"
   "net/url"
@@ -16,6 +17,7 @@ import (
   "sort"
   "strings"
   "sync"
+  "syscall"
   "time"
 
   "github.com/samchon/ttsc/packages/ttsc/driver/windowsjunction"
@@ -3860,7 +3862,18 @@ func loadTypeScriptConfigEvaluationWithin(
   location string,
   resolutionRoot string,
 ) (evaluatedConfigFile, error) {
-  tempDir, err := os.MkdirTemp(loaderTempBase(location, os.TempDir()), "ttsc-lint-config-")
+  systemTemp := os.TempDir()
+  preferred := loaderIdentityTempBase(location, systemTemp, os.Getenv("TTSC_NATIVE_PLUGIN_RECORD_ROOT"))
+  var tempDir string
+  var err error
+  if preferred != "" {
+    tempDir, err = os.MkdirTemp(preferred, "ttsc-lint-config-")
+  }
+  if preferred == "" || (err != nil &&
+    (os.IsPermission(err) || os.IsNotExist(err) ||
+      errors.Is(err, syscall.ENOTDIR) || errors.Is(err, syscall.EROFS))) {
+    tempDir, err = os.MkdirTemp(loaderTempBase(location, systemTemp), "ttsc-lint-config-")
+  }
   if err != nil {
     return evaluatedConfigFile{}, fmt.Errorf("@ttsc/lint: create config loader tempdir: %w", err)
   }
@@ -5341,6 +5354,71 @@ func loaderRootDir(outDir string) string {
   return filepath.ToSlash(vol + `\`)
 }
 
+// loaderIdentityTempBase accepts an already-created identity directory from
+// this native plugin invocation's record store when TEMP is on another volume
+// or contains the config directory. A loader beneath that directory
+// cannot move the config directory's own metadata. The store and config must
+// match the config's lexical drive when one exists. The identity directory must
+// be a real direct child rather than a link or an ancestor of the config directory. An empty
+// result leaves the established loader placement in control.
+func loaderIdentityTempBase(location, systemTemp, recordRoot string) string {
+  if recordRoot == "" || !filepath.IsAbs(recordRoot) {
+    return ""
+  }
+  if !filepath.IsAbs(location) {
+    return ""
+  }
+  volume := filepath.VolumeName(location)
+  configDir := filepath.Dir(location)
+  physicalConfigDir, err := loaderCanonicalDirectory(configDir)
+  if err != nil {
+    return ""
+  }
+  if strings.EqualFold(filepath.VolumeName(systemTemp), volume) {
+    lexicalContains := false
+    if volume != "" {
+      lexicalContains, err = loaderContainsDirectory(systemTemp, configDir)
+      if err != nil {
+        return ""
+      }
+    }
+    if !lexicalContains {
+      physicalTemp, err := loaderCanonicalDirectory(systemTemp)
+      if err != nil {
+        return ""
+      }
+      physicalContains, err := loaderContainsDirectory(physicalTemp, physicalConfigDir)
+      if err != nil || !physicalContains {
+        return ""
+      }
+    }
+  }
+  physicalRoot, err := loaderCanonicalDirectory(recordRoot)
+  if err != nil {
+    return ""
+  }
+  identity := filepath.Join(recordRoot, "identities")
+  entry, err := os.Lstat(identity)
+  if err != nil || !entry.IsDir() || entry.Mode()&os.ModeSymlink != 0 {
+    return ""
+  }
+  if _, err := os.Readlink(identity); err == nil {
+    return ""
+  }
+  physicalIdentity, err := loaderCanonicalDirectory(identity)
+  if err != nil || filepath.Dir(physicalIdentity) != physicalRoot ||
+    !strings.EqualFold(filepath.VolumeName(physicalIdentity), volume) {
+    return ""
+  }
+  if strings.EqualFold(filepath.VolumeName(physicalIdentity), filepath.VolumeName(physicalConfigDir)) {
+    contained, err := loaderContainsDirectory(physicalIdentity, physicalConfigDir)
+    if err != nil || contained {
+      return ""
+    }
+  }
+  return physicalIdentity
+}
+
 // loaderTempBase picks the parent directory for the ephemeral config-loader
 // tree. The system temp dir is the default, but when it sits on a different
 // volume than the config file (Windows: TEMP on `C:`, project on `D:`) the

package/linthost/loader_canonical_directory_other.go

@@ -0,0 +1,34 @@
+//go:build !windows
+
+package linthost
+
+import (
+  "os"
+  "path/filepath"
+)
+
+// loaderCanonicalDirectory resolves the existing directory on non-Windows hosts.
+func loaderCanonicalDirectory(path string) (string, error) {
+  return filepath.EvalSymlinks(path)
+}
+
+// loaderContainsDirectory compares opened filesystem identities so case-only
+// aliases on a case-insensitive POSIX volume cannot hide ancestry.
+func loaderContainsDirectory(base, child string) (bool, error) {
+  baseInfo, err := os.Stat(base)
+  if err != nil {
+    return false, err
+  }
+  for current := filepath.Clean(child); ; current = filepath.Dir(current) {
+    info, err := os.Stat(current)
+    if err != nil {
+      return false, err
+    }
+    if os.SameFile(baseInfo, info) {
+      return true, nil
+    }
+    if parent := filepath.Dir(current); parent == current {
+      return false, nil
+    }
+  }
+}

package/linthost/loader_canonical_directory_windows.go

@@ -0,0 +1,60 @@
+//go:build windows
+
+package linthost
+
+import (
+  "path/filepath"
+  "strings"
+
+  "golang.org/x/sys/windows"
+)
+
+// loaderCanonicalDirectory returns the opened directory's final filesystem
+// path, including through NTFS junction ancestors that EvalSymlinks can miss.
+func loaderCanonicalDirectory(path string) (string, error) {
+  pointer, err := windows.UTF16PtrFromString(path)
+  if err != nil {
+    return "", err
+  }
+  handle, err := windows.CreateFile(
+    pointer,
+    windows.FILE_READ_ATTRIBUTES,
+    windows.FILE_SHARE_READ|windows.FILE_SHARE_WRITE|windows.FILE_SHARE_DELETE,
+    nil,
+    windows.OPEN_EXISTING,
+    windows.FILE_FLAG_BACKUP_SEMANTICS,
+    0,
+  )
+  if err != nil {
+    return "", err
+  }
+  defer windows.CloseHandle(handle)
+
+  buffer := make([]uint16, windows.MAX_PATH)
+  for {
+    length, err := windows.GetFinalPathNameByHandle(handle, &buffer[0], uint32(len(buffer)), 0)
+    if err != nil {
+      return "", err
+    }
+    if length < uint32(len(buffer)) {
+      resolved := windows.UTF16ToString(buffer[:length])
+      if strings.HasPrefix(resolved, `\\?\UNC\`) {
+        resolved = `\\` + strings.TrimPrefix(resolved, `\\?\UNC\`)
+      } else {
+        resolved = strings.TrimPrefix(resolved, `\\?\`)
+      }
+      return filepath.Clean(resolved), nil
+    }
+    buffer = make([]uint16, length+1)
+  }
+}
+
+// loaderContainsDirectory compares Windows path spelling after final-path resolution.
+func loaderContainsDirectory(base, child string) (bool, error) {
+  relative, err := filepath.Rel(base, child)
+  if err != nil {
+    return false, err
+  }
+  return relative == "." ||
+    (relative != ".." && !strings.HasPrefix(relative, ".."+string(filepath.Separator)) && !filepath.IsAbs(relative)), nil
+}

package/linthost/loader_identity_temp_base_posix_test.go

@@ -0,0 +1,117 @@
+//go:build !windows
+
+package linthost
+
+import (
+  "os"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestLoaderIdentityTempBaseKeepsPOSIXConfigRootStable verifies an existing
+// record store receives lint-loader scratch when TMPDIR is the config root.
+//
+// 1. Create an ordinary project and a separate record store with identities.
+// 2. Select identities for project-root TMPDIR and create/remove scratch without changing the project directory.
+// 3. Preserve independent TMPDIR and relative-config fallback, and reject linked or ancestor identities.
+//
+// @evidence contracts/testing.md#behavioral-verification The lint selector returns the existing identity directory for project-root TMPDIR, where actual temporary creation and removal leave project metadata and identity contents stable; unsupported layouts return no preference.
+// @evidence contracts/testing.md#independent-expectations Authored sibling directories and before/after project metadata establish safe placement without using the selector as the oracle; an empty identities listing detects leaked scratch.
+// @evidence contracts/testing.md#distinguishing-cases Project-root, symlinked, and available case-only project-root TMPDIR select identities, while independent TMPDIR, relative config, missing or linked identity, and an identity ancestor of config preserve fallback.
+// @evidence contracts/testing.md#execution-ownership This named Go unit calls the lint selector and native filesystem operations in-process without launching ttsx or a plugin host.
+func TestLoaderIdentityTempBaseKeepsPOSIXConfigRootStable(t *testing.T) {
+  root := t.TempDir()
+  project := filepath.Join(root, "project")
+  recordRoot := filepath.Join(root, "cache")
+  identity := filepath.Join(recordRoot, "identities")
+  for _, dir := range []string{project, identity} {
+    if err := os.MkdirAll(dir, 0o755); err != nil {
+      t.Fatal(err)
+    }
+  }
+  config := filepath.Join(project, "lint.config.ts")
+  want, err := filepath.EvalSymlinks(identity)
+  if err != nil {
+    t.Fatal(err)
+  }
+  if got := loaderIdentityTempBase(config, project, recordRoot); got != want {
+    t.Fatalf("project-root TMPDIR selected %q, want %q", got, want)
+  }
+  before, err := os.Stat(project)
+  if err != nil {
+    t.Fatal(err)
+  }
+  scratch, err := os.MkdirTemp(want, "ttsc-lint-config-")
+  if err != nil {
+    t.Fatal(err)
+  }
+  t.Cleanup(func() {
+    if err := os.RemoveAll(scratch); err != nil {
+      t.Errorf("remove identity scratch: %v", err)
+    }
+  })
+  if err := os.RemoveAll(scratch); err != nil {
+    t.Fatal(err)
+  }
+  after, err := os.Stat(project)
+  if err != nil {
+    t.Fatal(err)
+  }
+  if !before.ModTime().Equal(after.ModTime()) {
+    t.Fatalf("project directory timestamp changed: %v -> %v", before.ModTime(), after.ModTime())
+  }
+  entries, err := os.ReadDir(identity)
+  if err != nil || len(entries) != 0 {
+    t.Fatalf("identity scratch remains: %v, %v", entries, err)
+  }
+  separateTemp := filepath.Join(root, "separate-temp")
+  if err := os.Mkdir(separateTemp, 0o755); err != nil {
+    t.Fatal(err)
+  }
+  if got := loaderIdentityTempBase(config, separateTemp, recordRoot); got != "" {
+    t.Fatalf("independent TMPDIR selected identities: %q", got)
+  }
+  if got := loaderIdentityTempBase("lint.config.ts", project, recordRoot); got != "" {
+    t.Fatalf("relative config selected identities: %q", got)
+  }
+  linkedTemp := filepath.Join(root, "linked-temp")
+  if err := os.Symlink(project, linkedTemp); err != nil {
+    t.Fatal(err)
+  }
+  if got := loaderIdentityTempBase(config, linkedTemp, recordRoot); got != want {
+    t.Fatalf("linked project-root TMPDIR selected %q, want %q", got, want)
+  }
+  missingRoot := filepath.Join(root, "missing-cache")
+  if got := loaderIdentityTempBase(config, project, missingRoot); got != "" {
+    t.Fatalf("missing store selected identities: %q", got)
+  }
+  linkedIdentityRoot := filepath.Join(root, "linked-identity-cache")
+  if err := os.Mkdir(linkedIdentityRoot, 0o755); err != nil {
+    t.Fatal(err)
+  }
+  if err := os.Symlink(identity, filepath.Join(linkedIdentityRoot, "identities")); err != nil {
+    t.Fatal(err)
+  }
+  if got := loaderIdentityTempBase(config, project, linkedIdentityRoot); got != "" {
+    t.Fatalf("linked identity child selected: %q", got)
+  }
+  nested := filepath.Join(identity, "nested")
+  if err := os.Mkdir(nested, 0o755); err != nil {
+    t.Fatal(err)
+  }
+  if got := loaderIdentityTempBase(filepath.Join(nested, "lint.config.ts"), project, recordRoot); got != "" {
+    t.Fatalf("identity ancestor of config selected: %q", got)
+  }
+  alternateCase := strings.ToUpper(project)
+  projectInfo, projectErr := os.Stat(project)
+  aliasInfo, aliasErr := os.Stat(alternateCase)
+  if projectErr == nil && aliasErr == nil && os.SameFile(projectInfo, aliasInfo) {
+    if got := loaderIdentityTempBase(config, alternateCase, recordRoot); got != want {
+      t.Fatalf("case-only ancestor TMPDIR selected %q, want %q", got, want)
+    }
+    if got := loaderIdentityTempBase(filepath.Join(strings.ToUpper(identity), "nested", "lint.config.ts"), project, recordRoot); got != "" {
+      t.Fatalf("case-only identity ancestor selected: %q", got)
+    }
+  }
+}

package/linthost/windows_loader_identity_temp_base_preserves_config_directory_test.go

@@ -0,0 +1,212 @@
+//go:build windows
+
+package linthost
+
+import (
+  "os"
+  "os/exec"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestWindowsLoaderIdentityTempBasePreservesConfigDirectory verifies a native
+// config loader can use an already-open record store without moving the config
+// directory's metadata during temporary loader creation and removal.
+//
+// 1. Choose a different simulated system-temp drive and an existing identity directory.
+// 2. Create and remove a loader there, then assert the config directory's timestamp stays fixed.
+// 3. Accept project-root and same-drive junction stores and ancestor TEMP, then reject missing, blocked, linked, and config-ancestor identities.
+// 4. Accept lexical-volume identities for a cross-drive config junction and reject a physical-volume store.
+//
+// @evidence contracts/testing.md#behavioral-verification The selected identity directory hosts actual MkdirTemp/RemoveAll work without changing the config directory timestamp or retaining scratch; unsupported stores return no preference and legacy placement remains on the config volume.
+// @evidence contracts/testing.md#independent-expectations Windows directory metadata changes when a direct child is created or removed; authored sibling, blocked, missing, junction, ancestor, and same-volume layouts define independent valid and invalid inputs.
+// @evidence contracts/testing.md#distinguishing-cases Preexisting sibling, project-root, same-drive junction and ancestor TEMP stores are accepted, while independent same-drive TEMP, absent, blocked or linked identities, a cross-drive cache store, and an identity ancestor of the config are rejected. The established fallback selector remains covered by TestWindowsLoaderTempBaseStaysOnConfigVolume.
+// @evidence contracts/testing.md#execution-ownership This Go unit invokes the real filesystem selector and native temporary directory calls in-process; cmd creates only the Windows junction fixture, and no ttsx child or native plugin build runs.
+func TestWindowsLoaderIdentityTempBasePreservesConfigDirectory(t *testing.T) {
+  root := t.TempDir()
+  project := filepath.Join(root, "project")
+  recordRoot := filepath.Join(root, "cache")
+  identity := filepath.Join(recordRoot, "identities")
+  for _, dir := range []string{project, identity} {
+    if err := os.MkdirAll(dir, 0o755); err != nil {
+      t.Fatal(err)
+    }
+  }
+  config := filepath.Join(project, "lint.config.ts")
+  otherVolumeTemp := `Z:\ttsc-fake-temp`
+  if strings.EqualFold(filepath.VolumeName(root), "Z:") {
+    otherVolumeTemp = `Y:\ttsc-fake-temp`
+  }
+  want, err := filepath.EvalSymlinks(identity)
+  if err != nil {
+    t.Fatal(err)
+  }
+  if got := loaderIdentityTempBase(config, otherVolumeTemp, recordRoot); got != want {
+    t.Fatalf("identity scratch base mismatch: %q != %q", got, want)
+  }
+  before, err := os.Stat(project)
+  if err != nil {
+    t.Fatal(err)
+  }
+  temporary, err := os.MkdirTemp(want, "ttsc-lint-config-")
+  if err != nil {
+    t.Fatal(err)
+  }
+  if err := os.RemoveAll(temporary); err != nil {
+    t.Fatal(err)
+  }
+  after, err := os.Stat(project)
+  if err != nil {
+    t.Fatal(err)
+  }
+  if !before.ModTime().Equal(after.ModTime()) {
+    t.Fatalf("config directory timestamp moved: %v -> %v", before.ModTime(), after.ModTime())
+  }
+  entries, err := os.ReadDir(identity)
+  if err != nil {
+    t.Fatal(err)
+  }
+  for _, entry := range entries {
+    if strings.HasPrefix(entry.Name(), "ttsc-lint-config-") {
+      t.Fatalf("identity scratch remains after cleanup: %s", entry.Name())
+    }
+  }
+  projectIdentity := filepath.Join(project, "identities")
+  if err := os.Mkdir(projectIdentity, 0o755); err != nil {
+    t.Fatal(err)
+  }
+  projectWant, err := filepath.EvalSymlinks(projectIdentity)
+  if err != nil {
+    t.Fatal(err)
+  }
+  if got := loaderIdentityTempBase(config, otherVolumeTemp, project); got != projectWant {
+    t.Fatalf("project-root store mismatch: %q != %q", got, projectWant)
+  }
+  linkedProject := filepath.Join(root, "linked-project")
+  if output, err := exec.Command("cmd", "/c", "mklink", "/J", linkedProject, project).CombinedOutput(); err != nil {
+    t.Fatalf("same-drive config junction failed: %v: %s", err, output)
+  }
+  if got := loaderIdentityTempBase(filepath.Join(linkedProject, "lint.config.ts"), otherVolumeTemp, recordRoot); got != want {
+    t.Fatalf("same-drive linked config did not select canonical identities: %q", got)
+  }
+  linkedRecordRoot := filepath.Join(root, "linked-record-root")
+  if output, err := exec.Command("cmd", "/c", "mklink", "/J", linkedRecordRoot, recordRoot).CombinedOutput(); err != nil {
+    t.Fatalf("same-drive record junction failed: %v: %s", err, output)
+  }
+  if got := loaderIdentityTempBase(config, otherVolumeTemp, linkedRecordRoot); got != want {
+    t.Fatalf("same-drive linked record root did not select canonical identities: %q", got)
+  }
+  before, err = os.Stat(project)
+  if err != nil {
+    t.Fatal(err)
+  }
+  temporary, err = os.MkdirTemp(projectWant, "ttsc-lint-config-")
+  if err != nil {
+    t.Fatal(err)
+  }
+  if err := os.RemoveAll(temporary); err != nil {
+    t.Fatal(err)
+  }
+  after, err = os.Stat(project)
+  if err != nil {
+    t.Fatal(err)
+  }
+  if !before.ModTime().Equal(after.ModTime()) {
+    t.Fatalf("project-root store moved config directory timestamp: %v -> %v", before.ModTime(), after.ModTime())
+  }
+  separateTemp := filepath.Join(root, "separate-temp")
+  if err := os.Mkdir(separateTemp, 0o755); err != nil {
+    t.Fatal(err)
+  }
+  if got := loaderIdentityTempBase(config, separateTemp, recordRoot); got != "" {
+    t.Fatalf("independent same-volume temp unexpectedly selected cache: %q", got)
+  }
+  for _, ancestorTemp := range []string{project, root} {
+    if got := loaderIdentityTempBase(config, ancestorTemp, recordRoot); got != want {
+      t.Fatalf("ancestor TEMP did not select identities: %q", got)
+    }
+  }
+  linkedTemp := filepath.Join(root, "linked-temp")
+  if output, err := exec.Command("cmd", "/c", "mklink", "/J", linkedTemp, project).CombinedOutput(); err != nil {
+    t.Fatalf("TEMP junction failed: %v: %s", err, output)
+  }
+  if got := loaderIdentityTempBase(config, linkedTemp, recordRoot); got != want {
+    t.Fatalf("physical ancestor TEMP did not select identities: %q", got)
+  }
+  if got := loaderIdentityTempBase(config, otherVolumeTemp, filepath.Join(root, "missing")); got != "" {
+    t.Fatalf("missing store unexpectedly selected cache: %q", got)
+  }
+  blockedRoot := filepath.Join(root, "blocked-cache")
+  if err := os.Mkdir(blockedRoot, 0o755); err != nil {
+    t.Fatal(err)
+  }
+  if err := os.WriteFile(filepath.Join(blockedRoot, "identities"), nil, 0o644); err != nil {
+    t.Fatal(err)
+  }
+  if got := loaderIdentityTempBase(config, otherVolumeTemp, blockedRoot); got != "" {
+    t.Fatalf("blocked identity child unexpectedly selected cache: %q", got)
+  }
+  if fallback := loaderTempBase(config, otherVolumeTemp); fallback == "" ||
+    !strings.EqualFold(filepath.VolumeName(fallback), filepath.VolumeName(config)) {
+    t.Fatalf("blocked identity fallback left config volume: %q", fallback)
+  }
+  if err := os.Mkdir(filepath.Join(identity, "nested"), 0o755); err != nil {
+    t.Fatal(err)
+  }
+  if got := loaderIdentityTempBase(filepath.Join(identity, "nested", "lint.config.ts"), otherVolumeTemp, recordRoot); got != "" {
+    t.Fatalf("config inside identity cache unexpectedly selected cache: %q", got)
+  }
+
+  linkedRoot := filepath.Join(root, "linked-cache")
+  realIdentity := filepath.Join(root, "real-identities")
+  for _, dir := range []string{linkedRoot, realIdentity} {
+    if err := os.MkdirAll(dir, 0o755); err != nil {
+      t.Fatal(err)
+    }
+  }
+  junction := filepath.Join(linkedRoot, "identities")
+  if output, err := exec.Command("cmd", "/c", "mklink", "/J", junction, realIdentity).CombinedOutput(); err != nil {
+    t.Fatalf("mklink /J failed: %v: %s", err, output)
+  }
+  if got := loaderIdentityTempBase(config, otherVolumeTemp, linkedRoot); got != "" {
+    t.Fatalf("linked identities unexpectedly selected cache: %q", got)
+  }
+  checkout, err := os.Getwd()
+  if err != nil {
+    t.Fatal(err)
+  }
+  if !strings.EqualFold(filepath.VolumeName(checkout), filepath.VolumeName(root)) {
+    checkoutRoot := filepath.Clean(filepath.Join(checkout, "..", "..", ".."))
+    otherPhysical, err := os.MkdirTemp(checkoutRoot, "ttsc-lint-junction-test-")
+    if err != nil {
+      t.Fatal(err)
+    }
+    t.Cleanup(func() {
+      if err := os.RemoveAll(otherPhysical); err != nil {
+        t.Errorf("remove cross-volume fixture: %v", err)
+      }
+    })
+    alias := filepath.Join(root, "linked-cache-root")
+    if err := os.Mkdir(filepath.Join(otherPhysical, "identities"), 0o755); err != nil {
+      t.Fatal(err)
+    }
+    if output, err := exec.Command("cmd", "/c", "mklink", "/J", alias, otherPhysical).CombinedOutput(); err != nil {
+      t.Fatalf("cross-volume mklink /J failed: %v: %s", err, output)
+    }
+    if got := loaderIdentityTempBase(config, otherVolumeTemp, alias); got != "" {
+      t.Fatalf("cross-volume cache junction unexpectedly selected: %q", got)
+    }
+    linkedConfigRoot := filepath.Join(root, "linked-cross-volume-config")
+    if output, err := exec.Command("cmd", "/c", "mklink", "/J", linkedConfigRoot, otherPhysical).CombinedOutput(); err != nil {
+      t.Fatalf("cross-volume config junction failed: %v: %s", err, output)
+    }
+    linkedConfig := filepath.Join(linkedConfigRoot, "lint.config.ts")
+    if got := loaderIdentityTempBase(linkedConfig, otherVolumeTemp, recordRoot); got != want {
+      t.Fatalf("lexical-volume identities not selected for linked config: %q", got)
+    }
+    if got := loaderIdentityTempBase(linkedConfig, otherVolumeTemp, otherPhysical); got != "" {
+      t.Fatalf("physical-volume identities selected for linked config: %q", got)
+    }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ttsc/lint",
-  "version": "0.33.0-next.1",
+  "version": "0.33.1",
   "description": "Reference ttsc plugin: ESLint-style lint rules over the TypeScript-Go Program used by the type-check pass.",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -38,7 +38,7 @@
     "@types/node": "^25.3.0",
     "rimraf": "^6.1.2",
     "typescript": "^7.0.2",
-    "ttsc": "0.33.0-next.1"
+    "ttsc": "0.33.1"
   },
   "repository": {
     "type": "git",