ttsc 0.11.0 → 0.12.0

package/driver/lsp_proxy.go

@@ -1,394 +0,0 @@
-package driver
-
-import (
-  "bytes"
-  "context"
-  "encoding/json"
-  "errors"
-  "fmt"
-  "io"
-  "sync"
-)
-
-
-// ErrCommandNotHandled is returned by PluginSource.ExecuteCommand for
-// commands ttsc does not own. Callers should fall through to upstream.
-var ErrCommandNotHandled = errors.New("lsp: command not handled by ttsc")
-
-const (
-  methodPublishDiagnostics = "textDocument/publishDiagnostics"
-  methodCodeAction         = "textDocument/codeAction"
-  methodExecuteCommand     = "workspace/executeCommand"
-  methodCancelRequest      = "$/cancelRequest"
-)
-
-// ProxyOptions wires the byte-level proxy together. ttscserver creates
-// the upstream pipes around an embedded tsgo lsp.Server and hands the
-// proxy editor stdio plus those pipe ends.
-type ProxyOptions struct {
-  EditorIn   io.Reader
-  EditorOut  io.Writer
-  UpstreamIn io.Writer // we write here; tsgo lsp.Server reads
-  UpstreamOut io.Reader // tsgo lsp.Server writes here; we read
-  Source     PluginSource
-}
-
-// Proxy bridges the editor and an upstream tsgo lsp.Server, intercepting
-// the message types ttsc cares about (publishDiagnostics merge, code
-// action augmentation, executeCommand for ttsc-owned commands).
-type Proxy struct {
-  editorIn    io.Reader
-  editorOut   io.Writer
-  upstreamIn  io.Writer
-  upstreamOut io.Reader
-  source      PluginSource
-
-  writeMu sync.Mutex // serializes WriteFrame calls to editorOut
-
-  pendingMu       sync.Mutex
-  pendingActions  map[string]pendingCodeActionRequest
-}
-
-type pendingCodeActionRequest struct {
-  uri string
-  rng LSPRange
-  ctx LSPCodeActionContext
-}
-
-// NewProxy returns a Proxy ready to Run. The PluginSource is required;
-// pass NullPluginSource{} for a no-contribution setup.
-func NewProxy(opts ProxyOptions) *Proxy {
-  source := opts.Source
-  if source == nil {
-    source = NullPluginSource{}
-  }
-  return &Proxy{
-    editorIn:       opts.EditorIn,
-    editorOut:      opts.EditorOut,
-    upstreamIn:     opts.UpstreamIn,
-    upstreamOut:    opts.UpstreamOut,
-    source:         source,
-    pendingActions: make(map[string]pendingCodeActionRequest),
-  }
-}
-
-// Run drives both pump goroutines until they return. Pumps return when
-// their input stream closes (ErrFrameClosed), when context cancellation
-// has already been observed by the upstream/editor closers, or when a
-// pipe write fails. ErrFrameClosed and context.Canceled are folded into
-// a nil result so editor shutdown does not look like a crash.
-func (p *Proxy) Run(ctx context.Context) error {
-  errCh := make(chan error, 2)
-  go func() { errCh <- p.pumpEditorToUpstream(ctx) }()
-  go func() { errCh <- p.pumpUpstreamToEditor(ctx) }()
-
-  var first error
-  for i := 0; i < 2; i++ {
-    err := <-errCh
-    if first == nil && err != nil && !errors.Is(err, ErrFrameClosed) {
-      first = err
-    }
-  }
-  return first
-}
-
-// pumpEditorToUpstream reads frames from the editor, decides whether to
-// forward verbatim or handle locally (executeCommand for ttsc commands,
-// codeAction request bookkeeping), and writes the chosen frame. When the
-// editor closes its end (ErrFrameClosed) the pump closes the upstream
-// writer so tsgo's server-side Read returns EOF and its Run loop drains;
-// without that nudge tsgo would wait forever for more input.
-func (p *Proxy) pumpEditorToUpstream(_ context.Context) error {
-  fr := NewFrameReader(p.editorIn)
-  for {
-    _, body, err := fr.Read()
-    if err != nil {
-      if errors.Is(err, ErrFrameClosed) {
-        p.closeUpstreamInput()
-      }
-      return err
-    }
-    env, parseErr := ParseEnvelope(body)
-    if parseErr != nil {
-      if forwardErr := WriteFrame(p.upstreamIn, body); forwardErr != nil {
-        return forwardErr
-      }
-      continue
-    }
-    if p.handleEditorEnvelope(env, body) {
-      continue
-    }
-    if err := WriteFrame(p.upstreamIn, body); err != nil {
-      return err
-    }
-  }
-}
-
-// closeUpstreamInput closes the upstream writer (if it is also an
-// io.Closer) so the embedded server reads io.EOF and exits its readLoop.
-// We type-assert because the public ProxyOptions surface promises only
-// io.Writer; RunLSPServer always passes an *io.PipeWriter in practice.
-func (p *Proxy) closeUpstreamInput() {
-  if closer, ok := p.upstreamIn.(io.Closer); ok {
-    _ = closer.Close()
-  }
-}
-
-// handleEditorEnvelope returns true if the envelope was fully processed
-// locally (responded to without forwarding upstream).
-func (p *Proxy) handleEditorEnvelope(env Envelope, body []byte) bool {
-  switch env.Method {
-  case methodExecuteCommand:
-    if env.IsRequest() && p.tryExecuteCommand(env) {
-      return true
-    }
-  case methodCodeAction:
-    if env.IsRequest() {
-      p.rememberCodeActionRequest(env)
-    }
-  case methodCancelRequest:
-    // $/cancelRequest names an in-flight id the editor has given up on.
-    // The proxy drops any pending codeAction entry for that id so the
-    // map cannot grow unbounded across long editor sessions, then lets
-    // the notification continue to upstream.
-    p.forgetCancelledRequest(env)
-  }
-  return false
-}
-
-// forgetCancelledRequest removes any pending codeAction entry whose id
-// the editor cancelled. The notification still flows to upstream so
-// tsgo can respond with its own cancellation error. The id is keyed
-// through the shared normalizer so a cancel for `1.0` deletes an entry
-// stored under `1` (and vice versa for string-vs-numeric encodings).
-func (p *Proxy) forgetCancelledRequest(env Envelope) {
-  var params struct {
-    ID json.RawMessage `json:"id"`
-  }
-  if err := json.Unmarshal(env.Params, &params); err != nil {
-    return
-  }
-  key := idKeyFromRaw(params.ID)
-  if key == "" {
-    return
-  }
-  p.pendingMu.Lock()
-  defer p.pendingMu.Unlock()
-  delete(p.pendingActions, key)
-}
-
-// rememberCodeActionRequest stores the request payload so the matching
-// response from upstream can be augmented with ttsc-owned code actions
-// for the same range.
-func (p *Proxy) rememberCodeActionRequest(env Envelope) {
-  var params struct {
-    TextDocument struct {
-      URI string `json:"uri"`
-    } `json:"textDocument"`
-    Range   LSPRange             `json:"range"`
-    Context LSPCodeActionContext `json:"context"`
-  }
-  if err := json.Unmarshal(env.Params, &params); err != nil {
-    return
-  }
-  p.pendingMu.Lock()
-  defer p.pendingMu.Unlock()
-  p.pendingActions[env.IDKey()] = pendingCodeActionRequest{
-    uri: params.TextDocument.URI,
-    rng: params.Range,
-    ctx: params.Context,
-  }
-}
-
-// tryExecuteCommand handles workspace/executeCommand requests whose
-// command id is registered with the PluginSource. Returns true on a
-// successful local response; false when the command should fall through
-// to upstream tsgo.
-func (p *Proxy) tryExecuteCommand(env Envelope) bool {
-  var params struct {
-    Command   string            `json:"command"`
-    Arguments []json.RawMessage `json:"arguments,omitempty"`
-  }
-  if err := json.Unmarshal(env.Params, &params); err != nil {
-    return false
-  }
-  if !p.ownsCommand(params.Command) {
-    return false
-  }
-  edit, err := p.source.ExecuteCommand(params.Command, params.Arguments)
-  if errors.Is(err, ErrCommandNotHandled) {
-    return false
-  }
-  if err != nil {
-    p.writeError(env.ID, fmt.Sprintf("ttsc command %q failed: %v", params.Command, err))
-    return true
-  }
-  // Cycle 1 returns the WorkspaceEdit inside the executeCommand response
-  // instead of sending workspace/applyEdit as a server→client request.
-  // ttsc owns both ends (its VSCode extension), so the extension applies
-  // the edit on its side. Sticking to one direction avoids tracking our
-  // own outgoing request ids in the proxy.
-  if edit == nil {
-    p.writeResult(env.ID, nil)
-    return true
-  }
-  p.writeResult(env.ID, edit)
-  return true
-}
-
-func (p *Proxy) ownsCommand(command string) bool {
-  for _, id := range p.source.CommandIDs() {
-    if id == command {
-      return true
-    }
-  }
-  return false
-}
-
-// pumpUpstreamToEditor reads frames from the embedded tsgo server,
-// augments publishDiagnostics and codeAction responses, and forwards
-// every other frame untouched. The loop terminates on Read error; ctx
-// propagation happens through pipe closure by RunLSPServer's deferred
-// cleanup goroutines.
-func (p *Proxy) pumpUpstreamToEditor(_ context.Context) error {
-  fr := NewFrameReader(p.upstreamOut)
-  for {
-    _, body, err := fr.Read()
-    if err != nil {
-      return err
-    }
-    env, parseErr := ParseEnvelope(body)
-    if parseErr != nil {
-      if forwardErr := p.writeEditorFrame(body); forwardErr != nil {
-        return forwardErr
-      }
-      continue
-    }
-    augmented := p.augmentUpstream(env, body)
-    if err := p.writeEditorFrame(augmented); err != nil {
-      return err
-    }
-  }
-}
-
-// augmentUpstream returns the (possibly rewritten) body to forward. For
-// publishDiagnostics it merges ttsc plugin diagnostics; for codeAction
-// responses tied to a remembered request it appends ttsc actions.
-//
-// Cancellation and response are handled in two independent goroutines
-// (pumpEditorToUpstream owns $/cancelRequest cleanup, pumpUpstreamToEditor
-// owns response augmentation). When the response wins the race against
-// a pending cancel, pendingActions[env.IDKey()] is still populated and
-// the response is augmented before forgetCancelledRequest runs — the
-// editor is expected to discard the late response per LSP $/cancelRequest
-// semantics. When the cancel wins, the pending entry is gone and
-// augmentation skips cleanly.
-func (p *Proxy) augmentUpstream(env Envelope, body []byte) []byte {
-  if env.IsNotification() && env.Method == methodPublishDiagnostics {
-    if merged, ok := p.mergePublishDiagnostics(env); ok {
-      return merged
-    }
-  }
-  if env.IsResponse() {
-    p.pendingMu.Lock()
-    pending, ok := p.pendingActions[env.IDKey()]
-    if ok {
-      delete(p.pendingActions, env.IDKey())
-    }
-    p.pendingMu.Unlock()
-    if ok {
-      if augmented, augOk := p.appendCodeActions(env, pending); augOk {
-        return augmented
-      }
-    }
-  }
-  return body
-}
-
-// mergePublishDiagnostics decodes the publishDiagnostics params, asks
-// the PluginSource for the URI's contributions, appends them, and
-// re-encodes the envelope. Returns the rewritten body and true on
-// success; ok=false means "nothing to merge — forward the upstream body
-// verbatim." Re-encoding our own types is guaranteed by their
-// definitions in lsp_plugin.go, so the marshal errors are not checked.
-func (p *Proxy) mergePublishDiagnostics(env Envelope) ([]byte, bool) {
-  var params struct {
-    URI         string            `json:"uri"`
-    Version     *int              `json:"version,omitempty"`
-    Diagnostics []json.RawMessage `json:"diagnostics"`
-  }
-  if err := json.Unmarshal(env.Params, &params); err != nil {
-    return nil, false
-  }
-  extras := p.source.Diagnostics(LSPDocumentVersion{URI: params.URI, Version: params.Version})
-  if len(extras) == 0 {
-    return nil, false
-  }
-  for _, extra := range extras {
-    raw, _ := json.Marshal(extra)
-    params.Diagnostics = append(params.Diagnostics, raw)
-  }
-  env.Params, _ = json.Marshal(params)
-  body, _ := json.Marshal(env)
-  return body, true
-}
-
-// appendCodeActions adds ttsc-owned code actions to a forwarded
-// codeAction response. The response body is either an array of actions
-// or null; we preserve that shape so editors that special-case null
-// keep working. The function refuses to splice into error responses
-// (JSON-RPC §5.1 forbids both `result` and `error` on the same frame)
-// and into non-array results (the LSP base protocol mandates an array
-// or null for codeAction; anything else means upstream returned a
-// shape ttsc cannot splice into, so the proxy forwards verbatim
-// rather than corrupting it).
-func (p *Proxy) appendCodeActions(env Envelope, pending pendingCodeActionRequest) ([]byte, bool) {
-  if env.IsErrorResponse() {
-    return nil, false
-  }
-  trimmed := bytes.TrimSpace(env.Result)
-  if len(trimmed) > 0 && trimmed[0] != '[' && !bytes.Equal(trimmed, []byte("null")) {
-    return nil, false
-  }
-  actions := p.source.CodeActions(pending.uri, pending.rng, pending.ctx)
-  if len(actions) == 0 {
-    return nil, false
-  }
-  var existing []json.RawMessage
-  if len(trimmed) > 0 && !bytes.Equal(trimmed, []byte("null")) {
-    if err := json.Unmarshal(trimmed, &existing); err != nil {
-      return nil, false
-    }
-  }
-  for _, action := range actions {
-    raw, _ := json.Marshal(action)
-    existing = append(existing, raw)
-  }
-  env.Result, _ = json.Marshal(existing)
-  body, _ := json.Marshal(env)
-  return body, true
-}
-
-func (p *Proxy) writeEditorFrame(body []byte) error {
-  p.writeMu.Lock()
-  defer p.writeMu.Unlock()
-  return WriteFrame(p.editorOut, body)
-}
-
-func (p *Proxy) writeResult(id json.RawMessage, result any) error {
-  rawResult, _ := json.Marshal(result)
-  env := Envelope{JSONRPC: "2.0", ID: id, Result: rawResult}
-  body, _ := json.Marshal(env)
-  return p.writeEditorFrame(body)
-}
-
-func (p *Proxy) writeError(id json.RawMessage, message string) error {
-  errPayload, _ := json.Marshal(struct {
-    Code    int    `json:"code"`
-    Message string `json:"message"`
-  }{Code: -32603, Message: message})
-  env := Envelope{JSONRPC: "2.0", ID: id, Error: errPayload}
-  body, _ := json.Marshal(env)
-  return p.writeEditorFrame(body)
-}
-

package/driver/lsp_server.go

@@ -1,197 +0,0 @@
-package driver
-
-import (
-  "context"
-  "errors"
-  "fmt"
-  "io"
-  "runtime/debug"
-  "sync"
-  "time"
-
-  "github.com/microsoft/typescript-go/shim/bundled"
-  shimlsp "github.com/microsoft/typescript-go/shim/lsp"
-  "github.com/microsoft/typescript-go/shim/vfs/osvfs"
-)
-
-// ErrLSPUpstreamPanic wraps a panic recovered from inside the embedded
-// tsgo lsp.Server. Without recovery the host process would die when
-// tsgo crashed; with this wrapper the proxy can surface a typed error
-// to the editor instead.
-var ErrLSPUpstreamPanic = errors.New("ttscserver: embedded tsgo server panicked")
-
-// RecoverPanicAs runs fn and converts a panic into an
-// ErrLSPUpstreamPanic-wrapped error. defaultUpstreamRunner uses it and
-// downstream LSP-host embeddings can opt into the same recovery
-// contract; the recovered stack is attached for diagnostics.
-//
-// recover() per the Go spec catches panics but NOT runtime.Goexit, so
-// a Goexit raised from inside fn surfaces as a clean nil return here
-// (the upstream goroutine exits without an error). Hosting code that
-// must turn Goexit into a typed error should run fn in a separate
-// goroutine and join on a sentinel channel — outside this helper's
-// scope today.
-func RecoverPanicAs(fn func() error) (err error) {
-  defer func() {
-    if r := recover(); r != nil {
-      err = fmt.Errorf("%w: %v\n%s", ErrLSPUpstreamPanic, r, debug.Stack())
-    }
-  }()
-  return fn()
-}
-
-// LSPServerOptions wires ttscserver to its three channels of state:
-// editor stdio for the LSP transport, an optional ttsc PluginSource for
-// merging plugin diagnostics into the stream, and a working directory
-// the embedded tsgo server treats as the project root.
-type LSPServerOptions struct {
-  // In is the editor-side reader; ttscserver reads JSON-RPC frames from
-  // it and forwards or handles them.
-  In io.Reader
-  // Out is the editor-side writer; ttscserver writes both upstream
-  // responses and locally-synthesized messages to it.
-  Out io.Writer
-  // Err is the upstream tsgo server's stderr sink. ttscserver does not
-  // log to it directly.
-  Err io.Writer
-
-  // Cwd is the project root passed to tsgo's LSP. An empty string
-  // panics inside tsgo, so RunLSPServer validates it up front.
-  Cwd string
-  // Source contributes ttsc plugin diagnostics / code actions /
-  // executeCommand handling. Nil falls back to NullPluginSource{}.
-  Source PluginSource
-  // ProgressDelay matches tsgo's option for delaying the progress UI;
-  // zero disables the delay.
-  ProgressDelay time.Duration
-}
-
-// ErrLSPCwdRequired is returned when LSPServerOptions.Cwd is empty.
-// ttsc surfaces a clean error here instead of letting tsgo's panic
-// reach the editor.
-var ErrLSPCwdRequired = errors.New("ttscserver: cwd is required")
-
-// lspUpstreamRunner is the seam tests use to substitute the embedded
-// tsgo lsp.Server with a controllable fake. Production wires it to the
-// real shim-backed server.
-type lspUpstreamRunner func(ctx context.Context, in io.Reader, out io.Writer, opts LSPServerOptions) error
-
-// upstreamRunner is replaced in tests via WithUpstreamRunnerForTest.
-var upstreamRunner lspUpstreamRunner = defaultUpstreamRunner
-
-// WithUpstreamRunnerForTest substitutes the upstream runner used by
-// RunLSPServer. Returns a function the caller defers to restore the
-// production runner. The seam stays in the public API because tests
-// live in driver_test and otherwise have no way to bypass tsgo.
-func WithUpstreamRunnerForTest(runner lspUpstreamRunner) func() {
-  prev := upstreamRunner
-  upstreamRunner = runner
-  return func() { upstreamRunner = prev }
-}
-
-func defaultUpstreamRunner(ctx context.Context, in io.Reader, out io.Writer, opts LSPServerOptions) error {
-  return RecoverPanicAs(func() error {
-    server := shimlsp.NewServer(&shimlsp.ServerOptions{
-      In:                 shimlsp.ToReader(in),
-      Out:                shimlsp.ToWriter(out),
-      Err:                opts.Err,
-      Cwd:                opts.Cwd,
-      FS:                 DefaultFS(),
-      DefaultLibraryPath: bundled.LibPath(),
-      TypingsLocation:    osvfs.GetGlobalTypingsCacheLocation(),
-      NpmInstall:         DenyNpmInstall,
-      ProgressDelay:      opts.ProgressDelay,
-    })
-    return server.Run(ctx)
-  })
-}
-
-// RunLSPServer starts the embedded tsgo lsp.Server and the byte-level
-// proxy, blocking until either side returns. The first non-graceful
-// error wins; ErrFrameClosed and context cancellation are treated as
-// clean shutdown so editor close sequences do not look like crashes.
-//
-// The lifecycle is:
-//
-//  1. Open two pipes around the embedded server (editor->server, server->editor).
-//  2. Spawn the upstream runner (real tsgo or a test fake) reading/writing those pipes.
-//  3. Run the proxy in parallel.
-//  4. A watchdog cascades context cancellation by closing every pipe so both
-//     halves unblock; the goroutines' own defers close the rest.
-func RunLSPServer(ctx context.Context, opts LSPServerOptions) error {
-  if opts.Cwd == "" {
-    return ErrLSPCwdRequired
-  }
-  source := opts.Source
-  if source == nil {
-    source = NullPluginSource{}
-  }
-
-  upstreamInR, upstreamInW := io.Pipe()
-  upstreamOutR, upstreamOutW := io.Pipe()
-
-  proxy := NewProxy(ProxyOptions{
-    EditorIn:    opts.In,
-    EditorOut:   opts.Out,
-    UpstreamIn:  upstreamInW,
-    UpstreamOut: upstreamOutR,
-    Source:      source,
-  })
-
-  serverCtx, cancel := context.WithCancel(ctx)
-  defer cancel()
-
-  // Watchdog: on cancel, close the writer ends of the upstream pipes so
-  // both halves unblock with a clean io.EOF. Closing readers directly
-  // would surface as io.ErrClosedPipe and make ttsc's error fold
-  // ambiguous; closing writers preserves the ErrFrameClosed signal.
-  go func() {
-    <-serverCtx.Done()
-    upstreamInW.Close()
-    upstreamOutW.Close()
-  }()
-
-  var wg sync.WaitGroup
-  var serverErr, proxyErr error
-  wg.Add(2)
-  go func() {
-    defer wg.Done()
-    defer cancel()
-    defer upstreamOutW.Close()
-    defer upstreamInR.Close()
-    serverErr = upstreamRunner(serverCtx, upstreamInR, upstreamOutW, opts)
-  }()
-  go func() {
-    defer wg.Done()
-    defer cancel()
-    defer upstreamInW.Close()
-    defer upstreamOutR.Close()
-    proxyErr = proxy.Run(serverCtx)
-  }()
-  wg.Wait()
-
-  for _, err := range []error{serverErr, proxyErr} {
-    if err == nil {
-      continue
-    }
-    if errors.Is(err, context.Canceled) {
-      continue
-    }
-    if errors.Is(err, ErrFrameClosed) {
-      continue
-    }
-    if errors.Is(err, io.ErrClosedPipe) {
-      continue
-    }
-    return err
-  }
-  return nil
-}
-
-// DenyNpmInstall is the NpmInstall callback ttscserver passes to tsgo's
-// LSP. ttsc has its own plugin / cache pipeline; we never want the LSP
-// host running npm under the user's editor. Exposed so other LSP host
-// embeddings can opt into the same behavior without copying the body.
-func DenyNpmInstall(_ string, args []string) ([]byte, error) {
-  return nil, fmt.Errorf("ttscserver: npm install disabled in LSP host (args=%v)", args)
-}

package/lib/defineTtscPlugin.d.ts

@@ -1,18 +0,0 @@
-import type { ITtscPlugin } from "./structures/ITtscPlugin";
-/**
- * Identity helper for authoring `ITtscPlugin` descriptors with full literal
- * type preservation.
- *
- * Two call shapes:
- *
- * - Object form: returns the descriptor unchanged but pins its narrowed type so
- *   editor tooling and `satisfies` clauses can see exact field values.
- * - Factory form: wraps a `(context) => descriptor` factory so the returned
- *   function carries the literal descriptor type through to consumers without
- *   forcing a manual `as const`.
- *
- * Pure pass-through at runtime — the function exists to teach TypeScript the
- * const-narrowing the user would otherwise have to spell out.
- */
-export declare function defineTtscPlugin<const T extends ITtscPlugin>(plugin: T): T;
-export declare function defineTtscPlugin<TContext, const T extends ITtscPlugin>(factory: (context: TContext) => T): (context: TContext) => T;

package/lib/defineTtscPlugin.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.defineTtscPlugin = defineTtscPlugin;
-function defineTtscPlugin(value) {
-    return value;
-}
-//# sourceMappingURL=defineTtscPlugin.js.map

package/lib/defineTtscPlugin.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"defineTtscPlugin.js","sourceRoot":"","sources":["../src/defineTtscPlugin.ts"],"names":[],"mappings":";;;AAqBA,0BACE,KAAwD;IAExD,OAAO,KAAK,CAAC;AACf,CAAC"}

package/src/defineTtscPlugin.ts

@@ -1,26 +0,0 @@
-import type { ITtscPlugin } from "./structures/ITtscPlugin";
-
-/**
- * Identity helper for authoring `ITtscPlugin` descriptors with full literal
- * type preservation.
- *
- * Two call shapes:
- *
- * - Object form: returns the descriptor unchanged but pins its narrowed type so
- *   editor tooling and `satisfies` clauses can see exact field values.
- * - Factory form: wraps a `(context) => descriptor` factory so the returned
- *   function carries the literal descriptor type through to consumers without
- *   forcing a manual `as const`.
- *
- * Pure pass-through at runtime — the function exists to teach TypeScript the
- * const-narrowing the user would otherwise have to spell out.
- */
-export function defineTtscPlugin<const T extends ITtscPlugin>(plugin: T): T;
-export function defineTtscPlugin<TContext, const T extends ITtscPlugin>(
-  factory: (context: TContext) => T,
-): (context: TContext) => T;
-export function defineTtscPlugin(
-  value: ITtscPlugin | ((context: unknown) => ITtscPlugin),
-): ITtscPlugin | ((context: unknown) => ITtscPlugin) {
-  return value;
-}