@tuturuuu/ui 0.37.0 → 0.37.2

package/src/hooks/__tests__/use-visible-workspaces.test.tsx

@@ -0,0 +1,76 @@
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { renderHook, waitFor } from '@testing-library/react';
+import type { ReactNode } from 'react';
+import { beforeEach, expect, it, vi } from 'vitest';
+import { useVisibleWorkspaces } from '../use-visible-workspaces';
+import { WorkspaceVisibilityProvider } from '../use-workspace-visibility';
+
+const mocks = vi.hoisted(() => ({ list: vi.fn(), hidden: vi.fn() }));
+vi.mock('@tuturuuu/internal-api/workspaces', () => ({
+  listWorkspaces: mocks.list,
+}));
+vi.mock('@tuturuuu/internal-api/users', () => ({
+  getCurrentUserHiddenWorkspaces: mocks.hidden,
+  updateCurrentUserHiddenWorkspace: vi.fn(),
+}));
+beforeEach(() => {
+  vi.clearAllMocks();
+  mocks.list.mockResolvedValue([{ id: 'visible' }, { id: 'hidden' }]);
+  mocks.hidden.mockResolvedValue({ hiddenWorkspaceIds: ['hidden'] });
+});
+function fixture() {
+  const client = new QueryClient({
+    defaultOptions: { queries: { retry: false, retryDelay: 0 } },
+  });
+  const wrapper = ({ children }: { children: ReactNode }) => (
+    <QueryClientProvider client={client}>
+      <WorkspaceVisibilityProvider actorId="A">
+        {children}
+      </WorkspaceVisibilityProvider>
+    </QueryClientProvider>
+  );
+  return { client, wrapper };
+}
+it('retains an explicit zero bound and only exposes known visible choices', async () => {
+  const { client, wrapper } = fixture();
+  const { result } = renderHook(() => useVisibleWorkspaces(true, 0), {
+    wrapper,
+  });
+  await waitFor(() => expect(result.current.data).toEqual([{ id: 'visible' }]));
+  expect(mocks.list).toHaveBeenCalledWith({ limit: 0 });
+  expect(client.getQueryData(['workspace-ui-list', 'A', 0])).toHaveLength(2);
+});
+it('settled private discovery failure is an error rather than permanent loading', async () => {
+  mocks.hidden.mockRejectedValue(new Error('offline'));
+  const { client, wrapper } = fixture();
+  const { result } = renderHook(() => useVisibleWorkspaces(), { wrapper });
+  await waitFor(() =>
+    expect(client.getQueryState(['workspace-hidden', 'A'])?.status).toBe(
+      'error'
+    )
+  );
+  await waitFor(() => expect(result.current.isLoading).toBe(false));
+  expect(result.current.isError).toBe(true);
+  expect(result.current.error?.message).toBe('offline');
+  expect(result.current.data).toBeUndefined();
+});
+
+it('distinguishes an absent personal workspace from one excluded by Hidden preferences', async () => {
+  mocks.list.mockResolvedValue([{ id: 'team', personal: false }]);
+  const { client, wrapper } = fixture();
+  const { result } = renderHook(() => useVisibleWorkspaces(), { wrapper });
+  await waitFor(() =>
+    expect(result.current.personalWorkspaceMissing).toBe(true)
+  );
+  mocks.list.mockResolvedValue([
+    { id: 'team', personal: false },
+    { id: 'personal', personal: true },
+  ]);
+  mocks.hidden.mockResolvedValue({ hiddenWorkspaceIds: ['personal'] });
+  await result.current.refetch();
+  await waitFor(() =>
+    expect(result.current.data).toEqual([{ id: 'team', personal: false }])
+  );
+  expect(result.current.personalWorkspaceMissing).toBe(false);
+  expect(client.getQueryData(['workspace-ui-list', 'A'])).toHaveLength(2);
+});

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

@@ -0,0 +1,155 @@
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { act, renderHook, waitFor } from '@testing-library/react';
+import type { ReactNode } from 'react';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import {
+  useWorkspaceVisibility,
+  WorkspaceVisibilityProvider,
+} from '../use-workspace-visibility';
+
+const mocks = vi.hoisted(() => ({ get: vi.fn(), put: vi.fn() }));
+vi.mock('@tuturuuu/internal-api/users', () => ({
+  getCurrentUserHiddenWorkspaces: mocks.get,
+  updateCurrentUserHiddenWorkspace: mocks.put,
+}));
+function deferred<T>() {
+  let resolve!: (v: T) => void;
+  let reject!: (e: Error) => void;
+  const promise = new Promise<T>((a, b) => {
+    resolve = a;
+    reject = b;
+  });
+  return { promise, resolve, reject };
+}
+function setup(
+  actor = 'A',
+  client = new QueryClient({
+    defaultOptions: { queries: { retry: false }, mutations: { retry: false } },
+  })
+) {
+  const wrapper = ({ children }: { children: ReactNode }) => (
+    <QueryClientProvider client={client}>
+      <WorkspaceVisibilityProvider actorId={actor}>
+        {children}
+      </WorkspaceVisibilityProvider>
+    </QueryClientProvider>
+  );
+  return { ...renderHook(() => useWorkspaceVisibility(), { wrapper }), client };
+}
+beforeEach(() => {
+  vi.clearAllMocks();
+  mocks.get.mockResolvedValue({ hiddenWorkspaceIds: [] });
+  mocks.put.mockResolvedValue({});
+});
+describe('private owner-scoped workspace visibility', () => {
+  it('optimistically hides and rolls back only the failed workspace', async () => {
+    const write = deferred<object>();
+    mocks.put.mockReturnValue(write.promise);
+    const hook = setup();
+    await waitFor(() => expect(hook.result.current.known).toBe(true));
+    let operation!: Promise<void>;
+    act(() => {
+      operation = hook.result.current.setHidden('ws-1', true);
+    });
+    await waitFor(() =>
+      expect(hook.result.current.hiddenIds).toEqual(['ws-1'])
+    );
+    await act(async () => {
+      write.reject(new Error('offline'));
+      await expect(operation).rejects.toThrow('offline');
+    });
+    expect(hook.result.current.hiddenIds).toEqual([]);
+    expect(hook.result.current.updateError).not.toBeNull();
+    expect(mocks.put).toHaveBeenCalledWith('ws-1', true, 'A');
+    await act(async () => {
+      await hook.result.current.refetch();
+    });
+    expect(hook.result.current.updateError).toBeNull();
+  });
+  it('a stale refresh cannot replace optimistic state', async () => {
+    const hook = setup();
+    await waitFor(() => expect(hook.result.current.known).toBe(true));
+    const read = deferred<{ hiddenWorkspaceIds: string[] }>();
+    mocks.get
+      .mockImplementationOnce(() => read.promise)
+      .mockResolvedValue({ hiddenWorkspaceIds: ['ws-1'] });
+    act(() => {
+      void hook.result.current.refetch();
+    });
+    await act(async () => {
+      await hook.result.current.setHidden('ws-1', true);
+    });
+    await act(async () => {
+      read.resolve({ hiddenWorkspaceIds: [] });
+    });
+    expect(hook.result.current.hiddenIds).toEqual(['ws-1']);
+  });
+  it('suppresses duplicate writes for the same pending workspace', async () => {
+    const write = deferred<object>();
+    mocks.put.mockReturnValue(write.promise);
+    const hook = setup();
+    await waitFor(() => expect(hook.result.current.known).toBe(true));
+    let operation!: Promise<void>;
+    act(() => {
+      operation = hook.result.current.setHidden('ws-1', true);
+    });
+    await waitFor(() =>
+      expect(hook.result.current.pending.has('ws-1')).toBe(true)
+    );
+    await act(async () => {
+      await hook.result.current.setHidden('ws-1', true);
+    });
+    expect(mocks.put).toHaveBeenCalledTimes(1);
+    await act(async () => {
+      write.resolve({});
+      await operation;
+    });
+  });
+  it('removes private owner caches on logout and ignores late response', async () => {
+    const hook = setup();
+    await waitFor(() => expect(hook.result.current.known).toBe(true));
+    const write = deferred<object>();
+    mocks.put.mockReturnValue(write.promise);
+    let operation!: Promise<void>;
+    act(() => {
+      operation = hook.result.current.setHidden('ws-1', true);
+    });
+    await waitFor(() =>
+      expect(hook.result.current.hiddenIds).toEqual(['ws-1'])
+    );
+    hook.unmount();
+    write.resolve({});
+    await operation;
+    expect(hook.client.getQueryData(['workspace-hidden', 'A'])).toBeUndefined();
+    expect(hook.client.getQueryData(['workspace-hidden', 'B'])).toBeUndefined();
+  });
+  it('two actors use independent hidden cache keys', async () => {
+    mocks.get.mockImplementation(async (actor: string) => ({
+      hiddenWorkspaceIds: actor === 'A' ? ['ws-1'] : [],
+    }));
+    const client = new QueryClient({
+      defaultOptions: { queries: { retry: false } },
+    });
+    const a = setup('A', client);
+    const b = setup('B', client);
+    await waitFor(() => expect(a.result.current.hiddenIds).toEqual(['ws-1']));
+    await waitFor(() => expect(b.result.current.known).toBe(true));
+    expect(b.result.current.hiddenIds).toEqual([]);
+  });
+});
+
+it('settles a refetch safely after logout without returning private old-actor data', async () => {
+  const hook = setup();
+  await waitFor(() => expect(hook.result.current.known).toBe(true));
+  const read = deferred<{ hiddenWorkspaceIds: string[] }>();
+  mocks.get.mockReturnValue(read.promise);
+  let operation!: ReturnType<typeof hook.result.current.refetch>;
+  act(() => {
+    operation = hook.result.current.refetch();
+  });
+  await waitFor(() => expect(mocks.get).toHaveBeenCalledTimes(2));
+  hook.unmount();
+  read.resolve({ hiddenWorkspaceIds: ['old-private'] });
+  await expect(operation).resolves.toBeNull();
+  expect(hook.client.getQueryData(['workspace-hidden', 'A'])).toBeUndefined();
+});

package/src/hooks/__tests__/workspace-actor-lifetime.test.tsx

@@ -0,0 +1,103 @@
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { act, render, screen, waitFor } from '@testing-library/react';
+import { beforeEach, expect, it, vi } from 'vitest';
+import { useWorkspaceUser } from '../use-workspace-user';
+import {
+  useWorkspaceVisibility,
+  WorkspaceVisibilityProvider,
+} from '../use-workspace-visibility';
+
+const mocks = vi.hoisted(() => ({ hidden: vi.fn(), profile: vi.fn() }));
+vi.mock('@tuturuuu/internal-api/users', () => ({
+  getCurrentUserHiddenWorkspaces: mocks.hidden,
+  getCurrentUserProfile: mocks.profile,
+  updateCurrentUserHiddenWorkspace: vi.fn(),
+}));
+beforeEach(() => {
+  vi.clearAllMocks();
+  mocks.hidden.mockResolvedValue({ hiddenWorkspaceIds: ['private'] });
+  mocks.profile.mockResolvedValue({ id: 'A' });
+});
+function Probe() {
+  const hidden = useWorkspaceVisibility();
+  const user = useWorkspaceUser();
+  return (
+    <output>
+      {JSON.stringify({
+        known: hidden.known,
+        ids: hidden.hiddenIds,
+        user: user.data?.id,
+      })}
+    </output>
+  );
+}
+function fixture() {
+  return new QueryClient({
+    defaultOptions: { queries: { retry: false, retryDelay: 0 } },
+  });
+}
+it('retains the root owner cache across same-actor route unmount and remount', async () => {
+  const client = fixture();
+  function Tree({ route }: { route: boolean }) {
+    return (
+      <QueryClientProvider client={client}>
+        <WorkspaceVisibilityProvider actorId="A">
+          {route && (
+            <WorkspaceVisibilityProvider actorId="A">
+              <Probe />
+            </WorkspaceVisibilityProvider>
+          )}
+        </WorkspaceVisibilityProvider>
+      </QueryClientProvider>
+    );
+  }
+  const tree = render(<Tree route />);
+  await waitFor(() =>
+    expect(screen.getByRole('status').textContent).toContain('"known":true')
+  );
+  await waitFor(() =>
+    expect(client.getQueryData(['workspace-user', 'A'])).toMatchObject({
+      id: 'A',
+    })
+  );
+  tree.rerender(<Tree route={false} />);
+  expect(client.getQueryData(['workspace-hidden', 'A'])).toEqual(['private']);
+  tree.rerender(<Tree route />);
+  await waitFor(() =>
+    expect(screen.getByRole('status').textContent).toContain('private')
+  );
+  expect(mocks.hidden).toHaveBeenCalledTimes(1);
+  expect(mocks.profile).toHaveBeenCalledTimes(1);
+  expect(client.getQueryData(['workspace-user'])).toBeUndefined();
+  tree.unmount();
+  expect(client.getQueryData(['workspace-hidden', 'A'])).toBeUndefined();
+  expect(client.getQueryData(['workspace-user', 'A'])).toBeUndefined();
+});
+it('does not read profiles or private preferences without verified identity', async () => {
+  const client = fixture();
+  render(
+    <QueryClientProvider client={client}>
+      <Probe />
+    </QueryClientProvider>
+  );
+  await act(async () => {});
+  expect(mocks.profile).not.toHaveBeenCalled();
+  expect(mocks.hidden).not.toHaveBeenCalled();
+  expect(screen.getByRole('status').textContent).toContain('"known":false');
+});
+it('fails a mismatched route actor closed under a verified root', async () => {
+  const client = fixture();
+  render(
+    <QueryClientProvider client={client}>
+      <WorkspaceVisibilityProvider actorId="B">
+        <WorkspaceVisibilityProvider actorId="A">
+          <Probe />
+        </WorkspaceVisibilityProvider>
+      </WorkspaceVisibilityProvider>
+    </QueryClientProvider>
+  );
+  await act(async () => {});
+  expect(mocks.profile).not.toHaveBeenCalled();
+  expect(mocks.hidden).not.toHaveBeenCalled();
+  expect(screen.getByRole('status').textContent).toContain('"known":false');
+});

package/src/hooks/calendar-event-lookup.test.ts

@@ -12,6 +12,45 @@ const event = (id: string, start: string, end: string): CalendarEvent => ({
   end_at: end,
 });
 describe('indexed calendar lookup', () => {
+  it.each([
+    ['Asia/Tokyo', 'America/Los_Angeles', '2026-01-01T07:30:00Z', 2025, 11, 31],
+    ['America/Los_Angeles', 'Asia/Tokyo', '2025-12-31T15:30:00Z', 2026, 0, 1],
+  ] as const)(
+    'groups timed instants in %s browser with %s calendar days',
+    (browserZone, calendarZone, instant, year, month, day) => {
+      vi.stubEnv('TZ', browserZone);
+      try {
+        const end = new Date(
+          new Date(instant).getTime() + 15 * 60_000
+        ).toISOString();
+        const lookup = createCalendarEventLookup(
+          [event('timed', instant, end)],
+          calendarZone
+        );
+        expect(
+          lookup(new Date(year, month, day, 18)).map((item) => item.id)
+        ).toEqual(['timed']);
+        expect(lookup(new Date(year, month, day + 1))).toEqual([]);
+      } finally {
+        vi.unstubAllEnvs();
+      }
+    }
+  );
+  it('preserves the existing all-day carrier identity when the calendar zone changes', () => {
+    vi.stubEnv('TZ', 'UTC');
+    try {
+      const events = [
+        event('all-day', '2026-01-01T00:00:00Z', '2026-01-02T00:00:00Z'),
+      ];
+      for (const zone of ['America/Los_Angeles', 'Asia/Tokyo']) {
+        const lookup = createCalendarEventLookup(events, zone);
+        expect(lookup(new Date(2026, 0, 1))).toHaveLength(1);
+        expect(lookup(new Date(2026, 0, 2))).toHaveLength(0);
+      }
+    } finally {
+      vi.unstubAllEnvs();
+    }
+  });
   it('preserves event order and exclusive all-day ends across a year boundary', () => {
     const events = [
       event('timed', '2026-12-31T23:00:00', '2027-01-01T01:00:00'),

package/src/hooks/calendar-event-lookup.ts

@@ -1,23 +1,37 @@
 import type { CalendarEvent } from '@tuturuuu/types/primitives/calendar-event';
 import { isAllDayEvent } from '@tuturuuu/utils/calendar-utils';
+import { calendarInstantDay, calendarToday } from '../lib/calendar-day';
 
 const dayStamp = (date: Date) =>
   new Date(date.getFullYear(), date.getMonth(), date.getDate()).getTime();
 /** Parse once, binary-search starts, and prune intervals that already ended. */
-export function createCalendarEventLookup(events: CalendarEvent[]) {
+export function createCalendarEventLookup(
+  events: CalendarEvent[],
+  timezone?: string
+) {
   const intervals = events
-    .map((event, order) => ({
-      event,
-      order,
-      start: dayStamp(new Date(event.start_at)),
-      end: dayStamp(new Date(event.end_at)) - (isAllDayEvent(event) ? 1 : 0),
-    }))
+    .map((event, order) => {
+      const allDay = isAllDayEvent(event);
+      const eventDay = (value: string) => {
+        const instant = new Date(value);
+        if (!Number.isFinite(instant.getTime())) return NaN;
+        return dayStamp(
+          allDay ? instant : calendarInstantDay(instant, timezone)
+        );
+      };
+      return {
+        event,
+        order,
+        start: eventDay(event.start_at),
+        end: eventDay(event.end_at) - (allDay ? 1 : 0),
+      };
+    })
     .filter((item) => Number.isFinite(item.start) && Number.isFinite(item.end))
     .sort((a, b) => a.start - b.start);
   let max = -Infinity;
   const latestEnd = intervals.map((item) => (max = Math.max(max, item.end)));
   const cache = new Map<number, CalendarEvent[]>();
-  return (date = new Date()) => {
+  return (date = calendarToday(timezone)) => {
     const target = dayStamp(date);
     const cached = cache.get(target);
     if (cached) return cached;

package/src/hooks/calendar-sync-range.test.ts

@@ -0,0 +1,92 @@
+import { describe, expect, it, vi } from 'vitest';
+import { calendarQueryRange } from '../lib/calendar-day';
+import {
+  calendarEventInQueryRange,
+  calendarRangeCacheKey,
+  calendarRangeIncludesToday,
+} from './calendar-sync-range';
+
+describe('calendar query date carriers', () => {
+  it('uses the effective device zone for auto cache identity', () => {
+    const dates = [new Date(2026, 0, 1)];
+    vi.stubEnv('TZ', 'Asia/Tokyo');
+    try {
+      expect(calendarRangeCacheKey(dates, 'auto')).toBe(
+        calendarRangeCacheKey(dates, 'Asia/Tokyo')
+      );
+      vi.stubEnv('TZ', 'America/Los_Angeles');
+      expect(calendarRangeCacheKey(dates, 'auto')).toBe(
+        calendarRangeCacheKey(dates, 'America/Los_Angeles')
+      );
+      expect(calendarRangeCacheKey(dates, 'auto')).not.toBe(
+        calendarRangeCacheKey(dates, 'Asia/Tokyo')
+      );
+    } finally {
+      vi.unstubAllEnvs();
+    }
+  });
+  it.each([
+    [2026, 2, 8, '2026-03-08T05:00:00.000Z', '2026-03-09T04:00:00.000Z', 23],
+    [2026, 10, 1, '2026-11-01T04:00:00.000Z', '2026-11-02T05:00:00.000Z', 25],
+  ] as const)(
+    'resolves independent New York midnights for %i/%i/%i',
+    (year, month, day, start, end, hours) => {
+      vi.stubEnv('TZ', 'Asia/Tokyo');
+      try {
+        const range = calendarQueryRange(
+          [new Date(year, month, day, 18)],
+          'America/New_York'
+        );
+        expect(range.start.toISOString()).toBe(start);
+        expect(range.end.toISOString()).toBe(end);
+        expect(range.end.getTime() - range.start.getTime()).toBe(
+          hours * 60 * 60_000
+        );
+      } finally {
+        vi.unstubAllEnvs();
+      }
+    }
+  );
+
+  it('partitions equal selected days by calendar timezone and ignores carrier clock fields', () => {
+    const dates = [new Date(2026, 0, 1)];
+    expect(calendarRangeCacheKey(dates, 'Asia/Tokyo')).not.toBe(
+      calendarRangeCacheKey(dates, 'America/Los_Angeles')
+    );
+    expect(calendarRangeCacheKey(dates, 'Asia/Tokyo')).toBe(
+      calendarRangeCacheKey([new Date(2026, 0, 1, 19)], 'Asia/Tokyo')
+    );
+    expect(calendarRangeCacheKey([], 'Asia/Tokyo')).toBe('');
+  });
+
+  it('detects today in the calendar zone across a year boundary', () => {
+    const now = new Date('2025-12-31T16:00:00Z');
+    const dates = [new Date(2026, 0, 1)];
+    expect(calendarRangeIncludesToday(dates, 'Asia/Tokyo', now)).toBe(true);
+    expect(calendarRangeIncludesToday(dates, 'America/Los_Angeles', now)).toBe(
+      false
+    );
+  });
+
+  it('filters optimistic events against the same zoned half-open query range', () => {
+    const dates = [new Date(2026, 0, 1)];
+    const zone = 'Asia/Tokyo';
+    expect(
+      calendarEventInQueryRange(
+        { start_at: '2025-12-31T15:00:00Z', end_at: '2025-12-31T16:00:00Z' },
+        dates,
+        zone
+      )
+    ).toBe(true);
+    expect(
+      calendarEventInQueryRange(
+        { start_at: '2026-01-01T15:00:00Z', end_at: '2026-01-01T16:00:00Z' },
+        dates,
+        zone
+      )
+    ).toBe(false);
+    expect(
+      calendarEventInQueryRange({ start_at: 'invalid' }, dates, zone)
+    ).toBe(true);
+  });
+});

package/src/hooks/calendar-sync-range.ts

@@ -0,0 +1,40 @@
+import { resolveTaskTimezone } from '@tuturuuu/utils/task-date-timezone';
+import {
+  calendarDayKey,
+  calendarQueryRange,
+  calendarToday,
+} from '../lib/calendar-day';
+
+/** Range identity uses date-only carriers and the zone that resolves boundaries. */
+export function calendarRangeCacheKey(dates: Date[], timezone?: string) {
+  const first = dates[0];
+  const last = dates[dates.length - 1];
+  return first && last
+    ? `${resolveTaskTimezone(timezone ?? 'auto')}:${calendarDayKey(first)}-${calendarDayKey(last)}`
+    : '';
+}
+
+export function calendarRangeIncludesToday(
+  dates: Date[],
+  timezone?: string,
+  now?: Date
+) {
+  const first = dates[0];
+  const last = dates[dates.length - 1];
+  if (!first || !last) return false;
+  const today = calendarDayKey(calendarToday(timezone, now));
+  return calendarDayKey(first) <= today && calendarDayKey(last) >= today;
+}
+
+export function calendarEventInQueryRange(
+  event: { start_at?: string; end_at?: string },
+  dates: Date[],
+  timezone?: string
+) {
+  if (!dates.length || (!event.start_at && !event.end_at)) return true;
+  const { start, end } = calendarQueryRange(dates, timezone);
+  const startAt = event.start_at ? new Date(event.start_at).getTime() : NaN;
+  const endAt = event.end_at ? new Date(event.end_at).getTime() : startAt;
+  if (Number.isNaN(startAt) || Number.isNaN(endAt)) return true;
+  return startAt < end.getTime() && endAt >= start.getTime();
+}

package/src/hooks/use-calendar-clock.ts

@@ -0,0 +1,49 @@
+'use client';
+
+import { useSyncExternalStore } from 'react';
+
+const MINUTE_MS = 60_000;
+const listeners = new Set<() => void>();
+let timer: ReturnType<typeof setTimeout> | undefined;
+
+function getSnapshot() {
+  return Math.floor(Date.now() / MINUTE_MS);
+}
+
+function getServerSnapshot() {
+  // Server and hydration must share a deterministic snapshot; React then reads now.
+  return 0;
+}
+
+function scheduleTick() {
+  timer = setTimeout(
+    () => {
+      timer = undefined;
+      for (const listener of listeners) listener();
+      if (listeners.size) scheduleTick();
+    },
+    MINUTE_MS - (Date.now() % MINUTE_MS)
+  );
+}
+
+function subscribe(listener: () => void) {
+  listeners.add(listener);
+  if (timer === undefined) scheduleTick();
+  return () => {
+    listeners.delete(listener);
+    if (!listeners.size && timer !== undefined) {
+      clearTimeout(timer);
+      timer = undefined;
+    }
+  };
+}
+
+/** One minute clock shared by every calendar view; selected days stay immutable. */
+export function useCalendarClock(): Date {
+  const minute = useSyncExternalStore(
+    subscribe,
+    getSnapshot,
+    getServerSnapshot
+  );
+  return new Date(minute * MINUTE_MS);
+}

package/src/hooks/use-calendar-day-zone.tsx

@@ -0,0 +1,12 @@
+'use client';
+import { createContext, useContext } from 'react';
+export type CalendarDayZone = {
+  timezone?: string;
+  setTimezone: (zone: string) => void;
+  goToToday?: () => void;
+};
+const CalendarDayZoneContext = createContext<CalendarDayZone | null>(null);
+export const CalendarDayZoneBridgeProvider = CalendarDayZoneContext.Provider;
+export function useCalendarDayZone() {
+  return useContext(CalendarDayZoneContext);
+}