wordinweb 0.2.2 → 0.2.3

package/dist/collab.d.ts

@@ -1,6 +1,6 @@
 import { ReactNode } from 'react';
-import { X as XmlElement, D as DocxDocument, C as ClientMessage, S as ServerMessage, P as PresencePosition, R as RosterEntry, a as ParticipantProfile, I as Intent, b as IdSidecar, L as LineageHead, T as ToolbarFeature, c as ToolbarMode, d as DocxViewApi, W as WriteStatus, U as UndoOutcome } from './index-C2J9egkh.js';
-export { e as bytesToB64, f as deriveEpochKeys, g as docKeyFromFragment, m as mintDocKey, s as sealCheckpoint, h as stretchShareCode } from './index-C2J9egkh.js';
+import { X as XmlElement, D as DocxDocument, C as ClientMessage, S as ServerMessage, P as PresencePosition, R as RosterEntry, a as ParticipantProfile, I as Intent, b as IdSidecar, L as LineageHead, T as ToolbarFeature, c as ToolbarMode, d as DocxViewApi, W as WriteStatus, U as UndoOutcome } from './index-CGp6gVjn.js';
+export { e as bytesToB64, f as deriveEpochKeys, g as docKeyFromFragment, m as mintDocKey, s as sealCheckpoint, h as stretchShareCode } from './index-CGp6gVjn.js';
 
 /**
  * How much of the document an applied intent disturbed — the input to
@@ -348,11 +348,8 @@ declare class CollabConnection {
      * the renderer re-mounts on this, but updates in place otherwise (no flash
      * for the common non-conflicting edits). */
     docEpoch: number;
-    /** Per-client id allocator for carried node ids (split/format-range/insert):
-     * a client-specific base block keeps concurrently-allocated ids disjoint
-     * across clients so they never collide. */
-    private idCounter;
-    private idBase;
+    /** Per-client id allocator for carried node ids (split/format-range/insert). */
+    private readonly idAllocator;
     /** The epoch id of the session this connection joined (from the welcome).
      * The resume layer compares it against the bundle's stored genesisId:
      * same ⇒ seamless rejoin; different ⇒ someone re-seeded while away
@@ -552,6 +549,8 @@ declare class CollabConnection {
  */
 interface DocBundle {
     docId: string;
+    /** Human title chosen for this browser copy. It never enters the room URL. */
+    title?: string;
     /** Epoch of the session this state came from (doc 12 §5): on rejoin,
      * same ⇒ seamless resume; different ⇒ someone re-seeded while away. */
     genesisId: string;
@@ -592,11 +591,14 @@ interface DocBundle {
     /**
      * The genesisId of the epoch the offline tail was recorded AGAINST. This
      * is what lets a resume decide the arrival rung without guessing: same
-     * epoch ⇒ the tail is morally a large pending queue and replays silently;
-     * different (or absent, for a tail written by an older build) ⇒ true
-     * divergence, offer suggest/draft — never silently bulldoze.
+     * epoch can replay after the required merge check; different (or absent,
+     * for a tail written by an older build) means true divergence and offers
+     * suggest/draft.
      */
     offlineTailEpoch?: string;
+    /** Confirmed room sequence when offline editing began. A stable-URL rejoin
+     * compares this with the room sequence to decide whether a review is needed. */
+    offlineBaseSeq?: number;
     /** Per-part media metadata (doc 16 §5.3): the sha (and E2EE iv/epoch)
      * of every media part this copy knows. The docx bytes carry the PIXELS;
      * this carries the ADDRESSES — without it a resumed holder couldn't
@@ -650,6 +652,8 @@ interface StoredDocSummary extends ParsedBundleKey {
     savedAt: number;
     /** Size of the stored document bytes. */
     byteLength: number;
+    /** Human title stored with the browser copy. */
+    title?: string;
 }
 /**
  * Storage seam for bundles. The browser implementation is IndexedDB (the
@@ -727,6 +731,7 @@ declare class BundlePersister {
         offlineTail?: () => {
             tail: Intent[];
             epoch?: string;
+            baseSeq?: number;
         } | null;
     });
     private get throttleMs();
@@ -913,8 +918,8 @@ interface CollabSession {
      * repaint sees every batched intent's scope.
      */
     takeRenderScope: () => Scope | null;
-    /** Increases only when reconciliation RELOADED the document (a true
-     * conflict). The editor re-mounts on this; between reloads it updates in
+    /** Increases when a reconnect or reconciliation replaces the document
+     * object. The editor re-mounts on this; between replacements it updates in
      * place (no flash for the common non-conflicting edits). */
     docEpoch: number;
     /** True once joined and the snapshot is loaded. */
@@ -974,8 +979,9 @@ interface CollabSession {
      *
      * Null while the connection is live, and null when a refusal already
      * blocks writes (a viewer's link does not become writable by going
-     * through a tunnel). On reconnect the tail replays: silently as ordinary
-     * edits when the session is the same epoch, else via {@link arrival}.
+     * through a tunnel). An automatic same-epoch reconnect replays the tail
+     * silently. An intentional disconnect uses {@link arrival} for an explicit
+     * merge check.
      */
     offline: {
         editsHeld: number;
@@ -988,6 +994,14 @@ interface CollabSession {
      * the statement that automatic recovery has stopped.
      */
     reconnect: () => void;
+    /**
+     * Intentionally leave the transport while the document stays open. Edits
+     * continue into the offline tail until {@link reconnect} rejoins the same
+     * room. This differs from a server refusal, which blocks edits.
+     */
+    disconnect: () => void;
+    /** Reapply the stored offline tail after a page reload restores its base. */
+    restoreOfflineView: () => void;
     /**
      * The server announced it will END this session, and this is the grace
      * period before it does. `inMs` is the measured remainder at the moment the
@@ -1136,19 +1150,19 @@ interface CollabSession {
      * a DIFFERENT epoch than the tail was recorded against, the recommended
      * mode is `suggest` (replay as tracked changes; ≤ the suggest threshold)
      * or `draft` (large tails). `structural` counts the tail intents that
-     * have no suggestion form (splits/merges/tables/format — rebase.ts):
+     * have no suggestion form (merges/tables/format — rebase.ts):
      * they are NOT replayed by `suggest` and survive in the banked draft
      * slot instead — say so, or their absence reads as silent loss. A
-     * same-epoch rejoin never surfaces here: its tail replays silently
-     * through the ordinary submit path, like a large pending queue.
+     * same-epoch automatic rejoin replays silently. An intentional disconnect
+     * offers `replay`; a changed room offers `suggest` or `draft`.
      * Null when there's nothing to reconcile. `reconcile()` runs the choice.
      */
     arrival: {
-        mode: "suggest" | "draft";
+        mode: "replay" | "suggest" | "draft";
         tailLength: number;
         structural: number;
     } | null;
-    reconcile: (mode: "suggest" | "draft") => void;
+    reconcile: (mode: "replay" | "suggest" | "draft") => void;
     /** How many times the connection self-healed a drifted optimistic replica
      * (encrypted mode's quiescent mirror check — the B6a class). Telemetry;
      * the heal itself is automatic and already reflected in doc/docEpoch. */
@@ -1250,6 +1264,8 @@ declare function useCollab(opts: UseCollabOptions): CollabSession;
 declare const COLLAB_TOOLBAR_DEFAULTS: Partial<Record<ToolbarFeature, boolean>>;
 declare function CollabEditor(opts: UseCollabOptions & {
     editable?: boolean;
+    /** Tracked-change display. Use markup to show suggestions in the document. */
+    revisions?: "final" | "markup";
     /** Render the Word-style ribbon toolbar above the page (default true). */
     toolbar?: boolean;
     /** Ribbon mode: "simple" (Home only) or "advanced" (default). */