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

package/src/node/offline.ts

@@ -1,16 +1,29 @@
 import { createHash } from 'node:crypto'
 import { readdirSync, readFileSync, statSync, writeFileSync } from 'node:fs'
-import { join, sep } from 'node:path'
+import { basename, join, sep } from 'node:path'
+import { OFFLINE_REQUESTS } from '@lincyaw/kernel'
 import { SERVICE_WORKER, urlPath } from '../domain/index.ts'
 import { MEDIA } from './publish.ts'
+import { APP_DIR, CODE_DIR } from './site-files.ts'
 
-const MESSAGES = { runtimes: 'presmium:offline-runtimes', save: 'presmium:save-offline' }
+interface OfflineCache {
+  prefix: string
+  cache: string
+  urls: string[]
+  runtimeCache: string
+  runtimes: string[]
+  runtimeBytes: number
+  base: string
+  app: string
+}
 
-function source(cache: string, urls: string[], runtimeCache: string, runtimes: string[], runtimeBytes: number, base: string): string {
+function source({ prefix, cache, urls, runtimeCache, runtimes, runtimeBytes, base, app }: OfflineCache): string {
   return `// Generated by @lincyaw/web.
 const CACHE = ${JSON.stringify(cache)}
+const PREFIX = ${JSON.stringify(prefix)}
 const RUNTIME_CACHE = ${JSON.stringify(runtimeCache)}
 const BASE = ${JSON.stringify(base)}
+const APP = ${JSON.stringify(app)}
 const URLS = ${JSON.stringify(urls)}
 const RUNTIMES = ${JSON.stringify(runtimes)}
 const RUNTIME_BYTES = ${runtimeBytes}
@@ -22,7 +35,7 @@ self.addEventListener('install', (event) => {
 
 self.addEventListener('activate', (event) => {
   event.waitUntil(caches.keys()
-    .then(keys => Promise.all(keys.filter(key => key.startsWith('presmium-web-') && key !== CACHE && key !== RUNTIME_CACHE).map(key => caches.delete(key))))
+    .then(keys => Promise.all(keys.filter(key => key.startsWith(PREFIX) && key !== CACHE && key !== RUNTIME_CACHE).map(key => caches.delete(key))))
     .then(() => self.clients.claim()))
 })
 
@@ -70,9 +83,9 @@ self.addEventListener('message', (event) => {
   const port = event.ports[0]
   const type = event.data && event.data.type
   if (!port) return
-  if (type === ${JSON.stringify(MESSAGES.runtimes)}) {
+  if (type === ${JSON.stringify(OFFLINE_REQUESTS.runtimes)}) {
     event.waitUntil(saved().then(done => port.postMessage({ bytes: RUNTIME_BYTES, saved: done })))
-  } else if (type === ${JSON.stringify(MESSAGES.save)}) {
+  } else if (type === ${JSON.stringify(OFFLINE_REQUESTS.save)}) {
     event.waitUntil(save().then(() => port.postMessage({ ok: true }), () => port.postMessage({ ok: false })))
   }
 })
@@ -80,12 +93,12 @@ self.addEventListener('message', (event) => {
 self.addEventListener('fetch', (event) => {
   const { request } = event
   const url = new URL(request.url)
-  if (request.method !== 'GET' || url.origin !== self.location.origin || !url.pathname.startsWith(BASE)) return
+  if (request.method !== 'GET' || url.origin !== self.location.origin || !(url.pathname.startsWith(BASE) || url.pathname.startsWith(APP))) return
   if (RUNTIME_PATHS.has(url.pathname)) {
     url.search = ''
     url.hash = ''
     event.respondWith(runtime(url.href))
-  } else if (url.pathname.startsWith(BASE + 'assets/')) {
+  } else if (url.pathname.startsWith(APP) || url.pathname.startsWith(BASE + ${JSON.stringify(`${CODE_DIR}/`)})) {
     event.respondWith(cached(request).then(hit => hit || fetch(request)))
   } else {
     event.respondWith(fetch(request).catch(() => cached(request).then(hit => hit || Response.error())))
@@ -115,8 +128,12 @@ function files(dir: string): string[] {
 
 const isRuntime = (file: string) => /^(?:pyodide|wasi|presmium\/jax-js)\//.test(file) && !/(?:^|\/)LICENSES?$/.test(file)
 
-export function writeServiceWorker(outDir: string, base: string): void {
-  const list = files(outDir).map(file => file.split(sep).join('/'))
+/**
+ * Writes the document's service worker: it keeps the document's files and the viewer app's (`app`, below the site's
+ * path, shared with the site's other documents) for reading offline, and the plugins' run-time files on request.
+ */
+export function writeServiceWorker(outDir: string, base: string, app: { dir: string, url: string }): void {
+  const list = files(outDir).filter(file => !file.startsWith(`${APP_DIR}${sep}`)).map(file => file.split(sep).join('/'))
   const shell = list.filter(file => !isRuntime(file))
   const runtimes = list.filter(isRuntime)
   const hash = (names: string[]) => {
@@ -125,6 +142,12 @@ export function writeServiceWorker(outDir: string, base: string): void {
     return digest.digest('hex').slice(0, 12)
   }
   const urls = (names: string[]) => names.map(file => file.split('/')).map(parts => base + (parts[0] === MEDIA ? parts.map(encodeURIComponent).join('/') : urlPath(parts.join('/'))))
+  const appFiles = files(app.dir).map(file => app.url + urlPath(file.split(sep).join('/')))
   const bytes = runtimes.reduce((sum, file) => sum + statSync(join(outDir, file)).size, 0)
-  writeFileSync(join(outDir, SERVICE_WORKER), source(`presmium-web-${hash(shell)}`, urls(shell), `presmium-web-runtimes-${hash(runtimes)}`, urls(runtimes), bytes, base))
+  const scope = createHash('sha256').update(base).digest('hex').slice(0, 16)
+  const prefix = `presmium-web-${scope}-`
+  writeFileSync(join(outDir, SERVICE_WORKER), source({
+    prefix, cache: `${prefix}${hash(shell)}-${basename(app.dir)}`, urls: [...urls(shell), ...appFiles],
+    runtimeCache: `${prefix}runtimes-${hash(runtimes)}`, runtimes: urls(runtimes), runtimeBytes: bytes, base, app: app.url,
+  }))
 }

package/src/node/publish.ts

@@ -1,17 +1,22 @@
+import { createHash } from 'node:crypto'
 import { statSync } from 'node:fs'
 import { join } from 'node:path'
-import { irBlocks, mapHtmlUrls, publishedUrl, withProp } from '@lincyaw/kernel'
-import type { DocumentLink, IRBlock, IRDocument, LocalAsset, MdastNode, RenderContext, SourcePos } from '@lincyaw/kernel'
-import { copyPublished } from '@lincyaw/kernel/node'
+import { irBlocks, mapHtmlUrls, NON_FILE_URL, publishedUrl, withPublishedAssets } from '@lincyaw/kernel'
+import type { DocumentLink, IRBlock, IRDocument, IRSection, LocalAsset, MdastNode, RenderContext, SourcePos } from '@lincyaw/kernel'
+import { copyPublished, fileVersion } from '@lincyaw/kernel/node'
 import katex from 'katex'
 
 export const MEDIA = 'media'
 
+/** The IR revision of an IR written as JSON. */
+export function irRevisionOfJson(json: string): string {
+  return createHash('sha256').update(json).digest('hex').slice(0, 16)
+}
+
 const LINKED = new Set(['image', 'link', 'definition', 'card'])
 
 interface Asset extends LocalAsset {
-  size: number
-  mtimeMs: number
+  version: string
 }
 
 const assets = new Map<string, Asset>()
@@ -19,21 +24,22 @@ const assets = new Map<string, Asset>()
 function localAsset(ctx: RenderContext, source: SourcePos, url: string): Asset | undefined {
   const key = `${source.file}\0${url}`
   const known = assets.get(key)
-  const now = known && statSync(known.file, { throwIfNoEntry: false })
-  if (known && now && now.size === known.size && now.mtimeMs === known.mtimeMs) return known
+  const now = known && statSync(known.file, { bigint: true, throwIfNoEntry: false })
+  if (known && now && fileVersion(now) === known.version) return known
   const found = ctx.localAsset(source, url)
-  const stat = found && statSync(found.file, { throwIfNoEntry: false })
+  const stat = found && statSync(found.file, { bigint: true, throwIfNoEntry: false })
   if (!found || !stat) {
     assets.delete(key)
     return undefined
   }
-  const asset = { ...found, size: stat.size, mtimeMs: stat.mtimeMs, directory: found.directory ?? stat.isDirectory() }
+  const asset = { ...found, version: fileVersion(stat), directory: found.directory ?? stat.isDirectory() }
   if (asset.directory) assets.delete(key)
   else assets.set(key, asset)
   return asset
 }
 
 const rendered = new Map<string, string>()
+const PUBLICATION_CACHE_BYTES = 16 << 20
 
 function renderMath(tex: string, display: boolean): string {
   const key = `${display ? 'D' : 'I'}${tex}`
@@ -47,9 +53,52 @@ function renderMath(tex: string, display: boolean): string {
 
 export type DocumentPage = (link: DocumentLink) => string | undefined
 
-export function publishedDocument(doc: IRDocument, ctx: RenderContext, publicDir: string, base: string, documentPage?: DocumentPage): IRDocument {
+export class PublicationCache {
+  readonly #sections = new Map<string, { key: string, section: IRSection, bytes: number }>()
+  #bytes = 0
+
+  lookup(section: IRSection): { key: string, section?: IRSection } {
+    const key = JSON.stringify(section)
+    const known = this.#sections.get(section.id)
+    return { key, ...known?.key === key ? { section: known.section } : {} }
+  }
+
+  store(original: IRSection, key: string, section: IRSection): void {
+    const old = this.#sections.get(original.id)
+    if (old) this.#bytes -= old.bytes
+    this.#sections.delete(original.id)
+    // Local files and raw HTML can change independently of the IR. Revisit them.
+    const local = (node: MdastNode): boolean => node.type === 'html'
+      || (LINKED.has(node.type) && typeof node.url === 'string' && !NON_FILE_URL.test(node.url))
+      || Boolean(node.children?.some(local))
+    for (const block of irBlocks(original.blocks)) {
+      if (block.node.type === 'markdown' && local(block.node.mdast)) return
+      if (block.node.type === 'component' && (Object.keys(block.node.assets ?? {}).length || (block.node.fallback && local(block.node.fallback)))) return
+      if (block.stepStates?.some(state => Object.keys(state.assets ?? {}).length)) return
+    }
+    const bytes = (key.length + JSON.stringify(section).length) * 2
+    if (bytes > PUBLICATION_CACHE_BYTES) return
+    this.#sections.set(original.id, { key, section, bytes })
+    this.#bytes += bytes
+    while (this.#bytes > PUBLICATION_CACHE_BYTES || this.#sections.size > 2048) {
+      const first = this.#sections.keys().next().value!
+      this.#bytes -= this.#sections.get(first)!.bytes
+      this.#sections.delete(first)
+    }
+  }
+
+  prune(ids: Set<string>): void {
+    for (const [id, entry] of this.#sections) {
+      if (ids.has(id)) continue
+      this.#sections.delete(id)
+      this.#bytes -= entry.bytes
+    }
+  }
+}
+
+export function publishedDocument(doc: IRDocument, ctx: RenderContext, publicDir: string, base: string, documentPage?: DocumentPage, cache?: PublicationCache): IRDocument {
   const { deckDir } = ctx
-  const copy = structuredClone(doc)
+  const copy: IRDocument = structuredClone(cache ? { ...doc, sections: [] } : doc)
   const media = join(publicDir, MEDIA)
   const relative = (pos: { file: string }) => {
     pos.file = ctx.portable(pos.file, deckDir) as string
@@ -73,20 +122,39 @@ export function publishedDocument(doc: IRDocument, ctx: RenderContext, publicDir
     if (node.type === 'markdown') mdast(node.mdast, source)
     if (node.type === 'component') {
       if (node.fallback) mdast(node.fallback, source)
-      for (const [path, url] of Object.entries(node.assets ?? {})) {
-        const published = publish(url, source)
-        if (published) node.props = withProp(node.props, path, published)
+      for (const state of b.stepStates ?? []) {
+        if (!state.parameters) continue
+        // Plugins can declare state-only resources. Other components inherit
+        // their declared asset paths, resolved against the current parameters.
+        const assets = state.assets ?? Object.fromEntries(Object.entries(node.assets ?? {}).flatMap(([path, original]) => {
+          const at = (props: Record<string, unknown>) => path.split('.').reduce<unknown>((current, key) => current && typeof current === 'object' ? (current as Record<string, unknown>)[key] : undefined, props)
+          const value = at(state.parameters!)
+          return typeof value === 'string' ? [[path, value !== at(node.props) ? value : original]] : []
+        }))
+        state.parameters = withPublishedAssets({ ...node, props: state.parameters, assets }, url => publish(url, source)).props
       }
+      node.props = withPublishedAssets(node, url => publish(url, source)).props
     }
   }
   copy.meta.entry = ctx.portable(copy.meta.entry, deckDir) as string
   copy.config.presmium = ctx.portable(copy.config.presmium, deckDir) as IRDocument['config']['presmium']
-  for (const section of copy.sections) {
+  for (const original of cache ? doc.sections : copy.sections) {
+    const known = cache?.lookup(original)
+    if (known?.section) {
+      copy.sections.push(known.section)
+      continue
+    }
+    const section = cache ? structuredClone(original) : original
     relative(section.source)
     if (section.config) section.config = ctx.portable(section.config, deckDir) as typeof section.config
     for (const b of irBlocks(section.blocks)) block(b)
     for (const b of irBlocks(section.blocks)) relative(b.source)
+    if (cache) {
+      copy.sections.push(section)
+      cache.store(original, known!.key, section)
+    }
   }
+  cache?.prune(new Set(doc.sections.map(section => section.id)))
   for (const finding of copy.diagnostics) {
     if (finding.source) relative(finding.source)
   }

package/src/node/renderer.ts

@@ -1,122 +1,51 @@
-import { rmSync } from 'node:fs'
 import { join, resolve } from 'node:path'
-import { irBlocks } from '@lincyaw/kernel'
-import type { IRDocument, RenderContext, Renderer } from '@lincyaw/kernel'
-import { diffDocuments } from '@lincyaw/viewer/domain'
+import type { IRDocument, RenderContext, RenderDevServer, Renderer, SiteDevServer, SiteDocument, SiteSpec } from '@lincyaw/kernel'
 import launchEditor from 'launch-editor'
-import { offlineEnabled, rendererConfig } from '../domain/index.ts'
-import type { WebRendererConfig } from '../domain/index.ts'
-import { clientModules, nodeVitePlugins } from './addons.ts'
-import type { ClientModules } from './addons.ts'
-import { writeServiceWorker } from './offline.ts'
-import { publishedDocument, publishedFile } from './publish.ts'
-import type { DocumentPage } from './publish.ts'
-import { siteFiles, write, writeSite } from './site.ts'
-import type { WorkspaceOptions } from './site.ts'
-import { buildSite, devSite } from './sites.ts'
-import { revisionOf } from './vite.ts'
-import { vitepressBuild, vitepressDev } from './vitepress.ts'
+import { buildSite as buildPages } from './site-build.ts'
+import type { BuiltDocument } from './site-build.ts'
+import { documentContext, documentSourceFiles } from './site-model.ts'
+import { startSiteServer } from './site-server.ts'
+import { viewerAppCache } from './viewer-app.ts'
 
 const BUILD_DIR = '.presmium/web/build'
+const LOOPBACK = '127.0.0.1'
 
-function sourceFiles(doc: IRDocument): Set<string> {
-  const files = new Set<string>()
-  for (const section of doc.sections) {
-    files.add(section.source.file)
-    for (const block of irBlocks(section.blocks)) files.add(block.source.file)
-  }
-  return files
-}
-
-export interface DocumentSite {
-  workspace?: WorkspaceOptions
-  extra?: ClientModules
-  documentPage?: DocumentPage
-  config?: string
-}
-
-function merge(modules: ClientModules, extra?: ClientModules): ClientModules {
-  if (!extra) return modules
-  return {
-    components: new Map([...extra.components, ...modules.components]),
-    plugins: [...extra.plugins, ...modules.plugins],
-    viewers: [...extra.viewers, ...modules.viewers],
-    vite: [...extra.vite, ...modules.vite],
-    nodeVite: [...extra.nodeVite, ...modules.nodeVite],
-  }
+/** One document as a site of its own: at the root of its site path, with no home page. */
+function documentSite(doc: IRDocument, ctx: RenderContext): SiteSpec {
+  return { title: doc.meta.title, documents: [{ dir: '', title: doc.meta.title, doc, ...ctx.translations ? { translations: ctx.translations } : {} }], config: ctx.config }
 }
 
-const REMOTE = /^(?:[a-z][a-z\d+.-]*:|\/\/)/i
-
-function headImage(doc: IRDocument, ctx: RenderContext, options: WebRendererConfig, publicDir: string, document: DocumentSite): string | undefined {
-  const image = options.shell.head?.image
-  if (!image || REMOTE.test(image)) return image
-  const published = publishedFile(ctx, publicDir, options.base, { file: document.config ?? resolve(ctx.deckDir, doc.meta.entry), line: 1 }, image)
-  return published && options.shell.sitemap ? `${options.shell.sitemap.hostname}${published}` : published
+function documentWorkDir(ctx: RenderContext, dir: string): string {
+  return join(ctx.workDir, 'documents', dir ? encodeURIComponent(dir) : '_')
 }
 
-async function prepare(doc: IRDocument, ctx: RenderContext, workDir: string, document: DocumentSite = {}) {
-  const options = rendererConfig(ctx)
-  const files = siteFiles(workDir)
-  rmSync(files.publicDir, { recursive: true, force: true })
-  const deck = { deckDir: ctx.deckDir, workspaceRoot: ctx.workspaceRoot }
-  const nodeVite = await nodeVitePlugins(ctx, doc.config.presmium, Boolean(document.workspace))
-  const publish = (d: IRDocument) => publishedDocument(d, ctx, files.publicDir, options.base, document.documentPage)
-  const image = headImage(doc, ctx, options, files.publicDir, document)
-  const site = (published: IRDocument) => writeSite(workDir, {
-    doc: published,
-    deck,
-    modules: merge(clientModules(ctx, nodeVite), document.extra),
-    options,
-    workspace: document.workspace,
-    translations: (ctx.translations ?? []).map(({ lang, doc: translated }) => ({ lang, doc: publish(translated) })),
-    image,
-    ...ctx.preview ? { preview: ctx.preview } : {},
+/** The dev server of one document (`presmium dev`): its pages, or its slides. */
+export async function devDocument(doc: IRDocument, ctx: RenderContext, form: 'web' | 'slides'): Promise<RenderDevServer> {
+  let current = doc
+  const port = Number(ctx.config.port) > 0 && Number.isInteger(Number(ctx.config.port)) ? Number(ctx.config.port) : undefined
+  const server = await startSiteServer({
+    site: () => documentSite(current, ctx),
+    form,
+    ctx,
+    cacheDir: viewerAppCache(),
+    workDir: join(ctx.outDir, 'site'),
+    document: async () => current,
+    context: () => ctx,
+    nodePlugins: () => ctx.nodeVitePlugins ?? [],
+    translations: () => (form === 'web' ? ctx.translations ?? [] : []),
+    listen: { host: LOOPBACK, port: port ?? 0 },
+    openSource(file, line) {
+      if (!documentSourceFiles(current).has(file)) return
+      launchEditor(`${resolve(ctx.deckDir, file)}:${line}`, (opened, error) => {
+        console.error(`[presmium] could not open ${opened} in an editor${error ? `: ${error}` : ''}; set $EDITOR or $LAUNCH_EDITOR`)
+      })
+    },
   })
-  return { options, files, publish, site }
-}
-
-export async function buildDocument(doc: IRDocument, ctx: RenderContext, workDir: string, document: DocumentSite = {}): Promise<void> {
-  const { options, files, publish, site } = await prepare(doc, ctx, workDir, document)
-  const published = publish(doc)
-  site(published)
-  write(join(files.publicDir, 'ir.json'), JSON.stringify(published))
-  const code = await vitepressBuild(files.root, ctx.outDir)
-  if (code !== 0) throw new Error(`vitepress build exited with code ${code}`)
-  if (offlineEnabled(doc.config.presmium)) writeServiceWorker(ctx.outDir, options.base)
-}
-
-export interface DocumentDevServer {
-  port: number
-  update(doc: IRDocument): Promise<void>
-  close(): Promise<void>
-}
-
-export async function devDocument(doc: IRDocument, ctx: RenderContext, document: DocumentSite = {}, port?: number, listen: { host?: string, signal?: AbortSignal } = {}): Promise<DocumentDevServer> {
-  const { options, files, publish, site } = await prepare(doc, ctx, ctx.outDir, document)
-  let current = publish(doc)
-  let revision = revisionOf(JSON.stringify(current))
-  site(current)
-  const server = await vitepressDev(files.root, port ?? options.port, (message) => {
-    if (message.type !== 'presmium:source' || document.workspace || !sourceFiles(current).has(message.file)) return
-    launchEditor(`${resolve(ctx.deckDir, message.file)}:${message.line}`, (file, error) => {
-      console.error(`[presmium] could not open ${file} in an editor${error ? `: ${error}` : ''}; set $EDITOR or $LAUNCH_EDITOR`)
-    })
-  }, listen)
   return {
-    port: server.port,
-    async update(next: IRDocument) {
-      const published = publish(next)
-      const update = diffDocuments(current, published)
-      site(published)
-      if (!update) {
-        if (ctx.translations?.length) server.send({ type: 'presmium:translations' })
-        return
-      }
-      const base = revision
-      current = published
-      revision = revisionOf(JSON.stringify(published))
-      server.send({ type: 'presmium:update', update, base, revision })
+    url: server.url,
+    async update(next) {
+      current = next
+      server.update('', next)
     },
     close: () => server.close(),
   }
@@ -128,20 +57,51 @@ export const renderer: Renderer = {
   support: () => 'full',
 
   async build(doc: IRDocument, ctx: RenderContext) {
-    await buildDocument(doc, ctx, join(ctx.deckDir, BUILD_DIR))
+    const work = join(ctx.deckDir, BUILD_DIR)
+    const entry: BuiltDocument = { dir: '', doc, ctx, nodePlugins: ctx.nodeVitePlugins ?? [], translations: ctx.translations ?? [] }
+    await buildPages(documentSite(doc, ctx), { ...ctx, workDir: work }, [entry])
     return { outDir: ctx.outDir, skipped: [] }
   },
 
-  async dev(doc: IRDocument, ctx: RenderContext) {
-    const server = await devDocument(doc, ctx)
-    const { base } = rendererConfig(ctx)
+  dev: (doc, ctx) => devDocument(doc, ctx, 'web'),
+
+  async buildSite(site: SiteSpec, ctx: RenderContext) {
+    const documents: BuiltDocument[] = site.documents.flatMap((entry) => {
+      if (!entry.doc) return []
+      const own = documentContext(ctx, site, entry.dir, entry.doc, join(ctx.outDir, entry.dir), documentWorkDir(ctx, entry.dir))
+      return [{ dir: entry.dir, doc: entry.doc, ctx: own, nodePlugins: entry.nodeVitePlugins ?? [], translations: entry.translations ?? [] }]
+    })
+    await buildPages(site, ctx, documents)
+    return { outDir: ctx.outDir, skipped: [] }
+  },
+
+  async devSite(site: SiteSpec, ctx: RenderContext, compile: (dir: string) => Promise<IRDocument>): Promise<SiteDevServer> {
+    const entryOf = (dir: string) => site.documents.find(entry => entry.dir === dir)
+    const host = typeof ctx.config.host === 'string' && ctx.config.host ? ctx.config.host : LOOPBACK
+    const server = await startSiteServer({
+      site: () => site,
+      ctx,
+      cacheDir: viewerAppCache(),
+      workDir: join(ctx.workDir, 'viewer'),
+      document: compile,
+      context: (dir, doc) => documentContext(ctx, site, dir, doc, documentWorkDir(ctx, dir), documentWorkDir(ctx, dir)),
+      nodePlugins: dir => entryOf(dir)?.nodeVitePlugins ?? [],
+      translations: dir => entryOf(dir)?.translations ?? [],
+      listen: { host, port: Number(ctx.config.port) || 0 },
+    })
     return {
-      url: `http://localhost:${server.port}${base}`,
-      update: next => server.update(next),
+      url: server.url,
+      async update(dir, doc) {
+        const known: SiteDocument = { dir, title: doc.meta.title, ...doc.meta.lang ? { lang: doc.meta.lang } : {}, ...Array.isArray(doc.meta.tags) ? { tags: (doc.meta.tags as unknown[]).filter((t): t is string => typeof t === 'string') } : {} }
+        const entry = entryOf(dir)
+        if (entry) Object.assign(entry, known)
+        else site.documents.push(known)
+        server.update(dir, doc)
+      },
+      target: async () => server.origin,
+      app: (dir, wait) => server.app(dir, wait),
+      warm: dir => server.warm(dir),
       close: () => server.close(),
     }
   },
-
-  buildSite,
-  devSite,
 }

package/src/node/site-assets.ts

@@ -0,0 +1,19 @@
+import { join, resolve } from 'node:path'
+import { ABSOLUTE_URL, isRecord } from '@lincyaw/kernel'
+import type { RenderContext, SiteSpec } from '@lincyaw/kernel'
+import { publishedFile } from './publish.ts'
+import { isSingle } from './site-model.ts'
+import { publishedTheme } from './site-theme.ts'
+
+/** Publish shell assets from the site's configuration owner, once for every document in the site: its logo and theme. */
+export function publishedSite(site: SiteSpec, ctx: RenderContext, outDir = ctx.outDir, base = ctx.base): SiteSpec {
+  site = publishedTheme(site, outDir, base)
+  const params = isRecord(site.config.params) ? site.config.params : undefined
+  if (!params || typeof params.logo !== 'string') return site
+  const logo = params.logo.trim()
+  const file = isSingle(site) ? resolve(ctx.deckDir, site.documents[0]!.doc?.meta.entry ?? 'lecture.json') : join(ctx.workspaceRoot, 'presmium.workspace.yaml')
+  const source = { file, line: 1 }
+  const url = ABSOLUTE_URL.test(logo) ? logo : logo.startsWith('/') ? `${ctx.base}${logo.slice(1)}` : publishedFile(ctx, outDir, base, source, logo)
+  const { logo: _source, ...rest } = params
+  return { ...site, config: { ...site.config, params: { ...rest, ...url ? { logo: url } : {} } } }
+}