@stainless-api/docs 0.1.0-beta.132 → 0.1.0-beta.134

package/stl-docs/og-image/components/OpenGraphImage.tsx

@@ -0,0 +1,126 @@
+import { darkThemeVars, lightThemeVars, typography } from '../theme';
+import { resolveLocalImageFile } from '../image-gen/get-logo-url';
+import { OG_IMAGE_OPTIONS } from 'virtual:stainless-docs/docs-og-image';
+
+/* The default open graph image template. It is expected to be used with @takumi-rs/image-response */
+export default function OpenGraphImage({
+  title,
+  description,
+  logo,
+  children,
+  theme,
+  breadcrumbs,
+}: {
+  title: string;
+  description?: string;
+  logo?: string;
+  children?: React.ReactNode;
+  theme?: 'light' | 'dark';
+  breadcrumbs?: string[];
+}) {
+  const colors = theme === 'dark' ? darkThemeVars : lightThemeVars;
+
+  const testLogo = OG_IMAGE_OPTIONS?.backgroundImage
+    ? resolveLocalImageFile(OG_IMAGE_OPTIONS.backgroundImage.src)
+    : undefined;
+
+  return (
+    <div
+      style={{
+        backgroundColor: colors.background,
+        width: '100%',
+        height: '100%',
+        display: 'flex',
+        alignItems: 'flex-start',
+        justifyContent: 'space-between',
+        flexDirection: 'column',
+        padding: '72px',
+        position: 'relative',
+        fontFeatureSettings: "'ss01' on, 'ss03' on, 'ss04' on, 'ss06' on",
+        lineHeight: `${typography.baseLineHeight}`,
+        fontSize: `${typography.baseFontSize}`,
+        letterSpacing: `${typography.baseLetterSpacing}`,
+      }}
+    >
+      {testLogo && (
+        <img
+          src={testLogo}
+          alt="Background"
+          style={{
+            position: 'absolute',
+            top: 0,
+            right: 0,
+            zIndex: -1,
+            ...OG_IMAGE_OPTIONS?.backgroundImage?.style,
+          }}
+        />
+      )}
+      {logo && <img src={logo} alt="Logo" style={{ height: '80px', marginBottom: '24px' }} />}
+      <div style={{ display: 'flex', flexDirection: 'column', gap: '16px', width: '100%' }}>
+        {breadcrumbs && breadcrumbs.length > 0 && (
+          <div style={{ display: 'flex', alignItems: 'center', gap: '8px', color: colors.foregroundMuted }}>
+            {breadcrumbs.map((crumb, index) => (
+              <div key={index} style={{ display: 'flex', alignItems: 'center', gap: '8px' }}>
+                {index > 0 && (
+                  <svg
+                    width="32"
+                    height="32"
+                    viewBox="0 0 32 32"
+                    fill="none"
+                    xmlns="http://www.w3.org/2000/svg"
+                  >
+                    <g opacity="0.6">
+                      <path
+                        d="M11.0573 7.05727C11.578 6.53657 12.422 6.53657 12.9427 7.05727L20.9427 15.0573C21.4634 15.578 21.4634 16.422 20.9427 16.9427L12.9427 24.9427C12.422 25.4634 11.578 25.4634 11.0573 24.9427C10.5366 24.422 10.5366 23.578 11.0573 23.0573L18.1146 16L11.0573 8.94269C10.5366 8.42199 10.5366 7.57797 11.0573 7.05727Z"
+                        fill={colors.foreground}
+                      />
+                    </g>
+                  </svg>
+                )}
+                <span
+                  style={{
+                    fontSize: `${typography.breadcrumbFontSize}`,
+                    lineHeight: `${typography.breadcrumbLineHeight}`,
+                    letterSpacing: `${typography.breadcrumbLetterSpacing}`,
+                  }}
+                >
+                  {crumb}
+                </span>
+              </div>
+            ))}
+          </div>
+        )}
+        <h1
+          style={{
+            marginBottom: '0',
+            marginTop: '0',
+            fontWeight: 600,
+            color: colors.foreground,
+            letterSpacing: `${typography.headerLetterSpacing}`,
+            lineClamp: 2,
+            textOverflow: 'ellipsis',
+            lineHeight: `${typography.headerLineHeight}`,
+            fontSize: `${typography.headerFontSize}`,
+            textWrap: 'balance',
+          }}
+        >
+          {title}
+        </h1>
+        {description && (
+          <p
+            style={{
+              color: colors.foregroundMuted,
+              marginBottom: 0,
+              marginTop: 0,
+              lineClamp: 2,
+              textOverflow: 'ellipsis',
+            }}
+          >
+            {description}
+          </p>
+        )}
+        {children}
+      </div>
+    </div>
+  );
+}

package/stl-docs/og-image/config.ts

@@ -0,0 +1,56 @@
+// Exported utilites for @stainless-api/docs consumers
+
+import type { ImageResponseOptions } from '@takumi-rs/image-response';
+import type { CSSProperties } from 'react';
+
+export type OGImageConfig = {
+  /**
+   * Path to source file for logo to include in generated OG images
+   *
+   * example: './src/assets/og-logo.png'
+   */
+  logo?: string;
+  /**
+   * Takumi ImageResponseOptions for OG image generation
+   */
+  renderOptions?: Omit<ImageResponseOptions, 'fonts'>;
+  /**
+   * A background image for the OG images. A tailwind `tw` string can be provided to style the image.
+   *
+   * example: './src/assets/og-background-logo.png'
+   */
+  backgroundImage?: {
+    /**
+     * Path to source file for background image
+     *
+     * example: './src/assets/og-background-logo.png'
+     */
+    src: string;
+    /**
+     * Style applied to the background image using React CSSProperties
+     *
+     * example: { right: -20px }
+     */
+    style?: CSSProperties;
+  };
+  /** Preferred theme for the OG images
+   */
+  theme?: 'light' | 'dark';
+  /** The base path for the docs site. To be used when setting `base` within your astro config is not sufficient depending on hosting strategy.
+   * If your docs site is hosted at a subpath (e.g. example.com/docs), set the basePath to '/docs'.
+   *
+   * example: '/docs'
+   */
+  basePath?: string;
+  /**
+   * Override the default OG image components with custom implementations.
+   * Each value should be a file path to a component that exports a default React component.
+   *
+   * You can import the default components from `@stainless-api/docs/og-image/components/OpenGraphImage`
+   * and `@stainless-api/docs/og-image/components/OpenGraphFunctionSignature` to compose with them.
+   */
+  components?: {
+    OpenGraphImage?: string;
+    OpenGraphFunctionSignature?: string;
+  };
+};

package/stl-docs/og-image/image-gen/generate-api-reference-og-image.tsx

@@ -0,0 +1,188 @@
+import { ImageResponse } from '@takumi-rs/image-response';
+import { generateDocsRoutes } from '@stainless-api/docs/generate-docs-routes';
+import { DocsLanguage, parseStainlessPath } from '@stainless-api/docs-ui/routing';
+import { getResourceFromSpec } from '@stainless-api/docs-ui/utils';
+import { ArrowDownLeft, ArrowUpRight, XIcon } from 'lucide-react';
+import OpenGraphImage from 'virtual:stainless-docs/docs-og-image/components/OpenGraphImage';
+import OpenGraphFunctionSignature from 'virtual:stainless-docs/docs-og-image/components/OpenGraphFunctionSignature';
+import { LanguageDeclNodes, Method } from '@stainless/sdk-json';
+import getLogoDataUrl from './get-logo-url';
+import { notFoundResponse, renderOptions } from '../utils';
+import { OG_IMAGE_OPTIONS } from 'virtual:stainless-docs/docs-og-image';
+import { darkThemeVars, lightThemeVars } from '../theme';
+import { generateApiBreadcrumbs } from '@stainless-api/docs-ui/components';
+import { getSDKJSONInSSR } from '@stainless-api/docs/specs/fetchSpecSSR';
+import { RESOLVED_API_REFERENCE_PATH } from 'virtual:stl-starlight-virtual-module';
+import type * as SDKJSON from '@stainless/sdk-json';
+
+type ApiReferenceRoute = ReturnType<typeof generateDocsRoutes>[number];
+
+export default async function generateApiReferenceOgImage({
+  apiReferenceRoute,
+  slug,
+}: {
+  apiReferenceRoute?: ApiReferenceRoute;
+  slug: string;
+}) {
+  if (!apiReferenceRoute?.props.stainlessPath) return notFoundResponse();
+
+  const spec = await getSDKJSONInSSR(apiReferenceRoute.props.language);
+
+  const parsed = parseStainlessPath(apiReferenceRoute.props.stainlessPath);
+  const resource = getResourceFromSpec(apiReferenceRoute.props.stainlessPath, spec);
+
+  if (!resource || !parsed?.method || !resource.methods[parsed.method]) return notFoundResponse();
+
+  if (apiReferenceRoute.props.kind === 'http_method') {
+    const method = resource.methods[parsed.method]!;
+    return generateApiReferenceMethodOgImage({
+      method,
+      language: apiReferenceRoute.props.language,
+      stainlessPath: apiReferenceRoute.props.stainlessPath,
+      slug: `${RESOLVED_API_REFERENCE_PATH}/${slug}`,
+      spec,
+    });
+  }
+
+  const logoDataUrl = getLogoDataUrl();
+
+  return new ImageResponse(
+    <OpenGraphImage
+      title={resource.title}
+      description={`API Overview - ${apiReferenceRoute.props.language} `}
+      logo={logoDataUrl}
+    />,
+    renderOptions,
+  );
+}
+
+function generateApiReferenceMethodOgImage({
+  method,
+  language,
+  stainlessPath,
+  slug,
+  spec,
+}: {
+  method: Method;
+  language: DocsLanguage;
+  stainlessPath: string;
+  slug: string;
+  spec: SDKJSON.Spec;
+}) {
+  const slugWithoutExtension = slug.replace(/\.[^/.]+$/, '');
+  const endpoint = method.endpoint.slice(method.endpoint.indexOf(' ') + 1);
+  const httpMethod = method.httpMethod.toUpperCase();
+
+  const decl = spec?.decls?.[language]?.[stainlessPath] as LanguageDeclNodes[keyof LanguageDeclNodes];
+
+  if (!decl) {
+    return notFoundResponse();
+  }
+
+  let params: { ident: string; optional?: boolean }[] | undefined = undefined;
+  let qualified: string | undefined = undefined;
+
+  if ('signature' in decl && decl.signature) {
+    params = decl.signature.parameters;
+  } else if ('parameters' in decl && decl.parameters) {
+    // @ts-expect-error TODO: this is breaking builds
+    params = decl.parameters;
+  } else if ('args' in decl && decl.args) {
+    params = decl.args;
+  }
+
+  if ('qualified' in decl && decl.qualified) {
+    qualified = decl.qualified;
+  }
+
+  const logoDataUrl = getLogoDataUrl();
+  const colors = OG_IMAGE_OPTIONS?.theme === 'dark' ? darkThemeVars : lightThemeVars;
+  const httpColors =
+    httpMethod === 'GET'
+      ? { background: colors.greenBackground, text: colors.green }
+      : httpMethod === 'POST'
+        ? { background: colors.blueBackground, text: colors.blue }
+        : httpMethod === 'PUT' || httpMethod === 'PATCH'
+          ? { background: colors.orangeBackground, text: colors.orange }
+          : httpMethod === 'DELETE'
+            ? { background: colors.redBackground, text: colors.red }
+            : { background: colors.foregroundMuted, text: colors.foreground };
+  // remove first and last breadcrumb (API Reference and current page)
+  const breadcrumbs = generateApiBreadcrumbs(
+    slugWithoutExtension,
+    spec,
+    RESOLVED_API_REFERENCE_PATH || '/api',
+  )?.slice(1, -1);
+
+  return new ImageResponse(
+    <OpenGraphImage
+      title={method.summary || method.title}
+      logo={logoDataUrl}
+      theme={OG_IMAGE_OPTIONS?.theme}
+      breadcrumbs={breadcrumbs ? breadcrumbs.map((b) => b.title) : undefined}
+    >
+      <div
+        style={{
+          display: 'flex',
+          flexDirection: 'column',
+          fontFamily: 'monospace',
+        }}
+      >
+        <OpenGraphFunctionSignature
+          params={params}
+          fullyQualifiedName={qualified}
+          theme={OG_IMAGE_OPTIONS?.theme}
+        />
+        <div
+          style={{
+            display: 'flex',
+            gap: '8px',
+            alignItems: 'center',
+            fontFamily: 'monospace',
+          }}
+        >
+          <div
+            style={{
+              display: 'flex',
+              alignItems: 'center',
+              justifyContent: 'center',
+              paddingLeft: '2px',
+              paddingRight: '6px',
+              paddingTop: '4px',
+              paddingBottom: '4px',
+              borderRadius: '8px',
+              fontWeight: 600,
+              color: httpColors.text,
+              backgroundColor: httpColors.background,
+              lineHeight: '100%',
+              fontSize: '25px',
+              stroke: colors.foreground,
+              fontFamily: 'monospace',
+              flexShrink: 0,
+            }}
+          >
+            {httpMethod === 'GET' && <ArrowDownLeft size={36} color={colors.green} />}
+            {httpMethod === 'POST' && <ArrowUpRight size={36} color={colors.blue} />}
+            {(httpMethod === 'PUT' || httpMethod === 'PATCH') && (
+              <ArrowUpRight size={36} color={colors.orange} />
+            )}
+            {httpMethod === 'DELETE' && <XIcon size={36} color={colors.red} />}
+            {httpMethod}
+          </div>
+          <div
+            style={{
+              lineClamp: 1,
+              overflow: 'hidden',
+              textOverflow: 'ellipsis',
+              color: colors.foregroundMuted,
+              fontFamily: 'monospace',
+            }}
+          >
+            {endpoint}
+          </div>
+        </div>
+      </div>
+    </OpenGraphImage>,
+    renderOptions,
+  );
+}

package/stl-docs/og-image/image-gen/generate-og-image.tsx

@@ -0,0 +1,119 @@
+import { getCollection } from 'astro:content';
+import { z } from 'astro/zod';
+import { ImageResponse } from '@takumi-rs/image-response';
+import { Tabs } from '@stainless-api/docs/docs-config';
+import OpenGraphImage from 'virtual:stainless-docs/docs-og-image/components/OpenGraphImage';
+import { OG_IMAGE_OPTIONS } from 'virtual:stainless-docs/docs-og-image';
+import { TABS } from 'virtual:stl-docs-virtual-module';
+import getLogoDataUrl from './get-logo-url';
+import { stainlessDocsSchemaExtension } from '../../schema-extension';
+import { notFoundResponse, renderOptions } from '../utils';
+
+type GetcollectionReturnType = Awaited<ReturnType<typeof getCollection<'docs'>>>[number];
+
+type PageEntry = {
+  data: GetcollectionReturnType['data'] & z.infer<typeof stainlessDocsSchemaExtension>;
+};
+
+let contentEntriesCache: { id: string }[] | null = null;
+
+async function getContentEntries(): Promise<{ id: string }[]> {
+  if (contentEntriesCache === null) {
+    contentEntriesCache = await getCollection('docs').then((entries) =>
+      entries.map((entry) => ({ id: entry.id })),
+    );
+  }
+  return contentEntriesCache ?? [];
+}
+
+async function resolveAutogenerateEntry(autogenerate: {
+  directory: string;
+}): Promise<NonNullable<Tabs[0]['sidebar']>> {
+  const entries = await getContentEntries();
+  const directoryPrefix = autogenerate.directory.endsWith('/')
+    ? autogenerate.directory
+    : `${autogenerate.directory}/`;
+
+  const matchingEntries = entries
+    .filter((entry) => {
+      return entry.id === autogenerate.directory || entry.id.startsWith(directoryPrefix);
+    })
+    .map((entry) => entry.id)
+    .sort();
+
+  return matchingEntries;
+}
+
+const findBreadcrumbsInSidebar = async (
+  data: NonNullable<Tabs[0]['sidebar']>,
+  slug: string,
+): Promise<string[] | null> => {
+  for (const entry of data) {
+    if (typeof entry === 'string') {
+      if (entry === slug) {
+        return [];
+      }
+    } else {
+      if ('link' in entry && entry.link === slug) {
+        return [entry.label];
+      }
+
+      if ('autogenerate' in entry && entry.autogenerate) {
+        const resolvedItems = await resolveAutogenerateEntry(entry.autogenerate);
+        const breadcrumbs = await findBreadcrumbsInSidebar(resolvedItems, slug);
+        if (breadcrumbs) {
+          return [entry.label, ...breadcrumbs];
+        }
+        continue;
+      }
+
+      const children = ('sidebar' in entry && entry.sidebar) || ('items' in entry && entry.items);
+      if (children) {
+        const breadcrumbs = await findBreadcrumbsInSidebar(children as NonNullable<Tabs[0]['sidebar']>, slug);
+        if (breadcrumbs) {
+          return [entry.label!, ...breadcrumbs];
+        }
+      }
+    }
+  }
+  return null;
+};
+
+const findBreadcrumbs = async (data: Tabs, slug: string): Promise<string[] | undefined> => {
+  for (const tab of data) {
+    if (tab.link === slug) {
+      return [tab.label];
+    }
+    if (!tab.sidebar) continue;
+    const breadcrumbs = await findBreadcrumbsInSidebar(tab.sidebar, slug);
+    if (breadcrumbs) {
+      return [tab.label, ...breadcrumbs.map((label) => label)];
+    }
+  }
+  return undefined;
+};
+
+async function generateOgImage({ page, slug }: { page?: PageEntry; slug: string }) {
+  if (!page) {
+    return notFoundResponse();
+  }
+
+  const logoDataUrl = getLogoDataUrl({
+    logo: page.data.ogImageOptions?.logo,
+    theme: page.data.ogImageOptions?.theme || OG_IMAGE_OPTIONS?.theme,
+  });
+
+  const breadcrumbs = page.data.template !== 'splash' ? await findBreadcrumbs(TABS, slug) : undefined;
+  return new ImageResponse(
+    <OpenGraphImage
+      title={page.data.ogImageOptions?.title ?? page.data.title}
+      description={page.data.ogImageOptions?.description ?? page.data.description}
+      logo={logoDataUrl}
+      theme={page.data.ogImageOptions?.theme || OG_IMAGE_OPTIONS?.theme}
+      breadcrumbs={breadcrumbs}
+    />,
+    renderOptions,
+  );
+}
+
+export default generateOgImage;

package/stl-docs/og-image/image-gen/get-logo-url.ts

@@ -0,0 +1,47 @@
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import { LOGO, OG_IMAGE_OPTIONS } from 'virtual:stainless-docs/docs-og-image';
+
+export function resolveLocalImageFile(logoPath: string): string | undefined {
+  try {
+    // Remove leading slash and resolve from project root
+    const filePath = join(process.cwd(), logoPath.replace(/^\//, ''));
+    const fileBuffer = readFileSync(filePath);
+
+    // Determine mime type from extension
+    const ext = logoPath.split('.').pop()?.toLowerCase();
+
+    const mimeType = ext === 'svg' ? 'image/svg+xml' : `image/${ext}`;
+
+    return `data:${mimeType};base64,${fileBuffer.toString('base64')}`;
+  } catch (error) {
+    console.warn('Failed to load logo for OG image:', error);
+    return undefined;
+  }
+}
+
+// Convert logo to base64 data URL if it exists
+function getLogoDataUrl({ logo, theme }: { logo?: string; theme?: 'light' | 'dark' } = {}):
+  | string
+  | undefined {
+  const logoConfig = logo ?? OG_IMAGE_OPTIONS?.logo ?? LOGO;
+  if (!logoConfig) return undefined;
+
+  // Handle string path or object with src/light properties
+  let logoPath: string | undefined;
+  if (typeof logoConfig === 'string') {
+    logoPath = logoConfig;
+  } else if ('src' in logoConfig) {
+    logoPath = logoConfig.src;
+  } else if ('dark' in logoConfig && theme === 'dark') {
+    logoPath = logoConfig.dark;
+  } else if ('light' in logoConfig) {
+    logoPath = logoConfig.light;
+  }
+
+  if (!logoPath) return undefined;
+
+  return resolveLocalImageFile(logoPath);
+}
+
+export default getLogoDataUrl;

package/stl-docs/og-image/index.ts

@@ -0,0 +1,135 @@
+import type { StarlightPlugin } from '@astrojs/starlight/types';
+import type { NormalizedStainlessDocsConfig } from '../loadStlDocsConfig';
+import { resolveSrcFile } from '../../resolveSrcFile';
+import { resolve } from 'path';
+import type { OGImageConfig } from './config';
+import { buildVirtualModuleString } from '../../shared/virtualModule';
+
+// The '\0' prefix tells Vite "this is a virtual module" and prevents it from being resolved again.
+function resolveVirtualModuleId<T extends string>(id: T): `\0${T}` {
+  return `\0${id}`;
+}
+
+const OG_IMAGE_DIR = '/stl-docs/og-image';
+
+const stainlessComponentDefaults = {
+  OpenGraphImage: resolveSrcFile(OG_IMAGE_DIR, 'components/OpenGraphImage.tsx'),
+  OpenGraphFunctionSignature: resolveSrcFile(OG_IMAGE_DIR, 'components/OpenGraphFunctionSignature.tsx'),
+};
+
+function checkTakumiInstalled(): boolean {
+  try {
+    import.meta.resolve('@takumi-rs/image-response');
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function ogImageStarlightPlugin(
+  config: OGImageConfig | undefined,
+  stainlessDocsConfig: NormalizedStainlessDocsConfig,
+): StarlightPlugin {
+  return {
+    name: 'stainless-og-image',
+    hooks: {
+      'config:setup': ({ astroConfig, addRouteMiddleware, addIntegration, logger, command }) => {
+        if (command !== 'build' && command !== 'dev') {
+          return;
+        }
+
+        if (!checkTakumiInstalled()) {
+          logger.error(
+            'The "@takumi-rs/image-response" package is required to use OG image generation. ' +
+              'Please install it: npm install @takumi-rs/image-response',
+          );
+          process.exit(1);
+        }
+
+        if (!astroConfig.site) {
+          logger.warn('astro.config.site is not set. Open Graph images will not be generated.');
+          return;
+        }
+        addRouteMiddleware({
+          entrypoint: resolveSrcFile(OG_IMAGE_DIR, 'routes/add-og-image.ts'),
+        });
+
+        addIntegration({
+          name: 'stainless-docs-og-image-astro-integration',
+          hooks: {
+            'astro:config:setup': ({ updateConfig, injectRoute, command, config: astroConfig }) => {
+              const resolvePath = (id: string) =>
+                JSON.stringify(id.startsWith('.') ? resolve(astroConfig.root.pathname, id) : id);
+
+              const userComponents = Object.fromEntries(
+                Object.entries(config?.components ?? {}).flatMap(([key, value]) =>
+                  value !== undefined ? [[key, value]] : [],
+                ),
+              );
+
+              const allComponents: Record<string, string> = {
+                ...stainlessComponentDefaults,
+                ...userComponents,
+              };
+
+              const modules = Object.fromEntries(
+                Object.entries(allComponents).map(([name, path]) => [
+                  `virtual:stainless-docs/docs-og-image/components/${name}`,
+                  `export { default } from ${resolvePath(path)};`,
+                ]),
+              );
+
+              const resolutionMap = Object.fromEntries(
+                Object.keys(modules).map((key) => [resolveVirtualModuleId(key), key]),
+              );
+
+              const virtualId = `virtual:stainless-docs/docs-og-image`;
+
+              updateConfig({
+                vite: {
+                  plugins: [
+                    {
+                      name: '@stainless-api/docs-og-image-vite',
+                      resolveId(id) {
+                        if (id in modules || id == virtualId) {
+                          return resolveVirtualModuleId(id);
+                        }
+                      },
+                      load(id) {
+                        if (id === resolveVirtualModuleId(virtualId)) {
+                          return buildVirtualModuleString({
+                            LOGO: stainlessDocsConfig?.starlightPassThrough?.logo,
+                            OG_IMAGE_OPTIONS: config,
+                          });
+                        }
+                        const resolution = resolutionMap[id];
+                        if (resolution) return modules[resolution];
+                      },
+                    },
+                  ],
+                },
+              });
+
+              injectRoute({
+                pattern: `/og/[...slug].png`,
+                entrypoint: resolveSrcFile(OG_IMAGE_DIR, 'routes/get-og-image.ts'),
+                prerender: command === 'build',
+              });
+
+              if (stainlessDocsConfig.apiReference !== null) {
+                const apiBasePath = stainlessDocsConfig.apiReference?.basePath ?? '/api';
+                const normalizedBasePath = apiBasePath.replace(/^\/+|\/+$/g, '');
+
+                injectRoute({
+                  pattern: `/og/${normalizedBasePath}/[...slug].png`,
+                  entrypoint: resolveSrcFile(OG_IMAGE_DIR, 'routes/get-api-reference-og-image.ts'),
+                  prerender: command === 'build',
+                });
+              }
+            },
+          },
+        });
+      },
+    },
+  };
+}