@dxos/app-framework 0.8.4-main.937b3ca → 0.8.4-main.9be5663bfe

package/src/common/operations.ts

@@ -7,384 +7,9 @@ import * as Schema from 'effect/Schema';
 import { Operation } from '@dxos/operation';
 
 import { Capability } from '../core';
-
 import { Label } from './translations';
 
-const LAYOUT_PLUGIN = 'dxos.org/plugin/layout';
-
-/**
- * Layout operations - Operation-based equivalents of LayoutAction intents.
- * These mirror the LayoutAction namespace but use the Operation pattern.
- */
-export namespace LayoutOperation {
-  //
-  // Sidebar Operations
-  //
-
-  export const UpdateSidebar = Operation.make({
-    meta: {
-      key: `${LAYOUT_PLUGIN}/operation/update-sidebar`,
-      name: 'Update Sidebar',
-      description: 'Update the sidebar state.',
-    },
-    executionMode: 'sync',
-    services: [Capability.Service],
-    schema: {
-      input: Schema.Struct({
-        subject: Schema.optional(
-          Schema.String.annotations({ description: 'URI of the component to display in the sidebar.' }),
-        ),
-        state: Schema.optional(
-          Schema.Literal('closed', 'collapsed', 'expanded').annotations({
-            description: 'Whether the sidebar is closed, collapsed, or expanded.',
-          }),
-        ),
-      }),
-      output: Schema.Void,
-    },
-  });
-
-  export const UpdateComplementary = Operation.make({
-    meta: {
-      key: `${LAYOUT_PLUGIN}/operation/update-complementary`,
-      name: 'Update Complementary Sidebar',
-      description: 'Update the complementary sidebar state.',
-    },
-    executionMode: 'sync',
-    services: [Capability.Service],
-    schema: {
-      input: Schema.Struct({
-        subject: Schema.optional(
-          Schema.String.annotations({ description: 'URI of the component to display in the complementary area.' }),
-        ),
-        state: Schema.optional(
-          Schema.Literal('closed', 'collapsed', 'expanded').annotations({
-            description: 'Whether the complementary sidebar is closed, collapsed, or expanded.',
-          }),
-        ),
-      }),
-      output: Schema.Void,
-    },
-  });
-
-  //
-  // Dialog Operations
-  //
-
-  export const UpdateDialog = Operation.make({
-    meta: {
-      key: `${LAYOUT_PLUGIN}/operation/update-dialog`,
-      name: 'Update Dialog',
-      description: 'Open, close, or update the dialog.',
-    },
-    executionMode: 'sync',
-    services: [Capability.Service],
-    schema: {
-      input: Schema.Struct({
-        subject: Schema.optional(
-          Schema.String.annotations({ description: 'URI of the component to display in the dialog.' }),
-        ),
-        state: Schema.optional(Schema.Boolean.annotations({ description: 'Whether the dialog is open or closed.' })),
-        type: Schema.optional(Schema.Literal('default', 'alert').annotations({ description: 'The type of dialog.' })),
-        blockAlign: Schema.optional(
-          Schema.Literal('start', 'center', 'end').annotations({ description: 'The alignment of the dialog.' }),
-        ),
-        overlayClasses: Schema.optional(
-          Schema.String.annotations({ description: 'Additional classes for the dialog overlay.' }),
-        ),
-        overlayStyle: Schema.optional(
-          Schema.Record({ key: Schema.String, value: Schema.Any }).annotations({
-            description: 'Additional styles for the dialog overlay.',
-          }),
-        ),
-        props: Schema.optional(
-          Schema.Record({ key: Schema.String, value: Schema.Any }).annotations({
-            description: 'Additional props for the dialog.',
-          }),
-        ),
-      }),
-      output: Schema.Void,
-    },
-  });
-
-  //
-  // Popover Operations
-  //
-
-  const PopoverBaseInput = Schema.Struct({
-    subject: Schema.optional(
-      Schema.Any.annotations({
-        description: 'URI of the component to display in the popover or data to pass to the popover.',
-      }),
-    ),
-    side: Schema.optional(
-      Schema.Literal('top', 'right', 'bottom', 'left').annotations({ description: 'The side of the anchor.' }),
-    ),
-    state: Schema.optional(Schema.Boolean.annotations({ description: 'Whether the popover is open or closed.' })),
-    props: Schema.optional(
-      Schema.Record({ key: Schema.String, value: Schema.Any }).annotations({
-        description: 'Additional props for the popover.',
-      }),
-    ),
-  });
-
-  const PopoverBaseWithKind = Schema.Union(
-    PopoverBaseInput.pipe(
-      Schema.extend(
-        Schema.Struct({
-          kind: Schema.Literal('base').pipe(Schema.optional),
-        }),
-      ),
-    ),
-    PopoverBaseInput.pipe(
-      Schema.extend(
-        Schema.Struct({
-          kind: Schema.Literal('card'),
-          title: Schema.optional(Label.annotations({ description: 'The title of the card.' })),
-        }),
-      ),
-    ),
-  );
-
-  export const UpdatePopover = Operation.make({
-    meta: {
-      key: `${LAYOUT_PLUGIN}/operation/update-popover`,
-      name: 'Update Popover',
-      description: 'Open, close, or update a popover.',
-    },
-    executionMode: 'sync',
-    services: [Capability.Service],
-    schema: {
-      input: Schema.Union(
-        PopoverBaseWithKind.pipe(
-          Schema.extend(
-            Schema.Struct({
-              variant: Schema.Literal('virtual'),
-              anchor: Schema.Any.annotations({ description: 'The DOM element to anchor the popover to.' }),
-            }),
-          ),
-        ),
-        PopoverBaseWithKind.pipe(
-          Schema.extend(
-            Schema.Struct({
-              variant: Schema.optional(Schema.Literal('react')),
-              anchorId: Schema.String.annotations({
-                description: 'An id that can be used to determine whether to render the anchor subcomponent.',
-              }),
-            }),
-          ),
-        ),
-      ),
-      output: Schema.Void,
-    },
-  });
-
-  //
-  // Toast Operations
-  //
-
-  export const Toast = Schema.Struct({
-    id: Schema.String.annotations({ description: 'The id of the toast.' }),
-    title: Schema.optional(Label.annotations({ description: 'The title of the toast.' })),
-    description: Schema.optional(Label.annotations({ description: 'The description of the toast.' })),
-    icon: Schema.optional(Schema.String.annotations({ description: 'The icon of the toast.' })),
-    duration: Schema.optional(Schema.Number.annotations({ description: 'The duration of the toast.' })),
-    closeLabel: Schema.optional(Label.annotations({ description: 'The label of the close button.' })),
-    actionLabel: Schema.optional(Label.annotations({ description: 'The label of the action button.' })),
-    actionAlt: Schema.optional(Label.annotations({ description: 'The alt text of the action button.' })),
-    onAction: Schema.optional(
-      Schema.Any.annotations({ description: 'The action to perform when the action button is clicked.' }),
-    ),
-  });
-
-  export interface Toast extends Omit<Schema.Schema.Type<typeof Toast>, 'onAction'> {
-    onAction?: () => void;
-  }
-
-  export const AddToast = Operation.make({
-    meta: {
-      key: `${LAYOUT_PLUGIN}/operation/add-toast`,
-      name: 'Add Toast',
-      description: 'Add a toast notification.',
-    },
-    executionMode: 'sync',
-    services: [Capability.Service],
-    schema: {
-      input: Toast,
-      output: Schema.Void,
-    },
-  });
-
-  //
-  // Layout Mode Operations
-  //
-
-  export const SetLayoutMode = Operation.make({
-    meta: {
-      key: `${LAYOUT_PLUGIN}/operation/set-layout-mode`,
-      name: 'Set Layout Mode',
-      description: 'Set the layout mode (solo, deck, fullscreen, etc.).',
-    },
-    executionMode: 'sync',
-    services: [Capability.Service],
-    schema: {
-      input: Schema.Union(
-        Schema.Struct({
-          subject: Schema.optional(
-            Schema.String.annotations({ description: 'Item which is the subject of the new layout mode.' }),
-          ),
-          mode: Schema.String.annotations({ description: 'The new layout mode.' }),
-        }),
-        Schema.Struct({
-          revert: Schema.Boolean.annotations({ description: 'Revert to the previous layout mode.' }),
-        }),
-      ),
-      output: Schema.Void,
-    },
-  });
-
-  //
-  // Workspace Operations
-  //
-
-  export const SwitchWorkspace = Operation.make({
-    meta: {
-      key: `${LAYOUT_PLUGIN}/operation/switch-workspace`,
-      name: 'Switch Workspace',
-      description: 'Switch to a different workspace.',
-    },
-    executionMode: 'sync',
-    services: [Capability.Service],
-    schema: {
-      input: Schema.Struct({
-        subject: Schema.String.annotations({ description: 'The id of the workspace to switch to.' }),
-      }),
-      output: Schema.Void,
-    },
-  });
-
-  export const RevertWorkspace = Operation.make({
-    meta: {
-      key: `${LAYOUT_PLUGIN}/operation/revert-workspace`,
-      name: 'Revert Workspace',
-      description: 'Revert to the previous workspace.',
-    },
-    executionMode: 'sync',
-    services: [Capability.Service],
-    schema: {
-      input: Schema.Void,
-      output: Schema.Void,
-    },
-  });
-
-  //
-  // Main Content Operations
-  //
-
-  export const Open = Operation.make({
-    meta: {
-      key: `${LAYOUT_PLUGIN}/operation/open`,
-      name: 'Open',
-      description: 'Open items in the main content area.',
-    },
-    executionMode: 'sync',
-    services: [Capability.Service],
-    schema: {
-      input: Schema.Struct({
-        subject: Schema.Array(Schema.String.annotations({ description: 'Ids of the items to open.' })),
-        state: Schema.optional(Schema.Literal(true).annotations({ description: 'The items are being added.' })),
-        variant: Schema.optional(Schema.String.annotations({ description: 'The variant of the item to open.' })),
-        key: Schema.optional(
-          Schema.String.annotations({
-            description: 'If provided, will replace item with a matching key (id prefix).',
-          }),
-        ),
-        workspace: Schema.optional(Schema.String.annotations({ description: 'The workspace to open the items in.' })),
-        scrollIntoView: Schema.optional(Schema.Boolean.annotations({ description: 'Scroll the items into view.' })),
-        pivotId: Schema.optional(
-          Schema.String.annotations({ description: 'The id of the item to place new items next to.' }),
-        ),
-        positioning: Schema.optional(
-          Schema.Union(
-            Schema.Literal('start').annotations({ description: 'The items are being added before the pivot item.' }),
-            Schema.Literal('end').annotations({ description: 'The items are being added after the pivot item.' }),
-          ),
-        ),
-      }),
-      output: Schema.Void,
-    },
-  });
-
-  export const Close = Operation.make({
-    meta: {
-      key: `${LAYOUT_PLUGIN}/operation/close`,
-      name: 'Close',
-      description: 'Close items in the main content area.',
-    },
-    executionMode: 'sync',
-    services: [Capability.Service],
-    schema: {
-      input: Schema.Struct({
-        subject: Schema.Array(Schema.String.annotations({ description: 'Ids of the items to close.' })),
-      }),
-      output: Schema.Void,
-    },
-  });
-
-  export const Set = Operation.make({
-    meta: {
-      key: `${LAYOUT_PLUGIN}/operation/set`,
-      name: 'Set',
-      description: 'Override items in the main content area.',
-    },
-    executionMode: 'sync',
-    services: [Capability.Service],
-    schema: {
-      input: Schema.Struct({
-        subject: Schema.Array(Schema.String.annotations({ description: 'Ids of the items to set.' })),
-      }),
-      output: Schema.Void,
-    },
-  });
-
-  //
-  // Navigation Operations
-  //
-
-  export const ScrollIntoView = Operation.make({
-    meta: {
-      key: `${LAYOUT_PLUGIN}/operation/scroll-into-view`,
-      name: 'Scroll Into View',
-      description: 'Scroll an item into view.',
-    },
-    services: [Capability.Service],
-    schema: {
-      input: Schema.Struct({
-        subject: Schema.optional(Schema.String.annotations({ description: 'The id of the item to scroll into view.' })),
-        cursor: Schema.optional(Schema.String.annotations({ description: 'A cursor to scroll to within the item.' })),
-        ref: Schema.optional(Schema.String.annotations({ description: 'A reference id for the scroll target.' })),
-      }),
-      output: Schema.Void,
-    },
-  });
-
-  export const Expose = Operation.make({
-    meta: {
-      key: `${LAYOUT_PLUGIN}/operation/expose`,
-      name: 'Expose',
-      description: 'Expose an item in the navigation area.',
-    },
-    services: [Capability.Service],
-    schema: {
-      input: Schema.Struct({
-        subject: Schema.String.annotations({ description: 'The id of the item to expose.' }),
-      }),
-      output: Schema.Void,
-    },
-  });
-}
-
-const UNDO_NAMESPACE = 'dxos.org/app-framework/undo';
+const UNDO_NAMESPACE = 'org.dxos.app-framework.undo';
 
 /**
  * Operations related to undo/history functionality.
@@ -396,17 +21,15 @@ export namespace UndoOperation {
    */
   export const ShowUndo = Operation.make({
     meta: {
-      key: `${UNDO_NAMESPACE}/operation/show-undo`,
+      key: `${UNDO_NAMESPACE}.operation.show-undo`,
       name: 'Show Undo',
       description: 'Show an undo toast notification.',
     },
     executionMode: 'sync',
     services: [Capability.Service],
-    schema: {
-      input: Schema.Struct({
-        message: Schema.optional(Label.annotations({ description: 'The message to display in the undo toast.' })),
-      }),
-      output: Schema.Void,
-    },
+    input: Schema.Struct({
+      message: Schema.optional(Label.annotations({ description: 'The message to display in the undo toast.' })),
+    }),
+    output: Schema.Void,
   });
 }

package/src/common/translations.ts

@@ -23,15 +23,3 @@ export const Label = Schema.Union(
   ),
 );
 export type Label = Schema.Schema.Type<typeof Label>;
-
-export const ResourceKey = Schema.Union(Schema.String, Schema.Record({ key: Schema.String, value: Schema.Any }));
-export type ResourceKey = Schema.Schema.Type<typeof ResourceKey>;
-
-export const ResourceLanguage = Schema.Record({ key: Schema.String, value: ResourceKey });
-export type ResourceLanguage = Schema.Schema.Type<typeof ResourceLanguage>;
-
-/**
- * A resource is a collection of translations for a language.
- */
-export const Resource = Schema.Record({ key: Schema.String, value: ResourceLanguage });
-export type Resource = Schema.Schema.Type<typeof Resource>;

package/src/context.ts

@@ -6,4 +6,4 @@ import { createContext } from '@dxos/web-context';
 
 import { type PluginManager } from './core';
 
-export const PluginManagerContext = createContext<PluginManager.PluginManager>('dxos.org/app-framework/plugin-manager');
+export const PluginManagerContext = createContext<PluginManager.PluginManager>('org.dxos.app-framework.plugin-manager');

package/src/core/activation-event.ts

@@ -2,11 +2,13 @@
 // Copyright 2025 DXOS.org
 //
 
+import { compositeKey } from '@dxos/util';
+
 /**
  * A unique string identifier representing an event.
  * This is expected to be a URI, where initial parts are often the id of the plugin whose package defines the event.
  *
- * @example dxos.org/plugin/example/event/ready
+ * @example org.dxos.plugin.example.event.ready
  */
 export type ActivationEvent = {
   id: string;
@@ -31,7 +33,8 @@ export const make = (id: string, specifier?: string) => {
 /**
  * Helper to create an activation event key.
  */
-export const eventKey = (event: ActivationEvent) => (event.specifier ? `${event.id}:${event.specifier}` : event.id);
+export const eventKey = (event: ActivationEvent) =>
+  event.specifier ? compositeKey(event.id, event.specifier) : event.id;
 
 /**
  * Helper to create an activation event that triggers when any of the given events are activated.

package/src/core/capability-manager.test.ts

@@ -2,8 +2,8 @@
 // Copyright 2025 DXOS.org
 //
 
-import { describe, expect, it, onTestFinished } from '@effect/vitest';
 import { Registry } from '@effect-atom/atom-react';
+import { describe, expect, it, onTestFinished } from '@effect/vitest';
 import * as Effect from 'effect/Effect';
 
 import * as Capability from './capability';

package/src/core/capability-manager.ts

@@ -59,6 +59,12 @@ export interface CapabilityManager {
    * @returns The capability.
    */
   waitFor<T>(interfaceDef: Capability.InterfaceDef<T>): Effect.Effect<T, Error>;
+
+  /**
+   * Get capabilities grouped by the module that contributed them.
+   * @returns An atom containing a record from module ID to capability implementations.
+   */
+  atomByModule<T>(interfaceDef: Capability.InterfaceDef<T>): Atom.Atom<Record<string, T[]>>;
 }
 
 /**
@@ -75,7 +81,18 @@ class CapabilityManagerImpl implements CapabilityManager {
     return Atom.make((get) => {
       const current = get(this._capabilityEntries(id));
       return current.map((c) => c.implementation);
-    });
+    }).pipe(Atom.keepAlive);
+  });
+
+  readonly _capabilitiesByModule = Atom.family<string, Atom.Atom<Record<string, unknown[]>>>((id: string) => {
+    return Atom.make((get) => {
+      const entries = get(this._capabilityEntries(id));
+      const result: Record<string, unknown[]> = {};
+      for (const entry of entries) {
+        (result[entry.moduleId] ??= []).push(entry.implementation);
+      }
+      return result;
+    }).pipe(Atom.keepAlive);
   });
 
   readonly _capability = Atom.family<string, Atom.Atom<unknown>>((id: string) => {
@@ -163,6 +180,10 @@ class CapabilityManagerImpl implements CapabilityManager {
       return result;
     });
   }
+
+  atomByModule<T>(interfaceDef: Capability.InterfaceDef<T>): Atom.Atom<Record<string, T[]>> {
+    return this._capabilitiesByModule(interfaceDef.identifier) as Atom.Atom<Record<string, T[]>>;
+  }
 }
 
 /**

package/src/core/capability.ts

@@ -62,6 +62,16 @@ export const waitFor = <T>(interfaceDef: InterfaceDef<T>): Effect.Effect<T, Erro
 export const atom = <T>(interfaceDef: InterfaceDef<T>): Effect.Effect<Atom.Atom<T[]>, never, Service> =>
   Effect.map(Service, (manager) => manager.atom(interfaceDef));
 
+/**
+ * Get capabilities grouped by the module that contributed them.
+ * @param interfaceDef The interface definition of the capability.
+ * @returns An Atom containing a record from module ID to capability implementations.
+ */
+export const atomByModule = <T>(
+  interfaceDef: InterfaceDef<T>,
+): Effect.Effect<Atom.Atom<Record<string, T[]>>, never, Service> =>
+  Effect.map(Service, (manager) => manager.atomByModule(interfaceDef));
+
 const InterfaceDefTypeId: unique symbol = Symbol.for('InterfaceDefTypeId');
 
 /**
@@ -120,6 +130,7 @@ export type ModuleReturn = void | Any | Any[] | readonly Any[] | [Any, ...Any[]]
 /**
  * Helper to define the implementation of a capability.
  */
+// TODO(dmaretskyi): Make the return type non-generic so capabilities are non-discernable.
 export const contributes = <I extends InterfaceDef<any>>(
   interfaceDef: I,
   implementation: Capability<InterfaceDef.Implementation<I>>['implementation'],
@@ -133,10 +144,10 @@ export const contributes = <I extends InterfaceDef<any>>(
 };
 
 type LoadCapability<Props, Capabilities extends ModuleReturn = ModuleReturn> = () => Promise<{
-  default: (props?: Props) => Effect.Effect<Capabilities, Error, Service | Plugin.Service | never>;
+  default: (props: Props) => Effect.Effect<Capabilities, Error, Service | Plugin.Service | never>;
 }>;
 type LoadCapabilities<Props, Capabilities extends ModuleReturn = ModuleReturn> = () => Promise<{
-  default: (props?: Props) => Effect.Effect<Capabilities, Error, Service | Plugin.Service | never>;
+  default: (props: Props) => Effect.Effect<Capabilities, Error, Service | Plugin.Service | never>;
 }>;
 
 type NormalizeReturn<R> = R extends readonly (infer A)[]
@@ -148,7 +159,7 @@ type NormalizeReturn<R> = R extends readonly (infer A)[]
       : Any[];
 
 export type LazyCapability<Props = void, Capabilities extends ModuleReturn = ModuleReturn, E extends Error = Error> = (
-  props?: Props,
+  props: Props,
 ) => Effect.Effect<NormalizeReturn<Capabilities>, E, Service | Plugin.Service | never>;
 
 /**
@@ -162,9 +173,9 @@ export const lazy = <T = void, R extends ModuleReturn = ModuleReturn>(
   name: string,
   c: LoadCapability<T, R> | LoadCapabilities<T, R>,
 ): LazyCapability<T, R> => {
-  const lazyFn: LazyCapability<T, R> = (props?: T) =>
+  const lazyFn: LazyCapability<T, R> = (props: T) =>
     Effect.gen(function* () {
-      const { default: getCapability } = yield* Effect.tryPromise(() => c());
+      const { default: getCapability } = yield* Effect.promise(() => c());
       const result = yield* getCapability(props);
       const normalized = result == null ? [] : Array.isArray(result) ? Array.from(result) : [result];
       return normalized as NormalizeReturn<R>;
@@ -217,10 +228,10 @@ export const getModuleTag = (capability: unknown): string | undefined => {
  *   })
  * );
  *
- * // Module with additional options (context accessed via layer)
+ * // Module with required options (context accessed via layer)
  * export default Capability.makeModule(
- *   Effect.fnUntraced(function* ({ observability }: { observability?: boolean }) {
- *     const invoker = yield* Capability.get(Common.Capability.OperationInvoker);
+ *   Effect.fnUntraced(function* (props: { observability: boolean }) {
+ *     const invoker = yield* Capability.get(Capabilities.OperationInvoker);
  *     return contributes(Capabilities.IntentResolver, ...);
  *   })
  * );
@@ -232,5 +243,5 @@ export const makeModule = <
   E extends Error = Error,
   R extends Service | Plugin.Service | never = Service,
 >(
-  fn: (props?: TProps) => Effect.Effect<TReturn, E, R>,
-): ((props?: TProps) => Effect.Effect<TReturn, E, R>) => fn;
+  fn: (props: TProps) => Effect.Effect<TReturn, E, R>,
+): ((props: TProps) => Effect.Effect<TReturn, E, R>) => fn;

package/src/core/index.ts

@@ -7,3 +7,4 @@ export * as Capability from './capability';
 export * as CapabilityManager from './capability-manager';
 export * as Plugin from './plugin';
 export * as PluginManager from './plugin-manager';
+export * as UrlLoader from './url-loader';