ttsc 0.19.3 → 0.20.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ttsc",
-  "version": "0.19.3",
+  "version": "0.20.0",
   "description": "General-purpose TypeScript-Go compiler, runtime, plugin host, and LSP host.",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -35,13 +35,13 @@
     "typescript": "^7.0.2"
   },
   "optionalDependencies": {
-    "@ttsc/linux-x64": "0.19.3",
-    "@ttsc/linux-arm64": "0.19.3",
-    "@ttsc/linux-arm": "0.19.3",
-    "@ttsc/darwin-arm64": "0.19.3",
-    "@ttsc/win32-x64": "0.19.3",
-    "@ttsc/darwin-x64": "0.19.3",
-    "@ttsc/win32-arm64": "0.19.3"
+    "@ttsc/linux-arm64": "0.20.0",
+    "@ttsc/linux-x64": "0.20.0",
+    "@ttsc/darwin-arm64": "0.20.0",
+    "@ttsc/darwin-x64": "0.20.0",
+    "@ttsc/win32-x64": "0.20.0",
+    "@ttsc/win32-arm64": "0.20.0",
+    "@ttsc/linux-arm": "0.20.0"
   },
   "sideEffects": false,
   "files": [

package/shim/ast/shim.go

@@ -279,6 +279,49 @@ func IsElementAccessExpression(node *Node) bool {
   return innerast.IsElementAccessExpression(node)
 }
 
+// IsTokenKind reports whether kind represents a lexical syntax token.
+func IsTokenKind(kind Kind) bool {
+  return innerast.IsTokenKind(kind)
+}
+
+// IsExpressionNode reports whether node has expression semantics in its
+// enclosing syntax context.
+func IsExpressionNode(node *Node) bool {
+  return innerast.IsExpressionNode(node)
+}
+
+// IsTypeDeclaration reports whether node declares a type-level symbol.
+func IsTypeDeclaration(node *Node) bool {
+  return innerast.IsTypeDeclaration(node)
+}
+
+// IsTypeDeclarationName reports whether node is the name of a type-level
+// declaration.
+func IsTypeDeclarationName(node *Node) bool {
+  return innerast.IsTypeDeclarationName(node)
+}
+
+// IsBindingElement reports whether node is one element of a binding pattern.
+func IsBindingElement(node *Node) bool {
+  return innerast.IsBindingElement(node)
+}
+
+// IsDeclaration reports whether node is a declaration syntax node.
+func IsDeclaration(node *Node) bool {
+  return innerast.IsDeclaration(node)
+}
+
+// IsDeclarationNameOrImportPropertyName reports whether node names a
+// declaration or the property side of an import or export specifier.
+func IsDeclarationNameOrImportPropertyName(node *Node) bool {
+  return innerast.IsDeclarationNameOrImportPropertyName(node)
+}
+
+// IsBindingPattern reports whether node is an object or array binding pattern.
+func IsBindingPattern(node *Node) bool {
+  return innerast.IsBindingPattern(node)
+}
+
 // GetSourceFileOfNode walks up the parent chain to return the SourceFile that
 // owns the given node. Linked from the internal package via go:linkname because
 // the function is unexported there.
@@ -286,9 +329,11 @@ func IsElementAccessExpression(node *Node) bool {
 //go:linkname GetSourceFileOfNode github.com/microsoft/typescript-go/internal/ast.GetSourceFileOfNode
 func GetSourceFileOfNode(node *innerast.Node) *innerast.SourceFile
 
-// GetNodeAtPosition returns the deepest AST node whose range covers position
-// in file. When includeJSDoc is true the search descends into JSDoc sub-trees.
-// Linked from the internal package via go:linkname.
+// GetNodeAtPosition returns the deepest non-token AST node whose range covers
+// position in file. When includeJSDoc is true the search descends into JSDoc
+// sub-trees. Cursor-facing callers that need the exact token should use
+// astnav.GetTouchingToken instead. Linked from the internal package via
+// go:linkname.
 //
 //go:linkname GetNodeAtPosition github.com/microsoft/typescript-go/internal/ast.GetNodeAtPosition
 func GetNodeAtPosition(file *innerast.SourceFile, position int, includeJSDoc bool) *innerast.Node

package/shim/astnav/go.mod

@@ -0,0 +1,14 @@
+module github.com/microsoft/typescript-go/shim/astnav
+
+go 1.26
+
+require github.com/microsoft/typescript-go v0.0.0-20260429010842-56ab4af42157
+
+require (
+	github.com/go-json-experiment/json v0.0.0-20260214004413-d219187c3433 // indirect
+	github.com/klauspost/cpuid/v2 v2.2.10 // indirect
+	github.com/zeebo/xxh3 v1.1.0 // indirect
+	golang.org/x/sync v0.20.0 // indirect
+	golang.org/x/sys v0.43.0 // indirect
+	golang.org/x/text v0.36.0 // indirect
+)

package/shim/astnav/go.sum

@@ -0,0 +1,20 @@
+github.com/go-json-experiment/json v0.0.0-20260214004413-d219187c3433 h1:vymEbVwYFP/L05h5TKQxvkXoKxNvTpjxYKdF1Nlwuao=
+github.com/go-json-experiment/json v0.0.0-20260214004413-d219187c3433/go.mod h1:tphK2c80bpPhMOI4v6bIc2xWywPfbqi1Z06+RcrMkDg=
+github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
+github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
+github.com/klauspost/cpuid/v2 v2.2.10 h1:tBs3QSyvjDyFTq3uoc/9xFpCuOsJQFNPiAhYdw2skhE=
+github.com/klauspost/cpuid/v2 v2.2.10/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0=
+github.com/microsoft/typescript-go v0.0.0-20260429010842-56ab4af42157 h1:llOMPhKDiQ+UEJiAaQuuWaJOTg5V7tNNTEf9JPWoYSY=
+github.com/microsoft/typescript-go v0.0.0-20260429010842-56ab4af42157/go.mod h1:m8YA0PMC7ti0GW0RI05D6fEcjQeu98XVS+FWF+VDW2k=
+github.com/zeebo/assert v1.3.0 h1:g7C04CbJuIDKNPFHmsk4hwZDO5O+kntRxzaUoNXj+IQ=
+github.com/zeebo/assert v1.3.0/go.mod h1:Pq9JiuJQpG8JLJdtkwrJESF0Foym2/D9XMU5ciN/wJ0=
+github.com/zeebo/xxh3 v1.1.0 h1:s7DLGDK45Dyfg7++yxI0khrfwq9661w9EN78eP/UZVs=
+github.com/zeebo/xxh3 v1.1.0/go.mod h1:IisAie1LELR4xhVinxWS5+zf1lA4p0MW4T+w+W07F5s=
+golang.org/x/sync v0.20.0 h1:e0PTpb7pjO8GAtTs2dQ6jYa5BWYlMuX047Dco/pItO4=
+golang.org/x/sync v0.20.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
+golang.org/x/sys v0.43.0 h1:Rlag2XtaFTxp19wS8MXlJwTvoh8ArU6ezoyFsMyCTNI=
+golang.org/x/sys v0.43.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
+golang.org/x/text v0.36.0 h1:JfKh3XmcRPqZPKevfXVpI1wXPTqbkE5f7JA92a55Yxg=
+golang.org/x/text v0.36.0/go.mod h1:NIdBknypM8iqVmPiuco0Dh6P5Jcdk8lJL0CUebqK164=
+gotest.tools/v3 v3.5.2 h1:7koQfIKdy+I8UTetycgUqXWSDwpgv193Ka+qRsmBY8Q=
+gotest.tools/v3 v3.5.2/go.mod h1:LtdLGcnqToBH83WByAAi/wiwSFCArdFIUV/xxN4pcjA=

package/shim/astnav/shim.go

@@ -0,0 +1,15 @@
+// Package astnav exposes cursor-position traversal helpers from TypeScript-Go.
+package astnav
+
+import (
+  "github.com/microsoft/typescript-go/internal/ast"
+  _ "github.com/microsoft/typescript-go/internal/astnav"
+  _ "unsafe"
+)
+
+// GetTouchingToken returns the token touching position in sourceFile. When
+// position touches no token, it returns the enclosing non-token node instead;
+// callers that require a token must check ast.IsTokenKind on the result kind.
+//
+//go:linkname GetTouchingToken github.com/microsoft/typescript-go/internal/astnav.GetTouchingToken
+func GetTouchingToken(sourceFile *ast.SourceFile, position int) *ast.Node

package/shim/checker/shim.go

@@ -28,6 +28,106 @@ type ElementFlags = innerchecker.ElementFlags
 type Program = innerchecker.Program
 type Tracer = innerchecker.Tracer
 
+//go:linkname checkerNewAnonymousType github.com/microsoft/typescript-go/internal/checker.(*Checker).newAnonymousType
+func checkerNewAnonymousType(
+  recv *innerchecker.Checker,
+  symbol *innerast.Symbol,
+  members innerast.SymbolTable,
+  callSignatures []*innerchecker.Signature,
+  constructSignatures []*innerchecker.Signature,
+  indexInfos []*innerchecker.IndexInfo,
+) *innerchecker.Type
+
+//go:linkname checkerGetTargetSymbol github.com/microsoft/typescript-go/internal/checker.(*Checker).getTargetSymbol
+func checkerGetTargetSymbol(recv *innerchecker.Checker, symbol *innerast.Symbol) *innerast.Symbol
+
+//go:linkname checkerIsPrototypeProperty github.com/microsoft/typescript-go/internal/checker.isPrototypeProperty
+func checkerIsPrototypeProperty(symbol *innerast.Symbol) bool
+
+//go:linkname checkerArePropertiesAbstractOrInterface github.com/microsoft/typescript-go/internal/checker.(*Checker).arePropertiesAbstractOrInterface
+func checkerArePropertiesAbstractOrInterface(
+  recv *innerchecker.Checker,
+  base *innerast.Symbol,
+  baseDeclarationFlags innerast.ModifierFlags,
+) bool
+
+// Checker_isPropertyAssignableTo asks the upstream assignability relater about
+// exactly one source/target property pair. The anonymous types retain the
+// original property symbols, so propertyRelatedTo still enforces instantiated
+// generic types, overloads, optionality, and private/protected declaration
+// origins without an unrelated sibling member participating in the result.
+func Checker_isPropertyAssignableTo(
+  recv *innerchecker.Checker,
+  sourceProperty *innerast.Symbol,
+  targetProperty *innerast.Symbol,
+) bool {
+  if recv == nil || sourceProperty == nil || targetProperty == nil ||
+    sourceProperty.Name == "" || sourceProperty.Name != targetProperty.Name {
+    return false
+  }
+  source := checkerNewAnonymousType(
+    recv,
+    nil,
+    innerast.SymbolTable{sourceProperty.Name: sourceProperty},
+    nil,
+    nil,
+    nil,
+  )
+  target := checkerNewAnonymousType(
+    recv,
+    nil,
+    innerast.SymbolTable{targetProperty.Name: targetProperty},
+    nil,
+    nil,
+    nil,
+  )
+  return source != nil && target != nil && recv.IsTypeAssignableTo(source, target)
+}
+
+// Checker_isValidClassMemberOverridePair applies the class-only member-kind
+// boundary from checkKindsOfPropertyMemberOverrides to one exact pair. Ordinary
+// structural assignability permits more shapes than a class extends clause:
+// notably a concrete property/accessor cannot be replaced by a method, while a
+// base method may be replaced by a function-valued property.
+func Checker_isValidClassMemberOverridePair(
+  recv *innerchecker.Checker,
+  derivedProperty *innerast.Symbol,
+  baseProperty *innerast.Symbol,
+) bool {
+  if recv == nil || derivedProperty == nil || baseProperty == nil {
+    return false
+  }
+  derived := checkerGetTargetSymbol(recv, derivedProperty)
+  base := checkerGetTargetSymbol(recv, baseProperty)
+  if derived == nil || base == nil || derived == base {
+    return false
+  }
+
+  baseDeclarationFlags := innerchecker.GetDeclarationModifierFlagsFromSymbol(base)
+  basePropertyFlags := base.Flags & innerast.SymbolFlagsPropertyOrAccessor
+  derivedPropertyFlags := derived.Flags & innerast.SymbolFlagsPropertyOrAccessor
+  if basePropertyFlags != 0 && derivedPropertyFlags != 0 {
+    // A direct class base member cannot be a mapped property. The upstream
+    // mapped-property exception therefore has no member declaration this
+    // direct-pair API could publish; assignment declarations and abstract /
+    // interface members are the two applicable exceptions.
+    if derived.ValueDeclaration != nil && innerast.IsBinaryExpression(derived.ValueDeclaration) ||
+      checkerArePropertiesAbstractOrInterface(recv, base, baseDeclarationFlags) {
+      return true
+    }
+    overriddenInstanceProperty := basePropertyFlags != innerast.SymbolFlagsProperty &&
+      derivedPropertyFlags == innerast.SymbolFlagsProperty
+    overriddenInstanceAccessor := basePropertyFlags == innerast.SymbolFlagsProperty &&
+      derivedPropertyFlags != innerast.SymbolFlagsProperty
+    return !overriddenInstanceProperty && !overriddenInstanceAccessor
+  }
+  if checkerIsPrototypeProperty(base) {
+    return checkerIsPrototypeProperty(derived) ||
+      derived.Flags&innerast.SymbolFlagsProperty != 0
+  }
+  return false
+}
+
 // NewChecker creates a checker that owns its complete type graph for program.
 // The returned mutex is the upstream checker-pool synchronization primitive;
 // callers that share the checker must serialize access through it.

package/shim/core/shim.go

@@ -1,3 +1,5 @@
+// gen_shims:hand-maintained
+//
 // Package core re-exports the subset of typescript-go's internal/core types
 // and constants that plugins and the ttsc driver need. It provides compiler
 // options, script-kind discrimination, tri-state booleans, and text-range
@@ -13,6 +15,12 @@ type CompilerOptions = innercore.CompilerOptions
 // JsxEmit is the parsed compilerOptions.jsx mode.
 type JsxEmit = innercore.JsxEmit
 
+// ModuleResolutionKind selects TypeScript-Go's module resolver.
+type ModuleResolutionKind = innercore.ModuleResolutionKind
+
+// ResolutionMode is the CommonJS or ESM lookup mode for one module use.
+type ResolutionMode = innercore.ResolutionMode
+
 // Tristate is a three-valued boolean: TSFalse, TSTrue, or TSUnknown. Used by
 // CompilerOptions fields that can be explicitly unset.
 type Tristate = innercore.Tristate
@@ -20,6 +28,10 @@ type Tristate = innercore.Tristate
 // TextPos is a zero-based byte offset into a source file's text.
 type TextPos = innercore.TextPos
 
+// ECMALineStarts holds the byte offset of every source line the compiler
+// recognizes under ECMAScript's line-terminator rules.
+type ECMALineStarts = innercore.ECMALineStarts
+
 // TextRange is a half-open [Pos, End) byte range inside a source file.
 type TextRange = innercore.TextRange
 
@@ -48,6 +60,35 @@ const (
   JsxEmitReact       = innercore.JsxEmitReact
   JsxEmitReactJSX    = innercore.JsxEmitReactJSX
   JsxEmitReactJSXDev = innercore.JsxEmitReactJSXDev
+
+  // ModuleKind* constants enumerate every configured output module format.
+  ModuleKindNone     = innercore.ModuleKindNone
+  ModuleKindCommonJS = innercore.ModuleKindCommonJS
+  ModuleKindAMD      = innercore.ModuleKindAMD
+  ModuleKindUMD      = innercore.ModuleKindUMD
+  ModuleKindSystem   = innercore.ModuleKindSystem
+  ModuleKindES2015   = innercore.ModuleKindES2015
+  ModuleKindES2020   = innercore.ModuleKindES2020
+  ModuleKindES2022   = innercore.ModuleKindES2022
+  ModuleKindESNext   = innercore.ModuleKindESNext
+  ModuleKindNode16   = innercore.ModuleKindNode16
+  ModuleKindNode18   = innercore.ModuleKindNode18
+  ModuleKindNode20   = innercore.ModuleKindNode20
+  ModuleKindNodeNext = innercore.ModuleKindNodeNext
+  ModuleKindPreserve = innercore.ModuleKindPreserve
+
+  // ResolutionMode* constants classify a single module-specifier lookup.
+  ResolutionModeNone     = innercore.ResolutionModeNone
+  ResolutionModeCommonJS = innercore.ResolutionModeCommonJS
+  ResolutionModeESM      = innercore.ResolutionModeESM
+
+  // ModuleResolutionKind* constants enumerate every TypeScript-Go resolver.
+  ModuleResolutionKindUnknown  = innercore.ModuleResolutionKindUnknown
+  ModuleResolutionKindClassic  = innercore.ModuleResolutionKindClassic
+  ModuleResolutionKindNode10   = innercore.ModuleResolutionKindNode10
+  ModuleResolutionKindNode16   = innercore.ModuleResolutionKindNode16
+  ModuleResolutionKindNodeNext = innercore.ModuleResolutionKindNodeNext
+  ModuleResolutionKindBundler  = innercore.ModuleResolutionKindBundler
 )
 
 // Version reports the TypeScript compiler version typescript-go implements, in
@@ -55,6 +96,12 @@ const (
 // consumer can tell which checker resolved the facts it is reading.
 func Version() string { return innercore.Version() }
 
+// ComputeECMALineStarts applies the compiler's LF, CRLF, CR, LS, and PS line
+// model to UTF-8 source text.
+func ComputeECMALineStarts(text string) ECMALineStarts {
+  return innercore.ComputeECMALineStarts(text)
+}
+
 // NewTextRange constructs a closed/open [pos, end) text range.
 func NewTextRange(pos, end int) TextRange { return innercore.NewTextRange(pos, end) }
 

package/shim/diagnosticwriter/lint.go

@@ -12,7 +12,10 @@
 package diagnosticwriter
 
 import (
+  "cmp"
   "io"
+  "slices"
+  "strings"
 
   "github.com/microsoft/typescript-go/internal/ast"
   "github.com/microsoft/typescript-go/internal/diagnostics"
@@ -166,7 +169,54 @@ func FormatMixedDiagnostics(
     },
     NewLine: "\n",
   }
+  slices.SortFunc(all, compareMixedDiagnostics)
   inner.FormatDiagnosticsWithColorAndContext(output, all, options)
   inner.WriteErrorSummaryText(output, all, options)
   return errors
 }
+
+// compareMixedDiagnostics imposes one deterministic source order on tsgo and
+// lint diagnostics before the upstream renderer consumes them. The renderer
+// intentionally writes its input order, while the two producers have separate
+// collection paths; ordering here keeps neither producer's traversal visible
+// in CLI output.
+func compareMixedDiagnostics(a, b inner.Diagnostic) int {
+  if c := strings.Compare(mixedDiagnosticFileName(a), mixedDiagnosticFileName(b)); c != 0 {
+    return c
+  }
+  if c := cmp.Compare(a.Pos(), b.Pos()); c != 0 {
+    return c
+  }
+  if c := cmp.Compare(a.End(), b.End()); c != 0 {
+    return c
+  }
+  if c := cmp.Compare(a.Code(), b.Code()); c != 0 {
+    return c
+  }
+  if c := cmp.Compare(a.Category(), b.Category()); c != 0 {
+    return c
+  }
+  if c := strings.Compare(a.Localize(locale.Default), b.Localize(locale.Default)); c != 0 {
+    return c
+  }
+  if c := compareMixedDiagnosticLists(a.MessageChain(), b.MessageChain()); c != 0 {
+    return c
+  }
+  return compareMixedDiagnosticLists(a.RelatedInformation(), b.RelatedInformation())
+}
+
+func mixedDiagnosticFileName(d inner.Diagnostic) string {
+  if file := d.File(); file != nil {
+    return file.FileName()
+  }
+  return ""
+}
+
+func compareMixedDiagnosticLists(a, b []inner.Diagnostic) int {
+  for i := 0; i < len(a) && i < len(b); i++ {
+    if c := compareMixedDiagnostics(a[i], b[i]); c != 0 {
+      return c
+    }
+  }
+  return cmp.Compare(len(a), len(b))
+}

package/src/TtscCompiler.ts

@@ -6,6 +6,7 @@ import { resolveProjectConfig } from "./compiler/internal/project/resolveProject
 import { resolveBinary } from "./compiler/internal/resolveBinary";
 import { createProcessDiagnostic } from "./compiler/internal/runBuild";
 import { transformProjectInMemory } from "./compiler/internal/transformProjectInMemory";
+import { assertSafeExplicitCacheDirectory } from "./internal/assertSafeExplicitCacheDirectory";
 import { resolveCleanTargets } from "./plugin/internal/buildSourcePlugin";
 import { loadProjectPlugins } from "./plugin/internal/loadProjectPlugins";
 import type { ITtscCompilerContext } from "./structures/ITtscCompilerContext";
@@ -91,7 +92,9 @@ export class TtscCompiler {
    * project-local caches. A user-provided `GOCACHE` is never removed. The cache
    * location comes from this instance's `cacheDir` and environment
    * (`TTSC_CACHE_DIR` / `TTSC_GO_CACHE_DIR`), defaulting to
-   * `<workspaceRoot>/node_modules/.cache/ttsc`.
+   * `<workspaceRoot>/node_modules/.cache/ttsc`. An explicit cache directory
+   * that equals or contains the project, or names a filesystem root, is
+   * rejected before any directory is removed.
    *
    * @returns Cache directories that were removed.
    */
@@ -103,6 +106,7 @@ export class TtscCompiler {
     ];
     const explicitCacheDir = this.resolveCacheDir();
     if (explicitCacheDir !== undefined) {
+      assertSafeExplicitCacheDirectory(projectRoot, explicitCacheDir);
       // An explicit constructor `cacheDir` names the cache directory for this
       // instance — exactly like `ttsc clean --cache-dir X` on the CLI — so
       // remove it wholesale plus the legacy project-local caches. This keeps

package/src/TtscService.ts

@@ -4,6 +4,18 @@ import type { ResidentTransformProcess } from "./compiler/internal/residentTrans
 import { startResidentTransform } from "./compiler/internal/startResidentTransform";
 import type { ITtscCompilerContext } from "./structures/ITtscCompilerContext";
 
+/** Construction controls for the resident transform request lifecycle. */
+export interface TtscServiceOptions {
+  /** Maximum time one transform or update request may await the host's reply. */
+  requestTimeoutMs?: number;
+}
+
+/** Per-call controls for a resident transform or update request. */
+export interface TtscServiceRequestOptions {
+  /** Abort this call before it receives a reply. */
+  signal?: AbortSignal;
+}
+
 /**
  * Resident, incremental transform service for the `ttsc` TypeScript-Go
  * pipeline.
@@ -37,14 +49,20 @@ export class TtscService {
    * host. The context is the same shape {@link TtscCompiler} accepts; it is not
    * replaceable per call.
    */
-  public constructor(context: ITtscCompilerContext = {}) {
-    const started = startResidentTransform({
-      ...context,
-      env: context.env ? { ...context.env } : undefined,
-      plugins: Array.isArray(context.plugins)
-        ? [...context.plugins]
-        : context.plugins,
-    });
+  public constructor(
+    context: ITtscCompilerContext = {},
+    options: TtscServiceOptions = {},
+  ) {
+    const started = startResidentTransform(
+      {
+        ...context,
+        env: context.env ? { ...context.env } : undefined,
+        plugins: Array.isArray(context.plugins)
+          ? [...context.plugins]
+          : context.plugins,
+      },
+      options,
+    );
     this.resident = started.process;
     this.projectRoot = started.projectRoot;
   }
@@ -57,10 +75,14 @@ export class TtscService {
    * Rejects when the resident host failed to compile the project; the rejection
    * carries the host's diagnostics so callers can surface a real build error.
    */
-  public async transformFile(fileName: string): Promise<string | undefined> {
+  public async transformFile(
+    fileName: string,
+    options: TtscServiceRequestOptions = {},
+  ): Promise<string | undefined> {
     const reply = await this.resident.request(
       { file: this.absolutePath(fileName) },
       "transform",
+      options,
     );
     // The resident client already validated the reply shape (boolean `found`,
     // string `typescript` when found), so a malformed or wrong-shape reply
@@ -78,10 +100,15 @@ export class TtscService {
    * did not compile and the previous transform is still in effect. A relative
    * `fileName` is resolved against the project root.
    */
-  public async updateFile(fileName: string, content: string): Promise<boolean> {
+  public async updateFile(
+    fileName: string,
+    content: string,
+    options: TtscServiceRequestOptions = {},
+  ): Promise<boolean> {
     const reply = await this.resident.request(
       { content, update: this.absolutePath(fileName) },
       "update",
+      options,
     );
     // The resident client validated the reply carries a boolean `updated`, so a
     // malformed or wrong-shape reply rejected instead of collapsing to `false`.