@vespercms/admin 0.0.0-stage → 0.1.0-next.1

package/dist/a11y/FieldNotes.d.ts

@@ -0,0 +1,23 @@
+import type { A11yNote } from '@vespercms/core';
+import type { ReactNode } from 'react';
+/** A note's words: what it's about, the problem, and why it matters (spec §6.18). */
+export declare function NoteText({ note }: {
+    note: A11yNote;
+}): import("react").JSX.Element;
+/**
+ * Accessibility notes under the field they're about. Text, never a coloured
+ * badge (spec §10.4): the small warning mark is the only colour, and the
+ * words say what it is. The list is part of the control's description.
+ */
+export declare function FieldNotes({ id, notes }: {
+    id: string;
+    notes: readonly A11yNote[];
+}): import("react").JSX.Element;
+/**
+ * One note the studio writes itself, not from a rule (a replaced image's alt
+ * text), in the same words and mark as the rules' notes beside a field.
+ */
+export declare function FieldNote({ id, children }: {
+    id: string;
+    children: ReactNode;
+}): import("react").JSX.Element;

package/dist/a11y/NotesDrawer.d.ts

@@ -0,0 +1,23 @@
+import type { A11yNote } from '@vespercms/core';
+/** The notes about one field (or the body), under its name. */
+export type NoteGroup = {
+    key: string;
+    label: string;
+    notes: A11yNote[];
+};
+/** "2 accessibility notes", and how many refuse a save under the site's gate. */
+export declare function notesCount(notes: number, blocking: number): string;
+/**
+ * Every accessibility note on the entry (spec §6.18), opened from the count
+ * in the top bar: grouped under each field's name in form order, each with
+ * why it matters and "Go to field". A modal drawer: focus moves in, Escape
+ * closes it, and focus returns to the count.
+ */
+export declare function NotesDrawer({ isOpen, onOpenChange, groups, isBlocking, onGo, }: {
+    isOpen: boolean;
+    onOpenChange: (open: boolean) => void;
+    groups: readonly NoteGroup[];
+    isBlocking: (note: A11yNote) => boolean;
+    /** Closes the drawer and takes focus to the note's field. */
+    onGo: (note: A11yNote) => void;
+}): import("react").JSX.Element;

package/dist/a11y/pdf.d.ts

@@ -0,0 +1,3 @@
+import type { PdfFacts } from '@vespercms/core';
+/** Reads the facts the PDF rules need. Nothing is rendered, and no script in the file runs. */
+export declare function readPdfFacts(bytes: ArrayBuffer | Uint8Array): Promise<PdfFacts>;

package/dist/a11y/run.d.ts

@@ -0,0 +1,3 @@
+import { entryChecker, type Manifest } from '@vespercms/core';
+export declare function a11yChecker(manifest: Manifest): ReturnType<typeof entryChecker>;
+export { pdfNotes } from '@vespercms/core';

package/dist/a11y/useNotes.d.ts

@@ -0,0 +1,28 @@
+import { type A11yNote, type BodyFormat, type CollectionManifest, type DataObject, type Manifest, type PdfTarget } from '@vespercms/core';
+export type EntryNotes = {
+    /** Field notes in form order, then the body's, then the PDFs'. */
+    notes: A11yNote[];
+    /** PDFs the entry points at. */
+    pdfs: PdfTarget[];
+};
+export type EntryNotesResult = EntryNotes & {
+    /** Checks the current values now, without the pause (for a save). PDFs keep their last result. */
+    recheck: () => Promise<A11yNote[]>;
+};
+/**
+ * The entry's accessibility notes (spec §6.18, layer 1), checked a moment
+ * after typing stops, the same pause as the body's validation. PDFs are read
+ * with PDF.js, and their notes join when they have been.
+ */
+export declare function useEntryNotes(options: {
+    manifest: Manifest;
+    collection: CollectionManifest;
+    values: DataObject;
+    /** The body without its leading line breaks, as the body editor has it. */
+    body: string | undefined;
+    format: BodyFormat;
+    /** The entry's file, which relative PDF paths are resolved against. */
+    entryPath: string;
+    /** Where the studio reads a site file from. */
+    fileUrl: (path: string) => Promise<string>;
+}): EntryNotesResult;

package/dist/app/App.d.ts

@@ -0,0 +1,2 @@
+import type { StudioOptions } from '../types.ts';
+export declare function App({ manifest, api, widgets, loadMdxProps, siteName, siteUrl, github, routes, loadUrlFunctions, account, cloud, connection, }: StudioOptions): import("react").JSX.Element;

package/dist/app/Screen.d.ts

@@ -0,0 +1,88 @@
+import { type IconName, type IconNode } from '@vespercms/ui';
+import { type ReactNode, type Ref, type RefObject, type UIEvent } from 'react';
+export type ScreenProps = {
+    /** The screen's one `h1`, and the start of the page title. */
+    title: string;
+    /** Visually hide the `h1` when the screen shows its title another way (the editor's title field). */
+    hideTitle?: boolean;
+    /** Replaces the top bar's middle and right side (the editor's bar, spec §10.3). */
+    bar?: ReactNode;
+    /** The accent's wash at the top of a welcoming screen: home and empty states, never a form. */
+    afterglow?: boolean;
+    /** Line the heading up with the editor's 720px column. */
+    column?: boolean;
+    /** An icon before the heading: a collection's. */
+    icon?: {
+        node: IconNode;
+    } | {
+        name: IconName;
+    };
+    children: ReactNode;
+};
+/**
+ * Every screen's frame: the skip link, the top bar, and `<main>` with one
+ * `h1` (spec §10.6). After an in-app navigation, focus moves to the new
+ * screen's heading, so keyboard and screen-reader users land on the content
+ * they asked for instead of at the top of the page.
+ *
+ * Inside the pane shell (app/panes.tsx) a screen is the deepest pane
+ * instead: its heading and bar head the pane, and it scrolls on its own,
+ * beneath them.
+ */
+export declare function Screen({ title, hideTitle, bar, afterglow, column, icon, children, }: ScreenProps): import("react").JSX.Element;
+/**
+ * The pane, or the screen, that leads names the browser tab, and takes focus
+ * after an in-app navigation (spec §10.6). Among panes that's the deepest.
+ */
+export declare function useLeadHeading(title: string, heading: RefObject<HTMLElement | null>): void;
+/**
+ * An element's width or height in pixels, kept current as it wraps or the
+ * window changes: give it the returned ref. A callback ref, never a ref
+ * object, because what's measured may be replaced or come and go: the top
+ * bar among panes leaves as the window narrows and comes back new as it
+ * widens, and a ref object went on measuring the bar that left, at 0, so
+ * every pane's header sat beneath the new one. The editor's bar moves from
+ * the top bar into a pane's header the same way.
+ */
+export declare function useMeasure(side: 'width' | 'height', fallback: number): [(element: HTMLElement | null) => void, number];
+/**
+ * A pane's frame: a landmark named by its heading, a header with the heading,
+ * the pane's actions and its collapse button (and the list's tools, as
+ * `toolbar`), then the pane's body. The deepest pane is the page's `main`,
+ * with its `h1`; the others are navigation, or a region, with `h2`s. The
+ * element stays the same as a pane's role changes, so what's in it isn't
+ * drawn afresh when an entry opens beside it.
+ *
+ * The frame is the pane's scroller, and it starts at the window's top: its
+ * body scrolls beneath its own header and the top bar, which are glass, so
+ * the content stays present beneath what floats (DECISIONS.md, "Panes scroll
+ * beneath glass"). Its scroll padding keeps a focused control clear of both.
+ */
+export declare function PaneFrame({ title, headingRef, hideTitle, icon, actions, toolbar, scrollRef, onScroll, className, children, }: {
+    title: string;
+    headingRef: RefObject<HTMLHeadingElement | null>;
+    hideTitle?: boolean;
+    icon?: {
+        node: IconNode;
+    } | {
+        name: IconName;
+    } | undefined;
+    actions?: ReactNode;
+    /** Below the heading, in the header that stays put: the list's search, Sort and Show. */
+    toolbar?: ReactNode;
+    scrollRef?: RefObject<HTMLDivElement | null>;
+    onScroll?: (event: UIEvent<HTMLDivElement>) => void;
+    className?: string | false | undefined;
+    children: ReactNode;
+}): import("react").JSX.Element;
+/**
+ * The skip link and the top bar. One screen at a time, it holds the screen's
+ * bar (the menus, or the editor's own); among panes it spans the full width
+ * and holds what's the person's, since the structure pane holds the site's.
+ */
+export declare function StudioHeader({ bar, headerRef, homeLink, }: {
+    bar?: ReactNode;
+    headerRef?: Ref<HTMLElement>;
+    /** False drops the site's name, the link home, on a narrow screen (the editor's bar). */
+    homeLink?: boolean;
+}): import("react").JSX.Element;

package/dist/app/UserMenu.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The user menu at the end of the top bar (spec §10.3): who is signed in and
+ * the way out in GitHub mode and the cloud (spec §6.9), and Appearance in
+ * every mode, local mode included, named by git's user there (DECISIONS.md,
+ * "Appearance is in the user menu, and local mode has a user menu").
+ */
+export declare function UserMenu(): import("react").JSX.Element;

package/dist/app/api.d.ts

@@ -0,0 +1,75 @@
+import type { CollectionSummary, EntryDocument, EntrySummary, MediaItem, MoveRequest, MoveResult, PageLink, ScheduledChange, PageTree, RedirectsDocument, ReorderEntryRequest, ReorderEntryResult, ReorderRequest, ReorderResult, SaveRedirectsRequest, SaveRedirectsResult, SaveRequest, SaveResponse, UploadResponse } from '@vespercms/core';
+/**
+ * Everything the studio needs from a storage back end. Local mode talks to
+ * the dev middleware; GitHub and cloud modes (Phases 3 and 4) implement the
+ * same interface, so screens never know which mode they're in.
+ */
+export interface StudioApi {
+    summary(): Promise<CollectionSummary[]>;
+    listEntries(collection: string): Promise<EntrySummary[]>;
+    readEntry(collection: string, id: string): Promise<EntryDocument>;
+    saveEntry(request: SaveRequest): Promise<SaveResponse>;
+    deleteEntry(collection: string, id: string, version: string): Promise<SaveResponse>;
+    listMedia(): Promise<MediaItem[]>;
+    /**
+     * Stores an upload. `withNextSave`: where saving publishes, the file waits
+     * and goes out with the next save, so an entry and its image are one
+     * commit (spec §6.8). Local mode writes it at once either way.
+     */
+    upload(file: Blob, name: string, folder: string, options?: {
+        withNextSave?: boolean;
+    }): Promise<UploadResponse>;
+    deleteMedia(path: string): Promise<SaveResponse>;
+    /** Site-relative paths of the Markdoc and Markdown files a `{% partial %}` can point at. */
+    listPartials(): Promise<string[]>;
+    /**
+     * A URL the studio can show a file from, given its site-relative path.
+     * Asynchronous: GitHub mode fetches the blob and hands back an object URL.
+     */
+    fileUrl(path: string): Promise<string>;
+    /** Every page with a URL, in every collection, for the link picker (spec §6.15.6). */
+    listPages(): Promise<PageLink[]>;
+    /** Every change still to come in the site's scheduled collections, soonest first (spec §6.17). */
+    listScheduled(): Promise<ScheduledChange[]>;
+    /** A tree collection's outline (spec §6.15.2). */
+    pageTree(collection: string): Promise<PageTree>;
+    /** Moves a page and everything under it; `dryRun` only describes what would happen. */
+    movePage(request: MoveRequest, options?: {
+        dryRun?: boolean;
+    }): Promise<MoveResult>;
+    reorderPage(request: ReorderRequest): Promise<ReorderResult>;
+    /** Puts an entry of a collection with `orderBy` in a new place, by writing its order numbers. */
+    reorderEntry(request: ReorderEntryRequest): Promise<ReorderEntryResult>;
+    /** Creates the missing section page of a folder in the tree. */
+    createSection(collection: string, path: string): Promise<SaveResponse>;
+    readRedirects(): Promise<RedirectsDocument>;
+    saveRedirects(request: SaveRedirectsRequest): Promise<SaveRedirectsResult>;
+    /**
+     * Whether Save publishes (GitHub and cloud modes) or only writes the file on
+     * this computer (local mode), where the site's publish gate can be saved past.
+     */
+    publishesOnSave(): boolean;
+    /**
+     * Local mode only: who is editing, from git's `user.name` on this computer,
+     * for the user menu (DECISIONS.md, "Appearance is in the user menu").
+     */
+    person?(): Promise<{
+        name: string | null;
+    }>;
+}
+export declare class ApiError extends Error {
+    readonly status: number;
+    constructor(status: number, message: string);
+}
+/** The header every studio request carries (spec §6.7). */
+export declare const STUDIO_HEADER = "X-Vesper";
+/**
+ * The local-mode client (spec §6.7). Every request carries the `X-Vesper`
+ * header: the dev middleware refuses requests without it, so another site
+ * open in the same browser can't reach it with a simple cross-origin request.
+ *
+ * Saves answer with a `SaveResponse` even when they fail (a conflict or an
+ * invalid value is an answer, not an error). Anything else that isn't 2xx
+ * throws an `ApiError`.
+ */
+export declare function createLocalApi(base: string, fetcher?: typeof fetch): StudioApi;

package/dist/app/appearance.d.ts

@@ -0,0 +1,10 @@
+export type Appearance = 'system' | 'light' | 'dark';
+export declare const APPEARANCE_KEY = "vesper:appearance";
+export declare const APPEARANCES: readonly {
+    id: Appearance;
+    label: string;
+}[];
+export declare function readAppearance(): Appearance;
+export declare function applyAppearance(appearance: Appearance): void;
+export declare function saveAppearance(appearance: Appearance): void;
+export declare function useAppearance(): [Appearance, (appearance: Appearance) => void];

package/dist/app/browser-api.d.ts

@@ -0,0 +1,17 @@
+import { type Manifest, type StorageAdapter, type UrlEntry } from '@vespercms/core';
+import { type StudioApi } from './api.ts';
+export type BrowserApiOptions = {
+    storage: StorageAdapter;
+    manifest: Manifest;
+    /** The site's schemas built for the browser. */
+    schemas: string;
+    loadMdxProps: () => Promise<Readonly<Record<string, unknown>>>;
+    loadUrlFunctions?: () => Promise<Readonly<Record<string, (entry: UrlEntry) => unknown>>>;
+    /** The site's static routes at build, for collision checks. */
+    routes?: readonly (readonly [string, string])[];
+    /** Whether a save publishes (GitHub mode) or keeps a draft (the cloud). */
+    publishesOnSave: boolean;
+    /** The storage's own errors in the studio's terms. */
+    mapError: (error: unknown) => unknown;
+};
+export declare function createBrowserApi(options: BrowserApiOptions): StudioApi;

package/dist/app/collection-icon.d.ts

@@ -0,0 +1,12 @@
+import type { CollectionManifest } from '@vespercms/core';
+import type { IconName, IconNode } from '@vespercms/ui';
+/**
+ * A collection's icon: the Lucide icon vesper.config.ts names for it,
+ * resolved into the manifest at build, or a default by kind (DECISIONS.md,
+ * "A collection's icon is named in vesper.config.ts").
+ */
+export declare function collectionIcon(collection: CollectionManifest): {
+    node: IconNode;
+} | {
+    name: IconName;
+};

package/dist/app/context.d.ts

@@ -0,0 +1,23 @@
+import type { CollectionManifest, Manifest } from '@vespercms/core';
+import type { Account, WidgetComponent } from '../types.ts';
+import type { CloudConnection } from '../cloud/connection.ts';
+import type { StudioApi } from './api.ts';
+export type Studio = {
+    manifest: Manifest;
+    api: StudioApi;
+    /** Custom widgets, as lazy components: each loads the first time a field uses it. */
+    widgets: Record<string, WidgetComponent>;
+    /** Loads declared MDX components' Zod props schemas, from vesper.config.ts (spec §6.5.2). */
+    loadMdxProps: () => Promise<Readonly<Record<string, unknown>>>;
+    siteName: string;
+    siteUrl: string | undefined;
+    collection: (name: string) => CollectionManifest | undefined;
+    /** The signed-in editor, in GitHub mode or the cloud. */
+    account?: Account;
+    /** The cloud, when the studio is connected to it. Absent, every cloud feature is absent (spec §6.9). */
+    cloud?: CloudConnection;
+};
+/** The name the studio shows when the site gives none: Vesper's own, set lowercase as its wordmark. */
+export declare const VESPER_NAME = "Vesper";
+export declare const StudioContext: import("react").Context<Studio | null>;
+export declare function useStudio(): Studio;

package/dist/app/entries-changed.d.ts

@@ -0,0 +1,11 @@
+export declare function entriesChanged(collection: string): void;
+/**
+ * Entries rewritten from outside their editor: a move in the list writes
+ * order numbers into them, and an editor open on one reads it again, or its
+ * next save would find a version it didn't start from.
+ */
+export declare function entriesRewritten(collection: string, ids: readonly string[]): void;
+/** Calls `listener` with the IDs whenever entries in `collection` are rewritten; returns the way to stop. */
+export declare function onEntriesRewritten(collection: string, listener: (ids: readonly string[]) => void): () => void;
+/** Calls `listener` after each save in `collection`; returns the way to stop. */
+export declare function onEntriesChanged(collection: string, listener: () => void): () => void;

package/dist/app/file-url.d.ts

@@ -0,0 +1,13 @@
+/**
+ * A URL the studio can show a site file from, or `''` until it's ready. In
+ * local mode it's the dev API's `/file`; in GitHub mode an object URL for
+ * the blob, since a private repository's files have no address a browser
+ * can load without the token.
+ */
+export declare function useFileUrl(path: string | null): string;
+/** A site image, shown once its URL is ready. Decorative: whatever lists it names it. */
+export declare function FileImage({ path, className, loading, }: {
+    path: string;
+    className?: string;
+    loading?: 'lazy' | 'eager';
+}): import("react").JSX.Element;

package/dist/app/format.d.ts

@@ -0,0 +1,4 @@
+/** "just now", "5 minutes ago", "yesterday", "3 weeks ago". */
+export declare function formatRelative(iso: string, now?: Date, locale?: string): string;
+/** "1 entry", "12 entries". */
+export declare function formatCount(count: number, singular: string, plural: string, locale?: string): string;

package/dist/app/idb.d.ts

@@ -0,0 +1,7 @@
+export type KeyValueStore<T> = {
+    get(key: string): Promise<T | undefined>;
+    put(key: string, value: T): Promise<void>;
+    delete(key: string): Promise<void>;
+    keys(): Promise<string[]>;
+};
+export declare function keyValueStore<T>(database: string, store: string): KeyValueStore<T>;

package/dist/app/load.d.ts

@@ -0,0 +1,16 @@
+export type Load<T> = {
+    state: 'loading';
+} | {
+    state: 'ready';
+    value: T;
+} | {
+    state: 'failed';
+    message: string;
+};
+/**
+ * Loads data for a screen. The loader runs again when `key` changes, or when
+ * `reload()` is called (after a save, for example); a reload keeps showing
+ * the old value until the new one arrives. A response that arrives after
+ * the key moved on is dropped.
+ */
+export declare function useLoad<T>(loader: () => Promise<T>, key?: string): [Load<T>, () => void];

package/dist/app/media.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Whether a CSS media query matches, kept current as the window changes.
+ * False where there's no `matchMedia` (and so in jsdom's stub).
+ */
+export declare function useMediaQuery(query: string): boolean;

package/dist/app/navigation.d.ts

@@ -0,0 +1,4 @@
+/** How many in-app navigations have happened. 0 on the screen the studio opened on. */
+export declare const NavigationContext: import("react").Context<{
+    count: number;
+}>;

package/dist/app/pane-context.d.ts

@@ -0,0 +1,19 @@
+/** Where a screen sits among the panes (app/panes.tsx), or null one screen at a time. */
+export type PaneInfo = {
+    /**
+     * `main` for the deepest pane, `nav` for the ones that lead to it, and
+     * `region` for a pane beside the deepest that leads nowhere (the cloud's
+     * waiting drafts on Home).
+     */
+    landmark: 'main' | 'nav' | 'region';
+    /** The deepest pane's title is the page's `h1`; the others are `h2`s. */
+    level: 1 | 2;
+    /** The deepest pane takes focus after a navigation, and names the browser tab. */
+    focusTarget: boolean;
+    /** How wide it is: the narrow panes get tighter padding and a smaller heading. */
+    width: 'structure' | 'list' | 'flex';
+    /** Folds the pane into a strip, when people may: every pane but the deepest. */
+    onCollapse?: () => void;
+};
+export declare const PaneContext: import("react").Context<PaneInfo | null>;
+export declare function usePane(): PaneInfo | null;

package/dist/app/panes.d.ts

@@ -0,0 +1,14 @@
+import type { Studio } from './context.tsx';
+import { type Route } from './router.ts';
+/** Wide enough for panes: below it, one screen at a time. */
+export declare const PANES = "(min-width: 48rem)";
+/**
+ * The studio's screens. Wide, they're panes; narrow, the deepest pane alone
+ * is the screen. Both are the same tree, so crossing the width keeps the
+ * open entry as it is, unsaved changes included.
+ */
+export declare function PaneShell({ route, studio, wide, }: {
+    route: Route;
+    studio: Studio;
+    wide: boolean;
+}): import("react").JSX.Element;

package/dist/app/router.d.ts

@@ -0,0 +1,62 @@
+export type Route = {
+    screen: 'home';
+} | {
+    screen: 'list';
+    collection: string;
+} | {
+    screen: 'edit';
+    collection: string;
+    id: string;
+} | {
+    screen: 'new';
+    collection: string;
+    parent?: string;
+}
+/** A new entry that starts as a copy of another (Duplicate, spec §10.3). */
+ | {
+    screen: 'copy';
+    collection: string;
+    id: string;
+} | {
+    screen: 'media';
+} | {
+    screen: 'redirects';
+}
+/** Every change still to come across the site (spec §6.17). */
+ | {
+    screen: 'scheduled';
+}
+/** Home with the cloud's Changes open: review emails link here. Home alone elsewhere. */
+ | {
+    screen: 'changes';
+} | {
+    screen: 'not-found';
+    path: string;
+};
+export type KnownRoute = Exclude<Route, {
+    screen: 'not-found';
+}>;
+export declare function parseRoute(hash: string): Route;
+export declare function hrefFor(route: KnownRoute): string;
+/** Goes to a route. `replace` swaps the current history entry (after creating an entry, say). */
+export declare function navigate(route: KnownRoute, options?: {
+    replace?: boolean;
+}): void;
+export declare function setLeaveGuard(hasUnsavedChanges: () => boolean): () => void;
+/** Whether the open screen has unsaved changes. */
+export declare function hasUnsavedChanges(): boolean;
+export type RouterState = {
+    route: Route;
+    /** A navigation held back because the open screen has unsaved changes. */
+    pending: string | null;
+    /** Leave anyway, discarding the changes. */
+    leave: () => void;
+    /** Stay on the current screen. */
+    stay: () => void;
+};
+/**
+ * The current route. Every in-app navigation is a hash change, so this is
+ * also where unsaved changes are protected: when the guard says so, the
+ * hash is put back and the navigation waits for `leave()` or `stay()`.
+ */
+export declare function useRouter(): RouterState;

package/dist/body/BodyEditor.d.ts

@@ -0,0 +1,42 @@
+import { type Editor } from '@tiptap/core';
+import { type A11yNote, type BodyFormat, type BodyIssue } from '@vespercms/core';
+import { type RefObject } from 'react';
+export type BodyEditorProps = {
+    /** The body text, LF line endings, without the line breaks after the frontmatter. */
+    value: string;
+    onChange: (value: string) => void;
+    format: BodyFormat;
+    disabled: boolean;
+    /** The entry's file, so images are stored relative to it. */
+    entryPath: string;
+    /** Where images uploaded into the body go. */
+    imageFolder: string;
+    /** Files a Markdoc partial can point at, once loaded (Markdoc bodies only). */
+    partials?: readonly string[] | null;
+    /** Problems in the whole body, from the last check: listed under the source view. */
+    issues?: readonly BodyIssue[];
+    /** Accessibility notes about the body (spec §6.18), listed under it. */
+    notes?: readonly A11yNote[];
+    /** Filled with the editor's actions, for the entry's notes drawer. */
+    apiRef?: RefObject<BodyApi | null>;
+    /** The level the body's top headings should have (the collection's `headingStart`); 2 when absent. */
+    headingStart?: number;
+};
+/** What the rest of the entry editor can ask of the body editor. */
+export type BodyApi = {
+    /** Puts the cursor on the place a note points at, in whichever view is open, and focuses it. */
+    reveal: (note: A11yNote) => void;
+};
+/**
+ * The body editor (spec §6.5): a writing view and a source view. The writing
+ * view owns only the blocks it can show faithfully, and saves splice changed
+ * blocks into the original text, so untouched blocks never change. Markdoc
+ * tags and declared MDX components are blocks with settings (spec §6.5.1,
+ * §6.5.2); everything else it can't show is a protected source block.
+ */
+export declare function BodyEditor(props: BodyEditorProps): import("react").JSX.Element;
+export declare function LinkDialog({ editor, isOpen, onOpenChange, }: {
+    editor: Editor;
+    isOpen: boolean;
+    onOpenChange: (open: boolean) => void;
+}): import("react").JSX.Element;

package/dist/body/TableView.d.ts

@@ -0,0 +1,2 @@
+import { type ReactNodeViewProps } from '@tiptap/react';
+export declare function TableView({ node, getPos, selected, editor }: ReactNodeViewProps): import("react").JSX.Element;

package/dist/body/catalog.d.ts

@@ -0,0 +1,47 @@
+import { type BodyFormat, type FieldModel, type Manifest } from '@vespercms/core';
+export type BlockShape = 'container' | 'card' | 'inline';
+export type BlockKind = {
+    /** `markdoc:callout`, `mdx:Callout`. */
+    key: string;
+    syntax: 'markdoc' | 'mdx';
+    name: string;
+    label: string;
+    summary?: string;
+    description?: string;
+    /** How a new one is inserted at a block position, or null when it can only go inline. */
+    block: Exclude<BlockShape, 'inline'> | null;
+    /** Whether it can go inside a line of text. */
+    inline: boolean;
+    /** Written without content (`/%}`, `/>`). */
+    selfClosing: boolean;
+    /** Markdoc's allowed child node types (containers); absent means anything. */
+    children?: string[];
+    /** The settings form. */
+    fields: FieldModel[];
+    /** Attribute order, for placing new attributes and writing new tags. */
+    order: string[];
+    /** Built-in constructs the studio handles itself: partials, conditions and pipe tables. */
+    builtin?: 'partial' | 'if' | 'else' | 'table';
+};
+export type Catalog = {
+    format: BodyFormat;
+    kinds: Map<string, BlockKind>;
+    /** The kind for a tag or component name in this body's syntax. */
+    find: (syntax: 'markdoc' | 'mdx', name: string) => BlockKind | undefined;
+};
+export declare function catalogOf(manifest: Manifest, format: BodyFormat): Catalog;
+/** Kinds a person can insert (built-in conditions are protected, so they aren't offered). */
+/**
+ * A pipe table, insertable in every format (PLAN.md, call T4). It isn't one
+ * of the catalog's kinds, so Markdoc's own `{% table %}` is never taken for it.
+ */
+export declare const TABLE_KIND: BlockKind;
+export declare function insertable(catalog: Catalog): BlockKind[];
+/** A new tag's text in house style: attributes in schema order, empty and default values left out. */
+export declare function newTagText(kind: BlockKind, attributes: Readonly<Record<string, unknown>>, shape: BlockShape, inner?: string): {
+    open: string;
+    close: string;
+    whole: string;
+};
+/** A friendly name for a tag nobody described: the humanized name, or the component's own. */
+export declare function fallbackLabel(syntax: 'markdoc' | 'mdx', name: string): string;

package/dist/body/checks.d.ts

@@ -0,0 +1,15 @@
+import { type BodyFormat, type BodyIssue, type Manifest } from '@vespercms/core';
+export type BodyChecks = {
+    /** Validates a whole body, or one block's text, as the site's build would. */
+    validate: (text: string) => Promise<BodyIssue[]>;
+    /** The same, synchronously, for Markdoc (MDX props schemas load on first use). */
+    validateSync: (text: string) => BodyIssue[] | null;
+};
+export declare function bodyChecks(options: {
+    manifest: Manifest;
+    format: BodyFormat;
+    /** Declared MDX components' Zod props schemas, loaded when first needed. */
+    loadMdxProps: () => Promise<Readonly<Record<string, unknown>>>;
+    partials: readonly string[] | null;
+    entryPath: string;
+}): BodyChecks;

package/dist/body/chips.d.ts

@@ -0,0 +1,31 @@
+import { type InlineChip } from '@vespercms/core';
+export declare function chipPlaceholder(source: string): string;
+export declare function decodeHex(hex: string): string;
+/** Text with every placeholder replaced by the chip source it holds. */
+export declare function restoreChips(text: string): string;
+/** A block's text with its chips (offsets relative to the text) replaced by placeholders. */
+export declare function withPlaceholders(text: string, chips: readonly {
+    start: number;
+    end: number;
+}[]): string;
+/** True when the text holds a private-use character the placeholders rely on. */
+export declare function hasPlaceholderCharacters(text: string): boolean;
+export type TagValues = {
+    /** Attribute values the settings form can edit. */
+    values: Record<string, unknown>;
+    /** Attributes set by code (variables, functions, JSX expressions): shown, never edited. */
+    code: Record<string, string>;
+};
+/** A tag's attributes, read from its opening (Markdoc) or its opening or whole element (MDX). */
+export declare function tagValues(syntax: 'markdoc' | 'mdx', text: string): TagValues;
+export type ChipInfo = {
+    syntax: 'markdoc' | 'mdx';
+    kind: InlineChip['kind'];
+    name?: string;
+    /** For tags and components: the opening, the content between, and the closing. */
+    open?: string;
+    inner?: string;
+    close?: string;
+};
+/** What a chip's source is: its kind, name and parts. */
+export declare function chipInfo(source: string): ChipInfo;