@ttsc/lint 0.18.4 → 0.19.0

package/linthost/config.go

@@ -86,30 +86,64 @@ func FindLintEntry(entries []PluginEntry) (*PluginEntry, error) {
 // rule name (e.g. "no-var").
 type RuleConfig map[string]Severity
 
-// RuleOptionsMap captures the rule-specific options blob, keyed by rule
-// name. Severity-only rules never appear here. The values are the raw
-// JSON the user wrote in the second tuple slot of a `["error", { ... }]`
-// rule setting; each rule decodes the blob into its own option struct on
-// demand.
+// RuleOptionsMap captures the rule-specific options payload, keyed by rule
+// name. Severity-only rules never appear here. A single option slot preserves
+// its JSON shape; multiple positional slots are encoded as an array. Each rule
+// decodes the payload according to its public option type on demand.
 type RuleOptionsMap map[string]json.RawMessage
 
-// ResolvedRuleConfig is the rule map that applies to one source file.
+// ProjectRuleSetting is the global declaration resolved for one registered
+// project rule. Declared distinguishes a missing entry from an explicit off.
+type ProjectRuleSetting struct {
+  Declared bool
+  Severity Severity
+  Options  json.RawMessage
+}
+
+// ResolvedRuleConfig is the complete rule setting that applies to one source
+// file. Rules and Options are folded from the same matching config entries so
+// an option tuple can never cross a files/ignores boundary independently of
+// its severity.
+//
 // `Ignored` means an `ignores`-only config entry matched the file and the
-// engine should skip linting it entirely.
+// engine should skip linting it entirely. `OutOfScope` means the store has at
+// least one rule-bearing entry but none applies to this file. Keeping the two
+// states distinct lets wrappers preserve entry-local ignores: one entry may
+// reject a file while another matching entry still contributes rules.
 type ResolvedRuleConfig struct {
   Rules   RuleConfig
-  Ignored bool
+  Options RuleOptionsMap
+  // OptionsResolved distinguishes an authoritative empty per-file option map
+  // from a legacy custom resolver that still supplies options exclusively via
+  // RuleResolver.RuleOptions.
+  OptionsResolved bool
+  Ignored         bool
+  OutOfScope      bool
+}
+
+// RuleOptions returns the file-resolved option payload for name. Built-in
+// aliases are normalized on lookup so the same key selects both severity and
+// options.
+func (r ResolvedRuleConfig) RuleOptions(name string) json.RawMessage {
+  if raw := r.Options[name]; len(raw) > 0 {
+    return raw
+  }
+  if raw := r.Options[normalizeBuiltinRuleName(name)]; len(raw) > 0 {
+    return raw
+  }
+  return nil
 }
 
 // RuleResolver is the engine-facing view of a resolved lint configuration.
 // Implementations include RuleConfig (severity-only, no options),
 // InlineRuleResolver (a severity map plus per-rule options), and *ConfigStore
-// (a parsed lint config file, with per-file glob resolution and a unified
-// options map).
+// (a parsed lint config file, with per-file glob resolution for both severity
+// and options).
 type RuleResolver interface {
-  // ResolveRules returns the effective severity map for the given source file.
-  // Implementations that support `files`/`ignores` patterns apply them here;
-  // flat RuleConfig always returns all rules unchanged.
+  // ResolveRules returns the effective severities and option payloads for the
+  // given source file. Implementations that support `files`/`ignores`
+  // patterns apply both halves of each rule setting here; flat RuleConfig
+  // always returns all severities unchanged and no options.
   ResolveRules(fileName string) ResolvedRuleConfig
   // ActiveRuleNames returns the sorted names of every rule that is not SeverityOff
   // in at least one config entry. Used to build the engine's dispatch table.
@@ -117,16 +151,78 @@ type RuleResolver interface {
   // EnabledRuleConfig returns the project-wide severity map for rules that are
   // not SeverityOff. Where multiple entries disagree, SeverityError wins.
   EnabledRuleConfig() RuleConfig
-  // RuleOptions returns the raw JSON options for `name`, or nil when the
-  // rule was configured with a severity alone. Returns nil for unknown
-  // rule names too — rules treat that as "use defaults".
+  // RuleOptions is the file-agnostic compatibility lookup used by flat and
+  // metadata-only consumers. Runtime file binding reads
+  // ResolveRules(fileName).RuleOptions(name), which is authoritative for
+  // scoped resolvers. Returns nil for severity-only and unknown rules.
   RuleOptions(name string) json.RawMessage
+  // ResolveProjectRules folds global declarations for registered project-rule
+  // names. A mention under a files selector is rejected because project state
+  // has no file identity.
+  ResolveProjectRules(names []string) (map[string]ProjectRuleSetting, error)
+}
+
+// RuleOptionsVariantsResolver is an optional extension for resolvers that can
+// declare more than one option payload for a rule. Engine construction uses
+// it to validate every files/extends variant before any file is visited.
+// Custom resolvers that omit this interface remain compatible through the
+// single RuleResolver.RuleOptions fallback.
+type RuleOptionsVariantsResolver interface {
+  RuleOptionsVariants(name string) []json.RawMessage
+}
+
+// resolvedRuleOptionsVariants returns every option shape a rule may receive.
+// File-scoped resolvers expose all declarations through the internal
+// extension; flat and external resolvers retain the RuleOptions fallback.
+func resolvedRuleOptionsVariants(resolver RuleResolver, name string) []json.RawMessage {
+  if variants, ok := resolver.(RuleOptionsVariantsResolver); ok {
+    if values := variants.RuleOptionsVariants(name); len(values) > 0 {
+      return values
+    }
+  }
+  return []json.RawMessage{append(json.RawMessage(nil), resolver.RuleOptions(name)...)}
+}
+
+// boundProjectRuleResolver retains the one project-wide resolution performed
+// while loading a config. Engine construction reads a defensive copy instead
+// of folding the extends chain a second time.
+type boundProjectRuleResolver struct {
+  RuleResolver
+  settings map[string]ProjectRuleSetting
+}
+
+func bindProjectRuleResolver(resolver RuleResolver) (RuleResolver, error) {
+  if resolver == nil {
+    resolver = RuleConfig{}
+  }
+  settings, err := resolver.ResolveProjectRules(allProjectRuleNames())
+  if err != nil {
+    return nil, err
+  }
+  return boundProjectRuleResolver{RuleResolver: resolver, settings: settings}, nil
+}
+
+func (r boundProjectRuleResolver) ResolveProjectRules(names []string) (map[string]ProjectRuleSetting, error) {
+  settings := make(map[string]ProjectRuleSetting, len(names))
+  for _, name := range names {
+    setting := r.settings[name]
+    setting.Options = append(json.RawMessage(nil), setting.Options...)
+    settings[name] = setting
+  }
+  return settings, nil
+}
+
+func (r boundProjectRuleResolver) RuleOptionsVariants(name string) []json.RawMessage {
+  return resolvedRuleOptionsVariants(r.RuleResolver, name)
 }
 
 // ResolveRules implements RuleResolver. A flat RuleConfig has no glob scoping,
 // so every file receives the full map unchanged.
 func (c RuleConfig) ResolveRules(string) ResolvedRuleConfig {
-  return ResolvedRuleConfig{Rules: normalizeRuleConfigKeys(c)}
+  return ResolvedRuleConfig{
+    Rules:           normalizeRuleConfigKeys(c),
+    OptionsResolved: true,
+  }
 }
 
 // ActiveRuleNames implements RuleResolver. Returns rule names whose severity
@@ -152,6 +248,17 @@ func (c RuleConfig) EnabledRuleConfig() RuleConfig {
 // predate option support.
 func (RuleConfig) RuleOptions(string) json.RawMessage { return nil }
 
+// ResolveProjectRules treats a flat RuleConfig as one global declaration.
+func (c RuleConfig) ResolveProjectRules(names []string) (map[string]ProjectRuleSetting, error) {
+  normalized := normalizeRuleConfigKeys(c)
+  out := make(map[string]ProjectRuleSetting, len(names))
+  for _, name := range names {
+    severity, declared := normalized[normalizeBuiltinRuleName(name)]
+    out[name] = ProjectRuleSetting{Declared: declared, Severity: severity}
+  }
+  return out, nil
+}
+
 func normalizeRuleConfigKeys(c RuleConfig) RuleConfig {
   if len(c) == 0 {
     return c
@@ -174,7 +281,22 @@ type InlineRuleResolver struct {
 // ResolveRules implements RuleResolver. Inline rules have no glob scoping;
 // the full map applies to every file.
 func (r InlineRuleResolver) ResolveRules(string) ResolvedRuleConfig {
-  return ResolvedRuleConfig{Rules: normalizeRuleConfigKeys(r.Rules)}
+  return ResolvedRuleConfig{
+    Rules:           normalizeRuleConfigKeys(r.Rules),
+    Options:         normalizeRuleOptionsKeys(r.Options),
+    OptionsResolved: true,
+  }
+}
+
+func normalizeRuleOptionsKeys(options RuleOptionsMap) RuleOptionsMap {
+  if len(options) == 0 {
+    return nil
+  }
+  normalized := make(RuleOptionsMap, len(options))
+  for name, raw := range options {
+    normalized[normalizeBuiltinRuleName(name)] = append(json.RawMessage(nil), raw...)
+  }
+  return normalized
 }
 
 // ActiveRuleNames implements RuleResolver by delegating to the inner RuleConfig.
@@ -204,11 +326,25 @@ func (r InlineRuleResolver) RuleOptions(name string) json.RawMessage {
   return nil
 }
 
+// ResolveProjectRules treats inline rules as global and preserves their
+// explicit options tuple.
+func (r InlineRuleResolver) ResolveProjectRules(names []string) (map[string]ProjectRuleSetting, error) {
+  settings, _ := r.Rules.ResolveProjectRules(names)
+  for _, name := range names {
+    setting := settings[name]
+    setting.Options = append(json.RawMessage(nil), r.RuleOptions(name)...)
+    settings[name] = setting
+  }
+  return settings, nil
+}
+
 // ConfigStore holds the parsed representation of a lint config file. It
 // implements RuleResolver with per-file glob scoping: ResolveRules walks the
-// entries in declaration order and the last matching entry wins. Options are
-// intentionally NOT per-file — one project-wide options map is kept so rule
-// behavior is uniform across the codebase even when severity varies by glob.
+// entries in declaration order and folds each matching rule's severity and
+// options together. A later option tuple replaces the inherited payload; a
+// later severity-only declaration preserves options from an earlier matching
+// entry and cannot borrow them from an entry that did not match the file.
+// https://eslint.org/docs/latest/use/configure/rules#using-configuration-files
 //
 // A config file is a single `ITtscLintConfig` object. Its `extends` field
 // names another config file to fold in first; the extends chain produces one
@@ -216,27 +352,64 @@ func (r InlineRuleResolver) RuleOptions(name string) json.RawMessage {
 // extending file's own entry so local rules win on collision.
 type ConfigStore struct {
   entries []ConfigEntry
-  // options is a flat rule-name → JSON map. Options are not scoped by
-  // `files` / `ignores`: a rule's behavior is a single project-wide
-  // configuration even when its severity is per-file. The simplification
-  // matches prettier-style options (one setting per project) while
-  // keeping severity layering intact.
-  options RuleOptionsMap
 }
 
-// RuleOptions implements RuleResolver.RuleOptions on ConfigStore.
+// RuleOptions implements the file-agnostic RuleResolver compatibility method.
+// Engine execution does not use this representative value: ResolveRules
+// carries the matching file's options. Callers that only understand the older
+// interface observe the final declared tuple, preserving the former flat
+// resolver behavior without storing a second source of truth.
 func (s *ConfigStore) RuleOptions(name string) json.RawMessage {
   if s == nil {
     return nil
   }
-  if raw := s.options[name]; len(raw) > 0 {
-    return raw
+  canonical := normalizeBuiltinRuleName(name)
+  var selected json.RawMessage
+  for _, entry := range s.entries {
+    if raw := entry.Options[canonical]; len(raw) > 0 {
+      selected = raw
+    }
+  }
+  return append(json.RawMessage(nil), selected...)
+}
+
+// flattenOptions returns the final declared payload for each rule without
+// claiming that it applies to any particular file. Metadata-only consumers
+// use this to enumerate option-bearing rules; execution always uses
+// ResolveRules instead.
+func (s *ConfigStore) flattenOptions() RuleOptionsMap {
+  if s == nil {
+    return nil
+  }
+  options := RuleOptionsMap{}
+  for _, entry := range s.entries {
+    for name, raw := range entry.Options {
+      options[normalizeBuiltinRuleName(name)] = append(json.RawMessage(nil), raw...)
+    }
+  }
+  return options
+}
+
+// RuleOptionsVariants exposes every entry-local payload (including a nil
+// severity-only declaration) so engine construction validates the full
+// files/extends surface rather than whichever tuple happened to be parsed
+// last.
+func (s *ConfigStore) RuleOptionsVariants(name string) []json.RawMessage {
+  if s == nil {
+    return nil
   }
   canonical := normalizeBuiltinRuleName(name)
-  if raw := s.options[canonical]; len(raw) > 0 {
-    return raw
+  variants := make([]json.RawMessage, 0)
+  for _, entry := range s.entries {
+    if entry.IgnoreOnly {
+      continue
+    }
+    if _, declared := entry.Rules[canonical]; !declared {
+      continue
+    }
+    variants = append(variants, append(json.RawMessage(nil), entry.Options[canonical]...))
   }
-  return nil
+  return variants
 }
 
 // ConfigEntry is the parsed form of one config file in the extends chain.
@@ -245,11 +418,13 @@ func (s *ConfigStore) RuleOptions(name string) json.RawMessage {
 // — these are evaluated first in ResolveRules and short-circuit the walk when
 // matched.
 type ConfigEntry struct {
-  BaseDir    string
-  Files      []string
-  Ignores    []string
-  Rules      RuleConfig
-  IgnoreOnly bool
+  BaseDir          string
+  Files            []string
+  HasFilesSelector bool
+  Ignores          []string
+  Rules            RuleConfig
+  Options          RuleOptionsMap
+  IgnoreOnly       bool
 }
 
 // ResolveRules implements RuleResolver. Ignore-only entries are checked first;
@@ -258,23 +433,40 @@ type ConfigEntry struct {
 // entry wins (later entries shadow earlier ones for the same rule name).
 func (s *ConfigStore) ResolveRules(fileName string) ResolvedRuleConfig {
   if s == nil {
-    return ResolvedRuleConfig{Rules: RuleConfig{}}
+    return ResolvedRuleConfig{Rules: RuleConfig{}, OptionsResolved: true}
   }
   for _, entry := range s.entries {
     if entry.IgnoreOnly && entry.matchesIgnores(fileName) {
-      return ResolvedRuleConfig{Rules: RuleConfig{}, Ignored: true}
+      return ResolvedRuleConfig{Rules: RuleConfig{}, OptionsResolved: true, Ignored: true}
     }
   }
   out := RuleConfig{}
+  options := RuleOptionsMap{}
+  hasEntries := false
+  matchedEntry := false
   for _, entry := range s.entries {
-    if entry.IgnoreOnly || !entry.matchesFile(fileName) {
+    if entry.IgnoreOnly {
+      continue
+    }
+    hasEntries = true
+    if !entry.matchesFile(fileName) {
       continue
     }
+    matchedEntry = true
     for name, sev := range entry.Rules {
-      out[normalizeBuiltinRuleName(name)] = sev
+      canonical := normalizeBuiltinRuleName(name)
+      out[canonical] = sev
+      if raw := entry.Options[canonical]; len(raw) > 0 {
+        options[canonical] = append(json.RawMessage(nil), raw...)
+      }
     }
   }
-  return ResolvedRuleConfig{Rules: out}
+  return ResolvedRuleConfig{
+    Rules:           out,
+    Options:         options,
+    OptionsResolved: true,
+    OutOfScope:      hasEntries && !matchedEntry,
+  }
 }
 
 // ActiveRuleNames implements RuleResolver. Returns the sorted union of all rule
@@ -324,6 +516,47 @@ func (s *ConfigStore) EnabledRuleConfig() RuleConfig {
   return out
 }
 
+// ResolveProjectRules folds the extends-expanded entries base-first. Only
+// global entries participate; any project-rule mention under files is an
+// invalid configuration, including off declarations and option tuples.
+func (s *ConfigStore) ResolveProjectRules(names []string) (map[string]ProjectRuleSetting, error) {
+  out := make(map[string]ProjectRuleSetting, len(names))
+  wanted := make(map[string]string, len(names))
+  for _, name := range names {
+    canonical := normalizeBuiltinRuleName(name)
+    wanted[canonical] = name
+    out[name] = ProjectRuleSetting{}
+  }
+  if s == nil {
+    return out, nil
+  }
+  for _, entry := range s.entries {
+    if entry.IgnoreOnly {
+      continue
+    }
+    for configuredName, severity := range entry.Rules {
+      name, projectRule := wanted[normalizeBuiltinRuleName(configuredName)]
+      if !projectRule {
+        continue
+      }
+      if entry.HasFilesSelector {
+        return nil, fmt.Errorf(
+          "@ttsc/lint: project rule %q cannot be configured in an entry with files",
+          name,
+        )
+      }
+      setting := out[name]
+      setting.Declared = true
+      setting.Severity = severity
+      if raw := entry.Options[normalizeBuiltinRuleName(configuredName)]; len(raw) > 0 {
+        setting.Options = append(json.RawMessage(nil), raw...)
+      }
+      out[name] = setting
+    }
+  }
+  return out, nil
+}
+
 // Flatten returns the unconstrained union of all non-ignore-only entries,
 // including SeverityOff rules. Used by LoadRuleConfig (callers that expect a
 // plain RuleConfig). Later entries shadow earlier ones for the same rule name.
@@ -372,9 +605,9 @@ func ParseRules(raw any) (RuleConfig, error) {
 }
 
 // ParseRulesWithOptions accepts either a severity literal or a
-// `[severity, options]` tuple per rule and returns the severity map
+// `[severity, ...options]` tuple per rule and returns the severity map
 // alongside an options map keyed by rule name. The options map only
-// contains entries for rules whose configuration was the tuple form.
+// contains entries for rules whose configuration carries option slots.
 func ParseRulesWithOptions(raw any) (RuleConfig, RuleOptionsMap, error) {
   if raw == nil {
     return RuleConfig{}, RuleOptionsMap{}, nil
@@ -398,10 +631,10 @@ func ParseRulesWithOptions(raw any) (RuleConfig, RuleOptionsMap, error) {
   return cfg, opts, nil
 }
 
-// parseRuleEntry splits a rule entry into its severity and (optional) options
-// payload. Bare severity literals produce a nil options blob; `[severity]`
-// (no options) does the same; `[severity, options]` re-serializes the options
-// to JSON so each rule can decode it into its own struct later.
+// parseRuleEntry splits a rule entry into its severity and optional positional
+// options. A single option keeps its JSON shape for existing object-option
+// rules. Two or more options become a JSON array so canonical ESLint rules
+// with several positional slots can decode them without parser special cases.
 func parseRuleEntry(value any) (Severity, json.RawMessage, error) {
   if tuple, ok := value.([]any); ok {
     if len(tuple) == 0 {
@@ -414,21 +647,14 @@ func parseRuleEntry(value any) (Severity, json.RawMessage, error) {
     if len(tuple) == 1 {
       return sev, nil, nil
     }
-    if len(tuple) > 2 {
-      return SeverityOff, nil, fmt.Errorf("severity tuple must be [severity] or [severity, options], got %d elements", len(tuple))
-    }
-    if tuple[1] == nil {
+    if len(tuple) == 2 && tuple[1] == nil {
       return sev, nil, nil
     }
-    if _, ok := tuple[1].(map[string]any); !ok {
-      // A positional string option (e.g. `["error", "single"]`) is
-      // rejected: every option struct in TtscLintRuleOptions is an
-      // object, and silently encoding a non-object slot would land in
-      // DecodeOptions as a decode error that every rule discards. Fail
-      // loudly so users discover the proper `["error", { … }]` form.
-      return SeverityOff, nil, fmt.Errorf("severity tuple's options slot must be an object, got %T", tuple[1])
+    var payload any = tuple[1]
+    if len(tuple) > 2 {
+      payload = tuple[1:]
     }
-    encoded, err := json.Marshal(tuple[1])
+    encoded, err := json.Marshal(payload)
     if err != nil {
       return SeverityOff, nil, fmt.Errorf("encode options: %w", err)
     }
@@ -558,6 +784,7 @@ func collectConfigObject(store *ConfigStore, raw any, baseDir, path string, chai
     }
   }
 
+  _, hasFilesSelector := obj["files"]
   files, err := parsePatternList(obj["files"], path+".files")
   if err != nil {
     return err
@@ -626,38 +853,38 @@ func collectConfigObject(store *ConfigStore, raw any, baseDir, path string, chai
     }
     merged := mergeRuleMaps(formatRulesRaw, rulesMap)
     if len(merged) > 0 {
-      parsed, err := parseExternalRuleMapInto(merged, path+".rules", store)
+      parsed, entryOptions, err := parseExternalRuleMapInto(merged, path+".rules")
       if err != nil {
         return err
       }
       store.entries = append(store.entries, ConfigEntry{
-        BaseDir: baseDir,
-        Files:   files,
-        Ignores: ignores,
-        Rules:   parsed,
+        BaseDir:          baseDir,
+        Files:            files,
+        HasFilesSelector: hasFilesSelector,
+        Ignores:          ignores,
+        Rules:            parsed,
+        Options:          entryOptions,
       })
     }
   }
   return nil
 }
 
-// parseExternalRuleMapInto parses the rules map and folds any
-// option blobs into `store.options`. Used by entry-creation paths so
-// the store ends with a unified options map for RuleResolver consumers.
-func parseExternalRuleMapInto(raw any, path string, store *ConfigStore) (RuleConfig, error) {
+// parseExternalRuleMapInto parses one entry's rules and option tuples. Options
+// stay on the ConfigEntry that owns their files/ignores scope; no project-wide
+// mirror is created.
+func parseExternalRuleMapInto(raw any, path string) (RuleConfig, RuleOptionsMap, error) {
   out := RuleConfig{}
-  if store.options == nil {
-    store.options = RuleOptionsMap{}
-  }
-  if err := collectExternalRuleMapWithOptions(out, store.options, raw, path); err != nil {
-    return nil, err
+  entryOptions := RuleOptionsMap{}
+  if err := collectExternalRuleMapWithOptions(out, entryOptions, raw, path); err != nil {
+    return nil, nil, err
   }
-  return out, nil
+  return out, entryOptions, nil
 }
 
-// collectExternalRuleMapWithOptions also records the rule's options blob
-// when the entry is a `[severity, options]` tuple. `opts` may be nil
-// when the caller does not need option capture.
+// collectExternalRuleMapWithOptions also records the rule's option payload
+// when the entry is a `[severity, ...options]` tuple. `opts` may be nil when
+// the caller does not need option capture.
 func collectExternalRuleMapWithOptions(out RuleConfig, opts RuleOptionsMap, raw any, path string) error {
   dict, ok := raw.(map[string]any)
   if !ok {
@@ -865,6 +1092,30 @@ func findLintConfigFileFrom(dir string) (string, error) {
   }
 }
 
+// pluginConfigDirEnv mirrors driver.PluginConfigDirEnv from
+// `packages/ttsc/driver`: the environment variable through which the ttsc
+// launcher passes the project root that plugin config-file discovery and
+// relative "configFile" resolution anchor at. It matters when the compiled
+// tsconfig is a generated wrapper outside the project (e.g. @ttsc/unplugin's
+// compiler-options overlay in the system temp directory) — the tsconfig
+// directory then no longer identifies the project. The constant is inlined
+// here instead of imported because @ttsc/lint deliberately avoids a
+// dependency on the in-tree ttsc module (see host.go).
+const pluginConfigDirEnv = "TTSC_PLUGIN_CONFIG_DIR"
+
+// explicitPluginConfigDir returns the launcher-provided config anchor from
+// pluginConfigDirEnv, resolved against cwd, or "" when the channel is unset.
+func explicitPluginConfigDir(cwd string) string {
+  dir := strings.TrimSpace(os.Getenv(pluginConfigDirEnv))
+  if dir == "" {
+    return ""
+  }
+  if !filepath.IsAbs(dir) && cwd != "" {
+    dir = filepath.Join(cwd, dir)
+  }
+  return filepath.Clean(dir)
+}
+
 // resolveConfigFilePath resolves a user-supplied config path to an absolute
 // path. Absolute paths are returned unchanged; relative paths are joined to the
 // tsconfig directory (or cwd when no tsconfig is set).
@@ -877,13 +1128,18 @@ func resolveConfigFilePath(configPath, cwd, tsconfigPath string) string {
 
 // discoveryConfigBaseDirs returns the ordered directories from which
 // auto-discovery walks upward when no explicit config path is provided. The
-// tsconfig directory comes first so that nested package configs are found
-// relative to the tsconfig that triggered the lint run; the working directory
-// follows as a fallback so a caller that points at an out-of-tree tsconfig
-// (e.g. a TtscCompiler invocation whose wrapper tsconfig lives in the system
-// temp dir but whose cwd/projectRoot is the real project) still discovers the
-// project's lint config instead of failing on the temp dir's empty ancestry.
+// launcher's explicit project-root channel (pluginConfigDirEnv) is the single
+// origin when set: it names the real project even when the tsconfig is a
+// generated wrapper in a temp directory, and keeps the wrapper's temp-tree
+// ancestry out of the walk. Otherwise the tsconfig directory comes first so
+// that nested package configs are found relative to the tsconfig that
+// triggered the lint run; the working directory follows as a fallback so a
+// caller that points at an out-of-tree tsconfig still discovers the project's
+// lint config instead of failing on the tsconfig dir's empty ancestry.
 func discoveryConfigBaseDirs(cwd, tsconfigPath string) []string {
+  if explicit := explicitPluginConfigDir(cwd); explicit != "" {
+    return []string{explicit}
+  }
   origins := make([]string, 0, 2)
   if tsconfigPath != "" {
     resolvedTsconfig := tsconfigPath
@@ -914,10 +1170,16 @@ func containsPath(paths []string, candidate string) bool {
   return false
 }
 
-// tsconfigBaseDir returns the directory that contains the tsconfig file, or
-// cwd when tsconfigPath is empty. Used as the base for relative config paths
-// supplied in the tsconfig plugin entry.
+// tsconfigBaseDir returns the base directory for relative config paths
+// supplied in the tsconfig plugin entry. The launcher's explicit project-root
+// channel (pluginConfigDirEnv) wins when set — the tsconfig may be a
+// generated wrapper in a temp directory that no longer identifies the
+// project — otherwise the directory containing the tsconfig is used, falling
+// back to cwd when tsconfigPath is empty.
 func tsconfigBaseDir(cwd, tsconfigPath string) string {
+  if explicit := explicitPluginConfigDir(cwd); explicit != "" {
+    return explicit
+  }
   if tsconfigPath == "" {
     return cwd
   }
@@ -1804,10 +2066,12 @@ func matchAnyPattern(baseDir string, patterns []string, fileName string) bool {
     if abs, err := filepath.Abs(base); err == nil {
       base = abs
     }
+    base = realProjectPath(base)
     file := fileName
     if abs, err := filepath.Abs(file); err == nil {
       file = abs
     }
+    file = realProjectPath(file)
     if candidate, err := filepath.Rel(base, file); err == nil {
       if candidate == ".." || strings.HasPrefix(candidate, ".."+string(filepath.Separator)) {
         return false

package/linthost/config_format.go

@@ -221,12 +221,20 @@ func expandFormatBlock(raw map[string]any) (map[string]any, error) {
   out["format/whitespace"] = ruleEntry(wsOpts)
 
   // formatSortImports, opt-in by `sortImports` (a boolean or options object).
+  // The top-level `endOfLine` is threaded in (like the other layout rules)
+  // so the rebuilt import block joins declarations with the file's line
+  // ending instead of a hard-coded LF. `endOfLine` is not a sortImports
+  // sub-key, so it is injected here rather than validated by
+  // expandSortImportsBlock.
   if v, ok := raw["sortImports"]; ok && v != nil {
     siOpts, enabled, err := expandSortImportsBlock(v)
     if err != nil {
       return nil, err
     }
     if enabled {
+      if eol, ok := layoutOpts["endOfLine"]; ok {
+        siOpts["endOfLine"] = eol
+      }
       out["format/sort-imports"] = ruleEntry(siOpts)
     }
   }
@@ -316,8 +324,14 @@ func expandSortImportsBlock(v any) (map[string]any, bool, error) {
           return nil, false, err
         }
         opts["combineTypeAndValue"] = b
+      case "unsafeSortRuntimeImports":
+        b, err := asBool("format.sortImports.unsafeSortRuntimeImports", val)
+        if err != nil {
+          return nil, false, err
+        }
+        opts["unsafeSortRuntimeImports"] = b
       default:
-        return nil, false, fmt.Errorf("@ttsc/lint: format.sortImports unknown key %q (allowed: order, caseSensitive, combineTypeAndValue)", key)
+        return nil, false, fmt.Errorf("@ttsc/lint: format.sortImports unknown key %q (allowed: order, caseSensitive, combineTypeAndValue, unsafeSortRuntimeImports)", key)
       }
     }
     return opts, true, nil