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

package/dist/lib/node/chunk-7PNEFY2G.cjs

@@ -0,0 +1,1665 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var chunk_7PNEFY2G_exports = {};
+__export(chunk_7PNEFY2G_exports, {
+  ActiveParts: () => ActiveParts,
+  Capabilities: () => Capabilities,
+  ErrorBoundary: () => ErrorBoundary,
+  Events: () => Events,
+  FileInfoSchema: () => FileInfoSchema,
+  INTENT_ACTION: () => INTENT_ACTION,
+  INTENT_PLUGIN: () => INTENT_PLUGIN,
+  IntentAction: () => IntentAction,
+  IntentPlugin: () => IntentPlugin,
+  IntentProvider: () => IntentProvider,
+  LAYOUT_ACTION: () => LAYOUT_ACTION,
+  LAYOUT_PLUGIN: () => LAYOUT_PLUGIN,
+  Label: () => Label,
+  Layout: () => Layout,
+  LayoutAction: () => LayoutAction,
+  NAVIGATION_ACTION: () => NAVIGATION_ACTION,
+  NAVIGATION_PLUGIN: () => NAVIGATION_PLUGIN,
+  NavigationAction: () => NavigationAction,
+  Plugin: () => Plugin,
+  PluginManager: () => PluginManager,
+  PluginManagerProvider: () => PluginManagerProvider,
+  PluginModule: () => PluginModule,
+  PluginsContext: () => PluginsContext,
+  Resource: () => Resource,
+  ResourceKey: () => ResourceKey,
+  ResourceLanguage: () => ResourceLanguage,
+  SLUG_COLLECTION_INDICATOR: () => SLUG_COLLECTION_INDICATOR,
+  SLUG_ENTRY_SEPARATOR: () => SLUG_ENTRY_SEPARATOR,
+  SLUG_KEY_VALUE_SEPARATOR: () => SLUG_KEY_VALUE_SEPARATOR,
+  SLUG_LIST_SEPARATOR: () => SLUG_LIST_SEPARATOR,
+  SLUG_PATH_SEPARATOR: () => SLUG_PATH_SEPARATOR,
+  Surface: () => Surface,
+  Toast: () => Toast,
+  allOf: () => allOf,
+  chain: () => chain,
+  contributes: () => contributes,
+  createApp: () => createApp,
+  createDispatcher: () => createDispatcher,
+  createIntent: () => createIntent,
+  createResolver: () => createResolver,
+  createSurface: () => createSurface,
+  defaultFileTypes: () => defaultFileTypes,
+  defineCapability: () => defineCapability,
+  defineEvent: () => defineEvent,
+  defineModule: () => defineModule,
+  definePlugin: () => definePlugin,
+  eventKey: () => eventKey,
+  firstIdInPart: () => firstIdInPart,
+  getEvents: () => getEvents,
+  indexInPart: () => indexInPart,
+  isAllOf: () => isAllOf,
+  isLayoutAdjustment: () => isLayoutAdjustment,
+  isLayoutMode: () => isLayoutMode,
+  isLayoutParts: () => isLayoutParts,
+  isOneOf: () => isOneOf,
+  isSurfaceAvailable: () => isSurfaceAvailable,
+  lazy: () => lazy,
+  oneOf: () => oneOf,
+  openIds: () => openIds,
+  partLength: () => partLength,
+  useCapabilities: () => useCapabilities,
+  useCapability: () => useCapability,
+  useIntentDispatcher: () => useIntentDispatcher,
+  useIntentResolver: () => useIntentResolver,
+  usePluginManager: () => usePluginManager
+});
+module.exports = __toCommonJS(chunk_7PNEFY2G_exports);
+var import_signals_core = require("@preact/signals-core");
+var import_async = require("@dxos/async");
+var import_invariant = require("@dxos/invariant");
+var import_live_object = require("@dxos/live-object");
+var import_log = require("@dxos/log");
+var import_signals_core2 = require("@preact/signals-core");
+var import_effect = require("effect");
+var import_async2 = require("@dxos/async");
+var import_live_object2 = require("@dxos/live-object");
+var import_log2 = require("@dxos/log");
+var import_echo_schema = require("@dxos/echo-schema");
+var import_echo_schema2 = require("@dxos/echo-schema");
+var import_echo_schema3 = require("@dxos/echo-schema");
+var import_effect2 = require("effect");
+var import_util = require("@dxos/util");
+var import_react = __toESM(require("react"));
+var import_react2 = require("react");
+var import_debug = require("@dxos/debug");
+var import_signals_core3 = require("@preact/signals-core");
+var import_react3 = require("react");
+var import_react4 = __toESM(require("react"));
+var import_react_hooks = require("@dxos/react-hooks");
+var import_util2 = require("@dxos/util");
+var import_echo_schema4 = require("@dxos/echo-schema");
+var import_react5 = require("react");
+var import_debug2 = require("@dxos/debug");
+var import_util3 = require("@dxos/util");
+var import_effect3 = require("effect");
+var import_react6 = __toESM(require("react"));
+var import_live_object3 = require("@dxos/live-object");
+var import_schema = require("@effect/schema");
+var import_util4 = require("@dxos/util");
+var import_zod = require("zod");
+var import_signals_core4 = require("@preact/signals-core");
+var import_react7 = __toESM(require("react"));
+var import_invariant2 = require("@dxos/invariant");
+var import_live_object4 = require("@dxos/live-object");
+var __dxlog_file = "/home/runner/work/dxos/dxos/packages/sdk/app-framework/src/core/capabilities.ts";
+var InterfaceDefTypeId = Symbol.for("InterfaceDefTypeId");
+var defineCapability = (identifier) => {
+  return {
+    identifier
+  };
+};
+var CapabilityImpl = class {
+  constructor(moduleId, implementation) {
+    this.moduleId = moduleId;
+    this.implementation = implementation;
+  }
+};
+var contributes = (interfaceDef, implementation, deactivate) => {
+  return {
+    interface: interfaceDef,
+    implementation,
+    deactivate
+  };
+};
+var lazy = (c) => (props) => c().then(({ default: getCapability }) => {
+  return getCapability(props);
+});
+var PluginsContext = class {
+  constructor({ activate, reset }) {
+    this._definedCapabilities = /* @__PURE__ */ new Map();
+    this.activate = activate;
+    this.reset = reset;
+  }
+  /**
+  * @internal
+  */
+  contributeCapability({ module: moduleId, interface: interfaceDef, implementation }) {
+    let current = this._definedCapabilities.get(interfaceDef.identifier);
+    if (!current) {
+      const object = (0, import_live_object.create)({
+        value: []
+      });
+      current = (0, import_signals_core.untracked)(() => object.value);
+      this._definedCapabilities.set(interfaceDef.identifier, current);
+    }
+    current.push(new CapabilityImpl(moduleId, implementation));
+    (0, import_log.log)("capability contributed", {
+      id: interfaceDef.identifier,
+      count: (0, import_signals_core.untracked)(() => current.length)
+    }, {
+      F: __dxlog_file,
+      L: 139,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+  }
+  /**
+  * @internal
+  */
+  removeCapability(interfaceDef, implementation) {
+    const current = this._definedCapabilities.get(interfaceDef.identifier);
+    if (!current) {
+      return;
+    }
+    const index = current.findIndex((i) => i.implementation === implementation);
+    if (index !== -1) {
+      current.splice(index, 1);
+      (0, import_log.log)("capability removed", {
+        id: interfaceDef.identifier,
+        count: (0, import_signals_core.untracked)(() => current.length)
+      }, {
+        F: __dxlog_file,
+        L: 154,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    }
+  }
+  /**
+  * Requests capabilities from the plugin context.
+  * @returns An array of capabilities.
+  * @reactive
+  */
+  requestCapabilities(interfaceDef, filter) {
+    let current = this._definedCapabilities.get(interfaceDef.identifier);
+    if (!current) {
+      const object = (0, import_live_object.create)({
+        value: []
+      });
+      current = (0, import_signals_core.untracked)(() => object.value);
+      this._definedCapabilities.set(interfaceDef.identifier, current);
+    }
+    const capabilities = filter ? current.filter((c) => filter(c.implementation, c.moduleId)) : current;
+    return capabilities.map((c) => c.implementation);
+  }
+  /**
+  * Requests a single capability from the plugin context.
+  * @returns The capability.
+  * @throws If no capability is found.
+  * @reactive
+  */
+  requestCapability(interfaceDef, filter) {
+    const capability = this.requestCapabilities(interfaceDef, filter)[0];
+    (0, import_invariant.invariant)(capability, `No capability found for ${interfaceDef.identifier}`, {
+      F: __dxlog_file,
+      L: 190,
+      S: this,
+      A: [
+        "capability",
+        "`No capability found for ${interfaceDef.identifier}`"
+      ]
+    });
+    return capability;
+  }
+  /**
+  * Waits for a capability to be contributed.
+  * @returns The capability.
+  */
+  async waitForCapability(interfaceDef, filter) {
+    const trigger = new import_async.Trigger();
+    const unsubscribe = (0, import_signals_core.effect)(() => {
+      const capabilities = this.requestCapabilities(interfaceDef, filter);
+      if (capabilities[0]) {
+        trigger.wake(capabilities[0]);
+      }
+    });
+    const capability = await trigger.wait();
+    unsubscribe();
+    return capability;
+  }
+};
+var defineEvent = (id, specifier) => {
+  return {
+    id,
+    specifier
+  };
+};
+var eventKey = (event) => event.specifier ? `${event.id}:${event.specifier}` : event.id;
+var oneOf = (...events) => ({
+  type: "one-of",
+  events
+});
+var allOf = (...events) => ({
+  type: "all-of",
+  events
+});
+var isOneOf = (events) => "type" in events && events.type === "one-of";
+var isAllOf = (events) => "type" in events && events.type === "all-of";
+var getEvents = (events) => "type" in events ? events.events : [
+  events
+];
+var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/sdk/app-framework/src/core/manager.ts";
+var isPromise = (value) => {
+  return value !== null && typeof value === "object" && "then" in value;
+};
+var PluginManager = class {
+  constructor({ pluginLoader, plugins = [], core = plugins.map(({ meta }) => meta.id), enabled = [] }) {
+    this.activation = new import_async2.Event();
+    this.context = new PluginsContext({
+      activate: (event) => this.activate(event),
+      reset: (id) => this.reset(id)
+    });
+    this._capabilities = /* @__PURE__ */ new Map();
+    this._pluginLoader = pluginLoader;
+    this._state = (0, import_live_object2.create)({
+      plugins,
+      core,
+      enabled,
+      modules: [],
+      active: [],
+      pendingRemoval: [],
+      pendingReset: [],
+      eventsFired: []
+    });
+    plugins.forEach((plugin) => this._addPlugin(plugin));
+    core.forEach((id) => this.enable(id));
+    enabled.forEach((id) => this.enable(id));
+  }
+  /**
+  * Plugins that are currently registered.
+  *
+  * @reactive
+  */
+  get plugins() {
+    return this._state.plugins;
+  }
+  /**
+  * Ids of plugins that are core and cannot be removed.
+  *
+  * @reactive
+  */
+  get core() {
+    return this._state.core;
+  }
+  /**
+  * Ids of plugins that are currently enabled.
+  *
+  * @reactive
+  */
+  get enabled() {
+    return this._state.enabled;
+  }
+  /**
+  * Modules of plugins which are currently enabled.
+  *
+  * @reactive
+  */
+  get modules() {
+    return this._state.modules;
+  }
+  /**
+  * Ids of modules which are currently active.
+  *
+  * @reactive
+  */
+  get active() {
+    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
+  */
+  get eventsFired() {
+    return this._state.eventsFired;
+  }
+  /**
+  * Ids of modules which are pending reset.
+  *
+  * @reactive
+  */
+  get pendingReset() {
+    return this._state.pendingReset;
+  }
+  /**
+  * Adds a plugin to the manager via the plugin loader.
+  * @param id The id of the plugin.
+  */
+  async add(id) {
+    return (0, import_signals_core2.untracked)(async () => {
+      (0, import_log2.log)("add plugin", {
+        id
+      }, {
+        F: __dxlog_file2,
+        L: 157,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      const plugin = await this._pluginLoader(id);
+      this._addPlugin(plugin);
+      return this.enable(id);
+    });
+  }
+  /**
+  * Enables a plugin.
+  * @param id The id of the plugin.
+  */
+  enable(id) {
+    return (0, import_signals_core2.untracked)(() => {
+      (0, import_log2.log)("enable plugin", {
+        id
+      }, {
+        F: __dxlog_file2,
+        L: 170,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      const plugin = this._getPlugin(id);
+      if (!plugin) {
+        return false;
+      }
+      if (!this._state.enabled.includes(id)) {
+        this._state.enabled.push(id);
+      }
+      plugin.modules.forEach((module2) => {
+        this._addModule(module2);
+        this._setPendingResetByModule(module2);
+      });
+      return true;
+    });
+  }
+  /**
+  * Removes a plugin from the manager.
+  * @param id The id of the plugin.
+  */
+  remove(id) {
+    return (0, import_signals_core2.untracked)(() => {
+      (0, import_log2.log)("remove plugin", {
+        id
+      }, {
+        F: __dxlog_file2,
+        L: 194,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      const result = this.disable(id);
+      if (!result) {
+        return false;
+      }
+      this._removePlugin(id);
+      return true;
+    });
+  }
+  /**
+  * Disables a plugin.
+  * @param id The id of the plugin.
+  */
+  disable(id) {
+    return (0, import_signals_core2.untracked)(() => {
+      (0, import_log2.log)("disable plugin", {
+        id
+      }, {
+        F: __dxlog_file2,
+        L: 211,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      if (this._state.core.includes(id)) {
+        return false;
+      }
+      const plugin = this._getPlugin(id);
+      if (!plugin) {
+        return false;
+      }
+      const enabledIndex = this._state.enabled.findIndex((enabled) => enabled === id);
+      if (enabledIndex !== -1) {
+        this._state.enabled.splice(enabledIndex, 1);
+        plugin.modules.forEach((module2) => {
+          if (this._state.active.includes(module2.id)) {
+            this._setPendingResetByModule(module2);
+            if (!this._state.pendingRemoval.includes(module2.id)) {
+              this._state.pendingRemoval.push(module2.id);
+            }
+          } else {
+            this._removeModule(module2.id);
+          }
+        });
+      }
+      return true;
+    });
+  }
+  /**
+  * Activates plugins based on the activation event.
+  * @param event The activation event.
+  * @returns Whether the activation was successful.
+  */
+  activate(event) {
+    return (0, import_signals_core2.untracked)(() => import_effect.Effect.runPromise(this._activate(event)));
+  }
+  /**
+  * Deactivates all of the modules for a plugin.
+  * @param id The id of the plugin.
+  * @returns Whether the deactivation was successful.
+  */
+  deactivate(id) {
+    return (0, import_signals_core2.untracked)(() => import_effect.Effect.runPromise(this._deactivate(id)));
+  }
+  /**
+  * Re-activates the modules that were activated by the event.
+  * @param event The activation event.
+  * @returns Whether the reset was successful.
+  */
+  reset(event) {
+    return (0, import_signals_core2.untracked)(() => import_effect.Effect.runPromise(this._reset(event)));
+  }
+  _addPlugin(plugin) {
+    (0, import_signals_core2.untracked)(() => {
+      (0, import_log2.log)("add plugin", {
+        id: plugin.meta.id
+      }, {
+        F: __dxlog_file2,
+        L: 270,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      if (!this._state.plugins.includes(plugin)) {
+        this._state.plugins.push(plugin);
+      }
+    });
+  }
+  _removePlugin(id) {
+    (0, import_signals_core2.untracked)(() => {
+      (0, import_log2.log)("remove plugin", {
+        id
+      }, {
+        F: __dxlog_file2,
+        L: 279,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      const pluginIndex = this._state.plugins.findIndex((plugin) => plugin.meta.id === id);
+      if (pluginIndex !== -1) {
+        this._state.plugins.splice(pluginIndex, 1);
+      }
+    });
+  }
+  _addModule(module2) {
+    (0, import_signals_core2.untracked)(() => {
+      (0, import_log2.log)("add module", {
+        id: module2.id
+      }, {
+        F: __dxlog_file2,
+        L: 289,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      if (!this._state.modules.includes(module2)) {
+        this._state.modules.push(module2);
+      }
+    });
+  }
+  _removeModule(id) {
+    (0, import_signals_core2.untracked)(() => {
+      (0, import_log2.log)("remove module", {
+        id
+      }, {
+        F: __dxlog_file2,
+        L: 298,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      const moduleIndex = this._state.modules.findIndex((module2) => module2.id === id);
+      if (moduleIndex !== -1) {
+        this._state.modules.splice(moduleIndex, 1);
+      }
+    });
+  }
+  _getPlugin(id) {
+    return this._state.plugins.find((plugin) => plugin.meta.id === id);
+  }
+  _getActiveModules() {
+    return this._state.modules.filter((module2) => this._state.active.includes(module2.id));
+  }
+  _getInactiveModules() {
+    return this._state.modules.filter((module2) => !this._state.active.includes(module2.id));
+  }
+  _getActiveModulesByEvent(key) {
+    return this._getActiveModules().filter((module2) => getEvents(module2.activatesOn).map(eventKey).includes(key));
+  }
+  _getInactiveModulesByEvent(key) {
+    return this._getInactiveModules().filter((module2) => getEvents(module2.activatesOn).map(eventKey).includes(key));
+  }
+  _setPendingResetByModule(module2) {
+    return (0, import_signals_core2.untracked)(() => {
+      const activationEvents = getEvents(module2.activatesOn).map(eventKey).filter((key) => this._state.eventsFired.includes(key));
+      const parentEvents = activationEvents.flatMap((event) => {
+        const modules = this._getActiveModules().filter((module22) => module22.activatesBefore?.map(eventKey).includes(event));
+        return modules.flatMap((module22) => getEvents(module22.activatesOn)).map(eventKey);
+      });
+      const pendingReset = Array.from(/* @__PURE__ */ new Set([
+        ...activationEvents,
+        ...parentEvents
+      ])).filter((event) => !this._state.pendingReset.includes(event));
+      if (pendingReset.length > 0) {
+        (0, import_log2.log)("pending reset", {
+          events: pendingReset
+        }, {
+          F: __dxlog_file2,
+          L: 342,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        this._state.pendingReset.push(...pendingReset);
+      }
+    });
+  }
+  // TODO(wittjosiah): Improve error typing.
+  _activate(event) {
+    const self = this;
+    return import_effect.Effect.gen(function* () {
+      const key = typeof event === "string" ? event : eventKey(event);
+      (0, import_log2.log)("activating", {
+        key
+      }, {
+        F: __dxlog_file2,
+        L: 353,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      const pendingIndex = self._state.pendingReset.findIndex((event2) => event2 === key);
+      if (pendingIndex !== -1) {
+        self._state.pendingReset.splice(pendingIndex, 1);
+      }
+      const modules = self._getInactiveModulesByEvent(key);
+      if (modules.length === 0) {
+        (0, import_log2.log)("no modules to activate", {
+          key
+        }, {
+          F: __dxlog_file2,
+          L: 361,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        return false;
+      }
+      self.activation.emit({
+        event: key,
+        state: "activating"
+      });
+      for (const module2 of modules) {
+        if (isAllOf(module2.activatesOn) && !module2.activatesOn.events.filter((event2) => eventKey(event2) !== key).every((event2) => self._state.eventsFired.includes(eventKey(event2)))) {
+          continue;
+        }
+        yield* import_effect.Effect.all(module2.activatesBefore?.map((event2) => self._activate(event2)) ?? []);
+        const result = yield* self._activateModule(module2).pipe(import_effect.Effect.either);
+        if (import_effect.Either.isLeft(result)) {
+          self.activation.emit({
+            event: key,
+            state: "error",
+            error: result.left
+          });
+          yield* import_effect.Effect.fail(result.left);
+        }
+        yield* import_effect.Effect.all(module2.activatesAfter?.map((event2) => self._activate(event2)) ?? []);
+      }
+      if (!self._state.eventsFired.includes(key)) {
+        self._state.eventsFired.push(key);
+      }
+      self.activation.emit({
+        event: key,
+        state: "activated"
+      });
+      (0, import_log2.log)("activated", {
+        key
+      }, {
+        F: __dxlog_file2,
+        L: 393,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      return true;
+    });
+  }
+  _activateModule(module2) {
+    const self = this;
+    return import_effect.Effect.gen(function* () {
+      const program = module2.activate(self.context);
+      const maybeCapabilities = yield* import_effect.Match.value(program).pipe(import_effect.Match.when(import_effect.Effect.isEffect, (effect3) => effect3), import_effect.Match.when(isPromise, (promise) => import_effect.Effect.tryPromise({
+        try: () => promise,
+        catch: (error) => error
+      })), import_effect.Match.orElse((program2) => import_effect.Effect.succeed(program2)));
+      const capabilities = import_effect.Match.value(maybeCapabilities).pipe(import_effect.Match.when(Array.isArray, (array) => array), import_effect.Match.orElse((value) => [
+        value
+      ]));
+      capabilities.forEach((capability) => {
+        self.context.contributeCapability({
+          module: module2.id,
+          ...capability
+        });
+      });
+      self._state.active.push(module2.id);
+      self._capabilities.set(module2.id, capabilities);
+    });
+  }
+  _deactivate(id) {
+    const self = this;
+    return import_effect.Effect.gen(function* () {
+      const plugin = self._getPlugin(id);
+      if (!plugin) {
+        return false;
+      }
+      const modules = plugin.modules;
+      const results = yield* import_effect.Effect.all(modules.map((module2) => self._deactivateModule(module2)));
+      return results.every((result) => result);
+    });
+  }
+  _deactivateModule(module2) {
+    const self = this;
+    return import_effect.Effect.gen(function* () {
+      const id = module2.id;
+      (0, import_log2.log)("deactivating", {
+        id
+      }, {
+        F: __dxlog_file2,
+        L: 444,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      const capabilities = self._capabilities.get(id);
+      if (capabilities) {
+        for (const capability of capabilities) {
+          self.context.removeCapability(capability.interface, capability.implementation);
+          const program = capability.deactivate?.();
+          yield* import_effect.Match.value(program).pipe(import_effect.Match.when(import_effect.Effect.isEffect, (effect3) => effect3), import_effect.Match.when(isPromise, (promise) => import_effect.Effect.tryPromise({
+            try: () => promise,
+            catch: (error) => error
+          })), import_effect.Match.orElse((program2) => import_effect.Effect.succeed(program2)));
+        }
+        self._capabilities.delete(id);
+      }
+      const activeIndex = self._state.active.findIndex((event) => event === id);
+      if (activeIndex !== -1) {
+        self._state.active.splice(activeIndex, 1);
+      }
+      (0, import_log2.log)("deactivated", {
+        id
+      }, {
+        F: __dxlog_file2,
+        L: 470,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      return true;
+    });
+  }
+  _reset(event) {
+    const self = this;
+    return import_effect.Effect.gen(function* () {
+      const key = typeof event === "string" ? event : eventKey(event);
+      (0, import_log2.log)("reset", {
+        key
+      }, {
+        F: __dxlog_file2,
+        L: 479,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      const modules = self._getActiveModulesByEvent(key);
+      const results = yield* import_effect.Effect.all(modules.map((module2) => self._deactivateModule(module2)));
+      if (self._state.pendingRemoval.length > 0) {
+        self._state.pendingRemoval.forEach((id) => {
+          self._removeModule(id);
+        });
+        self._state.pendingRemoval.splice(0, self._state.pendingRemoval.length);
+      }
+      if (results.every((result) => result)) {
+        return yield* self._activate(key);
+      } else {
+        return false;
+      }
+    });
+  }
+};
+var PluginModule = class {
+  constructor(options) {
+    this.id = options.id;
+    this.activatesOn = options.activatesOn;
+    this.activatesBefore = options.activatesBefore;
+    this.activatesAfter = options.activatesAfter;
+    this.activate = options.activate;
+  }
+};
+var defineModule = (options) => new PluginModule(options);
+var Plugin = class {
+  constructor(meta, modules) {
+    this.meta = meta;
+    this.modules = modules;
+  }
+};
+var definePlugin = (meta, modules) => {
+  return new Plugin(meta, modules);
+};
+var Capabilities;
+(function(Capabilities2) {
+  Capabilities2.PluginManager = defineCapability("dxos.org/app-framework/capability/plugin-manager");
+  Capabilities2.Null = defineCapability("dxos.org/app-framework/capability/null");
+  Capabilities2.ReactContext = defineCapability("dxos.org/app-framework/capability/react-context");
+  Capabilities2.ReactRoot = defineCapability("dxos.org/app-framework/capability/react-root");
+  Capabilities2.ReactSurface = defineCapability("dxos.org/app-framework/common/react-surface");
+  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");
+  Capabilities2.AppGraphSerializer = defineCapability("dxos.org/app-framework/capability/app-graph-serializer");
+  Capabilities2.SettingsStore = defineCapability("dxos.org/app-framework/capability/settings-store");
+  Capabilities2.Settings = defineCapability("dxos.org/app-framework/capability/settings");
+  Capabilities2.Metadata = defineCapability("dxos.org/app-framework/capability/metadata");
+  Capabilities2.Tools = defineCapability("dxos.org/app-framework/capability/tools");
+  Capabilities2.ArtifactDefinition = defineCapability("dxos.org/app-framework/capability/artifact-definition");
+  Capabilities2.FileUploader = defineCapability("dxos.org/app-framework/capability/file-uploader");
+})(Capabilities || (Capabilities = {}));
+var Events;
+(function(Events2) {
+  Events2.Startup = defineEvent("dxos.org/app-framework/event/startup");
+  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");
+  Events2.SetupTranslations = defineEvent("dxos.org/app-framework/event/setup-translations");
+  Events2.DispatcherReady = defineEvent("dxos.org/app-framework/event/dispatcher-ready");
+  Events2.SettingsReady = defineEvent("dxos.org/app-framework/event/settings-ready");
+  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 = {}));
+var defaultFileTypes = {
+  images: [
+    "png",
+    "jpg",
+    "jpeg",
+    "gif"
+  ],
+  media: [
+    "mp3",
+    "mp4",
+    "mov",
+    "avi"
+  ],
+  text: [
+    "pdf",
+    "txt",
+    "md"
+  ]
+};
+var FileInfoSchema = import_echo_schema.S.Struct({
+  name: import_echo_schema.S.String,
+  type: import_echo_schema.S.String,
+  url: import_echo_schema.S.optional(import_echo_schema.S.String),
+  cid: import_echo_schema.S.optional(import_echo_schema.S.String)
+});
+var createIntent = (schema, data = {}, params = {}) => {
+  const _ = import_echo_schema2.S.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 = import_echo_schema2.S.Union(import_echo_schema2.S.String, import_echo_schema2.S.mutable(import_echo_schema2.S.Tuple(import_echo_schema2.S.String, import_echo_schema2.S.mutable(import_echo_schema2.S.Struct({
+  ns: import_echo_schema2.S.String,
+  count: import_echo_schema2.S.optional(import_echo_schema2.S.Number)
+})))));
+var INTENT_PLUGIN = "dxos.org/plugin/intent";
+var INTENT_ACTION = `${INTENT_PLUGIN}/action`;
+var IntentAction;
+(function(IntentAction2) {
+  class ShowUndo extends import_echo_schema3.S.TaggedClass()(`${INTENT_ACTION}/show-undo`, {
+    input: import_echo_schema3.S.Struct({
+      message: Label
+    }),
+    output: import_echo_schema3.S.Void
+  }) {
+  }
+  IntentAction2.ShowUndo = ShowUndo;
+})(IntentAction || (IntentAction = {}));
+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);
+  }
+};
+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);
+  }
+};
+var EXECUTION_LIMIT = 100;
+var HISTORY_LIMIT = 100;
+var createResolver = (schema, effect3, params = {}) => ({
+  action: schema._tag,
+  effect: effect3,
+  ...params
+});
+var isUndoable = (historyEntry) => historyEntry.length > 0 && historyEntry.every(({ undoable }) => !!undoable);
+var createDispatcher = (getResolvers, { executionLimit = EXECUTION_LIMIT, historyLimit = HISTORY_LIMIT } = {}) => {
+  const historyRef = import_effect2.Effect.runSync(import_effect2.Ref.make([]));
+  const handleIntent = (intent) => {
+    return import_effect2.Effect.gen(function* () {
+      const candidates = getResolvers(intent.module).filter((r) => r.action === intent.action).filter((r) => !r.filter || r.filter(intent.data)).toSorted(import_util.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 = import_effect2.Effect.isEffect(effect3) ? yield* effect3 : yield* import_effect2.Effect.promise(async () => effect3);
+      return {
+        _intent: intent,
+        ...result
+      };
+    });
+  };
+  const dispatch = (intentChain, depth = 0) => {
+    return import_effect2.Effect.gen(function* () {
+      if (depth > executionLimit) {
+        yield* import_effect2.Effect.fail(new CycleDetectedError());
+      }
+      const resultsRef = yield* import_effect2.Ref.make([]);
+      for (const intent of intentChain.all) {
+        const { data: prev } = (yield* resultsRef.get)[0] ?? {};
+        const result2 = yield* handleIntent({
+          ...intent,
+          data: {
+            ...intent.data,
+            ...prev
+          }
+        });
+        yield* import_effect2.Ref.update(resultsRef, (results2) => [
+          result2,
+          ...results2
+        ]);
+        if (result2.intents) {
+          for (const intent2 of result2.intents) {
+            yield* dispatch(intent2, depth + 1);
+          }
+        }
+        if (result2.error) {
+          yield* import_effect2.Effect.fail(result2.error);
+        }
+      }
+      const results = yield* resultsRef.get;
+      const result = results[0];
+      yield* import_effect2.Ref.update(historyRef, (history) => {
+        const next = [
+          ...history,
+          results
+        ];
+        if (next.length > historyLimit) {
+          next.splice(0, next.length - historyLimit);
+        }
+        return next;
+      });
+      if (result.undoable && isUndoable(results)) {
+        yield* (0, import_effect2.pipe)(dispatch(createIntent(IntentAction.ShowUndo, {
+          message: result.undoable.message
+        })), import_effect2.Effect.catchSome((err) => err instanceof NoResolversError ? import_effect2.Option.some(import_effect2.Effect.succeed(void 0)) : import_effect2.Option.none()));
+      }
+      return result.data;
+    });
+  };
+  const dispatchPromise = (intentChain) => {
+    return import_effect2.Effect.runPromise(dispatch(intentChain)).then((data) => ({
+      data
+    })).catch((error) => ({
+      error
+    }));
+  };
+  const undo = () => {
+    return import_effect2.Effect.gen(function* () {
+      const history = yield* historyRef.get;
+      const last = history.findLastIndex(isUndoable);
+      const result = last !== -1 ? history[last] : void 0;
+      if (result) {
+        const all = result.map(({ _intent, undoable }) => {
+          const data = _intent.data;
+          const undoData = undoable?.data ?? {};
+          return {
+            ..._intent,
+            data: {
+              ...data,
+              ...undoData
+            },
+            undo: true
+          };
+        });
+        const intent = {
+          first: all[0],
+          last: all.at(-1),
+          all
+        };
+        yield* import_effect2.Ref.update(historyRef, (h) => h.filter((_, index) => index !== last));
+        return yield* dispatch(intent);
+      }
+    });
+  };
+  const undoPromise = () => {
+    return import_effect2.Effect.runPromise(undo()).then((data) => ({
+      data
+    })).catch((error) => ({
+      error
+    }));
+  };
+  return {
+    dispatch,
+    dispatchPromise,
+    undo,
+    undoPromise
+  };
+};
+var ErrorBoundary = class extends import_react.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__ */ import_react.default.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
+    });
+  }
+};
+var PluginManagerContext = (0, import_react2.createContext)(void 0);
+var usePluginManager = () => (0, import_react2.useContext)(PluginManagerContext) ?? (0, import_debug.raise)(new Error("Missing PluginManagerContext"));
+var PluginManagerProvider = PluginManagerContext.Provider;
+var useCapabilities = (interfaceDef, filter) => {
+  const manager = usePluginManager();
+  const signal = (0, import_react3.useMemo)(() => (0, import_signals_core3.computed)(() => manager.context.requestCapabilities(interfaceDef, filter)), [
+    interfaceDef
+  ]);
+  return signal.value;
+};
+var useCapability = (interfaceDef, filter) => {
+  const manager = usePluginManager();
+  const signal = (0, import_react3.useMemo)(() => (0, import_signals_core3.computed)(() => manager.context.requestCapability(interfaceDef, filter)), [
+    interfaceDef
+  ]);
+  return signal.value;
+};
+var IntentContext = /* @__PURE__ */ (0, import_react5.createContext)(void 0);
+var useIntentDispatcher = () => {
+  const context = (0, import_react5.useContext)(IntentContext) ?? (0, import_debug2.raise)(new Error("IntentContext not found"));
+  return (0, import_util3.pick)(context, [
+    "dispatch",
+    "dispatchPromise"
+  ]);
+};
+var useIntentResolver = (module2, resolver) => {
+  const manager = usePluginManager();
+  (0, import_react5.useEffect)(() => {
+    manager.context.contributeCapability({
+      module: module2,
+      interface: Capabilities.IntentResolver,
+      implementation: resolver
+    });
+    return () => manager.context.removeCapability(Capabilities.IntentResolver, resolver);
+  }, [
+    module2,
+    resolver
+  ]);
+};
+var IntentProvider = IntentContext.Provider;
+var defaultEffect = () => import_effect3.Effect.fail(new Error("Intent runtime not ready"));
+var defaultPromise = () => import_effect3.Effect.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 = (0, import_live_object3.create)({
+        dispatch: defaultEffect,
+        dispatchPromise: defaultPromise,
+        undo: defaultEffect,
+        undoPromise: defaultPromise
+      });
+      const { dispatch, dispatchPromise, undo, undoPromise } = createDispatcher((module2) => context.requestCapabilities(Capabilities.IntentResolver, (c, moduleId) => {
+        return module2 ? moduleId === module2 : 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__ */ import_react6.default.createElement(IntentProvider, {
+            value: state
+          }, children)
+        })
+      ];
+    }
+  })
+]);
+var Toast = import_echo_schema4.S.Struct({
+  id: import_echo_schema4.S.String,
+  title: import_echo_schema4.S.optional(Label),
+  description: import_echo_schema4.S.optional(Label),
+  icon: import_echo_schema4.S.optional(import_echo_schema4.S.String),
+  duration: import_echo_schema4.S.optional(import_echo_schema4.S.Number),
+  closeLabel: import_echo_schema4.S.optional(Label),
+  actionLabel: import_echo_schema4.S.optional(Label),
+  actionAlt: import_echo_schema4.S.optional(Label),
+  // TODO(wittjosiah): Make class with customizable method?
+  onAction: import_echo_schema4.S.optional(import_echo_schema4.S.Any)
+});
+var LayoutMode = import_echo_schema4.S.Union(import_echo_schema4.S.Literal("deck"), import_echo_schema4.S.Literal("solo"), import_echo_schema4.S.Literal("fullscreen"));
+var isLayoutMode = (value) => import_echo_schema4.S.is(LayoutMode)(value);
+var Layout = import_echo_schema4.S.mutable(import_echo_schema4.S.Struct({
+  layoutMode: LayoutMode,
+  sidebarOpen: import_echo_schema4.S.Boolean,
+  complementarySidebarOpen: import_echo_schema4.S.Boolean,
+  /**
+   * @deprecated Data to be passed to the complementary sidebar Surface.
+   */
+  complementarySidebarContent: import_echo_schema4.S.optional(import_echo_schema4.S.Any),
+  dialogOpen: import_echo_schema4.S.Boolean,
+  /**
+   * Data to be passed to the dialog Surface.
+   */
+  dialogContent: import_echo_schema4.S.optional(import_echo_schema4.S.Any),
+  // TODO(wittjosiah): Custom properties?
+  dialogBlockAlign: import_echo_schema4.S.optional(import_echo_schema4.S.Literal("start", "center")),
+  dialogType: import_echo_schema4.S.optional(import_echo_schema4.S.Literal("default", "alert")),
+  popoverOpen: import_echo_schema4.S.Boolean,
+  /**
+   * Data to be passed to the popover Surface.
+   */
+  popoverContent: import_echo_schema4.S.optional(import_echo_schema4.S.Any),
+  popoverAnchorId: import_echo_schema4.S.optional(import_echo_schema4.S.String),
+  toasts: import_echo_schema4.S.mutable(import_echo_schema4.S.Array(Toast)),
+  /**
+   * The identifier of a component to scroll into view when it is mounted.
+   */
+  scrollIntoView: import_echo_schema4.S.optional(import_echo_schema4.S.String)
+}));
+var LAYOUT_PLUGIN = "dxos.org/plugin/layout";
+var LAYOUT_ACTION = `${LAYOUT_PLUGIN}/action`;
+var LayoutAction;
+(function(LayoutAction2) {
+  class SetLayout extends import_echo_schema4.S.TaggedClass()(`${LAYOUT_ACTION}/set-layout`, {
+    input: import_echo_schema4.S.Struct({
+      /**
+      * Element to set the state of.
+      */
+      element: import_echo_schema4.S.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: import_echo_schema4.S.optional(import_echo_schema4.S.Boolean),
+      /**
+      * Component to render in the dialog or popover.
+      */
+      component: import_echo_schema4.S.optional(import_echo_schema4.S.String),
+      /**
+      * Data to be passed to the dialog or popover Surface.
+      */
+      subject: import_echo_schema4.S.optional(import_echo_schema4.S.Any),
+      /**
+      * Anchor ID for the popover.
+      */
+      anchorId: import_echo_schema4.S.optional(import_echo_schema4.S.String),
+      // TODO(wittjosiah): Custom properties?
+      /**
+      * Block alignment for the dialog.
+      */
+      dialogBlockAlign: import_echo_schema4.S.optional(import_echo_schema4.S.Literal("start", "center")),
+      /**
+      * Type of dialog.
+      */
+      dialogType: import_echo_schema4.S.optional(import_echo_schema4.S.Literal("default", "alert"))
+    }),
+    output: import_echo_schema4.S.Void
+  }) {
+  }
+  LayoutAction2.SetLayout = SetLayout;
+  class SetLayoutMode extends import_echo_schema4.S.TaggedClass()(`${LAYOUT_ACTION}/set-layout-mode`, {
+    input: import_echo_schema4.S.Union(import_echo_schema4.S.Struct({
+      layoutMode: LayoutMode
+    }), import_echo_schema4.S.Struct({
+      revert: import_echo_schema4.S.Literal(true)
+    })),
+    output: import_echo_schema4.S.Void
+  }) {
+  }
+  LayoutAction2.SetLayoutMode = SetLayoutMode;
+  class ScrollIntoView extends import_echo_schema4.S.TaggedClass()(`${LAYOUT_ACTION}/scroll-into-view`, {
+    input: import_echo_schema4.S.Struct({
+      id: import_echo_schema4.S.optional(import_echo_schema4.S.String),
+      // TODO(wittjosiah): Factor out to thread scroll into view action?
+      cursor: import_echo_schema4.S.optional(import_echo_schema4.S.String),
+      ref: import_echo_schema4.S.optional(import_echo_schema4.S.String)
+    }),
+    output: import_echo_schema4.S.Void
+  }) {
+  }
+  LayoutAction2.ScrollIntoView = ScrollIntoView;
+})(LayoutAction || (LayoutAction = {}));
+var SLUG_LIST_SEPARATOR = "+";
+var SLUG_ENTRY_SEPARATOR = "_";
+var SLUG_KEY_VALUE_SEPARATOR = "-";
+var SLUG_PATH_SEPARATOR = "~";
+var SLUG_COLLECTION_INDICATOR = "";
+var LayoutEntrySchema = import_schema.Schema.mutable(import_schema.Schema.Struct({
+  id: import_schema.Schema.String,
+  path: import_schema.Schema.optional(import_schema.Schema.String)
+}));
+var LayoutPartSchema = import_schema.Schema.Union(import_schema.Schema.Literal("sidebar").annotations({
+  description: "The primary sidebar."
+}), import_schema.Schema.Literal("main").annotations({
+  description: "The main content area."
+}), import_schema.Schema.Literal("solo").annotations({
+  description: "The solo content area."
+}), import_schema.Schema.Literal("complementary").annotations({
+  description: "The secondary sidebar."
+}), import_schema.Schema.Literal("fullScreen").annotations({
+  description: "Full screen content."
+}));
+var LayoutPartsSchema = import_schema.Schema.partial(import_schema.Schema.mutable(import_schema.Schema.Record({
+  key: LayoutPartSchema,
+  value: import_schema.Schema.mutable(import_schema.Schema.Array(LayoutEntrySchema))
+})));
+var LayoutCoordinateSchema = import_schema.Schema.mutable(import_schema.Schema.Struct({
+  part: LayoutPartSchema,
+  entryId: import_schema.Schema.String
+}));
+var PartAdjustmentSchema = import_schema.Schema.Union(import_schema.Schema.Literal("increment-start"), import_schema.Schema.Literal("increment-end"), import_schema.Schema.Literal("pin-start"), import_schema.Schema.Literal("pin-end"), import_schema.Schema.Literal("close"), import_schema.Schema.Literal("solo"));
+var LayoutAdjustmentSchema = import_schema.Schema.mutable(import_schema.Schema.Struct({
+  layoutCoordinate: LayoutCoordinateSchema,
+  type: PartAdjustmentSchema
+}));
+var ActiveParts = import_schema.Schema.Record({
+  key: import_schema.Schema.String,
+  value: import_schema.Schema.Union(import_schema.Schema.String, import_schema.Schema.mutable(import_schema.Schema.Array(import_schema.Schema.String)))
+});
+var LocationProvidesSchema = import_schema.Schema.mutable(import_schema.Schema.Struct({
+  location: import_schema.Schema.Struct({
+    active: LayoutPartsSchema,
+    closed: import_schema.Schema.Array(import_schema.Schema.String)
+  })
+}));
+var isLayoutParts = (value) => {
+  return import_schema.Schema.is(LayoutPartsSchema)(value);
+};
+var isLayoutAdjustment = (value) => {
+  return import_schema.Schema.is(LayoutAdjustmentSchema)(value);
+};
+var openIds = (layout, parts) => {
+  return Object.values(parts ? (0, import_util4.pick)(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 import_schema.Schema.TaggedClass()(`${NAVIGATION_ACTION}/open`, {
+    input: import_schema.Schema.Struct({
+      activeParts: ActiveParts,
+      noToggle: import_schema.Schema.optional(import_schema.Schema.Boolean)
+    }),
+    output: import_schema.Schema.Struct({
+      open: import_schema.Schema.Array(import_schema.Schema.String)
+    })
+  }) {
+  }
+  NavigationAction2.Open = Open;
+  class AddToActive extends import_schema.Schema.TaggedClass()(`${NAVIGATION_ACTION}/add-to-active`, {
+    input: import_schema.Schema.Struct({
+      id: import_schema.Schema.String.annotations({
+        description: "The ID of the item to add."
+      }),
+      part: LayoutPartSchema.annotations({
+        description: "The part to add the item to."
+      }),
+      scrollIntoView: import_schema.Schema.optional(import_schema.Schema.Boolean.annotations({
+        description: "Scroll the item into view."
+      })),
+      pivotId: import_schema.Schema.optional(import_schema.Schema.String.annotations({
+        description: "The ID of the item to place the new item next to."
+      })),
+      positioning: import_schema.Schema.optional(import_schema.Schema.Union(import_schema.Schema.Literal("start").annotations({
+        description: "Place the new item before the pivot item."
+      }), import_schema.Schema.Literal("end").annotations({
+        description: "Place the new item after the pivot item."
+      })).annotations({
+        description: "The position to place the new item."
+      }))
+    }),
+    output: import_schema.Schema.Void
+  }) {
+  }
+  NavigationAction2.AddToActive = AddToActive;
+  class Set2 extends import_schema.Schema.TaggedClass()(`${NAVIGATION_ACTION}/set`, {
+    input: import_schema.Schema.Struct({
+      activeParts: ActiveParts
+    }),
+    output: import_schema.Schema.Void
+  }) {
+  }
+  NavigationAction2.Set = Set2;
+  class Close extends import_schema.Schema.TaggedClass()(`${NAVIGATION_ACTION}/close`, {
+    input: import_schema.Schema.Struct({
+      activeParts: ActiveParts,
+      noToggle: import_schema.Schema.optional(import_schema.Schema.Boolean)
+    }),
+    output: import_schema.Schema.Void
+  }) {
+  }
+  NavigationAction2.Close = Close;
+  class Adjust extends import_schema.Schema.TaggedClass()(`${NAVIGATION_ACTION}/adjust`, {
+    input: LayoutAdjustmentSchema,
+    output: import_schema.Schema.Void
+  }) {
+  }
+  NavigationAction2.Adjust = Adjust;
+  class Expose extends import_schema.Schema.TaggedClass()(`${NAVIGATION_ACTION}/expose`, {
+    input: import_schema.Schema.Struct({
+      id: import_schema.Schema.String
+    }),
+    output: import_schema.Schema.Void
+  }) {
+  }
+  NavigationAction2.Expose = Expose;
+})(NavigationAction || (NavigationAction = {}));
+var createSurface = (definition) => definition;
+var ResourceKey = import_zod.z.union([
+  import_zod.z.string(),
+  import_zod.z.record(import_zod.z.any())
+]);
+var ResourceLanguage = import_zod.z.record(ResourceKey);
+var Resource = import_zod.z.record(ResourceLanguage);
+var useSurfaces = () => {
+  const surfaces = useCapabilities(Capabilities.ReactSurface);
+  return (0, import_react4.useMemo)(() => 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(import_util2.byDisposition);
+};
+var isSurfaceAvailable = (context, { role, data }) => {
+  const surfaces = context.requestCapabilities(Capabilities.ReactSurface);
+  const candidates = findCandidates(surfaces.flat(), {
+    role,
+    data
+  });
+  return candidates.length > 0;
+};
+var Surface = /* @__PURE__ */ (0, import_react4.memo)(/* @__PURE__ */ (0, import_react4.forwardRef)(({ id: _id, role, data: _data, limit, fallback, placeholder, ...rest }, forwardedRef) => {
+  const surfaces = useSurfaces();
+  const data = (0, import_react_hooks.useDefaultValue)(_data, () => ({}));
+  const candidates = (0, import_react4.useMemo)(() => {
+    const definitions = findCandidates(surfaces, {
+      role,
+      data
+    });
+    return limit ? definitions.slice(0, limit) : definitions;
+  }, [
+    surfaces,
+    role,
+    data,
+    limit
+  ]);
+  const nodes = candidates.map(({ component: Component2, id }) => /* @__PURE__ */ import_react4.default.createElement(Component2, {
+    ref: forwardedRef,
+    key: id,
+    id,
+    role,
+    data,
+    limit,
+    ...rest
+  }));
+  const suspense = placeholder ? /* @__PURE__ */ import_react4.default.createElement(import_react4.Suspense, {
+    fallback: placeholder
+  }, nodes) : nodes;
+  return fallback ? /* @__PURE__ */ import_react4.default.createElement(ErrorBoundary, {
+    data,
+    fallback
+  }, suspense) : suspense;
+}));
+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);
+};
+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);
+    (0, import_invariant2.invariant)(plugin, `Plugin not found: ${id}`, {
+      F: __dxlog_file3,
+      L: 68,
+      S: void 0,
+      A: [
+        "plugin",
+        "`Plugin not found: ${id}`"
+      ]
+    });
+    return plugin;
+  });
+  const state = (0, import_live_object4.create)({
+    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;
+    }
+  });
+  (0, import_signals_core4.effect)(() => {
+    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__ */ import_react7.default.createElement(ErrorBoundary, {
+    fallback
+  }, /* @__PURE__ */ import_react7.default.createElement(App, {
+    placeholder,
+    manager,
+    state
+  }));
+};
+var App = ({ placeholder, manager, state }) => {
+  if (state.error) {
+    throw state.error;
+  }
+  if (!state.ready) {
+    return /* @__PURE__ */ import_react7.default.createElement(import_react7.default.Fragment, null, placeholder);
+  }
+  const reactContexts = manager.context.requestCapabilities(Capabilities.ReactContext);
+  const reactRoots = manager.context.requestCapabilities(Capabilities.ReactRoot);
+  const ComposedContext = composeContexts(reactContexts);
+  return /* @__PURE__ */ import_react7.default.createElement(PluginManagerProvider, {
+    value: manager
+  }, /* @__PURE__ */ import_react7.default.createElement(ComposedContext, null, reactRoots.map(({ id, root: Component2 }) => /* @__PURE__ */ import_react7.default.createElement(Component2, {
+    key: id
+  }))));
+};
+var DefaultFallback = ({ error }) => {
+  return /* @__PURE__ */ import_react7.default.createElement("div", {
+    style: {
+      padding: "1rem"
+    }
+  }, /* @__PURE__ */ import_react7.default.createElement("h1", {
+    style: {
+      fontSize: "1.2rem",
+      fontWeight: 700,
+      margin: "0.5rem 0"
+    }
+  }, error.message), /* @__PURE__ */ import_react7.default.createElement("pre", null, error.stack));
+};
+var composeContexts = (contexts) => {
+  if (contexts.length === 0) {
+    return ({ children }) => /* @__PURE__ */ import_react7.default.createElement(import_react7.default.Fragment, null, children);
+  }
+  return topologicalSort(contexts).map(({ context }) => context).reduce((Acc, Next) => ({ children }) => /* @__PURE__ */ import_react7.default.createElement(Acc, null, /* @__PURE__ */ import_react7.default.createElement(Next, null, children)));
+};
+var setupDevtools = (manager) => {
+  globalThis.composer ??= {};
+  globalThis.composer.manager = manager;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ActiveParts,
+  Capabilities,
+  ErrorBoundary,
+  Events,
+  FileInfoSchema,
+  INTENT_ACTION,
+  INTENT_PLUGIN,
+  IntentAction,
+  IntentPlugin,
+  IntentProvider,
+  LAYOUT_ACTION,
+  LAYOUT_PLUGIN,
+  Label,
+  Layout,
+  LayoutAction,
+  NAVIGATION_ACTION,
+  NAVIGATION_PLUGIN,
+  NavigationAction,
+  Plugin,
+  PluginManager,
+  PluginManagerProvider,
+  PluginModule,
+  PluginsContext,
+  Resource,
+  ResourceKey,
+  ResourceLanguage,
+  SLUG_COLLECTION_INDICATOR,
+  SLUG_ENTRY_SEPARATOR,
+  SLUG_KEY_VALUE_SEPARATOR,
+  SLUG_LIST_SEPARATOR,
+  SLUG_PATH_SEPARATOR,
+  Surface,
+  Toast,
+  allOf,
+  chain,
+  contributes,
+  createApp,
+  createDispatcher,
+  createIntent,
+  createResolver,
+  createSurface,
+  defaultFileTypes,
+  defineCapability,
+  defineEvent,
+  defineModule,
+  definePlugin,
+  eventKey,
+  firstIdInPart,
+  getEvents,
+  indexInPart,
+  isAllOf,
+  isLayoutAdjustment,
+  isLayoutMode,
+  isLayoutParts,
+  isOneOf,
+  isSurfaceAvailable,
+  lazy,
+  oneOf,
+  openIds,
+  partLength,
+  useCapabilities,
+  useCapability,
+  useIntentDispatcher,
+  useIntentResolver,
+  usePluginManager
+});
+//# sourceMappingURL=chunk-7PNEFY2G.cjs.map