@dxos/plugin-debug 0.12.0-next-73daef452f1464b62efdbca75fb0067c1066f264 → 0.13.0

package/src/containers/index.ts

@@ -4,15 +4,28 @@
 
 import { type ComponentType, lazy } from 'react';
 
-export const DebugObjectPanel: ComponentType<any> = lazy(() => import('./DebugObjectPanel'));
-export const DebugSettings: ComponentType<any> = lazy(() => import('./DebugSettings'));
-export const DebugSpaceObjectsPanel: ComponentType<any> = lazy(() => import('./DebugSpaceObjectsPanel'));
-export const DebugStatus: ComponentType<any> = lazy(() => import('./DebugStatus'));
-export const LogStatus: ComponentType<any> = lazy(() =>
-  import('./LogStatus').then((module) => ({ default: module.LogStatus })),
+import { type DebugConsoleProps } from './DebugConsole/index.ts';
+import { type DebugPanelDrawerProps } from './DebugPanelDrawer/index.ts';
+import { type DebugPanelStatusProps } from './DebugPanelStatus/index.ts';
+
+export const DebugConsole: ComponentType<DebugConsoleProps> = lazy(() =>
+  import('./DebugConsole/index.ts').then((module) => ({ default: module.DebugConsole })),
+);
+export const DebugObjectPanel: ComponentType<any> = lazy(() => import('./DebugObjectPanel/index.ts'));
+export const DebugSettings: ComponentType<any> = lazy(() => import('./DebugSettings/index.ts'));
+export const DebugSpaceObjectsPanel: ComponentType<any> = lazy(() => import('./DebugSpaceObjectsPanel/index.ts'));
+export const DebugPanelDrawer: ComponentType<DebugPanelDrawerProps> = lazy(() =>
+  import('./DebugPanelDrawer/index.ts').then((module) => ({ default: module.DebugPanelDrawer })),
+);
+export const DebugPanelStatus: ComponentType<DebugPanelStatusProps> = lazy(() =>
+  import('./DebugPanelStatus/index.ts').then((module) => ({ default: module.DebugPanelStatus })),
+);
+export const DebugStatus: ComponentType<any> = lazy(() => import('./DebugStatus/index.ts'));
+export const LoggerPanel: ComponentType<any> = lazy(() =>
+  import('./LoggerPanel/index.ts').then((module) => ({ default: module.LoggerPanel })),
 );
-export const SpaceGenerator: ComponentType<any> = lazy(() => import('./SpaceGenerator'));
-export const Wireframe: ComponentType<any> = lazy(() => import('./Wireframe'));
+export const SpaceGenerator: ComponentType<any> = lazy(() => import('./SpaceGenerator/index.ts'));
+export const Wireframe: ComponentType<any> = lazy(() => import('./Wireframe/index.ts'));
 export const StatsPanel: ComponentType<any> = lazy(() =>
-  import('./StatsPanel').then((module) => ({ default: module.StatsPanel })),
+  import('./StatsPanel/index.ts').then((module) => ({ default: module.StatsPanel })),
 );

package/src/errors.ts

@@ -0,0 +1,23 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { BaseError } from '@dxos/errors';
+
+/** The requested template id matches nothing contributed; the operation's listing names the valid ids. */
+export class SpaceTemplateNotFoundError extends BaseError.extend(
+  'SpaceTemplateNotFoundError',
+  'No space template is registered under that id.',
+) {}
+
+/** The requested space id resolves to no space on this client. */
+export class SpaceNotFoundError extends BaseError.extend('SpaceNotFoundError', 'No space with that id.') {}
+
+/** Applying a template failed part-way; the cause carries what the phase actually threw. */
+export class SpaceTemplateApplyError extends BaseError.extend(
+  'SpaceTemplateApplyError',
+  'Failed to apply the space template.',
+) {}
+
+/** The history tracker has no undoable operation to revert. */
+export class NothingToUndoError extends BaseError.extend('NothingToUndoError', 'Nothing to undo.') {}

package/src/index.ts

@@ -2,6 +2,6 @@
 // Copyright 2026 DXOS.org
 //
 
-export * as DebugPlugin from './DebugPlugin';
-export * from '#meta';
+export * as DebugPlugin from './DebugPlugin.ts';
+export * from './samples/index.ts';
 export * from '#types';

package/src/meta.ts

@@ -4,6 +4,6 @@
 
 import * as Plugin from '@dxos/app-framework/Plugin';
 
-import config from '../dx.config';
+import config from '../dx.config.ts';
 
 export const meta = Plugin.getMetaFromConfig(config);

package/src/operations/DebugOperationHandlerSet.ts

@@ -8,5 +8,9 @@ import * as OperationHandlerSet from '@dxos/compute/OperationHandlerSet';
 import { DebugOperation } from '#types';
 
 export const handlers = OperationHandlerSet.lazy([
-  DebugOperation.InsertLoremIpsum.pipe(Operation.lazyHandler(() => import('./insert-lorem-ipsum'))),
+  DebugOperation.InsertLoremIpsum.pipe(Operation.lazyHandler(() => import('./insert-lorem-ipsum.ts'))),
+  DebugOperation.OpenPage.pipe(Operation.lazyHandler(() => import('./open-page.ts'))),
+  DebugOperation.Snapshot.pipe(Operation.lazyHandler(() => import('./snapshot.ts'))),
+  DebugOperation.CreateSpaceFromTemplate.pipe(Operation.lazyHandler(() => import('./create-space-from-template.ts'))),
+  DebugOperation.Undo.pipe(Operation.lazyHandler(() => import('./undo.ts'))),
 ]);

package/src/operations/create-space-from-template.ts

@@ -0,0 +1,57 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import * as ActivationEvents from '@dxos/app-framework/ActivationEvents';
+import * as Capability from '@dxos/app-framework/Capability';
+import * as Plugin from '@dxos/app-framework/Plugin';
+import * as AppCapabilities from '@dxos/app-toolkit/AppCapabilities';
+import * as AppSpace from '@dxos/app-toolkit/AppSpace';
+import * as Operation from '@dxos/compute/Operation';
+import * as ClientCapabilities from '@dxos/plugin-client/ClientCapabilities';
+import * as SpaceOperation from '@dxos/plugin-space/SpaceOperation';
+
+import { DebugOperation } from '#types';
+
+import { SpaceTemplateApplyError, SpaceTemplateNotFoundError } from '../errors.ts';
+
+const summarize = ({ id, label, description }: AppCapabilities.SpaceTemplate) => ({ id, label, description });
+
+const handler: Operation.WithHandler<typeof DebugOperation.CreateSpaceFromTemplate> =
+  DebugOperation.CreateSpaceFromTemplate.pipe(
+    Operation.withHandler(
+      Effect.fnUntraced(function* ({ id }) {
+        yield* Plugin.activate(ActivationEvents.SpaceTemplatesRequested);
+        const templates = yield* Capability.getAll(AppCapabilities.SpaceTemplate);
+        const available = templates.map(summarize);
+        if (!id) {
+          return { available };
+        }
+
+        const template = templates.find((template) => template.id === id);
+        if (!template) {
+          return yield* Effect.fail(
+            new SpaceTemplateNotFoundError({ context: { id, available: available.map(({ id }) => id) } }),
+          );
+        }
+
+        const { space, subject } = yield* Operation.invoke(SpaceOperation.Create, {
+          name: template.label,
+          icon: template.icon,
+          hue: template.hue,
+        });
+        const client = yield* Capability.get(ClientCapabilities.Client);
+        AppSpace.setSpaceTemplateId(space, template.id);
+        yield* Effect.tryPromise({
+          try: () => template.apply({ client, space }),
+          catch: (cause) => new SpaceTemplateApplyError({ context: { id: template.id }, cause }),
+        }).pipe(Effect.tapError(() => Effect.ignore(Operation.invoke(SpaceOperation.Delete, { space }))));
+
+        return { applied: summarize(template), spaceId: space.id, subject, available };
+      }),
+    ),
+  );
+
+export default handler;

package/src/operations/errors.ts

@@ -0,0 +1,8 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { BaseError } from '@dxos/errors';
+
+/** Debug operation failed. The underlying failure, where there is one, is the `cause`. */
+export class DebugOperationError extends BaseError.extend('DebugOperationError', 'Debug operation failed.') {}

package/src/operations/index.ts

@@ -2,4 +2,4 @@
 // Copyright 2026 DXOS.org
 //
 
-export * as DebugOperationHandlerSet from './DebugOperationHandlerSet';
+export * as DebugOperationHandlerSet from './DebugOperationHandlerSet.ts';

package/src/operations/open-page.ts

@@ -0,0 +1,51 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import * as Capability from '@dxos/app-framework/Capability';
+import * as AppGraph from '@dxos/app-graph/AppGraph';
+import * as AppCapabilities from '@dxos/app-toolkit/AppCapabilities';
+import * as LayoutOperation from '@dxos/app-toolkit/LayoutOperation';
+import * as Operation from '@dxos/compute/Operation';
+import * as AttentionCapabilities from '@dxos/plugin-attention/AttentionCapabilities';
+import { Path } from '@dxos/react-ui-list/util';
+
+import { DebugNodes, DebugOperation } from '#types';
+
+import { DEBUG_PANEL_CONTEXT, debugPanelAspect } from '../containers/DebugPanel/view-state.ts';
+
+const handler: Operation.WithHandler<typeof DebugOperation.OpenPage> = DebugOperation.OpenPage.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* ({ nodeId }) {
+      const { graph } = yield* Capability.get(AppCapabilities.AppGraph);
+      const viewState = yield* Capability.get(AttentionCapabilities.ViewState);
+
+      // The page's ancestors are built by connectors that run only on expansion.
+      AppGraph.expandPath(graph, nodeId);
+
+      // Tree paths run root, tree id, then each ancestor's qualified id; open every branch above the page.
+      const segments = nodeId.split('/');
+      const ancestors = segments
+        .slice(0, -1)
+        .map((_, index) => segments.slice(0, index + 1).join('/'))
+        .filter((id) => id.startsWith(DebugNodes.DEBUG_ROOT_ID) && id !== DebugNodes.DEBUG_ROOT_ID);
+      const branches = ancestors.map((_, index) =>
+        Path.create(DebugNodes.DEBUG_ROOT_ID, DEBUG_PANEL_CONTEXT, ...ancestors.slice(0, index + 1)),
+      );
+      viewState.update(debugPanelAspect, DEBUG_PANEL_CONTEXT, (prev) => ({
+        ...prev,
+        nodeId,
+        open: [...new Set([...prev.open, ...branches])],
+      }));
+
+      // A floating panel is opened by its own status-bar trigger; it shows the page when next opened.
+      if ((viewState.get(debugPanelAspect, DEBUG_PANEL_CONTEXT).mode ?? 'docked') === 'docked') {
+        yield* Operation.invoke(LayoutOperation.UpdateDrawer, { state: 'open' });
+      }
+    }),
+  ),
+);
+
+export default handler;

package/src/operations/snapshot.test.ts

@@ -0,0 +1,57 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { describe, test } from 'vitest';
+
+import * as Operation from '@dxos/compute/Operation';
+import * as EffectEx from '@dxos/effect/EffectEx';
+import { log } from '@dxos/log';
+import * as ClientCapabilities from '@dxos/plugin-client/ClientCapabilities';
+import * as ClientEvents from '@dxos/plugin-client/ClientEvents';
+import { ClientPlugin, initializeIdentity } from '@dxos/plugin-client/testing';
+import { SpacePlugin } from '@dxos/plugin-space/testing';
+import * as Harness from '@dxos/plugin-testing/Harness';
+
+import { DebugPlugin } from '#plugin';
+import { DebugOperation } from '#types';
+
+describe('DebugOperation.Snapshot', () => {
+  test('returns a degraded snapshot on a headless host', async ({ expect }) => {
+    await using harness = await Harness.createComposerTestApp({ plugins: [DebugPlugin()] });
+
+    const snapshot = await harness.runPromise(Operation.invoke(DebugOperation.Snapshot, {}));
+
+    // No deck plugin — the layout section degrades rather than failing the call.
+    expect(snapshot.layout).toBeUndefined();
+    // Attention is part of the harness core, so the section is present (and empty).
+    expect(snapshot.attention).toEqual([]);
+    expect(snapshot.planks).toEqual([]);
+    expect(snapshot.surfaces).toEqual([]);
+    expect(snapshot.toasts).toEqual([]);
+    expect(snapshot.plugins.installed).toBeGreaterThan(0);
+    expect(snapshot.plugins.active).toBeGreaterThan(0);
+    expect(snapshot.plugins.enabled).toBeLessThanOrEqual(snapshot.plugins.installed);
+  });
+
+  test('reports the spaces and the errors logged since a timestamp', async ({ expect }) => {
+    await using harness = await Harness.createComposerTestApp({
+      plugins: [ClientPlugin.make({}), SpacePlugin({}), DebugPlugin()],
+    });
+    const client = harness.get(ClientCapabilities.Client);
+    await EffectEx.runAndForwardErrors(initializeIdentity(client));
+    await harness.waitForEvent(ClientEvents.SpacesAvailable);
+
+    const before = Date.now();
+    log.error('snapshot test error');
+    const snapshot = await harness.runPromise(Operation.invoke(DebugOperation.Snapshot, { since: before }));
+
+    expect(snapshot.spaces.length).toBeGreaterThan(0);
+    expect(snapshot.spaces.some((space) => space.default)).toBe(true);
+    expect(snapshot.spaces.every((space) => space.state === 'SPACE_READY')).toBe(true);
+    expect(snapshot.errors.map((error) => error.message)).toContain('snapshot test error');
+
+    const later = await harness.runPromise(Operation.invoke(DebugOperation.Snapshot, { since: Date.now() }));
+    expect(later.errors).toEqual([]);
+  });
+});

package/src/operations/snapshot.ts

@@ -0,0 +1,243 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+
+import * as Capabilities from '@dxos/app-framework/Capabilities';
+import * as Capability from '@dxos/app-framework/Capability';
+import * as Plugin from '@dxos/app-framework/Plugin';
+import * as AppGraph from '@dxos/app-graph/AppGraph';
+import * as AppGraphNode from '@dxos/app-graph/AppGraphNode';
+import * as AppCapabilities from '@dxos/app-toolkit/AppCapabilities';
+import * as AppSpace from '@dxos/app-toolkit/AppSpace';
+import * as Operation from '@dxos/compute/Operation';
+import { Filter, Obj, Query, Relation } from '@dxos/echo';
+import { LogLevel } from '@dxos/log';
+import * as AttentionCapabilities from '@dxos/plugin-attention/AttentionCapabilities';
+import * as ClientCapabilities from '@dxos/plugin-client/ClientCapabilities';
+import * as Markdown from '@dxos/plugin-markdown/Markdown';
+import { SpaceState } from '@dxos/protocols/buf/dxos/client/invitation_pb';
+// UI-free subpath: the root barrel reaches the panel components.
+import { logBuffer } from '@dxos/react-ui-debug/log-buffer';
+import { AnchoredTo, type Message, type Thread } from '@dxos/types';
+
+import { DebugOperation } from '#types';
+
+type Translate = (label: unknown) => string | undefined;
+
+/** Best-effort localization: an i18n tuple degrades to its key when no translator is active. */
+const makeTranslate =
+  (translator: { t: (key: string, options?: unknown) => string } | undefined): Translate =>
+  (label) => {
+    if (typeof label === 'string') {
+      return label;
+    }
+    if (Array.isArray(label) && typeof label[0] === 'string') {
+      return translator ? translator.t(label[0], label[1]) : label[0];
+    }
+    return undefined;
+  };
+
+/** ECHO objects summarize to identity — a snapshot must be O(planks), never O(space). */
+const summarizeSubject = (data: unknown) => {
+  if (data == null || typeof data !== 'object') {
+    return undefined;
+  }
+  if (Obj.isObject(data)) {
+    return {
+      dxn: String(Obj.getURI(data)),
+      typename: Obj.getTypename(data),
+      name: Obj.getLabel(data),
+      // Bounded by the one open document, so the snapshot stays O(planks).
+      text: Obj.instanceOf(Markdown.Document, data) ? data.content.target?.content : undefined,
+    };
+  }
+  if ('id' in data && typeof data.id === 'string') {
+    return { id: data.id };
+  }
+  return undefined;
+};
+
+/** The comment threads on an object, with their messages loaded — the review companion's view of it. */
+const collectComments = async (subject: unknown) => {
+  if (!Obj.isObject(subject)) {
+    return undefined;
+  }
+  const db = Obj.getDatabase(subject);
+  if (!db) {
+    return undefined;
+  }
+  const anchors: AnchoredTo.AnchoredTo[] = await db
+    .query(Query.select(Filter.id(subject.id)).targetOf(AnchoredTo.AnchoredTo))
+    .run();
+  return Promise.all(
+    anchors.map(async (anchor) => {
+      const thread = Relation.getSource(anchor) as Thread.Thread;
+      const messages: Message.Message[] = await Promise.all(thread.messages.map((ref) => ref.load()));
+      return {
+        id: thread.id,
+        anchorId: anchor.id,
+        anchor: anchor.anchor,
+        status: thread.status,
+        messages: messages.map((message) => ({
+          id: message.id,
+          sender: message.sender.name ?? message.sender.identityDid,
+          text: message.blocks
+            .map((block) => (block._tag === 'text' ? block.text : undefined))
+            .filter((text): text is string => text !== undefined)
+            .join('\n'),
+        })),
+      };
+    }),
+  );
+};
+
+const OPERATION_DXN = /dxn:[^/]+/;
+
+/** Flattens the node's actions with one level of group expansion — what a menu would show. */
+const collectActions = (
+  graph: Parameters<typeof AppGraph.getActions>[0],
+  translate: Translate,
+  nodeId: string,
+): { id: string; label?: string; icon?: string; disabled?: boolean; operation?: string; group?: boolean }[] => {
+  const out: ReturnType<typeof collectActions> = [];
+  const walk = (items: readonly AppGraphNode.Node[], depth: number) => {
+    for (const item of items) {
+      const group = AppGraphNode.isActionGroup(item);
+      const properties = item.properties ?? {};
+      out.push({
+        id: item.id,
+        label: translate(properties.label),
+        icon: typeof properties.icon === 'string' ? properties.icon : undefined,
+        disabled: typeof properties.disabled === 'boolean' ? properties.disabled : undefined,
+        operation: item.id.match(OPERATION_DXN)?.[0],
+        group: group ? true : undefined,
+      });
+      if (group && depth < 1) {
+        walk(AppGraph.getActions(graph, item.id), depth + 1);
+      }
+    }
+  };
+  walk(AppGraph.getActions(graph, nodeId), 0);
+  return out;
+};
+
+/** Interim surface source until the surface registry (INTROSPECTION.md §3.2): dev builds wrap every mounted surface in `<dx-surface>`. */
+const collectSurfaces = () => {
+  if (typeof document === 'undefined') {
+    return [];
+  }
+  return Array.from(document.querySelectorAll('dx-surface')).map((el) => ({
+    id: el.getAttribute('data-id') ?? undefined,
+    role: el.getAttribute('data-role') ?? undefined,
+    component: el.getAttribute('data-component') ?? undefined,
+  }));
+};
+
+/** The app's own report of what an operation just did — read the way a user reads it, off the DOM. */
+const collectToasts = () => {
+  if (typeof document === 'undefined') {
+    return [];
+  }
+  return Array.from(document.querySelectorAll('[data-scope="toast"][data-part="root"]')).map((el) => ({
+    title: el.querySelector('[data-part="title"]')?.textContent ?? undefined,
+    description: el.querySelector('[data-part="description"]')?.textContent ?? undefined,
+    actions: Array.from(el.querySelectorAll('button')).map(
+      (button) => button.getAttribute('aria-label') ?? button.textContent ?? '',
+    ),
+  }));
+};
+
+/** Recent error-level entries from the process-wide log buffer, which the plugin starts recording at startup. */
+const collectErrors = (since: number) =>
+  logBuffer
+    .getRows()
+    .filter(({ entry }) => entry.level >= LogLevel.ERROR && entry.timestamp >= since)
+    .map(({ entry }) => ({
+      timestamp: entry.timestamp,
+      message: entry.message,
+      error: entry.computedError,
+      file: entry.meta?.F,
+    }));
+
+const DEFAULT_ERROR_WINDOW_MS = 60_000;
+
+const handler: Operation.WithHandler<typeof DebugOperation.Snapshot> = DebugOperation.Snapshot.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* ({ since }) {
+      const manager = yield* Plugin.Service;
+      const registry = yield* Capability.get(Capabilities.AtomRegistry);
+      // Each source is optional: the snapshot degrades per-section rather than failing when a
+      // contributing plugin (deck, graph, attention) is not active on this host.
+      const layoutAtom = yield* Capability.getOption(AppCapabilities.Layout);
+      const graphBuilder = yield* Capability.getOption(AppCapabilities.AppGraph);
+      const translator = yield* Capability.getOption(AppCapabilities.Translator);
+      const attention = yield* Capability.getOption(AttentionCapabilities.Attention);
+      const client = yield* Capability.getOption(ClientCapabilities.Client);
+
+      const translate = makeTranslate(Option.getOrUndefined(translator));
+      const layout = Option.getOrUndefined(Option.map(layoutAtom, (atom) => registry.get(atom)));
+      const graph = Option.getOrUndefined(Option.map(graphBuilder, (builder) => builder.graph));
+
+      const planks = yield* Effect.promise(() =>
+        Promise.all(
+          (layout?.active ?? []).map(async (id) => {
+            const node = graph ? Option.getOrUndefined(AppGraph.getNode(graph, id)) : undefined;
+            return {
+              id,
+              label: node ? translate(node.properties?.label) : undefined,
+              type: node?.type,
+              subject: node ? summarizeSubject(node.data) : undefined,
+              actions: graph ? collectActions(graph, translate, id) : [],
+              comments: node ? await collectComments(node.data) : undefined,
+            };
+          }),
+        ),
+      );
+
+      const spaces = Option.match(client, {
+        onNone: () => [],
+        onSome: (client) => {
+          const defaultSpace = AppSpace.getDefaultSpace(client);
+          return client.spaces.get().map((space) => ({
+            id: space.id,
+            name: space.state.get() === SpaceState.SPACE_READY ? space.properties.name : undefined,
+            state: SpaceState[space.state.get()],
+            default: space === defaultSpace ? true : undefined,
+          }));
+        },
+      });
+
+      const activeModules = new Set(manager.getActive());
+      const plugins = manager.getPlugins();
+
+      return {
+        layout: layout && {
+          mode: layout.mode,
+          sidebarOpen: layout.sidebarOpen,
+          complementarySidebarOpen: layout.complementarySidebarOpen,
+          dialogOpen: layout.dialogOpen,
+          workspace: layout.workspace,
+          active: layout.active,
+          inactive: layout.inactive,
+          scrollIntoView: layout.scrollIntoView,
+        },
+        attention: Option.getOrUndefined(attention)?.getCurrent().slice() ?? [],
+        planks,
+        surfaces: collectSurfaces(),
+        spaces,
+        toasts: collectToasts(),
+        errors: collectErrors(since ?? Date.now() - DEFAULT_ERROR_WINDOW_MS),
+        plugins: {
+          installed: plugins.length,
+          enabled: manager.getEnabled().length,
+          active: plugins.filter((plugin) => plugin.modules.some((module) => activeModules.has(module.id))).length,
+        },
+      };
+    }),
+  ),
+);
+
+export default handler;

package/src/operations/undo.test.ts

@@ -0,0 +1,19 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { describe, test } from 'vitest';
+
+import * as Operation from '@dxos/compute/Operation';
+import * as Harness from '@dxos/plugin-testing/Harness';
+
+import { DebugPlugin } from '#plugin';
+import { DebugOperation } from '#types';
+
+describe('DebugOperation.Undo', () => {
+  test('fails when there is nothing to undo', async ({ expect }) => {
+    await using harness = await Harness.createComposerTestApp({ plugins: [DebugPlugin()] });
+
+    await expect(harness.runPromise(Operation.invoke(DebugOperation.Undo, {}))).rejects.toThrow('Nothing to undo');
+  });
+});

package/src/operations/undo.ts

@@ -0,0 +1,28 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import * as Capabilities from '@dxos/app-framework/Capabilities';
+import * as Capability from '@dxos/app-framework/Capability';
+import * as Operation from '@dxos/compute/Operation';
+
+import { DebugOperation } from '#types';
+
+import { NothingToUndoError } from '../errors.ts';
+
+const handler: Operation.WithHandler<typeof DebugOperation.Undo> = DebugOperation.Undo.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* () {
+      const tracker = yield* Capability.get(Capabilities.HistoryTracker);
+      if (!tracker.canUndo()) {
+        return yield* Effect.fail(new NothingToUndoError());
+      }
+      yield* tracker.undo();
+      return { undone: true };
+    }),
+  ),
+);
+
+export default handler;

package/src/plugin.tsx

@@ -7,11 +7,13 @@ import * as Plugin from '@dxos/app-framework/Plugin';
 import {
   AppGraphBuilder,
   DebugSettings,
+  GraphRetention,
   LogRecording,
   MarkdownMenu,
   OperationHandler,
   PluginAsset,
   ReactSurface,
+  SpaceTemplates,
   StatsPanel,
   Translations,
 } from '#capabilities';
@@ -21,11 +23,13 @@ import { Debug } from '#types';
 export const DebugPlugin = Plugin.define<Debug.DebugPluginOptions>(meta).pipe(
   Plugin.addModule(AppGraphBuilder),
   Plugin.addModule(DebugSettings),
+  Plugin.addModule(GraphRetention),
   Plugin.addModule(LogRecording),
   Plugin.addModule(MarkdownMenu),
   Plugin.addModule(OperationHandler),
   Plugin.addModule(PluginAsset),
   Plugin.addModule(ReactSurface),
+  Plugin.addModule(SpaceTemplates),
   Plugin.addModule(StatsPanel),
   Plugin.addModule(Translations),
   Plugin.make,

package/src/samples/crm/PipelineSpace.test.ts

@@ -0,0 +1,55 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { describe, test } from 'vitest';
+
+import { buildArchive, histogram } from '@dxos/app-toolkit/testing';
+import * as EffectEx from '@dxos/effect/EffectEx';
+
+import * as PipelineSpace from './PipelineSpace.ts';
+
+/**
+ * The CRM template is built on demand rather than committed, so this asserts its shape in place
+ * of a fixture: if a schema it seeds changes incompatibly, the build fails here.
+ */
+describe('Northwind Sales template', () => {
+  test('builds an archive with the board, the accounts and the mail', { timeout: 120_000 }, async ({ expect }) => {
+    const { json, objectCount } = await EffectEx.runPromise(buildArchive(PipelineSpace.make()));
+    const counts = histogram(json);
+    const countOf = (typename: string) =>
+      Object.entries(counts)
+        .filter(([type]) => type.includes(typename))
+        .reduce((total, [, count]) => total + count, 0);
+
+    expect(objectCount).toBeGreaterThan(0);
+    expect(countOf('type.organization')).toBe(7);
+    expect(countOf('type.person')).toBe(7);
+    expect(countOf('type.pipeline')).toBe(1);
+    expect(countOf('type.mailbox')).toBe(1);
+    // Eight emails, in the mailbox's feed rather than the database.
+    expect(countOf('type.message')).toBe(8);
+    // One view per pipeline stage.
+    expect(countOf('type.view')).toBe(5);
+  });
+
+  // Same budget as above: this also boots a client and builds the whole space, which a shared CI
+  // runner with coverage instrumentation does not finish inside the 15s default.
+  test('backs every pipeline column with a stage-filtered view', { timeout: 120_000 }, async ({ expect }) => {
+    const { json } = await EffectEx.runPromise(buildArchive(PipelineSpace.make()));
+    const objects: Array<{ '@type'?: string; 'columns'?: Array<{ name: string; order: string[] }> }> =
+      JSON.parse(json).objects;
+
+    const pipeline = objects.find((object) => object['@type']?.includes('type.pipeline'));
+    const columns = pipeline?.columns ?? [];
+    expect(columns.map((column) => column.name)).toEqual([
+      'Prospect',
+      'Qualified',
+      'Commit',
+      'Closed won',
+      'Closed lost',
+    ]);
+    // Two accounts sit at commit, two closed won, one at each of the rest.
+    expect(columns.map((column) => column.order.length)).toEqual([1, 1, 2, 2, 1]);
+  });
+});