@dxos/app-framework 0.7.5-main.9d26e3a → 0.7.5-main.e9bb01b

package/dist/lib/node-esm/chunk-44J2VZBB.mjs

@@ -0,0 +1,1401 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+
+// packages/sdk/app-framework/src/plugin-intent/intent-dispatcher.ts
+import { Effect as Effect2, Option, pipe as pipe2, Ref } from "effect";
+import { create as create3 } from "@dxos/live-object";
+import { byPosition } from "@dxos/util";
+
+// packages/sdk/app-framework/src/plugin-intent/actions.ts
+import { Schema as S2 } from "@effect/schema";
+
+// packages/sdk/app-framework/src/plugin-intent/intent.ts
+import { Schema as S } from "@effect/schema";
+var createIntent = (schema, data = {}, params = {}) => {
+  const _ = S.validateSync(schema.fields.input)(data);
+  const intent = {
+    ...params,
+    _schema: schema,
+    id: schema._tag,
+    data
+  };
+  return {
+    first: intent,
+    last: intent,
+    all: [
+      intent
+    ]
+  };
+};
+var chain = (schema, data = {}, params = {}) => (intent) => {
+  const intents = "all" in intent ? intent.all : [
+    intent
+  ];
+  const first = intents[0];
+  const last = {
+    ...params,
+    _schema: schema,
+    id: schema._tag,
+    data
+  };
+  return {
+    first,
+    last,
+    all: [
+      ...intents,
+      last
+    ]
+  };
+};
+var Label = S.Union(S.String, S.mutable(S.Tuple(S.String, S.mutable(S.Struct({
+  ns: S.String,
+  count: S.optional(S.Number)
+})))));
+
+// packages/sdk/app-framework/src/plugin-intent/actions.ts
+var INTENT_PLUGIN = "dxos.org/plugin/intent";
+var INTENT_ACTION = `${INTENT_PLUGIN}/action`;
+var IntentAction;
+(function(IntentAction2) {
+  class ShowUndo extends S2.TaggedClass()(`${INTENT_ACTION}/show-undo`, {
+    input: S2.Struct({
+      message: Label
+    }),
+    output: S2.Void
+  }) {
+  }
+  IntentAction2.ShowUndo = ShowUndo;
+})(IntentAction || (IntentAction = {}));
+
+// packages/sdk/app-framework/src/plugin-intent/errors.ts
+var BaseError = class extends Error {
+  constructor(code, message, context) {
+    super(message ?? code);
+    this.code = code;
+    this.context = context;
+    this.name = code;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var NoResolversError = class extends BaseError {
+  constructor(action) {
+    super("NO_RESOLVERS", "No resolvers were found for the action", {
+      action
+    });
+  }
+};
+var CycleDetectedError = class extends BaseError {
+  constructor(context) {
+    super("CYCLE_DETECTED", "Intent execution limit exceeded. This is likely due to an infinite loop within intent resolvers.", context);
+  }
+};
+
+// packages/sdk/app-framework/src/core/capabilities.ts
+import { effect, untracked } from "@preact/signals-core";
+import { Trigger } from "@dxos/async";
+import { invariant } from "@dxos/invariant";
+import { create } from "@dxos/live-object";
+import { log } from "@dxos/log";
+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 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 = create({
+        value: []
+      });
+      current = untracked(() => object.value);
+      this._definedCapabilities.set(interfaceDef.identifier, current);
+    }
+    current.push(new CapabilityImpl(moduleId, implementation));
+    log("capability contributed", {
+      id: interfaceDef.identifier,
+      moduleId,
+      count: untracked(() => current.length)
+    }, {
+      F: __dxlog_file,
+      L: 142,
+      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);
+      log("capability removed", {
+        id: interfaceDef.identifier,
+        count: untracked(() => current.length)
+      }, {
+        F: __dxlog_file,
+        L: 161,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    } else {
+      log.warn("capability not removed", {
+        id: interfaceDef.identifier
+      }, {
+        F: __dxlog_file,
+        L: 163,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    }
+  }
+  /**
+  * 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 = create({
+        value: []
+      });
+      current = 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];
+    invariant(capability, `No capability found for ${interfaceDef.identifier}`, {
+      F: __dxlog_file,
+      L: 199,
+      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 Trigger();
+    const unsubscribe = effect(() => {
+      const capabilities = this.requestCapabilities(interfaceDef, filter);
+      if (capabilities[0]) {
+        trigger.wake(capabilities[0]);
+      }
+    });
+    const capability = await trigger.wait();
+    unsubscribe();
+    return capability;
+  }
+};
+
+// packages/sdk/app-framework/src/core/events.ts
+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
+];
+
+// packages/sdk/app-framework/src/core/manager.ts
+import { untracked as untracked2 } from "@preact/signals-core";
+import { Array as A, Effect, Either, Match, pipe } from "effect";
+import { Event } from "@dxos/async";
+import { create as create2 } from "@dxos/live-object";
+import { log as log2 } from "@dxos/log";
+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 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 = create2({
+      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 untracked2(async () => {
+      log2("add plugin", {
+        id
+      }, {
+        F: __dxlog_file2,
+        L: 146,
+        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 untracked2(async () => {
+      log2("enable plugin", {
+        id
+      }, {
+        F: __dxlog_file2,
+        L: 159,
+        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((module) => {
+        this._addModule(module);
+        this._setPendingResetByModule(module);
+      });
+      log2("pending reset", {
+        events: [
+          ...this.pendingReset
+        ]
+      }, {
+        F: __dxlog_file2,
+        L: 174,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      await Effect.runPromise(Effect.all(this.pendingReset.map((event) => this._activate(event)), {
+        concurrency: "unbounded"
+      }));
+      return true;
+    });
+  }
+  /**
+  * Removes a plugin from the manager.
+  * @param id The id of the plugin.
+  */
+  remove(id) {
+    return untracked2(() => {
+      log2("remove plugin", {
+        id
+      }, {
+        F: __dxlog_file2,
+        L: 192,
+        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 untracked2(async () => {
+      log2("disable plugin", {
+        id
+      }, {
+        F: __dxlog_file2,
+        L: 209,
+        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 Effect.runPromise(this._deactivate(id));
+        plugin.modules.forEach((module) => {
+          this._removeModule(module.id);
+        });
+      }
+      return true;
+    });
+  }
+  /**
+  * Activates plugins based on the activation event.
+  * @param event The activation event.
+  * @returns Whether the activation was successful.
+  */
+  activate(event) {
+    return untracked2(() => 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 untracked2(() => 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 untracked2(() => Effect.runPromise(this._reset(event)));
+  }
+  _addPlugin(plugin) {
+    untracked2(() => {
+      log2("add plugin", {
+        id: plugin.meta.id
+      }, {
+        F: __dxlog_file2,
+        L: 262,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      if (!this._state.plugins.includes(plugin)) {
+        this._state.plugins.push(plugin);
+      }
+    });
+  }
+  _removePlugin(id) {
+    untracked2(() => {
+      log2("remove plugin", {
+        id
+      }, {
+        F: __dxlog_file2,
+        L: 271,
+        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(module) {
+    untracked2(() => {
+      log2("add module", {
+        id: module.id
+      }, {
+        F: __dxlog_file2,
+        L: 281,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      if (!this._state.modules.includes(module)) {
+        this._state.modules.push(module);
+      }
+    });
+  }
+  _removeModule(id) {
+    untracked2(() => {
+      log2("remove module", {
+        id
+      }, {
+        F: __dxlog_file2,
+        L: 290,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      const moduleIndex = this._state.modules.findIndex((module) => module.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((module) => this._state.active.includes(module.id));
+  }
+  _getInactiveModules() {
+    return this._state.modules.filter((module) => !this._state.active.includes(module.id));
+  }
+  _getActiveModulesByEvent(key) {
+    return this._getActiveModules().filter((module) => getEvents(module.activatesOn).map(eventKey).includes(key));
+  }
+  _getInactiveModulesByEvent(key) {
+    return this._getInactiveModules().filter((module) => getEvents(module.activatesOn).map(eventKey).includes(key));
+  }
+  _setPendingResetByModule(module) {
+    return untracked2(() => {
+      const activationEvents = getEvents(module.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) {
+        log2("pending reset", {
+          events: pendingReset
+        }, {
+          F: __dxlog_file2,
+          L: 328,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        this._state.pendingReset.push(...pendingReset);
+      }
+    });
+  }
+  /**
+  * @internal
+  */
+  // TODO(wittjosiah): Improve error typing.
+  _activate(event) {
+    return Effect.gen(this, function* () {
+      const key = typeof event === "string" ? event : eventKey(event);
+      log2("activating", {
+        key
+      }, {
+        F: __dxlog_file2,
+        L: 341,
+        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((module) => {
+        const allOf2 = isAllOf(module.activatesOn);
+        if (!allOf2) {
+          return true;
+        }
+        const events = module.activatesOn.events.filter((event2) => eventKey(event2) !== key);
+        return events.every((event2) => this._state.eventsFired.includes(eventKey(event2)));
+      });
+      if (modules.length === 0) {
+        log2("no modules to activate", {
+          key
+        }, {
+          F: __dxlog_file2,
+          L: 357,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        if (!this._state.eventsFired.includes(key)) {
+          this._state.eventsFired.push(key);
+        }
+        return false;
+      }
+      log2("activating modules", {
+        key,
+        modules: modules.map((module) => module.id)
+      }, {
+        F: __dxlog_file2,
+        L: 364,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      this.activation.emit({
+        event: key,
+        state: "activating"
+      });
+      const getCapabilities = yield* Effect.all(modules.map(({ activate }) => Effect.tryPromise({
+        try: async () => activate(this.context),
+        catch: (error) => error
+      })), {
+        concurrency: "unbounded"
+      });
+      const result = yield* pipe(
+        modules,
+        A.zip(getCapabilities),
+        A.map(([module, getCapabilities2]) => this._activateModule(module, getCapabilities2)),
+        // TODO(wittjosiah): This currently can't be run in parallel.
+        //   Running this with concurrency causes races with `allOf` activation events.
+        Effect.all,
+        Effect.either
+      );
+      if (Either.isLeft(result)) {
+        this.activation.emit({
+          event: key,
+          state: "error",
+          error: result.left
+        });
+        yield* Effect.fail(result.left);
+      }
+      if (!this._state.eventsFired.includes(key)) {
+        this._state.eventsFired.push(key);
+      }
+      this.activation.emit({
+        event: key,
+        state: "activated"
+      });
+      log2("activated", {
+        key
+      }, {
+        F: __dxlog_file2,
+        L: 398,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      return true;
+    });
+  }
+  _activateModule(module, getCapabilities) {
+    return Effect.gen(this, function* () {
+      yield* Effect.all(module.activatesBefore?.map((event) => this._activate(event)) ?? [], {
+        concurrency: "unbounded"
+      });
+      log2("activating module...", {
+        module: module.id
+      }, {
+        F: __dxlog_file2,
+        L: 413,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      const maybeCapabilities = typeof getCapabilities === "function" ? getCapabilities() : getCapabilities;
+      const resolvedCapabilities = yield* Match.value(maybeCapabilities).pipe(
+        // TODO(wittjosiah): Activate with an effect?
+        // Match.when(Effect.isEffect, (effect) => effect),
+        Match.when(isPromise, (promise) => Effect.tryPromise({
+          try: () => promise,
+          catch: (error) => error
+        })),
+        Match.orElse((program) => Effect.succeed(program))
+      );
+      const capabilities = Match.value(resolvedCapabilities).pipe(Match.when(Array.isArray, (array) => array), Match.orElse((value) => [
+        value
+      ]));
+      capabilities.forEach((capability) => {
+        this.context.contributeCapability({
+          module: module.id,
+          ...capability
+        });
+      });
+      this._state.active.push(module.id);
+      this._capabilities.set(module.id, capabilities);
+      log2("activated module", {
+        module: module.id
+      }, {
+        F: __dxlog_file2,
+        L: 436,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      yield* Effect.all(module.activatesAfter?.map((event) => this._activate(event)) ?? [], {
+        concurrency: "unbounded"
+      });
+    });
+  }
+  _deactivate(id) {
+    return Effect.gen(this, function* () {
+      const plugin = this._getPlugin(id);
+      if (!plugin) {
+        return false;
+      }
+      const modules = plugin.modules;
+      const results = yield* Effect.all(modules.map((module) => this._deactivateModule(module)), {
+        concurrency: "unbounded"
+      });
+      return results.every((result) => result);
+    });
+  }
+  _deactivateModule(module) {
+    return Effect.gen(this, function* () {
+      const id = module.id;
+      log2("deactivating", {
+        id
+      }, {
+        F: __dxlog_file2,
+        L: 463,
+        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* Match.value(program).pipe(Match.when(Effect.isEffect, (effect2) => effect2), Match.when(isPromise, (promise) => Effect.tryPromise({
+            try: () => promise,
+            catch: (error) => error
+          })), Match.orElse((program2) => Effect.succeed(program2)));
+        }
+        this._capabilities.delete(id);
+      }
+      const activeIndex = this._state.active.findIndex((event) => event === id);
+      if (activeIndex !== -1) {
+        this._state.active.splice(activeIndex, 1);
+      }
+      log2("deactivated", {
+        id
+      }, {
+        F: __dxlog_file2,
+        L: 489,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      return true;
+    });
+  }
+  _reset(event) {
+    return Effect.gen(this, function* () {
+      const key = typeof event === "string" ? event : eventKey(event);
+      log2("reset", {
+        key
+      }, {
+        F: __dxlog_file2,
+        L: 497,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      const modules = this._getActiveModulesByEvent(key);
+      const results = yield* Effect.all(modules.map((module) => this._deactivateModule(module)), {
+        concurrency: "unbounded"
+      });
+      if (results.every((result) => result)) {
+        return yield* this._activate(key);
+      } else {
+        return false;
+      }
+    });
+  }
+};
+
+// packages/sdk/app-framework/src/core/plugin.ts
+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);
+};
+
+// packages/sdk/app-framework/src/common/capabilities.ts
+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.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.FileUploader = defineCapability("dxos.org/app-framework/capability/file-uploader");
+})(Capabilities || (Capabilities = {}));
+
+// packages/sdk/app-framework/src/common/events.ts
+var Events;
+(function(Events2) {
+  Events2.Startup = defineEvent("dxos.org/app-framework/event/startup");
+  Events2.SetupSurfaces = defineEvent("dxos.org/app-framework/event/setup-surfaces");
+  Events2.SetupMetadata = defineEvent("dxos.org/app-framework/event/setup-metadata");
+  Events2.SetupIntents = defineEvent("dxos.org/app-framework/event/setup-intents");
+  Events2.SetupSettings = defineEvent("dxos.org/app-framework/event/setup-settings");
+  Events2.SetupAppGraph = defineEvent("dxos.org/app-framework/event/setup-graph");
+  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);
+})(Events || (Events = {}));
+
+// packages/sdk/app-framework/src/common/file.ts
+import { Schema as S3 } from "@effect/schema";
+var defaultFileTypes = {
+  images: [
+    "png",
+    "jpg",
+    "jpeg",
+    "gif"
+  ],
+  media: [
+    "mp3",
+    "mp4",
+    "mov",
+    "avi"
+  ],
+  text: [
+    "pdf",
+    "txt",
+    "md"
+  ]
+};
+var FileInfoSchema = S3.Struct({
+  name: S3.String,
+  type: S3.String,
+  url: S3.optional(S3.String),
+  cid: S3.optional(S3.String)
+});
+
+// packages/sdk/app-framework/src/common/layout.ts
+import { Schema as S4 } from "@effect/schema";
+
+// packages/sdk/app-framework/src/plugin-intent/IntentPlugin.tsx
+var IntentPlugin = () => definePlugin({
+  id: INTENT_PLUGIN
+}, [
+  defineModule({
+    id: `${INTENT_PLUGIN}/module/dispatcher`,
+    // TODO(wittjosiah): This will mean that startup needs to be reset when intents are added or removed.
+    //   This is fine for now because it's how it worked prior to capabilities api anyways.
+    //   In the future, the intent dispatcher should be able to be reset without resetting the entire app.
+    activatesOn: Events.Startup,
+    activatesAfter: [
+      Events.DispatcherReady
+    ],
+    activate: lazy(() => import("./intent-dispatcher-LDQGDZ62.mjs"))
+  })
+]);
+
+// packages/sdk/app-framework/src/common/layout.ts
+var LAYOUT_PLUGIN = "dxos.org/plugin/layout";
+var LAYOUT_ACTION = `${LAYOUT_PLUGIN}/action`;
+var LayoutAction;
+(function(LayoutAction2) {
+  LayoutAction2.UPDATE_LAYOUT = `${LAYOUT_ACTION}/update-layout`;
+  class UpdateLayout extends S4.TaggedClass()(LayoutAction2.UPDATE_LAYOUT, {
+    input: S4.Struct({
+      part: S4.String.annotations({
+        description: "The part of the layout to mutate."
+      }),
+      subject: S4.optional(S4.Any.annotations({
+        description: "The subject of the layout update."
+      })),
+      options: S4.optional(S4.Record({
+        key: S4.String,
+        value: S4.Any
+      }).annotations({
+        description: "Additional options for the layout action."
+      }))
+    }),
+    output: S4.Void
+  }) {
+  }
+  LayoutAction2.UpdateLayout = UpdateLayout;
+  class SetLayoutMode extends S4.TaggedClass()(LayoutAction2.UPDATE_LAYOUT, {
+    input: S4.Struct({
+      part: S4.Literal("mode").annotations({
+        description: "Setting the layout mode."
+      }),
+      subject: S4.optional(S4.String.annotations({
+        description: "Item which is the subject of the new layout mode."
+      })),
+      options: S4.Union(S4.Struct({
+        mode: S4.String.annotations({
+          description: "The new layout mode."
+        })
+      }), S4.Struct({
+        revert: S4.Boolean.annotations({
+          description: "Revert to the previous layout mode."
+        })
+      }))
+    }),
+    output: S4.Void
+  }) {
+  }
+  LayoutAction2.SetLayoutMode = SetLayoutMode;
+  class UpdateSidebar extends S4.TaggedClass()(LayoutAction2.UPDATE_LAYOUT, {
+    input: S4.Struct({
+      part: S4.Literal("sidebar").annotations({
+        description: "Updating the sidebar."
+      }),
+      subject: S4.optional(S4.String.annotations({
+        description: "URI of the component to display in the sidebar."
+      })),
+      options: S4.optional(S4.Struct({
+        state: S4.Literal("closed", "collapsed", "expanded").annotations({
+          description: "Whether the sidebar is closed, collapsed, or expanded."
+        })
+      }))
+    }),
+    output: S4.Void
+  }) {
+  }
+  LayoutAction2.UpdateSidebar = UpdateSidebar;
+  class UpdateComplementary extends S4.TaggedClass()(LayoutAction2.UPDATE_LAYOUT, {
+    input: S4.Struct({
+      part: S4.Literal("complementary").annotations({
+        description: "Updating the complementary sidebar."
+      }),
+      subject: S4.optional(S4.String.annotations({
+        description: "URI of the component to display in the complementary area."
+      })),
+      options: S4.optional(S4.Struct({
+        state: S4.Literal("closed", "collapsed", "expanded").annotations({
+          description: "Whether the complementary sidebar is closed, collapsed, or expanded."
+        })
+      }))
+    }),
+    output: S4.Void
+  }) {
+  }
+  LayoutAction2.UpdateComplementary = UpdateComplementary;
+  class UpdateDialog extends S4.TaggedClass()(LayoutAction2.UPDATE_LAYOUT, {
+    input: S4.Struct({
+      part: S4.Literal("dialog").annotations({
+        description: "Updating the dialog."
+      }),
+      subject: S4.optional(S4.String.annotations({
+        description: "URI of the component to display in the dialog."
+      })),
+      options: S4.Struct({
+        state: S4.optional(S4.Boolean.annotations({
+          description: "Whether the dialog is open or closed."
+        })),
+        blockAlign: S4.optional(S4.Literal("start", "center").annotations({
+          description: "The alignment of the dialog."
+        })),
+        type: S4.optional(S4.Literal("default", "alert").annotations({
+          description: "The type of dialog."
+        })),
+        props: S4.optional(S4.Record({
+          key: S4.String,
+          value: S4.Any
+        }).annotations({
+          description: "Additional props for the dialog."
+        }))
+      })
+    }),
+    output: S4.Void
+  }) {
+  }
+  LayoutAction2.UpdateDialog = UpdateDialog;
+  class UpdatePopover extends S4.TaggedClass()(LayoutAction2.UPDATE_LAYOUT, {
+    input: S4.Struct({
+      part: S4.Literal("popover").annotations({
+        description: "Updating the popover."
+      }),
+      subject: S4.optional(S4.String.annotations({
+        description: "URI of the component to display in the popover."
+      })),
+      options: S4.Struct({
+        anchorId: S4.String.annotations({
+          description: "The id of the element to anchor the popover to."
+        }),
+        state: S4.optional(S4.Boolean.annotations({
+          description: "Whether the popover is open or closed."
+        })),
+        props: S4.optional(S4.Record({
+          key: S4.String,
+          value: S4.Any
+        }).annotations({
+          description: "Additional props for the popover."
+        }))
+      })
+    }),
+    output: S4.Void
+  }) {
+  }
+  LayoutAction2.UpdatePopover = UpdatePopover;
+  LayoutAction2.Toast = S4.Struct({
+    id: S4.String.annotations({
+      description: "The id of the toast."
+    }),
+    title: S4.optional(Label.annotations({
+      description: "The title of the toast."
+    })),
+    description: S4.optional(Label.annotations({
+      description: "The description of the toast."
+    })),
+    icon: S4.optional(S4.String.annotations({
+      description: "The icon of the toast."
+    })),
+    duration: S4.optional(S4.Number.annotations({
+      description: "The duration of the toast."
+    })),
+    closeLabel: S4.optional(Label.annotations({
+      description: "The label of the close button."
+    })),
+    actionLabel: S4.optional(Label.annotations({
+      description: "The label of the action button."
+    })),
+    actionAlt: S4.optional(Label.annotations({
+      description: "The alt text of the action button."
+    })),
+    onAction: S4.optional(S4.Any.annotations({
+      description: "The action to perform when the action button is clicked."
+    }))
+  });
+  class AddToast extends S4.TaggedClass()(LayoutAction2.UPDATE_LAYOUT, {
+    input: S4.Struct({
+      part: S4.Literal("toast").annotations({
+        description: "Adding a toast."
+      }),
+      subject: LayoutAction2.Toast.annotations({
+        description: "The toast to add."
+      })
+    }),
+    output: S4.Void
+  }) {
+  }
+  LayoutAction2.AddToast = AddToast;
+  class SwitchWorkspace extends S4.TaggedClass()(LayoutAction2.UPDATE_LAYOUT, {
+    input: S4.Struct({
+      part: S4.Literal("workspace").annotations({
+        description: "Switching the workspace."
+      }),
+      subject: S4.String.annotations({
+        description: "The id of the workspace to switch to."
+      })
+    }),
+    output: S4.Void
+  }) {
+  }
+  LayoutAction2.SwitchWorkspace = SwitchWorkspace;
+  class Open extends S4.TaggedClass()(LayoutAction2.UPDATE_LAYOUT, {
+    input: S4.Struct({
+      part: S4.Literal("main").annotations({
+        description: "Opening an item in the main content area."
+      }),
+      subject: S4.Array(S4.String.annotations({
+        description: "Ids of the items to open."
+      })),
+      options: S4.optional(S4.Struct({
+        state: S4.optional(S4.Literal(true).annotations({
+          description: "The items are being added."
+        })),
+        key: S4.optional(S4.String.annotations({
+          description: "If provided, will replace item with a matching key (id prefix)."
+        })),
+        scrollIntoView: S4.optional(S4.Boolean.annotations({
+          description: "Scroll the items into view."
+        })),
+        pivotId: S4.optional(S4.String.annotations({
+          description: "The id of the item to place new items next to."
+        })),
+        positioning: S4.optional(S4.Union(S4.Literal("start").annotations({
+          description: "The items are being added before the pivot item."
+        }), S4.Literal("end").annotations({
+          description: "The items are being added after the pivot item."
+        })))
+      }))
+    }),
+    output: S4.Void
+  }) {
+  }
+  LayoutAction2.Open = Open;
+  class Set2 extends S4.TaggedClass()(LayoutAction2.UPDATE_LAYOUT, {
+    input: S4.Struct({
+      part: S4.Literal("main").annotations({
+        description: "Setting items in the main content area."
+      }),
+      subject: S4.Array(S4.String.annotations({
+        description: "Ids of the items to set."
+      })),
+      options: S4.Struct({
+        override: S4.Literal(true).annotations({
+          description: "Override the current items in the main content area."
+        })
+      })
+    }),
+    output: S4.Void
+  }) {
+  }
+  LayoutAction2.Set = Set2;
+  class Close extends S4.TaggedClass()(LayoutAction2.UPDATE_LAYOUT, {
+    input: S4.Struct({
+      part: S4.Literal("main").annotations({
+        description: "Closing items in the main content area."
+      }),
+      subject: S4.Array(S4.String.annotations({
+        description: "Ids of the items to close."
+      })),
+      options: S4.Struct({
+        state: S4.Literal(false).annotations({
+          description: "The items are being removed."
+        })
+      })
+    }),
+    output: S4.Void
+  }) {
+  }
+  LayoutAction2.Close = Close;
+  class ScrollIntoView extends S4.TaggedClass()(LayoutAction2.UPDATE_LAYOUT, {
+    input: S4.Struct({
+      part: S4.Literal("current").annotations({
+        description: "Setting the current item"
+      }),
+      subject: S4.optional(S4.String.annotations({
+        description: "The id of the item to set as current."
+      })),
+      options: S4.optional(S4.Record({
+        key: S4.String,
+        value: S4.Any
+      }).annotations({
+        description: "Additional options for the scroll into view."
+      }))
+    }),
+    output: S4.Void
+  }) {
+  }
+  LayoutAction2.ScrollIntoView = ScrollIntoView;
+  class Expose extends S4.TaggedClass()(LayoutAction2.UPDATE_LAYOUT, {
+    input: S4.Struct({
+      part: S4.Literal("navigation").annotations({
+        description: "Exposing an item in the navigation area."
+      }),
+      subject: S4.String.annotations({
+        description: "The id of the item to expose."
+      })
+    }),
+    output: S4.Void
+  }) {
+  }
+  LayoutAction2.Expose = Expose;
+})(LayoutAction || (LayoutAction = {}));
+
+// packages/sdk/app-framework/src/common/surface.ts
+var createSurface = (definition) => definition;
+
+// packages/sdk/app-framework/src/common/translations.ts
+import { Schema as S5 } from "@effect/schema";
+var ResourceKey = S5.Union(S5.String, S5.Record({
+  key: S5.String,
+  value: S5.Any
+}));
+var ResourceLanguage = S5.Record({
+  key: S5.String,
+  value: ResourceKey
+});
+var Resource = S5.Record({
+  key: S5.String,
+  value: ResourceLanguage
+});
+
+// packages/sdk/app-framework/src/plugin-intent/intent-dispatcher.ts
+var EXECUTION_LIMIT = 100;
+var HISTORY_LIMIT = 100;
+var createResolver = (resolver) => resolver;
+var isUndoable = (historyEntry) => historyEntry.length > 0 && historyEntry.every(({ undoable }) => !!undoable);
+var createDispatcher = (getResolvers, { executionLimit = EXECUTION_LIMIT, historyLimit = HISTORY_LIMIT } = {}) => {
+  const historyRef = Effect2.runSync(Ref.make([]));
+  const handleIntent = (intent) => Effect2.gen(function* () {
+    const candidates = getResolvers(intent.module).filter((r) => r.intent._tag === intent.id).filter((r) => !r.filter || r.filter(intent.data)).toSorted(byPosition);
+    if (candidates.length === 0) {
+      yield* Effect2.fail(new NoResolversError(intent.id));
+    }
+    const effect2 = candidates[0].resolve(intent.data, intent.undo ?? false);
+    const result = Effect2.isEffect(effect2) ? yield* effect2 : yield* Effect2.promise(async () => effect2);
+    return {
+      _intent: intent,
+      ...result
+    };
+  });
+  const dispatch = (intentChain, depth = 0) => {
+    return Effect2.gen(function* () {
+      if (depth > executionLimit) {
+        yield* Effect2.fail(new CycleDetectedError());
+      }
+      const resultsRef = yield* 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* Ref.update(resultsRef, (results2) => [
+          result2,
+          ...results2
+        ]);
+        if (result2.intents) {
+          for (const intent2 of result2.intents) {
+            yield* dispatch(intent2, depth + 1);
+          }
+        }
+        if (result2.error) {
+          yield* Effect2.fail(result2.error);
+        }
+      }
+      const results = yield* resultsRef.get;
+      const result = results[0];
+      yield* 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* pipe2(dispatch(createIntent(IntentAction.ShowUndo, {
+          message: result.undoable.message
+        })), Effect2.catchSome((err) => err instanceof NoResolversError ? Option.some(Effect2.succeed(void 0)) : Option.none()));
+      }
+      return result.data;
+    });
+  };
+  const dispatchPromise = (intentChain) => {
+    return Effect2.runPromise(dispatch(intentChain)).then((data) => ({
+      data
+    })).catch((error) => ({
+      error
+    }));
+  };
+  const undo = () => {
+    return Effect2.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* Ref.update(historyRef, (h) => h.filter((_, index) => index !== last));
+        return yield* dispatch(intent);
+      }
+    });
+  };
+  const undoPromise = () => {
+    return Effect2.runPromise(undo()).then((data) => ({
+      data
+    })).catch((error) => ({
+      error
+    }));
+  };
+  return {
+    dispatch,
+    dispatchPromise,
+    undo,
+    undoPromise
+  };
+};
+var defaultEffect = () => Effect2.fail(new Error("Intent runtime not ready"));
+var defaultPromise = () => Effect2.runPromise(defaultEffect());
+var intent_dispatcher_default = (context) => {
+  const state = create3({
+    dispatch: defaultEffect,
+    dispatchPromise: defaultPromise,
+    undo: defaultEffect,
+    undoPromise: defaultPromise
+  });
+  const { dispatch, dispatchPromise, undo, undoPromise } = createDispatcher((module) => context.requestCapabilities(Capabilities.IntentResolver, (c, moduleId) => {
+    return module ? moduleId === module : true;
+  }).flat());
+  const manager = context.requestCapability(Capabilities.PluginManager);
+  state.dispatch = (intentChain, depth) => {
+    return Effect2.gen(function* () {
+      yield* manager._activate(Events.SetupIntents);
+      return yield* dispatch(intentChain, depth);
+    });
+  };
+  state.dispatchPromise = async (intentChain) => {
+    await manager.activate(Events.SetupIntents);
+    return await dispatchPromise(intentChain);
+  };
+  state.undo = undo;
+  state.undoPromise = undoPromise;
+  return contributes(Capabilities.IntentDispatcher, state);
+};
+
+export {
+  defineCapability,
+  contributes,
+  lazy,
+  PluginsContext,
+  defineEvent,
+  eventKey,
+  oneOf,
+  allOf,
+  isOneOf,
+  isAllOf,
+  getEvents,
+  PluginManager,
+  PluginModule,
+  defineModule,
+  Plugin,
+  definePlugin,
+  Capabilities,
+  Events,
+  defaultFileTypes,
+  FileInfoSchema,
+  createIntent,
+  chain,
+  Label,
+  INTENT_PLUGIN,
+  INTENT_ACTION,
+  IntentAction,
+  createResolver,
+  createDispatcher,
+  intent_dispatcher_default,
+  IntentPlugin,
+  LAYOUT_PLUGIN,
+  LAYOUT_ACTION,
+  LayoutAction,
+  createSurface,
+  ResourceKey,
+  ResourceLanguage,
+  Resource
+};
+//# sourceMappingURL=chunk-44J2VZBB.mjs.map