@arbidocs/react 0.4.4 → 0.4.5

package/dist/artifacts/index.d.cts

@@ -0,0 +1,276 @@
+import { RedlineWithRegions, RedlineRegion } from './redline-core.cjs';
+export { RegionKind, buildHybridRedlineMarkdown, buildHybridRedlineWithRegions, revertRedlineRegion } from './redline-core.cjs';
+import * as _tanstack_react_query from '@tanstack/react-query';
+import { FC, ComponentPropsWithoutRef, ReactNode } from 'react';
+
+/**
+ * Where a redline is computed. The default runs on the calling thread; a host with large
+ * documents passes an engine backed by a Web Worker (for example a Comlink proxy exposing the same
+ * three functions) so typing never waits on a diff.
+ */
+interface RedlineEngine {
+    buildRedline(baseText: string, compareText: string): string | Promise<string>;
+    buildRedlineWithRegions(baseText: string, compareText: string): RedlineWithRegions | Promise<RedlineWithRegions>;
+    revertRegion(baseText: string, compareText: string, regionId: string): string | Promise<string>;
+}
+/** Main-thread engine: the pure functions of `redline-diff`. */
+declare const mainThreadRedlineEngine: RedlineEngine;
+
+/** What a redline view can show. Mirrors the status parts of `@arbidocs/blocks/artifacts`. */
+type RedlineState = {
+    kind: 'idle';
+} | {
+    kind: 'computing';
+} | {
+    kind: 'ready';
+    markdown: string;
+    regions: RedlineRegion[];
+} | {
+    kind: 'identical';
+} | {
+    kind: 'unavailable';
+};
+interface UseRedlineOptions {
+    /** The older side. `null` means the text could not be loaded; `undefined` means not chosen. */
+    baseText: string | null | undefined;
+    /** The newer side (a loaded version, or the live edit buffer). */
+    compareText: string | null | undefined;
+    /** Either text is still being fetched. */
+    isLoading?: boolean;
+    /** Tag every change with a stable id so a view can offer per-change undo. */
+    withRegions?: boolean;
+    /** Defaults to the main thread; pass a worker-backed engine for big documents. */
+    engine?: RedlineEngine;
+}
+interface UseRedlineResult {
+    state: RedlineState;
+    /** Undo one change: resolves with the compare text rebuilt without it (null if nothing changed). */
+    revertRegion: (regionId: string) => Promise<string | null>;
+}
+/**
+ * Track-changes between two texts. Stale results are dropped when the inputs change mid-compute,
+ * and a failed diff reports `unavailable` instead of throwing into the render.
+ */
+declare function useRedline({ baseText, compareText, isLoading, withRegions, engine, }: UseRedlineOptions): UseRedlineResult;
+
+/**
+ * Version lineage of an artifact. Every save creates a NEW document whose `parent_ext_id` is the
+ * version it was saved from, so a lineage is a tree (a save from an old version is a deliberate
+ * branch). Computed from a document list the host already has; no extra request.
+ */
+/** The fields of a workspace document the lineage needs (structurally a subset of the API type). */
+interface VersionedDoc {
+    external_id?: string | null;
+    parent_ext_id?: string | null;
+    file_name?: string | null;
+    created_at?: string | null;
+}
+/** One row of a version list. Matches `VersionEntry` of `@arbidocs/blocks/artifacts`. */
+interface ArtifactVersion {
+    id: string;
+    /** File name as stored. */
+    name: string;
+    /** ISO timestamp. */
+    createdAt: string;
+    /** The version this one was saved from. */
+    parentId?: string | null;
+}
+/**
+ * The whole lineage of `docId` (root first, then oldest to newest), or `[]` when the document is
+ * not in `docs`. Cycle-safe.
+ */
+declare function buildVersionChain<T extends VersionedDoc>(docs: readonly T[], docId: string | null | undefined): T[];
+/** The lineage of `docId` as plain version rows. */
+declare function toArtifactVersions(chain: readonly VersionedDoc[]): ArtifactVersion[];
+/**
+ * "v2": the 1-based position of `docId` in its lineage. `null` when there is nothing to tell apart
+ * (the lineage is just this document, or it is unknown), so unversioned documents stay unlabelled.
+ */
+declare function versionLabel(versions: readonly ArtifactVersion[], docId: string | null | undefined): string | null;
+/** Join parsed chunks into one markdown text (blank line between chunks). */
+declare function flattenChunks(chunks: readonly {
+    content?: string | null;
+}[] | null | undefined): string;
+
+/** What a save reports back. `docId` is the new version when the backend already knows it. */
+interface ArtifactSaveResult {
+    docId?: string;
+}
+interface ArtifactEditSessionOptions {
+    /** The artifact being edited. Changing it discards the buffer and any comparison. */
+    docId: string | null | undefined;
+    /**
+     * The saved text of the open version. `undefined` while it loads; whenever it changes the
+     * baseline follows it (a version arriving from the realtime channel, a finished stream).
+     */
+    baseline: string | undefined;
+    /**
+     * A new document the user types from scratch: open straight in the editor, seeded with
+     * `initialContent`, instead of showing a read-only view. Read when `docId` changes.
+     */
+    startEditing?: boolean;
+    initialContent?: string;
+    /** The version this one was saved from. Offering "compare with previous" needs it. */
+    parentId?: string | null;
+    /** Controlled comparison target. Omit for an uncontrolled one the session owns. */
+    compareId?: string | null;
+    onCompareChange?: (id: string | null) => void;
+    /** The saved text of the compare target (the older side of the diff). */
+    compareText?: string | null;
+    compareLoading?: boolean;
+    /** Starting a comparison opens the editor with track changes on (default true). */
+    compareOpensEditor?: boolean;
+    /** Persist the buffer as a NEW version. Rejecting keeps the buffer so nothing is lost. */
+    save: (content: string) => Promise<ArtifactSaveResult | void>;
+    onSaved?: (result: ArtifactSaveResult, content: string) => void;
+    onSaveError?: (error: unknown) => void;
+    /** Every buffer change (a host keeps a draft store in sync with it). */
+    onContentChange?: (content: string) => void;
+    /** The unsaved-changes flag, for a host that warns before a panel is closed. */
+    onDirtyChange?: (dirty: boolean) => void;
+    /** Where the diff runs. Defaults to the main thread. */
+    redlineEngine?: RedlineEngine;
+    /** Typing is never debounced; the diff trails the buffer by this long. Default 300ms. */
+    diffDelayMs?: number;
+}
+interface ArtifactEditSession {
+    isEditing: boolean;
+    /** The saved text of the open version. */
+    baseline: string;
+    /** The text in the editor (the baseline until the first edit). */
+    content: string;
+    hasChanges: boolean;
+    isSaving: boolean;
+    canCompare: boolean;
+    compareId: string | null;
+    showTrackChanges: boolean;
+    /** Track changes between the compare target and the (debounced) buffer. */
+    redline: UseRedlineResult;
+    startEdit: () => void;
+    /** Discard the buffer and any comparison; back to the rendered view. */
+    cancel: () => void;
+    /** Save the buffer as a new version. Resolves false when it failed (the buffer is kept). */
+    save: () => Promise<boolean>;
+    /** The editor's `onChange`; also replaces the buffer (for example after an undo-this-change). */
+    change: (markdown: string) => void;
+    /** The editor's `onNormalized`: adopt its canonical form as the baseline so Save does not fire. */
+    normalized: (markdown: string) => void;
+    /** Compare with the previous version (when no id is given). */
+    compare: (id?: string) => void;
+    stopCompare: () => void;
+    setShowTrackChanges: (show: boolean) => void;
+    /** Undo one tracked change in the buffer. */
+    revertRegion: (regionId: string) => Promise<void>;
+}
+/**
+ * The state machine of an artifact edit session, with no SDK and no network: the edit buffer and
+ * its baseline, the dirty flag, immutable-version saves and a track-changes comparison. A host
+ * supplies the saved text and a `save` function (see `useArtifactSession` for the SDK binding).
+ */
+declare function useArtifactEditSession(options: ArtifactEditSessionOptions): ArtifactEditSession;
+
+/** The saved markdown of a document (its parsed chunks, joined). */
+declare function useArtifactText(docId: string | null | undefined, options?: {
+    enabled?: boolean;
+}): {
+    text: string | null | undefined;
+    isLoading: boolean;
+};
+/** The version lineage of an artifact in a workspace, oldest first. */
+declare function useArtifactVersions(workspaceId: string | undefined, docId: string | null | undefined): ArtifactVersion[];
+interface SaveArtifactVersionInput {
+    /** File name of the new version (`.md` is added when missing). */
+    title: string;
+    content: string;
+    /** The version this one is saved from; omit for a first version. */
+    parentId?: string | null;
+    /** The processing config (auto-title, parsing) to run the upload with. */
+    configId?: string | null;
+    /** `artifact` (default) for AI-style drafts; `source` for a document the user typed. */
+    wpType?: 'artifact' | 'source';
+}
+/**
+ * Save markdown as a NEW immutable version (a child document of `parentId`) and refresh the
+ * workspace document list so the version list picks it up. The id of the new version is often not
+ * known yet (the document is parsed asynchronously); it then arrives through the list.
+ */
+declare function useSaveArtifactVersion(): _tanstack_react_query.UseMutationResult<ArtifactSaveResult, Error, SaveArtifactVersionInput & {
+    workspaceId?: string;
+}, unknown>;
+interface ArtifactSessionOptions extends Pick<ArtifactEditSessionOptions, 'onSaved' | 'onSaveError' | 'onCompareChange' | 'compareId' | 'compareOpensEditor' | 'redlineEngine' | 'onDirtyChange'> {
+    workspaceId: string | undefined;
+    /** The open version. */
+    docId: string | null | undefined;
+    /** Name for saved versions. Defaults to the open version's file name, else "Untitled". */
+    title?: string;
+    /** Processing config for saved versions. */
+    configId?: string | null;
+}
+/** Everything `ArtifactEditor` (`@arbidocs/blocks/artifacts`) takes from a session, flat. */
+interface ArtifactSessionView {
+    content: string;
+    isEditing: boolean;
+    hasChanges: boolean;
+    isSaving: boolean;
+    canCompare: boolean;
+    comparing: boolean;
+    compareId: string | null;
+    showTrackChanges: boolean;
+    versions: ArtifactVersion[];
+    currentVersionId: string;
+    onStartEdit: () => void;
+    onCancel: () => void;
+    onSave: () => void;
+    onCompare: () => void;
+    onStopCompare: () => void;
+    onToggleTrackChanges: () => void;
+}
+interface ArtifactSession extends ArtifactEditSession {
+    isLoading: boolean;
+    versions: ArtifactVersion[];
+    /** "v2" for any version in the lineage. */
+    labelOf: (id: string | null | undefined) => string | null;
+    /** Props for `<ArtifactEditor>`. */
+    view: ArtifactSessionView;
+    /** Props for `<ArtifactMarkdownEditor>` (`@arbidocs/blocks/artifacts/editor`). */
+    editorProps: {
+        markdown: string;
+        onChange: (markdown: string) => void;
+        onNormalized: (markdown: string) => void;
+    };
+    /** Props for `<ArtifactRedlineView>`. */
+    redlineProps: {
+        state: ArtifactEditSession['redline']['state'];
+        onRevert: (regionId: string) => void;
+    };
+}
+/**
+ * Edit an artifact through the SDK: load it, edit it, save it as a new version, list its versions
+ * and compare any two with track changes. Needs an `<ArbiProvider>` and a selected workspace.
+ *
+ * ```tsx
+ * const session = useArtifactSession({ workspaceId, docId, onSaved: ({ docId }) => docId && open(docId) })
+ * <ArtifactEditor {...session.view} onOpenVersion={open}
+ *   editor={<ArtifactMarkdownEditor {...session.editorProps} />}
+ *   redline={<ArtifactRedlineView {...session.redlineProps} />} />
+ * ```
+ */
+declare function useArtifactSession(options: ArtifactSessionOptions): ArtifactSession;
+
+/** The `<del>` / `<ins>` renderers `ArtifactRedlineView` hands to a markdown renderer. */
+interface ArtifactRedlineComponents {
+    del: FC<ComponentPropsWithoutRef<'del'> & {
+        'data-cid'?: string;
+    }>;
+    ins: FC<ComponentPropsWithoutRef<'ins'> & {
+        'data-cid'?: string;
+    }>;
+}
+/**
+ * The kit's markdown renderer as the `renderMarkdown` slot of `ArtifactEditor` and
+ * `ArtifactRedlineView`: full markdown (tables, lists, code) plus the raw `<del>` / `<ins>` tags
+ * of a redline.
+ */
+declare function renderArtifactMarkdown(markdown: string, components?: ArtifactRedlineComponents): ReactNode;
+
+export { type ArtifactEditSession, type ArtifactEditSessionOptions, type ArtifactRedlineComponents, type ArtifactSaveResult, type ArtifactSession, type ArtifactSessionOptions, type ArtifactSessionView, type ArtifactVersion, type RedlineEngine, RedlineRegion, type RedlineState, RedlineWithRegions, type SaveArtifactVersionInput, type UseRedlineOptions, type UseRedlineResult, type VersionedDoc, buildVersionChain, flattenChunks, mainThreadRedlineEngine, renderArtifactMarkdown, toArtifactVersions, useArtifactEditSession, useArtifactSession, useArtifactText, useArtifactVersions, useRedline, useSaveArtifactVersion, versionLabel };

package/dist/artifacts/index.d.ts

@@ -0,0 +1,276 @@
+import { RedlineWithRegions, RedlineRegion } from './redline-core.js';
+export { RegionKind, buildHybridRedlineMarkdown, buildHybridRedlineWithRegions, revertRedlineRegion } from './redline-core.js';
+import * as _tanstack_react_query from '@tanstack/react-query';
+import { FC, ComponentPropsWithoutRef, ReactNode } from 'react';
+
+/**
+ * Where a redline is computed. The default runs on the calling thread; a host with large
+ * documents passes an engine backed by a Web Worker (for example a Comlink proxy exposing the same
+ * three functions) so typing never waits on a diff.
+ */
+interface RedlineEngine {
+    buildRedline(baseText: string, compareText: string): string | Promise<string>;
+    buildRedlineWithRegions(baseText: string, compareText: string): RedlineWithRegions | Promise<RedlineWithRegions>;
+    revertRegion(baseText: string, compareText: string, regionId: string): string | Promise<string>;
+}
+/** Main-thread engine: the pure functions of `redline-diff`. */
+declare const mainThreadRedlineEngine: RedlineEngine;
+
+/** What a redline view can show. Mirrors the status parts of `@arbidocs/blocks/artifacts`. */
+type RedlineState = {
+    kind: 'idle';
+} | {
+    kind: 'computing';
+} | {
+    kind: 'ready';
+    markdown: string;
+    regions: RedlineRegion[];
+} | {
+    kind: 'identical';
+} | {
+    kind: 'unavailable';
+};
+interface UseRedlineOptions {
+    /** The older side. `null` means the text could not be loaded; `undefined` means not chosen. */
+    baseText: string | null | undefined;
+    /** The newer side (a loaded version, or the live edit buffer). */
+    compareText: string | null | undefined;
+    /** Either text is still being fetched. */
+    isLoading?: boolean;
+    /** Tag every change with a stable id so a view can offer per-change undo. */
+    withRegions?: boolean;
+    /** Defaults to the main thread; pass a worker-backed engine for big documents. */
+    engine?: RedlineEngine;
+}
+interface UseRedlineResult {
+    state: RedlineState;
+    /** Undo one change: resolves with the compare text rebuilt without it (null if nothing changed). */
+    revertRegion: (regionId: string) => Promise<string | null>;
+}
+/**
+ * Track-changes between two texts. Stale results are dropped when the inputs change mid-compute,
+ * and a failed diff reports `unavailable` instead of throwing into the render.
+ */
+declare function useRedline({ baseText, compareText, isLoading, withRegions, engine, }: UseRedlineOptions): UseRedlineResult;
+
+/**
+ * Version lineage of an artifact. Every save creates a NEW document whose `parent_ext_id` is the
+ * version it was saved from, so a lineage is a tree (a save from an old version is a deliberate
+ * branch). Computed from a document list the host already has; no extra request.
+ */
+/** The fields of a workspace document the lineage needs (structurally a subset of the API type). */
+interface VersionedDoc {
+    external_id?: string | null;
+    parent_ext_id?: string | null;
+    file_name?: string | null;
+    created_at?: string | null;
+}
+/** One row of a version list. Matches `VersionEntry` of `@arbidocs/blocks/artifacts`. */
+interface ArtifactVersion {
+    id: string;
+    /** File name as stored. */
+    name: string;
+    /** ISO timestamp. */
+    createdAt: string;
+    /** The version this one was saved from. */
+    parentId?: string | null;
+}
+/**
+ * The whole lineage of `docId` (root first, then oldest to newest), or `[]` when the document is
+ * not in `docs`. Cycle-safe.
+ */
+declare function buildVersionChain<T extends VersionedDoc>(docs: readonly T[], docId: string | null | undefined): T[];
+/** The lineage of `docId` as plain version rows. */
+declare function toArtifactVersions(chain: readonly VersionedDoc[]): ArtifactVersion[];
+/**
+ * "v2": the 1-based position of `docId` in its lineage. `null` when there is nothing to tell apart
+ * (the lineage is just this document, or it is unknown), so unversioned documents stay unlabelled.
+ */
+declare function versionLabel(versions: readonly ArtifactVersion[], docId: string | null | undefined): string | null;
+/** Join parsed chunks into one markdown text (blank line between chunks). */
+declare function flattenChunks(chunks: readonly {
+    content?: string | null;
+}[] | null | undefined): string;
+
+/** What a save reports back. `docId` is the new version when the backend already knows it. */
+interface ArtifactSaveResult {
+    docId?: string;
+}
+interface ArtifactEditSessionOptions {
+    /** The artifact being edited. Changing it discards the buffer and any comparison. */
+    docId: string | null | undefined;
+    /**
+     * The saved text of the open version. `undefined` while it loads; whenever it changes the
+     * baseline follows it (a version arriving from the realtime channel, a finished stream).
+     */
+    baseline: string | undefined;
+    /**
+     * A new document the user types from scratch: open straight in the editor, seeded with
+     * `initialContent`, instead of showing a read-only view. Read when `docId` changes.
+     */
+    startEditing?: boolean;
+    initialContent?: string;
+    /** The version this one was saved from. Offering "compare with previous" needs it. */
+    parentId?: string | null;
+    /** Controlled comparison target. Omit for an uncontrolled one the session owns. */
+    compareId?: string | null;
+    onCompareChange?: (id: string | null) => void;
+    /** The saved text of the compare target (the older side of the diff). */
+    compareText?: string | null;
+    compareLoading?: boolean;
+    /** Starting a comparison opens the editor with track changes on (default true). */
+    compareOpensEditor?: boolean;
+    /** Persist the buffer as a NEW version. Rejecting keeps the buffer so nothing is lost. */
+    save: (content: string) => Promise<ArtifactSaveResult | void>;
+    onSaved?: (result: ArtifactSaveResult, content: string) => void;
+    onSaveError?: (error: unknown) => void;
+    /** Every buffer change (a host keeps a draft store in sync with it). */
+    onContentChange?: (content: string) => void;
+    /** The unsaved-changes flag, for a host that warns before a panel is closed. */
+    onDirtyChange?: (dirty: boolean) => void;
+    /** Where the diff runs. Defaults to the main thread. */
+    redlineEngine?: RedlineEngine;
+    /** Typing is never debounced; the diff trails the buffer by this long. Default 300ms. */
+    diffDelayMs?: number;
+}
+interface ArtifactEditSession {
+    isEditing: boolean;
+    /** The saved text of the open version. */
+    baseline: string;
+    /** The text in the editor (the baseline until the first edit). */
+    content: string;
+    hasChanges: boolean;
+    isSaving: boolean;
+    canCompare: boolean;
+    compareId: string | null;
+    showTrackChanges: boolean;
+    /** Track changes between the compare target and the (debounced) buffer. */
+    redline: UseRedlineResult;
+    startEdit: () => void;
+    /** Discard the buffer and any comparison; back to the rendered view. */
+    cancel: () => void;
+    /** Save the buffer as a new version. Resolves false when it failed (the buffer is kept). */
+    save: () => Promise<boolean>;
+    /** The editor's `onChange`; also replaces the buffer (for example after an undo-this-change). */
+    change: (markdown: string) => void;
+    /** The editor's `onNormalized`: adopt its canonical form as the baseline so Save does not fire. */
+    normalized: (markdown: string) => void;
+    /** Compare with the previous version (when no id is given). */
+    compare: (id?: string) => void;
+    stopCompare: () => void;
+    setShowTrackChanges: (show: boolean) => void;
+    /** Undo one tracked change in the buffer. */
+    revertRegion: (regionId: string) => Promise<void>;
+}
+/**
+ * The state machine of an artifact edit session, with no SDK and no network: the edit buffer and
+ * its baseline, the dirty flag, immutable-version saves and a track-changes comparison. A host
+ * supplies the saved text and a `save` function (see `useArtifactSession` for the SDK binding).
+ */
+declare function useArtifactEditSession(options: ArtifactEditSessionOptions): ArtifactEditSession;
+
+/** The saved markdown of a document (its parsed chunks, joined). */
+declare function useArtifactText(docId: string | null | undefined, options?: {
+    enabled?: boolean;
+}): {
+    text: string | null | undefined;
+    isLoading: boolean;
+};
+/** The version lineage of an artifact in a workspace, oldest first. */
+declare function useArtifactVersions(workspaceId: string | undefined, docId: string | null | undefined): ArtifactVersion[];
+interface SaveArtifactVersionInput {
+    /** File name of the new version (`.md` is added when missing). */
+    title: string;
+    content: string;
+    /** The version this one is saved from; omit for a first version. */
+    parentId?: string | null;
+    /** The processing config (auto-title, parsing) to run the upload with. */
+    configId?: string | null;
+    /** `artifact` (default) for AI-style drafts; `source` for a document the user typed. */
+    wpType?: 'artifact' | 'source';
+}
+/**
+ * Save markdown as a NEW immutable version (a child document of `parentId`) and refresh the
+ * workspace document list so the version list picks it up. The id of the new version is often not
+ * known yet (the document is parsed asynchronously); it then arrives through the list.
+ */
+declare function useSaveArtifactVersion(): _tanstack_react_query.UseMutationResult<ArtifactSaveResult, Error, SaveArtifactVersionInput & {
+    workspaceId?: string;
+}, unknown>;
+interface ArtifactSessionOptions extends Pick<ArtifactEditSessionOptions, 'onSaved' | 'onSaveError' | 'onCompareChange' | 'compareId' | 'compareOpensEditor' | 'redlineEngine' | 'onDirtyChange'> {
+    workspaceId: string | undefined;
+    /** The open version. */
+    docId: string | null | undefined;
+    /** Name for saved versions. Defaults to the open version's file name, else "Untitled". */
+    title?: string;
+    /** Processing config for saved versions. */
+    configId?: string | null;
+}
+/** Everything `ArtifactEditor` (`@arbidocs/blocks/artifacts`) takes from a session, flat. */
+interface ArtifactSessionView {
+    content: string;
+    isEditing: boolean;
+    hasChanges: boolean;
+    isSaving: boolean;
+    canCompare: boolean;
+    comparing: boolean;
+    compareId: string | null;
+    showTrackChanges: boolean;
+    versions: ArtifactVersion[];
+    currentVersionId: string;
+    onStartEdit: () => void;
+    onCancel: () => void;
+    onSave: () => void;
+    onCompare: () => void;
+    onStopCompare: () => void;
+    onToggleTrackChanges: () => void;
+}
+interface ArtifactSession extends ArtifactEditSession {
+    isLoading: boolean;
+    versions: ArtifactVersion[];
+    /** "v2" for any version in the lineage. */
+    labelOf: (id: string | null | undefined) => string | null;
+    /** Props for `<ArtifactEditor>`. */
+    view: ArtifactSessionView;
+    /** Props for `<ArtifactMarkdownEditor>` (`@arbidocs/blocks/artifacts/editor`). */
+    editorProps: {
+        markdown: string;
+        onChange: (markdown: string) => void;
+        onNormalized: (markdown: string) => void;
+    };
+    /** Props for `<ArtifactRedlineView>`. */
+    redlineProps: {
+        state: ArtifactEditSession['redline']['state'];
+        onRevert: (regionId: string) => void;
+    };
+}
+/**
+ * Edit an artifact through the SDK: load it, edit it, save it as a new version, list its versions
+ * and compare any two with track changes. Needs an `<ArbiProvider>` and a selected workspace.
+ *
+ * ```tsx
+ * const session = useArtifactSession({ workspaceId, docId, onSaved: ({ docId }) => docId && open(docId) })
+ * <ArtifactEditor {...session.view} onOpenVersion={open}
+ *   editor={<ArtifactMarkdownEditor {...session.editorProps} />}
+ *   redline={<ArtifactRedlineView {...session.redlineProps} />} />
+ * ```
+ */
+declare function useArtifactSession(options: ArtifactSessionOptions): ArtifactSession;
+
+/** The `<del>` / `<ins>` renderers `ArtifactRedlineView` hands to a markdown renderer. */
+interface ArtifactRedlineComponents {
+    del: FC<ComponentPropsWithoutRef<'del'> & {
+        'data-cid'?: string;
+    }>;
+    ins: FC<ComponentPropsWithoutRef<'ins'> & {
+        'data-cid'?: string;
+    }>;
+}
+/**
+ * The kit's markdown renderer as the `renderMarkdown` slot of `ArtifactEditor` and
+ * `ArtifactRedlineView`: full markdown (tables, lists, code) plus the raw `<del>` / `<ins>` tags
+ * of a redline.
+ */
+declare function renderArtifactMarkdown(markdown: string, components?: ArtifactRedlineComponents): ReactNode;
+
+export { type ArtifactEditSession, type ArtifactEditSessionOptions, type ArtifactRedlineComponents, type ArtifactSaveResult, type ArtifactSession, type ArtifactSessionOptions, type ArtifactSessionView, type ArtifactVersion, type RedlineEngine, RedlineRegion, type RedlineState, RedlineWithRegions, type SaveArtifactVersionInput, type UseRedlineOptions, type UseRedlineResult, type VersionedDoc, buildVersionChain, flattenChunks, mainThreadRedlineEngine, renderArtifactMarkdown, toArtifactVersions, useArtifactEditSession, useArtifactSession, useArtifactText, useArtifactVersions, useRedline, useSaveArtifactVersion, versionLabel };