@dxos/app-framework 0.9.0 → 0.9.1-staging.ee54ba693a

package/src/common/capabilities.ts

@@ -13,9 +13,9 @@ import type * as Runtime$ from 'effect/Runtime';
 import type { FC, PropsWithChildren } from 'react';
 
 import type {
+  OperationHandlerSet,
   LayerSpec as LayerSpec$,
   Operation as Operation$,
-  OperationHandlerSet,
   Process as Process$,
   ServiceResolver as ServiceResolver$,
   Trace as Trace$,
@@ -41,13 +41,13 @@ export const Null = Capability$.make<null>('org.dxos.app-framework.capability.nu
  * @category Capability
  */
 export const PluginManager = Capability$.make<PluginManager$.PluginManager>(
-  'org.dxos.app-framework.capability.plugin-manager',
+  'org.dxos.app-framework.capability.pluginManager',
 );
 
 /**
  * @category Capability
  */
-export const AtomRegistry = Capability$.make<Registry.Registry>('org.dxos.app-framework.capability.atom-registry');
+export const AtomRegistry = Capability$.make<Registry.Registry>('org.dxos.app-framework.capability.atomRegistry');
 
 export type ReactContext = Readonly<{
   id: string;
@@ -58,14 +58,14 @@ export type ReactContext = Readonly<{
 /**
  * @category Capability
  */
-export const ReactContext = Capability$.make<ReactContext>('org.dxos.app-framework.capability.react-context');
+export const ReactContext = Capability$.make<ReactContext>('org.dxos.app-framework.capability.reactContext');
 
 export type ReactRoot = Readonly<{ id: string; root: FC<PropsWithChildren> }>;
 
 /**
  * @category Capability
  */
-export const ReactRoot = Capability$.make<ReactRoot>('org.dxos.app-framework.capability.react-root');
+export const ReactRoot = Capability$.make<ReactRoot>('org.dxos.app-framework.capability.reactRoot');
 
 /**
  * Surface definitions that can be either React components or Web Components.
@@ -75,7 +75,7 @@ export type ReactSurface = Surface.Definition | readonly Surface.Definition[];
 /**
  * @category Capability
  */
-export const ReactSurface = Capability$.make<ReactSurface>('org.dxos.app-framework.common.react-surface');
+export const ReactSurface = Capability$.make<ReactSurface>('org.dxos.app-framework.capability.reactSurface');
 
 export type AnyCommand = Command$.Command<any, any, any, any>;
 
@@ -98,7 +98,7 @@ export const Layer = Capability$.make<Layer$.Layer<any, any, any>>('org.dxos.app
  *
  * @category Capability
  */
-export const LayerSpec = Capability$.make<LayerSpec$.LayerSpec>('org.dxos.app-framework.capability.layer-spec');
+export const LayerSpec = Capability$.make<LayerSpec$.LayerSpec>('org.dxos.app-framework.capability.layerSpec');
 
 /**
  * Context passed to {@link TraceSinkFactory} implementations when the
@@ -133,7 +133,7 @@ export type TraceSinkFactory = (ctx: TraceSinkFactoryContext) => Trace$.Sink;
  *
  * @category Capability
  */
-export const TraceSink = Capability$.make<TraceSinkFactory>('org.dxos.app-framework.capability.trace-sink');
+export const TraceSink = Capability$.make<TraceSinkFactory>('org.dxos.app-framework.capability.traceSink');
 
 /**
  * Service resolver backing the shared {@link ProcessManagerRuntime}.
@@ -147,7 +147,7 @@ export const TraceSink = Capability$.make<TraceSinkFactory>('org.dxos.app-framew
  * const resolver = yield* Capability.get(Capabilities.ServiceResolver);
  * yield* effect.pipe(
  *   Effect.provide(
- *     ServiceResolver.provide({ space }, Database.Service, Feed.FeedService).pipe(
+ *     ServiceResolver.provide({ space }, Database.Service).pipe(
  *       Layer.provide(Layer.succeed(ServiceResolver.ServiceResolver, resolver)),
  *     ),
  *   ),
@@ -157,7 +157,7 @@ export const TraceSink = Capability$.make<TraceSinkFactory>('org.dxos.app-framew
  * @category Capability
  */
 export const ServiceResolver = Capability$.make<ServiceResolver$.ServiceResolver>(
-  'org.dxos.app-framework.capability.service-resolver',
+  'org.dxos.app-framework.capability.serviceResolver',
 );
 
 /**
@@ -167,7 +167,7 @@ export const ServiceResolver = Capability$.make<ServiceResolver$.ServiceResolver
  *
  * @category Capability
  */
-export const ProcessMonitor = Capability$.make<Process$.Monitor>('org.dxos.app-framework.capability.process-monitor');
+export const ProcessMonitor = Capability$.make<Process$.Monitor>('org.dxos.app-framework.capability.processMonitor');
 
 /**
  * Services that are always available when running effects through a {@link ProcessManagerRuntime}.
@@ -207,7 +207,7 @@ export interface ProcessManagerRuntime {
  * @category Capability
  */
 export const ProcessManagerRuntime = Capability$.make<ProcessManagerRuntime>(
-  'org.dxos.app-framework.capability.process-manager-runtime',
+  'org.dxos.app-framework.capability.processManagerRuntime',
 );
 
 export type ManagedRuntime = ManagedRuntime$.ManagedRuntime<any, any>;
@@ -215,14 +215,14 @@ export type ManagedRuntime = ManagedRuntime$.ManagedRuntime<any, any>;
 /**
  * @category Capability
  */
-export const ManagedRuntime = Capability$.make<ManagedRuntime>('org.dxos.app-framework.capability.managed-runtime');
+export const ManagedRuntime = Capability$.make<ManagedRuntime>('org.dxos.app-framework.capability.managedRuntime');
 
 //
 // Operation System Capabilities
 //
 
 export const OperationHandler = Capability$.make<OperationHandlerSet.OperationHandlerSet>(
-  'org.dxos.app-framework.capability.operation-handler',
+  'org.dxos.app-framework.capability.operationHandler',
 );
 
 export type UndoMapping = UndoMapping$.UndoMapping;
@@ -231,7 +231,7 @@ export type UndoMapping = UndoMapping$.UndoMapping;
  * Undo mapping registration - contributed by plugins.
  * @category Capability
  */
-export const UndoMapping = Capability$.make<UndoMapping[]>('org.dxos.app-framework.capability.undo-mapping');
+export const UndoMapping = Capability$.make<UndoMapping[]>('org.dxos.app-framework.capability.undoMapping');
 
 /**
  * Operation invoker backed by the process manager. Spawns a process per
@@ -244,7 +244,7 @@ export type OperationInvoker = OperationInvoker$.OperationInvoker;
  * @category Capability
  */
 export const OperationInvoker = Capability$.make<OperationInvoker>(
-  'org.dxos.app-framework.capability.operation-invoker',
+  'org.dxos.app-framework.capability.operationInvoker',
 );
 
 export type UndoRegistry = UndoRegistry$.UndoRegistry;
@@ -253,7 +253,7 @@ export type UndoRegistry = UndoRegistry$.UndoRegistry;
  * Undo registry - provided by ProcessManagerPlugin.
  * @category Capability
  */
-export const UndoRegistry = Capability$.make<UndoRegistry>('org.dxos.app-framework.capability.undo-registry');
+export const UndoRegistry = Capability$.make<UndoRegistry>('org.dxos.app-framework.capability.undoRegistry');
 
 export type HistoryTracker = HistoryTracker$.HistoryTracker;
 
@@ -261,7 +261,7 @@ export type HistoryTracker = HistoryTracker$.HistoryTracker;
  * History tracker - provided by ProcessManagerPlugin.
  * @category Capability
  */
-export const HistoryTracker = Capability$.make<HistoryTracker>('org.dxos.app-framework.capability.history-tracker');
+export const HistoryTracker = Capability$.make<HistoryTracker>('org.dxos.app-framework.capability.historyTracker');
 
 //
 // Atom Capability Helpers

package/src/config/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+export { Config2 } from '@dxos/protocols';

package/src/core/activation-event.ts

@@ -2,16 +2,16 @@
 // Copyright 2025 DXOS.org
 //
 
+import { DXN } from '@dxos/keys';
 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.
+ * A unique DXN identifier representing an event.
  *
- * @example org.dxos.plugin.example.event.ready
+ * @example dxn:org.dxos.plugin.example.event.ready
  */
 export type ActivationEvent = {
-  id: string;
+  id: DXN.DXN;
   specifier?: string;
 };
 
@@ -24,11 +24,18 @@ export type Events =
   | { type: 'all-of'; events: ActivationEvent[] };
 
 /**
- * Helper to define an activation event.
+ * Helper to define an activation event from an NSID.
+ * Static NSID strings are validated at compile time via {@link DXN.Name}.
  */
-export const make = (id: string, specifier?: string) => {
-  return { id, specifier } as ActivationEvent;
-};
+export const make: {
+  <T extends string>(
+    nsid: [DXN.Name<T>] extends [never] ? `Invalid NSID "${T}": final segment must be camelCase (no hyphens)` : T,
+    specifier?: string,
+  ): ActivationEvent;
+} = (nsid: string, specifier?: string): ActivationEvent => ({
+  id: DXN.make(nsid),
+  specifier,
+});
 
 /**
  * Helper to create an activation event key.

package/src/core/capability.ts

@@ -7,6 +7,8 @@ import * as Context from 'effect/Context';
 import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 
+import type { DXN } from '@dxos/keys';
+
 import type * as CapabilityManager from './capability-manager';
 import type * as Plugin from './plugin';
 
@@ -100,8 +102,13 @@ export namespace InterfaceDef {
 
 /**
  * Helper to define the interface of a capability.
+ * Static NSID strings are validated at compile time via {@link DXN.Name}.
  */
-export const make = <T>(identifier: string) => {
+export const make: {
+  <T, S extends string = string>(
+    identifier: [DXN.Name<S>] extends [never] ? `Invalid NSID "${S}": final segment must be camelCase (no hyphens)` : S,
+  ): InterfaceDef<T>;
+} = <T>(identifier: string): InterfaceDef<T> => {
   return { identifier } as InterfaceDef<T>;
 };
 
@@ -136,13 +143,14 @@ export type ModuleReturn = void | Any | Any[] | readonly Any[] | [Any, ...Any[]]
 
 /**
  * Helper to define the implementation of a capability.
+ * Returns the opaque base type so callers cannot discriminate on capability kind,
+ * keeping d.ts emit portable across packages.
  */
-// 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'],
   deactivate?: Capability<InterfaceDef.Implementation<I>>['deactivate'],
-): Capability<I> => {
+): Any => {
   return {
     interface: interfaceDef,
     implementation,
@@ -179,8 +187,8 @@ export type LazyCapability<Props = void, Capabilities extends ModuleReturn = Mod
 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) =>
+): LazyCapability<T> => {
+  const lazyFn = (props: T) =>
     Effect.gen(function* () {
       const { default: getCapability } = yield* Effect.promise(() => c());
       const result = yield* getCapability(props);
@@ -188,7 +196,11 @@ export const lazy = <T = void, R extends ModuleReturn = ModuleReturn>(
       return normalized as NormalizeReturn<R>;
     });
 
-  return Object.assign(lazyFn, { [ModuleTag]: name });
+  // Props (T) are preserved so callers pass correctly-typed options, but the contributed
+  // Capabilities type is widened to the opaque base. The concrete capability type often traces to a
+  // module-internal source path that TypeScript cannot name in declaration files (TS2883); the base
+  // type is portable. The contributed type is checked at Capability.contributes regardless.
+  return Object.assign(lazyFn, { [ModuleTag]: name }) as LazyCapability<T>;
 };
 
 /**

package/src/core/edge-registry-plugin-provider.ts

@@ -6,31 +6,33 @@ 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 { type PluginView } from '@dxos/protocols';
 
+import type * as Plugin from './plugin';
 import * as Registry from './registry';
 
 /**
- * Maps a wire-format `PluginEntry` (from `@dxos/protocols`) to a
- * `Registry.Plugin` (the app-framework domain type).
+ * Maps a wire-format `PluginView` (from `@dxos/protocols`) to a runtime `Plugin.Meta`: the nested
+ * `profile` (the view's profile plus the resolved provenance `author`) and the latest `release`.
  *
- * This is the only translation seam between the two independently-defined type
- * hierarchies — fields are mapped explicitly, with no shared type between them.
+ * This is the one translation seam between the nested wire view and the resolved runtime manifest.
+ * `profile.key` is the composer plugin id — a valid NSID — so `DXN.make(profile.key, release.version)`
+ * reconstructs the canonical plugin DXN.
  */
-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,
-});
+const toRegistryPlugin = (entry: PluginView): Plugin.Meta | null => {
+  if (!entry.releases?.length) {
+    return null;
+  }
+  const latestRelease = entry.releases.find((release) => release.version === entry.latestVersion) ?? entry.releases[0];
+  return {
+    profile: {
+      ...entry.profile,
+      // Provenance: the verified publisher is the author (handle preferred, DID fallback).
+      author: entry.handle ?? entry.did,
+    },
+    release: latestRelease,
+  };
+};
 
 /**
  * Implements `Registry.PluginProvider` against the Edge `/registry` HTTP endpoints.
@@ -41,51 +43,48 @@ const toRegistryPlugin = (entry: PluginEntry): Registry.Plugin => ({
  * 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}).
+ * `listVersions` is served directly from the `releases` array inlined on each
+ * entry — no separate endpoint is needed.
  */
 export class EdgeRegistryPluginProvider implements Registry.PluginProvider {
   // Cached on first load so getPlugin/listVersions can resolve without re-fetching.
-  #cachedPlugins: readonly Registry.Plugin[] = [];
+  #cachedPlugins: readonly Plugin.Meta[] = [];
+  #cachedEntries: readonly PluginView[] = [];
 
   constructor(private readonly _client: EdgeHttpClient) {}
 
-  listPlugins(): Effect.Effect<readonly Registry.Plugin[], Error> {
+  listPlugins(): Effect.Effect<readonly Plugin.Meta[], 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.#cachedEntries = body.plugins;
+        const plugins = body.plugins.map(toRegistryPlugin).filter((entry): entry is Plugin.Meta => entry !== null);
         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}`));
+  listVersions(id: string): Effect.Effect<readonly Plugin.Release[], Error> {
+    const entry = this.#cachedEntries.find((candidate) => candidate.profile.key === id);
+    if (!entry) {
+      return Effect.fail(new Error(`Plugin not found in catalog: ${id}`));
     }
-    const version: Registry.PluginVersion = { tag: plugin.version, moduleUrl: plugin.moduleUrl };
-    return Effect.succeed([version]);
+    // Releases are already `PluginRelease`-shaped on the wire view; serve them directly.
+    return Effect.succeed(entry.releases);
   }
 
-  getPlugin(repo: string, version?: string): Effect.Effect<Registry.Plugin, Error> {
-    const plugin = this.#cachedPlugins.find((p) => p.repo === repo);
+  getPlugin(id: string, version?: string): Effect.Effect<Plugin.Meta, Error> {
+    const plugin = this.#cachedPlugins.find((candidate) => candidate.profile.key === id);
     if (!plugin) {
-      return Effect.fail(new Error(`Plugin not found in catalog: ${repo}`));
+      return Effect.fail(new Error(`Plugin not found in catalog: ${id}`));
     }
-    if (version && version !== plugin.version) {
-      return Effect.fail(new Error(`Version ${version} not available for ${repo}; only ${plugin.version} is cached`));
+    if (version && version !== plugin.release?.version) {
+      return Effect.fail(
+        new Error(`Version ${version} not available for ${id}; only ${plugin.release?.version} is cached`),
+      );
     }
     return Effect.succeed(plugin);
   }