@ttsc/lint 0.18.4 → 0.19.1

package/linthost/escape_string.go

@@ -0,0 +1,77 @@
+// escape_string.go ports eslint-plugin-unicorn's shared `escapeString` helper
+// (`rules/utils/escape-string.js`), which delegates to the `quote-js-string`
+// package. Every unicorn rule that rewrites a string literal from its cooked
+// value routes the replacement through it — `unicorn/better-regex`'s
+// `new RegExp("pattern", "flags")` branch and `unicorn/string-content`'s
+// literal branch — so the two share one port here rather than drifting apart.
+//
+// quote-js-string source: https://github.com/sindresorhus/quote-js-string
+package linthost
+
+import (
+  "strconv"
+  "strings"
+)
+
+// escapeStringIsUnsafeRune reports the code points quote-js-string treats as
+// unsafe to write raw into a JavaScript string literal: the C0 control range
+// (<= U+001F), DEL (U+007F), the U+2028 / U+2029 line and paragraph separators
+// (legal raw since ES2019, but line-oriented tooling still renders the literal
+// as broken across lines), and lone surrogates (no valid UTF-8 encoding).
+func escapeStringIsUnsafeRune(codePoint rune) bool {
+  return codePoint <= 0x1F ||
+    codePoint == 0x7F ||
+    codePoint == 0x2028 ||
+    codePoint == 0x2029 ||
+    (codePoint >= 0xD800 && codePoint <= 0xDFFF)
+}
+
+// escapeString wraps `value` in `quote` (`'` or `"`) the way upstream's
+// escapeString helper does. It escapes the backslash, the delimiter quote, and
+// every unsafe code point — writing the named escapes `\n \r \t \b \f \v` where
+// they apply and a braced ES6 code-point escape `\u{HEX}` (lowercase hex,
+// `\u{0}` for NUL) for the rest. Escaping the line terminators is what keeps a
+// cooked LF or CR from closing the literal early and corrupting the file.
+//
+// All other text passes through raw, exactly as upstream writes it: the
+// non-delimiter quote characters, C1 controls above DEL, non-ASCII letters,
+// exotic Unicode whitespace such as NBSP and the U+2000-U+200A group, and
+// astral symbols. Lone surrogates cannot reach this function — the tsgo scanner
+// cooks them to U+FFFD, which is safe and passes through like any other text.
+func escapeString(value string, quote byte) string {
+  var out strings.Builder
+  out.Grow(len(value) + 2)
+  out.WriteByte(quote)
+  for _, character := range value {
+    switch {
+    case character == '\\':
+      out.WriteString(`\\`)
+    case character == rune(quote):
+      out.WriteByte('\\')
+      out.WriteByte(quote)
+    case escapeStringIsUnsafeRune(character):
+      switch character {
+      case '\n':
+        out.WriteString(`\n`)
+      case '\r':
+        out.WriteString(`\r`)
+      case '\t':
+        out.WriteString(`\t`)
+      case '\b':
+        out.WriteString(`\b`)
+      case '\f':
+        out.WriteString(`\f`)
+      case '\v':
+        out.WriteString(`\v`)
+      default:
+        out.WriteString(`\u{`)
+        out.WriteString(strconv.FormatInt(int64(character), 16))
+        out.WriteString(`}`)
+      }
+    default:
+      out.WriteRune(character)
+    }
+  }
+  out.WriteByte(quote)
+  return out.String()
+}

package/linthost/fix.go

@@ -1,7 +1,7 @@
 // Autofix orchestration for the `@ttsc/lint fix` subcommand.
 //
 // RunFix drives the fix cascade: it repeatedly runs the native lint engine
-// and applies any emitted TextEdit suggestions until no more fixable
+// and applies any emitted automatic TextEdit fixes until no more fixable
 // findings remain or maxFixPasses is reached. After the cascade settles, it
 // runs a final diagnostic pass so remaining issues are surfaced in the
 // normal error stream.
@@ -43,14 +43,24 @@ func runFix(opts *subcommandOpts) int {
     fmt.Fprintln(os.Stderr, err)
     return 2
   }
-  // `ttsc fix` is the run-everything entry point: lint fixes AND formatter
-  // edits. Formatting is configured solely through the `format` block (a
-  // format/* key in `rules` is dropped), so wrap the resolver the same way
-  // `ttsc format` and the LSP paths do — formatCommandResolver force-
-  // activates the format rules the format block configured. A project with
-  // no format block populates no format options, so nothing extra is enabled
-  // and fix stays a pure lint pass.
+  // `ttsc fix` runs lint autofixes AND format-rule edits in one pass. Formatting
+  // is configured solely through the `format` block (a format/* key in `rules`
+  // is dropped), so wrap the resolver in formatCommandResolver to force-activate
+  // the format rules that block configured — the same promotion `ttsc format`
+  // applies to a configured block.
+  //
+  // Deliberately NOT newFormatCommandResolver: fix supplies no defaultOptions, so
+  // a project with no `format` block enables no format rules and fix stays a pure
+  // lint pass. Loading the always-on default formatter is `ttsc format`'s job;
+  // doing it here would reformat every file during a plain lint fix. This
+  // divergence is the contract pinned by
+  // command_fix_skips_default_formatting_that_format_applies_test.go and the
+  // website lint docs.
   engine := NewEngineWithResolver(formatCommandResolver{inner: rules})
+  if err := engine.ConfigError(); err != nil {
+    fmt.Fprintln(os.Stderr, err)
+    return 2
+  }
   engine.SetSerial(opts.singleThreaded)
   needsRuleChecker := engine.NeedsTypeChecker()
 
@@ -73,7 +83,7 @@ func runFix(opts *subcommandOpts) int {
   // kinds of findings in one pass — no filtering needed here.
   cascadeConverged := false
   for pass := 0; pass < maxFixPasses; pass++ {
-    findings := engine.Run(prog.userSourceFiles(), prog.checker)
+    findings := prog.runLintCycle(engine)
     fixed, err := applyFindingFixes(opts.cwd, findings)
     if err != nil {
       fmt.Fprintln(os.Stderr, err)
@@ -133,6 +143,7 @@ func loadFixProgram(opts *subcommandOpts, needsRuleChecker bool) (*program, int)
     singleThreaded:   opts.singleThreaded,
     checkers:         opts.checkers,
     tsgoArgs:         opts.tsgoArgs,
+    projectIdentity:  opts.projectIdentity,
   })
   if err != nil {
     fmt.Fprintf(os.Stderr, "@ttsc/lint: %v\n", err)
@@ -155,13 +166,14 @@ func reloadFixProgram(current *program, opts *subcommandOpts, needsRuleChecker b
   return loadFixProgram(opts, needsRuleChecker)
 }
 
-// fileFixes groups all pending TextEdit suggestions for a single file.
-// `text` is the source content at the time the findings were collected;
-// byte offsets in `edits` are relative to this snapshot.
+// fileFixes groups all pending automatic TextEdit fixes for a single file,
+// one edit group per finding so a multi-edit atomic fix stays all-or-nothing
+// during selection. `text` is the source content at the time the findings were
+// collected; byte offsets in `groups` are relative to this snapshot.
 type fileFixes struct {
-  path  string
-  text  string
-  edits []TextEdit
+  path   string
+  text   string
+  groups [][]TextEdit
 }
 
 // applyFindingFixes groups all fixable findings by file, resolves each
@@ -189,7 +201,7 @@ func applyFindingFixes(cwd string, findings []*Finding) (int, error) {
       bucket = &fileFixes{path: path, text: finding.File.Text()}
       byFile[path] = bucket
     }
-    bucket.edits = append(bucket.edits, finding.Fix...)
+    bucket.groups = append(bucket.groups, finding.Fix)
   }
 
   paths := make([]string, 0, len(byFile))
@@ -200,7 +212,7 @@ func applyFindingFixes(cwd string, findings []*Finding) (int, error) {
   total := 0
   for _, p := range paths {
     bucket := byFile[p]
-    fixed, err := applyTextEditsToFile(bucket.path, bucket.text, bucket.edits)
+    fixed, err := applyTextEditsToFile(bucket.path, bucket.text, bucket.groups)
     if err != nil {
       return total, err
     }
@@ -209,12 +221,13 @@ func applyFindingFixes(cwd string, findings []*Finding) (int, error) {
   return total, nil
 }
 
-// applyTextEditsToFile selects the non-overlapping edits from `edits`, applies
-// them to `source` in reverse order (right-to-left) to preserve earlier
-// offsets, and writes the result to `path`. Returns the number of edits
-// applied, or 0 when no edits survive selection.
-func applyTextEditsToFile(path, source string, edits []TextEdit) (int, error) {
-  selected := selectTextEdits(len(source), edits)
+// applyTextEditsToFile selects a non-overlapping, per-finding-atomic set of
+// edits from `groups` (one group per finding), applies them to `source` in
+// reverse order (right-to-left) to preserve earlier offsets, and writes the
+// result to `path`. Returns the number of edits applied, or 0 when no edits
+// survive selection.
+func applyTextEditsToFile(path, source string, groups [][]TextEdit) (int, error) {
+  selected := selectTextEditGroups(len(source), groups)
   if len(selected) == 0 {
     return 0, nil
   }
@@ -292,3 +305,100 @@ func selectTextEdits(sourceLen int, edits []TextEdit) []TextEdit {
   }
   return selected
 }
+
+// selectTextEditGroups selects a non-overlapping application sequence from
+// per-finding edit GROUPS, applying each group all-or-nothing. Unlike
+// selectTextEdits, which resolves conflicts edit-by-edit, this keeps a
+// finding's multi-edit fix atomic: a fix such as noImportTypeSideEffects emits
+// an `import type` insert paired with an inline `type` deletion, and applying
+// only one member emits invalid code (`import type { type A }`). Groups are
+// considered earliest-edit-first, and a group is accepted only when every one
+// of its edits coexists — under the same disjointness rules as selectTextEdits
+// — with the edits already accepted from earlier groups. If any member would be
+// dropped (it overlaps an already-selected group, duplicates an already-
+// selected edit, is a coincident zero-width insert, or is out of bounds), the
+// WHOLE group is skipped so the owning finding re-fires on the next cascade
+// pass rather than half-applying (samchon/ttsc#605).
+func selectTextEditGroups(sourceLen int, groups [][]TextEdit) []TextEdit {
+  order := make([]int, 0, len(groups))
+  for i := range groups {
+    if len(groups[i]) > 0 {
+      order = append(order, i)
+    }
+  }
+  sort.SliceStable(order, func(a, b int) bool {
+    return textEditGroupLess(groups[order[a]], groups[order[b]])
+  })
+  selected := make([]TextEdit, 0)
+  for _, index := range order {
+    group := dedupeTextEdits(groups[index])
+    candidate := make([]TextEdit, 0, len(selected)+len(group))
+    candidate = append(candidate, selected...)
+    candidate = append(candidate, group...)
+    kept := selectTextEdits(sourceLen, candidate)
+    // Accept the group only if nothing was dropped: a shorter result means one
+    // of its edits collided with an already-selected edit (or a sibling edit of
+    // its own group), so the group cannot apply atomically here.
+    if len(kept) == len(candidate) {
+      selected = kept
+    }
+  }
+  return selected
+}
+
+// dedupeTextEdits removes exact-duplicate edits while preserving order. A
+// finding that emits the same edit twice still applies its distinct edits;
+// deduping here keeps such a finding from being rejected as "internally
+// inconsistent" by selectTextEditGroups, since an exact duplicate is not a
+// conflict the way an overlap is.
+func dedupeTextEdits(edits []TextEdit) []TextEdit {
+  if len(edits) == 0 {
+    return nil
+  }
+  seen := make(map[TextEdit]struct{}, len(edits))
+  out := make([]TextEdit, 0, len(edits))
+  for _, edit := range edits {
+    if _, ok := seen[edit]; ok {
+      continue
+    }
+    seen[edit] = struct{}{}
+    out = append(out, edit)
+  }
+  return out
+}
+
+// textEditGroupLess orders edit groups by their earliest member under the same
+// (Pos, End, Text) key selectTextEdits sorts by, so selection is deterministic
+// and the earliest-starting finding wins a contested range.
+func textEditGroupLess(a, b []TextEdit) bool {
+  ea, eb := minTextEdit(a), minTextEdit(b)
+  if ea.Pos != eb.Pos {
+    return ea.Pos < eb.Pos
+  }
+  if ea.End != eb.End {
+    return ea.End < eb.End
+  }
+  return ea.Text < eb.Text
+}
+
+// minTextEdit returns the least edit of a non-empty group under the
+// (Pos, End, Text) order. Panics on an empty slice; callers filter empties out.
+func minTextEdit(edits []TextEdit) TextEdit {
+  least := edits[0]
+  for _, edit := range edits[1:] {
+    if textEditLess(edit, least) {
+      least = edit
+    }
+  }
+  return least
+}
+
+func textEditLess(a, b TextEdit) bool {
+  if a.Pos != b.Pos {
+    return a.Pos < b.Pos
+  }
+  if a.End != b.End {
+    return a.End < b.End
+  }
+  return a.Text < b.Text
+}

package/linthost/flags_gen.go

@@ -13,21 +13,22 @@ package linthost
 // Generated from packages/ttsc/src/flags/schema.ts. Edit the schema, not
 // this file.
 var LintFlagAllowList = map[string]bool{
-  "checkers":            true,
-  "cwd":                 true,
-  "diagnostics":         false,
-  "emit":                false,
-  "extendedDiagnostics": false,
-  "file":                true,
-  "noEmit":              false,
-  "out":                 true,
-  "outDir":              true,
-  "p":                   true,
-  "plugins-json":        true,
-  "project":             true,
-  "quiet":               false,
-  "singleThreaded":      false,
-  "tsconfig":            true,
-  "tsgo-args":           true,
-  "verbose":             false,
+  "checkers":             true,
+  "cwd":                  true,
+  "diagnostics":          false,
+  "emit":                 false,
+  "extendedDiagnostics":  false,
+  "file":                 true,
+  "noEmit":               false,
+  "out":                  true,
+  "outDir":               true,
+  "p":                    true,
+  "plugins-json":         true,
+  "project":              true,
+  "project-context-json": true,
+  "quiet":                false,
+  "singleThreaded":       false,
+  "tsconfig":             true,
+  "tsgo-args":            true,
+  "verbose":              false,
 }

package/linthost/format.go

@@ -48,6 +48,10 @@ func runFormat(opts *subcommandOpts) int {
     return 2
   }
   engine := NewEngineWithResolver(resolver)
+  if err := engine.ConfigError(); err != nil {
+    fmt.Fprintln(os.Stderr, err)
+    return 2
+  }
   engine.SetSerial(opts.singleThreaded)
   needsRuleChecker := engine.NeedsTypeChecker()
 
@@ -64,7 +68,7 @@ func runFormat(opts *subcommandOpts) int {
   totalFixes := 0
   cascadeConverged := false
   for pass := 0; pass < maxFormatPasses; pass++ {
-    findings := engine.Run(prog.userSourceFiles(), prog.checker)
+    findings := prog.runLintCycle(engine)
     fixed, err := applyFindingFixes(opts.cwd, filterFormatFindings(findings))
     if err != nil {
       fmt.Fprintln(os.Stderr, err)
@@ -115,15 +119,6 @@ type formatCommandResolver struct {
   // around as a value) shares the same underlying cache rather than copying a
   // sync.Once lock.
   ruleNames *formatRuleNamesCache
-  // entryDecisions memoizes the per-fileName ignored/matches decision that
-  // ResolveRules derives from fileIsIgnoredByEntry and fileMatchesAnyEntry.
-  // Both walk store.entries with glob matching and are recomputed identically
-  // for the same fileName on every format pass, so the result is cached once
-  // per file and reused. The field is a pointer (a *sync.Map) so the nil zero
-  // value stays valid for construction sites that omit it, and copying the
-  // resolver by value shares the same underlying map. sync.Map handles the
-  // engine's concurrent per-file ResolveRules calls without an extra lock.
-  entryDecisions *sync.Map
   // defaultOptions holds the always-on format rules' options (from
   // expandFormatBlock) to apply when the project config declares no `format`
   // block — no block in lint.config.*, or no config file at all. nil when a
@@ -142,9 +137,8 @@ type formatCommandResolver struct {
 // defaultOptions nil so the block stays authoritative.
 func newFormatCommandResolver(inner RuleResolver, startDir string, language string) (formatCommandResolver, error) {
   r := formatCommandResolver{
-    inner:          inner,
-    ruleNames:      &formatRuleNamesCache{},
-    entryDecisions: &sync.Map{},
+    inner:     inner,
+    ruleNames: &formatRuleNamesCache{},
   }
   if !hasInnerFormatRules(inner) {
     opts, err := defaultFormatOptions(editorFormatOverrides(startDir, language))
@@ -204,176 +198,52 @@ type formatRuleNamesCache struct {
   names []string
 }
 
-// formatEntryDecision is the cached per-fileName outcome of the two entry-scope
-// checks ResolveRules runs before applying its format-rule upgrade.
-type formatEntryDecision struct {
-  ignoredByEntry bool
-  matchesEntry   bool
-}
-
 // ResolveRules implements RuleResolver. It delegates to the inner resolver
 // and then upgrades format-rule entries from off to warn so they are applied
 // even when the project config omits them.
 //
-// A user-authored entry whose `ignores` list matches `fileName` is honored
-// here even when the entry also carries a `rules` block: the engine already
-// skips that entry's rule contributions via `ConfigEntry.matchesFile`, so the
-// format command must skip its blanket format-rule upgrade as well. Without
-// this guard, `ttsc format` would rewrite files that the user explicitly
-// asked the lint config to ignore — the engine's lint walk would skip the
-// file but the formatter would still touch it.
-//
-// The symmetric guard applies to `files`: if every non-IgnoreOnly entry
-// carries a `files` filter and `fileName` matches none of them, the engine
-// would not run any rules on the file (`ConfigEntry.matchesFile` returns
-// false for every entry). The format command must skip its blanket
-// format-rule upgrade for the same reason — otherwise `ttsc format` would
-// rewrite files that fall outside every entry's scope, e.g. a `.json`
-// resolved into the program via `resolveJsonModule` when the only entry
-// targets `src/**/*.ts`.
+// ConfigStore resolves entry applicability together with rules and options.
+// A global ignore skips the file, while OutOfScope skips only files rejected
+// by every rule-bearing entry. An ignore on one entry therefore cannot erase a
+// separate matching entry's contribution. The flags also survive resolver
+// wrappers, unlike inspecting a concrete ConfigStore from this outer layer.
 func (r formatCommandResolver) ResolveRules(fileName string) ResolvedRuleConfig {
   resolved := r.inner.ResolveRules(fileName)
-  if resolved.Ignored {
-    return resolved
-  }
-  decision := r.entryDecision(fileName)
-  if decision.ignoredByEntry {
-    return resolved
-  }
-  if !decision.matchesEntry {
+  if resolved.Ignored || resolved.OutOfScope {
     return resolved
   }
   if resolved.Rules == nil {
     resolved.Rules = RuleConfig{}
   }
+  if resolved.Options == nil {
+    resolved.Options = RuleOptionsMap{}
+  }
   for _, name := range r.formatOptionRuleNames() {
+    _, declaredForFile := resolved.Rules[normalizeBuiltinRuleName(name)]
+    if r.defaultOptions == nil && !declaredForFile {
+      // A configured format block is still a normal config entry: its files
+      // and ignores selectors scope the complete rule setting. Only the
+      // synthetic default set is allowed to introduce an undeclared rule.
+      continue
+    }
     if resolved.Rules.Severity(name) == SeverityOff {
       resolved.Rules[name] = SeverityWarn
     }
-  }
-  return resolved
-}
-
-// entryDecision returns the per-fileName ignored/matches outcome that
-// ResolveRules needs, computing it from fileIsIgnoredByEntry and
-// fileMatchesAnyEntry on first use and reusing it on later passes. When the
-// memo is absent (a resolver built without entryDecisions, e.g. in tests or
-// lsp) it computes the decision directly so behavior is identical, just
-// uncached.
-func (r formatCommandResolver) entryDecision(fileName string) formatEntryDecision {
-  if r.entryDecisions == nil {
-    return r.computeEntryDecision(fileName)
-  }
-  if cached, ok := r.entryDecisions.Load(fileName); ok {
-    return cached.(formatEntryDecision)
-  }
-  decision := r.computeEntryDecision(fileName)
-  // LoadOrStore keeps the first writer's value so concurrent passes over the
-  // same file agree; the decision is a pure function of fileName, so either
-  // value is correct.
-  actual, _ := r.entryDecisions.LoadOrStore(fileName, decision)
-  return actual.(formatEntryDecision)
-}
-
-// computeEntryDecision runs the two uncached entry-scope checks behind
-// entryDecision.
-func (r formatCommandResolver) computeEntryDecision(fileName string) formatEntryDecision {
-  return formatEntryDecision{
-    ignoredByEntry: r.fileIsIgnoredByEntry(fileName),
-    matchesEntry:   r.fileMatchesAnyEntry(fileName),
-  }
-}
-
-// fileIsIgnoredByEntry reports whether any non-IgnoreOnly entry in the inner
-// ConfigStore has an `ignores` glob that matches `fileName`. IgnoreOnly
-// entries are already handled by ResolvedRuleConfig.Ignored — they are
-// checked first by ConfigStore.ResolveRules and short-circuit the walk. This
-// helper covers the complementary case: an entry that carries both `rules`
-// and `ignores`, where the engine skips the entry's rule contributions via
-// `ConfigEntry.matchesFile` but the format command must learn the same fact
-// independently because its job is to upgrade format rules to `warn`, not to
-// read the engine's resolved severity map.
-func (r formatCommandResolver) fileIsIgnoredByEntry(fileName string) bool {
-  matched, _ := r.anyNonIgnoreEntry(func(entry *ConfigEntry) bool {
-    return entry.matchesIgnores(fileName)
-  })
-  return matched
-}
-
-// anyNonIgnoreEntry resolves the inner resolver to its concrete *ConfigStore
-// once and reports whether any non-IgnoreOnly entry satisfies `pred`. The
-// second return value is false when the inner resolver is not a *ConfigStore
-// (or is a nil one), letting each caller pick its own non-store default. This
-// collapses the shared store-resolution and entry-walk that fileIsIgnoredByEntry
-// and fileMatchesAnyEntry would otherwise duplicate; the per-caller default and
-// the empty-entries base case stay in the callers where they differ.
-func (r formatCommandResolver) anyNonIgnoreEntry(pred func(*ConfigEntry) bool) (matched bool, hasStore bool) {
-  store, ok := r.inner.(*ConfigStore)
-  if !ok || store == nil {
-    return false, false
-  }
-  for i := range store.entries {
-    entry := &store.entries[i]
-    if entry.IgnoreOnly {
-      continue
+    if len(resolved.RuleOptions(name)) == 0 {
+      var raw json.RawMessage
+      if resolved.OptionsResolved {
+        raw = r.defaultOptions[name]
+      } else {
+        // Legacy custom resolvers have no authoritative per-file options, so
+        // retain their file-agnostic override before consulting defaults.
+        raw = r.RuleOptions(name)
+      }
+      if len(raw) > 0 {
+        resolved.Options[name] = append(json.RawMessage(nil), raw...)
+      }
     }
-    if pred(entry) {
-      return true, true
-    }
-  }
-  return false, true
-}
-
-// fileMatchesAnyEntry reports whether `fileName` falls inside the `files`
-// scope of at least one non-IgnoreOnly entry. An entry without an explicit
-// `files` list matches every file by definition (eslint flat-config
-// semantics), so a config with any unrestricted non-IgnoreOnly entry returns
-// true for every file. The format command treats a `false` result the same
-// way the engine does: no entry contributes rules, so the blanket
-// format-rule upgrade must be skipped.
-//
-// Base cases:
-//
-//   - Empty entries slice: returns `true`. A store with no entries cannot
-//     skip a file by scope (the engine has nothing to walk), so format
-//     mode must be allowed to apply its default upgrade. Matching engine
-//     behavior at `ConfigStore.ResolveRules` for the same input
-//     (`Ignored = false`, empty rule map).
-//   - All entries are IgnoreOnly: returns `false`. No non-IgnoreOnly
-//     entry contributes a `files` scope, so the file is out-of-scope by
-//     construction.
-//   - Inner resolver is not a *ConfigStore: returns `true` (conservative
-//     default). The `files` concept is store-specific; an in-process
-//     custom resolver that does not surface a scope cannot have its
-//     rule-eligibility reasoned about from the outside, so the format
-//     upgrade applies the same as it does for an entry without `files`.
-func (r formatCommandResolver) fileMatchesAnyEntry(fileName string) bool {
-  matched, hasStore := r.anyNonIgnoreEntry(func(entry *ConfigEntry) bool {
-    return entry.matchesFile(fileName)
-  })
-  if !hasStore {
-    // Not a *ConfigStore: conservative default, see the doc comment above.
-    return true
-  }
-  // A store with no entries (or only IgnoreOnly ones that the walk skipped)
-  // produces matched == false; an empty entries slice must still return true
-  // so format mode applies its default upgrade, matching ConfigStore behavior.
-  // The all-IgnoreOnly case is distinguished by a non-empty entries slice.
-  if !matched && len(r.storeEntries()) == 0 {
-    return true
-  }
-  return matched
-}
-
-// storeEntries returns the inner resolver's config entries, or nil when the
-// inner resolver is not a *ConfigStore. Used by fileMatchesAnyEntry to tell the
-// empty-entries base case (return true) apart from the all-IgnoreOnly case
-// (return false) after anyNonIgnoreEntry reports no match.
-func (r formatCommandResolver) storeEntries() []ConfigEntry {
-  if store, ok := r.inner.(*ConfigStore); ok && store != nil {
-    return store.entries
   }
-  return nil
+  return resolved
 }
 
 // ActiveRuleNames implements RuleResolver. Returns the union of the inner
@@ -420,6 +290,40 @@ func (r formatCommandResolver) RuleOptions(name string) json.RawMessage {
   return nil
 }
 
+func (r formatCommandResolver) RuleOptionsVariants(name string) []json.RawMessage {
+  variants := resolvedRuleOptionsVariants(r.inner, name)
+  defaultOptions := r.defaultOptions[name]
+  if len(defaultOptions) == 0 {
+    return variants
+  }
+  effective := make([]json.RawMessage, 0, len(variants)+1)
+  defaultIncluded := false
+  for _, raw := range variants {
+    if len(raw) == 0 {
+      raw = defaultOptions
+      defaultIncluded = true
+    } else if string(raw) == string(defaultOptions) {
+      defaultIncluded = true
+    }
+    effective = append(effective, append(json.RawMessage(nil), raw...))
+  }
+  if !defaultIncluded {
+    // A scoped custom resolver may enumerate only its explicit tuples even
+    // though the default remains reachable for every other file.
+    effective = append(effective, append(json.RawMessage(nil), defaultOptions...))
+  }
+  return effective
+}
+
+// ResolveProjectRules forwards project declarations unchanged. Format defaults
+// are file rules and cannot create or scope project-rule state.
+func (r formatCommandResolver) ResolveProjectRules(names []string) (map[string]ProjectRuleSetting, error) {
+  if r.inner == nil {
+    return RuleConfig{}.ResolveProjectRules(names)
+  }
+  return r.inner.ResolveProjectRules(names)
+}
+
 // formatOptionRuleNames returns the sorted list of rule names from the inner
 // resolver's options that are registered as format rules. These are the rules
 // that formatCommandResolver promotes from off to warn.
@@ -464,10 +368,12 @@ func (r formatCommandResolver) computeFormatOptionRuleNames() []string {
 // options (e.g. bare RuleConfig).
 func resolverOptions(resolver RuleResolver) RuleOptionsMap {
   switch r := resolver.(type) {
+  case boundProjectRuleResolver:
+    return resolverOptions(r.RuleResolver)
   case InlineRuleResolver:
     return r.Options
   case *ConfigStore:
-    return r.options
+    return r.flattenOptions()
   default:
     return nil
   }