@codepress/blog 0.0.0-stage → 0.1.0

package/dist/editor/Toolbar.d.ts

@@ -0,0 +1,39 @@
+import { type Editor } from "@tiptap/react";
+import { type ReactElement, type ReactNode } from "react";
+import { type BlogEditorHeader } from "./header.js";
+/** A 32px control: icon buttons, menu triggers and the document actions share it. */
+export declare const toolClass = "inline-flex h-8 min-w-8 shrink-0 items-center justify-center gap-1.5 rounded-md px-2 text-[13px] font-medium text-[#4A4740] transition-colors hover:bg-[#F1EFE9] hover:text-[#111110] focus-visible:ring-2 focus-visible:ring-black/40 focus-visible:outline-none disabled:pointer-events-none disabled:opacity-40 data-[active=true]:bg-[#E8E5DC] data-[active=true]:text-[#111110] data-[state=open]:bg-[#F1EFE9] data-[state=open]:text-[#111110]";
+/** The menus match the site header's dropdown. */
+export declare const menuClass = "rounded-xl border-[#E6E3DA] bg-white p-1.5 text-[#111110] shadow-[0_8px_24px_-8px_rgba(10,10,10,0.16)]";
+export declare const menuItemClass = "flex cursor-pointer items-center gap-2.5 rounded-lg px-2.5 py-2 text-[13px] focus:bg-[#F1EFE9] focus:text-[#111110]";
+export declare function ToolbarSeparator({ className }: {
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;
+/** A hover and focus label, with the keyboard shortcut when there is one. */
+export declare function Tip({ label, shortcut, children, }: {
+    label: string;
+    shortcut?: string;
+    children: ReactElement;
+}): import("react/jsx-runtime").JSX.Element;
+/** `Mod-Shift-8` as the platform writes it: `⌘⇧8` on Apple devices, `Ctrl+Shift+8` elsewhere. */
+export declare function formatShortcut(combo: string, mac: boolean): string;
+export interface ToolbarProps {
+    editor: Editor;
+    /** Publishing or discarding: nothing may change the post. */
+    frozen: boolean;
+    /** Focus is in the title or the metadata, which are plain text. */
+    formattingOff: boolean;
+    linkOpen: boolean;
+    onLinkOpenChange: (open: boolean) => void;
+    /** The document actions (save status, Ask CodePress, Publish…), at the end of the row. */
+    actions?: ReactNode;
+    /** The host page's header the toolbar pins below. */
+    header?: BlogEditorHeader;
+}
+/**
+ * The editor's one toolbar. It spans the page directly under the site header and
+ * stays pinned there: its `top` is the header's measured height, so it can never
+ * slide under it. Formatting sits over the reading column; the document actions
+ * line up with the header's own right edge.
+ */
+export declare function Toolbar({ editor, frozen, formattingOff, linkOpen, onLinkOpenChange, actions, header, }: ToolbarProps): import("react/jsx-runtime").JSX.Element;

package/dist/editor/blocks.d.ts

@@ -0,0 +1,5 @@
+import type { SlashItem } from "./slash-command.js";
+/** Every block the `/` menu offers. */
+export declare const SLASH_ITEMS: SlashItem[];
+/** The toolbar's Insert menu: the same items as the `/` menu, minus the text blocks. */
+export declare const INSERT_ITEMS: SlashItem[];

package/dist/editor/client.d.ts

@@ -0,0 +1,88 @@
+/**
+ * The draft API client, with no editor code in it: a host can read what the
+ * caller may do, or publish, without downloading Tiptap.
+ */
+/** Supplies the caller's CodePress token; the client never reads storage itself. */
+export interface BlogEditorAuth {
+    getToken(): Promise<string | null>;
+    /** Sees every response, for a host that refreshes its token from a response header. */
+    onResponse?(response: Response): void;
+}
+/** The draft API's shapes; see `apps/backend/apps/content_sites/schemas.py`. */
+export interface DraftFile {
+    slug: string;
+    /** `draft` (the branch's file), `published` (the default branch's) or `new`. */
+    source: "draft" | "published" | "new";
+    html: string;
+    /** A git site's file blob sha; a database site's revision id. */
+    base_sha: string | null;
+    branch: string;
+    head_sha: string | null;
+    pr_number: number | null;
+    pr_url: string | null;
+    /** Where the site keeps its posts; absent (an older backend) means git. */
+    storage?: "git" | "db";
+    /** A database site's per-post revision count, from 1; null on a git site. */
+    revision?: number | null;
+}
+export interface Violation {
+    kind: string;
+    reason: string;
+    tag?: string | null;
+    attribute?: string | null;
+    prop?: string | null;
+}
+export interface Capabilities {
+    can_edit: boolean;
+    can_publish: boolean;
+    /** The site's organization; present when the caller can edit. */
+    organization_id?: string | null;
+    /** The org that owns the site and the repo its posts live in; set for editors only. */
+    organization_slug?: string | null;
+    repository_full_name?: string | null;
+}
+export type SaveResult = {
+    kind: "saved";
+    draft: DraftFile;
+} | {
+    kind: "conflict";
+    current: DraftFile;
+} | {
+    kind: "rejected";
+    detail: string;
+    violations: Violation[];
+} | {
+    kind: "error";
+    message: string;
+};
+export type ActionResult = {
+    kind: "ok";
+} | {
+    kind: "rejected";
+    detail: string;
+    violations: Violation[];
+} | {
+    kind: "error";
+    message: string;
+    status?: number;
+};
+export interface DraftClient {
+    getCapabilities(site: string): Promise<Capabilities | null>;
+    getDraft(site: string, slug: string): Promise<{
+        draft: DraftFile;
+    } | {
+        error: string;
+    }>;
+    saveDraft(site: string, slug: string, html: string, baseSha: string | null): Promise<SaveResult>;
+    publishDraft(site: string, slug: string): Promise<ActionResult>;
+    discardDraft(site: string, slug: string): Promise<ActionResult>;
+}
+/**
+ * A client for the content-site draft API at `apiBase` (the backend's `/v1`
+ * root). Every request carries `auth.getToken()` as its bearer token, and only
+ * that one.
+ */
+export declare function createDraftClient({ apiBase, auth, }: {
+    apiBase: string;
+    auth: BlogEditorAuth;
+}): DraftClient;

package/dist/editor/client.js

@@ -0,0 +1,6 @@
+import {
+  createDraftClient
+} from "../chunks/chunk-3WRTL63O.js";
+export {
+  createDraftClient
+};

package/dist/editor/component-node.d.ts

@@ -0,0 +1,14 @@
+import { Node } from "@tiptap/react";
+import { type ComponentTag } from "../index.js";
+/** Props a component starts with when inserted from the slash menu. */
+export declare const DEFAULT_PROPS: Record<ComponentTag, Record<string, unknown>>;
+/** `cp-callout` -> `cpCallout`. */
+export declare function componentNodeName(tag: string): string;
+/**
+ * One editor node per registry component: parsed from and rendered to the
+ * same `<cp-*>` tag the post file uses, with the props JSON kept in one
+ * attribute and edited through a form generated from the zod schema.
+ */
+export declare function componentNode(tag: ComponentTag): Node<{
+    tag: "cp-callout" | "cp-figure";
+}, any>;

package/dist/editor/config.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Editor timings and layout defaults. Every timing has a production default
+ * and a prop override (`timings`), so a host or QA can compress the clock.
+ */
+export interface BlogEditorTimings {
+    /** Quiet time after the last keystroke before the draft is saved. */
+    autosaveMs: number;
+    /** How often an open editor checks whether the draft changed elsewhere. */
+    draftPollMs: number;
+    /** How long the "published" notice shows before `onPublished` runs. */
+    publishReloadMs: number;
+}
+export declare const DEFAULT_TIMINGS: BlogEditorTimings;
+/** The defaults, with each override that is a positive number. */
+export declare function resolveTimings(timings: Partial<BlogEditorTimings> | undefined): BlogEditorTimings;
+/** The reading column the editor lays its title and body out in. */
+export declare const DEFAULT_COLUMN = "mx-auto w-full max-w-[720px] px-5 sm:px-8";
+/** Where the CodePress app lives: Ask CodePress, Edit design and History open there. */
+export declare const DEFAULT_APP_URL = "https://codepress.dev";
+/**
+ * CSS variable the toolbar sets on the document root while it is mounted: the
+ * viewport y of its bottom edge. Floating panels (Ask CodePress) keep below it.
+ */
+export declare const BLOG_TOOLBAR_BOTTOM_VAR = "--blog-toolbar-bottom";

package/dist/editor/document.d.ts

@@ -0,0 +1,47 @@
+/**
+ * The post file as text, split so an edit only rewrites the blocks that
+ * changed. Everything the author wrote around an unchanged block (its own
+ * line wrapping, the blank lines between blocks) is kept byte for byte, so a
+ * draft PR's diff shows the edited blocks and nothing else.
+ */
+export interface PostSource {
+    /** Text before the metadata block (normally empty). */
+    prefix: string;
+    /** The metadata block exactly as written, or `""` when there is none. */
+    metaText: string;
+    meta: Record<string, unknown>;
+    blocks: SourceBlock[];
+    /** `gaps[i]` is the text before `blocks[i]`; the last entry trails the file. */
+    gaps: string[];
+    /** Reasons this file cannot be edited in place; empty when it can. */
+    problems: string[];
+}
+export interface SourceBlock {
+    id: string | null;
+    tag: string;
+    text: string;
+}
+/** Splits a post file into its metadata block and top-level body blocks. */
+export declare function parsePostSource(source: string): PostSource;
+/** The metadata block in the layout the seed post uses. */
+export declare function serializeMeta(meta: Record<string, unknown>): string;
+/**
+ * A body block after editing. `sourceIndex` is set when it is unchanged;
+ * `replaces` is the source block an edited block came from (unset for a new one).
+ */
+export interface EditedBlock {
+    html: string;
+    sourceIndex: number | null;
+    replaces?: number | null;
+}
+/**
+ * Writes the post file. Unchanged blocks and the metadata block (when its
+ * values did not change) keep their original text and spacing.
+ */
+export declare function assemblePostFile(source: PostSource | null, meta: Record<string, unknown>, blocks: EditedBlock[]): string;
+/**
+ * A comparison form of a block: the same for two spellings of the same
+ * content (whitespace, attribute order, quoting, entity form), and ignoring
+ * `data-cp-id`, which the editor assigns to blocks that have none.
+ */
+export declare function canonicalBlock(html: string): string;

package/dist/editor/extensions.d.ts

@@ -0,0 +1,19 @@
+import { type Extensions } from "@tiptap/react";
+import { type SlashItem, type SlashState } from "./slash-command.js";
+export declare function generateBlockId(): string;
+/** UniqueID names the node attribute `cp-id` and writes it to HTML as `data-cp-id`. */
+export declare const BLOCK_ID_NODE_ATTRIBUTE: string;
+export interface EditorHooks {
+    isFrozen?: () => boolean;
+    onSlash?: (state: SlashState | null) => void;
+    onPasteRejected?: (reasons: string[]) => void;
+    slashItems?: SlashItem[];
+    onLinkShortcut?: () => void;
+}
+/**
+ * Everything a post may contain and nothing else: the elements the registry
+ * allows, one node per registered component, and a stable `data-cp-id` on each
+ * block. Marks and nodes outside the schema (strike, underline, tables) are
+ * turned off so the editor cannot produce content the backend would reject.
+ */
+export declare function editorExtensions(hooks?: EditorHooks): Extensions;

package/dist/editor/header.d.ts

@@ -0,0 +1,20 @@
+import { type RefObject } from "react";
+/** The host page's header, which the toolbar pins directly below. */
+export interface BlogEditorHeader {
+    /** The header element; defaults to `[data-blog-header]`, then the page's first `header`. */
+    selector?: string;
+    /** A fixed distance from the top of the viewport, used instead of measuring a header. */
+    offset?: number;
+}
+export declare const DEFAULT_HEADER_SELECTOR = "[data-blog-header]";
+/**
+ * The host's header: the selector's match, else the first `header` element
+ * outside the editor itself (its title block is a `header` too), else none.
+ */
+export declare function findHostHeader(selector: string | undefined, editorRoot: Element | null): HTMLElement | null;
+/**
+ * How far from the top the toolbar pins: the host header's height, measured
+ * and followed as it changes (a mobile menu opening), or `offset` when given,
+ * or 0 when the page has no header.
+ */
+export declare function useHeaderOffset(header: BlogEditorHeader | undefined, own: RefObject<HTMLElement | null>): number;

package/dist/editor/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * `@codepress/blog/editor`: the in-place editor. Client-only; the Tiptap
+ * editor itself is a lazy chunk that loads when someone who can edit clicks
+ * Edit, so importing this entry downloads no ProseMirror code.
+ */
+export { BlogEditorMount, appPageUrl, type AskPanelProps, type BlogEditorMountProps, type DesignLinkContext, } from "./BlogEditorMount.js";
+export { NewPostForm, isValidNewSlug, type NewPostFormProps, } from "./NewPostForm.js";
+export { BLOG_TOOLBAR_BOTTOM_VAR, DEFAULT_TIMINGS, type BlogEditorTimings, } from "./config.js";
+export { DEFAULT_HEADER_SELECTOR, type BlogEditorHeader } from "./header.js";
+export { designUrl, type DesignTarget } from "./EditDesignLink.js";
+export * from "./client.js";

package/dist/editor/index.js

@@ -0,0 +1,209 @@
+import {
+  createDraftClient
+} from "../chunks/chunk-3WRTL63O.js";
+import {
+  BLOG_TOOLBAR_BOTTOM_VAR,
+  DEFAULT_APP_URL,
+  DEFAULT_COLUMN,
+  DEFAULT_HEADER_SELECTOR,
+  DEFAULT_TIMINGS,
+  designTargetOf,
+  designUrl
+} from "../chunks/chunk-UA243KAQ.js";
+import {
+  SLUG_PATTERN
+} from "../chunks/chunk-XLJBCIXI.js";
+
+// src/editor/BlogEditorMount.tsx
+import {
+  Suspense,
+  lazy,
+  useEffect,
+  useMemo,
+  useState
+} from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var BlogEditor = lazy(() => import("../chunks/BlogEditor-VF3UAJB6.js"));
+function appPageUrl(appUrl, organizationSlug, site, slug, tab) {
+  if (!organizationSlug) return `${appUrl}/dashboard`;
+  const query = new URLSearchParams({ site, post: slug });
+  if (tab) query.set("tab", tab);
+  return `${appUrl}/dashboard/${encodeURIComponent(organizationSlug)}/apps?${query.toString()}`;
+}
+function BlogEditorMount({
+  site,
+  slug,
+  apiBase,
+  auth,
+  isNew = false,
+  header,
+  column = DEFAULT_COLUMN,
+  appUrl = DEFAULT_APP_URL,
+  timings,
+  onEditingChange,
+  onPublished,
+  onLeave,
+  slots,
+  actions
+}) {
+  const client = useMemo(
+    () => createDraftClient({ apiBase, auth }),
+    [apiBase, auth]
+  );
+  const [capabilities, setCapabilities] = useState(null);
+  const [checked, setChecked] = useState(false);
+  const [editing, setEditing] = useState(isNew);
+  const [ask, setAsk] = useState("closed");
+  useEffect(() => {
+    let cancelled = false;
+    void client.getCapabilities(site).then((result) => {
+      if (cancelled) return;
+      setCapabilities(result);
+      setChecked(true);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [client, site]);
+  const changeEditing = (next) => {
+    setEditing(next);
+    onEditingChange?.(next);
+  };
+  if (!checked) return null;
+  if (!capabilities?.can_edit) {
+    return isNew ? /* @__PURE__ */ jsx("p", { "data-testid": "blog-no-access", children: "You do not have access to write blog posts." }) : null;
+  }
+  const organizationId = capabilities.organization_id;
+  const organizationSlug = capabilities.organization_slug;
+  const askPanel = ask !== "closed" && organizationId && slots?.askPanel ? slots.askPanel({
+    site,
+    slug,
+    organizationId,
+    open: ask === "open",
+    onClose: () => setAsk("hidden")
+  }) : null;
+  const target = designTargetOf(capabilities);
+  const designHref = target ? slots?.designLink?.({ slug, ...target }) ?? designUrl(target, slug, appUrl) : null;
+  if (!editing) {
+    return /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(
+        "button",
+        {
+          type: "button",
+          className: "fixed right-6 bottom-6 z-40 rounded-full bg-[#111110] px-5 py-2.5 text-sm font-medium text-white shadow-lg",
+          "data-testid": "blog-edit-button",
+          onClick: () => changeEditing(true),
+          children: "Edit"
+        }
+      ),
+      askPanel
+    ] });
+  }
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(
+      Suspense,
+      {
+        fallback: /* @__PURE__ */ jsx(
+          "p",
+          {
+            className: `${column} pt-10 pb-20 sm:pt-14`,
+            "data-testid": "blog-editor-loading",
+            children: "Loading the editor\u2026"
+          }
+        ),
+        children: /* @__PURE__ */ jsx(
+          BlogEditor,
+          {
+            site,
+            slug,
+            client,
+            timings,
+            column,
+            header,
+            canPublish: capabilities.can_publish,
+            designHref,
+            historyHref: appPageUrl(
+              appUrl,
+              organizationSlug,
+              site,
+              slug,
+              "history"
+            ),
+            onAsk: organizationId && slots?.askPanel ? () => setAsk((current) => current === "open" ? "hidden" : "open") : void 0,
+            askHref: actions?.askCodePress?.href ?? appPageUrl(appUrl, organizationSlug, site, slug),
+            askIconSrc: `${appUrl}/logo-mark-square.png`,
+            askOpen: ask === "open",
+            onExit: () => isNew ? onLeave?.() : changeEditing(false),
+            onPublished: () => onPublished ? onPublished(slug) : window.location.reload(),
+            onDiscarded: () => isNew ? onLeave?.() : window.location.reload()
+          }
+        )
+      }
+    ),
+    askPanel
+  ] });
+}
+
+// src/editor/NewPostForm.tsx
+import { useState as useState2 } from "react";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var RESERVED_SLUGS = /* @__PURE__ */ new Set(["new"]);
+function isValidNewSlug(slug) {
+  return SLUG_PATTERN.test(slug) && !RESERVED_SLUGS.has(slug);
+}
+function NewPostForm({ onStart, prefix = "/blog/" }) {
+  const [draftSlug, setDraftSlug] = useState2("");
+  const valid = isValidNewSlug(draftSlug);
+  return /* @__PURE__ */ jsxs2(
+    "form",
+    {
+      "data-testid": "blog-new-form",
+      onSubmit: (event) => {
+        event.preventDefault();
+        if (valid) onStart(draftSlug);
+      },
+      children: [
+        /* @__PURE__ */ jsx2("h1", { className: "text-[34px] font-medium tracking-[-0.03em] text-[#111110]", children: "New post" }),
+        /* @__PURE__ */ jsxs2("label", { className: "mt-6 block text-sm text-[#6B6760]", children: [
+          "Address",
+          /* @__PURE__ */ jsxs2("div", { className: "mt-1 flex items-center gap-1 text-[#111110]", children: [
+            /* @__PURE__ */ jsx2("span", { children: prefix }),
+            /* @__PURE__ */ jsx2(
+              "input",
+              {
+                className: "w-full rounded-md border border-[#D9D5CC] px-2 py-1",
+                placeholder: "my-first-post",
+                "aria-label": "Post address",
+                "data-testid": "blog-new-slug",
+                value: draftSlug,
+                onChange: (event) => setDraftSlug(event.target.value)
+              }
+            )
+          ] })
+        ] }),
+        draftSlug && !valid ? /* @__PURE__ */ jsx2("p", { className: "mt-2 text-sm text-red-600", children: "Use lowercase letters, numbers and single hyphens." }) : null,
+        /* @__PURE__ */ jsx2(
+          "button",
+          {
+            type: "submit",
+            className: "mt-4 rounded-md bg-[#111110] px-4 py-2 text-sm text-white disabled:opacity-50",
+            "data-testid": "blog-new-start",
+            disabled: !valid,
+            children: "Start writing"
+          }
+        )
+      ]
+    }
+  );
+}
+export {
+  BLOG_TOOLBAR_BOTTOM_VAR,
+  BlogEditorMount,
+  DEFAULT_HEADER_SELECTOR,
+  DEFAULT_TIMINGS,
+  NewPostForm,
+  appPageUrl,
+  createDraftClient,
+  designUrl,
+  isValidNewSlug
+};

package/dist/editor/paste-guard.d.ts

@@ -0,0 +1,14 @@
+import { Extension } from "@tiptap/react";
+/**
+ * What in a pasted fragment the editor refuses rather than flattens. Ordinary
+ * web markup (`div`, `span`, styles) is normalized by the schema like any
+ * paste; scripts, event handlers, unsafe URLs, invalid component props and
+ * unregistered `cp-*` tags are rejected out loud so nobody wonders where they
+ * went.
+ */
+export declare function pasteRejections(html: string): string[];
+interface PasteGuardOptions {
+    onReject: (reasons: string[]) => void;
+}
+export declare const PasteGuard: Extension<PasteGuardOptions, any>;
+export {};

package/dist/editor/primitives.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The menu and tooltip primitives the toolbar uses: Radix, with the classes
+ * and markup of the CodePress UI kit's own wrappers, so the package needs no
+ * private dependency and the toolbar renders exactly as it does in the app.
+ */
+import * as DropdownMenuPrimitive from "@radix-ui/react-dropdown-menu";
+import * as TooltipPrimitive from "@radix-ui/react-tooltip";
+import type { ComponentProps } from "react";
+export declare function DropdownMenu(props: ComponentProps<typeof DropdownMenuPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+export declare function DropdownMenuTrigger(props: ComponentProps<typeof DropdownMenuPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+export declare function DropdownMenuContent({ className, sideOffset, ...props }: ComponentProps<typeof DropdownMenuPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
+export declare function DropdownMenuItem({ className, ...props }: ComponentProps<typeof DropdownMenuPrimitive.Item>): import("react/jsx-runtime").JSX.Element;
+export declare function DropdownMenuSeparator({ className, ...props }: ComponentProps<typeof DropdownMenuPrimitive.Separator>): import("react/jsx-runtime").JSX.Element;
+/** Each tooltip carries its own provider, so a host needs no provider around the editor. */
+export declare function Tooltip(props: ComponentProps<typeof TooltipPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+export declare function TooltipTrigger(props: ComponentProps<typeof TooltipPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+export declare function TooltipContent({ className, sideOffset, children, ...props }: ComponentProps<typeof TooltipPrimitive.Content>): import("react/jsx-runtime").JSX.Element;

package/dist/editor/props-form.d.ts

@@ -0,0 +1,17 @@
+import { z } from "zod";
+interface Field {
+    name: string;
+    kind: "enum" | "text" | "number" | "boolean";
+    options: string[];
+    required: boolean;
+}
+/** The editable fields of a component's props, read from its zod schema. */
+export declare function fieldsFor(schema: z.ZodType): Field[];
+interface PropsFormProps {
+    schema: z.ZodType;
+    value: Record<string, unknown>;
+    onChange: (next: Record<string, unknown>) => void;
+}
+/** A form generated from a props schema; it edits the props object in place. */
+export declare function PropsForm({ schema, value, onChange }: PropsFormProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/editor/serialize.d.ts

@@ -0,0 +1,34 @@
+import { type Node as ProseMirrorNode, type Schema } from "@tiptap/pm/model";
+import { type EditedBlock, type PostSource } from "./document.js";
+/** The ProseMirror schema the editor uses; built once. */
+export declare function postSchema(): Schema;
+/** The HTML of one top-level editor node, in the file's own conventions. */
+export declare function nodeToHtml(schema: Schema, node: ProseMirrorNode): string;
+/**
+ * Why a source file cannot be edited without loss: structural problems from
+ * parsing, and each block that would come out different after the editor
+ * loads and writes it back (unknown markup, unsupported elements).
+ */
+export declare function editabilityProblems(source: PostSource): string[];
+/**
+ * The source body as the editor's initial content, with an id on every block.
+ * Blocks the author left without a `data-cp-id` get one here, so each loaded
+ * block maps to its source block by id from the first keystroke; the injected
+ * id only reaches the file if that block is edited.
+ */
+export declare function sourceBodyHtml(source: PostSource): {
+    html: string;
+    indexById: Map<string, number>;
+};
+/** Maps each block's `data-cp-id` in the loaded document to its source block. */
+export declare function blockIndexById(doc: ProseMirrorNode): Map<string, number>;
+/** The current document as blocks, reusing source text for the unchanged ones. */
+export declare function editedBlocks(doc: ProseMirrorNode, source: PostSource | null, indexById: Map<string, number>): EditedBlock[];
+export interface LocalProblem {
+    message: string;
+}
+/**
+ * What the backend would reject, found before saving: the same registry
+ * checks the sanitizer applies, plus the metadata shape.
+ */
+export declare function localProblems(meta: Record<string, unknown>, blocks: EditedBlock[]): LocalProblem[];

package/dist/editor/slash-command.d.ts

@@ -0,0 +1,21 @@
+import { Extension, type Editor, type Range } from "@tiptap/react";
+export interface SlashItem {
+    id: string;
+    title: string;
+    description: string;
+    run: (editor: Editor, range: Range) => void;
+}
+/** What the menu component needs to draw itself and pick an item. */
+export interface SlashState {
+    items: SlashItem[];
+    index: number;
+    rect: DOMRect | null;
+    choose: (index: number) => void;
+}
+interface SlashOptions {
+    items: SlashItem[];
+    onState: (state: SlashState | null) => void;
+}
+/** Typing `/` at the start of a block opens a menu of blocks to insert. */
+export declare const SlashCommand: Extension<SlashOptions, any>;
+export {};

package/dist/feed.d.ts

@@ -0,0 +1,4 @@
+import type { PostSummary } from "./content-source.js";
+import { type BlogSite } from "./seo.js";
+/** An RSS 2.0 feed of `posts`, newest first. */
+export declare function feedXml(site: BlogSite, posts: PostSummary[]): string;

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./registry.js";
+export * from "./sanitize.js";
+export * from "./schema.js";
+export * from "./seo.js";
+export * from "./feed.js";
+export * from "./sitemap.js";
+export * from "./content-source.js";
+export { escapeXml } from "./xml.js";