mindoodb-app-sdk 0.0.51 → 0.0.54

package/dist/index.js

@@ -23,7 +23,7 @@ import {
   releaseMindooDBAppBridgeSessions,
   sanitizeHostShortcutBindings,
   snapshotElementToPng
-} from "./chunk-R76XXRJ6.js";
+} from "./chunk-6NTVTL6G.js";
 import {
   MINDOODB_APP_BUNDLE_ARCHIVE_FILE_NAME,
   MINDOODB_APP_BUNDLE_MANIFEST_FILE_NAME,
@@ -61,6 +61,9 @@ var MINDOODB_APP_DEFINITION_PERMISSIONS = [
   "proposeapps"
 ];
 var MINDOODB_APP_DEFINITION_REGISTRATION_PERMISSIONS = ["proposeapps"];
+var MINDOODB_APP_LISTING_SUMMARY_MAX = 300;
+var MINDOODB_APP_LISTING_DESCRIPTION_MAX = 4e3;
+var MINDOODB_APP_LISTING_MAX_SCREENSHOTS = 8;
 var LOGICAL_DATABASE_ID_PATTERN = /^[a-z0-9][a-z0-9._-]*$/i;
 function isPlainObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -200,6 +203,163 @@ function readDatabases(value, errors) {
   });
   return result.length ? result : void 0;
 }
+function readLocalizedText(value, label, maxLength, errors) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed.length > maxLength) {
+      errors.push(`${label} must not be longer than ${maxLength} characters.`);
+      return void 0;
+    }
+    return trimmed || void 0;
+  }
+  if (!isPlainObject(value)) {
+    errors.push(`${label} must be a string or an object of per-locale strings.`);
+    return void 0;
+  }
+  const result = {};
+  for (const [locale, text] of Object.entries(value)) {
+    if (typeof text !== "string") {
+      errors.push(`${label}.${locale} must be a string.`);
+      continue;
+    }
+    const trimmed = text.trim();
+    if (trimmed.length > maxLength) {
+      errors.push(`${label}.${locale} must not be longer than ${maxLength} characters.`);
+      continue;
+    }
+    if (trimmed) {
+      result[locale] = trimmed;
+    }
+  }
+  if (!Object.keys(result).length) {
+    return void 0;
+  }
+  if (!result.en) {
+    errors.push(`${label} must include an "en" entry as the fallback for other locales.`);
+    return void 0;
+  }
+  return result;
+}
+function readListingAssetPath(value, label, errors) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (typeof value !== "string" || !value.trim()) {
+    errors.push(`${label} must be a non-empty string.`);
+    return void 0;
+  }
+  const trimmed = value.trim();
+  const scheme = /^([a-z][a-z0-9+.-]*):/i.exec(trimmed)?.[1]?.toLowerCase();
+  if (scheme && scheme !== "https") {
+    errors.push(`${label} must be a path on the app origin or an https: URL.`);
+    return void 0;
+  }
+  if (trimmed.startsWith("//")) {
+    errors.push(`${label} must be a path on the app origin or an https: URL.`);
+    return void 0;
+  }
+  return trimmed;
+}
+function readListing(value, errors) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (!isPlainObject(value)) {
+    errors.push("App definition listing must be an object.");
+    return void 0;
+  }
+  const listing = {};
+  const summary = readLocalizedText(
+    value.summary,
+    "App definition listing.summary",
+    MINDOODB_APP_LISTING_SUMMARY_MAX,
+    errors
+  );
+  if (summary) listing.summary = summary;
+  const description = readLocalizedText(
+    value.description,
+    "App definition listing.description",
+    MINDOODB_APP_LISTING_DESCRIPTION_MAX,
+    errors
+  );
+  if (description) listing.description = description;
+  const descriptionMarkdown = readLocalizedText(
+    value.descriptionMarkdown,
+    "App definition listing.descriptionMarkdown",
+    MINDOODB_APP_LISTING_DESCRIPTION_MAX,
+    errors
+  );
+  if (descriptionMarkdown) listing.descriptionMarkdown = descriptionMarkdown;
+  const icon = readListingAssetPath(value.icon, "App definition listing.icon", errors);
+  if (icon) listing.icon = icon;
+  if (value.screenshots !== void 0 && value.screenshots !== null) {
+    if (!Array.isArray(value.screenshots)) {
+      errors.push("App definition listing.screenshots must be an array.");
+    } else if (value.screenshots.length > MINDOODB_APP_LISTING_MAX_SCREENSHOTS) {
+      errors.push(
+        `App definition listing.screenshots must not list more than ${MINDOODB_APP_LISTING_MAX_SCREENSHOTS} images.`
+      );
+    } else {
+      const screenshots = [];
+      value.screenshots.forEach((entry, index) => {
+        const label = `App definition listing.screenshots[${index}]`;
+        const raw = typeof entry === "string" ? { file: entry } : entry;
+        if (!isPlainObject(raw)) {
+          errors.push(`${label} must be a path or an object with a file.`);
+          return;
+        }
+        const file = readListingAssetPath(raw.file, `${label}.file`, errors);
+        if (!file) {
+          return;
+        }
+        const caption = readLocalizedText(raw.caption, `${label}.caption`, MINDOODB_APP_LISTING_SUMMARY_MAX, errors);
+        screenshots.push(caption ? { file, caption } : { file });
+      });
+      if (screenshots.length) listing.screenshots = screenshots;
+    }
+  }
+  if (value.publisher !== void 0 && value.publisher !== null) {
+    const publisher = isPlainObject(value.publisher) ? value.publisher : {};
+    const name = typeof publisher.name === "string" ? publisher.name.trim() : "";
+    if (!name) {
+      errors.push("App definition listing.publisher must be an object with a non-empty name.");
+    } else {
+      const url = readListingAssetPath(publisher.url, "App definition listing.publisher.url", errors);
+      if (url && !/^https:\/\//i.test(url)) {
+        errors.push("App definition listing.publisher.url must be an absolute https: URL.");
+      } else {
+        listing.publisher = url ? { name, url } : { name };
+      }
+    }
+  }
+  return Object.keys(listing).length ? listing : void 0;
+}
+function resolveMindooDBAppLocalizedText(text, locale) {
+  if (text === void 0) {
+    return "";
+  }
+  if (typeof text === "string") {
+    return text;
+  }
+  const normalized = locale.trim();
+  const language = normalized.split(/[-_]/)[0]?.toLowerCase() ?? "";
+  return text[normalized] ?? text[normalized.toLowerCase()] ?? (language ? text[language] : void 0) ?? text.en;
+}
+function resolveMindooDBAppListingAssetUrl(path, originUrl) {
+  try {
+    const base = new URL(originUrl.endsWith("/") ? originUrl : `${originUrl}/`);
+    const resolved = new URL(path, base);
+    if (resolved.protocol !== "https:" && resolved.protocol !== base.protocol) {
+      return null;
+    }
+    return resolved.toString();
+  } catch {
+    return null;
+  }
+}
 function validateMindooDBAppDefinition(raw) {
   const errors = [];
   if (!isPlainObject(raw)) {
@@ -251,6 +411,7 @@ function validateMindooDBAppDefinition(raw) {
   const allowGeolocation = readOptionalBoolean(raw, "allowGeolocation", errors);
   const allowWebRtc = readOptionalBoolean(raw, "allowWebRtc", errors);
   const allowWorkers = readOptionalBoolean(raw, "allowWorkers", errors);
+  const listing = readListing(raw.listing, errors);
   if (defaultLaunchDatabaseId && databases && !databases.some((database) => database.logicalDatabaseId === defaultLaunchDatabaseId)) {
     errors.push(
       `App definition defaultLaunchDatabaseId "${defaultLaunchDatabaseId}" is not one of the declared databases.`
@@ -279,7 +440,8 @@ function validateMindooDBAppDefinition(raw) {
       permissions,
       launchParameters,
       defaultLaunchDatabaseId,
-      databases
+      databases,
+      listing
     },
     errors: []
   };
@@ -389,6 +551,22 @@ function expandAbbreviatedName(value) {
 
 // src/client/hosting.ts
 var MINDOODB_APP_HOSTING_QUERY_PARAM = "mindoodbAppHosting";
+var MINDOODB_APP_LAUNCH_ID_QUERY_PARAM = "mindoodbAppLaunchId";
+function readMindooDBAppLaunchId(search) {
+  const raw = search ?? (typeof window === "undefined" ? "" : window.location.search);
+  if (!raw) {
+    return null;
+  }
+  try {
+    const launchId = new URLSearchParams(raw).get(MINDOODB_APP_LAUNCH_ID_QUERY_PARAM)?.trim();
+    return launchId || null;
+  } catch {
+    return null;
+  }
+}
+function isLaunchedByHaven(search) {
+  return readMindooDBAppLaunchId(search) !== null;
+}
 function readMindooDBAppHostingMode(search) {
   const raw = search ?? (typeof window === "undefined" ? "" : window.location.search);
   if (!raw) {
@@ -404,6 +582,451 @@ function isHostedBundleRuntime(search) {
   return readMindooDBAppHostingMode(search) === "hosted";
 }
 
+// src/listingMarkdown.ts
+var MAX_INLINE_DEPTH = 4;
+var HEADING = /^#{1,6}\s+(.*?)\s*#*\s*$/;
+var BULLET = /^[-*+]\s+(.*)$/;
+var ORDERED = /^\d{1,9}[.)]\s+(.*)$/;
+var ESCAPABLE = new Set("\\`*_[]()#+-.!<>".split(""));
+var BARE_URL_TRAILING_PUNCTUATION = /[.,;:!?)\]'"]+$/;
+function sanitizeListingHref(raw) {
+  const cleaned = raw.replace(/[\t\n\r]/g, "").trim();
+  if (!cleaned) {
+    return null;
+  }
+  try {
+    const url = new URL(cleaned);
+    if (url.protocol === "https:") {
+      return url.toString();
+    }
+    if (url.protocol === "mailto:" && url.pathname) {
+      return url.toString();
+    }
+  } catch {
+  }
+  return null;
+}
+function isWordCharacter(char) {
+  return char !== void 0 && /[\p{L}\p{N}]/u.test(char);
+}
+function pushText(nodes, text) {
+  if (!text) {
+    return;
+  }
+  const last = nodes[nodes.length - 1];
+  if (last?.type === "text") {
+    last.text += text;
+  } else {
+    nodes.push({ type: "text", text });
+  }
+}
+function findClosingDelimiter(text, from, delimiter) {
+  let index = text.indexOf(delimiter, from);
+  while (index !== -1) {
+    const before = text[index - 1];
+    const after = text[index + delimiter.length];
+    const closesAfterContent = index > from && before !== " " && before !== "\\";
+    const underscoreBoundary = delimiter[0] !== "_" || !isWordCharacter(after);
+    if (closesAfterContent && underscoreBoundary) {
+      return index;
+    }
+    index = text.indexOf(delimiter, index + 1);
+  }
+  return -1;
+}
+function findLinkTargetEnd(text, from) {
+  let open = 0;
+  for (let index = from; index < text.length; index += 1) {
+    const char = text[index];
+    if (char === "(") {
+      open += 1;
+    } else if (char === ")") {
+      if (open === 0) return index;
+      open -= 1;
+    } else if (char === " ") {
+      return -1;
+    }
+  }
+  return -1;
+}
+function parseInline(text, depth = 0) {
+  const nodes = [];
+  let index = 0;
+  while (index < text.length) {
+    const char = text[index];
+    if (char === "\\" && ESCAPABLE.has(text[index + 1] ?? "")) {
+      pushText(nodes, text[index + 1]);
+      index += 2;
+      continue;
+    }
+    if (char === "`") {
+      const end = text.indexOf("`", index + 1);
+      if (end > index + 1) {
+        nodes.push({ type: "code", text: text.slice(index + 1, end) });
+        index = end + 1;
+        continue;
+      }
+    }
+    if (depth < MAX_INLINE_DEPTH && (char === "*" || char === "_")) {
+      const strong = text[index + 1] === char;
+      const delimiter = strong ? char + char : char;
+      const next = text[index + delimiter.length];
+      const opens = next !== void 0 && next !== " " && (char !== "_" || !isWordCharacter(text[index - 1]));
+      if (opens) {
+        const end = findClosingDelimiter(text, index + delimiter.length, delimiter);
+        if (end !== -1) {
+          const children = parseInline(text.slice(index + delimiter.length, end), depth + 1);
+          nodes.push(strong ? { type: "strong", children } : { type: "em", children });
+          index = end + delimiter.length;
+          continue;
+        }
+      }
+    }
+    if (char === "[" && depth < MAX_INLINE_DEPTH) {
+      const labelEnd = text.indexOf("](", index + 1);
+      const urlEnd = labelEnd === -1 ? -1 : findLinkTargetEnd(text, labelEnd + 2);
+      if (labelEnd > index + 1 && urlEnd !== -1) {
+        const label = parseInline(text.slice(index + 1, labelEnd), depth + 1);
+        const href = sanitizeListingHref(text.slice(labelEnd + 2, urlEnd));
+        if (href) {
+          nodes.push({ type: "link", href, children: label });
+        } else {
+          nodes.push(...label);
+        }
+        index = urlEnd + 1;
+        continue;
+      }
+    }
+    if (char === "h" && text.startsWith("https://", index) && !isWordCharacter(text[index - 1])) {
+      let end = index;
+      while (end < text.length && !/\s/.test(text[end])) end += 1;
+      const candidate = text.slice(index, end).replace(BARE_URL_TRAILING_PUNCTUATION, "");
+      const href = sanitizeListingHref(candidate);
+      if (href) {
+        nodes.push({ type: "link", href, children: [{ type: "text", text: candidate }] });
+        index += candidate.length;
+        continue;
+      }
+    }
+    pushText(nodes, char);
+    index += 1;
+  }
+  return nodes;
+}
+function parseListingMarkdown(markdown) {
+  const blocks = [];
+  let paragraph = [];
+  let list = null;
+  const flushParagraph = () => {
+    if (paragraph.length) {
+      blocks.push({ type: "paragraph", children: parseInline(paragraph.join(" ")) });
+      paragraph = [];
+    }
+  };
+  const flushList = () => {
+    if (list) {
+      blocks.push({ type: "list", ordered: list.ordered, items: list.items.map((item) => parseInline(item)) });
+      list = null;
+    }
+  };
+  for (const rawLine of markdown.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line) {
+      flushParagraph();
+      flushList();
+      continue;
+    }
+    const heading = HEADING.exec(line);
+    const bullet = BULLET.exec(line);
+    const ordered = bullet ? null : ORDERED.exec(line);
+    if (heading) {
+      flushParagraph();
+      flushList();
+      blocks.push({ type: "heading", children: parseInline(heading[1]) });
+    } else if (bullet || ordered) {
+      flushParagraph();
+      const isOrdered = Boolean(ordered);
+      if (list && list.ordered !== isOrdered) {
+        flushList();
+      }
+      list ??= { ordered: isOrdered, items: [] };
+      list.items.push((bullet ?? ordered)[1]);
+    } else if (list) {
+      list.items[list.items.length - 1] += ` ${line}`;
+    } else {
+      paragraph.push(line);
+    }
+  }
+  flushParagraph();
+  flushList();
+  return blocks;
+}
+function inlineToPlainText(nodes) {
+  return nodes.map((node) => {
+    if (node.type === "text" || node.type === "code") {
+      return node.text;
+    }
+    const label = inlineToPlainText(node.children);
+    if (node.type !== "link") {
+      return label;
+    }
+    const target = node.href.replace(/^mailto:/, "").replace(/^https:\/\//, "").replace(/\/$/, "");
+    return label.includes(target) ? label : `${label} (${node.href.replace(/^mailto:/, "")})`;
+  }).join("");
+}
+function listingMarkdownToPlainText(markdown) {
+  const paragraphs = [];
+  for (const block of parseListingMarkdown(markdown)) {
+    if (block.type === "list") {
+      block.items.forEach((item, index) => {
+        paragraphs.push(`${block.ordered ? `${index + 1}.` : "\u2022"} ${inlineToPlainText(item)}`);
+      });
+    } else {
+      paragraphs.push(inlineToPlainText(block.children));
+    }
+  }
+  return paragraphs.filter((paragraph) => paragraph.trim()).join("\n\n");
+}
+
+// src/landing.ts
+var DEFAULT_HAVEN_URL = "https://haven.mindoodb.com";
+var APP_ICON_FALLBACKS = ["appicon.png", "appicon.webp", "appicon.svg"];
+var STRINGS = {
+  en: {
+    eyebrow: "App for MindooDB Haven",
+    cta: "Open in MindooDB Haven",
+    ctaHint: "Haven sets up your encrypted workspace and installs {label}. Already using Haven? Then the app is simply added.",
+    from: "from {origin}",
+    by: "by {publisher}",
+    screenshots: "Screenshots",
+    footer: "{label} runs inside MindooDB Haven, which keeps its data end-to-end encrypted and local-first. Opening this address on its own shows only this page.",
+    learnMore: "What is MindooDB?",
+    fallbackSummary: "This app runs inside MindooDB Haven."
+  },
+  de: {
+    eyebrow: "App f\xFCr MindooDB Haven",
+    cta: "In MindooDB Haven \xF6ffnen",
+    ctaHint: "Haven richtet deine verschl\xFCsselte Umgebung ein und installiert {label}. Du nutzt Haven schon? Dann wird die App einfach hinzugef\xFCgt.",
+    from: "von {origin}",
+    by: "von {publisher}",
+    screenshots: "Screenshots",
+    footer: "{label} l\xE4uft in MindooDB Haven, das ihre Daten Ende-zu-Ende-verschl\xFCsselt und lokal h\xE4lt. Direkt aufgerufen zeigt diese Adresse nur diese Seite.",
+    learnMore: "Was ist MindooDB?",
+    fallbackSummary: "Diese App l\xE4uft in MindooDB Haven."
+  }
+};
+function stringsFor(locale) {
+  return locale.toLowerCase().startsWith("de") ? STRINGS.de : STRINGS.en;
+}
+function format(template, values) {
+  return template.replace(/\{(\w+)\}/g, (match, key) => values[key] ?? match);
+}
+function resolveCurrentHavenAppUrl(href = window.location.href) {
+  const url = new URL(href);
+  url.search = "";
+  url.hash = "";
+  url.pathname = url.pathname.replace(/\/index\.html?$/i, "/");
+  return url.toString();
+}
+function buildHavenAppInstallUrl(appUrl, havenUrl = DEFAULT_HAVEN_URL) {
+  const url = new URL(havenUrl);
+  url.searchParams.set("app", appUrl);
+  return url.toString();
+}
+async function loadDefinition(appUrl) {
+  try {
+    const definitionUrl = new URL(MINDOODB_APP_DEFINITION_FILE_NAME, appUrl.endsWith("/") ? appUrl : `${appUrl}/`);
+    const response = await fetch(definitionUrl, { headers: { Accept: "application/json" } });
+    if (!response.ok) {
+      return null;
+    }
+    return validateMindooDBAppDefinition(await response.json()).definition;
+  } catch {
+    return null;
+  }
+}
+function el(tag, className, text) {
+  const node = document.createElement(tag);
+  if (className) node.className = className;
+  if (text !== void 0) node.textContent = text;
+  return node;
+}
+function externalLink(href) {
+  const link = el("a");
+  link.href = href;
+  link.rel = "noopener noreferrer";
+  link.target = "_blank";
+  return link;
+}
+function appendInline(parent, nodes) {
+  for (const node of nodes) {
+    if (node.type === "text") {
+      parent.append(node.text);
+    } else if (node.type === "code") {
+      parent.append(el("code", void 0, node.text));
+    } else {
+      const child = node.type === "link" ? externalLink(node.href) : el(node.type);
+      appendInline(child, node.children);
+      parent.append(child);
+    }
+  }
+}
+function renderMarkdownDescription(block, markdown) {
+  for (const entry of parseListingMarkdown(markdown)) {
+    if (entry.type === "list") {
+      const list = el(entry.ordered ? "ol" : "ul");
+      for (const item of entry.items) {
+        const li = el("li");
+        appendInline(li, item);
+        list.append(li);
+      }
+      block.append(list);
+    } else {
+      const node = el(entry.type === "heading" ? "h2" : "p");
+      appendInline(node, entry.children);
+      block.append(node);
+    }
+  }
+}
+var STYLE_ID = "mdb-landing-style";
+var STYLE = `
+.mdb-landing{--bg:#f4f6fb;--card:#fff;--text:#172033;--muted:#5b6478;--line:#e2e6ef;--accent:#1f3a8a;--accent-text:#fff;
+  min-height:100vh;box-sizing:border-box;margin:0;padding:48px 16px;background:var(--bg);color:var(--text);
+  font:16px/1.55 system-ui,-apple-system,"Segoe UI",Roboto,sans-serif}
+@media (prefers-color-scheme:dark){.mdb-landing{--bg:#0e1320;--card:#161d2e;--text:#e8ecf5;--muted:#9aa3b8;--line:#263049;--accent:#8fb0ff;--accent-text:#0e1320}}
+.mdb-landing *{box-sizing:border-box}
+.mdb-landing__card{max-width:880px;margin:0 auto;background:var(--card);border:1px solid var(--line);border-radius:24px;padding:40px;box-shadow:0 20px 60px rgba(15,23,42,.08)}
+.mdb-landing__head{display:flex;gap:24px;align-items:center}
+.mdb-landing__icon{width:96px;height:96px;border-radius:22px;object-fit:cover;flex:none;box-shadow:0 10px 30px rgba(15,23,42,.18)}
+.mdb-landing__eyebrow{margin:0 0 4px;font-size:12px;letter-spacing:.12em;text-transform:uppercase;color:var(--muted)}
+.mdb-landing__title{margin:0;font-size:clamp(26px,4vw,36px);line-height:1.15}
+.mdb-landing__meta{margin:6px 0 0;color:var(--muted);font-size:14px}
+.mdb-landing__summary{margin:28px 0 0;font-size:19px}
+.mdb-landing__cta{display:flex;flex-wrap:wrap;gap:16px;align-items:center;margin:28px 0 0}
+.mdb-landing__button{display:inline-block;padding:14px 22px;border-radius:12px;background:var(--accent);color:var(--accent-text);font-weight:600;text-decoration:none}
+.mdb-landing__button:focus-visible{outline:3px solid var(--accent);outline-offset:3px}
+.mdb-landing__hint{margin:0;max-width:420px;color:var(--muted);font-size:14px}
+.mdb-landing__description{margin:32px 0 0}
+.mdb-landing__description p,.mdb-landing__description ul,.mdb-landing__description ol{margin:0 0 12px}
+.mdb-landing__description ul,.mdb-landing__description ol{padding-left:22px}
+.mdb-landing__description li+li{margin-top:4px}
+.mdb-landing__description h2{margin:20px 0 8px;font-size:17px}
+.mdb-landing__description code{font:.92em ui-monospace,SFMono-Regular,Menlo,monospace;padding:1px 5px;border-radius:5px;background:var(--line)}
+.mdb-landing__description a,.mdb-landing__meta a{color:var(--accent)}
+.mdb-landing__shots-title{margin:32px 0 12px;font-size:15px;color:var(--muted);font-weight:600}
+.mdb-landing__shots{display:grid;grid-auto-flow:column;grid-auto-columns:min(78%,420px);gap:16px;overflow-x:auto;padding-bottom:8px;scroll-snap-type:x mandatory}
+.mdb-landing__shot{margin:0;scroll-snap-align:start}
+.mdb-landing__shot img{width:100%;border-radius:14px;border:1px solid var(--line);display:block}
+.mdb-landing__shot figcaption{margin-top:8px;font-size:13px;color:var(--muted)}
+.mdb-landing__footer{margin:36px 0 0;padding-top:20px;border-top:1px solid var(--line);color:var(--muted);font-size:13px}
+.mdb-landing__footer a{color:inherit}
+@media (max-width:560px){.mdb-landing{padding:16px}.mdb-landing__card{padding:24px;border-radius:18px}.mdb-landing__head{flex-direction:column;align-items:flex-start}.mdb-landing__icon{width:72px;height:72px}}
+`;
+async function renderHavenAppLandingPage(options = {}) {
+  const appUrl = options.appUrl ?? resolveCurrentHavenAppUrl();
+  const locale = options.locale ?? (typeof navigator === "undefined" ? "en" : navigator.language || "en");
+  const strings = stringsFor(locale);
+  const definition = options.definition ?? await loadDefinition(appUrl);
+  const installUrl = buildHavenAppInstallUrl(appUrl, options.havenUrl);
+  const listing = definition?.listing;
+  const label = definition?.label ?? (document.title || new URL(appUrl).host);
+  const origin = new URL(appUrl).host;
+  if (!document.getElementById(STYLE_ID)) {
+    const style = el("style");
+    style.id = STYLE_ID;
+    style.textContent = STYLE;
+    document.head.append(style);
+  }
+  document.title = label;
+  const root = el("main", "mdb-landing");
+  root.dataset.testid = "haven-app-landing";
+  const card = el("article", "mdb-landing__card");
+  root.append(card);
+  const head = el("header", "mdb-landing__head");
+  const iconCandidates = (listing?.icon ? [listing.icon] : [...APP_ICON_FALLBACKS]).map((path) => resolveMindooDBAppListingAssetUrl(path, appUrl)).filter((url) => Boolean(url));
+  if (iconCandidates.length) {
+    const icon = el("img", "mdb-landing__icon");
+    let next = 0;
+    icon.alt = "";
+    icon.addEventListener("error", () => {
+      next += 1;
+      if (next < iconCandidates.length) {
+        icon.src = iconCandidates[next];
+      } else {
+        icon.remove();
+      }
+    });
+    icon.src = iconCandidates[0];
+    head.append(icon);
+  }
+  const titles = el("div");
+  titles.append(el("p", "mdb-landing__eyebrow", strings.eyebrow), el("h1", "mdb-landing__title", label));
+  const meta = el("p", "mdb-landing__meta");
+  if (listing?.publisher) {
+    const [before, after = ""] = strings.by.split("{publisher}");
+    const name = listing.publisher.url ? Object.assign(externalLink(listing.publisher.url), { textContent: listing.publisher.name }) : listing.publisher.name;
+    meta.append(before ?? "", name, after, " \xB7 ");
+  }
+  meta.append(format(strings.from, { origin }));
+  titles.append(meta);
+  head.append(titles);
+  card.append(head);
+  const summary = resolveMindooDBAppLocalizedText(listing?.summary, locale) || definition?.description || strings.fallbackSummary;
+  card.append(el("p", "mdb-landing__summary", summary));
+  const cta = el("div", "mdb-landing__cta");
+  const button = el("a", "mdb-landing__button", strings.cta);
+  button.href = installUrl;
+  button.rel = "noopener";
+  button.dataset.testid = "haven-app-landing-install";
+  cta.append(button, el("p", "mdb-landing__hint", format(strings.ctaHint, { label })));
+  card.append(cta);
+  const descriptionMarkdown = resolveMindooDBAppLocalizedText(listing?.descriptionMarkdown, locale);
+  const description = resolveMindooDBAppLocalizedText(listing?.description, locale);
+  if (descriptionMarkdown || description) {
+    const block = el("section", "mdb-landing__description");
+    if (descriptionMarkdown) {
+      renderMarkdownDescription(block, descriptionMarkdown);
+    } else {
+      for (const paragraph of description.split(/\n\s*\n/)) {
+        if (paragraph.trim()) block.append(el("p", void 0, paragraph.trim()));
+      }
+    }
+    card.append(block);
+  }
+  const screenshots = (listing?.screenshots ?? []).map((shot) => ({
+    url: resolveMindooDBAppListingAssetUrl(shot.file, appUrl),
+    caption: resolveMindooDBAppLocalizedText(shot.caption, locale)
+  })).filter((shot) => Boolean(shot.url));
+  if (screenshots.length) {
+    card.append(el("h2", "mdb-landing__shots-title", strings.screenshots));
+    const strip = el("div", "mdb-landing__shots");
+    for (const shot of screenshots) {
+      const figure = el("figure", "mdb-landing__shot");
+      const image = el("img");
+      image.src = shot.url;
+      image.alt = shot.caption;
+      image.loading = "lazy";
+      figure.append(image);
+      if (shot.caption) figure.append(el("figcaption", void 0, shot.caption));
+      strip.append(figure);
+    }
+    card.append(strip);
+  }
+  const footer = el("footer", "mdb-landing__footer");
+  footer.append(format(strings.footer, { label }), " ");
+  const learnMore = el("a", void 0, strings.learnMore);
+  learnMore.href = "https://mindoodb.com";
+  learnMore.rel = "noopener";
+  footer.append(learnMore);
+  card.append(footer);
+  const container = options.container ?? document.body;
+  container.replaceChildren(root);
+  if (container === document.body) {
+    document.body.style.margin = "0";
+  }
+  return { definition, installUrl };
+}
+
 // src/client/havenStorageShim.ts
 var DEFAULT_QUOTA_BYTES = 256 * 1024;
 var DEFAULT_MAX_VALUE_BYTES = 64 * 1024;
@@ -731,11 +1354,11 @@ var MindooDBRichTextHandle = class {
       this.pollTimer = null;
     }
   }
-  reconcile(document, snapshot) {
+  reconcile(document2, snapshot) {
     const previous = JSON.stringify(this.spansInternal);
     this.spansInternal = cloneSpans(snapshot.spans);
     this.baseMaterializedText = spansToPlainText(snapshot.spans);
-    this.heads = snapshot.heads ?? document.heads ?? [];
+    this.heads = snapshot.heads ?? document2.heads ?? [];
     this.dirtyInternal = false;
     const changed = JSON.stringify(this.spansInternal) !== previous;
     if (changed) {
@@ -754,14 +1377,14 @@ var MindooDBRichTextHandle = class {
     if (this.dirtyInternal) {
       return false;
     }
-    const document = await this.options.database.documents.get(
+    const document2 = await this.options.database.documents.get(
       this.options.document.id
     );
-    if (!document) {
+    if (!document2) {
       return false;
     }
     const snapshot = await this.refresh();
-    return this.reconcile(document, snapshot);
+    return this.reconcile(document2, snapshot);
   }
   async flush(updateSpansConfig) {
     if (!this.dirtyInternal) {
@@ -778,7 +1401,7 @@ var MindooDBRichTextHandle = class {
     const localSpansAtFlush = cloneSpans(this.spansInternal);
     const localTextAtFlush = spansToPlainText(localSpansAtFlush);
     const textChanged = localTextAtFlush !== this.baseMaterializedText;
-    const document = textChanged ? await this.flushTextSteps(localTextAtFlush) : await this.options.database.documents.update(
+    const document2 = textChanged ? await this.flushTextSteps(localTextAtFlush) : await this.options.database.documents.update(
       this.options.document.id,
       {
         richText: [{
@@ -796,13 +1419,13 @@ var MindooDBRichTextHandle = class {
     const reconciled = JSON.stringify(snapshot.spans) !== JSON.stringify(localSpansAtFlush);
     this.spansInternal = cloneSpans(snapshot.spans);
     this.baseMaterializedText = spansToPlainText(snapshot.spans);
-    this.heads = snapshot.heads ?? document.heads ?? [];
+    this.heads = snapshot.heads ?? document2.heads ?? [];
     this.dirtyInternal = false;
     if (reconciled) {
       this.emitChange();
     }
     return {
-      document,
+      document: document2,
       snapshot,
       reconciled
     };
@@ -940,11 +1563,11 @@ var MindooDBTextBuffer = class {
    * Returns whether the text value changed. Use this after an external refresh
    * or after receiving a document update through another app-level mechanism.
    */
-  reconcile(document) {
-    const nextValue = readTextAtPath(document.data, this.options.path);
+  reconcile(document2) {
+    const nextValue = readTextAtPath(document2.data, this.options.path);
     const changed = nextValue !== this.valueInternal;
     this.valueInternal = nextValue;
-    this.heads = document.heads ? [...document.heads] : [];
+    this.heads = document2.heads ? [...document2.heads] : [];
     this.pendingEdits = [];
     return changed;
   }
@@ -966,20 +1589,20 @@ var MindooDBTextBuffer = class {
       };
     }
     const localValueAtFlush = this.valueInternal;
-    const document = await this.options.database.documents.update(this.options.document.id, {
+    const document2 = await this.options.database.documents.update(this.options.document.id, {
       text: [{
         path: this.options.path,
         baseHeads: this.heads,
         edits: this.pendingEdits.map((edit) => ({ ...edit }))
       }]
     });
-    const nextValue = readTextAtPath(document.data, this.options.path);
+    const nextValue = readTextAtPath(document2.data, this.options.path);
     const reconciled = nextValue !== localValueAtFlush;
     this.valueInternal = nextValue;
-    this.heads = document.heads ? [...document.heads] : [];
+    this.heads = document2.heads ? [...document2.heads] : [];
     this.pendingEdits = [];
     return {
-      document,
+      document: document2,
       value: this.valueInternal,
       reconciled
     };
@@ -1055,6 +1678,7 @@ export {
   DEFAULT_DRAG_LONG_PRESS_MS,
   DEFAULT_DRAG_POINTER_THRESHOLD_PX,
   DEFAULT_HAVEN_HOST_SHORTCUTS,
+  DEFAULT_HAVEN_URL,
   MINDOODB_APP_BUNDLE_ARCHIVE_FILE_NAME,
   MINDOODB_APP_BUNDLE_MANIFEST_FILE_NAME,
   MINDOODB_APP_BUNDLE_MANIFEST_FORMAT,
@@ -1065,6 +1689,10 @@ export {
   MINDOODB_APP_DEFINITION_REGISTRATION_PERMISSIONS,
   MINDOODB_APP_DEFINITION_VERSION,
   MINDOODB_APP_HOSTING_QUERY_PARAM,
+  MINDOODB_APP_LAUNCH_ID_QUERY_PARAM,
+  MINDOODB_APP_LISTING_DESCRIPTION_MAX,
+  MINDOODB_APP_LISTING_MAX_SCREENSHOTS,
+  MINDOODB_APP_LISTING_SUMMARY_MAX,
   MINDOODB_APP_MAX_DRAG_PAYLOAD_BYTES,
   MINDOODB_APP_MAX_DRAG_PREVIEW_BYTES,
   MINDOODB_APP_MAX_DRAG_PREVIEW_EDGE,
@@ -1080,6 +1708,7 @@ export {
   abbreviateCanonicalName,
   applyHostedDocumentOverscrollContain,
   bindDragSource,
+  buildHavenAppInstallUrl,
   buildMindooDBAppBundleContentHashInput,
   canPreviewAttachment,
   createMindooDBAppBridge,
@@ -1092,18 +1721,27 @@ export {
   installHostShortcutCapture,
   isHostShortcutAction,
   isHostedBundleRuntime,
+  isLaunchedByHaven,
   isMindooDBAppBundleHash,
   isMindooDBAppDragType,
+  listingMarkdownToPlainText,
   matchHostShortcut,
   normalizeDragAccepts,
   normalizeDragPointerInput,
   normalizeDragStartInput,
   normalizeMindooDBAppBundlePath,
+  parseListingMarkdown,
   queryDocuments,
   readMindooDBAppHostingMode,
+  readMindooDBAppLaunchId,
   releaseMindooDBAppBridgeSessions,
+  renderHavenAppLandingPage,
+  resolveCurrentHavenAppUrl,
   resolveMindooDBAppDefinitionUrl,
+  resolveMindooDBAppListingAssetUrl,
+  resolveMindooDBAppLocalizedText,
   sanitizeHostShortcutBindings,
+  sanitizeListingHref,
   snapshotElementToPng,
   validateMindooDBAppBundleManifest,
   validateMindooDBAppDefinition,