@dxos/app-framework 0.8.4-main.422d1c7879 → 0.8.4-main.4f23b4e393

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

@@ -1,7 +0,0 @@
-{
-  "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/operation';\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/operation';\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 { type 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", "BaseError", "extend", "make", "props", "resolveMessage", "message", "input", "output", "undefined", "make", "make", "getMappings", "lookup", "operation", "mappings", "mapping", "find", "m", "meta", "key", "undefined", "inverse", "deriveContext", "message", "make", "Effect", "Stream", "runAndForwardErrors", "log", "HISTORY_LIMIT", "make", "invoker", "undoRegistry", "history", "handleInvocation", "event", "mapping", "lookup", "operation", "inverseInput", "deriveContext", "input", "output", "undefined", "log", "key", "meta", "entry", "inverse", "timestamp", "push", "historyLength", "length", "splice", "resolvedMessage", "resolveMessage", "message", "Effect", "runFork", "invoke", "UndoOperation", "ShowUndo", "fromPubSub", "invocations", "pipe", "runForEach", "sync", "undo", "gen", "pop", "fail", "EmptyHistoryError", "inverseKey", "_invokeCore", "undoPromise", "runAndForwardErrors", "then", "catch", "error", "canUndo"]
-}

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

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/ui/components/App/App.tsx", "../../../src/ui/hooks/useApp.tsx", "../../../src/ui/hooks/useCapabilities.ts", "../../../src/ui/hooks/useLoading.tsx", "../../../src/ui/hooks/useSettingsState.ts"],
-  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport React, { type PropsWithChildren, useEffect } from 'react';\n\nimport { Capabilities } from '../../../common';\nimport { topologicalSort } from '../../../helpers';\nimport { LoadingState, type StartupProgress, type UseAppOptions, useCapabilities, useLoading } from '../../hooks';\n\nexport type AppProps = Pick<UseAppOptions, 'placeholder' | 'debounce'> & {\n  ready: boolean;\n  error: unknown;\n  progress?: StartupProgress;\n};\n\nconst FIRST_INTERACTIVE_MARK = 'app-framework:first-interactive';\n\nexport const App = ({ placeholder: Placeholder, ready, error, debounce, progress }: AppProps) => {\n  const reactContexts = useCapabilities(Capabilities.ReactContext);\n  const reactRoots = useCapabilities(Capabilities.ReactRoot);\n  const stage = useLoading(ready, debounce);\n  const placeholderDismissed = stage >= LoadingState.Done;\n\n  // Emit a once-per-app `app-framework:first-interactive` mark the first time\n  // the placeholder is dismissed and the real app shell renders. Closes the\n  // gap between `Startup` activated and the first interactive paint.\n  useEffect(() => {\n    if (placeholderDismissed && performance.getEntriesByName(FIRST_INTERACTIVE_MARK).length === 0) {\n      performance.mark(FIRST_INTERACTIVE_MARK);\n    }\n  }, [placeholderDismissed]);\n\n  if (error) {\n    // This triggers the error boundary to provide UI feedback for the startup error.\n    throw error;\n  }\n\n  // TODO(wittjosiah): Consider using Suspense instead.\n  if (!placeholderDismissed) {\n    if (!Placeholder) {\n      return null;\n    }\n\n    return <Placeholder stage={stage} progress={progress} />;\n  }\n\n  const ComposedContext = composeContexts(reactContexts);\n  return (\n    <ComposedContext>\n      {reactRoots.map(({ id, root: Component }) => (\n        <Component key={id} />\n      ))}\n    </ComposedContext>\n  );\n};\n\nconst composeContexts = (contexts: Capabilities.ReactContext[]) => {\n  if (contexts.length === 0) {\n    return ({ children }: PropsWithChildren) => <>{children}</>;\n  }\n\n  return topologicalSort(contexts)\n    .map(({ context }) => context)\n    .reduce((Acc, Next) => ({ children }) => (\n      <Acc>\n        <Next>{children}</Next>\n      </Acc>\n    ));\n};\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport { RegistryContext } from '@effect-atom/atom-react';\nimport * as Effect from 'effect/Effect';\nimport * as Fiber from 'effect/Fiber';\nimport * as PubSub from 'effect/PubSub';\nimport * as Queue from 'effect/Queue';\nimport React, { type FC, useCallback, useEffect, useMemo, useRef, useState } from 'react';\n\nimport { runAndForwardErrors } from '@dxos/effect';\nimport { invariant } from '@dxos/invariant';\nimport { log } from '@dxos/log';\nimport { ErrorBoundary, ErrorFallback, type FallbackProps } from '@dxos/react-error-boundary';\nimport { useAsyncEffect, useDefaultValue } from '@dxos/react-hooks';\nimport { ContextProtocolProvider } from '@dxos/web-context-react';\n\nimport { ActivationEvents, Capabilities } from '../../common';\nimport { PluginManagerContext } from '../../context';\nimport { type ActivationEvent, type Plugin, PluginManager } from '../../core';\nimport { App, PluginManagerProvider } from '../components';\n\nconst ENABLED_KEY = 'org.dxos.app-framework.enabled';\n\nexport type StartupProgress = {\n  /** Number of modules that have been activated. */\n  activated: number;\n  /** Total number of modules registered. */\n  total: number;\n  /** Fractional progress (0-1). */\n  progress: number;\n  /** Human-readable label for the currently activating module. */\n  status?: string;\n};\n\nexport type PlaceholderProps = {\n  stage?: number;\n  progress?: StartupProgress;\n};\n\nexport type UseAppOptions = {\n  pluginManager?: PluginManager.PluginManager;\n  pluginLoader?: PluginManager.ManagerOptions['pluginLoader'];\n  plugins?: Plugin.Plugin[];\n  core?: string[];\n  defaults?: string[];\n  /**\n   * Additional activation events to fire before startup.\n   * These are fired alongside SetupReactSurface before the Startup event.\n   */\n  setupEvents?: ActivationEvent.ActivationEvent[];\n  cacheEnabled?: boolean;\n  safeMode?: boolean;\n  debounce?: number;\n  timeout?: number;\n  fallback?: FC<FallbackProps>;\n  placeholder?: FC<PlaceholderProps>;\n};\n\n/**\n * Expected usage is for this to be the entrypoint of the application.\n * Initializes plugins and renders the root components.\n *\n * @example\n * const plugins = [LayoutPlugin(), MyPlugin()];\n * const core = [LayoutPluginId];\n * const default = [MyPluginId];\n * const fallback = <div>Initializing Plugins...</div>;\n * const App = useApp({ plugins, core, default, fallback });\n * createRoot(document.getElementById('root')!).render(\n *   <StrictMode>\n *     <App />\n *   </StrictMode>,\n * );\n *\n * @param params.pluginLoader A function which loads new plugins.\n * @param params.plugins All plugins available to the application.\n * @param params.core Core plugins which will always be enabled.\n * @param params.defaults Default plugins are enabled by default but can be disabled by the user.\n * @param params.cacheEnabled Whether to cache enabled plugins in localStorage.\n * @param params.safeMode Whether to enable safe mode, which disables optional plugins.\n * @param params.fallback Fallback component to render if an error occurs during startup.\n * @param params.placeholder Placeholder component to render during startup.\n */\nexport const useApp = ({\n  pluginManager,\n  pluginLoader: pluginLoaderProp,\n  plugins: pluginsProp,\n  core: coreProp,\n  defaults: defaultsProp,\n  setupEvents: setupEventsProp,\n  placeholder,\n  fallback = ErrorFallback,\n  cacheEnabled = false,\n  safeMode = false,\n  debounce = 0,\n  timeout = 30_000,\n}: UseAppOptions) => {\n  const plugins = useDefaultValue(pluginsProp, () => []);\n  const core = useDefaultValue(coreProp, () => plugins.map(({ meta }) => meta.id));\n  const defaults = useDefaultValue(defaultsProp, () => []);\n  const setupEvents = useDefaultValue(setupEventsProp, () => []);\n\n  const pluginLoader = useMemo(\n    () =>\n      pluginLoaderProp ??\n      ((id: string) =>\n        Effect.sync(() => {\n          const plugin = plugins.find((plugin) => plugin.meta.id === id);\n          invariant(plugin, `Plugin not found: ${id}`);\n          return plugin;\n        })),\n    [pluginLoaderProp, plugins],\n  );\n\n  const readyRef = useRef(false);\n  const [ready, setReady] = useState(false);\n  const errorRef = useRef<unknown>(null);\n  const [error, setError] = useState<unknown>(null);\n  const [startupProgress, setStartupProgress] = useState<StartupProgress>({\n    activated: 0,\n    total: 0,\n    progress: 0,\n  });\n  // TODO(wittjosiah): Migrate to Atom.kvs for isomorphic storage.\n  const cached: string[] = useMemo(() => JSON.parse(localStorage.getItem(ENABLED_KEY) ?? '[]'), []);\n  const enabled = useMemo(\n    () => (safeMode ? [] : cacheEnabled && cached.length > 0 ? cached : defaults),\n    [safeMode, cacheEnabled, cached, defaults],\n  );\n  const isExternalManager = !!pluginManager;\n  const manager = useMemo(() => {\n    const mgr = pluginManager ?? PluginManager.make({ pluginLoader, plugins, core, enabled });\n    log('useApp: useMemo created/reused manager', { provided: !!pluginManager });\n    return mgr;\n  }, [pluginManager, pluginLoader, plugins, core, enabled]);\n\n  useEffect(() => {\n    if (!cacheEnabled) {\n      return;\n    }\n    return manager.registry.subscribe(manager.enabled, (value) => {\n      localStorage.setItem(ENABLED_KEY, JSON.stringify(value));\n    });\n  }, [cacheEnabled, manager]);\n\n  useEffect(() => {\n    setupDevtools(manager);\n  }, [manager]);\n\n  useAsyncEffect(async () => {\n    log('useApp: effect mount');\n\n    manager.capabilities.contribute({\n      interface: Capabilities.PluginManager,\n      implementation: manager,\n      module: 'org.dxos.app-framework.plugin-manager',\n    });\n\n    manager.capabilities.contribute({\n      interface: Capabilities.AtomRegistry,\n      implementation: manager.registry,\n      module: 'org.dxos.app-framework.atom-registry',\n    });\n\n    const fiber = Effect.gen(function* () {\n      const queue = yield* PubSub.subscribe(manager.activation);\n      const listener = yield* Effect.forkDaemon(\n        Queue.take(queue).pipe(\n          Effect.tap(({ event, state, module, error: error$ }) =>\n            Effect.sync(() => {\n              if (event === ActivationEvents.Startup.id && state === 'activated') {\n                clearTimeout(timeoutId);\n                setReady(true);\n                readyRef.current = true;\n                // Trigger startup profiler dump if available.\n                (globalThis as any).composer?.profiler?.dump();\n                // Notify any host observability layer that startup completed.\n                // A `CustomEvent` keeps this generic — app-framework doesn't\n                // import a provider, and consumers can capture the startup\n                // summary without us picking one.\n                if (typeof window !== 'undefined') {\n                  window.dispatchEvent(new CustomEvent('app-framework:startup-activated'));\n                }\n                return;\n              }\n              // Update progress on every module-level `activated` message.\n              // Driven by the activation event itself rather than a poll, so\n              // the placeholder UI updates as soon as a module commits.\n              if (module && state === 'activated' && !readyRef.current) {\n                const active = manager.getActive();\n                const total = manager.getModules().length;\n                setStartupProgress({\n                  activated: active.length,\n                  total,\n                  progress: total > 0 ? active.length / total : 0,\n                  status: humanizeModuleId(module),\n                });\n              }\n              if (error$ && !readyRef.current) {\n                setError(error$);\n                errorRef.current = error$;\n              }\n            }),\n          ),\n          Effect.forever,\n        ),\n      );\n\n      yield* Effect.all([\n        ...setupEvents.map((event) => manager.activate(event)),\n        manager.activate(ActivationEvents.SetupReactSurface),\n        manager.activate(ActivationEvents.Startup),\n      ]);\n\n      return yield* Fiber.join(listener);\n    }).pipe(Effect.scoped, Effect.runFork);\n\n    // Set up a timeout for startup.\n    const timeoutId = setTimeout(() => {\n      if (!readyRef.current && !errorRef.current) {\n        log.warn('startup timeout diagnostic', {\n          eventsFired: manager.getEventsFired(),\n          activeModules: manager.getActive(),\n          pendingReset: manager.getPendingReset(),\n        });\n        void runAndForwardErrors(Fiber.interrupt(fiber));\n        setError(new Error(`Startup timed out after ${timeout}ms`));\n      }\n    }, timeout);\n\n    return () => {\n      log('useApp: effect cleanup');\n      clearTimeout(timeoutId);\n      void runAndForwardErrors(Fiber.interrupt(fiber));\n      if (!isExternalManager) {\n        void runAndForwardErrors(manager.shutdown());\n      }\n    };\n  }, [manager]);\n\n  return useCallback(\n    () => (\n      <ErrorBoundary name='app' FallbackComponent={fallback}>\n        <PluginManagerProvider value={manager}>\n          <ContextProtocolProvider value={manager} context={PluginManagerContext}>\n            <RegistryContext.Provider value={manager.registry}>\n              <App\n                placeholder={placeholder}\n                ready={ready}\n                error={error}\n                debounce={debounce}\n                progress={startupProgress}\n              />\n            </RegistryContext.Provider>\n          </ContextProtocolProvider>\n        </PluginManagerProvider>\n      </ErrorBoundary>\n    ),\n    [fallback, manager, placeholder, ready, error],\n  );\n};\n\nconst setupDevtools = (manager: PluginManager.PluginManager) => {\n  (globalThis as any).composer ??= {};\n  (globalThis as any).composer.manager = manager;\n};\n\n/**\n * Extracts a human-readable label from a module ID.\n * E.g., \"org.dxos.plugin.markdown.module.ReactSurface\" → \"Markdown\".\n */\nconst humanizeModuleId = (moduleId: string): string => {\n  // Extract plugin name from pattern: org.dxos.plugin.<name>.module.<capability>\n  const pluginMatch = moduleId.match(/\\.plugin\\.([^.]+)\\./);\n  if (pluginMatch) {\n    const name = pluginMatch[1];\n    // Convert kebab-case to title case.\n    return name\n      .split('-')\n      .map((word) => word.charAt(0).toUpperCase() + word.slice(1))\n      .join(' ');\n  }\n\n  // Fallback: use the last segment.\n  const parts = moduleId.split('.');\n  return parts[parts.length - 1];\n};\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport { type Atom, useAtomValue } from '@effect-atom/atom-react';\nimport { useCallback } from 'react';\n\nimport { invariant } from '@dxos/invariant';\n\nimport { Capabilities } from '../../common';\nimport { type Capability } from '../../core';\nimport { usePluginManager } from '../components';\n\n/**\n * Hook to request capabilities from the plugin context.\n * @returns An array of capabilities.\n */\nexport const useCapabilities = <T>(interfaceDef: Capability.InterfaceDef<T>) => {\n  const manager = usePluginManager();\n  return useAtomValue(manager.capabilities.atom(interfaceDef));\n};\n\n/**\n * Hook to request a capability from the plugin context.\n * @returns The capability.\n * @throws If no capability is found.\n */\nexport const useCapability = <T>(interfaceDef: Capability.InterfaceDef<T>) => {\n  const capabilities = useCapabilities(interfaceDef);\n  invariant(capabilities.length > 0, `No capability found for ${interfaceDef.identifier}`);\n  return capabilities[0];\n};\n\n/**\n * Hook to get the current value of an atom capability.\n * Automatically subscribes to changes.\n * @example const settings = useAtomCapability(ThreadCapabilities.Settings);\n */\nexport const useAtomCapability = <T>(atomCapability: Capability.InterfaceDef<Atom.Atom<T>>): T => {\n  const atom = useCapability(atomCapability);\n  return useAtomValue(atom);\n};\n\n/**\n * Hook to get value and updater for an atom capability.\n * Returns [currentValue, updateFn] similar to useState.\n * @example const [settings, updateSettings] = useAtomCapabilityState(ThreadCapabilities.Settings);\n */\nexport const useAtomCapabilityState = <T>(\n  atomCapability: Capability.InterfaceDef<Atom.Writable<T>>,\n): [T, (fn: (current: T) => T) => void] => {\n  const registry = useCapability(Capabilities.AtomRegistry);\n  const atom = useCapability(atomCapability);\n  const value = useAtomValue(atom);\n  const update = useCallback(\n    (fn: (current: T) => T) => {\n      registry.set(atom, fn(registry.get(atom)));\n    },\n    [registry, atom],\n  );\n  return [value, update];\n};\n\n/**\n * Hook to get the operation invoker capability.\n */\nexport const useOperationInvoker = (): Capabilities.OperationInvoker => useCapability(Capabilities.OperationInvoker);\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport { useEffect, useState } from 'react';\n\nexport enum LoadingState {\n  Loading = 0,\n  FadeIn = 1,\n  FadeOut = 2,\n  Done = 3,\n}\n\n/**\n * To avoid \"flashing\" the placeholder, we wait a period of time before starting the loading animation.\n * If loading completes during this time the placehoder is not shown, otherwise is it displayed for a minimum period of time.\n *\n * States:\n * 0: Loading   - Wait for a period of time before starting the loading animation.\n * 1: Fade-in   - Display a loading animation.\n * 2: Fade-out  - Fade out the loading animation.\n * 3: Done      - Remove the placeholder.\n */\nexport const useLoading = (ready: boolean, debounce = 0) => {\n  const [stage, setStage] = useState<LoadingState>(LoadingState.Loading);\n  useEffect(() => {\n    if (!debounce) {\n      return;\n    }\n\n    const i = setInterval(() => {\n      setStage((stage) => {\n        switch (stage) {\n          case LoadingState.Loading: {\n            if (!ready) {\n              return LoadingState.FadeIn;\n            } else {\n              clearInterval(i);\n              return LoadingState.Done;\n            }\n          }\n\n          case LoadingState.FadeIn: {\n            if (ready) {\n              return LoadingState.FadeOut;\n            }\n            break;\n          }\n\n          case LoadingState.FadeOut: {\n            clearInterval(i);\n            return LoadingState.Done;\n          }\n        }\n\n        return stage;\n      });\n    }, debounce);\n\n    return () => clearInterval(i);\n  }, [debounce]);\n\n  if (!debounce) {\n    return ready ? LoadingState.Done : LoadingState.Loading;\n  }\n\n  return stage;\n};\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport { type Atom, RegistryContext, useAtomValue } from '@effect-atom/atom-react';\nimport { useCallback, useContext } from 'react';\n\n/**\n * Hook to read and update a settings atom.\n * Returns the current value and an update function.\n */\nexport const useSettingsState = <T>(\n  atom: Atom.Writable<T>,\n): { settings: T; updateSettings: (fn: (current: T) => T) => void } => {\n  const registry = useContext(RegistryContext);\n  const settings = useAtomValue(atom);\n\n  const updateSettings = useCallback(\n    (fn: (current: T) => T) => {\n      registry.set(atom, fn(registry.get(atom)));\n    },\n    [registry, atom],\n  );\n\n  return { settings, updateSettings };\n};\n"],
-  "mappings": "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",
-  "names": ["React", "useEffect", "RegistryContext", "Effect", "Fiber", "PubSub", "Queue", "React", "useCallback", "useEffect", "useMemo", "useRef", "useState", "runAndForwardErrors", "invariant", "log", "ErrorBoundary", "ErrorFallback", "useAsyncEffect", "useDefaultValue", "ContextProtocolProvider", "ENABLED_KEY", "useApp", "pluginManager", "pluginLoader", "pluginLoaderProp", "plugins", "pluginsProp", "core", "coreProp", "defaults", "defaultsProp", "setupEvents", "setupEventsProp", "placeholder", "fallback", "ErrorFallback", "cacheEnabled", "safeMode", "debounce", "timeout", "useDefaultValue", "map", "meta", "id", "useMemo", "sync", "plugin", "find", "invariant", "readyRef", "useRef", "ready", "setReady", "useState", "errorRef", "error", "setError", "startupProgress", "setStartupProgress", "activated", "total", "progress", "cached", "JSON", "parse", "localStorage", "getItem", "enabled", "length", "isExternalManager", "manager", "mgr", "PluginManager", "make", "log", "provided", "useEffect", "registry", "subscribe", "value", "setItem", "stringify", "setupDevtools", "useAsyncEffect", "capabilities", "contribute", "interface", "Capabilities", "implementation", "module", "AtomRegistry", "fiber", "gen", "queue", "activation", "listener", "forkDaemon", "take", "pipe", "tap", "event", "state", "error$", "ActivationEvents", "Startup", "clearTimeout", "timeoutId", "current", "globalThis", "composer", "profiler", "dump", "window", "dispatchEvent", "CustomEvent", "active", "getActive", "getModules", "status", "humanizeModuleId", "forever", "all", "activate", "SetupReactSurface", "join", "scoped", "runFork", "setTimeout", "warn", "eventsFired", "getEventsFired", "activeModules", "pendingReset", "getPendingReset", "runAndForwardErrors", "interrupt", "Error", "shutdown", "useCallback", "ErrorBoundary", "name", "FallbackComponent", "PluginManagerProvider", "ContextProtocolProvider", "context", "PluginManagerContext", "RegistryContext", "Provider", "App", "moduleId", "pluginMatch", "match", "split", "word", "charAt", "toUpperCase", "slice", "parts", "useAtomValue", "useCallback", "invariant", "useCapabilities", "interfaceDef", "manager", "usePluginManager", "useAtomValue", "capabilities", "atom", "useCapability", "invariant", "length", "identifier", "useAtomCapability", "atomCapability", "useAtomCapabilityState", "registry", "Capabilities", "AtomRegistry", "value", "update", "useCallback", "fn", "set", "get", "useOperationInvoker", "OperationInvoker", "useEffect", "useState", "LoadingState", "useLoading", "ready", "debounce", "stage", "setStage", "useState", "useEffect", "i", "setInterval", "clearInterval", "RegistryContext", "useAtomValue", "useCallback", "useContext", "useSettingsState", "atom", "registry", "useContext", "RegistryContext", "settings", "useAtomValue", "updateSettings", "useCallback", "fn", "set", "get", "FIRST_INTERACTIVE_MARK", "App", "placeholder", "Placeholder", "ready", "error", "debounce", "progress", "reactContexts", "useCapabilities", "Capabilities", "ReactContext", "reactRoots", "ReactRoot", "stage", "useLoading", "placeholderDismissed", "LoadingState", "Done", "useEffect", "performance", "getEntriesByName", "length", "mark", "React", "ComposedContext", "composeContexts", "map", "id", "root", "Component", "key", "contexts", "children", "topologicalSort", "context", "reduce", "Acc", "Next"]
-}

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

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/plugin-operation/invoker-capability.ts"],
-  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Effect from 'effect/Effect';\n\nimport { OperationHandlerSet, OperationInvoker } from '@dxos/operation';\n\nimport { ActivationEvents, Capabilities } from '../common';\nimport { Capability, Plugin } from '../core';\n\n//\n// Capability Module\n//\n\nexport default Capability.makeModule(\n  Effect.fnUntraced(function* () {\n    // Get the services for synchronous access in callbacks.\n    const capabilityManager = yield* Capability.Service;\n    const pluginManager = yield* Plugin.Service;\n\n    // Get the ManagedRuntime capability (should be available since we activate after ManagedRuntimeReady).\n    const managedRuntime = yield* Capability.get(Capabilities.ManagedRuntime);\n\n    // Cache the merged handler promise to prevent concurrent module loading.\n    // Multiple Effects can invoke getHandlers simultaneously; without caching each\n    // creates a new merge() which triggers parallel dynamic imports that race in\n    // WebKit's module evaluator, causing TDZ errors on export default bindings.\n    let cachedSets: readonly OperationHandlerSet.OperationHandlerSet[] | undefined;\n    let cachedHandlers: ReturnType<OperationHandlerSet.OperationHandlerSet['getHandlers']> | undefined;\n\n    const invoker = OperationInvoker.make(\n      () =>\n        Effect.gen(function* () {\n          yield* Plugin.activate(ActivationEvents.SetupOperationHandler);\n          const sets = yield* Capability.getAll(Capabilities.OperationHandler);\n\n          if (sets !== cachedSets) {\n            cachedSets = sets;\n            cachedHandlers = OperationHandlerSet.merge(...sets).getHandlers();\n          }\n\n          return yield* Effect.promise(() => cachedHandlers!);\n        }).pipe(\n          Effect.provideService(Capability.Service, capabilityManager),\n          Effect.provideService(Plugin.Service, pluginManager),\n          Effect.orDie,\n        ),\n      managedRuntime,\n    );\n\n    return Capability.contributes(Capabilities.OperationInvoker, invoker);\n  }),\n);\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;AAIA,YAAYA,YAAY;AAExB,SAASC,qBAAqBC,wBAAwB;AAStD,IAAA,6BAAeC,mBAAWC,WACjBC,kBAAW,aAAA;AAEhB,QAAMC,oBAAoB,OAAOH,mBAAWI;AAC5C,QAAMC,gBAAgB,OAAOC,eAAOF;AAGpC,QAAMG,iBAAiB,OAAOP,mBAAWQ,IAAIC,qBAAaC,cAAc;AAMxE,MAAIC;AACJ,MAAIC;AAEJ,QAAMC,UAAUC,iBAAiBC,KAC/B,MACSC,WAAI,aAAA;AACT,WAAOV,eAAOW,SAASC,0BAAiBC,qBAAqB;AAC7D,UAAMC,OAAO,OAAOpB,mBAAWqB,OAAOZ,qBAAaa,gBAAgB;AAEnE,QAAIF,SAAST,YAAY;AACvBA,mBAAaS;AACbR,uBAAiBW,oBAAoBC,MAAK,GAAIJ,IAAAA,EAAMK,YAAW;IACjE;AAEA,WAAO,OAAcC,eAAQ,MAAMd,cAAAA;EACrC,CAAA,EAAGe,KACMC,sBAAe5B,mBAAWI,SAASD,iBAAAA,GACnCyB,sBAAetB,eAAOF,SAASC,aAAAA,GAC/BwB,YAAK,GAEhBtB,cAAAA;AAGF,SAAOP,mBAAW8B,YAAYrB,qBAAaK,kBAAkBD,OAAAA;AAC/D,CAAA,CAAA;",
-  "names": ["Effect", "OperationHandlerSet", "OperationInvoker", "Capability", "makeModule", "fnUntraced", "capabilityManager", "Service", "pluginManager", "Plugin", "managedRuntime", "get", "Capabilities", "ManagedRuntime", "cachedSets", "cachedHandlers", "invoker", "OperationInvoker", "make", "gen", "activate", "ActivationEvents", "SetupOperationHandler", "sets", "getAll", "OperationHandler", "OperationHandlerSet", "merge", "getHandlers", "promise", "pipe", "provideService", "orDie", "contributes"]
-}