superbee 0.4.4-pre.1 → 0.4.4-pre.10

package/dist/publication.mjs

@@ -30978,6 +30978,13 @@ function assertSafeConceptId(id) {
 }
 var FORMAT_AT_EDGE = new RegExp("^\\p{Cf}|\\p{Cf}$", "u");
 var FORMAT_INSIDE = new RegExp("(?![\\u200c\\u200d])\\p{Cf}", "u");
+function nonCanonicalDocumentId(id) {
+  const segments = id.split("/");
+  if (segments.some((segment) => segment !== segment.trim())) return "segment_whitespace";
+  if (segments.some((segment) => FORMAT_AT_EDGE.test(segment) || FORMAT_INSIDE.test(segment))) return "format_character";
+  if (id !== id.normalize("NFC")) return "not_nfc";
+  return null;
+}
 function assertSafeBlobKey(key) {
   if (typeof key !== "string" || key.trim() === "") {
     throw new InvalidInputError("Blob key must be a non-empty string.");
@@ -31351,6 +31358,11 @@ function stringifyDoc(frontmatter2, body) {
   return stringifyWithData(frontmatter2, body);
 }
 
+// ../core/src/code-unit-order.ts
+function compareCodeUnits(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+
 // ../core/src/links.ts
 function normalizeSegments(segments) {
   const out = [];
@@ -31372,6 +31384,13 @@ function isExternalHref(href) {
   return /^[a-z][a-z0-9+.-]*:\/\//i.test(h) || h.startsWith("mailto:") || h.startsWith("#");
 }
 function extractMarkdownLinks(source, options = {}) {
+  const out = [];
+  for (const span of extractMarkdownLinkSpans(source, options)) {
+    if (!span.image) out.push({ text: span.text, href: span.href });
+  }
+  return out;
+}
+function extractMarkdownLinkSpans(source, options = {}) {
   const body = options.skipCode ? maskMarkdownCode(source) : source;
   const out = [];
   let textOpen = -1;
@@ -31382,12 +31401,16 @@ function extractMarkdownLinks(source, options = {}) {
     const char = body[cursor];
     if (hrefRest) {
       if (char === ")") {
-        if (hrefRest.open === 0 || body[hrefRest.open - 1] !== "!") {
-          out.push({
-            text: source.slice(hrefRest.open + 1, hrefRest.close),
-            href: source.slice(hrefRest.hrefStart, cursor)
-          });
-        }
+        const image = hrefRest.open > 0 && body[hrefRest.open - 1] === "!";
+        out.push({
+          text: source.slice(hrefRest.open + 1, hrefRest.close),
+          href: source.slice(hrefRest.hrefStart, cursor),
+          start: image ? hrefRest.open - 1 : hrefRest.open,
+          end: cursor + 1,
+          hrefStart: hrefRest.hrefStart,
+          hrefEnd: cursor,
+          image
+        });
         textOpen = -1;
         afterClose = void 0;
         hrefFirst = void 0;
@@ -31767,12 +31790,13 @@ async function readDocVersioned(backend, id) {
 function isEnoent(err) {
   return typeof err === "object" && err !== null && err.code === "ENOENT";
 }
-async function readManyExisting(backend, ids, onMalformed) {
+async function readManyExisting(backend, ids, onMalformed, onAliased) {
   try {
     return await backend.readMany(ids);
   } catch (err) {
-    const malformed = err instanceof MalformedDocumentError;
-    if (!isEnoent(err) && !(malformed && onMalformed)) throw err;
+    const malformed = err instanceof MalformedDocumentError && onMalformed !== void 0;
+    const aliased = err instanceof FilesystemIdentityAliasError && onAliased !== void 0;
+    if (!isEnoent(err) && !malformed && !aliased) throw err;
     const out = [];
     for (const id of ids) {
       try {
@@ -31783,6 +31807,10 @@ async function readManyExisting(backend, ids, onMalformed) {
           onMalformed({ id, reason: candidate.detail });
           continue;
         }
+        if (candidate instanceof FilesystemIdentityAliasError && onAliased) {
+          onAliased({ id, reason: candidate.message });
+          continue;
+        }
         throw candidate;
       }
     }
@@ -31795,7 +31823,7 @@ async function scanMatching(backend, filter, onSkip) {
   for (const result of await readManyExisting(backend, ids, onSkip)) {
     if (matchesFilter(result.doc, filter)) results.push(result);
   }
-  results.sort((a, b) => a.doc.id.localeCompare(b.doc.id));
+  results.sort((a, b) => compareCodeUnits(a.doc.id, b.doc.id));
   return results;
 }
 async function query(backend, filter = {}, options = {}) {
@@ -31804,7 +31832,7 @@ async function query(backend, filter = {}, options = {}) {
 async function queryHeads(backend, filter = {}, options = {}) {
   if (backend.queryHeads) {
     const rows = (await backend.queryHeads(filter, options.onSkip ? { onSkip: options.onSkip } : void 0)).filter((row) => matchesFilter(row, filter));
-    rows.sort((a, b) => a.id.localeCompare(b.id));
+    rows.sort((a, b) => compareCodeUnits(a.id, b.id));
     return rows;
   }
   return (await scanMatching(backend, filter, options.onSkip)).map(({ doc, version: version2 }) => ({
@@ -31844,7 +31872,7 @@ async function queryEdges(backend, filter = {}, options = {}) {
       edges.push(link);
     }
   }
-  edges.sort((a, b) => a.from.localeCompare(b.from) || a.to.localeCompare(b.to) || a.text.localeCompare(b.text));
+  edges.sort((a, b) => compareCodeUnits(a.from, b.from) || compareCodeUnits(a.to, b.to) || compareCodeUnits(a.text, b.text));
   return edges;
 }
 
@@ -32053,14 +32081,14 @@ async function readOwnerRecord(lockPath) {
 }
 async function resolveOwnerRecord(lockPath, started, waitMs, pollMs) {
   while (true) {
-    const record2 = await readOwnerRecord(lockPath);
-    if (record2.state !== "unreadable" || Date.now() - started >= waitMs) return record2;
+    const record3 = await readOwnerRecord(lockPath);
+    if (record3.state !== "unreadable" || Date.now() - started >= waitMs) return record3;
     await delay(pollMs);
   }
 }
 async function readOwner(lockPath) {
-  const record2 = await readOwnerRecord(lockPath);
-  return record2.state === "record" ? record2.owner : null;
+  const record3 = await readOwnerRecord(lockPath);
+  return record3.state === "record" ? record3.owner : null;
 }
 function processExists(pid) {
   try {
@@ -32255,12 +32283,12 @@ async function claimLockPath(lockPath, owner, waitMs, pollMs, policy) {
 }
 async function rollBackOwnClaim(lockPath, owner, claimed, waitMs, pollMs, policy) {
   const started = Date.now();
-  const record2 = await resolveOwnerRecord(lockPath, started, waitMs, pollMs);
-  if (record2.state === "record") {
-    if (record2.owner.token === owner.token) await removeReleasedLock(lockPath, owner, started, waitMs, pollMs, policy);
+  const record3 = await resolveOwnerRecord(lockPath, started, waitMs, pollMs);
+  if (record3.state === "record") {
+    if (record3.owner.token === owner.token) await removeReleasedLock(lockPath, owner, started, waitMs, pollMs, policy);
     return;
   }
-  if (record2.state === "unreadable" || !await isClaimedDirectory(lockPath, claimed)) return;
+  if (record3.state === "unreadable" || !await isClaimedDirectory(lockPath, claimed)) return;
   const remnant = releasedLockRemnantPath(lockPath, owner);
   await fs.rename(lockPath, remnant);
   await fs.rm(remnant, { recursive: true, force: true });
@@ -32360,6 +32388,11 @@ async function acquireFilesystemIdentityLock(key, identity, options = {}) {
   return claimLockPath(path.join(lockRoot, `${key}.lock`), owner, waitMs, pollMs, policy);
 }
 
+// ../core/src/identity-fold.ts
+function foldSegment(segment) {
+  return segment.normalize("NFKD").toLowerCase().toUpperCase().toLowerCase();
+}
+
 // ../core/src/filesystem-identity.ts
 async function replaceExistingLeaf(port, tmp, target, rel) {
   try {
@@ -32405,9 +32438,6 @@ function relSegments(rel) {
   }
   return segments;
 }
-function foldSegment(segment) {
-  return segment.normalize("NFKD").toLowerCase().toUpperCase().toLowerCase();
-}
 async function existingAnchor(resolved) {
   const tail = [];
   let candidate = resolved;
@@ -33639,11 +33669,11 @@ function isPlainObject(value) {
   const prototype = Object.getPrototypeOf(value);
   return prototype === Object.prototype || prototype === null;
 }
-function hasOwn(record2, key) {
-  return Object.prototype.hasOwnProperty.call(record2, key);
+function hasOwn(record3, key) {
+  return Object.prototype.hasOwnProperty.call(record3, key);
 }
-function setOwn(record2, key, value) {
-  Object.defineProperty(record2, key, { value, enumerable: true, configurable: true, writable: true });
+function setOwn(record3, key, value) {
+  Object.defineProperty(record3, key, { value, enumerable: true, configurable: true, writable: true });
 }
 function isScalar(value) {
   return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
@@ -43199,6 +43229,22 @@ function resolveBound(requested, max) {
   if (requested === void 0 || !Number.isFinite(requested) || requested < 1) return max;
   return Math.min(Math.floor(requested), max);
 }
+var MAX_STATIC_IMAGE_ASSETS = 4096;
+var STATIC_IMAGE_PATH = /^\/assets\/(?:[A-Za-z0-9][A-Za-z0-9._-]*\/)*[A-Za-z0-9][A-Za-z0-9._-]*\.(?:png|jpe?g|gif|webp|avif|svg)$/;
+function staticImageLookup(options) {
+  const lookup = /* @__PURE__ */ new Map();
+  if (options.profile !== "inert" || options.imageAssets === void 0) return lookup;
+  if (!Array.isArray(options.imageAssets) || options.imageAssets.length > MAX_STATIC_IMAGE_ASSETS) {
+    throw new TypeError("static image asset inventory must be a bounded array");
+  }
+  for (const path6 of options.imageAssets) {
+    if (typeof path6 !== "string" || path6.length > 2048 || path6.trim() !== path6 || !STATIC_IMAGE_PATH.test(path6)) {
+      throw new TypeError("static image asset paths must be canonical local image paths");
+    }
+    lookup.set(path6, path6);
+  }
+  return lookup;
+}
 function textOf(node2) {
   if (node2.type === "text" || node2.type === "inlineCode" || node2.type === "html") {
     return node2.value ?? "";
@@ -43380,7 +43426,21 @@ function renderNode(node2, state, depth, index2) {
         index2
       );
     }
-    case "image":
+    case "image": {
+      const source = state.imageAssets.get(node2.url ?? "");
+      if (source !== void 0) {
+        return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+          "img",
+          {
+            src: source,
+            alt: node2.alt ?? "",
+            loading: "lazy",
+            decoding: "async",
+            referrerPolicy: "no-referrer"
+          },
+          index2
+        );
+      }
       return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(
         "span",
         {
@@ -43394,6 +43454,7 @@ function renderNode(node2, state, depth, index2) {
         },
         index2
       );
+    }
     case "table": {
       const align = node2.align ?? [];
       const rows = node2.children;
@@ -43463,7 +43524,7 @@ function renderMarkdown(body, options) {
     extensions: [gfm()],
     mdastExtensions: [gfmFromMarkdown()]
   });
-  const state = { count: 0, bounded: false, options, maxNodes };
+  const state = { count: 0, bounded: false, options, maxNodes, imageAssets: staticImageLookup(options) };
   const children = tree.children;
   const nodes = [];
   let i = 0;
@@ -43543,7 +43604,7 @@ function compareByMeaningfulChange(a, b) {
   } else if (b.timestampMs !== null) {
     return 1;
   }
-  return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+  return compareCodeUnits(a.id, b.id);
 }
 function sortByMeaningfulChange(rows, okfVersion) {
   return rows.map((row) => ({ row, key: meaningfulChangeOrderKey(row.id, row.frontmatter, okfVersion) })).sort((a, b) => compareByMeaningfulChange(a.key, b.key)).map(({ row }) => row);
@@ -43790,7 +43851,7 @@ function replyWithinLimit(reply) {
 }
 function skippedReply(skipped) {
   if (skipped.length === 0) return {};
-  return { skipped: [...skipped].sort((a, b) => a.id.localeCompare(b.id)).slice(0, MAX_QUERY_ROWS) };
+  return { skipped: [...skipped].sort((a, b) => compareCodeUnits(a.id, b.id)).slice(0, MAX_QUERY_ROWS) };
 }
 function boundedRows(rows, params, kinds) {
   const requested = params.limit === 0 || params.limit === void 0 ? MAX_QUERY_ROWS : Math.min(params.limit, MAX_QUERY_ROWS);
@@ -43905,7 +43966,7 @@ var BridgeService = class {
     for (const id of subscription.baseline.keys()) {
       if (!next.has(id)) removed.push(id);
     }
-    changes.sort((a, b) => a.id.localeCompare(b.id));
+    changes.sort((a, b) => compareCodeUnits(a.id, b.id));
     removed.sort();
     if (changes.length === 0 && removed.length === 0) return { status: "unchanged" };
     if (changes.length > MAX_CHANGE_ROWS || removed.length > MAX_CHANGE_ROWS) {
@@ -43934,7 +43995,7 @@ var BridgeService = class {
       throw new Error("the bundle is too large for the experimental View polling snapshot");
     }
     return new Map(
-      [...rows].sort((a, b) => a.id.localeCompare(b.id)).map((row) => [row.id, row.version])
+      [...rows].sort((a, b) => compareCodeUnits(a.id, b.id)).map((row) => [row.id, row.version])
     );
   }
   /**
@@ -44537,22 +44598,22 @@ function buildSnapshot(first) {
     });
     relationships.push(...parseLinksFromDoc(doc).map((link) => ({ ...link })));
   }
-  documents.sort((a, b) => a.id.localeCompare(b.id));
-  relationships.sort((a, b) => a.from.localeCompare(b.from) || a.to.localeCompare(b.to) || a.text.localeCompare(b.text) || a.href.localeCompare(b.href));
+  documents.sort((a, b) => compareCodeUnits(a.id, b.id));
+  relationships.sort((a, b) => compareCodeUnits(a.from, b.from) || compareCodeUnits(a.to, b.to) || compareCodeUnits(a.text, b.text) || compareCodeUnits(a.href, b.href));
   const reserved = first.reserved.map((row) => ({
     dir: row.dir,
     name: row.name,
     version: row.version,
     object: addObject(objects, row.bytes, "text/markdown; charset=utf-8", "exact")
   }));
-  reserved.sort((a, b) => `${a.dir}/${a.name}`.localeCompare(`${b.dir}/${b.name}`));
+  reserved.sort((a, b) => compareCodeUnits(`${a.dir}/${a.name}`, `${b.dir}/${b.name}`));
   const blobs = first.blobs.map((row) => ({
     key: row.key,
     version: row.version,
     contentType: row.contentType,
     object: addObject(objects, row.bytes, row.contentType, "exact")
   }));
-  blobs.sort((a, b) => a.key.localeCompare(b.key));
+  blobs.sort((a, b) => compareCodeUnits(a.key, b.key));
   const blobsByKey = new Map(blobs.map((row) => [row.key, row]));
   const views = [];
   for (const { doc, version: version2 } of parsedDocs.values()) {
@@ -44561,15 +44622,15 @@ function buildSnapshot(first) {
     if (!registration) {
       throw new PublicationError("INVALID_VIEW_REGISTRATION", "a View registration is invalid", { subject: doc.id });
     }
-    const blob = blobsByKey.get(registration.entry);
-    if (!blob) {
+    const blob2 = blobsByKey.get(registration.entry);
+    if (!blob2) {
       throw new PublicationError("VIEW_ENTRY_MISSING", "a registered View entry is missing", { subject: doc.id });
     }
-    if (registration.entryVersion && registration.entryVersion !== blob.version) {
+    if (registration.entryVersion && registration.entryVersion !== blob2.version) {
       throw new PublicationError("VIEW_ENTRY_VERSION_MISMATCH", "a registered View entry no longer matches its pin", {
         subject: doc.id,
         expected: registration.entryVersion,
-        actual: blob.version
+        actual: blob2.version
       });
     }
     const rawBlob = first.blobs.find((candidate) => candidate.key === registration.entry);
@@ -44590,11 +44651,11 @@ function buildSnapshot(first) {
       ...presentation === "workspace" || presentation === "inline" || presentation === "adaptive" ? { presentation } : {},
       access: resolveDeclaredAccess(doc.frontmatter),
       entry: registration.entry,
-      entryVersion: blob.version,
-      entryObject: blob.object
+      entryVersion: blob2.version,
+      entryObject: blob2.object
     });
   }
-  views.sort((a, b) => a.id.localeCompare(b.id));
+  views.sort((a, b) => compareCodeUnits(a.id, b.id));
   const withoutDigest = {
     schema: PUBLICATION_SNAPSHOT_V1,
     schemaVersion: 1,
@@ -45020,18 +45081,157 @@ function assertPublicationSourceExclusions(source, exclusions) {
     return slash > 0 && directories.has(fold(path6.slice(0, slash)));
   };
   const excludedType = (type) => type !== void 0 && type !== null && (types.has(kind(type)) || Array.isArray(type) && type.flat(Infinity).some((value) => types.has(kind(value))));
-  const count = source.documents.filter((document3) => excludedPath(document3.id) || excludedType(document3.frontmatter.type)).length + source.reserved.filter((file) => excludedPath(`${file.dir}/${file.name}`)).length + source.blobs.filter((blob) => excludedPath(blob.key)).length;
+  const count = source.documents.filter((document3) => excludedPath(document3.id) || excludedType(document3.frontmatter.type)).length + source.reserved.filter((file) => excludedPath(`${file.dir}/${file.name}`)).length + source.blobs.filter((blob2) => excludedPath(blob2.key)).length;
   if (count > 0) throw new PublicationError("INVALID_BUNDLE", "the publication source contains excluded content", { details: { excludedEntries: count } });
 }
+
+// ../core/src/json-data.ts
+function isJsonData(value, depth = 0) {
+  if (depth > 32) return false;
+  if (value === null || typeof value === "string" || typeof value === "boolean") return true;
+  if (typeof value === "number") return Number.isFinite(value);
+  if (Array.isArray(value)) return value.every((item) => isJsonData(item, depth + 1));
+  if (value === null || typeof value !== "object") return false;
+  const proto = Object.getPrototypeOf(value);
+  if (proto !== null && Object.getPrototypeOf(proto) !== null) return false;
+  return Object.values(value).every((item) => item !== void 0 && isJsonData(item, depth + 1));
+}
+
+// ../core/src/site-manifest.ts
+var SITE_TYPE = "Site";
+var SITES_PREFIX = "sites/";
+var SITE_LABEL = /^[a-z][a-z0-9-]{1,30}[a-z0-9]$/;
+var isSiteLabel = (value) => typeof value === "string" && SITE_LABEL.test(value) && !value.includes("--");
+var SITE_DOCUMENT_KEYS = ["type", "title", "description", "presentation", "landing", "views", "audience", "capabilities", "options", "brand"];
+var record2 = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+var packageName = /^(?:@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*$/;
+var exactVersion = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?$/;
+var encoder2 = new TextEncoder();
+function presentationReference(raw) {
+  if (typeof raw !== "string" || raw.length > 512) return void 0;
+  if (raw.startsWith("repo:")) {
+    const repository = raw.slice(5);
+    return /^[A-Za-z0-9][A-Za-z0-9-]{0,38}\/[A-Za-z0-9][A-Za-z0-9._-]{0,99}$/.test(repository) && !repository.endsWith(".git") ? { kind: "repository", repository } : void 0;
+  }
+  const at = raw.lastIndexOf("@");
+  if (at < 1) return void 0;
+  const name = raw.slice(0, at), version2 = raw.slice(at + 1), match = exactVersion.exec(version2);
+  if (name.length > 214 || !packageName.test(name) || !match || !match.slice(1, 4).every((part) => Number.isSafeInteger(Number(part))) || match[4]?.split(".").some((part) => /^\d+$/.test(part) && (part.length > 1 && part.startsWith("0") || !Number.isSafeInteger(Number(part))))) return void 0;
+  return { kind: "package", name, version: version2 };
+}
+var concept = (raw) => {
+  if (typeof raw !== "string") return false;
+  try {
+    assertSafeConceptId(raw);
+    return nonCanonicalDocumentId(raw) === null;
+  } catch {
+    return false;
+  }
+};
+var blob = (raw) => {
+  if (typeof raw !== "string") return false;
+  try {
+    assertSafeBlobKey(raw);
+    return true;
+  } catch {
+    return false;
+  }
+};
+function parseSiteManifestDoc(doc) {
+  const errors = [];
+  const fail2 = (path6, message) => {
+    errors.push({ code: "SITE_MANIFEST_INVALID", path: path6, message });
+  };
+  const fm = record2(doc?.frontmatter) ? doc.frontmatter : {};
+  const site = typeof doc?.id === "string" && doc.id.startsWith(SITES_PREFIX) ? doc.id.slice(SITES_PREFIX.length) : "";
+  if (!isSiteLabel(site)) fail2("/id", "a Site lives at sites/<site>, using one site label");
+  if (fm.type !== SITE_TYPE) fail2("/type", "type must be Site");
+  if (Object.keys(fm).some((key) => !SITE_DOCUMENT_KEYS.includes(key) && !isOkfStandardField(key) && !isManagedDocumentMetadataField(key)))
+    fail2("", "unrecognized Site fields");
+  if (typeof fm.title !== "string" || fm.title.trim() === "" || encoder2.encode(fm.title).byteLength > 512)
+    fail2("/title", "title must be a nonempty string of at most 512 bytes");
+  if (fm.description !== void 0 && (typeof fm.description !== "string" || encoder2.encode(fm.description).byteLength > 8192))
+    fail2("/description", "description must be a string of at most 8192 bytes");
+  const presentation = presentationReference(fm.presentation);
+  if (!presentation) fail2("/presentation", "presentation must name an exact npm version or repo:owner/name");
+  if (fm.audience !== "restricted") fail2("/audience", "only the restricted audience is supported");
+  const list3 = (raw, path6, maximum, valid) => {
+    if (!Array.isArray(raw) || raw.length > maximum || !raw.every(valid) || new Set(raw).size !== raw.length) {
+      fail2(path6, "expected a bounded list of unique valid references");
+      return [];
+    }
+    return [...raw];
+  };
+  const views = list3(fm.views, "/views", 64, concept);
+  const capability = (v) => typeof v === "string" && /^[a-z][a-z0-9-]{0,63}$/.test(v);
+  const capabilities = list3(fm.capabilities ?? [], "/capabilities", 16, capability);
+  if (fm.landing !== void 0 && !concept(fm.landing)) fail2("/landing", "landing must be a canonical document or View id");
+  const options = fm.options ?? {};
+  if (!record2(options) || !isJsonData(options) || encoder2.encode(JSON.stringify(options)).byteLength > 16384)
+    fail2("/options", "options must be JSON data of at most 16384 bytes");
+  let brand;
+  if (fm.brand !== void 0) {
+    if (!record2(fm.brand) || Object.keys(fm.brand).some((key) => key !== "logo" && key !== "fonts")) fail2("/brand", "brand may only name a logo and fonts");
+    else {
+      if (fm.brand.logo !== void 0 && !blob(fm.brand.logo)) fail2("/brand/logo", "logo must be a bundle blob reference");
+      const fonts = fm.brand.fonts === void 0 ? void 0 : list3(fm.brand.fonts, "/brand/fonts", 16, blob);
+      brand = { ...typeof fm.brand.logo === "string" ? { logo: fm.brand.logo } : {}, ...fonts ? { fonts } : {} };
+    }
+  }
+  if (errors.length) return { ok: false, errors };
+  return { ok: true, manifest: {
+    id: doc.id,
+    site,
+    title: fm.title,
+    presentation,
+    audience: "restricted",
+    views,
+    capabilities,
+    options: JSON.parse(JSON.stringify(options)),
+    ...fm.description === void 0 ? {} : { description: fm.description },
+    ...fm.landing === void 0 ? {} : { landing: fm.landing },
+    ...brand ? { brand } : {}
+  } };
+}
+
+// ../publication/src/site-manifest.ts
+function readPublicationSiteManifest(snapshot, site) {
+  const declarations = snapshot.documents.filter((doc) => doc.frontmatter.type === SITE_TYPE);
+  if (declarations.length !== 1 || declarations[0].id !== `${SITES_PREFIX}${site}`)
+    return { ok: false, errors: [{ code: "SITE_MANIFEST_INVALID", path: "/id", message: "the publication requires exactly one Site at sites/<site>" }] };
+  const parsed = parseSiteManifestDoc(declarations[0]);
+  if (!parsed.ok) return parsed;
+  const { manifest } = parsed;
+  const views = new Set(snapshot.views.map((view) => view.id));
+  const documents = new Set(snapshot.documents.map((doc) => doc.id));
+  const blobs = new Set(snapshot.blobs.map((blob2) => blob2.key));
+  const errors = [];
+  const fail2 = (path6, message) => {
+    errors.push({ code: "SITE_MANIFEST_INVALID", path: path6, message });
+  };
+  if (manifest.views.some((id) => !views.has(id))) fail2("/views", "every declared View must be registered in this publication");
+  if (manifest.landing !== void 0 && !documents.has(manifest.landing)) fail2("/landing", "landing must name a document or View in this publication");
+  if (manifest.landing !== void 0 && views.has(manifest.landing) && !manifest.views.includes(manifest.landing)) fail2("/landing", "a landing View must be declared by this Site");
+  if (manifest.brand?.logo !== void 0 && !blobs.has(manifest.brand.logo)) fail2("/brand/logo", "the logo must be a blob in this publication");
+  if (manifest.brand?.fonts?.some((key) => !blobs.has(key))) fail2("/brand/fonts", "every font must be a blob in this publication");
+  return errors.length ? { ok: false, errors } : parsed;
+}
 export {
   PUBLICATION_BRIDGE_V0,
   PUBLICATION_SNAPSHOT_SCHEMA_V1,
   PUBLICATION_SNAPSHOT_V1,
   PublicationError,
+  SITES_PREFIX,
+  SITE_DOCUMENT_KEYS,
+  SITE_LABEL,
+  SITE_TYPE,
   assertPublicationSourceExclusions,
   capturePublicationSnapshot,
   createPublicationBridge,
-  isPublicationError
+  isPublicationError,
+  isSiteLabel,
+  parseSiteManifestDoc,
+  readPublicationSiteManifest
 };
 /*! Bundled license information: