@tuturuuu/ui 0.37.2 → 0.39.0

package/src/hooks/__tests__/use-local-storage.test.tsx

@@ -147,6 +147,48 @@ describe('useLocalStorage', () => {
   });
 
   describe('error handling', () => {
+    it('completes initialization with defaults when getItem is denied', () => {
+      vi.spyOn(window.localStorage, 'getItem').mockImplementation(() => {
+        throw new DOMException('Synthetic denied read', 'SecurityError');
+      });
+      const { result } = renderHook(() =>
+        useLocalStorage('invoice-compact-view', false)
+      );
+      expect(result.current).toEqual([false, expect.any(Function), true]);
+      expect(console.error).toHaveBeenCalledWith(
+        'Unable to read browser preferences.'
+      );
+      act(() => result.current[1](true));
+      expect(result.current[0]).toBe(true);
+    });
+
+    it('completes initialization when the storage getter itself is denied', () => {
+      const storage = window.localStorage;
+      Object.defineProperty(window, 'localStorage', {
+        configurable: true,
+        get() {
+          throw new DOMException('Synthetic denied getter', 'SecurityError');
+        },
+      });
+      try {
+        const { result } = renderHook(() =>
+          useLocalStorage('printAfterCreate', true)
+        );
+        expect(result.current).toEqual([true, expect.any(Function), true]);
+        act(() => result.current[1](false));
+        expect(result.current[0]).toBe(false);
+        expect(console.error).toHaveBeenLastCalledWith(
+          'Unable to save browser preferences.'
+        );
+      } finally {
+        Object.defineProperty(window, 'localStorage', {
+          configurable: true,
+          writable: true,
+          value: storage,
+        });
+      }
+    });
+
     it('should handle invalid JSON in localStorage gracefully', () => {
       window.localStorage.setItem(TEST_KEY, 'invalid-json');
 

package/src/hooks/__tests__/use-native-calendar-occurrences.test.tsx

@@ -0,0 +1,140 @@
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { act, renderHook, waitFor } from '@testing-library/react';
+import { InternalApiError } from '@tuturuuu/internal-api/client';
+import type { CalendarEvent } from '@tuturuuu/types/primitives/calendar-event';
+import type { ReactNode } from 'react';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const mock = vi.hoisted(() => ({
+  list: vi.fn(),
+  actor: { actorId: 'actor', assertActive: vi.fn() },
+}));
+vi.mock('@tuturuuu/internal-api/calendar-series', () => ({
+  listNativeCalendarOccurrences: mock.list,
+}));
+vi.mock('../use-workspace-visibility', () => ({
+  useWorkspaceActor: () => mock.actor,
+}));
+
+import {
+  EMPTY_NATIVE_OCCURRENCES,
+  nativeOccurrencesKey,
+  useNativeCalendarOccurrences,
+  visibleNativeOccurrences,
+} from '../use-native-calendar-occurrences';
+
+const event: CalendarEvent = {
+  id: 'event',
+  seriesId: 'series',
+  start_at: '2026-10-05T09:00:00Z',
+  end_at: '2026-10-05T10:00:00Z',
+};
+const dates = [new Date(2026, 9, 5)];
+function setup() {
+  const client = new QueryClient({
+    defaultOptions: { queries: { retry: false } },
+  });
+  return {
+    client,
+    wrapper: ({ children }: { children: ReactNode }) => (
+      <QueryClientProvider client={client}>{children}</QueryClientProvider>
+    ),
+  };
+}
+beforeEach(() => {
+  mock.list.mockReset();
+  mock.actor.actorId = 'actor';
+  mock.actor.assertActive.mockReset();
+  mock.list.mockResolvedValue({ data: [event] });
+});
+describe('native occurrence SWR feed', () => {
+  it('uses one stable empty reference before data and for denied/external feeds', () => {
+    expect(visibleNativeOccurrences(undefined, null)).toBe(
+      EMPTY_NATIVE_OCCURRENCES
+    );
+    expect(
+      visibleNativeOccurrences([event], new InternalApiError('denied', 403))
+    ).toBe(EMPTY_NATIVE_OCCURRENCES);
+  });
+  it.each([
+    new TypeError('Failed to fetch'),
+    new InternalApiError('busy', 429),
+    new InternalApiError('failed', 503),
+    new InternalApiError('verify', 403, 'MFA_REQUIRED'),
+  ])('retains authorized rows for recoverable failure %o', (error) => {
+    const data = [event];
+    expect(visibleNativeOccurrences(data, error)).toBe(data);
+  });
+  it('loads the requested workspace range using an actor-scoped key', async () => {
+    const { client, wrapper } = setup();
+    const { result } = renderHook(
+      () => useNativeCalendarOccurrences('ws', dates, 'UTC', false),
+      { wrapper }
+    );
+    await waitFor(() => expect(result.current.data).toEqual([event]));
+    expect(mock.list).toHaveBeenCalledWith(
+      'ws',
+      { from: '2026-10-05T00:00:00.000Z', to: '2026-10-06T00:00:00.000Z' },
+      expect.objectContaining({ signal: expect.any(AbortSignal) })
+    );
+    expect(client.getQueryCache().getAll()[0]?.queryKey).toContain('actor');
+  });
+  it('retains cached rows while a transient refresh fails', async () => {
+    const { wrapper } = setup();
+    const { result } = renderHook(
+      () => useNativeCalendarOccurrences('ws', dates, 'UTC', false),
+      { wrapper }
+    );
+    await waitFor(() => expect(result.current.data).toEqual([event]));
+    mock.list.mockRejectedValue(new InternalApiError('busy', 429));
+    await act(async () => {
+      await result.current.refetch();
+    });
+    expect(result.current.data).toEqual([event]);
+    await waitFor(() => expect(result.current.isError).toBe(true));
+  });
+  it.each([401, 403, 404])(
+    'clears retained and durable rows after definitive status %s',
+    async (status) => {
+      const { client, wrapper } = setup();
+      const { result } = renderHook(
+        () => useNativeCalendarOccurrences('ws', dates, 'UTC', false),
+        { wrapper }
+      );
+      await waitFor(() => expect(result.current.data).toEqual([event]));
+      mock.list.mockRejectedValue(new InternalApiError('denied', status));
+      await act(async () => {
+        await result.current.refetch();
+      });
+      await waitFor(() =>
+        expect(result.current.data).toBe(EMPTY_NATIVE_OCCURRENCES)
+      );
+      expect(
+        client.getQueriesData({ queryKey: nativeOccurrencesKey('ws') })[0]?.[1]
+      ).toEqual([]);
+    }
+  );
+  it('does not read native data for externally supplied calendars or empty dates', () => {
+    const { wrapper } = setup();
+    const { result, rerender } = renderHook(
+      ({ external, range }) =>
+        useNativeCalendarOccurrences('ws', range, 'UTC', external),
+      { wrapper, initialProps: { external: true, range: dates } }
+    );
+    expect(result.current.data).toBe(EMPTY_NATIVE_OCCURRENCES);
+    rerender({ external: false, range: [] });
+    expect(mock.list).not.toHaveBeenCalled();
+  });
+  it('does not carry a previous actor snapshot into another account', async () => {
+    const { wrapper } = setup();
+    const { result, rerender } = renderHook(
+      () => useNativeCalendarOccurrences('ws', dates, 'UTC', false),
+      { wrapper }
+    );
+    await waitFor(() => expect(result.current.data).toEqual([event]));
+    mock.actor.actorId = 'other';
+    mock.list.mockImplementation(() => new Promise(() => {}));
+    rerender();
+    expect(result.current.data).toBe(EMPTY_NATIVE_OCCURRENCES);
+  });
+});

package/src/hooks/__tests__/use-notifications-subscription.test.tsx

@@ -11,7 +11,7 @@ import {
 } from '../use-notifications';
 
 const createRealtimeClient = vi.hoisted(() => vi.fn());
-vi.mock('@tuturuuu/supabase/next/realtime-browser', () => ({
+vi.mock('@tuturuuu/internal-api/realtime', () => ({
   createRealtimeClient,
 }));
 
@@ -31,6 +31,10 @@ describe('notification API refresh subscriptions', () => {
       configurable: true,
       value: 'visible',
     });
+    Object.defineProperty(navigator, 'onLine', {
+      configurable: true,
+      value: true,
+    });
   });
   afterEach(() => {
     __resetNotificationSubscriptionRegistryForTests();
@@ -51,6 +55,32 @@ describe('notification API refresh subscriptions', () => {
     client.clear();
   });
 
+  it('makes 30 shared refreshes per visible hour, pauses offline, and refreshes on reconnect', () => {
+    const client = new QueryClient();
+    const invalidate = vi.spyOn(client, 'invalidateQueries');
+    const hook = renderHook(() => useNotificationSubscription(null, 'user-1'), {
+      wrapper: wrapper(client),
+    });
+    act(() => vi.advanceTimersByTime(60 * 60_000));
+    expect(invalidate).toHaveBeenCalledTimes(30);
+    Object.defineProperty(navigator, 'onLine', {
+      configurable: true,
+      value: false,
+    });
+    act(() => vi.advanceTimersByTime(60 * 60_000));
+    expect(invalidate).toHaveBeenCalledTimes(30);
+    Object.defineProperty(navigator, 'onLine', {
+      configurable: true,
+      value: true,
+    });
+    act(() => window.dispatchEvent(new Event('online')));
+    expect(invalidate).toHaveBeenCalledTimes(31);
+    hook.unmount();
+    act(() => window.dispatchEvent(new Event('online')));
+    expect(invalidate).toHaveBeenCalledTimes(31);
+    client.clear();
+  });
+
   it('shares one refresh per user and query client without opening a denied realtime channel', () => {
     const client = new QueryClient();
     const invalidate = vi.spyOn(client, 'invalidateQueries');

package/src/hooks/__tests__/use-workspace-presence.test.tsx

@@ -3,7 +3,7 @@
  */
 
 import { act, renderHook, waitFor } from '@testing-library/react';
-import type { RealtimePresenceState } from '@tuturuuu/supabase/next/realtime';
+import type { RealtimePresenceState } from '@tuturuuu/internal-api/realtime';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import {
   type UseWorkspacePresenceResult,
@@ -16,8 +16,8 @@ const { createClientMock, getCurrentUserProfileMock } = vi.hoisted(() => ({
   getCurrentUserProfileMock: vi.fn(),
 }));
 
-vi.mock('@tuturuuu/supabase/next/client', () => ({
-  createClient: createClientMock,
+vi.mock('@tuturuuu/internal-api/realtime', () => ({
+  createRealtimeClient: createClientMock,
 }));
 
 vi.mock('@tuturuuu/internal-api/users', () => ({

package/src/hooks/__tests__/use-yjs-collaboration.test.tsx

@@ -0,0 +1,147 @@
+import { act, renderHook } from '@testing-library/react';
+import { type ReactNode, StrictMode } from 'react';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { useYjsCollaboration } from '../use-yjs-collaboration';
+
+const instances = vi.hoisted(
+  () =>
+    [] as {
+      id: number;
+      destroyed: boolean;
+      emit: (event: string, value: unknown) => void;
+    }[]
+);
+vi.mock('@tuturuuu/supabase/next/client', () => ({ createClient: () => ({}) }));
+vi.mock('@tuturuuu/ui/hooks/supabase-provider', () => ({
+  default: class {
+    id: number;
+    destroyed = false;
+    hydrated = false;
+    awareness: { destroy: () => void };
+    private listeners = new Map<string, (value: unknown) => void>();
+    constructor(
+      private doc: { clientID: number; destroy: () => void },
+      _client: unknown,
+      config: { awareness: { destroy: () => void } }
+    ) {
+      this.id = doc.clientID;
+      this.awareness = config.awareness;
+      instances.push(this);
+    }
+    on(event: string, callback: (value: unknown) => void) {
+      this.listeners.set(event, callback);
+    }
+    emit(event: string, value: unknown) {
+      if (event === 'hydrated') this.hydrated = true;
+      this.listeners.get(event)?.(value);
+    }
+    destroy() {
+      this.destroyed = true;
+      this.awareness.destroy();
+      this.doc.destroy();
+    }
+  },
+}));
+const user = { id: 'actor', name: 'Ada', color: '#123456' };
+const config = {
+  channel: 'task-editor-one',
+  tableName: 'tasks',
+  columnName: 'description_yjs_state',
+  id: 'one',
+  user,
+};
+const wrapper = ({ children }: { children: ReactNode }) => (
+  <StrictMode>{children}</StrictMode>
+);
+describe('collaboration hook lifecycle', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    instances.length = 0;
+  });
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+  it('does not start awareness before authentication and reuses StrictMode providers', async () => {
+    const { result, rerender, unmount } = renderHook(
+      (actor) => useYjsCollaboration({ ...config, user: actor }),
+      { wrapper, initialProps: null as typeof user | null }
+    );
+    expect(result.current.doc).toBeNull();
+    expect(result.current.awareness).toBeNull();
+    expect(instances).toHaveLength(0);
+    rerender(user);
+    expect(instances).toHaveLength(1);
+    const provider = result.current.provider;
+    expect(provider).not.toBeNull();
+    rerender({ ...user, name: 'Ada updated' });
+    expect(result.current.provider).toBe(provider);
+    expect(result.current.awareness?.getLocalState()?.user.name).toBe(
+      'Ada updated'
+    );
+    unmount();
+    await act(() => vi.advanceTimersByTimeAsync(100));
+    expect(instances[0]?.destroyed).toBe(true);
+    expect(vi.getTimerCount()).toBe(0);
+  });
+  it('isolates account/resource switches and ignores late callbacks from old providers', async () => {
+    const { result, rerender, unmount } = renderHook(
+      (id) =>
+        useYjsCollaboration({ ...config, id, channel: `task-editor-${id}` }),
+      { wrapper, initialProps: 'one' }
+    );
+    const first = instances[0]!;
+    const firstDoc = result.current.doc;
+    rerender('two');
+    expect(instances).toHaveLength(2);
+    expect(first.destroyed).toBe(true);
+    expect(result.current.doc).not.toBe(firstDoc);
+    const second = instances[1]!;
+    act(() => second.emit('status', [{ status: 'connected' }]));
+    expect(result.current.connected).toBe(true);
+    act(() => first.emit('disconnect', []));
+    expect(result.current.connected).toBe(true);
+    act(() => first.emit('synced', [true]));
+    expect(result.current.synced).toBe(false);
+    unmount();
+    await act(() => vi.advanceTimersByTimeAsync(100));
+    expect(second.destroyed).toBe(true);
+    expect(vi.getTimerCount()).toBe(0);
+  });
+  it('publishes durable hydration independently and fences an old document', async () => {
+    const { result, rerender, unmount } = renderHook(
+      (id) =>
+        useYjsCollaboration({ ...config, id, channel: `task-editor-${id}` }),
+      { wrapper, initialProps: 'one' }
+    );
+    const first = instances[0]!;
+    act(() => first.emit('hydrated', undefined));
+    expect(result.current.hydrated).toBe(true);
+    expect(result.current.connected).toBe(false);
+    rerender('two');
+    expect(result.current.hydrated).toBe(false);
+    act(() => first.emit('hydrated', undefined));
+    expect(result.current.hydrated).toBe(false);
+    unmount();
+    await act(() => vi.advanceTimersByTimeAsync(100));
+  });
+  it('reports a durable read failure until a successful hydration', async () => {
+    const { result, unmount } = renderHook(() => useYjsCollaboration(config), {
+      wrapper,
+    });
+    const provider = instances[0]!;
+    act(() =>
+      provider.emit('error', {
+        message: 'Unable to load',
+        status: 'DOCUMENT_ERROR',
+        channel: config.channel,
+      })
+    );
+    expect(result.current.hydrationFailed).toBe(true);
+    expect(result.current.hydrated).toBe(false);
+    act(() => provider.emit('hydrated', undefined));
+    expect(result.current.hydrationFailed).toBe(false);
+    expect(result.current.hydrated).toBe(true);
+    unmount();
+    await act(() => vi.advanceTimersByTimeAsync(100));
+  });
+});

package/src/hooks/calendar-connection-types.ts

@@ -0,0 +1,49 @@
+import type { CalendarEvent } from '@tuturuuu/types/primitives/calendar-event';
+// Type for calendar connection
+export type CalendarConnection = {
+  id: string;
+  ws_id: string;
+  calendar_id: string;
+  calendar_name: string;
+  is_enabled: boolean;
+  color: string | null;
+  provider?: 'google' | 'microsoft' | string;
+  auth_token_id?: string | null;
+  workspace_calendar_id?: string | null;
+  access_role?: string | null;
+  created_at: string;
+  updated_at: string;
+};
+
+export type CalendarSyncStatus = {
+  state: 'idle' | 'syncing' | 'success' | 'error';
+  message?: string;
+  lastSyncTime?: Date;
+  direction?: 'google-to-tuturuuu' | 'tuturuuu-to-google' | 'both';
+};
+export type CalendarOptimisticStatus =
+  | 'creating'
+  | 'updating'
+  | 'deleting'
+  | 'error';
+
+export type OptimisticCalendarSyncEvent = Partial<
+  Omit<CalendarEvent, 'color' | 'description' | 'location'>
+> &
+  Pick<CalendarEvent, 'id'> & {
+    color?: CalendarEvent['color'] | string | null;
+    description?: string | null;
+    location?: string | null;
+    _optimisticStatus?: CalendarOptimisticStatus;
+  };
+
+export type OptimisticCalendarPatchOptions = {
+  removeIds?: string[];
+  clearIds?: string[];
+  status?: CalendarOptimisticStatus;
+};
+
+export type OptimisticCalendarState = {
+  events: Record<string, OptimisticCalendarSyncEvent>;
+  removedIds: string[];
+};

package/src/hooks/calendar-creation-request.test.ts

@@ -0,0 +1,62 @@
+import { validate, version } from 'uuid';
+import { expect, it } from 'vitest';
+import {
+  createCalendarCreationRequests,
+  createOptimisticEventId,
+  newCalendarCreationRequestId,
+} from './calendar-creation-request';
+
+it('keeps explicit draft IDs on lost responses and separates manual and AI drafts', () => {
+  const ids = createCalendarCreationRequests();
+  const manual = newCalendarCreationRequestId();
+  const ai = [newCalendarCreationRequestId(), newCalendarCreationRequestId()];
+  expect(new Set([manual, ...ai]).size).toBe(3);
+  for (const [index, id] of [manual, ...ai].entries()) {
+    expect(validate(id)).toBe(true);
+    expect(version(id)).toBe(7);
+    const payload = {
+      title: `draft ${index}`,
+      source: { provider: 'google', connectionId: 'owned' },
+    };
+    expect(ids.forAttempt(payload, id)).toBe(id);
+    expect(ids.forAttempt({ ...payload }, id)).toBe(id);
+  }
+});
+it('rejects changed intent for an uncertain draft before dispatch', () => {
+  const ids = createCalendarCreationRequests();
+  const id = newCalendarCreationRequestId();
+  ids.forAttempt({ title: 'Original' }, id);
+  expect(() => ids.forAttempt({ title: 'Edited' }, id)).toThrow(
+    'draft changed'
+  );
+  expect(
+    ids.forAttempt({ title: 'Edited' }, newCalendarCreationRequestId())
+  ).not.toBe(id);
+});
+it('allocates a new independent intent per call unless the caller supplies a retry ID', () => {
+  const ids = createCalendarCreationRequests();
+  const event = { title: 'Same independent contents' };
+  expect(ids.forAttempt(event)).not.toBe(ids.forAttempt(event));
+});
+
+it('accepts the same serialized intent when object key order changes', () => {
+  const ids = createCalendarCreationRequests();
+  const id = newCalendarCreationRequestId();
+  ids.forAttempt(
+    { title: 'Same', source: { provider: 'google', connectionId: 'owned' } },
+    id
+  );
+  expect(
+    ids.forAttempt(
+      { source: { connectionId: 'owned', provider: 'google' }, title: 'Same' },
+      id
+    )
+  ).toBe(id);
+});
+
+it('keeps optimistic identifiers separate from multi-day segment delimiters', () => {
+  const id = createOptimisticEventId();
+  expect(id).toMatch(/^optimistic[a-zA-Z0-9]+$/);
+  expect(id).not.toContain('-');
+  expect(createOptimisticEventId()).not.toBe(id);
+});

package/src/hooks/calendar-creation-request.ts

@@ -0,0 +1,34 @@
+import { v7 } from 'uuid';
+
+export const newCalendarCreationRequestId = () => v7();
+/** Explicit draft IDs survive retries. Independent calls receive separate IDs;
+ * changed intent after an uncertain response must start an explicit new draft. */
+export function createCalendarCreationRequests() {
+  const intents = new Map<string, string>();
+  return {
+    forAttempt(event: object, requestId?: string) {
+      const id = requestId ?? v7();
+      const intent = JSON.stringify(event, (_key, value) =>
+        value && typeof value === 'object' && !Array.isArray(value)
+          ? Object.fromEntries(
+              Object.keys(value)
+                .sort()
+                .map((key) => [key, value[key]])
+            )
+          : value
+      );
+      const previous = intents.get(id);
+      if (previous !== undefined && previous !== intent)
+        throw new Error(
+          'This calendar draft changed after submission; recover it before starting a new draft'
+        );
+      if (requestId) intents.set(id, intent);
+      return id;
+    },
+  };
+}
+export const createOptimisticEventId = () => {
+  if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function')
+    return `optimistic${crypto.randomUUID().replaceAll('-', '')}`;
+  return `optimistic${Date.now()}${Math.random().toString(36).slice(2)}`;
+};

package/src/hooks/calendar-event-update-queue-types.ts

@@ -0,0 +1,12 @@
+import type { CalendarEvent } from '@tuturuuu/types/primitives/calendar-event';
+
+export interface PendingEventUpdate extends Partial<CalendarEvent> {
+  _updateId?: string;
+  _timestamp: number;
+  _eventId: string;
+  _previousEvent?: CalendarEvent;
+  _resolvers?: Array<{
+    resolve: (value: CalendarEvent) => void;
+    reject: (reason: unknown) => void;
+  }>;
+}

package/src/hooks/calendar-event-write-payload.ts

@@ -0,0 +1,57 @@
+import type { WorkspaceCalendarEventUpdatePayload } from '@tuturuuu/internal-api';
+import type { CalendarEvent } from '@tuturuuu/types/primitives/calendar-event';
+import { isProviderRecurrenceReadonly } from '@tuturuuu/utils/calendar-provider-readonly';
+
+export function calendarEventUpdatePayload(
+  input: Partial<CalendarEvent>
+): WorkspaceCalendarEventUpdatePayload {
+  const payload: WorkspaceCalendarEventUpdatePayload = {};
+  for (const field of [
+    'title',
+    'description',
+    'location',
+    'start_at',
+    'end_at',
+    'locked',
+    'source',
+    'providerColor',
+  ] as const) {
+    if (input[field] !== undefined)
+      Object.assign(payload, { [field]: input[field] });
+  }
+  if (!input.providerColor && input.color !== undefined)
+    payload.color = input.color;
+  return payload;
+}
+
+export function cleanCalendarEventUpdates(input: Partial<CalendarEvent>) {
+  const result: Partial<CalendarEvent> = {};
+  for (const field of [
+    'title',
+    'description',
+    'start_at',
+    'end_at',
+    'color',
+    'location',
+    'locked',
+    'source',
+  ] as const) {
+    if (input[field] !== undefined)
+      Object.assign(result, { [field]: input[field] });
+  }
+  return result;
+}
+export function calendarEventByIdentity(events: CalendarEvent[], id: string) {
+  return events.find((event) => event.id === id || event._originalId === id);
+}
+export function assertOrdinaryCalendarEvent(
+  events: CalendarEvent[],
+  id: string
+) {
+  if (isProviderRecurrenceReadonly(calendarEventByIdentity(events, id)))
+    throw new Error('Unsupported provider recurrence is read only');
+  if (calendarEventByIdentity(events, id)?.seriesId)
+    throw new Error(
+      'Recurring occurrences require an explicit series edit scope'
+    );
+}

package/src/hooks/collaboration-document-hydration.ts

@@ -0,0 +1,35 @@
+interface DocumentHydrationOptions {
+  load: () => Promise<number[] | null>;
+  apply: (state: Uint8Array) => void;
+  isActive: () => boolean;
+  onLoaded: () => void;
+  onError: () => void;
+}
+
+/** Coalesces durable reads and fences late completion after resource teardown. */
+export class DocumentHydration {
+  private pending: Promise<boolean> | undefined;
+
+  constructor(private readonly options: DocumentHydrationOptions) {}
+
+  load(): Promise<boolean> {
+    if (this.pending) return this.pending;
+    this.pending = this.read().finally(() => {
+      this.pending = undefined;
+    });
+    return this.pending;
+  }
+
+  private async read(): Promise<boolean> {
+    try {
+      const state = await this.options.load();
+      if (!this.options.isActive()) return false;
+      if (state?.length) this.options.apply(Uint8Array.from(state));
+      this.options.onLoaded();
+      return true;
+    } catch {
+      if (this.options.isActive()) this.options.onError();
+      return false;
+    }
+  }
+}