cursedbelt 2.8.0 → 3.0.0

package/src/react/studios/studioRoutes.spec.ts

@@ -1,156 +0,0 @@
-/**
- * manifest-fidelity-allow: client-router boundary unit (06 §4) — `buildStudioRoutes`
- * reads only `manifest.instances`, so a minimal hand-built manifest is the correct
- * isolation; the pipeline that derives instances is exercised by the verify runtime
- * suites, not here.
- */
-import { describe, expect, it } from 'bun:test';
-import type { EngineId } from '../../config/appConfig';
-import type { ViewLoader } from '../../client/router';
-import type { EffectiveManifest } from '../../verify/types';
-import { DevStudioView } from './BoundEngineShells';
-import { AssetStudioView, KnowledgeStudioView } from './BoundStudios';
-import { ENGINE_CATALOG } from '../../verify/engines';
-import { buildStudioRoutes, STUDIO_VIEW_IDS, studioSupportsView, studioViewComponent } from './studioRoutes';
-import { STUDIO_VIEW_COMPONENT } from './viewIds';
-
-// buildClientRoutes only reads `manifest.instances`, so a minimal manifest is enough.
-const manifest = (instances: unknown[]): EffectiveManifest =>
-  ({ instances } as unknown as EffectiveManifest);
-
-const route = (path: string, view: string, aliases: string[] = []) => ({ path, view, aliases });
-
-// A loader that records nothing — we only assert routing structure, not lazy chunks.
-const lazyView: ViewLoader = () => () => Promise.resolve({ default: () => null });
-
-describe('STUDIO_VIEW_IDS', () => {
-  it('names only view ids that exist in the engine catalog', () => {
-    // The failure this prevents: a shell claiming a view id no config can ever
-    // declare, which reads as coverage while backing nothing (and makes the
-    // generator emit a bound import for a route that never materializes).
-    for (const [engine, views] of Object.entries(STUDIO_VIEW_IDS)) {
-      const descriptor = ENGINE_CATALOG.find((candidate) => candidate.id === engine);
-      expect(descriptor).toBeDefined();
-      const catalogIds = descriptor?.views.map((view) => view.id) ?? [];
-      for (const view of views) expect(catalogIds).toContain(view);
-    }
-  });
-});
-
-describe('STUDIO_VIEW_COMPONENT', () => {
-  it('names a real export of the studios barrel for every engine with views', async () => {
-    // The generator emits `export { <name> as default } from "cursedbelt/react/studios"`
-    // from this map. A name that is not exported is a generated app that fails to
-    // build — so the map is asserted against the barrel itself, not against a copy.
-    const barrel = (await import('./index')) as Record<string, unknown>;
-    for (const engine of Object.keys(STUDIO_VIEW_IDS)) {
-      const component = STUDIO_VIEW_COMPONENT[engine];
-      expect(component).toBeDefined();
-      expect(typeof barrel[component as string]).toBe('function');
-    }
-  });
-});
-
-describe('studioSupportsView', () => {
-  it('knows the view ids each studio implements', () => {
-    expect(studioSupportsView('asset', 'gallery')).toBe(true);
-    expect(studioSupportsView('asset', 'file-browser')).toBe(true);
-    expect(studioSupportsView('knowledge', 'notes')).toBe(true);
-    expect(studioSupportsView('dev', 'fleet')).toBe(true);
-    expect(studioSupportsView('guard', 'secrets')).toBe(true);
-    expect(studioSupportsView('system', 'utilities')).toBe(true);
-  });
-  it('rejects views whose shell does not exist yet', () => {
-    expect(studioSupportsView('asset', 'nope')).toBe(false);
-    // `guard/account` LEFT this list in 02 §5 — its routes landed, so the shell
-    // backs it and the generator emits the bound view instead of a placeholder.
-    expect(studioSupportsView('guard', 'account')).toBe(true);
-  });
-
-  it('backs EVERY view the engine catalog declares (03 §1e, second half)', () => {
-    // The claim the arc has been walking toward: no catalog view renders a
-    // placeholder any more. The five DEV views were the last holdouts, and their
-    // gap was a SERVER one — `dev.mixin.ts` now mounts a feature-gated read
-    // behind each, so a shell is an affordance that works rather than a 404.
-    //
-    // Asserted over the CATALOG rather than a literal list, so a NEW view added
-    // to an engine descriptor fails here until something backs it. That is the
-    // point: the previous shape of this test named the gap, which meant a sixth
-    // unbacked view would have been invisible.
-    const unbacked: string[] = [];
-    for (const descriptor of ENGINE_CATALOG)
-      for (const view of descriptor.views)
-        if (!studioSupportsView(descriptor.id as EngineId, view.id))
-          unbacked.push(`${descriptor.id}/${view.id}`);
-    expect(unbacked).toEqual([]);
-  });
-
-  it('backs the five DEV views (03 §1e, second half)', () => {
-    for (const view of ['app-detail', 'docs', 'pipelines', 'screenshots', 'orchestration'])
-      expect(studioSupportsView('dev', view)).toBe(true);
-  });
-
-  it('backs every vertical whose server side is complete (03 §1b)', () => {
-    // The reachability claim, as data: each of these has a repository, a
-    // service, a feature-gated route block AND now a view. A regression here is
-    // a vertical that silently went back to rendering a placeholder div.
-    for (const view of ['kanban', 'lists', 'contacts', 'family-tree', 'oral-history'])
-      expect(studioSupportsView('knowledge', view)).toBe(true);
-    for (const view of ['time-off', 'budgets', 'subscriptions'])
-      expect(studioSupportsView('system', view)).toBe(true);
-  });
-
-  it('backs the six detail surfaces whose far side exists (03 §1e)', () => {
-    // asset: `video-detail` rides the NEW `GET /api/asset/items/:id`;
-    // `video-editor`/`image-studio` ride the landed upload + the browser tiers
-    // the views themselves declare (`ffmpeg.wasm`, `wasm-imaging`).
-    for (const view of ['video-detail', 'video-editor', 'image-studio'])
-      expect(studioSupportsView('asset', view)).toBe(true);
-    // knowledge: `note` rides the entity route's full projection, `conversation`
-    // rides `/api/knowledge/search`, `text-compare` needs no route at all.
-    for (const view of ['note', 'conversation', 'text-compare'])
-      expect(studioSupportsView('knowledge', view)).toBe(true);
-  });
-});
-
-describe('studioViewComponent', () => {
-  it('maps a supported view to its BOUND view component, else null', () => {
-    // The bound view, not the bare shell: it resolves its own instance and rows,
-    // which is what lets a generated view module be a one-line re-export.
-    expect(studioViewComponent('asset', 'gallery')).toBe(AssetStudioView as never);
-    expect(studioViewComponent('knowledge', 'notes')).toBe(KnowledgeStudioView as never);
-    expect(studioViewComponent('dev', 'apps')).toBe(DevStudioView as never);
-    expect(studioViewComponent('asset', 'nope')).toBeNull();
-    expect(studioViewComponent('guard' as EngineId, 'lock')).toBeNull();
-  });
-});
-
-describe('buildStudioRoutes', () => {
-  it('builds the SPA table and flags routes no studio implements', () => {
-    const m = manifest([
-      { id: 'gal', engine: 'asset', routes: [route('/gallery', 'gallery')] },
-      { id: 'notes', engine: 'knowledge', routes: [route('/notes', 'notes', ['/n'])] },
-      { id: 'custom', engine: 'asset', routes: [route('/x', 'bespoke')] },
-    ]);
-    const { routes, unsupported } = buildStudioRoutes(m, lazyView);
-
-    // The known views + the alias all land in the table.
-    expect(routes.map((r) => r.path).sort()).toEqual(['/gallery', '/n', '/notes', '/x']);
-    // The alias redirects to its canonical path.
-    expect(routes.find((r) => r.path === '/n')?.redirectTo).toBe('/notes');
-
-    // Only the bespoke view is unsupported — reported, never silently dropped.
-    expect(unsupported).toHaveLength(1);
-    expect(unsupported[0]).toMatchObject({ instanceId: 'custom', view: 'bespoke', path: '/x' });
-  });
-
-  it('surfaces cross-instance path collisions from buildClientRoutes', () => {
-    const m = manifest([
-      { id: 'a', engine: 'asset', routes: [route('/dupe', 'gallery')] },
-      { id: 'b', engine: 'knowledge', routes: [route('/dupe', 'notes')] },
-    ]);
-    const { collisions } = buildStudioRoutes(m, lazyView);
-    expect(collisions).toHaveLength(1);
-    expect(collisions[0]?.path).toBe('/dupe');
-  });
-});

package/src/react/studios/studioRoutes.ts

@@ -1,99 +0,0 @@
-// The binding between the studio shells and the compiled SPA route table (03 §3/§5).
-// `buildClientRoutes` (client/router) turns an EffectiveManifest's `instances[].routes`
-// into the lazy CCRoute table; a view id in a route declaration must resolve to a real
-// view component. These helpers name the view ids the studio shells implement and let an
-// app wire them into the router in one call, while surfacing any route that points at a
-// view no studio provides (the client mirror of V1 `dangling-view-reference`).
-//
-// **`STUDIO_VIEW_IDS` is the ONE source of truth for "does a shell back this view".**
-// The app generator imports it to decide whether a view module re-exports a bound
-// studio or emits a loud placeholder; it used to keep its own `STUDIO_BACKED_VIEWS`
-// copy, which is precisely the pairing that rots — a generator claiming a view is
-// backed emits an import of a component that does not exist, and one claiming it is
-// not emits a placeholder over a shell that does.
-//
-// Every id here is a view id from the engine catalog (`verify/engines.ts`); a name that
-// is not in that catalog can never appear in a verified config, so listing one would be
-// dead weight that reads as coverage.
-
-import type { ComponentType } from 'react';
-import { buildClientRoutes } from '../../client/router';
-import type { BuiltRoutes, ViewLoader } from '../../client/router';
-import type { EngineId } from '../../config/appConfig';
-import type { EffectiveManifest } from '../../verify/types';
-import { DevStudioView, GuardEngineView, SystemUtilityView } from './BoundEngineShells';
-import { AssetStudioView, KnowledgeStudioView } from './BoundStudios';
-import { STUDIO_VIEW_IDS, studioBacksView } from './viewIds';
-
-/**
- * Re-exported from the PURE table (`viewIds.ts`) so a client importing the
- * studios barrel and a generator importing `cursedbelt/react/studios/view-ids`
- * read the same list — see that file for why the split exists and which views
- * are deliberately unbacked.
- */
-export { STUDIO_VIEW_IDS };
-
-/**
- * The component backing every view id of an engine that has a studio — the BOUND
- * view, not the bare presentation shell: it resolves its own instance from the route
- * and its own rows through `useEngineResource`, which is what lets a generated view
- * module stay a one-line re-export (04 §5b).
- */
-const STUDIO_COMPONENTS: Partial<Record<EngineId, ComponentType<never>>> = {
-  asset: AssetStudioView as ComponentType<never>,
-  knowledge: KnowledgeStudioView as ComponentType<never>,
-  dev: DevStudioView as ComponentType<never>,
-  guard: GuardEngineView as ComponentType<never>,
-  system: SystemUtilityView as ComponentType<never>,
-};
-
-/** True iff a studio shell implements `view` for `engine`. */
-export function studioSupportsView(engine: EngineId, view: string): boolean {
-  return studioBacksView(engine, view);
-}
-
-/**
- * The component that renders `engine`/`view`, or `null` when no studio provides it.
- * It takes no props — it binds itself (04 §5b) — so a router loader can hand it
- * straight to `React.lazy`.
- */
-export function studioViewComponent(engine: EngineId, view: string): ComponentType<never> | null {
-  if (!studioSupportsView(engine, view)) return null;
-  return STUDIO_COMPONENTS[engine] ?? null;
-}
-
-export interface StudioRoutes extends BuiltRoutes {
-  /**
-   * Manifest routes whose `(engine, view)` no studio shell implements. Never silently
-   * dropped — the app decides whether to treat them as its own custom views or as the
-   * V1 `dangling-view-reference` error they would be in the pipeline.
-   */
-  unsupported: readonly { instanceId: string; engine: EngineId; view: string; path: string }[];
-}
-
-/**
- * Build the SPA route table for a manifest, binding studio views to their shells.
- *
- * `lazyView` is REQUIRED and app-injected: cursedbelt cannot statically know an app's
- * view import graph, and a dynamic `import(variable)` would defeat the bundler's code
- * splitting (03 §5 / client/router `ViewLoader`). An app that wants the built-in shells
- * passes a loader that resolves through {@link studioViewComponent}; an app with its own
- * views passes its own loader. Either way, every route whose view no studio recognizes is
- * reported in `unsupported`.
- */
-export function buildStudioRoutes(manifest: EffectiveManifest, lazyView: ViewLoader): StudioRoutes {
-  const built = buildClientRoutes({ manifest, lazyView });
-
-  const unsupported: StudioRoutes['unsupported'] = manifest.instances.flatMap((instance) =>
-    instance.routes
-      .filter((route) => !studioSupportsView(instance.engine, route.view))
-      .map((route) => ({
-        instanceId: instance.id,
-        engine: instance.engine,
-        view: route.view,
-        path: route.path,
-      })),
-  );
-
-  return { ...built, unsupported };
-}

package/src/react/studios/systemDataSurfaces.spec.tsx

@@ -1,213 +0,0 @@
-/**
- * The three SystemUtility data surfaces (03 §1b) — time off, budgets and
- * subscriptions.
- *
- * The load-bearing assertion is the FIRST one in each block: a surface exists
- * only when its feature is effective-on. Those routes are mounted at composition
- * time behind the same flag (R-3), so a surface rendered with the feature off is
- * a tab whose every request is a correct 404 — the exact failure the shells'
- * surface-list design exists to prevent.
- *
- * The rest pin the places where a control would advertise an action the server
- * would refuse: a decision on an already-decided request, a cancel on an
- * already-cancelled subscription.
- */
-import { afterEach, describe, expect, test } from 'bun:test';
-import { cleanup, fireEvent, render, screen } from '@testing-library/react';
-import type {
-  BudgetEntryView,
-  BudgetView,
-  SubscriptionView,
-  TimeOffRequestView,
-  TimeOffRequestStatus,
-} from '../../server/mixins/services';
-import { CCPortalProvider } from '../portal/CCPortalProvider';
-import { SystemUtilityShell } from './SystemUtilityShell';
-import { formatCents, parseCents } from './SystemUtilityShell';
-import type {
-  BudgetSurfaceState,
-  StudioInstance,
-  SubscriptionSurfaceState,
-  TimeOffSurfaceState,
-} from './types';
-
-afterEach(cleanup);
-
-const present = (selector: string): boolean => document.querySelector(selector) !== null;
-
-const instance = (effective: Record<string, boolean>): StudioInstance => ({
-  id: 'sys-main',
-  engine: 'system',
-  effective,
-  effectiveFeaturesHash: `h-${Object.keys(effective).join('-')}`,
-});
-
-const renderShell = (
-  effective: Record<string, boolean>,
-  view: string,
-  state: Partial<{
-    timeOff: TimeOffSurfaceState;
-    budgets: BudgetSurfaceState;
-    subscriptions: SubscriptionSurfaceState;
-  }>,
-) =>
-  render(
-    <CCPortalProvider>
-      <SystemUtilityShell instance={instance(effective)} claims={null} view={view} {...state} />
-    </CCPortalProvider>,
-  );
-
-/* ------------------------------------------------------------- time off */
-
-const request = (id: string, status: TimeOffRequestStatus): TimeOffRequestView => ({
-  id,
-  userId: 'u_1',
-  startsOn: '2026-08-01',
-  endsOn: '2026-08-01',
-  days: 1,
-  status,
-  createdAt: '2026-07-01T00:00:00.000Z',
-});
-
-const timeOffState = (over: Partial<TimeOffSurfaceState> = {}): TimeOffSurfaceState => ({
-  policies: [{ id: 'pol_1', title: 'Annual', accrualDays: 25 }],
-  requests: [request('req_1', 'pending'), request('req_2', 'approved')],
-  ledger: [{ id: 'led_1', userId: 'u_1', deltaDays: -1, reason: 'approved', at: '2026-07-02T00:00:00.000Z' }],
-  balance: 24,
-  ...over,
-});
-
-describe('SystemUtilityShell — time off (03 §1b)', () => {
-  test('the surface does not exist when `timeOff` is off', () => {
-    renderShell({ notifications: true }, 'time-off', { timeOff: timeOffState() });
-    expect(present('[data-cc-timeoff]')).toBe(false);
-    expect(present('[data-cc-nav="time-off"]')).toBe(false);
-  });
-
-  test('renders the folded balance, the policies and the requests', () => {
-    renderShell({ timeOff: true }, 'time-off', { timeOff: timeOffState() });
-    expect(document.querySelector('[data-cc-balance]')?.getAttribute('data-cc-balance')).toBe('24');
-    expect(present('[data-cc-policy="pol_1"]')).toBe(true);
-    expect(present('[data-cc-request="req_1"]')).toBe(true);
-    expect(present('[data-cc-ledger]')).toBe(true);
-  });
-
-  test('only a PENDING request offers a decision — the transitions are status-guarded', () => {
-    renderShell({ timeOff: true }, 'time-off', { timeOff: timeOffState({ onDecide: () => {} }) });
-    expect(present('[data-cc-request="req_1"] [data-cc-action="approve"]')).toBe(true);
-    // An approved request has no approve/deny button: the op would be a typed
-    // 404 (the repo's UPDATE is guarded on `status = 'pending'`).
-    expect(present('[data-cc-request="req_2"] [data-cc-action="approve"]')).toBe(false);
-    expect(present('[data-cc-request="req_2"] [data-cc-action="deny"]')).toBe(false);
-  });
-
-  test('approving names the request id and the approve decision', () => {
-    const decisions: [string, string][] = [];
-    renderShell({ timeOff: true }, 'time-off', {
-      timeOff: timeOffState({ onDecide: (id, decision) => decisions.push([id, decision]) }),
-    });
-    fireEvent.click(document.querySelector('[data-cc-request="req_1"] [data-cc-action="approve"]') as Element);
-    expect(decisions).toEqual([['req_1', 'approve']]);
-  });
-});
-
-/* -------------------------------------------------------------- budgets */
-
-const budget = (id: string, title: string, amountCents: number): BudgetView => ({
-  id,
-  title,
-  period: 'monthly',
-  amountCents,
-  currency: 'USD',
-});
-const entry = (id: string, amountCents: number): BudgetEntryView => ({
-  id,
-  budgetId: 'bg_1',
-  occurredOn: '2026-07-10',
-  amountCents,
-});
-
-describe('SystemUtilityShell — budgets (03 §1b)', () => {
-  const state = (over: Partial<BudgetSurfaceState> = {}): BudgetSurfaceState => ({
-    budgets: [budget('bg_1', 'Groceries', 20_000)],
-    activeBudgetId: 'bg_1',
-    entries: [entry('en_1', 5_000), entry('en_2', 2_500)],
-    ...over,
-  });
-
-  test('the surface does not exist when `budgets` is off', () => {
-    renderShell({ notifications: true }, 'budgets', { budgets: state() });
-    expect(present('[data-cc-budgets]')).toBe(false);
-  });
-
-  test('folds spend from the entries it is already showing', () => {
-    renderShell({ budgets: true }, 'budgets', { budgets: state() });
-    // 5000 + 2500 — computed from the rows on screen, so a second `/spend` read
-    // can never disagree with what the user is looking at.
-    expect(document.querySelector('[data-cc-spend]')?.getAttribute('data-cc-spend')).toBe('7500');
-    expect(screen.getByText(/75\.00 USD of 200\.00 USD/)).toBeDefined();
-  });
-
-  test('an entry amount that is not a number writes NOTHING', () => {
-    const created: unknown[] = [];
-    renderShell({ budgets: true }, 'budgets', { budgets: state({ onCreateEntry: (input) => created.push(input) }) });
-    const amount = screen.getByLabelText('Entry amount') as HTMLInputElement;
-    const date = screen.getByLabelText('New entry') as HTMLInputElement;
-    fireEvent.change(amount, { target: { value: 'abc' } });
-    fireEvent.change(date, { target: { value: '2026-07-20' } });
-    fireEvent.keyDown(date, { key: 'Enter' });
-    // Silently booking 0.00 against a budget is worse than doing nothing.
-    expect(created).toEqual([]);
-
-    fireEvent.change(amount, { target: { value: '12.34' } });
-    fireEvent.keyDown(date, { key: 'Enter' });
-    expect(created).toEqual([{ occurredOn: '2026-07-20', amountCents: 1234 }]);
-  });
-
-  test('money is integer cents in both directions', () => {
-    expect(parseCents('12.34')).toBe(1234);
-    expect(parseCents('')).toBe(0);
-    expect(parseCents('nope')).toBeNull();
-    expect(formatCents(1234, 'EUR')).toBe('12.34 EUR');
-  });
-});
-
-/* -------------------------------------------------------- subscriptions */
-
-const subscription = (id: string, title: string, cancelledAt?: string): SubscriptionView => ({
-  id,
-  title,
-  amountCents: 999,
-  currency: 'USD',
-  cadence: 'monthly',
-  ...(cancelledAt ? { cancelledAt } : {}),
-});
-
-describe('SystemUtilityShell — subscriptions (03 §1b)', () => {
-  const state = (over: Partial<SubscriptionSurfaceState> = {}): SubscriptionSurfaceState => ({
-    subscriptions: [subscription('sub_1', 'Streaming'), subscription('sub_2', 'Gym', '2026-06-01T00:00:00.000Z')],
-    includeCancelled: true,
-    ...over,
-  });
-
-  test('the surface does not exist when `subscriptions` is off', () => {
-    renderShell({ notifications: true }, 'subscriptions', { subscriptions: state() });
-    expect(present('[data-cc-subscriptions]')).toBe(false);
-  });
-
-  test('a cancelled subscription offers no cancel — a second cancel is a typed 404', () => {
-    renderShell({ subscriptions: true }, 'subscriptions', { subscriptions: state({ onCancel: () => {} }) });
-    expect(present('[data-cc-subscription="sub_1"] [data-cc-action="cancel-subscription"]')).toBe(true);
-    expect(present('[data-cc-subscription="sub_2"] [data-cc-action="cancel-subscription"]')).toBe(false);
-    expect(document.querySelector('[data-cc-subscription="sub_2"]')?.getAttribute('data-cc-cancelled')).toBe('true');
-  });
-
-  test('cancelling names the subscription id', () => {
-    const cancelled: string[] = [];
-    renderShell({ subscriptions: true }, 'subscriptions', {
-      subscriptions: state({ onCancel: (id) => cancelled.push(id) }),
-    });
-    fireEvent.click(document.querySelector('[data-cc-action="cancel-subscription"]') as Element);
-    expect(cancelled).toEqual(['sub_1']);
-  });
-});