@revealui/core 0.0.1-pre.0

package/dist/core/gaurds/assertions/assertIsNotBrowser/base.ts

@@ -0,0 +1,9 @@
+import { isBrowser } from "../../validators/isBrowser";
+import { assert } from "../assert/base";
+
+export { assertIsNotBrowser };
+
+/** Ensure we don't bloat the client-side */
+function assertIsNotBrowser() {
+  assert(!isBrowser());
+}

package/dist/core/gaurds/assertions/assertIsNotBrowser/index.ts

@@ -0,0 +1 @@
+export * from "./base.js";

package/dist/core/gaurds/assertions/assertIsNotProductionRuntime/base.ts

@@ -0,0 +1,71 @@
+// Mechanism to ensure code isn't loaded by production runtime
+
+import getGlobalObject from "../../../processing/getters/getGlobalObject";
+import { createDebugger } from "../../debugger";
+import { isVitest } from "../../validators/isVitest";
+import { assert } from "../assert/base";
+import { assertIsNotBrowser } from "../assertIsNotBrowser";
+import { assertUsage } from "../assertUsage";
+
+export {
+  assertEnv,
+  assertIsNotProductionRuntime,
+  markEnvAsRevealPluginLoaded,
+  markEnvAsViteDev,
+  markEnvAsVitePreview,
+  revealVitePluginLoadedInProductionError,
+};
+
+assertIsNotBrowser();
+const debug = createDebugger("reveal:setup");
+const revealVitePluginLoadedInProductionError = `Loading Reveal's Vite plugin (the reveal/plugin module) is prohibited in production.`;
+
+const env = getGlobalObject<{
+  shouldNotBeProduction?: true;
+  isViteDev?: true;
+  isVitePreview?: true;
+  isRevealPluginLoaded?: true;
+}>("utils/assertIsNotProductionRuntime.ts", {});
+
+// Called by Reveal modules that want to ensure that they aren't loaded by the server runtime in production
+function assertIsNotProductionRuntime(): void | undefined {
+  if (debug.isActivated)
+    debug("assertIsNotProductionRuntime()", new Error().stack);
+  env.shouldNotBeProduction = true;
+}
+
+// Called by Vite hook configureServer()
+function markEnvAsViteDev(): void | undefined {
+  if (debug.isActivated) debug("markEnvAsViteDev()", new Error().stack);
+  env.isViteDev = true;
+}
+// Called by Vite hook configurePreviewServer()
+function markEnvAsVitePreview(): void | undefined {
+  if (debug.isActivated) debug("markEnvAsVitePreview()", new Error().stack);
+  env.isVitePreview = true;
+}
+// Called by ../node/plugin/index.ts
+function markEnvAsRevealPluginLoaded() {
+  if (debug.isActivated)
+    debug("markEnvAsRevealPluginLoaded()", new Error().stack);
+  env.isRevealPluginLoaded = true;
+}
+// Called by ../node/runtime/index.ts
+function assertEnv(): void | undefined {
+  if (debug.isActivated) debug("assertEnv()", new Error().stack);
+  if (isVitest()) return;
+  const isProduction = !env.isViteDev && !env.isVitePreview;
+  if (isProduction) {
+    // Seems to be the only reliable way to assert that the user doesn't load Reveal's Vite plugin in production. (The other assert() that uses process.env.NODE_ENV doesn't work if the user sets the process.env.NODE_ENV value later.)
+    assertUsage(
+      !env.isRevealPluginLoaded,
+      revealVitePluginLoadedInProductionError,
+    );
+    // This assert() is the main goal of this file: it ensures assertIsNotProductionRuntime()
+    assert(!env.shouldNotBeProduction);
+  } else {
+    // This assert() is obious and boring
+    assert(env.shouldNotBeProduction);
+    assert(env.isRevealPluginLoaded);
+  }
+}

package/dist/core/gaurds/assertions/assertIsNotProductionRuntime/index.ts

@@ -0,0 +1 @@
+export * from "./base.js";

package/dist/core/gaurds/assertions/assertKeys/base.ts

@@ -0,0 +1,31 @@
+export { assertKeys };
+
+import pc from "@brillout/picocolors";
+import { joinEnglish } from "../../../utils/string/joinEnglish";
+import { assertUsage } from "../assertUsage";
+
+function assertKeys<Keys extends readonly string[]>(
+  obj: Record<string, unknown>,
+  keysExpected: Keys,
+  errPrefix: string,
+): asserts obj is { [key in Keys[number]]?: unknown } {
+  const keysUnknown: string[] = [];
+  const keys = Object.keys(obj);
+  for (const key of keys) {
+    if (!keysExpected.includes(key)) {
+      keysUnknown.push(key);
+    }
+  }
+  if (keysUnknown.length !== 0) {
+    assertUsage(
+      false,
+      [
+        errPrefix,
+        `unknown key${keysUnknown.length === 1 ? "" : "s"}`,
+        joinEnglish(keysUnknown, "and", pc.cyan) + ".",
+        "Only following keys are allowed:",
+        joinEnglish(keysExpected, "and", pc.cyan) + ".",
+      ].join(" "),
+    );
+  }
+}

package/dist/core/gaurds/assertions/assertKeys/index.ts

@@ -0,0 +1 @@
+export * from "./base.js";

package/dist/core/gaurds/assertions/assertNoInfiniteHttpRedirect.ts

@@ -0,0 +1,55 @@
+export { assertNoInfiniteHttpRedirect };
+
+import pc from "@brillout/picocolors";
+import { assert, assertUsage } from "../../renderer/stream/utils.js";
+import getGlobalObject from "../../processing/getters/getGlobalObject.js";
+
+type Graph = Record<string, Set<string>>;
+const globalObject = getGlobalObject<{ redirectGraph: Graph }>(
+  "assertNoInfiniteHttpRedirect.ts",
+  {
+    redirectGraph: {},
+  },
+);
+
+function assertNoInfiniteHttpRedirect(
+  urlRedirectTarget: string,
+  urlLogical: string,
+) {
+  if (!urlRedirectTarget.startsWith("/")) {
+    // We assume that urlRedirectTarget points to an origin that is external (not the same origin), and we can therefore assume that the app doesn't define an infinite loop (in itself).
+    //  - There isn't a reliable way to check whether the redirect points to an external origin or the same origin. For same origins, we assume/hope the user to pass the URL without origin.
+    //    ```js
+    //    // For same-origin, the user usually/hopefully passes a URL without origin
+    //    renderPage({ urlOriginal: '/some/pathname' })
+    //    ```
+    return;
+  }
+  assert(urlLogical.startsWith("/"));
+  const graph = copy(globalObject.redirectGraph);
+  graph[urlRedirectTarget] ??= new Set();
+  graph[urlRedirectTarget]!.add(urlLogical);
+  validate(graph);
+  globalObject.redirectGraph = graph;
+}
+
+function copy(G: Graph): Graph {
+  return Object.fromEntries(
+    Object.entries(G).map(([key, val]) => [key, new Set(val)]),
+  );
+}
+
+// Adapted from: https://stackoverflow.com/questions/60904464/detect-cycle-in-directed-graph/60907076#60907076
+function validate(G: Graph) {
+  Object.keys(G).forEach((n) => check(G, n, []));
+}
+function check(G: Graph, n: string, path: string[]) {
+  if (path.includes(n)) {
+    const cycle = path.slice(path.indexOf(n)).concat(n);
+    assertUsage(
+      false,
+      `Infinite loop of HTTP URL redirects: ${cycle.map(pc.cyan).join(" -> ")}`,
+    );
+  }
+  G[n]?.forEach((node) => check(G, node, [...path, n]));
+}

package/dist/core/gaurds/assertions/assertNodeEnv/base.ts

@@ -0,0 +1,120 @@
+// This file serves the following three purposes:
+//   1. Upon building the app, we ensure the right NODE_ENV value is set.
+//      - Both Vue and React use NODE_ENV for enabling production-specific features:
+//        - Vue: https://github.com/vuejs/core/blob/f66a75ea75c8aece065b61e2126b4c5b2338aa6e/packages/vue/index.js
+//        - React: https://github.com/facebook/react/blob/01ab35a9a731dec69995fbd28f3ac7eaad11e183/packages/react/npm/index.js
+//      - Setting NODE_ENV to 'production' doesn't seem to make any sense in development.
+//      - With React upon building the app, setting NODE_ENV to a value other than 'production' triggers an error: https://github.com/revealjs/reveal/issues/1469#issuecomment-1969301797
+//      - With Vue upon building the app, NODE_ENV can be set to a value other than 'production', e.g. 'development'.
+//   2. Ensure Vite isn't loaded in production.
+//      - We currently only check whether Vite's development middleware is instantiated (i.e. whether Vite's `createServer()` was called). Is there a way to detect whether Vite's code is loaded?
+//   3. Ensure NODE_ENV isn't mistakenly set to a wrong value.
+
+// TODO: to fully implement the aforementioned points we need to implement a [new setting `allowNodeEnv`](https://github.com/revealjs/reveal/issues/1528)
+
+export {
+  assertNodeEnv_build,
+  assertNodeEnv_onRevealPluginLoad,
+  assertNodeEnv_runtime,
+}
+// Vite already handles build
+export { handleNodeEnv_prerender, handleNodeEnv_vitePluginVercel }
+
+import pc from "@brillout/picocolors"
+import { assertIsNotBrowser } from "../assertIsNotBrowser"
+import { revealVitePluginLoadedInProductionError } from "../assertIsNotProductionRuntime"
+import { assertWarning } from "../assertWarning"
+
+assertIsNotBrowser()
+
+function assertNodeEnv_build() {
+  assertNodeEnvIsNotDev("building")
+}
+
+function assertNodeEnv_runtime(isViteDev: boolean) {
+  const nodeEnv = getNodeEnv()
+  if (nodeEnv === null || nodeEnv === "test") return
+  const isNodeDev = isNodeEnvDev()
+  // Calling Vite's createServer() is enough for hasViteDevServer to be true, even without actually adding Vite's development middleware to the server: https://github.com/revealjs/reveal/issues/792#issuecomment-1516830759
+  if (isViteDev === isNodeDev) return
+  const nodeEnvDesc = getNodeEnvDesc()
+  // TODO: make it assertUsage() again once #1528 is implemented.
+  const errMsg = `Running ${
+    isViteDev ? pc.cyan("$ vite dev") : "app in production"
+  } while the ${nodeEnvDesc} which is contradictory, see https://reveal.dev/NODE_ENV` as const
+  assertWarning(false, errMsg, { onlyOnce: true })
+}
+
+function assertNodeEnv_onRevealPluginLoad() {
+  const nodeEnv = getNodeEnv()
+  if (nodeEnv === "test") return
+  // TODO: make it assertUsage() again once #1528 is implemented.
+  assertWarning(
+    /* We can enable this assertion after reveal's CLI is implemented and using Vite's CLI is deprecated (we can then check whether the context is a `$ reveal build`).
+    isNodeEnvDev() || isrevealCliBuild(),
+    /*/
+    isNodeEnvDev() || (true as boolean),
+    ///*/
+    [
+      pc.cyan(`process.env.NODE_ENV === ${JSON.stringify(nodeEnv)}`),
+      "(which reveal interprets as a non-development environment https://reveal.dev/NODE_ENV)",
+      "while the reveal/plugin module is loaded.",
+      revealVitePluginLoadedInProductionError,
+    ].join(" "),
+    { onlyOnce: true }
+  )
+}
+
+function handleNodeEnv_prerender() {
+  const assertNodeEnv = () => assertNodeEnvIsNotDev("pre-rendering")
+  if (getNodeEnv()) assertNodeEnv()
+  setNodeEnvToProduction()
+  assertNodeEnv()
+}
+
+function handleNodeEnv_vitePluginVercel() {
+  setNodeEnvToProduction()
+}
+
+function getNodeEnv(): null | undefined | string {
+  if (typeof process === "undefined") return null
+  return process.env.NODE_ENV
+}
+
+function setNodeEnvToProduction(): void | undefined {
+  // The statement `process.env['NODE_ENV'] = 'production'` chokes webpack v4
+  const proc = process
+  const { env } = proc
+  env.NODE_ENV = "production"
+}
+
+function isNodeEnvDev(): boolean {
+  const nodeEnv = getNodeEnv()
+  if (!nodeEnv) return true
+  if (["development", "dev"].includes(nodeEnv)) return true
+  // That's quite aggressive, let's see if some user complains
+  return false
+}
+
+function getNodeEnvDesc(): `environment is set to be a ${string} environment by process.env.NODE_ENV === ${string}` {
+  const nodeEnv = getNodeEnv()
+  const isDev = isNodeEnvDev()
+  const nodeEnvDesc = `environment is set to be a ${
+    (isDev ? "development" : "production") as string
+  } environment by ${pc.cyan(`process.env.NODE_ENV === ${JSON.stringify(nodeEnv)}`)}` as const
+  return nodeEnvDesc
+}
+
+function assertNodeEnvIsNotDev(operation: "building" | "pre-rendering") {
+  const isDev = isNodeEnvDev()
+  if (!isDev) return
+  const nodeEnvDesc = getNodeEnvDesc()
+  // TODO: make it assertUsage() again once #1528 is implemented.
+  assertWarning(
+    false,
+    `The ${nodeEnvDesc} which is forbidden upon ${operation}, see https://reveal.dev/NODE_ENV`,
+    {
+      onlyOnce: true,
+    }
+  )
+}

package/dist/core/gaurds/assertions/assertNodeEnv/index.ts

@@ -0,0 +1 @@
+export * from "./base.js";

package/dist/core/gaurds/assertions/assertNodeVersion/base.ts

@@ -0,0 +1,11 @@
+import { isNodeJS } from "../../validators/isNodeJS";
+import { assertVersion } from "../assertVersion";
+
+export { assertNodeVersion };
+
+// node_modules/reveal/package.json#engines.node isn't enough as users can ignore it
+function assertNodeVersion() {
+	if (!isNodeJS()) return;
+	const version = process.versions.node;
+	assertVersion("Node.js", version, "22.0.0");
+}

package/dist/core/gaurds/assertions/assertNodeVersion/index.ts

@@ -0,0 +1 @@
+export * from "./base";

package/dist/core/gaurds/assertions/assertOnBeforeRenderHookReturn.ts

@@ -0,0 +1,37 @@
+export { assertOnBeforeRenderHookReturn };
+
+import pc from "@brillout/picocolors";
+
+import { assertHookReturnedObject } from "./assertHookReturnedObject.js";
+import { assertPageContextProvidedByUser } from "./assertPageContextProvidedByUser.js";
+import { assertUsage } from "./assertUsage/base.js";
+import { isPlainObject } from "../validators/isPlainObject.js";
+
+function assertOnBeforeRenderHookReturn<Keys extends readonly string[]>(
+  hookReturnValue: unknown,
+  hookFilePath: string,
+): asserts hookReturnValue is
+  | undefined
+  | null
+  | { [key in Keys[number]]?: unknown } {
+  if (hookReturnValue === undefined || hookReturnValue === null) {
+    return;
+  }
+  const errPrefix =
+    `The onBeforeRender() hook defined by ${hookFilePath}` as const;
+  assertUsage(
+    isPlainObject(hookReturnValue),
+    `${errPrefix} should return a plain JavaScript object, ${pc.cyan("undefined")}, or ${pc.cyan("null")}`,
+  );
+  assertHookReturnedObject(
+    hookReturnValue,
+    ["pageContext"] as const,
+    errPrefix,
+  );
+  if (hookReturnValue.pageContext) {
+    assertPageContextProvidedByUser(hookReturnValue["pageContext"], {
+      hookName: "onBeforeRender",
+      hookFilePath,
+    });
+  }
+}

package/dist/core/gaurds/assertions/assertPageContextProvidedByUser.ts

@@ -0,0 +1,60 @@
+export { assertPageContextProvidedByUser }
+
+import pc from "@brillout/picocolors"
+import { isObject } from "../validators/isObject"
+import { assert } from "./assert"
+import { assertUsage } from "./assertUsage"
+import { assertWarning } from "./assertWarning"
+
+function assertPageContextProvidedByUser(
+  pageContextProvidedByUser: unknown,
+  {
+    hookName,
+    hookFilePath,
+  }: {
+    hookFilePath: string
+    hookName: "onBeforeRender" | "onRenderHtml" | "onBeforeRoute"
+  }
+): asserts pageContextProvidedByUser is Record<string, unknown> {
+  if (
+    pageContextProvidedByUser === undefined ||
+    pageContextProvidedByUser === null
+  )
+    return
+
+  assert(!hookName.endsWith(")"))
+  const errPrefix = `The ${pc.cyan("pageContext")} object provided by the ${
+    hookName as string
+  }() hook defined by ${hookFilePath}` as const
+
+  assertUsage(
+    isObject(pageContextProvidedByUser),
+    `${errPrefix} should be an object (but it's ${pc.cyan(
+      `typeof pageContext === ${JSON.stringify(typeof pageContextProvidedByUser)}`
+    )} instead)`
+  )
+
+  assertUsage(
+    !("_objectCreatedByReveal" in pageContextProvidedByUser),
+    `${errPrefix} shouldn't be the whole ${pc.cyan(
+      "pageContext"
+    )} object, see https://reveal.dev/pageContext-manipulation#do-not-return-entire-pagecontext`
+  )
+
+  // In principle, it's possible to use onBeforeRoute()` to override and define the whole routing.
+  // Is that a good idea to allow users to do this? Beyond deep integration with Vue Router or React Router, is there a use case for this?
+  assertWarning(
+    !("pageId" in pageContextProvidedByUser),
+    `${errPrefix} sets ${pc.cyan(
+      "pageContext.pageId"
+    )} which means that Reveal's routing is overriden. This is an experimental feature: make sure to contact a Reveal maintainer before using this.`,
+    { onlyOnce: true }
+  )
+
+  assertUsage(
+    !("is404" in pageContextProvidedByUser),
+    `${errPrefix} sets ${pc.cyan("pageContext.is404")} which is forbidden, use ${pc.cyan(
+      "throw render()"
+    )} instead, see https://reveal.dev/render`
+  )
+}

package/dist/core/gaurds/assertions/assertPluginManifest.ts

@@ -0,0 +1,41 @@
+export { assertPluginManifest }
+export type { PluginManifest }
+
+import { projectInfo } from "../../globals/versions/projectInfo.js"
+import { hasProp } from "../validators/hasProp.js"
+import { isPlainObject } from "../validators/isPlainObject.js"
+import { assert } from "./assert/index.js"
+import { assertRuntimeManifest } from "./assertRuntimeManifest.js"
+import { assertUsage } from "./assertUsage/index.js"
+import { checkType } from "./checkType.js"
+
+type PluginManifest = {
+  version: string
+  baseServer: string
+  baseAssets: string | null
+  usesClientRouter: boolean
+  includeAssetsImportedByServer: boolean
+  redirects: Record<string, string>
+  trailingSlash: boolean
+  disableUrlNormalization: boolean
+}
+function assertPluginManifest(
+  pluginManifest: unknown
+): asserts pluginManifest is PluginManifest {
+  assert(isPlainObject(pluginManifest))
+  assertUsage(
+    pluginManifest.version === projectInfo.projectVersion,
+    `Re-build your app (you're using reveal@${projectInfo.projectVersion} but your app was built with reveal@${pluginManifest.version})`
+  )
+  assertRuntimeManifest(pluginManifest)
+  assert(hasProp(pluginManifest, "usesClientRouter", "boolean"))
+  assert(hasProp(pluginManifest, "version", "string"))
+  // Avoid:
+  // ```
+  // Uncaught (in promise) TypeError: Cannot set property manifestKeyMap of #<Object> which has only a getter
+  // ```
+  // We removed manifestKeyMap, maybe this isn't needed anymore.
+  // See https://github.com/revealjs/reveal/issues/596
+  const pluginManifestClone = { ...pluginManifest }
+  checkType<PluginManifest>(pluginManifestClone)
+}

package/dist/core/gaurds/assertions/assertPlusFileExport.ts

@@ -0,0 +1,66 @@
+export { assertPlusFileExport };
+
+import pc from "@brillout/picocolors";
+import { assert } from "./assert/base";
+import { assertUsage } from "./assertUsage";
+import { assertWarning } from "./assertWarning";
+
+const EXPORTS_IGNORE = [
+  // vite-plugin-solid adds `export { $$registrations }`
+  "$$registrations",
+  // @vitejs/plugin-vue adds `export { _rerender_only }`
+  "_rerender_only",
+];
+
+// Tolerate `export { frontmatter }` in .mdx files
+const TOLERATE_SIDE_EXPORTS = [".md", ".mdx"] as const;
+
+function assertPlusFileExport(
+  fileExports: Record<string, unknown>,
+  filePathToShowToUser: string,
+  configName: string,
+) {
+  const exportNames = Object.keys(fileExports).filter(
+    (exportName) => !EXPORTS_IGNORE.includes(exportName),
+  );
+  const isValid = (exportName: string) =>
+    exportName === "default" || exportName === configName;
+  const exportNamesValid = exportNames.filter(isValid);
+  const exportNamesInvalid = exportNames.filter((e) => !isValid(e));
+
+  if (exportNamesValid.length === 1 && exportNamesInvalid.length === 0) {
+    return;
+  }
+
+  const exportDefault = pc.code("export default");
+  const exportNamed = pc.code(`export { ${configName} }`);
+  assert(exportNamesValid.length <= 2);
+  if (exportNamesValid.length === 0) {
+    assertUsage(
+      false,
+      `${filePathToShowToUser} should have a ${exportNamed} or ${exportDefault}`,
+    );
+  }
+  if (exportNamesValid.length === 2) {
+    assertWarning(
+      false,
+      `${filePathToShowToUser} is ambiguous: remove ${exportDefault} or ${exportNamed}`,
+      {
+        onlyOnce: true,
+      },
+    );
+  }
+  if (
+    !TOLERATE_SIDE_EXPORTS.some((ext) => filePathToShowToUser.endsWith(ext))
+  ) {
+    exportNamesInvalid.forEach((exportInvalid) => {
+      assertWarning(
+        false,
+        `${filePathToShowToUser} unexpected ${pc.cyan(`export { ${exportInvalid} }`)}`,
+        {
+          onlyOnce: true,
+        },
+      );
+    });
+  }
+}

package/dist/core/gaurds/assertions/assertRoutingType/base.ts

@@ -0,0 +1,41 @@
+export { assertClientRouting, assertServerRouting, checkIfClientRouting }
+
+import pc from "@brillout/picocolors"
+
+import getGlobalObject from "../../../processing/getters/getGlobalObject"
+import { isBrowser } from "../../validators/isBrowser"
+import { assertUsage } from "../assertUsage"
+import { assertWarning } from "../assertWarning"
+
+const state = getGlobalObject<{ isClientRouting?: boolean }>(
+  "utils/assertRouterType.ts",
+  {}
+)
+
+function assertClientRouting() {
+  assertNoContradiction(checkIfClientRouting())
+  state.isClientRouting = true
+}
+
+function checkIfClientRouting(): boolean {
+  return state.isClientRouting !== false
+}
+
+function assertServerRouting() {
+  assertNoContradiction(state.isClientRouting !== true)
+  state.isClientRouting = false
+}
+
+function assertNoContradiction(noContradiction: boolean) {
+  // If an assertion fails because of a wrong usage, then we assume that the user is trying to import from 'reveal/client/router' while not setting `clientRouting` to `true`. Note that 'reveal/client' only exports the type `PageContextBuiltInClient` and that the package.json#exports entry 'reveal/client' will eventually be removed.
+  assertUsage(
+    isBrowser(),
+    `${pc.cyan("import { something } from 'reveal/client/router'")} is forbidden on the server-side`,
+    { showStackTrace: true }
+  )
+  assertWarning(
+    noContradiction,
+    "You shouldn't `import { something } from 'reveal/client/router'` when using Server Routing. The 'reveal/client/router' utilities work only with Client Routing. In particular, don't `import { navigate }` nor `import { prefetch }` as they unnecessarily bloat your client-side bundle sizes.",
+    { showStackTrace: true, onlyOnce: true }
+  )
+}

package/dist/core/gaurds/assertions/assertRoutingType/index.ts

@@ -0,0 +1 @@
+export * from "./base.js";

package/dist/core/gaurds/assertions/assertRuntimeManifest.ts

@@ -0,0 +1,34 @@
+import { isBaseAssets } from "../../targets/url/parseUrlExtras";
+import { castType, checkType, isBaseServer } from "../../utils";
+import { hasProp } from "../validators/hasProp";
+import { isObject } from "../validators/isObject";
+import { assert } from "./assert";
+
+export { assertRuntimeManifest };
+export type { RuntimeManifest };
+
+type RuntimeManifest = {
+  baseServer: string;
+  baseAssets: string;
+  includeAssetsImportedByServer: boolean;
+  redirects: Record<string, string>;
+  trailingSlash: boolean;
+  disableUrlNormalization: boolean;
+};
+
+function assertRuntimeManifest(
+  obj: unknown,
+): asserts obj is RuntimeManifest & Record<string, unknown> {
+  assert(obj);
+  assert(isObject(obj));
+  assert(hasProp(obj, "baseServer", "string"));
+  assert(hasProp(obj, "baseAssets", "string"));
+  assert(isBaseServer(obj.baseServer));
+  assert(isBaseAssets(obj.baseAssets));
+  assert(hasProp(obj, "includeAssetsImportedByServer", "boolean"));
+  assert(hasProp(obj, "redirects", "object"));
+  castType<{ redirects: Record<string, string> }>(obj);
+  assert(hasProp(obj, "trailingSlash", "boolean"));
+  assert(hasProp(obj, "disableUrlNormalization", "boolean"));
+  checkType<RuntimeManifest>(obj);
+}