@dxos/app-framework 0.8.4-main.8360d9e660 → 0.8.4-main.8baae0fced

package/src/ui/components/Placeholder/Placeholder.tsx

@@ -0,0 +1,155 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React, { type ReactNode, useEffect, useLayoutEffect, useRef } from 'react';
+
+import { ThemeProvider } from '@dxos/react-ui';
+import { defaultTx, mx } from '@dxos/ui-theme';
+
+import { type PlaceholderProps as PlaceholderSlotProps } from '../../hooks';
+
+declare global {
+  interface Window {
+    /**
+     * Driver injected by `@dxos/app-framework/vite-plugin`'s `bootLoaderPlugin`.
+     * Declared here so the {@link Placeholder} can dismiss the native-DOM
+     * loader once the React placeholder commits without each host having to
+     * re-declare the type.
+     */
+    __bootLoader?: {
+      status: (payload: {
+        event?: string;
+        module?: string;
+        humanized: string;
+        /**
+         * Optional `(index/total)` tick. When present, the loader replaces the
+         * current line in place ("Loading plugins (12/80)") instead of
+         * appending a new entry — keeps the visible log compact during long
+         * counted phases like plugin chunk-loading or module activation.
+         */
+        range?: { index: number; total: number };
+      }) => void;
+      progress: (fraction?: number) => void;
+      dismiss: () => void;
+    };
+  }
+}
+
+export type PlaceholderComponentProps = PlaceholderSlotProps & {
+  /**
+   * Brand mark rendered while the React tree settles. Pass either a static
+   * `ReactNode` (the framework wraps it in a sizing/animation div) or a
+   * render function that receives the precomputed `className` so the host
+   * can apply it directly to its logo (e.g. an SVG that accepts `className`
+   * — `composer-app` passes `(p) => <Composer {...p} />` from `@dxos/brand`).
+   */
+  logo?: ReactNode | ((props: { className: string }) => ReactNode);
+};
+
+/**
+ * React placeholder. The native-DOM boot loader is the visible UI through
+ * stages 0 (Loading) and 1 (FadeIn): we render `null` until `stage >= 2`
+ * (FadeOut) and instead feed activation progress + status into the still-
+ * alive boot loader. At stage 2 the loader dismisses and the React mark
+ * appears for the cross-fade to the real shell:
+ *
+ *   - composer-app fills `0 → 50%` from `getPlugins`'s per-chunk counter.
+ *   - this component fills `50 → 100%` from `useApp`'s
+ *     `startupProgress.progress` (`activated / total` modules) and pushes
+ *     the per-module status text to the loader's status line.
+ *   - at `stage >= 2` the boot loader is dismissed and the React mark
+ *     starts its `FadeOut → Done` shrink-and-fade.
+ *
+ * Stage progression (driven by `useApp`):
+ *   - `0` — Loading: native-DOM boot loader visible. Placeholder renders nothing.
+ *   - `1` — FadeIn: same — boot loader still owns the screen.
+ *   - `2` — FadeOut: boot loader dismissed, React mark visible at full opacity then shrinks.
+ */
+export const Placeholder = ({ stage = 1, progress, logo }: PlaceholderComponentProps) => {
+  // Used in tests to exercise the error boundary & reset dialog.
+  if (location.search === '?throw') {
+    throw new Error('Test error');
+  }
+
+  // Phase B: feed activation progress + status to the still-visible boot
+  // loader. Maps `[0, 1]` activation → `[0.5, 1]` of the ring; forwards
+  // the raw activation source (`event` / `module`) plus the pre-humanised
+  // label to `__bootLoader.status` so the loader gets to decide how to
+  // render and trace each transition (current default policy: "Activating
+  // <humanizedName>"; trace mode and timings track the structured fields).
+  // No-op once the loader has been dismissed (its `status()` early-returns
+  // when the boot DOM is gone). Skipping `stage >= 2` lets the dismissal
+  // run uncontended.
+  useEffect(() => {
+    if (stage >= 2) {
+      return;
+    }
+    const fraction = progress?.progress ?? 0;
+    window.__bootLoader?.progress(0.5 + fraction * 0.5);
+    if (progress?.humanizedName) {
+      window.__bootLoader?.status({
+        event: progress.event,
+        module: progress.module,
+        humanized: `Activating ${progress.humanizedName}`,
+      });
+    }
+  }, [stage, progress?.progress, progress?.event, progress?.module, progress?.humanizedName]);
+
+  // Hand off from the native-DOM boot loader once the placeholder starts
+  // fading out — keeping the loader visible through `stage 0` and `stage 1`
+  // means the ring stays the visible source of truth for activation
+  // progress. `useLayoutEffect` runs before the next paint so the loader
+  // DOM is removed in the same frame the cross-fade begins.
+  useLayoutEffect(() => {
+    if (stage >= 2) {
+      window.__bootLoader?.dismiss();
+    }
+  }, [stage]);
+
+  // Backstop for the fast-load path where `useLoading` can skip straight
+  // from stage 0 to `Done` (ready=true at the first debounce tick) — the
+  // stage-driven effect above never sees `stage >= 2`, so dismiss on
+  // unmount instead. The `stageRef` guard is what keeps StrictMode's
+  // synthetic mount → cleanup → remount cycle from prematurely dismissing
+  // the loader: the synthetic cleanup runs while `stageRef.current === 0`,
+  // skips the dismiss, and the real unmount (later, at stage `Done`)
+  // performs it.
+  const stageRef = useRef(stage);
+  stageRef.current = stage;
+  useEffect(() => {
+    return () => {
+      if (stageRef.current >= 3 /* Done */) {
+        window.__bootLoader?.dismiss();
+      }
+    };
+  }, []);
+
+  // Defer rendering anything until the FadeOut stage. The boot loader owns
+  // the screen during stages 0 and 1, so any DOM we render here would just
+  // sit invisibly behind it — and rendering null avoids paint cost during
+  // the longest part of the loading sequence (plugin activation).
+  if (stage < 2) {
+    return null;
+  }
+
+  const logoClassName = mx(
+    'h-[300px] w-[300px] scale-600 transition-all duration-500 ease-in-out filter grayscale opacity-0',
+    stage >= 1 && 'scale-100 grayscale-0 opacity-70',
+    stage >= 2 && 'scale-50 opacity-0',
+  );
+
+  return (
+    <ThemeProvider tx={defaultTx}>
+      <div className='relative dx-container h-dvh flex flex-col'>
+        <div className='flex flex-col grow justify-center items-center'>
+          {typeof logo === 'function' ? (
+            logo({ className: logoClassName })
+          ) : logo ? (
+            <div className={logoClassName}>{logo}</div>
+          ) : null}
+        </div>
+      </div>
+    </ThemeProvider>
+  );
+};

package/src/{plugin-runtime → ui/components/Placeholder}/index.ts

@@ -2,4 +2,4 @@
 // Copyright 2025 DXOS.org
 //
 
-export * from './RuntimePlugin';
+export * from './Placeholder';

package/src/ui/components/PluginManager/PluginManagerContext.stories.tsx

@@ -38,7 +38,9 @@ const CountStatus = () => {
     }
   }, [counter]);
 
-  if (!manager) return null;
+  if (!manager) {
+    return null;
+  }
 
   const isEven = count % 2 === 0;
 
@@ -118,6 +120,7 @@ const CounterComponent = () => {
 const CounterPlugin = Plugin.define({
   id: 'org.dxos.plugin.counter',
   name: 'Counter Plugin',
+  tags: ['system'],
 }).pipe(
   Plugin.addModule({
     id: 'CounterMain',
@@ -152,7 +155,6 @@ const CounterPlugin = Plugin.define({
 )();
 
 const plugins = [CounterPlugin];
-const core = ['org.dxos.plugin.counter'];
 const placeholder = () => (
   <div className='flex h-screen items-center justify-center p-4 text-lg text-neutral-500'>
     Initializing Application...
@@ -162,7 +164,6 @@ const placeholder = () => (
 const DefaultStory = () => {
   const App = useApp({
     plugins,
-    core,
     placeholder,
   });
 
@@ -170,7 +171,7 @@ const DefaultStory = () => {
 };
 
 const meta = {
-  title: 'sdk/app-framework/PluginManagerContext',
+  title: 'sdk/app-framework/components/PluginManagerContext',
   render: DefaultStory,
   decorators: [withTheme(), withLayout({ layout: 'fullscreen' })],
   parameters: {

package/src/ui/components/Surface/SurfaceComponent.stories.tsx

@@ -5,15 +5,14 @@
 import { type Meta, type StoryObj } from '@storybook/react-vite';
 import React, { forwardRef, useCallback, useEffect, useRef, useState } from 'react';
 
-import { faker } from '@dxos/random';
-import { List, ListItem, Toolbar } from '@dxos/react-ui';
+import { random } from '@dxos/random';
+import { List, ListItem, Panel, Toolbar } from '@dxos/react-ui';
 import { withLayout, withTheme } from '@dxos/react-ui/testing';
 import { type ColorStyles, getHashStyles, mx } from '@dxos/ui-theme';
 
 import { Capabilities } from '../../../common';
 import { withPluginManager } from '../../../testing';
 import { usePluginManager } from '../PluginManager';
-
 import { SurfaceComponent, useSurfaces } from './SurfaceComponent';
 import { create } from './types';
 
@@ -39,7 +38,7 @@ const DefaultStory = () => {
   const [selected, setSelected] = useState<string | undefined>();
 
   const handleAdd = useCallback(() => {
-    const id = `test-${faker.number.int({ min: 0, max: 1_000 })}`;
+    const id = `test-${random.number.int({ min: 0, max: 1_000 })}`;
     const styles = getHashStyles(id);
 
     manager.capabilities.contribute({
@@ -57,7 +56,7 @@ const DefaultStory = () => {
   }, [manager]);
 
   const handleSelect = useCallback(() => {
-    setSelected(faker.helpers.arrayElement(surfaces)?.id);
+    setSelected(random.helpers.arrayElement(surfaces)?.id);
   }, [surfaces]);
 
   const handleError = useCallback(() => {
@@ -105,13 +104,15 @@ const DefaultStory = () => {
   }, [ref]);
 
   return (
-    <div className='flex flex-col h-full overflow-hidden'>
-      <Toolbar.Root>
-        <Toolbar.Button onClick={handleAdd}>Add</Toolbar.Button>
-        <Toolbar.Button onClick={handleSelect}>Pick</Toolbar.Button>
-        <Toolbar.Button onClick={handleError}>Error</Toolbar.Button>
-      </Toolbar.Root>
-      <div className='grid grid-cols-2 h-full gap-4 overflow-hidden'>
+    <Panel.Root>
+      <Panel.Toolbar asChild>
+        <Toolbar.Root>
+          <Toolbar.Button onClick={handleAdd}>Add</Toolbar.Button>
+          <Toolbar.Button onClick={handleSelect}>Pick</Toolbar.Button>
+          <Toolbar.Button onClick={handleError}>Error</Toolbar.Button>
+        </Toolbar.Root>
+      </Panel.Toolbar>
+      <Panel.Content className='grid grid-cols-2 h-full gap-4 overflow-hidden'>
         <SurfaceComponent role='item' data={selected ? { id: selected } : undefined} limit={1} ref={ref} />
         <div className='overflow-y-auto h-full'>
           <List>
@@ -122,13 +123,13 @@ const DefaultStory = () => {
             ))}
           </List>
         </div>
-      </div>
-    </div>
+      </Panel.Content>
+    </Panel.Root>
   );
 };
 
 const meta = {
-  title: 'sdk/app-framework/Surface',
+  title: 'sdk/app-framework/components/Surface',
   render: DefaultStory,
   decorators: [withTheme(), withLayout({ layout: 'fullscreen' }), withPluginManager({ capabilities: [] })],
   parameters: {

package/src/ui/components/Surface/SurfaceComponent.tsx

@@ -2,9 +2,11 @@
 // Copyright 2025 DXOS.org
 //
 
+import { useAtomValue } from '@effect-atom/atom-react';
 import React, {
   Fragment,
   type NamedExoticComponent,
+  Profiler,
   type RefAttributes,
   Suspense,
   forwardRef,
@@ -21,22 +23,29 @@ import { byPosition } from '@dxos/util';
 
 import { Capabilities } from '../../../common';
 import { type CapabilityManager } from '../../../core';
-import { useCapabilities } from '../../hooks';
-
+import { usePluginManager } from '../PluginManager/PluginManagerProvider';
 import { SurfaceContext } from './context';
 import { SurfaceInfo } from './SurfaceInfo';
-import { type Definition, type Props, type WebComponentDefinition } from './types';
-
-const DEFAULT_PLACEHOLDER = <Fragment />;
+import { useSurfaceProfilerCallback } from './SurfaceProfilerContext';
+import {
+  type Definition,
+  type Props,
+  type RoleToken,
+  type TokenData,
+  type TypedProps,
+  type WebComponentDefinition,
+} from './types';
 
 const DEBUG = import.meta.env.VITE_DEBUG;
 
+const DEFAULT_PLACEHOLDER = <Fragment />;
+
 /**
  * Wrapper component for rendering Web Component surfaces.
  * Handles creation, prop setting, and cleanup of Web Components.
  */
 const WebComponentWrapper = memo(
-  forwardRef<HTMLElement, Props & { definition: WebComponentDefinition }>(
+  forwardRef<HTMLElement, Omit<Props, 'role'> & { role: string; definition: WebComponentDefinition }>(
     ({ id, role, data, limit, definition, ...rest }, forwardedRef) => {
       const containerRef = useRef<HTMLDivElement>(null);
       const elementRef = useRef<HTMLElement | null>(null);
@@ -106,9 +115,11 @@ WebComponentWrapper.displayName = 'WebComponentWrapper';
  */
 // TODO(burdon): Allow DebugPlugin to provide different fallback using react-ui ErrorFallback.
 const SurfaceContextProvider = memo(
-  forwardRef<HTMLElement, Props & { definition: Definition }>(
+  forwardRef<HTMLElement, Omit<Props, 'role'> & { role: string; definition: Definition }>(
     ({ id, role, data, limit, fallback = ErrorFallback, definition, ...rest }, forwardedRef) => {
       const contextValue = useMemo(() => ({ id, role, data }), [id, role, data]);
+      const onProfilerRender = useSurfaceProfilerCallback();
+      const profilerId = `surface/${id}/${role}`;
 
       // Handle Web Component surfaces
       if (definition.kind === 'web-component') {
@@ -137,10 +148,16 @@ const SurfaceContextProvider = memo(
       if (debug) {
         return (
           <ErrorBoundary name='surface' resetKeys={[data]} FallbackComponent={fallback}>
-            <div role='none' className='contents' data-id={id} data-role={role}>
+            <div className='contents' data-id={id} data-role={role}>
               <SurfaceContext.Provider value={contextValue}>
                 <SurfaceInfo ref={forwardedRef}>
-                  <Component id={id} role={role} data={data} limit={limit} {...rest} />
+                  {onProfilerRender && !profilerId.includes('org.dxos.plugin.debug') ? (
+                    <Profiler id={profilerId} onRender={onProfilerRender}>
+                      <Component id={id} role={role} data={data} limit={limit} {...rest} />
+                    </Profiler>
+                  ) : (
+                    <Component id={id} role={role} data={data} limit={limit} {...rest} />
+                  )}
                 </SurfaceInfo>
               </SurfaceContext.Provider>
             </div>
@@ -150,7 +167,7 @@ const SurfaceContextProvider = memo(
 
       return (
         <ErrorBoundary name='surface' resetKeys={[data]} FallbackComponent={fallback}>
-          <div role='none' className='contents' data-id={id} data-role={role}>
+          <div className='contents' data-id={id} data-role={role}>
             <SurfaceContext.Provider value={contextValue}>
               <Component id={id} role={role} data={data} limit={limit} {...rest} ref={forwardedRef} />
             </SurfaceContext.Provider>
@@ -167,43 +184,53 @@ SurfaceContextProvider.displayName = 'SurfaceContextProvider';
  * A surface is a named region of the screen that can be populated by plugins.
  */
 // TODO(burdon): Remove `ref` since relying on this would be error prone.
-export const SurfaceComponent: NamedExoticComponent<Props & RefAttributes<HTMLElement>> = memo(
-  forwardRef(({ id: _id, role, data: dataProp, limit, placeholder = DEFAULT_PLACEHOLDER, ...rest }, forwardedRef) => {
-    const data = useDefaultValue(dataProp, () => ({}));
-
-    // TODO(wittjosiah): This will make all surfaces depend on a single signal.
-    //   This isn't ideal because it means that any change to the data will cause all surfaces to re-render.
-    //   This effectively means that plugin modules which contribute surfaces need to all be activated at startup.
-    //   This should be fine for now because it's how it worked prior to capabilities api anyway.
-    //   In the future, it would be nice to be able to bucket the surface contributions by role.
-    const surfaces = useSurfaces();
-
-    // NOTE: Memoizing the candidates makes the surface not re-render based on reactivity within data.
-    const definitions = findCandidates(surfaces, { role, data });
-    const candidates = limit ? definitions.slice(0, limit) : definitions;
-    if (DEBUG && candidates.length === 0) {
-      log.warn('no candidates for surface', { role, data });
-      return null;
-    }
+export const SurfaceComponent = memo(
+  forwardRef<HTMLElement, Props & { type?: RoleToken<any> }>(
+    ({ id: _id, role, type, data: dataProp, limit, placeholder = DEFAULT_PLACEHOLDER, ...rest }, forwardedRef) => {
+      const data = useDefaultValue(dataProp, () => ({}));
+      // TODO(wittjosiah): This will make all surfaces depend on a single signal.
+      //   This isn't ideal because it means that any change to the data will cause all surfaces to re-render.
+      //   This effectively means that plugin modules which contribute surfaces need to all be activated at startup.
+      //   This should be fine for now because it's how it worked prior to capabilities api anyway.
+      //   In the future, it would be nice to be able to bucket the surface contributions by role.
+      const surfaces = useSurfaces();
+
+      const effectiveRole = role ?? type?.role;
+      if (effectiveRole == null) {
+        if (DEBUG) {
+          log.warn('Surface has neither `role` nor `type` prop', { id: _id });
+        }
+        return null;
+      }
 
-    return (
-      <Suspense fallback={placeholder}>
-        {candidates.map((definition) => (
-          <SurfaceContextProvider
-            key={definition.id}
-            id={definition.id}
-            role={role}
-            data={data}
-            limit={limit}
-            definition={definition}
-            ref={forwardedRef}
-            {...rest}
-          />
-        ))}
-      </Suspense>
-    );
-  }),
-);
+      // NOTE: Memoizing the candidates makes the surface not re-render based on reactivity within data.
+      const definitions = findCandidates(surfaces, { role: effectiveRole, data });
+      const candidates = limit ? definitions.slice(0, limit) : definitions;
+      if (DEBUG && candidates.length === 0) {
+        log.warn('no candidates for surface', { role: effectiveRole, data });
+        return null;
+      }
+
+      return (
+        <Suspense fallback={placeholder}>
+          {candidates.map((definition) => (
+            <SurfaceContextProvider
+              key={definition.id}
+              id={definition.id}
+              role={effectiveRole}
+              data={data}
+              limit={limit}
+              definition={definition}
+              ref={forwardedRef}
+              {...rest}
+            />
+          ))}
+        </Suspense>
+      );
+    },
+  ),
+) as (<TToken extends RoleToken<any>>(props: TypedProps<TToken> & RefAttributes<HTMLElement>) => React.ReactNode) &
+  NamedExoticComponent<Props & RefAttributes<HTMLElement>>;
 
 SurfaceComponent.displayName = 'Surface';
 
@@ -217,12 +244,12 @@ const ErrorFallback = ({ error }: Props) => {
   );
 };
 
-const findCandidates = (surfaces: Definition[], { role, data }: Pick<Props, 'role' | 'data'>) => {
+const findCandidates = (surfaces: Definition[], { role, data }: { role: string; data: Props['data'] }) => {
   return Object.values(surfaces)
     .filter((definition) =>
       Array.isArray(definition.role) ? definition.role.includes(role) : definition.role === role,
     )
-    .filter(({ filter }) => (filter ? filter(data ?? {}) : true))
+    .filter(({ filter }) => (filter ? filter(data ?? {}, role) : true))
     .toSorted(byPosition);
 };
 
@@ -230,18 +257,47 @@ const findCandidates = (surfaces: Definition[], { role, data }: Pick<Props, 'rol
  * @internal
  */
 export const useSurfaces = () => {
-  const surfaces = useCapabilities(Capabilities.ReactSurface);
-  return useMemo(() => surfaces.flat(), [surfaces]);
+  const manager = usePluginManager();
+  const surfacesByModule = useAtomValue(manager.capabilities.atomByModule(Capabilities.ReactSurface));
+  return useMemo(() => {
+    const result: Definition[] = [];
+    for (const [moduleId, surfaces] of Object.entries(surfacesByModule)) {
+      for (const def of surfaces.flat()) {
+        result.push({ ...def, id: `${moduleId}.${def.id}` });
+      }
+    }
+    return result;
+  }, [surfacesByModule]);
 };
 
 /**
  * @returns `true` if there is a contributed surface which matches the specified role & data, `false` otherwise.
+ *
+ * Two overloads:
+ * - Typed: pass a `type` role token and `data` is constrained to the token's
+ *   declared contract (e.g. `AppSurface.Section` requires `attendableId`).
+ * - Legacy: pass a string `role` and `data` is untyped.
  */
-export const isSurfaceAvailable = (
+export function isSurfaceAvailable<TToken extends RoleToken<any>>(
+  capabilityManager: CapabilityManager.CapabilityManager,
+  args: { type: TToken; data?: TokenData<TToken>; role?: never },
+): boolean;
+export function isSurfaceAvailable(
   capabilityManager: CapabilityManager.CapabilityManager,
-  { role, data }: Pick<Props, 'role' | 'data'>,
-) => {
+  args: Pick<Props, 'role' | 'data'> & { type?: undefined },
+): boolean;
+export function isSurfaceAvailable(
+  capabilityManager: CapabilityManager.CapabilityManager,
+  { role, type, data }: { role?: string; type?: RoleToken<any>; data?: unknown },
+): boolean {
+  const effectiveRole = role ?? type?.role;
+  if (effectiveRole == null) {
+    return false;
+  }
   const surfaces = capabilityManager.getAll(Capabilities.ReactSurface);
-  const candidates = findCandidates(surfaces.flat(), { role, data });
+  const candidates = findCandidates(surfaces.flat(), {
+    role: effectiveRole,
+    data: data as Props['data'],
+  });
   return candidates.length > 0;
-};
+}

package/src/ui/components/Surface/SurfaceInfo.tsx

@@ -65,7 +65,6 @@ export const SurfaceInfo = forwardRef<HTMLElement, SurfaceInfoProps>(({ children
       {rect &&
         createPortal(
           <div
-            role='none'
             className='z-[100] fixed flex flex-col-reverse scrollbar-none overflow-auto pointer-events-none'
             style={{
               top: rect.top + padding,