@fileverse-dev/dsheet 4.1.3 → 4.1.4

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

@@ -9,35 +9,66 @@ export declare class SyncManager {
     private socketClient;
     private roomKey;
     private roomKeyBytes;
+    private rotating;
+    private roomKeyBytesPrev;
+    private pendingRotationKey;
+    private healingPromise;
+    private healBackoffUntil;
+    private staleAckRetries;
+    private encryptMirror;
+    private fileKeyEpoch;
+    private mirrorIdleTimer;
+    private readonly MIRROR_IDLE_MS;
     private isOwner;
+    private joinOnly;
     private updateQueue;
-    private uncommittedUpdatesIdList;
     private contentTobeAppliedQueue;
     private isProcessing;
-    /** Prevents parallel terminateSession calls (UI + effect cleanup). */
-    private _terminating;
+    private syncId;
+    private floor;
+    private updatesSinceSnapshot;
+    private isAuthoringSnapshot;
+    private readonly SNAPSHOT_THRESHOLD;
+    private tailCompactTimer;
+    private gapCatchUpTimer;
+    private gapCatchUpInFlight;
+    private gapCatchUpCooldownUntil;
+    private readonly TAIL_COMPACT_PAGES;
+    private readonly TAIL_COMPACT_ROWS;
     private flushTimer;
     private readonly FLUSH_INTERVAL_MS;
     private readonly MAX_QUEUE_SIZE;
     private _awarenessUpdateHandler;
     private ydoc;
-    private servicesRef;
     private callbacksRef;
     private onLocalUpdate?;
     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): void;
     get isConnected(): boolean;
     get isReady(): boolean;
     get awareness(): Awareness | null;
     get status(): CollabStatus;
     get collabState(): CollabState;
+    private beginSyncAttempt;
+    private isCurrentSyncAttempt;
     private send;
     private runExitActions;
     private runEntryActions;
     connect(config: CollabConnectionConfig): Promise<void>;
     disconnect(): Promise<void>;
+    /** Owner rename mid-session — see SocketClient.updateDocumentMeta. */
+    updateTitle(args: {
+        encryptedTitle: string;
+        documentTitle: string;
+    }): Promise<void>;
     terminateSession(): Promise<void>;
+    /** In-place roomKey migration on CUTOVER: pause dispatch, swap the key, re-auth the same
+     *  socket, re-broadcast awareness, then flush. See SocketClient.rekey for the wire side. */
+    rekey(newRoomKey: string, newAppLock?: string, newEditUcan?: string): Promise<void>;
+    private onDecryptMiss;
+    private runGapCatchUp;
+    private scheduleGapCatchUp;
     enqueueLocalUpdate(update: Uint8Array): void;
     private flushUpdates;
     private awaitFlush;
@@ -45,21 +76,35 @@ export declare class SyncManager {
      * Fire-and-forget: merge all queued updates, encrypt, and emit via Socket.IO
      * without awaiting the server ACK. The server broadcasts to peers immediately
      * (before MongoDB write), so content reaches observers in near-real-time.
-     * ACK callback handles updateId tracking and auto-commit asynchronously.
      */
     private sendUpdateBatch;
+    private sendUpdateBatchAttempt;
+    private isRevocationResponse;
+    private isSessionTerminatedResponse;
+    private isSessionNotFoundResponse;
+    private classifyRevocation;
+    private handleWriteRevocation;
+    private surfaceSessionTerminated;
+    private maybeAuthorSnapshotAfterSend;
+    private scheduleMirror;
+    private authorMirror;
+    buildPendingBeaconPayload(): string | null;
+    fireBeacon(): void;
     forceCleanup(): void;
     private handleConnectionError;
     private handleReconnection;
     private connectSocket;
-    private syncLatestCommit;
+    private tryDecrypt;
+    private decodeInto;
+    private catchUpFloor;
+    private authorSnapshot;
+    private hydrate;
+    private maybeCompactTail;
     private initializeAwareness;
     private cleanupAwareness;
-    private commitLocalContents;
     private broadcastLocalContents;
     private processUpdateQueue;
     private processNextUpdate;
-    private processCommit;
     private handleRemoteContentUpdate;
     private applyRemoteYjsUpdate;
     private applyQueuedRemoteContents;

package/dist/sync-local/crypto/room-key.d.ts

@@ -0,0 +1,2 @@
+export declare const encryptForRoomKey: (roomKey: string, bytes: Uint8Array) => string;
+export declare const decryptForRoomKey: (roomKey: string, ciphertext: string) => Uint8Array;

package/dist/sync-local/crypto/room-key.test.d.ts

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

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

@@ -0,0 +1,8 @@
+import * as Y from 'yjs';
+export declare function advanceFloor(floor: number, pageSeqsAscending: number[]): number;
+export declare function shouldAuthorSnapshot(p: {
+    canAuthor: boolean;
+    updatesSinceLastSnapshot: number;
+    threshold: number;
+}): boolean;
+export declare function computeLocalOnlyUpdate(ydoc: Y.Doc, serverMerged: Uint8Array | null): Uint8Array | null;

package/dist/sync-local/floor.test.d.ts

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

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

@@ -1,3 +1,3 @@
 export { useSyncManager } from './useSyncManager';
 export { SyncManager } from './SyncManager';
-export type { SyncManagerConfig, CollabConnectionConfig, CollabServices, CollabCallbacks, CollaborationProps, CollabSessionMeta, CollabStatus, CollabState, CollabError, CollabErrorCode, CollabEvent, CollabContext, CollabUser, } from './types';
+export type { SyncManagerConfig, CollabConnectionConfig, CollabServices, CollabCallbacks, CollaborationProps, CollabSessionMeta, CollabStatus, CollabState, CollabError, CollabErrorCode, CollabEvent, CollabContext, } from './types';

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

@@ -0,0 +1,13 @@
+import { CollabUser } from './types';
+
+export interface AwarenessIdentity {
+    name: string;
+    color: string;
+    isEns: string | boolean;
+}
+export declare const PLACEHOLDER_COLOR = "#9CA3AF";
+export declare const COLLAB_PRESENCE_COLORS: readonly ["#30bced", "#6eeb83", "#fa69d1", "#ecd444", "#ee6352", "#db3041", "#0ad7f2", "#1bff39"];
+export declare function buildIdentityMap(states: Map<number, Record<string, unknown>>): Map<string, AwarenessIdentity>;
+export declare function mergePresence(roomMembers: string[], identityBySocketId: Map<string, AwarenessIdentity>): CollabUser[];
+export declare function assignSessionColors(collaborators: CollabUser[], colorByName: Map<string, string>): CollabUser[];
+export declare function identitySignature(roomMembers: string[], identityBySocketId: Map<string, AwarenessIdentity>): string;

package/dist/sync-local/presence.test.d.ts

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

package/dist/sync-local/session-tools.d.ts

@@ -0,0 +1,31 @@
+import { CollabConnectionConfig } from './types';
+
+/**
+ * Headless hydrate: pulls the OLD session's durable log and decrypts it with `roomKey`.
+ * The old session still exists server-side — termination only rejects writes, so a
+ * joinOnly read succeeds even after cutover. Mirrors the connect-time hydration pull
+ * (SyncManager.catchUpFloor / decodeInto), minus the Y.Doc/floor bookkeeping. Throws on
+ * connect/auth/pull failure; an individual undecryptable row is skipped, not fatal.
+ */
+export declare function fetchSessionState(args: {
+    dsheetId: string;
+    roomKey: string;
+    ownerAuth: CollabConnectionConfig;
+}): Promise<Uint8Array[]>;
+/**
+ * Headless seed: pushes `state` into a brand-new session as a single owner snapshot,
+ * encrypted under `newRoomKey`. `floorSeq: 0` — the target session is freshly created by
+ * the rotate op and holds no rows yet, so there is nothing to catch up before stamping.
+ *
+ * Caller ordering: must run AFTER the rotate op has already created the target session.
+ * This function's own owner `/auth` is create-or-join — calling it first would create the
+ * target session itself and, as an owner /auth, sweep (terminate) any other non-terminated
+ * session for this document, which is the OLD session that's supposed to keep draining
+ * stragglers during the rotation window. Seeding early collapses that drain early.
+ */
+export declare function seedSession(args: {
+    dsheetId: string;
+    newRoomKey: string;
+    state: Uint8Array;
+    ownerAuth: CollabConnectionConfig;
+}): Promise<void>;

package/dist/sync-local/session-tools.test.d.ts

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

package/dist/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,37 @@ interface ISocketClientConfig {
     ownerEdSecret?: string;
     contractAddress?: string;
     ownerAddress?: string;
+    editLock?: string;
+    encryptedTitle?: string;
+    identityToken?: string;
+    editUcan?: string;
+    refreshEditClaim?: () => Promise<{
+        status: 'ok';
+        token: string;
+    } | {
+        status: 'demoted';
+    } | {
+        status: 'unavailable';
+    }>;
+    onRotationPrepare?: (inner: {
+        epoch: number;
+        gp: string;
+        appLock?: string;
+    }) => Promise<string | {
+        roomKey: string;
+        editUcan?: string;
+    } | null>;
+    onEpochAvailable?: (data: {
+        roomId: string;
+        epoch: number;
+        payload: string;
+    }) => void | Promise<void>;
+    onCutover?: (data: {
+        roomId: string;
+        epoch: number;
+    }) => void | Promise<void>;
+    actorHandle?: string;
+    joinOnly?: boolean;
     onHandshakeData?: (response: {
         data: AckResponse;
         roomKey: string;
@@ -20,6 +51,8 @@ interface ISocketClientConfig {
 }
 export declare class SocketClient {
     private _socketUrl;
+    private _restBase;
+    private _lastSessionToken;
     private _socket;
     private _webSocketStatus;
     private _isIntentionalDisconnect;
@@ -27,38 +60,72 @@ export declare class SocketClient {
     get status(): SocketStatusEnum;
     private _websocketServiceDid;
     private roomId;
-    roomMembers: RoomMember[];
+    roomMembers: string[];
+    private _lastPresenceSignature;
+    private _presenceColorByName;
+    private _onPresenceChange?;
+    private _pendingAwarenessUpdates;
     private collaborationKeyPair;
     private ownerKeyPair?;
     private contractAddress?;
     private ownerUcan?;
     private collaborationUcan?;
     private ownerAddress?;
+    private editLock?;
+    private encryptedTitle?;
+    private identityToken?;
+    private editUcan?;
+    private refreshEditClaim?;
+    private lastGoodEditUcan?;
+    private actorHandle?;
+    private joinOnly?;
     private roomKey;
     private roomInfo?;
     private awareness;
     private connectionAttemptErrorCount;
     private _onHandshakeData;
+    private _onEpochAvailable;
+    private _onCutover;
+    private _rotating;
     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;
+    rekey(newRoomKey: string, newAppLock?: string, newEditUcan?: string): Promise<void>;
+    ackEpochLoaded(documentId: string, epoch: number): Promise<void>;
     terminateSession: () => Promise<void>;
+    flushBeacon(mergedUpdate: string): void;
     private getCollaborationKeyPair;
     private isUcanValid;
     private getOwnerToken;
     private buildSessionToken;
+    private _authenticate;
     private _handleHandShake;
     private _handleAwarenessUpdate;
     connectSocket(config: ISocketInitConfig): Promise<void>;

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

@@ -1,9 +1,12 @@
 import * as Y from 'yjs';
+/** dSheet presence identity. Cell coordinates stay in Yjs awareness and are
+ * intentionally excluded from the authoritative socket roster signature. */
 export interface CollabUser {
-    clientId: number;
+    clientId: string | number;
     name: string;
     color: string;
-    isEns: boolean;
+    isEns: string | boolean;
+    isPlaceholder?: boolean;
     cell?: {
         r: number;
         c: number;
@@ -16,6 +19,60 @@ 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): 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 (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: resolves the rotated roomKey for the given epoch payload (GP: gate release
+     *  unwrap of `gp`; workspace: app-key unwrap of `appLock`). Returns the new base64 roomKey —
+     *  or, for a gate-admitted editor, `{ roomKey, editUcan }`: the same gate release that unwraps
+     *  the relay also mints the new-epoch editUcan, and the cutover re-auth must present THAT token
+     *  (a re-mint through the host's fresh-open flow can race the deferred publish and hand back a
+     *  stale-epoch claim). `null` if this actor can't resolve it (falls back to the decrypt-miss
+     *  self-heal path). Opaque to the package. */
+    onRotationPrepare?: (inner: {
+        epoch: number;
+        gp: string;
+        appLock?: string;
+    }) => Promise<string | {
+        roomKey: string;
+        editUcan?: string;
+    } | null>;
+    /** 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;
@@ -28,21 +85,18 @@ export interface CollabConnectionConfig {
 /** Session metadata — changes to these update awareness, NOT reconnect */
 export interface CollabSessionMeta {
     username: string;
+    /** Spreadsheet-only awareness color used by Fortune cell cursors. */
     color?: 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 CollabErrorCode = 'CONNECTION_FAILED' | 'AUTH_FAILED' | 'SYNC_FAILED' | 'TIMEOUT' | 'POISONED_ROOM' | 'UNKNOWN';
+export type CollabServices = Record<string, never>;
+export type CollabErrorCode = 'CONNECTION_FAILED' | 'AUTH_FAILED' | 'SYNC_FAILED' | 'TIMEOUT' | 'UNKNOWN';
 export type CollabError = {
     code: CollabErrorCode;
     message: string;
     recoverable: boolean;
 };
-export type CollabStatus = 'idle' | 'connecting' | 'syncing' | 'ready' | 'reconnecting' | 'error' | 'terminated';
+export type CollabStatus = 'idle' | 'connecting' | 'syncing' | 'ready' | 'reconnecting' | 'rotating' | 'error' | 'terminated';
 export type CollabState = {
     status: 'idle';
 } | {
@@ -56,6 +110,10 @@ export type CollabState = {
     status: 'reconnecting';
     attempt: number;
     maxAttempts: number;
+}
+/** roomKey migration in flight — distinct from `terminated` so consumers don't mistake it for a kick. */
+ | {
+    status: 'rotating';
 } | {
     status: 'error';
     error: CollabError;
@@ -84,6 +142,10 @@ export type CollabEvent = {
 } | {
     type: 'SESSION_TERMINATED';
     reason?: string;
+}
+/** roomKey cutover in progress; no-op on status — lets the manager gate re-entrancy itself. */
+ | {
+    type: 'CUTOVER';
 } | {
     type: 'RESET';
 };
@@ -103,6 +165,13 @@ export interface CollabCallbacks {
         data: AckResponse;
         roomKey: string;
     }) => void;
+    /** Live rename from the room owner; title is roomKey-encrypted. */
+    onTitleUpdate?: (encryptedTitle: string | null) => void;
+    /** Decrypt-miss self-heal: resolves the CURRENT-epoch roomKey (same resolution the host
+     *  uses for `onRotationPrepare`, minus the relay payload — re-read the blob's
+     *  `wrappedRoomKey` / appLock). Returns the new base64 roomKey, or `null` if this actor
+     *  can't resolve one (the miss is then a real revocation, not a rotation lag). */
+    onRotationSelfHeal?: () => Promise<string | null>;
 }
 /** Discriminated union — TypeScript enforces config+services only when enabled */
 export type CollaborationProps = {
@@ -138,7 +207,9 @@ export declare enum ServerErrorCode {
     NOT_AUTHENTICATED = "NOT_AUTHENTICATED",
     DB_ERROR = "DB_ERROR",
     INTERNAL_ERROR = "INTERNAL_ERROR",
-    APP_MISMATCH = "APP_MISMATCH"
+    JOIN_DISABLED = "JOIN_DISABLED",
+    EDIT_REVOKED = "EDIT_REVOKED",
+    ROOM_NOT_ESTABLISHED = "ROOM_NOT_ESTABLISHED"
 }
 export interface AckResponse<T = Record<string, any>> {
     status: boolean;
@@ -156,11 +227,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 {
@@ -168,7 +258,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;
@@ -182,6 +272,8 @@ export interface ISocketInitConfig {
         };
         roomId: string;
     }) => void;
+    onPresenceChange?: (collaborators: CollabUser[]) => void;
+    onTitleUpdate?: (encryptedTitle: string | null) => void;
     onSessionTerminated: (data: {
         roomId: string;
     }) => void;
@@ -208,5 +300,9 @@ export interface IAuthArgs {
     contractAddress?: string;
     sessionDid?: string;
     roomInfo?: string;
+    identityToken?: string;
+    editUcan?: string;
+    actorHandle?: string;
+    joinOnly?: boolean;
     appType?: AppType;
 }

package/dist/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/{use-xlsx-import-impl-DB8XoHgC.js → use-xlsx-import-impl-tzKWGisi.js}

@@ -1,10 +1,10 @@
 import * as BZ from "yjs";
-import { i as Yl, a as ul, s as eZ, r as hl, y as Il, b as pl, m as Rl } from "./index-C-29uy7d.js";
+import { i as Yl, a as ul, s as eZ, r as hl, y as Il, b as pl, m as Rl } from "./index-CRzwkPJq.js";
 import { g as sl } from "./executeStringFunction-adhsb5GH.js";
 import { Workbook as al } from "exceljs";
 import Kl from "luckyexcel";
-import { e as Jl, b as xl, n as Ml } from "./xlsx-hyperlink-inline-iNImgoxT.js";
-import { parseDefinedNamesFromXlsxBuffer as Sl, excelEntriesToDefinedNames as OZ } from "./xlsx-defined-names-Cz6m4fA3.js";
+import { e as Jl, b as xl, n as Ml } from "./xlsx-hyperlink-inline-DWLdqDYy.js";
+import { parseDefinedNamesFromXlsxBuffer as Sl, excelEntriesToDefinedNames as OZ } from "./xlsx-defined-names-CflXuPTO.js";
 import { toast as fZ } from "@fileverse/ui";
 var Zl = { exports: {} };
 (function(c) {

package/dist/{xlsx-defined-names-Cz6m4fA3.js → xlsx-defined-names-CflXuPTO.js}

@@ -1,5 +1,5 @@
 import { i as w } from "./executeStringFunction-adhsb5GH.js";
-import { J as x } from "./xlsx-hyperlink-inline-iNImgoxT.js";
+import { J as x } from "./xlsx-hyperlink-inline-DWLdqDYy.js";
 function g(o) {
   return o.startsWith("_xlnm.");
 }

package/dist/{xlsx-export-impl-C1LcpSSe.js → xlsx-export-impl-CkJLfQwm.js}

@@ -1,9 +1,9 @@
 import { utils as F, write as it } from "xlsx-js-style";
 import { Workbook as ct } from "exceljs";
 import { toast as nt } from "@fileverse/ui";
-import { J as ft, c as X, g as ut, a as pt } from "./xlsx-hyperlink-inline-iNImgoxT.js";
+import { J as ft, c as X, g as ut, a as pt } from "./xlsx-hyperlink-inline-DWLdqDYy.js";
 import { b as dt } from "./executeStringFunction-adhsb5GH.js";
-import { e as ht } from "./index-C-29uy7d.js";
+import { e as ht } from "./index-CRzwkPJq.js";
 const mt = {
   1: "thin",
   2: "hair",
@@ -810,7 +810,7 @@ const Y = (e) => {
           D
         );
       });
-      const { applyDefinedNamesToExcelWorkbook: ot } = await import("./xlsx-defined-names-Cz6m4fA3.js");
+      const { applyDefinedNamesToExcelWorkbook: ot } = await import("./xlsx-defined-names-CflXuPTO.js");
       ot(
         j,
         (T = (a = (d = e.current).getWorkbookContext) == null ? void 0 : a.call(d)) == null ? void 0 : T.definedNames,

package/dist/{xlsx-hyperlink-inline-iNImgoxT.js → xlsx-hyperlink-inline-DWLdqDYy.js}

@@ -1,5 +1,5 @@
 import { g as Rt, c as yt } from "./executeStringFunction-adhsb5GH.js";
-import { c as wt } from "./index-C-29uy7d.js";
+import { c as wt } from "./index-CRzwkPJq.js";
 function jt(J, nt) {
   const g = J.getImages();
   if (!g.length) return [];

package/package.json

@@ -2,7 +2,7 @@
   "name": "@fileverse-dev/dsheet",
   "private": false,
   "description": "DSheet",
-  "version": "4.1.3",
+  "version": "4.1.4",
   "main": "dist/index.es.js",
   "module": "dist/index.es.js",
   "exports": {