@mp-lb/mdkit 0.0.1-main.2.1

package/README.md

@@ -0,0 +1,132 @@
+# `@mp-lb/mdkit`
+
+Frontend primitives for document editing flows:
+
+- `MdKitEditor` for a Markdown-first rich text surface with local and collaborative modes
+- `useMdKitDocument` for autosave, conflict handling, and resync against a CRUD backend
+- `MdKitDocumentToolbar` for unstyled connected-document workflow controls
+- `useMdKitDocumentVersions` and `VersionHistoryPanel` for version browsing and restore flows
+- `useMdKitCollaboration` for wiring the same editor into a Hocuspocus/Yjs session
+
+## Install
+
+```bash
+pnpm add @mp-lb/mdkit
+```
+
+The editor behavior does not require package CSS. Import the optional stylesheet
+when you want mdkit's reset-resistant markdown baseline and CSS-variable theme
+system:
+
+```ts
+import "@mp-lb/mdkit/styles.css";
+```
+
+## Quick Start
+
+```tsx
+import { useState } from "react";
+import { MdKitEditor } from "@mp-lb/mdkit";
+import "@mp-lb/mdkit/styles.css";
+
+export function MarkdownEditorExample() {
+  const [markdown, setMarkdown] = useState("# Hello markdown");
+
+  return <MdKitEditor value={markdown} onChange={setMarkdown} />;
+}
+```
+
+`MdKitEditor` is the textarea-like entry point. It has no persistence,
+version history, or collaboration. You own the `value` and `onChange` state.
+
+## Exports
+
+- `MdKitEditor`
+- `MdKitDocumentToolbar`
+- `useMdKitDocument`
+- `useMdKitDocumentVersions`
+- `useMdKitCollaboration`
+- `MdKitThemeEditor`
+- `VersionHistoryPanel`
+
+The package also exports the related prop, adapter, document, versioning, and
+collaboration types.
+
+## Add Persistence
+
+```tsx
+import {
+  MdKitDocumentToolbar,
+  MdKitEditor,
+  useMdKitDocument,
+} from "@mp-lb/mdkit";
+
+const document = useMdKitDocument({
+  adapter,
+  documentId: "docs/brief.md",
+});
+
+<>
+  <MdKitDocumentToolbar document={document} />
+  <MdKitEditor
+    value={document.value}
+    onChange={document.setContent}
+    onFocusChange={document.setFocused}
+  />
+</>;
+```
+
+The storage adapter provides `readDocument`, `writeDocument`, and optional
+`resyncDocument`.
+
+## Version History
+
+```tsx
+import {
+  VersionHistoryPanel,
+  useMdKitDocumentVersions,
+} from "@mp-lb/mdkit";
+
+const versions = useMdKitDocumentVersions({
+  adapter,
+  documentId: "docs/brief.md",
+});
+
+<VersionHistoryPanel
+  controller={versions}
+  onRestoreVersion={async (version) => {
+    document.setContent(version.content);
+    await document.saveNow();
+  }}
+/>;
+```
+
+## Collaboration
+
+```tsx
+import {
+  MdKitEditor,
+  useMdKitCollaboration,
+} from "@mp-lb/mdkit";
+
+const collaboration = useMdKitCollaboration({
+  collaborator: {
+    id: "felix",
+    name: "Felix",
+  },
+  documentId: "docs/brief.md",
+  endpoint: "ws://127.0.0.1:1234",
+});
+
+<MdKitEditor collaboration={collaboration} />;
+```
+
+## Testbench
+
+The workspace includes `apps/mdkit-testbench`, a Vite app for debugging the
+package in unconnected and connected modes.
+
+## Package Docs
+
+Published library docs live in [`docs/index.md`](./docs/index.md). Internal
+project notes live in the repository under [`../../docs/mdkit`](../../docs/mdkit).

package/dist/collaboration/useMdKitCollaboration.d.ts

@@ -0,0 +1,10 @@
+import type { MdKitCollaborationParticipant, MdKitCollaborationSession } from "../document/documentTypes";
+export type UseMdKitCollaborationOptions = {
+    collaborator: MdKitCollaborationParticipant;
+    documentId: string | null;
+    enabled?: boolean;
+    endpoint: string | null;
+    getToken?: () => Promise<string | null>;
+    resolveRoomName?: (documentId: string) => string;
+};
+export declare const useMdKitCollaboration: (options: UseMdKitCollaborationOptions) => MdKitCollaborationSession | null;

package/dist/collaboration/useMdKitCollaboration.js

@@ -0,0 +1,90 @@
+import { useEffect, useMemo, useState } from "react";
+import { HocuspocusProvider } from "@hocuspocus/provider";
+import * as Y from "yjs";
+const createColorFromId = (id) => {
+    let hash = 0;
+    for (let index = 0; index < id.length; index += 1) {
+        hash = (hash << 5) - hash + id.charCodeAt(index);
+        hash |= 0;
+    }
+    return `hsl(${Math.abs(hash) % 360}, 85%, 55%)`;
+};
+export const useMdKitCollaboration = (options) => {
+    const { collaborator, documentId, enabled = true, endpoint, getToken, resolveRoomName, } = options;
+    const [status, setStatus] = useState("disconnected");
+    const normalizedCollaborator = useMemo(() => ({
+        ...collaborator,
+        color: collaborator.color || createColorFromId(collaborator.id),
+    }), [collaborator]);
+    const roomName = useMemo(() => {
+        if (!documentId) {
+            return "";
+        }
+        return resolveRoomName ? resolveRoomName(documentId) : documentId;
+    }, [documentId, resolveRoomName]);
+    const ydoc = useMemo(() => {
+        void roomName;
+        return new Y.Doc();
+    }, [roomName]);
+    const provider = useMemo(() => {
+        if (!enabled || !documentId || !endpoint) {
+            return null;
+        }
+        return new HocuspocusProvider({
+            document: ydoc,
+            name: roomName,
+            onConnect: () => setStatus("connected"),
+            onDisconnect: () => setStatus("disconnected"),
+            onStatus: ({ status: nextStatus }) => {
+                if (nextStatus === "connecting") {
+                    setStatus("connecting");
+                }
+            },
+            token: async () => {
+                const token = getToken ? await getToken() : null;
+                return token || "";
+            },
+            url: endpoint,
+        });
+    }, [documentId, enabled, endpoint, getToken, roomName, ydoc]);
+    useEffect(() => {
+        if (!provider) {
+            return;
+        }
+        return () => {
+            provider.destroy();
+        };
+    }, [provider]);
+    useEffect(() => {
+        if (!provider) {
+            return;
+        }
+        provider.setAwarenessField("user", {
+            color: normalizedCollaborator.color,
+            id: normalizedCollaborator.id,
+            imageUrl: normalizedCollaborator.imageUrl || undefined,
+            name: normalizedCollaborator.name,
+        });
+    }, [normalizedCollaborator, provider]);
+    return useMemo(() => {
+        if (!enabled || !documentId || !endpoint) {
+            return null;
+        }
+        return {
+            collaborator: normalizedCollaborator,
+            document: ydoc,
+            provider,
+            roomName,
+            status: provider ? status : "disconnected",
+        };
+    }, [
+        documentId,
+        enabled,
+        endpoint,
+        normalizedCollaborator,
+        provider,
+        roomName,
+        status,
+        ydoc,
+    ]);
+};

package/dist/core/documentEngine.d.ts

@@ -0,0 +1,38 @@
+import type { MdKitDocumentSnapshot, MdKitDocumentVersionDetail, MdKitDocumentVersionToken, MdKitDocumentWriteResult } from "../document/documentTypes.js";
+export type MdKitDocumentRecord = {
+    current: MdKitDocumentSnapshot;
+    versions: MdKitDocumentVersionDetail[];
+};
+export type CreateMdKitDocumentRecordInput = {
+    content?: string;
+    now?: string;
+};
+export type WriteMdKitDocumentRecordInput = {
+    baseVersion: MdKitDocumentVersionToken;
+    content: string;
+    force?: boolean;
+    label?: string;
+    now?: string;
+};
+export type WriteMdKitDocumentRecordResult = {
+    record: MdKitDocumentRecord;
+    result: MdKitDocumentWriteResult;
+};
+export type RestoreMdKitDocumentVersionInput = {
+    label?: string;
+    now?: string;
+    versionId: string;
+};
+export type RestoreMdKitDocumentVersionResult = {
+    record: MdKitDocumentRecord;
+    restoredVersion: MdKitDocumentVersionDetail;
+    result: MdKitDocumentWriteResult;
+};
+export declare const normalizeMdKitVersionToken: (version: MdKitDocumentVersionToken | undefined) => string | null;
+export declare const detectMdKitDocumentConflict: (input: {
+    baseVersion: MdKitDocumentVersionToken;
+    currentVersion: MdKitDocumentVersionToken;
+}) => boolean;
+export declare const createMdKitDocumentRecord: (input?: CreateMdKitDocumentRecordInput) => MdKitDocumentRecord;
+export declare const writeMdKitDocumentRecord: (record: MdKitDocumentRecord, input: WriteMdKitDocumentRecordInput) => WriteMdKitDocumentRecordResult;
+export declare const restoreMdKitDocumentVersion: (record: MdKitDocumentRecord, input: RestoreMdKitDocumentVersionInput) => RestoreMdKitDocumentVersionResult;

package/dist/core/documentEngine.js

@@ -0,0 +1,95 @@
+const initialVersion = "0";
+const createTimestamp = () => new Date().toISOString();
+export const normalizeMdKitVersionToken = (version) => (version == null ? null : String(version));
+export const detectMdKitDocumentConflict = (input) => normalizeMdKitVersionToken(input.baseVersion) !==
+    normalizeMdKitVersionToken(input.currentVersion);
+const nextVersionToken = (currentVersion) => {
+    const current = Number(normalizeMdKitVersionToken(currentVersion));
+    return Number.isFinite(current) ? String(current + 1) : createTimestamp();
+};
+const createVersionDetail = (input) => ({
+    content: input.content,
+    createdAt: input.now,
+    id: input.id,
+    label: input.label,
+    updatedAt: input.now,
+    version: input.id,
+});
+export const createMdKitDocumentRecord = (input = {}) => {
+    const now = input.now ?? createTimestamp();
+    const content = input.content ?? "";
+    const current = {
+        content,
+        updatedAt: now,
+        version: initialVersion,
+    };
+    return {
+        current,
+        versions: [
+            createVersionDetail({
+                content,
+                id: initialVersion,
+                label: "Initial",
+                now,
+            }),
+        ],
+    };
+};
+export const writeMdKitDocumentRecord = (record, input) => {
+    if (!input.force &&
+        detectMdKitDocumentConflict({
+            baseVersion: input.baseVersion,
+            currentVersion: record.current.version,
+        })) {
+        return {
+            record,
+            result: {
+                conflict: true,
+                updatedAt: record.current.updatedAt,
+                version: record.current.version,
+            },
+        };
+    }
+    const now = input.now ?? createTimestamp();
+    const version = nextVersionToken(record.current.version);
+    const current = {
+        content: input.content,
+        updatedAt: now,
+        version,
+    };
+    return {
+        record: {
+            current,
+            versions: [
+                ...record.versions,
+                createVersionDetail({
+                    content: input.content,
+                    id: version,
+                    label: input.label ?? `Version ${version}`,
+                    now,
+                }),
+            ],
+        },
+        result: {
+            updatedAt: now,
+            version,
+        },
+    };
+};
+export const restoreMdKitDocumentVersion = (record, input) => {
+    const restoredVersion = record.versions.find((version) => version.id === input.versionId);
+    if (!restoredVersion) {
+        throw new Error(`Version not found: ${input.versionId}`);
+    }
+    const written = writeMdKitDocumentRecord(record, {
+        baseVersion: record.current.version,
+        content: restoredVersion.content,
+        force: true,
+        label: input.label ?? `Restore ${restoredVersion.id}`,
+        now: input.now,
+    });
+    return {
+        ...written,
+        restoredVersion,
+    };
+};

package/dist/core/documentEngine.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/documentEngine.test.js

@@ -0,0 +1,119 @@
+import { describe, expect, it } from "vitest";
+import { createMdKitDocumentRecord, detectMdKitDocumentConflict, restoreMdKitDocumentVersion, writeMdKitDocumentRecord, } from "./documentEngine";
+const now = "2026-04-30T12:00:00.000Z";
+describe("documentEngine", () => {
+    it("creates a current markdown snapshot with an initial version", () => {
+        const record = createMdKitDocumentRecord({
+            content: "# Initial",
+            now,
+        });
+        expect(record.current).toEqual({
+            content: "# Initial",
+            updatedAt: now,
+            version: "0",
+        });
+        expect(record.versions).toEqual([
+            {
+                content: "# Initial",
+                createdAt: now,
+                id: "0",
+                label: "Initial",
+                updatedAt: now,
+                version: "0",
+            },
+        ]);
+    });
+    it("writes a new version when the base version matches", () => {
+        const record = createMdKitDocumentRecord({ now });
+        const written = writeMdKitDocumentRecord(record, {
+            baseVersion: "0",
+            content: "# Saved",
+            now: "2026-04-30T12:01:00.000Z",
+        });
+        expect(written.result).toEqual({
+            updatedAt: "2026-04-30T12:01:00.000Z",
+            version: "1",
+        });
+        expect(written.record.current).toMatchObject({
+            content: "# Saved",
+            version: "1",
+        });
+        expect(written.record.versions.map((version) => version.id)).toEqual([
+            "0",
+            "1",
+        ]);
+    });
+    it("returns a conflict when the base version is stale", () => {
+        const record = createMdKitDocumentRecord({ now });
+        const first = writeMdKitDocumentRecord(record, {
+            baseVersion: "0",
+            content: "first",
+            now: "2026-04-30T12:01:00.000Z",
+        });
+        const second = writeMdKitDocumentRecord(first.record, {
+            baseVersion: "0",
+            content: "second",
+            now: "2026-04-30T12:02:00.000Z",
+        });
+        expect(second.result).toEqual({
+            conflict: true,
+            updatedAt: "2026-04-30T12:01:00.000Z",
+            version: "1",
+        });
+        expect(second.record).toBe(first.record);
+    });
+    it("can force-write a local version over a remote conflict", () => {
+        const record = createMdKitDocumentRecord({ now });
+        const first = writeMdKitDocumentRecord(record, {
+            baseVersion: "0",
+            content: "remote",
+            now: "2026-04-30T12:01:00.000Z",
+        });
+        const forced = writeMdKitDocumentRecord(first.record, {
+            baseVersion: "0",
+            content: "local",
+            force: true,
+            label: "Force save",
+            now: "2026-04-30T12:02:00.000Z",
+        });
+        expect(forced.record.current).toMatchObject({
+            content: "local",
+            version: "2",
+        });
+        expect(forced.record.versions.at(-1)).toMatchObject({
+            content: "local",
+            id: "2",
+            label: "Force save",
+        });
+    });
+    it("restores a saved version into the current snapshot", () => {
+        const record = createMdKitDocumentRecord({ content: "initial", now });
+        const first = writeMdKitDocumentRecord(record, {
+            baseVersion: "0",
+            content: "later",
+            now: "2026-04-30T12:01:00.000Z",
+        });
+        const restored = restoreMdKitDocumentVersion(first.record, {
+            now: "2026-04-30T12:02:00.000Z",
+            versionId: "0",
+        });
+        expect(restored.record.current).toMatchObject({
+            content: "initial",
+            version: "2",
+        });
+        expect(restored.record.versions.at(-1)).toMatchObject({
+            content: "initial",
+            label: "Restore 0",
+        });
+    });
+    it("detects conflict from base and current version tokens", () => {
+        expect(detectMdKitDocumentConflict({
+            baseVersion: "1",
+            currentVersion: "2",
+        })).toBe(true);
+        expect(detectMdKitDocumentConflict({
+            baseVersion: 1,
+            currentVersion: "1",
+        })).toBe(false);
+    });
+});

package/dist/core/index.d.ts

@@ -0,0 +1,3 @@
+export { createMdKitDocumentRecord, detectMdKitDocumentConflict, normalizeMdKitVersionToken, restoreMdKitDocumentVersion, writeMdKitDocumentRecord, } from "./documentEngine.js";
+export type { CreateMdKitDocumentRecordInput, MdKitDocumentRecord, RestoreMdKitDocumentVersionInput, RestoreMdKitDocumentVersionResult, WriteMdKitDocumentRecordInput, WriteMdKitDocumentRecordResult, } from "./documentEngine.js";
+export type { MdKitDocumentSnapshot, MdKitDocumentVersionDetail, MdKitDocumentVersionSummary, MdKitDocumentVersionToken, MdKitDocumentWriteInput, MdKitDocumentWriteResult, } from "../document/documentTypes.js";

package/dist/core/index.js

@@ -0,0 +1 @@
+export { createMdKitDocumentRecord, detectMdKitDocumentConflict, normalizeMdKitVersionToken, restoreMdKitDocumentVersion, writeMdKitDocumentRecord, } from "./documentEngine.js";

package/dist/document/MdKitConflictPanel.d.ts

@@ -0,0 +1,7 @@
+import type { MdKitDocumentController } from "./useMdKitDocument";
+export type MdKitConflictPanelProps = {
+    className?: string;
+    document: MdKitDocumentController;
+    title?: string;
+};
+export declare const MdKitConflictPanel: ({ className, document, title, }: MdKitConflictPanelProps) => import("react/jsx-runtime").JSX.Element | null;

package/dist/document/MdKitConflictPanel.js

@@ -0,0 +1,41 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from "react";
+import { joinClassNames } from "../ui/joinClassNames";
+export const MdKitConflictPanel = ({ className, document, title = "Document conflict", }) => {
+    const [pendingAction, setPendingAction] = useState(null);
+    const [activePreview, setActivePreview] = useState("remote");
+    if (!document.conflict) {
+        return null;
+    }
+    const runAction = async (name, action) => {
+        setPendingAction(name);
+        try {
+            await action();
+        }
+        finally {
+            setPendingAction(null);
+        }
+    };
+    const isBusy = pendingAction !== null || document.saveStatus === "saving";
+    const conflictDetails = document.conflictDetails;
+    const previewOptions = [
+        {
+            id: "remote",
+            label: "Keep remote",
+            value: conflictDetails?.remoteContent ??
+                "Remote content preview is not available. Keep remote will still reload the latest canonical document.",
+        },
+        {
+            id: "local",
+            label: "Keep local",
+            value: conflictDetails?.localContent ?? document.value,
+        },
+    ];
+    const activePreviewOption = previewOptions.find((option) => option.id === activePreview) ??
+        previewOptions[0];
+    return (_jsxs("section", { className: joinClassNames("mdkit-conflict-panel", className), children: [_jsxs("div", { className: "mdkit-conflict-panel-content", children: [_jsx("h2", { children: title }), _jsx("p", { children: "Remote changes conflict with local edits. Choose the remote document, or keep your local document by overwriting the remote copy." }), document.error ? (_jsx("p", { className: "mdkit-conflict-panel-error", children: document.error })) : null, conflictDetails ? (_jsxs("p", { className: "mdkit-conflict-panel-meta", children: ["Remote version ", String(conflictDetails.remoteVersion ?? "none"), conflictDetails.remoteUpdatedAt
+                                ? ` saved ${new Date(conflictDetails.remoteUpdatedAt).toLocaleTimeString()}`
+                                : ""] })) : null] }), _jsxs("div", { className: "mdkit-conflict-panel-preview", children: [_jsx("div", { className: "mdkit-conflict-panel-tabs", role: "tablist", children: previewOptions.map((option) => (_jsx("button", { type: "button", "aria-selected": activePreviewOption.id === option.id, className: activePreviewOption.id === option.id
+                                ? "mdkit-conflict-panel-tab mdkit-conflict-panel-tab-active"
+                                : "mdkit-conflict-panel-tab", role: "tab", onClick: () => setActivePreview(option.id), children: option.label }, option.id))) }), _jsx("textarea", { "aria-label": `${activePreviewOption.label} conflict content`, readOnly: true, value: activePreviewOption.value })] }), _jsxs("div", { className: "mdkit-conflict-panel-action-row", children: [_jsx("button", { type: "button", className: "mdkit-panel-secondary-action", disabled: isBusy, onClick: () => void runAction("reload", document.resync), children: pendingAction === "reload" ? "Keeping remote..." : "Keep remote" }), _jsx("button", { type: "button", className: "mdkit-panel-secondary-action", disabled: isBusy, onClick: () => void runAction("overwrite", document.forceSave), children: pendingAction === "overwrite" ? "Keeping local..." : "Keep local" })] })] }));
+};

package/dist/document/MdKitDocumentToolbar.d.ts

@@ -0,0 +1,13 @@
+import type { MdKitCollaborationSession } from "./documentTypes";
+import type { MdKitDocumentController } from "./useMdKitDocument";
+import type { MdKitDocumentVersionsController } from "../versioning/useMdKitDocumentVersions";
+export type MdKitDocumentToolbarProps = {
+    className?: string;
+    collaboration?: MdKitCollaborationSession | null;
+    document: MdKitDocumentController;
+    onOpenConflict?: () => Promise<void> | void;
+    onOpenVersionHistory?: () => Promise<void> | void;
+    showConflictActions?: boolean;
+    versions?: MdKitDocumentVersionsController | null;
+};
+export declare const MdKitDocumentToolbar: ({ className, collaboration, document, onOpenConflict, onOpenVersionHistory, showConflictActions, versions, }: MdKitDocumentToolbarProps) => import("react/jsx-runtime").JSX.Element;

package/dist/document/MdKitDocumentToolbar.js

@@ -0,0 +1,48 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from "react";
+import { joinClassNames } from "../ui/joinClassNames";
+const formatUpdatedAt = (updatedAt) => {
+    if (!updatedAt) {
+        return "Never saved";
+    }
+    return `Saved ${new Date(updatedAt).toLocaleTimeString()}`;
+};
+export const MdKitDocumentToolbar = ({ className, collaboration, document, onOpenConflict, onOpenVersionHistory, showConflictActions = false, versions, }) => {
+    const [pendingAction, setPendingAction] = useState(null);
+    const runAction = async (name, action) => {
+        setPendingAction(name);
+        try {
+            await action();
+        }
+        finally {
+            setPendingAction(null);
+        }
+    };
+    const hasVersionHistory = versions?.hasVersioning ?? false;
+    const isBusy = pendingAction !== null || document.saveStatus === "saving";
+    const status = document.conflict
+        ? "Conflict"
+        : document.isLoading
+            ? "Loading"
+            : document.saveStatus === "saving"
+                ? "Saving"
+                : document.saveStatus === "pending"
+                    ? "Autosave pending"
+                    : document.isDirty
+                        ? "Unsaved changes"
+                        : document.saveStatus === "saved"
+                            ? "Saved"
+                            : "Idle";
+    return (_jsxs("div", { className: joinClassNames("mdkit-document-toolbar", className), "data-conflict": document.conflict ? "true" : undefined, "data-dirty": document.isDirty ? "true" : undefined, "data-save-status": document.saveStatus, "data-status": status.toLowerCase().replace(/\s+/g, "-"), children: [_jsxs("div", { className: "mdkit-document-toolbar-status", children: [_jsx("strong", { children: status }), _jsx("span", { children: formatUpdatedAt(document.updatedAt) }), _jsxs("span", { children: ["Collaboration ", collaboration ? collaboration.status : "off"] })] }), document.error && !document.conflict ? (_jsx("div", { className: "mdkit-document-toolbar-error", children: document.error })) : null, _jsxs("div", { className: "mdkit-document-toolbar-actions", children: [_jsx("button", { type: "button", disabled: isBusy ||
+                            document.conflict ||
+                            !hasVersionHistory ||
+                            versions?.isLoading ||
+                            !onOpenVersionHistory, onClick: () => void runAction("versions", async () => {
+                            await versions?.refresh();
+                            await onOpenVersionHistory?.();
+                        }), children: versions?.isLoading
+                            ? "Loading versions..."
+                            : `Version ${String(document.version ?? "none")}` }), document.conflict && onOpenConflict ? (_jsx("button", { type: "button", className: "mdkit-document-toolbar-conflict-trigger", disabled: isBusy, onClick: () => void runAction("conflict", async () => {
+                            await onOpenConflict();
+                        }), children: "Resolve conflict" })) : null] }), document.conflict && showConflictActions ? (_jsxs("div", { className: "mdkit-document-toolbar-conflict", children: [_jsx("span", { children: "Remote changes conflict with local edits." }), _jsx("button", { type: "button", disabled: isBusy, onClick: () => void runAction("reload", document.resync), children: "Keep remote" }), _jsx("button", { type: "button", disabled: isBusy, onClick: () => void runAction("overwrite", document.forceSave), children: "Keep local" })] })) : null] }));
+};

package/dist/document/documentTypes.d.ts

@@ -0,0 +1,57 @@
+import type { HocuspocusProvider } from "@hocuspocus/provider";
+import type * as Y from "yjs";
+export type MdKitDocumentVersionToken = string | number | null;
+export type MdKitDocumentSnapshot = {
+    content: string;
+    version: MdKitDocumentVersionToken;
+    updatedAt?: string | null;
+};
+export type MdKitDocumentWriteInput = {
+    documentId: string;
+    content: string;
+    baseVersion: MdKitDocumentVersionToken;
+    force?: boolean;
+};
+export type MdKitDocumentWriteResult = {
+    version: MdKitDocumentVersionToken;
+    updatedAt?: string | null;
+} | {
+    conflict: true;
+    version?: MdKitDocumentVersionToken;
+    updatedAt?: string | null;
+};
+export type MdKitDocumentVersionSummary = {
+    id: string;
+    label?: string;
+    createdAt: string;
+    authorLabel?: string | null;
+    updatedAt?: string | null;
+    version?: MdKitDocumentVersionToken;
+};
+export type MdKitDocumentVersionDetail = MdKitDocumentVersionSummary & {
+    content: string;
+};
+export interface MdKitDocumentAdapter {
+    readDocument(documentId: string): Promise<MdKitDocumentSnapshot>;
+    writeDocument(input: MdKitDocumentWriteInput): Promise<MdKitDocumentWriteResult>;
+    resyncDocument?(documentId: string): Promise<MdKitDocumentSnapshot>;
+    listDocumentVersions?(documentId: string): Promise<MdKitDocumentVersionSummary[]>;
+    readDocumentVersion?(input: {
+        documentId: string;
+        versionId: string;
+    }): Promise<MdKitDocumentVersionDetail | null>;
+}
+export type MdKitCollaborationStatus = "connecting" | "connected" | "disconnected";
+export type MdKitCollaborationParticipant = {
+    id: string;
+    name: string;
+    color?: string;
+    imageUrl?: string;
+};
+export type MdKitCollaborationSession = {
+    collaborator: MdKitCollaborationParticipant;
+    document: Y.Doc;
+    provider: HocuspocusProvider | null;
+    roomName: string;
+    status: MdKitCollaborationStatus;
+};

package/dist/document/documentTypes.js

@@ -0,0 +1 @@
+export {};