@wizzlethorpe/vaults 0.9.4 → 0.9.6

package/dist/foundry-importer.bundle.js

@@ -0,0 +1,1270 @@
+// ../foundry/scripts/api.mjs
+function url(vault, path) {
+  if (!vault?.url) throw new Error("Vault URL is not configured.");
+  const u = new URL(path, vault.url.endsWith("/") ? vault.url : vault.url + "/");
+  if (vault.token) u.searchParams.set("_token", vault.token);
+  return u.toString();
+}
+async function fetchJson(u) {
+  const res = await fetch(u);
+  if (!res.ok) throw new Error(`GET ${u} \u2192 ${res.status}`);
+  return res.json();
+}
+async function fetchManifest(vault) {
+  return fetchJson(url(vault, "/_manifest.json"));
+}
+var BATCH_SIZE = 100;
+var BATCH_CONCURRENCY = 4;
+var DIRECT_CONCURRENCY = 8;
+async function fetchSourceBatch(vault, paths) {
+  if (paths.length === 0) return /* @__PURE__ */ new Map();
+  if (vault.public) return fetchSourceDirect(vault, paths);
+  const endpoint = url(vault, "/_batch");
+  const chunks = [];
+  for (let i = 0; i < paths.length; i += BATCH_SIZE) chunks.push(paths.slice(i, i + BATCH_SIZE));
+  const out = /* @__PURE__ */ new Map();
+  let next = 0;
+  const workers = Array.from({ length: Math.min(BATCH_CONCURRENCY, chunks.length) }, async () => {
+    while (next < chunks.length) {
+      const idx = next++;
+      const res = await fetch(endpoint, {
+        method: "POST",
+        headers: { "Content-Type": "text/plain" },
+        body: chunks[idx].join("\n")
+      });
+      if (!res.ok) throw new Error(`POST /_batch \u2192 ${res.status}`);
+      const data = await res.json();
+      if (data.files) {
+        for (const [p, content] of Object.entries(data.files)) out.set(p, content);
+      }
+    }
+  });
+  await Promise.all(workers);
+  return out;
+}
+async function fetchSourceDirect(vault, paths) {
+  const out = /* @__PURE__ */ new Map();
+  let next = 0;
+  const workers = Array.from({ length: Math.min(DIRECT_CONCURRENCY, paths.length) }, async () => {
+    while (next < paths.length) {
+      const idx = next++;
+      const path = paths[idx];
+      const u = url(vault, "/" + path);
+      try {
+        const res = await fetch(u);
+        if (!res.ok) {
+          if (res.status !== 404) console.warn(`Vaults | GET ${path} \u2192 ${res.status}`);
+          continue;
+        }
+        out.set(path, await res.text());
+      } catch (err) {
+        console.warn(`Vaults | GET ${path} failed:`, err);
+      }
+    }
+  });
+  await Promise.all(workers);
+  return out;
+}
+
+// ../foundry/scripts/settings.mjs
+var MODULE_ID = "vaults";
+
+// ../foundry/scripts/util.mjs
+function escapeAttr(s) {
+  return String(s ?? "").replace(/[&<>"]/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" })[c]);
+}
+function escapeHtml(s) {
+  return String(s ?? "").replace(/[&<>]/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;" })[c]);
+}
+function escapeBraces(s) {
+  return String(s).replace(/[{}]/g, "");
+}
+async function hexDigest(algorithm, text) {
+  const buf = await crypto.subtle.digest(algorithm, new TextEncoder().encode(text));
+  return [...new Uint8Array(buf)].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+// ../foundry/scripts/ids.mjs
+async function det(kind, key) {
+  const hex = await hexDigest("SHA-1", `vaults:${kind}:${key}`);
+  return hex.slice(0, 16);
+}
+function folderOfPath(path) {
+  const i = path.lastIndexOf("/");
+  return i < 0 ? "" : path.slice(0, i);
+}
+var entryId = (vaultId, path) => det("entry", `${vaultId}:${folderOfPath(path)}`);
+var pageId = (vaultId, path) => det("page", `${vaultId}:${path}`);
+var folderId = (vaultId, path) => det("folder", `${vaultId}:${path}`);
+var instanceId = (vaultId, path) => det("instance", `${vaultId}:${path}`);
+var subdocId = (vaultId, path, pointer) => det("subdoc", `${vaultId}:${path}:${pointer}`);
+
+// ../foundry/scripts/parser.mjs
+var CACHED_EXT_RE = /\.(png|jpe?g|webp|gif|svg|avif|tiff?|bmp|heic|apng|ogg|mp3|m4a|wav|flac|opus|aac|mp4|webm|mov|ogv|pdf|epub|json)$/i;
+
+// ../foundry/scripts/media.mjs
+var CACHE_DIR = "vaults-cache";
+var BATCH_SIZE2 = 25;
+var BATCH_BYTE_BUDGET = 8 * 1024 * 1024;
+var BATCH_CONCURRENCY2 = 4;
+function isCacheable(path) {
+  if (!CACHED_EXT_RE.test(path)) return false;
+  if (path.startsWith("_") || path.includes("/_")) return false;
+  if (/\.preview\.json$/i.test(path)) return false;
+  return true;
+}
+function localFileUrl(vaultId, vaultPath) {
+  const worldId = game.world?.id;
+  if (!worldId) throw new Error("No active world; cache path unavailable.");
+  const segs = vaultPath.split("/").map(encodeURIComponent).join("/");
+  const relative = `worlds/${worldId}/${CACHE_DIR}/${vaultId}/${segs}`;
+  return foundry.utils?.getRoute?.(relative) ?? `/${relative}`;
+}
+function vaultCacheDir(vaultId) {
+  const worldId = game.world.id;
+  return `worlds/${worldId}/${CACHE_DIR}/${vaultId}`;
+}
+async function syncImages(host, vault, manifestFiles) {
+  const remoteImages = /* @__PURE__ */ new Map();
+  for (const f of manifestFiles) {
+    if (isCacheable(f.path)) remoteImages.set(f.path, f.hash);
+  }
+  const lastImageManifest = host.getVaultState(vault.id).lastImageManifest;
+  const last = new Map(Object.entries(lastImageManifest || {}));
+  const toDownload = [];
+  for (const [path, hash] of remoteImages) {
+    if (last.get(path) !== hash) toDownload.push(path);
+  }
+  const toDelete = [...last.keys()].filter((p) => !remoteImages.has(p));
+  if (toDownload.length === 0 && toDelete.length === 0) return { downloaded: 0, removed: 0, errors: 0 };
+  const baseDir = vaultCacheDir(vault.id);
+  const worldRoot = `worlds/${game.world.id}`;
+  const dirsNeeded = /* @__PURE__ */ new Set();
+  const addChain = (fullPath) => {
+    const sub = fullPath.startsWith(worldRoot + "/") ? fullPath.slice(worldRoot.length + 1) : "";
+    if (!sub) return;
+    let acc = worldRoot;
+    for (const seg of sub.split("/")) {
+      acc += "/" + seg;
+      dirsNeeded.add(acc);
+    }
+  };
+  addChain(baseDir);
+  for (const p of toDownload) {
+    const segs = p.split("/").slice(0, -1);
+    if (segs.length > 0) addChain(`${baseDir}/${segs.join("/")}`);
+  }
+  await ensureDirs([...dirsNeeded]);
+  const sizeOf = /* @__PURE__ */ new Map();
+  for (const f of manifestFiles) sizeOf.set(f.path, f.size ?? 0);
+  const chunks = [];
+  let chunk = [];
+  let chunkBytes = 0;
+  for (const path of toDownload) {
+    const bytes = sizeOf.get(path) ?? 0;
+    if (chunk.length > 0 && (chunk.length >= BATCH_SIZE2 || chunkBytes + bytes > BATCH_BYTE_BUDGET)) {
+      chunks.push(chunk);
+      chunk = [];
+      chunkBytes = 0;
+    }
+    chunk.push(path);
+    chunkBytes += bytes;
+  }
+  if (chunk.length > 0) chunks.push(chunk);
+  let next = 0;
+  const downloaded = [];
+  const errors = [];
+  const workers = Array.from({ length: Math.min(BATCH_CONCURRENCY2, chunks.length) }, async () => {
+    while (next < chunks.length) {
+      const idx = next++;
+      const chunk2 = chunks[idx];
+      try {
+        const blobs = await fetchImagesBatch(vault, chunk2);
+        for (const path of chunk2) {
+          const blob = blobs.get(path);
+          if (!blob) {
+            errors.push({ path, err: new Error("missing in batch response") });
+            continue;
+          }
+          try {
+            await uploadToWorld(baseDir, path, blob);
+            downloaded.push(path);
+          } catch (err) {
+            errors.push({ path, err });
+          }
+        }
+      } catch (err) {
+        for (const path of chunk2) errors.push({ path, err });
+      }
+    }
+  });
+  await Promise.all(workers);
+  if (errors.length > 0) {
+    console.warn(`Vaults | ${errors.length} image(s) failed to download:`, errors);
+  }
+  let removed = 0;
+  for (const path of toDelete) {
+    try {
+      await deleteFromWorld(baseDir, path);
+      removed++;
+    } catch (err) {
+      console.warn(`Vaults | could not remove orphan ${path}:`, err?.message || err);
+    }
+  }
+  const persisted = {};
+  for (const [path, hash] of remoteImages) {
+    if (last.get(path) === hash) {
+      persisted[path] = hash;
+      continue;
+    }
+    if (downloaded.includes(path)) persisted[path] = hash;
+  }
+  await host.setVaultState(vault.id, { lastImageManifest: persisted });
+  return { downloaded: downloaded.length, removed, errors: errors.length };
+}
+async function deleteVaultCache(vaultId) {
+  const baseDir = vaultCacheDir(vaultId);
+  const impl = fp();
+  if (typeof impl.deleteFile !== "function") return false;
+  try {
+    await impl.deleteFile("data", baseDir);
+    return true;
+  } catch (err) {
+    console.warn(`Vaults | could not remove cache dir ${baseDir}:`, err?.message || err);
+    return false;
+  }
+}
+async function fetchImagesBatch(vault, paths) {
+  if (vault.public) return fetchImagesDirect(vault, paths);
+  const res = await fetch(url(vault, "/_batch-images"), {
+    method: "POST",
+    headers: { "Content-Type": "text/plain" },
+    // CORS-simple, no preflight
+    body: paths.join("\n")
+  });
+  if (!res.ok) throw new Error(`POST /_batch-images \u2192 ${res.status}`);
+  const data = await res.json();
+  const out = /* @__PURE__ */ new Map();
+  for (const [path, b64] of Object.entries(data.files || {})) {
+    out.set(path, base64ToBlob(b64, guessMime(path)));
+  }
+  return out;
+}
+async function fetchImagesDirect(vault, paths) {
+  const out = /* @__PURE__ */ new Map();
+  const PARALLEL = 6;
+  let next = 0;
+  const workers = Array.from({ length: Math.min(PARALLEL, paths.length) }, async () => {
+    while (next < paths.length) {
+      const idx = next++;
+      const path = paths[idx];
+      try {
+        const res = await fetch(url(vault, "/" + path));
+        if (!res.ok) continue;
+        const blob = await res.blob();
+        const typed = blob.type ? blob : new Blob([await blob.arrayBuffer()], { type: guessMime(path) });
+        out.set(path, typed);
+      } catch (err) {
+        console.warn(`Vaults | GET ${path} failed:`, err);
+      }
+    }
+  });
+  await Promise.all(workers);
+  return out;
+}
+function base64ToBlob(b64, type) {
+  const binary = atob(b64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+  return new Blob([bytes], { type });
+}
+function fp() {
+  return foundry.applications?.apps?.FilePicker?.implementation ?? FilePicker.implementation ?? FilePicker;
+}
+async function uploadToWorld(baseDir, path, blob) {
+  const segs = path.split("/");
+  const filename = segs.pop();
+  const dir = segs.length > 0 ? `${baseDir}/${segs.join("/")}` : baseDir;
+  const file = new File([blob], filename, { type: blob.type || guessMime(filename) });
+  const result = await fp().upload("data", dir, file, {}, { notify: false });
+  if (result === false || result?.status === "error") {
+    throw new Error(`upload failed: ${result?.message || "unknown"} (path=${dir}/${filename})`);
+  }
+}
+async function ensureDirs(paths) {
+  paths.sort((a, b) => a.length - b.length);
+  for (const p of paths) {
+    try {
+      await fp().createDirectory("data", p, {});
+    } catch (err) {
+      const msg = String(err?.message || err);
+      if (!/exists|already/i.test(msg)) throw err;
+    }
+  }
+}
+async function deleteFromWorld(baseDir, path) {
+  const full = `${baseDir}/${path}`;
+  const impl = fp();
+  if (typeof impl.deleteFile === "function") {
+    await impl.deleteFile("data", full);
+    return;
+  }
+  throw new Error("FilePicker.deleteFile is not available in this Foundry version.");
+}
+function guessMime(filename) {
+  const ext = filename.split(".").pop()?.toLowerCase();
+  return {
+    webp: "image/webp",
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    gif: "image/gif",
+    svg: "image/svg+xml",
+    avif: "image/avif",
+    tiff: "image/tiff",
+    bmp: "image/bmp",
+    heic: "image/heic",
+    apng: "image/apng",
+    ogg: "audio/ogg",
+    mp3: "audio/mpeg",
+    m4a: "audio/mp4",
+    wav: "audio/wav",
+    flac: "audio/flac",
+    opus: "audio/ogg",
+    aac: "audio/aac",
+    mp4: "video/mp4",
+    webm: "video/webm",
+    mov: "video/quicktime",
+    ogv: "video/ogg",
+    pdf: "application/pdf",
+    epub: "application/epub+zip",
+    json: "application/json"
+  }[ext] || "application/octet-stream";
+}
+
+// ../foundry/scripts/links.mjs
+var ANCHOR_RE = /<a\b([^>]*)>([\s\S]*?)<\/a>/gi;
+var MEDIA_SRC_RE = /<(img|audio|video)\b([^>]*?)src="([^"]+)"([^>]*)>/gi;
+var ATTR_HREF_RE = /\bhref="([^"]+)"/i;
+var ATTR_CLASS_RE = /\bclass="([^"]+)"/i;
+var TAG_RE = /<[^>]+>/g;
+function buildPathIndex(manifestFiles) {
+  const paths = /* @__PURE__ */ new Set();
+  const idOverrides = /* @__PURE__ */ new Map();
+  for (const f of manifestFiles) {
+    if (!f.path.endsWith(".body.html")) continue;
+    const mdPath = f.path.replace(/\.body\.html$/i, "") + ".md";
+    paths.add(mdPath);
+    const override = f.meta?.foundry?.id;
+    if (typeof override === "string" && override) idOverrides.set(mdPath, override);
+  }
+  return { paths, idOverrides };
+}
+function logicalPathFromHref(href) {
+  const decoded = decodeHtmlEntities(href);
+  const cleaned = decoded.replace(/^\//, "").split("#")[0];
+  try {
+    return decodeURIComponent(cleaned) + ".md";
+  } catch {
+    return cleaned + ".md";
+  }
+}
+function decodeHtmlEntities(s) {
+  const ta = document.createElement("textarea");
+  ta.innerHTML = s;
+  return ta.value;
+}
+async function transformHtmlForFoundry(vault, html, index) {
+  html = await rewriteWikilinks(vault.id, html, index);
+  html = rewriteMediaSrcs(vault.id, html);
+  html = rewritePassthroughLinks(vault.id, html);
+  html = await applyDomTransforms(html, vault, index);
+  return html;
+}
+async function applyDomTransforms(html, vault, index) {
+  const doc = new DOMParser().parseFromString(html, "text/html");
+  let touched = false;
+  touched = stripWebOnlyWidgets(doc) || touched;
+  touched = flattenBasesTabs(doc) || touched;
+  touched = neutralizeEnrichersInCode(doc) || touched;
+  touched = await rewriteBasesCardLinks(doc, vault.id, index) || touched;
+  touched = rewriteDiceButtons(doc) || touched;
+  touched = wrapRestrictedCalloutsAsSecret(doc, vault) || touched;
+  return touched ? doc.body.innerHTML : html;
+}
+var WEB_ONLY_WIDGET_SELECTOR = ".vaults-battlemap";
+function stripWebOnlyWidgets(doc) {
+  const widgets = doc.querySelectorAll(WEB_ONLY_WIDGET_SELECTOR);
+  for (const el of widgets) el.remove();
+  return widgets.length > 0;
+}
+function rewriteDiceButtons(doc) {
+  const buttons = doc.querySelectorAll("button.dice-roll[data-formula]");
+  if (buttons.length === 0) return false;
+  for (const btn of buttons) {
+    const formula = btn.getAttribute("data-formula");
+    if (!formula) continue;
+    btn.replaceWith(doc.createTextNode(`[[/r ${formula}]]`));
+  }
+  return true;
+}
+function flattenBasesTabs(doc) {
+  const tabbeds = doc.querySelectorAll(".bases-tabbed");
+  if (tabbeds.length === 0) return false;
+  for (const tabbed of tabbeds) {
+    const fragment = doc.createDocumentFragment();
+    for (const panel of tabbed.querySelectorAll(".bases-tab-panel")) {
+      panel.removeAttribute("hidden");
+      while (panel.firstChild) fragment.appendChild(panel.firstChild);
+    }
+    tabbed.replaceWith(fragment);
+  }
+  return true;
+}
+function neutralizeEnrichersInCode(doc) {
+  const codes = doc.querySelectorAll("code, pre");
+  if (codes.length === 0) return false;
+  const ZWS = "\u200B";
+  let touched = false;
+  for (const el of codes) {
+    const walker = doc.createTreeWalker(el, NodeFilter.SHOW_TEXT);
+    let node;
+    while (node = walker.nextNode()) {
+      const orig = node.nodeValue;
+      if (orig.indexOf("@") < 0) continue;
+      const next = orig.replace(/@/g, "@" + ZWS);
+      if (next !== orig) {
+        node.nodeValue = next;
+        touched = true;
+      }
+    }
+  }
+  return touched;
+}
+async function rewriteBasesCardLinks(doc, vaultId, index) {
+  const cards = doc.querySelectorAll("a.bases-card[href]");
+  if (cards.length === 0) return false;
+  let touched = false;
+  for (const a of cards) {
+    const href = a.getAttribute("href") || "";
+    if (!href.startsWith("/")) continue;
+    const path = logicalPathFromHref(href);
+    if (!index.paths.has(path)) continue;
+    const eId = await entryId(vaultId, path);
+    const pId = index.idOverrides?.get(path) ?? await pageId(vaultId, path);
+    a.classList.add("content-link");
+    a.setAttribute("data-uuid", `JournalEntry.${eId}.JournalEntryPage.${pId}`);
+    a.removeAttribute("href");
+    touched = true;
+  }
+  return touched;
+}
+function wrapRestrictedCalloutsAsSecret(doc, vault) {
+  if (!vault?.dmRole || !Array.isArray(vault.knownRoles) || vault.knownRoles.length === 0) {
+    return false;
+  }
+  const dmIdx = vault.knownRoles.indexOf(vault.dmRole);
+  if (dmIdx < 0) return false;
+  const restrictedRoles = vault.knownRoles.slice(dmIdx);
+  if (restrictedRoles.length === 0) return false;
+  let touched = false;
+  for (const role of restrictedRoles) {
+    for (const el of doc.querySelectorAll(".callout.callout-" + cssEscape(role))) {
+      const section = doc.createElement("section");
+      section.className = "secret";
+      el.parentNode.insertBefore(section, el);
+      section.appendChild(el);
+      touched = true;
+    }
+  }
+  return touched;
+}
+function cssEscape(s) {
+  return String(s).replace(/[^a-zA-Z0-9_-]/g, "\\$&");
+}
+async function rewriteWikilinks(vaultId, html, index) {
+  const matches = [];
+  let m;
+  ANCHOR_RE.lastIndex = 0;
+  while ((m = ANCHOR_RE.exec(html)) !== null) {
+    const [full, attrs, inner] = m;
+    const cls = ATTR_CLASS_RE.exec(attrs)?.[1] || "";
+    if (!/\binternal-link\b/.test(cls)) continue;
+    const label = stripTags(inner);
+    const isUnresolved = /\bis-unresolved\b/.test(cls);
+    const href = ATTR_HREF_RE.exec(attrs)?.[1] || "";
+    const path = href.startsWith("/") ? logicalPathFromHref(href) : null;
+    const inIndex = path != null && index.paths.has(path);
+    if (isUnresolved || !inIndex) {
+      matches.push({ idx: m.index, length: full.length, kind: "broken", label });
+      continue;
+    }
+    matches.push({ idx: m.index, length: full.length, kind: "uuid", label, path });
+  }
+  const uuidMatches = matches.filter((r) => r.kind === "uuid");
+  const resolved = await Promise.all(uuidMatches.map(async (r) => ({
+    eId: await entryId(vaultId, r.path),
+    pId: index.idOverrides?.get(r.path) ?? await pageId(vaultId, r.path)
+  })));
+  uuidMatches.forEach((r, i) => {
+    r.eId = resolved[i].eId;
+    r.pId = resolved[i].pId;
+  });
+  matches.sort((a, b) => b.idx - a.idx);
+  for (const r of matches) {
+    const replacement = r.kind === "uuid" ? `@UUID[JournalEntry.${r.eId}.JournalEntryPage.${r.pId}]{${escapeBraces(r.label)}}` : `<span class="vaults-broken">${escapeHtml(r.label)}</span>`;
+    html = html.slice(0, r.idx) + replacement + html.slice(r.idx + r.length);
+  }
+  return html;
+}
+function rewriteMediaSrcs(vaultId, html) {
+  return html.replace(MEDIA_SRC_RE, (full, tag, before, src, after) => {
+    if (!src.startsWith("/")) return full;
+    const path = decodeURIComponent(src.replace(/^\//, ""));
+    if (!CACHED_EXT_RE.test(path)) return full;
+    return `<${tag}${before}src="${escapeAttr(localFileUrl(vaultId, path))}"${after}>`;
+  });
+}
+function rewritePassthroughLinks(vaultId, html) {
+  return html.replace(ANCHOR_RE, (full, attrs, inner) => {
+    const cls = ATTR_CLASS_RE.exec(attrs)?.[1] || "";
+    if (!/\bpassthrough-link\b/.test(cls)) return full;
+    const href = ATTR_HREF_RE.exec(attrs)?.[1] || "";
+    if (!href.startsWith("/")) return full;
+    const path = decodeURIComponent(href.replace(/^\//, ""));
+    if (!CACHED_EXT_RE.test(path)) return full;
+    const newAttrs = attrs.replace(ATTR_HREF_RE, `href="${escapeAttr(localFileUrl(vaultId, path))}"`);
+    return `<a${newAttrs}>${inner}</a>`;
+  });
+}
+function stripTags(s) {
+  return s.replace(TAG_RE, "").trim();
+}
+
+// ../foundry/scripts/importer.mjs
+var INDEX_BASENAME = "index";
+var NON_INDEX_SORT_BASE = 1e5;
+var KNOWN_INSTANCE_DOC_TYPES = [
+  "Actor",
+  "Item",
+  "Scene",
+  "JournalEntry",
+  "RollTable",
+  "Macro",
+  "Cards",
+  "Playlist"
+];
+function inferInstanceDocName(base) {
+  if (typeof base !== "string" || !base) return null;
+  const raw = base.includes(".") ? base.split(".").at(-2) : base.split(":")[0];
+  return KNOWN_INSTANCE_DOC_TYPES.find((t) => t.toLowerCase() === raw?.toLowerCase()) ?? null;
+}
+async function ensureFolderChain(vault, segments) {
+  const rootName = vault.rootFolder || vault.label || "Vault";
+  const rootKey = `${vault.id}/__root__/${rootName}`;
+  const rootFId = await folderId(vault.id, rootKey);
+  await upsertFolder(rootFId, rootName, null);
+  let parentId = rootFId;
+  let acc = rootKey;
+  for (const seg of segments) {
+    acc += "/" + seg;
+    const fId = await folderId(vault.id, acc);
+    await upsertFolder(fId, seg, parentId);
+    parentId = fId;
+  }
+  return parentId;
+}
+async function upsertFolder(id, name, parentId) {
+  const existing = game.folders.get(id);
+  if (existing) {
+    if (existing.name !== name || existing.folder?.id !== parentId) {
+      await existing.update({ name, folder: parentId });
+    }
+    return existing;
+  }
+  return Folder.create({ _id: id, name, type: "JournalEntry", folder: parentId }, { keepId: true });
+}
+function buildFolderInfo(mdPaths) {
+  const map = /* @__PURE__ */ new Map();
+  const ensure = (folderPath) => {
+    let info = map.get(folderPath);
+    if (!info) {
+      const segs = folderPath ? folderPath.split("/") : [];
+      info = { hasSubfolders: false, displayName: segs[segs.length - 1] || "" };
+      map.set(folderPath, info);
+    }
+    return info;
+  };
+  ensure("");
+  for (const p of mdPaths) {
+    const folderPath = folderOfPath(p);
+    ensure(folderPath);
+    const segs = folderPath ? folderPath.split("/") : [];
+    for (let i = 0; i < segs.length; i++) {
+      ensure(segs.slice(0, i).join("/")).hasSubfolders = true;
+    }
+  }
+  return map;
+}
+function isIndexFile(filename) {
+  return filename.replace(/\.md$/i, "") === INDEX_BASENAME;
+}
+async function upsertFile(vault, path, body, index, meta, folderInfo) {
+  let html = await transformHtmlForFoundry(vault, body, index);
+  html = await appendInstanceDocLink(html, vault, path, meta);
+  const segs = path.split("/");
+  const filename = segs.pop();
+  const folderPath = segs.join("/");
+  const fInfo = folderInfo?.get(folderPath);
+  const leaf = !!fInfo && folderPath !== "" && !fInfo.hasSubfolders;
+  const hostSegs = leaf ? segs.slice(0, -1) : segs;
+  const folderFId = await ensureFolderChain(vault, hostSegs);
+  const entryName = folderPath === "" ? vault.rootFolder || vault.label || "Vault" : fInfo?.displayName || segs[segs.length - 1] || "";
+  const pageName = meta?.title || filename.replace(/\.md$/i, "");
+  const eId = await entryId(vault.id, path);
+  const idOverride = meta?.foundry?.id;
+  const pId = typeof idOverride === "string" && idOverride ? idOverride : await pageId(vault.id, path);
+  const pageOwnership = pageOwnershipLevelFor(vault, meta?.role);
+  const flags = { [MODULE_ID]: { vaultId: vault.id, path } };
+  const pageData = {
+    _id: pId,
+    name: pageName,
+    type: "text",
+    text: {
+      content: html,
+      format: 1
+      /* HTML */
+    },
+    sort: isIndexFile(filename) ? 0 : NON_INDEX_SORT_BASE,
+    flags,
+    // Ownership is set on the *page*, not the parent entry: in the
+    // folder-as-entry model a single entry can host pages of different
+    // tiers, and entry-level ownership would leak DM pages to players via
+    // the default INHERIT on sibling pages. The entry's own ownership is
+    // reconciled separately as the max of its pages' levels (so the entry
+    // remains visible in the sidebar to anyone who can see at least one
+    // page in it). See reconcileOwnership below.
+    ...pageOwnership !== null ? { ownership: { default: pageOwnership } } : {}
+  };
+  const existing = game.journal.get(eId);
+  if (existing) {
+    const entryPatch = {};
+    if (existing.name !== entryName) entryPatch.name = entryName;
+    if (existing.folder?.id !== folderFId) entryPatch.folder = folderFId;
+    if (Object.keys(entryPatch).length > 0) await existing.update(entryPatch);
+    const existingPage = existing.pages.get(pId);
+    if (existingPage) await existingPage.update(pageData);
+    else await existing.createEmbeddedDocuments("JournalEntryPage", [pageData], { keepId: true });
+    return "modified";
+  }
+  await JournalEntry.create({
+    _id: eId,
+    name: entryName,
+    folder: folderFId,
+    pages: [pageData],
+    flags,
+    // Bootstrap the entry visible at the page's tier so player-visible
+    // pages aren't hidden in the gap between create and the post-sync
+    // reconcileOwnership pass. Mixed-tier folders converge to max(pages)
+    // via reconcile.
+    ...pageOwnership !== null ? { ownership: { default: pageOwnership } } : {}
+  }, { keepId: true });
+  return "added";
+}
+function pageOwnershipLevelFor(vault, pageRole) {
+  if (!vault.dmRole || !vault.knownRoles?.length) return null;
+  const dmIdx = vault.knownRoles.indexOf(vault.dmRole);
+  if (dmIdx < 0) return null;
+  const pageIdx = pageRole ? vault.knownRoles.indexOf(pageRole) : -1;
+  const effectiveIdx = pageIdx < 0 ? 0 : pageIdx;
+  return effectiveIdx < dmIdx ? CONST.DOCUMENT_OWNERSHIP_LEVELS.OBSERVER : CONST.DOCUMENT_OWNERSHIP_LEVELS.NONE;
+}
+async function reconcileOwnership(vault, bodyMetaIndex) {
+  if (!vault.dmRole || !vault.knownRoles?.length) return;
+  const ours = game.journal.contents.filter(
+    (j) => j.getFlag(MODULE_ID, "vaultId") === vault.id
+  );
+  for (const entry of ours) {
+    let entryMax = null;
+    for (const page of entry.pages.contents) {
+      const pPath = page.getFlag(MODULE_ID, "path");
+      if (!pPath) continue;
+      const bodyPath = pPath.replace(/\.md$/i, ".body.html");
+      const meta = bodyMetaIndex.get(bodyPath);
+      if (!meta) continue;
+      const level = pageOwnershipLevelFor(vault, meta.role);
+      if (level === null) continue;
+      if (page.ownership?.default !== level) {
+        try {
+          await page.update({ ownership: { default: level } });
+        } catch (err) {
+          console.warn(`Vaults | reconcile ownership ${pPath} \u2192 ${level} failed:`, err);
+        }
+      }
+      if (entryMax === null || level > entryMax) entryMax = level;
+    }
+    if (entryMax !== null && entry.ownership?.default !== entryMax) {
+      try {
+        await entry.update({ ownership: { default: entryMax } });
+      } catch (err) {
+        console.warn(`Vaults | reconcile entry ownership for ${entry.name} \u2192 ${entryMax} failed:`, err);
+      }
+    }
+  }
+}
+async function reconcileEntryPlacement(vault, folderInfo) {
+  const ours = game.journal.contents.filter(
+    (j) => j.getFlag(MODULE_ID, "vaultId") === vault.id
+  );
+  for (const entry of ours) {
+    const firstPage = entry.pages.contents[0];
+    const path = firstPage?.getFlag(MODULE_ID, "path");
+    if (!path) continue;
+    const segs = path.split("/");
+    segs.pop();
+    const folderPath = segs.join("/");
+    const fInfo = folderInfo?.get(folderPath);
+    const leaf = !!fInfo && folderPath !== "" && !fInfo.hasSubfolders;
+    const hostSegs = leaf ? segs.slice(0, -1) : segs;
+    const expectedFolderId = await ensureFolderChain(vault, hostSegs);
+    if (entry.folder?.id !== expectedFolderId) {
+      try {
+        await entry.update({ folder: expectedFolderId });
+      } catch (err) {
+        console.warn(`Vaults | re-place ${path} \u2192 ${expectedFolderId} failed:`, err);
+      }
+    }
+  }
+}
+async function deleteFile(vault, path) {
+  const eId = await entryId(vault.id, path);
+  const pId = await pageId(vault.id, path);
+  const entry = game.journal.get(eId);
+  if (!entry) return;
+  const page = entry.pages.get(pId);
+  if (page) await page.delete();
+  if (entry.pages.size === 0) await entry.delete();
+}
+async function deleteVaultJournals(vaultId) {
+  const journals = game.journal.contents.filter((j) => j.getFlag(MODULE_ID, "vaultId") === vaultId);
+  for (const j of journals) await j.delete();
+  const folders = game.folders.contents.filter((f) => f.type === "JournalEntry");
+  for (const f of folders.reverse()) {
+    if (f.contents.length === 0 && f.children.length === 0) {
+      const root = await folderId(vaultId, `${vaultId}/__root__/${f.name}`);
+      if (f.id === root) await f.delete();
+    }
+  }
+}
+async function appendInstanceDocLink(html, vault, path, meta) {
+  const base = meta?.foundry?.base;
+  const docName = inferInstanceDocName(base);
+  if (!docName) return html;
+  const idOverride = meta?.foundry?.id;
+  const docId = typeof idOverride === "string" && idOverride ? idOverride : await instanceId(vault.id, path);
+  const label = meta?.title || path.split("/").pop().replace(/\.md$/i, "");
+  return html + `
+<p class="vaults-instance-link"><em>Foundry document:</em> @UUID[${docName}.${docId}]{${escapeBraces(label)}}</p>`;
+}
+
+// ../foundry/scripts/instance.mjs
+var DESCRIPTION_FIELDS = {
+  dnd5e: {
+    Actor: "system.details.biography.value",
+    Item: "system.description.value"
+  }
+};
+var CLONE_SUPPORTED_DOCS = /* @__PURE__ */ new Set(["Actor", "Item"]);
+var BLANK_DOC_TYPES = /* @__PURE__ */ new Set([
+  "Actor",
+  "Item",
+  "Scene",
+  "JournalEntry",
+  "RollTable",
+  "Macro",
+  "Cards",
+  "Playlist"
+]);
+var COLLECTION_FOR = {
+  Actor: () => game.actors,
+  Item: () => game.items,
+  Scene: () => game.scenes,
+  JournalEntry: () => game.journal,
+  RollTable: () => game.tables,
+  Macro: () => game.macros,
+  Cards: () => game.cards,
+  Playlist: () => game.playlists
+};
+async function applyInstance(vault, vaultPath, meta) {
+  const fm = meta?.foundry;
+  if (!fm || typeof fm !== "object") return;
+  const parsed = parseFoundryBase(fm.base);
+  if (!parsed) return;
+  let docName;
+  let baseData;
+  if (parsed.kind === "uuid") {
+    const template = await safeFromUuid(parsed.uuid);
+    if (!template) {
+      console.warn(`Vaults | foundry.base: ${vaultPath} \u2192 ${parsed.uuid} did not resolve; skipping.`);
+      return;
+    }
+    docName = template.documentName;
+    if (!CLONE_SUPPORTED_DOCS.has(docName)) {
+      console.warn(
+        `Vaults | foundry.base: ${vaultPath} \u2192 ${parsed.uuid} is a ${docName}; clone-from-UUID only supports ${[...CLONE_SUPPORTED_DOCS].join(", ")}.`
+      );
+      return;
+    }
+    try {
+      baseData = template.toObject();
+    } catch (err) {
+      console.warn(`Vaults | foundry.base: could not read template ${parsed.uuid}:`, err);
+      return;
+    }
+    delete baseData._id;
+  } else {
+    docName = parsed.docName;
+    baseData = parsed.subtype ? { type: parsed.subtype } : {};
+  }
+  const collection = COLLECTION_FOR[docName]?.();
+  if (!collection) {
+    console.warn(`Vaults | foundry.base: no world collection for ${docName}; skipping ${vaultPath}.`);
+    return;
+  }
+  const docClass = CONFIG[docName].documentClass;
+  const id = typeof fm.id === "string" && fm.id ? fm.id : await instanceId(vault.id, vaultPath);
+  const dataJson = fm.data_json && typeof fm.data_json === "object" && !Array.isArray(fm.data_json) ? rewriteVaultPaths(structuredClone(fm.data_json), vault.id) : null;
+  if (dataJson) await ensureEmbeddedIds(dataJson, vault.id, vaultPath);
+  const overlay = await buildOverlay(vault, vaultPath, meta, docName);
+  const existing = collection.get(id);
+  if (existing) {
+    const updatePatch = dataJson ? deepMerge(structuredClone(dataJson), overlay) : overlay;
+    try {
+      await existing.update(updatePatch);
+    } catch (err) {
+      console.warn(`Vaults | foundry.base update failed for ${vaultPath}:`, err);
+    }
+    return;
+  }
+  if (dataJson) deepMerge(baseData, dataJson);
+  baseData._id = id;
+  deepMerge(baseData, overlay);
+  try {
+    await docClass.create(baseData, { keepId: true, keepEmbeddedIds: true });
+  } catch (err) {
+    console.warn(`Vaults | foundry.base create failed for ${vaultPath}:`, err);
+    return;
+  }
+  if (docName === "Scene") {
+    const created = collection.get(id);
+    if (created && !created.thumb) {
+      try {
+        const { thumb } = await created.createThumbnail();
+        if (thumb) await created.update({ thumb });
+      } catch (err) {
+        console.warn(`Vaults | scene thumbnail generation failed for ${vaultPath}:`, err);
+      }
+    }
+  }
+}
+function parseFoundryBase(spec) {
+  if (typeof spec !== "string" || !spec) return null;
+  if (spec.includes(".")) return { kind: "uuid", uuid: spec };
+  const [typeRaw, subtype] = spec.split(":");
+  const docName = [...BLANK_DOC_TYPES].find((t) => t.toLowerCase() === typeRaw.toLowerCase());
+  if (!docName) return null;
+  return { kind: "blank", docName, subtype: subtype || void 0 };
+}
+async function deleteInstance(vault, vaultPath) {
+  const id = await instanceId(vault.id, vaultPath);
+  for (const getCollection of Object.values(COLLECTION_FOR)) {
+    const collection = getCollection();
+    const doc = collection?.get(id);
+    if (!doc) continue;
+    if (doc.getFlag(MODULE_ID, "vaultId") !== vault.id) continue;
+    try {
+      await doc.delete();
+    } catch (err) {
+      console.warn(`Vaults | failed to delete ${doc.documentName} for ${vaultPath}:`, err);
+    }
+  }
+}
+async function deleteVaultInstances(vaultId) {
+  for (const [docName, getCollection] of Object.entries(COLLECTION_FOR)) {
+    const collection = getCollection();
+    if (!collection) continue;
+    const ours = collection.contents.filter((d) => d.getFlag(MODULE_ID, "vaultId") === vaultId);
+    for (const doc of ours) {
+      try {
+        await doc.delete();
+      } catch (err) {
+        console.warn(`Vaults | failed to delete ${docName} ${doc.id}:`, err);
+      }
+    }
+  }
+  for (const docName of BLANK_DOC_TYPES) {
+    const fId = await instanceFolderId(vaultId, docName);
+    const folder = game.folders.get(fId);
+    if (!folder || folder.type !== docName) continue;
+    if (folder.contents.length > 0 || folder.children.length > 0) continue;
+    try {
+      await folder.delete();
+    } catch (err) {
+      console.warn(`Vaults | failed to delete ${docName} folder:`, err);
+    }
+  }
+}
+async function instanceFolderId(vaultId, docName) {
+  return folderId(vaultId, `${vaultId}/__instance__/${docName}`);
+}
+async function ensureInstanceFolder(vault, docName) {
+  const fId = await instanceFolderId(vault.id, docName);
+  const existing = game.folders.get(fId);
+  const name = vault.rootFolder || vault.label || "Vault";
+  if (existing) {
+    if (existing.name !== name) {
+      try {
+        await existing.update({ name });
+      } catch (err) {
+        console.warn(`Vaults | could not rename ${docName} folder for ${vault.label}:`, err);
+      }
+    }
+    return fId;
+  }
+  try {
+    await Folder.create({ _id: fId, name, type: docName, folder: null }, { keepId: true });
+    return fId;
+  } catch (err) {
+    console.warn(`Vaults | could not create ${docName} folder for ${vault.label}:`, err);
+    return null;
+  }
+}
+async function buildOverlay(vault, vaultPath, meta, docName) {
+  const overlay = {
+    // Prefer the page's frontmatter `title:` over the filename — the wiki
+    // already treats title as the page's display name, and a doc named
+    // "Potion of Healing (Mossfoot Brew)" reads better in the Foundry
+    // sidebar than "Healing Potion".
+    name: meta.title || baseName(vaultPath),
+    folder: await ensureInstanceFolder(vault, docName),
+    flags: { [MODULE_ID]: { vaultId: vault.id, path: vaultPath } }
+  };
+  if (meta.image) {
+    const localImg = imageUrlFromMeta(vault.id, meta.image);
+    if (localImg) {
+      overlay.img = localImg;
+      if (docName === "Actor") setPath(overlay, "prototypeToken.texture.src", localImg);
+    }
+  }
+  const fm = meta?.foundry;
+  const descPath = DESCRIPTION_FIELDS[game.system.id]?.[docName];
+  const embedAuto = fm?.embed !== false;
+  if (descPath && embedAuto) {
+    const eId = await entryId(vault.id, vaultPath);
+    const pId = await pageId(vault.id, vaultPath);
+    setPath(overlay, descPath, `<p>@Embed[JournalEntry.${eId}.JournalEntryPage.${pId} inline]</p>`);
+  }
+  if (fm?.data && typeof fm.data === "object") {
+    const cloned = rewriteVaultPaths(structuredClone(fm.data), vault.id);
+    await ensureEmbeddedIds(cloned, vault.id, vaultPath);
+    deepMerge(overlay, cloned);
+  }
+  if (docName === "Scene") {
+    const note = await buildJournalNote(vault, vaultPath, meta);
+    if (note) overlay.notes = [...overlay.notes ?? [], note];
+  }
+  return overlay;
+}
+async function buildJournalNote(vault, vaultPath, meta) {
+  const fm = meta?.foundry ?? {};
+  const cfg = { ...fm.data_json ?? {}, ...fm.data ?? {} };
+  const width = Number(cfg.width) || 4e3;
+  const height = Number(cfg.height) || 3e3;
+  const padding = Number(cfg.padding ?? 0.25);
+  const gridSize = Number(cfg.grid?.size) || 100;
+  const iconSize = gridSize;
+  const eId = await entryId(vault.id, vaultPath);
+  const idOverride = meta?.foundry?.id;
+  const pId = typeof idOverride === "string" && idOverride ? idOverride : await pageId(vault.id, vaultPath);
+  return {
+    _id: await subdocId(vault.id, vaultPath, "/notes/__journalLink__"),
+    entryId: eId,
+    pageId: pId,
+    x: gridSize * (Math.ceil(width / gridSize * padding) - 0.5),
+    y: gridSize * (Math.ceil(height / gridSize * padding) + 0.5),
+    iconSize,
+    texture: {
+      src: "icons/svg/book.svg",
+      anchorX: 0.5,
+      anchorY: 0.5,
+      fit: "contain",
+      tint: "#ffffff"
+    },
+    text: ""
+  };
+}
+var VALID_SUBDOC_ID = /^[A-Za-z0-9]{16}$/;
+async function ensureEmbeddedIds(value, vaultId, pagePath, ptr = "") {
+  if (Array.isArray(value)) {
+    for (let i = 0; i < value.length; i++) {
+      const childPtr = `${ptr}/${i}`;
+      const item = value[i];
+      if (item && typeof item === "object" && !Array.isArray(item)) {
+        if (typeof item._id !== "string" || !VALID_SUBDOC_ID.test(item._id)) {
+          item._id = await subdocId(vaultId, pagePath, childPtr);
+        }
+      }
+      await ensureEmbeddedIds(item, vaultId, pagePath, childPtr);
+    }
+  } else if (value && typeof value === "object") {
+    for (const k of Object.keys(value)) {
+      await ensureEmbeddedIds(value[k], vaultId, pagePath, `${ptr}/${k}`);
+    }
+  }
+}
+function rewriteVaultPaths(value, vaultId) {
+  if (typeof value === "string") return rewriteVaultString(value, vaultId);
+  if (Array.isArray(value)) {
+    for (let i = 0; i < value.length; i++) value[i] = rewriteVaultPaths(value[i], vaultId);
+    return value;
+  }
+  if (value && typeof value === "object") {
+    for (const k of Object.keys(value)) value[k] = rewriteVaultPaths(value[k], vaultId);
+    return value;
+  }
+  return value;
+}
+function rewriteVaultString(s, vaultId) {
+  if (!s.startsWith("@vault/")) return s;
+  const vaultPath = s.slice("@vault/".length);
+  if (!vaultPath) return s;
+  return localFileUrl(vaultId, vaultPath);
+}
+async function safeFromUuid(uuid) {
+  try {
+    return await fromUuid(uuid);
+  } catch {
+    return null;
+  }
+}
+function baseName(path) {
+  return path.split("/").pop().replace(/\.md$/i, "");
+}
+function imageUrlFromMeta(vaultId, image) {
+  if (/^https?:\/\//i.test(image)) return image;
+  const vaultPath = decodeURIComponent(image.replace(/^\//, ""));
+  if (!vaultPath) return null;
+  return localFileUrl(vaultId, vaultPath);
+}
+function setPath(obj, path, value) {
+  const segs = path.split(".");
+  let cursor = obj;
+  for (let i = 0; i < segs.length - 1; i++) {
+    const seg = segs[i];
+    if (cursor[seg] == null || typeof cursor[seg] !== "object") cursor[seg] = {};
+    cursor = cursor[seg];
+  }
+  cursor[segs[segs.length - 1]] = value;
+  return obj;
+}
+function deepMerge(target, source) {
+  for (const [k, v] of Object.entries(source)) {
+    if (v && typeof v === "object" && !Array.isArray(v) && target[k] && typeof target[k] === "object" && !Array.isArray(target[k])) {
+      deepMerge(target[k], v);
+    } else {
+      target[k] = v;
+    }
+  }
+  return target;
+}
+
+// ../foundry/scripts/auth.mjs
+function tokenInfo(token) {
+  if (!token) return null;
+  const parts = token.split(".");
+  if (parts.length !== 3) return null;
+  const exp = Number(parts[1]);
+  return {
+    role: parts[0],
+    expiresAt: Number.isFinite(exp) ? new Date(exp * 1e3) : null
+  };
+}
+
+// ../foundry/scripts/sync.mjs
+async function sync(host, vault, { forceFull = false } = {}) {
+  if (!vault?.url) {
+    host.notify("error", host.localize("VAULTS.Sync.NoUrl"));
+    return { ok: false, refreshHandlerAssets: false };
+  }
+  if (vault.token) {
+    const info = tokenInfo(vault.token);
+    const stillValid = info?.expiresAt && info.expiresAt > /* @__PURE__ */ new Date();
+    if (!stillValid) {
+      await host.updateVaultEntry(vault.id, { token: "", role: "" });
+      host.notify("warn", host.localize("VAULTS.Sync.TokenExpired", { name: vault.label }));
+      return { ok: false, refreshHandlerAssets: false };
+    }
+  }
+  const start = Date.now();
+  host.notify("info", host.localize("VAULTS.Sync.StartingNamed", { name: vault.label }));
+  let manifest;
+  try {
+    manifest = await fetchManifest(vault);
+  } catch (err) {
+    host.notify("error", host.localize("VAULTS.Sync.Error", { message: err.message }));
+    return { ok: false, refreshHandlerAssets: false };
+  }
+  const OUR_MANIFEST_VERSION = 1;
+  const remoteManifestVersion = Number(manifest.manifest_version) || 0;
+  if (remoteManifestVersion > OUR_MANIFEST_VERSION) {
+    console.warn(
+      `Vaults | ${vault.label}: deploy manifest_version=${remoteManifestVersion}, our module supports up to ${OUR_MANIFEST_VERSION}. Some new fields may be ignored. cli_version: ${manifest.cli_version || "(unknown)"}`
+    );
+  }
+  const isPublic = manifest.auth?.required === false;
+  const knownRoles = Array.isArray(manifest.auth?.roles) ? manifest.auth.roles : [];
+  const patch = {};
+  if (vault.public !== isPublic) patch.public = isPublic;
+  if (!arraysEqual(vault.knownRoles, knownRoles)) patch.knownRoles = knownRoles;
+  const remoteAssets = manifest.assets?.foundry || {};
+  const newAssetPaths = {
+    foundryJs: remoteAssets.js || null,
+    foundryCss: remoteAssets.css || null
+  };
+  if (JSON.stringify(vault.handlerAssetPaths || {}) !== JSON.stringify(newAssetPaths)) {
+    patch.handlerAssetPaths = newAssetPaths;
+  }
+  if (vault.dmRole && !knownRoles.includes(vault.dmRole)) patch.dmRole = "";
+  if (Object.keys(patch).length > 0) {
+    await host.updateVaultEntry(vault.id, patch);
+    Object.assign(vault, patch);
+  }
+  const remote = new Map(manifest.files.map((f) => [f.path, f.hash]));
+  const lastSync = host.getVaultState(vault.id);
+  const local = forceFull ? /* @__PURE__ */ new Map() : new Map(Object.entries(lastSync.lastManifest || {}));
+  const bodyPaths = manifest.files.filter((f) => f.path.endsWith(".body.html")).map((f) => f.path);
+  const pathIndex = buildPathIndex(manifest.files);
+  const allMdPaths = bodyPaths.map((p) => p.replace(/\.body\.html$/i, ".md"));
+  const folderInfo = buildFolderInfo(allMdPaths);
+  const bodyMetaIndex = /* @__PURE__ */ new Map();
+  for (const f of manifest.files) {
+    if (f.meta && f.path.endsWith(".body.html")) bodyMetaIndex.set(f.path, f.meta);
+  }
+  const toUpsert = bodyPaths.filter((p) => remote.get(p) !== local.get(p));
+  const toDelete = [...local.keys()].filter((p) => p.endsWith(".body.html") && !remote.has(p));
+  if (forceFull) await host.setVaultState(vault.id, { lastImageManifest: {} });
+  let imageStats = { downloaded: 0, removed: 0, errors: 0 };
+  try {
+    imageStats = await syncImages(host, vault, manifest.files);
+  } catch (err) {
+    console.warn(`Vaults | image sync failed for ${vault.label}:`, err);
+  }
+  if (toUpsert.length === 0 && toDelete.length === 0 && imageStats.downloaded === 0 && imageStats.removed === 0) {
+    host.notify("info", host.localize("VAULTS.Sync.NothingToDo"));
+    return {
+      ok: true,
+      refreshHandlerAssets: false,
+      added: 0,
+      modified: 0,
+      removed: 0,
+      imageStats,
+      instances: 0
+    };
+  }
+  host.notify(
+    "info",
+    forceFull ? host.localize("VAULTS.Sync.Initial", { count: toUpsert.length }) : host.localize("VAULTS.Sync.Incremental", {
+      add: toUpsert.length,
+      mod: 0,
+      del: toDelete.length
+    })
+  );
+  let bodies;
+  try {
+    bodies = await fetchSourceBatch(vault, toUpsert);
+  } catch (err) {
+    console.error(`Vaults | batch fetch failed for ${vault.label}:`, err);
+    host.notify("error", host.localize("VAULTS.Sync.Error", { message: err.message }));
+    return { ok: false, refreshHandlerAssets: false };
+  }
+  let added = 0, modified = 0, instances = 0;
+  for (const bodyPath of toUpsert) {
+    const html = bodies.get(bodyPath);
+    if (html == null) {
+      console.warn(`Vaults | server returned no content for ${bodyPath}`);
+      continue;
+    }
+    const logicalPath = bodyPath.replace(/\.body\.html$/i, ".md");
+    const pageMeta = bodyMetaIndex.get(bodyPath);
+    try {
+      const result = await upsertFile(vault, logicalPath, html, pathIndex, pageMeta, folderInfo);
+      if (result === "added") added++;
+      else modified++;
+      if (pageMeta?.foundry?.base) {
+        try {
+          await applyInstance(vault, logicalPath, pageMeta);
+          instances++;
+        } catch (err) {
+          console.warn(`Vaults | foundry instantiation failed for ${logicalPath}:`, err);
+        }
+      }
+    } catch (err) {
+      console.warn(`Vaults | upsert failed for ${logicalPath}:`, err);
+    }
+  }
+  let removed = 0;
+  for (const bodyPath of toDelete) {
+    const logicalPath = bodyPath.replace(/\.body\.html$/i, ".md");
+    try {
+      await deleteFile(vault, logicalPath);
+      removed++;
+    } catch (err) {
+      console.warn(`Vaults | delete failed for ${logicalPath}:`, err);
+    }
+    try {
+      await deleteInstance(vault, logicalPath);
+    } catch (err) {
+      console.warn(`Vaults | delete instance failed for ${logicalPath}:`, err);
+    }
+  }
+  await host.setVaultState(vault.id, { lastManifest: Object.fromEntries(remote) });
+  await reconcileEntryPlacement(vault, folderInfo);
+  await reconcileOwnership(vault, bodyMetaIndex);
+  const seconds = ((Date.now() - start) / 1e3).toFixed(1);
+  host.notify("info", host.localize("VAULTS.Sync.Done", { added, modified, removed, seconds }));
+  if (imageStats.downloaded > 0 || imageStats.removed > 0) {
+    console.info(`Vaults | ${vault.label} images: ${imageStats.downloaded} downloaded, ${imageStats.removed} removed` + (imageStats.errors ? `, ${imageStats.errors} failed` : ""));
+  }
+  if (instances > 0) console.info(`Vaults | ${vault.label} instantiated ${instances} document(s) from page foundry.base.`);
+  return {
+    ok: true,
+    refreshHandlerAssets: true,
+    added,
+    modified,
+    removed,
+    imageStats,
+    instances
+  };
+}
+function arraysEqual(a, b) {
+  if (!Array.isArray(a) || !Array.isArray(b)) return false;
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+  return true;
+}
+
+// ../foundry/scripts/importer-entry.mjs
+var REQUIRED_HOST_VERSION = 1;
+async function runSync(host, vault, options = {}) {
+  return sync(host, vault, options);
+}
+async function runRemove(_host, vault) {
+  await deleteVaultJournals(vault.id);
+  await deleteVaultCache(vault.id);
+  await deleteVaultInstances(vault.id);
+}
+export {
+  REQUIRED_HOST_VERSION,
+  runRemove,
+  runSync
+};