@lincyaw/compiler 1.0.0-rc.0 → 1.0.0-rc.10

package/src/export.ts

@@ -0,0 +1,49 @@
+import { rm } from 'node:fs/promises'
+import { join } from 'node:path'
+import type { ExportOutput } from '@lincyaw/kernel'
+import { build } from './build.ts'
+import type { Compilation } from './compiler.ts'
+import { documentExporters } from './renderers.ts'
+
+// Below the export's directory: the builds its exporter asks for, removed once it is done.
+const BUILDS = '.build'
+
+export interface ExportOptions {
+  /** An empty directory for the files. */
+  outDir: string
+  /** What the one who asked chose (`ExportContext.options`). */
+  options?: Record<string, unknown>
+  signal?: AbortSignal
+  progress?(phase: string, done?: number, total?: number): void
+  log?(line: string): void
+}
+
+/** Makes the document's export `id` (a plugin's exporter: the slides as a PDF, the lecture as a video) into `outDir`. */
+export async function exportDocument(compilation: Compilation, id: string, options: ExportOptions): Promise<ExportOutput> {
+  const found = (await documentExporters(compilation)).find(({ exporter }) => exporter.id === id)
+  if (!found) throw new Error(`no plugin of the document exports ${id}`)
+  const builds = join(options.outDir, BUILDS)
+  try {
+    return await found.exporter.run({
+      deckDir: compilation.deckDir,
+      workspaceRoot: compilation.workspaceRoot,
+      source: compilation.doc.source,
+      config: found.config,
+      outDir: options.outDir,
+      signal: options.signal ?? new AbortController().signal,
+      progress: options.progress ?? (() => {}),
+      log: options.log ?? (() => {}),
+      options: options.options ?? {},
+      async build(renderer, config = {}) {
+        const { renderers } = compilation.doc.config
+        const configured = { ...compilation, doc: { ...compilation.doc, config: { ...compilation.doc.config, renderers: { ...renderers, [renderer]: { ...renderers[renderer], ...config } } } } }
+        const report = await build(configured, { outDir: join(builds, renderer), to: [renderer], base: '/', ...options.log ? { log: options.log } : {} })
+        const own = report.outputs.find(output => output.renderer === renderer)
+        if (!own) throw new Error(report.findings.filter(f => f.severity === 'error').map(f => f.message).join('; ') || `the ${renderer} renderer made nothing`)
+        return own.outDir
+      },
+    })
+  } finally {
+    await rm(builds, { recursive: true, force: true })
+  }
+}

package/src/forbid.ts

@@ -1,8 +1,8 @@
-import { irBlocks, isRecord, mdastText } from '@lincyaw/kernel'
+import { irBlocks, isRecord, mdastText, propText } from '@lincyaw/kernel'
 import type { Finding, IRBlock, MdastNode, SourcePos } from '@lincyaw/kernel'
-import { lineFinder } from './links.ts'
 import type { PublishInput } from './links.ts'
-import { viewFor } from './renderers.ts'
+import { lineFinder } from './source-lines.ts'
+import { viewFor } from './views.ts'
 
 export function checkForbidden(input: PublishInput, headmatter: Record<string, unknown>): Finding[] {
   const given = isRecord(headmatter.checks) ? headmatter.checks.forbid : undefined
@@ -27,7 +27,7 @@ export function checkForbidden(input: PublishInput, headmatter: Record<string, u
     const view = viewFor(input.doc, renderer)
     const texts = view.sections.flatMap(section => [
       { source: section.source, text: section.title },
-      ...[...irBlocks(section.blocks)].map(block => ({ source: block.source, text: blockText(block) })),
+      ...[...irBlocks(section.blocks)].map(block => ({ source: block.source, text: searchableText(block) })),
     ])
     for (const { source, text } of texts) {
       for (const { text: name, pattern } of patterns) {
@@ -52,7 +52,8 @@ export function checkForbidden(input: PublishInput, headmatter: Record<string, u
   return findings
 }
 
-function blockText(block: IRBlock): string {
+/** What checks.forbid searches in a block: its text with link targets, every code variant and the recorded output. */
+function searchableText(block: IRBlock): string {
   const { node } = block
   switch (node.type) {
     case 'markdown': return `${mdastText(node.mdast)}\n${targets(node.mdast).join('\n')}`
@@ -73,10 +74,3 @@ function outputText(run: NonNullable<Extract<IRBlock['node'], { type: 'code' }>[
     return Object.entries(output.data).flatMap(([type, value]) => (type.startsWith('text/') || type === 'application/json' ? propText(value) : []))
   })]
 }
-
-function propText(value: unknown): string[] {
-  if (typeof value === 'string') return [value]
-  if (Array.isArray(value)) return value.flatMap(propText)
-  if (value && typeof value === 'object') return Object.values(value).flatMap(propText)
-  return []
-}

package/src/frontmatter.ts

@@ -0,0 +1,16 @@
+import { isRecord } from '@lincyaw/kernel'
+import { parse as parseYaml } from 'yaml'
+
+export function withoutBom(text: string): string {
+  return text.charCodeAt(0) === 0xFEFF ? text.slice(1) : text
+}
+
+export function parseFrontmatter(text: string): Record<string, unknown> {
+  const match = /^---[ \t]*\r?\n(?:([\s\S]*?)\r?\n)?---[ \t]*(?:\r?\n|$)/.exec(withoutBom(text))
+  try {
+    const data: unknown = match ? parseYaml(match[1] ?? '') : {}
+    return isRecord(data) ? data : {}
+  } catch {
+    return {}
+  }
+}

package/src/index.ts

@@ -1,20 +1,30 @@
-export { audienceView } from './audience.ts'
-export { Compiler, DECK_ENTRY, frontmatterLine, resolveEntry, sortFindings, workspacePlugins } from './compiler.ts'
-export type { Compilation, CompilerOptions } from './compiler.ts'
+export { directoryAsset, fileHash, publishesDirectory } from './assets.ts'
+export { availableRenderers, build } from './build.ts'
+export type { BuildOptions, BuildReport } from './build.ts'
+export { buildSummary, buildToDist, checkContext, runBlock } from './compilation-actions.ts'
+export { Compiler, DECK_ENTRY, resolveEntry, sortFindings, workspacePlugins } from './compiler.ts'
+export type { Compilation, CompileOptions, CompilerOptions, DocumentNodeServices } from './compiler.ts'
+export { dev } from './dev.ts'
+export type { DevOptions, DevServers } from './dev.ts'
 export { BUILTIN_DIRECTIVE_INFO, COMMON_DIRECTIVE_OPTIONS, RUN_OPTION } from './directives.ts'
 export type { DirectiveInfo, DirectiveOptionInfo } from './directives.ts'
 export type { RunStats } from './execute.ts'
-export { buildView, checkContext, runBlock } from './host.ts'
+export type { GitRead } from './inputs.ts'
+export { pluginLogger } from './logging.ts'
+export { parseFrontmatter } from './frontmatter.ts'
 export { portable, relativeIR } from './paths.ts'
 export { findPackageDir, loadPlugins, pluginId } from './plugins.ts'
 export type { LoadedPlugin, PluginProblem, PluginSources } from './plugins.ts'
-export { directoryAsset, fileHash, inside, lineOf, publishesDirectory } from './published.ts'
-export { build, dev, prepare, viewFor } from './renderers.ts'
-export type { BuildOptions, BuildReport } from './renderers.ts'
+export { exportDocument } from './export.ts'
+export type { ExportOptions } from './export.ts'
+export { documentExporters, nodeVitePlugins } from './renderers.ts'
+export type { DocumentExporter } from './renderers.ts'
 export { playwrightChromium, serveDirectory } from './serve.ts'
+export type { ServeDirectoryOptions } from './serve.ts'
 export type { ServedExtra, StaticServer } from './serve.ts'
-export { operatorDir, operatorPlugins, pluginLogger, WORKSPACE_CONFIG, workspaceSettings } from './settings.ts'
-export type { OperatorSettings } from './settings.ts'
-export { readFrontmatter } from './source.ts'
-export { compileTranslations } from './translations.ts'
+export { frontmatterLine, lineContaining } from './source-lines.ts'
+export { compileTranslations, documentDigest } from './translations.ts'
 export type { CompiledTranslation } from './translations.ts'
+export { viewFor } from './views.ts'
+export { operatorDir, WORKSPACE_CONFIG, workspaceSettings } from './workspace-settings.ts'
+export type { OperatorSettings } from './workspace-settings.ts'

package/src/{dependencies.ts → inputs.ts}

@@ -3,22 +3,24 @@ import { existsSync } from 'node:fs'
 import { dirname, resolve } from 'node:path'
 import { promisify } from 'node:util'
 import type { AnchorResolverRegistry, SourceReader } from '@lincyaw/kernel'
-import { COMMIT } from './workspace.ts'
+import { COMMIT_HASH } from './workspace.ts'
 
 export type CommittedFiles = Map<string, string>
 
 const run = promisify(execFile)
 
-export interface Revision {
+/** A file the compilation read at a git ref rather than from the working tree. */
+export interface GitRead {
   file: string
-  rev: string
+  ref: string
 }
 
-export class Dependencies {
+/** The files and git refs a compilation read besides its sources, to watch for changes. */
+export class CompileInputs {
   readonly #root: string
   readonly #committed: CommittedFiles
   readonly #files = new Set<string>()
-  readonly #revisions = new Map<string, Revision>()
+  readonly #gitReads = new Map<string, GitRead>()
 
   constructor(root: string, committed: CommittedFiles = new Map()) {
     this.#root = root
@@ -29,8 +31,8 @@ export class Dependencies {
     return [...this.#files]
   }
 
-  get revisions(): Revision[] {
-    return [...this.#revisions.values()]
+  get gitReads(): GitRead[] {
+    return [...this.#gitReads.values()]
   }
 
   watch(...files: string[]): void {
@@ -46,11 +48,11 @@ export class Dependencies {
           return src.read(file, ref)
         }
         const key = `${path}\0${ref}`
-        this.#revisions.set(key, { file: path, rev: ref })
+        this.#gitReads.set(key, { file: path, ref })
         const known = this.#committed.get(key)
         if (known !== undefined) return known
         const text = await src.read(file, ref)
-        if (text !== undefined && COMMIT.test(ref)) this.#committed.set(key, text)
+        if (text !== undefined && COMMIT_HASH.test(ref)) this.#committed.set(key, text)
         return text
       },
     }
@@ -65,12 +67,19 @@ export class Dependencies {
   }
 }
 
-export async function revisionFiles(dir: string, revs: Iterable<string>): Promise<string[]> {
+/** The files of git's own state that change when one of the refs that were read moves. */
+export async function gitReadFiles(reads: readonly GitRead[]): Promise<string[]> {
+  const refs = new Map<string, Set<string>>()
+  for (const { file, ref } of reads) refs.set(dirname(file), (refs.get(dirname(file)) ?? new Set<string>()).add(ref))
+  return (await Promise.all([...refs].map(([dir, names]) => gitRefFiles(dir, names)))).flat()
+}
+
+async function gitRefFiles(dir: string, refs: Iterable<string>): Promise<string[]> {
   let cwd = dir
   while (!existsSync(cwd) && dirname(cwd) !== cwd) cwd = dirname(cwd)
   const git = (args: string[]) => run('git', args, { cwd }).then(({ stdout }) => stdout.split('\n').filter(Boolean), () => [])
-  const names = new Set(['HEAD', ...[...revs].filter(rev => !rev.startsWith('-') && !COMMIT.test(rev))])
-  const refs = await Promise.all([...names].map(name => git(['rev-parse', '--symbolic-full-name', name])))
-  const files = new Set(['HEAD', 'packed-refs', ...refs.flat()])
+  const names = new Set(['HEAD', ...[...refs].filter(ref => !ref.startsWith('-') && !COMMIT_HASH.test(ref))])
+  const full = await Promise.all([...names].map(name => git(['rev-parse', '--symbolic-full-name', name])))
+  const files = new Set(['HEAD', 'packed-refs', ...full.flat()])
   return (await git(['rev-parse', ...[...files].flatMap(name => ['--git-path', name])])).map(path => resolve(cwd, path))
 }

package/src/links.ts

@@ -1,13 +1,15 @@
 import { execFile, spawnSync } from 'node:child_process'
 import { existsSync, readFileSync, statSync } from 'node:fs'
-import { basename, dirname, extname, join, relative, resolve, sep } from 'node:path'
-import { htmlAttributes, irBlocks, isRecord } from '@lincyaw/kernel'
+import { basename, dirname, join, relative, resolve, sep } from 'node:path'
+import { ABSOLUTE_URL, DOCUMENT_ENTRY, htmlAttributes, irBlocks, isRecord, validateDocument } from '@lincyaw/kernel'
 import type { Finding, IRBlock, IRDocument, MdastNode, SourcePos } from '@lincyaw/kernel'
-import { BUILTIN_DIRECTIVES } from './blocks.ts'
-import { inside, publishesDirectory, unpublishedDirectory } from './published.ts'
-import { viewFor } from './renderers.ts'
-import { plainText, slugify, splitSections } from './sections.ts'
-import { Parser, readFrontmatter } from './source.ts'
+import { isInside } from '@lincyaw/kernel/node'
+import { publishesDirectory, unpublishedDirectory } from './assets.ts'
+import { lowerDocument } from './document-lowering.ts'
+import { plainText, sectionSlug } from './sections.ts'
+import { lineFinder } from './source-lines.ts'
+import type { LineFinder } from './source-lines.ts'
+import { viewFor } from './views.ts'
 
 export interface PublishInput {
   doc: IRDocument
@@ -17,7 +19,6 @@ export interface PublishInput {
   renderers: string[]
 }
 
-const REMOTE = /^(?:[a-z][a-z\d+.-]*:|\/\/)/i
 const EXTERNAL = /^https?:\/\//i
 const URL_ATTRIBUTES = new Set(['href', 'src', 'poster'])
 const ID_ATTRIBUTES = new Set(['id', 'name'])
@@ -79,30 +80,31 @@ function blockUrls(block: IRBlock): string[] {
   if (node.type === 'component') {
     if (node.fallback) walk(node.fallback)
     for (const url of Object.values(node.assets ?? {})) urls.push(url)
+    for (const state of block.stepStates ?? []) for (const url of Object.values(state.assets ?? {})) urls.push(url)
   }
   return urls.map(url => url.trim()).filter(Boolean)
 }
 
 async function linkProblem(url: string, source: SourcePos, input: PublishInput, anchors: Set<string>, documents: Map<string, Promise<Set<string>>>): Promise<string | undefined> {
-  if (REMOTE.test(url)) return undefined
+  if (ABSOLUTE_URL.test(url)) return undefined
   const hash = url.indexOf('#')
   const fragment = hash < 0 ? '' : decode(url.slice(hash + 1))
   const path = decode((hash < 0 ? url : url.slice(0, hash)).replace(/\?.*$/s, ''))
   if (!path) return fragment && !anchors.has(fragment) ? `#${fragment} is no section, block, label or heading of the deck` : undefined
   const file = path.startsWith('/') ? join(input.deckDir, 'public', path) : resolve(dirname(source.file), path)
-  if (!inside(file, input.workspaceRoot)) return `${path} lies outside the repository: it cannot be published`
+  if (!isInside(file, input.workspaceRoot)) return `${path} lies outside the repository: it cannot be published`
   if (!existsSync(file)) return `${path}: no such file`
   const hidden = publishesDirectory(file, input.deckDir) ? unpublishedDirectory(file, input.deckDir) : undefined
   if (hidden) return `${path}: ${hidden}`
   if (!fragment) return undefined
-  const entry = statSync(file).isDirectory() ? join(file, 'lecture.md') : file
-  if (extname(entry) !== '.md' || !existsSync(entry)) return undefined
+  const entry = statSync(file).isDirectory() ? join(file, DOCUMENT_ENTRY) : file
+  if (basename(entry) !== DOCUMENT_ENTRY || !existsSync(entry)) return undefined
   if (entry === input.entry) return anchors.has(fragment) ? undefined : `${path}#${fragment}: #${fragment} is no section, block, label or heading of the deck`
   if (!documents.has(entry)) documents.set(entry, sourceAnchors(entry))
   return (await documents.get(entry)!).has(fragment) ? undefined : `${path}#${fragment}: no section, block, label or heading of ${relative(input.workspaceRoot, entry).split(sep).join('/')} has the id ${fragment}`
 }
 
-function documentAnchors(doc: IRDocument): Set<string> {
+function documentAnchors(doc: Pick<IRDocument, 'sections'>): Set<string> {
   const anchors = new Set<string>()
   for (const section of doc.sections) {
     anchors.add(section.id)
@@ -119,7 +121,7 @@ function documentAnchors(doc: IRDocument): Set<string> {
 function mdastAnchors(node: MdastNode, anchors: Set<string>): void {
   for (const key of ['identifier', 'label', 'html_id'] as const) if (typeof node[key] === 'string' && node[key]) anchors.add(node[key] as string)
   if (node.type === 'footnoteDefinition' && typeof node.identifier === 'string') anchors.add(`fn-${node.identifier}`)
-  if (node.type === 'heading') anchors.add(slugify(plainText(node)))
+  if (node.type === 'heading') anchors.add(sectionSlug(plainText(node)))
   if (node.type === 'mystDirective' && isRecord(node.options) && typeof node.options.label === 'string') anchors.add(node.options.label)
   if (node.type === 'html' && typeof node.value === 'string') {
     for (const { value } of htmlAttributes(node.value, ID_ATTRIBUTES)) if (value) anchors.add(value)
@@ -128,19 +130,14 @@ function mdastAnchors(node: MdastNode, anchors: Set<string>): void {
 }
 
 async function sourceAnchors(entry: string): Promise<Set<string>> {
-  const anchors = new Set<string>()
   try {
-    const parser = new Parser(new Map([...BUILTIN_DIRECTIVES]))
-    const { children } = await parser.expand(entry)
-    const text = readFileSync(entry, 'utf8')
-    const headmatter = readFrontmatter(text)
-    const depth = Number.isInteger(headmatter.sectionDepth) && (headmatter.sectionDepth as number) >= 1 ? headmatter.sectionDepth as number : 2
-    const title = typeof headmatter.title === 'string' ? headmatter.title : basename(dirname(entry))
-    for (const section of splitSections(children, { entry, title, sectionDepth: depth }, () => {})) anchors.add(section.id)
-    for (const node of children) mdastAnchors(node, anchors)
+    const checked = validateDocument(JSON.parse(readFileSync(entry, 'utf8').replace(/^\uFEFF/, '')))
+    if (!checked.document) return new Set()
+    const sections = lowerDocument(checked.document, entry, dirname(entry), () => {}, () => {})
+    return documentAnchors({ sections })
   } catch {
+    return new Set()
   }
-  return anchors
 }
 
 async function externalLinks(urls: Map<string, SourcePos>, entry: string, line: LineFinder): Promise<Finding[]> {
@@ -173,27 +170,6 @@ function needles(url: string): string[] {
   return [...new Set([url, decode(url)])]
 }
 
-export type LineFinder = (source: SourcePos, needles: string[]) => number
-
-export function lineFinder(): LineFinder {
-  const files = new Map<string, string[]>()
-  return (source, needles) => {
-    let lines = files.get(source.file)
-    if (!lines) {
-      try {
-        lines = readFileSync(source.file, 'utf8').split(/\r?\n/)
-      } catch {
-        lines = []
-      }
-      files.set(source.file, lines)
-    }
-    for (let line = source.line; line <= Math.min(source.endLine ?? source.line, lines.length); line++) {
-      if (needles.some(needle => needle && lines[line - 1]!.includes(needle))) return line
-    }
-    return source.line
-  }
-}
-
 function decode(text: string): string {
   try {
     return decodeURIComponent(text)

package/src/logging.ts

@@ -0,0 +1,16 @@
+import { prefixedLogger } from '@lincyaw/kernel'
+import type { Logger } from '@lincyaw/kernel'
+
+const STDERR: Logger = {
+  debug: (...args) => {
+    if (process.env.PRESMIUM_DEBUG) console.error(...args)
+  },
+  info: (...args) => console.error(...args),
+  warn: (...args) => console.error(...args),
+  error: (...args) => console.error(...args),
+}
+
+/** A plugin's logger in Node: everything on stderr, debug only with PRESMIUM_DEBUG, tagged with the plugin's ID. */
+export function pluginLogger(id: string): Logger {
+  return prefixedLogger(STDERR, id)
+}

package/src/node-services.ts

@@ -0,0 +1,33 @@
+import { ServiceRegistry } from '@lincyaw/kernel'
+import type { ServiceToken } from '@lincyaw/kernel'
+
+/** The Node services of one compilation: the host's, then each plugin's; a later plugin cannot replace a service. */
+export class NodeServices {
+  readonly #registry = new ServiceRegistry()
+
+  constructor(host: [ServiceToken<unknown>, unknown][] = []) {
+    const latest = new Map(host.map(entry => [entry[0].id, entry]))
+    for (const [token, implementation] of latest.values()) this.#registry.provide(token, implementation)
+  }
+
+  add(owner: string, entries: [ServiceToken<unknown>, unknown][]): string[] {
+    const problems: string[] = []
+    for (const [token, implementation] of entries) {
+      if (!token || typeof token.id !== 'string') {
+        problems.push(`plugin ${owner}: services() gave an entry without a service token`)
+        continue
+      }
+      const known = this.#registry.owner(token)
+      if (known !== undefined) {
+        problems.push(`plugin ${owner}: ${token.id} is already provided by ${known}; this implementation is ignored`)
+        continue
+      }
+      this.#registry.provide(token, implementation, owner)
+    }
+    return problems
+  }
+
+  tryGet<T>(token: ServiceToken<T>): T | undefined {
+    return this.#registry.tryGet(token)
+  }
+}

package/src/paths.ts

@@ -1,23 +1,19 @@
-import { existsSync, statSync } from 'node:fs'
-import { basename, dirname, isAbsolute, join, relative, resolve, sep } from 'node:path'
-import { irBlocks } from '@lincyaw/kernel'
+import { isAbsolute, relative, sep } from 'node:path'
+import { DOCUMENT_ENTRY, irBlocks } from '@lincyaw/kernel'
 import type { IRDocument, SourcePos } from '@lincyaw/kernel'
-import { fileHash } from './published.ts'
+import { isInside } from '@lincyaw/kernel/node'
 
-const REMOTE = /^(?:[a-z][a-z\d+.-]*:|\/\/|#)/i
+export const DECK_ENTRY = DOCUMENT_ENTRY
 
-function inRepository(path: string, root: string): boolean {
-  if (!isAbsolute(path)) return false
-  const rel = relative(root, path)
-  return rel !== '..' && !rel.startsWith(`..${sep}`) && !isAbsolute(rel)
-}
+/** The deck's directory of generated files: renderer work directories, staged files, caches. */
+export const WORK_DIR = '.presmium'
 
 function relativePath(from: string, path: string): string {
   return relative(from, path).split(sep).join('/') || '.'
 }
 
 export function portable(value: unknown, from: string, root: string): unknown {
-  if (typeof value === 'string') return inRepository(value, root) ? relativePath(from, value) : value
+  if (typeof value === 'string') return isAbsolute(value) && isInside(value, root) ? relativePath(from, value) : value
   if (Array.isArray(value)) return value.map(item => portable(item, from, root))
   if (value !== null && typeof value === 'object') return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, portable(item, from, root)]))
   return value
@@ -33,24 +29,14 @@ export function relativeIR(doc: IRDocument, deckDir: string, workspaceRoot: stri
   for (const section of copy.sections) {
     source(section.source)
     if (section.config) section.config = portable(section.config, deckDir, workspaceRoot) as typeof section.config
-    for (const block of irBlocks(section.blocks)) source(block.source)
+    for (const block of irBlocks(section.blocks)) {
+      source(block.source)
+      if (block.node.type === 'component' && block.node.definition && isAbsolute(block.node.definition.file))
+        block.node.definition.file = relativePath(deckDir, block.node.definition.file)
+    }
   }
   for (const finding of copy.diagnostics) {
     if (finding.source) source(finding.source as SourcePos)
   }
   return copy
 }
-
-export function localAsset(deckDir: string, source: SourcePos, url: string): { file: string, name: string } | undefined {
-  if (REMOTE.test(url)) return undefined
-  const path = url.replace(/[?#].*$/s, '')
-  if (!path) return undefined
-  let name = path
-  try {
-    name = decodeURIComponent(path)
-  } catch {
-  }
-  const file = name.startsWith('/') ? join(deckDir, 'public', name) : resolve(dirname(source.file), name)
-  if (!existsSync(file) || !statSync(file).isFile()) return undefined
-  return { file, name: `${fileHash(file).slice(0, 8)}-${basename(file)}` }
-}

package/src/plugins.ts

@@ -1,11 +1,12 @@
 import { existsSync, readFileSync, realpathSync } from 'node:fs'
 import { readdir, readFile } from 'node:fs/promises'
 import { dirname, isAbsolute, join, resolve } from 'node:path'
-import { fileURLToPath } from 'node:url'
+import { fileURLToPath, pathToFileURL } from 'node:url'
 import { errorMessage, isRecord, kernelIncompatibility } from '@lincyaw/kernel'
 import type { PresmiumNodePlugin, Severity } from '@lincyaw/kernel'
 import { createJiti } from 'jiti'
 import { satisfies, validRange } from 'semver'
+import { exports as resolveExports } from 'resolve.exports'
 
 export const NODE_PLUGIN_EXPORT = './presmium'
 
@@ -13,6 +14,7 @@ export interface LoadedPlugin {
   name: string
   dir: string
   plugin?: PresmiumNodePlugin
+  entry?: string
 }
 
 export interface PluginProblem {
@@ -61,6 +63,27 @@ interface PluginPackage {
 
 const PRESMIUM_SCOPE = '@lincyaw/'
 
+// The official plugins were named after Slidev's addons; a headmatter that still lists them gets the current packages.
+const LEGACY_PLUGIN = '@lincyaw/slidev-addon-'
+const PLUGIN = '@lincyaw/addon-'
+
+/** A plugin's package as the headmatter lists it, under its current name. */
+export function currentPluginName(name: string): string {
+  return name.startsWith(LEGACY_PLUGIN) ? PLUGIN + name.slice(LEGACY_PLUGIN.length) : name
+}
+
+// Plugins whose work the viewer does itself (the slides' host adapter, Slidev's); a headmatter may still list them.
+const RETIRED_PLUGINS: ReadonlySet<string> = new Set(['@lincyaw/addon-core'])
+
+export function isRetiredPlugin(name: string): boolean {
+  return RETIRED_PLUGINS.has(currentPluginName(name))
+}
+
+/** The plugins a headmatter lists, under their current names, the retired ones left out. */
+export function listedPlugins(names: readonly string[]): string[] {
+  return names.filter(name => !isRetiredPlugin(name)).map(currentPluginName)
+}
+
 const COMPILER_DIR = fileURLToPath(new URL('..', import.meta.url))
 const COMPILER_PACKAGE = JSON.parse(readFileSync(join(COMPILER_DIR, 'package.json'), 'utf8')) as { name: string, version: string }
 
@@ -91,9 +114,9 @@ async function loadFrom(name: string, dir: string, problem: (severity: Severity,
       const label = typeof pkg.name === 'string' ? ` (${pkg.name}${typeof pkg.version === 'string' ? ` ${pkg.version}` : ''})` : ''
       return { problem: problem('error', `plugin "${name}"${label} is not loaded: ${peers}`) }
     }
-    const target = exportTarget(pkg.exports?.[NODE_PLUGIN_EXPORT])
+    const target = exportTarget(pkg, dir)
     if (!target) return { loaded: { name, dir } }
-    const file = join(dir, target)
+    const file = fileURLToPath(new URL(target, pathToFileURL(`${dir}/`)))
     if (!existsSync(file)) {
       return { loaded: { name, dir }, problem: problem('warning', `plugin "${name}": ${NODE_PLUGIN_EXPORT} points to missing file ${target}; only its components are used`) }
     }
@@ -104,7 +127,7 @@ async function loadFrom(name: string, dir: string, problem: (severity: Severity,
       const version = plugin.version ? ` ${plugin.version}` : ''
       return { problem: problem('error', `plugin "${name}" (${plugin.id}${version}) is not loaded: ${incompatible}`) }
     }
-    return { loaded: { name, dir, plugin } }
+    return { loaded: { name, dir, plugin, entry: file } }
   } catch (error) {
     return { problem: problem('error', `cannot load plugin "${name}": ${errorMessage(error)}`) }
   }
@@ -124,7 +147,7 @@ export async function loadPlugins(deckDir: string, names: string[], sources?: Pl
 export async function loadOperatorPlugins(sources: PluginSources): Promise<{ plugins: LoadedPlugin[], problems: PluginProblem[] }> {
   const plugins: LoadedPlugin[] = []
   const problems: PluginProblem[] = []
-  for (const name of sources.listed) {
+  for (const name of listedPlugins(sources.listed)) {
     const dir = findPackageDir(name, resolve(sources.workspaceRoot), false) ?? bundledDir(name, sources)
     if (!dir) {
       problems.push({ name, severity: 'error', message: `operator plugin "${name}" (settings.presmium.workspace.plugins) is not installed at the workspace root ${sources.workspaceRoot}` })
@@ -139,7 +162,7 @@ export async function loadOperatorPlugins(sources: PluginSources): Promise<{ plu
 
 export const DECK_PLUGIN = 'deck'
 
-const COMPONENT = /^[^.]+\.(?:vue|[jt]sx?)$/
+const COMPONENT = /^[^.]+\.(?:[jt]sx?)$/
 
 export async function directoryComponents(dir: string): Promise<string[]> {
   const files = await readdir(join(dir, 'components')).catch(() => [])
@@ -162,10 +185,30 @@ export function findPackageDir(name: string, from: string, up = true): string |
   }
 }
 
-function exportTarget(value: unknown): string | undefined {
-  if (typeof value === 'string') return value
-  if (!isRecord(value)) return undefined
-  return exportTarget(value.import) ?? exportTarget(value.node) ?? exportTarget(value.default)
+function exportTarget(pkg: PluginPackage, dir: string): string | undefined {
+  let targets: string[] | void
+  try {
+    targets = resolveExports(pkg, NODE_PLUGIN_EXPORT)
+  } catch {
+    // A package with no matching Node export still contributes its components.
+    return undefined
+  }
+  if (!targets?.length) return undefined
+  const base = pathToFileURL(`${dir}/`)
+  for (const target of targets) {
+    const path = target.split(/[?#]/, 1)[0]!
+    if (!path.startsWith('./') || /%2f|%5c/i.test(path)) continue
+    try {
+      const segments = path.slice(2).split(/[\\/]/).map(decodeURIComponent)
+      if (segments.some(segment => /^(?:\.{1,2}|node_modules)$/i.test(segment))) continue
+      const normalized = new URL(target, base)
+      if (!normalized.href.startsWith(base.href)) continue
+      return target
+    } catch {
+      // Invalid URL encoding cannot name a package file; arrays may provide another target.
+    }
+  }
+  throw new Error(`${NODE_PLUGIN_EXPORT} has no valid package-relative Node target`)
 }
 
 function isNodePlugin(value: unknown): value is PresmiumNodePlugin {