@fileverse-dev/ddoc 4.2.0-yjs-dedupe-1 → 4.2.0-yjs-dedupe-2

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

@@ -1,4 +1,4 @@
-import { ISocketInitConfig, RoomMember, SocketStatusEnum, SendUpdateResponse, CommitResponse, AckResponse } from './types';
+import { ISocketInitConfig, SocketStatusEnum, SendUpdateResponse, HydrationResponse, SnapshotResponse, AckResponse } from './types';
 import { Awareness } from 'y-protocols/awareness.js';
 
 interface ISocketClientConfig {
@@ -8,6 +8,22 @@ interface ISocketClientConfig {
     ownerEdSecret?: string;
     contractAddress?: string;
     ownerAddress?: string;
+    ownerIdentityDid?: string;
+    editLock?: string;
+    encryptedTitle?: string;
+    identityToken?: string;
+    identityContractAddress?: string;
+    editUcan?: string;
+    refreshEditClaim?: () => Promise<{
+        status: 'ok';
+        token: string;
+    } | {
+        status: 'demoted';
+    } | {
+        status: 'unavailable';
+    }>;
+    actorHandle?: string;
+    joinOnly?: boolean;
     onHandshakeData?: (response: {
         data: AckResponse;
         roomKey: string;
@@ -20,6 +36,8 @@ interface ISocketClientConfig {
 }
 export declare class SocketClient {
     private _socketUrl;
+    private _restBase;
+    private _lastSessionToken;
     private _socket;
     private _webSocketStatus;
     private _isIntentionalDisconnect;
@@ -27,13 +45,26 @@ export declare class SocketClient {
     get status(): SocketStatusEnum;
     private _websocketServiceDid;
     private roomId;
-    roomMembers: RoomMember[];
+    roomMembers: string[];
+    private _lastPresenceSignature;
+    private _onPresenceChange?;
+    private _pendingAwarenessUpdates;
     private collaborationKeyPair;
     private ownerKeyPair?;
     private contractAddress?;
     private ownerUcan?;
     private collaborationUcan?;
     private ownerAddress?;
+    private ownerIdentityDid?;
+    private editLock?;
+    private encryptedTitle?;
+    private identityToken?;
+    private identityContractAddress?;
+    private editUcan?;
+    private refreshEditClaim?;
+    private lastGoodEditUcan?;
+    private actorHandle?;
+    private joinOnly?;
     private roomKey;
     private roomInfo?;
     private awareness;
@@ -41,20 +72,36 @@ export declare class SocketClient {
     private _onHandshakeData;
     constructor(config: ISocketClientConfig);
     registerAwareness(awareness: Awareness): void;
+    private _stampSocketId;
     private _emitWithAck;
     private _fetchRoomMembers;
+    private _recomputePresence;
     sendUpdate({ update }: {
         update: string;
     }): Promise<SendUpdateResponse>;
-    commitUpdates({ updates, cid }: {
-        updates: string[];
-        cid: string;
-    }): Promise<CommitResponse>;
-    fetchLatestCommit(): Promise<AckResponse<any>>;
-    getUncommittedChanges(): Promise<AckResponse<any>>;
+    fetchHydrationRange(sinceSeq?: number): Promise<HydrationResponse>;
+    sendSnapshot({ data, floorSeq, publishedMarker, }: {
+        data: string;
+        floorSeq: number;
+        publishedMarker?: string | null;
+    }): Promise<SnapshotResponse>;
+    sendMirrorSnapshot({ data, fileKeyEpoch, }: {
+        data: string;
+        fileKeyEpoch: number;
+    }): Promise<AckResponse<any>>;
+    setDocumentMeta(): Promise<void>;
+    /** Owner rename mid-session: refresh the connect-frozen title artifacts (so
+     *  every later /auth re-sends current values), persist server-side, and let
+     *  the server broadcast /document/meta_update to room peers. */
+    updateDocumentMeta(args: {
+        encryptedTitle: string;
+        documentTitle: string;
+    }): Promise<void>;
     broadcastAwareness(awarenessUpdate: string): Promise<void>;
     disconnect: () => void;
+    reauth: () => void;
     terminateSession: () => Promise<void>;
+    flushBeacon(mergedUpdate: string): void;
     private getCollaborationKeyPair;
     private isUcanValid;
     private getOwnerToken;

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

@@ -7,6 +7,49 @@ export interface CollabConnectionConfig {
     roomId: string;
     wsUrl: string;
     isOwner: boolean;
+    /** Host signal: doc is in an active live-collaboration context (shared / peers present). Keeps the socket connected. */
+    livePresence?: boolean;
+    /** Host signal: connect once on open to initialise durability even without an edit. */
+    connectOnOpen?: boolean;
+    /** Host signal (owner-only): the owner identity signingKey DID. Recorded by the durable server on the first owner /auth as the R3 owner binding. */
+    ownerIdentityDid?: string;
+    /** Host signal (owner-only): wrapped roomKey bytes (owner-lock construction), uploaded as the server editLock recovery artifact. Opaque to the package. */
+    editLock?: string;
+    /** Host signal (owner-only): the document title encrypted with the roomKey, uploaded as the server title recovery artifact. Opaque to the package. */
+    encryptedTitle?: string;
+    /** Host signal (owner-only): Ed25519 UCAN proving the owner identity, sent on /auth so the server binds the CRYPTOGRAPHICALLY PROVEN owner DID (not a bare asserted string). Opaque to the package. */
+    identityToken?: string;
+    /** Host signal (owner-only): the identity contract address the server reads to resolve the on-chain signingDid that verifies identityToken. */
+    identityContractAddress?: string;
+    /** Host signal (non-owner editor): the gate-minted edit-admission UCAN, forwarded on /auth so the
+     *  server admits this connection as a GP-rail editor. Opaque to the package. */
+    editUcan?: string;
+    /** Host signal (non-owner editor): re-mints a CURRENT-epoch editUcan. Called at every /auth
+     *  (incl. reconnect after a force-drop). Tri-state: `ok` (fresh token; overrides the static
+     *  `editUcan`), `demoted` (no longer an editor → terminal, drop to viewer), or `unavailable`
+     *  (transient/network → retry on the last-good claim). Opaque to the package. */
+    refreshEditClaim?: () => Promise<{
+        status: 'ok';
+        token: string;
+    } | {
+        status: 'demoted';
+    } | {
+        status: 'unavailable';
+    }>;
+    /** Host signal: an anonymous per-connection actor handle (public rail). Record-only; opaque. */
+    actorHandle?: string;
+    /** Host signal (non-creator workspace member): join-only. The server never creates or
+     *  binds a session for this connection and caps the role at editor; every handshake
+     *  rejection resolves to a quiet terminated state ('ROOM_NOT_ESTABLISHED' when the room
+     *  was never established, 'JOIN_REJECTED' otherwise) instead of an error. */
+    joinOnly?: boolean;
+    /** Host signal (editor): produces the view-plane mirror ciphertext from the live Yjs state. The app
+     *  AES-GCM-encrypts `{ file: base64(yjsUpdate), source }` under the fileKey in the publish wire
+     *  format. Absent ⇒ the mirror is not written. The package never sees the fileKey or the crypto. */
+    encryptMirror?: (yjsUpdate: Uint8Array) => Promise<string>;
+    /** Host signal: the fileKey's rotation epoch (the gate `currentEpoch` / fileKey version — NOT
+     *  `editGrantEpoch`; default 0 for non-rotating plain-public docs). */
+    fileKeyEpoch?: number;
     ownerEdSecret?: string;
     contractAddress?: string;
     ownerAddress?: string;
@@ -21,11 +64,7 @@ export interface CollabSessionMeta {
     username: string;
     isEns?: boolean;
 }
-/** Storage integrations the sync engine depends on */
-export interface CollabServices {
-    commitToStorage?: (file: File) => Promise<string>;
-    fetchFromStorage?: (cid: string) => Promise<any>;
-}
+export type CollabServices = Record<string, never>;
 export type CollabErrorCode = 'CONNECTION_FAILED' | 'AUTH_FAILED' | 'SYNC_FAILED' | 'TIMEOUT' | 'UNKNOWN';
 export type CollabError = {
     code: CollabErrorCode;
@@ -93,6 +132,8 @@ export interface CollabCallbacks {
         data: AckResponse;
         roomKey: string;
     }) => void;
+    /** Live rename from the room owner; title is roomKey-encrypted. */
+    onTitleUpdate?: (encryptedTitle: string | null) => void;
 }
 /** Discriminated union — TypeScript enforces config+services only when enabled */
 export type CollaborationProps = {
@@ -127,7 +168,10 @@ export declare enum ServerErrorCode {
     INVALID_ADDRESS = "INVALID_ADDRESS",
     NOT_AUTHENTICATED = "NOT_AUTHENTICATED",
     DB_ERROR = "DB_ERROR",
-    INTERNAL_ERROR = "INTERNAL_ERROR"
+    INTERNAL_ERROR = "INTERNAL_ERROR",
+    JOIN_DISABLED = "JOIN_DISABLED",
+    EDIT_REVOKED = "EDIT_REVOKED",
+    ROOM_NOT_ESTABLISHED = "ROOM_NOT_ESTABLISHED"
 }
 export interface AckResponse<T = Record<string, any>> {
     status: boolean;
@@ -145,11 +189,30 @@ export interface SendUpdateResponse extends AckResponse<{
     createdAt: number;
 }> {
 }
-export interface CommitResponse extends AckResponse<{
-    cid: string;
-    createdAt: number;
+export interface HydrationRow {
+    id: string;
     documentId: string;
-    updates: string[];
+    seq: number;
+    data: string;
+    updateType: string;
+    committed?: boolean;
+    commitCid?: string | null;
+    createdAt?: number;
+    sessionDid?: string;
+    publishedMarker?: string | null;
+    floorSeq?: number | null;
+}
+export interface HydrationResponse extends AckResponse<{
+    history: HydrationRow[];
+    total: number;
+    snapshot: HydrationRow | null;
+    nextSeq: number | null;
+    hasMore: boolean;
+}> {
+}
+export interface SnapshotResponse extends AckResponse<{
+    id: string;
+    seq: number;
 }> {
 }
 export interface ISocketInitConfig {
@@ -157,7 +220,7 @@ export interface ISocketInitConfig {
     onDisconnect: () => void;
     onSocketDropped: () => void;
     onError: (err: Error) => void;
-    onHandShakeError: (err: Error, statusCode?: number) => void;
+    onHandShakeError: (err: Error, statusCode?: number, errorCode?: ServerErrorCode) => void;
     onContentUpdate: (data: {
         id: string;
         data: string;
@@ -171,6 +234,8 @@ export interface ISocketInitConfig {
         };
         roomId: string;
     }) => void;
+    onPresenceChange?: (collaborators: IDocCollabUsers[]) => void;
+    onTitleUpdate?: (encryptedTitle: string | null) => void;
     onSessionTerminated: (data: {
         roomId: string;
     }) => void;
@@ -196,4 +261,10 @@ export interface IAuthArgs {
     contractAddress?: string;
     sessionDid?: string;
     roomInfo?: string;
+    ownerIdentityDid?: string;
+    identityToken?: string;
+    identityContractAddress?: string;
+    editUcan?: string;
+    actorHandle?: string;
+    joinOnly?: boolean;
 }

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

@@ -5,6 +5,10 @@ export declare const useSyncManager: (config: SyncManagerConfig) => {
     connect: (connectConfig: CollabConnectionConfig) => void;
     disconnect: () => void;
     terminateSession: () => void;
+    updateTitle: (args: {
+        encryptedTitle: string;
+        documentTitle: string;
+    }) => void;
     isReady: boolean;
     isSyncing: boolean;
     awareness: import('y-protocols/awareness.js').Awareness | null;

package/dist/package/types.d.ts

@@ -9,10 +9,11 @@ import { CollaborationProps } from './sync-local/types';
 export type { CollaborationProps, CollabConnectionConfig, CollabSessionMeta, CollabServices, CollabCallbacks, CollabState, CollabError, CollabErrorCode, CollabStatus, } from './sync-local/types';
 export declare const DdocEditorProps: EditorProps;
 export interface IDocCollabUsers {
-    clientId: number;
+    clientId: string | number;
     name: string;
     isEns: string;
     color: string;
+    isPlaceholder?: boolean;
 }
 export type InlineCommentData = {
     inlineCommentText: string;
@@ -103,6 +104,17 @@ export interface DocumentStyling {
      * @example "portrait" | "landscape"
      */
     orientation?: 'portrait' | 'landscape';
+    /**
+     * Custom CSS
+     * @description The author's escape hatch for styling the document beyond the
+     * structured options above. Write BARE selectors (`h1 { … }`, `p { … }`,
+     * `blockquote { … }`) — they are auto-scoped to the document content, so rules
+     * can't leak into the toolbar or the host app. Bare top-level declarations
+     * (e.g. `background`, `font-family`) style the document surface itself.
+     * Applies live in the editor, in preview, and in exports (Markdown/HTML).
+     * @example "h1 { letter-spacing: -0.02em } p { line-height: 1.8 }"
+     */
+    customCSS?: string;
 }
 export interface DdocProps extends CommentAccountProps {
     /**
@@ -169,8 +181,11 @@ export interface DdocProps extends CommentAccountProps {
     walletAddress?: string | null;
     username?: string | null;
     setUsername?: React.Dispatch<SetStateAction<string>>;
-    renderNavbar?: ({ editor }: {
+    renderNavbar?: ({ editor, liveEditor, }: {
+        /** JSON snapshot — legacy field, unchanged. */
         editor: JSONContent;
+        /** Live Tiptap editor instance (D8) — null until the editor is ready. */
+        liveEditor: Editor | null;
     }) => JSX.Element;
     onChange?: (updatedDocContent: string | JSONContent, updateChunk: string) => void;
     onCollaboratorChange?: (collaborators: undefined | IDocCollabUsers[]) => void;
@@ -198,6 +213,9 @@ export interface DdocProps extends CommentAccountProps {
     onComment?: () => void;
     onInlineComment?: () => void;
     onFocusMode?: (isFocusMode: boolean) => void;
+    /** Controlled focus mode (D6). Omit for the legacy internal-state behavior. */
+    isFocusMode?: boolean;
+    onFocusModeChange?: (isFocusMode: boolean) => void;
     onMarkdownExport?: () => void;
     onMarkdownImport?: () => void;
     onPdfExport?: () => void;

package/dist/package/use-ddoc-editor.d.ts

@@ -28,8 +28,13 @@ export declare const useDdocEditor: ({ isPreviewMode, viewerMode, initialContent
     duplicateTab: (tabId: string) => string | undefined;
     orderTab: (destinationTabId: string, movedTabId: string) => void;
     onConnect: (connectConfig: import('./types').CollabConnectionConfig) => void;
+    onDisconnect: () => void;
     isReady: boolean;
     isSyncing: boolean;
+    updateTitle: (args: {
+        encryptedTitle: string;
+        documentTitle: string;
+    }) => void;
     hasCollabContentInitialised: boolean;
     isIndexeddbSynced: boolean;
     initialiseYjsIndexedDbProvider: () => Promise<void>;

package/dist/package/utils/colors.d.ts

@@ -9,4 +9,5 @@ export declare const textColors: {
     light: string;
     dark: string;
 }[];
+export declare const resolveEditorColorVars: (value: string) => string;
 export declare const getResponsiveColor: (color?: string, theme?: ThemeKey) => string | undefined;

package/dist/package/utils/insert-commands.d.ts

@@ -0,0 +1,20 @@
+import { Editor, Range } from '@tiptap/core';
+import { IpfsImageUploadResponse } from '../types';
+
+type InsertCommand = (editor: Editor, range?: Range) => void;
+export type UploadImageOptions = {
+    onError?: (errorString: string) => void;
+    ipfsImageUploadFn?: (file: File) => Promise<IpfsImageUploadResponse>;
+};
+/**
+ * File-picker image upload — mirrors the toolbar flow
+ * (editor-utils.tsx "Upload Image") and the slash "Image" item.
+ */
+export declare const uploadImageCommand: (editor: Editor, { onError, ipfsImageUploadFn }?: UploadImageOptions) => void;
+/**
+ * Insert commands shared by the slash menu and `useEditorCommands`.
+ * Bodies are moved verbatim from `slash-command-utils.tsx`; the optional
+ * `range` only differs when invoked from the slash menu.
+ */
+export declare const insertCommands: Record<string, InsertCommand>;
+export {};

package/dist/package/utils/make-editor.d.ts

@@ -0,0 +1,9 @@
+import { Editor } from '@tiptap/react';
+
+/**
+ * Shared jsdom editor factory for unit tests (use-editor-commands.test.tsx,
+ * selection-utils.test.ts, ...). Collaboration owns the doc, so content must
+ * be set via `setContent` *after* construction — passing `content` to the
+ * `Editor` constructor is silently ignored once Collaboration is configured.
+ */
+export declare const makeEditor: (content?: string) => Editor;

package/dist/package/utils/sanitize-css.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Sanitize + scope + validate author-supplied custom CSS before it is injected
+ * into the document.
+ *
+ * Authors write **normal, full-page CSS** — `body { … }`, `html body h1 { … }`,
+ * `h1 { … }`, `* { … }` — the way they'd style any web page. We transparently
+ * scope every rule to the document so it can't leak into the app, AND we map the
+ * page-root selectors (`html`, `body`, `:root`) onto the document root so that
+ * `body { background: … }` styles the doc surface and `html body h1 { … }`
+ * styles the doc's headings. No `.ProseMirror` prefix, no learning curve.
+ *
+ * Because the raw string reaches VIEWERS of a published doc, it is untrusted.
+ * Every selector is force-scoped (so a `}` breakout is neutralised — the escaped
+ * rule is simply scoped too), and dangerous declarations are stripped:
+ *  - external resource loads / exfiltration: `url(…)`, `@import`;
+ *  - clickjacking / UI redressing: `position: fixed | sticky`;
+ *  - legacy script vectors: `expression()`, `-moz-binding`, `behavior:`.
+ *
+ * We parse with the browser's own CSS engine (no dependency), rewrite each
+ * selector, strip dangerous declarations at every nesting level, and let the
+ * engine re-serialise — so the output is always a valid, balanced stylesheet.
+ *
+ * The sanitizer knows exactly what it removed, so it returns non-blocking
+ * `diagnostics`; the editing UI surfaces them (CSS is forgiving — we warn,
+ * never block).
+ */
+export interface CssDiagnostic {
+    level: 'warning' | 'error';
+    message: string;
+}
+export interface CssValidationResult {
+    /** Sanitized, scoped CSS, safe to inject. '' when nothing survives. */
+    css: string;
+    /** What was stripped/ignored, deduped. Empty when the CSS was fully clean. */
+    diagnostics: CssDiagnostic[];
+}
+/**
+ * Sanitize + scope AND report. Use this from the editing UI for diagnostics.
+ */
+export declare const validateCustomCss: (raw: string | undefined | null, scope?: string) => CssValidationResult;
+/**
+ * Sanitized + scoped CSS only — used at injection/export sinks that just need
+ * the safe string. Diagnostics are surfaced separately via validateCustomCss.
+ */
+export declare const sanitizeCustomCss: (raw: string | undefined | null, scope?: string) => string;

package/dist/package/utils/selection-utils.d.ts

@@ -0,0 +1,35 @@
+import { Editor } from '@tiptap/core';
+
+/**
+ * Cursor-relative word range in the current textblock, or null when the
+ * cursor is not adjacent to a word character (whitespace runs, empty
+ * blocks). Position math is relative ($from.start() + parentOffset), so it
+ * is schema-agnostic (works under dBlock wrappers).
+ */
+export declare const findWordRangeAtCursor: (editor: Editor) => {
+    from: number;
+    to: number;
+} | null;
+/**
+ * Ensure a text target for anchored actions (inline comments): keep any
+ * existing non-empty TextSelection; otherwise select the word under the
+ * collapsed cursor. Shares findWordRangeAtCursor with enablement so
+ * "enabled" always implies "dispatch does something".
+ *
+ * Only a TextSelection passes through untouched — a non-empty NodeSelection
+ * (e.g. an image or horizontal rule selected as a node) looks "non-empty"
+ * but has no text content, so `textBetween` over it is '' and anything
+ * downstream that needs real text (e.g. createFloatingDraft) would silently
+ * no-op. Falling through to findWordRangeAtCursor for any other selection
+ * type gives either a legitimate adjacent word or null (schema-dependent —
+ * e.g. false for a NodeSelection whose dBlock wrapper has no text).
+ */
+export declare const selectWordAtCursor: (editor: Editor) => boolean;
+/**
+ * Single enablement predicate for anchored text actions (inline comments):
+ * true when there's already a non-empty TextSelection, or a word is
+ * reachable from a collapsed cursor via findWordRangeAtCursor. Mirrors the
+ * passthrough condition in selectWordAtCursor so "enabled" always implies
+ * selectWordAtCursor will produce a real text target.
+ */
+export declare const hasTextTargetAtSelection: (editor: Editor) => boolean;

package/dist/package/utils/typography.d.ts

@@ -0,0 +1,26 @@
+import { Editor } from '@tiptap/core';
+
+export declare const FONT_SIZES: readonly [8, 9, 10, 11, 12, 14, 16, 18, 24, 30, 32, 36, 48, 60, 72, 96];
+export declare const getFontSizeOptions: (editor?: Editor) => {
+    title: string;
+    value: string;
+    label: string;
+    command: (editor: Editor) => void;
+    isActive: () => boolean | undefined;
+}[];
+export declare const getCurrentFontSize: (editor: Editor | null, currentSize: string) => string;
+export declare const uiValueToPercentage: (uiValue: string) => string;
+export declare const percentageToUiValue: (percentage: string) => string;
+export declare const LINE_HEIGHT_OPTIONS: {
+    value: string;
+    label: string;
+    uiValue: string;
+    description: string;
+}[];
+export declare const getLineHeightOptions: () => {
+    value: string;
+    label: string;
+    uiValue: string;
+    description: string;
+}[];
+export declare const getCurrentLineHeight: (editor: Editor | null, currentLineHeight?: string) => string;

package/dist/{split-view-toolbar-8avjvjIR.mjs → split-view-toolbar-B7EkoqMb.mjs}

@@ -1,7 +1,7 @@
-import { j as d } from "./index-DYlSDaET.mjs";
+import { j as d } from "./index-CM9WymRI.mjs";
 import { useRef as I, useState as N, useEffect as D } from "react";
 import { DynamicDropdown as E, Tooltip as R, IconButton as O } from "@fileverse/ui";
-import { a3 as A, a4 as P, c as y } from "./index-BfVM4ukb.mjs";
+import { a3 as A, a4 as P, c as y } from "./index-QQcgsp20.mjs";
 const p = (e, t, o = t) => {
   const { state: s } = e, l = s.changeByRange((n) => {
     const u = s.sliceDoc(n.from, n.to), r = s.sliceDoc(