@agentskit/doc-bridge 1.0.2 → 1.2.1

package/src/gates/run-gates.ts

@@ -1,14 +1,23 @@
 import { readFileSync } from 'node:fs'
 
 import type { DocBridgeConfigV1 } from '../config/schema.js'
+import {
+  runDocumentationStandardV1,
+  type DocumentationConformanceReportV1,
+} from '../conformance/documentation-standard-v1.js'
 import { buildDocBridgeIndex } from '../index-builder/build-index.js'
 import { scanAgentCorpus } from '../index-builder/scan-corpus.js'
 import { scanHumanDocRecords } from '../index-builder/human-adapters/index.js'
 import { IndexNotFoundError, loadDocBridgeIndex } from '../query/load-index.js'
 
-export type GateId = 'index-freshness' | 'human-guide-links' | 'okf-type' | 'docs-style'
+export type GateId =
+  | 'index-freshness'
+  | 'human-guide-links'
+  | 'okf-type'
+  | 'docs-style'
+  | 'documentation-standard-v1'
 
-const SUPPORTED_GATES = ['index-freshness', 'human-guide-links', 'okf-type', 'docs-style'] as const
+const RESERVED_GATE_IDS = new Set(['link-rot', 'routing-currency', 'bootstrap-size'])
 
 export type GateResult = {
   readonly id: GateId
@@ -16,6 +25,7 @@ export type GateResult = {
   readonly message: string
   readonly expected?: string
   readonly actual?: string
+  readonly details?: DocumentationConformanceReportV1
 }
 
 export type GateRunResult = {
@@ -28,6 +38,19 @@ export const runGate = (
   config: DocBridgeConfigV1,
   id: GateId,
 ): GateResult => {
+  if (id === 'documentation-standard-v1') {
+    const details = runDocumentationStandardV1(root, config)
+    return {
+      id,
+      ok: details.ok,
+      message: details.ok
+        ? 'Documentation Standard v1 required rules pass'
+        : `${details.summary.required.failed} Documentation Standard v1 required rule(s) failed`,
+      expected: 'all required rules pass or have approved exceptions',
+      actual: `${details.summary.required.passed} passed, ${details.summary.required.failed} failed, ${details.summary.required.excepted} excepted`,
+      details,
+    }
+  }
   if (id === 'human-guide-links') return runHumanGuideLinksGate(root, config)
   if (id === 'okf-type') return runOkfTypeGate(root, config)
   if (id === 'docs-style') return runDocsStyleGate(root, config)
@@ -264,10 +287,16 @@ export const resolveGateIds = (config: DocBridgeConfigV1): GateId[] => {
   )
 
   for (const id of config.gates?.include ?? []) {
-    if (SUPPORTED_GATES.includes(id as GateId)) ids.add(id as GateId)
+    if (RESERVED_GATE_IDS.has(id)) {
+      process.emitWarning(`Gate "${id}" is reserved and has no runtime implementation; it was not executed.`, {
+        code: 'AK_DOCS_RESERVED_GATE',
+      })
+      continue
+    }
+    ids.add(id as GateId)
   }
   for (const id of config.gates?.exclude ?? []) {
-    if (SUPPORTED_GATES.includes(id as GateId)) ids.delete(id as GateId)
+    if (!RESERVED_GATE_IDS.has(id)) ids.delete(id as GateId)
   }
 
   return [...ids]

package/src/index-builder/human-adapters/core.ts

@@ -1,9 +1,10 @@
-import { readFileSync } from 'node:fs'
-import { join } from 'node:path'
+import { realpathSync } from 'node:fs'
+import { isAbsolute, relative, resolve, sep } from 'node:path'
 
 import type { HumanCorpusConfig } from '../../config/schema.js'
 import { slugFromPath } from '../../lib/markdown.js'
-import { toPosix } from '../../lib/paths.js'
+import { readBoundedText } from '../../lib/bounded-text.js'
+import { containedProjectPath, toPosix } from '../../lib/paths.js'
 import { walkFiles } from '../../lib/walk.js'
 
 export type HumanDocRecord = {
@@ -79,11 +80,17 @@ export const scanMarkdownDocs = (
   },
 ): HumanDocRecord[] => {
   const out: HumanDocRecord[] = []
-  const absRoot = join(root, humanRoot)
+  const projectRoot = realpathSync.native(resolve(root))
+  const absRoot = containedProjectPath(root, humanRoot)
+  if (!absRoot) return out
+  const budget = { used: 0 }
 
   for (const abs of walkFiles(absRoot, { extensions: ['.md', '.mdx'] })) {
+    const canonical = realpathSync.native(abs)
+    const fileRelative = relative(projectRoot, canonical)
+    if (isAbsolute(fileRelative) || fileRelative === '..' || fileRelative.startsWith(`..${sep}`)) continue
     const relToHumanRoot = toPosix(abs.replace(`${toPosix(absRoot)}/`, ''))
-    const raw = readFileSync(abs, 'utf8')
+    const raw = readBoundedText(abs, budget)
     if (options?.includeRelPath && !options.includeRelPath(relToHumanRoot, raw)) continue
     out.push({
       id: options?.idForDoc?.(relToHumanRoot, raw) ?? docId(relToHumanRoot, raw),

package/src/index-builder/human-adapters/docusaurus.ts

@@ -1,7 +1,8 @@
-import { existsSync, readFileSync } from 'node:fs'
-import { join } from 'node:path'
-import vm from 'node:vm'
+import { existsSync } from 'node:fs'
 
+import { readBoundedText } from '../../lib/bounded-text.js'
+import { containedProjectPath } from '../../lib/paths.js'
+import { parseStaticJsObject } from '../../lib/static-js-literal.js'
 import {
   optionString,
   parseFrontmatter,
@@ -43,48 +44,31 @@ const docusaurusRecordId = (relPath: string, raw: string): string => {
   return frontmatter.package ?? frontmatter.module ?? docusaurusSidebarId(relPath, raw)
 }
 
-const sidebarsValue = (file: string): unknown => {
-  if (!existsSync(file)) return undefined
-  const raw = readFileSync(file, 'utf8')
-    .replace(/import\s+type\s+[\s\S]*?;?\n/g, '')
-    .replace(/:\s*[A-Za-z0-9_.$<>{}\[\],\s]+(?=\s*=)/g, '')
-    .replace(/\s+satisfies\s+[A-Za-z0-9_.$<>{}\[\],\s]+(?=\s*(?:;|\n|$))/g, '')
-    .replace(/export\s+default/, 'module.exports =')
-  const sandbox = { module: { exports: {} as unknown }, exports: {} }
-  vm.runInNewContext(raw, sandbox, { timeout: 250 })
-  return sandbox.module.exports
-}
-
-const visitSidebar = (value: unknown, filter: { ids: Set<string>; autogenDirs: string[] }): void => {
-  if (typeof value === 'string') {
-    filter.ids.add(value)
-    return
-  }
-  if (Array.isArray(value)) {
-    for (const item of value) visitSidebar(item, filter)
-    return
-  }
-  if (!value || typeof value !== 'object') return
-
-  const item = value as Record<string, unknown>
-  if ((item.type === 'doc' || item.type === 'ref') && typeof item.id === 'string') {
-    filter.ids.add(item.id)
-  }
-  if (item.type === 'autogenerated' && typeof item.dirName === 'string') {
-    filter.autogenDirs.push(item.dirName)
-  }
-  if (Array.isArray(item.items)) visitSidebar(item.items, filter)
-  if (item.link && typeof item.link === 'object') visitSidebar(item.link, filter)
-  for (const child of Object.values(item)) {
-    if (Array.isArray(child)) visitSidebar(child, filter)
-  }
-}
-
-const readSidebars = (root: string, sidebarsFile: string | undefined): SidebarDocFilter => {
+const readSidebars = (sidebarsFile: string | undefined): SidebarDocFilter => {
   if (!sidebarsFile) return { enabled: false, ids: new Set(), autogenDirs: [] }
-  const value = sidebarsValue(join(root, sidebarsFile))
+  if (!existsSync(sidebarsFile)) return { enabled: false, ids: new Set(), autogenDirs: [] }
+  const raw = readBoundedText(sidebarsFile, { used: 0 }, { maxFileBytes: 1_048_576, maxCorpusBytes: 1_048_576 })
   const filter = { ids: new Set<string>(), autogenDirs: [] as string[] }
-  visitSidebar(value, filter)
+  const visit = (value: unknown): void => {
+    if (typeof value === 'string') {
+      filter.ids.add(value)
+      return
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) visit(item)
+      return
+    }
+    if (!value || typeof value !== 'object') return
+    const item = value as Record<string, unknown>
+    if ((item.type === 'doc' || item.type === 'ref') && typeof item.id === 'string') filter.ids.add(item.id)
+    if (item.type === 'autogenerated' && typeof item.dirName === 'string') filter.autogenDirs.push(item.dirName)
+    if (Array.isArray(item.items)) visit(item.items)
+    if (item.link && typeof item.link === 'object') visit(item.link)
+    for (const child of Object.values(item)) {
+      if (Array.isArray(child)) visit(child)
+    }
+  }
+  visit(parseStaticJsObject(raw))
   return { enabled: true, ...filter }
 }
 
@@ -102,7 +86,8 @@ export const docusaurusAdapter: HumanAdapter = {
   scan: ({ root, config }) => {
     const docsDir = optionString(config.options, ['docsDir', 'root'])
     if (!docsDir) return []
-    const sidebarFilter = readSidebars(root, optionString(config.options, ['sidebarsFile']))
+    const sidebarsFile = optionString(config.options, ['sidebarsFile'])
+    const sidebarFilter = readSidebars(sidebarsFile ? containedProjectPath(root, sidebarsFile) : undefined)
     return scanMarkdownDocs(root, docsDir, {
       includeRelPath: (relPath, raw) => isIncludedBySidebar(sidebarFilter, docusaurusSidebarId(relPath, raw)),
       idForDoc: docusaurusRecordId,

package/src/index-builder/human-adapters/index.ts

@@ -1,3 +1,6 @@
+import { realpathSync } from 'node:fs'
+import { resolve, sep } from 'node:path'
+
 import type { DocBridgeConfigV1, HumanCorpusConfig } from '../../config/schema.js'
 import { docusaurusAdapter } from './docusaurus.js'
 import { fumadocsAdapter } from './fumadocs.js'
@@ -18,22 +21,31 @@ const humanConfigs = (config: DocBridgeConfigV1): HumanCorpusConfig[] => {
   return Array.isArray(human) ? human : [human]
 }
 
+const canonicalPath = (path: string): string => {
+  try {
+    return realpathSync.native(path)
+  } catch {
+    return resolve(path)
+  }
+}
+
 export const scanHumanDocRecords = (
   root: string,
   config: DocBridgeConfigV1,
 ): HumanDocRecord[] => {
   const out: HumanDocRecord[] = []
   const seen = new Set<string>()
-  const agentRoot = config.corpus.agent.root.replace(/\/$/, '')
+  const agentRoot = canonicalPath(resolve(root, config.corpus.agent.root))
 
   for (const human of humanConfigs(config)) {
     const adapter = ADAPTERS.find((candidate) => candidate.plugin === human.plugin)
     if (!adapter) continue
     for (const record of adapter.scan({ root, config: human })) {
       // Never treat agent-corpus files as human docs (nested for-agents, etc.)
+      const recordPath = canonicalPath(record.path)
       if (
-        record.path === agentRoot ||
-        record.path.startsWith(`${agentRoot}/`) ||
+        recordPath === agentRoot ||
+        recordPath.startsWith(`${agentRoot}${sep}`) ||
         record.path.includes('/for-agents/') ||
         record.path.endsWith('/for-agents')
       ) {

package/src/index-builder/scan-corpus.ts

@@ -1,7 +1,5 @@
-import { readFileSync } from 'node:fs'
-import { join } from 'node:path'
-
 import type { DocBridgeConfigV1 } from '../config/schema.js'
+import { readBoundedText } from '../lib/bounded-text.js'
 import {
   extractSearchBody,
   firstHeading,
@@ -12,7 +10,7 @@ import {
   slugFromPath,
   type FrontmatterData,
 } from '../lib/markdown.js'
-import { toPosix } from '../lib/paths.js'
+import { containedProjectPath, toPosix } from '../lib/paths.js'
 import { walkFiles } from '../lib/walk.js'
 import type { KnowledgeEntry } from '../schemas/doc-bridge-index.js'
 
@@ -34,14 +32,16 @@ export type OwnershipSeed = {
 const relFromRoot = (root: string, abs: string): string => toPosix(abs.replace(`${toPosix(root)}/`, ''))
 
 export const scanAgentCorpus = (root: string, config: DocBridgeConfigV1): CorpusDoc[] => {
-  const agentRoot = join(root, config.corpus.agent.root)
+  const agentRoot = containedProjectPath(root, config.corpus.agent.root)
+  if (!agentRoot) throw new Error('Agent corpus root escapes the project root.')
   const files = walkFiles(agentRoot, { extensions: ['.md', '.mdx'] })
   const corpusRelRoot = toPosix(config.corpus.agent.root)
 
+  const budget = { used: 0 }
   return files.map((abs) => {
     const relToCorpus = toPosix(abs.replace(`${toPosix(agentRoot)}/`, ''))
     const relPath = `${corpusRelRoot}/${relToCorpus}`
-    const raw = readFileSync(abs, 'utf8')
+    const raw = readBoundedText(abs, budget)
     const { data: frontmatter } = parseFrontmatter(raw)
     const id =
       frontmatterString(frontmatter, 'id') ??

package/src/index.ts

@@ -9,8 +9,12 @@ export {
 } from './config/load-config.js'
 export {
   DocBridgeConfigV1Schema,
+  DocumentationStandardRuleIdSchema,
+  DocumentationStandardV1ConfigSchema,
+  EcosystemContractEvidenceSchema,
   type DocBridgeConfigV1,
   type AgentCorpusConfig,
+  type DocumentationStandardV1Config,
 } from './config/schema.js'
 
 export {
@@ -75,6 +79,19 @@ export {
   type GateResult,
   type GateRunResult,
 } from './gates/run-gates.js'
+export {
+  DOCUMENTATION_STANDARD_V1_ID,
+  DOCUMENTATION_STANDARD_V1_STATUS,
+  formatDocumentationStandardText,
+  runDocumentationStandardV1,
+  type DocumentationConformanceReportV1,
+  type DocumentationStandardEvidence,
+  type DocumentationStandardRemediation,
+  type DocumentationStandardRuleId,
+  type DocumentationStandardRuleLevel,
+  type DocumentationStandardRuleResult,
+  type DocumentationStandardRuleStatus,
+} from './conformance/documentation-standard-v1.js'
 export { MCP_TOOLS, handleMcpRequest, startMcpStdioServer } from './mcp/server.js'
 export { installMcpConfig, mcpSnippet, type McpInstallResult, type McpInstallTarget } from './mcp/install.js'
 export { runDoctor, formatDoctorText, type DoctorReport, type DoctorIssue, type DoctorCoverage } from './doctor/run-doctor.js'

package/src/lib/bounded-text.ts

@@ -0,0 +1,25 @@
+import { readFileSync, statSync } from 'node:fs'
+
+export const MAX_DOCUMENT_BYTES = 4 * 1_024 * 1_024
+export const MAX_CORPUS_BYTES = 64 * 1_024 * 1_024
+
+export type TextReadBudget = { used: number }
+
+export const readBoundedText = (
+  path: string,
+  budget: TextReadBudget,
+  limits?: { readonly maxFileBytes?: number; readonly maxCorpusBytes?: number },
+): string => {
+  const maxFileBytes = limits?.maxFileBytes ?? MAX_DOCUMENT_BYTES
+  const maxCorpusBytes = limits?.maxCorpusBytes ?? MAX_CORPUS_BYTES
+  const stat = statSync(path)
+  if (!stat.isFile()) throw new Error(`Documentation path is not a regular file: ${path}`)
+  if (stat.size > maxFileBytes) {
+    throw new Error(`Documentation file exceeds the ${maxFileBytes} byte limit: ${path}`)
+  }
+  if (budget.used + stat.size > maxCorpusBytes) {
+    throw new Error(`Documentation corpus exceeds the ${maxCorpusBytes} byte read budget.`)
+  }
+  budget.used += stat.size
+  return readFileSync(path, 'utf8')
+}

package/src/lib/paths.ts

@@ -1,6 +1,24 @@
-import { resolve } from 'node:path'
+import { existsSync, realpathSync } from 'node:fs'
+import { isAbsolute, relative, resolve, sep } from 'node:path'
 
 export const toPosix = (value: string): string => value.split('\\').join('/')
 
 export const resolveFromRoot = (root: string, rel: string): string =>
-  resolve(root, rel)
+  resolve(root, rel)
+
+export const containedProjectPath = (root: string, path: string): string | undefined => {
+  const projectRoot = realpathSync.native(resolve(root))
+  const unresolved = resolve(projectRoot, path)
+  const unresolvedRelative = relative(projectRoot, unresolved)
+  if (
+    isAbsolute(unresolvedRelative) ||
+    unresolvedRelative === '..' ||
+    unresolvedRelative.startsWith(`..${sep}`)
+  ) return undefined
+
+  const canonical = existsSync(unresolved) ? realpathSync.native(unresolved) : unresolved
+  const canonicalRelative = relative(projectRoot, canonical)
+  return isAbsolute(canonicalRelative) || canonicalRelative === '..' || canonicalRelative.startsWith(`..${sep}`)
+    ? undefined
+    : canonical
+}

package/src/lib/static-js-literal.ts

@@ -0,0 +1,261 @@
+const stripComments = (source: string): string => {
+  let out = ''
+  let index = 0
+  let quote: string | undefined
+  while (index < source.length) {
+    const char = source[index] ?? ''
+    const next = source[index + 1] ?? ''
+    if (quote) {
+      out += char
+      if (char === '\\') {
+        out += next
+        index += 2
+        continue
+      }
+      if (char === quote) quote = undefined
+      index += 1
+      continue
+    }
+    if (char === '"' || char === "'" || char === '`') {
+      quote = char
+      out += char
+      index += 1
+      continue
+    }
+    if (char === '/' && next === '/') {
+      while (index < source.length && source[index] !== '\n') index += 1
+      out += '\n'
+      index += 1
+      continue
+    }
+    if (char === '/' && next === '*') {
+      index += 2
+      while (index < source.length && !(source[index] === '*' && source[index + 1] === '/')) index += 1
+      index += 2
+      out += ' '
+      continue
+    }
+    out += char
+    index += 1
+  }
+  if (quote) throw new Error('Unterminated string in static JavaScript literal.')
+  return out
+}
+
+class LiteralParser {
+  private index = 0
+
+  constructor(private readonly source: string) {}
+
+  parseAt(index: number): unknown {
+    this.index = index
+    const value = this.value()
+    this.space()
+    return value
+  }
+
+  private space(): void {
+    while (/\s/.test(this.source[this.index] ?? '')) this.index += 1
+  }
+
+  private value(): unknown {
+    this.space()
+    const char = this.source[this.index]
+    if (char === '{') return this.object()
+    if (char === '[') return this.array()
+    if (char === '"' || char === "'") return this.string()
+    const word = this.word()
+    if (word === 'true') return true
+    if (word === 'false') return false
+    if (word === 'null') return null
+    if (/^-?\d+(?:\.\d+)?$/.test(word)) return Number(word)
+    throw new Error(`Unsupported dynamic sidebar expression near "${word || char || 'EOF'}".`)
+  }
+
+  private object(): Record<string, unknown> {
+    const result: Record<string, unknown> = {}
+    this.index += 1
+    this.space()
+    while (this.source[this.index] !== '}') {
+      const key = this.source[this.index] === '"' || this.source[this.index] === "'" ? this.string() : this.word()
+      if (!key) throw new Error('Static sidebar object key is required.')
+      this.space()
+      if (this.source[this.index] !== ':') throw new Error(`Static sidebar key "${key}" requires a literal value.`)
+      this.index += 1
+      result[key] = this.value()
+      this.space()
+      if (this.source[this.index] === ',') {
+        this.index += 1
+        this.space()
+        continue
+      }
+      if (this.source[this.index] !== '}') throw new Error('Expected comma or closing brace in static sidebar.')
+    }
+    this.index += 1
+    return result
+  }
+
+  private array(): unknown[] {
+    const result: unknown[] = []
+    this.index += 1
+    this.space()
+    while (this.source[this.index] !== ']') {
+      result.push(this.value())
+      this.space()
+      if (this.source[this.index] === ',') {
+        this.index += 1
+        this.space()
+        continue
+      }
+      if (this.source[this.index] !== ']') throw new Error('Expected comma or closing bracket in static sidebar.')
+    }
+    this.index += 1
+    return result
+  }
+
+  private string(): string {
+    const quote = this.source[this.index] ?? ''
+    this.index += 1
+    let result = ''
+    while (this.index < this.source.length) {
+      const char = this.source[this.index] ?? ''
+      if (char === quote) {
+        this.index += 1
+        return result
+      }
+      if (char === '\\') {
+        const escaped = this.source[this.index + 1]
+        if (escaped === undefined) break
+        const escapes: Record<string, string> = { n: '\n', r: '\r', t: '\t' }
+        result += escapes[escaped] ?? escaped
+        this.index += 2
+        continue
+      }
+      result += char
+      this.index += 1
+    }
+    throw new Error('Unterminated string in static sidebar.')
+  }
+
+  private word(): string {
+    this.space()
+    const start = this.index
+    while (/[A-Za-z0-9_$.-]/.test(this.source[this.index] ?? '')) this.index += 1
+    return this.source.slice(start, this.index)
+  }
+}
+
+const maskStrings = (source: string): string => {
+  const chars = [...source]
+  let quote: string | undefined
+  let previousToken: string | undefined
+  const regexPrefixKeywords = new Set([
+    'await', 'case', 'delete', 'do', 'else', 'in', 'instanceof', 'new',
+    'of', 'return', 'throw', 'typeof', 'void', 'yield',
+  ])
+  const canStartRegex = (): boolean => previousToken === undefined
+    || '=(:,[!&|?{};'.includes(previousToken)
+    || previousToken === '=>'
+    || regexPrefixKeywords.has(previousToken)
+  for (let index = 0; index < chars.length; index += 1) {
+    const char = chars[index] ?? ''
+    if (quote) {
+      chars[index] = ' '
+      if (char === '\\') {
+        if (index + 1 < chars.length) chars[index + 1] = ' '
+        index += 1
+      } else if (char === quote) {
+        quote = undefined
+        previousToken = 'literal'
+      }
+      continue
+    }
+    if (char === '"' || char === "'" || char === '`') {
+      quote = char
+      chars[index] = ' '
+      continue
+    }
+    if (char === '/' && canStartRegex()) {
+      chars[index] = ' '
+      let inClass = false
+      for (index += 1; index < chars.length; index += 1) {
+        const regexChar = chars[index] ?? ''
+        chars[index] = ' '
+        if (regexChar === '\\') {
+          if (index + 1 < chars.length) chars[index + 1] = ' '
+          index += 1
+        } else if (regexChar === '[') {
+          inClass = true
+        } else if (regexChar === ']') {
+          inClass = false
+        } else if (regexChar === '/' && !inClass) {
+          while (/[A-Za-z]/.test(chars[index + 1] ?? '')) {
+            index += 1
+            chars[index] = ' '
+          }
+          break
+        }
+      }
+      previousToken = 'literal'
+      continue
+    }
+    if (/[A-Za-z_$]/.test(char)) {
+      const start = index
+      while (/[A-Za-z0-9_$]/.test(chars[index + 1] ?? '')) index += 1
+      previousToken = chars.slice(start, index + 1).join('')
+      continue
+    }
+    if (char === '=' && chars[index + 1] === '>') {
+      previousToken = '=>'
+      index += 1
+      continue
+    }
+    if (!/\s/.test(char)) previousToken = char
+  }
+  return chars.join('')
+}
+
+const nonSpace = (source: string, start: number): number => {
+  let index = start
+  while (/\s/.test(source[index] ?? '')) index += 1
+  return index
+}
+
+const escapedRegex = (value: string): string => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+
+export const parseStaticJsObject = (source: string): unknown => {
+  const clean = stripComments(source)
+  const mask = maskStrings(clean)
+  const parseBinding = (identifier: string): unknown => {
+    const declaration = new RegExp(`\\b(?:const|let|var)\\s+${escapedRegex(identifier)}(?:\\s*:[^=;]+)?\\s*=`).exec(mask)
+    if (!declaration) throw new Error(`Exported binding "${identifier}" must reference a static object declaration.`)
+    const start = nonSpace(mask, declaration.index + declaration[0].length)
+    if (mask[start] !== '{') throw new Error(`Exported binding "${identifier}" must be a static object literal.`)
+    return new LiteralParser(clean).parseAt(start)
+  }
+  const commonJs = /\bmodule\.exports\s*=/.exec(mask)
+  if (commonJs) {
+    const start = nonSpace(mask, commonJs.index + commonJs[0].length)
+    if (mask[start] === '{') return new LiteralParser(clean).parseAt(start)
+    const identifier = /^[A-Za-z_$][\w$]*/.exec(mask.slice(start))?.[0]
+    if (identifier) return parseBinding(identifier)
+    throw new Error('module.exports must be assigned a static object literal or binding.')
+  }
+
+  const exported = /\bexport\s+default\b/.exec(mask)
+  if (exported) {
+    let start = nonSpace(mask, exported.index + exported[0].length)
+    if (mask.slice(start).startsWith('defineConfig')) {
+      start = nonSpace(mask, start + 'defineConfig'.length)
+      if (mask[start] !== '(') throw new Error('defineConfig must be called with a static object literal.')
+      start = nonSpace(mask, start + 1)
+      if (mask[start] !== '{') throw new Error('defineConfig must be called with a static object literal.')
+      return new LiteralParser(clean).parseAt(start)
+    }
+    if (mask[start] === '{') return new LiteralParser(clean).parseAt(start)
+
+    const identifier = /^[A-Za-z_$][\w$]*/.exec(mask.slice(start))?.[0]
+    if (identifier) return parseBinding(identifier)
+  }
+  throw new Error('Docusaurus sidebar must export a static object or assign one to a const.')
+}