superbee 0.4.4 → 0.4.5

package/dist/publication/capture.d.ts

@@ -1,8 +1,8 @@
 import type { FilesystemHostPolicy } from "@superbee/core/filesystem";
-import { type CapturePublicationSnapshotOptionsV1, type PublicationSnapshotHandleV1 } from "./types.js";
+import { type CapturePublicationSnapshotOptionsV1, type PublicationCapturedSnapshotHandleV1 } from "./types.js";
 export interface CapturePublicationRuntimeOptions {
     readonly filesystemHostPolicy?: FilesystemHostPolicy;
 }
 /** Capture one coherent immutable filesystem publication snapshot. */
-export declare function capturePublicationSnapshot(options: CapturePublicationSnapshotOptionsV1, runtimeOptions?: CapturePublicationRuntimeOptions): Promise<PublicationSnapshotHandleV1>;
+export declare function capturePublicationSnapshot(options: CapturePublicationSnapshotOptionsV1, runtimeOptions?: CapturePublicationRuntimeOptions): Promise<PublicationCapturedSnapshotHandleV1>;
 //# sourceMappingURL=capture.d.ts.map

package/dist/publication/external-link-policy.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Which external links become anchors. This file stays free of imports because `superbee/publication`
+ * ships its declaration on its own, without the private renderer package or React types.
+ *
+ * - `"none"` keeps every external target as inert text. Absent and unknown values mean the same.
+ * - `"https"` admits any `https:` URL with no userinfo.
+ * - `{ hosts }` also requires the default port and an exact match on one listed bare host name.
+ *
+ * The page owner's code sets this. Never read it from a document, Kind, recipe, View manifest,
+ * bundle record or tool argument. The one exception is a host's sealed room, whose host list comes
+ * from content that host validated and sealed.
+ */
+export type ExternalLinkPolicy = "none" | "https" | {
+    readonly hosts: readonly string[];
+};
+//# sourceMappingURL=external-link-policy.d.ts.map

package/dist/publication/index.d.ts

@@ -3,7 +3,7 @@ export { createPublicationBridge, type CreatePublicationBridgeOptionsV1 } from "
 export { PublicationError, isPublicationError } from "./errors.js";
 export type { PublicationErrorCodeV1, PublicationErrorOptions } from "./errors.js";
 export { PUBLICATION_SNAPSHOT_SCHEMA_V1 } from "./schema.js";
-export { PUBLICATION_BRIDGE_V0, PUBLICATION_SNAPSHOT_V1, type CapturePublicationSnapshotOptionsV1, type PublicationBridgeAdmissionV1, type PublicationBridgeOutcomeV1, type PublicationBridgeV1, type PublicationJsonValue, type PublicationObjectRefV1, type PublicationSnapshotHandleV1, type PublicationSnapshotV1, } from "./types.js";
+export { PUBLICATION_BRIDGE_V0, PUBLICATION_SNAPSHOT_V1, type CapturePublicationSnapshotOptionsV1, type ExternalLinkPolicy, type PublicationBridgeAdmissionV1, type PublicationBridgeOutcomeV1, type PublicationBridgeV1, type PublicationCapturedSnapshotHandleV1, type PublicationJsonValue, type PublicationObjectRefV1, type PublicationRenderDocumentOptionsV1, type PublicationRenderedDocumentV1, type PublicationSnapshotHandleV1, type PublicationSnapshotV1, } from "./types.js";
 export type { CapturePublicationRuntimeOptions } from "./capture.js";
 export { assertPublicationSourceExclusions } from "./source-exclusions.js";
 export type { PublicationSourceInventory, PublicationSourceExclusions } from "./source-exclusions.js";

package/dist/publication/types.d.ts

@@ -1,9 +1,11 @@
+import type { ExternalLinkPolicy } from "./external-link-policy.js";
 import type { JsonValue, ObjectRef, PublicationSnapshotV1 as GeneratedPublicationSnapshotV1 } from "./generated/publication-snapshot-v1.js";
 type DeepReadonly<T> = T extends (...args: never[]) => unknown ? T : T extends readonly (infer Item)[] ? readonly DeepReadonly<Item>[] : T extends object ? {
     readonly [Key in keyof T]: DeepReadonly<T[Key]>;
 } : T;
 export declare const PUBLICATION_SNAPSHOT_V1: "https://getsuperbee.com/schemas/publication-snapshot/v1";
 export declare const PUBLICATION_BRIDGE_V0: "v0";
+export type { ExternalLinkPolicy };
 export type PublicationJsonValue = DeepReadonly<JsonValue>;
 export type PublicationObjectRefV1 = DeepReadonly<ObjectRef>;
 export type PublicationSnapshotV1 = DeepReadonly<GeneratedPublicationSnapshotV1>;
@@ -26,6 +28,26 @@ export interface PublicationSnapshotHandleV1 {
     serializeManifest(): Uint8Array;
     close(): Promise<void>;
 }
+export interface PublicationRenderDocumentOptionsV1 {
+    /** Set by the caller's own code. Absent or unknown means `none`. */
+    externalLinks?: ExternalLinkPolicy;
+}
+export interface PublicationRenderedDocumentV1 {
+    html: string;
+    bounded: boolean;
+}
+/**
+ * The handle capture returns. Handles that only serve stored bytes, such as a deployed site's
+ * reader, implement {@link PublicationSnapshotHandleV1} and need no renderer.
+ */
+export interface PublicationCapturedSnapshotHandleV1 extends PublicationSnapshotHandleV1 {
+    /**
+     * Render one document again from its digest-checked source with the caller's link policy. The
+     * snapshot and its stored inert HTML do not change, and the View bridge never calls this.
+     * With no policy the HTML equals the stored object byte for byte.
+     */
+    renderDocument(id: string, options?: PublicationRenderDocumentOptionsV1): Promise<PublicationRenderedDocumentV1>;
+}
 export interface PublicationBridgeAdmissionV1 {
     id: string;
     entry: string;
@@ -40,5 +62,4 @@ export interface PublicationBridgeOutcomeV1 {
 export interface PublicationBridgeV1 {
     handle(rawRequest: unknown): Promise<PublicationBridgeOutcomeV1>;
 }
-export {};
 //# sourceMappingURL=types.d.ts.map

package/dist/publication.mjs

@@ -43438,6 +43438,72 @@ function gfmFromMarkdown() {
   ];
 }
 
+// ../markdown-renderer/src/parse.ts
+var MAX_BLOCK_SCORE = 44e7;
+var MAX_BLOCK_EMPHASIS = 4e3;
+var MAX_EMPHASIS_SCORE = 1e8;
+var MAX_PIPES = 25e3;
+var MAX_LINE_MARKERS = 14e3;
+var MAX_TABLES = 2500;
+var MAX_LINE_NESTING = 64;
+var MAX_LINE_PREFIX = 512;
+var CONTAINER_MARKER = />|[-+*](?=[ \t]|$)|\d{1,9}[.)](?=[ \t]|$)|\[\^[^[\]\s]+\]:/my;
+function withinParseLimits(source) {
+  let emphasisSum = 0, score = 0, block = 0, emphasis = 0, pipes = 0, markers = 0, tables = 0;
+  let lineStart = 0, linePipes = 0, lineDashes = 0, blank = true, delimiterRow = true;
+  for (let i = 0; i <= source.length; i++) {
+    const code2 = i < source.length ? source.charCodeAt(i) : 10;
+    if (code2 === 13 && source.charCodeAt(i + 1) === 10) continue;
+    if (code2 === 10 || code2 === 13) {
+      let nesting = 0, prefix = 0, position2 = lineStart;
+      for (; ; ) {
+        while (source.charCodeAt(position2) === 32 || source.charCodeAt(position2) === 9) position2++;
+        CONTAINER_MARKER.lastIndex = position2;
+        if (!CONTAINER_MARKER.test(source)) break;
+        position2 = CONTAINER_MARKER.lastIndex;
+        prefix = position2 - lineStart;
+        nesting++;
+      }
+      if (nesting > MAX_LINE_NESTING || prefix > MAX_LINE_PREFIX) return false;
+      markers += nesting;
+      if (delimiterRow && linePipes > 0 && lineDashes > 0) tables++;
+      if (blank) {
+        score += block * block;
+        emphasisSum += emphasis * emphasis;
+        block = 0;
+        emphasis = 0;
+      } else {
+        block += 2;
+      }
+      lineStart = i + 1;
+      linePipes = lineDashes = 0;
+      blank = delimiterRow = true;
+      continue;
+    }
+    if (code2 === 32 || code2 === 9) continue;
+    blank = false;
+    if (code2 === 124) linePipes++, pipes++;
+    else if (code2 === 45) lineDashes++;
+    else if (code2 !== 58 && code2 !== 62) delimiterRow = false;
+    const alphanumeric = code2 >= 48 && code2 <= 57 || code2 >= 65 && code2 <= 90 || code2 >= 97 && code2 <= 122 || code2 >= 128;
+    if (!alphanumeric) block += code2 === 93 ? 2 : 1;
+    if ((code2 === 42 || code2 === 95 || code2 === 126) && ++emphasis > MAX_BLOCK_EMPHASIS) return false;
+  }
+  return (emphasisSum + emphasis * emphasis) / MAX_EMPHASIS_SCORE + (score + block * block) / MAX_BLOCK_SCORE + (markers / MAX_LINE_MARKERS) ** 2 + (tables / MAX_TABLES) ** 2 + (pipes / MAX_PIPES) ** 2 <= 1;
+}
+function isCallStackExhausted(error) {
+  return error instanceof Error && (error.name === "RangeError" || error.name === "InternalError") && /call stack|recursion/i.test(error.message);
+}
+function parseWithinLimits(source) {
+  if (!withinParseLimits(source)) return null;
+  try {
+    return fromMarkdown(source, { extensions: [gfm()], mdastExtensions: [gfmFromMarkdown()] });
+  } catch (error) {
+    if (isCallStackExhausted(error)) return null;
+    throw error;
+  }
+}
+
 // ../markdown-renderer/src/index.tsx
 var import_jsx_runtime = __toESM(require_jsx_runtime(), 1);
 function renderableConceptId(fromId, raw) {
@@ -43467,13 +43533,20 @@ function staticImageLookup(options) {
   }
   return lookup;
 }
-function textOf(node2) {
-  if (node2.type === "text" || node2.type === "inlineCode" || node2.type === "html") {
-    return node2.value ?? "";
+function textOf(root) {
+  const parts = [];
+  const pending = [root];
+  while (pending.length > 0) {
+    const node2 = pending.pop();
+    if (node2.type === "text" || node2.type === "inlineCode" || node2.type === "html") {
+      parts.push(node2.value ?? "");
+      continue;
+    }
+    const children = node2.children;
+    if (!Array.isArray(children)) continue;
+    for (let i = children.length - 1; i >= 0; i--) pending.push(children[i]);
   }
-  const children = node2.children;
-  if (!Array.isArray(children)) return "";
-  return children.map((child) => textOf(child)).join("");
+  return parts.join("");
 }
 function renderTextFallback(node2, index2) {
   return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: "doc-markdown-fallback", children: textOf(node2) }, index2);
@@ -43526,16 +43599,19 @@ function admitFragment(raw) {
   }
   return fragment.length <= MAX_FRAGMENT_LENGTH && SAFE_FRAGMENT.test(fragment) ? fragment : null;
 }
-function admitExternalLink(raw, hosts) {
-  if (!Array.isArray(hosts) || hosts.length === 0) return null;
+function admitExternalLink(raw, policy) {
+  const anyHost = policy === "https";
+  const hosts = typeof policy === "object" && policy !== null ? policy.hosts : void 0;
+  if (!anyHost && (!Array.isArray(hosts) || hosts.length === 0)) return null;
   let url;
   try {
     url = new URL(raw);
   } catch {
     return null;
   }
-  if (url.protocol !== "https:" || url.username !== "" || url.password !== "" || url.port !== "") return null;
-  if (isIpLiteralHost(url.hostname)) return null;
+  if (url.protocol !== "https:" || url.username !== "" || url.password !== "") return null;
+  if (anyHost) return url.href;
+  if (url.port !== "") return null;
   for (const entry of hosts) {
     if (normalizeAllowedHost(entry) === url.hostname) return url.href;
   }
@@ -43617,10 +43693,14 @@ function renderNode(node2, state, depth, index2) {
     case "link": {
       const raw = node2.url ?? "";
       const resolved = renderableConceptId(state.options.fromId, raw);
+      const insideLink = state.insideLink;
+      state.insideLink = true;
       const children = renderChildren(node2, state, depth);
+      state.insideLink = insideLink;
       if (resolved === null) {
-        const external = admitExternalLink(raw, state.options.externalLinkHosts);
-        if (external !== null) {
+        const hasContent = /\S/.test(textOf(node2)) || node2.children.some((child) => child.type === "image");
+        const external = admitExternalLink(raw, state.options.externalLinks);
+        if (external !== null && !insideLink && hasContent) {
           return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("a", { href: external, rel: "noopener noreferrer", target: "_blank", className: "doc-link-external", children }, index2);
         }
         const fragment = admitFragment(raw);
@@ -43742,11 +43822,15 @@ function renderMarkdown(body, options) {
     source = source.slice(0, maxBodyChars);
     bounded = true;
   }
-  const tree = fromMarkdown(source, {
-    extensions: [gfm()],
-    mdastExtensions: [gfmFromMarkdown()]
-  });
-  const state = { count: 0, bounded: false, options, maxNodes, imageAssets: staticImageLookup(options) };
+  const tree = parseWithinLimits(source);
+  if (tree === null) {
+    return {
+      element: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("pre", { className: "doc-code doc-markdown-fallback", children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("code", { children: source }) }),
+      bounded: true,
+      limits: { maxBodyChars, maxNodes }
+    };
+  }
+  const state = { count: 0, bounded: false, insideLink: false, options, maxNodes, imageAssets: staticImageLookup(options) };
   const children = tree.children;
   const nodes = [];
   let i = 0;
@@ -43783,11 +43867,8 @@ function renderMarkdownToStaticHtml(body, options) {
   );
   return { html, bounded: rendered.bounded, limits: rendered.limits };
 }
-function renderDocumentToStaticHtml(document3, options = {}) {
-  const rendered = renderMarkdownToStaticHtml(document3.body, {
-    fromId: document3.id,
-    externalLinkHosts: options.externalLinkHosts
-  });
+function renderDocumentToStaticHtml(document3) {
+  const rendered = renderMarkdownToStaticHtml(document3.body, { fromId: document3.id });
   return { html: rendered.html, bounded: rendered.bounded };
 }
 
@@ -44685,6 +44766,17 @@ async function readInventory(backend, limits) {
   }
   return { documents, reserved, blobs };
 }
+function parseDocumentSource(bytes, id, okfEdition) {
+  try {
+    const raw = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+    return parseMarkdown(raw, `${id}.md`, { okfVersion: okfEdition });
+  } catch (error) {
+    throw new PublicationError("MALFORMED_DOCUMENT", "a publication document is malformed", {
+      subject: id,
+      cause: error
+    });
+  }
+}
 var SnapshotHandle = class {
   constructor(manifest, objects) {
     this.objects = objects;
@@ -44718,6 +44810,21 @@ var SnapshotHandle = class {
     }
     return bytes.slice();
   }
+  async renderDocument(id, options = {}) {
+    if (this.closed) throw new PublicationError("HANDLE_CLOSED", "the publication snapshot handle is closed");
+    const row = this.manifest.documents.find((document3) => document3.id === id);
+    if (!row) throw new PublicationError("OBJECT_MISSING", "the document is not part of this snapshot", { subject: id });
+    const parsed = parseDocumentSource(await this.readObject(row.source), id, this.manifest.source.okfEdition);
+    try {
+      const rendered = renderMarkdownToStaticHtml(parsed.body, { fromId: id, externalLinks: options.externalLinks });
+      return { html: rendered.html, bounded: rendered.bounded };
+    } catch (error) {
+      throw new PublicationError("RENDER_FAILED", "a publication document could not be rendered", {
+        subject: id,
+        cause: error
+      });
+    }
+  }
   serializeManifest() {
     if (this.closed) throw new PublicationError("HANDLE_CLOSED", "the publication snapshot handle is closed");
     return this.serializedManifest.slice();
@@ -44781,16 +44888,7 @@ function buildSnapshot(first) {
     }
   }
   for (const row of first.documents) {
-    let parsed;
-    try {
-      const raw = new TextDecoder("utf-8", { fatal: true }).decode(row.bytes);
-      parsed = parseMarkdown(raw, `${row.id}.md`, { okfVersion: okfEdition });
-    } catch (error) {
-      throw new PublicationError("MALFORMED_DOCUMENT", "a publication document is malformed", {
-        subject: row.id,
-        cause: error
-      });
-    }
+    const parsed = parseDocumentSource(row.bytes, row.id, okfEdition);
     if (typeof parsed.frontmatter.type !== "string" || !parsed.frontmatter.type.trim()) {
       throw new PublicationError("MALFORMED_DOCUMENT", "a publication document requires a non-empty type", {
         subject: row.id