blocks-dusted 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Designs Dusted
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,68 @@
+# blocks-dusted
+
+`blocks-dusted` installs reusable Payload CMS blocks into an existing Payload project.
+
+The GitHub source repository is private. That does not prevent installation from npm after the package is published, including when the published npm package is public.
+
+## Main Workflow
+
+Run commands from the root of your Payload project:
+
+```bash
+pnpm dlx blocks-dusted list
+pnpm dlx blocks-dusted doctor
+pnpm dlx blocks-dusted add DD-Hero --dry-run
+pnpm dlx blocks-dusted add DD-Hero
+```
+
+Use `blocks-dusted list` first to see the exact available block names in the package. `DD-Hero` is an existing block in the current manifest registry.
+
+The preferred install command after publication is:
+
+```bash
+pnpm dlx blocks-dusted add <BlockName>
+```
+
+## Commands
+
+```bash
+blocks-dusted --help
+blocks-dusted --version
+blocks-dusted list
+blocks-dusted doctor
+blocks-dusted doctor --cwd C:\Projects\my-payload-site
+blocks-dusted add DD-Hero --dry-run
+blocks-dusted add DD-Hero --no-register
+blocks-dusted add DD-Hero --cwd C:\Projects\my-payload-site
+```
+
+`--cwd` targets a Payload project directory without changing your shell directory. Relative `--cwd` values resolve from the directory where you launched the command.
+
+## Safety Behavior
+
+`--dry-run` performs no writes.
+
+`--no-register` copies block files and safe shared files but skips automatic collection and `RenderBlocks` registration.
+
+Existing block destinations are protected from overwrite. Existing shared files are never overwritten.
+
+Before supported source patches, the CLI creates backups such as `.bak`, `.bak.1`, and later numbered backups.
+
+Dependencies are reported but not installed. Install the reported packages manually after reviewing the output.
+
+Payload generators are never run automatically. Run these manually after reviewing changes:
+
+```bash
+pnpm payload generate:types
+pnpm payload generate:importmap
+```
+
+The CLI does not run migrations or build the target project.
+
+## Publishing Identities
+
+- GitHub repository: `https://github.com/Hadizainal/blocks-dusted.git`
+- npm package: `blocks-dusted`
+- CLI executable: `blocks-dusted`
+
+The repository can remain private while the npm package is published separately.

package/bin/index.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+import { runCli } from '../src/cli.js'
+
+runCli(process.argv.slice(2)).catch((error) => {
+  console.error(`Error: ${error.message}`)
+  process.exitCode = 1
+})

package/package.json

@@ -0,0 +1,40 @@
+{
+    "name":  "blocks-dusted",
+    "version":  "0.1.0",
+    "description":  "Manifest-driven CLI for installing reusable Payload CMS blocks.",
+    "type":  "module",
+    "bin":  {
+                "blocks-dusted":  "./bin/index.js"
+            },
+    "files":  [
+                  "bin",
+                  "src",
+                  "templates",
+                  "README.md",
+                  "LICENSE"
+              ],
+    "scripts":  {
+                    "start":  "node ./bin/index.js",
+                    "dev":  "node ./bin/index.js",
+                    "test":  "node --test test/cli.test.js",
+                    "validate:package":  "node ./scripts/validate-package.mjs",
+                    "test:pack":  "node --test test/pack.test.js",
+                    "prepack":  "npm run validate:package",
+                    "test:add":  "node ./bin/index.js add DD-Hero --dry-run",
+                    "test:list":  "node ./bin/index.js list",
+                    "test:doctor":  "node ./bin/index.js doctor",
+                    "convert:studio":  "node ./scripts/convertStudioBlock.mjs"
+                },
+    "engines":  {
+                    "node":  "\u003e=20"
+                },
+    "repository":  {
+                       "type":  "git",
+                       "url":  "git+https://github.com/Hadizainal/blocks-dusted.git"
+                   },
+    "bugs":  {
+                 "url":  "https://github.com/Hadizainal/blocks-dusted/issues"
+             },
+    "homepage":  "https://github.com/Hadizainal/blocks-dusted#readme",
+    "license":  "MIT"
+}

package/src/cli.js

@@ -0,0 +1,79 @@
+import { readFile } from 'node:fs/promises'
+import { resolve } from 'node:path'
+import { addTemplate } from './commands/add.js'
+import { doctor } from './commands/doctor.js'
+import { list } from './commands/list.js'
+import { error, info } from './utils/logger.js'
+import { packageRoot } from './utils/paths.js'
+
+function printHelp() {
+  info('blocks-dusted - reusable Payload CMS block installer')
+  info('')
+  info('Usage:')
+  info('  blocks-dusted list')
+  info('  blocks-dusted doctor [--cwd <path>]')
+  info('  blocks-dusted add <BlockName> [--dry-run] [--no-register] [--cwd <path>]')
+  info('  blocks-dusted --version')
+}
+
+export async function runCli(args, options = {}) {
+  const originalDirectory = options.cwd ?? process.cwd()
+
+  if (args.length === 0 || args.includes('--help') || args.includes('-h')) {
+    printHelp()
+    return
+  }
+
+  if (args.includes('--version') || args.includes('-v')) {
+    info(await packageVersion())
+    return
+  }
+
+  const { commandArgs, targetDirectory } = parseGlobalOptions(args, originalDirectory)
+  const [command, ...rest] = commandArgs
+
+  if (command === 'list') return list()
+  if (command === 'doctor') return doctor({ targetDirectory })
+  if (command === 'add') {
+    const templateName = rest.find((argument) => !argument.startsWith('-'))
+    return addTemplate({
+      templateName,
+      targetDirectory,
+      dryRun: rest.includes('--dry-run'),
+      noRegister: rest.includes('--no-register'),
+    })
+  }
+
+  error(`Unknown command: ${command}`)
+  printHelp()
+  process.exitCode = 1
+}
+
+function parseGlobalOptions(args, originalDirectory) {
+  const commandArgs = []
+  let targetDirectory = originalDirectory
+
+  for (let index = 0; index < args.length; index += 1) {
+    const argument = args[index]
+    if (argument === '--cwd') {
+      const value = args[index + 1]
+      if (!value) throw new Error('--cwd requires a directory path')
+      targetDirectory = resolve(originalDirectory, value)
+      index += 1
+      continue
+    }
+    if (argument.startsWith('--cwd=')) {
+      targetDirectory = resolve(originalDirectory, argument.slice('--cwd='.length))
+      continue
+    }
+    commandArgs.push(argument)
+  }
+
+  return { commandArgs, targetDirectory }
+}
+
+async function packageVersion() {
+  const packageJson = JSON.parse(await readFile(resolve(packageRoot, 'package.json'), 'utf8'))
+  return packageJson.version
+}
+

package/src/commands/add.js

@@ -0,0 +1,327 @@
+import { access } from 'node:fs/promises'
+import { join } from 'node:path'
+import { checkRequirements } from '../installers/checkRequirements.js'
+import {
+  copySharedFiles,
+  copyTemplateFiles,
+} from '../installers/copyTemplateFiles.js'
+import { checkDependencies } from '../installers/installDependencies.js'
+import { writeInstalledBlockReadme } from '../installers/writeInstalledBlockReadme.js'
+import { patchPayloadBlocksArray } from '../installers/patchPayloadBlocksArray.js'
+import { patchRenderBlocks } from '../installers/patchRenderBlocks.js'
+import { loadTemplateManifest } from '../registry/loadTemplateManifest.js'
+import { validateTemplateManifest } from '../registry/validateTemplateManifest.js'
+import { heading, info, item, status } from '../utils/logger.js'
+import { packageRoot } from '../utils/paths.js'
+import { fileExists, validateTargetProject } from '../utils/project.js'
+
+export async function addTemplate({
+  templateName,
+  targetDirectory = process.cwd(),
+  dryRun = false,
+  noRegister = false,
+}) {
+  if (!templateName) {
+    throw new Error(
+      'A block name is required. Example: blocks-dusted add DD-Hero --dry-run',
+    )
+  }
+
+  const { manifest, templateDirectory } = await loadTemplateManifest(templateName)
+  validateTemplateManifest(manifest)
+  await validateManifestSourceFiles({ manifest, templateDirectory, packageRoot })
+  const checks = await checkRequirements({ manifest, targetDirectory })
+  const dependencyChecks = await checkDependencies({ manifest, targetDirectory })
+
+  if (!dryRun) {
+    await validateTargetProject(targetDirectory)
+    const missingRequired = checks.missingRequirements ?? []
+    if (missingRequired.length > 0) {
+      throw new Error(
+        `Required project files are missing:\n${missingRequired.map((check) => `- ${check.path}: ${check.reason}`).join('\n')}`,
+      )
+    }
+  }
+
+  heading('Block')
+  info(`Name: ${manifest.name}`)
+  if (manifest.sourceName) info(`Source: ${manifest.sourceName}`)
+  if (manifest.portableName) info(`Portable name: ${manifest.portableName}`)
+  info(`Slug: ${manifest.slug}`)
+  info(`Type: ${manifest.type}`)
+  info(`Version: ${manifest.version}`)
+  info(`Target directory: ${targetDirectory}`)
+  info(`Register: ${noRegister ? 'no' : 'yes'}`)
+  info(`Source template path: ${templateDirectory}`)
+  info(`Target install path: ${checks.collisions.destinationPath}`)
+
+  heading(dryRun ? 'Files that would be copied' : 'Files to copy')
+  for (const file of manifest.files) item(`${file.from} -> ${file.to}`)
+
+  heading('Required project files')
+  if (checks.requiredFiles.length === 0) item('None')
+  for (const check of checks.requiredFiles) {
+    status(check.exists, check.path, check.reason)
+  }
+
+  heading('Optional project files')
+  if (checks.optionalFiles.length === 0) item('None')
+  for (const check of checks.optionalFiles) {
+    status(check.exists, check.path, check.reason)
+  }
+
+  heading('Package dependencies')
+  if (dependencyChecks.declared.length === 0) item('None')
+  for (const dependency of dependencyChecks.declared) {
+    const isMissing = dependencyChecks.missing.some(
+      (missing) => missing.name === dependency.name,
+    )
+    status(
+      !isMissing,
+      formatDependency(dependency),
+      isMissing ? 'missing' : 'already listed',
+    )
+  }
+  if (dependencyChecks.missing.length > 0) {
+    item(
+      `Install command: ${installCommandText(dependencyChecks.packageManager, dependencyChecks.missing)}`,
+    )
+  }
+
+  heading('Shared files')
+  const sharedFiles = manifest.sharedFiles ?? []
+  if (sharedFiles.length === 0) item('None')
+  for (const file of sharedFiles) {
+    item(
+      `${file.from} -> ${file.to}${file.safeToCopy === false ? ' (manual)' : ''}`,
+    )
+  }
+
+  heading('Collision checks')
+  collisionStatus(
+    !checks.collisions.destinationExists,
+    `Destination path: ${checks.collisions.destinationPath}`,
+  )
+  collisionStatus(
+    !checks.collisions.slugFound,
+    `Payload slug: ${manifest.slug}`,
+  )
+  collisionStatus(
+    !checks.collisions.configExportFound,
+    `Config export: ${manifest.exportName ?? manifest.name}`,
+  )
+  collisionStatus(
+    !checks.collisions.interfaceNameFound,
+    `interfaceName: ${manifest.interfaceName ?? manifest.exportName ?? manifest.name}`,
+  )
+  collisionStatus(
+    !checks.collisions.renderBlocksMappingFound,
+    `RenderBlocks mapping: ${manifest.slug}`,
+  )
+
+  if (checks.collisions.destinationExists) {
+    throw new Error(
+      `Refusing to install because ${checks.collisions.destinationPath} already exists.`,
+    )
+  }
+
+  heading('Manual steps')
+  manualSteps(manifest).forEach((step, index) => item(`${index + 1}. ${step}`))
+  heading('Generator commands')
+  item(
+    `${dependencyChecks.packageManager === 'npm' ? 'npx payload' : `${dependencyChecks.packageManager} payload`} generate:types`,
+  )
+  item(
+    `${dependencyChecks.packageManager === 'npm' ? 'npx payload' : `${dependencyChecks.packageManager} payload`} generate:importmap`,
+  )
+
+  heading('Patch targets')
+  for (const [name, target] of Object.entries(manifest.patchTargets ?? {})) {
+    item(`${name}: ${target.description}`)
+  }
+  const routeChecks = await checkPageRouteIntegration(manifest, targetDirectory)
+  if (
+    manifest.pageRouteIntegration?.description ||
+    manifest.pageRouteIntegration?.manualSteps?.length > 0 ||
+    routeChecks.length > 0
+  ) {
+    heading('Page route integration')
+    if (manifest.pageRouteIntegration.description)
+      item(manifest.pageRouteIntegration.description)
+    for (const check of routeChecks)
+      status(check.exists, check.path, check.reason)
+    for (const step of manifest.pageRouteIntegration.manualSteps ?? [])
+      item(step)
+  }
+
+  info('')
+  info(`Manifest loaded from: ${templateDirectory}`)
+
+  if (dryRun) {
+    const dryRunSharedResults = await copySharedFiles({
+      manifest,
+      packageRoot,
+      targetDirectory,
+      dryRun: true,
+    })
+    const dryRunCollectionResults = noRegister
+      ? [{ status: 'skipped', reason: '--no-register was passed' }]
+      : await patchPayloadBlocksArray({
+          manifest,
+          targetDirectory,
+          dryRun: true,
+        })
+    const dryRunRenderBlocksResults = noRegister
+      ? [{ status: 'skipped', reason: '--no-register was passed' }]
+      : await patchRenderBlocks({
+          manifest,
+          targetDirectory,
+          dryRun: true,
+        })
+
+    heading('Dry-run shared file results')
+    if (dryRunSharedResults.length === 0) item('None')
+    dryRunSharedResults.forEach((result) =>
+      item(
+        `${result.status}: ${result.to}${result.reason ? ` - ${result.reason}` : ''}`,
+      ),
+    )
+    heading('Dry-run collection registration')
+    dryRunCollectionResults.forEach((result) =>
+      item(`${result.status}: ${result.file ?? result.reason}`),
+    )
+    heading('Dry-run RenderBlocks registration')
+    dryRunRenderBlocksResults.forEach((result) =>
+      item(`${result.status}: ${result.file ?? result.reason}`),
+    )
+    info('Dry run complete: no files were changed.')
+    return
+  }
+
+  const sharedResults = await copySharedFiles({
+    manifest,
+    packageRoot,
+    targetDirectory,
+  })
+
+  const copiedFiles = await copyTemplateFiles({
+    manifest,
+    templateDirectory,
+    targetDirectory,
+  })
+
+  const collectionResults = noRegister
+    ? [{ status: 'skipped', reason: '--no-register was passed' }]
+    : await patchPayloadBlocksArray({ manifest, targetDirectory })
+  const renderBlocksResults = noRegister
+    ? [{ status: 'skipped', reason: '--no-register was passed' }]
+    : await patchRenderBlocks({ manifest, targetDirectory })
+  const readmePath = await writeInstalledBlockReadme({
+    manifest,
+    targetDirectory,
+    copiedFiles,
+    sharedResults,
+    dependencyChecks,
+    collectionResults,
+    renderBlocksResults,
+    packageManager: dependencyChecks.packageManager,
+    installCommand:
+      dependencyChecks.missing.length > 0
+        ? installCommandText(
+            dependencyChecks.packageManager,
+            dependencyChecks.missing,
+          )
+        : undefined,
+  })
+
+  heading('Copied files')
+  copiedFiles.forEach((file) => item(file))
+  heading('Shared file results')
+  if (sharedResults.length === 0) item('None')
+  sharedResults.forEach((result) =>
+    item(
+      `${result.status}: ${result.to}${result.reason ? ` - ${result.reason}` : ''}`,
+    ),
+  )
+  heading('Dependency install')
+  item('Skipped: dependency installation is manual')
+  if (dependencyChecks.missing.length > 0)
+    item(
+      `Run manually: ${installCommandText(dependencyChecks.packageManager, dependencyChecks.missing)}`,
+    )
+  heading('Collection registration')
+  collectionResults.forEach((result) =>
+    item(
+      `${result.status}: ${result.file ?? result.reason}${result.backupPath ? ` (backup: ${result.backupPath})` : ''}`,
+    ),
+  )
+  heading('RenderBlocks registration')
+  renderBlocksResults.forEach((result) =>
+    item(
+      `${result.status}: ${result.file ?? result.reason}${result.backupPath ? ` (backup: ${result.backupPath})` : ''}`,
+    ),
+  )
+  heading('Installed README')
+  item(readmePath)
+  info('')
+  info('Install complete.')
+  info(
+    'Payload generators were not run. Run them manually after reviewing changes.',
+  )
+}
+
+function formatDependency(dependency) {
+  return typeof dependency === 'string'
+    ? dependency
+    : `${dependency.name}${dependency.version ? `@${dependency.version}` : ''}`
+}
+
+function installCommandText(packageManager, dependencies) {
+  const command =
+    packageManager === 'yarn'
+      ? ['yarn', 'add']
+      : packageManager === 'bun'
+        ? ['bun', 'add']
+        : packageManager === 'npm'
+          ? ['npm', 'install']
+          : ['pnpm', 'add']
+  return [...command, ...dependencies.map(formatDependency)].join(' ')
+}
+
+function manualSteps(manifest) {
+  return manifest.manual ?? manifest.manualSteps ?? []
+}
+
+function collisionStatus(ok, label) {
+  console.log(`${ok ? '[ok]' : '[collision]'} ${label}`)
+}
+
+async function checkPageRouteIntegration(manifest, targetDirectory) {
+  const files = manifest.pageRouteIntegration?.requiredFiles ?? []
+  return Promise.all(
+    files.map(async (file) => ({
+      ...file,
+      exists: await fileExists(join(targetDirectory, file.path)),
+    })),
+  )
+}
+
+async function validateManifestSourceFiles({ manifest, templateDirectory, packageRoot }) {
+  const checks = [
+    ...manifest.files.map((file) => join(templateDirectory, file.from)),
+    ...(manifest.sharedFiles ?? []).map((file) => join(packageRoot, file.from)),
+  ]
+
+  const missing = []
+  for (const file of checks) {
+    try {
+      await access(file)
+    } catch {
+      missing.push(file)
+    }
+  }
+
+  if (missing.length > 0) {
+    throw new Error(`Manifest source files are missing:\n${missing.map((file) => `- ${file}`).join('\n')}`)
+  }
+}

package/src/commands/doctor.js

@@ -0,0 +1,21 @@
+import { inspectProject } from '../utils/project.js'
+import { heading, info, status } from '../utils/logger.js'
+
+export async function doctor({ targetDirectory } = {}) {
+  const project = await inspectProject(targetDirectory ?? process.cwd())
+  heading('Payload project doctor')
+  info(`Directory: ${project.targetDirectory}`)
+  status(project.hasPackageJson, 'package.json')
+  status(project.hasPayloadDependency, 'payload dependency')
+  status(project.hasSupportedSourceStructure, 'supported Payload source structure')
+  status(project.hasBlocksDirectory, 'src/blocks')
+  status(Boolean(project.payloadConfigPath), 'Payload config', project.payloadConfigPath || 'No likely config found')
+  status(project.isWritable, 'target directory writable')
+  status(!project.isCliRepository, 'not blocks-dusted source repository')
+  info(`Package manager: ${project.packageManager || 'not detected'}`)
+  info(`Appears to be a Payload project: ${project.isPayloadProject && !project.isCliRepository ? 'yes' : 'no'}`)
+
+  if (!project.isPayloadProject || project.isCliRepository || !project.isWritable) {
+    process.exitCode = 1
+  }
+}

package/src/commands/list.js

@@ -0,0 +1,18 @@
+import { listTemplates } from '../registry/listTemplates.js'
+import { heading, info, item } from '../utils/logger.js'
+
+export async function list() {
+  const templates = await listTemplates()
+  heading('Available blocks')
+
+  if (templates.length === 0) {
+    item('None')
+    return
+  }
+
+  for (const template of templates) {
+    item(`${template.name} (${template.type}, ${template.slug}, v${template.version})`)
+  }
+
+  info(`Total: ${templates.length}`)
+}

package/src/installers/checkRequirements.js

@@ -0,0 +1,101 @@
+import { access, readdir, readFile } from 'node:fs/promises'
+import { basename, dirname, join } from 'node:path'
+
+const SEARCH_EXTENSIONS = new Set(['.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs', '.json'])
+const IGNORED_DIRECTORIES = new Set(['.git', '.next', 'dist', 'build', 'node_modules'])
+
+export async function checkRequirements({ manifest, targetDirectory }) {
+  const requiredFiles = await checkFiles(manifest.requiredProjectFiles ?? [], targetDirectory)
+  const optionalFiles = await checkFiles(manifest.optionalProjectFiles ?? [], targetDirectory)
+  const destinationPath = commonDestination(manifest.files)
+  const searchableContent = await readSearchableProjectFiles(targetDirectory)
+  const exportName = manifest.exportName ?? manifest.name
+  const interfaceName = manifest.interfaceName ?? exportName
+
+  return {
+    requiredFiles,
+    optionalFiles,
+    missingRequirements: requiredFiles.filter((item) => !item.exists),
+    collisions: {
+      destinationPath,
+      destinationExists: await exists(join(targetDirectory, destinationPath)),
+      slugFound: contains(searchableContent, manifest.slug),
+      configExportFound: contains(searchableContent, `export const ${exportName}`),
+      interfaceNameFound: contains(searchableContent, `interfaceName: '${interfaceName}'`) || contains(searchableContent, `interfaceName: \"${interfaceName}\"`),
+      renderBlocksMappingFound: searchableContent.some(({ path, content }) => basename(path).toLowerCase().includes('renderblocks') && content.includes(manifest.slug)),
+    },
+  }
+}
+
+async function checkFiles(requirements, targetDirectory) {
+  return Promise.all(requirements.map(async (requirement) => ({
+    ...requirement,
+    exists: await exists(join(targetDirectory, requirement.path)),
+  })))
+}
+
+export async function destinationExists(targetDirectory, destinationPath) {
+  return exists(join(targetDirectory, destinationPath))
+}
+
+export async function projectContains(targetDirectory, text) {
+  return contains(await readSearchableProjectFiles(targetDirectory), text)
+}
+
+function contains(files, text) {
+  return files.some(({ content }) => content.includes(text))
+}
+
+function commonDestination(files) {
+  if (files.length === 0) return '.'
+  return dirname(files[0].to)
+}
+
+async function exists(path) {
+  try {
+    await access(path)
+    return true
+  } catch {
+    return false
+  }
+}
+
+async function readSearchableProjectFiles(targetDirectory) {
+  const files = []
+  await walk(join(targetDirectory, 'src'), files)
+
+  for (const fileName of ['payload.config.ts', 'payload.config.js']) {
+    const path = join(targetDirectory, fileName)
+    try {
+      files.push({ path, content: await readFile(path, 'utf8') })
+    } catch {
+      // Root-level Payload config is optional.
+    }
+  }
+
+  return files
+}
+
+async function walk(directory, output) {
+  let entries
+  try {
+    entries = await readdir(directory, { withFileTypes: true })
+  } catch {
+    return
+  }
+
+  for (const entry of entries) {
+    const path = join(directory, entry.name)
+    if (entry.isDirectory()) {
+      if (!IGNORED_DIRECTORIES.has(entry.name)) await walk(path, output)
+      continue
+    }
+    const extension = entry.name.slice(entry.name.lastIndexOf('.'))
+    if (!SEARCH_EXTENSIONS.has(extension)) continue
+    try {
+      output.push({ path, content: await readFile(path, 'utf8') })
+    } catch {
+      // Ignore unreadable files during diagnostics.
+    }
+  }
+}