cursedbelt 1.0.0 → 2.5.0

package/src/react/timeline/TimelineSurface.tsx

@@ -1,157 +0,0 @@
-import {
-  clampZoom,
-  secondsToPx,
-  type TimelineTrack,
-  totalDuration,
-  ZOOM_RANGE,
-  zoomAnchoredScrollLeft,
-} from 'cwip/timeline';
-import { Minus, Plus } from 'lucide-react';
-import { type ReactNode, useEffect, useRef } from 'react';
-import { IconButton } from '../components/IconButton';
-import { ScrollArea } from '../components/ScrollArea';
-import { Slider } from '../components/Slider';
-import { Tooltip } from '../components/Tooltip';
-import { cn } from '../lib/cn';
-import { Playhead } from './Playhead';
-import { TimeRuler } from './TimeRuler';
-
-export interface TimelineSurfaceProps {
-  tracks: TimelineTrack[];
-  zoomScale: number;
-  currentTime: number;
-  onScrub: (seconds: number) => void;
-  onScrubStart?: () => void;
-  onScrubEnd?: () => void;
-  /** Zoom changes arrive pre-clamped; scroll is re-anchored on the playhead. */
-  onZoomChange?: (zoomScale: number) => void;
-  /** Renders each track's lane (TrackLane + ClipViews) — the owner wires ops. */
-  renderTrack: (track: TimelineTrack, durationSeconds: number) => ReactNode;
-  /** Extra tail beyond the last clip so there's room to drop/extend (default 10s). */
-  tailSeconds?: number;
-  /** Auto-scroll so the playhead stays in view as `currentTime` advances (e.g. during
-   * playback) — once it nears the viewport edge, the view pages forward to keep it
-   * visible, rather than scrolling every frame. */
-  followPlayhead?: boolean;
-  className?: string;
-}
-
-/**
- * The composed timeline scroller: ruler + track lanes + playhead in one
- * horizontally-scrolling keyboard-inset-safe surface (ScrollArea — no raw
- * overflow), with zoom controls that keep the playhead visually anchored.
- * Fully controlled; owns NO timeline state.
- */
-export function TimelineSurface({
-  tracks,
-  zoomScale,
-  currentTime,
-  onScrub,
-  onScrubStart,
-  onScrubEnd,
-  onZoomChange,
-  renderTrack,
-  tailSeconds = 10,
-  followPlayhead = false,
-  className,
-}: TimelineSurfaceProps) {
-  const scrollRef = useRef<HTMLDivElement | null>(null);
-  const durationSeconds = totalDuration(tracks) + tailSeconds;
-
-  useEffect(() => {
-    if (!followPlayhead) return;
-    const el = scrollRef.current;
-    if (!el) return;
-    const playheadPx = secondsToPx(currentTime, zoomScale);
-    const viewportX = playheadPx - el.scrollLeft;
-    // Only page the view forward/back once the playhead nears an edge — scrolling every
-    // frame during playback would fight the user's ability to glance elsewhere.
-    const margin = el.clientWidth * 0.1;
-    if (viewportX < margin || viewportX > el.clientWidth - margin) {
-      el.scrollLeft = Math.max(0, playheadPx - el.clientWidth * 0.2);
-    }
-  }, [followPlayhead, currentTime, zoomScale]);
-
-  const changeZoom = (next: number) => {
-    if (!onZoomChange) return;
-    const clamped = clampZoom(next);
-    const el = scrollRef.current;
-    if (el) {
-      const anchorViewportPx = secondsToPx(currentTime, zoomScale) - el.scrollLeft;
-      // after the re-render at the new zoom, restore the playhead's viewport x
-      requestAnimationFrame(() => {
-        el.scrollLeft = zoomAnchoredScrollLeft(currentTime, anchorViewportPx, clamped);
-      });
-    }
-    onZoomChange(clamped);
-  };
-
-  return (
-    <div className={cn('flex flex-col', className)}>
-      {onZoomChange && (
-        <div className='flex items-center justify-end gap-2 border-b border-border px-2 py-1'>
-          <Tooltip content='Zoom out'>
-            <IconButton
-              label='Zoom out'
-              onClick={() => changeZoom(zoomScale / 1.4)}
-              disabled={zoomScale <= ZOOM_RANGE.min}
-            >
-              <Minus aria-hidden className='size-4' />
-            </IconButton>
-          </Tooltip>
-          <Slider
-            value={zoomScale}
-            min={ZOOM_RANGE.min}
-            max={ZOOM_RANGE.max}
-            // A coarse step of 1 would swallow the whole low end (0.05–1) in a single
-            // increment, making the zoomed-out-enough-to-fit-a-long-clip range
-            // unreachable by dragging — 0.5 keeps that end usable too.
-            step={0.5}
-            aria-label='Timeline zoom'
-            className='w-24'
-            onChange={changeZoom}
-          />
-          <span className='w-14 text-center text-caption tabular-nums text-muted-foreground'>
-            {Math.round(zoomScale)} px/s
-          </span>
-          <Tooltip content='Zoom in'>
-            <IconButton
-              label='Zoom in'
-              onClick={() => changeZoom(zoomScale * 1.4)}
-              disabled={zoomScale >= ZOOM_RANGE.max}
-            >
-              <Plus aria-hidden className='size-4' />
-            </IconButton>
-          </Tooltip>
-        </div>
-      )}
-      <ScrollArea axis='x' space='none' scrollRef={scrollRef} className='grow'>
-        <div className='relative w-max min-w-full'>
-          {/* ruler is offset by the sticky lane-header width so times align */}
-          <div className='ml-28'>
-            <TimeRuler
-              durationSeconds={durationSeconds}
-              zoomScale={zoomScale}
-              currentTimeSeconds={currentTime}
-              onScrub={onScrub}
-              onScrubStart={onScrubStart}
-              onScrubEnd={onScrubEnd}
-            />
-          </div>
-          {tracks.map((track) => renderTrack(track, durationSeconds))}
-          <div className='pointer-events-none absolute inset-y-0 left-28 right-0'>
-            <div className='relative h-full'>
-              <Playhead
-                timeSeconds={currentTime}
-                zoomScale={zoomScale}
-                onScrub={onScrub}
-                onScrubStart={onScrubStart}
-                onScrubEnd={onScrubEnd}
-              />
-            </div>
-          </div>
-        </div>
-      </ScrollArea>
-    </div>
-  );
-}

package/src/react/timeline/TrackLane.tsx

@@ -1,87 +0,0 @@
-import { pxToSeconds, secondsToPx, type TimelineTrack } from 'cwip/timeline';
-import { AudioLines, Film } from 'lucide-react';
-import type { DragEvent, ReactNode } from 'react';
-import { useRef } from 'react';
-import { cn } from '../lib/cn';
-
-export const TRACK_LANE_HEIGHT_PX = 108;
-
-export interface TrackLaneProps {
-  track: TimelineTrack;
-  zoomScale: number;
-  /** Lane runway width (seconds) — the surface passes one shared duration. */
-  durationSeconds: number;
-  /** Rendered `ClipView`s (the owner maps clips so it controls the wiring). */
-  children: ReactNode;
-  /** Lane height in px (default {@link TRACK_LANE_HEIGHT_PX}). Owners can shrink
-   * a rarely-used lane (e.g. an empty audio track) and grow it once it holds a
-   * clip, so unused lanes don't waste vertical space. */
-  laneHeightPx?: number;
-  /** Click on empty runway — typically seek + deselect. */
-  onRunwayClick?: (seconds: number) => void;
-  /** A `dataTransfer` drop on the runway (asset from a library/palette). */
-  onDropData?: (payload: { atSeconds: number; dataTransfer: DataTransfer }) => void;
-  className?: string;
-}
-
-/**
- * One track row: a sticky header (name + kind icon) and the clip runway. The
- * runway is the `relative` positioning context `ClipView`s place themselves
- * in, and the drop target for library assets (drop position is reported in
- * SECONDS, scroll offset already accounted for via the runway's own rect).
- */
-export function TrackLane({
-  track,
-  zoomScale,
-  durationSeconds,
-  children,
-  laneHeightPx = TRACK_LANE_HEIGHT_PX,
-  onRunwayClick,
-  onDropData,
-  className,
-}: TrackLaneProps) {
-  const runwayRef = useRef<HTMLDivElement>(null);
-
-  const secondsAt = (clientX: number): number => {
-    const rect = runwayRef.current?.getBoundingClientRect();
-    if (!rect) return 0;
-    return Math.max(0, pxToSeconds(clientX - rect.left, zoomScale));
-  };
-
-  const onDrop = (e: DragEvent) => {
-    if (!onDropData) return;
-    e.preventDefault();
-    onDropData({ atSeconds: secondsAt(e.clientX), dataTransfer: e.dataTransfer });
-  };
-
-  return (
-    <div
-      className={cn('flex border-b border-border/60 transition-[min-height]', className)}
-      style={{ minHeight: laneHeightPx }}
-    >
-      <div className='sticky left-0 z-30 flex w-28 shrink-0 items-center gap-1.5 border-r border-border bg-muted/60 px-2 backdrop-blur-sm'>
-        {track.type === 'video' ? (
-          <Film aria-hidden className='size-3.5 text-muted-foreground' />
-        ) : (
-          <AudioLines aria-hidden className='size-3.5 text-muted-foreground' />
-        )}
-        <span className='truncate text-xs text-foreground'>{track.name}</span>
-      </div>
-      {/* biome-ignore lint/a11y/useKeyWithClickEvents: seek-on-click pointer convenience — the ruler is the accessible seek control */}
-      {/* biome-ignore lint/a11y/noStaticElementInteractions: same — decorative runway, real controls live on the clips/ruler */}
-      <div
-        ref={runwayRef}
-        className='relative'
-        style={{ width: secondsToPx(durationSeconds, zoomScale) }}
-        onClick={(e) => onRunwayClick?.(secondsAt(e.clientX))}
-        onDragOver={(e) => {
-          if (onDropData) e.preventDefault(); // required for `drop` to fire
-        }}
-        onDrop={onDrop}
-        data-track-id={track.id}
-      >
-        {children}
-      </div>
-    </div>
-  );
-}

package/src/react/timeline/index.ts

@@ -1,12 +0,0 @@
-// cursedbelt/react/timeline — the generic multi-track timeline editor surface.
-// Controlled/presentational components over the cwip/timeline engine: they
-// translate pixels to seconds and report INTENT (select/move/trim/scrub); the
-// owner applies cwip ops (clamping, ripple, snapping) and passes state back
-// down. Reusable for any lane-based editor (video NLE, audio arrangement,
-// schedule lanes) — the cursedshell video-editor plugin is the reference user.
-
-export { ClipView, type ClipViewProps, type TrimEdge } from './ClipView';
-export { Playhead, type PlayheadProps } from './Playhead';
-export { TimelineSurface, type TimelineSurfaceProps } from './TimelineSurface';
-export { TimeRuler, type TimeRulerProps } from './TimeRuler';
-export { TRACK_LANE_HEIGHT_PX, TrackLane, type TrackLaneProps } from './TrackLane';

package/src/react/timeline/timeline.spec.tsx

@@ -1,175 +0,0 @@
-import { afterEach, describe, expect, test } from 'bun:test';
-import { cleanup, createEvent, fireEvent, render } from '@testing-library/react';
-import type { TimelineClip, TimelineTrack } from 'cwip/timeline';
-import { ClipView } from './ClipView';
-import { TimelineSurface } from './TimelineSurface';
-import { TimeRuler } from './TimeRuler';
-import { TrackLane } from './TrackLane';
-
-afterEach(cleanup);
-
-const clip = (partial: Partial<TimelineClip> & { id: string }): TimelineClip => ({
-  name: partial.id,
-  sourceAssetId: 'a1',
-  trackIn: 0,
-  trackOut: 10,
-  timelineStart: 0,
-  timelineEnd: 10,
-  speed: 1,
-  volume: 1,
-  ...partial,
-});
-
-const track = (
-  id: string,
-  clips: TimelineClip[] = [],
-  type: 'video' | 'audio' = 'video',
-): TimelineTrack => ({
-  id,
-  name: id,
-  type,
-  clips,
-});
-
-const noopClipHandlers = {
-  onSelect: () => {},
-  onMovePreview: () => {},
-  onMoveCommit: () => {},
-  onTrimPreview: () => {},
-  onTrimCommit: () => {},
-};
-
-describe('ClipView', () => {
-  test('positions by timeline seconds × zoom and shows name + source window', () => {
-    const c = clip({ id: 'intro', timelineStart: 2, timelineEnd: 6, trackIn: 1, trackOut: 5 });
-    const { getByRole, getByText } = render(
-      <ClipView clip={c} zoomScale={25} selected={false} {...noopClipHandlers} />,
-    );
-    const block = getByRole('button', { name: 'Clip intro' });
-    expect(block.style.left).toBe('50px');
-    expect(block.style.width).toBe('98px'); // 100px minus the 2px seam
-    expect(getByText('intro')).toBeDefined();
-    expect(getByText('0:01–0:05')).toBeDefined();
-  });
-
-  test('click selects (and stops at the clip, not the lane behind)', () => {
-    let selected = 0;
-    let laneClicks = 0;
-    const { getByRole } = render(
-      <TrackLane
-        track={track('v1')}
-        zoomScale={25}
-        durationSeconds={20}
-        onRunwayClick={() => {
-          laneClicks += 1;
-        }}
-      >
-        <ClipView
-          clip={clip({ id: 'c1' })}
-          zoomScale={25}
-          selected={false}
-          {...noopClipHandlers}
-          onSelect={() => {
-            selected += 1;
-          }}
-        />
-      </TrackLane>,
-    );
-    fireEvent.click(getByRole('button', { name: 'Clip c1' }));
-    expect(selected).toBe(1);
-    expect(laneClicks).toBe(0);
-  });
-
-  test('shows a speed badge only when speed ≠ 1', () => {
-    const { queryByText, rerender } = render(
-      <ClipView clip={clip({ id: 'c1' })} zoomScale={25} selected={false} {...noopClipHandlers} />,
-    );
-    expect(queryByText('1x')).toBeNull();
-    rerender(
-      <ClipView
-        clip={clip({ id: 'c1', speed: 2, timelineEnd: 5 })}
-        zoomScale={25}
-        selected={false}
-        {...noopClipHandlers}
-      />,
-    );
-    expect(queryByText('2x')).toBeDefined();
-  });
-});
-
-describe('TimeRuler', () => {
-  test('thins tick labels as zoom drops', () => {
-    const dense = render(<TimeRuler durationSeconds={10} zoomScale={100} onScrub={() => {}} />);
-    // 100 px/s → 1s ticks: 0..10 = 11 labels
-    expect(dense.container.querySelectorAll('span').length).toBe(11);
-    dense.unmount();
-    const sparse = render(<TimeRuler durationSeconds={10} zoomScale={10} onScrub={() => {}} />);
-    // 10 px/s → 10s ticks: 0, 10
-    expect(sparse.container.querySelectorAll('span').length).toBe(2);
-  });
-});
-
-describe('TrackLane', () => {
-  test('reports drops in seconds using the runway rect and zoom', () => {
-    let dropped: { atSeconds: number } | null = null;
-    const { container } = render(
-      <TrackLane
-        track={track('v1')}
-        zoomScale={25}
-        durationSeconds={20}
-        onDropData={(payload) => {
-          dropped = payload;
-        }}
-      >
-        <div />
-      </TrackLane>,
-    );
-    const runway = container.querySelector('[data-track-id="v1"]') as HTMLElement;
-    runway.getBoundingClientRect = () =>
-      ({
-        left: 100,
-        top: 0,
-        width: 500,
-        height: 64,
-        right: 600,
-        bottom: 64,
-        x: 100,
-        y: 0,
-      }) as DOMRect;
-    // happy-dom's DragEvent constructor ignores mouse-init fields — set them directly
-    const drop = createEvent.drop(runway);
-    Object.defineProperty(drop, 'clientX', { value: 200 });
-    Object.defineProperty(drop, 'dataTransfer', { value: { getData: () => '' } });
-    fireEvent(runway, drop);
-    expect(dropped).not.toBeNull();
-    expect((dropped as unknown as { atSeconds: number }).atSeconds).toBe(4); // (200-100)/25
-  });
-});
-
-describe('TimelineSurface', () => {
-  test('renders ruler, lanes, playhead, and zoom controls together', () => {
-    const tracks = [track('v1', [clip({ id: 'c1' })]), track('a1', [], 'audio')];
-    const { getByRole, getAllByRole, getByText } = render(
-      <TimelineSurface
-        tracks={tracks}
-        zoomScale={25}
-        currentTime={3}
-        onScrub={() => {}}
-        onZoomChange={() => {}}
-        renderTrack={(t, duration) => (
-          <TrackLane key={t.id} track={t} zoomScale={25} durationSeconds={duration}>
-            {t.clips.map((c) => (
-              <ClipView key={c.id} clip={c} zoomScale={25} selected={false} {...noopClipHandlers} />
-            ))}
-          </TrackLane>
-        )}
-      />,
-    );
-    expect(getByRole('slider', { name: 'Timeline position' })).toBeDefined();
-    expect(getByRole('slider', { name: 'Playhead' })).toBeDefined();
-    expect(getByRole('button', { name: 'Zoom in' })).toBeDefined();
-    expect(getByText('v1')).toBeDefined();
-    expect(getByText('a1')).toBeDefined();
-    expect(getAllByRole('button', { name: 'Clip c1' })).toHaveLength(1);
-  });
-});

package/src/server/private-media/index.ts

@@ -1,45 +0,0 @@
-// cursedbelt/server/private-media — encrypted private media: a multi-password, semi-deniable
-// layer over server/storage. Bytes are AES-128-encrypted HLS (fast, edge-cacheable, client-
-// decrypted); the per-item content key is wrapped under a set key that is either server-held
-// (standard, recoverable) or password-derived (deniable, zero-knowledge). A clear index exposes
-// only size + created-at so users can prune forgotten-password media; title/thumb/notes stay in
-// an encrypted envelope revealed only by the right password. Builds on cwip secretBox (scrypt +
-// AES-GCM) + server/auth (jose) + server/media (the encrypted-HLS pipeline).
-
-export type { ContentKey, KeyMode } from './crypto';
-export {
-  cryptBlobStream,
-  derivePasswordSetKey,
-  deriveServerSetKey,
-  generateContentKey,
-  generateUserSalt,
-  openMeta,
-  sealMeta,
-  unwrapContentKey,
-  wrapContentKey,
-} from './crypto';
-export {
-  createMemoryPrivateIndex,
-  type PrivateIndex,
-  type PrivateIndexRow,
-  type PrivateItem,
-  toPublic,
-} from './index-store';
-export {
-  type CorsResolver,
-  type MountPrivateOptions,
-  mountPrivateRoutes,
-} from './mountPrivateRoutes';
-export {
-  type PrivateBlobResult,
-  type PrivateProcessOptions,
-  type PrivateProcessResult,
-  processPrivateBlob,
-  processPrivateVideo,
-} from './pipeline';
-export {
-  createUnlockService,
-  type UnlockGrant,
-  type UnlockPasswordPolicy,
-  type UnlockService,
-} from './unlock';

package/src/server/seo/index.ts

@@ -1,8 +0,0 @@
-// cursedbelt/server/seo — Hono wiring for cwip's SEO core: sitemap.xml/robots.txt
-// routes and a static-HTML head-injection handler. See seo-reusable-plan.md for the
-// wider architecture (visibility model, delivery targets, cursedshell aggregation).
-export { type MountSeoOptions, mountSeoRoutes } from './mountSeoRoutes';
-export {
-  type ServeHeadInjectedIndexOptions,
-  serveHeadInjectedIndex,
-} from './serveHeadInjectedIndex';

package/src/server/seo/mountSeoRoutes.ts

@@ -1,37 +0,0 @@
-import type { SeoPolicy } from 'cwip/seo';
-import { buildRobots, buildSitemap } from 'cwip/seo';
-import type { Hono } from 'hono';
-
-export interface MountSeoOptions {
-  // Path the sitemap is served at (default '/sitemap.xml'); also what buildRobots
-  // points its `Sitemap:` line at.
-  sitemapPath?: string;
-  // Path robots.txt is served at (default '/robots.txt').
-  robotsPath?: string;
-  // Cache-Control header applied to both responses (default 'public, max-age=3600').
-  cacheControl?: string;
-}
-
-// Registers GET /sitemap.xml and GET /robots.txt from a SeoPolicy. These serve raw
-// text bytes, so — per cursedbelt STANDARDS.md §5 — they are registered DIRECTLY
-// with `app.get`, never through `buildRoutes`: routing them through the ctgr
-// GET-tunnel would base64url-encode the response body instead of serving it as-is.
-export const mountSeoRoutes = (
-  app: Hono,
-  policy: SeoPolicy,
-  options: MountSeoOptions = {},
-): void => {
-  const sitemapPath = options.sitemapPath ?? '/sitemap.xml';
-  const robotsPath = options.robotsPath ?? '/robots.txt';
-  const cacheControl = options.cacheControl ?? 'public, max-age=3600';
-
-  app.get(sitemapPath, (c) => {
-    c.header('Cache-Control', cacheControl);
-    return c.body(buildSitemap(policy), 200, { 'Content-Type': 'application/xml' });
-  });
-
-  app.get(robotsPath, (c) => {
-    c.header('Cache-Control', cacheControl);
-    return c.body(buildRobots(policy, { sitemapPath }), 200, { 'Content-Type': 'text/plain' });
-  });
-};

package/src/server/seo/seo.spec.ts

@@ -1,128 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import type { SeoPolicy } from 'cwip/seo';
-import { Hono } from 'hono';
-import { mountSeoRoutes } from './mountSeoRoutes';
-import { serveHeadInjectedIndex } from './serveHeadInjectedIndex';
-
-const policy: SeoPolicy = {
-  siteUrl: 'https://example.com',
-  defaultVisibility: 'private',
-  disallow: ['/api'],
-  entries: [
-    {
-      path: '/',
-      visibility: 'public',
-      head: { title: 'Home', description: 'Welcome' },
-    },
-    {
-      path: '/articles/free-monads',
-      visibility: 'public',
-      head: {
-        title: 'Free monads',
-        description: 'An article about free monads',
-        openGraph: { type: 'article' },
-      },
-      lastmod: '2026-01-01',
-    },
-    { path: '/notes', visibility: 'private' },
-  ],
-};
-
-describe('mountSeoRoutes', () => {
-  test('serves sitemap.xml with public entries and the right content-type', async () => {
-    const app = new Hono();
-    mountSeoRoutes(app, policy);
-    const res = await app.request('/sitemap.xml');
-    expect(res.status).toBe(200);
-    expect(res.headers.get('Content-Type')).toContain('application/xml');
-    const body = await res.text();
-    expect(body).toContain('<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">');
-    expect(body).toContain('https://example.com/articles/free-monads');
-    expect(body).not.toContain('/notes');
-  });
-
-  test('serves robots.txt disallowing private entries and explicit paths', async () => {
-    const app = new Hono();
-    mountSeoRoutes(app, policy);
-    const res = await app.request('/robots.txt');
-    expect(res.status).toBe(200);
-    expect(res.headers.get('Content-Type')).toContain('text/plain');
-    const body = await res.text();
-    expect(body).toContain('Disallow: /api');
-    expect(body).toContain('Disallow: /notes');
-    expect(body).toContain('Sitemap: https://example.com/sitemap.xml');
-  });
-
-  test('honors custom sitemapPath/robotsPath/cacheControl', async () => {
-    const app = new Hono();
-    mountSeoRoutes(app, policy, {
-      sitemapPath: '/custom-sitemap.xml',
-      robotsPath: '/custom-robots.txt',
-      cacheControl: 'no-cache',
-    });
-    const sitemap = await app.request('/custom-sitemap.xml');
-    const robots = await app.request('/custom-robots.txt');
-    expect(sitemap.status).toBe(200);
-    expect(sitemap.headers.get('Cache-Control')).toBe('no-cache');
-    expect(robots.status).toBe(200);
-    expect(await robots.text()).toContain('Sitemap: https://example.com/custom-sitemap.xml');
-  });
-});
-
-const baseHtml = `<!doctype html>
-<html>
-  <head>
-    <title>Base Title</title>
-    <meta name="description" content="Base description">
-  </head>
-  <body><div id="root"></div></body>
-</html>
-`;
-
-describe('serveHeadInjectedIndex', () => {
-  test('injects the resolved head and strips the base title/description for a mapped path', async () => {
-    const app = new Hono();
-    app.get('*', (c) =>
-      serveHeadInjectedIndex({
-        html: baseHtml,
-        resolve: (path) =>
-          path === '/articles/free-monads'
-            ? { title: 'Free monads', description: 'An article about free monads' }
-            : undefined,
-      })(c),
-    );
-    const res = await app.request('/articles/free-monads');
-    const body = await res.text();
-    expect(body).toContain('<title data-cwip-seo>Free monads</title>');
-    expect(body).toContain('An article about free monads');
-    expect(body).not.toContain('Base Title');
-    expect(body).not.toContain('Base description');
-  });
-
-  test('serves the base shell untouched for an unmapped path', async () => {
-    const app = new Hono();
-    app.get('*', (c) =>
-      serveHeadInjectedIndex({
-        html: baseHtml,
-        resolve: () => undefined,
-      })(c),
-    );
-    const res = await app.request('/some/authorized/path');
-    const body = await res.text();
-    expect(body).toContain('<title>Base Title</title>');
-    expect(body).toContain('Base description');
-  });
-
-  test('accepts an async html loader', async () => {
-    const app = new Hono();
-    app.get('*', (c) =>
-      serveHeadInjectedIndex({
-        html: async () => baseHtml,
-        resolve: () => ({ title: 'Loaded' }),
-      })(c),
-    );
-    const res = await app.request('/');
-    const body = await res.text();
-    expect(body).toContain('Loaded');
-  });
-});