cursedbelt 2.7.0 → 3.0.0

package/src/react/engine-studio/engineStudio.spec.tsx

@@ -1,355 +0,0 @@
-/**
- * The engine studio's rendering contract (03 §3).
- *
- * The kernel spec proves the RULES; this proves they reach the screen. The two
- * assertions that matter are the ones the section's second gate is about:
- * `engine-dependency-missing` appears attached to the `privateMedia` control,
- * and the save button is disabled while it stands — because a builder whose
- * diagnostics live only in a list at the bottom, or whose save button lets you
- * write a config the compiler will reject, has not implemented the gate.
- */
-import { afterEach, describe, expect, test } from 'bun:test';
-import { act, cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react';
-import { createStudioDesign, edit } from '../../studio';
-import { CCPortalProvider } from '../portal/CCPortalProvider';
-import { EngineStudio } from './EngineStudio';
-
-afterEach(cleanup);
-
-const mount = (props: Parameters<typeof EngineStudio>[0]) =>
-  render(
-    <CCPortalProvider>
-      <EngineStudio {...props} />
-    </CCPortalProvider>,
-  );
-
-/** The studio compiles on mount; nothing is asserted until that has landed. */
-const settled = async () => {
-  await waitFor(() => {
-    expect(document.querySelector('[data-cc-diagnostics-verifying]')).toBeNull();
-  });
-};
-
-const node = (id: string) => document.querySelector<HTMLElement>(`[data-cc-engine-node="${id}"]`);
-const saveButton = () => document.querySelector<HTMLButtonElement>('[data-cc-save]');
-const undoButton = () => document.querySelector<HTMLButtonElement>('[data-cc-undo]');
-const redoButton = () => document.querySelector<HTMLButtonElement>('[data-cc-redo]');
-const addAsset = () => document.querySelector<HTMLButtonElement>('[data-cc-palette-engine="asset"]');
-const palette = (engine: string) =>
-  document.querySelector<HTMLButtonElement>(`[data-cc-palette-engine="${engine}"]`);
-const modeButton = (m: 'build' | 'view') => document.querySelector<HTMLButtonElement>(`[data-cc-mode="${m}"]`);
-const studioMode = () => document.querySelector<HTMLElement>('[data-cc-studio-mode]')?.dataset.ccStudioMode;
-
-describe('the canvas renders the document', () => {
-  test('draws a node per instance and a socket per ENABLED port', async () => {
-    mount({ design: edit.addInstance(createStudioDesign({ appId: 'a', engines: ['asset'] }), 'knowledge') });
-    await settled();
-
-    expect(node('asset')).not.toBeNull();
-    expect(node('knowledge')).not.toBeNull();
-    expect(document.querySelector('[data-cc-socket="asset:videos-out"]')).not.toBeNull();
-  });
-
-  test('a port switched off by enabledWhen has no socket to grab', async () => {
-    const design = edit.setFeature(createStudioDesign({ appId: 'a', engines: ['asset'] }), 'asset', 'video', false);
-    mount({ design });
-    await settled();
-
-    expect(document.querySelector('[data-cc-socket="asset:items-in"]')).not.toBeNull();
-    // Fail-closed: the port does not exist, so the canvas cannot offer it.
-    expect(document.querySelector('[data-cc-socket="asset:videos-out"]')).toBeNull();
-  });
-
-  test('draws a wire for each connection', async () => {
-    let design = createStudioDesign({ appId: 'a', engines: ['asset'] });
-    design = edit.addInstance(design, 'asset');
-    design = edit.addConnection(design, 'asset:videos-out', 'asset-2:videos-in');
-    mount({ design });
-    await settled();
-
-    expect(document.querySelector('[data-cc-wire="asset:videos-out→asset-2:videos-in"]')).not.toBeNull();
-  });
-
-  test('marks a broken wire, so the author can find and click it', async () => {
-    const design = edit.addConnection(
-      edit.addInstance(createStudioDesign({ appId: 'a', engines: ['asset'] }), 'asset'),
-      'asset:videos-out',
-      'asset-2:refresh-in', // value → signal: V3 refuses it
-    );
-    mount({ design });
-    await settled();
-
-    await waitFor(() => {
-      expect(document.querySelector('[data-cc-wire-broken]')).not.toBeNull();
-    });
-  });
-
-  test('offers a resize handle on all eight sides and corners', async () => {
-    mount({ design: createStudioDesign({ appId: 'a', engines: ['asset'] }) });
-    await settled();
-    for (const edge of ['n', 's', 'e', 'w', 'ne', 'nw', 'se', 'sw']) {
-      expect(document.querySelector(`[data-cc-node-resize="asset:${edge}"]`)).not.toBeNull();
-    }
-  });
-
-  test('a pointer drag on a handle pins a manual size, and undo restores auto-fit', async () => {
-    mount({ design: createStudioDesign({ appId: 'a', engines: ['asset'] }) });
-    await settled();
-
-    const wrapper = () => node('asset')?.parentElement as HTMLElement;
-    // Auto-fit until touched: the wrapper sizes to content, not a fixed box.
-    expect(wrapper().style.width).toBe('fit-content');
-
-    const handle = document.querySelector<HTMLElement>('[data-cc-node-resize="asset:se"]')!;
-    const canvas = document.querySelector<HTMLElement>('[data-cc-engine-canvas]')!;
-    // Separate flushes: the pointer-down must COMMIT the resize gesture before the
-    // move handler (a fresh render's closure) can read it — one batched act would
-    // dispatch the move against the pre-gesture handler where `resize` is null.
-    await act(async () => void fireEvent.pointerDown(handle, { clientX: 100, clientY: 100 }));
-    await act(async () => void fireEvent.pointerMove(canvas, { clientX: 400, clientY: 300 }));
-    await act(async () => void fireEvent.pointerUp(canvas, { clientX: 400, clientY: 300 }));
-
-    // A manual box is now pinned — an explicit pixel size that wins over the fit.
-    expect(wrapper().style.width).toBe('300px');
-    expect(wrapper().style.height).toBe('200px');
-
-    // The whole gesture is ONE undo step: one undo returns to auto-fit.
-    await act(async () => {
-      fireEvent.click(undoButton()!);
-    });
-    await settled();
-    expect(wrapper().style.width).toBe('fit-content');
-  });
-});
-
-describe('the inspector', () => {
-  test('renders a control per feature key of the selected node', async () => {
-    mount({ design: createStudioDesign({ appId: 'a', engines: ['asset'] }) });
-    await settled();
-    expect(document.querySelector('[data-cc-inspector-empty]')).not.toBeNull();
-
-    act(() => node('asset')?.dispatchEvent(new PointerEvent('pointerdown', { bubbles: true })));
-    await waitFor(() => {
-      expect(document.querySelector('[data-cc-inspector="asset"]')).not.toBeNull();
-    });
-    // Reflected from FeaturesByEngine, not from a hand-written list.
-    expect(screen.getByText('Gallery')).toBeDefined();
-    expect(screen.getByText('Private Media')).toBeDefined();
-    expect(screen.getByText('Image Studio')).toBeDefined();
-  });
-});
-
-describe('GATE — the save gate is visible and enforced in the UI', () => {
-  test('a clean design saves; the button is enabled', async () => {
-    const saved: string[] = [];
-    mount({
-      design: createStudioDesign({ appId: 'clean', engines: ['asset'] }),
-      onSave: (design) => void saved.push(design.config.app.id),
-    });
-    await settled();
-
-    await waitFor(() => {
-      expect(saveButton()?.disabled).toBe(false);
-    });
-    act(() => saveButton()?.click());
-    await waitFor(() => expect(saved).toEqual(['clean']));
-  });
-
-  test('privateMedia without guard disables save and shows the reason in the header', async () => {
-    const design = edit.setFeature(
-      createStudioDesign({ appId: 'leaky', engines: ['asset'] }),
-      'asset',
-      'privateMedia',
-      true,
-    );
-    mount({ design, onSave: () => undefined });
-    await settled();
-
-    await waitFor(() => {
-      expect(saveButton()?.disabled).toBe(true);
-    });
-    const blocked = document.querySelector('[data-cc-save-blocked]');
-    expect(blocked?.textContent).toContain('engine-dependency-missing');
-  });
-
-  test('…and the diagnostic renders ON the privateMedia control, not only in the panel', async () => {
-    const design = edit.setFeature(
-      createStudioDesign({ appId: 'leaky', engines: ['asset'] }),
-      'asset',
-      'privateMedia',
-      true,
-    );
-    mount({ design });
-    await settled();
-
-    act(() => node('asset')?.dispatchEvent(new PointerEvent('pointerdown', { bubbles: true })));
-    await waitFor(() => {
-      expect(document.querySelector('[data-cc-inspector="asset"]')).not.toBeNull();
-    });
-
-    // The message sits inside the same field row as the control it is about —
-    // which is the whole difference between "inline" and "in a list somewhere".
-    const row = document.querySelector('[data-cc-field="privateMedia"]');
-    expect(row).not.toBeNull();
-    expect(row?.textContent).toContain('Private Media');
-    expect(row?.textContent).toContain("requires the 'guard' engine");
-    // …and the actionable half rides with it, so the control's error is at
-    // least as useful as the same error in a terminal.
-    expect(row?.textContent).toContain('Add the required engine to engines[]');
-  });
-
-  test('the node itself carries an error badge', async () => {
-    const design = edit.setFeature(
-      createStudioDesign({ appId: 'leaky', engines: ['asset'] }),
-      'asset',
-      'privateMedia',
-      true,
-    );
-    mount({ design });
-    await settled();
-
-    await waitFor(() => {
-      expect(node('asset')?.dataset.ccNodeErrors).toBe('1');
-    });
-  });
-});
-
-describe('undo / redo', () => {
-  test('the button is disabled until there is an edit, then reverts and reapplies it', async () => {
-    mount({ design: createStudioDesign({ appId: 'a', engines: ['asset'] }) });
-    await settled();
-    expect(undoButton()?.disabled).toBe(true);
-    expect(redoButton()?.disabled).toBe(true);
-
-    act(() => addAsset()?.click());
-    await waitFor(() => expect(node('asset-2')).not.toBeNull());
-    await settled();
-    expect(undoButton()?.disabled).toBe(false);
-
-    act(() => undoButton()?.click());
-    await waitFor(() => expect(node('asset-2')).toBeNull());
-    expect(redoButton()?.disabled).toBe(false);
-
-    act(() => redoButton()?.click());
-    await waitFor(() => expect(node('asset-2')).not.toBeNull());
-  });
-
-  test('cmd-Z undoes from the canvas — but never while a text field is focused', async () => {
-    mount({ design: createStudioDesign({ appId: 'a', engines: ['asset'] }) });
-    await settled();
-    act(() => addAsset()?.click());
-    await waitFor(() => expect(node('asset-2')).not.toBeNull());
-    await settled();
-
-    // Focus in a text input: the studio must NOT hijack the browser's own undo.
-    const input = document.createElement('input');
-    document.body.appendChild(input);
-    input.focus();
-    act(() => {
-      input.dispatchEvent(new KeyboardEvent('keydown', { key: 'z', metaKey: true, bubbles: true }));
-    });
-    expect(node('asset-2')).not.toBeNull();
-    input.remove();
-
-    // Focus outside any text field: cmd-Z now drives the studio undo.
-    act(() => {
-      document.dispatchEvent(new KeyboardEvent('keydown', { key: 'z', metaKey: true, bubbles: true }));
-    });
-    await waitFor(() => expect(node('asset-2')).toBeNull());
-
-    // shift-cmd-Z (key reports uppercase 'Z') redoes.
-    act(() => {
-      document.dispatchEvent(new KeyboardEvent('keydown', { key: 'Z', metaKey: true, shiftKey: true, bubbles: true }));
-    });
-    await waitFor(() => expect(node('asset-2')).not.toBeNull());
-  });
-});
-
-describe('Build vs View mode', () => {
-  test('starts in Build mode, where a palette click ADDS a second node', async () => {
-    mount({ design: createStudioDesign({ appId: 'a', engines: ['asset'] }) });
-    await settled();
-    expect(studioMode()).toBe('build');
-
-    act(() => addAsset()?.click());
-    await waitFor(() => expect(node('asset-2')).not.toBeNull());
-    // The original is still there — additive, not a replace.
-    expect(node('asset')).not.toBeNull();
-  });
-
-  test('switching to View makes the active mode obvious on the surface', async () => {
-    mount({ design: createStudioDesign({ appId: 'a', engines: ['asset'] }) });
-    await settled();
-
-    act(() => modeButton('view')?.click());
-    await waitFor(() => expect(studioMode()).toBe('view'));
-    // The active toggle marks itself, so the mode is never a guess.
-    expect(modeButton('view')?.dataset.ccModeActive).toBe('');
-    expect(modeButton('build')?.dataset.ccModeActive).toBeUndefined();
-  });
-
-  test('in View mode a palette click REPLACES the node on the canvas', async () => {
-    mount({ design: createStudioDesign({ appId: 'a', engines: ['asset'] }) });
-    await settled();
-
-    act(() => modeButton('view')?.click());
-    await waitFor(() => expect(studioMode()).toBe('view'));
-
-    // One asset on the canvas; picking knowledge swaps it in place.
-    act(() => palette('knowledge')?.click());
-    await waitFor(() => expect(node('knowledge')).not.toBeNull());
-    // The old node is GONE — replaced, not added alongside.
-    expect(node('asset')).toBeNull();
-  });
-
-  test('the View swap is a single undo step', async () => {
-    mount({ design: createStudioDesign({ appId: 'a', engines: ['asset'] }) });
-    await settled();
-    act(() => modeButton('view')?.click());
-    await waitFor(() => expect(studioMode()).toBe('view'));
-
-    act(() => palette('knowledge')?.click());
-    await waitFor(() => expect(node('knowledge')).not.toBeNull());
-    await settled();
-
-    // One undo restores the original asset and removes the knowledge node.
-    act(() => undoButton()?.click());
-    await waitFor(() => expect(node('asset')).not.toBeNull());
-    expect(node('knowledge')).toBeNull();
-  });
-});
-
-describe('the diagnostics panel', () => {
-  test('lists warnings that do NOT block the save', async () => {
-    mount({ design: createStudioDesign({ appId: 'a', engines: ['asset'] }), onSave: () => undefined });
-    await settled();
-
-    // `capability-downgrade` with no ffmpeg probed: worth telling the author,
-    // never a reason to refuse the save.
-    await waitFor(() => {
-      expect(document.querySelector('[data-cc-diagnostic="capability-downgrade"]')).not.toBeNull();
-    });
-    expect(saveButton()?.disabled).toBe(false);
-  });
-
-  test('says so plainly when there is nothing to report', async () => {
-    mount({ design: createStudioDesign({ appId: 'a' }) });
-    await settled();
-    expect(document.querySelector('[data-cc-diagnostics-clean]')).not.toBeNull();
-  });
-
-  test('surfaces a compiler failure instead of reading as clean', async () => {
-    mount({
-      design: createStudioDesign({ appId: 'a' }),
-      verify: async () => {
-        throw new Error('harvester exploded');
-      },
-      onSave: () => undefined,
-    });
-    await settled();
-
-    expect(document.querySelector('[data-cc-diagnostics-failure]')?.textContent).toContain('harvester exploded');
-    // A pipeline we could not run has approved nothing.
-    expect(saveButton()?.disabled).toBe(true);
-  });
-});

package/src/react/engine-studio/index.ts

@@ -1,14 +0,0 @@
-/**
- * `cursedbelt/react/engine-studio` — the visual builder on the engine model
- * (03 §3). A thin rendering of `cursedbelt/studio`; every rule lives there.
- */
-export { DiagnosticsPanel, type DiagnosticsPanelProps } from './DiagnosticsPanel';
-export { EngineCanvas, type EngineCanvasProps } from './EngineCanvas';
-export { EngineInspector, type EngineInspectorProps } from './EngineInspector';
-export {
-  EngineStudio,
-  type EngineStudioProps,
-  EngineStudioView,
-  type EngineStudioViewProps,
-} from './EngineStudio';
-export { useStudioSession, type UseStudioSession } from './useStudioSession';

package/src/react/engine-studio/useStudioSession.ts

@@ -1,71 +0,0 @@
-/**
- * React binding for the studio kernel's session (03 §3).
- *
- * The session is a plain external store, so this is `useSyncExternalStore` and
- * nothing else — no effect that mirrors session state into React state. That
- * matters: a mirroring effect renders once with the OLD verification after every
- * edit, which on this surface means the diagnostics panel flickers back to the
- * error you just fixed for one frame. Subscribing directly means React never
- * sees an intermediate.
- *
- * The session is created ONCE per mount and disposed on unmount. Changing the
- * verify options after mount is deliberately not supported: capabilities are a
- * property of the host, and swapping them mid-session would silently invalidate
- * every diagnostic on screen without a re-verify.
- */
-import { useCallback, useMemo, useRef, useSyncExternalStore } from 'react';
-import type { SaveDisposition, StudioDesign, StudioEdit, StudioSessionOptions, StudioSessionState } from '../../studio';
-import { createStudioSession } from '../../studio';
-
-export interface UseStudioSession {
-  state: StudioSessionState;
-  design: StudioDesign;
-  apply: (edit: StudioEdit, tag?: string | null) => void;
-  /** Restore the design before the last edit. Reflected reactively through
-   *  `state.canUndo` so a button can disable itself. */
-  undo: () => void;
-  redo: () => void;
-  reset: (design: StudioDesign) => void;
-  /** Resolves with the verification of the design current when it was called. */
-  settled: () => Promise<StudioSessionState['verification']>;
-  disposition: SaveDisposition;
-}
-
-export function useStudioSession(options: StudioSessionOptions): UseStudioSession {
-  // The options object is re-created on every render by most callers; capturing
-  // it in a ref keeps the session stable without asking every caller to memoize.
-  const optionsRef = useRef(options);
-  optionsRef.current = options;
-
-  const session = useMemo(
-    () => createStudioSession(optionsRef.current),
-    // Intentionally mount-only — see the module docstring.
-    [],
-  );
-
-  const subscribe = useCallback(
-    (onChange: () => void) => {
-      const unsubscribe = session.subscribe(onChange);
-      return () => {
-        unsubscribe();
-        // The last consumer to unsubscribe owns teardown: a session that keeps
-        // compiling after its canvas unmounted is a leak with a CPU cost.
-        session.dispose();
-      };
-    },
-    [session],
-  );
-
-  const state = useSyncExternalStore(subscribe, session.getState, session.getState);
-
-  return {
-    state,
-    design: state.design,
-    apply: useCallback((edit: StudioEdit, tag?: string | null) => void session.apply(edit, tag), [session]),
-    undo: useCallback(() => void session.undo(), [session]),
-    redo: useCallback(() => void session.redo(), [session]),
-    reset: useCallback((design: StudioDesign) => void session.reset(design), [session]),
-    settled: useCallback(async () => (await session.settled()) ?? null, [session]),
-    disposition: session.disposition(),
-  };
-}

package/src/react/media/fileUploadClient.spec.ts

@@ -1,132 +0,0 @@
-import { Database } from 'bun:sqlite';
-import { afterAll, beforeAll, describe, expect, test } from 'bun:test';
-import { mkdtemp, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
-import { Hono } from 'hono';
-import { MAX_SINGLE_UPLOAD_BYTES } from '../../core/media/uploadLimits';
-import { runMigrations } from '../../server/migration/runner';
-import { generateUserSalt } from '../../server/private-media/crypto';
-import { createUnlockService } from '../../server/private-media/unlock';
-import { createDiskStore } from '../../server/storage/diskStore';
-import { createSqliteFileCatalogue } from '../../server/storage/files/catalogue';
-import { mountFileRoutes, SINGLE_UPLOAD_TOO_LARGE } from '../../server/storage/files/fileRoutes';
-import { FILE_CATALOGUE_MIGRATIONS } from '../../server/storage/files/migrations';
-import { createStreamTokenService } from '../../server/storage/streamToken';
-import type { MediaCtx } from '../../server/storage/types';
-import { createFileUploadClient } from './fileUploadClient';
-
-// Drives the REAL mountFileRoutes edge — the client and the routes share one header
-// protocol (X-Filename/X-Tags/X-Unlock-Token), so the round-trip is the contract.
-
-const CTX: MediaCtx = { userId: 'u1', tenantId: 't1' };
-const unlock = createUnlockService({ serverSecret: 'srv', unlockSecret: 'unl' });
-const salt = generateUserSalt();
-
-describe('createFileUploadClient ⇄ mountFileRoutes', () => {
-  let db: Database;
-  let root: string;
-  const app = new Hono();
-  const client = createFileUploadClient({
-    authHeaders: () => ({ Authorization: 'Bearer test' }),
-    fetchImpl: ((input: RequestInfo | URL, init?: RequestInit) =>
-      app.request(input as string, init)) as typeof fetch,
-  });
-
-  beforeAll(async () => {
-    db = new Database(':memory:');
-    runMigrations(db, FILE_CATALOGUE_MIGRATIONS);
-    root = await mkdtemp(path.join(tmpdir(), 'fuc-'));
-    const catalogue = createSqliteFileCatalogue({
-      db,
-      store: createDiskStore(root),
-      workDir: path.join(root, 'w'),
-      owner: (c) => c.userId,
-    });
-    mountFileRoutes(app, {
-      store: createDiskStore(root),
-      token: createStreamTokenService({ secret: 's' }),
-      catalogue,
-      authorizeUpload: () => CTX,
-      privateUpload: {
-        unlock,
-        authorize: async () => ({ userId: CTX.userId, userSalt: salt }),
-      },
-    });
-  });
-  afterAll(async () => {
-    db.close();
-    await rm(root, { recursive: true, force: true });
-  });
-
-  let uploadedId = '';
-
-  test('upload carries filename + tags through to the catalogue row', async () => {
-    const res = await client.upload(new File(['hello'], 'notes.txt', { type: 'text/plain' }), {
-      tags: ['a', 'b'],
-    });
-    expect(res.ok).toBe(true);
-    if (!res.ok) return;
-    expect(res.file?.name).toBe('notes.txt');
-    expect(res.file?.tags).toEqual(['a', 'b']);
-    uploadedId = res.file?.id ?? '';
-  });
-
-  test('replace overwrites bytes under the same id', async () => {
-    const res = await client.replace(uploadedId, new Blob(['replaced'], { type: 'text/plain' }), {
-      name: 'notes-v2.txt',
-    });
-    expect(res.ok).toBe(true);
-    if (!res.ok) return;
-    expect(res.file?.id).toBe(uploadedId);
-    expect(res.file?.name).toBe('notes-v2.txt');
-    expect(res.file?.size).toBe('replaced'.length);
-  });
-
-  test('uploadPrivate with an unlock token lands an encrypted item', async () => {
-    const { token } = await unlock.unlock({ userId: CTX.userId, userSalt: salt, password: 'pw' });
-    const res = await client.uploadPrivate(
-      new File(['secret-bytes'], 'secret.jpg', { type: 'image/jpeg' }),
-      { unlockToken: token, tags: ['hidden'] },
-    );
-    expect(res.ok).toBe(true);
-    if (!res.ok) return;
-    expect(res.file?.processingStatus).toBe('ready'); // image blob path — no ffmpeg
-  });
-
-  test('uploadAuto falls back to the streamed PUT when chunked is unwired (404 init)', async () => {
-    const big = new File([new Uint8Array(9 * 1024 * 1024)], 'big.bin', {
-      type: 'application/octet-stream',
-    });
-    const res = await client.uploadAuto(big);
-    expect(res.ok).toBe(true);
-    if (!res.ok) return;
-    expect(res.file?.size).toBe(big.size);
-  });
-
-  test('uploadAuto surfaces a single-request-cap 413 as a hard ok:false error', async () => {
-    // Chunked is unwired (404 init) so uploadAuto falls back to the single PUT; a file over
-    // MAX_SINGLE_UPLOAD_BYTES must come back ok:false with the server's clear message — not a
-    // silent failure. (The guard fails fast on Content-Length, so no giant disk write.)
-    const tooBig = new File([new Uint8Array(MAX_SINGLE_UPLOAD_BYTES + 1024)], 'huge.bin', {
-      type: 'application/octet-stream',
-    });
-    const res = await client.uploadAuto(tooBig);
-    expect(res.ok).toBe(false);
-    if (res.ok) return;
-    expect(res.error).toBe(SINGLE_UPLOAD_TOO_LARGE);
-  });
-
-  test('an unauthenticated client is rejected', async () => {
-    const anon = createFileUploadClient({
-      authHeaders: () => ({}),
-      fetchImpl: ((_input: RequestInfo | URL, init?: RequestInit) => {
-        // Simulate the guard rejecting a missing session: the route's authorizeUpload above
-        // always allows, so drive a route that doesn't exist to prove errors surface cleanly.
-        return app.request('/_files/upload-nope', init);
-      }) as typeof fetch,
-    });
-    const res = await anon.upload(new File(['x'], 'x.txt', { type: 'text/plain' }));
-    expect(res.ok).toBe(false);
-  });
-});

package/src/react/router/CCRouteFallback.tsx

@@ -1,97 +0,0 @@
-/**
- * `CCRouteFallback` (03 §4) — the reason an unresolvable locator never
- * white-screens.
- *
- * Three failure modes reach here and they are deliberately NOT collapsed into
- * one "not found" page, because the useful action differs:
- *
- * - `unknown-route` — the app has no route for this locator. Offer re-route.
- * - `entity-missing` — the route exists, the row is gone (deleted, or never
- *   existed). Offer to create the target.
- * - `unauthorized` — the entity belongs to another tenant (J3-2). This copy must
- *   NOT confirm the entity exists; the server already returns a typed 404 for
- *   the same reason, and a fallback reading "you don't have access to note_9"
- *   would leak exactly what the 404 was protecting.
- */
-import { AlertTriangle, Home, Plus, Search } from 'lucide-react';
-import type { ReactNode } from 'react';
-import type { LocatorFailure } from '../../client/router';
-import { Button } from '../components/Button';
-import { EmptyState } from '../components/EmptyState';
-
-export interface CCRouteFallbackProps {
-  reason: LocatorFailure;
-  /** The locator that failed, when navigation came through `cc://` or `/go/`. */
-  locator?: string;
-  onGoHome?: () => void;
-  /** Offered for `unknown-route` — open the app's navigation/search. */
-  onReRoute?: () => void;
-  /** Offered for `entity-missing` — create the thing the link pointed at. */
-  onCreateTarget?: () => void;
-  children?: ReactNode;
-}
-
-interface FallbackCopy {
-  title: string;
-  body: string;
-}
-
-const COPY: Readonly<Record<LocatorFailure, FallbackCopy>> = {
-  'unknown-route': {
-    title: 'That link does not lead anywhere here',
-    body: 'This app has no view for that address. It may belong to a different app, or the feature that owned it is turned off.',
-  },
-  'entity-missing': {
-    title: 'That item no longer exists',
-    body: 'The link is valid but the item it points to has been deleted or was never created.',
-  },
-  // Deliberately indistinguishable from "does not exist" — see the module note.
-  unauthorized: {
-    title: 'That item is not available',
-    body: 'The link could not be opened with your current account.',
-  },
-};
-
-export function CCRouteFallback({
-  reason,
-  locator,
-  onGoHome,
-  onReRoute,
-  onCreateTarget,
-  children,
-}: CCRouteFallbackProps) {
-  const copy = COPY[reason];
-
-  return (
-    <div data-cc-fallback={reason} className='flex min-w-0 flex-col'>
-      <EmptyState
-        fill
-        icon={<AlertTriangle aria-hidden />}
-        title={copy.title}
-        // The locator is echoed only for the two non-sensitive reasons; showing
-        // it on `unauthorized` would confirm the id a caller guessed.
-        description={reason === 'unauthorized' || !locator ? copy.body : `${copy.body} (${locator})`}
-        action={
-          <div className='flex flex-wrap items-center justify-center gap-2'>
-            {onGoHome && (
-              <Button variant='secondary' tooltip='Return to the app home view' onClick={onGoHome}>
-                <Home aria-hidden /> Go home
-              </Button>
-            )}
-            {reason === 'unknown-route' && onReRoute && (
-              <Button variant='tertiary' tooltip='Search for the right place to go' onClick={onReRoute}>
-                <Search aria-hidden /> Find it
-              </Button>
-            )}
-            {reason === 'entity-missing' && onCreateTarget && (
-              <Button variant='primary' tooltip='Create the item this link points at' onClick={onCreateTarget}>
-                <Plus aria-hidden /> Create it
-              </Button>
-            )}
-          </div>
-        }
-      />
-      {children}
-    </div>
-  );
-}