@dxos/plugin-search 0.8.4-main.c4373fc → 0.8.4-main.c85a9c8dae

package/src/containers/SearchMain/SearchMain.tsx

@@ -0,0 +1,103 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import React, { useCallback, useMemo, useState } from 'react';
+
+import { Surface } from '@dxos/app-framework/ui';
+import { useObjectMenuItems, useObjectNavigate } from '@dxos/app-toolkit/ui';
+import { Entity, Query } from '@dxos/echo';
+import { Filter, type Space, useQuery } from '@dxos/react-client/echo';
+import { Card, Panel, ScrollArea, Toolbar, useTranslation } from '@dxos/react-ui';
+import { Menu } from '@dxos/react-ui-menu';
+import { Mosaic, type MosaicStackTileComponent } from '@dxos/react-ui-mosaic';
+import { SearchList } from '@dxos/react-ui-searchlist';
+import { Text } from '@dxos/schema';
+
+import { useGlobalSearch, useGlobalSearchResults, useWebSearch } from '../../hooks';
+import { meta } from '../../meta';
+import { type SearchResult } from '../../types';
+
+export const SearchMain = ({ space }: { space?: Space }) => {
+  const { t } = useTranslation(meta.id);
+  const { setMatch } = useGlobalSearch();
+  const [query, setQuery] = useState<string>();
+  // TODO(burdon): Option to search across spaces.
+  const objects = useQuery(
+    space?.db,
+    query === undefined
+      ? Query.select(Filter.nothing())
+      : // TODO(dmaretskyi): Final version would walk the ancestry of the object until we find a non-system type.
+        Query.all(
+          Query.select(Filter.text(query, { type: 'full-text' })).select(Filter.not(Filter.type(Text.Text))),
+          Query.select(Filter.text(query, { type: 'full-text' }))
+            .select(Filter.type(Text.Text))
+            .referencedBy('dxos.org/type/Document', 'content'),
+        ),
+  );
+
+  const results = useGlobalSearchResults(objects);
+  const { results: webResults } = useWebSearch({ query });
+  const allResults = useMemo(
+    () => [...results, ...webResults].filter(({ object }) => object && Entity.getLabel(object)),
+    [results, webResults],
+  );
+
+  const handleSearch = useCallback(
+    (text: string) => {
+      setQuery(text);
+      setMatch?.(text);
+    },
+    [setMatch],
+  );
+
+  return (
+    <SearchList.Root onSearch={handleSearch}>
+      <Panel.Root className='dx-article'>
+        <Panel.Toolbar asChild>
+          <Toolbar.Root>
+            <SearchList.Input placeholder={t('search placeholder')} />
+          </Toolbar.Root>
+        </Panel.Toolbar>
+        <Panel.Content asChild>
+          <SearchList.Content>
+            <Mosaic.Container asChild>
+              <ScrollArea.Root orientation='vertical'>
+                <ScrollArea.Viewport>
+                  <Mosaic.Stack items={allResults} getId={(result) => result.object!.id} Tile={SearchResultTile} />
+                </ScrollArea.Viewport>
+              </ScrollArea.Root>
+            </Mosaic.Container>
+            {allResults.length === 0 && <SearchList.Empty>{t('empty results message')}</SearchList.Empty>}
+          </SearchList.Content>
+        </Panel.Content>
+      </Panel.Root>
+    </SearchList.Root>
+  );
+};
+
+const SearchResultTile: MosaicStackTileComponent<SearchResult> = (props) => {
+  const data = props.data;
+  const object = data.object!;
+  const objectMenuItems = useObjectMenuItems(object);
+  const handleNavigate = useObjectNavigate(object);
+
+  return (
+    <Menu.Root>
+      <Card.Root key={data.id}>
+        <Card.Toolbar>
+          <Card.DragHandle />
+          <Card.Title onClick={handleNavigate}>
+            {data.label ?? (data.object && Entity.getLabel(data.object))}
+          </Card.Title>
+          {/* TODO(wittjosiah): Reconcile with Card.Menu. */}
+          <Menu.Trigger asChild disabled={!objectMenuItems?.length}>
+            <Toolbar.IconButton iconOnly variant='ghost' icon='ph--dots-three-vertical--regular' label='Actions' />
+          </Menu.Trigger>
+          <Menu.Content items={objectMenuItems} />
+        </Card.Toolbar>
+        <Surface.Surface role='card--content' data={{ subject: data.object }} limit={1} />
+      </Card.Root>
+    </Menu.Root>
+  );
+};

package/src/containers/SearchMain/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { SearchMain } from './SearchMain';
+
+export default SearchMain;

package/src/containers/SpaceMain/SpaceMain.tsx

@@ -0,0 +1,180 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React, { useCallback, useEffect, useMemo, useState } from 'react';
+
+import { useCapabilities, useOperationInvoker } from '@dxos/app-framework/ui';
+import { AppCapabilities, LayoutOperation } from '@dxos/app-toolkit';
+import { useAppGraph } from '@dxos/app-toolkit/ui';
+import { Filter, Obj, Query } from '@dxos/echo';
+import { Graph, Node, useActionRunner, useConnections } from '@dxos/plugin-graph';
+import { type Space, useQuery } from '@dxos/react-client/echo';
+import { ScrollArea, Toolbar, toLocalizedString, useTranslation } from '@dxos/react-ui';
+import { Card, Panel } from '@dxos/react-ui';
+import { Mosaic, type MosaicStackTileComponent } from '@dxos/react-ui-mosaic';
+import { SearchList } from '@dxos/react-ui-searchlist';
+import { Text } from '@dxos/schema';
+import { getStyles } from '@dxos/ui-theme';
+
+import { meta } from '../../meta';
+
+export const SpaceMain = ({ space }: { space: Space }) => {
+  const { t } = useTranslation(meta.id);
+  const { items, handleSearch } = useSpaceItems(space);
+
+  return (
+    <SearchList.Root onSearch={handleSearch}>
+      <Panel.Root className='dx-article'>
+        <Panel.Toolbar asChild>
+          <Toolbar.Root>
+            <SearchList.Input placeholder={t('search placeholder')} />
+          </Toolbar.Root>
+        </Panel.Toolbar>
+        <Panel.Content asChild>
+          <SearchList.Content>
+            <Mosaic.Container asChild>
+              <ScrollArea.Root orientation='vertical'>
+                <ScrollArea.Viewport classNames='p-2'>
+                  <Mosaic.Stack items={items} getId={(node) => node.id} Tile={NodeTile} />
+                </ScrollArea.Viewport>
+              </ScrollArea.Root>
+            </Mosaic.Container>
+          </SearchList.Content>
+        </Panel.Content>
+      </Panel.Root>
+    </SearchList.Root>
+  );
+};
+
+const NodeTile: MosaicStackTileComponent<Node.Node> = (props) => {
+  const node = props.data;
+  const { t } = useTranslation(meta.id);
+  const { graph } = useAppGraph();
+  const { invokeSync } = useOperationInvoker();
+  const runAction = useActionRunner();
+
+  const label = toLocalizedString(node.properties.label, t);
+  const icon = node.properties.icon ?? 'ph--placeholder--regular';
+  const iconHue = node.properties.iconHue;
+  const styles = iconHue ? getStyles(iconHue) : undefined;
+
+  const handleClick = () => {
+    if (Node.isAction(node)) {
+      // Run action if this is an action node.
+      const [parent] = Graph.getConnections(graph, node.id, Node.childRelation('inbound'));
+      if (parent) {
+        void runAction(node, { parent });
+      }
+    } else {
+      // Navigate to the node.
+      invokeSync(LayoutOperation.Open, { subject: [node.id] });
+    }
+  };
+
+  return (
+    <Card.Root fullWidth>
+      <Card.Toolbar>
+        <Card.ToolbarIconButton
+          variant='ghost'
+          label={label}
+          icon={icon}
+          iconOnly
+          iconClassNames={styles?.surfaceText}
+        />
+        <Card.Title onClick={handleClick}>{label}</Card.Title>
+        <Card.Menu />
+      </Card.Toolbar>
+    </Card.Root>
+  );
+};
+
+/**
+ * Hook to resolve metadata (icon, iconHue, etc.) for objects based on their typename.
+ */
+// TODO(wittjosiah): Factor out.
+const useMetadataResolver = () => {
+  const allMetadata = useCapabilities(AppCapabilities.Metadata);
+  return useCallback((typename: string) => allMetadata.find((m) => m.id === typename)?.metadata ?? {}, [allMetadata]);
+};
+
+/**
+ * Hook to get space items with search/filter support.
+ * Returns direct children when no query, or full-text search results when searching.
+ */
+const useSpaceItems = (space: Space) => {
+  const { graph } = useAppGraph();
+  const [query, setQuery] = useState<string>();
+  const resolveMetadata = useMetadataResolver();
+
+  // Expand the space node to load its children (needed when navigating directly to a space URL).
+  useEffect(() => {
+    const frame = requestAnimationFrame(() => {
+      Graph.expand(graph, space.id, 'child');
+    });
+    return () => cancelAnimationFrame(frame);
+  }, [graph, space.id]);
+
+  // Get direct children of the space node for the default view.
+  const children = useConnections(graph, space.id, 'child');
+
+  const handleSearch = useCallback((text: string) => {
+    setQuery(text);
+  }, []);
+
+  // TODO(dmaretskyi): Switch back to QueryEditor once query builder is ready for production.
+  // Query results using full-text search.
+  const results = useQuery(
+    space.db,
+    query === undefined
+      ? Query.select(Filter.nothing())
+      : Query.all(
+          Query.select(Filter.text(query, { type: 'full-text' })).select(Filter.not(Filter.type(Text.Text))),
+          Query.select(Filter.text(query, { type: 'full-text' }))
+            .select(Filter.type(Text.Text))
+            .referencedBy('dxos.org/type/Document', 'content'),
+        ),
+  );
+
+  // Determine if query is empty (show default view).
+  const isQueryEmpty = !query?.trim();
+
+  // Filter children to those which are objects, actions with disposition 'item', or alternate-tree nodes.
+  const filteredChildren = useMemo(
+    () =>
+      children.filter((node) => {
+        // Include regular objects.
+        if (Obj.isObject(node.data)) {
+          return true;
+        }
+        // Include actions with disposition 'item'.
+        return Node.isAction(node) && node.properties.disposition === 'item';
+      }),
+    [children],
+  );
+
+  // When showing default view, use nodes (which may include actions).
+  // When showing search results, wrap objects in a compatible shape with resolved metadata.
+  const items = useMemo(() => {
+    if (isQueryEmpty) {
+      return filteredChildren;
+    }
+    // Wrap query results as pseudo-nodes for consistent rendering.
+    return results.map((obj) => {
+      const typename = Obj.getTypename(obj);
+      const metadata = typename ? resolveMetadata(typename) : {};
+      return {
+        id: obj.id,
+        type: 'search-result',
+        data: obj,
+        properties: {
+          label: Obj.getLabel(obj) ?? obj.id,
+          icon: metadata.icon ?? 'ph--placeholder--regular',
+          iconHue: metadata.iconHue,
+        },
+      } as Node.Node;
+    });
+  }, [isQueryEmpty, filteredChildren, results, resolveMetadata]);
+
+  return { items, handleSearch };
+};

package/src/containers/SpaceMain/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { SpaceMain } from './SpaceMain';
+
+export default SpaceMain;

package/src/containers/index.ts

@@ -0,0 +1,11 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type ComponentType, lazy } from 'react';
+
+export type { SearchDialogProps } from './SearchDialog/SearchDialog';
+
+export const SearchDialog: ComponentType<any> = lazy(() => import('./SearchDialog'));
+export const SearchMain: ComponentType<any> = lazy(() => import('./SearchMain'));
+export const SpaceMain: ComponentType<any> = lazy(() => import('./SpaceMain'));

package/src/hooks/index.ts

@@ -3,5 +3,7 @@
 //
 
 export * from './sync';
+
 export * from './useGlobalSearch';
 export * from './useSearchResults';
+export * from './useWebSearch';

package/src/hooks/sync.test.ts

@@ -5,7 +5,8 @@
 import { describe, expect, test } from 'vitest';
 
 import { Client } from '@dxos/client';
-import { Filter, Obj, Type } from '@dxos/echo';
+import { Filter, Obj } from '@dxos/echo';
+import { TestSchema } from '@dxos/echo/testing';
 import { faker } from '@dxos/random';
 
 import { filterObjectsSync } from './sync';
@@ -15,7 +16,8 @@ faker.seed(1);
 // TODO(burdon): Reconcile with agent/minisearch.
 
 describe('Search', () => {
-  test('Prefix text search', async () => {
+  // TODO(mykola): Fix FTS index to filter by fields.
+  test.skip('Prefix text search', async () => {
     const client = new Client();
     await client.initialize();
     await client.halo.createIdentity();
@@ -25,10 +27,10 @@ describe('Search', () => {
     Array.from({ length: 20 }).map((_, i) => {
       const content =
         i === 10 ? faker.lorem.sentence() + ` ${match}}. ` + faker.lorem.sentence() : faker.lorem.sentences();
-      return space.db.add(Obj.make(Type.Expando, { title: faker.lorem.sentence(), content }));
+      return space.db.add(Obj.make(TestSchema.Expando, { title: faker.lorem.sentence(), content }));
     });
 
-    const { objects } = await space.db.query(Filter.everything()).run();
+    const objects = await space.db.query(Filter.everything()).run();
     const results = filterObjectsSync(objects, new RegExp(match, 'i'));
     expect(results).to.have.length(1);
   });

package/src/hooks/sync.ts

@@ -5,8 +5,8 @@
 import type * as Schema from 'effect/Schema';
 import * as SchemaAST from 'effect/SchemaAST';
 
-import { Obj } from '@dxos/echo';
-import { DataType } from '@dxos/schema';
+import { type Entity, Obj } from '@dxos/echo';
+import { Text } from '@dxos/schema';
 
 import { type SearchResult } from '../types';
 
@@ -39,39 +39,34 @@ const getIcon = (schema: Schema.Schema.AnyNoContext | undefined): string | undef
 export type TextFields = Record<string, string>;
 
 // TODO(thure): This returns `SearchResult[]` which is not just a narrower set of objects as the name implies.
-export const filterObjectsSync = <T extends Record<string, any>>(objects: T[], match?: RegExp): SearchResult[] => {
+export const filterObjectsSync = <T extends Entity.Unknown>(objects: T[], match?: RegExp): SearchResult<T>[] => {
   if (!match) {
     return [];
   }
 
-  return objects.reduce<SearchResult[]>((results, object) => {
+  return objects.reduce<SearchResult<T>[]>((results, object) => {
     // TODO(burdon): Hack to ignore Text objects.
-    if (object instanceof DataType.Text) {
+    if (object instanceof Text.Text) {
       return results;
     }
 
     const fields = mapObjectToTextFields(object);
     Object.entries(fields).some(([, value]) => {
-      const result = value.match(match);
-      if (result) {
-        // TODO(burdon): Use schema.
-        const label = getStringProperty(object, ['label', 'name', 'title']);
-
-        results.push({
-          id: object.id,
-          type: getIcon(Obj.getSchema(object)),
-          label,
-          match,
-          // TODO(burdon): Truncate.
-          // TODO(burdon): Issue with sketch documents.
-          snippet: value !== label ? value : (fields.content ?? fields.description ?? undefined),
-          object,
-        });
-
-        return true;
-      }
+      // TODO(burdon): Use schema.
+      const label = Obj.getLabel(object as any);
+
+      results.push({
+        id: object.id,
+        type: getIcon(Obj.getSchema(object)),
+        label,
+        match,
+        // TODO(burdon): Truncate.
+        // TODO(burdon): Issue with sketch documents.
+        snippet: value !== label ? value : (fields.content ?? fields.description ?? undefined),
+        object,
+      });
 
-      return false;
+      return true;
     });
 
     return results;
@@ -95,13 +90,13 @@ export const getStringProperty = (object: any, keys: string[]): string | undefin
 };
 
 // TODO(burdon): Filter system fields.
-const getKeys = (object: Record<string, unknown>): string[] => {
+const getKeys = <T extends Entity.Unknown>(object: T): string[] => {
   try {
     const obj = JSON.parse(JSON.stringify(object));
     return Object.keys(obj).filter(
       (key) => key !== 'id' && key !== 'identityKey' && key[0] !== '_' && key[0] !== '@',
     ) as string[];
-  } catch (err) {
+  } catch {
     // TODO(burdon): Error with TLDraw sketch.
     //  Uncaught Error: Type with the name content has already been defined with a different constructor
     return [];
@@ -109,13 +104,13 @@ const getKeys = (object: Record<string, unknown>): string[] => {
 };
 
 // TODO(burdon): Use ECHO schema.
-export const mapObjectToTextFields = <T extends Record<string, unknown>>(object: T): TextFields => {
+export const mapObjectToTextFields = <T extends Entity.Unknown>(object: T): TextFields => {
   return getKeys(object).reduce<TextFields>((fields, key) => {
-    const value = object[key] as any;
-    if (typeof value === 'string' || value instanceof DataType.Text) {
+    const value = (object as any)[key];
+    if (typeof value === 'string' || value instanceof Text.Text) {
       try {
         fields[key] = String(value);
-      } catch (err) {
+      } catch {
         // TODO(burdon): Exception when parsing sketch document.
       }
     }

package/src/hooks/useGlobalSearch.tsx

@@ -2,14 +2,19 @@
 // Copyright 2023 DXOS.org
 //
 
-import React, { type PropsWithChildren, createContext, useContext, useMemo, useState } from 'react';
+import React, { type PropsWithChildren, createContext, useCallback, useContext, useState } from 'react';
 
 import { raise } from '@dxos/debug';
+import { type Entity } from '@dxos/echo';
+import { GlobalFilterProvider } from '@dxos/react-ui-searchlist';
 
 import { type SearchResult } from '../types';
 
 import { filterObjectsSync, queryStringToMatch } from './sync';
 
+// Re-export for backward compatibility.
+export { useGlobalFilteredObjects, GlobalFilterProvider } from '@dxos/react-ui-searchlist';
+
 type SearchContextType = {
   match?: RegExp;
   setMatch?: (text?: string) => void;
@@ -17,26 +22,40 @@ type SearchContextType = {
 
 const SearchContext = createContext<SearchContextType>({});
 
+/**
+ * Provider for global search context.
+ * Also provides the GlobalFilterProvider for useGlobalFilteredObjects to work.
+ */
 export const SearchContextProvider = ({ children }: PropsWithChildren) => {
   const [match, setMatch] = useState<RegExp>();
   const handleMatch = (text?: string) => setMatch(queryStringToMatch(text));
-  return <SearchContext.Provider value={{ match, setMatch: handleMatch }}>{children}</SearchContext.Provider>;
+
+  // Provide a filter function for useGlobalFilteredObjects.
+  const filterFn = useCallback(
+    <T extends Entity.Any>(objects: T[]): T[] => {
+      if (!match) {
+        return objects;
+      }
+
+      return filterObjectsSync(objects, match)
+        .filter((result) => result.object)
+        .map((result) => result.object!);
+    },
+    [match],
+  );
+
+  return (
+    <SearchContext.Provider value={{ match, setMatch: handleMatch }}>
+      <GlobalFilterProvider filter={filterFn}>{children}</GlobalFilterProvider>
+    </SearchContext.Provider>
+  );
 };
 
 export const useGlobalSearch = () => {
   return useContext(SearchContext) ?? raise(new Error('Missing SearchContext.'));
 };
 
-export const useGlobalSearchResults = <T extends Record<string, any>>(objects?: T[]): SearchResult[] => {
+export const useGlobalSearchResults = <T extends Entity.Unknown>(objects?: T[]): SearchResult<T>[] => {
   const { match } = useGlobalSearch();
   return objects && match ? filterObjectsSync(objects, match) : [];
 };
-
-export const useGlobalFilteredObjects = <T extends Record<string, any>>(objects?: T[]): T[] => {
-  const { match } = useGlobalSearch();
-  if (!match || !objects) {
-    return objects ?? [];
-  }
-
-  return useMemo(() => filterObjectsSync(objects, match).map((result) => result.object), [objects, match]);
-};

package/src/hooks/useSearchResults.ts

@@ -5,12 +5,13 @@
 import { yieldOrContinue } from 'main-thread-scheduling';
 import { useEffect, useState } from 'react';
 
-import { DataType } from '@dxos/schema';
+import { type Entity } from '@dxos/echo';
+import { Text } from '@dxos/schema';
 
 // TODO(thure): Deprecate search-sync, move still-relevant utilities elsewhere (here, probably).
 import { mapObjectToTextFields, queryStringToMatch } from './sync';
 
-export const filterObjects = async <T extends Record<string, any>>(
+export const filterObjects = async <T extends Entity.Unknown>(
   objects: T[],
   match?: RegExp,
 ): Promise<Map<T, string[][]>> => {
@@ -18,9 +19,10 @@ export const filterObjects = async <T extends Record<string, any>>(
   if (!match) {
     return result;
   }
+
   await Promise.all(
     objects
-      .filter((object) => !(object instanceof DataType.Text))
+      .filter((object) => !(object instanceof Text.Text))
       .map(async (object) => {
         await yieldOrContinue('interactive');
         const fields = mapObjectToTextFields<T>(object);
@@ -34,10 +36,11 @@ export const filterObjects = async <T extends Record<string, any>>(
           });
       }),
   );
+
   return result;
 };
 
-export const useSearchResults = <T extends Record<string, any>>(
+export const useSearchResults = <T extends Entity.Unknown>(
   queryString?: string,
   objects?: T[],
   delay: number = 400,

package/src/hooks/useWebSearch.ts

@@ -2,32 +2,44 @@
 // Copyright 2025 DXOS.org
 //
 
-import { useState } from 'react';
+import { useCallback, useState } from 'react';
 
 import { EXA_API_KEY } from '@dxos/ai/testing';
 import { Obj } from '@dxos/echo';
-import { type DXN } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { getIconAnnotation } from '@dxos/schema';
-import { Testing } from '@dxos/schema/testing';
+import { TestSchema } from '@dxos/schema/testing';
 
 import { search } from '../search';
 import { type SearchResult } from '../types';
 
 import { getStringProperty } from './sync';
 
-export const useWebSearch = ({ query, context }: { query?: string; context?: string }) => {
+export type UseWebSearchProps = {
+  query?: string;
+  context?: string;
+};
+
+export type UseWebSearch = {
+  update: () => Promise<void>;
+  results: SearchResult[];
+  isLoading: boolean;
+};
+
+/** @deprecated */
+// TODO(burdon): Remove testing deps.
+export const useWebSearch = ({ query, context }: UseWebSearchProps): UseWebSearch => {
   const [results, setResults] = useState<SearchResult[]>([]);
   const [isLoading, setIsLoading] = useState(false);
 
-  const runSearch = async () => {
+  const update = useCallback(async () => {
     try {
       setIsLoading(true);
       log.info('Running web search', { query, context });
       const results = await search({
         query,
         context,
-        schema: [Testing.Project, Testing.Organization, Testing.Contact],
+        schema: [TestSchema.Person, TestSchema.Project, TestSchema.Organization], // TODO(burdon): ???
         exaApiKey: EXA_API_KEY,
       });
 
@@ -35,7 +47,6 @@ export const useWebSearch = ({ query, context }: { query?: string; context?: str
         const schema = Obj.getSchema(result);
         return {
           id: result.id,
-          objectType: Obj.getTypename(result) as DXN.String | undefined,
           label: getStringProperty(result, ['name', 'title', 'label']),
           snippet: getStringProperty(result, ['description', 'content', 'website', 'email']),
           object: result,
@@ -47,7 +58,7 @@ export const useWebSearch = ({ query, context }: { query?: string; context?: str
     } finally {
       setIsLoading(false);
     }
-  };
+  }, [query, context]);
 
-  return { runSearch, results, isLoading };
+  return { update, results, isLoading };
 };

package/src/meta.ts

@@ -2,12 +2,16 @@
 // Copyright 2023 DXOS.org
 //
 
-import { type PluginMeta } from '@dxos/app-framework';
+import { type Plugin } from '@dxos/app-framework';
+import { trim } from '@dxos/util';
 
-export const meta: PluginMeta = {
+export const meta: Plugin.Meta = {
   id: 'dxos.org/plugin/search',
   name: 'Search',
-  description: 'Search ECHO spaces for content.',
+  description: trim`
+    Full-text search engine for finding content across all spaces and object types.
+    Quickly locate documents, tables, and other objects with instant results and relevance ranking.
+  `,
   icon: 'ph--magnifying-glass--regular',
   source: 'https://github.com/dxos/dxos/tree/main/packages/plugins/plugin-search',
   tags: ['labs'],