@panphora/clayjs 1.18.1 → 1.20.0

package/docs/guide.md

@@ -4,7 +4,7 @@ This is the complete reference for building malleable documents with ClayJS: one
 
 It is written for a developer or an LLM building full apps with inline editing and inline controls: kanban boards with card detail, block writers, finance trackers, CRMs, flashcards, trackers. It covers the CMS plugin only in passing ([cms: content-managed pages](https://clayjs.com/docs/guide/components/#cms-content-managed-pages)), because an app whose product is editing should not route editing through a form sidebar.
 
-Every behavior stated here was read from ClayJS 1.17.0 source or executed. The four example files below are complete, tested apps that this guide quotes. A [test suite](https://github.com/panphora/clayjs/tree/main/tests/unit/guide-examples) boots each one in jsdom with the real loader and checks what it saves, how it merges a peer's edit, and what a viewer receives. Open any of them and view source, or download one and open it in HTML Clay to edit it:
+Every behavior stated here was read from ClayJS 1.17.0 source or executed. The four example files below are complete, tested apps that this guide quotes. A [test suite](https://github.com/hyperspacesystems/clayjs/tree/main/tests/unit/guide-examples) boots each one in jsdom with the real loader and checks what it saves, how it merges a peer's edit, and what a viewer receives. Open any of them and view source, or download one and open it in HTML Clay to edit it:
 
 | File | What it shows |
 |---|---|
@@ -314,6 +314,7 @@ Plugins add editing, sync, and UI features to `clay.js`. Most are off by default
 | `cms` | off | yes | `clay.cms`; implies `quickcrop` and `upload` |
 | `wire` | off | yes | `clay.wire`, the channel to a local agent process |
 | `message` | off | yes | `message-form`: a visitor's contact form to the owner, `clay.message` ([message: contact forms](https://clayjs.com/docs/guide/components/#message-contact-forms)) |
+| `like` | off | yes | `like`: a like button on any element, counted by the host, `clay.like` ([like](https://clayjs.com/docs/plugins/like/)) |
 | `ai-edit` | off | no | select text, ask an agent to rewrite it; implies `wire` |
 | `demo` | off | yes | fakes saving into `localStorage` for public demos |
 | `visitor-drafts` | off | yes | `clay.visitorDrafts`; in draft mode, the draft store, download prompt and intro area; outside it, only the owner chip, fetched when the owner edits ([Free documents for visitors](https://clayjs.com/docs/guide/free-documents/)) |
@@ -891,7 +892,23 @@ Traps in this table:
 - **Fill a scratchpad after `clay.ready`, and insert new ones empty.** The contents are captured when the element first appears. Content written before boot, or present in a cloned element when inserted, becomes its saved contents. Empty the scratchpads in a copied record before inserting it.
 - **Create `editor-ui` roots at runtime from an unmarked `<template>` on every load.** An `editor-ui` root disappears from the saved file, so it cannot be authored in the file. Do not mark the blueprint inside the `<template>` as `editor-ui`, or the first save empties the template and leaves no chrome to clone on the next load. Leave the blueprint unmarked and set `clay="editor-ui"` on each clone as you insert it.
 
-### 4.3 `persist`: form controls
+### 4.3 Copy policy: `no-copy` and `no-copy-unless:paid-forms`
+
+Save and sync tokens govern the working document; copy-policy tokens on `clay` govern what travels into an explicit copy:
+
+```html
+<script src="/analytics.js" defer clay="no-copy"></script>
+<header class="intro" clay="no-copy">…</header>
+<form action="/_/message" method="post" clay="no-copy-unless:paid-forms">…</form>
+```
+
+- **Normal saves keep the original.** Ordinary saves, live sync, versions, and automatic recovery retain `no-copy` and conditional regions.
+- **Explicit copies strip `no-copy` content, even for the owner.** Copies, duplicates, forks, HTML downloads, and ZIP exports remove `clay="no-copy"` elements (including inside `<template>` contents). User-requested recovery downloads filter visible HTML and embedded earlier HTML pages while preserving recovery records and edits.
+- **Authored loaders vs runtime scripts.** An authored loader marked `clay="no-copy"` stays in original saves and disappears from copies. Any SDK `<script>` added at runtime uses `clay="no-save no-snapshot no-watch no-copy"` so it is not persisted. ClayJS core knows only generic copy policy, not any analytics provider.
+- **Conditional paid forms.** `clay="no-copy-unless:paid-forms"` aliases legacy `data-paid-only="forms"` (still supported). Hosted copy/create checks the destination's existing `paid-forms` (`forms`) entitlement; offline downloads have no destination entitlement and strip optional conditional content. Reusable templates retain conditional regions for creation-time filtering, while unconditional `no-copy` regions are removed before owned template outputs. Exact case-sensitive matching fails closed, so an unknown conditional spelling cannot disguise a required paid feature.
+- **Supporting hosts and raw file limits.** Enforced in ClayJS client downloads and recovery exports, Hyperclay hosted copy/create/download flows, and Hyperclay Local / HTML Clay copies and exports. Finder, `cp`, and browser Save Page As bypass app hooks and copy raw file bytes unchanged.
+
+### 4.4 `persist`: form controls
 
 Put `persist` on every `<input>`, `<textarea>`, and `<select>` whose value belongs to the record. A control's typed value is a property, not an attribute, and serialization only reads attributes. Without `persist`, a typed value is lost on save and the file keeps the authored `value`.
 
@@ -912,7 +929,7 @@ Put `persist` on every `<input>`, `<textarea>`, and `<select>` whose value belon
 
 **After undo, redo, or a merge, ClayJS puts each control's display back in step with its attributes.** A control the user has touched shows its live property, not its attribute. A merge and the undo plugin copy `checked`, `value`, and `selected` back onto the property (undo does this for `persist` controls outside `no-undo` regions). A merge leaves the focused text field alone, while undo restores it too.
 
-### 4.4 Where to keep data that is not visible text
+### 4.5 Where to keep data that is not visible text
 
 In order of preference:
 
@@ -934,7 +951,7 @@ In order of preference:
 4. **A live JSON script (`clay="live"`)** for state that changes faster than a save: game boards, scores, cursors ([Live data: `clay="live"`](https://clayjs.com/docs/guide/live-sync/#live-data-clay-live)).
 5. **`<template>` content: never for mutable data.** It is saved, but edits there never trigger autosave.
 
-### 4.5 Element identity: `data-id` and `id`
+### 4.6 Element identity: `data-id` and `id`
 
 Live sync and undo pair elements across versions by **`data-id`, then `id`**, used only when the value is unique on its side and the tag names match. Without an id, elements pair by content, which works for distinct text and fails for identical new items.
 
@@ -955,11 +972,11 @@ Live sync and undo pair elements across versions by **`data-id`, then `id`**, us
 - **A `data-id` is also what presence names.** A record target `{ kind: "record", id }` carries it, so a stable id is what lets a peer's badge find the row again after a reload or a merge ([Presence](https://clayjs.com/docs/guide/live-sync/#presence)).
 - **Use ids to find records in commands:** `` board.querySelector(`.card[data-id="${CSS.escape(id)}"]`) ``. Never find a record by position.
 
-### 4.6 Assets
+### 4.7 Assets
 
 ClayJS saves an image through its `src`. Upload the file and write the returned URL ([upload and quickcrop](https://clayjs.com/docs/guide/components/#upload-and-quickcrop)). Every host returns a host path such as `/_/uploads/assets-<name>/photo-ab12.png`, which keeps working on that host when the document is renamed or moved. A document opened straight from disk shows those images broken; Export as zip takes a document with its files. Where the host cannot store files, embed a `data:` URL. Data URLs work anywhere, but every save carries the bytes, so keep embedded images small.
 
-### 4.7 Ephemeral state: per-tab state on saved elements
+### 4.8 Ephemeral state: per-tab state on saved elements
 
 Use `ephemeral` for per-tab state on a saved element, such as a selected card, a row being dragged, or an open section. Toggling a normal class or attribute is an edit like any other: it marks the page unsaved, starts an autosave, adds an undo step, reaches every peer, and lands in the file. Mark it `ephemeral` instead:
 
@@ -981,7 +998,7 @@ clay.ephemeral.toggle(card, "selected");   // add, remove, toggle(el, word, forc
 
 Use `ephemeral` for state on one element. State that comes from the URL hash and spans many records (the open card, a filter) is still painted with a runtime stylesheet ([Per-tab state](https://clayjs.com/docs/guide/architecture/#per-tab-state)).
 
-### 4.8 A template is an ordinary record with a tag
+### 4.9 A template is an ordinary record with a tag
 
 A reusable template is a record like any other, marked with a tag. It stays editable, searchable, exported, synced and in a visitor's draft, and it needs no second store and no new format. The app reads the tag off the body it already has:
 
@@ -991,7 +1008,7 @@ const templates = open => Entries.live().filter(a => a !== open && summary({ bod
 
 The tag is matched outside code spans and fences, so a template entry that shows a `#template` example does not become a template itself. Using one copies its text into the page, and the new record is written by the same save as everything else.
 
-### 4.9 Keep a helper that reads the text beside the editor, in an `editor-ui` row
+### 4.10 Keep a helper that reads the text beside the editor, in an `editor-ui` row
 
 A helper that reacts to the text being written belongs in a row a script builds beside the editor, marked `clay="editor-ui"`, and refreshed on a debounce. Nothing it draws is saved, printed or synced, and no keystroke pays for it beyond the debounce:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@panphora/clayjs",
-  "version": "1.18.1",
+  "version": "1.20.0",
   "type": "module",
   "description": "clayjs: malleable documents. Save lifecycle for self-saving HTML.",
   "license": "MIT-0",
@@ -66,11 +66,13 @@
   "scripts": {
     "test": "node scripts/test-guard.mjs",
     "measure:load": "node scripts/measure-load.mjs",
+    "test:perf": "node scripts/test-guard.mjs --runInBand --testMatch '**/tests/perf/**/*.test.js' tests/perf",
     "test:conformance": "UPDATE_GOLDENS=0 web-test-runner --config conformance/wtr.config.mjs",
     "conformance:update": "UPDATE_GOLDENS=1 web-test-runner --config conformance/wtr.config.mjs",
     "build:standalone": "node build.js --standalone",
     "prepack": "node build.js --standalone",
     "test:standalone": "node build.js --standalone && web-test-runner --config tests/browser/wtr.config.mjs",
+    "browser:install": "node scripts/chrome-for-testing/browser-runtime.cjs install",
     "prepublishOnly": "testbox run",
     "dev": "node tests/stub-server.mjs",
     "build": "npm run build:bevel && npm run build:skins && node build.js",
@@ -110,7 +112,7 @@
     "marked": "18.0.14",
     "overtype": "2.6.1",
     "parse5": "^7.3.0",
-    "playwright": "1.62.1",
+    "playwright": "1.64.1",
     "postcss": "^8.5.28",
     "prosemirror-commands": "1.7.2",
     "prosemirror-dropcursor": "1.8.4",

package/src/core/conflict-download.js

@@ -1,6 +1,7 @@
 import { serializeRecoveryClone, captureRecoveryPage } from "./snapshot.js";
 import { rowOf } from "./conflict-presentation.js";
 import { documentName, downloadHtml } from "./download.js";
+import { stripCopyContent } from "./copy-content.js";
 
 export { documentName, downloadHtml };
 
@@ -31,12 +32,12 @@ export function buildRecovery(records, { refused = false } = {}) {
     if (apply && !seen.has(apply.id)) { seen.add(apply.id); applies.push(apply); }
   }
   applies.sort((a, b) => (a.ticket || 0) - (b.ticket || 0));
-  const pageOf = (a) => serializeRecoveryClone(a.recoveryRoot ?? a.root, { prepared: a.domain === "save" });
+  const pageOf = (a) => stripCopyContent(serializeRecoveryClone(a.recoveryRoot ?? a.root, { prepared: a.domain === "save" }));
 
   let html;
   let older;
   if (refused || !applies.length) {
-    html = captureRecoveryPage();
+    html = stripCopyContent(captureRecoveryPage());
     older = applies;
   } else {
     html = pageOf(applies[applies.length - 1]);
@@ -66,9 +67,9 @@ export function buildRecovery(records, { refused = false } = {}) {
 // The review panel's own copy: the page a reload kept, when there is one, with every
 // stored row it drew listed beside it as JSON. The rows are already plain, so nothing
 // here reads the ledger the tab no longer has.
-export function downloadStored({ html = null, edits = [] } = {}) {
+export async function downloadStored({ html = null, edits = [] } = {}) {
   try {
-    const page = typeof html === "string" ? html : captureRecoveryPage();
+    const page = stripCopyContent(typeof html === "string" ? html : captureRecoveryPage());
     const data = {
       format: "clay-lost-edits",
       version: 1,
@@ -78,17 +79,17 @@ export function downloadStored({ html = null, edits = [] } = {}) {
       edits: Array.isArray(edits) ? edits : [],
       earlierPages: [],
     };
-    return downloadHtml({ html: embed(page, data), name: `${documentName()}-my-copy-${stamp()}.html` });
+    return await downloadHtml({ html: embed(page, data), name: `${documentName()}-my-copy-${stamp()}.html` });
   } catch (err) {
     console.error("clayjs: could not build the download", err);
     return false;
   }
 }
 
-export function downloadRecovery(records, { refused = false } = {}) {
+export async function downloadRecovery(records, { refused = false } = {}) {
   try {
     const { html, name } = buildRecovery(records, { refused });
-    return downloadHtml({ html, name });
+    return await downloadHtml({ html, name });
   } catch (err) {
     console.error("clayjs: could not build the download", err);
     return false;

package/src/core/conflict-notice-ui.js

@@ -707,12 +707,12 @@ async function onRevert() {
 let downloadedTimer = null;
 
 // Download my copy. Nothing here acknowledges or releases a record.
-function onDownload() {
+async function onDownload() {
   const l = ledger();
   // A refusal ends in a reload that takes every record with it, so its copy carries
   // all of them; a replaced notice covers the rows it drew.
   const records = refused ? (l?.list() ?? []) : renderedIds.map((id) => l?.get(id)).filter(Boolean);
-  const ok = downloadRecovery(records, { refused: !!refused });
+  const ok = await downloadRecovery(records, { refused: !!refused });
   downloadFailed = !ok;
   downloaded = ok;
   clearTimeout(downloadedTimer);
@@ -801,14 +801,14 @@ async function onCopyStored(entry) {
 
 // Download my copy, from the stored root: the page as this tab had it, with the
 // losing text in it. Nothing here acknowledges or releases a record.
-function onDownloadRecovered() {
+async function onDownloadRecovered() {
   const record = recovered.find((item) => item.root);
   const edits = [];
   for (const item of recovered) {
     for (const entry of item.conflicts) edits.push({ id: entry.id, kind: entry.kind, name: storedName(entry), yours: entry.yours, now: entry.now, sentence: entry.sentence });
   }
   for (const entry of recoveredUndo) edits.push({ id: entry.id, kind: entry.kind, name: entry.name, yours: entry.yours, now: entry.now, sentence: entry.sentence });
-  const ok = downloadStored({ html: record?.root ?? null, edits });
+  const ok = await downloadStored({ html: record?.root ?? null, edits });
   downloadFailed = !ok;
   downloaded = ok;
   clearTimeout(downloadedTimer);

package/src/core/copy-content.js

@@ -0,0 +1,103 @@
+// Copy-only content: marked regions that stay in the file, in normal saves, in snapshots
+// and in recovery storage, and are removed only from the bytes of a copy someone asks for.
+// The removal is a splice on the original string using parse5's source offsets, so every
+// byte outside a removed range survives, templates and implicit end tags included.
+
+import { parse } from "../vendor/parse5.vendor.js";
+
+const CLAY = "clay";
+const PAID_ONLY = "data-paid-only";
+const NO_COPY = "no-copy";
+const CONDITIONAL_FORMS = "no-copy-unless:paid-forms";
+const CLAY_TOKENS = /[\t\n\f\r ]+/;
+
+function attributeOf(node, name) {
+  return node.attrs?.find((attr) => attr.name === name)?.value ?? null;
+}
+
+function childrenOf(node) {
+  return node.content ? [...(node.childNodes || []), node.content] : (node.childNodes || []);
+}
+
+function eachElement(node, visit) {
+  visit(node);
+  for (const child of childrenOf(node)) eachElement(child, visit);
+}
+
+function clayTokensOf(node) {
+  return (attributeOf(node, CLAY) ?? "").split(CLAY_TOKENS);
+}
+
+// The marker is compared to a feature key exactly: no trim, no lowercase, so a typo, an
+// empty value or `FORMS` strips nothing and the content stays, which is the direction
+// that fails closed. `clay="no-copy-unless:paid-forms"` is the approved spelling of the
+// same condition.
+function paidMarkersOf(node) {
+  const markers = [];
+  const value = attributeOf(node, PAID_ONLY);
+  if (value !== null) markers.push(value);
+  if (clayTokensOf(node).includes(CONDITIONAL_FORMS)) markers.push("forms");
+  return [...new Set(markers)];
+}
+
+function lastDescendantEnd(node) {
+  let end = null;
+  eachElement(node, (entry) => {
+    const entryEnd = entry.sourceCodeLocation?.endOffset;
+    if (typeof entryEnd === "number" && entryEnd >= 0 && (end === null || entryEnd > end)) end = entryEnd;
+  });
+  return end;
+}
+
+function endOffsetFor(node) {
+  const location = node.sourceCodeLocation;
+  if (typeof location?.endOffset === "number" && location.endOffset >= 0) return location.endOffset;
+  const fallback = lastDescendantEnd(node) ?? location?.startTag?.endOffset ?? null;
+  if (fallback === null) return null;
+  console.warn(`clayjs: <${node.tagName}> has no end offset; removing through ${fallback}`);
+  return fallback;
+}
+
+function markedRanges(html, features) {
+  const ranges = [];
+  eachElement(parse(html, { sourceCodeLocationInfo: true }), (node) => {
+    const markers = paidMarkersOf(node);
+    const unconditional = clayTokensOf(node).includes(NO_COPY);
+    const conditional = features === null ? markers.length > 0 : markers.some((marker) => features.includes(marker));
+    if (!unconditional && !conditional) return;
+    const start = node.sourceCodeLocation?.startOffset;
+    const end = typeof start === "number" ? endOffsetFor(node) : null;
+    if (typeof start === "number" && start >= 0 && end !== null && end > start) ranges.push({ start, end });
+  });
+  return ranges.filter((range, index) => !ranges.some((other, otherIndex) =>
+    otherIndex !== index && other.start <= range.start && range.end <= other.end));
+}
+
+function leadingRunStart(html, start) {
+  const newline = html.lastIndexOf("\n", start - 1);
+  if (newline < 0 || /\S/.test(html.slice(newline + 1, start))) return start;
+  return html[newline - 1] === "\r" ? newline - 1 : newline;
+}
+
+function spliceRanges(html, ranges) {
+  const sorted = [...ranges].sort((a, b) => a.start - b.start);
+  let stripped = html;
+  let limit = html.length;
+  for (let index = sorted.length - 1; index >= 0; index -= 1) {
+    const { start, end } = sorted[index];
+    if (end > limit) continue;
+    const from = leadingRunStart(html, start);
+    if (from >= end) continue;
+    stripped = stripped.slice(0, from) + stripped.slice(end);
+    limit = from;
+  }
+  return stripped;
+}
+
+// `features` decides the conditional regions: null (the default, and the offline
+// destination) strips every one of them, while a list strips only the missing features
+// it names. Unconditional `no-copy` content always goes.
+export function stripCopyContent(html, features = null) {
+  if (typeof html !== "string" || !/clay|data-paid-only/i.test(html)) return html;
+  return spliceRanges(html, markedRanges(html, features));
+}

package/src/core/download.js

@@ -1,6 +1,13 @@
 // Saving a page as a file the browser downloads. Kept apart from the conflict copy
 // builders so an editor that only offers "download this page" loads none of them.
 
+const HTML_TYPES = ["text/html", "application/xhtml+xml"];
+
+function isHtml(type) {
+  if (typeof type !== "string") return false;
+  return HTML_TYPES.includes(type.split(";")[0].trim().toLowerCase());
+}
+
 export function documentName(pathname = location.pathname) {
   const last = pathname.split("/").filter(Boolean).pop();
   if (!last) return pathname.endsWith("/") || pathname === "" ? "index" : "page";
@@ -9,10 +16,15 @@ export function documentName(pathname = location.pathname) {
   return name.replace(/\.(html?|htmlclay)$/i, "") || "page";
 }
 
-export function downloadHtml({ html, name, type = "text/html" }) {
+export async function downloadHtml({ html, name, type = "text/html" }) {
   let url = null;
   try {
-    url = URL.createObjectURL(new Blob([html], { type }));
+    let contents = html;
+    if (isHtml(type) && typeof html === "string" && /clay|data-paid-only/i.test(html)) {
+      const { stripCopyContent } = await import("./copy-content.js");
+      contents = stripCopyContent(html);
+    }
+    url = URL.createObjectURL(new Blob([contents], { type }));
     const a = document.createElement("a");
     a.setAttribute("clay", "no-save no-watch no-snapshot");
     a.href = url;

package/src/core/save-size-notice.js

@@ -57,8 +57,8 @@ function place() {
 // The safe copy the conflict notice offers, for the same reason: a file the person can
 // open has to exist outside a host that will not store these bytes. It already reports
 // its own failure.
-function download() {
-  downloadStored({});
+async function download() {
+  await downloadStored({});
 }
 
 function build() {

package/src/core/upgrade-run.js

@@ -348,7 +348,11 @@ export async function pageBytes(clay, { loc = location, fetchFn = (url, init) =>
 export async function downloadCopy({ clay, doc = document, loc = location, fetchFn } = {}) {
   if (typeof URL === "undefined" || typeof URL.createObjectURL !== "function") return false;
   try {
-    const bytes = await pageBytes(clay, { loc, fetchFn });
+    let bytes = await pageBytes(clay, { loc, fetchFn });
+    if (typeof bytes === "string" && /clay|data-paid-only/i.test(bytes)) {
+      const { stripCopyContent } = await import("./copy-content.js");
+      bytes = stripCopyContent(bytes);
+    }
     const url = URL.createObjectURL(new Blob([bytes], { type: "text/html" }));
     const a = doc.createElement("a");
     a.setAttribute("clay", "editor-ui");

package/src/lib/region-policy.js

@@ -54,7 +54,7 @@ export const REGION_ATTRS = ['no-save', 'no-trigger-autosave', 'no-dirty', 'no-u
 // Every canonical token spellable inside the space-separated `clay` attribute.
 // Exported: this list used to exist as a private CLAY_TOKENS that nothing read,
 // while callers hardcoded their own copies.
-export const TOKENS = [...POLICY_TOKENS];
+export const TOKENS = [...POLICY_TOKENS, 'no-copy', 'no-copy-unless:paid-forms'];
 
 // True when a region marker is present, whether spelled as a `clay` token
 // (whitespace-token semantics, matching [clay~=token]) or a legacy bare attribute.

package/src/loader-logic.js

@@ -62,6 +62,9 @@ export const PLUGIN_PATHS = {
   // A visitor's contact form to the document's owner. Not editOnly: visitors are
   // who send messages.
   message:   { path: "plugins/message.js",         editOnly: false, default: false },
+  // A like button on any element, counted by the host. Not editOnly: visitors are
+  // who like.
+  like:      { path: "plugins/like.js",            editOnly: false, default: false },
   // Edit mode only: the AI comment box is an editing gesture. Opt in with
   // `plugins=ai-edit`; it stays dormant on any host that does not list a ready
   // `ai-edit` helper.
@@ -139,6 +142,7 @@ export const MODULES = {
   "plugins/menu.js":            () => import("./plugins/menu.js"),
   "plugins/wire.js":            () => import("./plugins/wire.js"),
   "plugins/message.js":         () => import("./plugins/message.js"),
+  "plugins/like.js":            () => import("./plugins/like.js"),
   "plugins/ai-edit.js":         () => import("./plugins/ai-edit.js"),
   "plugins/demo.js":            () => import("./plugins/demo.js"),
   "plugins/visitor-drafts.js": () => import("./plugins/visitor-drafts.js"),
@@ -151,7 +155,7 @@ export const MODULES = {
 
 // `source` is last on purpose: its install captures a save clone, so it wants every
 // plugin that registers a document transform to have registered it first.
-const PLUGIN_ORDER = ["visitor-drafts", "richclay", "indicator", "sortable", "undo", "unsent", "quickcrop", "upload", "people", "menu", "upgrade", "cms", "page-view", "sync", "live", "page", "message", "wire", "ai-edit", "demo", "derive", "bind-text", "source"];
+const PLUGIN_ORDER = ["visitor-drafts", "richclay", "indicator", "sortable", "undo", "unsent", "quickcrop", "upload", "people", "menu", "upgrade", "cms", "page-view", "sync", "live", "page", "message", "like", "wire", "ai-edit", "demo", "derive", "bind-text", "source"];
 
 // A plugin that cannot do its whole job alone. hypercms reads the cropper through
 // a capability lookup (`clay.quickcrop`) and silently uploads the raw file when it

package/src/loader.js

@@ -371,6 +371,8 @@ function attachPluginMember(path, mod, namespaces = loaded) {
     Object.defineProperty(clay, "me", { get: mod.currentMe, configurable: true, enumerable: true });
   } else if (path === "plugins/message.js") {
     clay.message = mod.message;
+  } else if (path === "plugins/like.js") {
+    clay.like = mod.like;
   } else if (path === "plugins/wire.js") {
     clay.wire = mod.wire || mod.default;
   } else if (path === "plugins/ai-edit.js") {

package/src/page/features/export-html.js

@@ -112,12 +112,12 @@ export function createFeature({ view = null, download = downloadHtml, fetch: fet
   }
 
   function decide(s) {
-    listen(s, s.panel, "click", (event) => {
+    listen(s, s.panel, "click", async (event) => {
       const b = event.target.closest?.("[data-act]");
       if (!b) return;
       event.preventDefault();
       if (b.dataset.act === "close") close();
-      else if (b.dataset.act === "download") save(s);
+      else if (b.dataset.act === "download") await save(s);
       else if (b.dataset.act === "retry") run().catch((error) => console.error("clayjs: the reading copy could not be made", error));
     });
     listen(s, doc, "keydown", (event) => {
@@ -130,9 +130,9 @@ export function createFeature({ view = null, download = downloadHtml, fetch: fet
 
   // The one place a reading copy becomes a file. The download is handed the bytes that
   // were shown, never a second render, so what a person saw is what they get.
-  function save(s) {
+  async function save(s) {
     if (!s.ready || disposed) return { ok: false, code: "not-editing" };
-    const saved = download({ html: s.ready.html, name: s.ready.name });
+    const saved = await download({ html: s.ready.html, name: s.ready.name });
     close();
     return { ok: saved === true, downloaded: saved === true };
   }

package/src/page/features/export-markdown.js

@@ -83,10 +83,10 @@ export function createFeature({ view = null, download = downloadHtml } = {}) {
     s.panel.replaceChildren(...parts);
   }
 
-  function save() {
+  async function save() {
     const s = session;
     if (!s) return { ok: false, code: "no-export" };
-    if (download({ html: s.report.text, name: s.name, type: "text/markdown" })) {
+    if (await download({ html: s.report.text, name: s.name, type: "text/markdown" })) {
       close();
       view.focus?.();
       return { ok: true, downloaded: true };

package/src/page/recovery-ui.js

@@ -228,12 +228,12 @@ export function createRecoveryReview({
     button.setAttribute("aria-expanded", "false");
   };
 
-  const download = () => {
+  const download = async () => {
     const edits = [];
     for (const row of rows) edits.push({ id: row.id, kind: "recovered-page", name: row.message, yours: row.text, now: "", sentence: row.message });
     const composing = "Text typed while composing never reached the page.";
     for (const row of journaled) edits.push({ id: row.id, kind: "composing", name: "Typed text", yours: row.text, now: "", sentence: composing });
-    if (!downloadStored({ html: null, edits })) failure = "That download could not be made.";
+    if (!(await downloadStored({ html: null, edits }))) failure = "That download could not be made.";
     draw();
   };
 

package/src/page/save-states.js

@@ -67,14 +67,14 @@ function withoutPageTag(html) {
 // One complete, openable file: the capture the save would have sent, with the
 // page projection already applied by the live store's snapshot listener, and
 // without the page editor's merge state, which no saved file or download carries.
-function downloadPageCopy() {
+async function downloadPageCopy() {
   const { forSave } = captureForSaveAndComparison({ emitForSync: false });
-  return downloadHtml({ html: withoutPageTag(forSave), name: `${documentName()}.html` });
+  return await downloadHtml({ html: withoutPageTag(forSave), name: `${documentName()}.html` });
 }
 
 // A copy of the page captured earlier (captureForSaveAndComparison().forSave), as a download.
-function downloadSnapshot(forSave) {
-  return downloadHtml({ html: withoutPageTag(forSave), name: `${documentName()}.html` });
+async function downloadSnapshot(forSave) {
+  return await downloadHtml({ html: withoutPageTag(forSave), name: `${documentName()}.html` });
 }
 
 // The article's own plain text, never the editor's chrome: the capture carries