@tuturuuu/utils 0.24.0 → 0.24.2

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [0.24.2](https://github.com/tutur3u/platform/compare/utils-v0.24.1...utils-v0.24.2) (2026-08-11)
+
+
+### Bug Fixes
+
+* **i18n:** preserve prerender locale fallback ([3a09b07](https://github.com/tutur3u/platform/commit/3a09b070abda729649f269310a70db78f9b3a1cc))
+
+## [0.24.1](https://github.com/tutur3u/platform/compare/utils-v0.24.0...utils-v0.24.1) (2026-08-11)
+
+
+### Bug Fixes
+
+* **i18n:** keep request locale build-safe ([cc575a2](https://github.com/tutur3u/platform/commit/cc575a2e951ef8fb46a4b8593d0dcfcbe03cd4e7))
+
 ## [0.24.0](https://github.com/tutur3u/platform/compare/utils-v0.23.1...utils-v0.24.0) (2026-08-09)
 
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tuturuuu/utils",
   "license": "MIT",
-  "version": "0.24.0",
+  "version": "0.24.2",
   "repository": {
     "type": "git",
     "url": "https://github.com/tutur3u/platform",
@@ -24,7 +24,7 @@
     "@tiptap/react": "3.29.2",
     "@tuturuuu/google": "0.1.0",
     "@tuturuuu/icons": "0.1.0",
-    "@tuturuuu/internal-api": "0.29.0",
+    "@tuturuuu/internal-api": "0.29.1",
     "@tuturuuu/supabase": "0.5.0",
     "@upstash/ratelimit": "^2.0.8",
     "@upstash/redis": "^1.38.2",

package/src/calendar-settings-resolver.test.ts

@@ -0,0 +1,168 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import {
+  detectLocaleFirstDay,
+  detectLocaleTimeFormat,
+  detectSystemTimezone,
+  firstDayToNumber,
+  numberToFirstDay,
+  resolveCalendarSettings,
+  resolveFirstDayOfWeek,
+  resolveTimeFormat,
+  resolveTimezone,
+} from './calendar-settings-resolver';
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe('calendar settings resolver', () => {
+  it.each([
+    ['vi-VN', 'monday'],
+    ['en-US', 'sunday'],
+    ['en-CA', 'sunday'],
+    ['ar-SA', 'saturday'],
+    ['he-IL', 'saturday'],
+    ['fr-FR', 'monday'],
+    ['unsupported-tag', 'monday'],
+  ] as const)('derives the first day for %s', (locale, expected) => {
+    expect(detectLocaleFirstDay(locale)).toBe(expected);
+  });
+
+  it.each([
+    {
+      label: 'user value',
+      user: { first_day_of_week: 'saturday' },
+      workspace: { first_day_of_week: 'sunday' },
+      locale: 'vi-VN',
+      expected: 'saturday',
+    },
+    {
+      label: 'workspace fallback',
+      user: { first_day_of_week: 'auto' },
+      workspace: { first_day_of_week: 'sunday' },
+      locale: 'vi-VN',
+      expected: 'sunday',
+    },
+    {
+      label: 'locale fallback for empty values',
+      user: { first_day_of_week: '' },
+      workspace: { first_day_of_week: null },
+      locale: 'ar-SA',
+      expected: 'saturday',
+    },
+    {
+      label: 'locale fallback for null settings',
+      user: null,
+      workspace: null,
+      locale: 'en-US',
+      expected: 'sunday',
+    },
+  ])(
+    'resolves first-day precedence from $label',
+    ({ user, workspace, locale, expected }) => {
+      expect(resolveFirstDayOfWeek(user, workspace, locale)).toBe(expected);
+    }
+  );
+
+  it('resolves timezone precedence and fixed system fallback', () => {
+    const originalDateTimeFormat = Intl.DateTimeFormat;
+    vi.spyOn(Intl, 'DateTimeFormat').mockImplementation(((
+      ...args: ConstructorParameters<typeof Intl.DateTimeFormat>
+    ) => {
+      if (args.length > 0) return new originalDateTimeFormat(...args);
+      return {
+        resolvedOptions: () => ({ timeZone: 'Pacific/Auckland' }),
+      } as Intl.DateTimeFormat;
+    }) as typeof Intl.DateTimeFormat);
+
+    expect(
+      resolveTimezone(
+        { timezone: 'Asia/Ho_Chi_Minh' },
+        { timezone: 'Europe/London' }
+      )
+    ).toBe('Asia/Ho_Chi_Minh');
+    expect(
+      resolveTimezone({ timezone: 'auto' }, { timezone: 'Europe/London' })
+    ).toBe('Europe/London');
+    expect(resolveTimezone({ timezone: '' }, { timezone: null })).toBe(
+      'Pacific/Auckland'
+    );
+    expect(detectSystemTimezone()).toBe('Pacific/Auckland');
+  });
+
+  it('falls back to UTC when system timezone detection throws', () => {
+    vi.spyOn(Intl, 'DateTimeFormat').mockImplementation(() => {
+      throw new Error('Intl unavailable');
+    });
+
+    expect(detectSystemTimezone()).toBe('UTC');
+  });
+
+  it.each([
+    ['en-US', '1', '12h'],
+    ['vi-VN', '13', '24h'],
+  ] as const)(
+    'detects the %s time format from fixed Intl parts',
+    (locale, hour, expected) => {
+      vi.spyOn(Intl, 'DateTimeFormat').mockImplementation(
+        (() =>
+          ({
+            formatToParts: () => [{ type: 'hour', value: hour }],
+          }) as Intl.DateTimeFormat) as typeof Intl.DateTimeFormat
+      );
+
+      expect(detectLocaleTimeFormat(locale)).toBe(expected);
+    }
+  );
+
+  it('uses locale-specific time-format fallbacks when Intl rejects a tag', () => {
+    vi.spyOn(Intl, 'DateTimeFormat').mockImplementation(() => {
+      throw new RangeError('Unsupported locale');
+    });
+
+    expect(detectLocaleTimeFormat('en-invalid')).toBe('12h');
+    expect(detectLocaleTimeFormat('xx-invalid')).toBe('24h');
+  });
+
+  it('prefers an explicit user time format over locale detection', () => {
+    expect(resolveTimeFormat({ time_format: '24h' }, 'en-US')).toBe('24h');
+    expect(resolveTimeFormat({ time_format: 'auto' }, 'en-US')).toBe(
+      detectLocaleTimeFormat('en-US')
+    );
+  });
+
+  it('resolves the complete settings object without changing precedence', () => {
+    expect(
+      resolveCalendarSettings(
+        {
+          timezone: 'Asia/Ho_Chi_Minh',
+          first_day_of_week: 'auto',
+          time_format: '24h',
+        },
+        {
+          timezone: 'Europe/London',
+          first_day_of_week: 'sunday',
+        },
+        'vi-VN'
+      )
+    ).toEqual({
+      timezone: 'Asia/Ho_Chi_Minh',
+      firstDayOfWeek: 'sunday',
+      timeFormat: '24h',
+    });
+  });
+
+  it.each([
+    ['sunday', 0],
+    ['monday', 1],
+    ['saturday', 6],
+  ] as const)('converts %s to %i and back', (day, number) => {
+    expect(firstDayToNumber(day)).toBe(number);
+    expect(numberToFirstDay(number)).toBe(day);
+  });
+
+  it('resolves auto and unsupported conversion values deterministically', () => {
+    expect(firstDayToNumber('auto', 'en-US')).toBe(0);
+    expect(numberToFirstDay(3)).toBe('monday');
+  });
+});

package/src/i18n-root-locale.test.ts

@@ -0,0 +1,57 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const mocks = vi.hoisted(() => ({
+  notFound: vi.fn(() => {
+    throw new Error('not found');
+  }),
+}));
+
+vi.mock('next/navigation', () => ({ notFound: mocks.notFound }));
+
+import { resolveRequestLocale, resolveRootLocale } from './i18n-root-locale';
+
+describe('resolveRequestLocale', () => {
+  it('accepts a supported request locale', () => {
+    expect(resolveRequestLocale(['en', 'vi'], 'vi', 'en')).toBe('vi');
+  });
+
+  it('uses the configured default for missing prerender locale context', () => {
+    expect(resolveRequestLocale(['en', 'vi'], undefined, 'en')).toBe('en');
+  });
+
+  it('uses the configured default for invalid route candidates', () => {
+    expect(resolveRequestLocale(['en', 'vi'], 'unknown', 'en')).toBe('en');
+  });
+});
+
+describe('resolveRootLocale', () => {
+  beforeEach(() => {
+    mocks.notFound.mockClear();
+  });
+
+  it('accepts an explicit locale candidate', async () => {
+    await expect(resolveRootLocale(['en', 'vi'], 'en')).resolves.toBe('en');
+  });
+
+  it('accepts an awaited request locale candidate', async () => {
+    const requestLocale = Promise.resolve('vi');
+
+    await expect(
+      resolveRootLocale(['en', 'vi'], await requestLocale)
+    ).resolves.toBe('vi');
+  });
+
+  it('rejects a missing locale candidate', async () => {
+    await expect(resolveRootLocale(['en', 'vi'], undefined)).rejects.toThrow(
+      'not found'
+    );
+    expect(mocks.notFound).toHaveBeenCalledOnce();
+  });
+
+  it('rejects unknown locale candidates', async () => {
+    await expect(resolveRootLocale(['en', 'vi'], 'unknown')).rejects.toThrow(
+      'not found'
+    );
+    expect(mocks.notFound).toHaveBeenCalledOnce();
+  });
+});

package/src/i18n-root-locale.ts

@@ -0,0 +1,22 @@
+import { notFound } from 'next/navigation';
+
+export function resolveRequestLocale<const Locale extends string>(
+  locales: readonly Locale[],
+  locale: string | undefined,
+  defaultLocale: Locale
+): Locale {
+  return locales.includes(locale as Locale)
+    ? (locale as Locale)
+    : defaultLocale;
+}
+
+export async function resolveRootLocale<const Locale extends string>(
+  locales: readonly Locale[],
+  locale?: string
+): Promise<Locale> {
+  if (!locales.includes(locale as Locale)) {
+    notFound();
+  }
+
+  return locale as Locale;
+}

package/src/platform-release.test.ts

@@ -7,7 +7,7 @@ import {
 
 describe('platform release metadata', () => {
   it('uses the centralized shared browser app version', () => {
-    expect(TUTURUUU_PLATFORM_VERSION).toBe('0.36.0'); // x-release-please-version
+    expect(TUTURUUU_PLATFORM_VERSION).toBe('0.36.2'); // x-release-please-version
   });
 
   it('preserves the source timestamp in builtAt and derives a short hash', () => {

package/src/platform-release.ts

@@ -1,6 +1,6 @@
 import { PLATFORM_BUILD_METADATA } from './generated/platform-build-metadata';
 
-export const TUTURUUU_PLATFORM_VERSION = '0.36.0'; // x-release-please-version
+export const TUTURUUU_PLATFORM_VERSION = '0.36.2'; // x-release-please-version
 
 export type PlatformBuildMetadataInput = {
   /** ISO timestamp of the source commit used for the build, not deployment time. */

package/src/timeblock-helper.test.ts

@@ -0,0 +1,381 @@
+import { readFileSync } from 'node:fs';
+import type { Timeblock } from '@tuturuuu/types/primitives/Timeblock';
+import { afterAll, beforeAll, describe, expect, test, vi } from 'vitest';
+import {
+  addTimeblocks,
+  datesToDateMatrix,
+  datesToTimeMatrix,
+  durationToTimeblocks,
+  getDateStrings,
+  removeTimeblocks,
+} from './timeblock-helper';
+
+const originalTimezone = process.env.TZ;
+
+beforeAll(() => {
+  process.env.TZ = 'UTC';
+  vi.useFakeTimers();
+  vi.setSystemTime(new Date('2024-01-15T12:00:00Z'));
+});
+
+afterAll(() => {
+  vi.useRealTimers();
+  process.env.TZ = originalTimezone;
+});
+
+function date(value: string) {
+  return new Date(value);
+}
+
+function block(
+  blockDate: string,
+  startTime: string,
+  endTime: string,
+  tentative = false
+): Timeblock {
+  return {
+    date: blockDate,
+    end_time: endTime,
+    start_time: startTime,
+    tentative,
+  };
+}
+
+function normalize(timeblocks: Timeblock[]) {
+  return timeblocks.map(
+    ({ date: blockDate, end_time, start_time, tentative }) =>
+      block(blockDate, start_time, end_time, tentative)
+  );
+}
+
+describe('timeblock temporal contract', () => {
+  test('uses a fixed UTC clock for deterministic date and time matrices', () => {
+    expect(process.env.TZ).toBe('UTC');
+    expect(new Date().toISOString()).toBe('2024-01-15T12:00:00.000Z');
+  });
+
+  test('formats dates in the fixed runtime timezone', () => {
+    expect(
+      getDateStrings([
+        date('2024-03-15T23:30:00Z'),
+        date('2024-03-16T00:30:00Z'),
+      ])
+    ).toEqual(['2024-03-15', '2024-03-16']);
+  });
+
+  test('rejects empty date and time matrices', () => {
+    expect(() => datesToDateMatrix([])).toThrow('Invalid input');
+    expect(() => datesToTimeMatrix([])).toThrow('Invalid input');
+  });
+
+  test('normalizes reverse date endpoints and includes the final grid cell', () => {
+    const matrix = datesToDateMatrix([
+      date('2024-03-17T19:00:00Z'),
+      date('2024-03-15T08:00:00Z'),
+    ]);
+    expect(matrix.soonest.toISOString()).toBe('2024-03-15T08:00:00.000Z');
+    expect(matrix.latest.toISOString()).toBe('2024-03-17T19:15:00.000Z');
+  });
+
+  test('normalizes reverse time endpoints independently of their dates', () => {
+    const matrix = datesToTimeMatrix([
+      date('2024-03-15T19:00:00Z'),
+      date('2024-03-17T08:00:00Z'),
+    ]);
+    expect(matrix.soonest.format('HH:mm:ssZ')).toBe('08:00:00+00:00');
+    expect(matrix.latest.format('HH:mm:ssZ')).toBe('19:00:00+00:00');
+  });
+});
+
+const durationCases: Array<{
+  dates: Date[];
+  expected: Timeblock[];
+  name: string;
+  tentative?: boolean;
+}> = [
+  { dates: [], expected: [], name: 'empty selection' },
+  {
+    dates: [date('2024-03-15T08:00:00Z')],
+    expected: [block('2024-03-15', '08:00:00+00:00', '08:15:00+00:00')],
+    name: 'one selected cell',
+  },
+  {
+    dates: [date('2024-03-15T08:00:00Z'), date('2024-03-15T08:00:00Z')],
+    expected: [block('2024-03-15', '08:00:00+00:00', '08:15:00+00:00')],
+    name: 'equal endpoints',
+  },
+  {
+    dates: [
+      date('2024-03-15T08:00:00Z'),
+      date('2024-03-15T08:15:00Z'),
+      date('2024-03-15T08:30:00Z'),
+    ],
+    expected: [],
+    name: 'more than two endpoints',
+  },
+  {
+    dates: [date('2024-03-15T08:00:00Z'), date('2024-03-15T19:00:00Z')],
+    expected: [block('2024-03-15', '08:00:00+00:00', '19:15:00+00:00')],
+    name: 'same-day forward selection',
+  },
+  {
+    dates: [date('2024-03-15T19:00:00Z'), date('2024-03-15T08:00:00Z')],
+    expected: [block('2024-03-15', '08:00:00+00:00', '19:15:00+00:00')],
+    name: 'same-day reverse selection',
+  },
+  {
+    dates: [date('2024-03-15T08:00:00Z'), date('2024-03-17T19:00:00Z')],
+    expected: ['15', '16', '17'].map((day) =>
+      block(`2024-03-${day}`, '08:00:00+00:00', '19:15:00+00:00')
+    ),
+    name: 'multi-day forward selection',
+  },
+  {
+    dates: [date('2024-03-17T19:00:00Z'), date('2024-03-15T08:00:00Z')],
+    expected: ['15', '16', '17'].map((day) =>
+      block(`2024-03-${day}`, '08:00:00+00:00', '19:15:00+00:00')
+    ),
+    name: 'multi-day reverse selection',
+  },
+  {
+    dates: [
+      date('2024-03-15T08:00:00+02:00'),
+      date('2024-03-17T19:00:00+02:00'),
+    ],
+    expected: ['15', '16', '17'].map((day) =>
+      block(`2024-03-${day}`, '06:00:00+00:00', '17:15:00+00:00')
+    ),
+    name: 'positive input offset normalized to UTC',
+  },
+  {
+    dates: [
+      date('2024-03-15T08:00:00-02:00'),
+      date('2024-03-17T19:00:00-02:00'),
+    ],
+    expected: ['15', '16', '17'].map((day) =>
+      block(`2024-03-${day}`, '10:00:00+00:00', '21:15:00+00:00')
+    ),
+    name: 'negative input offset normalized to UTC',
+  },
+  {
+    dates: [
+      date('2024-03-09T08:00:00-05:00'),
+      date('2024-03-11T09:00:00-04:00'),
+    ],
+    expected: ['09', '10', '11'].map((day) =>
+      block(`2024-03-${day}`, '13:00:00+00:00', '13:15:00+00:00', true)
+    ),
+    name: 'DST-adjacent explicit offsets normalized by instant',
+    tentative: true,
+  },
+];
+
+describe('durationToTimeblocks', () => {
+  test.each(durationCases)('$name', ({ dates, expected, tentative }) => {
+    expect(normalize(durationToTimeblocks(dates, tentative ?? false))).toEqual(
+      expected
+    );
+  });
+});
+
+const addCases: Array<{
+  dates: Date[];
+  expected: Timeblock[];
+  name: string;
+  previous: Timeblock[];
+  tentative?: boolean;
+}> = [
+  { dates: [], expected: [], name: 'empty state and selection', previous: [] },
+  {
+    dates: [],
+    expected: [block('2024-03-15', '08:00:00+00:00', '09:00:00+00:00')],
+    name: 'empty selection preserves state',
+    previous: [block('2024-03-15', '08:00:00+00:00', '09:00:00+00:00')],
+  },
+  {
+    dates: [date('2024-03-16T10:00:00Z'), date('2024-03-16T15:15:00Z')],
+    expected: [
+      block('2024-03-15', '08:00:00+00:00', '09:00:00+00:00'),
+      block('2024-03-16', '10:00:00+00:00', '15:30:00+00:00'),
+    ],
+    name: 'different day sorted after existing state',
+    previous: [block('2024-03-15', '08:00:00+00:00', '09:00:00+00:00')],
+  },
+  {
+    dates: [date('2024-03-15T08:15:00Z'), date('2024-03-15T08:30:00Z')],
+    expected: [block('2024-03-15', '08:00:00+00:00', '09:00:00+00:00')],
+    name: 'contained overlap',
+    previous: [block('2024-03-15', '08:00:00+00:00', '09:00:00+00:00')],
+  },
+  {
+    dates: [date('2024-03-15T09:00:00Z'), date('2024-03-15T09:00:00Z')],
+    expected: [block('2024-03-15', '08:00:00+00:00', '09:15:00+00:00')],
+    name: 'adjacent selection merges',
+    previous: [block('2024-03-15', '08:00:00+00:00', '09:00:00+00:00')],
+  },
+  {
+    dates: [date('2024-03-15T10:00:00Z'), date('2024-03-15T10:00:00Z')],
+    expected: [
+      block('2024-03-15', '08:00:00+00:00', '09:00:00+00:00'),
+      block('2024-03-15', '10:00:00+00:00', '10:15:00+00:00'),
+    ],
+    name: 'disjoint same-day selection stays separate',
+    previous: [block('2024-03-15', '08:00:00+00:00', '09:00:00+00:00')],
+  },
+  {
+    dates: [date('2024-03-15T08:30:00Z'), date('2024-03-15T10:00:00Z')],
+    expected: [block('2024-03-15', '08:00:00+00:00', '10:15:00+00:00')],
+    name: 'right overlap extends through final cell',
+    previous: [block('2024-03-15', '08:00:00+00:00', '09:00:00+00:00')],
+  },
+  {
+    dates: [date('2024-03-15T08:00:00Z'), date('2024-03-15T09:00:00Z')],
+    expected: [block('2024-03-15', '08:00:00+00:00', '10:00:00+00:00')],
+    name: 'left overlap normalizes reverse coverage',
+    previous: [block('2024-03-15', '09:00:00+00:00', '10:00:00+00:00')],
+  },
+  {
+    dates: [date('2024-03-15T08:30:00Z'), date('2024-03-15T09:00:00Z')],
+    expected: [
+      block('2024-03-15', '08:00:00+00:00', '08:30:00+00:00'),
+      block('2024-03-15', '08:30:00+00:00', '09:15:00+00:00', true),
+      block('2024-03-15', '09:15:00+00:00', '10:00:00+00:00'),
+    ],
+    name: 'tentative overlap splits committed state',
+    previous: [block('2024-03-15', '08:00:00+00:00', '10:00:00+00:00')],
+    tentative: true,
+  },
+];
+
+describe('addTimeblocks', () => {
+  test.each(addCases)('$name', ({ dates, expected, previous, tentative }) => {
+    expect(
+      normalize(addTimeblocks(previous, dates, tentative ?? false))
+    ).toEqual(expected);
+  });
+});
+
+const baseHour = block('2024-03-15', '08:00:00+00:00', '09:00:00+00:00');
+
+const removalCases: Array<{
+  dates: Date[];
+  expected: Timeblock[];
+  name: string;
+  previous: Timeblock[];
+}> = [
+  { dates: [], expected: [], name: 'empty state and selection', previous: [] },
+  {
+    dates: [],
+    expected: [baseHour],
+    name: 'empty selection preserves state',
+    previous: [baseHour],
+  },
+  {
+    dates: [date('2024-03-15T08:15:00Z')],
+    expected: [
+      block('2024-03-15', '08:00:00+00:00', '08:15:00+00:00'),
+      block('2024-03-15', '08:30:00+00:00', '09:00:00+00:00'),
+    ],
+    name: 'one-date shape removes exactly one cell',
+    previous: [baseHour],
+  },
+  {
+    dates: [date('2024-03-15T08:15:00Z'), date('2024-03-15T08:15:00Z')],
+    expected: [
+      block('2024-03-15', '08:00:00+00:00', '08:15:00+00:00'),
+      block('2024-03-15', '08:30:00+00:00', '09:00:00+00:00'),
+    ],
+    name: 'equal endpoints remove exactly one cell',
+    previous: [baseHour],
+  },
+  {
+    dates: [
+      date('2024-03-15T08:00:00Z'),
+      date('2024-03-15T08:30:00Z'),
+      date('2024-03-15T08:45:00Z'),
+    ],
+    expected: [block('2024-03-15', '08:15:00+00:00', '08:30:00+00:00')],
+    name: 'per-date shape removes one cell per selected instant',
+    previous: [baseHour],
+  },
+  {
+    dates: [date('2024-03-15T08:00:00Z'), date('2024-03-15T12:00:00Z')],
+    expected: [block('2024-03-15', '12:15:00+00:00', '19:15:00+00:00')],
+    name: 'first range split',
+    previous: [block('2024-03-15', '08:00:00+00:00', '19:15:00+00:00')],
+  },
+  {
+    dates: [date('2024-03-15T12:00:00Z'), date('2024-03-15T19:00:00Z')],
+    expected: [block('2024-03-15', '08:00:00+00:00', '12:00:00+00:00')],
+    name: 'last range split',
+    previous: [block('2024-03-15', '08:00:00+00:00', '19:15:00+00:00')],
+  },
+  {
+    dates: [date('2024-03-15T10:00:00Z'), date('2024-03-15T15:15:00Z')],
+    expected: [
+      block('2024-03-15', '08:00:00+00:00', '10:00:00+00:00'),
+      block('2024-03-15', '15:30:00+00:00', '19:15:00+00:00'),
+    ],
+    name: 'middle range split',
+    previous: [block('2024-03-15', '08:00:00+00:00', '19:15:00+00:00')],
+  },
+  {
+    dates: [date('2024-03-15T08:00:00Z'), date('2024-03-15T19:00:00Z')],
+    expected: [],
+    name: 'full range removal',
+    previous: [block('2024-03-15', '08:00:00+00:00', '19:15:00+00:00')],
+  },
+  {
+    dates: [date('2024-03-15T08:00:00Z'), date('2024-03-17T08:45:00Z')],
+    expected: [block('2024-03-15', '10:00:00+00:00', '11:00:00+00:00')],
+    name: 'same slot across multiple days',
+    previous: [
+      ...['15', '16', '17'].map((day) =>
+        block(`2024-03-${day}`, '08:00:00+00:00', '09:00:00+00:00')
+      ),
+      block('2024-03-15', '10:00:00+00:00', '11:00:00+00:00'),
+    ],
+  },
+  {
+    dates: [date('2024-03-15T08:00:00Z'), date('2024-03-15T19:00:00Z')],
+    expected: [block('2024-03-16', '08:00:00+00:00', '19:15:00+00:00')],
+    name: 'full removal across adjacent blocks on one day',
+    previous: [
+      block('2024-03-15', '08:00:00+00:00', '12:00:00+00:00'),
+      block('2024-03-15', '12:00:00+00:00', '19:15:00+00:00'),
+      block('2024-03-16', '08:00:00+00:00', '19:15:00+00:00'),
+    ],
+  },
+  {
+    dates: [date('2024-03-15T08:00:00Z'), date('2024-03-16T19:00:00Z')],
+    expected: [],
+    name: 'multi-day full removal',
+    previous: [
+      block('2024-03-15', '08:00:00+00:00', '19:15:00+00:00'),
+      block('2024-03-16', '08:00:00+00:00', '19:15:00+00:00'),
+    ],
+  },
+  {
+    dates: [date('2024-03-16T19:00:00Z'), date('2024-03-15T08:00:00Z')],
+    expected: [],
+    name: 'reverse multi-day full removal',
+    previous: [
+      block('2024-03-15', '08:00:00+00:00', '19:15:00+00:00'),
+      block('2024-03-16', '08:00:00+00:00', '19:15:00+00:00'),
+    ],
+  },
+];
+
+describe('removeTimeblocks', () => {
+  test.each(removalCases)('$name', ({ dates, expected, previous }) => {
+    expect(normalize(removeTimeblocks(previous, dates))).toEqual(expected);
+  });
+});
+
+test('state-machine suites cannot regain static skips or todos', () => {
+  const source = readFileSync(__filename, 'utf8');
+  expect(source).not.toMatch(/\b(?:test|it|describe)\.(?:skip|todo)\s*\(/u);
+  expect(
+    durationCases.length + addCases.length + removalCases.length
+  ).toBeGreaterThanOrEqual(25);
+});

package/src/timeblock-helper.ts

@@ -227,9 +227,8 @@ export function removeTimeblocks(
       .set('hour', soonestTime.hour())
       .set('minute', soonestTime.minute())
       .set('second', 0);
-    const removalEnd = removalStart.add(15, 'minutes');
 
-    return removeTimeblocksInRange(prevTimeblocks, removalStart, removalEnd);
+    return removeTimeblocksInRange(prevTimeblocks, removalStart, removalStart);
   }
 
   // Handle multi-day removal - process each day separately
@@ -298,8 +297,7 @@ export function removeTimeblocks(
 
   for (const date of sortedDates) {
     const removalStart = dayjs(date).set('second', 0);
-    const removalEnd = removalStart.add(15, 'minutes');
-    result = removeTimeblocksInRange(result, removalStart, removalEnd);
+    result = removeTimeblocksInRange(result, removalStart, removalStart);
   }
 
   return result;