vowel 0.6.3 → 0.7.0-beta.0

package/package.json

@@ -1,11 +1,15 @@
 {
   "name": "vowel",
   "type": "module",
-  "version": "0.6.3",
+  "version": "0.7.0-beta.0",
+  "engines": {
+    "node": ">=26"
+  },
   "bin": "bin.js",
   "main": "index.js",
   "scripts": {
-    "test": "node --test tests/*.js"
+    "test": "node --test tests/*.js",
+    "build:editor": "cd plugins/html/editor && rollup -c"
   },
   "keywords": [
     "markdown",
@@ -15,21 +19,35 @@
   "author": "Sam Littlefair",
   "license": "MIT",
   "description": "Markdown websites",
+  "devDependencies": {
+    "@rollup/plugin-node-resolve": "^16.0.3",
+    "linkedom": "^0.18.13",
+    "rollup": "^4.0.0",
+    "rollup-plugin-cleanup": "^3.2.1",
+    "rollup-plugin-svelte": "^7.2.3",
+    "svelte": "^5.56.9"
+  },
   "dependencies": {
     "@bomb.sh/args": "^0.3.1",
     "@bomb.sh/tab": "^0.0.15",
     "@clack/prompts": "^1.4.0",
     "@jsdevtools/rehype-toc": "^3.0.2",
     "autoprefixer": "^10.4.27",
+    "colorhorse": "^0.3.1",
     "cssnano": "^7.1.4",
+    "emojilib": "^4.0.3",
     "encoding-sniffer": "^1.0.2",
     "fast-xml-parser": "^5.3.6",
     "faye-websocket": "^0.11.4",
+    "github-slugger": "^2.0.0",
     "hast-util-from-html": "^2.0.3",
     "hast-util-to-string": "^3.0.1",
+    "hast-util-to-text": "^4.0.2",
     "hastscript": "^9.0.1",
+    "highlight.js": "^11.12.0",
     "js-yaml": "^4.1.0",
-    "lightningcss": "^1.32.0",
+    "lightningcss": "^1.33.0",
+    "lowlight": "^3.3.0",
     "mdast": "^2.3.2",
     "mdast-normalize-headings": "^4.0.0",
     "mdast-util-from-markdown": "^2.0.2",
@@ -37,6 +55,7 @@
     "mdast-util-gfm-strikethrough": "^2.0.0",
     "mdast-util-gfm-table": "^2.0.0",
     "mdast-util-gfm-task-list-item": "^2.0.0",
+    "mdast-util-highlight-mark": "^1.2.2",
     "mdast-util-to-hast": "^13.2.1",
     "mdast-util-to-markdown": "^2.1.2",
     "mdast-util-to-string": "^4.0.0",
@@ -44,6 +63,7 @@
     "micromark-extension-gfm-footnote": "^2.1.0",
     "micromark-extension-gfm-table": "^2.1.1",
     "micromark-extension-gfm-task-list-item": "^2.1.0",
+    "micromark-extension-highlight-mark": "^1.2.0",
     "postcss": "^8.5.9",
     "rehype": "^13.0.2",
     "rehype-document": "^7.0.3",
@@ -58,7 +78,9 @@
     "remark-html": "^16.0.1",
     "remark-parse": "^11.0.0",
     "remark-rehype": "^11.1.2",
+    "rollup-plugin-import-css": "^4.2.1",
     "sharp": "^0.35.3",
+    "svedit": "^0.14.0",
     "unified": "^11.0.5",
     "unist-util-find": "^3.0.0",
     "unist-util-is": "^6.0.0",
@@ -69,12 +91,25 @@
     "unist-util-visit-parents": "^6.0.0",
     "unpic": "^4.2.2",
     "url-metadata": "^5.4.1",
-    "voot": "^0.1.0",
-    "votive": "^0.4.0",
+    "votive": "0.5.0-beta.0",
     "xast-util-sitemap": "^2.0.0",
     "xast-util-to-xml": "^4.0.0",
     "xml": "^1.0.1",
     "yaml": "^2.8.2",
     "yamljs": "^0.3.0"
-  }
-}
+  },
+  "files": [
+    "bin.js",
+    "cli.js",
+    "config.js",
+    "extractDate.js",
+    "index.js",
+    "secretPaths.js",
+    "systemPaths.js",
+    "utils.js",
+    "plugins",
+    "stylesheets",
+    "!plugins/html/bundle.js",
+    "!plugins/html/editorClient.js"
+  ]
+}

package/plugins/assets/index.js

@@ -0,0 +1,65 @@
+import { statSync } from "node:fs"
+import path from "node:path"
+
+/** @import * as Votive from "votive" */
+
+/**
+ * Files the site publishes as they are: video, data and documents an
+ * author links to from a page. Copied through byte for byte - like a
+ * font - with one rule: **a file over the size limit is not published.**
+ * Cloudflare Pages refuses any single file over 25 MiB, and a deploy
+ * that fails on one video is worse than a build that says so up front.
+ * The read (deferred, like every buffer read) stats the source rather
+ * than reading it, logs one error naming the file and its size, and
+ * makes the target virtual, so nothing lands on disk and nothing links
+ * to it as though it were there. The limit is `config.assetSizeLimit`
+ * in bytes for a host that allows more.
+ *
+ * Per Sam (Sept 19): copy through mp4 and csv, with a reasonable file
+ * size limit. The list is what people link to from a page and expect
+ * to be there; adding an extension is adding it here.
+ */
+
+const EXTENSIONS = [".mp4", ".webm", ".csv", ".json", ".pdf"]
+
+/** 25 MiB: Cloudflare Pages' per-file limit. */
+const DEFAULT_SIZE_LIMIT = 25 * 1024 * 1024
+
+/** @param {number} bytes */
+const megabytes = (bytes) => `${(bytes / (1024 * 1024)).toFixed(1)} MB`
+
+/**
+ * @type {Votive.ProcessorRead}
+ */
+function readAsset(source, { config }) {
+  const limit = Number(config.assetSizeLimit) || DEFAULT_SIZE_LIMIT
+  const { size } = statSync(path.join(config.sourceFolder, source.path))
+  if (size <= limit) return { metadata: { size } }
+
+  config.log?.("error", `${source.path} is ${megabytes(size)}; files over ${megabytes(limit)} are not published (Cloudflare Pages refuses them). Host it elsewhere and link to it.`)
+  return { metadata: { size, oversized: true }, write: false }
+}
+
+/** @type {Votive.ProcessorWrite} */
+function writeAsset(target) {
+  if (target.metadata?.oversized) return undefined
+  return { data: target.buffer() }
+}
+
+/** @type {Votive.VotiveProcessor} */
+const assetsProcessor = {
+  format: "buffer",
+  extensions: EXTENSIONS,
+  router: ({ name, dir, ext }) => ({ name, dir, ext }),
+  readFile: readAsset,
+  writeFile: writeAsset
+}
+
+/** @type {Votive.VotivePlugin} */
+const vowelAssetsPlugin = {
+  name: "vowel-assets",
+  processors: [assetsProcessor]
+}
+
+export default vowelAssetsPlugin
+export { EXTENSIONS, DEFAULT_SIZE_LIMIT }

package/plugins/atproto/index.js

@@ -0,0 +1,132 @@
+import path from "node:path"
+import { pageRecord, publicationURI, siteOrigin } from "./record.js"
+import { publishToAtproto } from "./publish.js"
+import { saveAppPassword } from "./password.js"
+
+/** @import * as Votive from "votive" */
+
+/**
+ * AT Protocol, phase one: the site's domain becomes the account's handle.
+ *
+ * An AT Protocol account is a DID (`did:plc:…`), and a domain becomes its
+ * handle when the domain proves it points at that DID - one of the two
+ * proofs is serving the DID as plain text at `/.well-known/atproto-did`.
+ * That is a file, so it is a stub: declared when settings.md says
+ *
+ *     atproto_did: did:plc:abc123
+ *
+ * and gone, file and all, when it stops saying so. Deploying the site is
+ * then the verification. Nothing here talks to the network; the author
+ * pastes the DID from their account settings. Resolving it from a handle
+ * is a later phase, through readURL like any other fetch.
+ *
+ * Phase two: a page under an `atproto_lexicon:` gets an AT-URI and a record,
+ * computed by `transformFile` with no network (record.js), and a
+ * `<link rel="site.standard.document">` from the html plugin. Publishing
+ * is a command, `atproto-publish` (publish.js), which makes the account's
+ * records match the site. See tasks/2-in-progress/atproto-integration.md.
+ *
+ * The publication: with a `domain` too, the site is a
+ * `site.standard.publication`, every document's `site` names it, and
+ * `/.well-known/site.standard.publication` serves its AT-URI - the
+ * domain's claim to it. The record is the publish command's.
+ */
+
+const WELL_KNOWN = path.join(".well-known", "atproto-did")
+const WELL_KNOWN_PUBLICATION = path.join(".well-known", "site.standard.publication")
+
+/** A DID is `did:<method>:<id>`; that is all this checks. */
+function validDID(value) {
+  return typeof value === "string" && /^did:[a-z]+:[A-Za-z0-9._:%-]+$/.test(value)
+}
+
+/**
+ * The account, from the nearest settings.md that names one. The atproto
+ * settings are flat, `atproto_did` / `atproto_lexicon` / `atproto_pds`,
+ * so each cascades on its own: a folder that sets only a lexicon keeps
+ * the root's account. Not reserved, so each arrives as `fm_atproto_*`.
+ * @param {{ lastNonNull: (label: string) => unknown }} settings
+ */
+function atprotoDID(settings) {
+  return settings.lastNonNull("fm_atproto_did")
+}
+
+/**
+ * The page's AT-URI and record, stored as metadata for the html plugin's
+ * link and the publish command. Runs once per read of the page; nothing
+ * here reaches the network. A page missing a property its lexicon
+ * requires is not a record (mentioned under `verbose`); an unsupported
+ * lexicon is warned about.
+ */
+function transformFile(target, { settings, config }) {
+  if (target.write === false) return undefined
+  const did = atprotoDID(settings)
+  if (!validDID(did)) return undefined
+
+  const domain = settings.lastNonNull("fm_domain")
+  const result = pageRecord(target, { did, domain, settings })
+  if ("skip" in result) return undefined
+  if ("incomplete" in result) {
+    config.log("info", `${target.path}: ${result.incomplete}`)
+    return undefined
+  }
+  if ("warning" in result) {
+    config.log("warn", `${target.path}: ${result.warning}`)
+    return undefined
+  }
+  return { metadata: { atUri: result.atUri, atprotoRecord: result.record } }
+}
+
+/** @type {Votive.ProcessorStubs} */
+function createStubs({ settings }) {
+  const did = atprotoDID(settings)
+  if (!did) return []
+  if (!validDID(did)) {
+    throw new Error(`settings.md: atproto_did must look like did:plc:… or did:web:…, not ${JSON.stringify(did)}`)
+  }
+  const origin = siteOrigin(settings.lastNonNull("fm_domain"))
+  const publication = origin ? [{ path: WELL_KNOWN_PUBLICATION, params: { text: publicationURI(did, origin) } }] : []
+  return [{ path: WELL_KNOWN, params: { text: did } }, ...publication]
+}
+
+/** @type {Votive.ProcessorExpand} */
+function expandStubs({ params }) {
+  return { text: params.text }
+}
+
+/**
+ * Claims files with **no extension**, which is what a well-known file
+ * is, and `.publication`, which `site.standard.publication` looks like
+ * one to. The scan never hands this processor a real file - dot-folders
+ * are skipped - so only the stubs arrive; a file elsewhere in the project
+ * with either (a LICENSE) is read here and routed nowhere.
+ * @type {Votive.VotiveProcessor}
+ */
+const wellKnownProcessor = {
+  extensions: ["", ".publication"],
+  format: "text",
+  router: ({ dir, name, ext }) => dir.includes(".well-known") ? { dir, name, ext } : false,
+  createStubs,
+  expandStubs,
+  readFile: (source) => ({ data: source.text, metadata: {} }),
+  writeFile: (target) => ({ data: target.data })
+}
+
+const recordProcessor = {
+  extensions: [".html"],
+  format: "text",
+  transformFile
+}
+
+/** @type {Votive.VotivePlugin} */
+const vowelAtprotoPlugin = {
+  name: "vowel-atproto",
+  processors: [wellKnownProcessor, recordProcessor],
+  commands: {
+    "atproto-publish": publishToAtproto,
+    "atproto-password": saveAppPassword
+  }
+}
+
+export default vowelAtprotoPlugin
+export { validDID, atprotoDID }

package/plugins/atproto/password.js

@@ -0,0 +1,71 @@
+import { mkdir, writeFile } from "node:fs/promises"
+import path from "node:path"
+import { password as promptPassword, isCancel } from "@clack/prompts"
+import votive from "votive"
+import { passwordFile, resolvePDS, xrpc } from "./publish.js"
+
+/**
+ * `vowel --command atproto-password`: saves the account's app password
+ * where `atproto-publish` looks for it (publish.js's `passwordFile`).
+ *
+ * Asked for with a masked prompt, so it never lands in shell history. With
+ * no terminal to ask in - a Publish button, CI - it comes from the
+ * payload, `{"password": "…"}`.
+ *
+ * With an `atproto_did` in the root settings.md, the password is checked
+ * by logging in, and a password for another account, or none, is refused
+ * before anything is written. Without one it is saved unchecked, and
+ * said so. The file is readable by its owner only.
+ *
+ * @param {{ password?: string } | undefined} payload
+ * @param {{ config: import("votive").VotiveConfig, notify: (message: object) => void }} context
+ */
+async function saveAppPassword(payload, { config, notify }) {
+  const given = typeof payload?.password === "string" ? payload.password.trim() : ""
+  const password = given || await askForPassword()
+
+  const { did, pds: configuredPDS } = await account(config)
+  const verified = typeof did === "string" && did !== ""
+  if (verified) {
+    const pds = typeof configuredPDS === "string" && configuredPDS ? configuredPDS : await resolvePDS(did)
+    notify({ status: "progress", message: `Checking the password with ${pds}...` })
+    const session = await xrpc(pds, "com.atproto.server.createSession", { body: { identifier: did, password } })
+    if (session.did !== did) throw new Error(`atproto: that app password is for ${session.did}, not ${did}; nothing saved`)
+  }
+
+  const file = passwordFile(config.sourceFolder)
+  await mkdir(path.dirname(file), { recursive: true })
+  await writeFile(file, password, { mode: 0o600 })
+
+  const checked = verified ? `checked against ${did}` : "not checked: no atproto_did in settings.md"
+  notify({ status: "done", message: `Saved the app password to ${file} (${checked})` })
+  return { saved: file, verified }
+}
+
+/** The masked prompt, or an error saying what to pass instead. */
+async function askForPassword() {
+  if (!process.stdin.isTTY) {
+    throw new Error("atproto: no terminal to ask in; pass the app password as {\"password\": \"…\"}")
+  }
+  const answer = await promptPassword({ message: "App password (from your Bluesky settings)" })
+  if (isCancel(answer) || !answer.trim()) throw new Error("atproto: no app password given; nothing saved")
+  return answer.trim()
+}
+
+/**
+ * The root's `atproto_did` and `atproto_pds`, from a build of the site -
+ * settings are the database's to resolve.
+ * @param {import("votive").VotiveConfig} config
+ */
+async function account(config) {
+  const site = await votive({ ...config, verbose: false })
+  try {
+    await site.build({ defer: false })
+    const root = site.database.setting.getByFolder("")
+    return { did: root.lastNonNull("fm_atproto_did"), pds: root.lastNonNull("fm_atproto_pds") }
+  } finally {
+    await site.close()
+  }
+}
+
+export { saveAppPassword }