@codepress/blog 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,72 @@
+import {
+  buildContentSchema,
+  schemaVersion
+} from "./chunks/chunk-HWR3R5MU.js";
+import {
+  DROP_WITH_CONTENT,
+  sanitizeHtml,
+  sanitizeNodes,
+  sanitizeUrl
+} from "./chunks/chunk-EICE5ONB.js";
+import {
+  escapeXml,
+  feedXml,
+  sitemapXml
+} from "./chunks/chunk-TYX2HJZC.js";
+import {
+  absoluteImage,
+  blogPostingJsonLd,
+  blogUrl,
+  breadcrumbJsonLd,
+  createHttpContentSource,
+  feedUrl,
+  homeUrl,
+  jsonLd,
+  postUrl
+} from "./chunks/chunk-AEQDRBA3.js";
+import {
+  BLOCK_ID_ATTRIBUTE,
+  CALLOUT_TYPES,
+  COMPONENTS,
+  ELEMENTS,
+  PROPS_ATTRIBUTE,
+  SLUG_PATTERN,
+  URL_SCHEMES,
+  calloutProps,
+  figureProps,
+  isComponentTag,
+  isElementTag,
+  postMetaSchema
+} from "./chunks/chunk-XLJBCIXI.js";
+export {
+  BLOCK_ID_ATTRIBUTE,
+  CALLOUT_TYPES,
+  COMPONENTS,
+  DROP_WITH_CONTENT,
+  ELEMENTS,
+  PROPS_ATTRIBUTE,
+  SLUG_PATTERN,
+  URL_SCHEMES,
+  absoluteImage,
+  blogPostingJsonLd,
+  blogUrl,
+  breadcrumbJsonLd,
+  buildContentSchema,
+  calloutProps,
+  createHttpContentSource,
+  escapeXml,
+  feedUrl,
+  feedXml,
+  figureProps,
+  homeUrl,
+  isComponentTag,
+  isElementTag,
+  jsonLd,
+  postMetaSchema,
+  postUrl,
+  sanitizeHtml,
+  sanitizeNodes,
+  sanitizeUrl,
+  schemaVersion,
+  sitemapXml
+};

package/dist/next/app.d.ts

@@ -0,0 +1,34 @@
+import type { Metadata } from "next";
+import { type BlogConfig } from "./config.js";
+type SlugParams = {
+    params: Promise<{
+        slug: string;
+    }>;
+};
+/**
+ * The App Router blog. Each route file re-exports one member, and declares
+ * `export const revalidate = 60` itself (Next.js reads segment config
+ * statically):
+ *
+ * - `app/blog/page.tsx`: `IndexPage`, `generateIndexMetadata`
+ * - `app/blog/[slug]/page.tsx`: `PostPage`, `generatePostMetadata`, `generateStaticParams`
+ *
+ * The feed and sitemap route handlers come from `createAppBlogRoutes`
+ * (`@codepress/blog/next/routes`), which carries no React: a route handler
+ * cannot bundle `next/link`.
+ *
+ * A 404 from the API is "no such post"; any other failure throws, so ISR keeps
+ * serving the last good page.
+ */
+export declare function createAppBlog(config: BlogConfig): {
+    blog: import("./config.js").ResolvedBlog;
+    IndexPage(): Promise<import("react/jsx-runtime").JSX.Element>;
+    PostPage({ params }: SlugParams): Promise<import("react/jsx-runtime").JSX.Element>;
+    generateStaticParams(): Promise<{
+        slug: string;
+    }[]>;
+    generateIndexMetadata(): Promise<Metadata>;
+    generatePostMetadata({ params }: SlugParams): Promise<Metadata>;
+};
+export type AppBlog = ReturnType<typeof createAppBlog>;
+export {};

package/dist/next/config.d.ts

@@ -0,0 +1,44 @@
+import { type ContentSource, type PostSummary } from "../content-source.js";
+import type { BlogSite } from "../seo.js";
+export declare const DEFAULT_API_BASE = "https://api.codepress.dev/v1";
+export declare const DEFAULT_BASE_PATH = "/blog";
+export declare const DEFAULT_REVALIDATE_SECONDS = 60;
+/** How a Next.js site mounts its CodePress blog. */
+export interface BlogConfig {
+    /** The content site's slug on CodePress. */
+    site: string;
+    /** The site's public origin, for example `https://acme.com`. Canonical, feed and sitemap links are built from it. */
+    baseUrl: string;
+    /** Where the blog is mounted. Defaults to `/blog`. */
+    basePath?: string;
+    /** The CodePress API root including `/v1`. Defaults to `https://api.codepress.dev/v1`. */
+    apiBase?: string;
+    /** Seconds between ISR regenerations (Pages Router, and the feed and sitemap cache headers). Defaults to 60. */
+    revalidate?: number;
+    /** The publisher's name. Defaults to the host of `baseUrl`. */
+    name?: string;
+    /** The blog's title. Defaults to `<name> Blog`. */
+    title?: string;
+    /** The blog's description. */
+    description?: string;
+    /** Absolute URL of the share image for posts without an `ogImage`. */
+    defaultImage?: string;
+    /** Timeout for each API request. Defaults to 10 seconds. */
+    timeoutMs?: number;
+}
+export interface ResolvedBlog {
+    site: BlogSite;
+    /** The mount path, with a leading slash and no trailing slash. */
+    basePath: string;
+    revalidate: number;
+    source: ContentSource;
+}
+export declare function resolveBlog(config: BlogConfig): ResolvedBlog;
+/** True while `next build` prerenders pages. */
+export declare function isBuildPhase(): boolean;
+/**
+ * The published posts. `next build` prerenders the index, so an API outage
+ * then would fail the site's deploy: the build ships an empty blog instead.
+ * At runtime the error propagates, so ISR keeps serving the last good page.
+ */
+export declare function listPostsForRender(blog: ResolvedBlog): Promise<PostSummary[]>;

package/dist/next/index.d.ts

@@ -0,0 +1,2 @@
+export { createAppBlog, type AppBlog } from "./app.js";
+export { DEFAULT_API_BASE, DEFAULT_BASE_PATH, DEFAULT_REVALIDATE_SECONDS, resolveBlog, type BlogConfig, type ResolvedBlog, } from "./config.js";

package/dist/next/index.js

@@ -0,0 +1,94 @@
+import {
+  BlogIndexView,
+  BlogPostView,
+  shareImage
+} from "../chunks/chunk-WJVZD4UI.js";
+import {
+  DEFAULT_API_BASE,
+  DEFAULT_BASE_PATH,
+  DEFAULT_REVALIDATE_SECONDS,
+  listPostsForRender,
+  resolveBlog
+} from "../chunks/chunk-3GCZFCUK.js";
+import "../chunks/chunk-AJVVTSKZ.js";
+import "../chunks/chunk-EICE5ONB.js";
+import {
+  blogUrl,
+  feedUrl,
+  postUrl
+} from "../chunks/chunk-AEQDRBA3.js";
+import "../chunks/chunk-XLJBCIXI.js";
+
+// src/next/app.tsx
+import { notFound } from "next/navigation.js";
+import { cache } from "react";
+import { jsx } from "react/jsx-runtime";
+function createAppBlog(config) {
+  const blog = resolveBlog(config);
+  const { site } = blog;
+  const getPost = cache((slug) => blog.source.getPost(slug));
+  return {
+    blog,
+    async IndexPage() {
+      return /* @__PURE__ */ jsx(BlogIndexView, { blog, posts: await listPostsForRender(blog) });
+    },
+    async PostPage({ params }) {
+      const post = await getPost((await params).slug);
+      if (!post) notFound();
+      return /* @__PURE__ */ jsx(BlogPostView, { blog, post });
+    },
+    async generateStaticParams() {
+      return (await listPostsForRender(blog)).map(({ slug }) => ({ slug }));
+    },
+    async generateIndexMetadata() {
+      const image = shareImage(site, void 0);
+      return {
+        title: site.title,
+        description: site.description,
+        alternates: {
+          canonical: blogUrl(site),
+          types: { "application/rss+xml": feedUrl(site) }
+        },
+        openGraph: {
+          type: "website",
+          url: blogUrl(site),
+          title: site.title,
+          description: site.description,
+          ...image ? { images: [image] } : {}
+        }
+      };
+    },
+    async generatePostMetadata({ params }) {
+      const post = await getPost((await params).slug);
+      if (!post) return {};
+      const { slug, meta } = post;
+      const image = shareImage(site, meta.ogImage);
+      return {
+        title: meta.title,
+        description: meta.description,
+        authors: meta.authors?.map((name) => ({ name })),
+        alternates: {
+          canonical: postUrl(site, slug),
+          types: { "application/rss+xml": feedUrl(site) }
+        },
+        openGraph: {
+          type: "article",
+          url: postUrl(site, slug),
+          title: meta.title,
+          description: meta.description,
+          publishedTime: meta.date,
+          modifiedTime: meta.updated ?? meta.date,
+          ...image ? { images: [image] } : {}
+        },
+        twitter: { card: image ? "summary_large_image" : "summary" }
+      };
+    }
+  };
+}
+export {
+  DEFAULT_API_BASE,
+  DEFAULT_BASE_PATH,
+  DEFAULT_REVALIDATE_SECONDS,
+  createAppBlog,
+  resolveBlog
+};

package/dist/next/pages.d.ts

@@ -0,0 +1,33 @@
+import type { GetServerSideProps, GetStaticPaths, GetStaticProps } from "next";
+import type { Post, PostSummary } from "../content-source.js";
+import { type BlogConfig, type ResolvedBlog } from "./config.js";
+export type { BlogConfig } from "./config.js";
+interface IndexProps {
+    posts: PostSummary[];
+}
+interface PostProps {
+    post: Post;
+}
+/**
+ * The Pages Router blog. Each route file re-exports members:
+ *
+ * - `pages/blog/index.tsx`: `IndexPage`, `getIndexStaticProps` as `getStaticProps`
+ * - `pages/blog/[slug].tsx`: `PostPage`, `getPostStaticPaths`, `getPostStaticProps`
+ * - `pages/blog/feed.xml.tsx`, `sitemap.xml.tsx`: `getFeedServerSideProps`, `getSitemapServerSideProps`
+ *
+ * Pages regenerate every `revalidate` seconds (ISR). A 404 from the API is "no
+ * such post"; any other failure throws, so ISR keeps the last good page.
+ */
+export declare function createPagesBlog(config: BlogConfig): {
+    blog: ResolvedBlog;
+    IndexPage: ({ posts }: IndexProps) => import("react/jsx-runtime").JSX.Element;
+    PostPage: ({ post }: PostProps) => import("react/jsx-runtime").JSX.Element;
+    getIndexStaticProps: GetStaticProps<IndexProps>;
+    getPostStaticPaths: GetStaticPaths;
+    getPostStaticProps: GetStaticProps<PostProps>;
+    getFeedServerSideProps: GetServerSideProps;
+    getSitemapServerSideProps: GetServerSideProps;
+    /** The component for the feed and sitemap routes, whose response `getServerSideProps` writes. */
+    EmptyPage: () => null;
+};
+export type PagesBlog = ReturnType<typeof createPagesBlog>;

package/dist/next/pages.js

@@ -0,0 +1,167 @@
+import {
+  BlogIndexView,
+  BlogPostView,
+  indexJsonLd,
+  postJsonLd,
+  shareImage
+} from "../chunks/chunk-WJVZD4UI.js";
+import {
+  isBuildPhase,
+  listPostsForRender,
+  resolveBlog
+} from "../chunks/chunk-3GCZFCUK.js";
+import "../chunks/chunk-AJVVTSKZ.js";
+import "../chunks/chunk-EICE5ONB.js";
+import {
+  feedXml,
+  sitemapXml
+} from "../chunks/chunk-TYX2HJZC.js";
+import {
+  blogUrl,
+  feedUrl,
+  postUrl
+} from "../chunks/chunk-AEQDRBA3.js";
+import "../chunks/chunk-XLJBCIXI.js";
+
+// src/next/pages.tsx
+import Head from "next/head.js";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+function PageHead({
+  blog,
+  title,
+  description,
+  url,
+  image,
+  type,
+  structuredData
+}) {
+  return /* @__PURE__ */ jsxs(Head, { children: [
+    /* @__PURE__ */ jsx("title", { children: title }),
+    /* @__PURE__ */ jsx("meta", { name: "description", content: description }),
+    /* @__PURE__ */ jsx("link", { rel: "canonical", href: url }),
+    /* @__PURE__ */ jsx(
+      "link",
+      {
+        rel: "alternate",
+        type: "application/rss+xml",
+        title: blog.site.title,
+        href: feedUrl(blog.site)
+      }
+    ),
+    /* @__PURE__ */ jsx("meta", { property: "og:type", content: type }),
+    /* @__PURE__ */ jsx("meta", { property: "og:url", content: url }),
+    /* @__PURE__ */ jsx("meta", { property: "og:title", content: title }),
+    /* @__PURE__ */ jsx("meta", { property: "og:description", content: description }),
+    image ? /* @__PURE__ */ jsx("meta", { property: "og:image", content: image }) : null,
+    /* @__PURE__ */ jsx(
+      "meta",
+      {
+        name: "twitter:card",
+        content: image ? "summary_large_image" : "summary"
+      }
+    ),
+    structuredData.map((data, index) => /* @__PURE__ */ jsx(
+      "script",
+      {
+        type: "application/ld+json",
+        dangerouslySetInnerHTML: { __html: data }
+      },
+      index
+    ))
+  ] });
+}
+function createPagesBlog(config) {
+  const blog = resolveBlog(config);
+  const { site, revalidate } = blog;
+  function respond(res, body, contentType) {
+    res.setHeader("Content-Type", `${contentType}; charset=utf-8`);
+    res.setHeader(
+      "Cache-Control",
+      `public, s-maxage=${revalidate}, stale-while-revalidate=${revalidate}`
+    );
+    res.end(body);
+    return { props: {} };
+  }
+  function IndexPage({ posts }) {
+    return /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(
+        PageHead,
+        {
+          blog,
+          title: site.title,
+          description: site.description,
+          url: blogUrl(site),
+          image: shareImage(site, void 0),
+          type: "website",
+          structuredData: [indexJsonLd(site, posts)]
+        }
+      ),
+      /* @__PURE__ */ jsx(BlogIndexView, { blog, posts, structuredData: false })
+    ] });
+  }
+  function PostPage({ post }) {
+    return /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(
+        PageHead,
+        {
+          blog,
+          title: post.meta.title,
+          description: post.meta.description,
+          url: postUrl(site, post.slug),
+          image: shareImage(site, post.meta.ogImage),
+          type: "article",
+          structuredData: postJsonLd(site, post)
+        }
+      ),
+      /* @__PURE__ */ jsx(BlogPostView, { blog, post, structuredData: false })
+    ] });
+  }
+  const getIndexStaticProps = async () => {
+    try {
+      return { props: { posts: await blog.source.listPosts() }, revalidate };
+    } catch (error) {
+      if (!isBuildPhase()) throw error;
+      console.error(
+        "[blog] prerendering an empty blog, API unavailable:",
+        error
+      );
+      return { props: { posts: [] }, revalidate: 1 };
+    }
+  };
+  const getPostStaticPaths = async () => ({
+    paths: (await listPostsForRender(blog)).map(({ slug }) => ({
+      params: { slug }
+    })),
+    fallback: "blocking"
+  });
+  const getPostStaticProps = async ({ params }) => {
+    const post = await blog.source.getPost(String(params?.slug ?? ""));
+    if (!post) return { notFound: true, revalidate };
+    return { props: { post }, revalidate };
+  };
+  const getFeedServerSideProps = async ({ res }) => respond(
+    res,
+    feedXml(site, await blog.source.listPosts()),
+    "application/rss+xml"
+  );
+  const getSitemapServerSideProps = async ({ res }) => respond(
+    res,
+    sitemapXml(site, await blog.source.listPosts()),
+    "application/xml"
+  );
+  return {
+    blog,
+    IndexPage,
+    PostPage,
+    getIndexStaticProps,
+    getPostStaticPaths,
+    getPostStaticProps,
+    getFeedServerSideProps,
+    getSitemapServerSideProps,
+    /** The component for the feed and sitemap routes, whose response `getServerSideProps` writes. */
+    EmptyPage: () => null
+  };
+}
+export {
+  createPagesBlog
+};

package/dist/next/routes.d.ts

@@ -0,0 +1,14 @@
+import { type BlogConfig } from "./config.js";
+/**
+ * The App Router's feed and sitemap route handlers:
+ *
+ * - `app/blog/feed.xml/route.ts`: `export const GET = routes.feed`
+ * - `app/blog/sitemap.xml/route.ts`: `export const GET = routes.sitemap`
+ *
+ * Each route file declares `export const revalidate = 60` itself. Links are
+ * absolute, built from the config's `baseUrl` and `basePath`.
+ */
+export declare function createAppBlogRoutes(config: BlogConfig): {
+    feed(): Promise<Response>;
+    sitemap(): Promise<Response>;
+};

package/dist/next/routes.js

@@ -0,0 +1,37 @@
+import {
+  listPostsForRender,
+  resolveBlog
+} from "../chunks/chunk-3GCZFCUK.js";
+import {
+  feedXml,
+  sitemapXml
+} from "../chunks/chunk-TYX2HJZC.js";
+import "../chunks/chunk-AEQDRBA3.js";
+import "../chunks/chunk-XLJBCIXI.js";
+
+// src/next/routes.ts
+function xml(body, contentType) {
+  return new Response(body, {
+    headers: { "Content-Type": `${contentType}; charset=utf-8` }
+  });
+}
+function createAppBlogRoutes(config) {
+  const blog = resolveBlog(config);
+  return {
+    async feed() {
+      return xml(
+        feedXml(blog.site, await listPostsForRender(blog)),
+        "application/rss+xml"
+      );
+    },
+    async sitemap() {
+      return xml(
+        sitemapXml(blog.site, await listPostsForRender(blog)),
+        "application/xml"
+      );
+    }
+  };
+}
+export {
+  createAppBlogRoutes
+};

package/dist/next/views.d.ts

@@ -0,0 +1,18 @@
+import type { Post, PostSummary } from "../content-source.js";
+import { type BlogSite } from "../seo.js";
+import type { ResolvedBlog } from "./config.js";
+/** A share image, or nothing when neither the post nor the site has one. */
+export declare function shareImage(site: BlogSite, ogImage: string | undefined): string | undefined;
+export declare function indexJsonLd(site: BlogSite, posts: PostSummary[]): string;
+export declare function postJsonLd(site: BlogSite, post: Post): string[];
+export declare function BlogIndexView({ blog, posts, structuredData, }: {
+    blog: ResolvedBlog;
+    posts: PostSummary[];
+    /** The Pages Router renders JSON-LD in its `<Head>` instead. */
+    structuredData?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function BlogPostView({ blog, post, structuredData, }: {
+    blog: ResolvedBlog;
+    post: Post;
+    structuredData?: boolean;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/react/components.d.ts

@@ -0,0 +1,18 @@
+import type { ComponentType, ReactNode } from "react";
+import type { z } from "zod";
+import type { ComponentTag, calloutProps, figureProps } from "../registry.js";
+type CalloutProps = z.infer<typeof calloutProps> & {
+    children?: ReactNode;
+    "data-cp-id"?: string;
+};
+export declare function CpCallout({ type, children, ...rest }: CalloutProps): import("react/jsx-runtime").JSX.Element;
+type FigureProps = z.infer<typeof figureProps> & {
+    "data-cp-id"?: string;
+};
+export declare function CpFigure({ src, alt, caption, width, height, ...rest }: FigureProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Each registered component's view. It receives the validated props, plus
+ * `children` for block and inline content.
+ */
+export declare const COMPONENT_VIEWS: Record<ComponentTag, ComponentType<never>>;
+export {};

package/dist/react/index.d.ts

@@ -0,0 +1,2 @@
+export { renderPostBody } from "./render.js";
+export { COMPONENT_VIEWS, CpCallout, CpFigure } from "./components.js";

package/dist/react/index.js

@@ -0,0 +1,15 @@
+import "../chunks/chunk-QX6276YA.js";
+import {
+  COMPONENT_VIEWS,
+  CpCallout,
+  CpFigure,
+  renderPostBody
+} from "../chunks/chunk-AJVVTSKZ.js";
+import "../chunks/chunk-EICE5ONB.js";
+import "../chunks/chunk-XLJBCIXI.js";
+export {
+  COMPONENT_VIEWS,
+  CpCallout,
+  CpFigure,
+  renderPostBody
+};

package/dist/react/render.d.ts

@@ -0,0 +1,7 @@
+import { type ReactNode } from "react";
+/**
+ * Turns post HTML into React. The HTML is always sanitized first, so this is
+ * safe to call on content that came from anywhere; registered `cp-*` tags
+ * become their React component, everything else is plain markup.
+ */
+export declare function renderPostBody(html: string): ReactNode;

package/dist/registry.d.ts

@@ -0,0 +1,95 @@
+import { z } from "zod";
+/**
+ * The single source of truth for what a blog post may contain.
+ *
+ * The sanitizer, the renderer and the `_schema.json` contract are all derived
+ * from this file, so a tag added here is allowed, rendered and published to the
+ * backend validator together. It has no React in it, so server code (and the
+ * backend's bundled schema) can use it; `./react` maps each tag to its view. The backend validates against
+ * the schema that is actually deployed, which is what makes "new components
+ * only work after the deploy that registers them" true.
+ */
+/** Slugs double as file names and URL segments. */
+export declare const SLUG_PATTERN: RegExp;
+/** Attribute every element and component may carry: a stable block id. */
+export declare const BLOCK_ID_ATTRIBUTE = "data-cp-id";
+/** Attribute that carries a component's JSON props. */
+export declare const PROPS_ATTRIBUTE = "data-props";
+export declare const URL_SCHEMES: readonly ["https", "http", "mailto"];
+export interface ElementDefinition {
+    /** Attributes allowed on this element, `data-cp-id` included. */
+    attributes: readonly string[];
+    /** The subset of `attributes` whose value is a URL. */
+    urlAttributes?: readonly string[];
+}
+/** Plain HTML elements a post may use. Everything else is not allowed. */
+export declare const ELEMENTS: Record<string, ElementDefinition>;
+/**
+ * `"block"` components may contain block children, `"inline"` ones inline
+ * children, and `"none"` components are atoms whose props are all their
+ * content.
+ */
+export type ComponentContent = "block" | "inline" | "none";
+export interface ComponentDefinition {
+    attributes: readonly string[];
+    content: ComponentContent;
+    /** Validates the JSON in `data-props`; emitted as JSON Schema. */
+    props: z.ZodType<Record<string, unknown>>;
+}
+export declare const CALLOUT_TYPES: readonly ["info", "warn", "tip"];
+export declare const calloutProps: z.ZodObject<{
+    type: z.ZodEnum<{
+        info: "info";
+        warn: "warn";
+        tip: "tip";
+    }>;
+}, z.core.$strict>;
+export declare const figureProps: z.ZodObject<{
+    src: z.ZodString;
+    alt: z.ZodString;
+    caption: z.ZodOptional<z.ZodString>;
+    width: z.ZodOptional<z.ZodNumber>;
+    height: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const COMPONENTS: {
+    readonly "cp-callout": {
+        readonly attributes: readonly ["data-cp-id", "data-props"];
+        readonly content: "block";
+        readonly props: z.ZodObject<{
+            type: z.ZodEnum<{
+                info: "info";
+                warn: "warn";
+                tip: "tip";
+            }>;
+        }, z.core.$strict>;
+    };
+    readonly "cp-figure": {
+        readonly attributes: readonly ["data-cp-id", "data-props"];
+        readonly content: "none";
+        readonly props: z.ZodObject<{
+            src: z.ZodString;
+            alt: z.ZodString;
+            caption: z.ZodOptional<z.ZodString>;
+            width: z.ZodOptional<z.ZodNumber>;
+            height: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>;
+    };
+};
+export type ComponentTag = keyof typeof COMPONENTS;
+export declare function isComponentTag(tag: string): tag is ComponentTag;
+export declare function isElementTag(tag: string): boolean;
+/** The metadata block at the top of every post file. */
+export declare const postMetaSchema: z.ZodObject<{
+    title: z.ZodString;
+    description: z.ZodString;
+    date: z.ZodString;
+    updated: z.ZodOptional<z.ZodString>;
+    authors: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    ogImage: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<{
+        published: "published";
+        draft: "draft";
+    }>>;
+}, z.core.$loose>;
+export type PostMeta = z.infer<typeof postMetaSchema>;