@panphora/clayjs 1.15.2 → 1.17.0

package/dist/all.js

@@ -0,0 +1,90 @@
+/* all.js — clayjs satellite: All(selector) chainable querySelectorAll wrapper. https://clayjs.com */
+(function () {
+  var clay = window.clay = window.clay || {};
+  clay.loaded = clay.loaded || {};
+
+  var script = document.currentScript;
+  if (!script || !script.src) {
+    console.error("all.js: could not determine my own URL (load me with a classic <script src=...>, not type=\"module\")");
+    return;
+  }
+  var url = new URL(script.src, location.href);
+  // Query and fragment off first, then step out of the tarball's entries/ directory
+  // so package-path CDNs resolve src/. See clay.js for the full reason on both.
+  var path = url.href.split("#")[0].split("?")[0];
+  var base = path.slice(0, path.lastIndexOf("/"));
+  if (url.pathname.slice(0, url.pathname.lastIndexOf("/")).slice(-8) === "/entries") {
+    base = base.slice(0, -8);
+  }
+
+  var __clayChunks = (function (M) {
+  var clay = window.clay = window.clay || {};
+  var dir = new URL(M.dir, base + "/").href;
+  var tree = base.slice(-5) === "/dist" ? base.slice(0, -5) : base;
+  var have = {};
+  document.head.querySelectorAll('link[rel="modulepreload"]').forEach(function (link) { have[link.href] = true; });
+  // Only an explicit ?editmode=true asks for the supplement, or the window.clayEditMode
+  // global a standalone page sets before this script; the owner cookie is not an edit
+  // request, because an owner who opens a document in view resolves to view.
+  function __clayLikelyEdit(search) {
+    var asked = new URLSearchParams(search).get("editmode");
+    if (asked) return asked === "true";
+    if (typeof clayEditMode !== "undefined") return Boolean(clayEditMode);
+    return typeof __hyperclayEditMode !== "undefined" && Boolean(__hyperclayEditMode);
+  }
+  var likelyEdit = __clayLikelyEdit(window.location.search);
+  // The supplement an edit page is about to import, preloaded like the manifest.
+  if (likelyEdit) M.preload.push(M.edit);
+  M.preload.forEach(function (file) {
+    var href = dir + file;
+    if (have[href]) return;
+    have[href] = true;
+    var link = document.createElement("link");
+    link.rel = "modulepreload";
+    link.href = href;
+    link.setAttribute("clay", "no-save");
+    document.head.appendChild(link);
+  });
+  if (!clay.__runtime) {
+    clay.__runtime = Promise.all([
+      import(dir + M.manifest),
+      likelyEdit ? import(dir + M.edit).catch(function () { return null; }) : null
+    ]).then(function (r) {
+      var manifest = r[0].default;
+      manifest.base = dir;
+      var edit = r[1] ? r[1].default : null;
+      var hints = null;
+      // The cached hint fetch a resolved edit, draft or first entry uses. A failed one
+      // clears itself for retry and never selects another release.
+      function loadEditHints() {
+        if (!hints) {
+          hints = (edit ? Promise.resolve(edit) : import(dir + M.edit).then(function (m) { return m.default; }))
+            .catch(function (err) { hints = null; throw err; });
+        }
+        return hints;
+      }
+      return { chunks: true, dir: dir, manifest: manifest, edit: edit, loadEditHints: loadEditHints };
+    }, function (err) {
+      console.warn("clayjs: the bundled runtime did not load, loading the module tree instead:", err);
+      return { chunks: false, tree: tree };
+    });
+  }
+  return { tree: tree, runtime: clay.__runtime };
+})({"dir":"m/","manifest":"manifest-4C419D67.js","edit":"manifest-edit-B077F288.js","preload":["dom/all-APS5ZSKP.js","c-VHNSBD2M.js","manifest-4C419D67.js"]})
+
+  clay.loaded.all = __clayChunks.runtime.then(function (R) {
+  if (!R.chunks) return import(__clayChunks.tree + "/src/dom/all.js");
+  var file = R.manifest.entries["dom/all.js"];
+  if (!file) throw new Error("clayjs: release " + R.manifest.version + " has no dom/all.js");
+  return import(R.dir + file);
+})
+    .then(function (m) {
+      var All = m.default;
+      window.All = All;   // interop carve-out (§2.3)
+      clay.All = All;
+      return All;
+    })
+    .catch(function (err) { console.error("all.js failed to load:", err); throw err; });
+  // Mark handled: see clay-ui.js.
+  clay.loaded.all.catch(function () {});
+})();

package/dist/clay-dom.js

@@ -0,0 +1,84 @@
+/* clay-dom.js — clayjs satellite: Element prototype helpers (nearest, el, val, text, exec, cycle, show/hide). https://clayjs.com */
+(function () {
+  var clay = window.clay = window.clay || {};
+  clay.loaded = clay.loaded || {};
+
+  var script = document.currentScript;
+  if (!script || !script.src) {
+    console.error("clay-dom: could not determine my own URL (load me with a classic <script src=...>, not type=\"module\")");
+    return;
+  }
+  var url = new URL(script.src, location.href);
+  // Query and fragment off first, then step out of the tarball's entries/ directory
+  // so package-path CDNs resolve src/. See clay.js for the full reason on both.
+  var path = url.href.split("#")[0].split("?")[0];
+  var base = path.slice(0, path.lastIndexOf("/"));
+  if (url.pathname.slice(0, url.pathname.lastIndexOf("/")).slice(-8) === "/entries") {
+    base = base.slice(0, -8);
+  }
+
+  var __clayChunks = (function (M) {
+  var clay = window.clay = window.clay || {};
+  var dir = new URL(M.dir, base + "/").href;
+  var tree = base.slice(-5) === "/dist" ? base.slice(0, -5) : base;
+  var have = {};
+  document.head.querySelectorAll('link[rel="modulepreload"]').forEach(function (link) { have[link.href] = true; });
+  // Only an explicit ?editmode=true asks for the supplement, or the window.clayEditMode
+  // global a standalone page sets before this script; the owner cookie is not an edit
+  // request, because an owner who opens a document in view resolves to view.
+  function __clayLikelyEdit(search) {
+    var asked = new URLSearchParams(search).get("editmode");
+    if (asked) return asked === "true";
+    if (typeof clayEditMode !== "undefined") return Boolean(clayEditMode);
+    return typeof __hyperclayEditMode !== "undefined" && Boolean(__hyperclayEditMode);
+  }
+  var likelyEdit = __clayLikelyEdit(window.location.search);
+  // The supplement an edit page is about to import, preloaded like the manifest.
+  if (likelyEdit) M.preload.push(M.edit);
+  M.preload.forEach(function (file) {
+    var href = dir + file;
+    if (have[href]) return;
+    have[href] = true;
+    var link = document.createElement("link");
+    link.rel = "modulepreload";
+    link.href = href;
+    link.setAttribute("clay", "no-save");
+    document.head.appendChild(link);
+  });
+  if (!clay.__runtime) {
+    clay.__runtime = Promise.all([
+      import(dir + M.manifest),
+      likelyEdit ? import(dir + M.edit).catch(function () { return null; }) : null
+    ]).then(function (r) {
+      var manifest = r[0].default;
+      manifest.base = dir;
+      var edit = r[1] ? r[1].default : null;
+      var hints = null;
+      // The cached hint fetch a resolved edit, draft or first entry uses. A failed one
+      // clears itself for retry and never selects another release.
+      function loadEditHints() {
+        if (!hints) {
+          hints = (edit ? Promise.resolve(edit) : import(dir + M.edit).then(function (m) { return m.default; }))
+            .catch(function (err) { hints = null; throw err; });
+        }
+        return hints;
+      }
+      return { chunks: true, dir: dir, manifest: manifest, edit: edit, loadEditHints: loadEditHints };
+    }, function (err) {
+      console.warn("clayjs: the bundled runtime did not load, loading the module tree instead:", err);
+      return { chunks: false, tree: tree };
+    });
+  }
+  return { tree: tree, runtime: clay.__runtime };
+})({"dir":"m/","manifest":"manifest-4C419D67.js","edit":"manifest-edit-B077F288.js","preload":["dom/dom-helpers-L7OSR6S4.js","c-XQXZAO7N.js","c-WRBKEJD4.js","c-VHNSBD2M.js","manifest-4C419D67.js"]})
+
+  clay.loaded.dom = __clayChunks.runtime.then(function (R) {
+  if (!R.chunks) return import(__clayChunks.tree + "/src/dom/dom-helpers.js");
+  var file = R.manifest.entries["dom/dom-helpers.js"];
+  if (!file) throw new Error("clayjs: release " + R.manifest.version + " has no dom/dom-helpers.js");
+  return import(R.dir + file);
+})
+    .catch(function (err) { console.error("clay-dom failed to load:", err); throw err; });
+  // Mark handled: see clay-ui.js.
+  clay.loaded.dom.catch(function () {});
+})();

package/dist/clay-events.js

@@ -0,0 +1,103 @@
+/* clay-events.js — clayjs satellite: onclickaway, onclickchildren, onclone, onmutation, onpagemutation, onrender. https://clayjs.com */
+(function () {
+  var clay = window.clay = window.clay || {};
+  clay.loaded = clay.loaded || {};
+
+  var script = document.currentScript;
+  if (!script || !script.src) {
+    console.error("clay-events: could not determine my own URL (load me with a classic <script src=...>, not type=\"module\")");
+    return;
+  }
+  var url = new URL(script.src, location.href);
+  // Query and fragment off first, then step out of the tarball's entries/ directory
+  // so package-path CDNs resolve src/. See clay.js for the full reason on both.
+  var path = url.href.split("#")[0].split("?")[0];
+  var base = path.slice(0, path.lastIndexOf("/"));
+  if (url.pathname.slice(0, url.pathname.lastIndexOf("/")).slice(-8) === "/entries") {
+    base = base.slice(0, -8);
+  }
+
+  var __clayChunks = (function (M) {
+  var clay = window.clay = window.clay || {};
+  var dir = new URL(M.dir, base + "/").href;
+  var tree = base.slice(-5) === "/dist" ? base.slice(0, -5) : base;
+  var have = {};
+  document.head.querySelectorAll('link[rel="modulepreload"]').forEach(function (link) { have[link.href] = true; });
+  // Only an explicit ?editmode=true asks for the supplement, or the window.clayEditMode
+  // global a standalone page sets before this script; the owner cookie is not an edit
+  // request, because an owner who opens a document in view resolves to view.
+  function __clayLikelyEdit(search) {
+    var asked = new URLSearchParams(search).get("editmode");
+    if (asked) return asked === "true";
+    if (typeof clayEditMode !== "undefined") return Boolean(clayEditMode);
+    return typeof __hyperclayEditMode !== "undefined" && Boolean(__hyperclayEditMode);
+  }
+  var likelyEdit = __clayLikelyEdit(window.location.search);
+  // The supplement an edit page is about to import, preloaded like the manifest.
+  if (likelyEdit) M.preload.push(M.edit);
+  M.preload.forEach(function (file) {
+    var href = dir + file;
+    if (have[href]) return;
+    have[href] = true;
+    var link = document.createElement("link");
+    link.rel = "modulepreload";
+    link.href = href;
+    link.setAttribute("clay", "no-save");
+    document.head.appendChild(link);
+  });
+  if (!clay.__runtime) {
+    clay.__runtime = Promise.all([
+      import(dir + M.manifest),
+      likelyEdit ? import(dir + M.edit).catch(function () { return null; }) : null
+    ]).then(function (r) {
+      var manifest = r[0].default;
+      manifest.base = dir;
+      var edit = r[1] ? r[1].default : null;
+      var hints = null;
+      // The cached hint fetch a resolved edit, draft or first entry uses. A failed one
+      // clears itself for retry and never selects another release.
+      function loadEditHints() {
+        if (!hints) {
+          hints = (edit ? Promise.resolve(edit) : import(dir + M.edit).then(function (m) { return m.default; }))
+            .catch(function (err) { hints = null; throw err; });
+        }
+        return hints;
+      }
+      return { chunks: true, dir: dir, manifest: manifest, edit: edit, loadEditHints: loadEditHints };
+    }, function (err) {
+      console.warn("clayjs: the bundled runtime did not load, loading the module tree instead:", err);
+      return { chunks: false, tree: tree };
+    });
+  }
+  return { tree: tree, runtime: clay.__runtime };
+})({"dir":"m/","manifest":"manifest-4C419D67.js","edit":"manifest-edit-B077F288.js","preload":["events/index-RN2JNGBV.js","c-ZWIOJGMT.js","c-IJUK2GPW.js","c-VG5XIN4T.js","c-2YYDMLNZ.js","c-HA6INT6J.js","c-WRBKEJD4.js","c-DCFSEJZG.js","c-VHNSBD2M.js","manifest-4C419D67.js"]})
+
+  // The mutation-backed attrs subscribe to a hub that observes document.body, so
+  // wait for DOM ready before importing (same gate as clay.js).
+  function domReady() {
+    return new Promise(function (r) {
+      if (document.readyState === "loading") document.addEventListener("DOMContentLoaded", r);
+      else r();
+    });
+  }
+
+  // [onrender] sweeps the whole document the moment that import resolves, and those
+  // handlers routinely reach for clay-dom's element helpers (this.val, this.exec,
+  // this.nearest). The two satellites are independent dynamic imports with nothing
+  // ordering them, so on a cold load events can win and every handler throws
+  // "Cannot read properties of undefined". By DOM ready every satellite tag has run,
+  // so clay.loaded.dom is present exactly when clay-dom.js is on the page: wait for it
+  // then, proceed when it is absent. A clay-dom that failed to load must not take
+  // events down with it, so its rejection is swallowed here rather than chained.
+  clay.loaded.events = domReady()
+    .then(function () { return clay.loaded.dom && clay.loaded.dom.catch(function () {}); })
+    .then(function () { return __clayChunks.runtime.then(function (R) {
+  if (!R.chunks) return import(__clayChunks.tree + "/src/events/index.js");
+  var file = R.manifest.entries["events/index.js"];
+  if (!file) throw new Error("clayjs: release " + R.manifest.version + " has no events/index.js");
+  return import(R.dir + file);
+}); })
+    .catch(function (err) { console.error("clay-events failed to load:", err); throw err; });
+  // Mark handled: see clay-ui.js.
+  clay.loaded.events.catch(function () {});
+})();

package/dist/clay-internals.js

@@ -0,0 +1,85 @@
+/* clay-internals.js — clayjs satellite: clay.internals = the supported low-level surface (snapshot, region policy, save lane). https://clayjs.com */
+(function () {
+  var clay = window.clay = window.clay || {};
+  clay.loaded = clay.loaded || {};
+
+  var script = document.currentScript;
+  if (!script || !script.src) {
+    console.error("clay-internals: could not determine my own URL (load me with a classic <script src=...>, not type=\"module\")");
+    return;
+  }
+  var url = new URL(script.src, location.href);
+  // Query and fragment off first, then step out of the tarball's entries/ directory
+  // so package-path CDNs resolve src/. See clay.js for the full reason on both.
+  var path = url.href.split("#")[0].split("?")[0];
+  var base = path.slice(0, path.lastIndexOf("/"));
+  if (url.pathname.slice(0, url.pathname.lastIndexOf("/")).slice(-8) === "/entries") {
+    base = base.slice(0, -8);
+  }
+
+  var __clayChunks = (function (M) {
+  var clay = window.clay = window.clay || {};
+  var dir = new URL(M.dir, base + "/").href;
+  var tree = base.slice(-5) === "/dist" ? base.slice(0, -5) : base;
+  var have = {};
+  document.head.querySelectorAll('link[rel="modulepreload"]').forEach(function (link) { have[link.href] = true; });
+  // Only an explicit ?editmode=true asks for the supplement, or the window.clayEditMode
+  // global a standalone page sets before this script; the owner cookie is not an edit
+  // request, because an owner who opens a document in view resolves to view.
+  function __clayLikelyEdit(search) {
+    var asked = new URLSearchParams(search).get("editmode");
+    if (asked) return asked === "true";
+    if (typeof clayEditMode !== "undefined") return Boolean(clayEditMode);
+    return typeof __hyperclayEditMode !== "undefined" && Boolean(__hyperclayEditMode);
+  }
+  var likelyEdit = __clayLikelyEdit(window.location.search);
+  // The supplement an edit page is about to import, preloaded like the manifest.
+  if (likelyEdit) M.preload.push(M.edit);
+  M.preload.forEach(function (file) {
+    var href = dir + file;
+    if (have[href]) return;
+    have[href] = true;
+    var link = document.createElement("link");
+    link.rel = "modulepreload";
+    link.href = href;
+    link.setAttribute("clay", "no-save");
+    document.head.appendChild(link);
+  });
+  if (!clay.__runtime) {
+    clay.__runtime = Promise.all([
+      import(dir + M.manifest),
+      likelyEdit ? import(dir + M.edit).catch(function () { return null; }) : null
+    ]).then(function (r) {
+      var manifest = r[0].default;
+      manifest.base = dir;
+      var edit = r[1] ? r[1].default : null;
+      var hints = null;
+      // The cached hint fetch a resolved edit, draft or first entry uses. A failed one
+      // clears itself for retry and never selects another release.
+      function loadEditHints() {
+        if (!hints) {
+          hints = (edit ? Promise.resolve(edit) : import(dir + M.edit).then(function (m) { return m.default; }))
+            .catch(function (err) { hints = null; throw err; });
+        }
+        return hints;
+      }
+      return { chunks: true, dir: dir, manifest: manifest, edit: edit, loadEditHints: loadEditHints };
+    }, function (err) {
+      console.warn("clayjs: the bundled runtime did not load, loading the module tree instead:", err);
+      return { chunks: false, tree: tree };
+    });
+  }
+  return { tree: tree, runtime: clay.__runtime };
+})({"dir":"m/","manifest":"manifest-4C419D67.js","edit":"manifest-edit-B077F288.js","preload":["internals/index-PVXGPUDA.js","c-LWLBHLVC.js","c-SDAXDM2D.js","c-TQEMVJCS.js","c-DCXOXBF3.js","c-VRZN56XY.js","c-OW5QIGG3.js","c-BPF2NSPV.js","c-HA6INT6J.js","c-WRBKEJD4.js","c-P7KNDG34.js","c-CYWLPPUS.js","c-N7JPUPGC.js","c-IJUK2GPW.js","c-SPIORRYS.js","c-XQXZAO7N.js","c-S7LK4KUE.js","c-VG5XIN4T.js","c-2YYDMLNZ.js","c-DCFSEJZG.js","c-VHNSBD2M.js","manifest-4C419D67.js"]})
+
+  // No DOM gate: nothing here touches document.body at import time, unlike clay-ui.
+  clay.loaded.internals = __clayChunks.runtime.then(function (R) {
+  if (!R.chunks) return import(__clayChunks.tree + "/src/internals/index.js");
+  var file = R.manifest.entries["internals/index.js"];
+  if (!file) throw new Error("clayjs: release " + R.manifest.version + " has no internals/index.js");
+  return import(R.dir + file);
+})
+    .catch(function (err) { console.error("clay-internals failed to load:", err); throw err; });
+  // Mark handled: a blocked satellite must not emit an unhandled rejection.
+  clay.loaded.internals.catch(function () {});
+})();

package/dist/clay-options.js

@@ -0,0 +1,93 @@
+/* clay-options.js — clayjs satellite: option:/option-not:/show-when:/hide-when: visibility. https://clayjs.com */
+(function () {
+  var clay = window.clay = window.clay || {};
+  clay.loaded = clay.loaded || {};
+
+  var script = document.currentScript;
+  if (!script || !script.src) {
+    console.error("clay-options: could not determine my own URL (load me with a classic <script src=...>, not type=\"module\")");
+    return;
+  }
+  var url = new URL(script.src, location.href);
+  // Query and fragment off first, then step out of the tarball's entries/ directory
+  // so package-path CDNs resolve src/. See clay.js for the full reason on both.
+  var path = url.href.split("#")[0].split("?")[0];
+  var base = path.slice(0, path.lastIndexOf("/"));
+  if (url.pathname.slice(0, url.pathname.lastIndexOf("/")).slice(-8) === "/entries") {
+    base = base.slice(0, -8);
+  }
+
+  var __clayChunks = (function (M) {
+  var clay = window.clay = window.clay || {};
+  var dir = new URL(M.dir, base + "/").href;
+  var tree = base.slice(-5) === "/dist" ? base.slice(0, -5) : base;
+  var have = {};
+  document.head.querySelectorAll('link[rel="modulepreload"]').forEach(function (link) { have[link.href] = true; });
+  // Only an explicit ?editmode=true asks for the supplement, or the window.clayEditMode
+  // global a standalone page sets before this script; the owner cookie is not an edit
+  // request, because an owner who opens a document in view resolves to view.
+  function __clayLikelyEdit(search) {
+    var asked = new URLSearchParams(search).get("editmode");
+    if (asked) return asked === "true";
+    if (typeof clayEditMode !== "undefined") return Boolean(clayEditMode);
+    return typeof __hyperclayEditMode !== "undefined" && Boolean(__hyperclayEditMode);
+  }
+  var likelyEdit = __clayLikelyEdit(window.location.search);
+  // The supplement an edit page is about to import, preloaded like the manifest.
+  if (likelyEdit) M.preload.push(M.edit);
+  M.preload.forEach(function (file) {
+    var href = dir + file;
+    if (have[href]) return;
+    have[href] = true;
+    var link = document.createElement("link");
+    link.rel = "modulepreload";
+    link.href = href;
+    link.setAttribute("clay", "no-save");
+    document.head.appendChild(link);
+  });
+  if (!clay.__runtime) {
+    clay.__runtime = Promise.all([
+      import(dir + M.manifest),
+      likelyEdit ? import(dir + M.edit).catch(function () { return null; }) : null
+    ]).then(function (r) {
+      var manifest = r[0].default;
+      manifest.base = dir;
+      var edit = r[1] ? r[1].default : null;
+      var hints = null;
+      // The cached hint fetch a resolved edit, draft or first entry uses. A failed one
+      // clears itself for retry and never selects another release.
+      function loadEditHints() {
+        if (!hints) {
+          hints = (edit ? Promise.resolve(edit) : import(dir + M.edit).then(function (m) { return m.default; }))
+            .catch(function (err) { hints = null; throw err; });
+        }
+        return hints;
+      }
+      return { chunks: true, dir: dir, manifest: manifest, edit: edit, loadEditHints: loadEditHints };
+    }, function (err) {
+      console.warn("clayjs: the bundled runtime did not load, loading the module tree instead:", err);
+      return { chunks: false, tree: tree };
+    });
+  }
+  return { tree: tree, runtime: clay.__runtime };
+})({"dir":"m/","manifest":"manifest-4C419D67.js","edit":"manifest-edit-B077F288.js","preload":["options/options-EJMS3K24.js","c-7SWMYKAI.js","c-ZWIOJGMT.js","c-IJUK2GPW.js","c-VG5XIN4T.js","c-2YYDMLNZ.js","c-HA6INT6J.js","c-WRBKEJD4.js","c-DCFSEJZG.js","c-VHNSBD2M.js","manifest-4C419D67.js"]})
+
+  // Subscribes to the mutation hub (observes document.body); wait for DOM ready.
+  function domReady() {
+    return new Promise(function (r) {
+      if (document.readyState === "loading") document.addEventListener("DOMContentLoaded", r);
+      else r();
+    });
+  }
+
+  clay.loaded.options = domReady()
+    .then(function () { return __clayChunks.runtime.then(function (R) {
+  if (!R.chunks) return import(__clayChunks.tree + "/src/options/options.js");
+  var file = R.manifest.entries["options/options.js"];
+  if (!file) throw new Error("clayjs: release " + R.manifest.version + " has no options/options.js");
+  return import(R.dir + file);
+}); })
+    .catch(function (err) { console.error("clay-options failed to load:", err); throw err; });
+  // Mark handled: see clay-ui.js.
+  clay.loaded.options.catch(function () {});
+})();

package/dist/clay-router.js

@@ -0,0 +1,98 @@
+/* clay-router.js — clayjs satellite: URL-hash routing as tab-local attributes. https://clayjs.com */
+(function () {
+  var clay = window.clay = window.clay || {};
+  clay.loaded = clay.loaded || {};
+
+  var script = document.currentScript;
+  if (!script || !script.src) {
+    console.error("clay-router: could not determine my own URL (load me with a classic <script src=...>, not type=\"module\")");
+    return;
+  }
+  var url = new URL(script.src, location.href);
+  // Query and fragment off first, then step out of the tarball's entries/ directory
+  // so package-path CDNs resolve src/. See clay.js for the full reason on both.
+  var path = url.href.split("#")[0].split("?")[0];
+  var base = path.slice(0, path.lastIndexOf("/"));
+  if (url.pathname.slice(0, url.pathname.lastIndexOf("/")).slice(-8) === "/entries") {
+    base = base.slice(0, -8);
+  }
+
+  var __clayChunks = (function (M) {
+  var clay = window.clay = window.clay || {};
+  var dir = new URL(M.dir, base + "/").href;
+  var tree = base.slice(-5) === "/dist" ? base.slice(0, -5) : base;
+  var have = {};
+  document.head.querySelectorAll('link[rel="modulepreload"]').forEach(function (link) { have[link.href] = true; });
+  // Only an explicit ?editmode=true asks for the supplement, or the window.clayEditMode
+  // global a standalone page sets before this script; the owner cookie is not an edit
+  // request, because an owner who opens a document in view resolves to view.
+  function __clayLikelyEdit(search) {
+    var asked = new URLSearchParams(search).get("editmode");
+    if (asked) return asked === "true";
+    if (typeof clayEditMode !== "undefined") return Boolean(clayEditMode);
+    return typeof __hyperclayEditMode !== "undefined" && Boolean(__hyperclayEditMode);
+  }
+  var likelyEdit = __clayLikelyEdit(window.location.search);
+  // The supplement an edit page is about to import, preloaded like the manifest.
+  if (likelyEdit) M.preload.push(M.edit);
+  M.preload.forEach(function (file) {
+    var href = dir + file;
+    if (have[href]) return;
+    have[href] = true;
+    var link = document.createElement("link");
+    link.rel = "modulepreload";
+    link.href = href;
+    link.setAttribute("clay", "no-save");
+    document.head.appendChild(link);
+  });
+  if (!clay.__runtime) {
+    clay.__runtime = Promise.all([
+      import(dir + M.manifest),
+      likelyEdit ? import(dir + M.edit).catch(function () { return null; }) : null
+    ]).then(function (r) {
+      var manifest = r[0].default;
+      manifest.base = dir;
+      var edit = r[1] ? r[1].default : null;
+      var hints = null;
+      // The cached hint fetch a resolved edit, draft or first entry uses. A failed one
+      // clears itself for retry and never selects another release.
+      function loadEditHints() {
+        if (!hints) {
+          hints = (edit ? Promise.resolve(edit) : import(dir + M.edit).then(function (m) { return m.default; }))
+            .catch(function (err) { hints = null; throw err; });
+        }
+        return hints;
+      }
+      return { chunks: true, dir: dir, manifest: manifest, edit: edit, loadEditHints: loadEditHints };
+    }, function (err) {
+      console.warn("clayjs: the bundled runtime did not load, loading the module tree instead:", err);
+      return { chunks: false, tree: tree };
+    });
+  }
+  return { tree: tree, runtime: clay.__runtime };
+})({"dir":"m/","manifest":"manifest-4C419D67.js","edit":"manifest-edit-B077F288.js","preload":["route/route-KOCZSEGN.js","c-VHNSBD2M.js","manifest-4C419D67.js"]})
+
+  // Mirror the hash onto <html> now, before the module loads, so a saved
+  // show-when:route-* rule is right at first paint. The module re-applies.
+  try {
+    var raw = location.hash.slice(1);
+    if (raw.indexOf("=") !== -1) {
+      new URLSearchParams(raw).forEach(function (value, name) {
+        if (/^[a-z][a-z0-9-]*$/.test(name) && name !== "active" && value) {
+          document.documentElement.setAttribute("route-" + name, value);
+        }
+      });
+    }
+  } catch (e) { /* the module applies it */ }
+
+  clay.loaded.router = __clayChunks.runtime.then(function (R) {
+  if (!R.chunks) return import(__clayChunks.tree + "/src/route/route.js");
+  var file = R.manifest.entries["route/route.js"];
+  if (!file) throw new Error("clayjs: release " + R.manifest.version + " has no route/route.js");
+  return import(R.dir + file);
+})
+    .then(function (m) { return m.default; })
+    .catch(function (err) { console.error("clay-router failed to load:", err); throw err; });
+  // Mark handled: see clay-ui.js.
+  clay.loaded.router.catch(function () {});
+})();

package/dist/clay-ui.js

@@ -0,0 +1,95 @@
+/* clay-ui.js — clayjs satellite: toasts, modals, ask/confirm/tell dialogs, auto clay:save-* feedback. https://clayjs.com */
+(function () {
+  var clay = window.clay = window.clay || {};
+  clay.loaded = clay.loaded || {};
+
+  var script = document.currentScript;
+  if (!script || !script.src) {
+    console.error("clay-ui: could not determine my own URL (load me with a classic <script src=...>, not type=\"module\")");
+    return;
+  }
+  var url = new URL(script.src, location.href);
+  // Query and fragment off first, then step out of the tarball's entries/ directory
+  // so package-path CDNs resolve src/. See clay.js for the full reason on both.
+  var path = url.href.split("#")[0].split("?")[0];
+  var base = path.slice(0, path.lastIndexOf("/"));
+  if (url.pathname.slice(0, url.pathname.lastIndexOf("/")).slice(-8) === "/entries") {
+    base = base.slice(0, -8);
+  }
+
+  var __clayChunks = (function (M) {
+  var clay = window.clay = window.clay || {};
+  var dir = new URL(M.dir, base + "/").href;
+  var tree = base.slice(-5) === "/dist" ? base.slice(0, -5) : base;
+  var have = {};
+  document.head.querySelectorAll('link[rel="modulepreload"]').forEach(function (link) { have[link.href] = true; });
+  // Only an explicit ?editmode=true asks for the supplement, or the window.clayEditMode
+  // global a standalone page sets before this script; the owner cookie is not an edit
+  // request, because an owner who opens a document in view resolves to view.
+  function __clayLikelyEdit(search) {
+    var asked = new URLSearchParams(search).get("editmode");
+    if (asked) return asked === "true";
+    if (typeof clayEditMode !== "undefined") return Boolean(clayEditMode);
+    return typeof __hyperclayEditMode !== "undefined" && Boolean(__hyperclayEditMode);
+  }
+  var likelyEdit = __clayLikelyEdit(window.location.search);
+  // The supplement an edit page is about to import, preloaded like the manifest.
+  if (likelyEdit) M.preload.push(M.edit);
+  M.preload.forEach(function (file) {
+    var href = dir + file;
+    if (have[href]) return;
+    have[href] = true;
+    var link = document.createElement("link");
+    link.rel = "modulepreload";
+    link.href = href;
+    link.setAttribute("clay", "no-save");
+    document.head.appendChild(link);
+  });
+  if (!clay.__runtime) {
+    clay.__runtime = Promise.all([
+      import(dir + M.manifest),
+      likelyEdit ? import(dir + M.edit).catch(function () { return null; }) : null
+    ]).then(function (r) {
+      var manifest = r[0].default;
+      manifest.base = dir;
+      var edit = r[1] ? r[1].default : null;
+      var hints = null;
+      // The cached hint fetch a resolved edit, draft or first entry uses. A failed one
+      // clears itself for retry and never selects another release.
+      function loadEditHints() {
+        if (!hints) {
+          hints = (edit ? Promise.resolve(edit) : import(dir + M.edit).then(function (m) { return m.default; }))
+            .catch(function (err) { hints = null; throw err; });
+        }
+        return hints;
+      }
+      return { chunks: true, dir: dir, manifest: manifest, edit: edit, loadEditHints: loadEditHints };
+    }, function (err) {
+      console.warn("clayjs: the bundled runtime did not load, loading the module tree instead:", err);
+      return { chunks: false, tree: tree };
+    });
+  }
+  return { tree: tree, runtime: clay.__runtime };
+})({"dir":"m/","manifest":"manifest-4C419D67.js","edit":"manifest-edit-B077F288.js","preload":["ui/index-3JLVI27O.js","c-AMSNPOCX.js","c-KIPQJX4B.js","c-QHWJ5ZIJ.js","c-4JZDZFF6.js","c-46XYM55L.js","c-LFPHCXY3.js","c-OIBUTDXI.js","c-VAK7SG37.js","c-NUHP2XDB.js","c-ZUCOKOHT.js","c-UL2YUY52.js","c-VKEDWYDF.js","c-2AZDZWCK.js","c-VHNSBD2M.js","manifest-4C419D67.js"]})
+
+  // Toasts and dialogs append to document.body, so `loaded.ui` must not resolve
+  // before the DOM is ready (same gate as clay-events).
+  function domReady() {
+    return new Promise(function (r) {
+      if (document.readyState === "loading") document.addEventListener("DOMContentLoaded", r);
+      else r();
+    });
+  }
+
+  clay.loaded.ui = domReady()
+    .then(function () { return __clayChunks.runtime.then(function (R) {
+  if (!R.chunks) return import(__clayChunks.tree + "/src/ui/index.js");
+  var file = R.manifest.entries["ui/index.js"];
+  if (!file) throw new Error("clayjs: release " + R.manifest.version + " has no ui/index.js");
+  return import(R.dir + file);
+}); })
+    .catch(function (err) { console.error("clay-ui failed to load:", err); throw err; });
+  // Mark handled: a blocked satellite must not emit an unhandled rejection.
+  // Consumers who await clay.loaded.ui still get the error.
+  clay.loaded.ui.catch(function () {});
+})();