@dxos/plugin-native 0.8.4-main.c85a9c8dae → 0.8.4-main.d9fc60f731

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/plugin-native",
-  "version": "0.8.4-main.c85a9c8dae",
+  "version": "0.8.4-main.d9fc60f731",
   "description": "Composer plugin that runs when on a native device.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -8,50 +8,98 @@
     "type": "git",
     "url": "https://github.com/dxos/dxos"
   },
-  "license": "MIT",
+  "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"
+    },
+    "./assets/PLUGIN.mdl": "./PLUGIN.mdl",
+    "./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"
+    "src",
+    "PLUGIN.mdl"
   ],
   "dependencies": {
-    "@effect/platform": "0.94.4",
-    "@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.19.16",
-    "@dxos/ai": "0.8.4-main.c85a9c8dae",
-    "@dxos/app-toolkit": "0.8.4-main.c85a9c8dae",
-    "@dxos/app-framework": "0.8.4-main.c85a9c8dae",
-    "@dxos/log": "0.8.4-main.c85a9c8dae",
-    "@dxos/plugin-assistant": "0.8.4-main.c85a9c8dae",
-    "@dxos/operation": "0.8.4-main.c85a9c8dae",
-    "@dxos/plugin-help": "0.8.4-main.c85a9c8dae",
-    "@dxos/util": "0.8.4-main.c85a9c8dae",
-    "@dxos/plugin-navtree": "0.8.4-main.c85a9c8dae"
+    "@effect-atom/atom-react": "^0.5.0",
+    "@effect/platform": "0.96.1",
+    "@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.d9fc60f731",
+    "@dxos/app-toolkit": "0.8.4-main.d9fc60f731",
+    "@dxos/app-framework": "0.8.4-main.d9fc60f731",
+    "@dxos/effect": "0.8.4-main.d9fc60f731",
+    "@dxos/log": "0.8.4-main.d9fc60f731",
+    "@dxos/keys": "0.8.4-main.d9fc60f731",
+    "@dxos/plugin-assistant": "0.8.4-main.d9fc60f731",
+    "@dxos/util": "0.8.4-main.d9fc60f731"
   },
   "devDependencies": {
-    "vite": "^7.1.11",
-    "@dxos/react-ui": "0.8.4-main.c85a9c8dae"
+    "@types/react": "~19.2.7",
+    "effect": "3.21.2",
+    "react": "~19.2.3",
+    "vite": "^8.0.14",
+    "@dxos/plugin-testing": "0.8.4-main.d9fc60f731",
+    "@dxos/react-ui-form": "0.8.4-main.d9fc60f731",
+    "@dxos/react-ui": "0.8.4-main.d9fc60f731"
   },
   "peerDependencies": {
-    "effect": "3.19.16",
-    "@dxos/react-ui": "0.8.4-main.c85a9c8dae"
+    "effect": "3.21.2",
+    "react": "~19.2.3",
+    "@dxos/react-ui": "0.8.4-main.d9fc60f731",
+    "@dxos/react-ui-form": "0.8.4-main.d9fc60f731"
   },
   "publishConfig": {
     "access": "public"

package/src/NativePlugin.tsx

@@ -6,26 +6,36 @@ 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';
+
+// eslint-disable-next-line import/no-relative-packages
+import pluginSpec from '../PLUGIN.mdl?raw';
 
 export const NativePlugin = Plugin.define(meta).pipe(
+  AppPlugin.addSettingsModule({ activate: NativeSettings }),
+  AppPlugin.addSurfaceModule({ activate: ReactSurface }),
   AppPlugin.addTranslationsModule({ translations }),
   Plugin.addModule({
-    id: 'updater',
-    activatesOn: ActivationEvents.OperationInvokerReady,
-    activate: Updater,
+    id: 'spotlight-listener',
+    activatesOn: ActivationEvents.ProcessManagerReady,
+    activate: SpotlightListener,
   }),
   Plugin.addModule({
-    id: 'window',
-    activatesOn: ActivationEvents.OperationInvokerReady,
-    activate: Window,
+    id: 'updater',
+    activatesOn: ActivationEvents.ProcessManagerReady,
+    activate: Updater,
   }),
   Plugin.addModule({
     id: 'ollama',
     activatesOn: AssistantEvents.SetupAiServiceProviders,
     activate: Ollama,
   }),
+  AppPlugin.addPluginAssetModule({
+    asset: { pluginId: meta.id, path: 'PLUGIN.mdl', content: pluginSpec, mimeType: 'application/x-mdl' },
+  }),
   Plugin.make,
 );
+
+export default NativePlugin;

package/src/capabilities/index.ts

@@ -2,6 +2,10 @@
 // Copyright 2025 DXOS.org
 //
 
-export * from './ollama';
-export * from './updater';
-export * from './window';
+import { Capability } from '@dxos/app-framework';
+
+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/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: 'pluginSettings',
+        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

@@ -0,0 +1,194 @@
+//
+// 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 * 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 Match from 'effect/Match';
+import * as Schedule from 'effect/Schedule';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { LayoutOperation } from '@dxos/app-toolkit';
+import { log } from '@dxos/log';
+
+import { meta } from '#meta';
+import { NativeCapabilities, type Update } from '#types';
+
+import { TAURI_LOCALHOST_PORT } from '../constants';
+
+const SUPPORTS_OTA = ['linux', 'macos', 'windows'];
+
+/** 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 statusAtom = Atom.make<Update.Status>(enabled ? { kind: 'idle' } : { kind: 'unsupported' }).pipe(
+      Atom.keepAlive,
+    );
+
+    // 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;
+      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;
+          registry.set(statusAtom, { kind: 'downloading', downloaded, contentLength });
+        }),
+        Match.when({ event: 'Progress' }, (event) => {
+          downloaded += event.data.chunkLength;
+          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;
+    };
+
+    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];
+    }
+
+    // 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)),
+    ];
+  }),
+);

package/src/components/NativeSettings/NativeSettings.tsx

@@ -0,0 +1,132 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { useAtomValue } from '@effect-atom/atom-react';
+import { formatDistanceToNow } from 'date-fns/formatDistanceToNow';
+import * as Match from 'effect/Match';
+import React, { type ReactNode, useState } from 'react';
+
+import { useCapability } from '@dxos/app-framework/ui';
+import { type AppSurface } from '@dxos/app-toolkit/ui';
+import { Button, useTranslation } from '@dxos/react-ui';
+import { Settings as SettingsForm } from '@dxos/react-ui-form';
+
+import { meta } from '#meta';
+import { NativeCapabilities, type Settings, type Update } from '#types';
+
+export type NativeSettingsProps = AppSurface.SettingsArticleProps<Settings.Settings>;
+
+type Pending = null | 'check' | 'install' | 'relaunch';
+
+type UpdateActions = {
+  onCheck: () => Promise<void>;
+  onInstall: () => Promise<void>;
+  onRelaunch: () => Promise<void>;
+};
+
+type UpdateRow = { description: string; button: ReactNode };
+
+export const NativeSettings = (_props: NativeSettingsProps) => {
+  const { t } = useTranslation(meta.id);
+  const manager = useCapability(NativeCapabilities.UpdateManager);
+  const status = useAtomValue(manager.status);
+
+  // UI-level pending flag. The status atom can flip between `checking` and `up-to-date` faster
+  // than the user can perceive, so we also gate the button on the click handler's lifetime to
+  // guarantee no duplicate triggers and a visible busy state.
+  const [pending, setPending] = useState<Pending>(null);
+
+  const runAction = (kind: Exclude<Pending, null>, action: () => Promise<void>) => async () => {
+    setPending(kind);
+    try {
+      await action();
+    } finally {
+      setPending(null);
+    }
+  };
+
+  const { description, button } = renderUpdateRow(status, pending, t, {
+    onCheck: runAction('check', manager.check),
+    onInstall: runAction('install', manager.install),
+    onRelaunch: runAction('relaunch', manager.relaunch),
+  });
+
+  return (
+    <SettingsForm.Viewport>
+      <SettingsForm.Section title={t('settings.title')}>
+        <SettingsForm.Item title={t('settings.updates.label')} description={description}>
+          {button}
+        </SettingsForm.Item>
+      </SettingsForm.Section>
+    </SettingsForm.Viewport>
+  );
+};
+
+const renderUpdateRow = (
+  status: Update.Status,
+  pending: Pending,
+  t: (key: string, options?: Record<string, unknown>) => string,
+  { onCheck, onInstall, onRelaunch }: UpdateActions,
+): UpdateRow => {
+  const isChecking = pending === 'check' || status.kind === 'checking';
+  const isInstalling = pending === 'install' || status.kind === 'downloading';
+
+  const checkButton = (disabled = false) => (
+    <Button disabled={disabled || isChecking || isInstalling || pending === 'relaunch'} onClick={() => void onCheck()}>
+      {isChecking ? t('settings.updates.checking.label') : t('settings.updates.check.label')}
+    </Button>
+  );
+
+  return Match.value(status).pipe(
+    Match.withReturnType<UpdateRow>(),
+    Match.when({ kind: 'unsupported' }, () => ({
+      description: t('settings.updates.unsupported.message'),
+      button: checkButton(true),
+    })),
+    Match.when({ kind: 'idle' }, () => ({
+      description: isChecking ? t('settings.updates.checking.message') : t('settings.updates.idle.message'),
+      button: checkButton(),
+    })),
+    Match.when({ kind: 'checking' }, () => ({
+      description: t('settings.updates.checking.message'),
+      button: checkButton(),
+    })),
+    Match.when({ kind: 'up-to-date' }, (s) => ({
+      description: isChecking
+        ? t('settings.updates.checking.message')
+        : t('settings.updates.up-to-date.message', {
+            checkedAt: formatDistanceToNow(new Date(s.checkedAt), { addSuffix: true }),
+          }),
+      button: checkButton(),
+    })),
+    Match.when({ kind: 'available' }, (s) => ({
+      description: t('settings.updates.available.message', { version: s.version }),
+      button: (
+        <Button variant='primary' disabled={isInstalling} onClick={() => void onInstall()}>
+          {isInstalling ? t('settings.updates.downloading.label') : t('settings.updates.update-now.label')}
+        </Button>
+      ),
+    })),
+    Match.when({ kind: 'downloading' }, (s) => {
+      const percent = s.contentLength > 0 ? Math.round((s.downloaded / s.contentLength) * 100) : 0;
+      return {
+        description: t('settings.updates.downloading.message', { percent }),
+        button: <Button disabled>{t('settings.updates.downloading.label')}</Button>,
+      };
+    }),
+    Match.when({ kind: 'ready' }, () => ({
+      description: t('settings.updates.ready.message'),
+      button: (
+        <Button variant='primary' disabled={pending === 'relaunch'} onClick={() => void onRelaunch()}>
+          {t('settings.updates.relaunch.label')}
+        </Button>
+      ),
+    })),
+    Match.when({ kind: 'failed' }, (s) => ({
+      description: t('settings.updates.failed.message', { error: s.error }),
+      button: checkButton(),
+    })),
+    Match.exhaustive,
+  );
+};

package/src/components/NativeSettings/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export { NativeSettings as default } from './NativeSettings';

package/src/components/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type ComponentType, lazy } from 'react';
+
+export const NativeSettings: ComponentType<any> = lazy(() => import('./NativeSettings'));

package/src/constants.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+/// Stable port for the Tauri localhost asset server in production builds.
+/// Must match LOCALHOST_PORT in src-tauri/src/lib.rs.
+export const TAURI_LOCALHOST_PORT = '26777';

package/src/index.ts

@@ -2,6 +2,4 @@
 // Copyright 2023 DXOS.org
 //
 
-export * from './capabilities';
 export * from './meta';
-export * from './NativePlugin';