@dxos/app-framework 0.8.4-main.ef1bc66f44 → 0.8.4-main.effb148878

package/src/common/operations.ts

@@ -4,13 +4,12 @@
 
 import * as Schema from 'effect/Schema';
 
-import { Operation } from '@dxos/operation';
+import { Operation } from '@dxos/compute';
 
 import { Capability } from '../core';
-
 import { Label } from './translations';
 
-const UNDO_NAMESPACE = 'dxos.org/app-framework/undo';
+const UNDO_NAMESPACE = 'org.dxos.app-framework.undo';
 
 /**
  * Operations related to undo/history functionality.
@@ -22,17 +21,16 @@ 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.',
+      icon: 'ph--arrow-counter-clockwise--regular',
     },
     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/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

@@ -5,6 +5,7 @@
 import { type Atom } from '@effect-atom/atom-react';
 import * as Context from 'effect/Context';
 import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
 
 import type * as CapabilityManager from './capability-manager';
 import type * as Plugin from './plugin';
@@ -62,6 +63,22 @@ 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));
+
+/**
+ * Constructs a layer that will request its interface implementation from the capability manager.
+ */
+export const asLayer = <T, I>(interfaceDef: InterfaceDef<T>, tag: Context.Tag<I, T>): Layer.Layer<I, never, Service> =>
+  Layer.effect(tag, get(interfaceDef).pipe(Effect.orDie));
+
 const InterfaceDefTypeId: unique symbol = Symbol.for('InterfaceDefTypeId');
 
 /**
@@ -120,6 +137,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 +151,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 +166,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 +180,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,11 +235,11 @@ 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 }) {
+ *   Effect.fnUntraced(function* (props: { observability: boolean }) {
  *     const invoker = yield* Capability.get(Capabilities.OperationInvoker);
- *     return contributes(Capabilities.IntentResolver, ...);
+ *     return contributes(Capabilities.OperationHandler, ...);
  *   })
  * );
  * ```
@@ -232,5 +250,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/edge-registry-plugin-provider.ts

@@ -0,0 +1,92 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Context } from '@dxos/context';
+import { type EdgeHttpClient } from '@dxos/edge-client';
+import { type PluginEntry } from '@dxos/protocols';
+
+import * as Registry from './registry';
+
+/**
+ * Maps a wire-format `PluginEntry` (from `@dxos/protocols`) to a
+ * `Registry.Plugin` (the app-framework domain type).
+ *
+ * This is the only translation seam between the two independently-defined type
+ * hierarchies — fields are mapped explicitly, with no shared type between them.
+ */
+const toRegistryPlugin = (entry: PluginEntry): Registry.Plugin => ({
+  id: entry.meta.id,
+  name: entry.meta.name,
+  description: entry.meta.description,
+  homePage: entry.meta.homePage,
+  source: entry.meta.source,
+  screenshots: entry.meta.screenshots ? [...entry.meta.screenshots] : undefined,
+  tags: entry.meta.tags ? [...entry.meta.tags] : undefined,
+  icon: entry.meta.icon,
+  iconHue: entry.meta.iconHue,
+  moduleUrl: entry.moduleUrl,
+  repo: entry.repo,
+  version: entry.releaseTag,
+});
+
+/**
+ * Implements `Registry.PluginProvider` against the Edge `/registry` HTTP endpoints.
+ *
+ * Lives in app-framework (rather than the more obvious home of `@dxos/edge-client`)
+ * because edge-client doesn't depend on app-framework; siting the implementation
+ * here keeps the dependency arrow `app-framework → edge-client` and avoids a
+ * cycle. The class needs only the public `EdgeHttpClient` type, so a one-way
+ * type-import is enough.
+ *
+ * `listVersions` is currently a stub: it returns the single latest version derived
+ * from the cached plugin list, so the host's version picker has something to render.
+ * The wire contract for the real endpoint already exists — see
+ * `GetPluginVersionsResponseBodySchema` in `@dxos/protocols/edge/registry` and
+ * {@link EdgeHttpClient.getRegistryPluginVersions} — so once Edge ships
+ * `GET /registry/plugins/:repo/versions`, swap this stub for a call to
+ * `this._client.getRegistryPluginVersions(...)` and map each entry through a
+ * `toRegistryPluginVersion` helper (mirror of {@link toRegistryPlugin}).
+ */
+export class EdgeRegistryPluginProvider implements Registry.PluginProvider {
+  // Cached on first load so getPlugin/listVersions can resolve without re-fetching.
+  #cachedPlugins: readonly Registry.Plugin[] = [];
+
+  constructor(private readonly _client: EdgeHttpClient) {}
+
+  listPlugins(): Effect.Effect<readonly Registry.Plugin[], Error> {
+    return Effect.tryPromise({
+      try: () => this._client.getRegistryPlugins(Context.default()),
+      catch: (error) => (error instanceof Error ? error : new Error(String(error))),
+    }).pipe(
+      Effect.map((body) => {
+        const plugins = body.plugins.filter((entry) => entry.health === 'ok').map(toRegistryPlugin);
+        this.#cachedPlugins = plugins;
+        return plugins;
+      }),
+    );
+  }
+
+  listVersions(repo: string): Effect.Effect<readonly Registry.PluginVersion[], Error> {
+    // Stub: return only the currently-known version until Edge implements the versions endpoint.
+    const plugin = this.#cachedPlugins.find((candidate) => candidate.repo === repo);
+    if (!plugin) {
+      return Effect.fail(new Error(`Plugin not found in catalog: ${repo}`));
+    }
+    const version: Registry.PluginVersion = { tag: plugin.version, moduleUrl: plugin.moduleUrl };
+    return Effect.succeed([version]);
+  }
+
+  getPlugin(repo: string, version?: string): Effect.Effect<Registry.Plugin, Error> {
+    const plugin = this.#cachedPlugins.find((p) => p.repo === repo);
+    if (!plugin) {
+      return Effect.fail(new Error(`Plugin not found in catalog: ${repo}`));
+    }
+    if (version && version !== plugin.version) {
+      return Effect.fail(new Error(`Version ${version} not available for ${repo}; only ${plugin.version} is cached`));
+    }
+    return Effect.succeed(plugin);
+  }
+}

package/src/core/index.ts

@@ -6,4 +6,10 @@ export * as ActivationEvent from './activation-event';
 export * as Capability from './capability';
 export * as CapabilityManager from './capability-manager';
 export * as Plugin from './plugin';
+export * as PluginAssetCache from './plugin-asset-cache';
 export * as PluginManager from './plugin-manager';
+export * as PluginManifest from './plugin-manifest';
+export { PLUGIN_DEV_SERVER_PORT } from './plugin-manifest';
+export * as Registry from './registry';
+export { EdgeRegistryPluginProvider } from './edge-registry-plugin-provider';
+export * as UrlLoader from './url-loader';

package/src/core/plugin-asset-cache.ts

@@ -0,0 +1,60 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { BaseError } from '@dxos/errors';
+
+/**
+ * Tagged error for cache operations. Construction sites supply `context.operation`
+ * (one of `'cache' | 'evict' | 'resolve' | 'list'`) and `context.pluginId` so
+ * downstream handlers can route on the failed call without scanning the message.
+ */
+export class PluginAssetCacheError extends BaseError.extend(
+  'PluginAssetCacheError',
+  'Plugin asset cache operation failed',
+) {}
+
+/**
+ * Per-platform offline cache for third-party plugin assets.
+ *
+ * Implementations live alongside their platform glue (composer-app's
+ * `asset-cache/{tauri,service-worker}.ts`); the no-op default is for tests
+ * and unsupported environments.
+ */
+export interface Cache {
+  /**
+   * Persist all listed URLs under the namespace of `pluginId`. Idempotent.
+   * The order of `urls` is significant — the first entry is treated as the entry module.
+   */
+  cache(pluginId: string, urls: readonly string[]): Effect.Effect<void, PluginAssetCacheError>;
+
+  /**
+   * Drop all assets for a plugin (uninstall).
+   */
+  evict(pluginId: string): Effect.Effect<void, PluginAssetCacheError>;
+
+  /**
+   * Resolves a plugin asset URL to a platform-specific cached URL when one is available.
+   * Returns the original URL when no cached copy exists or the platform serves cached
+   * responses transparently (e.g. service worker fetch interception on web).
+   */
+  resolve(pluginId: string, url: string): Effect.Effect<string, PluginAssetCacheError>;
+
+  /**
+   * List currently cached plugin ids (diagnostic).
+   */
+  list(): Effect.Effect<readonly string[], PluginAssetCacheError>;
+}
+
+/**
+ * No-op implementation. Used when no platform cache is registered (tests, unsupported environments).
+ * Plugins still load — they just have no offline guarantee.
+ */
+export const noop = (): Cache => ({
+  cache: () => Effect.void,
+  evict: () => Effect.void,
+  resolve: (_pluginId, url) => Effect.succeed(url),
+  list: () => Effect.succeed([] as readonly string[]),
+});