@dxos/app-framework 0.8.4-staging.60fe92afc8 → 0.9.1-main.c7dcc2e112

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

@@ -0,0 +1,7 @@
+{
+  "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/useProcessManagerRuntime.ts", "../../../src/ui/hooks/useSettingsState.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport React, { type PropsWithChildren, useEffect, useLayoutEffect } from 'react';\n\nimport { Capabilities } from '../../../common';\nimport { topologicalSort } from '../../../helpers';\nimport { LoadingState, type StartupProgress, type UseAppOptions, useCapabilities, useLoading } from '../../hooks';\n\ndeclare global {\n  interface Window {\n    /**\n     * Driver injected by `@dxos/app-framework/vite-plugin`'s `bootLoaderPlugin`\n     * (a Solid app inlined into `index.html`). Declared here — on a module that\n     * is part of the `@dxos/app-framework/ui` export surface — so the React side\n     * and host apps (e.g. composer-app) can drive the loader without each\n     * re-declaring the type. The canonical definition lives in the plugin's\n     * `loader-app/types.ts`; this mirror exists because that source compiles in a\n     * separate (Solid) program that doesn't ship its globals to consumers.\n     */\n    __bootLoader?: {\n      status: (payload: {\n        event?: string;\n        module?: string;\n        humanized: string;\n        /**\n         * Optional `(index/total)` tick. When present, the loader replaces the\n         * current line in place (\"Loading plugins (12/80)\") instead of appending\n         * a new entry — keeps the visible log compact during long counted phases.\n         */\n        range?: { index: number; total: number };\n      }) => void;\n      progress: (fraction?: number) => void;\n      ready: () => void;\n      dismiss: () => void;\n    };\n  }\n}\n\nexport type AppProps = Pick<UseAppOptions, 'debounce'> & {\n  ready: boolean;\n  error: unknown;\n  progress?: StartupProgress;\n};\n\nconst FIRST_INTERACTIVE_MARK = 'app-framework:first-interactive';\n\nexport const App = ({ 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  // Relay the startup lifecycle into the boot loader injected by\n  // `@dxos/app-framework/vite-plugin` (a Solid app inlined into `index.html`,\n  // the only visible loading UI). Plugin activation fills the `[0.5, 1]` half\n  // of the ring; the raw `event` / `module` ids ride along so the loader owns\n  // how each transition is rendered and traced. No-op once the outro has\n  // started (`FadeOut`), so the dismissal runs uncontended.\n  useEffect(() => {\n    if (stage >= LoadingState.FadeOut) {\n      return;\n    }\n    const fraction = progress?.progress ?? 0;\n    window.__bootLoader?.progress(0.5 + fraction * 0.5);\n    if (progress?.humanizedName) {\n      window.__bootLoader?.status({\n        event: progress.event,\n        module: progress.module,\n        humanized: `Activating ${progress.humanizedName}`,\n      });\n    }\n  }, [stage, progress?.progress, progress?.event, progress?.module, progress?.humanizedName]);\n\n  // Hand off at fade-out: play the loader's graceful shrink-and-fade outro.\n  // `useLayoutEffect` runs before the next paint so the outro begins in the\n  // same frame the real shell starts rendering beneath it.\n  useLayoutEffect(() => {\n    if (stage >= LoadingState.FadeOut) {\n      window.__bootLoader?.ready();\n    }\n  }, [stage]);\n\n  // Emit a once-per-app `app-framework:first-interactive` mark the first time\n  // the loader is dismissed and the real app shell renders. Closes the gap\n  // between `Startup` activated and the first interactive paint.\n  //\n  // Also the framework-owned handoff-complete signal: `dismiss()` removes the\n  // loader immediately on the fast-load path (where `useLoading` skips\n  // `FadeOut`), and is a no-op once an outro is already in flight, so it never\n  // cuts the animation short.\n  useEffect(() => {\n    if (!placeholderDismissed) {\n      return;\n    }\n    if (performance.getEntriesByName(FIRST_INTERACTIVE_MARK).length === 0) {\n      performance.mark(FIRST_INTERACTIVE_MARK);\n    }\n    window.__bootLoader?.dismiss();\n  }, [placeholderDismissed]);\n\n  // Used in tests to exercise the error boundary & reset dialog (see\n  // composer-app's `basic.spec.ts`). Thrown into the surrounding `ErrorBoundary`.\n  if (location.search === '?throw') {\n    throw new Error('Test error');\n  }\n\n  if (error) {\n    // This triggers the error boundary to provide UI feedback for the startup error.\n    throw error;\n  }\n\n  // The boot loader owns the screen until handoff completes; render nothing\n  // until then (any DOM here would sit invisibly behind the `z-index: 10`\n  // loader anyway).\n  // TODO(wittjosiah): Consider using Suspense instead.\n  if (!placeholderDismissed) {\n    return null;\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 { EffectEx } 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  /**\n   * Raw activation event key (e.g. `org.dxos.app-framework.event.startup`).\n   * Set on event-level transitions, *and* on module-level transitions where\n   * it carries the parent activation event that first triggered the\n   * module's load (plumbed through `_loadCapabilitiesForModules` →\n   * `_loadModule`). Consumers can use this either as the primary id (when\n   * {@link module} is absent) or as an extra \"context\" field alongside\n   * {@link module}.\n   */\n  event?: string;\n  /**\n   * Raw module id (e.g. `org.dxos.plugin.observability.module.ReactSurface`)\n   * when the in-flight activation is module-level. When present,\n   * {@link event} may also be set, identifying the parent activation that\n   * triggered this module's load.\n   */\n  module?: string;\n  /**\n   * Pre-humanized label for the currently surfaced transition (module\n   * label if {@link module} is set, otherwise the event label), supplied\n   * for consumers that want a sensible default. Hosts that prefer to\n   * render their own label can read the raw {@link event}/{@link module}\n   * fields and ignore this — the framework leaves the policy choice\n   * (which transitions to surface, how to format them, whether to drop\n   * sub-modules entirely) to the host's `Placeholder`.\n   */\n  humanizedName?: string;\n};\n\nexport type UseAppOptions = {\n  pluginManager?: PluginManager.PluginManager;\n  pluginLoader?: PluginManager.ManagerOptions['pluginLoader'];\n  onPluginRemove?: PluginManager.ManagerOptions['onRemove'];\n  pluginRegistryProvider?: PluginManager.ManagerOptions['pluginRegistryProvider'];\n  plugins?: Plugin.Plugin[];\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};\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 defaults = [MyPluginId];\n * const fallback = () => <div>Initializing Plugins...</div>;\n * const App = useApp({ plugins, defaults, 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. Plugins whose `meta.profile.tags` includes `'system'` are treated as core (force-enabled, not user-toggleable).\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 */\nexport const useApp = ({\n  pluginManager,\n  pluginLoader: pluginLoaderProp,\n  onPluginRemove,\n  pluginRegistryProvider,\n  plugins: pluginsProp,\n  defaults: defaultsProp,\n  setupEvents: setupEventsProp,\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 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.profile.key === 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 =\n      pluginManager ??\n      PluginManager.make({\n        pluginLoader,\n        plugins,\n        enabled,\n        onRemove: onPluginRemove,\n        pluginRegistryProvider,\n      });\n    log('useApp: useMemo created/reused manager', { provided: !!pluginManager });\n    return mgr;\n  }, [pluginManager, pluginLoader, plugins, enabled, onPluginRemove, pluginRegistryProvider]);\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              // Event-level Startup activated (no `module` field) fires once,\n              // after every module triggered by Startup has finished. Module\n              // activations now also carry their parent event id (so the trace\n              // can attribute a module to its triggering event), which means\n              // each module activated under Startup publishes\n              // `{ event: 'startup', state: 'activated', module: <id> }`. Without\n              // the `!module` guard the listener would mark the app ready on\n              // the *first* such module rather than waiting for the event-level\n              // completion — leaving downstream capabilities (operation-invoker,\n              // app-graph, …) un-registered when the boot loader dismisses.\n              if (event === ActivationEvents.Startup.id && state === 'activated' && !module) {\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              // `activating` is the start-of-load signal. Surface the raw\n              // `module` (or `event`) plus a pre-humanized label so the\n              // boot loader can decide how to render each transition — show\n              // everything, suppress noisy sub-modules, group by plugin,\n              // or apply its own formatting. We intentionally do NOT touch\n              // these fields on `activated`: pairing the two would cause\n              // back-to-back identical updates to the host's effect, which\n              // the boot loader treats as a re-trigger because\n              // `progress.progress` moved. Leaving the label alone on\n              // completion keeps it accurate (\"now activating X\") until\n              // the next module starts.\n              if (module && state === 'activating' && !readyRef.current) {\n                setStartupProgress((current) => ({\n                  ...current,\n                  // `event` here is the activation event that first\n                  // triggered this module load (plumbed through\n                  // `_loadCapabilitiesForModules` → `_loadModule`).\n                  // Falsy/empty falls back to undefined so consumers can\n                  // tell \"no parent context\" from \"parent context: <X>\".\n                  event: event || undefined,\n                  module,\n                  humanizedName: humanizeModuleId(module),\n                }));\n              }\n              // Update the activation count when a module commits. The\n              // ring's fraction comes from this; `event`/`module`/\n              // `humanizedName` were set by the matching `activating`\n              // message above and are left alone so the count can advance\n              // without re-firing the host's status callback.\n              if (module && state === 'activated' && !readyRef.current) {\n                const active = manager.getActive();\n                const total = manager.getModules().length;\n                setStartupProgress((current) => ({\n                  ...current,\n                  activated: active.length,\n                  total,\n                  progress: total > 0 ? active.length / total : 0,\n                }));\n              }\n              // Event-level `activating` (no `module`) — fired at the start\n              // of `_activateModulesForEvent` and recursively for each\n              // before/after event. Surfaces a label during the gap before\n              // the first module-level message lands; subsequent module\n              // updates immediately overwrite this with a more specific\n              // label.\n              if (event && !module && state === 'activating' && !readyRef.current) {\n                setStartupProgress((current) => ({\n                  ...current,\n                  event,\n                  module: undefined,\n                  humanizedName: humanizeEventKey(event),\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 EffectEx.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 EffectEx.runAndForwardErrors(Fiber.interrupt(fiber));\n      if (!isExternalManager) {\n        void EffectEx.runAndForwardErrors(manager.shutdown());\n      }\n    };\n  }, [manager]);\n\n  const progressRef = useRef(startupProgress);\n  progressRef.current = startupProgress;\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 ready={ready} error={error} debounce={debounce} progress={progressRef.current} />\n            </RegistryContext.Provider>\n          </ContextProtocolProvider>\n        </PluginManagerProvider>\n      </ErrorBoundary>\n    ),\n    [fallback, manager, 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 *\n * Module IDs follow `org.dxos.plugin.<plugin-slug>.module.<module-name>`,\n * where `<plugin-slug>` is kebab-case and `<module-name>` is either an\n * explicit string (often kebab-case, e.g. `'observability'`, `'namespace'`)\n * or a capability tag in PascalCase from `Capability.getModuleTag(...)`\n * (e.g. `'ReactSurface'`, `'AppGraphBuilder'`). The output is\n * `\"Title Case Plugin: kebab-module\"` so the visible status names both the\n * plugin and the aspect being activated, helping disambiguate the multiple\n * modules a plugin contributes.\n *\n * Examples:\n *   - \"org.dxos.plugin.markdown.module.ReactSurface\" → \"Markdown: react-surface\"\n *   - \"org.dxos.plugin.observability.module.AppGraphBuilder\" → \"Observability: app-graph-builder\"\n *   - \"org.dxos.plugin.observability.module.observability\" → \"Observability\"\n *     (the module name matches the plugin slug — collapsed to avoid\n *     \"Observability: observability\" noise.)\n */\nconst humanizeModuleId = (moduleId: string): string => {\n  const match = moduleId.match(/\\.plugin\\.([^.]+)\\.module\\.(.+)$/);\n  if (!match) {\n    // Fallback: use the last segment.\n    const parts = moduleId.split('.');\n    return parts[parts.length - 1];\n  }\n  const [, pluginSlug, moduleName] = match;\n  const pluginLabel = pluginSlug\n    .split('-')\n    .map((word) => word.charAt(0).toUpperCase() + word.slice(1))\n    .join(' ');\n  // Normalise the module name to kebab-case so PascalCase capability tags\n  // (\"ReactSurface\") read consistently with explicit kebab IDs\n  // (\"operation-handler\"). The two-step substitution handles consecutive\n  // uppercase runs (`URLLoader` → `url-loader`) without splitting them\n  // mid-acronym.\n  const moduleLabel = moduleName\n    .replace(/([a-z0-9])([A-Z])/g, '$1-$2')\n    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1-$2')\n    .toLowerCase();\n  // Capability modules whose name matches the plugin slug (e.g. the\n  // observability plugin's `observability` capability module) would render\n  // as \"Observability: observability\" — drop the redundant suffix.\n  if (moduleLabel === pluginSlug) {\n    return pluginLabel;\n  }\n  return `${pluginLabel}: ${moduleLabel}`;\n};\n\n/**\n * Extracts a human-readable label from an activation event key.\n * E.g., \"org.dxos.app-framework.event.setup-react-surface\" → \"Setup React Surface\".\n */\nconst humanizeEventKey = (eventKey: string): string => {\n  // Strip a leading specifier (composite key form: \"<id>:<specifier>\").\n  const id = eventKey.split(':')[0];\n  // Match the trailing segment after `.event.`.\n  const match = id.match(/\\.event\\.(.+)$/);\n  const slug = match ? match[1] : (id.split('.').pop() ?? id);\n  return slug\n    .split('-')\n    .map((word) => word.charAt(0).toUpperCase() + word.slice(1))\n    .join(' ');\n};\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport { Atom } from '@effect-atom/atom';\nimport { 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 { useOptionalPluginManager, usePluginManager } from '../components';\n\n/** Stable empty result for capability lookups made outside a plugin manager. */\nconst emptyCapabilities = Atom.make(() => [] as const);\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 */\n// TODO(burdon): Option not to throw?\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 request capabilities without requiring a plugin manager.\n * @returns An array of capabilities, or an empty array when rendered outside a {@link PluginManagerProvider}.\n */\nexport const useOptionalCapabilities = <T>(interfaceDef: Capability.InterfaceDef<T>): readonly T[] => {\n  const manager = useOptionalPluginManager();\n  return useAtomValue(\n    manager ? manager.capabilities.atom(interfaceDef) : (emptyCapabilities as Atom.Atom<readonly T[]>),\n  );\n};\n\n/**\n * Hook to request a single capability without requiring a plugin manager.\n * @returns The first matching capability, or `undefined` when none is registered (or there is no plugin manager).\n */\nexport const useOptionalCapability = <T>(interfaceDef: Capability.InterfaceDef<T>): T | undefined =>\n  useOptionalCapabilities(interfaceDef)[0];\n\n/**\n * Hook to get the current value of an atom capability.\n * Automatically subscribes to changes.\n * @example const settings = useAtomCapability(CommentCapabilities.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(CommentCapabilities.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, useRef, 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  // Mirror `ready` into a ref so the interval's `setStage` callback can read\n  // the latest value without depending on the effect re-running. The pure\n  // closure-capture pattern (with `ready` in deps) sticks the FSM at\n  // `FadeIn` whenever HMR doesn't propagate the dep change end-to-end —\n  // a ref sidesteps that entirely and fires the read on every tick.\n  const readyRef = useRef(ready);\n  readyRef.current = ready;\n\n  useEffect(() => {\n    if (!debounce) {\n      return;\n    }\n\n    const i = setInterval(() => {\n      setStage((stage) => {\n        const isReady = readyRef.current;\n        switch (stage) {\n          case LoadingState.Loading: {\n            if (!isReady) {\n              return LoadingState.FadeIn;\n            }\n            clearInterval(i);\n            return LoadingState.Done;\n          }\n\n          case LoadingState.FadeIn: {\n            if (isReady) {\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 2026 DXOS.org\n//\n\nimport * as Context from 'effect/Context';\nimport * as Effect from 'effect/Effect';\nimport * as Layer from 'effect/Layer';\nimport { type DependencyList, use, useCallback, useMemo } from 'react';\n\nimport { Operation, ServiceResolver } from '@dxos/compute';\nimport { EffectEx } from '@dxos/effect';\nimport type { SpaceId } from '@dxos/keys';\n\nimport { Capabilities } from '../../common';\nimport { useCapability } from './useCapabilities';\n\n/**\n * Resolve the shared {@link Capabilities.ProcessManagerRuntime} from the plugin context.\n */\nexport const useProcessManagerRuntime = (): Capabilities.ProcessManagerRuntime =>\n  useCapability(Capabilities.ProcessManagerRuntime);\n\n/**\n * Build a callback that runs an effect on the {@link Capabilities.ProcessManagerRuntime}\n * with space-scoped services resolved via {@link ServiceResolver.provide}.\n *\n * The `tags` tuple must list every service the effect requires (beyond the\n * fixed {@link Capabilities.ProcessManagerRuntimeServices}); these services are\n * resolved for the given `spaceId` through the runtime's service resolver.\n *\n * Nested `Operation.invoke` / `Operation.schedule` calls within the effect\n * inherit `spaceId` as a default {@link Operation.InvokeOptions} so that\n * spawned operation processes have a space context (and therefore can resolve\n * space-scoped services like `Database.Service`) without each call site having\n * to thread the id through manually.\n */\nexport const useSpaceCallback = <const Tags extends readonly Context.Tag<any, any>[], T>(\n  spaceId: SpaceId | undefined,\n  tags: Tags,\n  fn: () => Effect.Effect<T, any, Context.Tag.Identifier<Tags[number]> | Capabilities.ProcessManagerRuntimeServices>,\n  deps?: DependencyList,\n): (() => Promise<T>) => {\n  const runtime = useProcessManagerRuntime();\n  return useCallback(() => {\n    if (spaceId === undefined) {\n      throw new TypeError('Space not provided to useSpaceCallback');\n    }\n    const layer = Layer.merge(\n      ServiceResolver.provide({ space: spaceId }, ...tags),\n      Operation.withInvocationOptions({ spaceId }),\n    );\n    return runtime.runPromise(fn().pipe(Effect.provide(layer)) as Effect.Effect<T, any, any>);\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [runtime, spaceId, ...(deps ?? [])]);\n};\n\n/**\n * Suspensefully resolve a single space-scoped service via the\n * {@link Capabilities.ProcessManagerRuntime}'s service resolver.\n */\nexport const useSpaceService = <T extends Context.Tag<any, any>>(\n  tag: T,\n  spaceId: SpaceId | undefined,\n): Context.Tag.Service<T> | undefined => {\n  const runtime = useProcessManagerRuntime();\n  const promise = useMemo(() => {\n    if (spaceId === undefined) {\n      return undefined;\n    }\n    const layer = ServiceResolver.provide({ space: spaceId }, tag);\n    const effect = Effect.flatMap(tag, (service) => Effect.succeed(service)).pipe(Effect.provide(layer));\n    return runtime.runPromiseExit(effect as Effect.Effect<Context.Tag.Service<T>, any, any>);\n  }, [runtime, spaceId, tag]);\n  if (!promise) {\n    return undefined;\n  }\n  return EffectEx.unwrapExit(use(promise));\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", "useLayoutEffect", "RegistryContext", "Effect", "Fiber", "PubSub", "Queue", "React", "useCallback", "useEffect", "useMemo", "useRef", "useState", "EffectEx", "invariant", "log", "ErrorBoundary", "ErrorFallback", "useAsyncEffect", "useDefaultValue", "ContextProtocolProvider", "ENABLED_KEY", "defaults", "useDefaultValue", "defaultsProp", "setupEvents", "setupEventsProp", "pluginLoader", "pluginLoaderProp", "plugin", "find", "meta", "invariant", "id", "plugins", "errorRef", "useRef", "error", "setError", "useState", "startupProgress", "setStartupProgress", "activated", "total", "progress", "safeMode", "cacheEnabled", "cached", "pluginManager", "enabled", "onRemove", "pluginRegistryProvider", "mgr", "onPluginRemove", "useEffect", "manager", "useAsyncEffect", "capabilities", "contribute", "interface", "Capabilities", "PluginManager", "implementation", "module", "registry", "fiber", "forkDaemon", "setReady", "readyRef", "current", "globalThis", "humanizedName", "humanizeModuleId", "length", "active", "event", "error$", "Effect", "forever", "activate", "ActivationEvents", "Startup", "join", "listener", "pipe", "timeoutId", "eventsFired", "getEventsFired", "activeModules", "pendingReset", "getPendingReset", "runAndForwardErrors", "interrupt", "Error", "timeout", "clearTimeout", "Fiber", "isExternalManager", "EffectEx", "shutdown", "progressRef", "name", "FallbackComponent", "fallback", "value", "ContextProtocolProvider", "PluginManagerContext", "App", "ready", "debounce", "composer", "match", "parts", "pluginSlug", "moduleName", "pluginLabel", "split", "map", "word", "Atom", "useAtomValue", "useCallback", "invariant", "__dxlog_file", "useAtomValue", "capabilities", "interfaceDef", "invariant", "length", "atom", "useCapability", "atomCapability", "value", "update", "fn", "registry", "set", "useCallback", "useEffect", "useRef", "useState", "LoadingState", "useLoading", "ready", "debounce", "stage", "setStage", "readyRef", "current", "i", "setInterval", "isReady", "clearInterval", "Effect", "Layer", "use", "useCallback", "useMemo", "Operation", "ServiceResolver", "EffectEx", "useProcessManagerRuntime", "useCapability", "Capabilities", "ProcessManagerRuntime", "useSpaceCallback", "spaceId", "tags", "fn", "deps", "runtime", "useCallback", "undefined", "TypeError", "layer", "merge", "ServiceResolver", "provide", "space", "Operation", "withInvocationOptions", "runPromise", "pipe", "useSpaceService", "tag", "promise", "useMemo", "effect", "flatMap", "service", "succeed", "runPromiseExit", "EffectEx", "unwrapExit", "use", "RegistryContext", "useAtomValue", "useCallback", "useContext", "useSettingsState", "atom", "registry", "settings", "updateSettings", "fn", "set", "get", "FIRST_INTERACTIVE_MARK", "App", "ready", "error", "debounce", "progress", "reactContexts", "useCapabilities", "Capabilities", "ReactContext", "reactRoots", "ReactRoot", "stage", "useLoading", "placeholderDismissed", "LoadingState", "Done", "useEffect", "FadeOut", "fraction", "window", "__bootLoader", "humanizedName", "status", "event", "module", "humanized", "useLayoutEffect", "performance", "getEntriesByName", "length", "mark", "dismiss", "location", "search", "Error", "ComposedContext", "composeContexts", "React", "map", "id", "root", "Component", "key", "contexts", "children", "topologicalSort", "context", "reduce", "Acc", "Next"]
+}

package/dist/lib/browser/{chunk-DC3WRPBV.mjs → chunk-S2ZBYQPI.mjs}

@@ -1,6 +1,6 @@
 import {
   getModuleTag
-} from "./chunk-IW44C7UL.mjs";
+} from "./chunk-CMINFVA5.mjs";
 import {
   __export
 } from "./chunk-J5LGTIGS.mjs";
@@ -9,13 +9,18 @@ import {
 var plugin_exports = {};
 __export(plugin_exports, {
   LazyPluginError: () => LazyPluginError,
+  Meta: () => Meta,
   PluginDependencyError: () => PluginDependencyError,
   PluginModuleTypeId: () => PluginModuleTypeId,
   PluginTypeId: () => PluginTypeId,
+  Profile: () => Profile,
+  Release: () => Release,
   Service: () => Service,
   activate: () => activate,
   addModule: () => addModule,
   define: () => define,
+  getMetaFromConfig: () => getMetaFromConfig,
+  getURI: () => getURI,
   isLazy: () => isLazy,
   isPlugin: () => isPlugin,
   isPluginModule: () => isPluginModule,
@@ -30,9 +35,11 @@ import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import * as Pipeable from "effect/Pipeable";
+import * as Schema from "effect/Schema";
 import { BaseError } from "@dxos/errors";
 import { invariant } from "@dxos/invariant";
 import { DXN } from "@dxos/keys";
+import { PluginProfileSchema, PluginReleaseSchema } from "@dxos/protocols";
 var __dxlog_file = "/__w/dxos/dxos/packages/sdk/app-framework/src/core/plugin.ts";
 var Service = class extends Context.Tag("@dxos/app-framework/PluginManager")() {
 };
@@ -61,11 +68,32 @@ var PluginModuleImpl = class {
     this.activate = options.activate;
   }
 };
-var makeMeta = (options) => ({
-  ...options,
-  id: DXN.getName(options.key),
-  version: DXN.getVersion(options.key)
+var Profile = Schema.Struct({
+  ...PluginProfileSchema.fields,
+  author: Schema.optional(Schema.String)
 });
+var Release = PluginReleaseSchema;
+var Meta = Schema.Struct({
+  profile: Profile,
+  release: Schema.optional(Release)
+});
+var makeMeta = (options) => {
+  const { key, ...rest } = options;
+  return {
+    profile: {
+      ...rest,
+      key: DXN.getName(key)
+    }
+  };
+};
+var getURI = (meta) => DXN.make(meta.profile.key, meta.release?.version);
+var getMetaFromConfig = ({ plugin }) => {
+  const { key, ...rest } = plugin;
+  return makeMeta({
+    key: DXN.make(key),
+    ...rest
+  });
+};
 var PluginTypeId = /* @__PURE__ */ Symbol.for("@dxos/app-framework/Plugin");
 var isPlugin = (value) => {
   return typeof value === "object" && value !== null && PluginTypeId in value;
@@ -112,11 +140,11 @@ function addModule(moduleOptionsOrBuilder, moduleOptions) {
 }
 var resolveModule = (meta, module, options) => {
   const moduleOptions = typeof module === "function" ? module(options) : module;
-  const pluginName = meta.id;
+  const pluginName = meta.profile.key;
   const id = Option.fromNullable(moduleOptions.id).pipe(Option.match({
     onNone: () => {
       const exportName = getModuleTag(moduleOptions.activate);
-      invariant(exportName, `Plugin module missing name. Plugin: ${meta.id}`, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 148, S: void 0, A: ["exportName", "`Plugin module missing name. Plugin: ${meta.id}`"] });
+      invariant(exportName, `Plugin module missing name. Plugin: ${meta.profile.key}`, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 174, S: void 0, A: ["exportName", "`Plugin module missing name. Plugin: ${meta.profile.key}`"] });
       return computeModuleId(pluginName, exportName);
     },
     onSome: (id2) => computeModuleId(pluginName, id2)
@@ -128,7 +156,7 @@ var resolveModule = (meta, module, options) => {
 };
 function make(builder) {
   const meta = builder.meta;
-  invariant(!meta.dependsOn?.includes(meta.id), `Plugin ${meta.id} declares itself as a dependency.`, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 161, S: this, A: ["!meta.dependsOn?.includes(meta.id)", "`Plugin ${meta.id} declares itself as a dependency.`"] });
+  invariant(!meta.profile.dependsOn?.includes(meta.profile.key), `Plugin ${meta.profile.key} declares itself as a dependency.`, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 187, S: this, A: ["!meta.profile.dependsOn?.includes(meta.profile.key)", "`Plugin ${meta.profile.key} declares itself as a dependency.`"] });
   const factory = (options) => {
     const modules = builder.modules.map((module) => resolveModule(meta, module, options));
     return new PluginImpl(meta, modules);
@@ -163,7 +191,7 @@ var resolveLazy = (plugin) => Effect.gen(function* () {
   if (!isLazy(plugin)) {
     return plugin;
   }
-  const id = plugin.meta.id;
+  const id = plugin.meta.profile.key;
   const { loader, options } = plugin[LazyTag];
   const mod = yield* Effect.tryPromise({
     try: loader,
@@ -192,12 +220,12 @@ var resolveLazy = (plugin) => Effect.gen(function* () {
       }
     }));
   }
-  if (result.meta.id !== id) {
+  if (result.meta.profile.key !== id) {
     return yield* Effect.fail(new LazyPluginError({
       context: {
         id,
         reason: "meta-mismatch",
-        returnedId: result.meta.id
+        returnedId: result.meta.profile.key
       }
     }));
   }
@@ -211,7 +239,12 @@ export {
   shutdown,
   PluginModuleTypeId,
   isPluginModule,
+  Profile,
+  Release,
+  Meta,
   makeMeta,
+  getURI,
+  getMetaFromConfig,
   PluginTypeId,
   isPlugin,
   define,
@@ -224,4 +257,4 @@ export {
   resolveLazy,
   plugin_exports
 };
-//# sourceMappingURL=chunk-DC3WRPBV.mjs.map
+//# sourceMappingURL=chunk-S2ZBYQPI.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/core/plugin.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Context from 'effect/Context';\nimport * as Effect from 'effect/Effect';\nimport * as Option from 'effect/Option';\nimport * as Pipeable from 'effect/Pipeable';\nimport * as Schema from 'effect/Schema';\n\nimport { BaseError } from '@dxos/errors';\nimport { invariant } from '@dxos/invariant';\nimport { DXN } from '@dxos/keys';\nimport { Config2, PluginProfileSchema, PluginReleaseSchema } from '@dxos/protocols';\n\nimport type * as ActivationEvent from './activation-event';\nimport * as Capability from './capability';\nimport type * as PluginManager from './plugin-manager';\n\n//\n// Plugin Service Layer\n//\n\n/**\n * Effect Context.Tag for accessing PluginManager via the Effect layer system.\n * This allows lifecycle operations to access the plugin manager without having it passed as an argument.\n */\nexport class Service extends Context.Tag('@dxos/app-framework/PluginManager')<Service, PluginManager.PluginManager>() {}\n\n//\n// Lifecycle Functions\n//\n\n/**\n * Activates plugins based on the activation event.\n * Accesses the PluginManager via the Effect layer system.\n * @param event The activation event.\n * @returns Whether the activation was successful.\n */\nexport const activate = (event: ActivationEvent.ActivationEvent): Effect.Effect<boolean, Error, Service> =>\n  Effect.flatMap(Service, (manager) => manager.activate(event));\n\n/**\n * Re-activates the modules that were activated by the event.\n * Accesses the PluginManager via the Effect layer system.\n * @param event The activation event.\n * @returns Whether the reset was successful.\n */\nexport const reset = (event: ActivationEvent.ActivationEvent): Effect.Effect<boolean, Error, Service> =>\n  Effect.flatMap(Service, (manager) => manager.reset(event));\n\n/**\n * Shuts down the plugin manager, deactivating all active modules and clearing lifecycle state.\n * Accesses the PluginManager via the Effect layer system.\n */\nexport const shutdown = (): Effect.Effect<boolean, Error, Service> =>\n  Effect.flatMap(Service, (manager) => manager.shutdown());\n\n/**\n * Computes a module ID from plugin ID and export name.\n */\nconst computeModuleId = (pluginId: string, moduleName: string): string => {\n  return `${pluginId}.module.${moduleName}`;\n};\n\n/**\n * Identifier denoting a PluginModule.\n */\nexport const PluginModuleTypeId: unique symbol = Symbol.for('@dxos/app-framework/PluginModule');\nexport type PluginModuleTypeId = typeof PluginModuleTypeId;\n\n/**\n * Type guard to check if a value is a PluginModule.\n */\nexport const isPluginModule = (value: unknown): value is PluginModule => {\n  return typeof value === 'object' && value !== null && PluginModuleTypeId in value;\n};\n\n/**\n * A unit of containment of modular functionality that can be provided to an application.\n * Activation of a module is async allowing for code to split and loaded lazily.\n */\nexport interface PluginModule {\n  readonly [PluginModuleTypeId]: PluginModuleTypeId;\n  /**\n   * Unique id of the module.\n   */\n  id: string;\n\n  /**\n   * Events for which the module will be activated.\n   */\n  activatesOn: ActivationEvent.Events;\n\n  /**\n   * Events that this module fires *before* its own activation runs.\n   *\n   * When this module is asked to activate (via {@link activatesOn}), the\n   * plugin manager first activates every event listed here, ensuring any\n   * other modules that contribute to those events have completed before\n   * this module's {@link activate} body executes. These events are fired\n   * by the framework on this module's behalf — the module does not need\n   * to wait for some other code to fire them.\n   *\n   * The module is marked as needing reset if a module activated by one\n   * of these events is later removed.\n   *\n   * Read as: \"this module fires these events before [its] activation\".\n   */\n  firesBeforeActivation?: ActivationEvent.ActivationEvent[];\n\n  /**\n   * Events that this module fires *after* its own activation completes.\n   *\n   * Once this module's {@link activate} body has finished executing, the\n   * plugin manager activates every event listed here, causing any modules\n   * listening on those events to run. These events are fired by the\n   * framework on this module's behalf as part of this module's lifecycle.\n   *\n   * Read as: \"this module fires these events after [its] activation\".\n   */\n  firesAfterActivation?: ActivationEvent.ActivationEvent[];\n\n  /**\n   * Called when the module is activated.\n   * CapabilityManager is accessed via the Effect layer system (Capability.Service).\n   * PluginManager is accessed via Plugin.Service.\n   * @param props Optional props passed to the module.\n   * @returns The capabilities of the module.\n   */\n  activate: (props?: any) => Effect.Effect<Capability.ModuleReturn, Error, Capability.Service | Service | never>;\n}\n\nexport type PluginModuleOptions = Omit<PluginModule, 'id' | typeof PluginModuleTypeId> & { id?: string };\n\nclass PluginModuleImpl implements PluginModule {\n  readonly [PluginModuleTypeId]: PluginModuleTypeId = PluginModuleTypeId;\n  readonly id: PluginModule['id'];\n  readonly activatesOn: PluginModule['activatesOn'];\n  readonly firesBeforeActivation?: PluginModule['firesBeforeActivation'];\n  readonly firesAfterActivation?: PluginModule['firesAfterActivation'];\n  readonly activate: PluginModule['activate'];\n\n  constructor(options: Omit<PluginModule, typeof PluginModuleTypeId>) {\n    this.id = options.id;\n    this.activatesOn = options.activatesOn;\n    this.firesBeforeActivation = options.firesBeforeActivation;\n    this.firesAfterActivation = options.firesAfterActivation;\n    this.activate = options.activate;\n  }\n}\n\n/**\n * Runtime plugin metadata, derived from the `@dxos/protocols` registry schemas (protocols owns the\n * config + registry schemas; the runtime projection lives here).\n *\n * - {@link Profile}: version-independent identity + display + provenance — the wire `PluginProfileSchema`\n *   (which carries `key`, the display fields, `dependsOn`, `spec`) plus `author` (resolved at runtime\n *   from the publisher's handle/DID for registry plugins, or self-declared for bundled).\n * - {@link Release}: a specific hosted release — the wire `PluginReleaseSchema` (version, moduleUrl, dependencies).\n * - {@link Meta}: a resolved single-release view — `{ profile, release? }`, both nested. `release` is\n *   unset for bundled plugins (compiled in) and set for registry plugins.\n */\nexport const Profile = Schema.Struct({\n  ...PluginProfileSchema.fields,\n  author: Schema.optional(Schema.String),\n});\nexport type Profile = Schema.Schema.Type<typeof Profile>;\n\nexport const Release = PluginReleaseSchema;\nexport type Release = Schema.Schema.Type<typeof Release>;\n\nexport const Meta = Schema.Struct({\n  profile: Profile,\n  release: Schema.optional(Release),\n});\nexport type Meta = Schema.Schema.Type<typeof Meta>;\n\n/** Options for {@link makeMeta}: the {@link Profile} content fields plus the canonical DXN `key`. */\nexport type MakeMetaOptions = {\n  key: DXN.DXN;\n  name: string;\n  description?: string;\n  author?: string;\n  homePage?: string;\n  source?: string;\n  tags?: readonly string[];\n  dependsOn?: readonly string[];\n  spec?: string;\n  icon?: Config2.Icon;\n  screenshots?: ReadonlyArray<Config2.Screenshot>;\n};\n\n/** Constructs a bundled-plugin {@link Meta} from a canonical DXN. `profile.key` is the bare NSID derived from `key`. */\nexport const makeMeta = (options: MakeMetaOptions): Meta => {\n  const { key, ...rest } = options;\n  return { profile: { ...rest, key: DXN.getName(key) } };\n};\n\n/** Returns the plugin's canonical DXN URI, constructed from `meta.profile.key` and `meta.release?.version`. */\nexport const getURI = (meta: Meta): DXN.DXN => DXN.make(meta.profile.key, meta.release?.version);\n\n/**\n * Derives a runtime {@link Meta} from a loaded `dx.config.ts` (the `@dxos/protocols` `Config2.Config`).\n * Maps the flat authoring config to the nested profile; bundled plugins have no `release`.\n */\nexport const getMetaFromConfig = ({ plugin }: Config2.Config): Meta => {\n  const { key, ...rest } = plugin;\n  return makeMeta({ key: DXN.make(key), ...rest });\n};\n\n/**\n * Identifier denoting a Plugin.\n */\nexport const PluginTypeId: unique symbol = Symbol.for('@dxos/app-framework/Plugin');\nexport type PluginTypeId = typeof PluginTypeId;\n\n/**\n * Type guard to check if a value is a Plugin.\n */\nexport const isPlugin = (value: unknown): value is Plugin => {\n  return typeof value === 'object' && value !== null && PluginTypeId in value;\n};\n\n/**\n * A collection of modules that are be enabled/disabled as a unit.\n * Plugins provide things such as components, state, actions, etc. to the application.\n */\n// TODO(burdon): Convert to ECHO schema.\nexport interface Plugin {\n  readonly [PluginTypeId]: PluginTypeId;\n  readonly meta: Readonly<Meta>;\n  readonly modules: ReadonlyArray<PluginModule>;\n}\n\n/**\n * Internal implementation of Plugin.\n * @internal\n */\nclass PluginImpl implements Plugin {\n  readonly [PluginTypeId]: PluginTypeId = PluginTypeId;\n\n  constructor(\n    private readonly _meta: Meta,\n    private readonly _modules: PluginModule[],\n  ) {}\n\n  get meta(): Readonly<Meta> {\n    return this._meta;\n  }\n\n  get modules(): ReadonlyArray<PluginModule> {\n    return this._modules;\n  }\n}\n\n/**\n * Builder interface for creating plugins incrementally.\n */\nexport interface PluginBuilder<T = void> extends Pipeable.Pipeable {\n  readonly meta: Meta;\n  readonly modules: ReadonlyArray<PluginModuleOptions | ((options: T) => PluginModuleOptions)>;\n  addModule(moduleOptions: PluginModuleOptions | ((options: T) => PluginModuleOptions)): PluginBuilder<T>;\n}\n\n/**\n * Builder implementation for creating plugins incrementally.\n */\nclass PluginBuilderImpl<T = void> implements PluginBuilder<T> {\n  readonly meta: Meta;\n  private readonly _modules: Array<PluginModuleOptions | ((options: T) => PluginModuleOptions)> = [];\n\n  constructor(meta: Meta) {\n    this.meta = meta;\n  }\n\n  get modules(): ReadonlyArray<PluginModuleOptions | ((options: T) => PluginModuleOptions)> {\n    return this._modules;\n  }\n\n  addModule(moduleOptions: PluginModuleOptions | ((options: T) => PluginModuleOptions)): PluginBuilder<T> {\n    this._modules.push(moduleOptions);\n    return this;\n  }\n\n  pipe() {\n    // eslint-disable-next-line prefer-rest-params\n    return Pipeable.pipeArguments(this, arguments);\n  }\n}\n\n/**\n * Creates a new PluginBuilder to start building a plugin.\n */\nexport const define = <T = void>(meta: Meta): PluginBuilder<T> => new PluginBuilderImpl<T>(meta);\n\n/**\n * Adds a module to a plugin builder.\n * Supports both pipeline and direct call styles.\n * Modules can be either PluginModuleOptions or functions that receive options.\n */\nexport function addModule<T>(\n  moduleOptions: PluginModuleOptions | ((options: T) => PluginModuleOptions),\n): (builder: PluginBuilder<T>) => PluginBuilder<T>;\nexport function addModule<T>(\n  builder: PluginBuilder<T>,\n  moduleOptions: PluginModuleOptions | ((options: T) => PluginModuleOptions),\n): PluginBuilder<T>;\nexport function addModule<T>(\n  moduleOptionsOrBuilder: PluginModuleOptions | ((options: T) => PluginModuleOptions) | PluginBuilder<T>,\n  moduleOptions?: PluginModuleOptions | ((options: T) => PluginModuleOptions),\n): ((builder: PluginBuilder<T>) => PluginBuilder<T>) | PluginBuilder<T> {\n  // If second arg is provided, it's the direct call style: addModule(builder, moduleOptions)\n  if (moduleOptions !== undefined) {\n    return (moduleOptionsOrBuilder as PluginBuilder<T>).addModule(moduleOptions);\n  }\n  // Otherwise it's pipeline style: addModule(moduleOptions) returns a function\n  const moduleOpts = moduleOptionsOrBuilder as PluginModuleOptions | ((options: T) => PluginModuleOptions);\n  return (builder: PluginBuilder<T>) => builder.addModule(moduleOpts);\n}\n\nexport type PluginFactory<T = void> = ((options: T) => Plugin) & { meta: Meta };\n\n/**\n * Resolves a module from either PluginModuleOptions or a function that returns PluginModuleOptions.\n */\nconst resolveModule = (\n  meta: Meta,\n  module: PluginModuleOptions | ((options: any) => PluginModuleOptions),\n  options?: any,\n): PluginModuleImpl => {\n  const moduleOptions = typeof module === 'function' ? module(options) : module;\n  const pluginName = meta.profile.key;\n  const id = Option.fromNullable(moduleOptions.id).pipe(\n    Option.match({\n      onNone: () => {\n        const exportName = Capability.getModuleTag(moduleOptions.activate);\n        invariant(exportName, `Plugin module missing name. Plugin: ${meta.profile.key}`);\n        return computeModuleId(pluginName, exportName);\n      },\n      onSome: (id) => computeModuleId(pluginName, id),\n    }),\n  );\n  return new PluginModuleImpl({ ...moduleOptions, id });\n};\n\n/**\n * Creates a Plugin from a builder.\n * Supports both pipeline and direct call styles.\n * Always returns a factory function (options: T) => Plugin.\n * When T is void, the function takes no arguments: () => Plugin.\n */\nexport function make<T>(builder: PluginBuilder<T>): PluginFactory<T>;\nexport function make<T>(builder: PluginBuilder<T>): PluginFactory<T> {\n  const meta = builder.meta;\n  // `dependsOn` entries and `key` are both bare NSIDs, so compare directly.\n  invariant(\n    !meta.profile.dependsOn?.includes(meta.profile.key),\n    `Plugin ${meta.profile.key} declares itself as a dependency.`,\n  );\n\n  const factory = (options: T) => {\n    const modules = builder.modules.map((module) => resolveModule(meta, module, options));\n    return new PluginImpl(meta, modules);\n  };\n\n  return Object.assign(factory, { meta });\n}\n\n//\n// Lazy plugin loading\n//\n\n/**\n * Symbol used to tag lazy plugin stubs with their loader closure.\n * Hidden from enumeration so plugin manager iteration / serialization paths\n * don't trip over it.\n */\nconst LazyTag: unique symbol = Symbol.for('@dxos/app-framework/Plugin/Lazy');\n\n/**\n * Async loader for a lazy plugin's real implementation.\n * The default export of the loaded module must be a `PluginFactory<T>` —\n * i.e. the same shape `Plugin.make` produces.\n */\nexport type LazyLoader<T = void> = () => Promise<{ default: PluginFactory<T> }>;\n\n/** Internal: payload carried on a lazy stub. */\ntype LazyPayload = { loader: LazyLoader<any>; options: unknown };\n\n/**\n * Defines a lazy plugin whose body is loaded on first enable.\n *\n * The returned factory produces a stub `Plugin` that exposes `meta`\n * synchronously (so callers can read `Plugin.meta.profile.key` for free) but defers\n * loading the real plugin's modules until the manager calls\n * `Plugin.resolveLazy`. This lets the plugin's main entry point ship as a\n * tiny meta-only chunk — the heavy capabilities, schema, React surfaces,\n * etc. live behind the dynamic `import()` and become a separate Rollup\n * chunk that is only fetched when the plugin is enabled.\n *\n * @example\n * ```ts\n * // plugin-markdown/src/index.ts\n * import { Plugin } from '@dxos/app-framework';\n * import { meta } from './meta';\n *\n * export const MarkdownPlugin = Plugin.lazy(meta, () => import('./MarkdownPlugin'));\n *\n * // plugin-markdown/src/MarkdownPlugin.tsx\n * export const MarkdownPlugin = Plugin.define(meta).pipe(...heavy modules..., Plugin.make);\n * export default MarkdownPlugin;\n * ```\n */\nexport const lazy = <T = void>(meta: Meta, loader: LazyLoader<T>): PluginFactory<T> => {\n  const factory = (options: T): Plugin => {\n    const stub = new PluginImpl(meta, []);\n    Object.defineProperty(stub, LazyTag, {\n      value: { loader, options } satisfies LazyPayload,\n      enumerable: false,\n    });\n    return stub;\n  };\n  return Object.assign(factory, { meta });\n};\n\n/**\n * Type guard for lazy plugin stubs produced by {@link lazy}.\n */\nexport const isLazy = (plugin: Plugin): boolean => LazyTag in plugin;\n\n/**\n * Tagged error for failures during lazy plugin resolution. `context.id` is\n * the lazy plugin's `meta.profile.key`; `context.reason` discriminates the failure\n * mode (`'load-failed' | 'missing-default' | 'invalid-plugin' |\n * 'meta-mismatch'`) so callers can route on it.\n */\nexport class LazyPluginError extends BaseError.extend('LazyPluginError', 'Failed to resolve lazy plugin') {}\n\n/**\n * Tagged error for plugin-level dependency resolution failures.\n *\n * `context.id` is the plugin id the manager was acting on. `context.reason`\n * discriminates the failure mode:\n *  - `'missing'` — declared dep is neither registered nor in the catalog.\n *    `context.missing` lists offending ids.\n *  - `'install-failed'` — dep was found in the catalog but `add()` failed.\n *    `cause` carries the original error.\n *  - `'cycle'` — closure walk detected a cycle. `context.path` is the cycle path.\n *  - `'core-dependent'` — cascade-disable would have to disable a core plugin.\n *    `context.coreDependent` is the blocking id.\n */\nexport class PluginDependencyError extends BaseError.extend(\n  'PluginDependencyError',\n  'Plugin dependency resolution failed',\n) {}\n\n/**\n * Resolves a lazy plugin stub to its real plugin.\n * Returns the plugin unchanged if it is not lazy. Failures surface as\n * {@link LazyPluginError} with `context.reason` indicating the failure mode\n * and (for loader failures) `cause` set to the original error.\n */\nexport const resolveLazy = (plugin: Plugin): Effect.Effect<Plugin, LazyPluginError> =>\n  Effect.gen(function* () {\n    if (!isLazy(plugin)) {\n      return plugin;\n    }\n    const id = plugin.meta.profile.key;\n    const { loader, options } = (plugin as unknown as { [LazyTag]: LazyPayload })[LazyTag];\n    const mod = yield* Effect.tryPromise({\n      try: loader,\n      catch: (error) => new LazyPluginError({ context: { id, reason: 'load-failed' }, cause: error }),\n    });\n    if (!mod || typeof mod.default !== 'function') {\n      return yield* Effect.fail(new LazyPluginError({ context: { id, reason: 'missing-default' } }));\n    }\n    const result = mod.default(options);\n    if (!isPlugin(result)) {\n      return yield* Effect.fail(new LazyPluginError({ context: { id, reason: 'invalid-plugin' } }));\n    }\n    if (result.meta.profile.key !== id) {\n      return yield* Effect.fail(\n        new LazyPluginError({ context: { id, reason: 'meta-mismatch', returnedId: result.meta.profile.key } }),\n      );\n    }\n    return result;\n  });\n"],
+  "mappings": "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",
+  "names": ["Context", "Effect", "Option", "Pipeable", "Schema", "BaseError", "invariant", "DXN", "PluginProfileSchema", "PluginReleaseSchema", "PluginModuleImpl", "id", "activatesOn", "firesBeforeActivation", "firesAfterActivation", "activate", "author", "Schema", "Release", "PluginReleaseSchema", "profile", "Profile", "release", "optional", "DXN", "makeMeta", "key", "make", "rest", "_meta", "_modules", "meta", "modules", "addModule", "moduleOptions", "pipe", "undefined", "pluginName", "fromNullable", "Option", "onNone", "exportName", "Capability", "getModuleTag", "invariant", "onSome", "computeModuleId", "builder", "module", "resolveModule", "options", "PluginImpl", "Object", "assign", "factory", "stub", "defineProperty", "value", "loader", "enumerable", "plugin", "mod", "Effect", "tryPromise", "try", "catch", "error", "LazyPluginError", "reason", "cause", "context", "result", "fail", "returnedId"]
+}

package/dist/lib/browser/{chunk-HFLKXMT7.mjs → chunk-SWECIICH.mjs}

@@ -1,6 +1,6 @@
 import {
   capabilities_exports
-} from "./chunk-CO3XLNUX.mjs";
+} from "./chunk-37PG7XJC.mjs";
 
 // src/helpers.ts
 var topologicalSort = (nodes) => {
@@ -42,6 +42,7 @@ import { createContext, useContext } from "react";
 import { raise } from "@dxos/debug";
 var PluginManagerContext = createContext(void 0);
 var usePluginManager = () => useContext(PluginManagerContext) ?? raise(new Error("Missing PluginManagerContext"));
+var useOptionalPluginManager = () => useContext(PluginManagerContext);
 var PluginManagerProvider = PluginManagerContext.Provider;
 
 // src/ui/components/Surface/context.ts
@@ -409,15 +410,15 @@ var SurfaceContextProvider = /* @__PURE__ */ memo(/* @__PURE__ */ forwardRef2(({
   }))));
 }));
 SurfaceContextProvider.displayName = "SurfaceContextProvider";
-var SurfaceComponent = /* @__PURE__ */ memo(/* @__PURE__ */ forwardRef2(({ id: _id, role, type, data: dataProp, limit, placeholder = DEFAULT_PLACEHOLDER, ...rest }, forwardedRef) => {
+var SurfaceComponent = /* @__PURE__ */ memo(/* @__PURE__ */ forwardRef2(({ id: _id, type, data: dataProp, limit, placeholder = DEFAULT_PLACEHOLDER, ...rest }, forwardedRef) => {
   const data = useDefaultValue(dataProp, () => ({}));
   const surfaces = useSurfaces();
-  const effectiveRole = role ?? type?.role;
+  const effectiveRole = type?.role;
   if (effectiveRole == null) {
     if (DEBUG) {
-      log.warn("Surface has neither `role` nor `type` prop", {
+      log.warn("Surface is missing required `type` prop", {
         id: _id
-      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 194, S: void 0 });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 193, S: void 0 });
     }
     return null;
   }
@@ -430,7 +431,7 @@ var SurfaceComponent = /* @__PURE__ */ memo(/* @__PURE__ */ forwardRef2(({ id: _
     log.warn("no candidates for surface", {
       role: effectiveRole,
       data
-    }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 207, S: void 0 });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 206, S: void 0 });
     return null;
   }
   return /* @__PURE__ */ React3.createElement(Suspense, {
@@ -476,24 +477,49 @@ var useSurfaces = () => {
     surfacesByModule
   ]);
 };
-function isSurfaceAvailable(capabilityManager, { role, type, data }) {
-  const effectiveRole = role ?? type?.role;
+function isSurfaceAvailable(capabilityManager, args) {
+  const effectiveRole = args.type?.role;
   if (effectiveRole == null) {
     return false;
   }
   const surfaces = capabilityManager.getAll(capabilities_exports.ReactSurface);
   const candidates = findCandidates(surfaces.flat(), {
     role: effectiveRole,
-    data
+    data: args.data
   });
   return candidates.length > 0;
 }
 
 // src/ui/components/Surface/types.ts
+import { log as log2 } from "@dxos/log";
+var __dxlog_file2 = "/__w/dxos/dxos/packages/sdk/app-framework/src/ui/components/Surface/types.ts";
 var isSurfaceFilter = (value) => typeof value === "object" && value !== null && Array.isArray(value.bindings);
-var makeType = (role) => ({
-  role
-});
+var makeType = (nsid) => {
+  if (typeof nsid !== "string" || !/^[a-zA-Z]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(\.[a-zA-Z][a-zA-Z0-9]{0,62})$/.test(nsid)) {
+    throw new Error(`Invalid role NSID: "${nsid}". Must be a dotted name with a camelCase final segment (no hyphens in the last segment).`);
+  }
+  return {
+    role: nsid
+  };
+};
+var makeFilter = (token, guard) => {
+  const boundGuard = guard == null ? () => true : (data) => {
+    try {
+      return guard(data);
+    } catch (err) {
+      log2.catch(err, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 39, S: void 0 });
+      return false;
+    }
+  };
+  return {
+    bindings: [
+      {
+        role: token.role,
+        guard: boundGuard
+      }
+    ]
+  };
+};
 var expandBindings = (filter) => {
   const bindings = filter.bindings;
   const roles = Array.from(new Set(bindings.map((binding) => binding.role)));
@@ -517,40 +543,28 @@ var validateLocalId = (id) => {
 };
 function create(definition) {
   validateLocalId(definition.id);
-  if (isSurfaceFilter(definition.filter)) {
-    const { id, filter, component, position } = definition;
-    const { role, guard } = expandBindings(filter);
-    return {
-      kind: "react",
-      id,
-      role,
-      position,
-      component,
-      filter: guard
-    };
-  }
+  const { id, filter, component, position } = definition;
+  const { role, guard } = expandBindings(filter);
   return {
-    ...definition,
-    kind: "react"
+    kind: "react",
+    id,
+    role,
+    position,
+    component,
+    filter: guard
   };
 }
 function createWeb(definition) {
   validateLocalId(definition.id);
-  if (isSurfaceFilter(definition.filter)) {
-    const { id, filter, tagName, position } = definition;
-    const { role, guard } = expandBindings(filter);
-    return {
-      kind: "web-component",
-      id,
-      role,
-      position,
-      tagName,
-      filter: guard
-    };
-  }
+  const { id, filter, tagName, position } = definition;
+  const { role, guard } = expandBindings(filter);
   return {
-    ...definition,
-    kind: "web-component"
+    kind: "web-component",
+    id,
+    role,
+    position,
+    tagName,
+    filter: guard
   };
 }
 
@@ -562,6 +576,7 @@ function createWeb(definition) {
   Surface2.Surface = SurfaceComponent;
   Surface2.isAvailable = isSurfaceAvailable;
   Surface2.makeType = makeType;
+  Surface2.makeFilter = makeFilter;
   Surface2.isFilter = isSurfaceFilter;
   Surface2.ProfilerProvider = SurfaceProfilerProvider;
   Surface2.useProfilerCallback = useSurfaceProfilerCallback;
@@ -580,8 +595,9 @@ export {
   topologicalSort,
   useSurface,
   usePluginManager,
+  useOptionalPluginManager,
   PluginManagerProvider,
   SurfaceComponent,
   Surface
 };
-//# sourceMappingURL=chunk-HFLKXMT7.mjs.map
+//# sourceMappingURL=chunk-SWECIICH.mjs.map