@fileverse-dev/ddoc 6.0.0-drop-in.2 → 6.0.0

package/dist/package/components/editor-toolbar.d.ts

@@ -4,7 +4,7 @@ import { FontDescriptor, IpfsImageFetchPayload, IpfsImageUploadResponse } from '
 import { Tab } from './tabs/utils/tab-utils';
 
 import * as Y from 'yjs';
-declare const MemoizedTiptapToolBar: React.MemoExoticComponent<({ editor, onError, isPresentationMode, setIsPresentationMode, enableCollaboration, zoomLevel, setZoomLevel, isNavbarVisible, setIsNavbarVisible, showNavbarToggle, ipfsImageUploadFn, onMarkdownExport, onMarkdownImport, onPdfExport, onHtmlExport, onTxtExport, onOdtExport, onDocxImport, ipfsImageFetchFn, fetchV1ImageFn, isConnected, tabs, ydoc, onRegisterExportTrigger, toggleFocusMode, isSplitView, onToggleSplitView, fonts: consumerFonts, renderToolbarLeading, }: {
+declare const MemoizedTiptapToolBar: React.MemoExoticComponent<({ editor, onError, isPresentationMode, setIsPresentationMode, enableCollaboration, zoomLevel, setZoomLevel, isNavbarVisible, setIsNavbarVisible, ipfsImageUploadFn, onMarkdownExport, onMarkdownImport, onPdfExport, onHtmlExport, onTxtExport, onOdtExport, onDocxImport, ipfsImageFetchFn, fetchV1ImageFn, isConnected, tabs, ydoc, onRegisterExportTrigger, toggleFocusMode, isSplitView, onToggleSplitView, fonts: consumerFonts, renderToolbarLeading, }: {
     editor: Editor | null;
     onError?: (errorString: string) => void;
     isPresentationMode?: boolean;
@@ -14,7 +14,6 @@ declare const MemoizedTiptapToolBar: React.MemoExoticComponent<({ editor, onErro
     setZoomLevel: (zoom: string) => void;
     isNavbarVisible: boolean;
     setIsNavbarVisible: React.Dispatch<React.SetStateAction<boolean>>;
-    showNavbarToggle?: boolean;
     ipfsImageUploadFn?: (file: File) => Promise<IpfsImageUploadResponse>;
     onMarkdownExport?: () => void;
     onMarkdownImport?: () => void;

package/dist/package/components/fullscreen-toolbar.d.ts

@@ -4,8 +4,8 @@ import { DdocProps } from '../types';
 type FullScreenToolbarProps = {
     dropdownOpen: boolean;
     setDropdownOpen: Dispatch<SetStateAction<boolean>>;
-    zoomLevel: string;
-    setZoomLevel: Dispatch<SetStateAction<string>>;
+    zoomLevel: DdocProps['zoomLevel'];
+    setZoomLevel: DdocProps['setZoomLevel'];
     showTOC: DdocProps['showTOC'];
     setShowTOC: DdocProps['setShowTOC'];
     toggleFocusMode: () => Promise<void>;

package/dist/package/components/mobile-toolbar.d.ts

@@ -2,13 +2,12 @@ import { default as React } from 'react';
 import { Editor } from '@tiptap/react';
 import { FontDescriptor, IpfsImageFetchPayload, IpfsImageUploadResponse } from '../types';
 
-declare const MemoizedMobileToolbar: React.MemoExoticComponent<({ editor, onError, isKeyboardVisible, isNavbarVisible, setIsNavbarVisible, showNavbarToggle, ipfsImageUploadFn, ipfsImageFetchFn, fetchV1ImageFn, fonts, }: {
+declare const MemoizedMobileToolbar: React.MemoExoticComponent<({ editor, onError, isKeyboardVisible, isNavbarVisible, setIsNavbarVisible, ipfsImageUploadFn, ipfsImageFetchFn, fetchV1ImageFn, fonts, }: {
     editor: Editor | null;
     onError?: (errorString: string) => void;
     isKeyboardVisible: boolean;
     isNavbarVisible: boolean;
     setIsNavbarVisible: React.Dispatch<React.SetStateAction<boolean>>;
-    showNavbarToggle?: boolean;
     ipfsImageUploadFn?: (file: File) => Promise<IpfsImageUploadResponse>;
     ipfsImageFetchFn?: (_data: IpfsImageFetchPayload) => Promise<{
         url: string;

package/dist/package/components/tabs/document-mobile-tab-panel.d.ts

@@ -25,7 +25,5 @@ export interface DocumentMobileTabPanelProps {
     isVersionHistoryMode: boolean;
     isConnected?: boolean;
     isFocusMode?: boolean;
-    layout?: DocumentOutlineProps['layout'];
-    tabPanelSlot?: HTMLElement | null;
 }
-export declare const DocumentMobileTabPanel: ({ tabs, activeTabId, setActiveTabId, editor, items, setItems, orientation, renameTab, createTab, duplicateTab, orderTab, deleteTab, tabCommentCounts, isPreviewMode, tabConfig, isVersionHistoryMode, isConnected, isFocusMode, layout, tabPanelSlot, }: DocumentMobileTabPanelProps) => import("react/jsx-runtime").JSX.Element | null;
+export declare const DocumentMobileTabPanel: ({ tabs, activeTabId, setActiveTabId, editor, items, setItems, orientation, renameTab, createTab, duplicateTab, orderTab, deleteTab, tabCommentCounts, isPreviewMode, tabConfig, isVersionHistoryMode, isConnected, isFocusMode, }: DocumentMobileTabPanelProps) => import("react/jsx-runtime").JSX.Element;

package/dist/package/components/tabs/document-tabs-sidebar.d.ts

@@ -32,10 +32,9 @@ export interface DocumentTabsSidebarProps {
     deleteTab?: (tabId: string) => void;
     isConnected?: boolean;
     isFocusMode?: boolean;
-    layout?: DocumentOutlineProps['layout'];
 }
 export declare const DocumentTabsSidebar: ({ tabSectionContainer, ...rest }: DocumentTabsSidebarProps) => import("react/jsx-runtime").JSX.Element | null;
-export declare const TabSidebar: ({ tabs, activeTabId, setActiveTabId, showTOC, setShowTOC, hasToC, isPreviewMode, editor, items, setItems, orientation, createTab, renameTab, duplicateTab, orderTab, tabCommentCounts, isVersionHistoryMode, tabConfig, deleteTab, isConnected, isFocusMode, layout, }: DocumentTabsSidebarProps) => import("react/jsx-runtime").JSX.Element;
+export declare const TabSidebar: ({ tabs, activeTabId, setActiveTabId, showTOC, setShowTOC, hasToC, isPreviewMode, editor, items, setItems, orientation, createTab, renameTab, duplicateTab, orderTab, tabCommentCounts, isVersionHistoryMode, tabConfig, deleteTab, isConnected, isFocusMode, }: DocumentTabsSidebarProps) => import("react/jsx-runtime").JSX.Element;
 export declare const DdocTab: ({ tab, tabIndex, tabCount, handleEmojiChange, handleNameChange, onClick, editor, tocItem, setTocItems, orientation, activeTabId, duplicateTab, commentCount, moveTabUp, moveTabDown, isPreviewMode, isVersionHistoryMode, tabConfig, onDelete, showOutline, onShowOutlineChange, isConnected, }: {
     tab: Tab;
     tabIndex: number;

package/dist/package/components/toc/document-outline.d.ts

@@ -1,3 +1,3 @@
 import { DocumentOutlineProps } from './types';
 
-export declare const DocumentOutline: ({ editor, hasToC, items, setItems, showTOC, setShowTOC, isPreviewMode, orientation, tabs, setTabs, activeTabId, setActiveTabId, createTab, renameTab, duplicateTab, orderTab, ydoc, tabCommentCounts, tabSectionContainer, isVersionHistoryMode, tabConfig, deleteTab, isConnected, isFocusMode, layout, tabPanelSlot, }: DocumentOutlineProps) => import("react/jsx-runtime").JSX.Element;
+export declare const DocumentOutline: ({ editor, hasToC, items, setItems, showTOC, setShowTOC, isPreviewMode, orientation, tabs, setTabs, activeTabId, setActiveTabId, createTab, renameTab, duplicateTab, orderTab, ydoc, tabCommentCounts, tabSectionContainer, isVersionHistoryMode, tabConfig, deleteTab, isConnected, isFocusMode, }: DocumentOutlineProps) => import("react/jsx-runtime").JSX.Element;

package/dist/package/components/toc/toc.d.ts

@@ -1,5 +1,5 @@
 import { ToCProps, ToCItemProps } from './types';
 
-export declare const ToCItem: import('react').MemoExoticComponent<({ item, onItemClick, index, orientation, isMobile, isWide, }: ToCItemProps) => import("react/jsx-runtime").JSX.Element>;
+export declare const ToCItem: import('react').MemoExoticComponent<({ item, onItemClick, index, orientation, }: ToCItemProps) => import("react/jsx-runtime").JSX.Element>;
 export declare const ToCEmptyState: import('react').MemoExoticComponent<() => import("react/jsx-runtime").JSX.Element>;
 export declare const ToC: import('react').MemoExoticComponent<({ items, editor, setItems, orientation }: ToCProps) => import("react/jsx-runtime").JSX.Element>;

package/dist/package/components/toc/types.d.ts

@@ -22,10 +22,6 @@ export type ToCItemProps = {
     onItemRemove: (e: React.MouseEvent, id: string) => void;
     index: number;
     orientation?: 'portrait' | 'landscape';
-    /** At or below 1280px: the item is in the mobile list. */
-    isMobile?: boolean;
-    /** At or above 1280px: the item takes the rail's width caps. */
-    isWide?: boolean;
 };
 export interface DocumentOutlineProps {
     editor: Editor;
@@ -58,7 +54,4 @@ export interface DocumentOutlineProps {
     deleteTab?: (tabId: string) => void;
     isConnected?: boolean;
     isFocusMode?: boolean;
-    /** 'contained': sized from the editor canvas. Only DdocEditor passes it. */
-    layout?: 'viewport' | 'contained';
-    tabPanelSlot?: HTMLElement | null;
 }

package/dist/package/hooks/use-doc-schema-version.d.ts

@@ -1,11 +1,13 @@
+import { SchemaStampGuardEvent } from '../types';
 import * as Y from 'yjs';
 interface UseDocSchemaVersionArgs {
     ydoc: Y.Doc;
     isNewDdoc: boolean;
     isContentResolved: boolean;
     preferredSchemaVersion?: number;
+    onSchemaStampGuard?: (event: SchemaStampGuardEvent) => void;
 }
-export declare const useDocSchemaVersion: ({ ydoc, isNewDdoc, isContentResolved, preferredSchemaVersion, }: UseDocSchemaVersionArgs) => {
+export declare const useDocSchemaVersion: ({ ydoc, isNewDdoc, isContentResolved, preferredSchemaVersion, onSchemaStampGuard, }: UseDocSchemaVersionArgs) => {
     docSchemaVersion: number;
     isSchemaUnsupported: boolean;
 };

package/dist/package/hooks/use-export-headless-editor-content.d.ts

@@ -33,6 +33,10 @@ export declare const useExportHeadlessEditorContent: (props?: UseHeadlessEditorP
     downloadContentAsTxt: (content: string | string[] | JSONContent, title: string) => Promise<void>;
     mergeYjsUpdates: (contents: string[]) => string;
     handleMarkdownContent: typeof import('../extensions/mardown-paste-handler').handleMarkdownContent;
-    getYjsContentFromMarkdown: (file: File, ipfsImageUploadFn: (file: File) => Promise<import('../types').IpfsImageUploadResponse>) => Promise<string | null>;
-    getYjsContentFromDocx: (file: File, ipfsImageUploadFn: (file: File) => Promise<import('../types').IpfsImageUploadResponse>) => Promise<string | null>;
+    getYjsContentFromMarkdown: (file: File, ipfsImageUploadFn: (file: File) => Promise<import('../types').IpfsImageUploadResponse>, options?: {
+        schemaVersion?: number;
+    }) => Promise<string | null>;
+    getYjsContentFromDocx: (file: File, ipfsImageUploadFn: (file: File) => Promise<import('../types').IpfsImageUploadResponse>, options?: {
+        schemaVersion?: number;
+    }) => Promise<string | null>;
 };

package/dist/package/hooks/use-focus-mode.d.ts

@@ -1,7 +1,9 @@
 type UseFocusModeOptions = {
-    /** @deprecated Use onFocusModeChange. Still fires on every change. */
+    /** Notify callback — fires on every toggle in both modes (existing API). */
     onFocusMode?: (isFocusMode: boolean) => void;
+    /** Controlled value (D6). Omit for the legacy internal-state behavior. */
     isFocusMode?: boolean;
+    /** Controlled setter — receives the next value instead of internal mutation. */
     onFocusModeChange?: (isFocusMode: boolean) => void;
 };
 export declare const useFocusMode: ({ onFocusMode, isFocusMode: controlledValue, onFocusModeChange, }?: UseFocusModeOptions) => {

package/dist/package/hooks/use-headless-editor.d.ts

@@ -53,8 +53,12 @@ export declare const createHeadlessEditorRuntime: (props?: UseHeadlessEditorProp
     downloadContentAsTxt: (content: string | string[] | JSONContent, title: string) => Promise<void>;
     mergeYjsUpdates: (contents: string[]) => string;
     handleMarkdownContent: typeof handleMarkdownContent;
-    getYjsContentFromMarkdown: (file: File, ipfsImageUploadFn: (file: File) => Promise<IpfsImageUploadResponse>) => Promise<string | null>;
-    getYjsContentFromDocx: (file: File, ipfsImageUploadFn: (file: File) => Promise<IpfsImageUploadResponse>) => Promise<string | null>;
+    getYjsContentFromMarkdown: (file: File, ipfsImageUploadFn: (file: File) => Promise<IpfsImageUploadResponse>, options?: {
+        schemaVersion?: number;
+    }) => Promise<string | null>;
+    getYjsContentFromDocx: (file: File, ipfsImageUploadFn: (file: File) => Promise<IpfsImageUploadResponse>, options?: {
+        schemaVersion?: number;
+    }) => Promise<string | null>;
 };
 export declare const useHeadlessEditor: (props?: UseHeadlessEditorProps) => {
     setContent: (initialContent: string | string[] | JSONContent, editor: Editor, ydoc: Y.Doc) => void;
@@ -76,6 +80,10 @@ export declare const useHeadlessEditor: (props?: UseHeadlessEditorProps) => {
     downloadContentAsTxt: (content: string | string[] | JSONContent, title: string) => Promise<void>;
     mergeYjsUpdates: (contents: string[]) => string;
     handleMarkdownContent: typeof handleMarkdownContent;
-    getYjsContentFromMarkdown: (file: File, ipfsImageUploadFn: (file: File) => Promise<IpfsImageUploadResponse>) => Promise<string | null>;
-    getYjsContentFromDocx: (file: File, ipfsImageUploadFn: (file: File) => Promise<IpfsImageUploadResponse>) => Promise<string | null>;
+    getYjsContentFromMarkdown: (file: File, ipfsImageUploadFn: (file: File) => Promise<IpfsImageUploadResponse>, options?: {
+        schemaVersion?: number;
+    }) => Promise<string | null>;
+    getYjsContentFromDocx: (file: File, ipfsImageUploadFn: (file: File) => Promise<IpfsImageUploadResponse>, options?: {
+        schemaVersion?: number;
+    }) => Promise<string | null>;
 };

package/dist/package/hooks/use-tab-editor.d.ts

@@ -4,14 +4,12 @@ import { AnyExtension, Editor } from '@tiptap/react';
 import { CommentAnchor } from '../extensions/comment/comment-decoration-plugin';
 import { DBlockRuntimeStateRef } from '../extensions/d-block/dblock-runtime';
 import { ToCItemType } from '../components/toc/types';
-import { EditorWidthStore } from '../utils/editor-width-store';
 import { CollabConnectionConfig, CollaborationProps } from '../sync-local/types';
 
 import * as Y from 'yjs';
 export declare const TAB_EDITOR_ATTRIBUTES: Record<string, string>;
 interface UseTabEditorArgs {
     ydoc: Y.Doc;
-    editorWidthStore?: EditorWidthStore;
     isVersionMode?: boolean;
     hasTabState?: boolean;
     versionId?: string;
@@ -38,7 +36,6 @@ interface UseTabEditorArgs {
     setWordCount?: DdocProps['setWordCount'];
     setSelectedWordCount?: DdocProps['setSelectedWordCount'];
     setPageCount?: DdocProps['setPageCount'];
-    onStatsChange?: DdocProps['onStatsChange'];
     setIsContentLoading: Dispatch<SetStateAction<boolean>>;
     setIsCollabContentLoading: Dispatch<SetStateAction<boolean>>;
     unFocused?: boolean;
@@ -61,7 +58,7 @@ interface UseTabEditorArgs {
     dBlockRuntimeStateRef?: DBlockRuntimeStateRef;
     docSchemaVersion?: number;
 }
-export declare const useTabEditor: ({ ydoc, editorWidthStore, isVersionMode, hasTabState, versionId, isPreviewMode, viewerMode, initialContent, collaboration, isReady, awareness, disableInlineComment, isFocusMode, onCommentInteraction, onError, ipfsImageUploadFn, metadataProxyUrl, onCopyHeadingLink, ipfsImageFetchFn, fetchV1ImageFn, isConnected, activeModel, maxTokens, isAIAgentEnabled, setCharacterCount, setWordCount, setSelectedWordCount, setPageCount, onStatsChange, setIsContentLoading, setIsCollabContentLoading, unFocused, zoomLevel, isPresentationMode, onInvalidContentError, ignoreCorruptedData, onConnect, onDisconnect, isIndexeddbSynced, hasCollabContentInitialised, initialiseYjsIndexedDbProvider, externalExtensions, isContentLoading, activeTabId, tabIds, theme, editorRef, initialCommentAnchors, dBlockRuntimeStateRef, docSchemaVersion, }: UseTabEditorArgs) => {
+export declare const useTabEditor: ({ ydoc, isVersionMode, hasTabState, versionId, isPreviewMode, viewerMode, initialContent, collaboration, isReady, awareness, disableInlineComment, isFocusMode, onCommentInteraction, onError, ipfsImageUploadFn, metadataProxyUrl, onCopyHeadingLink, ipfsImageFetchFn, fetchV1ImageFn, isConnected, activeModel, maxTokens, isAIAgentEnabled, setCharacterCount, setWordCount, setSelectedWordCount, setPageCount, setIsContentLoading, setIsCollabContentLoading, unFocused, zoomLevel, isPresentationMode, onInvalidContentError, ignoreCorruptedData, onConnect, onDisconnect, isIndexeddbSynced, hasCollabContentInitialised, initialiseYjsIndexedDbProvider, externalExtensions, isContentLoading, activeTabId, tabIds, theme, editorRef, initialCommentAnchors, dBlockRuntimeStateRef, docSchemaVersion, }: UseTabEditorArgs) => {
     editor: Editor | null;
     cachedEditorEntries: import('./use-tab-editor-cache').CachedTabEditorRenderEntry[];
     ref: import('react').RefObject<HTMLDivElement>;

package/dist/package/hooks/use-tab-manager.d.ts

@@ -7,6 +7,8 @@ interface UseTabManagerArgs {
     initialContent: DdocProps['initialContent'];
     enableCollaboration?: boolean;
     isDDocOwner: boolean;
+    /** Overrides the derived "brand-new document" (see DdocProps.isNewDocument). */
+    isNewDocument?: boolean;
     createDefaultTabIfMissing: boolean;
     shouldSyncActiveTab: boolean;
     defaultTabId?: string;
@@ -16,7 +18,7 @@ interface UseTabManagerArgs {
     flushPendingUpdate?: () => void;
 }
 export declare const getNewTabId: () => string;
-export declare const useTabManager: ({ ydoc, initialContent, enableCollaboration, isDDocOwner, createDefaultTabIfMissing, shouldSyncActiveTab, defaultTabId, preferFirstTabOnInit, onVersionHistoryActiveTabChange, flushPendingUpdate, getEditor, }: UseTabManagerArgs) => {
+export declare const useTabManager: ({ ydoc, initialContent, enableCollaboration, isDDocOwner, isNewDocument, createDefaultTabIfMissing, shouldSyncActiveTab, defaultTabId, preferFirstTabOnInit, onVersionHistoryActiveTabChange, flushPendingUpdate, getEditor, }: UseTabManagerArgs) => {
     tabs: Tab[];
     hasTabState: boolean;
     activeTabId: string;

package/dist/package/hooks/use-yjs-setup.d.ts

@@ -3,13 +3,19 @@ import { DdocProps } from '../types';
 import * as Y from 'yjs';
 interface UseYjsSetupArgs {
     onChange?: DdocProps['onChange'];
+    onLocalChange?: DdocProps['onLocalChange'];
     enableIndexeddbSync?: boolean;
     ddocId?: string;
     collaboration?: CollaborationProps;
     onCollaboratorChange?: DdocProps['onCollaboratorChange'];
     onIndexedDbError?: (error: Error) => void;
+    /**
+     * How long to wait for y-indexeddb before checking whether the store is
+     * corrupt. Internal; tests shorten it.
+     */
+    indexeddbStallCheckMs?: number;
 }
-export declare const useYjsSetup: ({ onChange, enableIndexeddbSync, ddocId, collaboration, onCollaboratorChange, onIndexedDbError, }: UseYjsSetupArgs) => {
+export declare const useYjsSetup: ({ onChange, onLocalChange, enableIndexeddbSync, ddocId, collaboration, onCollaboratorChange, onIndexedDbError, indexeddbStallCheckMs, }: UseYjsSetupArgs) => {
     ydoc: Y.Doc;
     onConnect: (connectConfig: import('../types').CollabConnectionConfig) => void;
     onDisconnect: () => void;

package/dist/package/persistence/compaction.d.ts

@@ -0,0 +1,27 @@
+import { IndexeddbPersistence } from 'y-indexeddb';
+
+/**
+ * Below this many already-replayed rows the store is left alone. A normal
+ * open leaves two or three (the previous compacted row, the last session's
+ * edits and y-indexeddb's attach row), so rewriting the full doc then would
+ * buy little.
+ */
+export declare const DEFAULT_COMPACTION_MIN_ROWS = 3;
+/** Is this one of compaction's own transactions? */
+export declare const isCompactionTransaction: (transaction: IDBTransaction) => boolean;
+/**
+ * y-indexeddb appends a copy of the doc every time a provider attaches, and
+ * only trims after 500 rows. The editor applies the consumer's initialContent
+ * before attaching, so each open stores a FULL copy of the doc and every load
+ * replays them all.
+ *
+ * During sync y-indexeddb applies every stored row to the doc and then sets
+ * `_dbref` to one past the last key. Every row below `_dbref` is therefore
+ * already in `persistence.doc`, so those rows are replaced with a single
+ * `encodeStateAsUpdate(doc)` without reading or merging them. Rows at or above
+ * `_dbref` (later edits, writes from another tab) are never touched.
+ *
+ * Runs in ONE readwrite transaction: any failure rolls back to the original
+ * rows. Returns the number of rows replaced (0 when nothing was compacted).
+ */
+export declare const compactDdocPersistence: (persistence: IndexeddbPersistence, minRows?: number) => Promise<number>;

package/dist/package/persistence/content-fingerprint.d.ts

@@ -0,0 +1,27 @@
+import * as Y from 'yjs';
+type ClockRange = [start: number, end: number];
+/**
+ * Join ranges that touch. Input is sorted by start, as the store keeps it.
+ * Lossless: the result covers exactly the same clocks, written one way, so
+ * the description does not depend on how Yjs split or joined items.
+ */
+export declare const mergeRanges: (ranges: ClockRange[]) => ClockRange[];
+/**
+ * A canonical description of a doc's content: for every writer, which clock
+ * ranges it inserted and which of those are deleted, leaving out the
+ * active-tab pointer.
+ *
+ * Every content edit (text, formatting, a tab rename or reorder, any root a
+ * later package version adds) inserts or deletes a struct, so it changes this.
+ * The active tab is per-user UI state written with the `'self'` origin
+ * (use-tab-manager.ts) and is skipped, so a tab switch does not. The rule
+ * lists what to skip rather than what to include, so a mistake can only make
+ * an unchanged doc look changed, never hide an edit.
+ *
+ * Ranges are merged so the result does not depend on how Yjs split or joined
+ * items: the same state gives the same description however it was produced.
+ */
+export declare const describeDdocContent: (doc: Y.Doc) => string;
+/** SHA-256 of `describeDdocContent`, base64 (44 characters). */
+export declare const fingerprintDdocContent: (doc: Y.Doc) => Promise<string>;
+export {};

package/dist/package/persistence/ddoc-persistence.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Read, merge into, delete and fingerprint a dDoc's y-indexeddb database
+ * without mounting an editor. The editor's IndexeddbPersistence names the
+ * database after the ddocId and stores Yjs updates in the `updates` store;
+ * these functions read and write that same layout.
+ *
+ * Nothing here imports React or the editor, so it is safe to call from app
+ * services and workers.
+ */
+export declare const DEFAULT_DDOC_PERSISTENCE_TIMEOUT_MS = 8000;
+/**
+ * `name` of the Error passed to `onIndexedDbError` when the editor repaired a
+ * corrupt store on load. It is a notice, not a failed save: the store is
+ * working again, but the unreadable rows it dropped are gone.
+ */
+export declare const DDOC_STORE_REPAIRED = "DdocStoreRepaired";
+export type DdocContentStatus = 'available' | 'empty' | 'missing' | 'corrupt' | 'timed-out' | 'unavailable';
+export type DdocContentSnapshot = {
+    ddocId: string;
+    status: DdocContentStatus;
+    /** base64 Yjs update of the whole doc; null unless available or empty. */
+    encodedState: string | null;
+    error?: Error;
+};
+export type DdocContentMergeResult = DdocContentSnapshot & {
+    /** True when the merge wrote something the database did not have. */
+    changed: boolean;
+    /** True when the database did not exist and this merge created it. */
+    created: boolean;
+};
+export type DdocContentDeleteResult = {
+    ddocId: string;
+    status: 'deleted' | 'blocked' | 'unavailable';
+    error?: Error;
+};
+export type DdocPersistenceOptions = {
+    timeoutMs?: number;
+};
+/**
+ * Read the doc's database as stored: every row replayed in key order, the
+ * same thing the editor loads on open. Never creates a database. Every call
+ * reads afresh: a read already under way may have started before the latest
+ * edit was written, so its result is never handed to a later caller.
+ */
+export declare const readDdocContent: (ddocId: string, options?: DdocPersistenceOptions) => Promise<DdocContentSnapshot>;
+/**
+ * Merge a full Yjs state into the doc's database, creating the database if
+ * it does not exist. Only the part the database does not already hold is
+ * written, as one row, in one readwrite transaction; merging state that is
+ * already stored writes nothing.
+ *
+ * An editor open in another tab sees the new row on its next load. An editor
+ * open in this tab does not (its Y.Doc is in memory), so callers with a
+ * mounted editor merge into its live doc instead.
+ *
+ * Expects a complete state (`Y.encodeStateAsUpdate` of a doc). An update whose
+ * new parts all depend on updates the store does not have yet changes nothing
+ * visible, and is not stored.
+ */
+export declare const mergeDdocContent: (ddocId: string, encodedState: string, options?: DdocPersistenceOptions) => Promise<DdocContentMergeResult>;
+export type DdocContentRepairResult = {
+    ddocId: string;
+    /**
+     * `repaired`: bad rows were dropped. `healthy`: nothing to drop, nothing
+     * written. `missing`: no database. `corrupt`: the database has no `updates`
+     * store, so there are no rows to keep.
+     */
+    status: 'repaired' | 'healthy' | 'missing' | 'corrupt' | 'timed-out' | 'unavailable';
+    droppedRows: number;
+    error?: Error;
+};
+/**
+ * Drop the stored rows that are not valid Yjs updates. One row y-indexeddb
+ * cannot apply makes its replay throw and never finish, so an editor waiting
+ * for it never loads. Each row is checked on its own; only the bad ones are
+ * deleted, in one readwrite transaction, and the good rows are left exactly as
+ * they are. Their content is lost, but it was already unreadable. Writes
+ * nothing when every row is good. Never creates a database.
+ */
+export declare const repairDdocContent: (ddocId: string, options?: DdocPersistenceOptions) => Promise<DdocContentRepairResult>;
+/**
+ * Delete the doc's database. Resolves `blocked` when another connection
+ * (an editor in another tab, for example) still holds it after the timeout;
+ * the browser keeps the delete queued and completes it once that connection
+ * closes. A missing database counts as deleted.
+ */
+export declare const deleteDdocContent: (ddocId: string, options?: DdocPersistenceOptions) => Promise<DdocContentDeleteResult>;
+/**
+ * Short, stable fingerprint of a doc's content (44 characters). Changes on
+ * every content edit, including delete-only and formatting-only edits; does
+ * not change when only the active tab changes. The same content gives the
+ * same fingerprint however the state was produced. See
+ * `describeDdocContent` for the rule. Uses `crypto.subtle`, which browsers
+ * only provide on secure (https or localhost) pages.
+ */
+export declare const getDdocContentFingerprint: (encodedState: string) => Promise<string>;

package/dist/package/persistence/index.d.ts

@@ -0,0 +1,2 @@
+export { DDOC_STORE_REPAIRED, DEFAULT_DDOC_PERSISTENCE_TIMEOUT_MS, deleteDdocContent, getDdocContentFingerprint, mergeDdocContent, readDdocContent, repairDdocContent, } from './ddoc-persistence';
+export type { DdocContentDeleteResult, DdocContentMergeResult, DdocContentRepairResult, DdocContentSnapshot, DdocContentStatus, DdocPersistenceOptions, } from './ddoc-persistence';

package/dist/package/persistence/provider-lifecycle.d.ts

@@ -0,0 +1,37 @@
+import { IndexeddbPersistence } from 'y-indexeddb';
+
+/**
+ * y-indexeddb's `whenSynced` resolves only on its 'synced' event. If
+ * `indexedDB.open` rejects, it never settles and nothing reports the failure.
+ * Reject on an open failure so the caller's error path runs.
+ */
+export declare const waitForIndexeddbSync: (persistence: IndexeddbPersistence) => Promise<void>;
+/**
+ * Like `waitForIndexeddbSync`, but resolves `stalled` if the provider has not
+ * synced after `stallMs`, so the caller can check why. The underlying wait is
+ * not cancelled; wait again to keep waiting.
+ */
+export declare const waitForIndexeddbSyncOrStall: (persistence: IndexeddbPersistence, stallMs: number) => Promise<"synced" | "stalled">;
+type WatchOptions = {
+    /** Called for every failed write and for a lost connection. */
+    onError: (error: Error) => void;
+    /** Called once the provider has been detached from the doc. */
+    onDetached: () => void;
+};
+/**
+ * Watch a synced provider's connection for the failures y-indexeddb itself
+ * ignores:
+ *
+ * - A failed write aborts its transaction, and `abort` bubbles to the
+ *   database. y-indexeddb never looks, so quota errors and the like are lost.
+ * - The browser can close the connection (site data cleared, storage
+ *   pressure: `close`), and a delete from another tab waits on it
+ *   (`versionchange`). After either, y-indexeddb's update handler throws
+ *   InvalidStateError into the next edit. Destroy the provider instead: it
+ *   unsubscribes from doc updates before closing, so editing continues in
+ *   memory, and a pending delete can proceed.
+ *
+ * Returns a function that removes the listeners.
+ */
+export declare const watchIndexeddbConnection: (persistence: IndexeddbPersistence, { onError, onDetached }: WatchOptions) => (() => void);
+export {};

package/dist/package/sync-local/SyncManager.d.ts

@@ -57,9 +57,10 @@ export declare class SyncManager {
     private ydoc;
     private callbacksRef;
     private onLocalUpdate?;
+    private onLocalChange?;
     constructor(config: SyncManagerConfig, onCollabStateChange: (state: CollabState) => void);
     /** Called by useSyncManager on every render to keep refs fresh */
-    updateRefs(_services: CollabServices | undefined, callbacks: CollabCallbacks | undefined, onLocalUpdate?: (updatedDocContent: string, updateChunk: string) => void): void;
+    updateRefs(_services: CollabServices | undefined, callbacks: CollabCallbacks | undefined, onLocalUpdate?: (updatedDocContent: string, updateChunk: string) => void, onLocalChange?: () => void): void;
     get isConnected(): boolean;
     get isReady(): boolean;
     get isResuming(): boolean;
@@ -135,6 +136,12 @@ export declare class SyncManager {
     private processNextUpdate;
     private handleRemoteContentUpdate;
     private applyRemoteYjsUpdate;
+    /**
+     * Tell the host that a collaborator's update changed the doc. The full
+     * document is encoded only for a host that asked for it (`onLocalUpdate`);
+     * `onLocalChange` gets the signal without that cost.
+     */
+    private notifyHostOfRemoteChange;
     private applyQueuedRemoteContents;
     private withRetry;
     private disconnectInternal;

package/dist/package/sync-local/server-clock.d.ts

@@ -0,0 +1,26 @@
+import type * as ucans from '@ucans/ucans';
+/**
+ * The collab server's clock, learned from its handshake. The server checks auth UCAN nbf/exp
+ * against its own clock, so tokens built from a skewed device clock get a 401.
+ */
+export declare class ServerClock {
+    private readonly wallNow;
+    private readonly monoNow;
+    private anchor;
+    constructor(wallNow?: () => number, monoNow?: (() => number) | null);
+    /**
+     * Time since the handshake is measured on the monotonic clock, so a device clock change
+     * mid-session cannot skew it. A missing or implausible stamp (older server) falls back to the
+     * device clock. Delivery delay and sleep only make the estimate trail the server, which the
+     * token window absorbs.
+     */
+    sync(serverTimeMs: unknown): void;
+    nowSeconds(): number;
+    ucanWindow(): {
+        notBefore: number;
+        expiration: number;
+    };
+    /** Whether a cached UCAN can still be presented: active, and not expiring within the margin. */
+    isUsable(ucan: ucans.Ucan): boolean;
+    private elapsedBase;
+}

package/dist/package/sync-local/socketClient.d.ts

@@ -74,6 +74,7 @@ export declare class SocketClient {
     private contractAddress?;
     private ownerUcan?;
     private collaborationUcan?;
+    private serverClock;
     private ownerAddress?;
     private ddocId?;
     private editLock?;
@@ -130,7 +131,6 @@ export declare class SocketClient {
     terminateSession: () => Promise<void>;
     flushBeacon(mergedUpdate: string): void;
     private getCollaborationKeyPair;
-    private isUcanValid;
     private getOwnerToken;
     private buildSessionToken;
     private _authenticate;

package/dist/package/sync-local/types/index.d.ts

@@ -199,6 +199,8 @@ export interface SyncManagerConfig {
     services?: CollabServices;
     callbacks?: CollabCallbacks;
     onLocalUpdate?: (updatedDocContent: Data['editorJSONData'], updateChunk: string) => void;
+    /** Like `onLocalUpdate` but without arguments, so no full-document encode. */
+    onLocalChange?: () => void;
     /** Origins to ignore in the ydoc update handler (e.g. IndexedDB provider) */
     ignoredOrigins?: Array<{
         current: unknown;