@ttsc/lint 0.10.2 → 0.11.0-dev.20260517

package/{plugin → linthost}/rules_logic.go

@@ -1,4 +1,4 @@
-package main
+package linthost
 
 import shimast "github.com/microsoft/typescript-go/shim/ast"
 
@@ -119,12 +119,64 @@ func (eqeqeq) Check(ctx *Context, node *shimast.Node) {
   }
   switch expr.OperatorToken.Kind {
   case shimast.KindEqualsEqualsToken:
-    ctx.ReportRange(expr.OperatorToken.Pos(), expr.OperatorToken.End(), "Expected '===' and instead saw '=='.")
+    reportEqeqeq(ctx, expr.OperatorToken, expr, "Expected '===' and instead saw '=='.", "===")
   case shimast.KindExclamationEqualsToken:
-    ctx.ReportRange(expr.OperatorToken.Pos(), expr.OperatorToken.End(), "Expected '!==' and instead saw '!='.")
+    reportEqeqeq(ctx, expr.OperatorToken, expr, "Expected '!==' and instead saw '!='.", "!==")
   }
 }
 
+func reportEqeqeq(ctx *Context, operator *shimast.Node, expr *shimast.BinaryExpression, message, replacement string) {
+  pos, end := tokenRange(ctx.File, operator)
+  if pos < 0 {
+    pos, end = operator.Pos(), operator.End()
+  }
+  if isEqeqeqAutoFixSafe(expr) {
+    ctx.ReportRangeFix(
+      pos,
+      end,
+      message,
+      TextEdit{Pos: pos, End: end, Text: replacement},
+    )
+    return
+  }
+  ctx.ReportRange(pos, end, message)
+}
+
+func isEqeqeqAutoFixSafe(expr *shimast.BinaryExpression) bool {
+  if expr == nil {
+    return false
+  }
+  left := stripParens(expr.Left)
+  right := stripParens(expr.Right)
+  if left == nil || right == nil {
+    return false
+  }
+  if left.Kind == shimast.KindTypeOfExpression || right.Kind == shimast.KindTypeOfExpression {
+    return true
+  }
+  leftKind := comparableLiteralKind(left)
+  return leftKind != "" && leftKind == comparableLiteralKind(right)
+}
+
+func comparableLiteralKind(node *shimast.Node) string {
+  if node == nil {
+    return ""
+  }
+  switch node.Kind {
+  case shimast.KindStringLiteral:
+    return "string"
+  case shimast.KindNumericLiteral:
+    return "number"
+  case shimast.KindBigIntLiteral:
+    return "bigint"
+  case shimast.KindTrueKeyword, shimast.KindFalseKeyword:
+    return "boolean"
+  case shimast.KindNullKeyword:
+    return "object"
+  }
+  return ""
+}
+
 // use-isnan: `x === NaN` is always false. Use `Number.isNaN(x)`.
 // https://eslint.org/docs/latest/rules/use-isnan
 type useIsnan struct{}

package/{plugin → linthost}/rules_loops.go

@@ -1,4 +1,4 @@
-package main
+package linthost
 
 import shimast "github.com/microsoft/typescript-go/shim/ast"
 

package/{plugin → linthost}/rules_misc.go

@@ -1,4 +1,4 @@
-package main
+package linthost
 
 import shimast "github.com/microsoft/typescript-go/shim/ast"
 

package/linthost/rules_params.go

@@ -0,0 +1,64 @@
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+// default-param-last: forbid parameters with default initializers that
+// precede non-default parameters. The combination forces every caller
+// to spell out `undefined` for the defaulted parameter — which defeats
+// the purpose of the default. ESLint canonical:
+// https://eslint.org/docs/latest/rules/default-param-last
+type defaultParamLast struct{}
+
+func (defaultParamLast) Name() string { return "default-param-last" }
+func (defaultParamLast) Visits() []shimast.Kind {
+  return []shimast.Kind{
+    shimast.KindFunctionDeclaration,
+    shimast.KindFunctionExpression,
+    shimast.KindArrowFunction,
+    shimast.KindMethodDeclaration,
+    shimast.KindConstructor,
+  }
+}
+func (defaultParamLast) Check(ctx *Context, node *shimast.Node) {
+  params := node.Parameters()
+  if len(params) == 0 {
+    return
+  }
+  // Walk right-to-left; once we see a parameter without an Initializer
+  // (and not a rest parameter), every earlier parameter that DOES have
+  // an Initializer is misordered.
+  sawNonDefaultAfter := false
+  for i := len(params) - 1; i >= 0; i-- {
+    p := params[i]
+    if p == nil {
+      continue
+    }
+    decl := p.AsParameterDeclaration()
+    if decl == nil {
+      continue
+    }
+    if decl.DotDotDotToken != nil {
+      // Rest parameters are always last by grammar; they don't
+      // participate in the default-position check.
+      continue
+    }
+    // typescript-eslint canonical treats both default-initialized and
+    // optional (`a?: T`) parameters as default-like for ordering: both
+    // permit callers to elide the argument, so a non-optional / non-
+    // default parameter after either one forces the caller to spell
+    // `undefined`. The round-1 implementation only checked Initializer;
+    // round 2 adds the QuestionToken branch.
+    isDefaultLike := decl.Initializer != nil || decl.QuestionToken != nil
+    if !isDefaultLike {
+      sawNonDefaultAfter = true
+      continue
+    }
+    if sawNonDefaultAfter {
+      ctx.Report(p, "Default parameters should be last.")
+    }
+  }
+}
+
+func init() {
+  Register(defaultParamLast{})
+}

package/{plugin → linthost}/rules_problems.go

@@ -5,7 +5,7 @@
 // fast and predictable. Rules that require scope binding or
 // flow-sensitive analysis are intentionally not implemented here —
 // those are upstream's job.
-package main
+package linthost
 
 import (
   "strings"
@@ -549,6 +549,14 @@ func (noObjCalls) Check(ctx *Context, node *shimast.Node) {
 // hasAsyncModifier returns whether a function-like node carries the
 // `async` keyword. Used by no-async-promise-executor.
 func hasAsyncModifier(node *shimast.Node) bool {
+  return hasModifier(node, shimast.KindAsyncKeyword)
+}
+
+// hasModifier returns whether a node's modifier list contains a token of
+// the given kind. Generic over modifier kinds (async, static, abstract,
+// override, public/private/protected, readonly) so individual rules don't
+// have to re-implement the loop.
+func hasModifier(node *shimast.Node, kind shimast.Kind) bool {
   if node == nil {
     return false
   }
@@ -557,7 +565,7 @@ func hasAsyncModifier(node *shimast.Node) bool {
     return false
   }
   for _, m := range mods.Nodes {
-    if m != nil && m.Kind == shimast.KindAsyncKeyword {
+    if m != nil && m.Kind == kind {
       return true
     }
   }

package/linthost/rules_promise.go

@@ -0,0 +1,111 @@
+package linthost
+
+import (
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimchecker "github.com/microsoft/typescript-go/shim/checker"
+)
+
+// await-thenable: `await x` where `x` is not a Promise and not a
+// thenable is always a no-op. The runtime resolves `await 42` to `42`
+// after one microtask hop — almost never the intent. typescript-eslint
+// recommended-type-checked:
+// https://typescript-eslint.io/rules/await-thenable/
+//
+// This is the first rule in the corpus to consult `ctx.Checker`. The
+// shim's `Checker` is a type alias for tsgo's `*innerchecker.Checker`,
+// so every exported method (`GetTypeAtLocation`, `GetPromisedTypeOfPromise`,
+// `GetPropertyOfType`, `GetSignaturesOfType`) is callable directly with
+// no shim addition.
+type awaitThenable struct{}
+
+func (awaitThenable) Name() string { return "await-thenable" }
+func (awaitThenable) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindAwaitExpression}
+}
+func (awaitThenable) Check(ctx *Context, node *shimast.Node) {
+  if ctx.Checker == nil {
+    return
+  }
+  expr := node.AsAwaitExpression()
+  if expr == nil || expr.Expression == nil {
+    return
+  }
+  operandType := ctx.Checker.GetTypeAtLocation(expr.Expression)
+  if operandType == nil {
+    return
+  }
+  if isAwaitable(ctx.Checker, operandType) {
+    return
+  }
+  message := "Unexpected `await` of a non-Promise (non-thenable) value."
+  // Fix: drop the `await ` keyword and the following whitespace by
+  // replacing [node.Pos(), expr.Expression.Pos()) with empty text.
+  // `node.Pos()` may include leading trivia; use tokenRange to anchor
+  // the start at the actual `await` token.
+  startPos, _ := tokenRange(ctx.File, node)
+  operandStart := expr.Expression.Pos()
+  if startPos < 0 || operandStart <= startPos {
+    ctx.Report(node, message)
+    return
+  }
+  ctx.ReportFix(
+    node,
+    message,
+    TextEdit{Pos: startPos, End: operandStart, Text: ""},
+  )
+}
+
+// isAwaitable reports whether `t` is safe to `await`. A type is awaitable
+// when it is `any` / `unknown` / `never` (out of scope for strictness),
+// when it is a Promise, when it is a thenable (has a callable `then`),
+// or — for union/intersection types — when ANY constituent satisfies one
+// of the above. The union case is the round-2 repair: `GetPromisedTypeOfPromise`
+// returns nil on `Promise<X> | number` because the outer type is not a
+// reference to globalPromise, and `GetPropertyOfType` filters `then` as
+// a partial member, so without iterating constituents the rule would
+// fire on legitimate code.
+func isAwaitable(checker *shimchecker.Checker, t *shimchecker.Type) bool {
+  if checker == nil || t == nil {
+    return false
+  }
+  flags := t.Flags()
+  if flags&shimchecker.TypeFlagsAny != 0 ||
+    flags&shimchecker.TypeFlagsUnknown != 0 ||
+    flags&shimchecker.TypeFlagsNever != 0 {
+    return true
+  }
+  if flags&(shimchecker.TypeFlagsUnion|shimchecker.TypeFlagsIntersection) != 0 {
+    for _, part := range t.Types() {
+      if part == nil {
+        continue
+      }
+      if isAwaitable(checker, part) {
+        return true
+      }
+    }
+    return false
+  }
+  if checker.GetPromisedTypeOfPromise(t) != nil {
+    return true
+  }
+  return isThenableType(checker, t)
+}
+
+func isThenableType(checker *shimchecker.Checker, t *shimchecker.Type) bool {
+  if checker == nil || t == nil {
+    return false
+  }
+  prop := checker.GetPropertyOfType(t, "then")
+  if prop == nil {
+    return false
+  }
+  propType := checker.GetTypeOfSymbol(prop)
+  if propType == nil {
+    return false
+  }
+  return len(checker.GetSignaturesOfType(propType, shimchecker.SignatureKindCall)) > 0
+}
+
+func init() {
+  Register(awaitThenable{})
+}

package/{plugin → linthost}/rules_protos.go

@@ -1,4 +1,4 @@
-package main
+package linthost
 
 import shimast "github.com/microsoft/typescript-go/shim/ast"
 

package/{plugin → linthost}/rules_self.go

@@ -1,4 +1,4 @@
-package main
+package linthost
 
 import shimast "github.com/microsoft/typescript-go/shim/ast"
 

package/{plugin → linthost}/rules_strings.go

@@ -1,4 +1,4 @@
-package main
+package linthost
 
 import (
   "strings"

package/{plugin → linthost}/rules_suggestions.go

@@ -1,7 +1,7 @@
 // Bulk implementation of ESLint's "Suggestions" category — rules that
 // don't catch outright bugs but flag stylistic or maintainability
 // patterns. AST-only, no scope analysis.
-package main
+package linthost
 
 import (
   "strings"
@@ -891,28 +891,61 @@ func (noUselessRename) Check(ctx *Context, node *shimast.Node) {
     if spec == nil || spec.PropertyName == nil {
       return
     }
-    if identifierText(spec.PropertyName) == identifierText(spec.Name()) {
-      ctx.Report(node, "Import { x as x } is redundant.")
+    if sameIdentifierRename(spec.PropertyName, spec.Name()) {
+      reportUselessRenameFix(ctx, node, spec.PropertyName, spec.Name(), "Import { x as x } is redundant.")
     }
   case shimast.KindExportSpecifier:
     spec := node.AsExportSpecifier()
     if spec == nil || spec.PropertyName == nil {
       return
     }
-    if identifierText(spec.PropertyName) == identifierText(spec.Name()) {
-      ctx.Report(node, "Export { x as x } is redundant.")
+    if sameIdentifierRename(spec.PropertyName, spec.Name()) {
+      reportUselessRenameFix(ctx, node, spec.PropertyName, spec.Name(), "Export { x as x } is redundant.")
     }
   case shimast.KindBindingElement:
     el := node.AsBindingElement()
     if el == nil || el.PropertyName == nil {
       return
     }
-    if identifierText(el.PropertyName) == identifierText(el.Name()) {
-      ctx.Report(node, "Destructuring rename to the same name is redundant.")
+    if sameIdentifierRename(el.PropertyName, el.Name()) {
+      reportUselessRenameFix(ctx, node, el.PropertyName, el.Name(), "Destructuring rename to the same name is redundant.")
     }
   }
 }
 
+// sameIdentifierRename gates the rename-tail collapse on both sides being
+// real Identifier nodes that lex to the same text. Without the kind guard
+// a `{ "foo" as "bar" }` pair would compare via `identifierText` ➜ `""`
+// on both sides, collapse to `"" == ""`, and the fix would delete
+// ` as "bar"` — rebinding the local symbol. Both sides must be
+// KindIdentifier (the redundant rename shape ESLint targets).
+func sameIdentifierRename(propertyName, name *shimast.Node) bool {
+  if propertyName == nil || name == nil {
+    return false
+  }
+  if propertyName.Kind != shimast.KindIdentifier || name.Kind != shimast.KindIdentifier {
+    return false
+  }
+  return identifierText(propertyName) == identifierText(name)
+}
+
+// reportUselessRenameFix deletes the rename tail (`<separator> name`) so
+// `{ x as x }` collapses to `{ x }` and `{ x: x }` to `{ x }`. The
+// separator (` as ` for import/export, `: ` for binding) lives between
+// the propertyName's end and the name's start; deleting up to name's End
+// removes it without touching surrounding tokens.
+func reportUselessRenameFix(ctx *Context, node, propertyName, name *shimast.Node, message string) {
+  if propertyName == nil || name == nil {
+    ctx.Report(node, message)
+    return
+  }
+  ctx.ReportFix(
+    node,
+    message,
+    TextEdit{Pos: propertyName.End(), End: name.End(), Text: ""},
+  )
+}
+
 // object-shorthand: `{ x: x }` → `{ x }`.
 type objectShorthand struct{}
 
@@ -928,9 +961,18 @@ func (objectShorthand) Check(ctx *Context, node *shimast.Node) {
   if keyName == "" || valueName == "" {
     return
   }
-  if keyName == valueName {
-    ctx.Report(node, "Expected property shorthand.")
+  if keyName != valueName {
+    return
   }
+  // Delete `: <value>` so `{ x: x }` becomes `{ x }`. The range starts
+  // at the end of the property name and ends at the end of the
+  // initializer; any whitespace between `:` and the value is part of
+  // that range.
+  ctx.ReportFix(
+    node,
+    "Expected property shorthand.",
+    TextEdit{Pos: prop.Name().End(), End: prop.Initializer.End(), Text: ""},
+  )
 }
 
 // operator-assignment: `x = x + 1` → `x += 1`.

package/{plugin → linthost}/rules_throw.go

@@ -1,4 +1,4 @@
-package main
+package linthost
 
 import shimast "github.com/microsoft/typescript-go/shim/ast"
 

package/{plugin → linthost}/rules_ts.go

@@ -1,4 +1,4 @@
-package main
+package linthost
 
 import shimast "github.com/microsoft/typescript-go/shim/ast"
 
@@ -189,7 +189,17 @@ func (preferAsConst) Check(ctx *Context, node *shimast.Node) {
   if !literalsMatchSourceText(ctx.File, expr, literalType.Literal) {
     return
   }
-  ctx.Report(node, "Expected `as const` instead of `as` literal type.")
+  message := "Expected `as const` instead of `as` literal type."
+  pos, end := tokenRange(ctx.File, typeNode)
+  if pos < 0 {
+    ctx.Report(node, message)
+    return
+  }
+  ctx.ReportFix(
+    node,
+    message,
+    TextEdit{Pos: pos, End: end, Text: "const"},
+  )
 }
 
 func literalsMatchSourceText(file *shimast.SourceFile, lhs, rhs *shimast.Node) bool {

package/{plugin → linthost}/rules_ts_extra.go

@@ -3,7 +3,7 @@
 // match the rules `eslint-plugin-typescript`'s recommended preset relies
 // on most heavily — the rest of that plugin's catalog is type-aware and
 // out of scope for v0.
-package main
+package linthost
 
 import (
   "strings"
@@ -77,6 +77,66 @@ func (noDuplicateEnumValues) Check(ctx *Context, node *shimast.Node) {
   }
 }
 
+// no-mixed-enums: forbid enums that mix numeric and string member shapes.
+// A single enum with `{ A, B = "two" }` produces broken reverse mappings
+// and surprising assignability. typescript-eslint recommended:
+// https://typescript-eslint.io/rules/no-mixed-enums/
+type noMixedEnums struct{}
+
+func (noMixedEnums) Name() string { return "no-mixed-enums" }
+func (noMixedEnums) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindEnumDeclaration}
+}
+func (noMixedEnums) Check(ctx *Context, node *shimast.Node) {
+  decl := node.AsEnumDeclaration()
+  if decl == nil || decl.Members == nil {
+    return
+  }
+  // Classify each member as numeric or string. Implicit members
+  // (no initializer) count as numeric — that is what tsgo materializes.
+  // The rule fires when both categories appear in the same enum body.
+  var hasNumeric, hasString bool
+  type classification struct {
+    member *shimast.Node
+    isStr  bool
+  }
+  members := make([]classification, 0, len(decl.Members.Nodes))
+  for _, member := range decl.Members.Nodes {
+    if member == nil {
+      continue
+    }
+    em := member.AsEnumMember()
+    if em == nil {
+      continue
+    }
+    isStr := false
+    if em.Initializer != nil {
+      switch em.Initializer.Kind {
+      case shimast.KindStringLiteral, shimast.KindNoSubstitutionTemplateLiteral:
+        isStr = true
+      }
+    }
+    if isStr {
+      hasString = true
+    } else {
+      hasNumeric = true
+    }
+    members = append(members, classification{member: member, isStr: isStr})
+  }
+  if !(hasNumeric && hasString) {
+    return
+  }
+  // Report each member whose category disagrees with the first member's
+  // category. ESLint's rule pins to the *second* observed category; we
+  // do the same by treating the first member as authoritative.
+  firstIsStr := members[0].isStr
+  for _, m := range members[1:] {
+    if m.isStr != firstIsStr {
+      ctx.Report(m.member, "Mixing string and number enum values is not allowed.")
+    }
+  }
+}
+
 // no-extra-non-null-assertion: `a!!` / `a!?.b` collapses two assertions.
 type noExtraNonNullAssertion struct{}
 
@@ -89,9 +149,24 @@ func (noExtraNonNullAssertion) Check(ctx *Context, node *shimast.Node) {
   if parent == nil {
     return
   }
-  if parent.Kind == shimast.KindNonNullExpression {
-    ctx.Report(node, "Forbidden extra non-null assertion.")
+  if parent.Kind != shimast.KindNonNullExpression {
+    return
   }
+  message := "Forbidden extra non-null assertion."
+  // The outer NonNullExpression spans `a!!`; the redundant `!` is the
+  // last byte before the outer's End. Deleting [parent.End()-1, parent.End())
+  // collapses `a!!` to `a!` while preserving any source already after the
+  // outer expression.
+  pos := parent.End() - 1
+  if pos < 0 || pos >= len(ctx.File.Text()) || ctx.File.Text()[pos] != '!' {
+    ctx.Report(node, message)
+    return
+  }
+  ctx.ReportFix(
+    node,
+    message,
+    TextEdit{Pos: pos, End: pos + 1, Text: ""},
+  )
 }
 
 // no-non-null-asserted-optional-chain: `foo?.bar!` — the chain produces
@@ -314,7 +389,17 @@ func (preferNamespaceKeyword) Check(ctx *Context, node *shimast.Node) {
   if decl.Keyword != shimast.KindModuleKeyword {
     return
   }
-  ctx.Report(node, "Use 'namespace' instead of 'module' to declare custom TypeScript modules.")
+  message := "Use 'namespace' instead of 'module' to declare custom TypeScript modules."
+  start := keywordStart(ctx.File, node, "module")
+  if start < 0 {
+    ctx.Report(node, message)
+    return
+  }
+  ctx.ReportFix(
+    node,
+    message,
+    TextEdit{Pos: start, End: start + len("module"), Text: "namespace"},
+  )
 }
 
 // triple-slash-reference: `/// <reference path="..." />` directives.
@@ -658,6 +743,7 @@ var _ = struct{}{}
 func init() {
   Register(noConfusingNonNullAssertion{})
   Register(noDuplicateEnumValues{})
+  Register(noMixedEnums{})
   Register(noExtraNonNullAssertion{})
   Register(noNonNullAssertedOptionalChain{})
   Register(noMisusedNew{})

package/{plugin → linthost}/rules_var.go

@@ -1,4 +1,4 @@
-package main
+package linthost
 
 import shimast "github.com/microsoft/typescript-go/shim/ast"
 
@@ -14,6 +14,16 @@ func (noVar) Check(ctx *Context, node *shimast.Node) {
     return
   }
   if shimast.IsVar(stmt.DeclarationList) {
+    start := keywordStart(ctx.File, stmt.DeclarationList, "var")
+    if start >= 0 {
+      ctx.ReportRangeFix(
+        start,
+        start+len("var"),
+        "Unexpected var, use let or const instead.",
+        TextEdit{Pos: start, End: start + len("var"), Text: "let"},
+      )
+      return
+    }
     ctx.Report(node, "Unexpected var, use let or const instead.")
   }
 }
@@ -29,8 +39,9 @@ func (preferConst) Name() string           { return "prefer-const" }
 func (preferConst) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindSourceFile} }
 func (preferConst) Check(ctx *Context, node *shimast.Node) {
   type candidate struct {
-    name string
-    node *shimast.Node
+    name     string
+    node     *shimast.Node
+    listNode *shimast.Node
   }
   var candidates []candidate
   assigned := map[string]bool{}
@@ -53,7 +64,7 @@ func (preferConst) Check(ctx *Context, node *shimast.Node) {
       if !isConstEligibleLetDeclaration(child, decl) {
         return
       }
-      candidates = append(candidates, candidate{name: name, node: child})
+      candidates = append(candidates, candidate{name: name, node: child, listNode: listNode})
     case shimast.KindBinaryExpression:
       expr := child.AsBinaryExpression()
       if expr == nil || expr.OperatorToken == nil || !isAssignmentOperator(expr.OperatorToken.Kind) {
@@ -87,11 +98,31 @@ func (preferConst) Check(ctx *Context, node *shimast.Node) {
 
   for _, c := range candidates {
     if !assigned[c.name] {
-      ctx.Report(c.node, "Use const instead of let.")
+      start := -1
+      if isSingleDeclarationList(c.listNode) {
+        start = keywordStart(ctx.File, c.listNode, "let")
+      }
+      if start >= 0 {
+        ctx.ReportFix(
+          c.node,
+          "Use const instead of let.",
+          TextEdit{Pos: start, End: start + len("let"), Text: "const"},
+        )
+      } else {
+        ctx.Report(c.node, "Use const instead of let.")
+      }
     }
   }
 }
 
+func isSingleDeclarationList(node *shimast.Node) bool {
+  if node == nil {
+    return false
+  }
+  list := node.AsVariableDeclarationList()
+  return list != nil && list.Declarations != nil && len(list.Declarations.Nodes) == 1
+}
+
 func isConstEligibleLetDeclaration(node *shimast.Node, decl *shimast.VariableDeclaration) bool {
   if decl.Initializer != nil {
     if node.Parent != nil && node.Parent.Parent != nil && node.Parent.Parent.Kind == shimast.KindForStatement {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ttsc/lint",
-  "version": "0.10.2",
+  "version": "0.11.0-dev.20260517",
   "description": "Reference ttsc plugin: ESLint-style lint rules hosted in the same Program/Checker as the type-check pass.",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -25,16 +25,18 @@
   },
   "files": [
     "README.md",
-    "lib",
-    "src",
     "go.mod",
-    "plugin"
+    "lib",
+    "linthost",
+    "plugin",
+    "rule",
+    "src"
   ],
   "devDependencies": {
-    "@typescript/native-preview": "7.0.0-dev.20260510.1",
+    "@typescript/native-preview": "7.0.0-dev.20260515.1",
     "@types/node": "^25.3.0",
     "rimraf": "^6.1.2",
-    "ttsc": "0.10.2"
+    "ttsc": "0.11.0-dev.20260517"
   },
   "repository": {
     "type": "git",