@dxos/app-framework 0.7.5-labs.5f04cf6 → 0.7.5-labs.8a82073

package/dist/lib/node-esm/{chunk-ZFOOPWBG.mjs → chunk-ZTB4TA6Q.mjs}

@@ -1,5 +1,96 @@
 import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
 
+// packages/sdk/app-framework/src/plugin-intent/intent-dispatcher.ts
+import { Effect as Effect2, Option, pipe as pipe2, Ref } from "effect";
+import { create as create3 } from "@dxos/live-object";
+import { byPosition } from "@dxos/util";
+
+// packages/sdk/app-framework/src/plugin-intent/actions.ts
+import { Schema as S2 } from "@effect/schema";
+
+// packages/sdk/app-framework/src/plugin-intent/intent.ts
+import { Schema as S } from "@effect/schema";
+var createIntent = (schema, data = {}, params = {}) => {
+  const _ = S.validateSync(schema.fields.input)(data);
+  const intent = {
+    ...params,
+    _schema: schema,
+    id: schema._tag,
+    data
+  };
+  return {
+    first: intent,
+    last: intent,
+    all: [
+      intent
+    ]
+  };
+};
+var chain = (schema, data = {}, params = {}) => (intent) => {
+  const intents = "all" in intent ? intent.all : [
+    intent
+  ];
+  const first = intents[0];
+  const last = {
+    ...params,
+    _schema: schema,
+    id: schema._tag,
+    data
+  };
+  return {
+    first,
+    last,
+    all: [
+      ...intents,
+      last
+    ]
+  };
+};
+var Label = S.Union(S.String, S.mutable(S.Tuple(S.String, S.mutable(S.Struct({
+  ns: S.String,
+  count: S.optional(S.Number)
+})))));
+
+// packages/sdk/app-framework/src/plugin-intent/actions.ts
+var INTENT_PLUGIN = "dxos.org/plugin/intent";
+var INTENT_ACTION = `${INTENT_PLUGIN}/action`;
+var IntentAction;
+(function(IntentAction2) {
+  class ShowUndo extends S2.TaggedClass()(`${INTENT_ACTION}/show-undo`, {
+    input: S2.Struct({
+      message: Label
+    }),
+    output: S2.Void
+  }) {
+  }
+  IntentAction2.ShowUndo = ShowUndo;
+})(IntentAction || (IntentAction = {}));
+
+// packages/sdk/app-framework/src/plugin-intent/errors.ts
+var BaseError = class extends Error {
+  constructor(code, message, context) {
+    super(message ?? code, {
+      cause: context
+    });
+    this.code = code;
+    this.context = context;
+    this.name = code;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var NoResolversError = class extends BaseError {
+  constructor(action) {
+    super("NO_RESOLVERS", "No resolvers were found for the action", {
+      action
+    });
+  }
+};
+var CycleDetectedError = class extends BaseError {
+  constructor(context) {
+    super("CYCLE_DETECTED", "Intent execution limit exceeded. This is likely due to an infinite loop within intent resolvers.", context);
+  }
+};
+
 // packages/sdk/app-framework/src/core/capabilities.ts
 import { effect, untracked } from "@preact/signals-core";
 import { Trigger } from "@dxos/async";
@@ -26,9 +117,10 @@ var contributes = (interfaceDef, implementation, deactivate) => {
     deactivate
   };
 };
-var lazy = (c) => (props) => c().then(({ default: getCapability }) => {
-  return getCapability(props);
-});
+var lazy = (c) => async (props) => {
+  const { default: getCapability } = await c();
+  return async () => getCapability(props);
+};
 var PluginsContext = class {
   constructor({ activate, reset }) {
     this._definedCapabilities = /* @__PURE__ */ new Map();
@@ -50,10 +142,11 @@ var PluginsContext = class {
     current.push(new CapabilityImpl(moduleId, implementation));
     log("capability contributed", {
       id: interfaceDef.identifier,
+      moduleId,
       count: untracked(() => current.length)
     }, {
       F: __dxlog_file,
-      L: 139,
+      L: 142,
       S: this,
       C: (f, a) => f(...a)
     });
@@ -74,7 +167,16 @@ var PluginsContext = class {
         count: untracked(() => current.length)
       }, {
         F: __dxlog_file,
-        L: 154,
+        L: 161,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    } else {
+      log.warn("capability not removed", {
+        id: interfaceDef.identifier
+      }, {
+        F: __dxlog_file,
+        L: 163,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -107,7 +209,7 @@ var PluginsContext = class {
     const capability = this.requestCapabilities(interfaceDef, filter)[0];
     invariant(capability, `No capability found for ${interfaceDef.identifier}`, {
       F: __dxlog_file,
-      L: 190,
+      L: 199,
       S: this,
       A: [
         "capability",
@@ -158,7 +260,7 @@ var getEvents = (events) => "type" in events ? events.events : [
 
 // packages/sdk/app-framework/src/core/manager.ts
 import { untracked as untracked2 } from "@preact/signals-core";
-import { Effect, Either, Match } from "effect";
+import { Array as A, Effect, Either, Match, pipe } from "effect";
 import { Event } from "@dxos/async";
 import { create as create2 } from "@dxos/live-object";
 import { log as log2 } from "@dxos/log";
@@ -181,7 +283,6 @@ var PluginManager = class {
       enabled,
       modules: [],
       active: [],
-      pendingRemoval: [],
       pendingReset: [],
       eventsFired: []
     });
@@ -230,14 +331,6 @@ var PluginManager = class {
     return this._state.active;
   }
   /**
-  * Ids of modules which are pending removal.
-  *
-  * @reactive
-  */
-  get pendingRemoval() {
-    return this._state.pendingRemoval;
-  }
-  /**
   * Ids of events which have been fired.
   *
   * @reactive
@@ -263,7 +356,7 @@ var PluginManager = class {
         id
       }, {
         F: __dxlog_file2,
-        L: 157,
+        L: 146,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -277,12 +370,12 @@ var PluginManager = class {
   * @param id The id of the plugin.
   */
   enable(id) {
-    return untracked2(() => {
+    return untracked2(async () => {
       log2("enable plugin", {
         id
       }, {
         F: __dxlog_file2,
-        L: 170,
+        L: 159,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -297,6 +390,19 @@ var PluginManager = class {
         this._addModule(module);
         this._setPendingResetByModule(module);
       });
+      log2("pending reset", {
+        events: [
+          ...this.pendingReset
+        ]
+      }, {
+        F: __dxlog_file2,
+        L: 174,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      await Effect.runPromise(Effect.all(this.pendingReset.map((event) => this._activate(event)), {
+        concurrency: "unbounded"
+      }));
       return true;
     });
   }
@@ -310,7 +416,7 @@ var PluginManager = class {
         id
       }, {
         F: __dxlog_file2,
-        L: 194,
+        L: 192,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -327,12 +433,12 @@ var PluginManager = class {
   * @param id The id of the plugin.
   */
   disable(id) {
-    return untracked2(() => {
+    return untracked2(async () => {
       log2("disable plugin", {
         id
       }, {
         F: __dxlog_file2,
-        L: 211,
+        L: 209,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -346,15 +452,9 @@ var PluginManager = class {
       const enabledIndex = this._state.enabled.findIndex((enabled) => enabled === id);
       if (enabledIndex !== -1) {
         this._state.enabled.splice(enabledIndex, 1);
+        await Effect.runPromise(this._deactivate(id));
         plugin.modules.forEach((module) => {
-          if (this._state.active.includes(module.id)) {
-            this._setPendingResetByModule(module);
-            if (!this._state.pendingRemoval.includes(module.id)) {
-              this._state.pendingRemoval.push(module.id);
-            }
-          } else {
-            this._removeModule(module.id);
-          }
+          this._removeModule(module.id);
         });
       }
       return true;
@@ -390,7 +490,7 @@ var PluginManager = class {
         id: plugin.meta.id
       }, {
         F: __dxlog_file2,
-        L: 270,
+        L: 262,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -405,7 +505,7 @@ var PluginManager = class {
         id
       }, {
         F: __dxlog_file2,
-        L: 279,
+        L: 271,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -421,7 +521,7 @@ var PluginManager = class {
         id: module.id
       }, {
         F: __dxlog_file2,
-        L: 289,
+        L: 281,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -436,7 +536,7 @@ var PluginManager = class {
         id
       }, {
         F: __dxlog_file2,
-        L: 298,
+        L: 290,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -464,20 +564,13 @@ var PluginManager = class {
   _setPendingResetByModule(module) {
     return untracked2(() => {
       const activationEvents = getEvents(module.activatesOn).map(eventKey).filter((key) => this._state.eventsFired.includes(key));
-      const parentEvents = activationEvents.flatMap((event) => {
-        const modules = this._getActiveModules().filter((module2) => module2.activatesBefore?.map(eventKey).includes(event));
-        return modules.flatMap((module2) => getEvents(module2.activatesOn)).map(eventKey);
-      });
-      const pendingReset = Array.from(/* @__PURE__ */ new Set([
-        ...activationEvents,
-        ...parentEvents
-      ])).filter((event) => !this._state.pendingReset.includes(event));
+      const pendingReset = Array.from(new Set(activationEvents)).filter((event) => !this._state.pendingReset.includes(event));
       if (pendingReset.length > 0) {
         log2("pending reset", {
           events: pendingReset
         }, {
           F: __dxlog_file2,
-          L: 342,
+          L: 328,
           S: this,
           C: (f, a) => f(...a)
         });
@@ -485,59 +578,87 @@ var PluginManager = class {
       }
     });
   }
+  /**
+  * @internal
+  */
   // TODO(wittjosiah): Improve error typing.
   _activate(event) {
-    const self = this;
-    return Effect.gen(function* () {
+    return Effect.gen(this, function* () {
       const key = typeof event === "string" ? event : eventKey(event);
       log2("activating", {
         key
       }, {
         F: __dxlog_file2,
-        L: 353,
+        L: 341,
         S: this,
         C: (f, a) => f(...a)
       });
-      const pendingIndex = self._state.pendingReset.findIndex((event2) => event2 === key);
+      const pendingIndex = this._state.pendingReset.findIndex((event2) => event2 === key);
       if (pendingIndex !== -1) {
-        self._state.pendingReset.splice(pendingIndex, 1);
+        this._state.pendingReset.splice(pendingIndex, 1);
       }
-      const modules = self._getInactiveModulesByEvent(key);
+      const modules = this._getInactiveModulesByEvent(key).filter((module) => {
+        const allOf2 = isAllOf(module.activatesOn);
+        if (!allOf2) {
+          return true;
+        }
+        const events = module.activatesOn.events.filter((event2) => eventKey(event2) !== key);
+        return events.every((event2) => this._state.eventsFired.includes(eventKey(event2)));
+      });
       if (modules.length === 0) {
         log2("no modules to activate", {
           key
         }, {
           F: __dxlog_file2,
-          L: 361,
+          L: 357,
           S: this,
           C: (f, a) => f(...a)
         });
+        if (!this._state.eventsFired.includes(key)) {
+          this._state.eventsFired.push(key);
+        }
         return false;
       }
-      self.activation.emit({
+      log2("activating modules", {
+        key,
+        modules: modules.map((module) => module.id)
+      }, {
+        F: __dxlog_file2,
+        L: 364,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      this.activation.emit({
         event: key,
         state: "activating"
       });
-      for (const module of modules) {
-        if (isAllOf(module.activatesOn) && !module.activatesOn.events.filter((event2) => eventKey(event2) !== key).every((event2) => self._state.eventsFired.includes(eventKey(event2)))) {
-          continue;
-        }
-        yield* Effect.all(module.activatesBefore?.map((event2) => self._activate(event2)) ?? []);
-        const result = yield* self._activateModule(module).pipe(Effect.either);
-        if (Either.isLeft(result)) {
-          self.activation.emit({
-            event: key,
-            state: "error",
-            error: result.left
-          });
-          yield* Effect.fail(result.left);
-        }
-        yield* Effect.all(module.activatesAfter?.map((event2) => self._activate(event2)) ?? []);
+      const getCapabilities = yield* Effect.all(modules.map(({ activate }) => Effect.tryPromise({
+        try: async () => activate(this.context),
+        catch: (error) => error
+      })), {
+        concurrency: "unbounded"
+      });
+      const result = yield* pipe(
+        modules,
+        A.zip(getCapabilities),
+        A.map(([module, getCapabilities2]) => this._activateModule(module, getCapabilities2)),
+        // TODO(wittjosiah): This currently can't be run in parallel.
+        //   Running this with concurrency causes races with `allOf` activation events.
+        Effect.all,
+        Effect.either
+      );
+      if (Either.isLeft(result)) {
+        this.activation.emit({
+          event: key,
+          state: "error",
+          error: result.left
+        });
+        yield* Effect.fail(result.left);
       }
-      if (!self._state.eventsFired.includes(key)) {
-        self._state.eventsFired.push(key);
+      if (!this._state.eventsFired.includes(key)) {
+        this._state.eventsFired.push(key);
       }
-      self.activation.emit({
+      this.activation.emit({
         event: key,
         state: "activated"
       });
@@ -545,79 +666,105 @@ var PluginManager = class {
         key
       }, {
         F: __dxlog_file2,
-        L: 393,
+        L: 398,
         S: this,
         C: (f, a) => f(...a)
       });
       return true;
     });
   }
-  _activateModule(module) {
-    const self = this;
-    return Effect.gen(function* () {
-      const program = module.activate(self.context);
-      const maybeCapabilities = yield* Match.value(program).pipe(Match.when(Effect.isEffect, (effect3) => effect3), Match.when(isPromise, (promise) => Effect.tryPromise({
-        try: () => promise,
-        catch: (error) => error
-      })), Match.orElse((program2) => Effect.succeed(program2)));
-      const capabilities = Match.value(maybeCapabilities).pipe(Match.when(Array.isArray, (array) => array), Match.orElse((value) => [
+  _activateModule(module, getCapabilities) {
+    return Effect.gen(this, function* () {
+      yield* Effect.all(module.activatesBefore?.map((event) => this._activate(event)) ?? [], {
+        concurrency: "unbounded"
+      });
+      log2("activating module...", {
+        module: module.id
+      }, {
+        F: __dxlog_file2,
+        L: 413,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      const maybeCapabilities = typeof getCapabilities === "function" ? getCapabilities() : getCapabilities;
+      const resolvedCapabilities = yield* Match.value(maybeCapabilities).pipe(
+        // TODO(wittjosiah): Activate with an effect?
+        // Match.when(Effect.isEffect, (effect) => effect),
+        Match.when(isPromise, (promise) => Effect.tryPromise({
+          try: () => promise,
+          catch: (error) => error
+        })),
+        Match.orElse((program) => Effect.succeed(program))
+      );
+      const capabilities = Match.value(resolvedCapabilities).pipe(Match.when(Array.isArray, (array) => array), Match.orElse((value) => [
         value
       ]));
       capabilities.forEach((capability) => {
-        self.context.contributeCapability({
+        this.context.contributeCapability({
           module: module.id,
           ...capability
         });
       });
-      self._state.active.push(module.id);
-      self._capabilities.set(module.id, capabilities);
+      this._state.active.push(module.id);
+      this._capabilities.set(module.id, capabilities);
+      log2("activated module", {
+        module: module.id
+      }, {
+        F: __dxlog_file2,
+        L: 436,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      yield* Effect.all(module.activatesAfter?.map((event) => this._activate(event)) ?? [], {
+        concurrency: "unbounded"
+      });
     });
   }
   _deactivate(id) {
-    const self = this;
-    return Effect.gen(function* () {
-      const plugin = self._getPlugin(id);
+    return Effect.gen(this, function* () {
+      const plugin = this._getPlugin(id);
       if (!plugin) {
         return false;
       }
       const modules = plugin.modules;
-      const results = yield* Effect.all(modules.map((module) => self._deactivateModule(module)));
+      const results = yield* Effect.all(modules.map((module) => this._deactivateModule(module)), {
+        concurrency: "unbounded"
+      });
       return results.every((result) => result);
     });
   }
   _deactivateModule(module) {
-    const self = this;
-    return Effect.gen(function* () {
+    return Effect.gen(this, function* () {
       const id = module.id;
       log2("deactivating", {
         id
       }, {
         F: __dxlog_file2,
-        L: 444,
+        L: 463,
         S: this,
         C: (f, a) => f(...a)
       });
-      const capabilities = self._capabilities.get(id);
+      const capabilities = this._capabilities.get(id);
       if (capabilities) {
         for (const capability of capabilities) {
-          self.context.removeCapability(capability.interface, capability.implementation);
+          this.context.removeCapability(capability.interface, capability.implementation);
           const program = capability.deactivate?.();
-          yield* Match.value(program).pipe(Match.when(Effect.isEffect, (effect3) => effect3), Match.when(isPromise, (promise) => Effect.tryPromise({
+          yield* Match.value(program).pipe(Match.when(Effect.isEffect, (effect2) => effect2), Match.when(isPromise, (promise) => Effect.tryPromise({
             try: () => promise,
             catch: (error) => error
           })), Match.orElse((program2) => Effect.succeed(program2)));
         }
-        self._capabilities.delete(id);
+        this._capabilities.delete(id);
       }
-      const activeIndex = self._state.active.findIndex((event) => event === id);
+      const activeIndex = this._state.active.findIndex((event) => event === id);
       if (activeIndex !== -1) {
-        self._state.active.splice(activeIndex, 1);
+        this._state.active.splice(activeIndex, 1);
       }
       log2("deactivated", {
         id
       }, {
         F: __dxlog_file2,
-        L: 470,
+        L: 489,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -625,27 +772,22 @@ var PluginManager = class {
     });
   }
   _reset(event) {
-    const self = this;
-    return Effect.gen(function* () {
+    return Effect.gen(this, function* () {
       const key = typeof event === "string" ? event : eventKey(event);
       log2("reset", {
         key
       }, {
         F: __dxlog_file2,
-        L: 479,
+        L: 497,
         S: this,
         C: (f, a) => f(...a)
       });
-      const modules = self._getActiveModulesByEvent(key);
-      const results = yield* Effect.all(modules.map((module) => self._deactivateModule(module)));
-      if (self._state.pendingRemoval.length > 0) {
-        self._state.pendingRemoval.forEach((id) => {
-          self._removeModule(id);
-        });
-        self._state.pendingRemoval.splice(0, self._state.pendingRemoval.length);
-      }
+      const modules = this._getActiveModulesByEvent(key);
+      const results = yield* Effect.all(modules.map((module) => this._deactivateModule(module)), {
+        concurrency: "unbounded"
+      });
       if (results.every((result) => result)) {
-        return yield* self._activate(key);
+        return yield* this._activate(key);
       } else {
         return false;
       }
@@ -685,9 +827,6 @@ var Capabilities;
   Capabilities2.IntentResolver = defineCapability("dxos.org/app-framework/capability/intent-resolver");
   Capabilities2.IntentDispatcher = defineCapability("dxos.org/app-framework/capability/intent-dispatcher");
   Capabilities2.Layout = defineCapability("dxos.org/app-framework/capability/layout");
-  Capabilities2.MutableLayout = defineCapability("dxos.org/app-framework/capability/layout");
-  Capabilities2.Location = defineCapability("dxos.org/app-framework/capability/location");
-  Capabilities2.MutableLocation = defineCapability("dxos.org/app-framework/capability/location");
   Capabilities2.Translations = defineCapability("dxos.org/app-framework/capability/translations");
   Capabilities2.AppGraph = defineCapability("dxos.org/app-framework/capability/app-graph");
   Capabilities2.AppGraphBuilder = defineCapability("dxos.org/app-framework/capability/app-graph-builder");
@@ -704,6 +843,8 @@ var Capabilities;
 var Events;
 (function(Events2) {
   Events2.Startup = defineEvent("dxos.org/app-framework/event/startup");
+  Events2.SetupSurfaces = defineEvent("dxos.org/app-framework/event/setup-surfaces");
+  Events2.SetupMetadata = defineEvent("dxos.org/app-framework/event/setup-metadata");
   Events2.SetupIntents = defineEvent("dxos.org/app-framework/event/setup-intents");
   Events2.SetupSettings = defineEvent("dxos.org/app-framework/event/setup-settings");
   Events2.SetupAppGraph = defineEvent("dxos.org/app-framework/event/setup-graph");
@@ -713,11 +854,10 @@ var Events;
   Events2.AppGraphReady = defineEvent("dxos.org/app-framework/event/graph-ready");
   Events2.createStateEvent = (specifier) => defineEvent("dxos.org/app-framework/event/state", specifier);
   Events2.LayoutReady = Events2.createStateEvent(Capabilities.Layout.identifier);
-  Events2.LocationReady = Events2.createStateEvent(Capabilities.Location.identifier);
 })(Events || (Events = {}));
 
 // packages/sdk/app-framework/src/common/file.ts
-import { S } from "@dxos/echo-schema";
+import { Schema as S3 } from "@effect/schema";
 var defaultFileTypes = {
   images: [
     "png",
@@ -737,127 +877,367 @@ var defaultFileTypes = {
     "md"
   ]
 };
-var FileInfoSchema = S.Struct({
-  name: S.String,
-  type: S.String,
-  url: S.optional(S.String),
-  cid: S.optional(S.String)
+var FileInfoSchema = S3.Struct({
+  name: S3.String,
+  type: S3.String,
+  url: S3.optional(S3.String),
+  cid: S3.optional(S3.String)
 });
 
-// packages/sdk/app-framework/src/plugin-intent/intent.ts
-import { S as S2 } from "@dxos/echo-schema";
-var createIntent = (schema, data = {}, params = {}) => {
-  const _ = S2.validateSync(schema.fields.input)(data);
-  const intent = {
-    ...params,
-    _schema: schema,
-    action: schema._tag,
-    data
-  };
-  return {
-    first: intent,
-    last: intent,
-    all: [
-      intent
-    ]
-  };
-};
-var chain = (schema, data = {}, params = {}) => (intent) => {
-  const intents = "all" in intent ? intent.all : [
-    intent
-  ];
-  const first = intents[0];
-  const last = {
-    ...params,
-    _schema: schema,
-    action: schema._tag,
-    data
-  };
-  return {
-    first,
-    last,
-    all: [
-      ...intents,
-      last
-    ]
-  };
-};
-var Label = S2.Union(S2.String, S2.mutable(S2.Tuple(S2.String, S2.mutable(S2.Struct({
-  ns: S2.String,
-  count: S2.optional(S2.Number)
-})))));
+// packages/sdk/app-framework/src/common/layout.ts
+import { Schema as S4 } from "@effect/schema";
 
-// packages/sdk/app-framework/src/plugin-intent/actions.ts
-import { S as S3 } from "@dxos/echo-schema";
-var INTENT_PLUGIN = "dxos.org/plugin/intent";
-var INTENT_ACTION = `${INTENT_PLUGIN}/action`;
-var IntentAction;
-(function(IntentAction2) {
-  class ShowUndo extends S3.TaggedClass()(`${INTENT_ACTION}/show-undo`, {
-    input: S3.Struct({
-      message: Label
+// packages/sdk/app-framework/src/plugin-intent/IntentPlugin.tsx
+var IntentPlugin = () => definePlugin({
+  id: INTENT_PLUGIN
+}, [
+  defineModule({
+    id: `${INTENT_PLUGIN}/module/dispatcher`,
+    // TODO(wittjosiah): This will mean that startup needs to be reset when intents are added or removed.
+    //   This is fine for now because it's how it worked prior to capabilities api anyways.
+    //   In the future, the intent dispatcher should be able to be reset without resetting the entire app.
+    activatesOn: Events.Startup,
+    activatesAfter: [
+      Events.DispatcherReady
+    ],
+    activate: lazy(() => import("./intent-dispatcher-RZAWA4XD.mjs"))
+  })
+]);
+
+// packages/sdk/app-framework/src/common/layout.ts
+var LAYOUT_PLUGIN = "dxos.org/plugin/layout";
+var LAYOUT_ACTION = `${LAYOUT_PLUGIN}/action`;
+var LayoutAction;
+(function(LayoutAction2) {
+  LayoutAction2.UPDATE_LAYOUT = `${LAYOUT_ACTION}/update-layout`;
+  class UpdateLayout extends S4.TaggedClass()(LayoutAction2.UPDATE_LAYOUT, {
+    input: S4.Struct({
+      part: S4.String.annotations({
+        description: "The part of the layout to mutate."
+      }),
+      subject: S4.optional(S4.Any.annotations({
+        description: "The subject of the layout update."
+      })),
+      options: S4.optional(S4.Record({
+        key: S4.String,
+        value: S4.Any
+      }).annotations({
+        description: "Additional options for the layout action."
+      }))
     }),
-    output: S3.Void
+    output: S4.Void
   }) {
   }
-  IntentAction2.ShowUndo = ShowUndo;
-})(IntentAction || (IntentAction = {}));
-
-// packages/sdk/app-framework/src/plugin-intent/intent-dispatcher.ts
-import { Effect as Effect2, Option, pipe, Ref } from "effect";
-import { byDisposition } from "@dxos/util";
-
-// packages/sdk/app-framework/src/plugin-intent/errors.ts
-var BaseError = class extends Error {
-  constructor(code, message, context) {
-    super(message ?? code);
-    this.code = code;
-    this.context = context;
-    this.name = code;
-    Object.setPrototypeOf(this, new.target.prototype);
+  LayoutAction2.UpdateLayout = UpdateLayout;
+  class SetLayoutMode extends S4.TaggedClass()(LayoutAction2.UPDATE_LAYOUT, {
+    input: S4.Struct({
+      part: S4.Literal("mode").annotations({
+        description: "Setting the layout mode."
+      }),
+      subject: S4.optional(S4.String.annotations({
+        description: "Item which is the subject of the new layout mode."
+      })),
+      options: S4.Union(S4.Struct({
+        mode: S4.String.annotations({
+          description: "The new layout mode."
+        })
+      }), S4.Struct({
+        revert: S4.Boolean.annotations({
+          description: "Revert to the previous layout mode."
+        })
+      }))
+    }),
+    output: S4.Void
+  }) {
   }
-};
-var NoResolversError = class extends BaseError {
-  constructor(action) {
-    super("NO_RESOLVERS", "No resolvers were found for the action", {
-      action
-    });
+  LayoutAction2.SetLayoutMode = SetLayoutMode;
+  class UpdateSidebar extends S4.TaggedClass()(LayoutAction2.UPDATE_LAYOUT, {
+    input: S4.Struct({
+      part: S4.Literal("sidebar").annotations({
+        description: "Updating the sidebar."
+      }),
+      subject: S4.optional(S4.String.annotations({
+        description: "URI of the component to display in the sidebar."
+      })),
+      options: S4.optional(S4.Struct({
+        state: S4.Literal("closed", "collapsed", "expanded").annotations({
+          description: "Whether the sidebar is closed, collapsed, or expanded."
+        })
+      }))
+    }),
+    output: S4.Void
+  }) {
   }
-};
-var CycleDetectedError = class extends BaseError {
-  constructor(context) {
-    super("CYCLE_DETECTED", "Intent execution limit exceeded. This is likely due to an infinite loop within intent resolvers.", context);
+  LayoutAction2.UpdateSidebar = UpdateSidebar;
+  class UpdateComplementary extends S4.TaggedClass()(LayoutAction2.UPDATE_LAYOUT, {
+    input: S4.Struct({
+      part: S4.Literal("complementary").annotations({
+        description: "Updating the complementary sidebar."
+      }),
+      subject: S4.optional(S4.String.annotations({
+        description: "URI of the component to display in the complementary area."
+      })),
+      options: S4.optional(S4.Struct({
+        state: S4.Literal("closed", "collapsed", "expanded").annotations({
+          description: "Whether the complementary sidebar is closed, collapsed, or expanded."
+        })
+      }))
+    }),
+    output: S4.Void
+  }) {
   }
-};
+  LayoutAction2.UpdateComplementary = UpdateComplementary;
+  class UpdateDialog extends S4.TaggedClass()(LayoutAction2.UPDATE_LAYOUT, {
+    input: S4.Struct({
+      part: S4.Literal("dialog").annotations({
+        description: "Updating the dialog."
+      }),
+      subject: S4.optional(S4.String.annotations({
+        description: "URI of the component to display in the dialog."
+      })),
+      options: S4.Struct({
+        state: S4.optional(S4.Boolean.annotations({
+          description: "Whether the dialog is open or closed."
+        })),
+        blockAlign: S4.optional(S4.Literal("start", "center").annotations({
+          description: "The alignment of the dialog."
+        })),
+        type: S4.optional(S4.Literal("default", "alert").annotations({
+          description: "The type of dialog."
+        })),
+        props: S4.optional(S4.Record({
+          key: S4.String,
+          value: S4.Any
+        }).annotations({
+          description: "Additional props for the dialog."
+        }))
+      })
+    }),
+    output: S4.Void
+  }) {
+  }
+  LayoutAction2.UpdateDialog = UpdateDialog;
+  class UpdatePopover extends S4.TaggedClass()(LayoutAction2.UPDATE_LAYOUT, {
+    input: S4.Struct({
+      part: S4.Literal("popover").annotations({
+        description: "Updating the popover."
+      }),
+      subject: S4.optional(S4.String.annotations({
+        description: "URI of the component to display in the popover."
+      })),
+      options: S4.Struct({
+        anchorId: S4.String.annotations({
+          description: "The id of the element to anchor the popover to."
+        }),
+        state: S4.optional(S4.Boolean.annotations({
+          description: "Whether the popover is open or closed."
+        })),
+        props: S4.optional(S4.Record({
+          key: S4.String,
+          value: S4.Any
+        }).annotations({
+          description: "Additional props for the popover."
+        }))
+      })
+    }),
+    output: S4.Void
+  }) {
+  }
+  LayoutAction2.UpdatePopover = UpdatePopover;
+  LayoutAction2.Toast = S4.Struct({
+    id: S4.String.annotations({
+      description: "The id of the toast."
+    }),
+    title: S4.optional(Label.annotations({
+      description: "The title of the toast."
+    })),
+    description: S4.optional(Label.annotations({
+      description: "The description of the toast."
+    })),
+    icon: S4.optional(S4.String.annotations({
+      description: "The icon of the toast."
+    })),
+    duration: S4.optional(S4.Number.annotations({
+      description: "The duration of the toast."
+    })),
+    closeLabel: S4.optional(Label.annotations({
+      description: "The label of the close button."
+    })),
+    actionLabel: S4.optional(Label.annotations({
+      description: "The label of the action button."
+    })),
+    actionAlt: S4.optional(Label.annotations({
+      description: "The alt text of the action button."
+    })),
+    onAction: S4.optional(S4.Any.annotations({
+      description: "The action to perform when the action button is clicked."
+    }))
+  });
+  class AddToast extends S4.TaggedClass()(LayoutAction2.UPDATE_LAYOUT, {
+    input: S4.Struct({
+      part: S4.Literal("toast").annotations({
+        description: "Adding a toast."
+      }),
+      subject: LayoutAction2.Toast.annotations({
+        description: "The toast to add."
+      })
+    }),
+    output: S4.Void
+  }) {
+  }
+  LayoutAction2.AddToast = AddToast;
+  class SwitchWorkspace extends S4.TaggedClass()(LayoutAction2.UPDATE_LAYOUT, {
+    input: S4.Struct({
+      part: S4.Literal("workspace").annotations({
+        description: "Switching the workspace."
+      }),
+      subject: S4.String.annotations({
+        description: "The id of the workspace to switch to."
+      })
+    }),
+    output: S4.Void
+  }) {
+  }
+  LayoutAction2.SwitchWorkspace = SwitchWorkspace;
+  class Open extends S4.TaggedClass()(LayoutAction2.UPDATE_LAYOUT, {
+    input: S4.Struct({
+      part: S4.Literal("main").annotations({
+        description: "Opening an item in the main content area."
+      }),
+      subject: S4.Array(S4.String.annotations({
+        description: "Ids of the items to open."
+      })),
+      options: S4.optional(S4.Struct({
+        state: S4.optional(S4.Literal(true).annotations({
+          description: "The items are being added."
+        })),
+        key: S4.optional(S4.String.annotations({
+          description: "If provided, will replace item with a matching key (id prefix)."
+        })),
+        scrollIntoView: S4.optional(S4.Boolean.annotations({
+          description: "Scroll the items into view."
+        })),
+        pivotId: S4.optional(S4.String.annotations({
+          description: "The id of the item to place new items next to."
+        })),
+        positioning: S4.optional(S4.Union(S4.Literal("start").annotations({
+          description: "The items are being added before the pivot item."
+        }), S4.Literal("end").annotations({
+          description: "The items are being added after the pivot item."
+        })))
+      }))
+    }),
+    output: S4.Void
+  }) {
+  }
+  LayoutAction2.Open = Open;
+  class Set2 extends S4.TaggedClass()(LayoutAction2.UPDATE_LAYOUT, {
+    input: S4.Struct({
+      part: S4.Literal("main").annotations({
+        description: "Setting items in the main content area."
+      }),
+      subject: S4.Array(S4.String.annotations({
+        description: "Ids of the items to set."
+      })),
+      options: S4.Struct({
+        override: S4.Literal(true).annotations({
+          description: "Override the current items in the main content area."
+        })
+      })
+    }),
+    output: S4.Void
+  }) {
+  }
+  LayoutAction2.Set = Set2;
+  class Close extends S4.TaggedClass()(LayoutAction2.UPDATE_LAYOUT, {
+    input: S4.Struct({
+      part: S4.Literal("main").annotations({
+        description: "Closing items in the main content area."
+      }),
+      subject: S4.Array(S4.String.annotations({
+        description: "Ids of the items to close."
+      })),
+      options: S4.Struct({
+        state: S4.Literal(false).annotations({
+          description: "The items are being removed."
+        })
+      })
+    }),
+    output: S4.Void
+  }) {
+  }
+  LayoutAction2.Close = Close;
+  class ScrollIntoView extends S4.TaggedClass()(LayoutAction2.UPDATE_LAYOUT, {
+    input: S4.Struct({
+      part: S4.Literal("current").annotations({
+        description: "Setting the current item"
+      }),
+      subject: S4.optional(S4.String.annotations({
+        description: "The id of the item to set as current."
+      })),
+      options: S4.optional(S4.Record({
+        key: S4.String,
+        value: S4.Any
+      }).annotations({
+        description: "Additional options for the scroll into view."
+      }))
+    }),
+    output: S4.Void
+  }) {
+  }
+  LayoutAction2.ScrollIntoView = ScrollIntoView;
+  class Expose extends S4.TaggedClass()(LayoutAction2.UPDATE_LAYOUT, {
+    input: S4.Struct({
+      part: S4.Literal("navigation").annotations({
+        description: "Exposing an item in the navigation area."
+      }),
+      subject: S4.String.annotations({
+        description: "The id of the item to expose."
+      })
+    }),
+    output: S4.Void
+  }) {
+  }
+  LayoutAction2.Expose = Expose;
+})(LayoutAction || (LayoutAction = {}));
+
+// packages/sdk/app-framework/src/common/surface.ts
+var createSurface = (definition) => definition;
+
+// packages/sdk/app-framework/src/common/translations.ts
+import { Schema as S5 } from "@effect/schema";
+var ResourceKey = S5.Union(S5.String, S5.Record({
+  key: S5.String,
+  value: S5.Any
+}));
+var ResourceLanguage = S5.Record({
+  key: S5.String,
+  value: ResourceKey
+});
+var Resource = S5.Record({
+  key: S5.String,
+  value: ResourceLanguage
+});
 
 // packages/sdk/app-framework/src/plugin-intent/intent-dispatcher.ts
 var EXECUTION_LIMIT = 100;
 var HISTORY_LIMIT = 100;
-var createResolver = (schema, effect3, params = {}) => ({
-  action: schema._tag,
-  effect: effect3,
-  ...params
-});
+var createResolver = (resolver) => resolver;
 var isUndoable = (historyEntry) => historyEntry.length > 0 && historyEntry.every(({ undoable }) => !!undoable);
 var createDispatcher = (getResolvers, { executionLimit = EXECUTION_LIMIT, historyLimit = HISTORY_LIMIT } = {}) => {
   const historyRef = Effect2.runSync(Ref.make([]));
-  const handleIntent = (intent) => {
-    return Effect2.gen(function* () {
-      const candidates = getResolvers(intent.module).filter((r) => r.action === intent.action).filter((r) => !r.filter || r.filter(intent.data)).toSorted(byDisposition);
-      if (candidates.length === 0) {
-        return {
-          _intent: intent,
-          error: new NoResolversError(intent.action)
-        };
-      }
-      const effect3 = candidates[0].effect(intent.data, intent.undo ?? false);
-      const result = Effect2.isEffect(effect3) ? yield* effect3 : yield* Effect2.promise(async () => effect3);
-      return {
-        _intent: intent,
-        ...result
-      };
-    });
-  };
+  const handleIntent = (intent) => Effect2.gen(function* () {
+    const candidates = getResolvers(intent.module).filter((r) => r.intent._tag === intent.id).filter((r) => !r.filter || r.filter(intent.data)).toSorted(byPosition);
+    if (candidates.length === 0) {
+      yield* Effect2.fail(new NoResolversError(intent.id));
+    }
+    const effect2 = candidates[0].resolve(intent.data, intent.undo ?? false);
+    const result = Effect2.isEffect(effect2) ? yield* effect2 : yield* Effect2.promise(async () => effect2);
+    return {
+      _intent: intent,
+      ...result
+    };
+  });
   const dispatch = (intentChain, depth = 0) => {
     return Effect2.gen(function* () {
       if (depth > executionLimit) {
@@ -899,7 +1279,7 @@ var createDispatcher = (getResolvers, { executionLimit = EXECUTION_LIMIT, histor
         return next;
       });
       if (result.undoable && isUndoable(results)) {
-        yield* pipe(dispatch(createIntent(IntentAction.ShowUndo, {
+        yield* pipe2(dispatch(createIntent(IntentAction.ShowUndo, {
           message: result.undoable.message
         })), Effect2.catchSome((err) => err instanceof NoResolversError ? Option.some(Effect2.succeed(void 0)) : Option.none()));
       }
@@ -955,602 +1335,32 @@ var createDispatcher = (getResolvers, { executionLimit = EXECUTION_LIMIT, histor
     undoPromise
   };
 };
-
-// packages/sdk/app-framework/src/react/ErrorBoundary.tsx
-import React, { Component } from "react";
-var ErrorBoundary = class extends Component {
-  constructor(props) {
-    super(props);
-    this.state = {
-      error: void 0
-    };
-  }
-  static getDerivedStateFromError(error) {
-    return {
-      error
-    };
-  }
-  componentDidUpdate(prevProps) {
-    if (prevProps.data !== this.props.data) {
-      this.resetError();
-    }
-  }
-  render() {
-    if (this.state.error) {
-      return /* @__PURE__ */ React.createElement(this.props.fallback, {
-        data: this.props.data,
-        error: this.state.error,
-        reset: this.resetError
-      });
-    }
-    return this.props.children;
-  }
-  resetError() {
-    this.setState({
-      error: void 0
-    });
-  }
-};
-
-// packages/sdk/app-framework/src/react/PluginManagerProvider.ts
-import { createContext, useContext } from "react";
-import { raise } from "@dxos/debug";
-var PluginManagerContext = createContext(void 0);
-var usePluginManager = () => useContext(PluginManagerContext) ?? raise(new Error("Missing PluginManagerContext"));
-var PluginManagerProvider = PluginManagerContext.Provider;
-
-// packages/sdk/app-framework/src/react/useCapabilities.ts
-import { computed } from "@preact/signals-core";
-import { useMemo } from "react";
-var useCapabilities = (interfaceDef, filter) => {
-  const manager = usePluginManager();
-  const signal = useMemo(() => computed(() => manager.context.requestCapabilities(interfaceDef, filter)), [
-    interfaceDef
-  ]);
-  return signal.value;
-};
-var useCapability = (interfaceDef, filter) => {
-  const manager = usePluginManager();
-  const signal = useMemo(() => computed(() => manager.context.requestCapability(interfaceDef, filter)), [
-    interfaceDef
-  ]);
-  return signal.value;
-};
-
-// packages/sdk/app-framework/src/react/Surface.tsx
-import React3, { memo, forwardRef, Suspense, useMemo as useMemo2 } from "react";
-import { useDefaultValue } from "@dxos/react-hooks";
-import { byDisposition as byDisposition2 } from "@dxos/util";
-
-// packages/sdk/app-framework/src/common/layout.ts
-import { S as S4 } from "@dxos/echo-schema";
-
-// packages/sdk/app-framework/src/plugin-intent/IntentContext.tsx
-import { createContext as createContext2, useContext as useContext2, useEffect } from "react";
-import { raise as raise2 } from "@dxos/debug";
-import { pick } from "@dxos/util";
-var IntentContext = /* @__PURE__ */ createContext2(void 0);
-var useIntentDispatcher = () => {
-  const context = useContext2(IntentContext) ?? raise2(new Error("IntentContext not found"));
-  return pick(context, [
-    "dispatch",
-    "dispatchPromise"
-  ]);
-};
-var useIntentResolver = (module, resolver) => {
-  const manager = usePluginManager();
-  useEffect(() => {
-    manager.context.contributeCapability({
-      module,
-      interface: Capabilities.IntentResolver,
-      implementation: resolver
-    });
-    return () => manager.context.removeCapability(Capabilities.IntentResolver, resolver);
-  }, [
-    module,
-    resolver
-  ]);
-};
-var IntentProvider = IntentContext.Provider;
-
-// packages/sdk/app-framework/src/plugin-intent/IntentPlugin.tsx
-import { Effect as Effect3 } from "effect";
-import React2 from "react";
-import { create as create3 } from "@dxos/live-object";
-var defaultEffect = () => Effect3.fail(new Error("Intent runtime not ready"));
-var defaultPromise = () => Effect3.runPromise(defaultEffect());
-var IntentPlugin = () => definePlugin({
-  id: INTENT_PLUGIN
-}, [
-  defineModule({
-    id: `${INTENT_PLUGIN}/module/dispatcher`,
-    // TODO(wittjosiah): This will mean that startup needs to be reset when intents are added or removed.
-    //   This is fine for now because it's how it worked prior to capabilities api anyways.
-    //   In the future, the intent dispatcher should be able to be reset without resetting the entire app.
-    activatesOn: Events.Startup,
-    activatesBefore: [
-      Events.SetupIntents
-    ],
-    activatesAfter: [
-      Events.DispatcherReady
-    ],
-    activate: (context) => {
-      const state = create3({
-        dispatch: defaultEffect,
-        dispatchPromise: defaultPromise,
-        undo: defaultEffect,
-        undoPromise: defaultPromise
-      });
-      const { dispatch, dispatchPromise, undo, undoPromise } = createDispatcher((module) => context.requestCapabilities(Capabilities.IntentResolver, (c, moduleId) => {
-        return module ? moduleId === module : true;
-      }).flat());
-      state.dispatch = dispatch;
-      state.dispatchPromise = dispatchPromise;
-      state.undo = undo;
-      state.undoPromise = undoPromise;
-      return [
-        contributes(Capabilities.IntentDispatcher, state),
-        contributes(Capabilities.ReactContext, {
-          id: INTENT_PLUGIN,
-          context: ({ children }) => /* @__PURE__ */ React2.createElement(IntentProvider, {
-            value: state
-          }, children)
-        })
-      ];
-    }
-  })
-]);
-
-// packages/sdk/app-framework/src/common/layout.ts
-var Toast = S4.Struct({
-  id: S4.String,
-  title: S4.optional(Label),
-  description: S4.optional(Label),
-  icon: S4.optional(S4.String),
-  duration: S4.optional(S4.Number),
-  closeLabel: S4.optional(Label),
-  actionLabel: S4.optional(Label),
-  actionAlt: S4.optional(Label),
-  // TODO(wittjosiah): Make class with customizable method?
-  onAction: S4.optional(S4.Any)
-});
-var LayoutMode = S4.Union(S4.Literal("deck"), S4.Literal("solo"), S4.Literal("fullscreen"));
-var isLayoutMode = (value) => S4.is(LayoutMode)(value);
-var Layout = S4.mutable(S4.Struct({
-  layoutMode: LayoutMode,
-  sidebarOpen: S4.Boolean,
-  complementarySidebarOpen: S4.Boolean,
-  /**
-   * @deprecated Data to be passed to the complementary sidebar Surface.
-   */
-  complementarySidebarContent: S4.optional(S4.Any),
-  dialogOpen: S4.Boolean,
-  /**
-   * Data to be passed to the dialog Surface.
-   */
-  dialogContent: S4.optional(S4.Any),
-  // TODO(wittjosiah): Custom properties?
-  dialogBlockAlign: S4.optional(S4.Literal("start", "center")),
-  dialogType: S4.optional(S4.Literal("default", "alert")),
-  popoverOpen: S4.Boolean,
-  /**
-   * Data to be passed to the popover Surface.
-   */
-  popoverContent: S4.optional(S4.Any),
-  popoverAnchorId: S4.optional(S4.String),
-  toasts: S4.mutable(S4.Array(Toast)),
-  /**
-   * The identifier of a component to scroll into view when it is mounted.
-   */
-  scrollIntoView: S4.optional(S4.String)
-}));
-var LAYOUT_PLUGIN = "dxos.org/plugin/layout";
-var LAYOUT_ACTION = `${LAYOUT_PLUGIN}/action`;
-var LayoutAction;
-(function(LayoutAction2) {
-  class SetLayout extends S4.TaggedClass()(`${LAYOUT_ACTION}/set-layout`, {
-    input: S4.Struct({
-      /**
-      * Element to set the state of.
-      */
-      element: S4.Literal("fullscreen", "sidebar", "complementary", "dialog", "popover", "toast"),
-      /**
-      * Whether the element is on or off.
-      *
-      * If omitted, the element's state will be toggled or set based on other provided data.
-      * For example, if `component` is provided, the state will be set to `true`.
-      */
-      state: S4.optional(S4.Boolean),
-      /**
-      * Component to render in the dialog or popover.
-      */
-      component: S4.optional(S4.String),
-      /**
-      * Data to be passed to the dialog or popover Surface.
-      */
-      subject: S4.optional(S4.Any),
-      /**
-      * Anchor ID for the popover.
-      */
-      anchorId: S4.optional(S4.String),
-      // TODO(wittjosiah): Custom properties?
-      /**
-      * Block alignment for the dialog.
-      */
-      dialogBlockAlign: S4.optional(S4.Literal("start", "center")),
-      /**
-      * Type of dialog.
-      */
-      dialogType: S4.optional(S4.Literal("default", "alert"))
-    }),
-    output: S4.Void
-  }) {
-  }
-  LayoutAction2.SetLayout = SetLayout;
-  class SetLayoutMode extends S4.TaggedClass()(`${LAYOUT_ACTION}/set-layout-mode`, {
-    input: S4.Union(S4.Struct({
-      layoutMode: LayoutMode
-    }), S4.Struct({
-      revert: S4.Literal(true)
-    })),
-    output: S4.Void
-  }) {
-  }
-  LayoutAction2.SetLayoutMode = SetLayoutMode;
-  class ScrollIntoView extends S4.TaggedClass()(`${LAYOUT_ACTION}/scroll-into-view`, {
-    input: S4.Struct({
-      id: S4.optional(S4.String),
-      // TODO(wittjosiah): Factor out to thread scroll into view action?
-      cursor: S4.optional(S4.String),
-      ref: S4.optional(S4.String)
-    }),
-    output: S4.Void
-  }) {
-  }
-  LayoutAction2.ScrollIntoView = ScrollIntoView;
-})(LayoutAction || (LayoutAction = {}));
-
-// packages/sdk/app-framework/src/common/navigation.ts
-import { Schema as S5 } from "@effect/schema";
-import { pick as pick2 } from "@dxos/util";
-var SLUG_LIST_SEPARATOR = "+";
-var SLUG_ENTRY_SEPARATOR = "_";
-var SLUG_KEY_VALUE_SEPARATOR = "-";
-var SLUG_PATH_SEPARATOR = "~";
-var SLUG_COLLECTION_INDICATOR = "";
-var LayoutEntrySchema = S5.mutable(S5.Struct({
-  id: S5.String,
-  path: S5.optional(S5.String)
-}));
-var LayoutPartSchema = S5.Union(S5.Literal("sidebar").annotations({
-  description: "The primary sidebar."
-}), S5.Literal("main").annotations({
-  description: "The main content area."
-}), S5.Literal("solo").annotations({
-  description: "The solo content area."
-}), S5.Literal("complementary").annotations({
-  description: "The secondary sidebar."
-}), S5.Literal("fullScreen").annotations({
-  description: "Full screen content."
-}));
-var LayoutPartsSchema = S5.partial(S5.mutable(S5.Record({
-  key: LayoutPartSchema,
-  value: S5.mutable(S5.Array(LayoutEntrySchema))
-})));
-var LayoutCoordinateSchema = S5.mutable(S5.Struct({
-  part: LayoutPartSchema,
-  entryId: S5.String
-}));
-var PartAdjustmentSchema = S5.Union(S5.Literal("increment-start"), S5.Literal("increment-end"), S5.Literal("pin-start"), S5.Literal("pin-end"), S5.Literal("close"), S5.Literal("solo"));
-var LayoutAdjustmentSchema = S5.mutable(S5.Struct({
-  layoutCoordinate: LayoutCoordinateSchema,
-  type: PartAdjustmentSchema
-}));
-var ActiveParts = S5.Record({
-  key: S5.String,
-  value: S5.Union(S5.String, S5.mutable(S5.Array(S5.String)))
-});
-var LocationProvidesSchema = S5.mutable(S5.Struct({
-  location: S5.Struct({
-    active: LayoutPartsSchema,
-    closed: S5.Array(S5.String)
-  })
-}));
-var isLayoutParts = (value) => {
-  return S5.is(LayoutPartsSchema)(value);
-};
-var isLayoutAdjustment = (value) => {
-  return S5.is(LayoutAdjustmentSchema)(value);
-};
-var openIds = (layout, parts) => {
-  return Object.values(parts ? pick2(layout, parts) : layout).flatMap((part) => part?.map((entry) => entry.id) ?? []).filter((id) => id !== void 0);
-};
-var firstIdInPart = (layout, part) => {
-  if (!layout) {
-    return void 0;
-  }
-  return layout[part]?.at(0)?.id;
-};
-var indexInPart = (layout, layoutCoordinate) => {
-  if (!layout || !layoutCoordinate) {
-    return void 0;
-  }
-  const { part, entryId } = layoutCoordinate;
-  return layout[part]?.findIndex((entry) => entry.id === entryId);
-};
-var partLength = (layout, part) => {
-  if (!layout || !part) {
-    return 0;
-  }
-  return layout[part]?.length ?? 0;
-};
-var NAVIGATION_PLUGIN = "dxos.org/plugin/navigation";
-var NAVIGATION_ACTION = `${NAVIGATION_PLUGIN}/action`;
-var NavigationAction;
-(function(NavigationAction2) {
-  class Open extends S5.TaggedClass()(`${NAVIGATION_ACTION}/open`, {
-    input: S5.Struct({
-      activeParts: ActiveParts,
-      noToggle: S5.optional(S5.Boolean)
-    }),
-    output: S5.Struct({
-      open: S5.Array(S5.String)
-    })
-  }) {
-  }
-  NavigationAction2.Open = Open;
-  class AddToActive extends S5.TaggedClass()(`${NAVIGATION_ACTION}/add-to-active`, {
-    input: S5.Struct({
-      id: S5.String.annotations({
-        description: "The ID of the item to add."
-      }),
-      part: LayoutPartSchema.annotations({
-        description: "The part to add the item to."
-      }),
-      scrollIntoView: S5.optional(S5.Boolean.annotations({
-        description: "Scroll the item into view."
-      })),
-      pivotId: S5.optional(S5.String.annotations({
-        description: "The ID of the item to place the new item next to."
-      })),
-      positioning: S5.optional(S5.Union(S5.Literal("start").annotations({
-        description: "Place the new item before the pivot item."
-      }), S5.Literal("end").annotations({
-        description: "Place the new item after the pivot item."
-      })).annotations({
-        description: "The position to place the new item."
-      }))
-    }),
-    output: S5.Void
-  }) {
-  }
-  NavigationAction2.AddToActive = AddToActive;
-  class Set2 extends S5.TaggedClass()(`${NAVIGATION_ACTION}/set`, {
-    input: S5.Struct({
-      activeParts: ActiveParts
-    }),
-    output: S5.Void
-  }) {
-  }
-  NavigationAction2.Set = Set2;
-  class Close extends S5.TaggedClass()(`${NAVIGATION_ACTION}/close`, {
-    input: S5.Struct({
-      activeParts: ActiveParts,
-      noToggle: S5.optional(S5.Boolean)
-    }),
-    output: S5.Void
-  }) {
-  }
-  NavigationAction2.Close = Close;
-  class Adjust extends S5.TaggedClass()(`${NAVIGATION_ACTION}/adjust`, {
-    input: LayoutAdjustmentSchema,
-    output: S5.Void
-  }) {
-  }
-  NavigationAction2.Adjust = Adjust;
-  class Expose extends S5.TaggedClass()(`${NAVIGATION_ACTION}/expose`, {
-    input: S5.Struct({
-      id: S5.String
-    }),
-    output: S5.Void
-  }) {
-  }
-  NavigationAction2.Expose = Expose;
-})(NavigationAction || (NavigationAction = {}));
-
-// packages/sdk/app-framework/src/common/surface.ts
-var createSurface = (definition) => definition;
-
-// packages/sdk/app-framework/src/common/translations.ts
-import { z } from "zod";
-var ResourceKey = z.union([
-  z.string(),
-  z.record(z.any())
-]);
-var ResourceLanguage = z.record(ResourceKey);
-var Resource = z.record(ResourceLanguage);
-
-// packages/sdk/app-framework/src/react/Surface.tsx
-var useSurfaces = () => {
-  const surfaces = useCapabilities(Capabilities.ReactSurface);
-  return useMemo2(() => surfaces.flat(), [
-    surfaces
-  ]);
-};
-var findCandidates = (surfaces, { role, data }) => {
-  return Object.values(surfaces).filter((definition) => Array.isArray(definition.role) ? definition.role.includes(role) : definition.role === role).filter(({ filter }) => filter ? filter(data ?? {}) : true).toSorted(byDisposition2);
-};
-var isSurfaceAvailable = (context, { role, data }) => {
-  const surfaces = context.requestCapabilities(Capabilities.ReactSurface);
-  const candidates = findCandidates(surfaces.flat(), {
-    role,
-    data
+var defaultEffect = () => Effect2.fail(new Error("Intent runtime not ready"));
+var defaultPromise = () => Effect2.runPromise(defaultEffect());
+var intent_dispatcher_default = (context) => {
+  const state = create3({
+    dispatch: defaultEffect,
+    dispatchPromise: defaultPromise,
+    undo: defaultEffect,
+    undoPromise: defaultPromise
   });
-  return candidates.length > 0;
-};
-var Surface = /* @__PURE__ */ memo(/* @__PURE__ */ forwardRef(({ id: _id, role, data: _data, limit, fallback, placeholder, ...rest }, forwardedRef) => {
-  const surfaces = useSurfaces();
-  const data = useDefaultValue(_data, () => ({}));
-  const candidates = useMemo2(() => {
-    const definitions = findCandidates(surfaces, {
-      role,
-      data
+  const { dispatch, dispatchPromise, undo, undoPromise } = createDispatcher((module) => context.requestCapabilities(Capabilities.IntentResolver, (c, moduleId) => {
+    return module ? moduleId === module : true;
+  }).flat());
+  const manager = context.requestCapability(Capabilities.PluginManager);
+  state.dispatch = (intentChain, depth) => {
+    return Effect2.gen(function* () {
+      yield* manager._activate(Events.SetupIntents);
+      return yield* dispatch(intentChain, depth);
     });
-    return limit ? definitions.slice(0, limit) : definitions;
-  }, [
-    surfaces,
-    role,
-    data,
-    limit
-  ]);
-  const nodes = candidates.map(({ component: Component2, id }) => /* @__PURE__ */ React3.createElement(Component2, {
-    ref: forwardedRef,
-    key: id,
-    id,
-    role,
-    data,
-    limit,
-    ...rest
-  }));
-  const suspense = placeholder ? /* @__PURE__ */ React3.createElement(Suspense, {
-    fallback: placeholder
-  }, nodes) : nodes;
-  return fallback ? /* @__PURE__ */ React3.createElement(ErrorBoundary, {
-    data,
-    fallback
-  }, suspense) : suspense;
-}));
-
-// packages/sdk/app-framework/src/App.tsx
-import { effect as effect2 } from "@preact/signals-core";
-import React4 from "react";
-import { invariant as invariant2 } from "@dxos/invariant";
-import { create as create4 } from "@dxos/live-object";
-
-// packages/sdk/app-framework/src/helpers.ts
-var topologicalSort = (nodes) => {
-  const getDependencies = (nodeId, seen = /* @__PURE__ */ new Set(), path = /* @__PURE__ */ new Set()) => {
-    if (path.has(nodeId)) {
-      throw new Error(`Circular dependency detected involving ${nodeId}`);
-    }
-    if (seen.has(nodeId)) {
-      return [];
-    }
-    const node = nodes.find((n) => n.id === nodeId);
-    if (!node) {
-      throw new Error(`Node ${nodeId} not found but is listed as a dependency`);
-    }
-    const newPath = /* @__PURE__ */ new Set([
-      ...path,
-      nodeId
-    ]);
-    const newSeen = /* @__PURE__ */ new Set([
-      ...seen,
-      nodeId
-    ]);
-    const dependsOn = node.dependsOn ?? [];
-    return [
-      ...dependsOn.flatMap((depId) => getDependencies(depId, newSeen, newPath)),
-      nodeId
-    ];
   };
-  const allDependencies = nodes.map((node) => node.id).flatMap((id) => getDependencies(id)).filter((id, index, self) => self.indexOf(id) === index);
-  return allDependencies.map((id) => nodes.find((node) => node.id === id)).filter((node) => node !== void 0);
-};
-
-// packages/sdk/app-framework/src/App.tsx
-var __dxlog_file3 = "/home/runner/work/dxos/dxos/packages/sdk/app-framework/src/App.tsx";
-var ENABLED_KEY = "dxos.org/app-framework/enabled";
-var createApp = ({ pluginManager, pluginLoader: _pluginLoader, plugins = [], core = plugins.map(({ meta }) => meta.id), defaults = [], placeholder = null, fallback = DefaultFallback, cacheEnabled = false }) => {
-  const pluginLoader = _pluginLoader ?? ((id) => {
-    const plugin = plugins.find((plugin2) => plugin2.meta.id === id);
-    invariant2(plugin, `Plugin not found: ${id}`, {
-      F: __dxlog_file3,
-      L: 68,
-      S: void 0,
-      A: [
-        "plugin",
-        "`Plugin not found: ${id}`"
-      ]
-    });
-    return plugin;
-  });
-  const state = create4({
-    ready: false,
-    error: null
-  });
-  const cached = JSON.parse(localStorage.getItem(ENABLED_KEY) ?? "[]");
-  const enabled = cacheEnabled && cached.length > 0 ? cached : defaults;
-  const manager = pluginManager ?? new PluginManager({
-    pluginLoader,
-    plugins,
-    core,
-    enabled
-  });
-  manager.activation.on(({ event, state: _state, error }) => {
-    if (event === Events.Startup.id) {
-      state.ready = _state === "activated";
-    }
-    if (error && !state.ready && !state.error) {
-      state.error = error;
-    }
-  });
-  effect2(() => {
-    cacheEnabled && localStorage.setItem(ENABLED_KEY, JSON.stringify(manager.enabled));
-  });
-  manager.context.contributeCapability({
-    interface: Capabilities.PluginManager,
-    implementation: manager,
-    module: "dxos.org/app-framework/plugin-manager"
-  });
-  setupDevtools(manager);
-  void manager.activate(Events.Startup);
-  return () => /* @__PURE__ */ React4.createElement(ErrorBoundary, {
-    fallback
-  }, /* @__PURE__ */ React4.createElement(App, {
-    placeholder,
-    manager,
-    state
-  }));
-};
-var App = ({ placeholder, manager, state }) => {
-  if (state.error) {
-    throw state.error;
-  }
-  if (!state.ready) {
-    return /* @__PURE__ */ React4.createElement(React4.Fragment, null, placeholder);
-  }
-  const reactContexts = manager.context.requestCapabilities(Capabilities.ReactContext);
-  const reactRoots = manager.context.requestCapabilities(Capabilities.ReactRoot);
-  const ComposedContext = composeContexts(reactContexts);
-  return /* @__PURE__ */ React4.createElement(PluginManagerProvider, {
-    value: manager
-  }, /* @__PURE__ */ React4.createElement(ComposedContext, null, reactRoots.map(({ id, root: Component2 }) => /* @__PURE__ */ React4.createElement(Component2, {
-    key: id
-  }))));
-};
-var DefaultFallback = ({ error }) => {
-  return /* @__PURE__ */ React4.createElement("div", {
-    style: {
-      padding: "1rem"
-    }
-  }, /* @__PURE__ */ React4.createElement("h1", {
-    style: {
-      fontSize: "1.2rem",
-      fontWeight: 700,
-      margin: "0.5rem 0"
-    }
-  }, error.message), /* @__PURE__ */ React4.createElement("pre", null, error.stack));
-};
-var composeContexts = (contexts) => {
-  if (contexts.length === 0) {
-    return ({ children }) => /* @__PURE__ */ React4.createElement(React4.Fragment, null, children);
-  }
-  return topologicalSort(contexts).map(({ context }) => context).reduce((Acc, Next) => ({ children }) => /* @__PURE__ */ React4.createElement(Acc, null, /* @__PURE__ */ React4.createElement(Next, null, children)));
-};
-var setupDevtools = (manager) => {
-  globalThis.composer ??= {};
-  globalThis.composer.manager = manager;
+  state.dispatchPromise = async (intentChain) => {
+    await manager.activate(Events.SetupIntents);
+    return await dispatchPromise(intentChain);
+  };
+  state.undo = undo;
+  state.undoPromise = undoPromise;
+  return contributes(Capabilities.IntentDispatcher, state);
 };
 
 export {
@@ -1582,42 +1392,14 @@ export {
   IntentAction,
   createResolver,
   createDispatcher,
-  ErrorBoundary,
-  usePluginManager,
-  PluginManagerProvider,
-  useCapabilities,
-  useCapability,
-  isSurfaceAvailable,
-  Surface,
-  useIntentDispatcher,
-  useIntentResolver,
-  IntentProvider,
+  intent_dispatcher_default,
   IntentPlugin,
-  Toast,
-  isLayoutMode,
-  Layout,
   LAYOUT_PLUGIN,
   LAYOUT_ACTION,
   LayoutAction,
-  SLUG_LIST_SEPARATOR,
-  SLUG_ENTRY_SEPARATOR,
-  SLUG_KEY_VALUE_SEPARATOR,
-  SLUG_PATH_SEPARATOR,
-  SLUG_COLLECTION_INDICATOR,
-  ActiveParts,
-  isLayoutParts,
-  isLayoutAdjustment,
-  openIds,
-  firstIdInPart,
-  indexInPart,
-  partLength,
-  NAVIGATION_PLUGIN,
-  NAVIGATION_ACTION,
-  NavigationAction,
   createSurface,
   ResourceKey,
   ResourceLanguage,
-  Resource,
-  createApp
+  Resource
 };
-//# sourceMappingURL=chunk-ZFOOPWBG.mjs.map
+//# sourceMappingURL=chunk-ZTB4TA6Q.mjs.map