@ttsc/wasm 0.26.1 → 0.27.0

package/dist/.ttsc-wasm-build.json

@@ -1,11 +1,11 @@
 {
   "schema": 1,
-  "identity": "752eeb8e4ed48203ae31a47a136b0a4040e52f80d04b20b14b7c6f73060f57c5",
+  "identity": "909fe771e33d587b54640b0c1f1971dbda3250440df3de236c2824dd9986231f",
   "artifacts": [
     {
       "path": "/home/runner/work/ttsc/ttsc/packages/wasm/dist/ttsc.wasm",
       "type": "file",
-      "sha256": "d22e7d8a0fdfbb4041027288e2b25199570d4f94bc6e7011dbd9ba67689030eb"
+      "sha256": "566c2e1f04b41c9c41c249b4d693efae7aa97a326c4946711a50d867069d30f7"
     },
     {
       "path": "/home/runner/work/ttsc/ttsc/packages/wasm/dist/wasm_exec.js",
@@ -111,15 +111,19 @@
         },
         {
           "path": "checker/go.mod",
-          "sha256": "d191ae8d581a2d548e02221e27cdde3ad54611abd62ac7ba3c647da7435f67e6"
+          "sha256": "94e107d6628d4693f2da8a342e49ff326ad28d5d0c31bec30ad3a42a98aad4cf"
+        },
+        {
+          "path": "checker/go.sum",
+          "sha256": "a94c806630860a27e74df1db99b2abf86fada0e699937a813b42fe190021a16d"
         },
         {
           "path": "checker/shim.go",
-          "sha256": "cd45126b5cc0fbbe1213343dd561c51c4d0673135ff62d6542bd1ea6e3426eab"
+          "sha256": "432f81d0e74e879f6a67a1f96c248b82950a899db8fe16a983bd48c9fa5af488"
         },
         {
           "path": "compiler/emit_sourcemap.go",
-          "sha256": "f488641b1ef9f20a54abf4a58a4c0e39a691ad175b51fb30417bc7a35d76c9ad"
+          "sha256": "78e2a0ad04a7d8845b95a7a248c70fc8348d1c932854ab7976aa7e4e2cc7ecdc"
         },
         {
           "path": "compiler/emitassemble.go",
@@ -143,7 +147,7 @@
         },
         {
           "path": "compiler/incremental.go",
-          "sha256": "8020631b8bc293f7cc860afbd4f40b1f4a304459b28d1111ecf366826f7e88ab"
+          "sha256": "3c873bed3659cfe1969a97caea105d230dad510e66d8da6e4ca2c4dc6617a04c"
         },
         {
           "path": "compiler/shim.go",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ttsc/wasm",
-  "version": "0.26.1",
+  "version": "0.27.0",
   "description": "Build in-browser ttsc playgrounds. Compose ttsc + typescript-go with your own plugins via the Go host helper.",
   "main": "lib/src/index.js",
   "types": "lib/src/index.d.ts",

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

@@ -3,3 +3,12 @@ module github.com/microsoft/typescript-go/shim/checker
 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-vendor/shim/checker/go.sum

@@ -0,0 +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/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/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=
+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/checker/shim.go

@@ -22,6 +22,8 @@ type IndexInfo = innerchecker.IndexInfo
 type Signature = innerchecker.Signature
 type SignatureKind = innerchecker.SignatureKind
 type Type = innerchecker.Type
+type TypeMapper = innerchecker.TypeMapper
+type TypeMapperKind = innerchecker.TypeMapperKind
 type TypeFlags = innerchecker.TypeFlags
 type ObjectFlags = innerchecker.ObjectFlags
 type ElementFlags = innerchecker.ElementFlags
@@ -216,6 +218,11 @@ func Checker_isSymbolAccessibleAsValue(recv *innerchecker.Checker, symbol *inner
 const (
   SignatureKindCall = innerchecker.SignatureKindCall
 
+  TypeMapperKindUnknown = innerchecker.TypeMapperKindUnknown
+  TypeMapperKindSimple  = innerchecker.TypeMapperKindSimple
+  TypeMapperKindArray   = innerchecker.TypeMapperKindArray
+  TypeMapperKindMerged  = innerchecker.TypeMapperKindMerged
+
   TypeFlagsAny             = innerchecker.TypeFlagsAny
   TypeFlagsUnknown         = innerchecker.TypeFlagsUnknown
   TypeFlagsUndefined       = innerchecker.TypeFlagsUndefined
@@ -597,3 +604,71 @@ func Checker_getRestTypeOfSignature(recv *innerchecker.Checker, signature *inner
   }
   return recv.GetRestTypeOfSignature(signature)
 }
+
+//go:linkname checkerInstantiateType github.com/microsoft/typescript-go/internal/checker.(*Checker).instantiateType
+func checkerInstantiateType(recv *innerchecker.Checker, t *innerchecker.Type, m *innerchecker.TypeMapper) *innerchecker.Type
+
+//go:linkname checkerNewSimpleTypeMapper github.com/microsoft/typescript-go/internal/checker.newSimpleTypeMapper
+func checkerNewSimpleTypeMapper(source *innerchecker.Type, target *innerchecker.Type) *innerchecker.TypeMapper
+
+//go:linkname checkerNewTypeMapper github.com/microsoft/typescript-go/internal/checker.newTypeMapper
+func checkerNewTypeMapper(sources []*innerchecker.Type, targets []*innerchecker.Type) *innerchecker.TypeMapper
+
+// Checker_instantiateType substitutes the type parameters of `t` with the
+// concrete types in `mapper`, returning the instantiated type. A type-transform
+// plugin uses it to instantiate a generic class's constructor type with the
+// reference's type arguments, so a type parameter nested inside a container
+// (`A[]`, `[A, B]`) is substituted for free. Returns nil if recv or t is nil.
+func Checker_instantiateType(recv *innerchecker.Checker, t *innerchecker.Type, mapper *innerchecker.TypeMapper) *innerchecker.Type {
+  if recv == nil || t == nil {
+    return nil
+  }
+  return checkerInstantiateType(recv, t, mapper)
+}
+
+// Checker_newSimpleTypeMapper builds a single-pair type mapper that substitutes
+// `source` with `target`. It is the building block for instantiating a generic
+// class's constructor type with its reference type arguments. Returns nil if
+// source or target is nil.
+func Checker_newSimpleTypeMapper(source *innerchecker.Type, target *innerchecker.Type) *innerchecker.TypeMapper {
+  if source == nil || target == nil {
+    return nil
+  }
+  return checkerNewSimpleTypeMapper(source, target)
+}
+
+// Checker_newTypeMapper builds a parallel type mapper from corresponding
+// source and target slices. Unlike Checker_combineTypeMappers, it does not feed
+// one substitution's target through later substitutions, so a mapping such as
+// `[A, B] -> [B, A]` preserves both target identities. Returns nil when the
+// slices are empty, differ in length, or contain nil types.
+func Checker_newTypeMapper(sources []*innerchecker.Type, targets []*innerchecker.Type) *innerchecker.TypeMapper {
+  if len(sources) == 0 || len(sources) != len(targets) {
+    return nil
+  }
+  for i := range sources {
+    if sources[i] == nil || targets[i] == nil {
+      return nil
+    }
+  }
+  return checkerNewTypeMapper(sources, targets)
+}
+
+//go:linkname checkerCombineTypeMappers github.com/microsoft/typescript-go/internal/checker.(*Checker).combineTypeMappers
+func checkerCombineTypeMappers(recv *innerchecker.Checker, m1 *innerchecker.TypeMapper, m2 *innerchecker.TypeMapper) *innerchecker.TypeMapper
+
+// Checker_combineTypeMappers composes two mapper stages. The first mapper's
+// substituted target is instantiated through the second mapper, so use
+// Checker_newTypeMapper instead when source and target slices are parallel
+// declaration-parameter mappings. Returns m2 when m1 is nil, including when
+// recv is nil. Returns nil when m1 is non-nil and recv or m2 is nil, because
+// both are required to build a usable composite mapper.
+func Checker_combineTypeMappers(recv *innerchecker.Checker, m1 *innerchecker.TypeMapper, m2 *innerchecker.TypeMapper) *innerchecker.TypeMapper {
+  if m1 == nil {
+    return m2
+  }
+  if recv == nil || m2 == nil {
+    return nil
+  }
+  return checkerCombineTypeMappers(recv, m1, m2)
+}

package/shim-vendor/shim/compiler/emit_sourcemap.go

@@ -5,12 +5,27 @@
 // tsgo's Program.Emit has no hook to inject a custom transformer, so ttsc's
 // driver assembles the per-file emit pipeline by hand (see GetSourceFilesToEmit
 // / GetScriptTransformers / GetOutputPathsFor). That hand-assembly must also
-// reproduce the source-map step the emitter would otherwise run: a bare
-// printer.Write with a nil generator drops the `.js.map` entirely. This file
-// ports internal/compiler/emitter.go's `printSourceFile` source-map branch so a
-// `sourceMap` / `inlineSourceMap` build that goes through a plugin transform
-// produces the same map (and `//# sourceMappingURL=` trailer) a plain build
-// does. Keep it in sync with that emitter source when the pin is bumped.
+// reproduce every step the emitter would otherwise run: building the printer's
+// options from the compiler options, the source-map branch a bare printer.Write
+// with a nil generator drops entirely, the `emitBOM` byte-order mark, and the
+// `WriteFileData` the emitter hands its writeFile callback. This file ports
+// internal/compiler/emitter.go's `emitJSFile` PrinterOptions construction and
+// the whole of its `printSourceFile` so a build that goes through a plugin
+// transform honors the same compiler options — and produces the same map (and
+// `//# sourceMappingURL=` trailer, and the same first bytes) — a plain build
+// does.
+//
+// Keep it in sync with that emitter source when the pin is bumped. Anything
+// `emitJSFile` sets and this file omits takes the Go zero value, which silently
+// turns the option off for every project that emits through a plugin transform,
+// and anything `printSourceFile` does around the printer that this file omits
+// is missing from the plugin lane's output even when the option set matches.
+// `printer_options_field_set_matches_pinned_emitter_test.go` fails when the pin
+// changes the PrinterOptions field set,
+// `write_file_data_field_set_matches_pinned_emitter_test.go` fails when it
+// changes the WriteFileData field set, and
+// `emit_plugin_transform_matches_plain_emit_for_printer_options_test.go` fails
+// when a forwarded option stops matching the plain emit.
 package compiler
 
 import (
@@ -25,24 +40,43 @@ import (
 
 // PrintedFile is the rendered output of one source file in the plugin-transform
 // emit path. JS is the JavaScript text, already carrying a trailing
-// `//# sourceMappingURL=` comment when a map was produced. MapText/MapPath are
-// the external source-map file and its path; both are empty when no external map
-// is written (source maps disabled, or an inline map encoded into the JS).
+// `//# sourceMappingURL=` comment when a map was produced and a leading UTF-8
+// byte order mark when `emitBOM` is on. MapText/MapPath are the external
+// source-map file and its path; both are empty when no external map is written
+// (source maps disabled, or an inline map encoded into the JS).
 type PrintedFile struct {
   JS      string
   MapText string
   MapPath string
+  // SourceMapUrlPos is the offset of the `//# sourceMappingURL=` trailer in JS,
+  // or -1 when no trailer was written — the value tsgo's emitter reports as
+  // WriteFileData.SourceMapUrlPos so a caller can locate and rewrite the
+  // trailer without re-scanning the text. Like the emitter's, it is the printer
+  // writer's text position, taken BEFORE the `emitBOM` mark is prepended, so a
+  // BOM build's offset is three bytes short of the trailer's position in the
+  // written file. That is the pinned emitter's own behavior
+  // (internal/compiler/emitter.go::printSourceFile computes sourceMapUrlPos
+  // from the writer and only then calls AddUTF8ByteOrderMark), and this lane
+  // exists to match it: "correcting" the offset here would make a plugin build
+  // disagree with the plain build of the same project.
+  SourceMapUrlPos int
 }
 
 // PrintFileWithSourceMap renders sourceFile through a printer built from options
 // and emitContext, optionally generating a source map, mirroring
-// emitter.printSourceFile for the single-file plugin-transform path. When
+// emitter.emitJSFile and emitter.printSourceFile for the single-file
+// plugin-transform path. The PrinterOptions below are emitJSFile's, field for
+// field: `removeComments`, `newLine`, `noEmitHelpers`, `sourceMap`,
+// `inlineSourceMap`, `inlineSources`, and `target`. When
 // `sourceMap`/`inlineSourceMap` is enabled (and the file is not JSON) it builds a
 // sourcemap.Generator, feeds it to the printer so positions are recorded,
-// appends the sourceMappingURL trailer, and returns the external map text/path
-// (or encodes the map inline). host supplies the same directory/casing context
-// tsgo's emitter reads. With source maps off it is byte-for-byte the prior
-// bare-printer behavior.
+// appends the sourceMappingURL trailer, records its offset, and returns the
+// external map text/path (or encodes the map inline). `emitBOM` prepends the
+// UTF-8 byte order mark to the JavaScript afterwards, exactly where
+// printSourceFile does it — outside PrinterOptions, which is why forwarding the
+// whole options struct never reached it. The external map is written without a
+// mark, matching the emitter's own `writeText(sourceMapFilePath, ..., nil)`.
+// host supplies the same directory/casing context tsgo's emitter reads.
 func PrintFileWithSourceMap(
   emitContext *innerprinter.EmitContext,
   node *innerast.Node,
@@ -53,10 +87,13 @@ func PrintFileWithSourceMap(
   sourceMapFilePath string,
 ) PrintedFile {
   printer := innerprinter.NewPrinter(innerprinter.PrinterOptions{
+    RemoveComments:  options.RemoveComments.IsTrue(),
     NewLine:         options.NewLine,
+    NoEmitHelpers:   options.NoEmitHelpers.IsTrue(),
     SourceMap:       options.SourceMap.IsTrue(),
     InlineSourceMap: options.InlineSourceMap.IsTrue(),
     InlineSources:   options.InlineSources.IsTrue(),
+    Target:          options.Target,
   }, innerprinter.PrintHandlers{}, emitContext)
   writer := innerprinter.NewTextWriter(options.NewLine.GetNewLineCharacter(), 0)
 
@@ -78,7 +115,7 @@ func PrintFileWithSourceMap(
 
   printer.Write(node, sourceFile, writer, generator)
 
-  result := PrintedFile{}
+  result := PrintedFile{SourceMapUrlPos: -1}
   if generator != nil {
     url := sourceMappingURL(options, generator, host, jsFilePath, sourceMapFilePath, sourceFile)
     if len(url) > 0 {
@@ -89,6 +126,7 @@ func PrintFileWithSourceMap(
           writer.RawWrite("\n")
         }
       }
+      result.SourceMapUrlPos = writer.GetTextPos()
       writer.WriteComment("//# sourceMappingURL=")
       writer.WriteComment(url)
     }
@@ -100,6 +138,9 @@ func PrintFileWithSourceMap(
     writer.WriteLine()
   }
   result.JS = writer.String()
+  if options.EmitBOM.IsTrue() {
+    result.JS = innerstringutil.AddUTF8ByteOrderMark(result.JS)
+  }
   return result
 }
 

package/shim-vendor/shim/compiler/incremental.go

@@ -1,13 +1,20 @@
 // gen_shims:hand-maintained
 //
-// Reference-graph parts of tsgo's own incremental engine (`tsc --incremental`
-// semantics), linked from internal/execute/incremental so ttsc's transform
-// envelopes can carry the same language-semantic input bound the compiler
-// itself uses for invalidation: per-file direct resolved references and the
-// files that contribute to the global scope.
+// Parts of tsgo's own incremental engine (`tsc --incremental` semantics),
+// exposed from internal/execute/incremental for the two things a ttsc host
+// needs from it:
+//
+//   - the reference graph, so transform envelopes can carry the same
+//     language-semantic input bound the compiler itself uses for invalidation:
+//     per-file direct resolved references and the files that contribute to the
+//     global scope;
+//   - the build-information emit, so a host that constructs its Program
+//     in-process still writes the `.tsbuildinfo` an `incremental` or
+//     `composite` project asked for.
 package compiler
 
 import (
+  "context"
   _ "unsafe"
 
   innerast "github.com/microsoft/typescript-go/internal/ast"
@@ -15,11 +22,41 @@ import (
   innercompiler "github.com/microsoft/typescript-go/internal/compiler"
   "github.com/microsoft/typescript-go/internal/tspath"
 
-  // The linknamed symbols below live in the incremental package; the blank
-  // import compiles it into every shim consumer so the references resolve.
-  _ "github.com/microsoft/typescript-go/internal/execute/incremental"
+  // Imported for EmitFreshWithBuildInfo below, and for the linknamed symbols
+  // further down: compiling the package into every shim consumer is what makes
+  // those references resolve.
+  "github.com/microsoft/typescript-go/internal/execute/incremental"
 )
 
+// EmitFreshWithBuildInfo runs a full emit through tsgo's own incremental
+// program, so an `incremental` or `composite` project gets the `.tsbuildinfo`
+// tsgo would have written, in the exact format and location
+// `outputpaths.GetBuildInfoFileName` resolves from the compiler options.
+//
+// This is the emit half of `tsc.go::performIncrementalCompilation`, which the
+// tsgo CLI takes whenever `CompilerOptions.IsIncremental()`. A host that builds
+// its Program in-process (ttsc's driver, and therefore every plugin sidecar
+// emitting through it) never reaches that CLI path, so without this the build
+// information is silently dropped even though the options parsed cleanly.
+//
+// "Fresh" is the load-bearing word: no previous snapshot is supplied, so
+// `programToSnapshot` marks every file changed and this emits the whole program
+// exactly as `Program.Emit` does, then writes the build info. A ttsc plugin's
+// output is not a pure function of the source text a build info records — it
+// also depends on the plugin binary, its config file, and its contributors —
+// so reusing a previous snapshot to skip a file would serve stale transformed
+// output. Producing the record is sound; consuming it needs plugin identity in
+// the invalidation key first.
+func EmitFreshWithBuildInfo(ctx context.Context, program *Program, options EmitOptions) *EmitResult {
+  incrementalProgram := incremental.NewProgram(
+    program,
+    nil,
+    incremental.CreateHost(program.Host()),
+    false,
+  )
+  return incrementalProgram.Emit(ctx, options)
+}
+
 //go:linkname incrementalGetReferencedFiles github.com/microsoft/typescript-go/internal/execute/incremental.getReferencedFiles
 func incrementalGetReferencedFiles(program *innercompiler.Program, file *innerast.SourceFile) *collections.Set[tspath.Path]