@dxos/app-framework 0.8.3 → 0.8.4-main.03d5cd7b56

package/dist/lib/browser/chunk-FJ4765WW.mjs.map

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

package/dist/lib/browser/chunk-FO3IYSLV.mjs

@@ -0,0 +1,68 @@
+// src/core/edge-registry-plugin-provider.ts
+import * as Effect from "effect/Effect";
+import { Context } from "@dxos/context";
+var __dxlog_file = "/__w/dxos/dxos/packages/sdk/app-framework/src/core/edge-registry-plugin-provider.ts";
+var toRegistryPlugin = (entry) => ({
+  id: entry.meta.id,
+  name: entry.meta.name,
+  description: entry.meta.description,
+  homePage: entry.meta.homePage,
+  source: entry.meta.source,
+  screenshots: entry.meta.screenshots ? [
+    ...entry.meta.screenshots
+  ] : void 0,
+  tags: entry.meta.tags ? [
+    ...entry.meta.tags
+  ] : void 0,
+  icon: entry.meta.icon,
+  iconHue: entry.meta.iconHue,
+  moduleUrl: entry.moduleUrl,
+  repo: entry.repo,
+  version: entry.releaseTag
+});
+var EdgeRegistryPluginProvider = class {
+  _client;
+  // Cached on first load so getPlugin/listVersions can resolve without re-fetching.
+  #cachedPlugins = [];
+  constructor(_client) {
+    this._client = _client;
+  }
+  listPlugins() {
+    return Effect.tryPromise({
+      try: () => this._client.getRegistryPlugins(Context.default(void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 56 })),
+      catch: (error) => error instanceof Error ? error : new Error(String(error))
+    }).pipe(Effect.map((body) => {
+      const plugins = body.plugins.filter((entry) => entry.health === "ok").map(toRegistryPlugin);
+      this.#cachedPlugins = plugins;
+      return plugins;
+    }));
+  }
+  listVersions(repo) {
+    const plugin = this.#cachedPlugins.find((candidate) => candidate.repo === repo);
+    if (!plugin) {
+      return Effect.fail(new Error(`Plugin not found in catalog: ${repo}`));
+    }
+    const version = {
+      tag: plugin.version,
+      moduleUrl: plugin.moduleUrl
+    };
+    return Effect.succeed([
+      version
+    ]);
+  }
+  getPlugin(repo, version) {
+    const plugin = this.#cachedPlugins.find((p) => p.repo === repo);
+    if (!plugin) {
+      return Effect.fail(new Error(`Plugin not found in catalog: ${repo}`));
+    }
+    if (version && version !== plugin.version) {
+      return Effect.fail(new Error(`Version ${version} not available for ${repo}; only ${plugin.version} is cached`));
+    }
+    return Effect.succeed(plugin);
+  }
+};
+
+export {
+  EdgeRegistryPluginProvider
+};
+//# sourceMappingURL=chunk-FO3IYSLV.mjs.map

package/dist/lib/browser/chunk-FO3IYSLV.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/core/edge-registry-plugin-provider.ts"],
+  "sourcesContent": ["//\n// Copyright 2026 DXOS.org\n//\n\nimport * as Effect from 'effect/Effect';\n\nimport { Context } from '@dxos/context';\nimport { type EdgeHttpClient } from '@dxos/edge-client';\nimport { type PluginEntry } from '@dxos/protocols';\n\nimport * as Registry from './registry';\n\n/**\n * Maps a wire-format `PluginEntry` (from `@dxos/protocols`) to a\n * `Registry.Plugin` (the app-framework domain type).\n *\n * This is the only translation seam between the two independently-defined type\n * hierarchies — fields are mapped explicitly, with no shared type between them.\n */\nconst toRegistryPlugin = (entry: PluginEntry): Registry.Plugin => ({\n  id: entry.meta.id,\n  name: entry.meta.name,\n  description: entry.meta.description,\n  homePage: entry.meta.homePage,\n  source: entry.meta.source,\n  screenshots: entry.meta.screenshots ? [...entry.meta.screenshots] : undefined,\n  tags: entry.meta.tags ? [...entry.meta.tags] : undefined,\n  icon: entry.meta.icon,\n  iconHue: entry.meta.iconHue,\n  moduleUrl: entry.moduleUrl,\n  repo: entry.repo,\n  version: entry.releaseTag,\n});\n\n/**\n * Implements `Registry.PluginProvider` against the Edge `/registry` HTTP endpoints.\n *\n * Lives in app-framework (rather than the more obvious home of `@dxos/edge-client`)\n * because edge-client doesn't depend on app-framework; siting the implementation\n * here keeps the dependency arrow `app-framework → edge-client` and avoids a\n * cycle. The class needs only the public `EdgeHttpClient` type, so a one-way\n * type-import is enough.\n *\n * `listVersions` is currently a stub: it returns the single latest version derived\n * from the cached plugin list, so the host's version picker has something to render.\n * The wire contract for the real endpoint already exists — see\n * `GetPluginVersionsResponseBodySchema` in `@dxos/protocols/edge/registry` and\n * {@link EdgeHttpClient.getRegistryPluginVersions} — so once Edge ships\n * `GET /registry/plugins/:repo/versions`, swap this stub for a call to\n * `this._client.getRegistryPluginVersions(...)` and map each entry through a\n * `toRegistryPluginVersion` helper (mirror of {@link toRegistryPlugin}).\n */\nexport class EdgeRegistryPluginProvider implements Registry.PluginProvider {\n  // Cached on first load so getPlugin/listVersions can resolve without re-fetching.\n  #cachedPlugins: readonly Registry.Plugin[] = [];\n\n  constructor(private readonly _client: EdgeHttpClient) {}\n\n  listPlugins(): Effect.Effect<readonly Registry.Plugin[], Error> {\n    return Effect.tryPromise({\n      try: () => this._client.getRegistryPlugins(Context.default()),\n      catch: (error) => (error instanceof Error ? error : new Error(String(error))),\n    }).pipe(\n      Effect.map((body) => {\n        const plugins = body.plugins.filter((entry) => entry.health === 'ok').map(toRegistryPlugin);\n        this.#cachedPlugins = plugins;\n        return plugins;\n      }),\n    );\n  }\n\n  listVersions(repo: string): Effect.Effect<readonly Registry.PluginVersion[], Error> {\n    // Stub: return only the currently-known version until Edge implements the versions endpoint.\n    const plugin = this.#cachedPlugins.find((candidate) => candidate.repo === repo);\n    if (!plugin) {\n      return Effect.fail(new Error(`Plugin not found in catalog: ${repo}`));\n    }\n    const version: Registry.PluginVersion = { tag: plugin.version, moduleUrl: plugin.moduleUrl };\n    return Effect.succeed([version]);\n  }\n\n  getPlugin(repo: string, version?: string): Effect.Effect<Registry.Plugin, Error> {\n    const plugin = this.#cachedPlugins.find((p) => p.repo === repo);\n    if (!plugin) {\n      return Effect.fail(new Error(`Plugin not found in catalog: ${repo}`));\n    }\n    if (version && version !== plugin.version) {\n      return Effect.fail(new Error(`Version ${version} not available for ${repo}; only ${plugin.version} is cached`));\n    }\n    return Effect.succeed(plugin);\n  }\n}\n"],
+  "mappings": ";AAIA,YAAYA,YAAY;AAExB,SAASC,eAAe;AAMxB,IAAA,eAAA;IASEC,mBAAqB,CAAA,WAAA;EACrBC,IAAAA,MAAAA,KAAaC;EACbC,MAAAA,MAAUD,KAAME;EAChBC,aAAQH,MAAWG,KAAAA;EACnBC,UAAAA,MAAaJ,KAAME;UAAuBF,MAAME,KAAKE;eAAeC,MAAAA,KAAAA,cAAAA;IACpEC,GAAMN,MAAME,KAAKI;;QAA8BD,MAAAA,KAAAA,OAAAA;IAC/CE,GAAMP,MAAME,KAAKK;EACjBC,IAAAA;EACAC,MAAAA,MAAWT,KAAMS;EACjBC,SAAMV,MAAMU,KAAI;EAChBC,WAASX,MAAMY;EACjB,MAAA,MAAA;EAEA,SAAA,MAAA;;AAmBE,IAAA,6BAAA,MAAA;EACA;;mBAE6BC,CAAAA;EAA0B,YAAA,SAAA;AAEvDC,SAAAA,UAAgE;;gBAEvD;WACGC,kBAAWA;MAClBC,KACDpB,MAAAA,KAAU,QAAEqB,mBAAAA,QAAAA,QAAAA,QAAAA,EAAAA,YAAAA,YAAAA,GAAAA,cAAAA,GAAAA,GAAAA,CAAAA,CAAAA;MACV,OAAMC,CAAAA,UAAUD,iBAAaE,QAAQnB,QAAUA,IAAMoB,MAAM,OAAK,KAAS,CAACC;YACrE,WAAA,CAAA,SAAiBH;AACtB,YAAA,UAAOA,KAAAA,QAAAA,OAAAA,CAAAA,UAAAA,MAAAA,WAAAA,IAAAA,EAAAA,IAAAA,gBAAAA;AACT,WAAA,iBAAA;AAEJ,aAAA;IAEAI,CAAAA,CAAAA;;eAEQC,MAAS;UAEb,SAAO3B,KAAO4B,eAAgB,KAAA,CAAA,cAAA,UAA6B,SAAQ,IAAA;AACrE,QAAA,CAAA,QAAA;AACA,aAAwC,YAAA,IAAA,MAAA,gCAAA,IAAA,EAAA,CAAA;;UAAuBf,UAAWc;MAAiB,KAAA,OAAA;MAC3F,WAAcE,OAAQ;;WAAS,eAAA;MACjC;IAEAC,CAAAA;;YAEOH,MAAAA,SAAQ;UACX,SAAO3B,KAAO4B,eAAgB,KAAA,CAAA,MAAA,EAAA,SAAA,IAAA;AAChC,QAAA,CAAA,QAAA;AACIb,aAAWA,YAAAA,IAAYY,MAAAA,gCAAgB,IAAA,EAAA,CAAA;;AAE3C,QAAA,WAAA,YAAA,OAAA,SAAA;AACA,aAAcE,YAAQF,IAAAA,MAAAA,WAAAA,OAAAA,sBAAAA,IAAAA,UAAAA,OAAAA,OAAAA,YAAAA,CAAAA;IACxB;AACF,WAAA,eAAA,MAAA;;;",
+  "names": ["Effect", "Context", "name", "description", "entry", "homePage", "meta", "source", "screenshots", "undefined", "tags", "icon", "iconHue", "moduleUrl", "repo", "version", "releaseTag", "_client", "listPlugins", "error", "pipe", "body", "plugins", "filter", "health", "toRegistryPlugin", "listVersions", "plugin", "fail", "succeed", "getPlugin"]
+}

package/dist/lib/browser/chunk-J5LGTIGS.mjs

@@ -0,0 +1,10 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export {
+  __export
+};
+//# sourceMappingURL=chunk-J5LGTIGS.mjs.map

package/dist/lib/browser/chunk-JD3Z5NEF.mjs

@@ -0,0 +1,469 @@
+import {
+  PluginManagerProvider,
+  topologicalSort,
+  usePluginManager
+} from "./chunk-7VZJR2OA.mjs";
+import {
+  PluginManagerContext
+} from "./chunk-FJ4765WW.mjs";
+import {
+  capabilities_exports
+} from "./chunk-WBHCSOBW.mjs";
+import {
+  activation_events_exports
+} from "./chunk-45CHLTBV.mjs";
+import {
+  plugin_manager_exports
+} from "./chunk-NBXPP7JR.mjs";
+
+// src/ui/components/App/App.tsx
+import React2, { useEffect as useEffect3 } from "react";
+
+// src/ui/hooks/useApp.tsx
+import { RegistryContext } from "@effect-atom/atom-react";
+import * as Effect from "effect/Effect";
+import * as Fiber from "effect/Fiber";
+import * as PubSub from "effect/PubSub";
+import * as Queue from "effect/Queue";
+import React, { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { runAndForwardErrors } from "@dxos/effect";
+import { invariant } from "@dxos/invariant";
+import { log } from "@dxos/log";
+import { ErrorBoundary, ErrorFallback } from "@dxos/react-error-boundary";
+import { useAsyncEffect, useDefaultValue } from "@dxos/react-hooks";
+import { ContextProtocolProvider } from "@dxos/web-context-react";
+var __dxlog_file = "/__w/dxos/dxos/packages/sdk/app-framework/src/ui/hooks/useApp.tsx";
+var ENABLED_KEY = "org.dxos.app-framework.enabled";
+var useApp = ({ pluginManager, pluginLoader: pluginLoaderProp, onPluginRemove, pluginRegistryProvider, plugins: pluginsProp, core: coreProp, defaults: defaultsProp, setupEvents: setupEventsProp, placeholder, fallback = ErrorFallback, cacheEnabled = false, safeMode = false, debounce = 0, timeout = 3e4 }) => {
+  const plugins = useDefaultValue(pluginsProp, () => []);
+  const core = useDefaultValue(coreProp, () => plugins.map(({ meta }) => meta.id));
+  const defaults = useDefaultValue(defaultsProp, () => []);
+  const setupEvents = useDefaultValue(setupEventsProp, () => []);
+  const pluginLoader = useMemo(() => pluginLoaderProp ?? ((id) => Effect.sync(() => {
+    const plugin = plugins.find((plugin2) => plugin2.meta.id === id);
+    invariant(plugin, `Plugin not found: ${id}`, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 52, S: void 0, A: ["plugin", "`Plugin not found: ${id}`"] });
+    return {
+      plugin
+    };
+  })), [
+    pluginLoaderProp,
+    plugins
+  ]);
+  const readyRef = useRef(false);
+  const [ready, setReady] = useState(false);
+  const errorRef = useRef(null);
+  const [error, setError] = useState(null);
+  const [startupProgress, setStartupProgress] = useState({
+    activated: 0,
+    total: 0,
+    progress: 0
+  });
+  const cached = useMemo(() => JSON.parse(localStorage.getItem(ENABLED_KEY) ?? "[]"), []);
+  const enabled = useMemo(() => safeMode ? [] : cacheEnabled && cached.length > 0 ? cached : defaults, [
+    safeMode,
+    cacheEnabled,
+    cached,
+    defaults
+  ]);
+  const isExternalManager = !!pluginManager;
+  const manager = useMemo(() => {
+    const mgr = pluginManager ?? plugin_manager_exports.make({
+      pluginLoader,
+      plugins,
+      core,
+      enabled,
+      onRemove: onPluginRemove,
+      pluginRegistryProvider
+    });
+    log("useApp: useMemo created/reused manager", {
+      provided: !!pluginManager
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 87, S: void 0 });
+    return mgr;
+  }, [
+    pluginManager,
+    pluginLoader,
+    plugins,
+    core,
+    enabled,
+    onPluginRemove,
+    pluginRegistryProvider
+  ]);
+  useEffect(() => {
+    if (!cacheEnabled) {
+      return;
+    }
+    return manager.registry.subscribe(manager.enabled, (value) => {
+      localStorage.setItem(ENABLED_KEY, JSON.stringify(value));
+    });
+  }, [
+    cacheEnabled,
+    manager
+  ]);
+  useEffect(() => {
+    setupDevtools(manager);
+  }, [
+    manager
+  ]);
+  useAsyncEffect(async () => {
+    log("useApp: effect mount", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 117, S: void 0 });
+    manager.capabilities.contribute({
+      interface: capabilities_exports.PluginManager,
+      implementation: manager,
+      module: "org.dxos.app-framework.plugin-manager"
+    });
+    manager.capabilities.contribute({
+      interface: capabilities_exports.AtomRegistry,
+      implementation: manager.registry,
+      module: "org.dxos.app-framework.atom-registry"
+    });
+    const fiber = Effect.gen(function* () {
+      const queue = yield* PubSub.subscribe(manager.activation);
+      const listener = yield* Effect.forkDaemon(Queue.take(queue).pipe(Effect.tap(({ event, state, module, error: error$ }) => Effect.sync(() => {
+        if (event === activation_events_exports.Startup.id && state === "activated" && !module) {
+          clearTimeout(timeoutId);
+          setReady(true);
+          readyRef.current = true;
+          globalThis.composer?.profiler?.dump();
+          if (typeof window !== "undefined") {
+            window.dispatchEvent(new CustomEvent("app-framework:startup-activated"));
+          }
+          return;
+        }
+        if (module && state === "activating" && !readyRef.current) {
+          setStartupProgress((current) => ({
+            ...current,
+            // `event` here is the activation event that first
+            // triggered this module load (plumbed through
+            // `_loadCapabilitiesForModules` → `_loadModule`).
+            // Falsy/empty falls back to undefined so consumers can
+            // tell "no parent context" from "parent context: <X>".
+            event: event || void 0,
+            module,
+            humanizedName: humanizeModuleId(module)
+          }));
+        }
+        if (module && state === "activated" && !readyRef.current) {
+          const active = manager.getActive();
+          const total = manager.getModules().length;
+          setStartupProgress((current) => ({
+            ...current,
+            activated: active.length,
+            total,
+            progress: total > 0 ? active.length / total : 0
+          }));
+        }
+        if (event && !module && state === "activating" && !readyRef.current) {
+          setStartupProgress((current) => ({
+            ...current,
+            event,
+            module: void 0,
+            humanizedName: humanizeEventKey(event)
+          }));
+        }
+        if (error$ && !readyRef.current) {
+          setError(error$);
+          errorRef.current = error$;
+        }
+      })), Effect.forever));
+      yield* Effect.all([
+        ...setupEvents.map((event) => manager.activate(event)),
+        manager.activate(activation_events_exports.SetupReactSurface),
+        manager.activate(activation_events_exports.Startup)
+      ]);
+      return yield* Fiber.join(listener);
+    }).pipe(Effect.scoped, Effect.runFork);
+    const timeoutId = setTimeout(() => {
+      if (!readyRef.current && !errorRef.current) {
+        log.warn("startup timeout diagnostic", {
+          eventsFired: manager.getEventsFired(),
+          activeModules: manager.getActive(),
+          pendingReset: manager.getPendingReset()
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 224, S: void 0 });
+        void runAndForwardErrors(Fiber.interrupt(fiber));
+        setError(new Error(`Startup timed out after ${timeout}ms`));
+      }
+    }, timeout);
+    return () => {
+      log("useApp: effect cleanup", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 234, S: void 0 });
+      clearTimeout(timeoutId);
+      void runAndForwardErrors(Fiber.interrupt(fiber));
+      if (!isExternalManager) {
+        void runAndForwardErrors(manager.shutdown());
+      }
+    };
+  }, [
+    manager
+  ]);
+  const progressRef = useRef(startupProgress);
+  progressRef.current = startupProgress;
+  return useCallback(() => /* @__PURE__ */ React.createElement(ErrorBoundary, {
+    name: "app",
+    FallbackComponent: fallback
+  }, /* @__PURE__ */ React.createElement(PluginManagerProvider, {
+    value: manager
+  }, /* @__PURE__ */ React.createElement(ContextProtocolProvider, {
+    value: manager,
+    context: PluginManagerContext
+  }, /* @__PURE__ */ React.createElement(RegistryContext.Provider, {
+    value: manager.registry
+  }, /* @__PURE__ */ React.createElement(App, {
+    placeholder,
+    ready,
+    error,
+    debounce,
+    progress: progressRef.current
+  }))))), [
+    fallback,
+    manager,
+    placeholder,
+    ready,
+    error
+  ]);
+};
+var setupDevtools = (manager) => {
+  globalThis.composer ??= {};
+  globalThis.composer.manager = manager;
+};
+var humanizeModuleId = (moduleId) => {
+  const match = moduleId.match(/\.plugin\.([^.]+)\.module\.(.+)$/);
+  if (!match) {
+    const parts = moduleId.split(".");
+    return parts[parts.length - 1];
+  }
+  const [, pluginSlug, moduleName] = match;
+  const pluginLabel = pluginSlug.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+  const moduleLabel = moduleName.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2").toLowerCase();
+  if (moduleLabel === pluginSlug) {
+    return pluginLabel;
+  }
+  return `${pluginLabel}: ${moduleLabel}`;
+};
+var humanizeEventKey = (eventKey) => {
+  const id = eventKey.split(":")[0];
+  const match = id.match(/\.event\.(.+)$/);
+  const slug = match ? match[1] : id.split(".").pop() ?? id;
+  return slug.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+};
+
+// src/ui/hooks/useCapabilities.ts
+import { useAtomValue } from "@effect-atom/atom-react";
+import { useCallback as useCallback2 } from "react";
+import { invariant as invariant2 } from "@dxos/invariant";
+var __dxlog_file2 = "/__w/dxos/dxos/packages/sdk/app-framework/src/ui/hooks/useCapabilities.ts";
+var useCapabilities = (interfaceDef) => {
+  const manager = usePluginManager();
+  return useAtomValue(manager.capabilities.atom(interfaceDef));
+};
+var useCapability = (interfaceDef) => {
+  const capabilities = useCapabilities(interfaceDef);
+  invariant2(capabilities.length > 0, `No capability found for ${interfaceDef.identifier}`, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 22, S: void 0, A: ["capabilities.length > 0", "`No capability found for ${interfaceDef.identifier}`"] });
+  return capabilities[0];
+};
+var useAtomCapability = (atomCapability) => {
+  const atom = useCapability(atomCapability);
+  return useAtomValue(atom);
+};
+var useAtomCapabilityState = (atomCapability) => {
+  const registry = useCapability(capabilities_exports.AtomRegistry);
+  const atom = useCapability(atomCapability);
+  const value = useAtomValue(atom);
+  const update = useCallback2((fn) => {
+    registry.set(atom, fn(registry.get(atom)));
+  }, [
+    registry,
+    atom
+  ]);
+  return [
+    value,
+    update
+  ];
+};
+var useOperationInvoker = () => useCapability(capabilities_exports.OperationInvoker);
+
+// src/ui/hooks/useLoading.tsx
+import { useEffect as useEffect2, useRef as useRef2, useState as useState2 } from "react";
+var LoadingState = /* @__PURE__ */ (function(LoadingState2) {
+  LoadingState2[LoadingState2["Loading"] = 0] = "Loading";
+  LoadingState2[LoadingState2["FadeIn"] = 1] = "FadeIn";
+  LoadingState2[LoadingState2["FadeOut"] = 2] = "FadeOut";
+  LoadingState2[LoadingState2["Done"] = 3] = "Done";
+  return LoadingState2;
+})({});
+var useLoading = (ready, debounce = 0) => {
+  const [stage, setStage] = useState2(0);
+  const readyRef = useRef2(ready);
+  readyRef.current = ready;
+  useEffect2(() => {
+    if (!debounce) {
+      return;
+    }
+    const i = setInterval(() => {
+      setStage((stage2) => {
+        const isReady = readyRef.current;
+        switch (stage2) {
+          case 0: {
+            if (!isReady) {
+              return 1;
+            }
+            clearInterval(i);
+            return 3;
+          }
+          case 1: {
+            if (isReady) {
+              return 2;
+            }
+            break;
+          }
+          case 2: {
+            clearInterval(i);
+            return 3;
+          }
+        }
+        return stage2;
+      });
+    }, debounce);
+    return () => clearInterval(i);
+  }, [
+    debounce
+  ]);
+  if (!debounce) {
+    return ready ? 3 : 0;
+  }
+  return stage;
+};
+
+// src/ui/hooks/useSettingsState.ts
+import { RegistryContext as RegistryContext2, useAtomValue as useAtomValue2 } from "@effect-atom/atom-react";
+import { useCallback as useCallback3, useContext } from "react";
+var useSettingsState = (atom) => {
+  const registry = useContext(RegistryContext2);
+  const settings = useAtomValue2(atom);
+  const updateSettings = useCallback3((fn) => {
+    registry.set(atom, fn(registry.get(atom)));
+  }, [
+    registry,
+    atom
+  ]);
+  return {
+    settings,
+    updateSettings
+  };
+};
+
+// src/ui/components/App/App.tsx
+var FIRST_INTERACTIVE_MARK = "app-framework:first-interactive";
+var App = ({ placeholder: Placeholder2, ready, error, debounce, progress }) => {
+  const reactContexts = useCapabilities(capabilities_exports.ReactContext);
+  const reactRoots = useCapabilities(capabilities_exports.ReactRoot);
+  const stage = useLoading(ready, debounce);
+  const placeholderDismissed = stage >= LoadingState.Done;
+  useEffect3(() => {
+    if (!placeholderDismissed) {
+      return;
+    }
+    if (performance.getEntriesByName(FIRST_INTERACTIVE_MARK).length === 0) {
+      performance.mark(FIRST_INTERACTIVE_MARK);
+    }
+    window.__bootLoader?.dismiss?.();
+  }, [
+    placeholderDismissed
+  ]);
+  if (error) {
+    throw error;
+  }
+  if (!placeholderDismissed) {
+    if (!Placeholder2) {
+      return null;
+    }
+    return /* @__PURE__ */ React2.createElement(Placeholder2, {
+      stage,
+      progress
+    });
+  }
+  const ComposedContext = composeContexts(reactContexts);
+  return /* @__PURE__ */ React2.createElement(ComposedContext, null, reactRoots.map(({ id, root: Component }) => /* @__PURE__ */ React2.createElement(Component, {
+    key: id
+  })));
+};
+var composeContexts = (contexts) => {
+  if (contexts.length === 0) {
+    return ({ children }) => /* @__PURE__ */ React2.createElement(React2.Fragment, null, children);
+  }
+  return topologicalSort(contexts).map(({ context }) => context).reduce((Acc, Next) => ({ children }) => /* @__PURE__ */ React2.createElement(Acc, null, /* @__PURE__ */ React2.createElement(Next, null, children)));
+};
+
+// src/ui/components/Placeholder/Placeholder.tsx
+import React3, { useEffect as useEffect4, useLayoutEffect, useRef as useRef3 } from "react";
+import { ThemeProvider } from "@dxos/react-ui";
+import { defaultTx, mx } from "@dxos/ui-theme";
+var Placeholder = ({ stage = 1, progress, logo }) => {
+  if (location.search === "?throw") {
+    throw new Error("Test error");
+  }
+  useEffect4(() => {
+    if (stage >= 2) {
+      return;
+    }
+    const fraction = progress?.progress ?? 0;
+    window.__bootLoader?.progress(0.5 + fraction * 0.5);
+    if (progress?.humanizedName) {
+      window.__bootLoader?.status({
+        event: progress.event,
+        module: progress.module,
+        humanized: `Activating ${progress.humanizedName}`
+      });
+    }
+  }, [
+    stage,
+    progress?.progress,
+    progress?.event,
+    progress?.module,
+    progress?.humanizedName
+  ]);
+  useLayoutEffect(() => {
+    if (stage >= 2) {
+      window.__bootLoader?.dismiss();
+    }
+  }, [
+    stage
+  ]);
+  const stageRef = useRef3(stage);
+  stageRef.current = stage;
+  useEffect4(() => {
+    return () => {
+      if (stageRef.current >= 3) {
+        window.__bootLoader?.dismiss();
+      }
+    };
+  }, []);
+  if (stage < 2) {
+    return null;
+  }
+  const logoClassName = mx("h-[300px] w-[300px] scale-600 transition-all duration-500 ease-in-out filter grayscale opacity-0", stage >= 1 && "scale-100 grayscale-0 opacity-70", stage >= 2 && "scale-50 opacity-0");
+  return /* @__PURE__ */ React3.createElement(ThemeProvider, {
+    tx: defaultTx
+  }, /* @__PURE__ */ React3.createElement("div", {
+    className: "relative dx-container h-dvh flex flex-col"
+  }, /* @__PURE__ */ React3.createElement("div", {
+    className: "flex flex-col grow justify-center items-center"
+  }, typeof logo === "function" ? logo({
+    className: logoClassName
+  }) : logo ? /* @__PURE__ */ React3.createElement("div", {
+    className: logoClassName
+  }, logo) : null)));
+};
+
+export {
+  useApp,
+  useCapabilities,
+  useCapability,
+  useAtomCapability,
+  useAtomCapabilityState,
+  useOperationInvoker,
+  LoadingState,
+  useLoading,
+  useSettingsState,
+  App,
+  Placeholder
+};
+//# sourceMappingURL=chunk-JD3Z5NEF.mjs.map