@dxos/app-framework 0.8.3 → 0.8.4-main.2e9d522

package/dist/lib/node/chunk-VSOSVDQ3.cjs

@@ -1,1551 +0,0 @@
-"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_VSOSVDQ3_exports = {};
-__export(chunk_VSOSVDQ3_exports, {
-  Capabilities: () => Capabilities,
-  CollaborationActions: () => CollaborationActions,
-  Events: () => Events,
-  FileInfoSchema: () => FileInfoSchema,
-  INTENT_ACTION: () => INTENT_ACTION,
-  INTENT_PLUGIN: () => INTENT_PLUGIN,
-  IntentAction: () => IntentAction,
-  IntentPlugin: () => IntentPlugin,
-  LAYOUT_ACTION: () => LAYOUT_ACTION,
-  LAYOUT_PLUGIN: () => LAYOUT_PLUGIN,
-  Label: () => Label,
-  LayoutAction: () => LayoutAction,
-  Plugin: () => Plugin,
-  PluginContext: () => PluginContext,
-  PluginManager: () => PluginManager,
-  PluginModule: () => PluginModule,
-  Resource: () => Resource,
-  ResourceKey: () => ResourceKey,
-  ResourceLanguage: () => ResourceLanguage,
-  allOf: () => allOf,
-  chain: () => chain,
-  contributes: () => contributes,
-  createDispatcher: () => createDispatcher,
-  createIntent: () => createIntent,
-  createResolver: () => createResolver,
-  createSurface: () => createSurface,
-  defaultFileTypes: () => defaultFileTypes,
-  defineCapability: () => defineCapability,
-  defineEvent: () => defineEvent,
-  defineModule: () => defineModule,
-  definePlugin: () => definePlugin,
-  eventKey: () => eventKey,
-  getEvents: () => getEvents,
-  intent_dispatcher_default: () => intent_dispatcher_default,
-  isAllOf: () => isAllOf,
-  isOneOf: () => isOneOf,
-  lazy: () => lazy,
-  oneOf: () => oneOf
-});
-module.exports = __toCommonJS(chunk_VSOSVDQ3_exports);
-var import_effect = require("effect");
-var import_live_object = require("@dxos/live-object");
-var import_log = require("@dxos/log");
-var import_util = require("@dxos/util");
-var import_effect2 = require("effect");
-var import_effect3 = require("effect");
-var import_rx_react = require("@effect-rx/rx-react");
-var import_effect4 = require("effect");
-var import_async = require("@dxos/async");
-var import_invariant = require("@dxos/invariant");
-var import_log2 = require("@dxos/log");
-var import_rx_react2 = require("@effect-rx/rx-react");
-var import_signals_core = require("@preact/signals-core");
-var import_effect5 = require("effect");
-var import_async2 = require("@dxos/async");
-var import_live_object2 = require("@dxos/live-object");
-var import_log3 = require("@dxos/log");
-var import_effect6 = require("effect");
-var import_echo_schema = require("@dxos/echo-schema");
-var import_effect7 = require("effect");
-var import_effect8 = require("effect");
-var import_effect9 = require("effect");
-var createIntent = (schema, data = {}, params = {}) => {
-  const _ = import_effect3.Schema.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 = import_effect3.Schema.Union(import_effect3.Schema.String, import_effect3.Schema.mutable(import_effect3.Schema.Tuple(import_effect3.Schema.String, import_effect3.Schema.mutable(import_effect3.Schema.Struct({
-  ns: import_effect3.Schema.String,
-  count: import_effect3.Schema.optional(import_effect3.Schema.Number),
-  defaultValue: import_effect3.Schema.optional(import_effect3.Schema.String)
-})))));
-var INTENT_PLUGIN = "dxos.org/plugin/intent";
-var INTENT_ACTION = `${INTENT_PLUGIN}/action`;
-(function(IntentAction2) {
-  class Track extends import_effect2.Schema.TaggedClass()(`${INTENT_ACTION}/track`, {
-    input: import_effect2.Schema.Struct({
-      intents: import_effect2.Schema.Array(import_effect2.Schema.String),
-      error: import_effect2.Schema.optional(import_effect2.Schema.String)
-    }),
-    output: import_effect2.Schema.Void
-  }) {
-  }
-  IntentAction2.Track = Track;
-  class ShowUndo extends import_effect2.Schema.TaggedClass()(`${INTENT_ACTION}/show-undo`, {
-    input: import_effect2.Schema.Struct({
-      message: Label
-    }),
-    output: import_effect2.Schema.Void
-  }) {
-  }
-  IntentAction2.ShowUndo = ShowUndo;
-})(IntentAction || (IntentAction = {}));
-var IntentAction;
-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);
-  }
-};
-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) => async (props) => {
-  const { default: getCapability } = await c();
-  return async () => getCapability(props);
-};
-var PluginContext = class {
-  constructor({ registry, activate, reset }) {
-    this._capabilityImpls = import_rx_react.Rx.family(() => {
-      return import_rx_react.Rx.make([]).pipe(import_rx_react.Rx.keepAlive);
-    });
-    this._capabilities = import_rx_react.Rx.family((id) => {
-      return import_rx_react.Rx.make((get) => {
-        const current = get(this._capabilityImpls(id));
-        return current.map((c) => c.implementation);
-      });
-    });
-    this._capability = import_rx_react.Rx.family((id) => {
-      return import_rx_react.Rx.make((get) => {
-        const current = get(this._capabilities(id));
-        (0, import_invariant.invariant)(current.length > 0, `No capability found for ${id}`, {
-          F: __dxlog_file,
-          L: 117,
-          S: this,
-          A: [
-            "current.length > 0",
-            "`No capability found for ${id}`"
-          ]
-        });
-        return current[0];
-      });
-    });
-    this._registry = registry;
-    this.activate = activate;
-    this.reset = reset;
-  }
-  /**
-  * @internal
-  */
-  contributeCapability({ module: moduleId, interface: interfaceDef, implementation }) {
-    const current = this._registry.get(this._capabilityImpls(interfaceDef.identifier));
-    const capability = new CapabilityImpl(moduleId, implementation);
-    if (current.includes(capability)) {
-      return;
-    }
-    this._registry.set(this._capabilityImpls(interfaceDef.identifier), [
-      ...current,
-      capability
-    ]);
-    (0, import_log2.log)("capability contributed", {
-      id: interfaceDef.identifier,
-      moduleId,
-      count: current.length
-    }, {
-      F: __dxlog_file,
-      L: 161,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-  }
-  /**
-  * @internal
-  */
-  removeCapability(interfaceDef, implementation) {
-    const current = this._registry.get(this._capabilityImpls(interfaceDef.identifier));
-    if (current.length === 0) {
-      return;
-    }
-    const next = current.filter((c) => c.implementation !== implementation);
-    if (next.length !== current.length) {
-      this._registry.set(this._capabilityImpls(interfaceDef.identifier), next);
-      (0, import_log2.log)("capability removed", {
-        id: interfaceDef.identifier,
-        count: current.length
-      }, {
-        F: __dxlog_file,
-        L: 180,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-    } else {
-      import_log2.log.warn("capability not removed", {
-        id: interfaceDef.identifier
-      }, {
-        F: __dxlog_file,
-        L: 182,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-    }
-  }
-  /**
-  * Get the Rx reference to the available capabilities for a given interface.
-  * Primarily useful for deriving other Rx values based on the capabilities or
-  * for subscribing to changes in the capabilities.
-  * @returns An Rx reference to the available capabilities.
-  */
-  capabilities(interfaceDef) {
-    return this._capabilities(interfaceDef.identifier);
-  }
-  /**
-  * Get the Rx reference to the available capabilities for a given interface.
-  * Primarily useful for deriving other Rx values based on the capability or
-  * for subscribing to changes in the capability.
-  * @returns An Rx reference to the available capability.
-  * @throws If no capability is found.
-  */
-  capability(interfaceDef) {
-    return this._capability(interfaceDef.identifier);
-  }
-  /**
-  * Get capabilities from the plugin context.
-  * @returns An array of capabilities.
-  */
-  getCapabilities(interfaceDef) {
-    return this._registry.get(this.capabilities(interfaceDef));
-  }
-  /**
-  * Requests a single capability from the plugin context.
-  * @returns The capability.
-  * @throws If no capability is found.
-  */
-  getCapability(interfaceDef) {
-    return this._registry.get(this.capability(interfaceDef));
-  }
-  /**
-  * Waits for a capability to be available.
-  * @returns The capability.
-  */
-  async waitForCapability(interfaceDef) {
-    const [capability] = this.getCapabilities(interfaceDef);
-    if (capability) {
-      return capability;
-    }
-    const trigger = new import_async.Trigger();
-    const cancel = this._registry.subscribe(this.capabilities(interfaceDef), (capabilities) => {
-      if (capabilities.length > 0) {
-        trigger.wake(capabilities[0]);
-      }
-    });
-    const result = await trigger.wait();
-    cancel();
-    return result;
-  }
-  async activatePromise(event) {
-    return this.activate(event).pipe(import_effect4.Effect.runPromise);
-  }
-  async resetPromise(event) {
-    return this.reset(event).pipe(import_effect4.Effect.runPromise);
-  }
-};
-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 = [], registry }) {
-    this.activation = new import_async2.Event();
-    this._capabilities = /* @__PURE__ */ new Map();
-    this.registry = registry ?? import_rx_react2.Registry.make();
-    this.context = new PluginContext({
-      registry: this.registry,
-      activate: (event) => this._activate(event),
-      reset: (id) => this._reset(id)
-    });
-    this._pluginLoader = pluginLoader;
-    this._state = (0, import_live_object2.live)({
-      plugins,
-      core,
-      enabled,
-      modules: [],
-      active: [],
-      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 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_core.untracked)(async () => {
-      (0, import_log3.log)("add plugin", {
-        id
-      }, {
-        F: __dxlog_file2,
-        L: 154,
-        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_core.untracked)(async () => {
-      (0, import_log3.log)("enable plugin", {
-        id
-      }, {
-        F: __dxlog_file2,
-        L: 167,
-        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);
-      });
-      (0, import_log3.log)("pending reset", {
-        events: [
-          ...this.pendingReset
-        ]
-      }, {
-        F: __dxlog_file2,
-        L: 182,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      await import_effect5.Effect.runPromise(import_effect5.Effect.all(this.pendingReset.map((event) => this._activate(event)), {
-        concurrency: "unbounded"
-      }));
-      return true;
-    });
-  }
-  /**
-  * Removes a plugin from the manager.
-  * @param id The id of the plugin.
-  */
-  remove(id) {
-    return (0, import_signals_core.untracked)(() => {
-      (0, import_log3.log)("remove plugin", {
-        id
-      }, {
-        F: __dxlog_file2,
-        L: 200,
-        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_core.untracked)(async () => {
-      (0, import_log3.log)("disable plugin", {
-        id
-      }, {
-        F: __dxlog_file2,
-        L: 217,
-        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);
-        await import_effect5.Effect.runPromise(this._deactivate(id));
-        plugin.modules.forEach((module2) => {
-          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_core.untracked)(() => import_effect5.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_core.untracked)(() => import_effect5.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_core.untracked)(() => import_effect5.Effect.runPromise(this._reset(event)));
-  }
-  _addPlugin(plugin) {
-    (0, import_signals_core.untracked)(() => {
-      (0, import_log3.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_core.untracked)(() => {
-      (0, import_log3.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_core.untracked)(() => {
-      (0, import_log3.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_core.untracked)(() => {
-      (0, import_log3.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_core.untracked)(() => {
-      const activationEvents = getEvents(module2.activatesOn).map(eventKey).filter((key) => this._state.eventsFired.includes(key));
-      const pendingReset = Array.from(new Set(activationEvents)).filter((event) => !this._state.pendingReset.includes(event));
-      if (pendingReset.length > 0) {
-        (0, import_log3.log)("pending reset", {
-          events: pendingReset
-        }, {
-          F: __dxlog_file2,
-          L: 336,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        this._state.pendingReset.push(...pendingReset);
-      }
-    });
-  }
-  /**
-  * @internal
-  */
-  // TODO(wittjosiah): Improve error typing.
-  _activate(event) {
-    return import_effect5.Effect.gen(this, function* () {
-      const key = typeof event === "string" ? event : eventKey(event);
-      (0, import_log3.log)("activating", {
-        key
-      }, {
-        F: __dxlog_file2,
-        L: 349,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      const pendingIndex = this._state.pendingReset.findIndex((event2) => event2 === key);
-      if (pendingIndex !== -1) {
-        this._state.pendingReset.splice(pendingIndex, 1);
-      }
-      const modules = this._getInactiveModulesByEvent(key).filter((module2) => {
-        const allOf2 = isAllOf(module2.activatesOn);
-        if (!allOf2) {
-          return true;
-        }
-        const events = module2.activatesOn.events.filter((event2) => eventKey(event2) !== key);
-        return events.every((event2) => this._state.eventsFired.includes(eventKey(event2)));
-      });
-      if (modules.length === 0) {
-        (0, import_log3.log)("no modules to activate", {
-          key
-        }, {
-          F: __dxlog_file2,
-          L: 365,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        if (!this._state.eventsFired.includes(key)) {
-          this._state.eventsFired.push(key);
-        }
-        return false;
-      }
-      (0, import_log3.log)("activating modules", {
-        key,
-        modules: modules.map((module2) => module2.id)
-      }, {
-        F: __dxlog_file2,
-        L: 372,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      this.activation.emit({
-        event: key,
-        state: "activating"
-      });
-      const getCapabilities = yield* import_effect5.Effect.all(modules.map(({ activate }) => import_effect5.Effect.tryPromise({
-        try: async () => activate(this.context),
-        catch: (error) => error
-      })), {
-        concurrency: "unbounded"
-      });
-      const result = yield* (0, import_effect5.pipe)(
-        modules,
-        import_effect5.Array.zip(getCapabilities),
-        import_effect5.Array.map(([module2, getCapabilities2]) => this._activateModule(module2, getCapabilities2)),
-        // TODO(wittjosiah): This currently can't be run in parallel.
-        //   Running this with concurrency causes races with `allOf` activation events.
-        import_effect5.Effect.all,
-        import_effect5.Effect.either
-      );
-      if (import_effect5.Either.isLeft(result)) {
-        this.activation.emit({
-          event: key,
-          state: "error",
-          error: result.left
-        });
-        yield* import_effect5.Effect.fail(result.left);
-      }
-      if (!this._state.eventsFired.includes(key)) {
-        this._state.eventsFired.push(key);
-      }
-      this.activation.emit({
-        event: key,
-        state: "activated"
-      });
-      (0, import_log3.log)("activated", {
-        key
-      }, {
-        F: __dxlog_file2,
-        L: 406,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      return true;
-    });
-  }
-  _activateModule(module2, getCapabilities) {
-    return import_effect5.Effect.gen(this, function* () {
-      yield* import_effect5.Effect.all(module2.activatesBefore?.map((event) => this._activate(event)) ?? [], {
-        concurrency: "unbounded"
-      });
-      (0, import_log3.log)("activating module...", {
-        module: module2.id
-      }, {
-        F: __dxlog_file2,
-        L: 421,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      const maybeCapabilities = typeof getCapabilities === "function" ? getCapabilities() : getCapabilities;
-      const resolvedCapabilities = yield* import_effect5.Match.value(maybeCapabilities).pipe(
-        // TODO(wittjosiah): Activate with an effect?
-        // Match.when(Effect.isEffect, (effect) => effect),
-        import_effect5.Match.when(isPromise, (promise) => import_effect5.Effect.tryPromise({
-          try: () => promise,
-          catch: (error) => error
-        })),
-        import_effect5.Match.orElse((program) => import_effect5.Effect.succeed(program))
-      );
-      const capabilities = import_effect5.Match.value(resolvedCapabilities).pipe(import_effect5.Match.when(Array.isArray, (array) => array), import_effect5.Match.orElse((value) => [
-        value
-      ]));
-      capabilities.forEach((capability) => {
-        this.context.contributeCapability({
-          module: module2.id,
-          ...capability
-        });
-      });
-      this._state.active.push(module2.id);
-      this._capabilities.set(module2.id, capabilities);
-      (0, import_log3.log)("activated module", {
-        module: module2.id
-      }, {
-        F: __dxlog_file2,
-        L: 444,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      yield* import_effect5.Effect.all(module2.activatesAfter?.map((event) => this._activate(event)) ?? [], {
-        concurrency: "unbounded"
-      });
-    });
-  }
-  _deactivate(id) {
-    return import_effect5.Effect.gen(this, function* () {
-      const plugin = this._getPlugin(id);
-      if (!plugin) {
-        return false;
-      }
-      const modules = plugin.modules;
-      const results = yield* import_effect5.Effect.all(modules.map((module2) => this._deactivateModule(module2)), {
-        concurrency: "unbounded"
-      });
-      return results.every((result) => result);
-    });
-  }
-  _deactivateModule(module2) {
-    return import_effect5.Effect.gen(this, function* () {
-      const id = module2.id;
-      (0, import_log3.log)("deactivating", {
-        id
-      }, {
-        F: __dxlog_file2,
-        L: 471,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      const capabilities = this._capabilities.get(id);
-      if (capabilities) {
-        for (const capability of capabilities) {
-          this.context.removeCapability(capability.interface, capability.implementation);
-          const program = capability.deactivate?.();
-          yield* import_effect5.Match.value(program).pipe(import_effect5.Match.when(import_effect5.Effect.isEffect, (effect) => effect), import_effect5.Match.when(isPromise, (promise) => import_effect5.Effect.tryPromise({
-            try: () => promise,
-            catch: (error) => error
-          })), import_effect5.Match.orElse((program2) => import_effect5.Effect.succeed(program2)));
-        }
-        this._capabilities.delete(id);
-      }
-      const activeIndex = this._state.active.findIndex((event) => event === id);
-      if (activeIndex !== -1) {
-        this._state.active.splice(activeIndex, 1);
-      }
-      (0, import_log3.log)("deactivated", {
-        id
-      }, {
-        F: __dxlog_file2,
-        L: 497,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      return true;
-    });
-  }
-  _reset(event) {
-    return import_effect5.Effect.gen(this, function* () {
-      const key = typeof event === "string" ? event : eventKey(event);
-      (0, import_log3.log)("reset", {
-        key
-      }, {
-        F: __dxlog_file2,
-        L: 505,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      const modules = this._getActiveModulesByEvent(key);
-      const results = yield* import_effect5.Effect.all(modules.map((module2) => this._deactivateModule(module2)), {
-        concurrency: "unbounded"
-      });
-      if (results.every((result) => result)) {
-        return yield* this._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);
-};
-(function(Capabilities2) {
-  Capabilities2.PluginManager = defineCapability("dxos.org/app-framework/capability/plugin-manager");
-  Capabilities2.Null = defineCapability("dxos.org/app-framework/capability/null");
-  Capabilities2.RxRegistry = defineCapability("dxos.org/app-framework/capability/rx-registry");
-  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.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");
-  Capabilities2.AnchorSort = defineCapability("dxos.org/app-framework/capability/anchor-sort");
-})(Capabilities || (Capabilities = {}));
-var Capabilities;
-(function(CollaborationActions2) {
-  class InsertContent extends import_effect6.Schema.TaggedClass()("assistant/intent-content", {
-    input: import_effect6.Schema.Struct({
-      target: import_echo_schema.Expando,
-      object: (0, import_echo_schema.Ref)(import_echo_schema.Expando),
-      at: import_effect6.Schema.optional(import_effect6.Schema.String),
-      label: import_effect6.Schema.String.pipe(import_effect6.Schema.optional)
-    }).annotations({
-      description: "Enables plugins to inject content blocks or references into a related entity."
-    }),
-    output: import_effect6.Schema.Void
-  }) {
-  }
-  CollaborationActions2.InsertContent = InsertContent;
-})(CollaborationActions || (CollaborationActions = {}));
-var CollaborationActions;
-(function(Events2) {
-  Events2.Startup = defineEvent("dxos.org/app-framework/event/startup");
-  Events2.SetupReactSurface = defineEvent("dxos.org/app-framework/event/setup-react-surface");
-  Events2.SetupMetadata = defineEvent("dxos.org/app-framework/event/setup-metadata");
-  Events2.SetupIntentResolver = defineEvent("dxos.org/app-framework/event/setup-intent-resolver");
-  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.SetupArtifactDefinition = defineEvent("dxos.org/app-framework/event/setup-artifact-definition");
-  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);
-})(Events || (Events = {}));
-var Events;
-var defaultFileTypes = {
-  images: [
-    "png",
-    "jpg",
-    "jpeg",
-    "gif"
-  ],
-  media: [
-    "mp3",
-    "mp4",
-    "mov",
-    "avi"
-  ],
-  text: [
-    "pdf",
-    "txt",
-    "md"
-  ]
-};
-var FileInfoSchema = import_effect7.Schema.Struct({
-  name: import_effect7.Schema.String,
-  type: import_effect7.Schema.String,
-  url: import_effect7.Schema.optional(import_effect7.Schema.String),
-  cid: import_effect7.Schema.optional(import_effect7.Schema.String)
-});
-var IntentPlugin = () => definePlugin({
-  id: INTENT_PLUGIN,
-  name: "Intent"
-}, [
-  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-C3SVKJ62.cjs"))
-  })
-]);
-var LAYOUT_PLUGIN = "dxos.org/plugin/layout";
-var LAYOUT_ACTION = `${LAYOUT_PLUGIN}/action`;
-(function(LayoutAction2) {
-  LayoutAction2.UPDATE_LAYOUT = `${LAYOUT_ACTION}/update-layout`;
-  class UpdateLayout extends import_effect8.Schema.TaggedClass()(LayoutAction2.UPDATE_LAYOUT, {
-    input: import_effect8.Schema.Struct({
-      part: import_effect8.Schema.String.annotations({
-        description: "The part of the layout to mutate."
-      }),
-      subject: import_effect8.Schema.optional(import_effect8.Schema.Any.annotations({
-        description: "The subject of the layout update."
-      })),
-      options: import_effect8.Schema.optional(import_effect8.Schema.Record({
-        key: import_effect8.Schema.String,
-        value: import_effect8.Schema.Any
-      }).annotations({
-        description: "Additional options for the layout action."
-      }))
-    }),
-    output: import_effect8.Schema.Void
-  }) {
-  }
-  LayoutAction2.UpdateLayout = UpdateLayout;
-  class SetLayoutMode extends import_effect8.Schema.TaggedClass()(LayoutAction2.UPDATE_LAYOUT, {
-    input: import_effect8.Schema.Struct({
-      part: import_effect8.Schema.Literal("mode").annotations({
-        description: "Setting the layout mode."
-      }),
-      subject: import_effect8.Schema.optional(import_effect8.Schema.String.annotations({
-        description: "Item which is the subject of the new layout mode."
-      })),
-      options: import_effect8.Schema.Union(import_effect8.Schema.Struct({
-        mode: import_effect8.Schema.String.annotations({
-          description: "The new layout mode."
-        })
-      }), import_effect8.Schema.Struct({
-        revert: import_effect8.Schema.Boolean.annotations({
-          description: "Revert to the previous layout mode."
-        })
-      }))
-    }),
-    output: import_effect8.Schema.Void
-  }) {
-  }
-  LayoutAction2.SetLayoutMode = SetLayoutMode;
-  class UpdateSidebar extends import_effect8.Schema.TaggedClass()(LayoutAction2.UPDATE_LAYOUT, {
-    input: import_effect8.Schema.Struct({
-      part: import_effect8.Schema.Literal("sidebar").annotations({
-        description: "Updating the sidebar."
-      }),
-      subject: import_effect8.Schema.optional(import_effect8.Schema.String.annotations({
-        description: "URI of the component to display in the sidebar."
-      })),
-      options: import_effect8.Schema.optional(import_effect8.Schema.Struct({
-        state: import_effect8.Schema.Literal("closed", "collapsed", "expanded").annotations({
-          description: "Whether the sidebar is closed, collapsed, or expanded."
-        })
-      }))
-    }),
-    output: import_effect8.Schema.Void
-  }) {
-  }
-  LayoutAction2.UpdateSidebar = UpdateSidebar;
-  class UpdateComplementary extends import_effect8.Schema.TaggedClass()(LayoutAction2.UPDATE_LAYOUT, {
-    input: import_effect8.Schema.Struct({
-      part: import_effect8.Schema.Literal("complementary").annotations({
-        description: "Updating the complementary sidebar."
-      }),
-      subject: import_effect8.Schema.optional(import_effect8.Schema.String.annotations({
-        description: "URI of the component to display in the complementary area."
-      })),
-      options: import_effect8.Schema.optional(import_effect8.Schema.Struct({
-        state: import_effect8.Schema.Literal("closed", "collapsed", "expanded").annotations({
-          description: "Whether the complementary sidebar is closed, collapsed, or expanded."
-        })
-      }))
-    }),
-    output: import_effect8.Schema.Void
-  }) {
-  }
-  LayoutAction2.UpdateComplementary = UpdateComplementary;
-  class UpdateDialog extends import_effect8.Schema.TaggedClass()(LayoutAction2.UPDATE_LAYOUT, {
-    input: import_effect8.Schema.Struct({
-      part: import_effect8.Schema.Literal("dialog").annotations({
-        description: "Updating the dialog."
-      }),
-      subject: import_effect8.Schema.optional(import_effect8.Schema.String.annotations({
-        description: "URI of the component to display in the dialog."
-      })),
-      options: import_effect8.Schema.Struct({
-        state: import_effect8.Schema.optional(import_effect8.Schema.Boolean.annotations({
-          description: "Whether the dialog is open or closed."
-        })),
-        type: import_effect8.Schema.optional(import_effect8.Schema.Literal("default", "alert").annotations({
-          description: "The type of dialog."
-        })),
-        blockAlign: import_effect8.Schema.optional(import_effect8.Schema.Literal("start", "center", "end").annotations({
-          description: "The alignment of the dialog."
-        })),
-        overlayClasses: import_effect8.Schema.optional(import_effect8.Schema.String.annotations({
-          description: "Additional classes for the dialog overlay."
-        })),
-        overlayStyle: import_effect8.Schema.optional(import_effect8.Schema.Record({
-          key: import_effect8.Schema.String,
-          value: import_effect8.Schema.Any
-        }).annotations({
-          description: "Additional styles for the dialog overlay."
-        })),
-        props: import_effect8.Schema.optional(import_effect8.Schema.Record({
-          key: import_effect8.Schema.String,
-          value: import_effect8.Schema.Any
-        }).annotations({
-          description: "Additional props for the dialog."
-        }))
-      })
-    }),
-    output: import_effect8.Schema.Void
-  }) {
-  }
-  LayoutAction2.UpdateDialog = UpdateDialog;
-  class UpdatePopover extends import_effect8.Schema.TaggedClass()(LayoutAction2.UPDATE_LAYOUT, {
-    input: import_effect8.Schema.Struct({
-      part: import_effect8.Schema.Literal("popover").annotations({
-        description: "Updating the popover."
-      }),
-      subject: import_effect8.Schema.optional(import_effect8.Schema.Any.annotations({
-        description: "URI of the component to display in the popover or data to pass to the popover."
-      })),
-      options: import_effect8.Schema.Struct({
-        side: import_effect8.Schema.optional(import_effect8.Schema.Literal("top", "right", "bottom", "left").annotations({
-          description: "The side of the anchor."
-        })),
-        state: import_effect8.Schema.optional(import_effect8.Schema.Boolean.annotations({
-          description: "Whether the popover is open or closed."
-        })),
-        props: import_effect8.Schema.optional(import_effect8.Schema.Record({
-          key: import_effect8.Schema.String,
-          value: import_effect8.Schema.Any
-        }).annotations({
-          description: "Additional props for the popover."
-        }))
-      }).pipe(import_effect8.Schema.extend(import_effect8.Schema.Union(import_effect8.Schema.Struct({
-        variant: import_effect8.Schema.Literal("virtual"),
-        anchor: import_effect8.Schema.Any.annotations({
-          description: "The DOM element to anchor the popover to."
-        })
-      }), import_effect8.Schema.Struct({
-        variant: import_effect8.Schema.optional(import_effect8.Schema.Literal("react")),
-        anchorId: import_effect8.Schema.String.annotations({
-          description: "An id that can be used to determine whether to render the anchor subcomponent."
-        })
-      }))))
-    }),
-    output: import_effect8.Schema.Void
-  }) {
-  }
-  LayoutAction2.UpdatePopover = UpdatePopover;
-  LayoutAction2.Toast = import_effect8.Schema.Struct({
-    id: import_effect8.Schema.String.annotations({
-      description: "The id of the toast."
-    }),
-    title: import_effect8.Schema.optional(Label.annotations({
-      description: "The title of the toast."
-    })),
-    description: import_effect8.Schema.optional(Label.annotations({
-      description: "The description of the toast."
-    })),
-    icon: import_effect8.Schema.optional(import_effect8.Schema.String.annotations({
-      description: "The icon of the toast."
-    })),
-    duration: import_effect8.Schema.optional(import_effect8.Schema.Number.annotations({
-      description: "The duration of the toast."
-    })),
-    closeLabel: import_effect8.Schema.optional(Label.annotations({
-      description: "The label of the close button."
-    })),
-    actionLabel: import_effect8.Schema.optional(Label.annotations({
-      description: "The label of the action button."
-    })),
-    actionAlt: import_effect8.Schema.optional(Label.annotations({
-      description: "The alt text of the action button."
-    })),
-    onAction: import_effect8.Schema.optional(import_effect8.Schema.Any.annotations({
-      description: "The action to perform when the action button is clicked."
-    }))
-  });
-  class AddToast extends import_effect8.Schema.TaggedClass()(LayoutAction2.UPDATE_LAYOUT, {
-    input: import_effect8.Schema.Struct({
-      part: import_effect8.Schema.Literal("toast").annotations({
-        description: "Adding a toast."
-      }),
-      subject: LayoutAction2.Toast.annotations({
-        description: "The toast to add."
-      })
-    }),
-    output: import_effect8.Schema.Void
-  }) {
-  }
-  LayoutAction2.AddToast = AddToast;
-  class SwitchWorkspace extends import_effect8.Schema.TaggedClass()(LayoutAction2.UPDATE_LAYOUT, {
-    input: import_effect8.Schema.Struct({
-      part: import_effect8.Schema.Literal("workspace").annotations({
-        description: "Switching the workspace."
-      }),
-      subject: import_effect8.Schema.String.annotations({
-        description: "The id of the workspace to switch to."
-      })
-    }),
-    output: import_effect8.Schema.Void
-  }) {
-  }
-  LayoutAction2.SwitchWorkspace = SwitchWorkspace;
-  class RevertWorkspace extends import_effect8.Schema.TaggedClass()(LayoutAction2.UPDATE_LAYOUT, {
-    input: import_effect8.Schema.Struct({
-      part: import_effect8.Schema.Literal("workspace").annotations({
-        description: "Switching the workspace."
-      }),
-      options: import_effect8.Schema.Struct({
-        revert: import_effect8.Schema.Literal(true).annotations({
-          description: "Revert to the previous workspace."
-        })
-      })
-    }),
-    output: import_effect8.Schema.Void
-  }) {
-  }
-  LayoutAction2.RevertWorkspace = RevertWorkspace;
-  class Open extends import_effect8.Schema.TaggedClass()(LayoutAction2.UPDATE_LAYOUT, {
-    input: import_effect8.Schema.Struct({
-      part: import_effect8.Schema.Literal("main").annotations({
-        description: "Opening an item in the main content area."
-      }),
-      subject: import_effect8.Schema.Array(import_effect8.Schema.String.annotations({
-        description: "Ids of the items to open."
-      })),
-      options: import_effect8.Schema.optional(import_effect8.Schema.Struct({
-        state: import_effect8.Schema.optional(import_effect8.Schema.Literal(true).annotations({
-          description: "The items are being added."
-        })),
-        variant: import_effect8.Schema.optional(import_effect8.Schema.String.annotations({
-          description: "The variant of the item to open."
-        })),
-        key: import_effect8.Schema.optional(import_effect8.Schema.String.annotations({
-          description: "If provided, will replace item with a matching key (id prefix)."
-        })),
-        workspace: import_effect8.Schema.optional(import_effect8.Schema.String.annotations({
-          description: "The workspace to open the items in."
-        })),
-        scrollIntoView: import_effect8.Schema.optional(import_effect8.Schema.Boolean.annotations({
-          description: "Scroll the items into view."
-        })),
-        pivotId: import_effect8.Schema.optional(import_effect8.Schema.String.annotations({
-          description: "The id of the item to place new items next to."
-        })),
-        positioning: import_effect8.Schema.optional(import_effect8.Schema.Union(import_effect8.Schema.Literal("start").annotations({
-          description: "The items are being added before the pivot item."
-        }), import_effect8.Schema.Literal("end").annotations({
-          description: "The items are being added after the pivot item."
-        })))
-      }))
-    }),
-    output: import_effect8.Schema.Void
-  }) {
-  }
-  LayoutAction2.Open = Open;
-  class Set2 extends import_effect8.Schema.TaggedClass()(LayoutAction2.UPDATE_LAYOUT, {
-    input: import_effect8.Schema.Struct({
-      part: import_effect8.Schema.Literal("main").annotations({
-        description: "Setting items in the main content area."
-      }),
-      subject: import_effect8.Schema.Array(import_effect8.Schema.String.annotations({
-        description: "Ids of the items to set."
-      })),
-      options: import_effect8.Schema.Struct({
-        override: import_effect8.Schema.Literal(true).annotations({
-          description: "Override the current items in the main content area."
-        })
-      })
-    }),
-    output: import_effect8.Schema.Void
-  }) {
-  }
-  LayoutAction2.Set = Set2;
-  class Close extends import_effect8.Schema.TaggedClass()(LayoutAction2.UPDATE_LAYOUT, {
-    input: import_effect8.Schema.Struct({
-      part: import_effect8.Schema.Literal("main").annotations({
-        description: "Closing items in the main content area."
-      }),
-      subject: import_effect8.Schema.Array(import_effect8.Schema.String.annotations({
-        description: "Ids of the items to close."
-      })),
-      options: import_effect8.Schema.Struct({
-        state: import_effect8.Schema.Literal(false).annotations({
-          description: "The items are being removed."
-        })
-      })
-    }),
-    output: import_effect8.Schema.Void
-  }) {
-  }
-  LayoutAction2.Close = Close;
-  class ScrollIntoView extends import_effect8.Schema.TaggedClass()(LayoutAction2.UPDATE_LAYOUT, {
-    input: import_effect8.Schema.Struct({
-      part: import_effect8.Schema.Literal("current").annotations({
-        description: "Setting the current item"
-      }),
-      subject: import_effect8.Schema.optional(import_effect8.Schema.String.annotations({
-        description: "The id of the item to set as current."
-      })),
-      options: import_effect8.Schema.optional(import_effect8.Schema.Record({
-        key: import_effect8.Schema.String,
-        value: import_effect8.Schema.Any
-      }).annotations({
-        description: "Additional options for the scroll into view."
-      }))
-    }),
-    output: import_effect8.Schema.Void
-  }) {
-  }
-  LayoutAction2.ScrollIntoView = ScrollIntoView;
-  class Expose extends import_effect8.Schema.TaggedClass()(LayoutAction2.UPDATE_LAYOUT, {
-    input: import_effect8.Schema.Struct({
-      part: import_effect8.Schema.Literal("navigation").annotations({
-        description: "Exposing an item in the navigation area."
-      }),
-      subject: import_effect8.Schema.String.annotations({
-        description: "The id of the item to expose."
-      })
-    }),
-    output: import_effect8.Schema.Void
-  }) {
-  }
-  LayoutAction2.Expose = Expose;
-})(LayoutAction || (LayoutAction = {}));
-var LayoutAction;
-var createSurface = (definition) => definition;
-var ResourceKey = import_effect9.Schema.Union(import_effect9.Schema.String, import_effect9.Schema.Record({
-  key: import_effect9.Schema.String,
-  value: import_effect9.Schema.Any
-}));
-var ResourceLanguage = import_effect9.Schema.Record({
-  key: import_effect9.Schema.String,
-  value: ResourceKey
-});
-var Resource = import_effect9.Schema.Record({
-  key: import_effect9.Schema.String,
-  value: ResourceLanguage
-});
-var __dxlog_file3 = "/home/runner/work/dxos/dxos/packages/sdk/app-framework/src/plugin-intent/intent-dispatcher.ts";
-var EXECUTION_LIMIT = 100;
-var HISTORY_LIMIT = 100;
-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 = import_effect.Effect.runSync(import_effect.Ref.make([]));
-  const handleIntent = (intent) => import_effect.Effect.gen(function* () {
-    const candidates = getResolvers().filter((resolver) => resolver.intent._tag === intent.id).filter((resolver) => !resolver.filter || resolver.filter(intent.data)).toSorted(import_util.byPosition);
-    if (candidates.length === 0) {
-      yield* import_effect.Effect.fail(new NoResolversError(intent.id));
-    }
-    const effect = candidates[0].resolve(intent.data, intent.undo ?? false);
-    const result = import_effect.Effect.isEffect(effect) ? yield* effect : yield* import_effect.Effect.promise(async () => effect);
-    return {
-      _intent: intent,
-      ...result
-    };
-  });
-  const dispatch = (intentChain, depth = 0) => {
-    return import_effect.Effect.gen(function* () {
-      if (depth > executionLimit) {
-        yield* import_effect.Effect.fail(new CycleDetectedError());
-      }
-      const resultsRef = yield* import_effect.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_effect.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_effect.Effect.fail(result2.error);
-        }
-      }
-      const results = yield* resultsRef.get;
-      const result = results[0];
-      yield* import_effect.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_effect.pipe)(dispatch(createIntent(IntentAction.ShowUndo, {
-          message: result.undoable.message
-        })), import_effect.Effect.catchSome((err) => err instanceof NoResolversError ? import_effect.Option.some(import_effect.Effect.succeed(void 0)) : import_effect.Option.none()));
-      }
-      return result.data;
-    });
-  };
-  const dispatchPromise = (intentChain) => {
-    return import_effect.Effect.runPromise(dispatch(intentChain)).then((data) => ({
-      data
-    })).catch((error) => {
-      import_log.log.catch(error, void 0, {
-        F: __dxlog_file3,
-        L: 270,
-        S: void 0,
-        C: (f, a) => f(...a)
-      });
-      return {
-        error
-      };
-    });
-  };
-  const undo = () => {
-    return import_effect.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_effect.Ref.update(historyRef, (h) => h.filter((_, index) => index !== last));
-        return yield* dispatch(intent);
-      }
-    });
-  };
-  const undoPromise = () => {
-    return import_effect.Effect.runPromise(undo()).then((data) => ({
-      data
-    })).catch((error) => ({
-      error
-    }));
-  };
-  return {
-    dispatch,
-    dispatchPromise,
-    undo,
-    undoPromise
-  };
-};
-var defaultEffect = () => import_effect.Effect.fail(new Error("Intent runtime not ready"));
-var defaultPromise = () => import_effect.Effect.runPromise(defaultEffect());
-var intent_dispatcher_default = (context) => {
-  const state = (0, import_live_object.live)({
-    dispatch: defaultEffect,
-    dispatchPromise: defaultPromise,
-    undo: defaultEffect,
-    undoPromise: defaultPromise
-  });
-  const { dispatch, dispatchPromise, undo, undoPromise } = createDispatcher(() => context.getCapabilities(Capabilities.IntentResolver).flat());
-  const manager = context.getCapability(Capabilities.PluginManager);
-  state.dispatch = (intentChain, depth) => {
-    return import_effect.Effect.gen(function* () {
-      yield* manager._activate(Events.SetupIntentResolver);
-      return yield* dispatch(intentChain, depth);
-    });
-  };
-  state.dispatchPromise = async (intentChain) => {
-    await manager.activate(Events.SetupIntentResolver);
-    return await dispatchPromise(intentChain);
-  };
-  state.undo = undo;
-  state.undoPromise = undoPromise;
-  return contributes(Capabilities.IntentDispatcher, state);
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Capabilities,
-  CollaborationActions,
-  Events,
-  FileInfoSchema,
-  INTENT_ACTION,
-  INTENT_PLUGIN,
-  IntentAction,
-  IntentPlugin,
-  LAYOUT_ACTION,
-  LAYOUT_PLUGIN,
-  Label,
-  LayoutAction,
-  Plugin,
-  PluginContext,
-  PluginManager,
-  PluginModule,
-  Resource,
-  ResourceKey,
-  ResourceLanguage,
-  allOf,
-  chain,
-  contributes,
-  createDispatcher,
-  createIntent,
-  createResolver,
-  createSurface,
-  defaultFileTypes,
-  defineCapability,
-  defineEvent,
-  defineModule,
-  definePlugin,
-  eventKey,
-  getEvents,
-  intent_dispatcher_default,
-  isAllOf,
-  isOneOf,
-  lazy,
-  oneOf
-});
-//# sourceMappingURL=chunk-VSOSVDQ3.cjs.map