@ttsc/wasm 0.30.4 → 0.31.1

package/shim-vendor/shim/diagnosticwriter/shim.go

@@ -15,6 +15,20 @@ import (
 
 // FormatASTDiagnosticsWithColorAndContext writes TypeScript-style pretty
 // diagnostics using the same internal formatter as typescript-go.
+// diagnostics must contain non-nil compiler diagnostics; output and source
+// files retain their caller-owned lifetimes.
+// The writer must be usable, and locations/message chains must satisfy the
+// formatter's compiler-data premises. Upstream ignores individual write errors;
+// this void operation neither reports successful delivery nor closes the writer.
+//
+// @evidence contracts/common.md#principled-implementation Upstream AST adapters implement the formatter's Diagnostic interface, and the same rendering/summary operations receive them with the caller's current directory and default locale.
+// @evidence contracts/common.md#clear-and-simple-design One pure-AST rendering entry composes adaptation, contextual formatting and summary emission; mixed lint rendering stays in its separate adjacent entry.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts The supplied output writer receives real compiler messages; no global stream replacement or source-pattern diagnostic approximation is involved.
+// @evidence contracts/common.md#meaningful-documentation Native prose identifies upstream formatting, non-nil input requirements and caller-owned writer/source lifetime before these tags.
+// @evidence contracts/performance.md#bound-retention-and-release-resources Adapted diagnostic and related/message-chain arrays, snippet strings and summary grouping/sorting state are invocation-local, borrowing caller diagnostic/source graphs. Supplied writer storage and any source-position caches remain with their owners; output can remain retained by that writer after return. This adapter neither closes it nor imposes a fixed byte/population cap, and local state becoming unreachable does not promise immediate reclamation.
+// @evidence contracts/performance.md#efficient-algorithms Adapt the input once, render diagnostics in supplied order, then build the error summary. Actual work includes nested messages/related data, path text, source-position lookup and snippet bytes, plus a second diagnostic scan and filename grouping/sort for the summary. Writer operations contribute their own cost; one formatter call does not make the whole operation a single linear pass over diagnostic count.
+// @evidenceExclude contracts/performance.md#reuse-equivalent-work This call-local renderer coordinates no completed/in-flight formatted-result cache. Upstream and source owners manage reusable message/localization or source-position state, while the caller owns whether emitted output can be reused for equivalent diagnostics and context.
+// @evidence contracts/portability.md#os-neutral-implementation The path comparison options carry the supplied current directory and a fixed case-sensitive policy because the writer only renders display paths and compares no filesystem identities.
 func FormatASTDiagnosticsWithColorAndContext(output io.Writer, diagnostics []*ast.Diagnostic, currentDirectory string) {
   if len(diagnostics) == 0 {
     return

package/shim-vendor/shim/lsp/go.mod

@@ -2,15 +2,15 @@ module github.com/microsoft/typescript-go/shim/lsp
 
 go 1.26
 
-require github.com/microsoft/typescript-go v0.0.0-20260429010842-56ab4af42157
+require github.com/microsoft/typescript-go v0.0.0-20260610182825-7fc57c005063
 
 require (
 	github.com/Microsoft/go-winio v0.6.2 // indirect
-	github.com/go-json-experiment/json v0.0.0-20260214004413-d219187c3433 // indirect
+	github.com/go-json-experiment/json v0.0.0-20260601182631-00ed12fed2a6 // indirect
 	github.com/klauspost/cpuid/v2 v2.2.10 // indirect
 	github.com/mackerelio/go-osstat v0.2.7 // 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
+	golang.org/x/sync v0.21.0 // indirect
+	golang.org/x/sys v0.46.0 // indirect
+	golang.org/x/text v0.38.0 // indirect
 )

package/shim-vendor/shim/lsp/go.sum

@@ -1,26 +1,26 @@
 github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY=
 github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU=
-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/go-json-experiment/json v0.0.0-20260601182631-00ed12fed2a6 h1:nxP4pPoyqOAgX8lYDFCfl3DyKeXErCvSvhcyzwGV9CE=
+github.com/go-json-experiment/json v0.0.0-20260601182631-00ed12fed2a6/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/mackerelio/go-osstat v0.2.7 h1:TCavZi10wF49bT6iQZ9eT2keGZQpC69MTDfdJej5e94=
 github.com/mackerelio/go-osstat v0.2.7/go.mod h1:dwpYh5pIPmvk+IEwBKNIWRFMB92mrC08CmXOhDC7nQk=
-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/microsoft/typescript-go v0.0.0-20260610182825-7fc57c005063 h1:UUVrjTrD+7nkVvkJTjxwA5+SaZ5n1uyAffm2zX2gn+o=
+github.com/microsoft/typescript-go v0.0.0-20260610182825-7fc57c005063/go.mod h1:s3yhRRZ7nzSZaiKicku520Tj9Mvewr9y2UtrvpwOmDE=
 github.com/peter-evans/patience v0.3.0 h1:rX0JdJeepqdQl1Sk9c9uvorjYYzL2TfgLX1adqYm9cA=
 github.com/peter-evans/patience v0.3.0/go.mod h1:Kmxu5sY1NmBLFSStvXjX1wS9mIv7wMcP/ubucyMOAu0=
 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=
+golang.org/x/sync v0.21.0 h1:HLII4xRRTtCRkxYp4HNFF0Js/Og6q2i++KXbg0gHCwM=
+golang.org/x/sync v0.21.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
+golang.org/x/sys v0.46.0 h1:noSf2Fq6F8DBgS+LysIkx7rIExoNHJsxOAtPp4rthXw=
+golang.org/x/sys v0.46.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
+golang.org/x/text v0.38.0 h1:sXmwo9DwP3OK9EZ7PqAdaooSGozfl/3a6/xJcbzPRhE=
+golang.org/x/text v0.38.0/go.mod h1:YXZt3QhHUKYT53r2lLKFIVi6Ao1jdzrTR/KQ09qyxF4=
 gotest.tools/v3 v3.5.2 h1:7koQfIKdy+I8UTetycgUqXWSDwpgv193Ka+qRsmBY8Q=
 gotest.tools/v3 v3.5.2/go.mod h1:LtdLGcnqToBH83WByAAi/wiwSFCArdFIUV/xxN4pcjA=

package/shim-vendor/shim/lsp/shim.go

@@ -2,7 +2,7 @@
 //
 // Minimal shim of tsgo's internal/lsp package. Hand-written instead of
 // generated so the surface stays narrow for custom in-process host
-// experiments. The shipped ttscserver wraps `tsc --lsp --stdio` as an
+// experiments. The shipped ttscserver wraps `tsgo --lsp --stdio` as an
 // external process and does not import this package. The marker on the
 // first line tells gen_shims to skip this file.
 package lsp
@@ -15,22 +15,98 @@ import (
 )
 
 // Server is the opaque LSP server type from tsgo.
+//
+// @evidence contracts/common.md#principled-implementation A Go alias preserves the upstream server identity and method set, so NewServer results can be used without an incompatible wrapper type.
+// @evidence contracts/common.md#clear-and-simple-design The opaque alias leaves protocol state and execution with the existing server instead of duplicating its lifecycle in the shim.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts This bridge names the actual upstream type without substituting a ttsc-specific server or mutating its methods.
+// @evidence contracts/common.md#meaningful-documentation The declaration identifies opaque server provenance; package prose explains the experimental in-process scope and the shipped external-process host distinction.
+// @evidenceExclude contracts/performance.md#bound-retention-and-release-resources A type declaration acquires and holds no runtime resource.
+// @evidenceExclude contracts/performance.md#efficient-algorithms A type declaration chooses no processing strategy.
+// @evidenceExclude contracts/performance.md#reuse-equivalent-work A type declaration computes nothing, so there is no work to share.
+// @evidenceExclude contracts/portability.md#os-neutral-implementation This type declaration describes a data shape only; it opens no file, builds no path and branches on no platform.
 type Server = innerlsp.Server
 
 // ServerOptions mirrors the upstream construction parameters. Fields with
 // internal-package types (e.g. ParseCache *project.ParseCache) can be left
 // unset by callers when upstream accepts nil.
+// Native paths, filesystem operations and process callbacks remain supplied
+// by the embedding host; this alias adds no platform-specific defaults.
+//
+// @evidence contracts/common.md#principled-implementation The alias retains the upstream options fields and callback types exactly; no shadow struct loses filesystem, transport or construction distinctions.
+// @evidence contracts/common.md#clear-and-simple-design Server construction accepts its native configuration directly, avoiding a second options mapper beside NewServer.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts Callers supply upstream configuration rather than consumer-specific defaults or fabricated project state.
+// @evidence contracts/common.md#meaningful-documentation Native prose identifies construction purpose and the internal-type limitation, conditioning omission on upstream nil support rather than promising every field is optional.
+// @evidenceExclude contracts/performance.md#bound-retention-and-release-resources A type declaration acquires and holds no runtime resource.
+// @evidenceExclude contracts/performance.md#efficient-algorithms A type declaration chooses no processing strategy.
+// @evidenceExclude contracts/performance.md#reuse-equivalent-work A type declaration computes nothing, so there is no work to share.
+// @evidence contracts/portability.md#os-neutral-implementation The exact upstream options preserve Cwd, filesystem and library/typings paths, npm execution and parent-process callback boundaries; the embedding host supplies their native semantics, while the alias performs no path folding, shell construction or platform substitution.
 type ServerOptions = innerlsp.ServerOptions
 
-// Reader / Writer carry framed lsproto.Message values.
+// Reader receives decoded lsproto.Message values from the upstream LSP transport.
+//
+// @evidence contracts/common.md#principled-implementation Aliasing the upstream interface preserves its Read result and error contract, including its exact message identity.
+// @evidence contracts/common.md#clear-and-simple-design The reader interface names the inbound message boundary independently of byte-stream adaptation in ToReader.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts Messages remain upstream protocol values rather than a simplified ttsc-only request schema.
+// @evidence contracts/common.md#meaningful-documentation The comment identifies decoded inbound messages; it does not conflate this message reader with io.Reader bytes.
+// @evidenceExclude contracts/performance.md#bound-retention-and-release-resources A type declaration acquires and holds no runtime resource.
+// @evidenceExclude contracts/performance.md#efficient-algorithms A type declaration chooses no processing strategy.
+// @evidenceExclude contracts/performance.md#reuse-equivalent-work A type declaration computes nothing, so there is no work to share.
+// @evidenceExclude contracts/portability.md#os-neutral-implementation This type declaration describes a data shape only; it opens no file, builds no path and branches on no platform.
 type Reader = innerlsp.Reader
+
+// Writer sends lsproto.Message values through the upstream LSP transport.
+//
+// @evidence contracts/common.md#principled-implementation Aliasing the upstream Write interface preserves message type identity and its returned transport error.
+// @evidence contracts/common.md#clear-and-simple-design The outbound message interface remains distinct from the byte writer wrapped by ToWriter.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts The transport keeps upstream protocol messages without modifying a foreign writer or hiding failed writes.
+// @evidence contracts/common.md#meaningful-documentation The native comment names outbound messages and distinguishes the interface from raw byte output.
+// @evidenceExclude contracts/performance.md#bound-retention-and-release-resources A type declaration acquires and holds no runtime resource.
+// @evidenceExclude contracts/performance.md#efficient-algorithms A type declaration chooses no processing strategy.
+// @evidenceExclude contracts/performance.md#reuse-equivalent-work A type declaration computes nothing, so there is no work to share.
+// @evidenceExclude contracts/portability.md#os-neutral-implementation This type declaration describes a data shape only; it opens no file, builds no path and branches on no platform.
 type Writer = innerlsp.Writer
 
+// NewServer constructs the upstream in-process server. opts must be non-nil
+// and supply Cwd; missing Cwd panics under the upstream construction contract.
+//
+// @evidence contracts/common.md#principled-implementation The exact linked constructor receives aliased options and returns the upstream Server; its non-nil options and required Cwd premises remain caller obligations.
+// @evidence contracts/common.md#clear-and-simple-design One constructor bridge leaves initialization, project state and queues with the upstream server rather than layering a separate host lifecycle.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts Explicit symbol linkage exposes the existing implementation; the shim does not fake server readiness or patch construction defaults.
+// @evidence contracts/common.md#meaningful-documentation Native prose states in-process purpose, required options and the Cwd panic boundary before the linked declaration.
+// @evidenceExclude contracts/performance.md#bound-retention-and-release-resources NewServer declares a signature only; the implementation owns acquisition and release of resources.
+// @evidenceExclude contracts/performance.md#efficient-algorithms NewServer declares a signature only; the implementation owns the processing strategy.
+// @evidenceExclude contracts/performance.md#reuse-equivalent-work NewServer declares a signature only; the implementation owns any shared work.
+// @evidenceExclude contracts/portability.md#os-neutral-implementation NewServer is a signature without a body here; path and platform behavior belongs to the implementation that supplies it.
+//
 //go:linkname NewServer github.com/microsoft/typescript-go/internal/lsp.NewServer
 func NewServer(opts *ServerOptions) *Server
 
+// ToReader adapts an io.Reader into the upstream framed-message decoder.
+// It retains the supplied stream; the caller owns that stream's lifetime.
+//
+// @evidence contracts/common.md#principled-implementation The linked adapter constructs upstream lsproto framing and message decoding over the supplied byte stream, preserving the server's Reader contract.
+// @evidence contracts/common.md#clear-and-simple-design A single adapter separates raw bytes from decoded messages without a parallel JSON-RPC parser in the shim.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts The actual stream is supplied explicitly; no process-global input replacement or canned decoded request is used.
+// @evidence contracts/common.md#meaningful-documentation Native prose identifies framing and retained-stream ownership rather than merely repeating the conversion name.
+// @evidenceExclude contracts/performance.md#bound-retention-and-release-resources ToReader declares a signature only; the implementation owns acquisition and release of resources.
+// @evidenceExclude contracts/performance.md#efficient-algorithms ToReader declares a signature only; the implementation owns the processing strategy.
+// @evidenceExclude contracts/performance.md#reuse-equivalent-work ToReader declares a signature only; the implementation owns any shared work.
+// @evidenceExclude contracts/portability.md#os-neutral-implementation ToReader is a signature without a body here; path and platform behavior belongs to the implementation that supplies it.
+//
 //go:linkname ToReader github.com/microsoft/typescript-go/internal/lsp.ToReader
 func ToReader(r io.Reader) Reader
 
+// ToWriter adapts an io.Writer into the upstream framed-message encoder.
+// It retains the supplied stream; the caller owns that stream's lifetime.
+//
+// @evidence contracts/common.md#principled-implementation The linked adapter uses upstream JSON encoding and lsproto framing on the supplied byte writer, retaining the Writer error contract.
+// @evidence contracts/common.md#clear-and-simple-design One adapter owns message-to-byte representation while the upstream transport owns serialization and framing details.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts Output uses the caller's stream rather than a replacement global stdout or a success-only transport stub.
+// @evidence contracts/common.md#meaningful-documentation Native prose identifies encoding and retained-stream ownership, with a blank comment separator before the acknowledgment tags.
+// @evidenceExclude contracts/performance.md#bound-retention-and-release-resources ToWriter declares a signature only; the implementation owns acquisition and release of resources.
+// @evidenceExclude contracts/performance.md#efficient-algorithms ToWriter declares a signature only; the implementation owns the processing strategy.
+// @evidenceExclude contracts/performance.md#reuse-equivalent-work ToWriter declares a signature only; the implementation owns any shared work.
+// @evidenceExclude contracts/portability.md#os-neutral-implementation ToWriter is a signature without a body here; path and platform behavior belongs to the implementation that supplies it.
+//
 //go:linkname ToWriter github.com/microsoft/typescript-go/internal/lsp.ToWriter
 func ToWriter(w io.Writer) Writer

package/shim-vendor/shim/parser/go.mod

@@ -2,4 +2,13 @@ module github.com/microsoft/typescript-go/shim/parser
 
 go 1.26
 
-require github.com/microsoft/typescript-go v0.0.0-20260429010842-56ab4af42157
+require github.com/microsoft/typescript-go v0.0.0-20260610182825-7fc57c005063
+
+require (
+	github.com/go-json-experiment/json v0.0.0-20260601182631-00ed12fed2a6 // indirect
+	github.com/klauspost/cpuid/v2 v2.2.10 // indirect
+	github.com/zeebo/xxh3 v1.1.0 // indirect
+	golang.org/x/sync v0.21.0 // indirect
+	golang.org/x/sys v0.46.0 // indirect
+	golang.org/x/text v0.38.0 // indirect
+)

package/shim-vendor/shim/parser/go.sum

@@ -0,0 +1,22 @@
+github.com/go-json-experiment/json v0.0.0-20260601182631-00ed12fed2a6 h1:nxP4pPoyqOAgX8lYDFCfl3DyKeXErCvSvhcyzwGV9CE=
+github.com/go-json-experiment/json v0.0.0-20260601182631-00ed12fed2a6/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-20260610182825-7fc57c005063 h1:UUVrjTrD+7nkVvkJTjxwA5+SaZ5n1uyAffm2zX2gn+o=
+github.com/microsoft/typescript-go v0.0.0-20260610182825-7fc57c005063/go.mod h1:s3yhRRZ7nzSZaiKicku520Tj9Mvewr9y2UtrvpwOmDE=
+github.com/peter-evans/patience v0.3.0 h1:rX0JdJeepqdQl1Sk9c9uvorjYYzL2TfgLX1adqYm9cA=
+github.com/peter-evans/patience v0.3.0/go.mod h1:Kmxu5sY1NmBLFSStvXjX1wS9mIv7wMcP/ubucyMOAu0=
+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.21.0 h1:HLII4xRRTtCRkxYp4HNFF0Js/Og6q2i++KXbg0gHCwM=
+golang.org/x/sync v0.21.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
+golang.org/x/sys v0.46.0 h1:noSf2Fq6F8DBgS+LysIkx7rIExoNHJsxOAtPp4rthXw=
+golang.org/x/sys v0.46.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
+golang.org/x/text v0.38.0 h1:sXmwo9DwP3OK9EZ7PqAdaooSGozfl/3a6/xJcbzPRhE=
+golang.org/x/text v0.38.0/go.mod h1:YXZt3QhHUKYT53r2lLKFIVi6Ao1jdzrTR/KQ09qyxF4=
+gotest.tools/v3 v3.5.2 h1:7koQfIKdy+I8UTetycgUqXWSDwpgv193Ka+qRsmBY8Q=
+gotest.tools/v3 v3.5.2/go.mod h1:LtdLGcnqToBH83WByAAi/wiwSFCArdFIUV/xxN4pcjA=

package/shim-vendor/shim/printer/emithost.go

@@ -9,16 +9,61 @@ import innerprinter "github.com/microsoft/typescript-go/internal/printer"
 
 // EmitHost is the per-emit host interface tsgo's transformers query (Options,
 // SourceFiles, GetEmitResolver, GetEmitModuleFormatOfFile, WriteFile, ...).
+// The embedding host supplies native path/case policy and file output;
+// upstream requires host operations to be thread-safe.
+//
+// @evidence contracts/common.md#principled-implementation The exact upstream interface alias preserves the option, resolver and output callbacks its transformer chain requires; driver hosts satisfy that same contract without conversion.
+// @evidence contracts/common.md#clear-and-simple-design One interface alias exposes the owning compiler boundary instead of a second host abstraction with independently maintained methods.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts Implementing this interface is supported dependency injection; the alias neither patches a host instance nor changes upstream dispatch.
+// @evidence contracts/common.md#meaningful-documentation Native prose identifies the per-emit role and representative queries, while the package introduction explains the driver-to-transformer use.
+// @evidenceExclude contracts/performance.md#bound-retention-and-release-resources A type declaration acquires and holds no runtime resource.
+// @evidenceExclude contracts/performance.md#efficient-algorithms A type declaration chooses no processing strategy.
+// @evidenceExclude contracts/performance.md#reuse-equivalent-work A type declaration computes nothing, so there is no work to share.
+// @evidence contracts/portability.md#os-neutral-implementation The upstream interface preserves current/common directories, filename case policy, project-reference paths and WriteFile errors as explicit host boundaries; its implementation supplies native semantics without alias-owned path folding or an assumed universal filesystem policy.
 type EmitHost = innerprinter.EmitHost
 
 // EmitResolver resolves emit-time facts about nodes (referenced imports,
-// declaration flags, ...) under the checker mutex.
+// declaration flags, ...). Synchronization belongs to the supplied resolver
+// implementation and host contract; the pinned checker-backed resolver locks
+// its checker internally for semantic queries. The alias adds no lock.
+//
+// @evidence contracts/common.md#principled-implementation An exact resolver interface alias retains the compiler's emit-time semantic queries and lets the host supply facts from the same checked program.
+// @evidence contracts/common.md#clear-and-simple-design The alias exposes the existing semantic boundary without duplicating checker state or inventing another resolver protocol.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts The host supplies a resolver through upstream's interface; no foreign method or checker global is replaced.
+// @evidence contracts/common.md#meaningful-documentation Native prose identifies emit-time facts, distinguishes resolver/host synchronization from the alias and notes the pinned checker resolver's internal locking instead of requiring a caller-held checker mutex.
+// @evidenceExclude contracts/performance.md#bound-retention-and-release-resources A type declaration acquires and holds no runtime resource.
+// @evidenceExclude contracts/performance.md#efficient-algorithms A type declaration chooses no processing strategy.
+// @evidenceExclude contracts/performance.md#reuse-equivalent-work A type declaration computes nothing, so there is no work to share.
+// @evidenceExclude contracts/portability.md#os-neutral-implementation This type declaration describes a data shape only; it opens no file, builds no path and branches on no platform.
 type EmitResolver = innerprinter.EmitResolver
 
 // EmitTextWriter is the sink the printer emits into; String() yields the text.
+//
+// @evidence contracts/common.md#principled-implementation The upstream writer interface alias preserves printing operations and text extraction as one compatible sink contract.
+// @evidence contracts/common.md#clear-and-simple-design The printer and host share the existing sink interface, avoiding a separate buffering adapter.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts The declaration introduces no replacement methods, fixture dispatch or compensating behavior.
+// @evidence contracts/common.md#meaningful-documentation Native prose states the sink's output role and how callers obtain its accumulated text.
+// @evidenceExclude contracts/performance.md#bound-retention-and-release-resources A type declaration acquires and holds no runtime resource.
+// @evidenceExclude contracts/performance.md#efficient-algorithms A type declaration chooses no processing strategy.
+// @evidenceExclude contracts/performance.md#reuse-equivalent-work A type declaration computes nothing, so there is no work to share.
+// @evidenceExclude contracts/portability.md#os-neutral-implementation This type declaration describes a data shape only; it opens no file, builds no path and branches on no platform.
 type EmitTextWriter = innerprinter.EmitTextWriter
 
 // NewTextWriter creates a fresh writer for one emit (newLine e.g. "\n").
+// indentSize controls spaces per indentation level; nonpositive values select
+// the pinned writer's default of four spaces.
+// The caller owns the returned mutable sink and its accumulated text;
+// Clear resets its buffer state, while previously returned strings remain
+// owned by their consumers.
+//
+// @evidence contracts/common.md#principled-implementation Delegating newline and indentation width preserves upstream position accounting and its four-space fallback for nonpositive widths.
+// @evidence contracts/common.md#clear-and-simple-design The constructor returns one fresh upstream sink without shared buffers or additional output policy.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts Formatting parameters are explicit inputs; no consumer-specific formatting or foreign method replacement is introduced.
+// @evidence contracts/common.md#meaningful-documentation Native prose states writer lifetime, newline example, indentation units and nonpositive-width default with tags separated from descriptive text.
+// @evidence contracts/performance.md#bound-retention-and-release-resources The returned sink retains its newline backing string and subsequently accumulated output; its caller controls Clear and reference release, and strings already returned can keep output bytes alive after Clear. Construction opens no handle and enforces no output-byte cap or concurrent-use guard.
+// @evidenceExclude contracts/performance.md#efficient-algorithms The upstream constructor owns indentation fallback and fresh writer initialization; this adapter chooses no independent buffering or formatting strategy.
+// @evidenceExclude contracts/performance.md#reuse-equivalent-work This factory requests a fresh upstream writer; the caller decides when an existing sink can be cleared and reused, without an adapter-owned shared producer or request-validity cache.
+// @evidenceExclude contracts/portability.md#os-neutral-implementation NewTextWriter computes from its arguments only; it opens no file, builds no path and calls no platform or process API.
 func NewTextWriter(newLine string, indentSize int) EmitTextWriter {
   return innerprinter.NewTextWriter(newLine, indentSize)
 }

package/shim-vendor/shim/printer/go.mod

@@ -2,13 +2,13 @@ module github.com/microsoft/typescript-go/shim/printer
 
 go 1.26
 
-require github.com/microsoft/typescript-go v0.0.0-20260429010842-56ab4af42157
+require github.com/microsoft/typescript-go v0.0.0-20260610182825-7fc57c005063
 
 require (
-	github.com/go-json-experiment/json v0.0.0-20260214004413-d219187c3433 // indirect
+	github.com/go-json-experiment/json v0.0.0-20260601182631-00ed12fed2a6 // 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
+	golang.org/x/sync v0.21.0 // indirect
+	golang.org/x/sys v0.46.0 // indirect
+	golang.org/x/text v0.38.0 // indirect
 )

package/shim-vendor/shim/printer/go.sum

@@ -1,22 +1,22 @@
-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/go-json-experiment/json v0.0.0-20260601182631-00ed12fed2a6 h1:nxP4pPoyqOAgX8lYDFCfl3DyKeXErCvSvhcyzwGV9CE=
+github.com/go-json-experiment/json v0.0.0-20260601182631-00ed12fed2a6/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/microsoft/typescript-go v0.0.0-20260610182825-7fc57c005063 h1:UUVrjTrD+7nkVvkJTjxwA5+SaZ5n1uyAffm2zX2gn+o=
+github.com/microsoft/typescript-go v0.0.0-20260610182825-7fc57c005063/go.mod h1:s3yhRRZ7nzSZaiKicku520Tj9Mvewr9y2UtrvpwOmDE=
 github.com/peter-evans/patience v0.3.0 h1:rX0JdJeepqdQl1Sk9c9uvorjYYzL2TfgLX1adqYm9cA=
 github.com/peter-evans/patience v0.3.0/go.mod h1:Kmxu5sY1NmBLFSStvXjX1wS9mIv7wMcP/ubucyMOAu0=
 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=
+golang.org/x/sync v0.21.0 h1:HLII4xRRTtCRkxYp4HNFF0Js/Og6q2i++KXbg0gHCwM=
+golang.org/x/sync v0.21.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
+golang.org/x/sys v0.46.0 h1:noSf2Fq6F8DBgS+LysIkx7rIExoNHJsxOAtPp4rthXw=
+golang.org/x/sys v0.46.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
+golang.org/x/text v0.38.0 h1:sXmwo9DwP3OK9EZ7PqAdaooSGozfl/3a6/xJcbzPRhE=
+golang.org/x/text v0.38.0/go.mod h1:YXZt3QhHUKYT53r2lLKFIVi6Ao1jdzrTR/KQ09qyxF4=
 gotest.tools/v3 v3.5.2 h1:7koQfIKdy+I8UTetycgUqXWSDwpgv193Ka+qRsmBY8Q=
 gotest.tools/v3 v3.5.2/go.mod h1:LtdLGcnqToBH83WByAAi/wiwSFCArdFIUV/xxN4pcjA=

package/shim-vendor/shim/printer/shim.go

@@ -5,28 +5,85 @@ package printer
 
 import (
   "github.com/microsoft/typescript-go/internal/ast"
+  "github.com/microsoft/typescript-go/internal/core"
   innerprinter "github.com/microsoft/typescript-go/internal/printer"
 )
 
-// PrintHandlers provides optional hooks (e.g. substituteNode) called during
-// AST emission.
+// PrintHandlers supplies the pinned printer's global-name collision hook and
+// before/after notifications for nodes, node lists and tokens. The legacy
+// node-substitution and custom emit-callback hooks are not exposed by this
+// TypeScript-Go version.
+//
+// @evidence contracts/common.md#principled-implementation The alias preserves HasGlobalName and the six node/list/token notification callbacks with their upstream signatures, allowing collision queries and traversal observations through the printer's actual supported boundaries.
+// @evidence contracts/common.md#clear-and-simple-design One upstream handler value groups collision queries and traversal notifications without a separate dispatch framework or a shim-owned substitution protocol.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts Supported callback injection supplies collision facts and traversal observations without replacing foreign printer methods; unavailable legacy substitution and custom emit callbacks are not simulated.
+// @evidence contracts/common.md#meaningful-documentation Native prose names the available callback families and distinguishes their notifications from unavailable legacy substitution and custom emission hooks.
+// @evidenceExclude contracts/performance.md#bound-retention-and-release-resources A type declaration acquires and holds no runtime resource.
+// @evidenceExclude contracts/performance.md#efficient-algorithms A type declaration chooses no processing strategy.
+// @evidenceExclude contracts/performance.md#reuse-equivalent-work A type declaration computes nothing, so there is no work to share.
+// @evidenceExclude contracts/portability.md#os-neutral-implementation This type declaration describes a data shape only; it opens no file, builds no path and branches on no platform.
 type PrintHandlers = innerprinter.PrintHandlers
 
 // Printer holds the stateful emitter produced by NewPrinter.
+//
+// @evidence contracts/common.md#principled-implementation Go alias identity preserves upstream printer state and methods, allowing direct emission of compiler AST nodes without a parallel representation.
+// @evidence contracts/common.md#clear-and-simple-design The existing emitter remains the single printing owner; this alias adds no mutable wrapper state.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts Emission uses the actual compiler printer rather than source-spelling replacements or patched internals.
+// @evidence contracts/common.md#meaningful-documentation The native comment identifies stateful construction provenance; NewPrinter documents shared emit-context use.
+// @evidenceExclude contracts/performance.md#bound-retention-and-release-resources A type declaration acquires and holds no runtime resource.
+// @evidenceExclude contracts/performance.md#efficient-algorithms A type declaration chooses no processing strategy.
+// @evidenceExclude contracts/performance.md#reuse-equivalent-work A type declaration computes nothing, so there is no work to share.
+// @evidenceExclude contracts/portability.md#os-neutral-implementation This type declaration describes a data shape only; it opens no file, builds no path and branches on no platform.
 type Printer = innerprinter.Printer
 
 // PrinterOptions configures newline style, source-map generation, and other
 // emission knobs.
+//
+// @evidence contracts/common.md#principled-implementation Aliasing the complete pinned options struct preserves the printer's supported fields and enum identities instead of losing settings in an incomplete copied schema.
+// @evidence contracts/common.md#clear-and-simple-design One native options value configures all printer constructors, without independent defaults or translation in the shim.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts Settings remain caller data; the alias adds no consumer-specific emission overrides.
+// @evidence contracts/common.md#meaningful-documentation Native prose identifies newline and source-map configuration, distinct from the printer's retained state.
+// @evidenceExclude contracts/performance.md#bound-retention-and-release-resources A type declaration acquires and holds no runtime resource.
+// @evidenceExclude contracts/performance.md#efficient-algorithms A type declaration chooses no processing strategy.
+// @evidenceExclude contracts/performance.md#reuse-equivalent-work A type declaration computes nothing, so there is no work to share.
+// @evidenceExclude contracts/portability.md#os-neutral-implementation This type declaration describes a data shape only; it opens no file, builds no path and branches on no platform.
 type PrinterOptions = innerprinter.PrinterOptions
 
-// EmitContext accumulates per-emit metadata (source maps, comment positions)
-// and must be created fresh for each emit round via NewEmitContext.
+// EmitContext owns per-emit node provenance, generated names and helper state.
+// Create it fresh via NewEmitContext and share it across one transform/emit round.
+//
+// @evidence contracts/common.md#principled-implementation The alias retains the compiler's original-node links, naming metadata and node factory identity, allowing transformations and printing to interpret one shared provenance graph.
+// @evidence contracts/common.md#clear-and-simple-design One upstream context couples related emit operations; separate rounds use separate contexts rather than another metadata synchronization layer.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts Context state is supplied through the supported API rather than process-global caches or foreign AST metadata patches.
+// @evidence contracts/common.md#meaningful-documentation Native prose states actual retained metadata and the one-round sharing/lifetime boundary.
+// @evidenceExclude contracts/performance.md#bound-retention-and-release-resources A type declaration acquires and holds no runtime resource.
+// @evidenceExclude contracts/performance.md#efficient-algorithms A type declaration chooses no processing strategy.
+// @evidenceExclude contracts/performance.md#reuse-equivalent-work A type declaration computes nothing, so there is no work to share.
+// @evidenceExclude contracts/portability.md#os-neutral-implementation This type declaration describes a data shape only; it opens no file, builds no path and branches on no platform.
 type EmitContext = innerprinter.EmitContext
 
 // AutoGenerateOptions configures how NodeFactory allocates generated names.
+//
+// @evidence contracts/common.md#principled-implementation The alias preserves upstream naming flags, prefix and suffix fields exactly, matching the emit context's generated-name policy.
+// @evidence contracts/common.md#clear-and-simple-design One options value groups the naming decision without a parallel identifier allocator.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts Naming policy uses compiler flags and caller spelling rather than fixed names chosen for known consumers.
+// @evidence contracts/common.md#meaningful-documentation The comment identifies generated-name allocation rather than treating this as general printer formatting options.
+// @evidenceExclude contracts/performance.md#bound-retention-and-release-resources A type declaration acquires and holds no runtime resource.
+// @evidenceExclude contracts/performance.md#efficient-algorithms A type declaration chooses no processing strategy.
+// @evidenceExclude contracts/performance.md#reuse-equivalent-work A type declaration computes nothing, so there is no work to share.
+// @evidenceExclude contracts/portability.md#os-neutral-implementation This type declaration describes a data shape only; it opens no file, builds no path and branches on no platform.
 type AutoGenerateOptions = innerprinter.AutoGenerateOptions
 
 // GeneratedIdentifierFlags controls generated-name scope and collision checks.
+//
+// @evidence contracts/common.md#principled-implementation Go alias identity keeps the upstream name-kind and policy bits compatible with AutoGenerateOptions and the adjacent forwarded constants.
+// @evidence contracts/common.md#clear-and-simple-design One native flag representation expresses generated-name policy without a shim-owned enum translation.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts Flags use compiler definitions rather than guessed numeric bits or consumer-specific naming exemptions.
+// @evidence contracts/common.md#meaningful-documentation Native prose identifies scope and collision policy, and adjacent constants expose the supported flag family.
+// @evidenceExclude contracts/performance.md#bound-retention-and-release-resources A type declaration acquires and holds no runtime resource.
+// @evidenceExclude contracts/performance.md#efficient-algorithms A type declaration chooses no processing strategy.
+// @evidenceExclude contracts/performance.md#reuse-equivalent-work A type declaration computes nothing, so there is no work to share.
+// @evidenceExclude contracts/portability.md#os-neutral-implementation This type declaration describes a data shape only; it opens no file, builds no path and branches on no platform.
 type GeneratedIdentifierFlags = innerprinter.GeneratedIdentifierFlags
 
 const (
@@ -42,20 +99,70 @@ const (
   GeneratedIdentifierFlagsAllowNameSubstitution  = innerprinter.GeneratedIdentifierFlagsAllowNameSubstitution
 )
 
-// NewPrinter creates an emitter with the supplied options, substitution hooks,
-// and emit context. Callers must pass the same EmitContext to all operations
-// in a single emit round.
+// NewPrinter creates an emitter with the supplied options, handlers and emit
+// context. A nil context creates a fresh upstream context; operations that
+// depend on one round's shared node provenance must pass that same context.
+// The returned printer keeps its context and handler references; callers own
+// their lifetimes and must respect the upstream mutable-state contract.
+//
+// @evidence contracts/common.md#principled-implementation Direct delegation preserves upstream printer construction over the supplied options, hook and shared context, so transformed-node provenance remains available during emission.
+// @evidence contracts/common.md#clear-and-simple-design One constructor keeps printer state with the emitter while the caller explicitly supplies the context shared by the round.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts The supported constructor accepts dependencies directly without replacing printer internals or injecting a consumer-specific emitter.
+// @evidence contracts/common.md#meaningful-documentation Native prose identifies supplied handlers, nil-context allocation, provenance sharing and caller-owned mutable printer state.
+// @evidence contracts/performance.md#bound-retention-and-release-resources The returned printer retains handlers and its supplied or newly created context, with name-generator closures referencing that printer; later writer and name/mapping state belong to its caller-owned lifetime. Construction opens no handle and supplies no population cap, concurrent-use guard or automatic round disposal.
+// @evidenceExclude contracts/performance.md#efficient-algorithms Initial field setup, nil-context construction and name-generator wiring are upstream printer responsibilities; this adapter chooses no independent initialization or emission strategy.
+// @evidenceExclude contracts/performance.md#reuse-equivalent-work The caller controls which printers share a valid emit context, and the upstream printer owns its internal writer and metadata reuse; this constructor coordinates no request cache or shared producer.
+// @evidenceExclude contracts/portability.md#os-neutral-implementation NewPrinter computes from its arguments only; it opens no file, builds no path and calls no platform or process API.
 func NewPrinter(options PrinterOptions, handlers PrintHandlers, emitContext *EmitContext) *Printer {
   return innerprinter.NewPrinter(options, handlers, emitContext)
 }
 
 // NewEmitContext allocates a fresh EmitContext for a new emit round.
+// The caller owns its lifetime and the node metadata accumulated by the
+// round; the context is not guaranteed to be thread-safe.
+//
+// @evidence contracts/common.md#principled-implementation The upstream constructor initializes the context's own node factory; each call obtains a separate metadata identity for a separate emit round.
+// @evidence contracts/common.md#clear-and-simple-design One factory creates the context and its coupled factory together rather than exposing partially initialized emit state.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts Calls acquire real fresh upstream state rather than sharing a process-global context across unrelated emit rounds.
+// @evidence contracts/common.md#meaningful-documentation The comment identifies fresh allocation and its per-round purpose; the context type explains sharing within that round.
+// @evidence contracts/performance.md#bound-retention-and-release-resources The returned context and its factory reference each other and belong to the caller's emit round; subsequent metadata maps and scope state can retain nodes and provenance until the owning consumers release them. Construction opens no handle and imposes no metadata population cap or automatic round reset.
+// @evidenceExclude contracts/performance.md#efficient-algorithms Upstream constructs the context and factory with their node hooks; this adapter owns no independent allocation or metadata processing strategy.
+// @evidenceExclude contracts/performance.md#reuse-equivalent-work Context identity and sharing within an emit round belong to the caller; this factory only requests fresh upstream state and owns no cross-request producer or validity coordinator.
+// @evidenceExclude contracts/portability.md#os-neutral-implementation NewEmitContext computes from its arguments only; it opens no file, builds no path and calls no platform or process API.
 func NewEmitContext() *EmitContext {
   return innerprinter.NewEmitContext()
 }
 
 // EmitSourceFile renders the full source file through the printer and returns
 // the emitted text.
+// The supplied printer must be nonnil and used according to its upstream
+// state and handler contract; this adapter adds no concurrent-use guard.
+//
+// @evidence contracts/common.md#principled-implementation Delegating to the supplied upstream printer preserves AST-aware source emission; callers provide a real source file and a printer constructed for their emit context.
+// @evidence contracts/common.md#clear-and-simple-design A single rendering adapter returns text while printer configuration and context construction retain their separate owners.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts Source text is produced by compiler AST printing rather than guessed textual substitution or fixture-specific output.
+// @evidence contracts/common.md#meaningful-documentation Native prose states full-file rendering and the returned text, distinct from the source-map companion operation.
+// @evidence contracts/performance.md#bound-retention-and-release-resources The returned string retains emitted bytes for its consumers; the borrowed printer owns its reusable writer object and emit context. On normal completion upstream clears the writer's builder, while context and any prior printer state remain caller-owned, with no adapter-owned historical cache or byte cap.
+// @evidenceExclude contracts/performance.md#efficient-algorithms AST traversal, source trivia and handler work, and output-byte construction belong to the supplied upstream Printer.Emit path; this adapter chooses no independent emission algorithm, and delegation does not make those input-dependent costs constant.
+// @evidenceExclude contracts/performance.md#reuse-equivalent-work The supplied printer owns writer reuse and emit context; this adapter coordinates no equivalent requests or completed-output cache and always asks that printer to render the supplied source.
+// @evidenceExclude contracts/portability.md#os-neutral-implementation EmitSourceFile computes from its arguments only; it opens no file, builds no path and calls no platform or process API.
 func EmitSourceFile(p *Printer, sourceFile *ast.SourceFile) string {
   return p.EmitSourceFile(sourceFile)
 }
+
+// RangeStartPositionsAreOnSameLine compares two range starts after skipping
+// leading trivia in sourceFile. The nonnil file and both nonnegative range
+// starts must refer to the same source text, with positions within its bytes.
+// Synthesized negative positions are not a supported source-line query.
+//
+// @evidence contracts/common.md#principled-implementation Upstream trivia skipping and source-line comparison preserve printer layout semantics for both range starts.
+// @evidence contracts/common.md#clear-and-simple-design One predicate keeps source-position interpretation with the printer instead of a second line-index implementation.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts Actual source bytes and compiler ranges determine line identity without guessed UTF-16 offsets.
+// @evidence contracts/common.md#meaningful-documentation Native prose states trivia handling, nonnil source and shared byte-coordinate premises.
+// @evidence contracts/performance.md#bound-retention-and-release-resources When distinct trivia-adjusted positions require a line lookup, upstream can initialize the borrowed source file's locked line-start cache, retaining one entry per line for that source's lifetime. This adapter returns only a boolean and owns no historical state or handle; consumers own source and cache reference release.
+// @evidenceExclude contracts/performance.md#efficient-algorithms Upstream owns trivia scanning and source-line comparison: adjusted starts can shortcut when equal, otherwise first-use line indexing scans source bytes and line lookup uses binary search. This forwarding adapter chooses no independent scan or indexing strategy, and its constant wrapper size does not bound delegated work.
+// @evidenceExclude contracts/performance.md#reuse-equivalent-work The borrowed source file owns lazy line-map initialization and reuse for its text identity; this adapter coordinates no equivalent requests or additional cache and delegates that same source to upstream.
+// @evidenceExclude contracts/portability.md#os-neutral-implementation RangeStartPositionsAreOnSameLine computes from its arguments only; it opens no file, builds no path and calls no platform or process API.
+func RangeStartPositionsAreOnSameLine(first core.TextRange, second core.TextRange, sourceFile *ast.SourceFile) bool {
+  return innerprinter.RangeStartPositionsAreOnSameLine(first, second, sourceFile)
+}

package/shim-vendor/shim/printer/sourcemap.go

@@ -0,0 +1,55 @@
+// gen_shims:hand-maintained
+//
+// Prints one source file together with a source map back to its original text,
+// for hosts that hand transformed TypeScript to a bundler instead of emitting
+// JavaScript.
+package printer
+
+import (
+  "github.com/microsoft/typescript-go/internal/ast"
+  innerprinter "github.com/microsoft/typescript-go/internal/printer"
+  "github.com/microsoft/typescript-go/internal/sourcemap"
+  "github.com/microsoft/typescript-go/internal/tspath"
+)
+
+// EmitSourceFileWithSourceMap renders sourceFile the way EmitSourceFile does
+// and also returns a version 3 source map, as JSON, from the rendered text back
+// to the original positions its nodes still carry.
+//
+// It builds its own printer from options, handlers, and emitContext, because a
+// printer remembers the last source it mapped across writes and would reuse
+// that source's index in the next file's map. `file` is the source file's base
+// name and `sources` are relative to its directory, the layout a bundler
+// resolves a module's map against. options.InlineSources adds each source's
+// original text as `sourcesContent`, which lets a consumer check the map
+// against the text it was generated from.
+// sourceFile must be nonnil. Mapping quality depends on transformed nodes
+// retaining valid original positions through emitContext.
+//
+// @evidence contracts/common.md#principled-implementation The upstream printer writes text and mapping segments in the same traversal, using node positions and EmitContext provenance; the version-3 map names the output basename and resolves sources relative to its directory.
+// @evidence contracts/common.md#clear-and-simple-design A fresh printer, generator and writer belong to one file, preventing printer-held source indexes from leaking into the next map.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts Fresh per-file mapping state corrects the actual source-index lifetime; source names and inline content come from compiler objects rather than consumer-specific substitutions.
+// @evidence contracts/common.md#meaningful-documentation Native prose explains map layout, fresh-printer ownership, inline sources, nonnil input and original-position requirements in separated paragraphs.
+// @evidence contracts/performance.md#efficient-algorithms The same printer Write supplies text and mapping segments without a separate map-building AST pass in this adapter. Work includes upstream traversal, trivia and supplied handlers, source/name path processing, mapping encoding, cloned source/name/content lists and JSON serialization; space grows with output, mapping and optional inline source bytes, with temporary JSON bytes alongside the returned map string.
+// @evidence contracts/performance.md#reuse-equivalent-work The same traversal supplies both outputs and EmitContext supplies original-node provenance; a fresh per-file printer is necessary because retained source indexes cannot be shared between independent map generators.
+// @evidence contracts/performance.md#bound-retention-and-release-resources The call owns its fresh printer, generator and writer; returned text and map strings retain output bytes for their consumers. Local mapping lists, source references and temporary JSON storage become unreachable when the call ends, while the borrowed emit context and handler state remain caller-owned. There is no adapter-owned historical cache, running task or enforced byte cap.
+// @evidence contracts/portability.md#os-neutral-implementation The generator uses the emitted source directory as its lexical path base and a fixed case-sensitive policy for original source names, including names recovered through emit provenance. These map paths are presentation data rather than filesystem identity queries; the adapter performs no native lookup or case-sensitivity probe.
+func EmitSourceFileWithSourceMap(
+  options PrinterOptions,
+  handlers PrintHandlers,
+  emitContext *EmitContext,
+  sourceFile *ast.SourceFile,
+) (string, string) {
+  printer := innerprinter.NewPrinter(options, handlers, emitContext)
+  fileName := sourceFile.FileName()
+  directory := tspath.GetDirectoryPath(fileName)
+  generator := sourcemap.NewGenerator(
+    tspath.GetBaseFileName(fileName),
+    "",
+    directory,
+    tspath.ComparePathsOptions{UseCaseSensitiveFileNames: true, CurrentDirectory: directory},
+  )
+  writer := innerprinter.NewTextWriter(options.NewLine.GetNewLineCharacter(), 0)
+  printer.Write(sourceFile.AsNode(), sourceFile, writer, generator)
+  return writer.String(), generator.String()
+}