@dxos/app-framework 0.8.4-main.67995b8 → 0.8.4-main.a4bbb77

package/dist/lib/node-esm/{chunk-ZEZ4FVEU.mjs → chunk-SOVTUUAY.mjs}

@@ -1,111 +1,30 @@
 import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
 
 // src/plugin-intent/intent-dispatcher.ts
-import { Effect as Effect3, Option, pipe as pipe2, Ref as Ref2 } from "effect";
+import { Effect as Effect3, Option, Ref as Ref2, pipe as pipe2 } from "effect";
 import { live as live2 } from "@dxos/live-object";
 import { log as log3 } from "@dxos/log";
 import { byPosition } from "@dxos/util";
 
-// src/plugin-intent/actions.ts
-import { Schema as Schema2 } from "effect";
-
-// src/plugin-intent/intent.ts
-import { Schema } from "effect";
-var createIntent = (schema, data = {}, params = {}) => {
-  const _ = 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 = Schema.Union(Schema.String, Schema.mutable(Schema.Tuple(Schema.String, Schema.mutable(Schema.Struct({
-  ns: Schema.String,
-  count: Schema.optional(Schema.Number),
-  defaultValue: Schema.optional(Schema.String)
-})))));
-
-// src/plugin-intent/actions.ts
-var INTENT_PLUGIN = "dxos.org/plugin/intent";
-var INTENT_ACTION = `${INTENT_PLUGIN}/action`;
-(function(IntentAction2) {
-  class Track extends Schema2.TaggedClass()(`${INTENT_ACTION}/track`, {
-    input: Schema2.Struct({
-      intents: Schema2.Array(Schema2.String),
-      error: Schema2.optional(Schema2.String)
-    }),
-    output: Schema2.Void
-  }) {
-  }
-  IntentAction2.Track = Track;
-  class ShowUndo extends Schema2.TaggedClass()(`${INTENT_ACTION}/show-undo`, {
-    input: Schema2.Struct({
-      message: Label
-    }),
-    output: Schema2.Void
-  }) {
-  }
-  IntentAction2.ShowUndo = ShowUndo;
-})(IntentAction || (IntentAction = {}));
-var IntentAction;
-
-// src/plugin-intent/errors.ts
-var BaseError = class extends Error {
-  constructor(code, message, context) {
-    super(message ?? code, {
-      cause: context
-    }), this.code = code, this.context = context;
-    this.name = code;
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-};
-var NoResolversError = class extends BaseError {
-  constructor(action) {
-    super("NO_RESOLVERS", "No resolvers were found for the action", {
-      action
-    });
-  }
-};
-var CycleDetectedError = class extends BaseError {
-  constructor(context) {
-    super("CYCLE_DETECTED", "Intent execution limit exceeded. This is likely due to an infinite loop within intent resolvers.", context);
-  }
-};
-
 // src/core/capabilities.ts
 import { Rx } from "@effect-rx/rx-react";
 import { Effect } from "effect";
 import { Trigger } from "@dxos/async";
 import { invariant } from "@dxos/invariant";
 import { log } from "@dxos/log";
+function _define_property(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
 var __dxlog_file = "/__w/dxos/dxos/packages/sdk/app-framework/src/core/capabilities.ts";
 var InterfaceDefTypeId = Symbol.for("InterfaceDefTypeId");
 var defineCapability = (identifier) => {
@@ -115,6 +34,8 @@ var defineCapability = (identifier) => {
 };
 var CapabilityImpl = class {
   constructor(moduleId, implementation) {
+    _define_property(this, "moduleId", void 0);
+    _define_property(this, "implementation", void 0);
     this.moduleId = moduleId;
     this.implementation = implementation;
   }
@@ -131,35 +52,6 @@ var lazy = (c) => async (props) => {
   return async () => getCapability(props);
 };
 var PluginContext = class {
-  constructor({ registry, activate, reset }) {
-    this._capabilityImpls = Rx.family(() => {
-      return Rx.make([]).pipe(Rx.keepAlive);
-    });
-    this._capabilities = Rx.family((id) => {
-      return Rx.make((get) => {
-        const current = get(this._capabilityImpls(id));
-        return current.map((c) => c.implementation);
-      });
-    });
-    this._capability = Rx.family((id) => {
-      return Rx.make((get) => {
-        const current = get(this._capabilities(id));
-        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
   */
@@ -179,7 +71,7 @@ var PluginContext = class {
       count: current.length
     }, {
       F: __dxlog_file,
-      L: 161,
+      L: 166,
       S: this,
       C: (f, a) => f(...a)
     });
@@ -200,7 +92,7 @@ var PluginContext = class {
         count: current.length
       }, {
         F: __dxlog_file,
-        L: 180,
+        L: 185,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -209,7 +101,7 @@ var PluginContext = class {
         id: interfaceDef.identifier
       }, {
         F: __dxlog_file,
-        L: 182,
+        L: 187,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -274,6 +166,38 @@ var PluginContext = class {
   async resetPromise(event) {
     return this.reset(event).pipe(Effect.runPromise);
   }
+  constructor({ registry, activate, reset }) {
+    _define_property(this, "_registry", void 0);
+    _define_property(this, "_capabilityImpls", Rx.family(() => {
+      return Rx.make([]).pipe(Rx.keepAlive);
+    }));
+    _define_property(this, "_capabilities", Rx.family((id) => {
+      return Rx.make((get) => {
+        const current = get(this._capabilityImpls(id));
+        return current.map((c) => c.implementation);
+      });
+    }));
+    _define_property(this, "_capability", Rx.family((id) => {
+      return Rx.make((get) => {
+        const current = get(this._capabilities(id));
+        invariant(current.length > 0, `No capability found for ${id}`, {
+          F: __dxlog_file,
+          L: 122,
+          S: this,
+          A: [
+            "current.length > 0",
+            "`No capability found for ${id}`"
+          ]
+        });
+        return current[0];
+      });
+    }));
+    _define_property(this, "activate", void 0);
+    _define_property(this, "reset", void 0);
+    this._registry = registry;
+    this.activate = activate;
+    this.reset = reset;
+  }
 };
 
 // src/core/events.ts
@@ -301,38 +225,28 @@ var getEvents = (events) => "type" in events ? events.events : [
 // src/core/manager.ts
 import { Registry } from "@effect-rx/rx-react";
 import { untracked } from "@preact/signals-core";
-import { Array as A, Effect as Effect2, Either, Match, pipe } from "effect";
+import { Array, Duration, Effect as Effect2, Fiber, HashSet, Match, Ref, pipe } from "effect";
 import { Event } from "@dxos/async";
 import { live } from "@dxos/live-object";
 import { log as log2 } from "@dxos/log";
+function _define_property2(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
 var __dxlog_file2 = "/__w/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 Event();
-    this._capabilities = /* @__PURE__ */ new Map();
-    this.registry = registry ?? Registry.make();
-    this.context = new PluginContext({
-      registry: this.registry,
-      activate: (event) => this._activate(event),
-      reset: (id) => this._reset(id)
-    });
-    this._pluginLoader = pluginLoader;
-    this._state = 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.
   *
@@ -399,7 +313,7 @@ var PluginManager = class {
         id
       }, {
         F: __dxlog_file2,
-        L: 154,
+        L: 157,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -418,7 +332,7 @@ var PluginManager = class {
         id
       }, {
         F: __dxlog_file2,
-        L: 167,
+        L: 170,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -439,7 +353,7 @@ var PluginManager = class {
         ]
       }, {
         F: __dxlog_file2,
-        L: 182,
+        L: 185,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -459,7 +373,7 @@ var PluginManager = class {
         id
       }, {
         F: __dxlog_file2,
-        L: 200,
+        L: 203,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -481,7 +395,7 @@ var PluginManager = class {
         id
       }, {
         F: __dxlog_file2,
-        L: 217,
+        L: 220,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -533,7 +447,7 @@ var PluginManager = class {
         id: plugin.meta.id
       }, {
         F: __dxlog_file2,
-        L: 270,
+        L: 273,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -548,7 +462,7 @@ var PluginManager = class {
         id
       }, {
         F: __dxlog_file2,
-        L: 279,
+        L: 283,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -564,7 +478,7 @@ var PluginManager = class {
         id: module.id
       }, {
         F: __dxlog_file2,
-        L: 289,
+        L: 293,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -579,7 +493,7 @@ var PluginManager = class {
         id
       }, {
         F: __dxlog_file2,
-        L: 298,
+        L: 303,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -607,13 +521,13 @@ var PluginManager = class {
   _setPendingResetByModule(module) {
     return untracked(() => {
       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));
+      const pendingReset = Array.fromIterable(new Set(activationEvents)).filter((event) => !this._state.pendingReset.includes(event));
       if (pendingReset.length > 0) {
         log2("pending reset", {
           events: pendingReset
         }, {
           F: __dxlog_file2,
-          L: 336,
+          L: 341,
           S: this,
           C: (f, a) => f(...a)
         });
@@ -625,35 +539,40 @@ var PluginManager = class {
   * @internal
   */
   // TODO(wittjosiah): Improve error typing.
-  _activate(event) {
+  _activate(event, params) {
     return Effect2.gen(this, function* () {
       const key = typeof event === "string" ? event : eventKey(event);
       log2("activating", {
-        key
+        key,
+        ...params
       }, {
         F: __dxlog_file2,
-        L: 349,
+        L: 357,
         S: this,
         C: (f, a) => f(...a)
       });
+      yield* Ref.update(this._activatingEvents, (activating) => Array.append(activating, key));
       const pendingIndex = this._state.pendingReset.findIndex((event2) => event2 === key);
       if (pendingIndex !== -1) {
         this._state.pendingReset.splice(pendingIndex, 1);
       }
+      const activatingEvents = yield* this._activatingEvents;
+      const activatingModules = yield* this._activatingModules;
       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)));
+        return events.every((event2) => this._state.eventsFired.includes(eventKey(event2)) || activatingEvents.includes(eventKey(event2))) && !activatingModules.includes(module.id);
       });
+      yield* Ref.update(this._activatingModules, (activating) => Array.appendAll(activating, modules.map((module) => module.id)));
       if (modules.length === 0) {
         log2("no modules to activate", {
           key
         }, {
           F: __dxlog_file2,
-          L: 365,
+          L: 388,
           S: this,
           C: (f, a) => f(...a)
         });
@@ -667,7 +586,7 @@ var PluginManager = class {
         modules: modules.map((module) => module.id)
       }, {
         F: __dxlog_file2,
-        L: 372,
+        L: 395,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -675,29 +594,36 @@ var PluginManager = class {
         event: key,
         state: "activating"
       });
-      const getCapabilities = yield* Effect2.all(modules.map(({ activate }) => Effect2.tryPromise({
-        try: async () => activate(this.context),
-        catch: (error) => error
-      })), {
+      yield* pipe(modules, Array.flatMap((module) => module.activatesBefore ?? []), HashSet.fromIterable, HashSet.toValues, Array.filter((event2) => !activatingEvents.includes(eventKey(event2))), Array.map((event2) => this._activate(event2, {
+        before: key
+      })), Effect2.allWith({
         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.
-        Effect2.all,
-        Effect2.either
-      );
-      if (Either.isLeft(result)) {
+      }));
+      const getCapabilities = yield* pipe(modules, Array.map((mod) => this._loadModule(mod)), Effect2.allWith({
+        concurrency: "unbounded"
+      }), Effect2.catchAll((error) => {
         this.activation.emit({
           event: key,
           state: "error",
-          error: result.left
+          error
         });
-        yield* Effect2.fail(result.left);
-      }
+        return Effect2.fail(error);
+      }));
+      yield* pipe(
+        modules,
+        Array.zip(getCapabilities),
+        Array.map(([module, capabilities]) => this._contributeCapabilities(module, capabilities)),
+        // TODO(wittjosiah): This currently can't be run in parallel.
+        //   Running this with concurrency causes races with `allOf` activation events.
+        Effect2.all
+      );
+      yield* pipe(modules, Array.flatMap((module) => module.activatesAfter ?? []), HashSet.fromIterable, HashSet.toValues, Array.filter((event2) => !activatingEvents.includes(eventKey(event2))), Array.map((event2) => this._activate(event2, {
+        after: key
+      })), Effect2.allWith({
+        concurrency: "unbounded"
+      }));
+      yield* Ref.update(this._activatingEvents, (activating) => Array.filter(activating, (event2) => event2 !== key));
+      yield* Ref.update(this._activatingModules, (activating) => Array.filter(activating, (module) => !modules.map((module2) => module2.id).includes(module)));
       if (!this._state.eventsFired.includes(key)) {
         this._state.eventsFired.push(key);
       }
@@ -709,39 +635,15 @@ var PluginManager = class {
         key
       }, {
         F: __dxlog_file2,
-        L: 406,
+        L: 451,
         S: this,
         C: (f, a) => f(...a)
       });
       return true;
     });
   }
-  _activateModule(module, getCapabilities) {
+  _contributeCapabilities(module, capabilities) {
     return Effect2.gen(this, function* () {
-      yield* Effect2.all(module.activatesBefore?.map((event) => this._activate(event)) ?? [], {
-        concurrency: "unbounded"
-      });
-      log2("activating module...", {
-        module: module.id
-      }, {
-        F: __dxlog_file2,
-        L: 421,
-        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) => Effect2.tryPromise({
-          try: () => promise,
-          catch: (error) => error
-        })),
-        Match.orElse((program) => Effect2.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,
@@ -750,17 +652,6 @@ var PluginManager = class {
       });
       this._state.active.push(module.id);
       this._capabilities.set(module.id, capabilities);
-      log2("activated module", {
-        module: module.id
-      }, {
-        F: __dxlog_file2,
-        L: 444,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      yield* Effect2.all(module.activatesAfter?.map((event) => this._activate(event)) ?? [], {
-        concurrency: "unbounded"
-      });
     });
   }
   _deactivate(id) {
@@ -783,10 +674,11 @@ var PluginManager = class {
         id
       }, {
         F: __dxlog_file2,
-        L: 471,
+        L: 533,
         S: this,
         C: (f, a) => f(...a)
       });
+      this._moduleMemoMap.delete(id);
       const capabilities = this._capabilities.get(id);
       if (capabilities) {
         for (const capability of capabilities) {
@@ -807,7 +699,7 @@ var PluginManager = class {
         id
       }, {
         F: __dxlog_file2,
-        L: 497,
+        L: 560,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -821,7 +713,7 @@ var PluginManager = class {
         key
       }, {
         F: __dxlog_file2,
-        L: 505,
+        L: 568,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -836,11 +728,125 @@ var PluginManager = class {
       }
     });
   }
+  constructor({ pluginLoader, plugins = [], core = plugins.map(({ meta: meta2 }) => meta2.id), enabled = [], registry }) {
+    _define_property2(this, "activation", new Event());
+    _define_property2(this, "context", void 0);
+    _define_property2(this, "registry", void 0);
+    _define_property2(this, "_state", void 0);
+    _define_property2(this, "_pluginLoader", void 0);
+    _define_property2(this, "_capabilities", /* @__PURE__ */ new Map());
+    _define_property2(this, "_moduleMemoMap", /* @__PURE__ */ new Map());
+    _define_property2(this, "_activatingEvents", Effect2.runSync(Ref.make([])));
+    _define_property2(this, "_activatingModules", Effect2.runSync(Ref.make([])));
+    _define_property2(this, "_loadModule", (mod) => Effect2.tryPromise({
+      try: async () => {
+        const entry = this._moduleMemoMap.get(mod.id);
+        if (entry) {
+          return entry;
+        }
+        const promise = (async () => {
+          const start = performance.now();
+          let failed = false;
+          try {
+            log2("loading module", {
+              module: mod.id
+            }, {
+              F: __dxlog_file2,
+              L: 470,
+              S: this,
+              C: (f, a) => f(...a)
+            });
+            let activationResult = await mod.activate(this.context);
+            if (typeof activationResult === "function") {
+              activationResult = await activationResult();
+            }
+            return Array.isArray(activationResult) ? activationResult : [
+              activationResult
+            ];
+          } catch (error) {
+            failed = true;
+            throw error;
+          } finally {
+            performance.measure("activate-module", {
+              start,
+              end: performance.now(),
+              detail: {
+                module: mod.id
+              }
+            });
+            log2("loaded module", {
+              module: mod.id,
+              elapsed: performance.now() - start,
+              failed
+            }, {
+              F: __dxlog_file2,
+              L: 488,
+              S: this,
+              C: (f, a) => f(...a)
+            });
+          }
+        })();
+        this._moduleMemoMap.set(mod.id, promise);
+        return promise;
+      },
+      catch: (error) => error
+    }).pipe(Effect2.withSpan("PluginManager._loadModule"), together(Effect2.sleep(Duration.seconds(10)).pipe(Effect2.andThen(Effect2.sync(() => log2.warn(`module is taking a long time to activate`, {
+      module: mod.id
+    }, {
+      F: __dxlog_file2,
+      L: 499,
+      S: this,
+      C: (f, a) => f(...a)
+    })))))));
+    this.registry = registry ?? Registry.make();
+    this.context = new PluginContext({
+      registry: this.registry,
+      activate: (event) => this._activate(event),
+      reset: (id) => this._reset(id)
+    });
+    this._pluginLoader = pluginLoader;
+    this._state = live({
+      plugins,
+      core,
+      enabled,
+      modules: [],
+      active: [],
+      eventsFired: [],
+      pendingReset: []
+    });
+    plugins.forEach((plugin) => this._addPlugin(plugin));
+    core.forEach((id) => this.enable(id));
+    enabled.forEach((id) => this.enable(id));
+  }
 };
+var together = (togetherEffect) => (effect) => Effect2.gen(function* () {
+  const togetherFiber = yield* Effect2.fork(togetherEffect);
+  const result = yield* effect;
+  yield* Fiber.interrupt(togetherFiber);
+  return result;
+});
 
 // src/core/plugin.ts
+function _define_property3(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
 var PluginModule = class {
   constructor(options) {
+    _define_property3(this, "id", void 0);
+    _define_property3(this, "activatesOn", void 0);
+    _define_property3(this, "activatesBefore", void 0);
+    _define_property3(this, "activatesAfter", void 0);
+    _define_property3(this, "activate", void 0);
     this.id = options.id;
     this.activatesOn = options.activatesOn;
     this.activatesBefore = options.activatesBefore;
@@ -850,13 +856,20 @@ var PluginModule = class {
 };
 var defineModule = (options) => new PluginModule(options);
 var Plugin = class {
-  constructor(meta, modules) {
-    this.meta = meta;
+  constructor(meta2, modules) {
+    _define_property3(this, "meta", void 0);
+    _define_property3(this, "modules", void 0);
+    this.meta = meta2;
     this.modules = modules;
   }
 };
-var definePlugin = (meta, modules) => {
-  return new Plugin(meta, modules);
+var definePlugin = (meta2, provider) => {
+  const factory = (args) => {
+    return new Plugin(meta2, provider(args));
+  };
+  return Object.assign(factory, {
+    meta: meta2
+  });
 };
 
 // src/common/capabilities.ts
@@ -877,8 +890,11 @@ var definePlugin = (meta, modules) => {
   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.Toolkit = defineCapability("dxos.org/app-framework/capability/ai-toolkit");
+  Capabilities2.ToolkitHandler = defineCapability("dxos.org/app-framework/capability/ai-toolkit-handler");
+  Capabilities2.BlueprintDefinition = defineCapability("dxos.org/app-framework/capability/blueprint-definition");
+  Capabilities2.AiServiceLayer = defineCapability("dxos.org/app-framework/capability/ai-service-factory");
+  Capabilities2.AiModelResolver = defineCapability("dxos.org/app-framework/capability/ai-model-resolver");
   Capabilities2.Functions = defineCapability("dxos.org/app-framework/capability/functions");
   Capabilities2.FileUploader = defineCapability("dxos.org/app-framework/capability/file-uploader");
   Capabilities2.AnchorSort = defineCapability("dxos.org/app-framework/capability/anchor-sort");
@@ -886,22 +902,19 @@ var definePlugin = (meta, modules) => {
 var Capabilities;
 
 // src/common/collaboration.ts
-import { Schema as Schema3 } from "effect";
-import { Expando, Ref } from "@dxos/echo-schema";
+import { Schema } from "effect";
+import { DataType } from "@dxos/schema";
 (function(CollaborationActions2) {
-  class InsertContent extends Schema3.TaggedClass()("assistant/intent-content", {
-    input: Schema3.Struct({
-      target: Expando,
-      object: Ref(Expando),
-      at: Schema3.optional(Schema3.String),
-      label: Schema3.String.pipe(Schema3.optional)
-    }).annotations({
-      description: "Enables plugins to inject content blocks or references into a related entity."
+  class AcceptProposal extends Schema.TaggedClass()("collaboration/accept-proposal", {
+    input: Schema.Struct({
+      subject: Schema.Any,
+      anchor: Schema.String,
+      proposal: DataType.MessageBlock.Proposal
     }),
-    output: Schema3.Void
+    output: Schema.Void
   }) {
   }
-  CollaborationActions2.InsertContent = InsertContent;
+  CollaborationActions2.AcceptProposal = AcceptProposal;
 })(CollaborationActions || (CollaborationActions = {}));
 var CollaborationActions;
 
@@ -924,7 +937,7 @@ var CollaborationActions;
 var Events;
 
 // src/common/file.ts
-import { Schema as Schema4 } from "effect";
+import { Schema as Schema2 } from "effect";
 var defaultFileTypes = {
   images: [
     "png",
@@ -944,23 +957,131 @@ var defaultFileTypes = {
     "md"
   ]
 };
-var FileInfoSchema = Schema4.Struct({
-  name: Schema4.String,
-  type: Schema4.String,
-  url: Schema4.optional(Schema4.String),
-  cid: Schema4.optional(Schema4.String)
+var FileInfoSchema = Schema2.Struct({
+  name: Schema2.String,
+  type: Schema2.String,
+  url: Schema2.optional(Schema2.String),
+  cid: Schema2.optional(Schema2.String)
 });
 
 // src/common/layout.ts
 import { Schema as Schema5 } from "effect";
 
-// src/plugin-intent/IntentPlugin.ts
-var IntentPlugin = () => definePlugin({
-  id: INTENT_PLUGIN,
+// src/plugin-intent/actions.ts
+import { Schema as Schema4 } from "effect";
+
+// src/plugin-intent/intent.ts
+import { Schema as Schema3 } from "effect";
+var createIntent = (schema, data = {}, params = {}) => {
+  const _ = Schema3.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 = Schema3.Union(Schema3.String, Schema3.mutable(Schema3.Tuple(Schema3.String, Schema3.mutable(Schema3.Struct({
+  ns: Schema3.String,
+  count: Schema3.optional(Schema3.Number),
+  defaultValue: Schema3.optional(Schema3.String)
+})))));
+
+// src/plugin-intent/meta.ts
+var meta = {
+  id: "dxos.org/plugin/intent",
   name: "Intent"
-}, [
+};
+
+// src/plugin-intent/actions.ts
+(function(IntentAction2) {
+  class Track extends Schema4.TaggedClass()(`${meta.id}/action/track`, {
+    input: Schema4.Struct({
+      intents: Schema4.Array(Schema4.String),
+      error: Schema4.optional(Schema4.String)
+    }),
+    output: Schema4.Void
+  }) {
+  }
+  IntentAction2.Track = Track;
+  class ShowUndo extends Schema4.TaggedClass()(`${meta.id}/action/show-undo`, {
+    input: Schema4.Struct({
+      message: Label
+    }),
+    output: Schema4.Void
+  }) {
+  }
+  IntentAction2.ShowUndo = ShowUndo;
+})(IntentAction || (IntentAction = {}));
+var IntentAction;
+
+// src/plugin-intent/errors.ts
+function _define_property4(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+var BaseError = class extends Error {
+  constructor(code, message, context) {
+    super(message ?? code, {
+      cause: context
+    }), _define_property4(this, "code", void 0), _define_property4(this, "context", void 0), 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);
+  }
+};
+
+// src/plugin-intent/IntentPlugin.ts
+var IntentPlugin = definePlugin(meta, () => [
   defineModule({
-    id: `${INTENT_PLUGIN}/module/dispatcher`,
+    id: `${meta.id}/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.
@@ -968,15 +1089,14 @@ var IntentPlugin = () => definePlugin({
     activatesAfter: [
       Events.DispatcherReady
     ],
-    activate: lazy(() => import("./intent-dispatcher-6CYNGPSW.mjs"))
+    activate: lazy(() => import("./intent-dispatcher-SAPOKSLZ.mjs"))
   })
 ]);
 
 // src/common/layout.ts
 var LAYOUT_PLUGIN = "dxos.org/plugin/layout";
-var LAYOUT_ACTION = `${LAYOUT_PLUGIN}/action`;
 (function(LayoutAction2) {
-  LayoutAction2.UPDATE_LAYOUT = `${LAYOUT_ACTION}/update-layout`;
+  LayoutAction2.UPDATE_LAYOUT = `${LAYOUT_PLUGIN}/action/update-layout`;
   class UpdateLayout extends Schema5.TaggedClass()(LayoutAction2.UPDATE_LAYOUT, {
     input: Schema5.Struct({
       part: Schema5.String.annotations({
@@ -1338,7 +1458,7 @@ var createDispatcher = (getResolvers, { executionLimit = EXECUTION_LIMIT, histor
   const handleIntent = (intent) => Effect3.gen(function* () {
     const candidates = getResolvers().filter((resolver) => resolver.intent._tag === intent.id).filter((resolver) => !resolver.filter || resolver.filter(intent.data)).toSorted(byPosition);
     if (candidates.length === 0) {
-      yield* Effect3.fail(new NoResolversError(intent.id));
+      return yield* Effect3.fail(new NoResolversError(intent.id));
     }
     const effect = candidates[0].resolve(intent.data, intent.undo ?? false);
     const result = Effect3.isEffect(effect) ? yield* effect : yield* Effect3.promise(async () => effect);
@@ -1350,7 +1470,7 @@ var createDispatcher = (getResolvers, { executionLimit = EXECUTION_LIMIT, histor
   const dispatch = (intentChain, depth = 0) => {
     return Effect3.gen(function* () {
       if (depth > executionLimit) {
-        yield* Effect3.fail(new CycleDetectedError());
+        return yield* Effect3.fail(new CycleDetectedError());
       }
       const resultsRef = yield* Ref2.make([]);
       for (const intent of intentChain.all) {
@@ -1372,7 +1492,7 @@ var createDispatcher = (getResolvers, { executionLimit = EXECUTION_LIMIT, histor
           }
         }
         if (result2.error) {
-          yield* Effect3.fail(result2.error);
+          return yield* Effect3.fail(result2.error);
         }
       }
       const results = yield* resultsRef.get;
@@ -1401,7 +1521,7 @@ var createDispatcher = (getResolvers, { executionLimit = EXECUTION_LIMIT, histor
     })).catch((error) => {
       log3.catch(error, void 0, {
         F: __dxlog_file3,
-        L: 270,
+        L: 271,
         S: void 0,
         C: (f, a) => f(...a)
       });
@@ -1454,7 +1574,7 @@ var createDispatcher = (getResolvers, { executionLimit = EXECUTION_LIMIT, histor
 };
 var defaultEffect = () => Effect3.fail(new Error("Intent runtime not ready"));
 var defaultPromise = () => Effect3.runPromise(defaultEffect());
-var intent_dispatcher_default = (context) => {
+var intent_dispatcher_default = ((context) => {
   const state = live2({
     dispatch: defaultEffect,
     dispatchPromise: defaultPromise,
@@ -1476,7 +1596,7 @@ var intent_dispatcher_default = (context) => {
   state.undo = undo;
   state.undoPromise = undoPromise;
   return contributes(Capabilities.IntentDispatcher, state);
-};
+});
 
 export {
   defineCapability,
@@ -1503,19 +1623,18 @@ export {
   createIntent,
   chain,
   Label,
-  INTENT_PLUGIN,
-  INTENT_ACTION,
   IntentAction,
+  BaseError,
+  NoResolversError,
+  CycleDetectedError,
   createResolver,
   createDispatcher,
   intent_dispatcher_default,
   IntentPlugin,
-  LAYOUT_PLUGIN,
-  LAYOUT_ACTION,
   LayoutAction,
   createSurface,
   ResourceKey,
   ResourceLanguage,
   Resource
 };
-//# sourceMappingURL=chunk-ZEZ4FVEU.mjs.map
+//# sourceMappingURL=chunk-SOVTUUAY.mjs.map