@dxos/app-framework 0.8.4-main.3eb6e50203 → 0.8.4-main.3fbcb4aa9b

package/dist/lib/node-esm/capability-JOIQ2MQE.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/plugin-operation/history/capability.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Effect from 'effect/Effect';\n\nimport { OperationInvoker } from '@dxos/operation';\n\nimport { Capabilities } from '../../common';\nimport { Capability } from '../../core';\nimport * as HistoryTracker from './history-tracker';\nimport * as UndoRegistry from './undo-registry';\n\n//\n// Capability Module - contributes both UndoRegistry and HistoryTracker.\n//\n\nexport default Capability.makeModule(\n  Effect.fnUntraced(function* () {\n    // Get the context for synchronous access in callbacks.\n    const capabilities = yield* Capability.Service;\n\n    // Create UndoRegistry.\n    const undoRegistry = UndoRegistry.make(() => capabilities.getAll(Capabilities.UndoMapping).flat());\n\n    // Create HistoryTracker (depends on UndoRegistry and OperationInvoker).\n    const invoker = yield* Capability.get(Capabilities.OperationInvoker);\n    // Cast to internal type - the factory always returns OperationInvokerInternal.\n    const historyTracker = HistoryTracker.make(invoker as OperationInvoker.OperationInvokerInternal, undoRegistry);\n\n    return [\n      Capability.contributes(Capabilities.UndoRegistry, undoRegistry),\n      Capability.contributes(Capabilities.HistoryTracker, historyTracker),\n    ];\n  }),\n);\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;AAIA,YAAYA,YAAY;AAaxB,IAAA,qBAAeC,mBAAWC,WACjBC,kBAAW,aAAA;AAEhB,QAAMC,eAAe,OAAOH,mBAAWI;AAGvC,QAAMC,eAA4BC,KAAK,MAAMH,aAAaI,OAAOC,qBAAaC,WAAW,EAAEC,KAAI,CAAA;AAG/F,QAAMC,UAAU,OAAOX,mBAAWY,IAAIJ,qBAAaK,gBAAgB;AAEnE,QAAMC,iBAAgCR,MAAKK,SAAsDN,YAAAA;AAEjG,SAAO;IACLL,mBAAWe,YAAYP,qBAAaQ,cAAcX,YAAAA;IAClDL,mBAAWe,YAAYP,qBAAaS,gBAAgBH,cAAAA;;AAExD,CAAA,CAAA;",
+  "names": ["Effect", "Capability", "makeModule", "fnUntraced", "capabilities", "Service", "undoRegistry", "make", "getAll", "Capabilities", "UndoMapping", "flat", "invoker", "get", "OperationInvoker", "historyTracker", "contributes", "UndoRegistry", "HistoryTracker"]
+}

package/dist/lib/node-esm/{chunk-UEWJDI2L.mjs → chunk-37Z53PXZ.mjs}

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

package/dist/lib/node-esm/{chunk-UEWJDI2L.mjs.map → chunk-37Z53PXZ.mjs.map}

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

@@ -0,0 +1,35 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  activation_event_exports
+} from "./chunk-XOCUANHO.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,
+  SetupOperationHandler: () => SetupOperationHandler,
+  SetupReactSurface: () => SetupReactSurface,
+  Startup: () => Startup
+});
+var Startup = activation_event_exports.make("org.dxos.app-framework.event.startup");
+var SetupReactSurface = activation_event_exports.make("org.dxos.app-framework.event.setup-react-surface");
+var SetupOperationHandler = activation_event_exports.make("org.dxos.app-framework.event.setup-operation-handler");
+var SetupLayer = activation_event_exports.make("org.dxos.app-framework.event.setup-layer");
+var OperationInvokerReady = activation_event_exports.make("org.dxos.app-framework.event.operation-invoker-ready");
+var ManagedRuntimeReady = activation_event_exports.make("org.dxos.app-framework.event.managed-runtime-ready");
+
+export {
+  Startup,
+  SetupReactSurface,
+  SetupOperationHandler,
+  SetupLayer,
+  OperationInvokerReady,
+  ManagedRuntimeReady,
+  activation_events_exports
+};
+//# sourceMappingURL=chunk-6XW6LET6.mjs.map

package/dist/lib/node-esm/chunk-6XW6LET6.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/common/activation-events.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport { ActivationEvent as ActivationEvent$ } from '../core';\n\n/**\n * Fired when the app is started.\n */\nexport const Startup = ActivationEvent$.make('org.dxos.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('org.dxos.app-framework.event.setup-react-surface');\n\n/**\n * Fired before the operation invoker is activated.\n */\nexport const SetupOperationHandler = ActivationEvent$.make('org.dxos.app-framework.event.setup-operation-handler');\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('org.dxos.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('org.dxos.app-framework.event.operation-invoker-ready');\n\n/**\n * Fired after the managed runtime is ready.\n */\nexport const ManagedRuntimeReady = ActivationEvent$.make('org.dxos.app-framework.event.managed-runtime-ready');\n"],
+  "mappings": ";;;;;;;;;AAAA;;;;;;;;;AASO,IAAMA,UAAUC,yBAAiBC,KAAK,sCAAA;AAStC,IAAMC,oBAAoBF,yBAAiBC,KAAK,kDAAA;AAKhD,IAAME,wBAAwBH,yBAAiBC,KAAK,sDAAA;AAMpD,IAAMG,aAAaJ,yBAAiBC,KAAK,0CAAA;AASzC,IAAMI,wBAAwBL,yBAAiBC,KAAK,sDAAA;AAKpD,IAAMK,sBAAsBN,yBAAiBC,KAAK,oDAAA;",
+  "names": ["Startup", "ActivationEvent$", "make", "SetupReactSurface", "SetupOperationHandler", "SetupLayer", "OperationInvokerReady", "ManagedRuntimeReady"]
+}

package/dist/lib/node-esm/{chunk-DHSHRYIB.mjs → chunk-D347W3KO.mjs}

@@ -1,17 +1,14 @@
 import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
 import {
   UndoOperation
-} from "./chunk-J2PHTRHC.mjs";
+} from "./chunk-SBS2YMPT.mjs";
 import {
   __export
 } from "./chunk-HSLMI22Q.mjs";
 
 // src/plugin-operation/history/errors.ts
-import { OperationError } from "@dxos/operation";
-var EmptyHistoryError = class extends OperationError {
-  constructor() {
-    super("EMPTY_HISTORY", "Cannot undo: history is empty.");
-  }
+import { BaseError } from "@dxos/errors";
+var EmptyHistoryError = class extends BaseError.extend("EmptyHistoryError", "Cannot undo: history is empty.") {
 };
 
 // src/plugin-operation/history/undo-mapping.ts
@@ -76,12 +73,7 @@ var make3 = (invoker, undoRegistry) => {
     if (inverseInput === void 0) {
       log("operation not undoable", {
         key: event.operation.meta.key
-      }, {
-        F: __dxlog_file,
-        L: 58,
-        S: void 0,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 29, S: void 0 });
       return;
     }
     const entry = {
@@ -96,12 +88,7 @@ var make3 = (invoker, undoRegistry) => {
     log("history entry added", {
       key: event.operation.meta.key,
       historyLength: history.length
-    }, {
-      F: __dxlog_file,
-      L: 72,
-      S: void 0,
-      C: (f, a) => f(...a)
-    });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 43, S: void 0 });
     if (history.length > HISTORY_LIMIT) {
       history.splice(0, history.length - HISTORY_LIMIT);
     }
@@ -120,31 +107,16 @@ var make3 = (invoker, undoRegistry) => {
       log("undoing operation", {
         key: entry.operation.meta.key,
         inverseKey: entry.inverse.meta.key
-      }, {
-        F: __dxlog_file,
-        L: 102,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 65, S: this });
       yield* invoker._invokeCore(entry.inverse, entry.inverseInput);
       log("undo completed", {
         key: entry.operation.meta.key
-      }, {
-        F: __dxlog_file,
-        L: 107,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 71, S: this });
     });
   };
   const undoPromise = async () => {
     return runAndForwardErrors(undo()).then(() => ({})).catch((error) => {
-      log.catch(error, void 0, {
-        F: __dxlog_file,
-        L: 115,
-        S: void 0,
-        C: (f, a) => f(...a)
-      });
+      log.catch(error, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 78, S: void 0 });
       return {
         error
       };
@@ -168,4 +140,4 @@ export {
   make3 as make2,
   history_tracker_exports
 };
-//# sourceMappingURL=chunk-DHSHRYIB.mjs.map
+//# sourceMappingURL=chunk-D347W3KO.mjs.map

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

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

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

@@ -0,0 +1,470 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  PluginManagerProvider,
+  topologicalSort,
+  usePluginManager
+} from "./chunk-V24UWT36.mjs";
+import {
+  PluginManagerContext
+} from "./chunk-37Z53PXZ.mjs";
+import {
+  capabilities_exports
+} from "./chunk-WFSRZKBP.mjs";
+import {
+  activation_events_exports
+} from "./chunk-6XW6LET6.mjs";
+import {
+  plugin_manager_exports
+} from "./chunk-MUVUQC3G.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-DRZKO5UZ.mjs.map