@dxos/plugin-native 0.8.4-main.7ace549 → 0.8.4-main.8baae0fced

package/package.json

@@ -1,51 +1,104 @@
 {
   "name": "@dxos/plugin-native",
-  "version": "0.8.4-main.7ace549",
+  "version": "0.8.4-main.8baae0fced",
   "description": "Composer plugin that runs when on a native device.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
-  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dxos/dxos"
+  },
+  "license": "FSL-1.1-Apache-2.0",
   "author": "DXOS.org",
   "sideEffects": true,
   "type": "module",
+  "imports": {
+    "#capabilities": {
+      "source": "./src/capabilities/index.ts",
+      "types": "./dist/types/src/capabilities/index.d.ts",
+      "default": "./dist/lib/neutral/capabilities/index.mjs"
+    },
+    "#components": {
+      "source": "./src/components/index.ts",
+      "types": "./dist/types/src/components/index.d.ts",
+      "default": "./dist/lib/neutral/components/index.mjs"
+    },
+    "#meta": {
+      "source": "./src/meta.ts",
+      "types": "./dist/types/src/meta.d.ts",
+      "default": "./dist/lib/neutral/meta.mjs"
+    },
+    "#plugin": {
+      "source": "./src/NativePlugin.tsx",
+      "types": "./dist/types/src/NativePlugin.d.ts",
+      "default": "./dist/lib/neutral/NativePlugin.mjs"
+    },
+    "#translations": {
+      "source": "./src/translations.ts",
+      "types": "./dist/types/src/translations.d.ts",
+      "default": "./dist/lib/neutral/translations.mjs"
+    },
+    "#types": {
+      "source": "./src/types/index.ts",
+      "types": "./dist/types/src/types/index.d.ts",
+      "default": "./dist/lib/neutral/types/index.mjs"
+    }
+  },
   "exports": {
     ".": {
       "source": "./src/index.ts",
       "types": "./dist/types/src/index.d.ts",
-      "browser": "./dist/lib/browser/index.mjs"
+      "default": "./dist/lib/neutral/index.mjs"
+    },
+    "./plugin": {
+      "source": "./src/plugin.ts",
+      "types": "./dist/types/src/plugin.d.ts",
+      "default": "./dist/lib/neutral/plugin.mjs"
+    },
+    "./translations": {
+      "source": "./src/translations.ts",
+      "types": "./dist/types/src/translations.d.ts",
+      "default": "./dist/lib/neutral/translations.mjs"
     }
   },
   "types": "dist/types/src/index.d.ts",
-  "typesVersions": {
-    "*": {}
-  },
   "files": [
     "dist",
     "src"
   ],
   "dependencies": {
-    "@effect/platform": "^0.92.1",
-    "@tauri-apps/api": "^2.8.0",
-    "@tauri-apps/plugin-os": "^2.3.1",
-    "@tauri-apps/plugin-process": "^2.3.0",
-    "@tauri-apps/plugin-shell": "^2.3.1",
-    "@tauri-apps/plugin-updater": "^2.9.0",
-    "effect": "3.18.3",
-    "@dxos/ai": "0.8.4-main.7ace549",
-    "@dxos/app-framework": "0.8.4-main.7ace549",
-    "@dxos/log": "0.8.4-main.7ace549",
-    "@dxos/plugin-assistant": "0.8.4-main.7ace549",
-    "@dxos/plugin-help": "0.8.4-main.7ace549",
-    "@dxos/util": "0.8.4-main.7ace549",
-    "@dxos/plugin-navtree": "0.8.4-main.7ace549"
+    "@effect-atom/atom-react": "^0.5.0",
+    "@effect/platform": "0.94.4",
+    "@tauri-apps/api": "^2.11.0",
+    "@tauri-apps/plugin-os": "^2.3.2",
+    "@tauri-apps/plugin-process": "^2.3.1",
+    "@tauri-apps/plugin-shell": "^2.3.5",
+    "@tauri-apps/plugin-updater": "^2.10.1",
+    "date-fns": "^3.6.0",
+    "@dxos/ai": "0.8.4-main.8baae0fced",
+    "@dxos/app-framework": "0.8.4-main.8baae0fced",
+    "@dxos/app-toolkit": "0.8.4-main.8baae0fced",
+    "@dxos/effect": "0.8.4-main.8baae0fced",
+    "@dxos/log": "0.8.4-main.8baae0fced",
+    "@dxos/operation": "0.8.4-main.8baae0fced",
+    "@dxos/plugin-navtree": "0.8.4-main.8baae0fced",
+    "@dxos/util": "0.8.4-main.8baae0fced",
+    "@dxos/plugin-assistant": "0.8.4-main.8baae0fced"
   },
   "devDependencies": {
-    "vite": "7.1.9",
-    "@dxos/react-ui": "0.8.4-main.7ace549"
+    "@types/react": "~19.2.7",
+    "effect": "3.20.0",
+    "react": "~19.2.3",
+    "vite": "^8.0.13",
+    "@dxos/plugin-testing": "0.8.4-main.8baae0fced",
+    "@dxos/react-ui": "0.8.4-main.8baae0fced",
+    "@dxos/react-ui-form": "0.8.4-main.8baae0fced"
   },
   "peerDependencies": {
-    "effect": "^3.13.3",
-    "@dxos/react-ui": "0.8.4-main.7ace549"
+    "effect": "3.20.0",
+    "react": "~19.2.3",
+    "@dxos/react-ui": "0.8.4-main.8baae0fced",
+    "@dxos/react-ui-form": "0.8.4-main.8baae0fced"
   },
   "publishConfig": {
     "access": "public"

package/src/NativePlugin.tsx

@@ -2,32 +2,34 @@
 // Copyright 2023 DXOS.org
 //
 
-import { Capabilities, Events, contributes, defineModule, definePlugin } from '@dxos/app-framework';
+import { ActivationEvents, Plugin } from '@dxos/app-framework';
+import { AppPlugin } from '@dxos/app-toolkit';
 import { AssistantEvents } from '@dxos/plugin-assistant';
 
-import { Ollama, Updater, Window } from './capabilities';
-import { meta } from './meta';
-import { translations } from './translations';
+import { NativeSettings, Ollama, ReactSurface, SpotlightListener, Updater } from '#capabilities';
+import { meta } from '#meta';
+import { translations } from '#translations';
 
-export const NativePlugin = definePlugin(meta, () => [
-  defineModule({
-    id: `${meta.id}/module/translations`,
-    activatesOn: Events.SetupTranslations,
-    activate: () => contributes(Capabilities.Translations, translations),
+export const NativePlugin = Plugin.define(meta).pipe(
+  AppPlugin.addSettingsModule({ activate: NativeSettings }),
+  AppPlugin.addSurfaceModule({ activate: ReactSurface }),
+  AppPlugin.addTranslationsModule({ translations }),
+  Plugin.addModule({
+    id: 'spotlight-listener',
+    activatesOn: ActivationEvents.ProcessManagerReady,
+    activate: SpotlightListener,
   }),
-  defineModule({
-    id: `${meta.id}/module/updater`,
-    activatesOn: Events.DispatcherReady,
+  Plugin.addModule({
+    id: 'updater',
+    activatesOn: ActivationEvents.ProcessManagerReady,
     activate: Updater,
   }),
-  defineModule({
-    id: `${meta.id}/module/window`,
-    activatesOn: Events.DispatcherReady,
-    activate: Window,
-  }),
-  defineModule({
-    id: `${meta.id}/module/ollama`,
+  Plugin.addModule({
+    id: 'ollama',
     activatesOn: AssistantEvents.SetupAiServiceProviders,
     activate: Ollama,
   }),
-]);
+  Plugin.make,
+);
+
+export default NativePlugin;

package/src/capabilities/index.ts

@@ -2,8 +2,10 @@
 // Copyright 2025 DXOS.org
 //
 
-import { lazy } from '@dxos/app-framework';
+import { Capability } from '@dxos/app-framework';
 
-export const Ollama = lazy(() => import('./ollama'));
-export const Updater = lazy(() => import('./updater'));
-export const Window = lazy(() => import('./window'));
+export const NativeSettings = Capability.lazy('NativeSettings', () => import('./settings'));
+export const Ollama = Capability.lazy('Ollama', () => import('./ollama'));
+export const ReactSurface = Capability.lazy('ReactSurface', () => import('./react-surface'));
+export const SpotlightListener = Capability.lazy('SpotlightListener', () => import('./spotlight-listener'));
+export const Updater = Capability.lazy('Updater', () => import('./updater'));

package/src/capabilities/ollama.ts

@@ -10,29 +10,33 @@ import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 import * as ManagedRuntime from 'effect/ManagedRuntime';
 
-import * as AiServiceRouter from '@dxos/ai/AiServiceRouter';
-import { Capabilities, type Capability, type PluginContext, contributes } from '@dxos/app-framework';
+import { type AiModelResolver } from '@dxos/ai';
+import { OllamaResolver } from '@dxos/ai/resolvers';
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
 import { log } from '@dxos/log';
 
-// Running ollama on non-standard port.
+// NOTE: Running ollama on non-standard port (config Tauri).
 const OLLAMA_HOST = 'http://localhost:21434';
 
-export default (_context: PluginContext): Capability<any> => {
-  const runtime = ManagedRuntime.make(OllamaSidecar.layerLive);
+export type OllamaCapabilities = Capability.Capability<typeof AppCapabilities.AiModelResolver>;
 
-  // Layer for the sidecar but the lifecycle is managed by the runtime.
-  const sidecarLayer = Layer.effectContext(
-    runtime.runtimeEffect.pipe(Effect.map((rt) => rt.context.pipe(Context.pick(OllamaSidecar)))),
-  );
+export default Capability.makeModule<[], OllamaCapabilities>(() =>
+  Effect.sync(() => {
+    const runtime = ManagedRuntime.make(OllamaSidecar.layerLive);
 
-  return contributes(
-    Capabilities.AiModelResolver,
-    OllamaSidecarModelResolver.pipe(Layer.provide(sidecarLayer)),
-    async () => {
-      await runtime.dispose();
-    },
-  );
-};
+    // Layer for the sidecar but the lifecycle is managed by the runtime.
+    const sidecarLayer = Layer.effectContext(
+      runtime.runtimeEffect.pipe(Effect.map((rt) => rt.context.pipe(Context.pick(OllamaSidecar)))),
+    );
+
+    return Capability.contributes(
+      AppCapabilities.AiModelResolver,
+      OllamaSidecarModelResolver.pipe(Layer.provide(sidecarLayer)),
+      () => Effect.tryPromise(() => runtime.dispose()),
+    );
+  }),
+);
 
 class OllamaSidecar extends Context.Tag('@dxos/plugin-native/OllamaSidecar')<
   OllamaSidecar,
@@ -51,7 +55,9 @@ class OllamaSidecar extends Context.Tag('@dxos/plugin-native/OllamaSidecar')<
       });
 
       // NOTE: Keeping those as console.log for consistent formatting.
+      // eslint-disable-next-line no-console
       command.stdout.on('data', (data) => console.log('[ollama]', data.toString()));
+      // eslint-disable-next-line no-console
       command.stderr.on('data', (data) => console.error('[ollama]', data.toString()));
       command.on('close', (code) => log.info('Ollama process exited', { code }));
       command.on('error', (error) => log.error('Ollama error', { error }));
@@ -70,12 +76,12 @@ class OllamaSidecar extends Context.Tag('@dxos/plugin-native/OllamaSidecar')<
   );
 }
 
-const OllamaSidecarModelResolver: Layer.Layer<AiServiceRouter.AiModelResolver, never, OllamaSidecar> =
+const OllamaSidecarModelResolver: Layer.Layer<AiModelResolver.AiModelResolver, never, OllamaSidecar> =
   Layer.unwrapEffect(
     Effect.gen(function* () {
       const { endpoint } = yield* OllamaSidecar;
-      return AiServiceRouter.OllamaResolver({
-        host: endpoint,
+      return OllamaResolver.make({
+        endpoint,
         transformClient: HttpClient.withTracerPropagation(false),
       });
     }),

package/src/capabilities/react-surface.tsx

@@ -0,0 +1,29 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import React from 'react';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { Surface, useSettingsState } from '@dxos/app-framework/ui';
+import { AppSurface } from '@dxos/app-toolkit/ui';
+
+import { NativeSettings } from '#components';
+import { meta } from '#meta';
+import { type Settings } from '#types';
+
+export default Capability.makeModule(() =>
+  Effect.succeed(
+    Capability.contributes(Capabilities.ReactSurface, [
+      Surface.create({
+        id: 'plugin-settings',
+        filter: AppSurface.settings(AppSurface.Article, meta.id),
+        component: ({ data: { subject } }) => {
+          const { settings, updateSettings } = useSettingsState<Settings.Settings>(subject.atom);
+          return <NativeSettings settings={settings} onSettingsChange={updateSettings} />;
+        },
+      }),
+    ]),
+  ),
+);

package/src/capabilities/settings.ts

@@ -0,0 +1,31 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
+import { createKvsStore } from '@dxos/effect';
+
+import { meta } from '#meta';
+import { NativeCapabilities, Settings } from '#types';
+
+export default Capability.makeModule(() =>
+  Effect.sync(() => {
+    const settingsAtom = createKvsStore({
+      key: meta.id,
+      schema: Settings.Settings,
+      defaultValue: () => ({}),
+    });
+
+    return [
+      Capability.contributes(NativeCapabilities.Settings, settingsAtom),
+      Capability.contributes(AppCapabilities.Settings, {
+        prefix: meta.id,
+        schema: Settings.Settings,
+        atom: settingsAtom,
+      }),
+    ];
+  }),
+);

package/src/capabilities/spotlight-listener.ts

@@ -0,0 +1,58 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { LayoutOperation } from '@dxos/app-toolkit';
+import { log } from '@dxos/log';
+
+// TODO(wittjosiah): Formalize with a stricter schema if we evolve this protocol.
+type SpotlightInvokePayload = {
+  operation: string;
+  payload?: Record<string, any>;
+};
+
+/**
+ * Listens for spotlight:invoke events from the popover window and dispatches the corresponding operation.
+ */
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    const { invokePromise } = yield* Capability.get(Capabilities.OperationInvoker);
+
+    const unlisten = yield* Effect.promise(async () => {
+      const { listen } = await import('@tauri-apps/api/event');
+      const { getCurrentWindow } = await import('@tauri-apps/api/window');
+
+      return listen<SpotlightInvokePayload>('spotlight:invoke', async (event) => {
+        const { operation, payload } = event.payload;
+        log.info('Received spotlight invoke event', { operation, payload });
+        try {
+          switch (operation) {
+            case 'open':
+              await invokePromise(LayoutOperation.Open, payload as any);
+              break;
+            case 'switch-workspace':
+              await invokePromise(LayoutOperation.SwitchWorkspace, payload as any);
+              break;
+            default:
+              log.warn('Unknown spotlight operation', { operation });
+          }
+
+          const mainWindow = getCurrentWindow();
+          await mainWindow.show();
+          await mainWindow.setFocus();
+        } catch (err) {
+          log.catch(err);
+        }
+      });
+    });
+
+    return Capability.contributes(Capabilities.Null, null, () =>
+      Effect.sync(() => {
+        unlisten();
+      }),
+    );
+  }),
+);

package/src/capabilities/updater.ts

@@ -2,84 +2,193 @@
 // Copyright 2025 DXOS.org
 //
 
+import { Atom } from '@effect-atom/atom-react';
 import { type } from '@tauri-apps/plugin-os';
 import { relaunch } from '@tauri-apps/plugin-process';
-import { type DownloadEvent, check } from '@tauri-apps/plugin-updater';
+import * as Updater from '@tauri-apps/plugin-updater';
 import * as Duration from 'effect/Duration';
 import * as Effect from 'effect/Effect';
 import * as Fiber from 'effect/Fiber';
-import * as Function from 'effect/Function';
 import * as Match from 'effect/Match';
 import * as Schedule from 'effect/Schedule';
 
-import { Capabilities, LayoutAction, type PluginContext, contributes, createIntent } from '@dxos/app-framework';
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { LayoutOperation } from '@dxos/app-toolkit';
 import { log } from '@dxos/log';
 
-import { meta } from '../meta';
+import { meta } from '#meta';
+import { NativeCapabilities, type Update } from '#types';
+
+import { TAURI_LOCALHOST_PORT } from '../constants';
 
 const SUPPORTS_OTA = ['linux', 'macos', 'windows'];
 
-export default (context: PluginContext) => {
-  // Skip updates if not supported or in dev mode.
-  const platform = type();
-  if (!SUPPORTS_OTA.includes(platform) || window.location.hostname === 'localhost') {
-    return contributes(Capabilities.Null, null);
+/** Safe wrapper around Updater.check(). Distinguishes "no update" (ok with null update) from a thrown error. */
+const safeCheck = async (): Promise<{ ok: true; update: Updater.Update | null } | { ok: false; error: string }> => {
+  try {
+    return { ok: true, update: await Updater.check() };
+  } catch (error) {
+    log.error('failed to check for updates', { error });
+    return { ok: false, error: formatError(error) };
+  }
+};
+
+/** Safe wrapper around update.downloadAndInstall(). */
+const safeDownloadAndInstall = async (
+  update: Updater.Update,
+  onEvent: (event: Updater.DownloadEvent) => void,
+): Promise<{ ok: true } | { ok: false; error: string }> => {
+  try {
+    await update.downloadAndInstall(onEvent);
+    return { ok: true };
+  } catch (error) {
+    log.error('failed to download and install update', { error });
+    return { ok: false, error: formatError(error) };
   }
+};
+
+/** Extract a user-readable error string from whatever the Tauri updater threw. */
+const formatError = (error: unknown): string => {
+  if (typeof error === 'string') {
+    return error;
+  }
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+};
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    const platform = type();
+    const isDevServer = window.location.port !== TAURI_LOCALHOST_PORT;
+    const enabled = SUPPORTS_OTA.includes(platform) && !isDevServer;
+
+    const registry = yield* Capability.get(Capabilities.AtomRegistry);
+    const { invoke } = yield* Capability.get(Capabilities.OperationInvoker);
 
-  const { dispatch } = context.getCapability(Capabilities.IntentDispatcher);
+    const statusAtom = Atom.make<Update.Status>(enabled ? { kind: 'idle' } : { kind: 'unsupported' }).pipe(
+      Atom.keepAlive,
+    );
 
-  // https://tauri.app/plugin/updater/#checking-for-updates
-  const action = Effect.gen(function* () {
-    log.info('checking for updates');
-    const update = yield* Effect.tryPromise(() => check());
-    log.info('checked for updates', { version: update?.version, currentVersion: update?.currentVersion });
-    if (update) {
-      log.info('update available', update);
+    // Updater.Update is a class with instance methods (downloadAndInstall) and can't live in an
+    // atom value; cache it here between check and install.
+    let pendingUpdate: Updater.Update | null = null;
+
+    // Core: check for an update and update the status atom. Returns the update if available.
+    const doCheck = async (): Promise<Updater.Update | null> => {
+      registry.set(statusAtom, { kind: 'checking' });
+      log.info('checking for updates');
+      const result = await safeCheck();
+      if (!result.ok) {
+        pendingUpdate = null;
+        registry.set(statusAtom, { kind: 'failed', error: result.error });
+        return null;
+      }
+      const update = result.update;
+      if (!update?.available) {
+        pendingUpdate = null;
+        registry.set(statusAtom, { kind: 'up-to-date', checkedAt: Date.now() });
+        return null;
+      }
+      log.info('update available', { version: update.version });
+      pendingUpdate = update;
+      registry.set(statusAtom, { kind: 'available', version: update.version });
+      return update;
+    };
+
+    // Core: download + install the cached pending update, streaming progress to the status atom.
+    const doInstall = async (): Promise<boolean> => {
+      const update = pendingUpdate;
+      if (!update) {
+        return false;
+      }
       let downloaded = 0;
       let contentLength = 0;
-
-      const handleDownload = Match.type<DownloadEvent>().pipe(
+      registry.set(statusAtom, { kind: 'downloading', downloaded: 0, contentLength: 0 });
+      const onEvent = Match.type<Updater.DownloadEvent>().pipe(
         Match.when({ event: 'Started' }, (event) => {
           contentLength = event.data.contentLength ?? 0;
-          log.info('download started', { contentLength });
+          registry.set(statusAtom, { kind: 'downloading', downloaded, contentLength });
         }),
         Match.when({ event: 'Progress' }, (event) => {
           downloaded += event.data.chunkLength;
-          log.verbose('download progress', { downloaded, contentLength });
+          registry.set(statusAtom, { kind: 'downloading', downloaded, contentLength });
         }),
         Match.when({ event: 'Finished' }, () => {
           log.info('download completed');
         }),
         Match.exhaustive,
       );
+      const result = await safeDownloadAndInstall(update, onEvent);
+      if (result.ok) {
+        registry.set(statusAtom, { kind: 'ready' });
+        return true;
+      }
+      registry.set(statusAtom, { kind: 'failed', error: result.error });
+      return false;
+    };
 
-      yield* Effect.tryPromise(() => update.downloadAndInstall(handleDownload));
-
-      yield* dispatch(
-        createIntent(LayoutAction.AddToast, {
-          part: 'toast',
-          subject: {
-            id: `${meta.id}/update-ready`,
-            title: ['update ready label', { ns: meta.id }],
-            description: ['update ready description', { ns: meta.id }],
-            duration: Infinity,
-            actionLabel: ['update label', { ns: meta.id }],
-            actionAlt: ['update alt', { ns: meta.id }],
-            onAction: () => relaunch(),
-          },
-        }),
-      );
+    const manager: Update.Manager = {
+      status: statusAtom,
+      check: async () => {
+        if (!enabled) {
+          return;
+        }
+        await doCheck();
+      },
+      install: async () => {
+        if (!enabled) {
+          return;
+        }
+        await doInstall();
+      },
+      relaunch: async () => {
+        await relaunch();
+      },
+    };
+
+    const managerContribution = Capability.contributes(NativeCapabilities.UpdateManager, manager);
+
+    if (!enabled) {
+      log.info('updater disabled', { platform, port: window.location.port });
+      return [managerContribution];
     }
-  });
-
-  const fiber = Function.pipe(
-    // prettier-ignore
-    action,
-    Effect.repeat(Schedule.fixed(Duration.hours(1))),
-    Effect.runFork,
-  );
-
-  return contributes(Capabilities.Null, null, () => {
-    Effect.runSync(Fiber.interrupt(fiber));
-  });
-};
+
+    // Background flow: periodic check + auto-install + toast when ready.
+    // The toast is the entry point for users who weren't watching the settings panel.
+    const backgroundAction = Effect.gen(function* () {
+      const update = yield* Effect.promise(() => doCheck());
+      if (!update) {
+        return true;
+      }
+      const ok = yield* Effect.promise(() => doInstall());
+      if (!ok) {
+        return true;
+      }
+      yield* invoke(LayoutOperation.AddToast, {
+        id: `${meta.id}.update-ready`,
+        title: ['update-ready.label', { ns: meta.id }],
+        description: ['update-ready.description', { ns: meta.id }],
+        duration: Infinity,
+        actionLabel: ['update.label', { ns: meta.id }],
+        actionAlt: ['update.alt', { ns: meta.id }],
+        onAction: () => relaunch(),
+      });
+      return false;
+    });
+
+    const schedule = Schedule.fixed(Duration.hours(1)).pipe(
+      Schedule.whileInput((keepChecking: boolean) => keepChecking),
+    );
+    const fiber = yield* backgroundAction.pipe(Effect.repeat(schedule), Effect.forkDaemon);
+    log.info('updater module initialized, update check scheduled');
+
+    return [
+      managerContribution,
+      // Return the interruption effect directly; Fiber.interrupt is async and would throw
+      // AsyncFiberException if wrapped in Effect.runSync.
+      Capability.contributes(Capabilities.Null, null, () => Fiber.interrupt(fiber)),
+    ];
+  }),
+);