@dxos/app-framework 0.8.4-main.ead640a → 0.8.4-main.ef1bc66f44

package/dist/lib/node-esm/chunk-DHSHRYIB.mjs

@@ -0,0 +1,171 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  UndoOperation
+} from "./chunk-J2PHTRHC.mjs";
+import {
+  __export
+} from "./chunk-HSLMI22Q.mjs";
+
+// src/plugin-operation/history/errors.ts
+import { OperationError } from "@dxos/operation";
+var EmptyHistoryError = class extends OperationError {
+  constructor() {
+    super("EMPTY_HISTORY", "Cannot undo: history is empty.");
+  }
+};
+
+// src/plugin-operation/history/undo-mapping.ts
+var undo_mapping_exports = {};
+__export(undo_mapping_exports, {
+  make: () => make,
+  resolveMessage: () => resolveMessage
+});
+var make = (props) => props;
+var resolveMessage = (message, input, output) => {
+  if (message === void 0) {
+    return void 0;
+  }
+  if (typeof message === "function") {
+    return message(input, output);
+  }
+  return message;
+};
+
+// src/plugin-operation/history/undo-registry.ts
+var undo_registry_exports = {};
+__export(undo_registry_exports, {
+  make: () => make2
+});
+var make2 = (getMappings) => {
+  const lookup = (operation) => {
+    const mappings = getMappings();
+    const mapping = mappings.find((m) => m.operation.meta.key === operation.meta.key);
+    if (!mapping) {
+      return void 0;
+    }
+    return {
+      inverse: mapping.inverse,
+      deriveContext: mapping.deriveContext,
+      message: mapping.message
+    };
+  };
+  return {
+    lookup
+  };
+};
+
+// src/plugin-operation/history/history-tracker.ts
+var history_tracker_exports = {};
+__export(history_tracker_exports, {
+  make: () => make3
+});
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import { runAndForwardErrors } from "@dxos/effect";
+import { log } from "@dxos/log";
+var __dxlog_file = "/__w/dxos/dxos/packages/sdk/app-framework/src/plugin-operation/history/history-tracker.ts";
+var HISTORY_LIMIT = 100;
+var make3 = (invoker, undoRegistry) => {
+  const history = [];
+  const handleInvocation = (event) => {
+    const mapping = undoRegistry.lookup(event.operation);
+    if (!mapping) {
+      return;
+    }
+    const inverseInput = mapping.deriveContext(event.input, event.output);
+    if (inverseInput === void 0) {
+      log("operation not undoable", {
+        key: event.operation.meta.key
+      }, {
+        F: __dxlog_file,
+        L: 58,
+        S: void 0,
+        C: (f, a) => f(...a)
+      });
+      return;
+    }
+    const entry = {
+      operation: event.operation,
+      input: event.input,
+      output: event.output,
+      inverse: mapping.inverse,
+      inverseInput,
+      timestamp: event.timestamp
+    };
+    history.push(entry);
+    log("history entry added", {
+      key: event.operation.meta.key,
+      historyLength: history.length
+    }, {
+      F: __dxlog_file,
+      L: 72,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+    if (history.length > HISTORY_LIMIT) {
+      history.splice(0, history.length - HISTORY_LIMIT);
+    }
+    const resolvedMessage = resolveMessage(mapping.message, event.input, event.output);
+    Effect.runFork(invoker.invoke(UndoOperation.ShowUndo, {
+      message: resolvedMessage
+    }));
+  };
+  Effect.runFork(Stream.fromPubSub(invoker.invocations).pipe(Stream.runForEach((event) => Effect.sync(() => handleInvocation(event)))));
+  const undo = () => {
+    return Effect.gen(function* () {
+      const entry = history.pop();
+      if (!entry) {
+        return yield* Effect.fail(new EmptyHistoryError());
+      }
+      log("undoing operation", {
+        key: entry.operation.meta.key,
+        inverseKey: entry.inverse.meta.key
+      }, {
+        F: __dxlog_file,
+        L: 102,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      yield* invoker._invokeCore(entry.inverse, entry.inverseInput);
+      log("undo completed", {
+        key: entry.operation.meta.key
+      }, {
+        F: __dxlog_file,
+        L: 107,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    });
+  };
+  const undoPromise = async () => {
+    return runAndForwardErrors(undo()).then(() => ({})).catch((error) => {
+      log.catch(error, void 0, {
+        F: __dxlog_file,
+        L: 115,
+        S: void 0,
+        C: (f, a) => f(...a)
+      });
+      return {
+        error
+      };
+    });
+  };
+  const canUndo = () => {
+    return history.length > 0;
+  };
+  return {
+    undo,
+    undoPromise,
+    canUndo
+  };
+};
+
+export {
+  EmptyHistoryError,
+  undo_mapping_exports,
+  make2 as make,
+  undo_registry_exports,
+  make3 as make2,
+  history_tracker_exports
+};
+//# sourceMappingURL=chunk-DHSHRYIB.mjs.map

package/dist/lib/node-esm/chunk-DHSHRYIB.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/plugin-operation/history/errors.ts", "../../../src/plugin-operation/history/undo-mapping.ts", "../../../src/plugin-operation/history/undo-registry.ts", "../../../src/plugin-operation/history/history-tracker.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport { OperationError } from '@dxos/operation';\n\nexport class EmptyHistoryError extends OperationError {\n  constructor() {\n    super('EMPTY_HISTORY', 'Cannot undo: history is empty.');\n  }\n}\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport type { Operation } from '@dxos/operation';\n\n/**\n * Label type for translatable text (canonical definition in @dxos/app-toolkit).\n */\ntype Label = string | [string, { ns: string; count?: number; defaultValue?: string }];\n\n/**\n * Extract the input type from an OperationDefinition.\n */\nexport type InputOf<T> = T extends Operation.Definition<infer I, any> ? I : never;\n\n/**\n * Extract the output type from an OperationDefinition.\n */\nexport type OutputOf<T> = T extends Operation.Definition<any, infer O> ? O : never;\n\n/**\n * Message provider for undo toast.\n * Can be a static Label or a function that derives the message from input/output.\n */\nexport type MessageProvider<Op extends Operation.Definition<any, any>> =\n  | Label\n  | ((input: InputOf<Op>, output: OutputOf<Op>) => Label);\n\n/**\n * Undo mapping that links a forward operation to its inverse.\n * Type parameters ensure deriveContext has correctly typed arguments.\n *\n * @template Op - The forward operation definition type.\n * @template Inv - The inverse operation definition type.\n */\nexport interface UndoMapping<\n  Op extends Operation.Definition<any, any> = Operation.Definition<any, any>,\n  Inv extends Operation.Definition<any, any> = Operation.Definition<any, any>,\n> {\n  /** The forward operation. */\n  readonly operation: Op;\n\n  /** The inverse operation to invoke for undo. */\n  readonly inverse: Inv;\n\n  /**\n   * Derives the input for the inverse operation from the forward operation's input and output.\n   * @param input - The input that was passed to the forward operation.\n   * @param output - The output that was returned by the forward operation.\n   * @returns The input to pass to the inverse operation, or undefined to indicate the operation is not undoable.\n   */\n  readonly deriveContext: (input: InputOf<Op>, output: OutputOf<Op>) => InputOf<Inv> | undefined;\n\n  /**\n   * Optional message to show in the undo toast.\n   * Can be a static Label or a function that derives the message from input/output.\n   */\n  readonly message?: MessageProvider<Op>;\n}\n\n/**\n * Props for creating an UndoMapping.\n */\nexport interface UndoMappingProps<\n  Op extends Operation.Definition<any, any>,\n  Inv extends Operation.Definition<any, any>,\n> {\n  /** The forward operation. */\n  operation: Op;\n\n  /** The inverse operation to invoke for undo. */\n  inverse: Inv;\n\n  /**\n   * Derives the input for the inverse operation from the forward operation's input and output.\n   * Return undefined to indicate the operation is not undoable.\n   */\n  deriveContext: (input: InputOf<Op>, output: OutputOf<Op>) => InputOf<Inv> | undefined;\n\n  /**\n   * Optional message to show in the undo toast.\n   * Can be a static Label or a function that derives the message from input/output.\n   */\n  message?: MessageProvider<Op>;\n}\n\n/**\n * Creates a type-safe undo mapping.\n *\n * @example\n * ```ts\n * // Static message\n * const mapping = UndoMapping.make({\n *   operation: DeleteThread,\n *   inverse: RestoreThread,\n *   deriveContext: (input, output) => ({\n *     thread: output.thread,\n *     anchor: output.anchor,\n *   }),\n *   message: ['thread deleted label', { ns: '@dxos/plugin-thread' }],\n * });\n *\n * // Dynamic message based on input/output\n * const mapping = UndoMapping.make({\n *   operation: RemoveObjects,\n *   inverse: RestoreObjects,\n *   deriveContext: (_input, output) => output,\n *   message: (input, _output) =>\n *     input.objects.length === 1\n *       ? ['object deleted label', { ns: getTypename(input.objects[0]) }]\n *       : ['objects deleted label', { ns: '@dxos/plugin-space' }],\n * });\n * ```\n */\nexport const make = <Op extends Operation.Definition<any, any>, Inv extends Operation.Definition<any, any>>(\n  props: UndoMappingProps<Op, Inv>,\n): UndoMapping<Op, Inv> => props;\n\n/**\n * Resolves a message provider to a Label.\n */\nexport const resolveMessage = <Op extends Operation.Definition<any, any>>(\n  message: MessageProvider<Op> | undefined,\n  input: InputOf<Op>,\n  output: OutputOf<Op>,\n): Label | undefined => {\n  if (message === undefined) {\n    return undefined;\n  }\n  if (typeof message === 'function') {\n    return message(input, output);\n  }\n  return message;\n};\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport type { Operation } from '@dxos/operation';\n\nimport type * as UndoMapping from './undo-mapping';\n\n//\n// Public Interface\n//\n\n/**\n * Lookup result from UndoRegistry.\n */\nexport type UndoMappingResult = {\n  inverse: Operation.Definition<any, any>;\n  /** Returns undefined to indicate the operation is not undoable. */\n  deriveContext: (input: any, output: any) => any | undefined;\n  /** Message provider - may be a static Label or a function. */\n  message?: UndoMapping.MessageProvider<Operation.Definition<any, any>>;\n};\n\n/**\n * UndoRegistry interface - looks up inverse operations.\n */\nexport interface UndoRegistry {\n  lookup: (operation: Operation.Definition<any, any>) => UndoMappingResult | undefined;\n}\n\n//\n// Factory\n//\n\n/**\n * Creates an UndoRegistry that looks up inverse operations.\n */\nexport const make = (getMappings: () => UndoMapping.UndoMapping[]): UndoRegistry => {\n  const lookup = (operation: Operation.Definition<any, any>): UndoMappingResult | undefined => {\n    const mappings = getMappings();\n    const mapping = mappings.find((m) => m.operation.meta.key === operation.meta.key);\n    if (!mapping) {\n      return undefined;\n    }\n\n    return {\n      inverse: mapping.inverse,\n      deriveContext: mapping.deriveContext,\n      message: mapping.message,\n    };\n  };\n\n  return { lookup };\n};\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Effect from 'effect/Effect';\nimport * as Stream from 'effect/Stream';\n\nimport { runAndForwardErrors } from '@dxos/effect';\nimport { log } from '@dxos/log';\nimport { type OperationInvoker } from '@dxos/operation';\n\nimport { UndoOperation } from '../../common';\n\nimport { EmptyHistoryError } from './errors';\nimport type { HistoryEntry } from './types';\nimport { resolveMessage } from './undo-mapping';\nimport type { UndoRegistry } from './undo-registry';\n\nconst HISTORY_LIMIT = 100;\n\n//\n// Public Interface\n//\n\n/**\n * HistoryTracker interface - tracks operation history and provides undo.\n */\nexport interface HistoryTracker {\n  undo: () => Effect.Effect<void, Error>;\n  undoPromise: () => Promise<{ error?: Error }>;\n  canUndo: () => boolean;\n}\n\n//\n// Factory\n//\n\n/**\n * Creates a HistoryTracker that subscribes to invocation events and provides undo.\n */\nexport const make = (\n  invoker: OperationInvoker.OperationInvokerInternal,\n  undoRegistry: UndoRegistry,\n): HistoryTracker => {\n  const history: HistoryEntry[] = [];\n\n  // Subscribe to invocation stream.\n  const handleInvocation = (event: OperationInvoker.InvocationEvent) => {\n    const mapping = undoRegistry.lookup(event.operation);\n    if (!mapping) {\n      // Operation is not undoable, skip.\n      return;\n    }\n\n    const inverseInput = mapping.deriveContext(event.input, event.output);\n    if (inverseInput === undefined) {\n      // Operation is conditionally not undoable (deriveContext returned undefined).\n      log('operation not undoable', { key: event.operation.meta.key });\n      return;\n    }\n\n    const entry: HistoryEntry = {\n      operation: event.operation,\n      input: event.input,\n      output: event.output,\n      inverse: mapping.inverse,\n      inverseInput,\n      timestamp: event.timestamp,\n    };\n\n    history.push(entry);\n    log('history entry added', { key: event.operation.meta.key, historyLength: history.length });\n\n    // Trim history if it exceeds limit.\n    if (history.length > HISTORY_LIMIT) {\n      history.splice(0, history.length - HISTORY_LIMIT);\n    }\n\n    // Show undo toast (resolve message if it's a function).\n    const resolvedMessage = resolveMessage(mapping.message, event.input, event.output);\n    Effect.runFork(\n      invoker.invoke(UndoOperation.ShowUndo, {\n        message: resolvedMessage,\n      }),\n    );\n  };\n\n  // Fork a fiber to consume the invocation stream.\n  Effect.runFork(\n    Stream.fromPubSub(invoker.invocations).pipe(\n      Stream.runForEach((event) => Effect.sync(() => handleInvocation(event))),\n    ),\n  );\n\n  const undo = (): Effect.Effect<void, Error> => {\n    return Effect.gen(function* () {\n      const entry = history.pop();\n      if (!entry) {\n        return yield* Effect.fail(new EmptyHistoryError());\n      }\n\n      log('undoing operation', { key: entry.operation.meta.key, inverseKey: entry.inverse.meta.key });\n\n      // Use _invokeCore to skip event emission (avoid undo-of-undo loops).\n      yield* invoker._invokeCore(entry.inverse, entry.inverseInput);\n\n      log('undo completed', { key: entry.operation.meta.key });\n    });\n  };\n\n  const undoPromise = async (): Promise<{ error?: Error }> => {\n    return runAndForwardErrors(undo())\n      .then(() => ({}))\n      .catch((error) => {\n        log.catch(error);\n        return { error };\n      });\n  };\n\n  const canUndo = (): boolean => {\n    return history.length > 0;\n  };\n\n  return {\n    undo,\n    undoPromise,\n    canUndo,\n  };\n};\n"],
+  "mappings": "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",
+  "names": ["OperationError", "EmptyHistoryError", "OperationError", "make", "props", "resolveMessage", "message", "input", "output", "undefined", "make", "make", "getMappings", "lookup", "operation", "mappings", "mapping", "find", "m", "meta", "key", "undefined", "inverse", "deriveContext", "message", "make", "Effect", "Stream", "runAndForwardErrors", "log", "HISTORY_LIMIT", "make", "invoker", "undoRegistry", "history", "handleInvocation", "event", "mapping", "lookup", "operation", "inverseInput", "deriveContext", "input", "output", "undefined", "log", "key", "meta", "entry", "inverse", "timestamp", "push", "historyLength", "length", "splice", "resolvedMessage", "resolveMessage", "message", "Effect", "runFork", "invoke", "UndoOperation", "ShowUndo", "fromPubSub", "invocations", "pipe", "runForEach", "sync", "undo", "gen", "pop", "fail", "EmptyHistoryError", "inverseKey", "_invokeCore", "undoPromise", "runAndForwardErrors", "then", "catch", "error", "canUndo"]
+}

package/dist/lib/node-esm/chunk-DZ2XLAGI.mjs

@@ -0,0 +1,146 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  getModuleTag
+} from "./chunk-64IMLAS2.mjs";
+import {
+  __export
+} from "./chunk-HSLMI22Q.mjs";
+
+// src/core/plugin.ts
+var plugin_exports = {};
+__export(plugin_exports, {
+  PluginModuleTypeId: () => PluginModuleTypeId,
+  PluginTypeId: () => PluginTypeId,
+  Service: () => Service,
+  activate: () => activate,
+  addModule: () => addModule,
+  define: () => define,
+  isPlugin: () => isPlugin,
+  isPluginModule: () => isPluginModule,
+  make: () => make,
+  reset: () => reset
+});
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Pipeable from "effect/Pipeable";
+import { invariant } from "@dxos/invariant";
+var __dxlog_file = "/__w/dxos/dxos/packages/sdk/app-framework/src/core/plugin.ts";
+var Service = class extends Context.Tag("@dxos/app-framework/PluginManager")() {
+};
+var activate = (event) => Effect.flatMap(Service, (manager) => manager.activate(event));
+var reset = (event) => Effect.flatMap(Service, (manager) => manager.reset(event));
+var computeModuleId = (pluginId, moduleName) => {
+  return `${pluginId}/module/${moduleName}`;
+};
+var PluginModuleTypeId = Symbol.for("@dxos/app-framework/PluginModule");
+var isPluginModule = (value) => {
+  return typeof value === "object" && value !== null && PluginModuleTypeId in value;
+};
+var PluginModuleImpl = class {
+  [PluginModuleTypeId] = PluginModuleTypeId;
+  id;
+  activatesOn;
+  activatesBefore;
+  activatesAfter;
+  activate;
+  constructor(options) {
+    this.id = options.id;
+    this.activatesOn = options.activatesOn;
+    this.activatesBefore = options.activatesBefore;
+    this.activatesAfter = options.activatesAfter;
+    this.activate = options.activate;
+  }
+};
+var PluginTypeId = Symbol.for("@dxos/app-framework/Plugin");
+var isPlugin = (value) => {
+  return typeof value === "object" && value !== null && PluginTypeId in value;
+};
+var PluginImpl = class {
+  _meta;
+  _modules;
+  [PluginTypeId] = PluginTypeId;
+  constructor(_meta, _modules) {
+    this._meta = _meta;
+    this._modules = _modules;
+  }
+  get meta() {
+    return this._meta;
+  }
+  get modules() {
+    return this._modules;
+  }
+};
+var PluginBuilderImpl = class {
+  meta;
+  _modules = [];
+  constructor(meta) {
+    this.meta = meta;
+  }
+  get modules() {
+    return this._modules;
+  }
+  addModule(moduleOptions) {
+    this._modules.push(moduleOptions);
+    return this;
+  }
+  pipe() {
+    return Pipeable.pipeArguments(this, arguments);
+  }
+};
+var define = (meta) => new PluginBuilderImpl(meta);
+function addModule(moduleOptionsOrBuilder, moduleOptions) {
+  if (moduleOptions !== void 0) {
+    return moduleOptionsOrBuilder.addModule(moduleOptions);
+  }
+  const moduleOpts = moduleOptionsOrBuilder;
+  return (builder) => builder.addModule(moduleOpts);
+}
+var resolveModule = (meta, module, options) => {
+  const moduleOptions = typeof module === "function" ? module(options) : module;
+  const id = Option.fromNullable(moduleOptions.id).pipe(Option.match({
+    onNone: () => {
+      const exportName = getModuleTag(moduleOptions.activate);
+      invariant(exportName, `Plugin module missing name. Plugin: ${meta.id}`, {
+        F: __dxlog_file,
+        L: 300,
+        S: void 0,
+        A: [
+          "exportName",
+          "`Plugin module missing name. Plugin: ${meta.id}`"
+        ]
+      });
+      return computeModuleId(meta.id, exportName);
+    },
+    onSome: (id2) => computeModuleId(meta.id, id2)
+  }));
+  return new PluginModuleImpl({
+    ...moduleOptions,
+    id
+  });
+};
+function make(builder) {
+  const meta = builder.meta;
+  const factory = (options) => {
+    const modules = builder.modules.map((module) => resolveModule(meta, module, options));
+    return new PluginImpl(meta, modules);
+  };
+  return Object.assign(factory, {
+    meta
+  });
+}
+
+export {
+  Service,
+  activate,
+  reset,
+  PluginModuleTypeId,
+  isPluginModule,
+  PluginTypeId,
+  isPlugin,
+  define,
+  addModule,
+  make,
+  plugin_exports
+};
+//# sourceMappingURL=chunk-DZ2XLAGI.mjs.map

package/dist/lib/node-esm/chunk-DZ2XLAGI.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/core/plugin.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Context from 'effect/Context';\nimport * as Effect from 'effect/Effect';\nimport * as Option from 'effect/Option';\nimport * as Pipeable from 'effect/Pipeable';\n\nimport { invariant } from '@dxos/invariant';\n\nimport type * as ActivationEvent from './activation-event';\nimport * as Capability from './capability';\nimport type * as PluginManager from './plugin-manager';\n\n//\n// Plugin Service Layer\n//\n\n/**\n * Effect Context.Tag for accessing PluginManager via the Effect layer system.\n * This allows lifecycle operations to access the plugin manager without having it passed as an argument.\n */\nexport class Service extends Context.Tag('@dxos/app-framework/PluginManager')<Service, PluginManager.PluginManager>() {}\n\n//\n// Lifecycle Functions\n//\n\n/**\n * Activates plugins based on the activation event.\n * Accesses the PluginManager via the Effect layer system.\n * @param event The activation event.\n * @returns Whether the activation was successful.\n */\nexport const activate = (event: ActivationEvent.ActivationEvent): Effect.Effect<boolean, Error, Service> =>\n  Effect.flatMap(Service, (manager) => manager.activate(event));\n\n/**\n * Re-activates the modules that were activated by the event.\n * Accesses the PluginManager via the Effect layer system.\n * @param event The activation event.\n * @returns Whether the reset was successful.\n */\nexport const reset = (event: ActivationEvent.ActivationEvent): Effect.Effect<boolean, Error, Service> =>\n  Effect.flatMap(Service, (manager) => manager.reset(event));\n\n/**\n * Computes a module ID from plugin ID and export name.\n */\nconst computeModuleId = (pluginId: string, moduleName: string): string => {\n  return `${pluginId}/module/${moduleName}`;\n};\n\n/**\n * Identifier denoting a PluginModule.\n */\nexport const PluginModuleTypeId: unique symbol = Symbol.for('@dxos/app-framework/PluginModule');\nexport type PluginModuleTypeId = typeof PluginModuleTypeId;\n\n/**\n * Type guard to check if a value is a PluginModule.\n */\nexport const isPluginModule = (value: unknown): value is PluginModule => {\n  return typeof value === 'object' && value !== null && PluginModuleTypeId in value;\n};\n\n/**\n * A unit of containment of modular functionality that can be provided to an application.\n * Activation of a module is async allowing for code to split and loaded lazily.\n */\nexport interface PluginModule {\n  readonly [PluginModuleTypeId]: PluginModuleTypeId;\n  /**\n   * Unique id of the module.\n   */\n  id: string;\n\n  /**\n   * Events for which the module will be activated.\n   */\n  activatesOn: ActivationEvent.Events;\n\n  /**\n   * Events which the plugin depends on being activated.\n   * Plugin is marked as needing reset a plugin activated by a dependent event is removed.\n   * Events are automatically activated before activation of the plugin.\n   */\n  activatesBefore?: ActivationEvent.ActivationEvent[];\n\n  /**\n   * Events which this plugin triggers upon activation.\n   */\n  activatesAfter?: ActivationEvent.ActivationEvent[];\n\n  /**\n   * Called when the module is activated.\n   * CapabilityManager is accessed via the Effect layer system (Capability.Service).\n   * PluginManager is accessed via Plugin.Service.\n   * @param props Optional props passed to the module.\n   * @returns The capabilities of the module.\n   */\n  activate: (props?: any) => Effect.Effect<Capability.ModuleReturn, Error, Capability.Service | Service | never>;\n}\n\nexport type PluginModuleOptions = Omit<PluginModule, 'id' | typeof PluginModuleTypeId> & { id?: string };\n\nclass PluginModuleImpl implements PluginModule {\n  readonly [PluginModuleTypeId]: PluginModuleTypeId = PluginModuleTypeId;\n  readonly id: PluginModule['id'];\n  readonly activatesOn: PluginModule['activatesOn'];\n  readonly activatesBefore?: PluginModule['activatesBefore'];\n  readonly activatesAfter?: PluginModule['activatesAfter'];\n  readonly activate: PluginModule['activate'];\n\n  constructor(options: Omit<PluginModule, typeof PluginModuleTypeId>) {\n    this.id = options.id;\n    this.activatesOn = options.activatesOn;\n    this.activatesBefore = options.activatesBefore;\n    this.activatesAfter = options.activatesAfter;\n    this.activate = options.activate;\n  }\n}\n\nexport type Meta = {\n  /**\n   * Globally unique ID.\n   *\n   * Expected to be in the form of a valid URL.\n   *\n   * @example dxos.org/plugin/example\n   */\n  id: string;\n\n  /**\n   * Human-readable name.\n   */\n  name: string;\n\n  /**\n   * Short description of plugin functionality.\n   */\n  description?: string;\n\n  /**\n   * URL of home page.\n   */\n  homePage?: string;\n\n  /**\n   * URL of source code.\n   */\n  source?: string;\n\n  /**\n   * URL of screenshot.\n   */\n  screenshots?: string[];\n\n  /**\n   * Tags to help categorize the plugin.\n   */\n  tags?: string[];\n\n  /**\n   * A grep-able symbol string which can be resolved to an icon asset by @ch-ui/icons, via @ch-ui/vite-plugin-icons.\n   */\n  icon?: string;\n\n  /**\n   * Icon hue (ChromaticPalette).\n   */\n  iconHue?: string;\n};\n\n/**\n * Identifier denoting a Plugin.\n */\nexport const PluginTypeId: unique symbol = Symbol.for('@dxos/app-framework/Plugin');\nexport type PluginTypeId = typeof PluginTypeId;\n\n/**\n * Type guard to check if a value is a Plugin.\n */\nexport const isPlugin = (value: unknown): value is Plugin => {\n  return typeof value === 'object' && value !== null && PluginTypeId in value;\n};\n\n/**\n * A collection of modules that are be enabled/disabled as a unit.\n * Plugins provide things such as components, state, actions, etc. to the application.\n */\nexport interface Plugin {\n  readonly [PluginTypeId]: PluginTypeId;\n  readonly meta: Readonly<Meta>;\n  readonly modules: ReadonlyArray<PluginModule>;\n}\n\n/**\n * Internal implementation of Plugin.\n * @internal\n */\nclass PluginImpl implements Plugin {\n  readonly [PluginTypeId]: PluginTypeId = PluginTypeId;\n\n  constructor(\n    private readonly _meta: Meta,\n    private readonly _modules: PluginModule[],\n  ) {}\n\n  get meta(): Readonly<Meta> {\n    return this._meta;\n  }\n\n  get modules(): ReadonlyArray<PluginModule> {\n    return this._modules;\n  }\n}\n\n/**\n * Builder interface for creating plugins incrementally.\n */\nexport interface PluginBuilder<T = void> extends Pipeable.Pipeable {\n  readonly meta: Meta;\n  readonly modules: ReadonlyArray<PluginModuleOptions | ((options: T) => PluginModuleOptions)>;\n  addModule(moduleOptions: PluginModuleOptions | ((options: T) => PluginModuleOptions)): PluginBuilder<T>;\n}\n\n/**\n * Builder implementation for creating plugins incrementally.\n */\nclass PluginBuilderImpl<T = void> implements PluginBuilder<T> {\n  readonly meta: Meta;\n  private readonly _modules: Array<PluginModuleOptions | ((options: T) => PluginModuleOptions)> = [];\n\n  constructor(meta: Meta) {\n    this.meta = meta;\n  }\n\n  get modules(): ReadonlyArray<PluginModuleOptions | ((options: T) => PluginModuleOptions)> {\n    return this._modules;\n  }\n\n  addModule(moduleOptions: PluginModuleOptions | ((options: T) => PluginModuleOptions)): PluginBuilder<T> {\n    this._modules.push(moduleOptions);\n    return this;\n  }\n\n  pipe() {\n    // eslint-disable-next-line prefer-rest-params\n    return Pipeable.pipeArguments(this, arguments);\n  }\n}\n\n/**\n * Creates a new PluginBuilder to start building a plugin.\n */\nexport const define = <T = void>(meta: Meta): PluginBuilder<T> => new PluginBuilderImpl<T>(meta);\n\n/**\n * Adds a module to a plugin builder.\n * Supports both pipeline and direct call styles.\n * Modules can be either PluginModuleOptions or functions that receive options.\n */\nexport function addModule<T>(\n  moduleOptions: PluginModuleOptions | ((options: T) => PluginModuleOptions),\n): (builder: PluginBuilder<T>) => PluginBuilder<T>;\nexport function addModule<T>(\n  builder: PluginBuilder<T>,\n  moduleOptions: PluginModuleOptions | ((options: T) => PluginModuleOptions),\n): PluginBuilder<T>;\nexport function addModule<T>(\n  moduleOptionsOrBuilder: PluginModuleOptions | ((options: T) => PluginModuleOptions) | PluginBuilder<T>,\n  moduleOptions?: PluginModuleOptions | ((options: T) => PluginModuleOptions),\n): ((builder: PluginBuilder<T>) => PluginBuilder<T>) | PluginBuilder<T> {\n  // If second arg is provided, it's the direct call style: addModule(builder, moduleOptions)\n  if (moduleOptions !== undefined) {\n    return (moduleOptionsOrBuilder as PluginBuilder<T>).addModule(moduleOptions);\n  }\n  // Otherwise it's pipeline style: addModule(moduleOptions) returns a function\n  const moduleOpts = moduleOptionsOrBuilder as PluginModuleOptions | ((options: T) => PluginModuleOptions);\n  return (builder: PluginBuilder<T>) => builder.addModule(moduleOpts);\n}\n\nexport type PluginFactory<T = void> = ((options: T) => Plugin) & { meta: Meta };\n\n/**\n * Resolves a module from either PluginModuleOptions or a function that returns PluginModuleOptions.\n */\nconst resolveModule = (\n  meta: Meta,\n  module: PluginModuleOptions | ((options: any) => PluginModuleOptions),\n  options?: any,\n): PluginModuleImpl => {\n  const moduleOptions = typeof module === 'function' ? module(options) : module;\n  const id = Option.fromNullable(moduleOptions.id).pipe(\n    Option.match({\n      onNone: () => {\n        const exportName = Capability.getModuleTag(moduleOptions.activate);\n        invariant(exportName, `Plugin module missing name. Plugin: ${meta.id}`);\n        return computeModuleId(meta.id, exportName);\n      },\n      onSome: (id) => computeModuleId(meta.id, id),\n    }),\n  );\n  return new PluginModuleImpl({ ...moduleOptions, id });\n};\n\n/**\n * Creates a Plugin from a builder.\n * Supports both pipeline and direct call styles.\n * Always returns a factory function (options: T) => Plugin.\n * When T is void, the function takes no arguments: () => Plugin.\n */\nexport function make<T>(builder: PluginBuilder<T>): PluginFactory<T>;\nexport function make<T>(builder: PluginBuilder<T>): PluginFactory<T> {\n  const meta = builder.meta;\n\n  const factory = (options: T) => {\n    const modules = builder.modules.map((module) => resolveModule(meta, module, options));\n    return new PluginImpl(meta, modules);\n  };\n\n  return Object.assign(factory, { meta });\n}\n"],
+  "mappings": ";;;;;;;;;AAAA;;;;;;;;;;;;;AAIA,YAAYA,aAAa;AACzB,YAAYC,YAAY;AACxB,YAAYC,YAAY;AACxB,YAAYC,cAAc;AAE1B,SAASC,iBAAiB;;AAcnB,IAAMC,UAAN,cAA8BC,YAAI,mCAAA,EAAA,EAAA;AAA8E;AAYhH,IAAMC,WAAW,CAACC,UAChBC,eAAQJ,SAAS,CAACK,YAAYA,QAAQH,SAASC,KAAAA,CAAAA;AAQjD,IAAMG,QAAQ,CAACH,UACbC,eAAQJ,SAAS,CAACK,YAAYA,QAAQC,MAAMH,KAAAA,CAAAA;AAKrD,IAAMI,kBAAkB,CAACC,UAAkBC,eAAAA;AACzC,SAAO,GAAGD,QAAAA,WAAmBC,UAAAA;AAC/B;AAKO,IAAMC,qBAAoCC,OAAOC,IAAI,kCAAA;AAMrD,IAAMC,iBAAiB,CAACC,UAAAA;AAC7B,SAAO,OAAOA,UAAU,YAAYA,UAAU,QAAQJ,sBAAsBI;AAC9E;AA0CA,IAAMC,mBAAN,MAAMA;EACK,CAACL,kBAAAA,IAA0CA;EAC3CM;EACAC;EACAC;EACAC;EACAjB;EAET,YAAYkB,SAAwD;AAClE,SAAKJ,KAAKI,QAAQJ;AAClB,SAAKC,cAAcG,QAAQH;AAC3B,SAAKC,kBAAkBE,QAAQF;AAC/B,SAAKC,iBAAiBC,QAAQD;AAC9B,SAAKjB,WAAWkB,QAAQlB;EAC1B;AACF;AAwDO,IAAMmB,eAA8BV,OAAOC,IAAI,4BAAA;AAM/C,IAAMU,WAAW,CAACR,UAAAA;AACvB,SAAO,OAAOA,UAAU,YAAYA,UAAU,QAAQO,gBAAgBP;AACxE;AAgBA,IAAMS,aAAN,MAAMA;;;EACK,CAACF,YAAAA,IAA8BA;EAExC,YACmBG,OACAC,UACjB;SAFiBD,QAAAA;SACAC,WAAAA;EAChB;EAEH,IAAIC,OAAuB;AACzB,WAAO,KAAKF;EACd;EAEA,IAAIG,UAAuC;AACzC,WAAO,KAAKF;EACd;AACF;AAcA,IAAMG,oBAAN,MAAMA;EACKF;EACQD,WAA+E,CAAA;EAEhG,YAAYC,MAAY;AACtB,SAAKA,OAAOA;EACd;EAEA,IAAIC,UAAsF;AACxF,WAAO,KAAKF;EACd;EAEAI,UAAUC,eAA8F;AACtG,SAAKL,SAASM,KAAKD,aAAAA;AACnB,WAAO;EACT;EAEAE,OAAO;AAEL,WAAgBC,uBAAc,MAAMC,SAAAA;EACtC;AACF;AAKO,IAAMC,SAAS,CAAWT,SAAiC,IAAIE,kBAAqBF,IAAAA;AAcpF,SAASG,UACdO,wBACAN,eAA2E;AAG3E,MAAIA,kBAAkBO,QAAW;AAC/B,WAAQD,uBAA4CP,UAAUC,aAAAA;EAChE;AAEA,QAAMQ,aAAaF;AACnB,SAAO,CAACG,YAA8BA,QAAQV,UAAUS,UAAAA;AAC1D;AAOA,IAAME,gBAAgB,CACpBd,MACAe,QACArB,YAAAA;AAEA,QAAMU,gBAAgB,OAAOW,WAAW,aAAaA,OAAOrB,OAAAA,IAAWqB;AACvE,QAAMzB,KAAY0B,oBAAaZ,cAAcd,EAAE,EAAEgB,KACxCW,aAAM;IACXC,QAAQ,MAAA;AACN,YAAMC,aAAwBC,aAAahB,cAAc5B,QAAQ;AACjE6C,gBAAUF,YAAY,uCAAuCnB,KAAKV,EAAE,IAAE;;;;;;;;;AACtE,aAAOT,gBAAgBmB,KAAKV,IAAI6B,UAAAA;IAClC;IACAG,QAAQ,CAAChC,QAAOT,gBAAgBmB,KAAKV,IAAIA,GAAAA;EAC3C,CAAA,CAAA;AAEF,SAAO,IAAID,iBAAiB;IAAE,GAAGe;IAAed;EAAG,CAAA;AACrD;AASO,SAASiC,KAAQV,SAAyB;AAC/C,QAAMb,OAAOa,QAAQb;AAErB,QAAMwB,UAAU,CAAC9B,YAAAA;AACf,UAAMO,UAAUY,QAAQZ,QAAQwB,IAAI,CAACV,WAAWD,cAAcd,MAAMe,QAAQrB,OAAAA,CAAAA;AAC5E,WAAO,IAAIG,WAAWG,MAAMC,OAAAA;EAC9B;AAEA,SAAOyB,OAAOC,OAAOH,SAAS;IAAExB;EAAK,CAAA;AACvC;",
+  "names": ["Context", "Effect", "Option", "Pipeable", "invariant", "Service", "Tag", "activate", "event", "flatMap", "manager", "reset", "computeModuleId", "pluginId", "moduleName", "PluginModuleTypeId", "Symbol", "for", "isPluginModule", "value", "PluginModuleImpl", "id", "activatesOn", "activatesBefore", "activatesAfter", "options", "PluginTypeId", "isPlugin", "PluginImpl", "_meta", "_modules", "meta", "modules", "PluginBuilderImpl", "addModule", "moduleOptions", "push", "pipe", "pipeArguments", "arguments", "define", "moduleOptionsOrBuilder", "undefined", "moduleOpts", "builder", "resolveModule", "module", "fromNullable", "match", "onNone", "exportName", "getModuleTag", "invariant", "onSome", "make", "factory", "map", "Object", "assign"]
+}

package/dist/lib/node-esm/chunk-HSLMI22Q.mjs

@@ -0,0 +1,11 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export {
+  __export
+};
+//# sourceMappingURL=chunk-HSLMI22Q.mjs.map

package/dist/lib/node-esm/chunk-HSLMI22Q.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/dist/lib/node-esm/chunk-J2PHTRHC.mjs

@@ -0,0 +1,45 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  capability_exports
+} from "./chunk-64IMLAS2.mjs";
+
+// src/common/translations.ts
+import * as Schema from "effect/Schema";
+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/common/operations.ts
+import * as Schema2 from "effect/Schema";
+import { Operation } from "@dxos/operation";
+var UNDO_NAMESPACE = "dxos.org/app-framework/undo";
+(function(UndoOperation2) {
+  UndoOperation2.ShowUndo = Operation.make({
+    meta: {
+      key: `${UNDO_NAMESPACE}/operation/show-undo`,
+      name: "Show Undo",
+      description: "Show an undo toast notification."
+    },
+    executionMode: "sync",
+    services: [
+      capability_exports.Service
+    ],
+    schema: {
+      input: Schema2.Struct({
+        message: Schema2.optional(Label.annotations({
+          description: "The message to display in the undo toast."
+        }))
+      }),
+      output: Schema2.Void
+    }
+  });
+})(UndoOperation || (UndoOperation = {}));
+var UndoOperation;
+
+export {
+  Label,
+  UndoOperation
+};
+//# sourceMappingURL=chunk-J2PHTRHC.mjs.map

package/dist/lib/node-esm/chunk-J2PHTRHC.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/common/translations.ts", "../../../src/common/operations.ts"],
+  "sourcesContent": ["//\n// Copyright 2023 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\n\n/**\n * A Label represents translatable text - either a simple string or a tuple of [key, options].\n */\nexport const Label = Schema.Union(\n  Schema.String,\n  Schema.mutable(\n    Schema.Tuple(\n      Schema.String,\n      Schema.mutable(\n        Schema.Struct({\n          ns: Schema.String,\n          count: Schema.optional(Schema.Number),\n          defaultValue: Schema.optional(Schema.String),\n        }),\n      ),\n    ),\n  ),\n);\nexport type Label = Schema.Schema.Type<typeof Label>;\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\n\nimport { Operation } from '@dxos/operation';\n\nimport { Capability } from '../core';\n\nimport { Label } from './translations';\n\nconst UNDO_NAMESPACE = 'dxos.org/app-framework/undo';\n\n/**\n * Operations related to undo/history functionality.\n */\nexport namespace UndoOperation {\n  /**\n   * Show an undo toast notification.\n   * Fired by HistoryTracker when an undoable operation is tracked.\n   */\n  export const ShowUndo = Operation.make({\n    meta: {\n      key: `${UNDO_NAMESPACE}/operation/show-undo`,\n      name: 'Show Undo',\n      description: 'Show an undo toast notification.',\n    },\n    executionMode: 'sync',\n    services: [Capability.Service],\n    schema: {\n      input: Schema.Struct({\n        message: Schema.optional(Label.annotations({ description: 'The message to display in the undo toast.' })),\n      }),\n      output: Schema.Void,\n    },\n  });\n}\n"],
+  "mappings": ";;;;;;AAIA,YAAYA,YAAY;AAKjB,IAAMC,QAAeC,aACnBC,eACAC,eACEC,aACEF,eACAC,eACEE,cAAO;EACZC,IAAWJ;EACXK,OAAcC,gBAAgBC,aAAM;EACpCC,cAAqBF,gBAAgBN,aAAM;AAC7C,CAAA,CAAA,CAAA,CAAA,CAAA;;;ACfR,YAAYS,aAAY;AAExB,SAASC,iBAAiB;AAM1B,IAAMC,iBAAiB;UAKNC,gBAAAA;iBAKFC,WAAWC,UAAUC,KAAK;IACrCC,MAAM;MACJC,KAAK,GAAGN,cAAAA;MACRO,MAAM;MACNC,aAAa;IACf;IACAC,eAAe;IACfC,UAAU;MAACC,mBAAWC;;IACtBC,QAAQ;MACNC,OAAcC,eAAO;QACnBC,SAAgBC,iBAASC,MAAMC,YAAY;UAAEX,aAAa;QAA4C,CAAA,CAAA;MACxG,CAAA;MACAY,QAAeC;IACjB;EACF,CAAA;AACF,GApBiBpB,kBAAAA,gBAAAA,CAAAA,EAAAA;;",
+  "names": ["Schema", "Label", "Union", "String", "mutable", "Tuple", "Struct", "ns", "count", "optional", "Number", "defaultValue", "Schema", "Operation", "UNDO_NAMESPACE", "UndoOperation", "ShowUndo", "Operation", "make", "meta", "key", "name", "description", "executionMode", "services", "Capability", "Service", "schema", "input", "Struct", "message", "optional", "Label", "annotations", "output", "Void"]
+}

package/dist/lib/node-esm/chunk-JAZVHID3.mjs

@@ -0,0 +1,35 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  activation_event_exports
+} from "./chunk-7OWSHPYK.mjs";
+import {
+  __export
+} from "./chunk-HSLMI22Q.mjs";
+
+// src/common/activation-events.ts
+var activation_events_exports = {};
+__export(activation_events_exports, {
+  ManagedRuntimeReady: () => ManagedRuntimeReady,
+  OperationInvokerReady: () => OperationInvokerReady,
+  SetupLayer: () => SetupLayer,
+  SetupOperationResolver: () => SetupOperationResolver,
+  SetupReactSurface: () => SetupReactSurface,
+  Startup: () => Startup
+});
+var Startup = activation_event_exports.make("dxos.org/app-framework/event/startup");
+var SetupReactSurface = activation_event_exports.make("dxos.org/app-framework/event/setup-react-surface");
+var SetupOperationResolver = activation_event_exports.make("dxos.org/app-framework/event/setup-operation-resolver");
+var SetupLayer = activation_event_exports.make("dxos.org/app-framework/event/setup-layer");
+var OperationInvokerReady = activation_event_exports.make("dxos.org/app-framework/event/operation-invoker-ready");
+var ManagedRuntimeReady = activation_event_exports.make("dxos.org/app-framework/event/managed-runtime-ready");
+
+export {
+  Startup,
+  SetupReactSurface,
+  SetupOperationResolver,
+  SetupLayer,
+  OperationInvokerReady,
+  ManagedRuntimeReady,
+  activation_events_exports
+};
+//# sourceMappingURL=chunk-JAZVHID3.mjs.map

package/dist/lib/node-esm/chunk-JAZVHID3.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/common/activation-events.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport { ActivationEvent as ActivationEvent$ } from '../core';\n\n/**\n * Fired when the app is started.\n */\nexport const Startup = ActivationEvent$.make('dxos.org/app-framework/event/startup');\n\n//\n// Dependent Events\n//\n\n/**\n * Fired to load any newly available surfaces.\n */\nexport const SetupReactSurface = ActivationEvent$.make('dxos.org/app-framework/event/setup-react-surface');\n\n/**\n * Fired before the operation invoker is activated.\n */\nexport const SetupOperationResolver = ActivationEvent$.make('dxos.org/app-framework/event/setup-operation-resolver');\n\n/**\n * Fired before the managed runtime is created.\n * Plugins should contribute their Layer capabilities before this event.\n */\nexport const SetupLayer = ActivationEvent$.make('dxos.org/app-framework/event/setup-layer');\n\n//\n// Triggered Events\n//\n\n/**\n * Fired after the operation invoker is ready.\n */\nexport const OperationInvokerReady = ActivationEvent$.make('dxos.org/app-framework/event/operation-invoker-ready');\n\n/**\n * Fired after the managed runtime is ready.\n */\nexport const ManagedRuntimeReady = ActivationEvent$.make('dxos.org/app-framework/event/managed-runtime-ready');\n"],
+  "mappings": ";;;;;;;;;AAAA;;;;;;;;;AASO,IAAMA,UAAUC,yBAAiBC,KAAK,sCAAA;AAStC,IAAMC,oBAAoBF,yBAAiBC,KAAK,kDAAA;AAKhD,IAAME,yBAAyBH,yBAAiBC,KAAK,uDAAA;AAMrD,IAAMG,aAAaJ,yBAAiBC,KAAK,0CAAA;AASzC,IAAMI,wBAAwBL,yBAAiBC,KAAK,sDAAA;AAKpD,IAAMK,sBAAsBN,yBAAiBC,KAAK,oDAAA;",
+  "names": ["Startup", "ActivationEvent$", "make", "SetupReactSurface", "SetupOperationResolver", "SetupLayer", "OperationInvokerReady", "ManagedRuntimeReady"]
+}

package/dist/lib/node-esm/chunk-OQYHRZYF.mjs

@@ -0,0 +1,81 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  capability_exports
+} from "./chunk-64IMLAS2.mjs";
+import {
+  __export
+} from "./chunk-HSLMI22Q.mjs";
+
+// src/common/capabilities.ts
+var capabilities_exports = {};
+__export(capabilities_exports, {
+  AtomRegistry: () => AtomRegistry,
+  Command: () => Command,
+  HistoryTracker: () => HistoryTracker,
+  Layer: () => Layer,
+  ManagedRuntime: () => ManagedRuntime,
+  Null: () => Null,
+  OperationInvoker: () => OperationInvoker,
+  OperationResolver: () => OperationResolver,
+  PluginManager: () => PluginManager,
+  ReactContext: () => ReactContext,
+  ReactRoot: () => ReactRoot,
+  ReactSurface: () => ReactSurface,
+  UndoMapping: () => UndoMapping,
+  UndoRegistry: () => UndoRegistry,
+  getAtomValue: () => getAtomValue,
+  subscribeAtom: () => subscribeAtom,
+  updateAtomValue: () => updateAtomValue
+});
+import * as Effect from "effect/Effect";
+var Null = capability_exports.make("dxos.org/app-framework/capability/null");
+var PluginManager = capability_exports.make("dxos.org/app-framework/capability/plugin-manager");
+var AtomRegistry = capability_exports.make("dxos.org/app-framework/capability/atom-registry");
+var ReactContext = capability_exports.make("dxos.org/app-framework/capability/react-context");
+var ReactRoot = capability_exports.make("dxos.org/app-framework/capability/react-root");
+var ReactSurface = capability_exports.make("dxos.org/app-framework/common/react-surface");
+var Command = capability_exports.make("dxos.org/app-framework/capability/command");
+var Layer = capability_exports.make("dxos.org/app-framework/capability/layer");
+var ManagedRuntime = capability_exports.make("dxos.org/app-framework/capability/managed-runtime");
+var OperationResolver = capability_exports.make("dxos.org/app-framework/capability/operation-resolver");
+var UndoMapping = capability_exports.make("dxos.org/app-framework/capability/undo-mapping");
+var OperationInvoker = capability_exports.make("dxos.org/app-framework/capability/operation-invoker");
+var UndoRegistry = capability_exports.make("dxos.org/app-framework/capability/undo-registry");
+var HistoryTracker = capability_exports.make("dxos.org/app-framework/capability/history-tracker");
+var getAtomValue = (atomCapability) => Effect.gen(function* () {
+  const registry = yield* capability_exports.get(AtomRegistry);
+  const atom = yield* capability_exports.get(atomCapability);
+  return registry.get(atom);
+});
+var updateAtomValue = (atomCapability, fn) => Effect.gen(function* () {
+  const registry = yield* capability_exports.get(AtomRegistry);
+  const atom = yield* capability_exports.get(atomCapability);
+  registry.set(atom, fn(registry.get(atom)));
+});
+var subscribeAtom = (atomCapability, callback) => Effect.gen(function* () {
+  const registry = yield* capability_exports.get(AtomRegistry);
+  const atom = yield* capability_exports.get(atomCapability);
+  return registry.subscribe(atom, () => callback(registry.get(atom)));
+});
+
+export {
+  Null,
+  PluginManager,
+  AtomRegistry,
+  ReactContext,
+  ReactRoot,
+  ReactSurface,
+  Command,
+  Layer,
+  ManagedRuntime,
+  OperationResolver,
+  UndoMapping,
+  OperationInvoker,
+  UndoRegistry,
+  HistoryTracker,
+  getAtomValue,
+  updateAtomValue,
+  subscribeAtom,
+  capabilities_exports
+};
+//# sourceMappingURL=chunk-OQYHRZYF.mjs.map

package/dist/lib/node-esm/chunk-OQYHRZYF.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/common/capabilities.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport type * as Command$ from '@effect/cli/Command';\nimport { type Atom, type Registry } from '@effect-atom/atom-react';\nimport * as Effect from 'effect/Effect';\nimport type * as Layer$ from 'effect/Layer';\nimport type * as ManagedRuntime$ from 'effect/ManagedRuntime';\nimport type { FC, PropsWithChildren } from 'react';\n\nimport type { OperationInvoker as OperationInvoker$, OperationResolver as OperationResolver$ } from '@dxos/operation';\n\nimport { Capability as Capability$, type PluginManager as PluginManager$ } from '../core';\nimport type {\n  HistoryTracker as HistoryTracker$,\n  UndoMapping as UndoMapping$,\n  UndoRegistry as UndoRegistry$,\n} from '../plugin-operation';\nimport type { Surface } from '../ui';\n\n/**\n * Null capability.\n * @category Capability\n */\nexport const Null = Capability$.make<null>('dxos.org/app-framework/capability/null');\n\n/**\n * @category Capability\n */\nexport const PluginManager = Capability$.make<PluginManager$.PluginManager>(\n  'dxos.org/app-framework/capability/plugin-manager',\n);\n\n/**\n * @category Capability\n */\nexport const AtomRegistry = Capability$.make<Registry.Registry>('dxos.org/app-framework/capability/atom-registry');\n\nexport type ReactContext = Readonly<{\n  id: string;\n  dependsOn?: string[];\n  context: FC<PropsWithChildren>;\n}>;\n\n/**\n * @category Capability\n */\nexport const ReactContext = Capability$.make<ReactContext>('dxos.org/app-framework/capability/react-context');\n\nexport type ReactRoot = Readonly<{ id: string; root: FC<PropsWithChildren> }>;\n\n/**\n * @category Capability\n */\nexport const ReactRoot = Capability$.make<ReactRoot>('dxos.org/app-framework/capability/react-root');\n\n/**\n * Surface definitions that can be either React components or Web Components.\n */\nexport type ReactSurface = Surface.Definition | readonly Surface.Definition[];\n\n/**\n * @category Capability\n */\nexport const ReactSurface = Capability$.make<ReactSurface>('dxos.org/app-framework/common/react-surface');\n\nexport type AnyCommand = Command$.Command<any, any, any, any>;\n\n/**\n * @category Capability\n */\nexport const Command = Capability$.make<AnyCommand>('dxos.org/app-framework/capability/command');\n\n/**\n * @category Capability\n */\nexport const Layer = Capability$.make<Layer$.Layer<any, any, any>>('dxos.org/app-framework/capability/layer');\n\nexport type ManagedRuntime = ManagedRuntime$.ManagedRuntime<any, any>;\n\n/**\n * @category Capability\n */\nexport const ManagedRuntime = Capability$.make<ManagedRuntime>('dxos.org/app-framework/capability/managed-runtime');\n\n//\n// Operation System Capabilities\n//\n\nexport type OperationResolver = OperationResolver$.OperationResolver<any, any, any, any>;\n\n/**\n * Handler registration for operations - contributed by plugins.\n * @category Capability\n */\nexport const OperationResolver = Capability$.make<OperationResolver[]>(\n  'dxos.org/app-framework/capability/operation-resolver',\n);\n\nexport type UndoMapping = UndoMapping$.UndoMapping;\n\n/**\n * Undo mapping registration - contributed by plugins.\n * @category Capability\n */\nexport const UndoMapping = Capability$.make<UndoMapping[]>('dxos.org/app-framework/capability/undo-mapping');\n\nexport type OperationInvoker = OperationInvoker$.OperationInvoker;\n\n/**\n * Operation invoker - provided by OperationPlugin.\n * @category Capability\n */\nexport const OperationInvoker = Capability$.make<OperationInvoker>(\n  'dxos.org/app-framework/capability/operation-invoker',\n);\n\nexport type UndoRegistry = UndoRegistry$.UndoRegistry;\n\n/**\n * Undo registry - provided by OperationPlugin.\n * @category Capability\n */\nexport const UndoRegistry = Capability$.make<UndoRegistry>('dxos.org/app-framework/capability/undo-registry');\n\nexport type HistoryTracker = HistoryTracker$.HistoryTracker;\n\n/**\n * History tracker - provided by OperationPlugin.\n * @category Capability\n */\nexport const HistoryTracker = Capability$.make<HistoryTracker>('dxos.org/app-framework/capability/history-tracker');\n\n//\n// Atom Capability Helpers\n//\n\n/**\n * Get the current value of an atom capability.\n * @example const settings = yield* Capabilities.getAtomValue(ThreadCapabilities.Settings);\n */\nexport const getAtomValue = <T>(\n  atomCapability: Capability$.InterfaceDef<Atom.Atom<T>>,\n): Effect.Effect<T, Error, Capability$.Service> =>\n  Effect.gen(function* () {\n    const registry = yield* Capability$.get(AtomRegistry);\n    const atom = yield* Capability$.get(atomCapability);\n    return registry.get(atom);\n  });\n\n/**\n * Update an atom capability value (requires writable atom).\n * @example yield* Capabilities.updateAtomValue(ThreadCapabilities.Settings, (s) => ({ ...s, foo: true }));\n */\nexport const updateAtomValue = <T>(\n  atomCapability: Capability$.InterfaceDef<Atom.Writable<T>>,\n  fn: (current: T) => T,\n): Effect.Effect<void, Error, Capability$.Service> =>\n  Effect.gen(function* () {\n    const registry = yield* Capability$.get(AtomRegistry);\n    const atom = yield* Capability$.get(atomCapability);\n    registry.set(atom, fn(registry.get(atom)));\n  });\n\n/**\n * Subscribe to an atom capability.\n * @example const unsubscribe = yield* Capabilities.subscribeAtom(ThreadCapabilities.Settings, (value) => ...);\n */\nexport const subscribeAtom = <T>(\n  atomCapability: Capability$.InterfaceDef<Atom.Atom<T>>,\n  callback: (value: T) => void,\n): Effect.Effect<() => void, Error, Capability$.Service> =>\n  Effect.gen(function* () {\n    const registry = yield* Capability$.get(AtomRegistry);\n    const atom = yield* Capability$.get(atomCapability);\n    return registry.subscribe(atom, () => callback(registry.get(atom)));\n  });\n"],
+  "mappings": ";;;;;;;;;AAAA;;;;;;;;;;;;;;;;;;;;AAMA,YAAYA,YAAY;AAmBjB,IAAMC,OAAOC,mBAAYC,KAAW,wCAAA;AAKpC,IAAMC,gBAAgBF,mBAAYC,KACvC,kDAAA;AAMK,IAAME,eAAeH,mBAAYC,KAAwB,iDAAA;AAWzD,IAAMG,eAAeJ,mBAAYC,KAAmB,iDAAA;AAOpD,IAAMI,YAAYL,mBAAYC,KAAgB,8CAAA;AAU9C,IAAMK,eAAeN,mBAAYC,KAAmB,6CAAA;AAOpD,IAAMM,UAAUP,mBAAYC,KAAiB,2CAAA;AAK7C,IAAMO,QAAQR,mBAAYC,KAAkC,yCAAA;AAO5D,IAAMQ,iBAAiBT,mBAAYC,KAAqB,mDAAA;AAYxD,IAAMS,oBAAoBV,mBAAYC,KAC3C,sDAAA;AASK,IAAMU,cAAcX,mBAAYC,KAAoB,gDAAA;AAQpD,IAAMW,mBAAmBZ,mBAAYC,KAC1C,qDAAA;AASK,IAAMY,eAAeb,mBAAYC,KAAmB,iDAAA;AAQpD,IAAMa,iBAAiBd,mBAAYC,KAAqB,mDAAA;AAUxD,IAAMc,eAAe,CAC1BC,mBAEOC,WAAI,aAAA;AACT,QAAMC,WAAW,OAAOlB,mBAAYmB,IAAIhB,YAAAA;AACxC,QAAMiB,OAAO,OAAOpB,mBAAYmB,IAAIH,cAAAA;AACpC,SAAOE,SAASC,IAAIC,IAAAA;AACtB,CAAA;AAMK,IAAMC,kBAAkB,CAC7BL,gBACAM,OAEOL,WAAI,aAAA;AACT,QAAMC,WAAW,OAAOlB,mBAAYmB,IAAIhB,YAAAA;AACxC,QAAMiB,OAAO,OAAOpB,mBAAYmB,IAAIH,cAAAA;AACpCE,WAASK,IAAIH,MAAME,GAAGJ,SAASC,IAAIC,IAAAA,CAAAA,CAAAA;AACrC,CAAA;AAMK,IAAMI,gBAAgB,CAC3BR,gBACAS,aAEOR,WAAI,aAAA;AACT,QAAMC,WAAW,OAAOlB,mBAAYmB,IAAIhB,YAAAA;AACxC,QAAMiB,OAAO,OAAOpB,mBAAYmB,IAAIH,cAAAA;AACpC,SAAOE,SAASQ,UAAUN,MAAM,MAAMK,SAASP,SAASC,IAAIC,IAAAA,CAAAA,CAAAA;AAC9D,CAAA;",
+  "names": ["Effect", "Null", "Capability$", "make", "PluginManager", "AtomRegistry", "ReactContext", "ReactRoot", "ReactSurface", "Command", "Layer", "ManagedRuntime", "OperationResolver", "UndoMapping", "OperationInvoker", "UndoRegistry", "HistoryTracker", "getAtomValue", "atomCapability", "gen", "registry", "get", "atom", "updateAtomValue", "fn", "set", "subscribeAtom", "callback", "subscribe"]
+}

package/dist/lib/node-esm/chunk-UEWJDI2L.mjs

@@ -0,0 +1,10 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+
+// src/context.ts
+import { createContext } from "@dxos/web-context";
+var PluginManagerContext = createContext("dxos.org/app-framework/plugin-manager");
+
+export {
+  PluginManagerContext
+};
+//# sourceMappingURL=chunk-UEWJDI2L.mjs.map

package/dist/lib/node-esm/chunk-UEWJDI2L.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/context.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport { createContext } from '@dxos/web-context';\n\nimport { type PluginManager } from './core';\n\nexport const PluginManagerContext = createContext<PluginManager.PluginManager>('dxos.org/app-framework/plugin-manager');\n"],
+  "mappings": ";;;AAIA,SAASA,qBAAqB;AAIvB,IAAMC,uBAAuBC,cAA2C,uCAAA;",
+  "names": ["createContext", "PluginManagerContext", "createContext"]
+}