@stacksjs/defaults 0.75.62 → 0.75.63

package/ide/vscode/tests/fake-vscode.ts

@@ -1,228 +0,0 @@
-/**
- * Just enough of the `vscode` API for ./pickier.test.ts and ./env.test.ts:
- * documents, diagnostics, code actions, hovers and the provider registries,
- * recorded so tests can call the providers the way the editor would.
- */
-
-type Listener<T> = (event: T) => unknown
-
-export function emitter<T>() {
-  const listeners = new Set<Listener<T>>()
-  return {
-    event: (listener: Listener<T>) => {
-      listeners.add(listener)
-      return { dispose: () => listeners.delete(listener) }
-    },
-    fire: (value: T) => {
-      for (const listener of [...listeners]) listener(value)
-    },
-  }
-}
-
-export class Position {
-  constructor(readonly line: number, readonly character: number) {}
-  translate(lines = 0, characters = 0) {
-    return new Position(this.line + lines, this.character + characters)
-  }
-}
-
-export class Range {
-  readonly start: Position
-  readonly end: Position
-  constructor(a: Position | number, b: Position | number, c?: number, d?: number) {
-    this.start = typeof a === 'number' ? new Position(a, b as number) : a
-    this.end = typeof a === 'number' ? new Position(c as number, d as number) : b as Position
-  }
-}
-
-export class CodeActionKind {
-  static readonly QuickFix = new CodeActionKind('quickfix')
-  static readonly SourceFixAll = new CodeActionKind('source.fixAll')
-  constructor(readonly value: string) {}
-  append(part: string) {
-    return new CodeActionKind(`${this.value}.${part}`)
-  }
-
-  contains(other: CodeActionKind) {
-    return other.value === this.value || other.value.startsWith(`${this.value}.`)
-  }
-}
-
-export class WorkspaceEdit {
-  readonly edits: Array<{ uri: unknown, range?: Range, position?: Position, text: string }> = []
-  replace(uri: unknown, range: Range, text: string) {
-    this.edits.push({ uri, range, text })
-  }
-
-  insert(uri: unknown, position: Position, text: string) {
-    this.edits.push({ uri, position, text })
-  }
-}
-
-export class MarkdownString {
-  value = ''
-  appendMarkdown(text: string) {
-    this.value += text
-    return this
-  }
-
-  appendCodeblock(code: string, language = '') {
-    this.value += `\n\`\`\`${language}\n${code}\n\`\`\`\n`
-    return this
-  }
-}
-
-export interface FakeDocument {
-  uri: { fsPath: string, scheme: string, toString: () => string }
-  languageId: string
-  version: number
-  isClosed: boolean
-  lineCount: number
-  getText: () => string
-  lineAt: (line: number) => { text: string, lineNumber: number, range: Range }
-  getWordRangeAtPosition: (position: Position) => Range | undefined
-}
-
-export function document(path: string, text: string, languageId = 'typescript'): FakeDocument {
-  const lines = text.split('\n')
-  return {
-    uri: { fsPath: path, scheme: 'file', toString: () => `file://${path}` },
-    languageId,
-    version: 1,
-    isClosed: false,
-    lineCount: lines.length,
-    getText: () => text,
-    lineAt: (line: number) => ({ text: lines[line] ?? '', lineNumber: line, range: new Range(line, 0, line, (lines[line] ?? '').length) }),
-    getWordRangeAtPosition: (position: Position) => {
-      const line = lines[position.line] ?? ''
-      const match = /\w+/.exec(line.slice(position.character))
-      return match && match.index === 0 ? new Range(position.line, position.character, position.line, position.character + match[0].length) : undefined
-    },
-  }
-}
-
-export function fakeVscode(options: { folders: string[], settings?: Record<string, unknown>, documents?: FakeDocument[] }) {
-  const settings = options.settings ?? {}
-  const diagnostics = new Map<string, any[]>()
-  const handlers = new Map<string, (...args: any[]) => any>()
-  const codeActionProviders: any[] = []
-  const formatters: any[] = []
-  const hovers: any[] = []
-  const messages: string[] = []
-  const answers: Array<string | undefined> = []
-  const inputs: any[] = []
-  const output: string[] = []
-  const applied: WorkspaceEdit[] = []
-  const clipboard: string[] = []
-  const opened = emitter<FakeDocument>()
-  const changed = emitter<{ document: FakeDocument }>()
-  const saved = emitter<FakeDocument>()
-  const closed = emitter<FakeDocument>()
-
-  const message = (text: string) => {
-    messages.push(text)
-    return Promise.resolve(answers.shift())
-  }
-
-  const api = {
-    Position,
-    Range,
-    CodeActionKind,
-    WorkspaceEdit,
-    MarkdownString,
-    DiagnosticSeverity: { Error: 0, Warning: 1, Information: 2, Hint: 3 },
-    Diagnostic: class {
-      source?: string
-      code?: string
-      constructor(readonly range: Range, readonly message: string, readonly severity: number) {}
-    },
-    CodeAction: class {
-      edit?: WorkspaceEdit
-      diagnostics?: unknown[]
-      constructor(readonly title: string, readonly kind: CodeActionKind) {}
-    },
-    Hover: class {
-      constructor(readonly contents: MarkdownString, readonly range?: Range) {}
-    },
-    TextEdit: { replace: (range: Range, newText: string) => ({ range, newText }) },
-    commands: {
-      registerCommand: (id: string, handler: (...args: any[]) => any) => {
-        handlers.set(id, handler)
-        return { dispose: () => handlers.delete(id) }
-      },
-    },
-    env: { clipboard: { writeText: async (text: string) => { clipboard.push(text) } } },
-    languages: {
-      createDiagnosticCollection: () => ({
-        set: (uri: { toString: () => string }, list: any[]) => diagnostics.set(uri.toString(), list),
-        delete: (uri: { toString: () => string }) => diagnostics.delete(uri.toString()),
-        clear: () => diagnostics.clear(),
-        dispose: () => {},
-      }),
-      registerCodeActionsProvider: (_selector: unknown, provider: unknown) => {
-        codeActionProviders.push(provider)
-        return { dispose: () => {} }
-      },
-      registerDocumentFormattingEditProvider: (_selector: unknown, provider: unknown) => {
-        formatters.push(provider)
-        return { dispose: () => {} }
-      },
-      registerHoverProvider: (_selector: unknown, provider: unknown) => {
-        hovers.push(provider)
-        return { dispose: () => {} }
-      },
-    },
-    window: {
-      activeTextEditor: undefined as undefined | { document: FakeDocument },
-      createOutputChannel: () => ({ appendLine: (line: string) => output.push(line), dispose: () => {} }),
-      showInformationMessage: message,
-      showWarningMessage: message,
-      showErrorMessage: message,
-      showInputBox: (inputOptions: unknown) => {
-        inputs.push(inputOptions)
-        return Promise.resolve(answers.shift())
-      },
-      showQuickPick: (items: string[], pickOptions: unknown) => {
-        inputs.push({ items, ...pickOptions as object })
-        return Promise.resolve(answers.shift())
-      },
-    },
-    workspace: {
-      workspaceFolders: options.folders.map((folder, index) => ({ uri: { fsPath: folder }, name: folder, index })),
-      textDocuments: options.documents ?? [],
-      getConfiguration: () => ({ get: (key: string, fallback: unknown) => key in settings ? settings[key] : fallback }),
-      getWorkspaceFolder: (uri: { fsPath: string }) => {
-        const folder = options.folders.find(candidate => uri.fsPath.startsWith(`${candidate}/`))
-        return folder ? { uri: { fsPath: folder } } : undefined
-      },
-      applyEdit: async (edit: WorkspaceEdit) => {
-        applied.push(edit)
-        return true
-      },
-      onDidOpenTextDocument: opened.event,
-      onDidChangeTextDocument: changed.event,
-      onDidSaveTextDocument: saved.event,
-      onDidCloseTextDocument: closed.event,
-      onDidChangeConfiguration: emitter<any>().event,
-    },
-  }
-
-  return {
-    api,
-    diagnostics,
-    handlers,
-    codeActionProviders,
-    formatters,
-    hovers,
-    messages,
-    answers,
-    inputs,
-    output,
-    applied,
-    clipboard,
-    events: { opened, changed, saved, closed },
-    context: { subscriptions: [] as Array<{ dispose: () => unknown }> },
-  }
-}
-
-export const flush = () => new Promise(resolve => setTimeout(resolve, 10))

package/ide/vscode/tests/manifest.test.ts

@@ -1,141 +0,0 @@
-/**
- * The extension manifest.
- *
- * The Stacks extension is self-contained: stx support, pickier and env files
- * are built in, so it installs no extension pack and depends on no other
- * extension. stx support comes from `@stacksjs/stx-vscode`, the library build
- * of the stx extension (Stacks.vscode-stx); with both installed, the stx
- * extension stands down (stacksjs/stx#2020).
- */
-import { describe, expect, it } from 'bun:test'
-import { readFileSync } from 'node:fs'
-import { join } from 'node:path'
-import { libraryContributes, OWN_COMMAND_PREFIX, withStxContributes } from '../scripts/stx-contributes'
-
-const root = join(import.meta.dir, '..')
-const manifest = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8'))
-const STX_EXTENSION_ID = 'Stacks.vscode-stx'
-const projectSettings = Bun.JSONC.parse(readFileSync(join(root, '.vscode/settings.json'), 'utf8')) as Record<string, any>
-const recommendations = (Bun.JSONC.parse(readFileSync(join(root, '.vscode/extensions.json'), 'utf8')) as { recommendations: string[] }).recommendations
-
-describe('marketplace identity', () => {
-  it('is Stacks.vscode-stacks, not the stx extension', () => {
-    const id = `${manifest.publisher}.${manifest.name}`
-    expect(id).toBe('Stacks.vscode-stacks')
-    expect(id.toLowerCase()).not.toBe(STX_EXTENSION_ID.toLowerCase())
-  })
-})
-
-describe('self-contained', () => {
-  it('installs no extension pack and depends on no extension', () => {
-    expect(manifest.extensionPack).toBeUndefined()
-    expect(manifest.extensionDependencies).toBeUndefined()
-  })
-
-  it('has no runtime dependencies to ship', () => {
-    expect(manifest.dependencies).toBeUndefined()
-  })
-
-  it('recommends only itself to new projects', () => {
-    expect(recommendations.map(id => id.toLowerCase())).toEqual(['stacks.vscode-stacks'])
-  })
-
-  it('configures new projects for no other extension', () => {
-    // Settings that only mean something to an extension the project no longer
-    // asks for: ESLint, Prettier, Biome, markdownlint, shell-format, cSpell,
-    // Grammarly, vscode-icons, Todo Tree.
-    const foreign = Object.keys(projectSettings).filter(key =>
-      /^(?:eslint|prettier|biome|markdownlint|cSpell|grammarly|vsicons|todo-tree)\./.test(key))
-    expect(foreign).toEqual([])
-    expect(JSON.stringify(projectSettings)).not.toMatch(/dbaeumer|foxundermoon|DavidAnson|esbenp/i)
-  })
-
-  it('formats and fixes with pickier through this extension', () => {
-    expect(projectSettings['editor.defaultFormatter']).toBe('Stacks.vscode-stacks')
-    expect(projectSettings['editor.codeActionsOnSave']['source.fixAll.pickier']).toBe('explicit')
-  })
-})
-
-describe('stx language support', () => {
-  it('declares what @stacksjs/stx-vscode ships (run `bun run sync:stx` after updating it)', () => {
-    expect(withStxContributes(manifest, libraryContributes(root))).toEqual(manifest)
-  })
-
-  it('declares no stx command the library no longer ships', () => {
-    const shipped = new Set(libraryContributes(root).commands.map(command => command.command))
-    const stale = manifest.contributes.commands
-      .map((command: { command: string }) => command.command)
-      .filter((id: string) => !id.startsWith(OWN_COMMAND_PREFIX) && !shipped.has(id))
-    expect(stale).toEqual([])
-  })
-
-  it('drops a command stx renamed when syncing', () => {
-    const stale = { ...manifest, contributes: { ...manifest.contributes, commands: [...manifest.contributes.commands, { command: 'css.reload', title: 'Css: Reload Configuration' }] } }
-    expect(withStxContributes(stale, libraryContributes(root))).toEqual(manifest)
-  })
-
-  it('declares the stx language and its grammar from the bundled assets', () => {
-    expect(manifest.contributes.languages.map((language: { id: string }) => language.id)).toContain('stx')
-    expect(manifest.contributes.grammars[0].path).toStartWith('./dist/stx/')
-    expect(manifest.files).toContain('dist/stx/**')
-    expect(manifest.activationEvents).toContain('onLanguage:stx')
-  })
-
-  it('leaves snippets to runtime, so they never show twice next to the stx extension', () => {
-    expect(manifest.contributes.snippets).toBeUndefined()
-  })
-
-  it('does not map .stx files to another language', () => {
-    const extensionDefaults = manifest.contributes.configurationDefaults['files.associations'] ?? {}
-    for (const associations of [extensionDefaults, projectSettings['files.associations'] ?? {}])
-      expect(Object.keys(associations).filter(pattern => pattern.endsWith('.stx'))).toEqual([])
-  })
-})
-
-// tsserver loads a plugin only by package name, from the extension's
-// node_modules, and VS Code only sends it documents of a language a plugin
-// claims (stacksjs/stx#2028).
-describe('stx type checking', () => {
-  const plugins = manifest.contributes.typescriptServerPlugins as Array<{ name: string, languages?: string[], enableForWorkspaceTypeScriptVersions?: boolean }>
-
-  it('contributes the stx TypeScript server plugin by package name', () => {
-    expect(plugins.map(plugin => plugin.name)).toEqual(['@stacksjs/stx-typescript-plugin'])
-    for (const plugin of plugins) {
-      // The rule tsserver applies before loading anything (requestEnablePlugin).
-      expect(plugin.name).not.toMatch(/^(?:\.\.?(?:\/|$)|\/|[a-z]:)/i)
-      expect(plugin.name).not.toMatch(/[\\/]\.\.?(?:$|[\\/])/)
-    }
-  })
-
-  it('claims the stx language, also with the workspace TypeScript the project settings select', () => {
-    for (const plugin of plugins) {
-      expect(plugin.languages).toEqual(['stx'])
-      expect(plugin.enableForWorkspaceTypeScriptVersions).toBeTrue()
-    }
-    expect(manifest.contributes.configurationDefaults['typescript.tsdk']).toBe('node_modules/typescript/lib')
-  })
-
-  it('declares the setting that switches it off', () => {
-    const settings = Object.assign({}, ...manifest.contributes.configuration.map((section: { properties: object }) => section.properties))
-    expect(settings['stxTypescriptPlugin.enabled'].default).toBeTrue()
-  })
-})
-
-describe('packaging', () => {
-  it('adds the plugin to the VSIX, which vsce --no-dependencies leaves without node_modules', () => {
-    expect(manifest.scripts.package).toBe('bun scripts/package.ts')
-    expect(manifest.scripts.release).toBe('bun scripts/package.ts --publish')
-    expect(readFileSync(join(root, 'scripts/package.ts'), 'utf8')).toContain(`'vsce', 'package', '--no-dependencies'`)
-    // The release workflow publishes through the script, not a bare `vsce publish`.
-    const workflow = readFileSync(join(root, '../../../../../.github/workflows/release.yml'), 'utf8')
-    const step = workflow.slice(workflow.indexOf('- name: Publish VS Code Extension'))
-    expect(step.slice(0, step.indexOf('- name:', 10))).toContain('bun run release')
-    expect(workflow).not.toContain('vsce publish')
-  })
-
-  it('ships the files the extension loads at runtime', () => {
-    for (const file of ['dist/extension.js', 'dist/pickier-worker.js', 'dist/pickier-worker.bunfig.toml'])
-      expect(manifest.files).toContain(file)
-    expect(manifest.main).toBe('./dist/extension.js')
-  })
-})

package/ide/vscode/tests/package.test.ts

@@ -1,47 +0,0 @@
-/**
- * The VSIX, as VS Code installs it. It is packaged with `--no-dependencies`,
- * which leaves node_modules out, so scripts/package.ts adds the stx TypeScript
- * plugin's entry there afterwards; without it tsserver finds no plugin and no
- * `.stx` file is type-checked.
- */
-import { describe, expect, it } from 'bun:test'
-import { mkdtempSync, readFileSync, realpathSync, rmSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { packageExtension } from '../scripts/package'
-import { TS_PLUGIN_DIST, tsPluginModuleDir, tsPluginName } from '../scripts/ts-plugin'
-import { expectDeclarationsFound, loadLikeTsserver } from './ts-plugin-harness'
-
-const root = join(import.meta.dir, '..')
-const manifest = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8'))
-
-// vsce runs `vscode:prepublish` through npm, so this needs npm on PATH; the
-// release workflow, which runs these tests before publishing, has it.
-const canPackage = Boolean(Bun.which('npm') && Bun.which('zip') && Bun.which('unzip'))
-
-describe('the VSIX', () => {
-  it.skipIf(!canPackage)('carries the stx TypeScript plugin, and it loads from the installed layout', () => {
-    // Real path: require() resolves symlinks, and macOS's tmpdir is one.
-    const dir = realpathSync(mkdtempSync(join(tmpdir(), 'stacks-vsix-test-')))
-    try {
-      const vsix = packageExtension(join(dir, 'stacks.vsix'))
-      const listing = Bun.spawnSync(['unzip', '-Z1', vsix]).stdout.toString().split('\n')
-      const name = tsPluginName(root)
-
-      expect(listing).toContain(`extension/${tsPluginModuleDir(name)}/package.json`)
-      expect(listing).toContain(`extension/${tsPluginModuleDir(name)}/index.js`)
-      // Nothing else of node_modules: the bundle carries its dependencies.
-      expect(listing.filter(file => file.startsWith('extension/node_modules/') && !file.startsWith(`extension/${tsPluginModuleDir(name)}/`))).toEqual([])
-      expect(listing).toContain(`extension/${TS_PLUGIN_DIST}/types/stx-module.d.ts`)
-
-      expect(Bun.spawnSync(['unzip', '-q', vsix, 'extension/*', '-d', dir]).exitCode).toBe(0)
-      const installed = join(dir, 'extension')
-      expect(JSON.parse(readFileSync(join(installed, 'package.json'), 'utf8')).version).toBe(manifest.version)
-      expect(typeof loadLikeTsserver(installed, name)).toBe('function')
-      expectDeclarationsFound(installed, name, join(installed, TS_PLUGIN_DIST, 'types'))
-    }
-    finally {
-      rmSync(dir, { recursive: true, force: true })
-    }
-  }, 180_000)
-})

package/ide/vscode/tests/pickier.test.ts

@@ -1,202 +0,0 @@
-/**
- * Pickier support (src/pickier.ts), driven through a fake `vscode` API and a
- * fake worker process: no editor, no Bun, no pickier.
- */
-import type { PickierProcess } from '../src/pickier'
-import type { PickierRequest, PickierResult } from '../src/pickier-protocol'
-import { describe, expect, it } from 'bun:test'
-import { chooseBun, createPickierSupport, disableNextLineComment, isLintedFile, isPickierConfigPath } from '../src/pickier'
-import { CodeActionKind, document, fakeVscode, flush } from './fake-vscode'
-
-const ROOT = '/work/app'
-
-interface Worker {
-  answer?: (request: PickierRequest) => PickierResult
-  ready?: false
-  fixText?: boolean
-  exitOnStart?: boolean
-}
-
-function setup(options: { worker?: Worker, files?: string[], settings?: Record<string, unknown>, documents?: ReturnType<typeof document>[] } = {}) {
-  const files = new Set(options.files ?? [`${ROOT}/buddy`])
-  const fake = fakeVscode({ folders: [ROOT], settings: options.settings, documents: options.documents })
-  const spawned: Array<{ bun: string, script: string, cwd: string, requests: PickierRequest[] }> = []
-
-  const host = {
-    exists: (path: string) => files.has(path),
-    spawnBun(bun: string, script: string, cwd: string): PickierProcess {
-      const record = { bun, script, cwd, requests: [] as PickierRequest[] }
-      spawned.push(record)
-      const lineListeners: Array<(line: string) => void> = []
-      const exitListeners: Array<() => void> = []
-      const emit = (message: unknown) => queueMicrotask(() => lineListeners.forEach(listener => listener(JSON.stringify(message))))
-      const worker = options.worker ?? {}
-
-      queueMicrotask(() => {
-        if (worker.exitOnStart)
-          return exitListeners.forEach(listener => listener())
-        if (worker.ready === false)
-          return emit({ ready: false, error: 'Cannot find package \'pickier\'', missing: true })
-        emit({ ready: true, version: '0.1.66', fixText: worker.fixText ?? true })
-      })
-
-      return {
-        write(line) {
-          const request = JSON.parse(line) as PickierRequest
-          record.requests.push(request)
-          const result = worker.answer?.(request) ?? (request.op === 'lint' ? { op: 'lint', issues: [] } : { op: request.op, text: null })
-          emit({ id: request.id, ok: true, result })
-        },
-        onLine: listener => lineListeners.push(listener),
-        onExit: listener => exitListeners.push(listener),
-        kill: () => {},
-      }
-    },
-  }
-
-  const support = createPickierSupport(fake.api as any, host, { workerPath: '/ext/dist/pickier-worker.js', lintDelayMs: 1 })
-  support.activate(fake.context)
-  return { ...fake, spawned, support }
-}
-
-describe('helpers', () => {
-  it('runs pickier on the configured Bun, else the project\'s pinned Bun, else bun on the PATH', () => {
-    expect(chooseBun(' /opt/bun ', ROOT, () => true)).toBe('/opt/bun')
-    expect(chooseBun('', ROOT, path => path === `${ROOT}/pantry/.bin/bun`)).toBe(`${ROOT}/pantry/.bin/bun`)
-    expect(chooseBun('', ROOT, () => false)).toBe('bun')
-  })
-
-  it('lints exactly the files `buddy lint` does', () => {
-    expect(isLintedFile(ROOT, `${ROOT}/app/Actions/Hello.ts`)).toBeTrue()
-    expect(isLintedFile(ROOT, `${ROOT}/README.md`)).toBeTrue()
-    expect(isLintedFile(ROOT, `${ROOT}/node_modules/x/index.ts`)).toBeFalse()
-    expect(isLintedFile(ROOT, `${ROOT}/dist/index.js`)).toBeFalse()
-    expect(isLintedFile(ROOT, `${ROOT}/resources/views/index.stx`)).toBeFalse()
-    expect(isLintedFile(ROOT, '/elsewhere/a.ts')).toBeFalse()
-  })
-
-  it('recognises the files pickier reads its config from', () => {
-    expect(isPickierConfigPath(`${ROOT}/config/code-style.ts`)).toBeTrue()
-    expect(isPickierConfigPath(`${ROOT}/pickier.config.ts`)).toBeTrue()
-    expect(isPickierConfigPath(`${ROOT}/.config/pickier.ts`)).toBeTrue()
-    expect(isPickierConfigPath(`${ROOT}/config/app.ts`)).toBeFalse()
-  })
-
-  it('disables a rule for the next line at that line\'s indentation', () => {
-    expect(disableNextLineComment('    let x = 1', 'prefer-const', '//')).toBe('    // pickier-disable-next-line prefer-const\n')
-  })
-})
-
-describe('diagnostics', () => {
-  it('reports the project pickier\'s issues on an open file, in editor coordinates', async () => {
-    const file = document(`${ROOT}/app/x.ts`, 'import { a } from \'b\'\nlet x = 1\n')
-    const { diagnostics, spawned } = setup({
-      documents: [file],
-      worker: {
-        answer: () => ({ op: 'lint', issues: [{ line: 2, column: 5, ruleId: 'prefer-const', message: '\'x\' is never reassigned', severity: 'error', help: 'Use const' }] }),
-      },
-    })
-    await flush()
-
-    expect(spawned).toHaveLength(1)
-    expect(spawned[0]).toMatchObject({ bun: 'bun', script: '/ext/dist/pickier-worker.js', cwd: ROOT })
-    expect(spawned[0]!.requests[0]).toMatchObject({ op: 'lint', file: `${ROOT}/app/x.ts` })
-
-    const [diagnostic] = diagnostics.get(`file://${ROOT}/app/x.ts`)!
-    expect(diagnostic.source).toBe('pickier')
-    expect(diagnostic.code).toBe('prefer-const')
-    expect(diagnostic.severity).toBe(0)
-    expect(diagnostic.range.start).toMatchObject({ line: 1, character: 4 })
-    expect(diagnostic.range.end).toMatchObject({ line: 1, character: 5 })
-    expect(diagnostic.message).toBe('\'x\' is never reassigned\nUse const')
-  })
-
-  it('leaves folders that are not Stacks projects alone', async () => {
-    const { spawned } = setup({ files: [], documents: [document(`${ROOT}/x.ts`, 'let x = 1\n')] })
-    await flush()
-    expect(spawned).toHaveLength(0)
-  })
-
-  it('lints nothing when turned off', async () => {
-    const { spawned } = setup({ settings: { 'pickier.enable': false }, documents: [document(`${ROOT}/x.ts`, 'let x = 1\n')] })
-    await flush()
-    expect(spawned).toHaveLength(0)
-  })
-
-  it('stops asking a project with no pickier, and says why once', async () => {
-    const { spawned, events, output, diagnostics } = setup({ worker: { ready: false }, documents: [document(`${ROOT}/a.ts`, '')] })
-    await flush()
-    events.opened.fire(document(`${ROOT}/b.ts`, '') as any)
-    await flush()
-
-    expect(spawned).toHaveLength(1)
-    expect(diagnostics.size).toBe(0)
-    expect(output.filter(line => line.includes('not available'))).toHaveLength(1)
-  })
-
-  it('gives up on a worker that keeps exiting instead of respawning it on every keystroke', async () => {
-    const { spawned, events } = setup({ worker: { exitOnStart: true } })
-    for (let i = 0; i < 5; i++) {
-      events.opened.fire(document(`${ROOT}/x${i}.ts`, '') as any)
-      await flush()
-    }
-    expect(spawned).toHaveLength(3)
-  })
-})
-
-describe('fixing and formatting', () => {
-  const FIXED = 'const x = 1\n'
-
-  it('offers source.fixAll.pickier, the code action codeActionsOnSave asks for', async () => {
-    const file = document(`${ROOT}/x.ts`, 'let x = 1\n')
-    const { codeActionProviders, spawned } = setup({ worker: { answer: request => request.op === 'fix' ? { op: 'fix', text: FIXED } : { op: 'lint', issues: [] } } })
-
-    const only = CodeActionKind.SourceFixAll.append('pickier')
-    const [action] = await codeActionProviders[0].provideCodeActions(file, undefined, { only, diagnostics: [] })
-
-    expect(action.kind.value).toBe('source.fixAll.pickier')
-    expect(action.edit.edits[0].text).toBe(FIXED)
-    expect(spawned[0]!.requests.at(-1)!.op).toBe('fix')
-
-    // The generic `source.fixAll` includes it too.
-    const generic = await codeActionProviders[0].provideCodeActions(file, undefined, { only: CodeActionKind.SourceFixAll, diagnostics: [] })
-    expect(generic).toHaveLength(1)
-  })
-
-  it('offers nothing when there is nothing to fix, or the project\'s pickier cannot fix text', async () => {
-    const file = document(`${ROOT}/x.ts`, FIXED)
-    const unchanged = setup({ worker: { answer: request => ({ op: request.op as 'fix', text: FIXED }) } })
-    expect(await unchanged.codeActionProviders[0].provideCodeActions(file, undefined, { only: CodeActionKind.SourceFixAll, diagnostics: [] })).toEqual([])
-
-    const old = setup({ worker: { fixText: false } })
-    expect(await old.codeActionProviders[0].provideCodeActions(document(`${ROOT}/x.ts`, 'let x = 1\n'), undefined, { only: CodeActionKind.SourceFixAll, diagnostics: [] })).toEqual([])
-  })
-
-  it('offers quick fixes for its own diagnostics: fix all, and disable the rule for the line', async () => {
-    const file = document(`${ROOT}/x.ts`, 'function f() {\n  let x = 1\n}\n')
-    const { codeActionProviders } = setup({ worker: { answer: request => request.op === 'fix' ? { op: 'fix', text: 'function f() {\n  const x = 1\n}\n' } : { op: 'lint', issues: [] } } })
-    const diagnostic = { source: 'pickier', code: 'prefer-const', range: { start: { line: 1, character: 6 } } }
-
-    const actions = await codeActionProviders[0].provideCodeActions(file, undefined, { diagnostics: [diagnostic, { source: 'ts', code: 1 }] })
-
-    expect(actions.map((action: any) => action.title)).toEqual(['Fix all pickier problems', 'Disable prefer-const for this line'])
-    expect(actions[1].edit.edits[0]).toMatchObject({ position: { line: 1, character: 0 }, text: '  // pickier-disable-next-line prefer-const\n' })
-  })
-
-  it('formats with the project\'s pickier', async () => {
-    const file = document(`${ROOT}/x.ts`, 'const a = "x"\n')
-    const { formatters } = setup({ worker: { answer: request => request.op === 'format' ? { op: 'format', text: 'const a = \'x\'\n' } : { op: 'lint', issues: [] } } })
-
-    const [edit] = await formatters[0].provideDocumentFormattingEdits(file)
-    expect(edit.newText).toBe('const a = \'x\'\n')
-  })
-
-  it('applies the fixes to the active file from the command palette', async () => {
-    const file = document(`${ROOT}/x.ts`, 'let x = 1\n')
-    const fake = setup({ worker: { answer: request => request.op === 'fix' ? { op: 'fix', text: FIXED } : { op: 'lint', issues: [] } } })
-    fake.api.window.activeTextEditor = { document: file }
-
-    await fake.handlers.get('stacks.pickier.fixAll')!()
-    expect(fake.applied[0]!.edits[0]!.text).toBe(FIXED)
-  })
-})