superbee 0.4.4-pre.1 → 0.4.4-pre.11

package/dist/portable-export.mjs

@@ -3,6 +3,11 @@ import { createHash } from "node:crypto";
 import { mkdir, mkdtemp, realpath, rm, writeFile } from "node:fs/promises";
 import path from "node:path";
 
+// ../core/src/path-fold.ts
+function foldPath(path2) {
+  return path2.normalize("NFC").toLowerCase().toUpperCase().toLowerCase().normalize("NFC");
+}
+
 // ../core/src/errors.ts
 var InvalidInputError = class extends Error {
   constructor(message) {
@@ -175,7 +180,6 @@ function readStoredZip(archive) {
   return entries;
 }
 var WINDOWS_DEVICE_NAMES = /* @__PURE__ */ new Set(["CON", "PRN", "AUX", "NUL", ...Array.from({ length: 9 }, (_, i) => `COM${i + 1}`), ...Array.from({ length: 9 }, (_, i) => `LPT${i + 1}`)]);
-var fold = (segment) => segment.normalize("NFC").toLowerCase();
 function classifyEntryPath(entryPath) {
   const unsafe = (why) => new ExportArchiveError("unsafe_path", `the archive holds a path a bundle cannot keep (${why}): ${JSON.stringify(entryPath.slice(0, 200))}`);
   if (entryPath === "" || entryPath.length > 4096) throw unsafe("empty or too long");
@@ -209,13 +213,13 @@ function findEntryCollision(paths) {
   const dirs = /* @__PURE__ */ new Map();
   for (const entryPath of paths) {
     const segments = entryPath.split("/");
-    const key = segments.map(fold).join("/");
+    const key = segments.map(foldPath).join("/");
     const file = files.get(key) ?? dirs.get(key)?.by;
     if (file !== void 0) return [file, entryPath];
     files.set(key, entryPath);
     for (let depth = 1; depth < segments.length; depth += 1) {
       const spelling = segments.slice(0, depth).join("/");
-      const dirKey = segments.slice(0, depth).map(fold).join("/");
+      const dirKey = segments.slice(0, depth).map(foldPath).join("/");
       const asFile = files.get(dirKey);
       if (asFile !== void 0) return [asFile, entryPath];
       const seen = dirs.get(dirKey);

package/dist/publication/index.d.ts

@@ -7,4 +7,7 @@ export { PUBLICATION_BRIDGE_V0, PUBLICATION_SNAPSHOT_V1, type CapturePublication
 export type { CapturePublicationRuntimeOptions } from "./capture.js";
 export { assertPublicationSourceExclusions } from "./source-exclusions.js";
 export type { PublicationSourceInventory, PublicationSourceExclusions } from "./source-exclusions.js";
+export { parseSiteManifestDoc, isSiteLabel, SITE_LABEL, SITE_TYPE, SITES_PREFIX, SITE_DOCUMENT_KEYS } from "./site-manifest-core.js";
+export type { SiteManifest, SiteManifestError, SiteManifestParseResult, SitePresentationReference } from "./site-manifest-core.js";
+export { readPublicationSiteManifest } from "./site-manifest.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/publication/site-manifest-core.d.ts

@@ -0,0 +1,49 @@
+export declare const SITE_TYPE = "Site";
+export declare const SITES_PREFIX = "sites/";
+/** One site label leaves room for its workspace label in a combined DNS name. */
+export declare const SITE_LABEL: RegExp;
+export declare const isSiteLabel: (value: unknown) => value is string;
+export declare const SITE_DOCUMENT_KEYS: readonly ["type", "title", "description", "presentation", "landing", "views", "audience", "capabilities", "options", "brand"];
+export type SitePresentationReference = {
+    readonly kind: "package";
+    readonly name: string;
+    readonly version: string;
+} | {
+    readonly kind: "repository";
+    readonly repository: string;
+};
+export interface SiteManifest {
+    readonly id: string;
+    readonly site: string;
+    readonly title: string;
+    readonly description?: string;
+    readonly presentation: SitePresentationReference;
+    readonly landing?: string;
+    readonly views: readonly string[];
+    readonly audience: "restricted";
+    readonly capabilities: readonly string[];
+    readonly options: Readonly<Record<string, unknown>>;
+    readonly brand?: {
+        readonly logo?: string;
+        readonly fonts?: readonly string[];
+    };
+}
+export interface SiteManifestError {
+    readonly code: "SITE_MANIFEST_INVALID";
+    readonly path: string;
+    readonly message: string;
+}
+export type SiteManifestParseResult = {
+    readonly ok: true;
+    readonly manifest: SiteManifest;
+} | {
+    readonly ok: false;
+    readonly errors: readonly SiteManifestError[];
+};
+/** Standard OKF and managed metadata survive on the document; only Site fields enter this value.
+ * Presentation owners validate option semantics. Builders separately admit trusted resolved code. */
+export declare function parseSiteManifestDoc(doc: {
+    readonly id: string;
+    readonly frontmatter: Readonly<Record<string, unknown>>;
+}): SiteManifestParseResult;
+//# sourceMappingURL=site-manifest.d.ts.map

package/dist/publication/site-manifest-entry.d.ts

@@ -0,0 +1,5 @@
+/** Portable declaration surface, with no filesystem capture or credential handling. */
+export { parseSiteManifestDoc, isSiteLabel, SITE_LABEL, SITE_TYPE, SITES_PREFIX, SITE_DOCUMENT_KEYS } from "./site-manifest-core.js";
+export type { SiteManifest, SiteManifestError, SiteManifestParseResult, SitePresentationReference } from "./site-manifest-core.js";
+export { readPublicationSiteManifest } from "./site-manifest.js";
+//# sourceMappingURL=site-manifest-entry.d.ts.map

package/dist/publication/site-manifest.d.ts

@@ -0,0 +1,5 @@
+import { type SiteManifestParseResult } from "./site-manifest-core.js";
+import type { PublicationSnapshotV1 } from "./types.js";
+/** Resolve only declarations and references in the frozen publication. This never resolves code. */
+export declare function readPublicationSiteManifest(snapshot: Pick<PublicationSnapshotV1, "documents" | "views" | "blobs">, site: string): SiteManifestParseResult;
+//# sourceMappingURL=site-manifest.d.ts.map

package/dist/publication-bridge.mjs

@@ -3397,6 +3397,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 = [];
@@ -3418,6 +3423,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;
@@ -3428,12 +3440,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;
@@ -3813,12 +3829,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 {
@@ -3829,6 +3846,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;
       }
     }
@@ -3841,7 +3862,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 = {}) {
@@ -3850,7 +3871,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 }) => ({
@@ -3890,7 +3911,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;
 }
 
@@ -4406,6 +4427,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 {
@@ -4451,9 +4477,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;
@@ -6328,7 +6351,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);
@@ -6575,7 +6598,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);
@@ -6690,7 +6713,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) {
@@ -6719,7 +6742,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])
     );
   }
   /**

package/dist/publication-site-manifest.mjs

@@ -0,0 +1,212 @@
+// ../core/src/errors.ts
+var InvalidInputError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InvalidInputError";
+  }
+};
+
+// ../core/src/paths.ts
+function assertPortablePath(value, label) {
+  if (/[\u0000-\u001f\u007f]/u.test(value) || /^[a-z]:/i.test(value)) {
+    throw new InvalidInputError(`${label} must not contain controls or start with a drive prefix.`);
+  }
+  if (value.includes("\\") || value.split("/").some((segment) => segment === "" || segment === "." || segment === "..")) {
+    throw new InvalidInputError(`${label} must be canonical and bundle-relative.`);
+  }
+}
+function assertSafeConceptId(id) {
+  if (typeof id !== "string" || id.trim() === "") {
+    throw new InvalidInputError("Concept id must be a non-empty string.");
+  }
+  assertPortablePath(id, "Concept id");
+  const segments = id.split("/");
+  if (segments.slice(0, -1).some((seg) => seg.toLowerCase().endsWith(".md"))) {
+    throw new InvalidInputError(
+      `Concept id must not contain a non-final segment ending in '.md': '${id}' (it collides with a concept file at that path).`
+    );
+  }
+}
+var FORMAT_AT_EDGE = /^\p{Cf}|\p{Cf}$/u;
+var FORMAT_INSIDE = /(?![\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.");
+  }
+  assertPortablePath(key, "Blob key");
+  const segments = key.split("/");
+  if (segments.some((seg) => seg.startsWith("."))) {
+    throw new InvalidInputError(`Blob key must not contain dot-prefixed segments: '${key}'.`);
+  }
+  if (segments.some((seg) => seg.toLowerCase().endsWith(".md"))) {
+    throw new InvalidInputError(
+      `Blob key '${key}' has a path segment ending in '.md' (checked case-insensitively, at any depth), which collides with the concept-document namespace \u2014 write it as a doc instead.`
+    );
+  }
+}
+
+// ../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/okf-standard-fields.ts
+var OKF_STANDARD_FIELD_NAMES = ["type", "title", "description", "resource", "tags", "status", "sources", "generated", "verified", "stale_after", "usage_window", "runtime", "computation", "parameters", "executor", "attester", "okf_version"];
+function isOkfStandardField(field) {
+  return OKF_STANDARD_FIELD_NAMES.includes(field);
+}
+
+// ../core/src/managed-document-metadata.ts
+var MANAGED_DOCUMENT_METADATA_FIELDS = /* @__PURE__ */ new Set([
+  "generated",
+  "verified",
+  "superbee_updated_by",
+  "actor",
+  "timestamp"
+]);
+function isManagedDocumentMetadataField(field) {
+  return MANAGED_DOCUMENT_METADATA_FIELDS.has(field);
+}
+
+// ../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 record = (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 encoder = 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), version = raw.slice(at + 1), match = exactVersion.exec(version);
+  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 };
+}
+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 fail = (path, message) => {
+    errors.push({ code: "SITE_MANIFEST_INVALID", path, message });
+  };
+  const fm = record(doc?.frontmatter) ? doc.frontmatter : {};
+  const site = typeof doc?.id === "string" && doc.id.startsWith(SITES_PREFIX) ? doc.id.slice(SITES_PREFIX.length) : "";
+  if (!isSiteLabel(site)) fail("/id", "a Site lives at sites/<site>, using one site label");
+  if (fm.type !== SITE_TYPE) fail("/type", "type must be Site");
+  if (Object.keys(fm).some((key) => !SITE_DOCUMENT_KEYS.includes(key) && !isOkfStandardField(key) && !isManagedDocumentMetadataField(key)))
+    fail("", "unrecognized Site fields");
+  if (typeof fm.title !== "string" || fm.title.trim() === "" || encoder.encode(fm.title).byteLength > 512)
+    fail("/title", "title must be a nonempty string of at most 512 bytes");
+  if (fm.description !== void 0 && (typeof fm.description !== "string" || encoder.encode(fm.description).byteLength > 8192))
+    fail("/description", "description must be a string of at most 8192 bytes");
+  const presentation = presentationReference(fm.presentation);
+  if (!presentation) fail("/presentation", "presentation must name an exact npm version or repo:owner/name");
+  if (fm.audience !== "restricted") fail("/audience", "only the restricted audience is supported");
+  const list = (raw, path, maximum, valid) => {
+    if (!Array.isArray(raw) || raw.length > maximum || !raw.every(valid) || new Set(raw).size !== raw.length) {
+      fail(path, "expected a bounded list of unique valid references");
+      return [];
+    }
+    return [...raw];
+  };
+  const views = list(fm.views, "/views", 64, concept);
+  const capability = (v) => typeof v === "string" && /^[a-z][a-z0-9-]{0,63}$/.test(v);
+  const capabilities = list(fm.capabilities ?? [], "/capabilities", 16, capability);
+  if (fm.landing !== void 0 && !concept(fm.landing)) fail("/landing", "landing must be a canonical document or View id");
+  const options = fm.options ?? {};
+  if (!record(options) || !isJsonData(options) || encoder.encode(JSON.stringify(options)).byteLength > 16384)
+    fail("/options", "options must be JSON data of at most 16384 bytes");
+  let brand;
+  if (fm.brand !== void 0) {
+    if (!record(fm.brand) || Object.keys(fm.brand).some((key) => key !== "logo" && key !== "fonts")) fail("/brand", "brand may only name a logo and fonts");
+    else {
+      if (fm.brand.logo !== void 0 && !blob(fm.brand.logo)) fail("/brand/logo", "logo must be a bundle blob reference");
+      const fonts = fm.brand.fonts === void 0 ? void 0 : list(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 fail = (path, message) => {
+    errors.push({ code: "SITE_MANIFEST_INVALID", path, message });
+  };
+  if (manifest.views.some((id) => !views.has(id))) fail("/views", "every declared View must be registered in this publication");
+  if (manifest.landing !== void 0 && !documents.has(manifest.landing)) fail("/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)) fail("/landing", "a landing View must be declared by this Site");
+  if (manifest.brand?.logo !== void 0 && !blobs.has(manifest.brand.logo)) fail("/brand/logo", "the logo must be a blob in this publication");
+  if (manifest.brand?.fonts?.some((key) => !blobs.has(key))) fail("/brand/fonts", "every font must be a blob in this publication");
+  return errors.length ? { ok: false, errors } : parsed;
+}
+export {
+  SITES_PREFIX,
+  SITE_DOCUMENT_KEYS,
+  SITE_LABEL,
+  SITE_TYPE,
+  isSiteLabel,
+  parseSiteManifestDoc,
+  readPublicationSiteManifest
+};