cursedbelt 1.0.0 → 2.3.0

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');
-  });
-});

package/src/server/seo/serveHeadInjectedIndex.ts

@@ -1,36 +0,0 @@
-import type { HeadModel } from 'cwip/seo';
-import { injectHead, renderHead, stripBaseTitleAndDescription } from 'cwip/seo';
-import type { Context } from 'hono';
-
-export interface ServeHeadInjectedIndexOptions {
-  // The SPA's index.html, or a (possibly async) loader for it — read once per
-  // request so a caller can hot-reload the file in dev without restarting.
-  html: string | (() => string | Promise<string>);
-  // Looks up the HeadModel for a request path; return undefined to serve the base
-  // shell untouched (no injection) for an unmapped route.
-  resolve: (path: string) => HeadModel | undefined;
-  // Strip the base <title>/<meta name="description"> out of the shell before
-  // injecting the route's own (default true) — otherwise the shell's baseline
-  // title/description would sit alongside the injected ones.
-  stripBase?: boolean;
-}
-
-// Builds a Hono handler that serves `opts.html` with a per-route HeadModel spliced
-// into <head> via cwip's `injectHead`/`renderHead` — a pure string transform, so it
-// runs anywhere Bun does (this repo's Hono/Bun.serve host). An HTMLRewriter-based
-// streaming variant for Cloudflare Workers/Pages Functions can reuse the exact same
-// `renderHead` output later; that seam is intentionally left for a future target
-// rather than built here (see seo-reusable-plan.md §4/§6).
-export const serveHeadInjectedIndex = (opts: ServeHeadInjectedIndexOptions) => {
-  const stripBase = opts.stripBase ?? true;
-
-  return async (c: Context) => {
-    const html = typeof opts.html === 'function' ? await opts.html() : opts.html;
-    const model = opts.resolve(c.req.path);
-    if (!model) return c.html(html);
-
-    const shell = stripBase ? stripBaseTitleAndDescription(html) : html;
-    const headHtml = renderHead(model, { marker: true, indent: '    ' });
-    return c.html(injectHead(shell, headHtml));
-  };
-};