@lincyaw/web 0.0.0-stage → 1.0.0-rc.1

package/src/node/document-bundle.ts

@@ -0,0 +1,227 @@
+import { createHash } from 'node:crypto'
+import { existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs'
+import { join, resolve, sep } from 'node:path'
+import { pathToFileURL } from 'node:url'
+import { irBlocks } from '@lincyaw/kernel'
+import type { IRDocument, PresmiumNodePlugin } from '@lincyaw/kernel'
+import { collectBrowserModules, deckPackage, emptyClientModules, isRestartablePackage } from './client-modules.ts'
+import { quietDirectives } from './viewer-app.ts'
+
+/**
+ * A document's own browser code, apart from the viewer app that shows it: its components, browser and viewer plugins,
+ * and the document modules its plugins generate for it (`PresmiumNodePlugin.documentModules`), as one small bundle that
+ * imports React, Presmium's packages and the plugins' public subpaths by name, from the app, through its import map.
+ */
+
+const BUNDLE_MANIFEST = 'bundle.json'
+export const BUNDLE_ENTRY = 'document.js'
+const DOCUMENT_MODULE = '\0presmium-document-bundle:'
+const KEEP = 3
+
+export interface DocumentBundleInput {
+  deckDir: string
+  workspaceRoot: string
+  /** Where the document's bundles are kept, each in a directory by its key. */
+  outDir: string
+  /** The specifiers the app's import map names: never bundled. */
+  externals: string[]
+  /** The Node entries of the document's plugins, with their configuration, for their document modules. */
+  nodePlugins: { entry: string, config: Record<string, unknown> }[]
+  /** Canonical file implementations, registered by their derived runtime names. */
+  components?: DocumentComponent[]
+}
+
+export interface DocumentComponent { name: string, file: string, exportName?: string }
+
+/** Own React components are selected by the compiled definition, regardless of their directory. */
+export function documentComponents(doc: IRDocument | undefined): DocumentComponent[] {
+  const found = new Map<string, DocumentComponent>()
+  for (const section of doc?.sections ?? []) for (const block of irBlocks(section.blocks)) {
+    const node = block.node
+    if (node.type !== 'component' || node.plugin !== 'deck' || !node.definition) continue
+    const component = { name: node.name, file: node.definition.file, ...node.definition.exportName !== undefined ? { exportName: node.definition.exportName } : {} }
+    const known = found.get(component.name)
+    if (known && (known.file !== component.file || known.exportName !== component.exportName)) throw new Error(`Document component ${component.name} names multiple implementations.`)
+    found.set(component.name, component)
+  }
+  return [...found.values()]
+}
+
+export interface DocumentBundle {
+  key: string
+  dir: string
+  /** The files the bundle was built from, by path, with their size and time then. */
+  inputs: Record<string, string>
+  restartable: boolean
+  /** The names of the document's own components. */
+  components: string[]
+}
+
+interface DocumentCode {
+  key: string
+  entry: string
+  components: string[]
+  /** The document modules' sources, by id. */
+  generated: Record<string, string>
+  restartable: boolean
+}
+
+const stamp = (file: string) => {
+  try {
+    const { size, mtimeMs } = statSync(file)
+    return `${size}:${Math.trunc(mtimeMs)}`
+  } catch {
+    return 'missing'
+  }
+}
+
+/** The entry of the document's bundle and the key of what it is made of, or none when the document has no code of its own. */
+async function documentCode(input: DocumentBundleInput): Promise<DocumentCode | undefined> {
+  const modules = emptyClientModules()
+  collectBrowserModules(input.deckDir, 'deck', modules, false, deckPackage(input.deckDir, input.workspaceRoot))
+  const components = new Map([...modules.components].map(([name, file]) => [name, { file, exportName: 'default' }]))
+  if (input.components?.length && !isRestartablePackage(deckPackage(input.deckDir, input.workspaceRoot))) modules.restartable = false
+  for (const component of input.components ?? []) components.set(component.name, { file: resolve(input.deckDir, component.file), exportName: component.exportName ?? 'default' })
+  const generated: Record<string, string> = {}
+  for (const { entry, config } of input.nodePlugins) {
+    const plugin = (await import(pathToFileURL(entry).href) as { default?: PresmiumNodePlugin }).default
+    Object.assign(generated, plugin?.documentModules?.({ deckDir: input.deckDir, workspaceRoot: input.workspaceRoot, config }) ?? {})
+  }
+  if (components.size + modules.plugins.length + modules.viewers.length + Object.keys(generated).length === 0) return undefined
+  const load = (file: string) => `() => import(${JSON.stringify(file)})`
+  const ids = Object.keys(generated)
+  const entry = `${ids.map((id, i) => `import module${i} from ${JSON.stringify(id)}\n`).join('')}
+export const components = {
+${[...components].map(([name, { file, exportName }]) => `  ${JSON.stringify(name)}: () => import(${JSON.stringify(file)}).then(module => { if (!module[${JSON.stringify(exportName)}]) throw new Error(${JSON.stringify(`Document component ${name} has no export ${exportName}.`)}); return { default: module[${JSON.stringify(exportName)}] } }),`).join('\n')}
+}
+export const plugins = [${modules.plugins.map(load).join(', ')}]
+export const viewers = [${modules.viewers.map(({ name, file }) => `{ name: ${JSON.stringify(name)}, load: ${load(file)} }`).join(', ')}]
+export const documentModules = {
+${ids.map((id, i) => `  ${JSON.stringify(id)}: module${i},`).join('\n')}
+}
+export const restartable = ${modules.restartable}
+`
+  const key = createHash('sha256').update(JSON.stringify([input.externals.toSorted(), entry, generated])).digest('hex').slice(0, 16)
+  return { key, entry, generated, restartable: modules.restartable, components: [...components.keys()] }
+}
+
+function readBundle(dir: string): DocumentBundle | undefined {
+  try {
+    const bundle = JSON.parse(readFileSync(join(dir, BUNDLE_MANIFEST), 'utf8')) as DocumentBundle
+    return Object.entries(bundle.inputs).every(([file, known]) => stamp(file) === known) ? { ...bundle, components: bundle.components ?? [], dir } : undefined
+  } catch {
+    return undefined
+  }
+}
+
+/** The newest bundle of the document's code (`key`) built from its files as they are now. */
+function freshBundle(outDir: string, key: string): DocumentBundle | undefined {
+  let entries: string[]
+  try {
+    entries = readdirSync(outDir).filter(entry => entry.startsWith(`${key}-`))
+  } catch {
+    return undefined
+  }
+  const builds = entries.map(entry => ({ dir: join(outDir, entry), time: statSync(join(outDir, entry)).mtimeMs })).sort((a, b) => b.time - a.time)
+  for (const { dir } of builds) {
+    const bundle = readBundle(dir)
+    if (bundle) return bundle
+  }
+  return undefined
+}
+
+/** The document's bundle as its files are now, if one was built from them. */
+export async function findDocumentBundle(input: DocumentBundleInput): Promise<DocumentBundle | null | undefined> {
+  const code = await documentCode(input)
+  if (!code) return null
+  return freshBundle(input.outDir, code.key)
+}
+
+/**
+ * Builds the document's bundle (unless it is there already); none when the document has no code of its own. Its
+ * directory is named by its code and its content, so that its files never change under their address.
+ */
+export async function buildDocumentBundle(input: DocumentBundleInput): Promise<DocumentBundle | null> {
+  const code = await documentCode(input)
+  if (!code) return null
+  const known = freshBundle(input.outDir, code.key)
+  if (known) return known
+  const work = join(input.outDir, `.build-${code.key}-${process.pid}`)
+  rmSync(work, { recursive: true, force: true })
+  mkdirSync(work, { recursive: true })
+  // Vite resolves symlinks, including macOS's /var -> /private/var temporary paths.
+  const realWork = realpathSync(work)
+  writeFileSync(join(work, 'entry.ts'), code.entry)
+  const { generated } = code
+  const externals = new Set(input.externals)
+  const inputs: Record<string, string> = {}
+  const { build } = await import('vite')
+  await build({
+    configFile: false,
+    root: input.deckDir,
+    base: './',
+    logLevel: 'warn',
+    mode: 'production',
+    esbuild: { jsx: 'automatic' },
+    publicDir: false,
+    plugins: [
+      {
+        name: 'presmium:document-bundle',
+        // Before Vite's own resolution: the app's modules stay imports by name.
+        enforce: 'pre' as const,
+        resolveId(id: string) {
+          // Headmatter aliases already load the renamed plugins. Older document code must import the same shared
+          // modules too, rather than resolving the removed packages or bundling a second copy of their runtime.
+          const shared = externals.has(id) ? id : id.replace(/^@lincyaw\/slidev-addon-/, '@lincyaw/addon-')
+          if (externals.has(shared)) return { id: shared, external: true }
+          return generated[id] === undefined ? undefined : `${DOCUMENT_MODULE}${id}`
+        },
+        load(id: string) {
+          return id.startsWith(DOCUMENT_MODULE) ? generated[id.slice(DOCUMENT_MODULE.length)] : undefined
+        },
+        generateBundle(_: unknown, bundle: Record<string, { type: string, moduleIds?: string[] }>) {
+          for (const chunk of Object.values(bundle)) {
+            for (const id of chunk.moduleIds ?? []) {
+              const file = id.replace(/[?#].*$/s, '')
+              if (file.startsWith('\0') || !existsSync(file)) continue
+              const realFile = realpathSync(file)
+              if (!realFile.startsWith(realWork + sep) && !realFile.split(sep).includes('node_modules')) inputs[realFile] = stamp(realFile)
+            }
+          }
+        },
+        onLog: quietDirectives,
+      },
+    ],
+    resolve: { dedupe: ['react', 'react-dom'] },
+    build: {
+      outDir: join(work, 'out'),
+      emptyOutDir: true,
+      target: 'es2022',
+      reportCompressedSize: false,
+      chunkSizeWarningLimit: 100_000,
+      copyPublicDir: false,
+      rollupOptions: {
+        input: { document: join(work, 'entry.ts') },
+        preserveEntrySignatures: 'strict',
+        output: {
+          format: 'es',
+          entryFileNames: BUNDLE_ENTRY,
+          chunkFileNames: 'chunks/[name]-[hash].js',
+          assetFileNames: 'assets/[name]-[hash][extname]',
+        },
+      },
+    },
+  })
+  const content = createHash('sha256').update(readFileSync(join(work, 'out', BUNDLE_ENTRY))).digest('hex').slice(0, 8)
+  const name = `${code.key}-${content}`
+  const out = join(input.outDir, name)
+  const bundle: DocumentBundle = { key: name, dir: out, inputs, restartable: code.restartable, components: code.components }
+  writeFileSync(join(work, 'out', BUNDLE_MANIFEST), `${JSON.stringify(bundle, null, 2)}\n`)
+  rmSync(out, { recursive: true, force: true })
+  renameSync(join(work, 'out'), out)
+  rmSync(work, { recursive: true, force: true })
+  // The document's last few bundles stay, for pages still loading an earlier one.
+  const builds = readdirSync(input.outDir).filter(entry => !entry.startsWith('.')).map(entry => ({ dir: join(input.outDir, entry), time: statSync(join(input.outDir, entry)).mtimeMs })).sort((a, b) => b.time - a.time)
+  for (const old of builds.slice(KEEP)) rmSync(old.dir, { recursive: true, force: true })
+  return bundle
+}

package/src/node/landing-template.ts

@@ -0,0 +1,34 @@
+import { cpSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { basename, dirname, join } from 'node:path'
+import { mapHtmlUrls } from '@lincyaw/kernel'
+import { build } from 'vite'
+import { SITE_CONTENT_ELEMENT } from '../domain/index.ts'
+import type { SiteContent } from '../domain/index.ts'
+
+/** A website template is an ordinary Vite HTML entry, with its own CSS and modules. */
+export async function buildLandingTemplate(file: string, workDir: string, base: string, content: SiteContent, workspaceRoot: string): Promise<{ html: string, dir: string }> {
+  const dir = join(workDir, 'template')
+  const data = JSON.stringify(content).replace(/</g, '\\u003c')
+  await build({
+    configFile: false,
+    root: dirname(file),
+    base,
+    publicDir: join(workspaceRoot, 'public'),
+    logLevel: 'silent',
+    plugins: [{
+      name: 'presmium-site-content',
+      transformIndexHtml: { order: 'pre', handler: () => [{ tag: 'script', attrs: { id: SITE_CONTENT_ELEMENT, type: 'application/json' }, children: data, injectTo: 'head' }] },
+    }],
+    build: { outDir: dir, emptyOutDir: true, copyPublicDir: false, assetsDir: '_landing/assets', rollupOptions: { input: file } },
+  })
+  const html = mapHtmlUrls(readFileSync(join(dir, basename(file)), 'utf8'), url => url.startsWith('/') && !url.startsWith('//') && !url.startsWith(base) ? `${base}${url.slice(1)}` : undefined)
+  return { html, dir }
+}
+
+export function writeLandingTemplate(output: { html: string, dir: string }, outDir: string, prefix = ''): void {
+  // Only emitted assets are shared; the entry itself is mounted as the site's index.html.
+  if (existsSync(join(output.dir, '_landing'))) cpSync(join(output.dir, '_landing'), join(outDir, '_landing'), { recursive: true, force: true })
+  const index = join(outDir, prefix, 'index.html')
+  mkdirSync(dirname(index), { recursive: true })
+  writeFileSync(index, output.html)
+}

package/src/node/landing.ts

@@ -0,0 +1,82 @@
+import { existsSync, readFileSync, realpathSync, statSync } from 'node:fs'
+import { basename, dirname, extname, join, resolve } from 'node:path'
+import { ABSOLUTE_URL, deckLocale, DOCUMENT_ENTRY, isRecord, safeDecodeURIComponent } from '@lincyaw/kernel'
+import type { IRDocument, RenderContext, SiteSpec } from '@lincyaw/kernel'
+import { isInside } from '@lincyaw/kernel/node'
+import { parseLandingPage, WEB_MESSAGES } from '../domain/index.ts'
+import type { HomeDocument, SiteContent, SiteLandingPage } from '../domain/index.ts'
+import { publishedFile } from './publish.ts'
+import { documentLinkOf, documentPage, siteLanguage, siteTitle } from './site-model.ts'
+
+export type IndependentLanding = { kind: 'page', page: SiteLandingPage, source: string } | { kind: 'template', file: string }
+
+/** Resolve website pages from their own source, independently of the document compiler. */
+export function loadLanding(site: SiteSpec, ctx: RenderContext): IndependentLanding | undefined {
+  const input = site.config.landing
+  if (input === undefined || typeof input === 'string') return undefined
+  const fail = (key: string): never => { throw new Error(WEB_MESSAGES[deckLocale(siteLanguage(site))].invalidSiteParameter(key)) }
+  if (!isRecord(input) || site.home !== undefined) return fail('site.landing')
+  const file = (value: unknown, key: string, extension: string) => {
+    if (typeof value !== 'string' || !value.trim()) return fail(key)
+    const path = resolve(ctx.workspaceRoot, value)
+    if (!existsSync(path) || !statSync(path).isFile() || extname(path).toLowerCase() !== extension || !isInside(realpathSync(path), realpathSync(ctx.workspaceRoot))) return fail(key)
+    return path
+  }
+  if ('source' in input && 'template' in input) return fail('site.landing')
+  if ('template' in input) return { kind: 'template', file: file(input.template, 'site.landing.template', '.html') }
+  if ('source' in input) {
+    const source = file(input.source, 'site.landing.source', '.json')
+    let value: unknown
+    try { value = JSON.parse(readFileSync(source, 'utf8')) } catch { return fail('site.landing.source') }
+    return { kind: 'page', page: parseLandingPage(value, siteLanguage(site)), source }
+  }
+  return { kind: 'page', page: parseLandingPage(input, siteLanguage(site)), source: join(ctx.workspaceRoot, 'presmium.workspace.yaml') }
+}
+
+/** Local media belongs to the page source; site-absolute navigation belongs to the deployment base. */
+export function publishLanding(landing: Extract<IndependentLanding, { kind: 'page' }>, site: SiteSpec, ctx: RenderContext, outDir = ctx.outDir, base = ctx.base, docs: ReadonlyMap<string, IRDocument> = new Map(site.documents.flatMap(entry => entry.doc ? [[entry.dir, entry.doc] as const] : []))): SiteLandingPage {
+  const page = structuredClone(landing.page)
+  const source = { file: landing.source, line: 1 }
+  const publish = (value: string, link = false): string => {
+    if (ABSOLUTE_URL.test(value) || value.startsWith('#')) return value
+    if (value.startsWith('/')) return `${ctx.base}${value.slice(1)}`
+    if (link) {
+      const reference = documentLinkOf(ctx)(source, value)
+      if (reference) {
+        const href = documentPage(site, ctx.base, docs)(reference)
+        if (href) return href
+        throw new Error(WEB_MESSAGES[deckLocale(siteLanguage(site))].invalidSiteParameter(`site.landing: ${value}`))
+      }
+      const path = value.replace(/[?#].*$/s, '')
+      if (!extname(path)) return `${ctx.base}${value.replace(/^\.\//, '')}`
+    }
+    const file = resolve(dirname(landing.source), safeDecodeURIComponent(value.replace(/[?#].*$/s, '')))
+    if (existsSync(file) && basename(realpathSync(file)) === DOCUMENT_ENTRY) throw new Error(WEB_MESSAGES[deckLocale(siteLanguage(site))].invalidSiteParameter(`site.landing: ${value}`))
+    const result = publishedFile(ctx, outDir, base, source, value)
+    if (!result) throw new Error(WEB_MESSAGES[deckLocale(siteLanguage(site))].invalidSiteParameter(`site.landing: ${value}`))
+    return result
+  }
+  const actions = (items: { link: string }[] | undefined) => items?.forEach(action => { action.link = publish(action.link, true) })
+  if (page.hero) {
+    if (page.hero.image) page.hero.image = publish(page.hero.image)
+    actions(page.hero.actions)
+  }
+  for (const section of page.sections) {
+    if (section.type === 'features') for (const item of section.items) {
+      if (item.image) item.image = publish(item.image)
+      if (item.link) item.link = publish(item.link, true)
+    }
+    if (section.type === 'media') {
+      section.src = publish(section.src)
+      if (section.poster) section.poster = publish(section.poster)
+      if (section.captions) section.captions = Object.fromEntries(Object.entries(section.captions).map(([lang, url]) => [lang, publish(url)]))
+    }
+    if (section.type === 'cta') actions(section.actions)
+  }
+  return page
+}
+
+/** The public content collection available to a free-form HTML template. */
+export function siteContent(site: SiteSpec, base: string, lang: string, documents: HomeDocument[]): SiteContent {
+  return { schemaVersion: 1, title: siteTitle(site, lang), base, lang, documents: documents.map(({ dir, title, href, description, lang, tags, pages }) => ({ id: dir, title, href, description, lang, tags, pages })) }
+}

package/src/node/offline.ts

@@ -0,0 +1,153 @@
+import { createHash } from 'node:crypto'
+import { readdirSync, readFileSync, statSync, writeFileSync } from 'node:fs'
+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'
+
+interface OfflineCache {
+  prefix: string
+  cache: string
+  urls: string[]
+  runtimeCache: string
+  runtimes: string[]
+  runtimeBytes: number
+  base: string
+  app: 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}
+const RUNTIME_PATHS = new Set(RUNTIMES)
+
+self.addEventListener('install', (event) => {
+  event.waitUntil(caches.open(CACHE).then(cache => cache.addAll(URLS)).then(() => self.skipWaiting()))
+})
+
+self.addEventListener('activate', (event) => {
+  event.waitUntil(caches.keys()
+    .then(keys => Promise.all(keys.filter(key => key.startsWith(PREFIX) && key !== CACHE && key !== RUNTIME_CACHE).map(key => caches.delete(key))))
+    .then(() => self.clients.claim()))
+})
+
+async function cached(request) {
+  const url = new URL(request.url)
+  url.search = ''
+  url.hash = ''
+  const path = url.pathname
+  const candidates = [url.href]
+  if (path.endsWith('/')) candidates.push(url.href + 'index.html')
+  else if (!/\\.[^/]+$/.test(path)) candidates.push(url.href + '.html')
+  for (const candidate of candidates) {
+    const hit = await caches.match(candidate, { cacheName: CACHE })
+    if (hit) return hit
+  }
+  return undefined
+}
+
+/** A runtime file from its cache, else from the network, kept for next time. */
+async function runtime(href) {
+  const cache = await caches.open(RUNTIME_CACHE)
+  const hit = await cache.match(href)
+  if (hit) return hit
+  const response = await fetch(href)
+  if (response.status === 200) await cache.put(href, response.clone())
+  return response
+}
+
+const runtimeUrls = () => RUNTIMES.map(path => new URL(path, self.location.origin).href)
+
+async function saved() {
+  const cache = await caches.open(RUNTIME_CACHE)
+  const kept = new Set((await cache.keys()).map(request => request.url))
+  return runtimeUrls().every(href => kept.has(href))
+}
+
+async function save() {
+  for (const href of runtimeUrls()) {
+    const response = await runtime(href)
+    if (response.status !== 200) throw new Error(href + ': ' + response.status)
+  }
+}
+
+self.addEventListener('message', (event) => {
+  const port = event.ports[0]
+  const type = event.data && event.data.type
+  if (!port) return
+  if (type === ${JSON.stringify(OFFLINE_REQUESTS.runtimes)}) {
+    event.waitUntil(saved().then(done => port.postMessage({ bytes: RUNTIME_BYTES, saved: done })))
+  } else if (type === ${JSON.stringify(OFFLINE_REQUESTS.save)}) {
+    event.waitUntil(save().then(() => port.postMessage({ ok: true }), () => port.postMessage({ ok: false })))
+  }
+})
+
+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) || 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(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())))
+  }
+})
+`
+}
+
+function fallbackFonts(dir: string, all: string[]): Set<string> {
+  const unused = new Set<string>()
+  for (const file of all.filter(f => f.endsWith('.css'))) {
+    for (const [, face] of readFileSync(join(dir, file), 'utf8').matchAll(/@font-face\s*\{([^}]*)\}/g)) {
+      if (!/woff2/.test(face!)) continue
+      for (const [, url] of face!.matchAll(/url\(\s*["']?([^"')]+\.(?:woff|ttf))["']?\s*\)/g)) unused.add(url!.split('/').pop()!)
+    }
+  }
+  return unused
+}
+
+function files(dir: string): string[] {
+  const all = readdirSync(dir, { recursive: true, encoding: 'utf8' })
+    .filter(file => statSync(join(dir, file)).isFile() && file !== SERVICE_WORKER)
+    .sort()
+  const unused = fallbackFonts(dir, all)
+  return all.filter(file => !unused.has(file.split(sep).pop()!))
+}
+
+const isRuntime = (file: string) => /^(?:pyodide|wasi|presmium\/jax-js)\//.test(file) && !/(?:^|\/)LICENSES?$/.test(file)
+
+/**
+ * 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[]) => {
+    const digest = createHash('sha256')
+    for (const file of names) digest.update(file).update(readFileSync(join(outDir, file)))
+    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)
+  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/presmium.ts

@@ -0,0 +1,10 @@
+import { createRequire } from 'node:module'
+import type { PresmiumNodePlugin } from '@lincyaw/kernel'
+import { WEB_ID } from '../domain/index.ts'
+import { renderer } from './renderer.ts'
+
+const { version } = createRequire(import.meta.url)('../../package.json') as { version: string }
+
+const plugin: PresmiumNodePlugin = { id: WEB_ID, version, kernel: '^1.0.0', renderer }
+
+export default plugin