vowel 0.7.0-beta.0 → 0.7.1

package/plugins/atproto/publish.js

@@ -5,41 +5,51 @@ import path from "node:path"
 import sharp from "sharp"
 import votive from "votive"
 import { systemDirectoryFor } from "../../systemPaths.js"
-import { DOCUMENT, PUBLICATION, siteOrigin, publicationURI } from "./record.js"
+import { EXPECTED } from "../markdown/frontmatter.js"
+import { contentSection } from "../xml/entryContent.js"
+import { PUBLICATION, siteOrigin, publicationURI, pageRecordURI } from "./record.js"
+import { createLexiconResolver, resolvePDS } from "./lexicons.js"
+import { mapRecord } from "./mapper.js"
+import { markdownBody, richTextBody } from "./body.js"
 
 /**
  * `vowel --command atproto-publish`: make the account's records match the
- * site.
+ * site's pages.
  *
- * The PDS is the ledger. The command builds the site, collects the record
- * each page's transform stored (`metadata.atprotoRecord`), lists what the
- * PDS holds, and sends the difference through `applyWrites`: a record the
- * site has and the PDS does not is created, one that differs is updated,
- * and one the PDS has for this site and the site no longer produces is
- * deleted. Nothing is remembered between runs, so clearing a cache
- * cannot cause a resend, a revert publishes, and a coworker sees the
- * same state.
+ * The command builds the site, fetches every lexicon a page names
+ * (lexicons.js; cached in memory), fits each page to its lexicon
+ * (mapper.js), lists what the PDS holds in each collection, and sends the
+ * difference through `applyWrites`: a record the PDS doesn't have is
+ * created, one that differs is updated. Nothing is remembered between
+ * runs, so clearing a cache cannot cause a resend, a revert publishes,
+ * and a coworker sees the same state.
  *
- * **Only this site's records are ever deleted.** `listRecords` returns
- * every record in the collection, including ones another site or app
- * published to the same account. A record is this site's when its `site`
- * is this site's origin. A record at one of our keys with another `site`
- * is a collision; it is reported and left alone.
+ * **Vowel owns only the records it creates** - the ones at keys it
+ * derives from the site's page URLs (rkey.js). It never deletes one on
+ * its own: a record whose page is gone can't be told from anyone else's,
+ * because its key can no longer be derived. A page with
+ * `status: deleted` is how a record is deleted - the page stays in the
+ * project, unwritten, so its key can still be derived.
+ *
+ * A page that doesn't fit its lexicon - a required property with no
+ * value, a lexicon that isn't published - is left out with a warning.
  *
  * The build uses a throwaway database, so every page is read and every
  * transform runs against current settings. A transform only re-runs when
  * its source is re-read (tasks/1-proposed/transform-reruns-on-stale.md),
  * so a warm database could hold records built from old settings.
  *
- * **The publication goes first.** One `site.standard.publication` per
- * site, at the key record.js derives from the origin: `url` from
- * `domain:`, `name` from the root `name:` (else the homepage's title),
- * and `description` and `icon` from the root's `atproto_publication:`.
- * The icon defaults to `logo:`. It is rendered to a 512px square PNG and
- * its blob reference - CID, type, size - computed here, so an unchanged
- * icon compares equal and is never uploaded again; a changed one is
- * uploaded just before the write that names it. The publication is
- * created and updated, never deleted.
+ * **The publication goes first**, when any page publishes to
+ * `site.standard.*`: standard.site defines a document's `site` as its
+ * publication. One `site.standard.publication` per site, at the key
+ * record.js derives from the origin: `url` from `domain:`, `name` from
+ * the root `name:` (else the homepage's title), and `description` and
+ * `icon` from the root's `atproto_publication:`. The icon defaults to
+ * `logo:`. It is rendered to a 512px square PNG and its blob reference -
+ * CID, type, size - computed here, so an unchanged icon compares equal
+ * and is never uploaded again; a changed one is uploaded just before the
+ * write that names it. The publication is created and updated, never
+ * deleted.
  *
  * The app password comes from `ATPROTO_APP_PASSWORD`, or from a file
  * named `atproto-app-password` in the project's system directory, never
@@ -47,6 +57,9 @@ import { DOCUMENT, PUBLICATION, siteOrigin, publicationURI } from "./record.js"
  * and sends nothing, and does not need the password. `{"optional": true}`
  * makes a site with no `atproto_did` a skip rather than an error, for
  * the `publish` command, which runs this after every deploy.
+ *
+ * `config.atprotoLexicons` replaces the lexicon resolver - for tests,
+ * which can't publish a DNS record.
  */
 
 const PASSWORD_FILE = "atproto-app-password"
@@ -143,27 +156,6 @@ async function xrpc(pds, nsid, { query, body, bytes, mimeType, token } = {}) {
   throw new Error(`${nsid}: ${response.status} ${json.error ?? ""} ${json.message ?? ""}`.trim())
 }
 
-/**
- * The PDS that hosts `did`, from its DID document. `did:plc` is resolved
- * through the PLC directory, `did:web` through its own host.
- * @param {string} did
- */
-async function resolvePDS(did) {
-  const documentURL = did.startsWith("did:plc:")
-    ? `https://plc.directory/${did}`
-    : did.startsWith("did:web:")
-      ? `https://${decodeURIComponent(did.slice("did:web:".length))}/.well-known/did.json`
-      : undefined
-  if (!documentURL) throw new Error(`atproto: can't resolve ${did}; set atproto_pds in settings.md`)
-
-  const response = await fetch(documentURL, { signal: AbortSignal.timeout(TIMEOUT) })
-  if (!response.ok) throw new Error(`atproto: resolving ${did} failed: ${response.status}`)
-  const document = await response.json()
-  const service = (document.service ?? []).find(entry => entry.id === "#atproto_pds" || entry.id === `${did}#atproto_pds`)
-  if (!service) throw new Error(`atproto: ${did} names no PDS`)
-  return service.serviceEndpoint
-}
-
 /**
  * Where the app password is kept: the project's system directory, never
  * the project, so it is neither committed nor deployed.
@@ -203,14 +195,83 @@ async function listAll(pds, did, collection, cursor) {
 const rkeyOf = (uri) => uri.slice(uri.lastIndexOf("/") + 1)
 
 /**
- * What the site should hold: every stored record, by rkey, the site's
- * own settings, and the publication's name, description and icon. The
- * icon is read from the build's output - it is a URL path from the root
- * (frontmatter.js resolves it), which is where the output has it. Built
- * into a scratch folder that is removed afterwards.
+ * The default `$type` for a body that goes into an open union - a
+ * `content` any lexicon may fill, like standard.site's. MarkPub's
+ * markdown lexicon, fetched and interpreted like any other; a folder's
+ * `atproto_content:` names another.
+ */
+const CONTENT_LEXICON = "at.markpub.markdown"
+
+/**
+ * The page as mapper.js reads it: its title, description, date, image
+ * and tags, the frontmatter keys that are the author's own (every key
+ * vowel reads for itself is left out), and its body - both forms, made
+ * only when asked for, from the rendered page. Every value is read now:
+ * a target's properties are lazy database reads, and the build's
+ * database is closed before anything is mapped.
+ * @param {any} target
+ * @param {string} pageURL
+ */
+function pageFor(target, pageURL) {
+  const { metadata } = target
+  const declared = Array.isArray(metadata.frontmatter_keys) ? metadata.frontmatter_keys : []
+  const frontmatter = Object.fromEntries(declared
+    .filter(key => !(key in EXPECTED) && `fm_${key}` in metadata)
+    .map(key => [key, metadata[`fm_${key}`]]))
+  const html = target.data
+  const section = () => contentSection(html)
+  return {
+    title: metadata.title,
+    description: metadata.description,
+    date: metadata.date,
+    image: metadata.image,
+    tags: metadata.tags,
+    frontmatter,
+    markdown: () => markdownBody(section(), pageURL),
+    richText: (features) => richTextBody(section(), pageURL, features)
+  }
+}
+
+/**
+ * The folder whose settings a page reads: the page as a folder -
+ * `blog/post.html` → `blog/post` - which is what votive hands a write
+ * (`pageSettingsFolder` in votive's lib/utils, not exported), so publish
+ * sees each page's lexicon exactly as its write did. `index.html` is
+ * `/index` there, and here.
+ * @param {string} targetPath
+ */
+function pageSettingsFolder(targetPath) {
+  const segments = targetPath.split("/").filter(Boolean)
+  const folder = path.relative("", [...segments.slice(0, -1), ""].join(path.sep))
+  return folder + path.sep + path.parse(targetPath).name
+}
+
+/**
+ * Every page under a lexicon, with its AT-URI: the author's own pages -
+ * a generated one (a tag page, a folder index, the default home or 404)
+ * is a stub, and inherits a folder's lexicon without being anything to
+ * publish.
+ * @param {any} database - a built site's
+ * @returns {{ target: any, uri: string }[]}
+ */
+function recordPages(database) {
+  const stubs = new Set(database.source.getStubs().map(row => row.path))
+  return database.target.getAll()
+    .filter(target => target.extension === ".html" && !stubs.has(target.source))
+    .map(target => ({ target, uri: pageRecordURI(target, database.setting.getByFolder(pageSettingsFolder(target.path))).uri }))
+    .filter(page => typeof page.uri === "string")
+}
+
+/**
+ * What the site should hold: every page under a lexicon - its AT-URI,
+ * its status, and what mapper.js reads - the site's own settings, and
+ * the publication's name, description and icon. The icon is read from
+ * the build's output - it is a URL path from the root (frontmatter.js
+ * resolves it), which is where the output has it. Built into a scratch
+ * folder that is removed afterwards.
  * @param {import("votive").VotiveConfig} config
  */
-async function collectRecords(config) {
+async function collectPages(config) {
   const scratch = await mkdtemp(path.join(tmpdir(), "vowel-atproto-"))
   try {
     const site = await votive({
@@ -225,9 +286,21 @@ async function collectRecords(config) {
       const did = root.lastNonNull("fm_atproto_did")
       const pds = root.lastNonNull("fm_atproto_pds")
       const domain = root.lastNonNull("fm_domain")
-      const targets = site.database.target.getAll()
-      const pages = targets.filter(target => "atUri" in target.metadata && "atprotoRecord" in target.metadata)
-      const records = pages.map(target => ({ uri: target.metadata.atUri, value: target.metadata.atprotoRecord }))
+      const origin = siteOrigin(domain)
+      const pages = recordPages(site.database).map(({ target, uri }) => {
+        const [, , account, collection, rkey] = uri.split("/")
+        const pageURL = new URL(target.metadata.prettyURL, origin).href
+        const contentLexicon = site.database.setting.getByFolder(target.dir).lastNonNull("fm_atproto_content")
+        return {
+          path: target.path,
+          account,
+          collection,
+          rkey,
+          deleted: target.metadata.fm_status === "deleted",
+          context: { origin, pageURL, path: target.metadata.prettyURL, contentLexicon: typeof contentLexicon === "string" && contentLexicon ? contentLexicon : CONTENT_LEXICON },
+          page: target.metadata.fm_status === "deleted" ? undefined : pageFor(target, pageURL)
+        }
+      })
 
       const settings = root.lastNonNull("fm_atproto_publication") ?? {}
       const home = site.database.target.get("index.html")
@@ -235,7 +308,7 @@ async function collectRecords(config) {
       const iconPath = settings.icon ?? root.lastNonNull("logo")
       const icon = iconPath ? await readIcon(path.join(scratch, "output"), iconPath) : undefined
       const publication = { name, description: settings.description, iconPath, icon }
-      return { did, pds, domain, records, publication }
+      return { did, pds, domain, pages, publication }
     } finally {
       await site.close()
     }
@@ -275,46 +348,49 @@ function planPublication(remote, rkey, value) {
 }
 
 /**
- * The writes that make `remote` match `local`, plus the collisions.
- * @param {{ uri: string, value: any }[]} local
- * @param {{ uri: string, value: any }[]} remote
- * @param {Set<string>} sites - the `site` values that are this site's
+ * The writes that make the account match the site. `local` is the
+ * records the pages make, `deleted` the keys of pages whose status is
+ * `deleted`; `remote` is what the PDS holds in those collections, keyed
+ * `<collection>/<rkey>`. A record the PDS doesn't hold is created, one
+ * that differs is updated, and a deleted page's record is deleted if it
+ * is there. Nothing else in a collection is touched.
+ * @param {{ collection: string, rkey: string, value: unknown }[]} local
+ * @param {{ collection: string, rkey: string }[]} deleted
+ * @param {Map<string, unknown>} remote
  */
-function planWrites(local, remote, sites) {
-  const remoteByKey = new Map(remote.map(record => [rkeyOf(record.uri), record]))
-  const localKeys = new Set(local.map(record => rkeyOf(record.uri)))
-
-  const compared = local.map(record => {
-    const rkey = rkeyOf(record.uri)
-    const existing = remoteByKey.get(rkey)
-    if (!existing) return { action: "create", rkey, value: record.value }
-    if (!sites.has(existing.value?.site)) return { action: "collision", rkey, site: existing.value?.site }
-    if (sameRecord(existing.value, record.value)) return { action: "unchanged", rkey }
-    return { action: "update", rkey, value: record.value }
+function planWrites(local, deleted, remote) {
+  const compared = local.map(({ collection, rkey, value }) => {
+    const existing = remote.get(`${collection}/${rkey}`)
+    if (existing === undefined) return { action: "create", collection, rkey, value }
+    if (sameRecord(existing, value)) return { action: "unchanged", collection, rkey }
+    return { action: "update", collection, rkey, value }
   })
-
-  const deletions = remote
-    .filter(record => sites.has(record.value?.site) && !localKeys.has(rkeyOf(record.uri)))
-    .map(record => ({ action: "delete", rkey: rkeyOf(record.uri) }))
-
+  const deletions = deleted
+    .filter(({ collection, rkey }) => remote.has(`${collection}/${rkey}`))
+    .map(({ collection, rkey }) => ({ action: "delete", collection, rkey }))
   return [...compared, ...deletions]
 }
 
-/** @param {{ action: string, rkey: string, value?: unknown, collection?: string }} write */
-function applyWrite({ action, rkey, value, collection = DOCUMENT }) {
+/** @param {{ action: string, collection: string, rkey: string, value?: unknown }} write */
+function applyWrite({ action, collection, rkey, value }) {
   const base = { $type: `com.atproto.repo.applyWrites#${action}`, collection, rkey }
   return action === "delete" ? base : { ...base, value }
 }
 
+const defaultResolver = createLexiconResolver()
+
 /**
  * @param {{ dryRun?: boolean, optional?: boolean } | undefined} payload
- * @param {{ config: import("votive").VotiveConfig, notify: (message: object) => void }} context
+ * @param {{ config: import("votive").VotiveConfig & { atprotoLexicons?: ReturnType<typeof createLexiconResolver> }, notify: (message: object) => void }} context
  */
 async function publishToAtproto(payload, { config, notify }) {
   const dryRun = Boolean(payload?.dryRun)
+  // A command's config comes straight from the caller and may carry no
+  // logger; votive() adds one only to the config its hooks receive.
+  const log = config.log ?? ((level, message) => console.error(message))
 
   notify({ status: "progress", message: "Building..." })
-  const { did, pds: configuredPDS, domain, records, publication } = await collectRecords(config)
+  const { did, pds: configuredPDS, domain, pages, publication } = await collectPages(config)
 
   if ((typeof did !== "string" || !did) && payload?.optional) {
     notify({ status: "done", message: "No atproto_did in settings.md; nothing to publish to AT Protocol" })
@@ -324,34 +400,54 @@ async function publishToAtproto(payload, { config, notify }) {
   const origin = siteOrigin(domain)
   if (!origin) throw new Error("atproto: set domain in the root settings.md; every record carries the site's url")
 
-  const accounts = new Set(records.map(record => record.uri.split("/")[2]))
-  const others = [...accounts].filter(account => account !== did)
+  const others = [...new Set(pages.map(page => page.account))].filter(account => account !== did)
   if (others.length) throw new Error(`atproto: pages name ${others.join(", ")}; one site publishes to one account (${did})`)
 
-  if (typeof publication.name !== "string" || !publication.name) {
+  // The publication, only for a site that publishes to standard.site.
+  const live = pages.filter(page => !page.deleted)
+  const standardSite = live.some(page => page.collection.startsWith("site.standard."))
+  if (standardSite && (typeof publication.name !== "string" || !publication.name)) {
     throw new Error("atproto: set name in the root settings.md; the publication needs one")
   }
+  const publicationURL = standardSite ? publicationURI(did, origin) : undefined
+
+  notify({ status: "progress", message: "Fetching lexicons..." })
+  const resolver = config.atprotoLexicons ?? defaultResolver
+  const roots = [...new Set(live.flatMap(page => [page.collection, page.context.contentLexicon]))]
+  const { lexicons, errors } = await resolver.load(roots)
+
+  const mapped = live.map(page => {
+    const context = { ...page.context, publication: publicationURL }
+    const unresolved = errors.get(page.collection)
+    const result = unresolved ? { ignored: unresolved, warnings: [] } : mapRecord(page.collection, page.page, { lexicons, context })
+    result.warnings.forEach(warning => log("warn", `${page.path}: ${warning}`))
+    if ("ignored" in result) log("warn", `${page.path}: not published to AT Protocol: ${result.ignored}`)
+    return { page, result }
+  })
+  const local = mapped
+    .filter(({ result }) => "record" in result)
+    .map(({ page, result }) => ({ collection: page.collection, rkey: page.rkey, value: result.record }))
+  const deleted = pages.filter(page => page.deleted).map(({ collection, rkey }) => ({ collection, rkey }))
 
-  const icon = publication.icon ? await iconBlob(publication.icon, publication.iconPath) : undefined
-  const publicationRecord = {
+  const icon = standardSite && publication.icon ? await iconBlob(publication.icon, publication.iconPath) : undefined
+  const publicationRecord = standardSite ? {
     $type: PUBLICATION,
     url: origin,
     name: publication.name,
     ...(typeof publication.description === "string" && publication.description ? { description: publication.description } : {}),
     ...(icon ? { icon: icon.ref } : {})
-  }
-  const publicationURL = publicationURI(did, origin)
+  } : undefined
 
-  // A document is this site's when its `site` is the publication, or the
-  // origin a loose document carried before there was one.
-  const sites = new Set([origin, publicationURL, ...records.map(record => record.value.site)])
   const pds = typeof configuredPDS === "string" && configuredPDS ? configuredPDS : await resolvePDS(did)
 
-  notify({ status: "progress", message: `Comparing ${records.length} records with ${pds}...` })
-  const remote = await listAll(pds, did, DOCUMENT)
-  const remotePublications = await listAll(pds, did, PUBLICATION)
-  const publicationWrite = planPublication(remotePublications, rkeyOf(publicationURL), publicationRecord)
-  const plan = planWrites(records, remote, sites)
+  const collections = [...new Set([...local, ...deleted].map(record => record.collection))]
+  notify({ status: "progress", message: `Comparing ${local.length} records with ${pds}...` })
+  const listed = await Promise.all(collections.map(collection => listAll(pds, did, collection)))
+  const remote = new Map(listed.flatMap((records, index) => records.map(record => [`${collections[index]}/${rkeyOf(record.uri)}`, record.value])))
+  const plan = planWrites(local, deleted, remote)
+  const publicationWrite = publicationRecord
+    ? planPublication(await listAll(pds, did, PUBLICATION), rkeyOf(publicationURL), publicationRecord)
+    : { action: "none" }
 
   const count = (action) => plan.filter(write => write.action === action).length
   const summary = {
@@ -359,20 +455,14 @@ async function publishToAtproto(payload, { config, notify }) {
     updated: count("update"),
     deleted: count("delete"),
     unchanged: count("unchanged"),
-    collisions: plan.filter(write => write.action === "collision").map(({ rkey, site }) => ({ rkey, site })),
+    ignored: mapped.filter(({ result }) => "ignored" in result).length,
     publication: publicationWrite.action,
     dryRun
   }
-  // A command's config comes straight from the caller and may carry no
-  // logger; votive() adds one only to the config its hooks receive.
-  const log = config.log ?? ((level, message) => console.error(message))
-  for (const { rkey, site } of summary.collisions) {
-    log("error", `atproto: ${DOCUMENT}/${rkey} belongs to ${site}, not ${origin}; left alone`)
-  }
 
-  const publicationWrites = publicationWrite.action === "unchanged" ? [] : [{ ...publicationWrite, collection: PUBLICATION }]
-  const documentWrites = plan.filter(write => ["create", "update", "delete"].includes(write.action))
-  const writes = [...publicationWrites, ...documentWrites].map(applyWrite)
+  const publicationWrites = ["create", "update"].includes(publicationWrite.action) ? [{ ...publicationWrite, collection: PUBLICATION }] : []
+  const recordWrites = plan.filter(write => ["create", "update", "delete"].includes(write.action))
+  const writes = [...publicationWrites, ...recordWrites].map(applyWrite)
   if (dryRun || !writes.length) {
     notify({ status: "done", message: `${dryRun ? "Would send" : "Nothing to send"}: ${JSON.stringify(summary)}` })
     return summary
@@ -403,4 +493,4 @@ async function publishToAtproto(payload, { config, notify }) {
   return summary
 }
 
-export { publishToAtproto, planWrites, planPublication, sameRecord, resolvePDS, blobCID, xrpc, passwordFile }
+export { publishToAtproto, recordPages, pageSettingsFolder, planWrites, planPublication, sameRecord, resolvePDS, blobCID, xrpc, passwordFile }

package/plugins/atproto/record.js

@@ -1,19 +1,31 @@
-import { toText } from "hast-util-to-text"
 import { MARKER } from "../../secretPaths.js"
 import createRkey from "./rkey.js"
+import { validNSID } from "./lexicons.js"
 
 /**
- * Which pages become records, and what each record holds. No network:
- * everything here is a function of the page and its settings, so it runs
- * in the build, and the publish command only compares and sends.
+ * Which pages become records, and where each record lives. No network,
+ * and no lexicon: a page's lexicon and AT-URI are a function of the page
+ * and its settings (`pageRecordURI`), worked out wherever they're needed -
+ * the html plugin's write, for standard.site's `<link>`, and
+ * atproto-publish. The record itself is made at publish (publish.js),
+ * once the lexicon has been fetched (lexicons.js) and the page fitted to
+ * it (mapper.js).
+ *
+ * At write, not in a transform: a transform runs only when its page is
+ * read, so adding `atproto_did` or a lexicon to a settings.md changed
+ * nothing for pages already built - not even after a restart, since the
+ * database persists (tasks/1-proposed/transform-reruns-on-stale.md).
+ * Settings read at write are tracked, so a change re-renders the pages
+ * it reaches.
+ *
+ * `site.standard.publication` is the one lexicon named here: standard.site
+ * defines a document's `site` as its publication's AT-URI, and vowel
+ * interprets that standard as written - the site is a publication when
+ * any of its pages publish to `site.standard.*`.
  */
 
-const DOCUMENT = "site.standard.document"
 const PUBLICATION = "site.standard.publication"
 
-/** The lexicons vowel can build a record for. */
-const SUPPORTED = [DOCUMENT]
-
 /**
  * The page's lexicon and, for a secret page, whether it may use it.
  *
@@ -74,71 +86,48 @@ function publicationURI(did, origin) {
   return `at://${did}/${PUBLICATION}/${createRkey(origin)}`
 }
 
-/**
- * A `site.standard.document` record for the page, or the list of what it
- * is missing. `title`, `publishedAt` and `site` are required by the
- * lexicon; a page without a date cannot be a document. `site` is the
- * publication's AT-URI; `origin` is what the page's key is made from.
- * @param {{ metadata: Record<string, any> }} target
- * @param {string | undefined} origin
- * @param {string} [site] - the publication's AT-URI
- * @returns {{ record: Record<string, unknown> } | { missing: string[] }}
- */
-function documentRecord(target, origin, site = origin) {
-  const { title, date, prettyURL, description, tags, hastAbstract } = target.metadata
-  const published = date ? new Date(date) : undefined
-  const validDate = published && !Number.isNaN(published.getTime())
-
-  const missing = [
-    ...(origin ? [] : ["domain"]),
-    ...(title ? [] : ["title"]),
-    ...(validDate ? [] : ["date"])
-  ]
-  if (missing.length) return { missing }
-
-  const textContent = hastAbstract ? toText(hastAbstract).trim() : ""
-
-  const record = {
-    $type: DOCUMENT,
-    site,
-    path: prettyURL,
-    title,
-    publishedAt: published.toISOString(),
-    ...(description ? { description } : {}),
-    ...(Array.isArray(tags) && tags.length ? { tags } : {}),
-    ...(textContent ? { textContent } : {})
-  }
-  return { record }
+/** A DID is `did:<method>:<id>`; that is all this checks. @param {unknown} value */
+function validDID(value) {
+  return typeof value === "string" && /^did:[a-z]+:[A-Za-z0-9._:%-]+$/.test(value)
 }
 
 /**
- * The page's AT-URI and record, or why it has none. `skip` is silent (the
- * page is not meant to be published). `incomplete` is a page under a
- * lexicon that lacks a property the lexicon requires; it is not a record,
- * by design, and is only mentioned under `verbose`. `warning` is a
- * misconfiguration: a lexicon vowel cannot build.
- * @param {{ path: string, source?: string, metadata: Record<string, any> }} target
- * @param {{ did: string, domain: unknown, settings: any }} context
- * @returns {{ atUri: string, record: Record<string, unknown> } | { skip: true } | { incomplete: string } | { warning: string }}
+ * The page's AT-URI, from the page and its settings - the page-as-folder
+ * view a write gets (`blog/post.html` reads `""`, `blog`, `blog/post`).
+ * None for a page with `status: hidden`, which is listed nowhere, nor for
+ * one that isn't written (`html_file: false`) - except `status: deleted`,
+ * which is kept unwritten precisely so publish can delete its record.
+ * None without an account, a `domain` (the key is made from the page's
+ * url) or a lexicon. A lexicon name that isn't an NSID comes back as a
+ * warning; whether the page fits its lexicon is publish's question.
+ * @param {{ source?: string, write?: boolean, metadata: Record<string, any> }} target
+ * @param {any} settings
+ * @returns {{ uri?: string, warning?: string }}
  */
-function pageRecord(target, { did, domain, settings }) {
+function pageRecordURI(target, settings) {
+  const status = target.metadata.fm_status
+  if (status === "hidden") return {}
+  if (target.write === false && status !== "deleted") return {}
+  const did = settings.lastNonNull("fm_atproto_did")
+  if (!validDID(did)) return {}
+  const origin = siteOrigin(settings.lastNonNull("fm_domain"))
+  if (!origin) return {}
   const lexicon = lexiconFor(target, settings)
-  if (!lexicon) return { skip: true }
-  if (!SUPPORTED.includes(lexicon)) {
-    return { warning: `lexicon "${lexicon}" is not one vowel can build a record for (supported: ${SUPPORTED.join(", ")})` }
-  }
-
-  const origin = siteOrigin(domain)
-  const site = origin ? publicationURI(did, origin) : undefined
-  const built = documentRecord(target, origin, site)
-  if ("missing" in built) {
-    return { incomplete: `not published to AT Protocol: a ${lexicon} record needs ${built.missing.join(", ")}` }
-  }
+  if (!lexicon) return {}
+  if (!validNSID(lexicon)) return { warning: `atproto_lexicon "${lexicon}" is not a lexicon name (an NSID, like app.bsky.feed.post)` }
+  return { uri: recordURI(did, lexicon, origin, target.metadata.prettyURL) }
+}
 
-  // The key is the page's canonical URL - origin and path - and frozen
-  // (rkey.js), whatever `site` holds.
-  const rkey = createRkey(new URL(String(built.record.path), origin).href)
-  return { atUri: `at://${did}/${lexicon}/${rkey}`, record: built.record }
+/**
+ * The page's AT-URI: the account, the lexicon, and a key derived from
+ * the page's canonical URL - origin and path - and frozen (rkey.js).
+ * @param {string} did
+ * @param {string} lexicon
+ * @param {string} origin
+ * @param {string} prettyURL
+ */
+function recordURI(did, lexicon, origin, prettyURL) {
+  return `at://${did}/${lexicon}/${createRkey(new URL(prettyURL, origin).href)}`
 }
 
-export { DOCUMENT, PUBLICATION, SUPPORTED, lexiconFor, siteOrigin, publicationURI, documentRecord, pageRecord }
+export { PUBLICATION, validDID, lexiconFor, siteOrigin, publicationURI, recordURI, pageRecordURI }

package/plugins/deploy-cloudflare/index.js

@@ -66,7 +66,10 @@ async function deployToCloudflarePages(payload, { config, notify }) {
     proc.stdout.on("data", chunk => notify({ status: "progress", message: chunk.toString() }))
     proc.stderr.on("data", chunk => notify({ status: "progress", message: chunk.toString() }))
 
-    proc.on("error", reject) // e.g. wrangler isn't installed
+    proc.on("error", error => {
+      if (error.code !== "ENOENT") return reject(error)
+      reject(new Error("wrangler isn't installed, and deploying to Cloudflare Pages needs it. Install it with `npm install -g wrangler`, then deploy again."))
+    })
     proc.on("exit", code => {
       if (code === 0) resolve({ deployed: true, projectName })
       else reject(new Error(`wrangler exited with code ${code}`))