@panphora/clayjs 1.15.2 → 1.16.0

package/src/core/upgrade-run.js

@@ -0,0 +1,408 @@
+import { replace as replaceDocument } from "./save-replace.js";
+import { lastSeenEtag } from "./etag.js";
+import { claimDocumentOperation, releaseDocumentOperation } from "./save-core.js";
+import { isNewerVersion } from "./version.js";
+import { upgrade, readMeta } from "../vendor/hyper-html-api-upgrade.vendor.js";
+
+const MANIFEST_FAILED = "The new version could not be downloaded. Nothing was changed.";
+const SAVE_FAILED = "The upgrade could not be saved. Nothing was changed.";
+const CONFLICT = "This document changed somewhere else. Reload and try again.";
+const BUSY = "Something else is changing this document. Nothing was changed.";
+
+async function digestOf(bytes) {
+  const subtle = globalThis.crypto && globalThis.crypto.subtle;
+  if (!subtle) return null;
+  const digest = await subtle.digest("SHA-256", bytes);
+  return [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+
+async function fetchOrNull(fetchFn, url) {
+  try {
+    const res = await fetchFn(url, { credentials: "omit" });
+    if (!res || !res.ok) return null;
+    return res;
+  } catch {
+    return null;
+  }
+}
+
+function manifestUrl(update, doc, loc) {
+  if (update && typeof update.latestUrl === "string" && update.latestUrl) return update.latestUrl;
+  const source = readMeta(doc, "hyper-source");
+  if (!source) return null;
+  try {
+    const url = new URL(source, loc ? loc.href : undefined);
+    url.pathname = url.pathname.replace(/\.html$/, ".json");
+    return url.href;
+  } catch {
+    return null;
+  }
+}
+
+function templateOf(doc) {
+  const value = readMeta(doc, "clay-template");
+  if (!value) return null;
+  const [id, variant] = value.split(/\s+/);
+  return id && variant ? { id, variant } : null;
+}
+
+function leavesOf(value, path = "", out = []) {
+  if (Array.isArray(value)) {
+    for (const item of value) leavesOf(item, `${path}[]`, out);
+    return out;
+  }
+  if (value && typeof value === "object") {
+    for (const [key, item] of Object.entries(value)) leavesOf(item, path ? `${path}.${key}` : key, out);
+    return out;
+  }
+  if (value !== null && value !== undefined) out.push({ path, value });
+  return out;
+}
+
+function valuesAt(data, pattern) {
+  let current = [data];
+  for (const part of String(pattern).split(".")) {
+    const list = part.endsWith("[]");
+    const key = list ? part.slice(0, -2) : part;
+    const next = [];
+    for (const node of current) {
+      const value = key ? node?.[key] : node;
+      if (list) {
+        if (Array.isArray(value)) next.push(...value);
+      } else {
+        next.push(value);
+      }
+    }
+    current = next;
+  }
+  return current;
+}
+
+export function lostValues(before, after, renames = {}) {
+  const kept = new Map();
+  for (const { path, value } of leavesOf(after)) {
+    const key = `${path}\u0000${String(value)}`;
+    kept.set(key, (kept.get(key) || 0) + 1);
+  }
+  const lost = [];
+  for (const { path, value } of leavesOf(before)) {
+    const key = `${path}\u0000${String(value)}`;
+    if (kept.get(key) > 0) {
+      kept.set(key, kept.get(key) - 1);
+      continue;
+    }
+    const renamed = renames[path];
+    if (typeof renamed === "string" && valuesAt(after, renamed).some((candidate) => candidate === value)) continue;
+    lost.push({ path, value });
+  }
+  return lost;
+}
+
+async function evaluateTransform(code) {
+  const blob = new Blob([code], { type: "text/javascript" });
+  const url = URL.createObjectURL(blob);
+  try {
+    return await new Function("url", "return import(url)")(url);
+  } finally {
+    URL.revokeObjectURL(url);
+  }
+}
+
+async function declaredRenames(htmlText) {
+  const sourceDoc = new DOMParser().parseFromString(htmlText, "text/html");
+  const tag = sourceDoc.querySelector('script[type="text/hyper-upgrade"]');
+  if (!tag) return {};
+  const mod = await evaluateTransform(tag.textContent || "");
+  return mod && mod.renames && typeof mod.renames === "object" ? mod.renames : {};
+}
+
+export async function prepare(update, {
+  doc = document,
+  loc = location,
+  fetchFn = (url, init) => fetch(url, init),
+} = {}) {
+  const clay = (typeof window !== "undefined" && window.clay) || {};
+  if (clay.isDraftMode) return { ok: false, code: "draft" };
+  if (!update || typeof update.version !== "string") return { ok: false, code: "unavailable", message: MANIFEST_FAILED };
+
+  const latestUrl = manifestUrl(update, doc, loc);
+  if (!latestUrl) return { ok: false, code: "unavailable", message: MANIFEST_FAILED };
+
+  const manifestRes = await fetchOrNull(fetchFn, latestUrl);
+  if (!manifestRes) return { ok: false, code: "unavailable", message: MANIFEST_FAILED };
+  let latest;
+  try {
+    latest = await manifestRes.json();
+  } catch {
+    return { ok: false, code: "unavailable", message: MANIFEST_FAILED };
+  }
+  if (!latest || typeof latest !== "object") return { ok: false, code: "unavailable", message: MANIFEST_FAILED };
+
+  const template = templateOf(doc);
+  if (!template || latest.id !== template.id || latest.variant !== template.variant) {
+    return { ok: false, code: "template", message: "This upgrade is for a different document." };
+  }
+  const fromVersion = readMeta(doc, "hyper-version");
+  if (!fromVersion || typeof latest.version !== "string" || !isNewerVersion(latest.version, fromVersion)) {
+    return { ok: false, code: "not-newer", message: "There is no newer version to install." };
+  }
+  if (typeof latest.html !== "string" || !latest.html) return { ok: false, code: "unavailable", message: MANIFEST_FAILED };
+
+  let htmlUrl;
+  try {
+    htmlUrl = new URL(latest.html, latestUrl).href;
+  } catch {
+    return { ok: false, code: "unavailable", message: MANIFEST_FAILED };
+  }
+  if (!/^https:\/\/hyperclay\.com\/templates\//.test(htmlUrl)) {
+    return { ok: false, code: "source", message: "This upgrade is not from the template host." };
+  }
+
+  const htmlRes = await fetchOrNull(fetchFn, htmlUrl);
+  if (!htmlRes) return { ok: false, code: "unavailable", message: MANIFEST_FAILED };
+  let htmlText;
+  try {
+    htmlText = await htmlRes.text();
+  } catch {
+    return { ok: false, code: "unavailable", message: MANIFEST_FAILED };
+  }
+  const digest = await digestOf(new TextEncoder().encode(htmlText));
+  if (!digest || digest !== String(latest.sha256 || "").toLowerCase()) {
+    return { ok: false, code: "unavailable", message: MANIFEST_FAILED };
+  }
+
+  let result;
+  let renames;
+  try {
+    renames = await declaredRenames(htmlText);
+    result = await upgrade.run({
+      sourceUrl: htmlUrl,
+      doc,
+      loc,
+      fromVersion,
+      fetchFn: async () => ({ ok: true, status: 200, text: async () => htmlText }),
+    });
+  } catch (err) {
+    return { ok: false, code: "transform", message: err && err.message ? err.message : MANIFEST_FAILED };
+  }
+  const afterDoc = new DOMParser().parseFromString(result.html, "text/html");
+  const before = upgrade.extractAll(doc).dataByName;
+  const after = upgrade.extractAll(afterDoc).dataByName;
+  const lost = lostValues(before, after, renames);
+  const discarded = result.summary && result.summary.totals ? result.summary.totals.discarded || 0 : 0;
+  if (lost.length || discarded > 0) {
+    return { ok: false, code: "lost", lost, discarded, message: lossMessage(lost, discarded) };
+  }
+  return { ok: true, html: result.html, version: result.toVersion || latest.version };
+}
+
+function lossMessage(lost, discarded) {
+  const names = lost.slice(0, 5).map(({ path }) => path);
+  const more = lost.length > names.length ? ` and ${lost.length - names.length} more` : "";
+  if (names.length) return `This upgrade would lose data: ${names.join(", ")}${more}. Nothing was changed.`;
+  return `This upgrade would lose ${discarded} value${discarded === 1 ? "" : "s"}. Nothing was changed.`;
+}
+
+function flushFailure(err) {
+  const state = err && err.state;
+  if (state === "conflict") return { ok: false, code: "conflict", message: CONFLICT };
+  const reason = err && err.message ? err.message : "The document could not be saved.";
+  return { ok: false, code: "flush", state: state || "failed", message: reason };
+}
+
+export async function apply(update, {
+  doc = document,
+  loc = location,
+  fetchFn = (url, init) => fetch(url, init),
+  clay = typeof window !== "undefined" ? window.clay : null,
+  reload = () => window.location.reload(),
+  replace = null,
+  etag,
+} = {}) {
+  const pageClay = clay || {};
+  if (pageClay.isDraftMode) return { ok: false, code: "draft" };
+
+  // An upgrade flushes this generation and then replaces it with another, so it speaks
+  // for the whole document while it runs: a mode switch cannot start its barrier in the
+  // middle of one, and two upgrades cannot interleave their flushes and writes.
+  const operation = claimDocumentOperation("upgrade");
+  if (!operation) return { ok: false, code: "busy", message: BUSY };
+  try {
+    return await applyUnderSlot(update, { doc, loc, fetchFn, clay, reload, replace, etag });
+  } finally {
+    releaseDocumentOperation(operation);
+  }
+}
+
+async function applyUnderSlot(update, { doc, loc, fetchFn, clay, reload, replace, etag }) {
+  const pageClay = clay || {};
+
+  if (pageClay.isEditMode && pageClay.save && typeof pageClay.save.flush === "function") {
+    let flushed;
+    try {
+      flushed = await pageClay.save.flush();
+    } catch (err) {
+      return flushFailure(err);
+    }
+    if (flushed && typeof flushed.state === "string" && flushed.state !== "saved" && flushed.state !== "clean" && flushed.state !== "view") {
+      return { ok: false, code: "flush", state: flushed.state, message: "This document has changes that could not be saved. Nothing was changed." };
+    }
+  }
+
+  const prepared = await prepare(update, { doc, loc, fetchFn });
+  if (!prepared.ok) return prepared;
+
+  const save = typeof replace === "function"
+    ? replace
+    : pageClay.save && typeof pageClay.save.replace === "function"
+      ? pageClay.save.replace
+      : replaceDocument;
+  let result;
+  try {
+    result = await save(prepared.html, { etag: etag !== undefined ? etag : lastSeenEtag() });
+  } catch {
+    return { ok: false, code: "failed", message: SAVE_FAILED };
+  }
+  if (!result || !result.ok) {
+    const code = result && result.code ? result.code : "failed";
+    if (code === "conflict") return { ok: false, code, message: CONFLICT };
+    if (code === "forbidden") return { ok: false, code, message: "You are not allowed to save this document." };
+    if (code === "unsupported") return { ok: false, code, message: "This host cannot save the upgrade." };
+    return { ok: false, code, message: SAVE_FAILED };
+  }
+  reload();
+  return { ok: true, html: prepared.html, version: prepared.version, etag: result.etag };
+}
+
+function element(doc, tag, props = {}) {
+  const node = doc.createElement(tag);
+  node.setAttribute("clay", "editor-ui");
+  for (const [key, value] of Object.entries(props)) {
+    if (key === "style") node.setAttribute("style", value);
+    else if (key === "text") node.textContent = value;
+    else node.setAttribute(key, value);
+  }
+  return node;
+}
+
+function downloadName(loc) {
+  const last = (loc && loc.pathname ? loc.pathname : "/").split("/").filter(Boolean).pop();
+  let name = last || "page.html";
+  try {
+    name = decodeURIComponent(name);
+  } catch {}
+  return /\.html?$/i.test(name) ? name : `${name}.html`;
+}
+
+export function downloadCopy({ clay, doc = document, loc = location } = {}) {
+  const getHTML = clay && clay.getHTML;
+  if (typeof getHTML !== "function" || typeof URL === "undefined" || typeof URL.createObjectURL !== "function") return false;
+  try {
+    const url = URL.createObjectURL(new Blob([getHTML()], { type: "text/html" }));
+    const a = doc.createElement("a");
+    a.setAttribute("clay", "editor-ui");
+    a.href = url;
+    a.download = downloadName(loc);
+    a.style.setProperty("display", "none", "important");
+    doc.body.appendChild(a);
+    a.click();
+    a.remove();
+    setTimeout(() => URL.revokeObjectURL(url), 40000);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function hasHistory(clay) {
+  const host = clay && clay.host;
+  if (!host || !host.versions) return false;
+  try {
+    return (await host.versions) === true;
+  } catch {
+    return false;
+  }
+}
+
+export async function start(update, options = {}) {
+  const doc = options.doc || document;
+  const clay = options.clay || (typeof window !== "undefined" ? window.clay : null) || {};
+  if (clay.isDraftMode) return null;
+  if (!update || typeof update.version !== "string") return null;
+
+  const versions = await hasHistory(clay);
+  const root = element(doc, "div", {
+    role: "dialog",
+    "aria-modal": "true",
+    "data-clay-upgrade": "",
+    style: "position:fixed;inset:0;z-index:2147483000;display:flex;align-items:center;justify-content:center;padding:16px;background:rgba(15,17,21,.42);font-family:system-ui,-apple-system,'Segoe UI',sans-serif;",
+  });
+  const panel = element(doc, "div", {
+    style: "width:min(460px,100%);padding:20px;border-radius:14px;background:var(--clay-ui-bg,#fff);color:var(--clay-ui-fg,#1f2328);box-shadow:0 18px 48px -16px rgba(0,0,0,.55);font-size:14px;line-height:1.5;",
+  });
+  const title = element(doc, "h2", { text: `Upgrade to version ${update.version}`, style: "margin:0 0 8px;font-size:16px;" });
+  const body = element(doc, "p", {
+    text: `Your data moves into version ${update.version}. The page's layout and code are replaced; your current version stays in this document's history.`,
+    style: "margin:0 0 16px;",
+  });
+  const status = element(doc, "p", { role: "status", style: "margin:0 0 12px;min-height:1.5em;" });
+  const actions = element(doc, "div", { style: "display:flex;flex-wrap:wrap;gap:8px;justify-content:flex-end;" });
+  const buttonStyle = "padding:7px 12px;border-radius:8px;border:1px solid rgba(23,28,36,.2);background:transparent;color:inherit;font:inherit;cursor:pointer;";
+  const cancel = element(doc, "button", { type: "button", text: "Cancel", style: buttonStyle });
+  const download = versions ? null : element(doc, "button", { type: "button", text: "Download a copy first", style: buttonStyle });
+  const agree = element(doc, "button", {
+    type: "button",
+    text: "Upgrade",
+    style: `${buttonStyle}border-color:transparent;background:#2f6fed;color:#fff;font-weight:600;`,
+  });
+  if (!versions) agree.disabled = true;
+
+  if (download) actions.append(download);
+  actions.append(cancel, agree);
+  panel.append(title, body, status, actions);
+  root.append(panel);
+  doc.body.appendChild(root);
+
+  let closed = false;
+  const close = () => {
+    if (closed) return;
+    closed = true;
+    root.remove();
+  };
+
+  if (download) {
+    download.addEventListener("click", () => {
+      if (downloadCopy({ clay, doc, loc: options.loc })) {
+        agree.disabled = false;
+        status.textContent = "Your copy was downloaded.";
+      } else {
+        status.textContent = "The copy could not be downloaded. Nothing was changed.";
+      }
+    });
+  }
+
+  cancel.addEventListener("click", close);
+
+  let resolveDone;
+  const done = new Promise((resolve) => {
+    resolveDone = resolve;
+  });
+
+  agree.addEventListener("click", async () => {
+    agree.disabled = true;
+    if (download) download.disabled = true;
+    status.textContent = `Upgrading to version ${update.version}…`;
+    const result = await apply(update, options);
+    if (result.ok) {
+      close();
+      resolveDone(result);
+      return;
+    }
+    status.textContent = result.message || SAVE_FAILED;
+    agree.disabled = false;
+    if (download) download.disabled = false;
+    resolveDone(result);
+  });
+
+  return { root, title, body, status, cancel, download, upgrade: agree, close, done };
+}

package/src/core/version.js

@@ -0,0 +1,18 @@
+export function parseVersion(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim().replace(/^v/, "");
+  return /^\d+(\.\d+)*$/.test(trimmed) ? trimmed.split(".").map(Number) : null;
+}
+
+export function isNewerVersion(candidate, current) {
+  const next = parseVersion(candidate);
+  const now = parseVersion(current);
+  if (!next || !now) return false;
+  const length = Math.max(next.length, now.length);
+  for (let index = 0; index < length; index++) {
+    const candidatePart = next[index] || 0;
+    const currentPart = now[index] || 0;
+    if (candidatePart !== currentPart) return candidatePart > currentPart;
+  }
+  return false;
+}

package/src/lib/assets.js

@@ -0,0 +1,30 @@
+// Libraries a document asks for by name, loaded the first time it asks. Each is a module in this
+// release, so whichever host serves ClayJS serves them too, offline included.
+const ASSETS = {
+  overtype: () => import("../vendor/overtype.vendor.js"),
+  marked: () => import("../vendor/marked.vendor.js"),
+  highlight: () => import("../vendor/highlight.vendor.js"),
+  "highlight/bash": () => import("../vendor/hljs-bash.vendor.js"),
+  "highlight/css": () => import("../vendor/hljs-css.vendor.js"),
+  "highlight/javascript": () => import("../vendor/hljs-javascript.vendor.js"),
+  "highlight/json": () => import("../vendor/hljs-json.vendor.js"),
+  "highlight/python": () => import("../vendor/hljs-python.vendor.js"),
+  "highlight/xml": () => import("../vendor/hljs-xml.vendor.js"),
+};
+
+export function createAssets(table) {
+  const loading = new Map();
+  function load(name) {
+    if (!Object.hasOwn(table, name)) return Promise.reject(new Error(`clay.assets: no asset named "${name}"`));
+    if (!loading.has(name)) {
+      loading.set(name, table[name]().catch((error) => {
+        loading.delete(name);
+        throw error;
+      }));
+    }
+    return loading.get(name);
+  }
+  return { load, names: () => Object.keys(table) };
+}
+
+export const assets = createAssets(ASSETS);

package/src/lib/autosave-debug-gate.js

@@ -0,0 +1,50 @@
+/**
+ * Autosave Debug Gate
+ *
+ * The boot-size half of the autosave debug utility: a person who never turns
+ * `clay:debug:autosave` on downloads nothing but this file. Each wrapper returns
+ * before the dynamic import when debug is off, and forwards to the real logger
+ * once it lands when it is on.
+ */
+
+const DEBUG_KEY = 'clay:debug:autosave';
+
+export function isDebugEnabled() {
+  try {
+    return localStorage.getItem(DEBUG_KEY) === 'true';
+  } catch {
+    return false;
+  }
+}
+
+function load() {
+  return import('./autosave-debug.js').catch((err) => {
+    console.warn('[autosave-debug] Failed to load the debug logger:', err);
+    return null;
+  });
+}
+
+export function logSaveCheck(label, matches) {
+  if (!isDebugEnabled()) return;
+  load().then((mod) => mod?.logSaveCheck(label, matches));
+}
+
+export function logBaseline(event, details = '') {
+  if (!isDebugEnabled()) return;
+  load().then((mod) => mod?.logBaseline(event, details));
+}
+
+export function logUnloadDiff(currentContents, lastSaved) {
+  if (!isDebugEnabled()) return;
+  load().then((mod) => mod?.logUnloadDiff(currentContents, lastSaved));
+}
+
+export function logUnloadDiffSync(currentContents, lastSaved) {
+  if (!isDebugEnabled()) return;
+  load().then((mod) => mod?.logUnloadDiffSync(currentContents, lastSaved));
+}
+
+export function preloadIfEnabled() {
+  if (!isDebugEnabled()) return;
+  load().then((mod) => mod?.preloadIfEnabled());
+}

package/src/lib/autosave-scheduler.js

@@ -0,0 +1,141 @@
+/**
+ * Automatic-save scheduling.
+ *
+ * One automatic attempt at a time, and none until this module admits it: the idle
+ * and maximum-wait state that used to live in the Mutation hub's debounce is here,
+ * so nothing captures the page for a save that is still only an intention.
+ *
+ * The clock, the timers and the attempt are injected, so the cadence is executable
+ * with fake time and testable without a DOM.
+ */
+
+export const IDLE_MS = 1500;
+export const MIN_GAP_MS = 1200;
+export const CONTINUOUS_MS = 10000;
+export const MAX_COOLDOWN_MS = 30000;
+
+// Adaptive spacing: make the gap after a save at least COST_MULTIPLIER times that
+// save's synchronous cost, so a three-second save earns twelve seconds of quiet
+// rather than spending the quiet window doing the next capture. Off for now, and
+// the multiplier is zero while it is off, which makes the cooldown term exactly
+// MIN_GAP_MS and keeps today's 1,500 / 10,000 ms cadence.
+export const ADAPTIVE_SPACING = false;
+export const COST_MULTIPLIER = ADAPTIVE_SPACING ? 4 : 0;
+
+// "No such time yet": before the first activity or the first completed save the
+// page must be governed by its own timers, not by when this module was imported.
+const NO_TIME = Number.NEGATIVE_INFINITY;
+
+/**
+ * The earliest moment the next automatic attempt may be admitted.
+ *
+ * A quiet period can flush after IDLE_MS even when the continuous-typing ceiling
+ * is longer, and a save's own completion is never treated as an idle period: quiet
+ * time starts no earlier than the save finished.
+ */
+export function nextAutoAt({ firstDirtyAt = NO_TIME, lastActivityAt = NO_TIME, finishedAt = NO_TIME, costMs = 0 } = {}) {
+  const first = firstDirtyAt ?? NO_TIME;
+  const last = lastActivityAt ?? NO_TIME;
+  const finished = finishedAt ?? NO_TIME;
+  const cooldown = Math.min(MAX_COOLDOWN_MS, Math.max(MIN_GAP_MS, COST_MULTIPLIER * costMs));
+  const quietAt = Math.max(last, finished) + IDLE_MS;
+  const continuousAt = Math.max(first + CONTINUOUS_MS, finished + cooldown);
+  return Math.max(finished + MIN_GAP_MS, Math.min(quietAt, continuousAt));
+}
+
+export function createAutosaveScheduler({
+  now = () => Date.now(),
+  setTimer = (fn, ms) => setTimeout(fn, ms),
+  clearTimer = (id) => clearTimeout(id),
+  run = () => {}
+} = {}) {
+  let firstDirtyAt = null;
+  let lastActivityAt = null;
+  let finishedAt = NO_TIME;
+  let costMs = 0;
+  let timer = null;
+  let timerAt = null;
+  let pending = false;
+  let running = false;
+
+  function dueAt() {
+    return nextAutoAt({ firstDirtyAt, lastActivityAt, finishedAt, costMs });
+  }
+
+  function schedule() {
+    if (!pending || running) return;
+    const at = dueAt();
+    if (timer !== null) {
+      if (timerAt === at) return;
+      clearTimer(timer);
+    }
+    timerAt = at;
+    timer = setTimer(fire, Math.max(0, at - now()));
+  }
+
+  function fire() {
+    timer = null;
+    timerAt = null;
+    if (!pending || running) return;
+    if (now() < dueAt()) {
+      schedule();
+      return;
+    }
+    admit();
+  }
+
+  function admit() {
+    pending = false;
+    running = true;
+    firstDirtyAt = null;
+    lastActivityAt = null;
+    let attempt;
+    try {
+      attempt = run();
+    } catch (err) {
+      finish();
+      return;
+    }
+    Promise.resolve(attempt).then(finish, finish);
+  }
+
+  function finish() {
+    running = false;
+    finishedAt = now();
+    if (pending) schedule();
+  }
+
+  function noteActivity({ at = now() } = {}) {
+    if (firstDirtyAt === null) firstDirtyAt = at;
+    lastActivityAt = at;
+    pending = true;
+    schedule();
+  }
+
+  // An attempt asked for by something other than user activity (a merge that kept
+  // this tab's edits). It respects holds and the cost spacing, and it invents no
+  // input timestamp: with none recorded the idle and continuous terms are already
+  // past, so the attempt is due as soon as the gap after the last save allows.
+  function request() {
+    pending = true;
+    schedule();
+  }
+
+  // Cost of the synchronous preparation and completion work of the last admitted
+  // attempt. React at once to a slow save, decay gradually. Skipped or coalesced
+  // attempts report nothing and must not zero the estimate.
+  function noteCost(sampleMs) {
+    if (!(sampleMs > 0)) return;
+    costMs = Math.max(sampleMs, costMs * 0.8);
+  }
+
+  return {
+    noteActivity,
+    request,
+    noteCost,
+    dueAt,
+    costEstimate: () => costMs,
+    pending: () => pending || running,
+    running: () => running
+  };
+}

package/src/lib/boot-imports.js

@@ -0,0 +1,8 @@
+export const BOOT_IMPORTS = {
+  "plugins/sortable.js": ["vendor/Sortable.vendor.js"],
+  "plugins/derive.js": ["vendor/sap-core.vendor.js"],
+};
+export const EDIT_BOOT_IMPORTS = ["core/host-permission.js"];
+// Code a Document's edit boot fetches before it can take input. The editor is a
+// dynamic target of its own, so only a plan that runs the page plugin preloads it.
+export const EDITOR_BOOT_IMPORTS = ["page/editor.js"];

package/src/lib/derived.js

@@ -9,7 +9,9 @@ import { bootPhase } from "../core/boot-phase.js";
 // from its own attributes, so the same answer holds for the live page, a
 // snapshot clone and a parsed frame. No expression is evaluated here.
 
-export const isDerivedAttr = (el, name) => ownsAttr(el, name);
+// `host` is the element a just-removed subtree belongs under (the undo engine passes
+// it), so a detached card is read as painted the way it was while attached.
+export const isDerivedAttr = (el, name, host = null) => ownsAttr(el, name, host);
 
 export const ownsDerivedText = (el) => !!el && el.nodeType === 1 && !!paintsOf(el)?.text;