@revealui/core 0.0.1-pre.0

package/dist/core/processing/getters/getHtmlTags.ts

@@ -0,0 +1,341 @@
+export { getHtmlTags }
+export type { HtmlTag, InjectFilterEntry, PreloadFilter }
+
+import pc from "@brillout/picocolors"
+
+import { PageConfigRuntime } from "../../../types/interfaces/page.js"
+import type { PageContextInjectAssets } from "../../assets/index.js"
+import { inferAssetTag, inferPreloadTag } from "../../assets/inferHtmlTags.js"
+import { mergeScriptTags } from "../../assets/mergeScriptTags.js"
+import { sanitizeJson } from "../../assets/sanitizeJson.js"
+import { assert } from "../../gaurds/assertions/assert/index.js"
+import { assertUsage } from "../../gaurds/assertions/assertUsage/index.js"
+import { assertWarning } from "../../gaurds/assertions/assertWarning/index.js"
+import { freezePartial } from "../../gaurds/normalization/freezePartial.js"
+import { isObject } from "../../gaurds/validators/isObject.js"
+import { getGlobalContext } from "../../globals/contexts/index.js"
+import { StreamFromReactStreamingPackage } from "../../renderer/stream/react-streaming.js"
+import {
+  PageContextSerialization,
+  serializePageContextClientSide,
+} from "../serializers/serializePageContextClientSide.js"
+import { getConfigDefinedAt } from "./getConfigDefinedAt.js"
+import { getConfigValueRuntime } from "./getConfigValue.js"
+import { PageAsset } from "./getPageAssets.js"
+import { getPageConfig } from "./getPageConfig.js"
+
+const stamp = "__injectFilterEntry"
+
+type PreloadFilter =
+  | null
+  | ((assets: InjectFilterEntry[]) => InjectFilterEntry[])
+type PreloadFilterInject = false | "HTML_BEGIN" | "HTML_END"
+/** Filter what assets reveal injects in the HTML.
+ *
+ * https://reveal.dev/injectFilter
+ */
+type InjectFilterEntry = {
+  src: string
+  assetType: null | PageAsset["assetType"]
+  mediaType: null | PageAsset["mediaType"]
+  /** Whether src is a root in the dependency graph.
+   *  - For JavaScript this means whether src is imported by a dynamic import() statement.
+   *  - All CSS files have `isEntry: true`
+   */
+  isEntry: boolean
+  inject: PreloadFilterInject
+}
+
+type Position = "HTML_BEGIN" | "HTML_END" | "HTML_STREAM"
+type HtmlTag = {
+  htmlTag: string | (() => string)
+  position: Position
+}
+function getHtmlTags(
+  pageContext: { _isStream: boolean } & PageContextInjectAssets,
+  streamFromReactStreamingPackage: null | StreamFromReactStreamingPackage,
+  injectFilter: PreloadFilter,
+  pageAssets: PageAsset[],
+  viteDevScript: string,
+  isStream: boolean
+) {
+  assert([true, false].includes(pageContext._isHtmlOnly))
+  const isHtmlOnly = pageContext._isHtmlOnly
+  const { isProduction } = getGlobalContext()
+  const injectScriptsAt = getInjectScriptsAt(
+    pageContext.pageId,
+    pageContext._pageConfigs
+  )
+
+  const injectFilterEntries: InjectFilterEntry[] = pageAssets
+    .filter((asset) => {
+      if (asset.isEntry && asset.assetType === "script") {
+        // We could allow the user to change the position of <script> but we currently don't:
+        //  - Because of mergeScriptEntries()
+        //  - We would need to add HTML_STREAM to to PreloadFilterInject
+        // To suppor this, we should add the JavaScript entry to injectFilterEntries (with an `src` value of `null`)
+        return false
+      }
+      return true
+    })
+    .map((asset) => {
+      const inject = (() => {
+        if (!isProduction) {
+          // In development, we should always load assets as soon as possible, in order to eagerly process assets (e.g. applying the transform() hooks of Vite plugins) which are lazily discovered.
+          return "HTML_BEGIN"
+        }
+        if (asset.assetType === "style" || asset.assetType === "font") {
+          return "HTML_BEGIN"
+        }
+        if (asset.assetType === "script") {
+          if (isHtmlOnly) return false
+          return "HTML_END"
+        }
+        return false
+      })()
+      const entry: InjectFilterEntry = {
+        ...asset,
+        inject,
+        // @ts-ignore
+        [stamp]: true,
+      }
+      return entry
+    })
+  assertInjectFilterEntries(injectFilterEntries)
+
+  // ==============
+  // injectFilter()
+  // ==============
+  if (injectFilter && isProduction) {
+    Object.seal(injectFilterEntries) // `Object.seal()` instead of `Object.freeze()` to allow the user to `assets.sort()`
+    Object.values(injectFilterEntries).forEach((entry) =>
+      freezePartial(entry, {
+        inject: (val) =>
+          val === false || val === "HTML_BEGIN" || val === "HTML_END",
+      })
+    )
+    // Call the user's injectFilter() hook https://reveal.dev/injectFilter
+    const res = injectFilter(injectFilterEntries)
+    assertUsage(
+      res === undefined,
+      `injectFilter() should return ${pc.cyan("undefined")}, see https://reveal.dev/injectFilter`
+    )
+    assertInjectFilterUsage(injectFilterEntries)
+  }
+
+  const htmlTags: HtmlTag[] = []
+
+  // ==============
+  // Non-JavaScript
+  // ==============
+  injectFilterEntries
+    .filter((asset) => asset.assetType !== "script" && asset.inject)
+    .forEach((asset) => {
+      if (!asset.inject) return
+      const htmlTag = asset.isEntry
+        ? inferAssetTag(asset)
+        : inferPreloadTag(asset)
+      htmlTags.push({ htmlTag, position: asset.inject })
+    })
+
+  // ==========
+  // JavaScript
+  // ==========
+  // - By default, we place the entry <script> towards the end of the HTML for better performance.
+  //   - Performance-wise, it's more interesting to start showing the page (parse HTML and load CSS) before starting loading scripts.
+  //   - But with HTML streaming, in order to support [Progressive Rendering](https://reveal.dev/streaming#progressive-rendering), the entry <script> should be injected earlier instead.
+  // - The entry <script> shouldn't be `<script defer>` upon HTML streaming, otherwise progressive hydration while SSR streaming won't work.
+  // - `<script id="reveal_pageContext" type="application/json">` (the `pageContext` JSON) should be fully sent before reveal's client runtime starts executing.
+  //   - Otherwise, race condition "SyntaxError: Unterminated string in JSON": https://github.com/revealjs/reveal/issues/567
+  //   - `<script id="reveal_pageContext" type="application/json">` must appear before the entry <script> (which loads reveal's client runtime).
+  //   - `<script id="reveal_pageContext" type="application/json">` can't be async nor defer.
+  const positionJavaScriptDefault = "HTML_END"
+  const positionJavaScriptEntry = (() => {
+    if (injectScriptsAt !== null) {
+      if (pageContext._pageContextPromise) {
+        assertWarning(
+          injectScriptsAt === "HTML_END" || !isStream,
+          `You're setting injectScriptsAt to ${pc.code(
+            JSON.stringify(injectScriptsAt)
+          )} while using HTML streaming with a pageContext promise (https://reveal.dev/streaming#initial-data-after-stream-end) which is contradictory: the pageContext promise is skipped.`,
+          { onlyOnce: true }
+        )
+      }
+      if (injectScriptsAt === "HTML_STREAM" && !isStream) {
+        return positionJavaScriptDefault
+      }
+      return injectScriptsAt
+    }
+    if (pageContext._pageContextPromise) {
+      // - If there is a pageContext._pageContextPromise then <script id="reveal_pageContext" type="application/json"> needs to await for it.
+      // - pageContext._pageContextPromise is typically resolved only after the page's components are rendered and the stream ended.
+      // - https://reveal.dev/streaming#initial-data-after-stream-end
+      return positionJavaScriptDefault
+    }
+    if (
+      streamFromReactStreamingPackage &&
+      !streamFromReactStreamingPackage.hasStreamEnded()
+    ) {
+      // If there is a stream then, in order to support progressive hydration, inject the JavaScript during the stream after React(/Vue/Solid/...) resolved the first suspense boundary.
+      return "HTML_STREAM"
+    }
+    return positionJavaScriptDefault
+  })()
+  if (pageContext._pageContextPromise && streamFromReactStreamingPackage) {
+    assertWarning(
+      false,
+      "We recommend against using HTML streaming and a pageContext promise (https://reveal.dev/streaming#initial-data-after-stream-end) at the same time, because progressive hydration (https://reveal.dev/streaming#progressive-rendering) won't work.",
+      { onlyOnce: true }
+    )
+  }
+  // <script id="reveal_pageContext" type="application/json">
+  if (!isHtmlOnly) {
+    htmlTags.push({
+      htmlTag: () =>
+        // Needs to be called after resolvePageContextPromise()
+        getPageContextJsonScriptTag(pageContext),
+      position: positionJavaScriptEntry,
+    })
+  }
+  // The JavaScript entry <script> tag
+  const scriptEntry = mergeScriptEntries(pageAssets, viteDevScript)
+  if (scriptEntry) {
+    htmlTags.push({
+      htmlTag: scriptEntry,
+      position: positionJavaScriptEntry,
+    })
+  }
+  // Preload tags
+  injectFilterEntries
+    .filter((asset) => asset.assetType === "script")
+    .forEach((asset) => {
+      assert(!asset.isEntry) // Users cannot re-order JavaScript entries, see creation of injectFilterEntries
+      const htmlTag = inferPreloadTag(asset)
+      if (!asset.inject) return
+      // Ideally, instead of this conditional ternary operator, we should add HTML_STREAM to PreloadFilterInject
+      const position =
+        asset.inject === "HTML_END" ? positionJavaScriptEntry : asset.inject
+      htmlTags.push({ htmlTag, position })
+    })
+
+  return htmlTags
+}
+
+function mergeScriptEntries(
+  pageAssets: PageAsset[],
+  viteDevScript: string
+): null | string {
+  const scriptEntries = pageAssets.filter(
+    (pageAsset) => pageAsset.isEntry && pageAsset.assetType === "script"
+  )
+  const scriptTagsHtml = `${viteDevScript}${scriptEntries.map((asset) => inferAssetTag(asset)).join("")}`
+  const scriptTag = mergeScriptTags(scriptTagsHtml)
+  return scriptTag
+}
+
+function getPageContextJsonScriptTag(
+  pageContext: PageContextSerialization
+): string {
+  const pageContextSerialized = sanitizeJson(
+    serializePageContextClientSide(pageContext)
+  )
+  const htmlTag = `<script id="reveal_pageContext" type="application/json">${pageContextSerialized}</script>`
+
+  // Used by contra.com https://github.com/gajus
+  // @ts-expect-error
+  pageContext._pageContextHtmlTag = htmlTag
+
+  return htmlTag
+}
+
+function assertInjectFilterEntries(injectFilterEntries: InjectFilterEntry[]) {
+  try {
+    checkForWrongUsage(injectFilterEntries)
+  } catch (err) {
+    if (
+      (err as undefined | { message: string })?.message.includes(
+        "[Wrong Usage]"
+      )
+    ) {
+      assert(false)
+    }
+    throw err
+  }
+}
+
+function assertInjectFilterUsage(injectFilterEntries: InjectFilterEntry[]) {
+  checkForWrongUsage(injectFilterEntries)
+  checkForWarnings(injectFilterEntries)
+}
+function checkForWrongUsage(injectFilterEntries: InjectFilterEntry[]) {
+  injectFilterEntries.forEach((entry, i) => {
+    assertUsage(isObject(entry), `[injectFilter()] Entry ${i} isn't an object`)
+    assertUsage(
+      typeof entry.src === "string",
+      `[injectFilter()] Entry ${i} is missing property ${pc.cyan("src")}`
+    )
+    assertUsage(
+      (entry as Record<string, unknown>)[stamp] === true,
+      `[injectFilter()] Entry ${i} (${entry.src}) isn't the original object, see https://reveal.dev/injectFilter`
+    )
+    assert([false, "HTML_BEGIN", "HTML_END"].includes(entry.inject))
+    assert(entry.assetType === null || typeof entry.assetType === "string")
+    assert(entry.mediaType === null || typeof entry.mediaType === "string")
+    assert(typeof entry.isEntry === "boolean")
+    assert(Object.keys(entry).length === 6)
+  })
+}
+function checkForWarnings(injectFilterEntries: InjectFilterEntry[]) {
+  injectFilterEntries.forEach((a) => {
+    /*
+    if (a.assetType === 'script' && a.isEntry) {
+      assertUsage(a.inject, `[injectFilter()] ${a.src} needs to be injected`)
+    }
+    */
+    if (a.assetType === "style" && a.isEntry) {
+      // In development, Vite automatically inject styles, but we still inject `<link rel="stylesheet" type="text/css" href="${src}">` tags in order to avoid FOUC (flash of unstyled content).
+      //  - https://github.com/vitejs/vite/issues/2282
+      //  - https://github.com/revealjs/reveal/issues/261
+      assertWarning(
+        a.inject,
+        `[injectFilter()] We recommend against not injecting ${a.src}`,
+        {
+          onlyOnce: true,
+        }
+      )
+    }
+    if (a.assetType === "script") {
+      assertWarning(
+        a.inject,
+        `[injectFilter()] We recommend against not preloading JavaScript (${a.src})`,
+        {
+          onlyOnce: true,
+        }
+      )
+    }
+  })
+}
+function getInjectScriptsAt(
+  pageId: string,
+  pageConfigs: PageConfigRuntime[]
+): null | Position {
+  if (pageConfigs.length === 0) return null // only support V1 design
+  const pageConfig = getPageConfig(pageId, pageConfigs)
+  const configValue = getConfigValueRuntime(pageConfig, "injectScriptsAt")
+  if (!configValue) return null
+  const injectScriptsAt = configValue.value
+  assert(configValue.definedAtData)
+  const configDefinedAt = getConfigDefinedAt(
+    "Config",
+    "injectScriptsAt",
+    configValue.definedAtData
+  )
+  assertUsage(
+    injectScriptsAt === null ||
+      injectScriptsAt === "HTML_BEGIN" ||
+      injectScriptsAt === "HTML_END" ||
+      injectScriptsAt === "HTML_STREAM",
+    `${configDefinedAt} has an invalid value`
+  )
+  return injectScriptsAt
+}

package/dist/core/processing/getters/getHttpRequestAsyncStore.ts

@@ -0,0 +1,122 @@
+// Purpose of this file:
+//  - Swallow redundant error messages (Vite is buggy and emits the same error multiple times)
+//  - Prepend "[request(n)]" tag to Vite logs
+
+// The mechanism is skipped if the runtime doesn't support Async Hooks:
+//  - Bun doesn't support Async Hooks: https://github.com/oven-sh/bun/issues/1832
+//  - Node.js and Deno support Async Hooks
+
+// We purposely don't use config.logger.hasErrorLogged(err) because:
+// - We don't trust Vite with such details
+//   - Example of Vite bug leading to swallowing of errors: https://github.com/vitejs/vite/issues/12631
+// - We dedupe errors ourself with getHttpRequestAsyncStore().shouldErrorBeSwallowed()
+
+export { getHttpRequestAsyncStore, installHttpRequestAsyncStore };
+
+import type { AsyncLocalStorage as AsyncLocalStorageType } from "node:async_hooks";
+import { isDeepStrictEqual } from "node:util";
+import {
+  assert,
+  assertIsNotProductionRuntime,
+  isObject,
+  unique,
+} from "../../../plugins/utils.js";
+import { isEquivalentErrorWithCodeSnippet } from "../../gaurds/logger/loggerNotProd/errorWithCodeSnippet.js";
+import { getConfigBuildErrorFormatted } from "./getRevealConfig/transpileAndExecuteFile.js";
+import { renderPage_addWrapper } from "../../renderer/page/index.js";
+import { logErrorDebugNote } from "../../gaurds/logger/loggerNotProd.js";
+
+assertIsNotProductionRuntime();
+
+type HttpRequestAsyncStore = {
+  httpRequestId: number;
+  // Error swallowing mechanism
+  shouldErrorBeSwallowed: (err: unknown) => boolean;
+  markErrorAsLogged: (err: unknown) => void;
+  errorDebugNoteAlreadyShown: boolean;
+};
+let asyncLocalStorage: null | AsyncLocalStorageType<HttpRequestAsyncStore> =
+  null;
+
+async function installHttpRequestAsyncStore(): Promise<void> {
+  let mod: typeof import("node:async_hooks");
+  try {
+    mod = await import("node:async_hooks");
+  } catch {
+    return;
+  }
+  asyncLocalStorage = new mod.AsyncLocalStorage();
+  renderPage_addWrapper(async (httpRequestId, renderPage) => {
+    assert(asyncLocalStorage);
+
+    const loggedErrors = new Set<unknown>();
+    const markErrorAsLogged = (err: unknown) => {
+      loggedErrors.add(err);
+    };
+
+    const shouldErrorBeSwallowed = (err: unknown) => {
+      if (
+        loggedErrors.has(err) ||
+        Array.from(loggedErrors).some((errAlreadyLogged) =>
+          isEquivalent(err, errAlreadyLogged),
+        )
+      ) {
+        // In principle, some random message can be shown between the non-swallowed error and this logErrorDebugNote() call.
+        // We take a leap of faith that it happens only seldomly and that it's worth the risk.
+        logErrorDebugNote();
+        return true;
+      } else {
+        return false;
+      }
+    };
+
+    const store = {
+      httpRequestId,
+      markErrorAsLogged,
+      shouldErrorBeSwallowed,
+      errorDebugNoteAlreadyShown: false,
+    };
+    const pageContextReturn = await asyncLocalStorage.run(store, renderPage);
+    return { pageContextReturn };
+  });
+  return;
+}
+
+function getHttpRequestAsyncStore(): null | undefined | HttpRequestAsyncStore {
+  if (asyncLocalStorage === null) return null;
+  const store = asyncLocalStorage.getStore();
+  assert(store === undefined || isObject(store));
+  return store;
+}
+
+function isEquivalent(err1: unknown, err2: unknown) {
+  if (err1 === err2) return true;
+  if (!isObject(err1) || !isObject(err2)) return false;
+
+  {
+    const errMsgFormatted1 = getConfigBuildErrorFormatted(err1);
+    const errMsgFormatted2 = getConfigBuildErrorFormatted(err2);
+    if (errMsgFormatted1 && errMsgFormatted1 === errMsgFormatted2) return true;
+  }
+
+  if (isEquivalentErrorWithCodeSnippet(err1, err2)) return true;
+
+  if (
+    unique([
+      // error.message and error.stack aren't enumerable and therefore not listed by Object.keys()
+      "message",
+      "stack",
+      ...Object.keys(err1),
+      ...Object.keys(err2),
+    ]).every((k) => {
+      // isDeepStrictEqual() need to compare error.position wich is an object.
+      if (isDeepStrictEqual(err1[k], err2[k])) return true;
+      // console.log('diff', k)
+      return false;
+    })
+  ) {
+    return true;
+  }
+
+  return false;
+}

package/dist/core/processing/getters/getHttpResponseBody.ts

@@ -0,0 +1,177 @@
+export { getHttpResponseBody, getHttpResponseBodyStreamHandlers }
+export type { HttpResponseBody }
+
+import pc from "@brillout/picocolors"
+import { RenderHook } from "../../renderer/page/executeOnRenderHtmlHook.js"
+import { getHtmlString, type HtmlRender } from "../../renderer/stream/html.js"
+import {
+  StreamReadableNode,
+  StreamReadableWeb,
+  StreamWritableNode,
+  StreamWritableWeb,
+  getStreamName,
+  getStreamReadableNode,
+  getStreamReadableWeb,
+  inferStreamName,
+  isStream,
+  isStreamPipeNode,
+  isStreamPipeWeb,
+  isStreamReadableNode,
+  isStreamReadableWeb,
+  isStreamWritableNode,
+  isStreamWritableWeb,
+  pipeToStreamWritableNode,
+  pipeToStreamWritableWeb,
+} from "../../renderer/stream/index.js"
+import { assert, assertUsage } from "../../renderer/stream/utils.js"
+
+const streamDocs = "See https://reveal.dev/streaming for more information."
+
+type HttpResponseBody = {
+  body: string
+  pipe: (writable: StreamWritableWeb | StreamWritableNode) => void
+  getReadableWebStream: () => StreamReadableWeb
+  getReadableNodeStream: () => Promise<StreamReadableNode>
+  getBody: () => Promise<string>
+}
+
+function getHttpResponseBody(
+  htmlRender: HtmlRender,
+  renderHook: null | RenderHook
+) {
+  if (typeof htmlRender !== "string") {
+    assertUsage(
+      false,
+      getErrMsg(
+        htmlRender,
+        renderHook,
+        "body",
+        `Use ${pc.cyan("pageContext.httpResponse.pipe()")} instead`
+      )
+    )
+  }
+  const body = htmlRender
+  return body
+}
+
+function getHttpResponseBodyStreamHandlers(
+  htmlRender: HtmlRender,
+  renderHook: null | RenderHook
+) {
+  return {
+    pipe(writable: StreamWritableNode | StreamWritableWeb) {
+      const getErrMsgMixingStreamTypes = (
+        writableType: "Web Writable" | "Node.js Writable"
+      ) =>
+        `The ${getErrMsgBody(htmlRender, renderHook)} while a ${
+          writableType as string
+        } was passed to pageContext.httpResponse.pipe() which is contradictory. You cannot mix a Web Stream with a Node.js Stream.` as const
+      if (isStreamWritableWeb(writable)) {
+        const success = pipeToStreamWritableWeb(htmlRender, writable)
+        if (success) {
+          return
+        } else {
+          assert(
+            isStreamReadableNode(htmlRender) || isStreamPipeNode(htmlRender)
+          )
+          assertUsage(false, getErrMsgMixingStreamTypes("Web Writable"))
+        }
+      }
+      if (isStreamWritableNode(writable)) {
+        const success = pipeToStreamWritableNode(htmlRender, writable)
+        if (success) {
+          return
+        } else {
+          assert(isStreamReadableWeb(htmlRender) || isStreamPipeWeb(htmlRender))
+          assertUsage(false, getErrMsgMixingStreamTypes("Node.js Writable"))
+        }
+      }
+      assertUsage(
+        false,
+        `The argument ${pc.cyan("writable")} passed to ${pc.cyan(
+          "pageContext.httpResponse.pipe(writable)"
+        )} doesn't seem to be ${getStreamName("writable", "web")} nor ${getStreamName("writable", "node")}.`
+      )
+    },
+    getReadableWebStream() {
+      const webStream = getStreamReadableWeb(htmlRender)
+      if (webStream === null) {
+        assertUsage(
+          false,
+          getErrMsg(
+            htmlRender,
+            renderHook,
+            "getReadableWebStream()",
+            getFixMsg("readable", "web")
+          )
+        )
+      }
+      return webStream
+    },
+    async getReadableNodeStream() {
+      const nodeStream = await getStreamReadableNode(htmlRender)
+      if (nodeStream === null) {
+        assertUsage(
+          false,
+          getErrMsg(
+            htmlRender,
+            renderHook,
+            "getReadableNodeStream()",
+            getFixMsg("readable", "node")
+          )
+        )
+      }
+      return nodeStream
+    },
+    async getBody(): Promise<string> {
+      const body = await getHtmlString(htmlRender)
+      return body
+    },
+  }
+
+  function getFixMsg(kind: "pipe" | "readable", type: "web" | "node") {
+    const streamName = getStreamName(kind, type)
+    assert(["a ", "an ", "the "].some((s) => streamName.startsWith(s)))
+    assert(renderHook)
+    const { hookFilePath, hookName } = renderHook
+    return `Make sure the ${hookName}() defined by ${hookFilePath} hook provides ${streamName} instead`
+  }
+}
+
+function getErrMsg(
+  htmlRender: HtmlRender,
+  renderHook: null | RenderHook,
+  method: string,
+  msgAddendum?: string
+) {
+  assert(!msgAddendum || !msgAddendum.endsWith("."))
+  const errMsgBody = getErrMsgBody(htmlRender, renderHook)
+  return [
+    `pageContext.httpResponse.${method} can't be used because the ${errMsgBody}`,
+    msgAddendum,
+    streamDocs,
+  ]
+    .filter(Boolean)
+    .join(". ")
+}
+function getErrMsgBody(htmlRender: HtmlRender, renderHook: null | RenderHook) {
+  assert(renderHook)
+  const { hookFilePath, hookName } = renderHook
+  const hookReturnType = getHookReturnType(htmlRender)
+  assert(["a ", "an ", "the "].some((s) => hookReturnType.startsWith(s)))
+  const errMsgBody =
+    `${hookName as string}()\ hook defined by ${hookFilePath} provides ${
+      hookReturnType as string
+    }` as const
+  assert(!errMsgBody.endsWith(" "))
+  return errMsgBody
+}
+function getHookReturnType(htmlRender: HtmlRender) {
+  if (typeof htmlRender === "string") {
+    return "an HTML string"
+  } else if (isStream(htmlRender)) {
+    return inferStreamName(htmlRender)
+  } else {
+    assert(false)
+  }
+}