cursedbelt 2.7.0 → 3.0.0

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

@@ -1,200 +0,0 @@
-/**
- * The 04 §5c–§5e gates for the three new studio shells.
- *
- * The load-bearing one is the FIRST: without `infra:write`, the configEditor and
- * dbAdmin surfaces must be ABSENT from the rendered tree — not disabled, not
- * hidden with CSS, not routable-if-you-guess-the-view-id. It is the client twin
- * of the `infra-privilege-gate` fixture, and it is asserted three ways (nav gone,
- * panel gone, direct view request refused) because each is a separate way to get
- * the omission wrong.
- */
-import { afterEach, describe, expect, test } from 'bun:test';
-import { cleanup, render, screen } from '@testing-library/react';
-import type { CCUserClaims } from '../../core/session/claims';
-import { CCPortalProvider } from '../portal/CCPortalProvider';
-import { DevStudioShell } from './DevStudioShell';
-import { GuardEngineShell } from './GuardEngineShell';
-import { SystemUtilityShell } from './SystemUtilityShell';
-import type { StudioInstance } from './types';
-
-// Without this the document accumulates every previous render — and a
-// `querySelector` assertion then reads another test's tree (and, when it fails,
-// prints a multi-megabyte happy-dom dump).
-afterEach(cleanup);
-
-/** Presence as a BOOLEAN: a failing element assertion must not serialize the DOM. */
-const present = (selector: string): boolean => document.querySelector(selector) !== null;
-
-const claims = (permissions: readonly string[]): CCUserClaims => ({
-  tenantId: 't_local',
-  userId: 'u_local',
-  role: 'OWNER',
-  permissions: [...permissions],
-  privateScope: false,
-  jti: 'j1',
-  exp: Math.floor(Date.now() / 1000) + 600,
-});
-
-const instance = (engine: StudioInstance['engine'], effective: Record<string, boolean>): StudioInstance => ({
-  id: `${engine}-1`,
-  engine,
-  title: `${engine} studio`,
-  effective,
-  effectiveFeaturesHash: `hash-${Object.keys(effective).join('-')}`,
-});
-
-const DEV_FEATURES = { appRegistry: true, fleet: true, deploy: true, configEditor: true, dbAdmin: true };
-
-describe('DevStudioShell — privileged-surface omission (04 §5c)', () => {
-  test('WITH infra:write, the config and database surfaces exist', () => {
-    render(
-      <DevStudioShell
-        instance={instance('dev', DEV_FEATURES)}
-        claims={claims(['infra:write'])}
-        view='config-editor'
-        apps={[{ appId: 'a1', title: 'App One', running: true }]}
-      />,
-    );
-
-    expect(present('[data-cc-nav="config-editor"]')).toBe(true);
-    expect(present('[data-cc-nav="db-admin"]')).toBe(true);
-    expect(present('[data-cc-config-editor]')).toBe(true);
-  });
-
-  test('WITHOUT infra:write, both are absent from the tree — and unreachable by view id', () => {
-    render(
-      <DevStudioShell
-        instance={instance('dev', DEV_FEATURES)}
-        claims={claims([])}
-        // A direct link to the privileged view: it must not render the panel.
-        view='config-editor'
-        apps={[{ appId: 'a1', title: 'App One', running: true }]}
-      />,
-    );
-
-    expect(present('[data-cc-nav="config-editor"]')).toBe(false);
-    expect(present('[data-cc-nav="db-admin"]')).toBe(false);
-    expect(present('[data-cc-config-editor]')).toBe(false);
-    expect(present('[data-cc-db-admin]')).toBe(false);
-    // It fell back to the first surface this session MAY see, rather than to a
-    // blank screen.
-    expect(present('[data-cc-surface="apps"]')).toBe(true);
-    expect(screen.getByText('App One')).toBeDefined();
-  });
-
-  test('a feature-off surface is absent even WITH the permission', () => {
-    render(
-      <DevStudioShell
-        instance={instance('dev', { appRegistry: true, configEditor: false, dbAdmin: false })}
-        claims={claims(['infra:write'])}
-        apps={[]}
-      />,
-    );
-    expect(present('[data-cc-nav="config-editor"]')).toBe(false);
-    expect(present('[data-cc-nav="apps"]')).toBe(true);
-  });
-});
-
-describe('SystemUtilityShell (04 §5d)', () => {
-  test('the dashboard is a Slot host: no fill ⇒ an empty state, never a broken grid', () => {
-    render(
-      <SystemUtilityShell
-        instance={instance('system', { dashboard: true })}
-        claims={claims([])}
-        view='dashboard'
-        fills={[]}
-      />,
-    );
-    expect(present('[data-cc-dashboard]')).toBe(true);
-    expect(screen.getByText('No widgets')).toBeDefined();
-  });
-
-  test('the notifications surface renders wire rows and offers exactly the action the server has', () => {
-    render(
-      <SystemUtilityShell
-        instance={instance('system', { notifications: true })}
-        claims={claims([])}
-        view='notifications'
-        notifications={[
-          { id: 'n1', title: 'Disk low', done: false },
-          { id: 'n2', title: 'Old news', done: true },
-        ]}
-      />,
-    );
-    expect(document.querySelector('[data-cc-notification="n1"]')?.getAttribute('data-cc-done')).toBe('false');
-    // The done row offers no "Done" button — the server has no undo for it.
-    expect(document.querySelectorAll('[data-cc-notifications] button').length).toBe(1);
-  });
-
-  test('the utility drawer renders only the tools whose features are on', () => {
-    render(
-      <SystemUtilityShell
-        instance={instance('system', { stopwatch: true, httpClient: false, formatLab: false })}
-        claims={claims([])}
-        view='utilities'
-      />,
-    );
-    expect(present('[data-cc-tool="stopwatch"]')).toBe(true);
-    expect(present('[data-cc-tool="httpClient"]')).toBe(false);
-    expect(present('[data-cc-tool="formatLab"]')).toBe(false);
-  });
-});
-
-describe('GuardEngineShell (04 §5e)', () => {
-  test('locked renders the unlock form; unlocked renders the lock action instead', () => {
-    const { unmount } = render(
-      <CCPortalProvider>
-        <GuardEngineShell
-          instance={instance('guard', { privateMode: true })}
-          claims={claims([])}
-          view='unlock'
-          unlocked={false}
-        />
-      </CCPortalProvider>,
-    );
-    expect(present('[data-cc-vault="locked"]')).toBe(true);
-    unmount();
-
-    render(
-      <CCPortalProvider>
-        <GuardEngineShell
-          instance={instance('guard', { privateMode: true })}
-          claims={claims([])}
-          view='unlock'
-          unlocked
-        />
-      </CCPortalProvider>,
-    );
-    expect(present('[data-cc-vault="unlocked"]')).toBe(true);
-    expect(present('[data-cc-vault="locked"]')).toBe(false);
-  });
-
-  test('the secrets panel needs BOTH its feature and infra:write', () => {
-    render(
-      <CCPortalProvider>
-        <GuardEngineShell
-          instance={instance('guard', { privateMode: true, secretsPanel: true })}
-          claims={claims([])}
-          view='secrets'
-          unlocked
-          secrets={[{ key: 'OPENAI_KEY', updatedAt: '2026-07-24' }]}
-        />
-      </CCPortalProvider>,
-    );
-    expect(present('[data-cc-nav="secrets"]')).toBe(false);
-    expect(present('[data-cc-secret="OPENAI_KEY"]')).toBe(false);
-
-    render(
-      <CCPortalProvider>
-        <GuardEngineShell
-          instance={instance('guard', { privateMode: true, secretsPanel: true })}
-          claims={claims(['infra:write'])}
-          view='secrets'
-          unlocked
-          secrets={[{ key: 'OPENAI_KEY', updatedAt: '2026-07-24' }]}
-        />
-      </CCPortalProvider>,
-    );
-    expect(present('[data-cc-secret="OPENAI_KEY"]')).toBe(true);
-  });
-});

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

@@ -1,70 +0,0 @@
-import { describe, expect, it } from 'bun:test';
-import type { EffectiveFeatureMap } from '../../verify/types';
-import {
-  assetSurfaces,
-  enabledKnowledgeKinds,
-  featureOn,
-  galleryLayoutsOf,
-  knowledgeItemVisible,
-  resolveCatalogueLayout,
-} from './featureGate';
-
-describe('featureOn', () => {
-  it('is a strict boolean gate — numbers and arrays never count as on', () => {
-    const effective: EffectiveFeatureMap = { a: true, b: false, n: 1, arr: ['x'] };
-    expect(featureOn(effective, 'a')).toBe(true);
-    expect(featureOn(effective, 'b')).toBe(false);
-    expect(featureOn(effective, 'n')).toBe(false);
-    expect(featureOn(effective, 'arr')).toBe(false);
-    expect(featureOn(effective, 'missing')).toBe(false);
-  });
-});
-
-describe('resolveCatalogueLayout', () => {
-  it('masonry wins when configured (the absorbed Photo Gallery mode)', () => {
-    expect(resolveCatalogueLayout({ galleryLayouts: ['rows', 'masonry'] })).toBe('masonry');
-  });
-  it('columns/dense map to columns', () => {
-    expect(resolveCatalogueLayout({ galleryLayouts: ['columns'] })).toBe('columns');
-    expect(resolveCatalogueLayout({ galleryLayouts: ['dense'] })).toBe('columns');
-  });
-  it('defaults to rows when unset or unrecognized', () => {
-    expect(resolveCatalogueLayout({})).toBe('rows');
-    expect(resolveCatalogueLayout({ galleryLayouts: ['rows'] })).toBe('rows');
-    // A non-array value is ignored rather than crashing.
-    expect(resolveCatalogueLayout({ galleryLayouts: true })).toBe('rows');
-  });
-});
-
-describe('galleryLayoutsOf', () => {
-  it('returns [] for a non-array value', () => {
-    expect(galleryLayoutsOf({ galleryLayouts: 3 })).toEqual([]);
-    expect(galleryLayoutsOf({})).toEqual([]);
-  });
-});
-
-describe('assetSurfaces', () => {
-  it('derives per-surface flags and anyCatalogue from the effective map', () => {
-    const s = assetSurfaces({ gallery: true, video: false, privateMedia: true });
-    expect(s.gallery).toBe(true);
-    expect(s.video).toBe(false);
-    expect(s.privateMedia).toBe(true);
-    expect(s.anyCatalogue).toBe(true);
-  });
-  it('anyCatalogue is false when no grid surface is on (private-only is not a catalogue)', () => {
-    expect(assetSurfaces({ privateMedia: true }).anyCatalogue).toBe(false);
-    expect(assetSurfaces({}).anyCatalogue).toBe(false);
-  });
-});
-
-describe('knowledge kind gating', () => {
-  it('lists only the spine kinds whose feature flag is on', () => {
-    expect(enabledKnowledgeKinds({ notes: true, bookmarks: true })).toEqual(['note', 'bookmark']);
-    expect(enabledKnowledgeKinds({})).toEqual([]);
-  });
-  it('knowledgeItemVisible maps each kind to its flag', () => {
-    expect(knowledgeItemVisible({ todos: true }, 'todo')).toBe(true);
-    expect(knowledgeItemVisible({ todos: true }, 'note')).toBe(false);
-    expect(knowledgeItemVisible({ worklog: true }, 'worklog')).toBe(true);
-  });
-});

package/src/react/studios/featureGate.ts

@@ -1,178 +0,0 @@
-// Pure feature-flag resolution for the studio shells. Every rule here is a boolean
-// lookup over the EFFECTIVE feature map (02 §6.1 / J2-3 — no predicates, no eval): the
-// shells and the route binder call these so the gating logic is one testable unit,
-// never re-derived per component.
-
-import type { EffectiveFeatureMap } from '../../verify/types';
-import type { MediaCatalogueLayout } from '../media/types';
-import type { KnowledgeSpineKind } from './types';
-
-/** A feature is on iff it resolved to boolean `true` (numbers/arrays are never a gate). */
-export const featureOn = (effective: EffectiveFeatureMap, key: string): boolean =>
-  effective[key] === true;
-
-/** The configured gallery layout names (02 §2.1 — `galleryLayouts`, min 1, default rows). */
-export const galleryLayoutsOf = (effective: EffectiveFeatureMap): readonly string[] => {
-  const raw = effective.galleryLayouts;
-  return Array.isArray(raw) ? (raw as readonly string[]) : [];
-};
-
-/**
- * Which catalogue layout the AssetStudio grid opens in. `MediaCatalogueViewer` speaks
- * masonry/rows/columns; `dense` (a configured layout with no catalogue equivalent)
- * degrades to `columns`. Masonry wins when configured — that is exactly the absorbed
- * Photo Gallery mode (02 §1.1). Falls back to the spec default `rows`.
- */
-export const resolveCatalogueLayout = (effective: EffectiveFeatureMap): MediaCatalogueLayout => {
-  const layouts = galleryLayoutsOf(effective);
-  if (layouts.includes('masonry')) return 'masonry';
-  if (layouts.includes('columns') || layouts.includes('dense')) return 'columns';
-  return 'rows';
-};
-
-/** The AssetStudio surfaces enabled for an instance, in render order. */
-export interface AssetSurfaces {
-  gallery: boolean;
-  video: boolean;
-  fileBrowser: boolean;
-  taggedFiles: boolean;
-  privateMedia: boolean;
-  /** Any grid at all — the shell renders an empty catalogue rather than nothing. */
-  anyCatalogue: boolean;
-}
-
-export const assetSurfaces = (effective: EffectiveFeatureMap): AssetSurfaces => {
-  const gallery = featureOn(effective, 'gallery');
-  const video = featureOn(effective, 'video');
-  const fileBrowser = featureOn(effective, 'fileBrowser');
-  const taggedFiles = featureOn(effective, 'taggedFiles');
-  const privateMedia = featureOn(effective, 'privateMedia');
-  return {
-    gallery,
-    video,
-    fileBrowser,
-    taggedFiles,
-    privateMedia,
-    anyCatalogue: gallery || video || fileBrowser || taggedFiles,
-  };
-};
-
-/** Maps a spine record kind to the KnowledgeStudio feature flag that enables it (02 §1.2). */
-export const KNOWLEDGE_KIND_FEATURE: Readonly<Record<KnowledgeSpineKind, string>> = {
-  note: 'notes',
-  todo: 'todos',
-  bookmark: 'bookmarks',
-  worklog: 'worklog',
-  habit: 'habits',
-  article: 'articles',
-};
-
-/** The spine kinds whose feature flag is effective-on — the master list is filtered to these. */
-export const enabledKnowledgeKinds = (
-  effective: EffectiveFeatureMap,
-): readonly KnowledgeSpineKind[] =>
-  (Object.keys(KNOWLEDGE_KIND_FEATURE) as KnowledgeSpineKind[]).filter((kind) =>
-    featureOn(effective, KNOWLEDGE_KIND_FEATURE[kind]),
-  );
-
-/** A spine row is shown iff its kind's feature is on. */
-export const knowledgeItemVisible = (
-  effective: EffectiveFeatureMap,
-  kind: KnowledgeSpineKind,
-): boolean => featureOn(effective, KNOWLEDGE_KIND_FEATURE[kind]);
-
-/* ------------------------------------------------------------- surfaces */
-
-/**
- * One navigable surface inside a shell: the tab/route the shell renders, the
- * feature that enables it, and — for a privileged one — the permission WITHOUT
- * WHICH IT IS NOT RENDERED AT ALL.
- *
- * That last part is the whole point of modeling surfaces as data (02 §4.4): a
- * shell that filtered its nav but still rendered the panel on a direct hit would
- * be a UI that "hides" a control the session may not use. One list, one filter,
- * both the nav and the body read it.
- */
-export interface StudioSurface {
-  id: string;
-  label: string;
-  /** Feature key that must be effective-on. Absent = always available. */
-  feature?: string;
-  /** Permission the claims must carry, or the surface does not exist for them. */
-  permission?: string;
-}
-
-/** Filter surfaces to those whose feature is on AND whose permission is held. */
-export const availableSurfaces = (
-  surfaces: readonly StudioSurface[],
-  effective: EffectiveFeatureMap,
-  permissions: readonly string[],
-): readonly StudioSurface[] =>
-  surfaces.filter(
-    (surface) =>
-      (surface.feature === undefined || featureOn(effective, surface.feature)) &&
-      (surface.permission === undefined || permissions.includes(surface.permission)),
-  );
-
-/**
- * DevStudio's surfaces, in nav order. `configEditor`/`dbAdmin` carry
- * `infra:write` because the DEV MIXIN carries it: the server refuses those
- * routes without the claim even under the local profile, so a rendered control
- * would be a guaranteed 403.
- */
-export const DEV_SURFACES: readonly StudioSurface[] = [
-  { id: 'apps', label: 'Apps', feature: 'appRegistry' },
-  { id: 'fleet', label: 'Fleet', feature: 'fleet' },
-  { id: 'deploy', label: 'Deploy', feature: 'deploy' },
-  { id: 'disk', label: 'Disk', feature: 'diskUsage' },
-  // The four nav surfaces of 03 §1e's second half. Each is gated on the SAME
-  // feature its route block is gated on in `dev.mixin.ts`, so a tab and the
-  // route behind it appear and disappear together (R-3). `app-detail` is
-  // deliberately NOT here: it is a parameterised DETAIL view opened from an Apps
-  // row, not a place in the nav — the same shape as asset `video-detail`.
-  { id: 'docs', label: 'Docs', feature: 'docs' },
-  { id: 'pipelines', label: 'Pipelines', feature: 'pipelines' },
-  { id: 'screenshots', label: 'Screenshots', feature: 'screenshots' },
-  { id: 'orchestration', label: 'Jobs', feature: 'orchestration' },
-  { id: 'config-editor', label: 'Config', feature: 'configEditor', permission: 'infra:write' },
-  { id: 'db-admin', label: 'Database', feature: 'dbAdmin', permission: 'infra:write' },
-];
-
-/** SystemUtility's surfaces. `utilities` has no feature gate — it is the drawer's home. */
-export const SYSTEM_SURFACES: readonly StudioSurface[] = [
-  { id: 'dashboard', label: 'Dashboard', feature: 'dashboard' },
-  { id: 'calendar', label: 'Calendar', feature: 'calendar' },
-  { id: 'notifications', label: 'Notifications', feature: 'notifications' },
-  // The three data surfaces (03 §1b). Their routes are mounted at composition
-  // time only when the feature is effective-on, so the surface and the route
-  // appear and disappear together — a surface listed with its feature off would
-  // be a tab whose every request is a correct 404.
-  { id: 'time-off', label: 'Time off', feature: 'timeOff' },
-  { id: 'budgets', label: 'Budgets', feature: 'budgets' },
-  { id: 'subscriptions', label: 'Subscriptions', feature: 'subscriptions' },
-  { id: 'utilities', label: 'Utilities' },
-];
-
-/**
- * GuardEngine's surfaces. `secrets` is privileged for the same reason the guard
- * mixin makes it privileged: listing which credentials exist is reconnaissance.
- *
- * `account` carries NO permission: it is the surface a signed-OUT caller uses to
- * become a signed-in one (02 §5), so gating it on a claim would be a login screen
- * that requires a login. Its own privileged half (the members panel) is gated
- * inside the surface, on the session's role, exactly as the server gates the
- * routes behind it.
- */
-export const GUARD_SURFACES: readonly StudioSurface[] = [
-  { id: 'unlock', label: 'Unlock', feature: 'privateMode' },
-  { id: 'account', label: 'Account', feature: 'accounts' },
-  { id: 'secrets', label: 'Secrets', feature: 'secretsPanel', permission: 'infra:write' },
-];
-
-/** The utility tools the drawer offers, gated by their own feature flags. */
-export const SYSTEM_TOOLS: readonly StudioSurface[] = [
-  { id: 'stopwatch', label: 'Stopwatch', feature: 'stopwatch' },
-  { id: 'formatLab', label: 'Format lab', feature: 'formatLab' },
-  { id: 'lineFilter', label: 'Line filter', feature: 'lineFilter' },
-  { id: 'httpClient', label: 'Request builder', feature: 'httpClient' },
-];