@dxos/app-framework 0.8.4-main.c85a9c8dae → 0.8.4-main.d05539e30a

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

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/core/plugin-manager.ts", "../../../src/core/capability-manager.ts"],
-  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport { Atom, Registry } from '@effect-atom/atom-react';\nimport * as Array from 'effect/Array';\nimport * as Cause from 'effect/Cause';\nimport * as Deferred from 'effect/Deferred';\nimport * as Duration from 'effect/Duration';\nimport * as Effect from 'effect/Effect';\nimport * as Fiber from 'effect/Fiber';\nimport * as Function from 'effect/Function';\nimport * as HashSet from 'effect/HashSet';\nimport * as PubSub from 'effect/PubSub';\nimport * as Ref from 'effect/Ref';\n\nimport { runAndForwardErrors } from '@dxos/effect';\nimport { Performance } from '@dxos/effect';\nimport { log } from '@dxos/log';\n\nimport * as ActivationEvent from './activation-event';\nimport * as Capability from './capability';\nimport * as CapabilityManager from './capability-manager';\nimport * as Plugin from './plugin';\n\n/**\n * Identifier denoting a Manager.\n */\nexport const ManagerTypeId: unique symbol = Symbol.for('@dxos/app-framework/Manager');\nexport type ManagerTypeId = typeof ManagerTypeId;\n\nexport type ManagerOptions = {\n  pluginLoader: (id: string) => Effect.Effect<Plugin.Plugin, Error>;\n  plugins?: Plugin.Plugin[];\n  core?: string[];\n  enabled?: string[];\n  registry?: Registry.Registry;\n};\n\ntype ActivationMessage = { event: string; state: 'activating' | 'activated' | 'error'; error?: Error };\n\n/**\n * Interface for the Plugin Manager.\n */\nexport interface PluginManager {\n  readonly [ManagerTypeId]: ManagerTypeId;\n  readonly activation: PubSub.PubSub<ActivationMessage>;\n  readonly capabilities: CapabilityManager.CapabilityManager;\n  readonly registry: Registry.Registry;\n\n  readonly plugins: Atom.Atom<readonly Plugin.Plugin[]>;\n  readonly core: Atom.Atom<readonly string[]>;\n  readonly enabled: Atom.Atom<readonly string[]>;\n  readonly modules: Atom.Atom<readonly Plugin.PluginModule[]>;\n  readonly active: Atom.Atom<readonly string[]>;\n  readonly eventsFired: Atom.Atom<readonly string[]>;\n  readonly pendingReset: Atom.Atom<readonly string[]>;\n\n  getPlugins(): readonly Plugin.Plugin[];\n  getCore(): readonly string[];\n  getEnabled(): readonly string[];\n  getModules(): readonly Plugin.PluginModule[];\n  getActive(): readonly string[];\n  getEventsFired(): readonly string[];\n  getPendingReset(): readonly string[];\n\n  add(id: string): Effect.Effect<boolean, Error>;\n  enable(id: string): Effect.Effect<boolean, Error>;\n  remove(id: string): boolean;\n  disable(id: string): Effect.Effect<boolean, Error>;\n  // TODO(wittjosiah): Improve error typing.\n  activate(\n    event: ActivationEvent.ActivationEvent | string,\n    params?: { before?: string; after?: string },\n  ): Effect.Effect<boolean, Error>;\n  deactivate(id: string): Effect.Effect<boolean, Error>;\n  reset(event: ActivationEvent.ActivationEvent | string): Effect.Effect<boolean, Error>;\n}\n\n/**\n * Type guard to check if a value is a PluginManager.\n */\nexport const isManager = (value: unknown): value is PluginManager => {\n  return typeof value === 'object' && value !== null && ManagerTypeId in value;\n};\n\n/**\n * Internal implementation of PluginManager.\n */\nclass ManagerImpl implements PluginManager {\n  readonly [ManagerTypeId]: ManagerTypeId = ManagerTypeId;\n  readonly activation = Effect.runSync(PubSub.unbounded<ActivationMessage>());\n  readonly capabilities: CapabilityManager.CapabilityManager;\n  readonly registry: Registry.Registry;\n\n  private readonly _pluginsAtom: Atom.Writable<Plugin.Plugin[]>;\n  private readonly _coreAtom: Atom.Writable<string[]>;\n  private readonly _enabledAtom: Atom.Writable<string[]>;\n  private readonly _modulesAtom: Atom.Writable<Plugin.PluginModule[]>;\n  private readonly _activeAtom: Atom.Writable<string[]>;\n  private readonly _eventsFiredAtom: Atom.Writable<string[]>;\n  private readonly _pendingResetAtom: Atom.Writable<string[]>;\n  private readonly _pluginLoader: ManagerOptions['pluginLoader'];\n  private readonly _capabilities = new Map<string, Capability.Any[]>();\n  private readonly _moduleMemoMap = new Map<Plugin.PluginModule['id'], Deferred.Deferred<Capability.Any[], Error>>();\n  private readonly _moduleSemaphores = new Map<Plugin.PluginModule['id'], Effect.Semaphore>();\n  private readonly _activatingEvents = Effect.runSync(Ref.make<string[]>([]));\n  private readonly _activatingModules = Effect.runSync(Ref.make<string[]>([]));\n\n  constructor({\n    pluginLoader,\n    plugins = [],\n    core = plugins.map(({ meta }) => meta.id),\n    enabled = [],\n    registry,\n  }: ManagerOptions) {\n    this.registry = registry ?? Registry.make();\n    this.capabilities = CapabilityManager.make({\n      registry: this.registry,\n    });\n\n    this._pluginLoader = pluginLoader;\n    this._pluginsAtom = Atom.make(plugins).pipe(Atom.keepAlive);\n    this._coreAtom = Atom.make(core).pipe(Atom.keepAlive);\n    this._enabledAtom = Atom.make(enabled).pipe(Atom.keepAlive);\n    this._modulesAtom = Atom.make<Plugin.PluginModule[]>([]).pipe(Atom.keepAlive);\n    this._activeAtom = Atom.make<string[]>([]).pipe(Atom.keepAlive);\n    this._eventsFiredAtom = Atom.make<string[]>([]).pipe(Atom.keepAlive);\n    this._pendingResetAtom = Atom.make<string[]>([]).pipe(Atom.keepAlive);\n    plugins.forEach((plugin) => this._addPlugin(plugin));\n    void Effect.all([...core, ...enabled].map((id) => this.enable(id))).pipe(runAndForwardErrors);\n  }\n\n  get plugins(): Atom.Atom<readonly Plugin.Plugin[]> {\n    return this._pluginsAtom;\n  }\n\n  get core(): Atom.Atom<readonly string[]> {\n    return this._coreAtom;\n  }\n\n  /**\n   * Ids of plugins that are currently enabled.\n   */\n  get enabled(): Atom.Atom<readonly string[]> {\n    return this._enabledAtom;\n  }\n\n  /**\n   * Modules of plugins which are currently enabled.\n   */\n  get modules(): Atom.Atom<readonly Plugin.PluginModule[]> {\n    return this._modulesAtom;\n  }\n\n  /**\n   * Ids of modules which are currently active.\n   */\n  get active(): Atom.Atom<readonly string[]> {\n    return this._activeAtom;\n  }\n\n  /**\n   * Ids of events which have been fired.\n   */\n  get eventsFired(): Atom.Atom<readonly string[]> {\n    return this._eventsFiredAtom;\n  }\n\n  /**\n   * Ids of modules which are pending reset.\n   */\n  get pendingReset(): Atom.Atom<readonly string[]> {\n    return this._pendingResetAtom;\n  }\n\n  getPlugins(): readonly Plugin.Plugin[] {\n    return this._get(this._pluginsAtom);\n  }\n\n  getCore(): readonly string[] {\n    return this._get(this._coreAtom);\n  }\n\n  getEnabled(): readonly string[] {\n    return this._get(this._enabledAtom);\n  }\n\n  getModules(): readonly Plugin.PluginModule[] {\n    return this._get(this._modulesAtom);\n  }\n\n  getActive(): readonly string[] {\n    return this._get(this._activeAtom);\n  }\n\n  getEventsFired(): readonly string[] {\n    return this._get(this._eventsFiredAtom);\n  }\n\n  getPendingReset(): readonly string[] {\n    return this._get(this._pendingResetAtom);\n  }\n\n  /**\n   * Adds a plugin to the manager via the plugin loader.\n   * @param id The id of the plugin.\n   */\n  add(id: string): Effect.Effect<boolean, Error> {\n    return Effect.gen(this, function* () {\n      log('add plugin', { id });\n      const plugin = yield* this._pluginLoader(id);\n      this._addPlugin(plugin);\n      return yield* this.enable(id);\n    });\n  }\n\n  /**\n   * Enables a plugin.\n   * @param id The id of the plugin.\n   */\n  enable(id: string): Effect.Effect<boolean, Error> {\n    return Effect.gen(this, function* () {\n      log('enable plugin', { id });\n      const plugin = this._getPlugin(id);\n      if (!plugin) {\n        return false;\n      }\n\n      this._update(this._enabledAtom, (enabled) => (enabled.includes(id) ? enabled : [...enabled, id]));\n\n      plugin.modules.forEach((module) => {\n        this._addModule(module);\n        this._setPendingResetByModule(module);\n      });\n\n      log('pending reset', { events: [...this.getPendingReset()] });\n      yield* Effect.all(\n        this.getPendingReset().map((event) => this.activate(event)),\n        { concurrency: 'unbounded' },\n      );\n\n      return true;\n    });\n  }\n\n  /**\n   * Removes a plugin from the manager.\n   * @param id The id of the plugin.\n   */\n  remove(id: string): boolean {\n    log('remove plugin', { id });\n    const result = this.disable(id);\n    if (!result) {\n      return false;\n    }\n\n    this._removePlugin(id);\n    return true;\n  }\n\n  /**\n   * Disables a plugin.\n   * @param id The id of the plugin.\n   */\n  disable(id: string): Effect.Effect<boolean, Error> {\n    return Effect.gen(this, function* () {\n      log('disable plugin', { id });\n      if (this._get(this._coreAtom).includes(id)) {\n        return false;\n      }\n\n      const plugin = this._getPlugin(id);\n      if (!plugin) {\n        return false;\n      }\n\n      const enabledIndex = this._get(this._enabledAtom).findIndex((enabled) => enabled === id);\n      if (enabledIndex !== -1) {\n        this._update(this._enabledAtom, (enabled) => enabled.filter((item) => item !== id));\n        yield* this.deactivate(id);\n\n        plugin.modules.forEach((module) => {\n          this._removeModule(module.id);\n        });\n      }\n\n      return true;\n    });\n  }\n\n  /**\n   * Activates plugins based on the activation event.\n   * @param event The activation event.\n   * @returns Whether the activation was successful.\n   */\n  activate(\n    event: ActivationEvent.ActivationEvent | string,\n    params?: { before?: string; after?: string },\n  ): Effect.Effect<boolean, Error> {\n    const key = typeof event === 'string' ? event : ActivationEvent.eventKey(event);\n    return Effect.gen(this, function* () {\n      log('activating', { key, ...params });\n      yield* Ref.update(this._activatingEvents, (activating) => Array.append(activating, key));\n      const pendingIndex = this._get(this._pendingResetAtom).findIndex((event) => event === key);\n      if (pendingIndex !== -1) {\n        this._update(this._pendingResetAtom, (pending) => pending.filter((event) => event !== key));\n      }\n\n      const activatingEvents = yield* this._activatingEvents;\n      const activatingModules = yield* this._activatingModules;\n      const modules = this._getInactiveModulesByEvent(key).filter((module) => {\n        const allOf = ActivationEvent.isAllOf(module.activatesOn);\n        if (!allOf) {\n          return true;\n        }\n\n        // Check to see if all of the events in the `allOf` have been fired.\n        // An event can be considered \"fired\" if it is in the `eventsFired` list or if it is currently being activated.\n        const events = ActivationEvent.getEvents(module.activatesOn).filter(\n          (event) => ActivationEvent.eventKey(event) !== key,\n        );\n        return (\n          events.every(\n            (event) =>\n              this._get(this._eventsFiredAtom).includes(ActivationEvent.eventKey(event)) ||\n              activatingEvents.includes(ActivationEvent.eventKey(event)),\n          ) && !activatingModules.includes(module.id)\n        );\n      });\n      yield* Ref.update(this._activatingModules, (activating) =>\n        Array.appendAll(\n          activating,\n          modules.map((module) => module.id),\n        ),\n      );\n      if (modules.length === 0) {\n        log('no modules to activate', { key });\n        if (!this._get(this._eventsFiredAtom).includes(key)) {\n          this._update(this._eventsFiredAtom, (events) => [...events, key]);\n        }\n        return false;\n      }\n\n      log('activating modules', { key, modules: modules.map((module) => module.id) });\n      yield* PubSub.publish(this.activation, { event: key, state: 'activating' });\n\n      // Fire activatesBefore events.\n      const beforeEvents = Function.pipe(\n        modules,\n        Array.flatMap((module) => module.activatesBefore ?? []),\n        HashSet.fromIterable,\n        HashSet.toValues,\n        Array.filter((event) => !activatingEvents.includes(ActivationEvent.eventKey(event))),\n      );\n      yield* Function.pipe(\n        beforeEvents,\n        Array.map((event) => this.activate(event, { before: key })),\n        Effect.allWith({ concurrency: 'unbounded' }),\n        together(\n          Effect.sleep(Duration.seconds(10)).pipe(\n            Effect.andThen(\n              Effect.sync(() =>\n                log.warn('activatesBefore is taking a long time', {\n                  event: key,\n                  beforeEvents: beforeEvents.map(ActivationEvent.eventKey),\n                }),\n              ),\n            ),\n          ),\n        ),\n      );\n\n      // Concurrently triggers loading of lazy capabilities.\n      const getCapabilities = yield* Function.pipe(\n        modules,\n        Array.map((mod) => this._loadModule(mod)),\n        Effect.allWith({ concurrency: 'unbounded' }),\n        Effect.catchAll((error) => {\n          return Effect.gen(this, function* () {\n            yield* PubSub.publish(this.activation, { event: key, state: 'error', error });\n            return yield* Effect.fail(error);\n          });\n        }),\n      );\n\n      // Contribute the capabilities from the activated modules.\n      yield* Function.pipe(\n        modules,\n        Array.zip(getCapabilities),\n        Array.map(([module, capabilities]) => this._contributeCapabilities(module, capabilities)),\n        // TODO(wittjosiah): This currently can't be run in parallel.\n        //   Running this with concurrency causes races with `allOf` activation events.\n        Effect.all,\n      );\n\n      // Fire activatesAfter events.\n      const afterEvents = Function.pipe(\n        modules,\n        Array.flatMap((module) => module.activatesAfter ?? []),\n        HashSet.fromIterable,\n        HashSet.toValues,\n        Array.filter((event) => !activatingEvents.includes(ActivationEvent.eventKey(event))),\n      );\n      yield* Function.pipe(\n        afterEvents,\n        Array.map((event) => this.activate(event, { after: key })),\n        Effect.allWith({ concurrency: 'unbounded' }),\n        together(\n          Effect.sleep(Duration.seconds(10)).pipe(\n            Effect.andThen(\n              Effect.sync(() =>\n                log.warn('activatesAfter is taking a long time', {\n                  event: key,\n                  afterEvents: afterEvents.map(ActivationEvent.eventKey),\n                }),\n              ),\n            ),\n          ),\n        ),\n      );\n\n      yield* Ref.update(this._activatingEvents, (activating) => Array.filter(activating, (event) => event !== key));\n      yield* Ref.update(this._activatingModules, (activating) =>\n        Array.filter(activating, (module) => !modules.map((module) => module.id).includes(module)),\n      );\n\n      if (!this._get(this._eventsFiredAtom).includes(key)) {\n        this._update(this._eventsFiredAtom, (events) => [...events, key]);\n      }\n\n      yield* PubSub.publish(this.activation, { event: key, state: 'activated' });\n      log('activated', { key });\n\n      return true;\n    }).pipe(\n      together(\n        Effect.sleep(Duration.seconds(15)).pipe(\n          Effect.andThen(Effect.sync(() => log.warn('event activation is taking a long time', { event: key }))),\n        ),\n      ),\n      Performance.addTrackEntry({\n        name: typeof event === 'string' ? event : ActivationEvent.eventKey(event),\n        devtools: {\n          dataType: 'track-entry',\n          track: 'Event Activation',\n          trackGroup: 'Composer',\n          color: 'primary',\n        },\n      }),\n    );\n  }\n\n  /**\n   * Deactivates all of the modules for a plugin.\n   * @param id The id of the plugin.\n   * @returns Whether the deactivation was successful.\n   */\n  deactivate(id: string): Effect.Effect<boolean, Error> {\n    return Effect.gen(this, function* () {\n      const plugin = this._getPlugin(id);\n      if (!plugin) {\n        return false;\n      }\n\n      const modules = plugin.modules;\n      const results = yield* Effect.all(\n        modules.map((module) => this._deactivateModule(module)),\n        { concurrency: 'unbounded' },\n      );\n      return results.every((result) => result);\n    });\n  }\n\n  /**\n   * Re-activates the modules that were activated by the event.\n   * @param event The activation event.\n   * @returns Whether the reset was successful.\n   */\n  reset(event: ActivationEvent.ActivationEvent | string): Effect.Effect<boolean, Error> {\n    return Effect.gen(this, function* () {\n      const key = typeof event === 'string' ? event : ActivationEvent.eventKey(event);\n      log('reset', { key });\n      const modules = this._getActiveModulesByEvent(key);\n      const results = yield* Effect.all(\n        modules.map((module) => this._deactivateModule(module)),\n        { concurrency: 'unbounded' },\n      );\n\n      if (results.every((result) => result)) {\n        return yield* this.activate(key);\n      } else {\n        return false;\n      }\n    });\n  }\n\n  private _get<T>(atom: Atom.Atom<T>): T {\n    return this.registry.get(atom);\n  }\n\n  private _set<T>(atom: Atom.Writable<T>, value: T): void {\n    this.registry.set(atom, value);\n  }\n\n  private _update<T>(atom: Atom.Writable<T>, updater: (current: T) => T): void {\n    this._set(atom, updater(this._get(atom)));\n  }\n\n  private _addPlugin(plugin: Plugin.Plugin): void {\n    log('add plugin', { id: plugin.meta.id });\n    // TODO(wittjosiah): Find a way to add a warning for duplicate plugins that doesn't cause log spam.\n    this._update(this._pluginsAtom, (plugins) => (plugins.includes(plugin) ? plugins : [...plugins, plugin]));\n  }\n\n  private _removePlugin(id: string): void {\n    log('remove plugin', { id });\n    this._update(this._pluginsAtom, (plugins) => plugins.filter((plugin) => plugin.meta.id !== id));\n  }\n\n  private _addModule(module: Plugin.PluginModule): void {\n    log('add module', { id: module.id });\n    // TODO(wittjosiah): Find a way to add a warning for duplicate modules that doesn't cause log spam.\n    this._update(this._modulesAtom, (modules) => (modules.includes(module) ? modules : [...modules, module]));\n  }\n\n  private _removeModule(id: string): void {\n    log('remove module', { id });\n    this._update(this._modulesAtom, (modules) => modules.filter((module) => module.id !== id));\n  }\n\n  private _getPlugin(id: string): Plugin.Plugin | undefined {\n    return this._get(this._pluginsAtom).find((plugin) => plugin.meta.id === id);\n  }\n\n  private _getActiveModules(): Plugin.PluginModule[] {\n    const active = this._get(this._activeAtom);\n    return this._get(this._modulesAtom).filter((module) => active.includes(module.id));\n  }\n\n  private _getInactiveModules(): Plugin.PluginModule[] {\n    const active = this._get(this._activeAtom);\n    return this._get(this._modulesAtom).filter((module) => !active.includes(module.id));\n  }\n\n  private _getActiveModulesByEvent(key: string): Plugin.PluginModule[] {\n    return this._getActiveModules().filter((module) =>\n      ActivationEvent.getEvents(module.activatesOn).map(ActivationEvent.eventKey).includes(key),\n    );\n  }\n\n  private _getInactiveModulesByEvent(key: string): Plugin.PluginModule[] {\n    return this._getInactiveModules().filter((module) =>\n      ActivationEvent.getEvents(module.activatesOn).map(ActivationEvent.eventKey).includes(key),\n    );\n  }\n\n  private _setPendingResetByModule(module: Plugin.PluginModule): void {\n    const activationEvents = ActivationEvent.getEvents(module.activatesOn)\n      .map(ActivationEvent.eventKey)\n      .filter((key) => this._get(this._eventsFiredAtom).includes(key));\n\n    const pendingReset = Array.fromIterable(new Set(activationEvents)).filter((event) => {\n      const pending = this._get(this._pendingResetAtom);\n      return !pending.includes(event);\n    });\n    if (pendingReset.length > 0) {\n      log('pending reset', { events: pendingReset });\n      this._update(this._pendingResetAtom, (current) => [...current, ...pendingReset]);\n    }\n  }\n\n  private _getModuleSemaphore(moduleId: Plugin.PluginModule['id']): Effect.Semaphore {\n    let semaphore = this._moduleSemaphores.get(moduleId);\n    if (!semaphore) {\n      semaphore = Effect.runSync(Effect.makeSemaphore(1));\n      this._moduleSemaphores.set(moduleId, semaphore);\n    }\n    return semaphore;\n  }\n\n  private _loadModule = (module: Plugin.PluginModule): Effect.Effect<Capability.Any[], Error> =>\n    Effect.gen(this, function* () {\n      const semaphore = this._getModuleSemaphore(module.id);\n\n      // Atomically check-and-set under per-module semaphore to prevent race conditions.\n      const deferredToAwait = yield* Effect.gen(this, function* () {\n        const existing = this._moduleMemoMap.get(module.id);\n        if (existing) {\n          return existing;\n        }\n\n        // First caller - create deferred, store it, and start loading in background.\n        const deferred = yield* Deferred.make<Capability.Any[], Error>();\n        this._moduleMemoMap.set(module.id, deferred);\n\n        const loadEffect = Effect.gen(this, function* () {\n          log('loading module', { module: module.id });\n          const [duration, capabilities] = yield* module\n            .activate()\n            .pipe(\n              Effect.provideService(Capability.Service, this.capabilities),\n              Effect.provideService(Plugin.Service, this),\n              Effect.timed,\n            );\n          const normalized = capabilities == null ? [] : Array.isArray(capabilities) ? capabilities : [capabilities];\n          log('loaded module', {\n            module: module.id,\n            elapsed: Duration.toMillis(duration),\n            failed: false,\n          });\n          return normalized as Capability.Any[];\n        }).pipe(\n          Effect.withSpan('PluginManager._loadModule'),\n          together(\n            Effect.sleep(Duration.seconds(10)).pipe(\n              Effect.andThen(\n                Effect.sync(() => log.warn(`module is taking a long time to activate`, { module: module.id })),\n              ),\n            ),\n          ),\n          Performance.addTrackEntry({\n            name: module.id,\n            devtools: {\n              dataType: 'track-entry',\n              track: 'Module Activation',\n              trackGroup: 'Composer',\n              color: 'primary',\n            },\n          }),\n        );\n\n        // Fork the load to run in background, completing the deferred when done.\n        yield* Effect.forkDaemon(\n          loadEffect.pipe(\n            Effect.tap((result) => Deferred.succeed(deferred, result)),\n            Effect.catchAllCause((cause) => {\n              const error = Cause.squash(cause);\n              log.error('module failed to activate', {\n                module: module.id,\n                error: error instanceof Error ? error.message : String(error),\n                stack: error instanceof Error ? error.stack : undefined,\n                isDefect: !Cause.isFailure(cause),\n              });\n              return Deferred.fail(deferred, error instanceof Error ? error : new Error(String(error)));\n            }),\n          ),\n        );\n\n        return deferred;\n      }).pipe(semaphore.withPermits(1));\n\n      // Wait for result outside the semaphore so multiple waiters can proceed concurrently.\n      return yield* Deferred.await(deferredToAwait);\n    });\n\n  private _contributeCapabilities(\n    module: Plugin.PluginModule,\n    capabilities: Capability.Any[],\n  ): Effect.Effect<void, Error> {\n    return Effect.gen(this, function* () {\n      capabilities.forEach((capability) => {\n        this.capabilities.contribute({ module: module.id, ...capability });\n      });\n      this._update(this._activeAtom, (active) => [...active, module.id]);\n      this._capabilities.set(module.id, capabilities);\n    });\n  }\n\n  private _deactivateModule(module: Plugin.PluginModule): Effect.Effect<boolean, Error> {\n    return Effect.gen(this, function* () {\n      const id = module.id;\n      log('deactivating', { id });\n      this._moduleMemoMap.delete(id);\n\n      const capabilities = this._capabilities.get(id);\n      if (capabilities) {\n        for (const capability of capabilities) {\n          this.capabilities.remove(capability.interface, capability.implementation);\n          const program = capability.deactivate?.() ?? Effect.succeed(undefined);\n          yield* program;\n        }\n        this._capabilities.delete(id);\n      }\n\n      const activeIndex = this._get(this._activeAtom).findIndex((event) => event === id);\n      if (activeIndex !== -1) {\n        this._update(this._activeAtom, (active) => active.filter((event) => event !== id));\n      }\n\n      log('deactivated', { id });\n      return true;\n    });\n  }\n}\n\n/**\n * Creates a new Plugin Manager instance.\n */\nexport const make = (options: ManagerOptions): PluginManager => new ManagerImpl(options);\n\n/**\n * Runs an effect concurrently with another effect.\n * If the first effect completes, the second effect is interrupted.\n */\n// TODO(dmaretskyi): Effect.race > Effect.asVoid\nconst together =\n  <R1>(togetherEffect: Effect.Effect<void, never, R1>) =>\n  <A, E, R2>(effect: Effect.Effect<A, E, R2>): Effect.Effect<A, E, R1 | R2> =>\n    Effect.gen(function* () {\n      const togetherFiber = yield* Effect.fork(togetherEffect);\n      const result = yield* effect;\n      yield* Fiber.interrupt(togetherFiber);\n      return result;\n    });\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport { Atom, type Registry } from '@effect-atom/atom-react';\nimport * as Deferred from 'effect/Deferred';\nimport * as Effect from 'effect/Effect';\n\nimport { invariant } from '@dxos/invariant';\nimport { log } from '@dxos/log';\n\nimport type * as Capability from './capability';\n\ntype CapabilityEntry<T> = {\n  moduleId: string;\n  implementation: T;\n};\n\n/**\n * Options for creating a capability manager.\n * @internal\n */\nexport type CapabilityManagerOptions = {\n  registry: Registry.Registry;\n};\n\n/**\n * Interface for the Capability Manager.\n * Provides methods for contributing, removing, and accessing capabilities.\n */\nexport interface CapabilityManager {\n  contribute<T>(args: { module: string; interface: Capability.InterfaceDef<T>; implementation: T }): void;\n\n  remove<T>(interfaceDef: Capability.InterfaceDef<T>, implementation: T): void;\n\n  /**\n   * Get the Atom reference to the available capabilities for a given interface.\n   * Primarily useful for deriving other Atom values based on the capabilities or\n   * for subscribing to changes in the capabilities.\n   * @returns An atom reference to the available capabilities.\n   */\n  atom<T>(interfaceDef: Capability.InterfaceDef<T>): Atom.Atom<T[]>;\n\n  /**\n   * Get capabilities from the capability manager.\n   * @returns An array of capabilities.\n   */\n  getAll<T>(interfaceDef: Capability.InterfaceDef<T>): T[];\n\n  /**\n   * Requests a single capability from the capability manager.\n   * @returns The capability.\n   * @throws If no capability is found.\n   */\n  get<T>(interfaceDef: Capability.InterfaceDef<T>): T;\n\n  /**\n   * Waits for a capability to be available.\n   * @returns The capability.\n   */\n  waitFor<T>(interfaceDef: Capability.InterfaceDef<T>): Effect.Effect<T, Error>;\n}\n\n/**\n * Internal implementation of CapabilityManager.\n */\nclass CapabilityManagerImpl implements CapabilityManager {\n  private readonly _registry: Registry.Registry;\n\n  private readonly _capabilityEntries = Atom.family<string, Atom.Writable<CapabilityEntry<unknown>[]>>(() => {\n    return Atom.make<CapabilityEntry<unknown>[]>([]).pipe(Atom.keepAlive);\n  });\n\n  readonly _capabilities = Atom.family<string, Atom.Atom<unknown[]>>((id: string) => {\n    return Atom.make((get) => {\n      const current = get(this._capabilityEntries(id));\n      return current.map((c) => c.implementation);\n    });\n  });\n\n  readonly _capability = Atom.family<string, Atom.Atom<unknown>>((id: string) => {\n    return Atom.make((get) => {\n      const current = get(this._capabilities(id));\n      invariant(current.length > 0, `No capability found for ${id}`);\n      return current[0];\n    });\n  });\n\n  constructor({ registry }: CapabilityManagerOptions) {\n    this._registry = registry;\n  }\n\n  contribute<T>({\n    module: moduleId,\n    interface: interfaceDef,\n    implementation,\n  }: {\n    module: string;\n    interface: Capability.InterfaceDef<T>;\n    implementation: T;\n  }): void {\n    const current = this._registry.get(this._capabilityEntries(interfaceDef.identifier));\n    const isDuplicate = current.some((c) => c.moduleId === moduleId && c.implementation === implementation);\n    if (isDuplicate) {\n      log('capability already contributed, skipping', { id: interfaceDef.identifier, moduleId });\n      return;\n    }\n\n    const entry: CapabilityEntry<T> = { moduleId, implementation };\n    this._registry.set(this._capabilityEntries(interfaceDef.identifier), [...current, entry]);\n    log('capability contributed', {\n      id: interfaceDef.identifier,\n      moduleId,\n      count: current.length,\n    });\n  }\n\n  remove<T>(interfaceDef: Capability.InterfaceDef<T>, implementation: T): void {\n    const current = this._registry.get(this._capabilityEntries(interfaceDef.identifier));\n    if (current.length === 0) {\n      return;\n    }\n\n    const next = current.filter((c) => c.implementation !== implementation);\n    if (next.length !== current.length) {\n      this._registry.set(this._capabilityEntries(interfaceDef.identifier), next);\n      log('capability removed', { id: interfaceDef.identifier, count: current.length });\n    } else {\n      log.warn('capability not removed', { id: interfaceDef.identifier });\n    }\n  }\n\n  atom<T>(interfaceDef: Capability.InterfaceDef<T>): Atom.Atom<T[]> {\n    // NOTE: This the type-checking for capabilities is done at the time of contribution.\n    return this._capabilities(interfaceDef.identifier) as Atom.Atom<T[]>;\n  }\n\n  getAll<T>(interfaceDef: Capability.InterfaceDef<T>): T[] {\n    return this._registry.get(this.atom(interfaceDef));\n  }\n\n  get<T>(interfaceDef: Capability.InterfaceDef<T>): T {\n    const capabilities = this.getAll(interfaceDef);\n    invariant(capabilities.length > 0, `No capability found for ${interfaceDef.identifier}`);\n    return capabilities[0];\n  }\n\n  waitFor<T>(interfaceDef: Capability.InterfaceDef<T>): Effect.Effect<T, Error> {\n    return Effect.gen(this, function* () {\n      const [capability] = this.getAll(interfaceDef);\n      if (capability) {\n        return capability;\n      }\n\n      const deferred = yield* Deferred.make<T, Error>();\n      const cancel = this._registry.subscribe(this.atom(interfaceDef), (capabilities) => {\n        if (capabilities.length > 0) {\n          Effect.runSync(Deferred.succeed(deferred, capabilities[0]));\n        }\n      });\n      const result = yield* Deferred.await(deferred);\n      cancel();\n      return result;\n    });\n  }\n}\n\n/**\n * Creates a new Capability Manager instance.\n */\nexport const make = (options: CapabilityManagerOptions): CapabilityManager => new CapabilityManagerImpl(options);\n"],
-  "mappings": "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",
-  "names": ["make", "Atom", "Registry", "Array", "Cause", "Deferred", "Duration", "Effect", "Fiber", "Function", "HashSet", "PubSub", "Ref", "runAndForwardErrors", "Performance", "log", "make", "Atom", "Deferred", "Effect", "invariant", "log", "CapabilityManagerImpl", "_registry", "_capabilityEntries", "family", "pipe", "keepAlive", "_capabilities", "id", "get", "current", "map", "c", "implementation", "_capability", "length", "registry", "contribute", "module", "moduleId", "interface", "interfaceDef", "identifier", "isDuplicate", "some", "entry", "set", "count", "remove", "next", "filter", "warn", "atom", "getAll", "capabilities", "waitFor", "gen", "capability", "deferred", "cancel", "subscribe", "runSync", "succeed", "result", "await", "options", "ManagerTypeId", "Symbol", "for", "isManager", "value", "ManagerImpl", "activation", "runSync", "unbounded", "capabilities", "registry", "_pluginsAtom", "_coreAtom", "_enabledAtom", "_modulesAtom", "_activeAtom", "_eventsFiredAtom", "_pendingResetAtom", "_pluginLoader", "_capabilities", "Map", "_moduleMemoMap", "_moduleSemaphores", "_activatingEvents", "make", "_activatingModules", "pluginLoader", "plugins", "core", "map", "meta", "id", "enabled", "Registry", "Atom", "pipe", "keepAlive", "forEach", "plugin", "_addPlugin", "all", "enable", "runAndForwardErrors", "modules", "active", "eventsFired", "pendingReset", "getPlugins", "_get", "getCore", "getEnabled", "getModules", "getActive", "getEventsFired", "getPendingReset", "add", "gen", "log", "_getPlugin", "_update", "includes", "module", "_addModule", "_setPendingResetByModule", "events", "event", "activate", "concurrency", "remove", "result", "disable", "_removePlugin", "enabledIndex", "findIndex", "filter", "item", "deactivate", "_removeModule", "params", "key", "eventKey", "update", "activating", "append", "pendingIndex", "pending", "activatingEvents", "activatingModules", "_getInactiveModulesByEvent", "allOf", "isAllOf", "activatesOn", "getEvents", "every", "appendAll", "length", "publish", "state", "beforeEvents", "flatMap", "activatesBefore", "fromIterable", "toValues", "before", "allWith", "together", "sleep", "seconds", "andThen", "sync", "warn", "getCapabilities", "mod", "_loadModule", "catchAll", "error", "fail", "zip", "_contributeCapabilities", "afterEvents", "activatesAfter", "after", "Performance", "addTrackEntry", "name", "devtools", "dataType", "track", "trackGroup", "color", "results", "_deactivateModule", "reset", "_getActiveModulesByEvent", "atom", "get", "_set", "set", "updater", "find", "_getActiveModules", "_getInactiveModules", "activationEvents", "Set", "current", "_getModuleSemaphore", "moduleId", "semaphore", "makeSemaphore", "deferredToAwait", "existing", "deferred", "loadEffect", "duration", "provideService", "Service", "timed", "normalized", "isArray", "elapsed", "toMillis", "failed", "withSpan", "forkDaemon", "tap", "succeed", "catchAllCause", "cause", "squash", "Error", "message", "String", "stack", "undefined", "isDefect", "isFailure", "withPermits", "await", "capability", "contribute", "delete", "interface", "implementation", "program", "activeIndex", "options", "togetherEffect", "effect", "togetherFiber", "fork", "interrupt"]
-}

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

@@ -1,35 +0,0 @@
-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

@@ -1,7 +0,0 @@
-{
-  "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-SB5ODNPX.mjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/core/capability.ts"],
-  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport { type Atom } from '@effect-atom/atom-react';\nimport * as Context from 'effect/Context';\nimport * as Effect from 'effect/Effect';\n\nimport type * as CapabilityManager from './capability-manager';\nimport type * as Plugin from './plugin';\n\n//\n// Capability Service Layer\n//\n\n/**\n * Effect Context.Tag for accessing CapabilityManager via the Effect layer system.\n * This allows capability modules to access the capability manager without having it passed as an argument.\n */\nexport class Service extends Context.Tag('@dxos/app-framework/CapabilityManager')<\n  Service,\n  CapabilityManager.CapabilityManager\n>() {}\n\n/**\n * Get a single capability from the capability manager.\n * @param interfaceDef The interface definition of the capability.\n * @returns The capability implementation.\n * @throws If no capability is found.\n */\n// TODO(wittjosiah): Add custom tagged errors (Data.TaggedError) for app-framework to enable\n//   type-safe error handling with Effect. Consider CapabilityNotFoundError, ModuleActivationError, etc.\nexport const get = <T>(interfaceDef: InterfaceDef<T>): Effect.Effect<T, Error, Service> =>\n  Effect.flatMap(Service, (manager) =>\n    Effect.try({\n      try: () => manager.get(interfaceDef),\n      catch: (error) => (error instanceof Error ? error : new Error(String(error))),\n    }),\n  );\n\n/**\n * Get all capabilities from the capability manager for a given interface.\n * @param interfaceDef The interface definition of the capability.\n * @returns An array of capability implementations.\n */\nexport const getAll = <T>(interfaceDef: InterfaceDef<T>): Effect.Effect<T[], never, Service> =>\n  Effect.map(Service, (manager) => manager.getAll(interfaceDef));\n\n/**\n * Wait for a capability to be available.\n * @param interfaceDef The interface definition of the capability.\n * @returns The capability implementation once available.\n */\nexport const waitFor = <T>(interfaceDef: InterfaceDef<T>): Effect.Effect<T, Error, Service> =>\n  Effect.flatMap(Service, (manager) => manager.waitFor(interfaceDef));\n\n/**\n * Get the Atom reference to capabilities for reactive access.\n * @param interfaceDef The interface definition of the capability.\n * @returns An Atom containing the array of capability implementations.\n */\nexport const atom = <T>(interfaceDef: InterfaceDef<T>): Effect.Effect<Atom.Atom<T[]>, never, Service> =>\n  Effect.map(Service, (manager) => manager.atom(interfaceDef));\n\nconst InterfaceDefTypeId: unique symbol = Symbol.for('InterfaceDefTypeId');\n\n/**\n * Symbol used to tag lazy capability functions with their module ID.\n */\nexport const ModuleTag: unique symbol = Symbol.for('@dxos/app-framework/ModuleTag');\n\n/**\n * The interface definition of a capability.\n */\nexport type InterfaceDef<T> = {\n  [InterfaceDefTypeId]: T;\n  identifier: string;\n};\n\nexport namespace InterfaceDef {\n  export type Implementation<I extends InterfaceDef<any>> = I extends InterfaceDef<infer T> ? T : never;\n}\n\n/**\n * Helper to define the interface of a capability.\n */\nexport const make = <T>(identifier: string) => {\n  return { identifier } as InterfaceDef<T>;\n};\n\n/**\n * A unique string identifier with a Typescript type associated with it.\n * When a capability is contributed to the application an implementation of the interface is provided.\n */\nexport type Capability<T> = {\n  /**\n   * The interface definition of the capability.\n   */\n  readonly interface: InterfaceDef<T>;\n\n  /**\n   * The implementation of the capability.\n   */\n  readonly implementation: T;\n\n  /**\n   * Called when the capability is deactivated.\n   */\n  readonly deactivate?: () => Effect.Effect<void, Error>;\n};\n\nexport type Any = Capability<any>;\n\n/**\n * Union type representing all valid return types for a capability module.\n * Supports single capabilities, arrays, and tuples of different capability types.\n */\nexport type ModuleReturn = void | Any | Any[] | readonly Any[] | [Any, ...Any[]] | readonly [Any, ...Any[]];\n\n/**\n * Helper to define the implementation of a capability.\n */\nexport const contributes = <I extends InterfaceDef<any>>(\n  interfaceDef: I,\n  implementation: Capability<InterfaceDef.Implementation<I>>['implementation'],\n  deactivate?: Capability<InterfaceDef.Implementation<I>>['deactivate'],\n): Capability<I> => {\n  return {\n    interface: interfaceDef,\n    implementation,\n    deactivate,\n  } satisfies Capability<I>;\n};\n\ntype LoadCapability<Props, Capabilities extends ModuleReturn = ModuleReturn> = () => Promise<{\n  default: (props: Props) => Effect.Effect<Capabilities, Error, Service | Plugin.Service | never>;\n}>;\ntype LoadCapabilities<Props, Capabilities extends ModuleReturn = ModuleReturn> = () => Promise<{\n  default: (props: Props) => Effect.Effect<Capabilities, Error, Service | Plugin.Service | never>;\n}>;\n\ntype NormalizeReturn<R> = R extends readonly (infer A)[]\n  ? A[]\n  : R extends (infer A)[]\n    ? A[]\n    : R extends Any\n      ? [R]\n      : Any[];\n\nexport type LazyCapability<Props = void, Capabilities extends ModuleReturn = ModuleReturn, E extends Error = Error> = (\n  props: Props,\n) => Effect.Effect<NormalizeReturn<Capabilities>, E, Service | Plugin.Service | never>;\n\n/**\n * Helper to define a lazily loaded implementation of a capability.\n * Supports single capabilities, arrays, and tuples of different capability types.\n * @param name The export name (e.g., 'AppGraphBuilder') - used to auto-compute module IDs.\n * @param loader The lazy loader function.\n * @returns A lazy capability function with ModuleTag symbol attached.\n */\nexport const lazy = <T = void, R extends ModuleReturn = ModuleReturn>(\n  name: string,\n  c: LoadCapability<T, R> | LoadCapabilities<T, R>,\n): LazyCapability<T, R> => {\n  const lazyFn: LazyCapability<T, R> = (props: T) =>\n    Effect.gen(function* () {\n      const { default: getCapability } = yield* Effect.tryPromise(() => c());\n      const result = yield* getCapability(props);\n      const normalized = result == null ? [] : Array.isArray(result) ? Array.from(result) : [result];\n      return normalized as NormalizeReturn<R>;\n    });\n\n  return Object.assign(lazyFn, { [ModuleTag]: name });\n};\n\n/**\n * Gets the module tag (export name) from a lazy capability function.\n * @param capability The lazy capability function.\n * @returns The module tag if present, undefined otherwise.\n */\n// TODO(wittjosiah): Stricter type for capability.\nexport const getModuleTag = (capability: unknown): string | undefined => {\n  return capability && typeof capability === 'function' && ModuleTag in capability\n    ? String(capability[ModuleTag])\n    : undefined;\n};\n\n/**\n * Helper to define a capability module with explicit typing.\n * Wraps the default export function to provide better type inference and make the pattern explicit.\n *\n * This helper provides explicit typing for the module activation function,\n * making it clear that the function should:\n * - Access CapabilityManager via the Effect layer system (Capability.get, Capability.getAll, etc.)\n * - Return a capability, array of capabilities, or tuple of different capability types (sync or async)\n *\n * Supports returning multiple capabilities of different types as a tuple, which will be normalized\n * to an array at runtime for compatibility with the plugin system.\n *\n * @example\n * ```ts\n * // Module without options - single capability\n * export default Capability.makeModule(\n *   Effect.fnUntraced(function* () {\n *     const client = yield* Capability.get(ClientCapabilities.Client);\n *     return contributes(Capabilities.SettingsStore, store);\n *   })\n * );\n *\n * // Module with multiple capabilities\n * export default Capability.makeModule(\n *   Effect.fnUntraced(function* () {\n *     return [\n *       contributes(Capabilities.SettingsStore, store),\n *       contributes(Capabilities.Translations, translations),\n *     ];\n *   })\n * );\n *\n * // Module with required options (context accessed via layer)\n * export default Capability.makeModule(\n *   Effect.fnUntraced(function* (props: { observability: boolean }) {\n *     const invoker = yield* Capability.get(Capabilities.OperationInvoker);\n *     return contributes(Capabilities.IntentResolver, ...);\n *   })\n * );\n * ```\n */\nexport const makeModule = <\n  TProps = void,\n  TReturn extends ModuleReturn = ModuleReturn,\n  E extends Error = Error,\n  R extends Service | Plugin.Service | never = Service,\n>(\n  fn: (props: TProps) => Effect.Effect<TReturn, E, R>,\n): ((props: TProps) => Effect.Effect<TReturn, E, R>) => fn;\n"],
-  "mappings": ";;;;;;AAAA;;;;;;;;;;;;;;AAKA,YAAYA,aAAa;AACzB,YAAYC,YAAY;AAajB,IAAMC,UAAN,cAA8BC,YAAI,uCAAA,EAAA,EAAA;AAGpC;AAUE,IAAMC,MAAM,CAAIC,iBACdC,eAAQJ,SAAS,CAACK,YAChBC,WAAI;EACTA,KAAK,MAAMD,QAAQH,IAAIC,YAAAA;EACvBI,OAAO,CAACC,UAAWA,iBAAiBC,QAAQD,QAAQ,IAAIC,MAAMC,OAAOF,KAAAA,CAAAA;AACvE,CAAA,CAAA;AAQG,IAAMG,SAAS,CAAIR,iBACjBS,WAAIZ,SAAS,CAACK,YAAYA,QAAQM,OAAOR,YAAAA,CAAAA;AAO3C,IAAMU,UAAU,CAAIV,iBAClBC,eAAQJ,SAAS,CAACK,YAAYA,QAAQQ,QAAQV,YAAAA,CAAAA;AAOhD,IAAMW,OAAO,CAAIX,iBACfS,WAAIZ,SAAS,CAACK,YAAYA,QAAQS,KAAKX,YAAAA,CAAAA;AAOzC,IAAMY,YAA2BC,uBAAOC,IAAI,+BAAA;AAiB5C,IAAMC,OAAO,CAAIC,eAAAA;AACtB,SAAO;IAAEA;EAAW;AACtB;AAkCO,IAAMC,cAAc,CACzBC,cACAC,gBACAC,eAAAA;AAEA,SAAO;IACLC,WAAWH;IACXC;IACAC;EACF;AACF;AA4BO,IAAME,OAAO,CAClBC,MACAC,MAAAA;AAEA,QAAMC,SAA+B,CAACC,UAC7BC,WAAI,aAAA;AACT,UAAM,EAAEC,SAASC,cAAa,IAAK,OAAcC,kBAAW,MAAMN,EAAAA,CAAAA;AAClE,UAAMO,SAAS,OAAOF,cAAcH,KAAAA;AACpC,UAAMM,aAAaD,UAAU,OAAO,CAAA,IAAKE,MAAMC,QAAQH,MAAAA,IAAUE,MAAME,KAAKJ,MAAAA,IAAU;MAACA;;AACvF,WAAOC;EACT,CAAA;AAEF,SAAOI,OAAOC,OAAOZ,QAAQ;IAAE,CAACb,SAAAA,GAAYW;EAAK,CAAA;AACnD;AAQO,IAAMe,eAAe,CAACC,eAAAA;AAC3B,SAAOA,cAAc,OAAOA,eAAe,cAAc3B,aAAa2B,aAClEC,OAAOD,WAAW3B,SAAAA,CAAU,IAC5B6B;AACN;AA2CO,IAAMC,aAAa,CAMxBC,OACsDA;",
-  "names": ["Context", "Effect", "Service", "Tag", "get", "interfaceDef", "flatMap", "manager", "try", "catch", "error", "Error", "String", "getAll", "map", "waitFor", "atom", "ModuleTag", "Symbol", "for", "make", "identifier", "contributes", "interfaceDef", "implementation", "deactivate", "interface", "lazy", "name", "c", "lazyFn", "props", "gen", "default", "getCapability", "tryPromise", "result", "normalized", "Array", "isArray", "from", "Object", "assign", "getModuleTag", "capability", "String", "undefined", "makeModule", "fn"]
-}

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

@@ -1,81 +0,0 @@
-import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
-import {
-  capability_exports
-} from "./chunk-SB5ODNPX.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-UFW652GS.mjs.map

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

@@ -1,7 +0,0 @@
-{
-  "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-Z4TJPSMP.mjs

@@ -1,2 +0,0 @@
-import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
-//# sourceMappingURL=chunk-Z4TJPSMP.mjs.map

package/dist/lib/node-esm/invoker-capability-VF6SP44V.mjs

@@ -1,37 +0,0 @@
-import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
-import "./chunk-VUIUFIGT.mjs";
-import {
-  capabilities_exports
-} from "./chunk-UFW652GS.mjs";
-import {
-  activation_events_exports
-} from "./chunk-JAZVHID3.mjs";
-import "./chunk-Z4TJPSMP.mjs";
-import "./chunk-DTCHT2X2.mjs";
-import "./chunk-7OWSHPYK.mjs";
-import {
-  plugin_exports
-} from "./chunk-CJCQS2YL.mjs";
-import {
-  capability_exports
-} from "./chunk-SB5ODNPX.mjs";
-import "./chunk-HSLMI22Q.mjs";
-
-// src/plugin-operation/invoker-capability.ts
-import * as Effect from "effect/Effect";
-import { OperationInvoker } from "@dxos/operation";
-var invoker_capability_default = capability_exports.makeModule(Effect.fnUntraced(function* () {
-  const capabilityManager = yield* capability_exports.Service;
-  const pluginManager = yield* plugin_exports.Service;
-  const managedRuntimes = yield* capability_exports.getAll(capabilities_exports.ManagedRuntime);
-  const managedRuntime = managedRuntimes.length > 0 ? managedRuntimes[0] : void 0;
-  const invoker = OperationInvoker.make(() => Effect.gen(function* () {
-    yield* plugin_exports.activate(activation_events_exports.SetupOperationResolver);
-    return (yield* capability_exports.getAll(capabilities_exports.OperationResolver)).flat();
-  }).pipe(Effect.provideService(capability_exports.Service, capabilityManager), Effect.provideService(plugin_exports.Service, pluginManager)), managedRuntime);
-  return capability_exports.contributes(capabilities_exports.OperationInvoker, invoker);
-}));
-export {
-  invoker_capability_default as default
-};
-//# sourceMappingURL=invoker-capability-VF6SP44V.mjs.map

package/dist/lib/node-esm/invoker-capability-VF6SP44V.mjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/plugin-operation/invoker-capability.ts"],
-  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Effect from 'effect/Effect';\n\nimport { OperationInvoker } from '@dxos/operation';\n\nimport { ActivationEvents, Capabilities } from '../common';\nimport { Capability, Plugin } from '../core';\n\n//\n// Capability Module\n//\n\nexport default Capability.makeModule(\n  Effect.fnUntraced(function* () {\n    // Get the services for synchronous access in callbacks.\n    const capabilityManager = yield* Capability.Service;\n    const pluginManager = yield* Plugin.Service;\n\n    // Get the ManagedRuntime capability (should be available since we activate after ManagedRuntimeReady).\n    const managedRuntimes = yield* Capability.getAll(Capabilities.ManagedRuntime);\n    const managedRuntime = managedRuntimes.length > 0 ? managedRuntimes[0] : undefined;\n\n    const invoker = OperationInvoker.make(\n      () =>\n        Effect.gen(function* () {\n          yield* Plugin.activate(ActivationEvents.SetupOperationResolver);\n          return (yield* Capability.getAll(Capabilities.OperationResolver)).flat();\n        }).pipe(\n          Effect.provideService(Capability.Service, capabilityManager),\n          Effect.provideService(Plugin.Service, pluginManager),\n        ),\n      managedRuntime,\n    );\n\n    return Capability.contributes(Capabilities.OperationInvoker, invoker);\n  }),\n);\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;AAIA,YAAYA,YAAY;AAExB,SAASC,wBAAwB;AASjC,IAAA,6BAAeC,mBAAWC,WACjBC,kBAAW,aAAA;AAEhB,QAAMC,oBAAoB,OAAOH,mBAAWI;AAC5C,QAAMC,gBAAgB,OAAOC,eAAOF;AAGpC,QAAMG,kBAAkB,OAAOP,mBAAWQ,OAAOC,qBAAaC,cAAc;AAC5E,QAAMC,iBAAiBJ,gBAAgBK,SAAS,IAAIL,gBAAgB,CAAA,IAAKM;AAEzE,QAAMC,UAAUC,iBAAiBC,KAC/B,MACSC,WAAI,aAAA;AACT,WAAOX,eAAOY,SAASC,0BAAiBC,sBAAsB;AAC9D,YAAQ,OAAOpB,mBAAWQ,OAAOC,qBAAaY,iBAAiB,GAAGC,KAAI;EACxE,CAAA,EAAGC,KACMC,sBAAexB,mBAAWI,SAASD,iBAAAA,GACnCqB,sBAAelB,eAAOF,SAASC,aAAAA,CAAAA,GAE1CM,cAAAA;AAGF,SAAOX,mBAAWyB,YAAYhB,qBAAaM,kBAAkBD,OAAAA;AAC/D,CAAA,CAAA;",
-  "names": ["Effect", "OperationInvoker", "Capability", "makeModule", "fnUntraced", "capabilityManager", "Service", "pluginManager", "Plugin", "managedRuntimes", "getAll", "Capabilities", "ManagedRuntime", "managedRuntime", "length", "undefined", "invoker", "OperationInvoker", "make", "gen", "activate", "ActivationEvents", "SetupOperationResolver", "OperationResolver", "flat", "pipe", "provideService", "contributes"]
-}

package/dist/types/src/plugin-operation/OperationPlugin.d.ts

@@ -1,3 +0,0 @@
-import { Plugin } from '../core';
-export declare const OperationPlugin: Plugin.PluginFactory<void>;
-//# sourceMappingURL=OperationPlugin.d.ts.map

package/dist/types/src/plugin-operation/OperationPlugin.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"OperationPlugin.d.ts","sourceRoot":"","sources":["../../../../src/plugin-operation/OperationPlugin.ts"],"names":[],"mappings":"AAKA,OAAO,EAAc,MAAM,EAAE,MAAM,SAAS,CAAC;AAO7C,eAAO,MAAM,eAAe,4BAY3B,CAAC"}

package/dist/types/src/plugin-operation/history/capability.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"capability.d.ts","sourceRoot":"","sources":["../../../../../src/plugin-operation/history/capability.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAKxC,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAExC,OAAO,KAAK,cAAc,MAAM,mBAAmB,CAAC;AACpD,OAAO,KAAK,YAAY,MAAM,iBAAiB,CAAC;;AAMhD,wBAkBE"}

package/dist/types/src/plugin-operation/history/errors.d.ts

@@ -1,5 +0,0 @@
-import { OperationError } from '@dxos/operation';
-export declare class EmptyHistoryError extends OperationError {
-    constructor();
-}
-//# sourceMappingURL=errors.d.ts.map

package/dist/types/src/plugin-operation/history/errors.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../../../src/plugin-operation/history/errors.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEjD,qBAAa,iBAAkB,SAAQ,cAAc;;CAIpD"}

package/dist/types/src/plugin-operation/history/history-tracker.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"history-tracker.d.ts","sourceRoot":"","sources":["../../../../../src/plugin-operation/history/history-tracker.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAKxC,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAOxD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAQpD;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IACvC,WAAW,EAAE,MAAM,OAAO,CAAC;QAAE,KAAK,CAAC,EAAE,KAAK,CAAA;KAAE,CAAC,CAAC;IAC9C,OAAO,EAAE,MAAM,OAAO,CAAC;CACxB;AAMD;;GAEG;AACH,eAAO,MAAM,IAAI,GACf,SAAS,gBAAgB,CAAC,wBAAwB,EAClD,cAAc,YAAY,KACzB,cAqFF,CAAC"}

package/dist/types/src/plugin-operation/history/history-tracker.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"history-tracker.test.d.ts","sourceRoot":"","sources":["../../../../../src/plugin-operation/history/history-tracker.test.ts"],"names":[],"mappings":""}

package/dist/types/src/plugin-operation/history/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/plugin-operation/history/index.ts"],"names":[],"mappings":"AAIA,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,OAAO,KAAK,WAAW,MAAM,gBAAgB,CAAC;AAC9C,OAAO,KAAK,YAAY,MAAM,iBAAiB,CAAC;AAChD,OAAO,KAAK,cAAc,MAAM,mBAAmB,CAAC"}

package/dist/types/src/plugin-operation/history/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/plugin-operation/history/types.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEjD;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,SAAS,EAAE,SAAS,CAAC,UAAU,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;IAC1C,KAAK,EAAE,GAAG,CAAC;IACX,MAAM,EAAE,GAAG,CAAC;IACZ,OAAO,EAAE,SAAS,CAAC,UAAU,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;IACxC,YAAY,EAAE,GAAG,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC"}

package/dist/types/src/plugin-operation/history/undo-mapping.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"undo-mapping.d.ts","sourceRoot":"","sources":["../../../../../src/plugin-operation/history/undo-mapping.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEjD;;GAEG;AACH,KAAK,KAAK,GAAG,MAAM,GAAG,CAAC,MAAM,EAAE;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,YAAY,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAEtF;;GAEG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI,CAAC,SAAS,SAAS,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,GAAG,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;AAElF;;GAEG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI,CAAC,SAAS,SAAS,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;AAEnF;;;GAGG;AACH,MAAM,MAAM,eAAe,CAAC,EAAE,SAAS,SAAS,CAAC,UAAU,CAAC,GAAG,EAAE,GAAG,CAAC,IACjE,KAAK,GACL,CAAC,CAAC,KAAK,EAAE,OAAO,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,CAAC,KAAK,KAAK,CAAC,CAAC;AAE1D;;;;;;GAMG;AACH,MAAM,WAAW,WAAW,CAC1B,EAAE,SAAS,SAAS,CAAC,UAAU,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,SAAS,CAAC,UAAU,CAAC,GAAG,EAAE,GAAG,CAAC,EAC1E,GAAG,SAAS,SAAS,CAAC,UAAU,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,SAAS,CAAC,UAAU,CAAC,GAAG,EAAE,GAAG,CAAC;IAE3E,6BAA6B;IAC7B,QAAQ,CAAC,SAAS,EAAE,EAAE,CAAC;IAEvB,gDAAgD;IAChD,QAAQ,CAAC,OAAO,EAAE,GAAG,CAAC;IAEtB;;;;;OAKG;IACH,QAAQ,CAAC,aAAa,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,CAAC,KAAK,OAAO,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC;IAE/F;;;OAGG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,eAAe,CAAC,EAAE,CAAC,CAAC;CACxC;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB,CAC/B,EAAE,SAAS,SAAS,CAAC,UAAU,CAAC,GAAG,EAAE,GAAG,CAAC,EACzC,GAAG,SAAS,SAAS,CAAC,UAAU,CAAC,GAAG,EAAE,GAAG,CAAC;IAE1C,6BAA6B;IAC7B,SAAS,EAAE,EAAE,CAAC;IAEd,gDAAgD;IAChD,OAAO,EAAE,GAAG,CAAC;IAEb;;;OAGG;IACH,aAAa,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,CAAC,KAAK,OAAO,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC;IAEtF;;;OAGG;IACH,OAAO,CAAC,EAAE,eAAe,CAAC,EAAE,CAAC,CAAC;CAC/B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,IAAI,GAAI,EAAE,SAAS,SAAS,CAAC,UAAU,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,GAAG,SAAS,SAAS,CAAC,UAAU,CAAC,GAAG,EAAE,GAAG,CAAC,EACxG,OAAO,gBAAgB,CAAC,EAAE,EAAE,GAAG,CAAC,KAC/B,WAAW,CAAC,EAAE,EAAE,GAAG,CAAU,CAAC;AAEjC;;GAEG;AACH,eAAO,MAAM,cAAc,GAAI,EAAE,SAAS,SAAS,CAAC,UAAU,CAAC,GAAG,EAAE,GAAG,CAAC,EACtE,SAAS,eAAe,CAAC,EAAE,CAAC,GAAG,SAAS,EACxC,OAAO,OAAO,CAAC,EAAE,CAAC,EAClB,QAAQ,QAAQ,CAAC,EAAE,CAAC,KACnB,KAAK,GAAG,SAQV,CAAC"}

package/dist/types/src/plugin-operation/history/undo-registry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"undo-registry.d.ts","sourceRoot":"","sources":["../../../../../src/plugin-operation/history/undo-registry.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEjD,OAAO,KAAK,KAAK,WAAW,MAAM,gBAAgB,CAAC;AAMnD;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,EAAE,SAAS,CAAC,UAAU,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;IACxC,mEAAmE;IACnE,aAAa,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,KAAK,GAAG,GAAG,SAAS,CAAC;IAC5D,8DAA8D;IAC9D,OAAO,CAAC,EAAE,WAAW,CAAC,eAAe,CAAC,SAAS,CAAC,UAAU,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC;CACvE,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,CAAC,SAAS,EAAE,SAAS,CAAC,UAAU,CAAC,GAAG,EAAE,GAAG,CAAC,KAAK,iBAAiB,GAAG,SAAS,CAAC;CACtF;AAMD;;GAEG;AACH,eAAO,MAAM,IAAI,GAAI,aAAa,MAAM,WAAW,CAAC,WAAW,EAAE,KAAG,YAgBnE,CAAC"}

package/dist/types/src/plugin-operation/history/undo-registry.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"undo-registry.test.d.ts","sourceRoot":"","sources":["../../../../../src/plugin-operation/history/undo-registry.test.ts"],"names":[],"mappings":""}

package/dist/types/src/plugin-operation/index.d.ts

@@ -1,3 +0,0 @@
-export * from './history';
-export * from './OperationPlugin';
-//# sourceMappingURL=index.d.ts.map

package/dist/types/src/plugin-operation/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugin-operation/index.ts"],"names":[],"mappings":"AAIA,cAAc,WAAW,CAAC;AAC1B,cAAc,mBAAmB,CAAC"}

package/dist/types/src/plugin-operation/invoker-capability.d.ts

@@ -1,6 +0,0 @@
-import * as Effect from 'effect/Effect';
-import { OperationInvoker } from '@dxos/operation';
-import { Capability, Plugin } from '../core';
-declare const _default: (props: void) => Effect.Effect<Capability.Capability<Capability.InterfaceDef<OperationInvoker.OperationInvoker>>, never, Capability.Service | Plugin.Service>;
-export default _default;
-//# sourceMappingURL=invoker-capability.d.ts.map

package/dist/types/src/plugin-operation/invoker-capability.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"invoker-capability.d.ts","sourceRoot":"","sources":["../../../../src/plugin-operation/invoker-capability.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAGnD,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;;AAM7C,wBAwBE"}

package/dist/types/src/plugin-operation/meta.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"meta.d.ts","sourceRoot":"","sources":["../../../../src/plugin-operation/meta.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,SAAS,CAAC;AAEtC,eAAO,MAAM,IAAI,EAAE,MAAM,CAAC,IAIzB,CAAC"}

package/dist/types/src/plugin-operation/testing.d.ts

@@ -1,109 +0,0 @@
-import * as Effect from 'effect/Effect';
-import * as Schema from 'effect/Schema';
-import { Operation, type OperationInvoker, OperationResolver } from '@dxos/operation';
-export declare const Compute: Omit<{
-    readonly schema: {
-        readonly input: Schema.Struct<{
-            value: typeof Schema.Number;
-        }>;
-        readonly output: Schema.Struct<{
-            value: typeof Schema.Number;
-        }>;
-    };
-    readonly meta: {
-        readonly key: "test.compute";
-    };
-}, "executionMode"> & import("effect/Pipeable").Pipeable & {
-    readonly executionMode: "sync" | "async";
-};
-export declare const HalveCompute: Omit<{
-    readonly schema: {
-        readonly input: Schema.Struct<{
-            value: typeof Schema.Number;
-        }>;
-        readonly output: Schema.Struct<{
-            value: typeof Schema.Number;
-        }>;
-    };
-    readonly meta: {
-        readonly key: "test.halve-compute";
-    };
-}, "executionMode"> & import("effect/Pipeable").Pipeable & {
-    readonly executionMode: "sync" | "async";
-};
-export declare const ToString: Omit<{
-    readonly schema: {
-        readonly input: Schema.Struct<{
-            value: typeof Schema.Number;
-        }>;
-        readonly output: Schema.Struct<{
-            string: typeof Schema.String;
-        }>;
-    };
-    readonly meta: {
-        readonly key: "test.to-string";
-    };
-}, "executionMode"> & import("effect/Pipeable").Pipeable & {
-    readonly executionMode: "sync" | "async";
-};
-export declare const Add: Omit<{
-    readonly schema: {
-        readonly input: Schema.Tuple2<typeof Schema.Number, typeof Schema.Number>;
-        readonly output: typeof Schema.Number;
-    };
-    readonly meta: {
-        readonly key: "test.add";
-    };
-}, "executionMode"> & import("effect/Pipeable").Pipeable & {
-    readonly executionMode: "sync" | "async";
-};
-export declare const SideEffect: Omit<{
-    readonly schema: {
-        readonly input: typeof Schema.Void;
-        readonly output: typeof Schema.Void;
-    };
-    readonly meta: {
-        readonly key: "test.side-effect";
-    };
-}, "executionMode"> & import("effect/Pipeable").Pipeable & {
-    readonly executionMode: "sync" | "async";
-};
-export declare const computeHandler: OperationResolver.OperationResolver<{
-    readonly value: number;
-}, {
-    readonly value: number;
-}, never, Operation.Service>;
-export declare const halveComputeHandler: OperationResolver.OperationResolver<{
-    readonly value: number;
-}, {
-    readonly value: number;
-}, never, Operation.Service>;
-export declare const toStringHandler: OperationResolver.OperationResolver<{
-    readonly value: number;
-}, {
-    readonly string: string;
-}, never, Operation.Service>;
-export declare const addHandler: OperationResolver.OperationResolver<readonly [number, number], number, never, Operation.Service>;
-export declare const sideEffectHandler: OperationResolver.OperationResolver<void, void, never, Operation.Service>;
-/**
- * Event collector for testing - provides deterministic event collection using Effect primitives.
- */
-export interface EventCollector {
-    /** All collected events. */
-    readonly events: OperationInvoker.InvocationEvent[];
-    /** Wait until N events have been collected. */
-    waitForEvents: (count: number) => Effect.Effect<void>;
-    /** Clean up the subscription fiber. */
-    dispose: Effect.Effect<void>;
-}
-/**
- * Creates an event collector that subscribes to invoker events.
- * Uses Effect primitives for synchronization.
- */
-export declare const createEventCollector: (invoker: OperationInvoker.OperationInvoker) => Effect.Effect<EventCollector>;
-/**
- * Waits until a condition is true, yielding to the JS event loop between checks.
- * Uses setImmediate to allow other async work to complete.
- */
-export declare const waitUntil: (condition: () => boolean) => Effect.Effect<void>;
-//# sourceMappingURL=testing.d.ts.map

package/dist/types/src/plugin-operation/testing.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"testing.d.ts","sourceRoot":"","sources":["../../../../src/plugin-operation/testing.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAGxC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAGxC,OAAO,EAAE,SAAS,EAAE,KAAK,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAMtF,eAAO,MAAM,OAAO;;;;;;;;;;;;;;CAMlB,CAAC;AAEH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;CAMvB,CAAC;AAEH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;CAMnB,CAAC;AAEH,eAAO,MAAM,GAAG;;;;;;;;;;CAMd,CAAC;AAEH,eAAO,MAAM,UAAU;;;;;;;;;;CAMrB,CAAC;AAMH,eAAO,MAAM,cAAc;;;;4BAOzB,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;4BAG9B,CAAC;AAEH,eAAO,MAAM,eAAe;;;;4BAG1B,CAAC;AAEH,eAAO,MAAM,UAAU,kGAGrB,CAAC;AAEH,eAAO,MAAM,iBAAiB,2EAG5B,CAAC;AAMH;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,4BAA4B;IAC5B,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC,eAAe,EAAE,CAAC;IACpD,+CAA+C;IAC/C,aAAa,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IACtD,uCAAuC;IACvC,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;CAC9B;AAED;;;GAGG;AACH,eAAO,MAAM,oBAAoB,GAAI,SAAS,gBAAgB,CAAC,gBAAgB,KAAG,MAAM,CAAC,MAAM,CAAC,cAAc,CAoD1G,CAAC;AAEL;;;GAGG;AACH,eAAO,MAAM,SAAS,GAAI,WAAW,MAAM,OAAO,KAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAKnE,CAAC"}

package/dist/types/src/plugin-runtime/RuntimePlugin.d.ts

@@ -1,3 +0,0 @@
-import { Plugin } from '../core';
-export declare const RuntimePlugin: Plugin.PluginFactory<void>;
-//# sourceMappingURL=RuntimePlugin.d.ts.map

package/dist/types/src/plugin-runtime/RuntimePlugin.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"RuntimePlugin.d.ts","sourceRoot":"","sources":["../../../../src/plugin-runtime/RuntimePlugin.ts"],"names":[],"mappings":"AAKA,OAAO,EAAc,MAAM,EAAE,MAAM,SAAS,CAAC;AAM7C,eAAO,MAAM,aAAa,4BAQzB,CAAC"}

package/dist/types/src/plugin-runtime/capability.d.ts

@@ -1,6 +0,0 @@
-import * as Effect from 'effect/Effect';
-import { Capabilities } from '../common';
-import { Capability, Plugin } from '../core';
-declare const _default: (props: void) => Effect.Effect<Capability.Capability<Capability.InterfaceDef<Capabilities.ManagedRuntime>>, Error, Capability.Service | Plugin.Service>;
-export default _default;
-//# sourceMappingURL=capability.d.ts.map

package/dist/types/src/plugin-runtime/capability.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"capability.d.ts","sourceRoot":"","sources":["../../../../src/plugin-runtime/capability.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAIxC,OAAO,EAAoB,YAAY,EAAE,MAAM,WAAW,CAAC;AAC3D,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;;AAM7C,wBAqCE"}

package/dist/types/src/plugin-runtime/index.d.ts

@@ -1,2 +0,0 @@
-export * from './RuntimePlugin';
-//# sourceMappingURL=index.d.ts.map

package/dist/types/src/plugin-runtime/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugin-runtime/index.ts"],"names":[],"mappings":"AAIA,cAAc,iBAAiB,CAAC"}

package/dist/types/src/plugin-runtime/meta.d.ts

@@ -1,3 +0,0 @@
-import { type Plugin } from '../core';
-export declare const meta: Plugin.Meta;
-//# sourceMappingURL=meta.d.ts.map

package/dist/types/src/plugin-runtime/meta.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"meta.d.ts","sourceRoot":"","sources":["../../../../src/plugin-runtime/meta.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,SAAS,CAAC;AAEtC,eAAO,MAAM,IAAI,EAAE,MAAM,CAAC,IAIzB,CAAC"}