@dxos/app-framework 0.14.0 → 0.16.0

package/dist/lib/chunk-capabilities.mjs

@@ -0,0 +1,202 @@
+import { t as __exportAll } from "./chunk-rolldown-runtime.mjs";
+import { S as makeSingleton, b as make, g as getOption, p as get } from "./chunk-capability.mjs";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+//#region src/common/capabilities.ts
+var capabilities_exports = /* @__PURE__ */ __exportAll({
+	AtomRegistry: () => AtomRegistry,
+	Command: () => Command,
+	HistoryTracker: () => HistoryTracker,
+	Layer: () => Layer,
+	LayerSpec: () => LayerSpec,
+	ManagedRuntime: () => ManagedRuntime,
+	OperationHandler: () => OperationHandler,
+	OperationHandlers: () => OperationHandlers,
+	OperationInvoker: () => OperationInvoker,
+	PluginManager: () => PluginManager,
+	ProcessManager: () => ProcessManager,
+	ProcessManagerRuntime: () => ProcessManagerRuntime,
+	ReactContext: () => ReactContext,
+	ReactRoot: () => ReactRoot,
+	ReactSurface: () => ReactSurface,
+	RemoteTraceMonitor: () => RemoteTraceMonitor,
+	ServiceResolver: () => ServiceResolver,
+	TraceSink: () => TraceSink,
+	UndoMapping: () => UndoMapping,
+	UndoRegistry: () => UndoRegistry,
+	getAtomValue: () => getAtomValue,
+	getAtomValueOption: () => getAtomValueOption,
+	subscribeAtom: () => subscribeAtom,
+	updateAtomValue: () => updateAtomValue
+});
+/**
+* @category Capability
+*/
+var PluginManager = makeSingleton()("org.dxos.app-framework.capability.pluginManager");
+/**
+* @category Capability
+*/
+var AtomRegistry = makeSingleton()("org.dxos.app-framework.capability.atomRegistry");
+/**
+* @category Capability
+*/
+var ReactContext = make()("org.dxos.app-framework.capability.reactContext");
+/**
+* @category Capability
+*/
+var ReactRoot = make()("org.dxos.app-framework.capability.reactRoot");
+/**
+* @category Capability
+*/
+var ReactSurface = make()("org.dxos.app-framework.capability.reactSurface");
+/**
+* @category Capability
+*/
+var Command = make()("org.dxos.app-framework.capability.command");
+/**
+* @category Capability
+*/
+var Layer = make()("org.dxos.app-framework.capability.layer");
+/**
+* Layer specification contributed by plugins.
+*
+* Plugins contribute {@link LayerSpec.LayerSpec} entries that are collected by the
+* process-manager module and composed into a {@link LayerStack} which backs the
+* {@link ProcessManagerRuntime}'s service resolver.
+*
+* @category Capability
+*/
+var LayerSpec = make()("org.dxos.app-framework.capability.layerSpec");
+/**
+* Trace sink contribution.
+*
+* Plugins contribute {@link TraceSinkFactory} functions; the process-manager
+* capability invokes each factory with the runtime's
+* {@link ServiceResolver$.ServiceResolver}, collects the resulting
+* {@link Trace$.Sink}s, merges them via {@link Trace$.mergeSinks}, and
+* installs the merged sink as {@link Trace$.TraceSink} in the runtime layer
+* so every process writes to every contributed sink.
+*
+* @category Capability
+*/
+var TraceSink = make()("org.dxos.app-framework.capability.traceSink");
+/**
+* Source of ephemeral trace messages broadcast by remote runtimes over the space swarm (DX-1125).
+* Contributed by a client-aware plugin; the process-manager capability wires the first contribution
+* (or a no-op) into the aggregate {@link ProcessManager} so its `subscribeToTraceMessages` surfaces
+* remote progress alongside local.
+*
+* @category Capability
+*/
+var RemoteTraceMonitor = make()("org.dxos.app-framework.capability.remoteTraceMonitor");
+/**
+* Service resolver backing the shared {@link ProcessManagerRuntime}.
+*
+* Contributed by the process-manager capability module. Consumers can combine
+* it with {@link ServiceResolver$.provide} to build space-scoped layers without
+* having to go through the process-manager runtime:
+*
+* @example
+* ```ts
+* const resolver = yield* Capability.get(Capabilities.ServiceResolver);
+* yield* effect.pipe(
+*   Effect.provide(
+*     ServiceResolver.provide({ space }, Database.Service).pipe(
+*       Layer.provide(Layer.succeed(ServiceResolver.ServiceResolver, resolver)),
+*     ),
+*   ),
+* );
+* ```
+*
+* @category Capability
+*/
+var ServiceResolver = makeSingleton()("org.dxos.app-framework.capability.serviceResolver");
+/**
+* Process manager backing the shared {@link ProcessManagerRuntime}. Exposes the
+* live process tree (including inactive/terminated entries) via
+* {@link Process.Manager#processTreeAtom}.
+*
+* @category Capability
+*/
+var ProcessManager = makeSingleton()("org.dxos.app-framework.capability.processManager");
+/**
+* @category Capability
+*/
+var ProcessManagerRuntime = makeSingleton()("org.dxos.app-framework.capability.processManagerRuntime");
+/**
+* @category Capability
+*/
+var ManagedRuntime = makeSingleton()("org.dxos.app-framework.capability.managedRuntime");
+var OperationHandler = make()("org.dxos.app-framework.capability.operationHandler");
+/**
+* Merged, contribution-ordered view over all {@link OperationHandler} contributions — the same
+* set the operation invoker resolves against. Provided by ProcessManagerPlugin.
+* @category Capability
+*/
+var OperationHandlers = makeSingleton()("org.dxos.app-framework.capability.operationHandlers");
+/**
+* Undo mapping registration - contributed by plugins.
+* @category Capability
+*/
+var UndoMapping = make()("org.dxos.app-framework.capability.undoMapping");
+/**
+* Operation invoker - provided by the process-manager capability.
+* @category Capability
+*/
+var OperationInvoker = makeSingleton()("org.dxos.app-framework.capability.operationInvoker");
+/**
+* Undo registry - provided by ProcessManagerPlugin.
+* @category Capability
+*/
+var UndoRegistry = makeSingleton()("org.dxos.app-framework.capability.undoRegistry");
+/**
+* History tracker - provided by ProcessManagerPlugin.
+* @category Capability
+*/
+var HistoryTracker = makeSingleton()("org.dxos.app-framework.capability.historyTracker");
+/**
+* Get the current value of an atom capability.
+* @example const settings = yield* Capabilities.getAtomValue(CommentCapabilities.Settings);
+*/
+var getAtomValue = (atomCapability) => Effect.gen(function* () {
+	const registry = yield* get(AtomRegistry);
+	const atom = yield* get(atomCapability);
+	return registry.get(atom);
+});
+/**
+* Get the current value of an atom capability, or `Option.none()` when either the registry or the
+* atom itself is uncontributed.
+*
+* For operations that run on both the app and a headless host (the edge operation-service, `dx mcp
+* serve`): those hosts have a capability manager but activate no UI plugins, so {@link getAtomValue}
+* fails on capabilities like `Layout` that only the app contributes.
+*
+* @example const layout = yield* Capabilities.getAtomValueOption(AppCapabilities.Layout);
+*/
+var getAtomValueOption = (atomCapability) => Effect.gen(function* () {
+	const registry = yield* getOption(AtomRegistry);
+	const atom = yield* getOption(atomCapability);
+	return Option.map(Option.all([registry, atom]), ([registry, atom]) => registry.get(atom));
+});
+/**
+* Update an atom capability value (requires writable atom).
+* @example yield* Capabilities.updateAtomValue(CommentCapabilities.Settings, (s) => ({ ...s, foo: true }));
+*/
+var updateAtomValue = (atomCapability, fn) => Effect.gen(function* () {
+	const registry = yield* get(AtomRegistry);
+	const atom = yield* get(atomCapability);
+	registry.set(atom, fn(registry.get(atom)));
+});
+/**
+* Subscribe to an atom capability.
+* @example const unsubscribe = yield* Capabilities.subscribeAtom(CommentCapabilities.Settings, (value) => ...);
+*/
+var subscribeAtom = (atomCapability, callback) => Effect.gen(function* () {
+	const registry = yield* get(AtomRegistry);
+	const atom = yield* get(atomCapability);
+	return registry.subscribe(atom, () => callback(registry.get(atom)));
+});
+//#endregion
+export { getAtomValueOption as C, getAtomValue as S, updateAtomValue as T, ServiceResolver as _, LayerSpec as a, UndoRegistry as b, OperationHandlers as c, ProcessManager as d, ProcessManagerRuntime as f, RemoteTraceMonitor as g, ReactSurface as h, Layer as i, OperationInvoker as l, ReactRoot as m, Command as n, ManagedRuntime as o, ReactContext as p, HistoryTracker as r, OperationHandler as s, AtomRegistry as t, PluginManager as u, TraceSink as v, subscribeAtom as w, capabilities_exports as x, UndoMapping as y };
+
+//# sourceMappingURL=chunk-capabilities.mjs.map

package/dist/lib/chunk-capabilities.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk-capabilities.mjs","names":["Capability$.makeSingleton","Capability$.make","Capability$.get","Capability$.getOption"],"sources":["../../src/common/capabilities.ts"],"sourcesContent":["//\n// Copyright 2025 DXOS.org\n//\n\nimport type * as Command$ from 'effect/cli/Command';\nimport * as Effect from 'effect/Effect';\nimport type * as Exit$ from 'effect/Exit';\nimport type * as Fiber$ from 'effect/Fiber';\nimport type * as Layer$ from 'effect/Layer';\nimport type * as ManagedRuntime$ from 'effect/ManagedRuntime';\nimport * as Option from 'effect/Option';\nimport type * as Atom from 'effect/reactivity/Atom';\nimport type * as Registry from 'effect/reactivity/AtomRegistry';\nimport type { FC, PropsWithChildren } from 'react';\n\nimport type {\n  ProcessManager as ProcessManager$,\n  RemoteTraceMonitor as RemoteTraceMonitor$,\n} from '@dxos/compute-runtime';\nimport * as ComputeLayerSpec from '@dxos/compute/LayerSpec';\nimport * as Operation from '@dxos/compute/Operation';\nimport * as OperationHandlerSet from '@dxos/compute/OperationHandlerSet';\nimport * as Process from '@dxos/compute/Process';\nimport * as ComputeServiceResolver from '@dxos/compute/ServiceResolver';\nimport * as Trace from '@dxos/compute/Trace';\nimport { OperationInvoker as OperationInvoker$ } from '@dxos/operation';\n\nimport { Capability as Capability$, Plugin as Plugin$, type PluginManager as PluginManager$ } from '../core/index.ts';\nimport type {\n  HistoryTracker as HistoryTracker$,\n  UndoMapping as UndoMapping$,\n  UndoRegistry as UndoRegistry$,\n} from '../plugin-process-manager/index.ts';\nimport type { Surface } from '../ui/index.ts';\n\n/**\n * @category Capability\n */\nexport const PluginManager = Capability$.makeSingleton<PluginManager$.PluginManager>()(\n  'org.dxos.app-framework.capability.pluginManager',\n);\n\n/**\n * @category Capability\n */\nexport const AtomRegistry = Capability$.makeSingleton<Registry.AtomRegistry>()(\n  'org.dxos.app-framework.capability.atomRegistry',\n);\n\nexport type ReactContext = Readonly<{\n  id: string;\n  dependsOn?: string[];\n  context: FC<PropsWithChildren>;\n}>;\n\n/**\n * @category Capability\n */\nexport const ReactContext = Capability$.make<ReactContext>()('org.dxos.app-framework.capability.reactContext');\n\nexport type ReactRoot = Readonly<{ id: string; root: FC<PropsWithChildren> }>;\n\n/**\n * @category Capability\n */\nexport const ReactRoot = Capability$.make<ReactRoot>()('org.dxos.app-framework.capability.reactRoot');\n\n/**\n * Surface definitions that can be either React components or Web Components.\n */\nexport type ReactSurface = Surface.Definition | readonly Surface.Definition[];\n\n/**\n * @category Capability\n */\nexport const ReactSurface = Capability$.make<ReactSurface>()('org.dxos.app-framework.capability.reactSurface');\n\n// The requirement channel stays open: a command's services are supplied partly by the contributing\n// plugin and partly by the host — `CommandConfig` carries the host's global flags and is provided as\n// an ambient layer by the host binary — so no single side can discharge them all. `CommandServices`\n// in @dxos/cli-util names what a host owes; hosts should type their layer with it.\nexport type AnyCommand = Command$.Command<any, any, any, any, any>;\n\n/**\n * @category Capability\n */\nexport const Command = Capability$.make<AnyCommand>()('org.dxos.app-framework.capability.command');\n\n/**\n * @category Capability\n */\n// The input channel is closed: a contributed layer is merged into whatever a host is assembling, so\n// it has to carry its own requirements rather than expect the host to satisfy them.\nexport const Layer = Capability$.make<Layer$.Layer<any, any, never>>()('org.dxos.app-framework.capability.layer');\n\n/**\n * Layer specification contributed by plugins.\n *\n * Plugins contribute {@link LayerSpec.LayerSpec} entries that are collected by the\n * process-manager module and composed into a {@link LayerStack} which backs the\n * {@link ProcessManagerRuntime}'s service resolver.\n *\n * @category Capability\n */\nexport const LayerSpec = Capability$.make<ComputeLayerSpec.LayerSpec>()('org.dxos.app-framework.capability.layerSpec');\n\n/**\n * Context passed to {@link TraceSinkFactory} implementations when the\n * process-manager capability materialises contributed sinks.\n */\nexport interface TraceSinkFactoryContext {\n  /**\n   * Service resolver backing the shared {@link ProcessManagerRuntime}. Use it\n   * to resolve per-space (or per-process) services like `FeedTraceSink` when\n   * building a routing sink.\n   */\n  readonly resolver: ComputeServiceResolver.ServiceResolver;\n}\n\n/**\n * Factory that builds a {@link Trace$.Sink} when the process-manager\n * capability is ready. Plugins that only need a static sink can ignore the\n * context (e.g. `() => myConsoleSink`); plugins that need per-space routing\n * can use {@link TraceSinkFactoryContext.resolver} to look up services.\n */\nexport type TraceSinkFactory = (ctx: TraceSinkFactoryContext) => Trace.Sink;\n\n/**\n * Trace sink contribution.\n *\n * Plugins contribute {@link TraceSinkFactory} functions; the process-manager\n * capability invokes each factory with the runtime's\n * {@link ServiceResolver$.ServiceResolver}, collects the resulting\n * {@link Trace$.Sink}s, merges them via {@link Trace$.mergeSinks}, and\n * installs the merged sink as {@link Trace$.TraceSink} in the runtime layer\n * so every process writes to every contributed sink.\n *\n * @category Capability\n */\nexport const TraceSink = Capability$.make<TraceSinkFactory>()('org.dxos.app-framework.capability.traceSink');\n\n/**\n * Source of ephemeral trace messages broadcast by remote runtimes over the space swarm (DX-1125).\n * Contributed by a client-aware plugin; the process-manager capability wires the first contribution\n * (or a no-op) into the aggregate {@link ProcessManager} so its `subscribeToTraceMessages` surfaces\n * remote progress alongside local.\n *\n * @category Capability\n */\nexport const RemoteTraceMonitor = Capability$.make<RemoteTraceMonitor$.Monitor>()(\n  'org.dxos.app-framework.capability.remoteTraceMonitor',\n);\n\n/**\n * Service resolver backing the shared {@link ProcessManagerRuntime}.\n *\n * Contributed by the process-manager capability module. Consumers can combine\n * it with {@link ServiceResolver$.provide} to build space-scoped layers without\n * having to go through the process-manager runtime:\n *\n * @example\n * ```ts\n * const resolver = yield* Capability.get(Capabilities.ServiceResolver);\n * yield* effect.pipe(\n *   Effect.provide(\n *     ServiceResolver.provide({ space }, Database.Service).pipe(\n *       Layer.provide(Layer.succeed(ServiceResolver.ServiceResolver, resolver)),\n *     ),\n *   ),\n * );\n * ```\n *\n * @category Capability\n */\nexport const ServiceResolver = Capability$.makeSingleton<ComputeServiceResolver.ServiceResolver>()(\n  'org.dxos.app-framework.capability.serviceResolver',\n);\n\n/**\n * Process manager backing the shared {@link ProcessManagerRuntime}. Exposes the\n * live process tree (including inactive/terminated entries) via\n * {@link Process.Manager#processTreeAtom}.\n *\n * @category Capability\n */\nexport const ProcessManager = Capability$.makeSingleton<Process.Manager>()(\n  'org.dxos.app-framework.capability.processManager',\n);\n\n/**\n * Services that are always available when running effects through a {@link ProcessManagerRuntime}.\n */\nexport type ProcessManagerRuntimeServices =\n  | Capability$.Service\n  | Plugin$.Service\n  | ProcessManager$.ProcessManagerService\n  | Operation.Service\n  | ComputeServiceResolver.ServiceResolver;\n\n/**\n * Runtime that runs effects requiring a fixed set of capability-manager and\n * process-manager services.\n *\n * The shape mirrors {@link ManagedRuntime$.ManagedRuntime} but deliberately does\n * not expose `dispose` – lifecycle is driven by the host plugin manager.\n */\nexport interface ProcessManagerRuntime {\n  runPromise<A, E>(\n    effect: Effect.Effect<A, E, ProcessManagerRuntimeServices>,\n    options?: { readonly signal?: AbortSignal },\n  ): Promise<A>;\n  runPromiseExit<A, E>(\n    effect: Effect.Effect<A, E, ProcessManagerRuntimeServices>,\n    options?: { readonly signal?: AbortSignal },\n  ): Promise<Exit$.Exit<A, E>>;\n  runFork<A, E>(\n    effect: Effect.Effect<A, E, ProcessManagerRuntimeServices>,\n    options?: Effect.RunOptions,\n  ): Fiber$.Fiber<A, E>;\n  runSync<A, E>(effect: Effect.Effect<A, E, ProcessManagerRuntimeServices>): A;\n}\n\n/**\n * @category Capability\n */\nexport const ProcessManagerRuntime = Capability$.makeSingleton<ProcessManagerRuntime>()(\n  'org.dxos.app-framework.capability.processManagerRuntime',\n);\n\nexport type ManagedRuntime = ManagedRuntime$.ManagedRuntime<any, any>;\n\n/**\n * @category Capability\n */\nexport const ManagedRuntime = Capability$.makeSingleton<ManagedRuntime>()(\n  'org.dxos.app-framework.capability.managedRuntime',\n);\n\n//\n// Operation System Capabilities\n//\n\nexport const OperationHandler = Capability$.make<OperationHandlerSet.OperationHandlerSet>()(\n  'org.dxos.app-framework.capability.operationHandler',\n);\n\n/**\n * Merged, contribution-ordered view over all {@link OperationHandler} contributions — the same\n * set the operation invoker resolves against. Provided by ProcessManagerPlugin.\n * @category Capability\n */\nexport const OperationHandlers = Capability$.makeSingleton<OperationHandlerSet.OperationHandlerSet>()(\n  'org.dxos.app-framework.capability.operationHandlers',\n);\n\nexport type UndoMapping = UndoMapping$.UndoMapping;\n\n/**\n * Undo mapping registration - contributed by plugins.\n * @category Capability\n */\nexport const UndoMapping = Capability$.make<UndoMapping[]>()('org.dxos.app-framework.capability.undoMapping');\n\n/**\n * Operation invoker backed by the process manager. Spawns a process per\n * operation invocation; see `ProcessOperationInvoker` in `@dxos/compute-runtime`.\n */\nexport type OperationInvoker = OperationInvoker$.OperationInvoker;\n\n/**\n * Operation invoker - provided by the process-manager capability.\n * @category Capability\n */\nexport const OperationInvoker = Capability$.makeSingleton<OperationInvoker>()(\n  'org.dxos.app-framework.capability.operationInvoker',\n);\n\nexport type UndoRegistry = UndoRegistry$.UndoRegistry;\n\n/**\n * Undo registry - provided by ProcessManagerPlugin.\n * @category Capability\n */\nexport const UndoRegistry = Capability$.makeSingleton<UndoRegistry>()('org.dxos.app-framework.capability.undoRegistry');\n\nexport type HistoryTracker = HistoryTracker$.HistoryTracker;\n\n/**\n * History tracker - provided by ProcessManagerPlugin.\n * @category Capability\n */\nexport const HistoryTracker = Capability$.makeSingleton<HistoryTracker>()(\n  'org.dxos.app-framework.capability.historyTracker',\n);\n\n//\n// Atom Capability Helpers\n//\n\n/**\n * Get the current value of an atom capability.\n * @example const settings = yield* Capabilities.getAtomValue(CommentCapabilities.Settings);\n */\nexport const getAtomValue = <T>(\n  atomCapability: Capability$.InterfaceDef<Atom.Atom<T>>,\n): Effect.Effect<T, Error, Capability$.Service> =>\n  Effect.gen(function* () {\n    const registry = yield* Capability$.get(AtomRegistry);\n    const atom = yield* Capability$.get(atomCapability);\n    return registry.get(atom);\n  });\n\n/**\n * Get the current value of an atom capability, or `Option.none()` when either the registry or the\n * atom itself is uncontributed.\n *\n * For operations that run on both the app and a headless host (the edge operation-service, `dx mcp\n * serve`): those hosts have a capability manager but activate no UI plugins, so {@link getAtomValue}\n * fails on capabilities like `Layout` that only the app contributes.\n *\n * @example const layout = yield* Capabilities.getAtomValueOption(AppCapabilities.Layout);\n */\nexport const getAtomValueOption = <T>(\n  atomCapability: Capability$.InterfaceDef<Atom.Atom<T>>,\n): Effect.Effect<Option.Option<T>, never, Capability$.Service> =>\n  Effect.gen(function* () {\n    const registry = yield* Capability$.getOption(AtomRegistry);\n    const atom = yield* Capability$.getOption(atomCapability);\n    return Option.map(Option.all([registry, atom]), ([registry, atom]) => registry.get(atom));\n  });\n\n/**\n * Update an atom capability value (requires writable atom).\n * @example yield* Capabilities.updateAtomValue(CommentCapabilities.Settings, (s) => ({ ...s, foo: true }));\n */\nexport const updateAtomValue = <T>(\n  atomCapability: Capability$.InterfaceDef<Atom.Writable<T>>,\n  fn: (current: T) => T,\n): Effect.Effect<void, Error, Capability$.Service> =>\n  Effect.gen(function* () {\n    const registry = yield* Capability$.get(AtomRegistry);\n    const atom = yield* Capability$.get(atomCapability);\n    registry.set(atom, fn(registry.get(atom)));\n  });\n\n/**\n * Subscribe to an atom capability.\n * @example const unsubscribe = yield* Capabilities.subscribeAtom(CommentCapabilities.Settings, (value) => ...);\n */\nexport const subscribeAtom = <T>(\n  atomCapability: Capability$.InterfaceDef<Atom.Atom<T>>,\n  callback: (value: T) => void,\n): Effect.Effect<() => void, Error, Capability$.Service> =>\n  Effect.gen(function* () {\n    const registry = yield* Capability$.get(AtomRegistry);\n    const atom = yield* Capability$.get(atomCapability);\n    return registry.subscribe(atom, () => callback(registry.get(atom)));\n  });\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCA,IAAa,gBAAgBA,cAAwD,CAAC,CACpF,iDACF;;;;AAKA,IAAa,eAAeA,cAAiD,CAAC,CAC5E,gDACF;;;;AAWA,IAAa,eAAeC,KAA+B,CAAC,CAAC,gDAAgD;;;;AAO7G,IAAa,YAAYA,KAA4B,CAAC,CAAC,6CAA6C;;;;AAUpG,IAAa,eAAeA,KAA+B,CAAC,CAAC,gDAAgD;;;;AAW7G,IAAa,UAAUA,KAA6B,CAAC,CAAC,2CAA2C;;;;AAOjG,IAAa,QAAQA,KAAgD,CAAC,CAAC,yCAAyC;;;;;;;;;;AAWhH,IAAa,YAAYA,KAA6C,CAAC,CAAC,6CAA6C;;;;;;;;;;;;;AAmCrH,IAAa,YAAYA,KAAmC,CAAC,CAAC,6CAA6C;;;;;;;;;AAU3G,IAAa,qBAAqBA,KAA8C,CAAC,CAC/E,sDACF;;;;;;;;;;;;;;;;;;;;;;AAuBA,IAAa,kBAAkBD,cAAkE,CAAC,CAChG,mDACF;;;;;;;;AASA,IAAa,iBAAiBA,cAA2C,CAAC,CACxE,kDACF;;;;AAsCA,IAAa,wBAAwBA,cAAiD,CAAC,CACrF,yDACF;;;;AAOA,IAAa,iBAAiBA,cAA0C,CAAC,CACvE,kDACF;AAMA,IAAa,mBAAmBC,KAA0D,CAAC,CACzF,oDACF;;;;;;AAOA,IAAa,oBAAoBD,cAAmE,CAAC,CACnG,qDACF;;;;;AAQA,IAAa,cAAcC,KAAgC,CAAC,CAAC,+CAA+C;;;;;AAY5G,IAAa,mBAAmBD,cAA4C,CAAC,CAC3E,oDACF;;;;;AAQA,IAAa,eAAeA,cAAwC,CAAC,CAAC,gDAAgD;;;;;AAQtH,IAAa,iBAAiBA,cAA0C,CAAC,CACvE,kDACF;;;;;AAUA,IAAa,gBACX,mBAEA,OAAO,IAAI,aAAa;CACtB,MAAM,WAAW,OAAOE,IAAgB,YAAY;CACpD,MAAM,OAAO,OAAOA,IAAgB,cAAc;CAClD,OAAO,SAAS,IAAI,IAAI;AAC1B,CAAC;;;;;;;;;;;AAYH,IAAa,sBACX,mBAEA,OAAO,IAAI,aAAa;CACtB,MAAM,WAAW,OAAOC,UAAsB,YAAY;CAC1D,MAAM,OAAO,OAAOA,UAAsB,cAAc;CACxD,OAAO,OAAO,IAAI,OAAO,IAAI,CAAC,UAAU,IAAI,CAAC,IAAI,CAAC,UAAU,UAAU,SAAS,IAAI,IAAI,CAAC;AAC1F,CAAC;;;;;AAMH,IAAa,mBACX,gBACA,OAEA,OAAO,IAAI,aAAa;CACtB,MAAM,WAAW,OAAOD,IAAgB,YAAY;CACpD,MAAM,OAAO,OAAOA,IAAgB,cAAc;CAClD,SAAS,IAAI,MAAM,GAAG,SAAS,IAAI,IAAI,CAAC,CAAC;AAC3C,CAAC;;;;;AAMH,IAAa,iBACX,gBACA,aAEA,OAAO,IAAI,aAAa;CACtB,MAAM,WAAW,OAAOA,IAAgB,YAAY;CACpD,MAAM,OAAO,OAAOA,IAAgB,cAAc;CAClD,OAAO,SAAS,UAAU,YAAY,SAAS,SAAS,IAAI,IAAI,CAAC,CAAC;AACpE,CAAC"}

package/dist/lib/chunk-capability-manager.mjs

@@ -0,0 +1,203 @@
+import { t as __exportAll } from "./chunk-rolldown-runtime.mjs";
+import { T as CapabilityNotFoundError, n as ContributionTypeId } from "./chunk-capability.mjs";
+import * as Effect from "effect/Effect";
+import * as EffectEx from "@dxos/effect/EffectEx";
+import { log } from "@dxos/log";
+import * as Deferred from "effect/Deferred";
+import * as Atom from "effect/reactivity/Atom";
+//#region src/core/capability-manager.ts
+var capability_manager_exports = /* @__PURE__ */ __exportAll({
+	expandContributions: () => expandContributions,
+	isContribution: () => isContribution,
+	make: () => make,
+	normalizeActivateResult: () => normalizeActivateResult
+});
+var __dxlog_file = "/__w/dxos/dxos/packages/sdk/app-framework/src/core/capability-manager.ts";
+/**
+* Type guard to check if a value is a {@link Capability.Contribution}.
+*/
+var isContribution = (value) => {
+	return typeof value === "object" && value !== null && ContributionTypeId in value;
+};
+/**
+* Normalizes a module activate result into a flat list of items (legacy capabilities and
+* typed contributions).
+*/
+var normalizeActivateResult = (result) => {
+	if (result == null) return [];
+	return Array.isArray(result) ? [...result] : [result];
+};
+/**
+* Expands typed contributions into per-value capability entries; legacy capability entries
+* pass through.
+*/
+var expandContributions = (items) => items.flatMap((item) => isContribution(item) ? item.values.map((value) => ({
+	interface: item.capability,
+	implementation: value
+})) : [item]);
+/**
+* Internal implementation of CapabilityManager.
+*/
+var CapabilityManagerImpl = class {
+	_registry;
+	_registeredIdentifiers = /* @__PURE__ */ new Set();
+	_contributionsViews = /* @__PURE__ */ new Map();
+	/** In-flight {@link waitForPromise} results, keyed by interface identifier. */
+	_waitPromises = /* @__PURE__ */ new Map();
+	_capabilityEntries = Atom.family(() => {
+		return Atom.make([]).pipe(Atom.keepAlive);
+	});
+	_capabilities = Atom.family((id) => {
+		return Atom.make((get) => {
+			return get(this._capabilityEntries(id)).map((c) => c.implementation);
+		}).pipe(Atom.keepAlive);
+	});
+	_capabilitiesByModule = Atom.family((id) => {
+		return Atom.make((get) => {
+			const entries = get(this._capabilityEntries(id));
+			const result = {};
+			for (const entry of entries) (result[entry.moduleId] ??= []).push(entry.implementation);
+			return result;
+		}).pipe(Atom.keepAlive);
+	});
+	_capability = Atom.family((id) => {
+		return Atom.make((get) => {
+			const current = get(this._capabilities(id));
+			if (current.length === 0) throw new CapabilityNotFoundError({
+				identifier: id,
+				registered: this.listRegisteredIdentifiers()
+			});
+			return current[0];
+		});
+	});
+	constructor({ registry }) {
+		this._registry = registry;
+	}
+	contribute({ module: moduleId, interface: interfaceDef, implementation }) {
+		const current = this._registry.get(this._capabilityEntries(interfaceDef.identifier));
+		if (current.some((c) => c.moduleId === moduleId && c.implementation === implementation)) {
+			log("capability already contributed, skipping", {
+				id: interfaceDef.identifier,
+				moduleId
+			}, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 195,
+				S: this
+			});
+			return;
+		}
+		const entry = {
+			moduleId,
+			implementation
+		};
+		this._registry.set(this._capabilityEntries(interfaceDef.identifier), [...current, entry]);
+		this._registeredIdentifiers.add(interfaceDef.identifier);
+		log("capability contributed", {
+			id: interfaceDef.identifier,
+			moduleId,
+			count: current.length
+		}, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file,
+			L: 202,
+			S: this
+		});
+	}
+	remove(interfaceDef, implementation) {
+		const current = this._registry.get(this._capabilityEntries(interfaceDef.identifier));
+		if (current.length === 0) return;
+		const next = current.filter((c) => c.implementation !== implementation);
+		if (next.length !== current.length) {
+			this._registry.set(this._capabilityEntries(interfaceDef.identifier), next);
+			if (next.length === 0) this._registeredIdentifiers.delete(interfaceDef.identifier);
+			log("capability removed", {
+				id: interfaceDef.identifier,
+				count: current.length
+			}, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 221,
+				S: this
+			});
+		} else log.warn("capability not removed", { id: interfaceDef.identifier }, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file,
+			L: 223,
+			S: this
+		});
+	}
+	atom(interfaceDef) {
+		return this._capabilities(interfaceDef.identifier);
+	}
+	getAll(interfaceDef) {
+		return this._registry.get(this.atom(interfaceDef));
+	}
+	get(interfaceDef) {
+		const capabilities = this.getAll(interfaceDef);
+		if (capabilities.length === 0) {
+			log("capability not available", {
+				requested: interfaceDef.identifier,
+				registered: this.listRegisteredIdentifiers()
+			}, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 239,
+				S: this
+			});
+			throw new CapabilityNotFoundError({
+				identifier: interfaceDef.identifier,
+				registered: this.listRegisteredIdentifiers()
+			});
+		}
+		return capabilities[0];
+	}
+	listRegisteredIdentifiers() {
+		return [...this._registeredIdentifiers].sort();
+	}
+	waitFor(interfaceDef) {
+		return Effect.gen({ self: this }, function* () {
+			const [capability] = this.getAll(interfaceDef);
+			if (capability) return capability;
+			const deferred = yield* Deferred.make();
+			const cancel = this._registry.subscribe(this.atom(interfaceDef), (capabilities) => {
+				if (capabilities.length > 0) Effect.runSync(Deferred.succeed(deferred, capabilities[0]));
+			});
+			const result = yield* Deferred.await(deferred);
+			cancel();
+			return result;
+		});
+	}
+	waitForPromise(interfaceDef) {
+		const existing = this._waitPromises.get(interfaceDef.identifier);
+		if (existing) return existing;
+		const promise = EffectEx.runPromise(this.waitFor(interfaceDef)).finally(() => {
+			this._waitPromises.delete(interfaceDef.identifier);
+		});
+		this._waitPromises.set(interfaceDef.identifier, promise);
+		return promise;
+	}
+	atomByModule(interfaceDef) {
+		return this._capabilitiesByModule(interfaceDef.identifier);
+	}
+	contributions(interfaceDef) {
+		const existing = this._contributionsViews.get(interfaceDef.identifier);
+		if (existing) return existing;
+		const atom = this._capabilities(interfaceDef.identifier);
+		const view = {
+			atom,
+			get: () => this._registry.get(atom),
+			subscribe: (cb) => this._registry.subscribe(atom, cb)
+		};
+		this._contributionsViews.set(interfaceDef.identifier, view);
+		return view;
+	}
+};
+/**
+* Creates a new Capability Manager instance.
+*/
+var make = (options) => new CapabilityManagerImpl(options);
+//#endregion
+export { normalizeActivateResult as a, make as i, expandContributions as n, isContribution as r, capability_manager_exports as t };
+
+//# sourceMappingURL=chunk-capability-manager.mjs.map

package/dist/lib/chunk-capability-manager.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk-capability-manager.mjs","names":[],"sources":["../../src/core/capability-manager.ts"],"sourcesContent":["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Deferred from 'effect/Deferred';\nimport * as Effect from 'effect/Effect';\nimport * as Atom from 'effect/reactivity/Atom';\nimport type * as Registry from 'effect/reactivity/AtomRegistry';\n\nimport * as EffectEx from '@dxos/effect/EffectEx';\nimport { log } from '@dxos/log';\n\nimport type * as Capability from './capability.ts';\nimport { ContributionTypeId } from './capability.ts';\nimport { CapabilityNotFoundError } from './errors.ts';\n\ntype CapabilityEntry<T> = {\n  moduleId: string;\n  implementation: T;\n};\n\n//\n// Contribution ingestion — manager-side machinery for a module's activate result. Lives here\n// rather than in `capability` so the authoring namespace exposes only the plugin-author API.\n//\n\n/**\n * Type guard to check if a value is a {@link Capability.Contribution}.\n */\nexport const isContribution = (value: unknown): value is Capability.AnyContribution => {\n  return typeof value === 'object' && value !== null && ContributionTypeId in value;\n};\n\n/**\n * Normalizes a module activate result into a flat list of items (legacy capabilities and\n * typed contributions).\n */\nexport const normalizeActivateResult = (\n  result: Capability.ModuleReturn | Capability.AnyContribution | readonly Capability.AnyContribution[],\n): Array<Capability.Any | Capability.AnyContribution> => {\n  if (result == null) {\n    return [];\n  }\n  // Cast: Array.isArray does not narrow the ReadonlyArray members of ModuleReturn.\n  return (Array.isArray(result) ? [...result] : [result]) as Array<Capability.Any | Capability.AnyContribution>;\n};\n\n/**\n * Expands typed contributions into per-value capability entries; legacy capability entries\n * pass through.\n */\nexport const expandContributions = (\n  items: ReadonlyArray<Capability.Any | Capability.AnyContribution>,\n): Capability.Any[] =>\n  items.flatMap((item) =>\n    isContribution(item)\n      ? item.values.map((value): Capability.Any => ({\n          interface: item.capability,\n          implementation: value,\n        }))\n      : [item],\n  );\n\n/**\n * Options for creating a capability manager.\n * @internal\n */\nexport type CapabilityManagerOptions = {\n  registry: Registry.AtomRegistry;\n};\n\n/**\n * Interface for the Capability Manager.\n * Provides methods for contributing, removing, and accessing capabilities.\n */\nexport interface CapabilityManager {\n  contribute<T>(args: { module: string; interface: Capability.InterfaceDef<T>; implementation: T }): void;\n\n  remove<T>(interfaceDef: Capability.InterfaceDef<T>, implementation: T): void;\n\n  /**\n   * Get the Atom reference to the available capabilities for a given interface.\n   * Primarily useful for deriving other Atom values based on the capabilities or\n   * for subscribing to changes in the capabilities.\n   * @returns An atom reference to the available capabilities.\n   */\n  atom<T>(interfaceDef: Capability.InterfaceDef<T>): Atom.Atom<T[]>;\n\n  /**\n   * Get capabilities from the capability manager.\n   * @returns An array of capabilities.\n   */\n  getAll<T>(interfaceDef: Capability.InterfaceDef<T>): T[];\n\n  /**\n   * Requests a single capability from the capability manager.\n   * @returns The capability.\n   * @throws If no capability is found.\n   */\n  get<T>(interfaceDef: Capability.InterfaceDef<T>): T;\n\n  /**\n   * Waits for a capability to be available.\n   * @returns The capability.\n   */\n  waitFor<T>(interfaceDef: Capability.InterfaceDef<T>): Effect.Effect<T>;\n\n  /**\n   * Promise form of {@link waitFor}, memoized per interface so repeated calls return the SAME\n   * reference — React dedupes suspended renders by thrown-promise identity, so a fresh promise per\n   * render would re-suspend forever.\n   * @returns A promise settling once at least one capability is contributed.\n   */\n  waitForPromise<T>(interfaceDef: Capability.InterfaceDef<T>): Promise<T>;\n\n  /**\n   * Get capabilities grouped by the module that contributed them.\n   * @returns An atom containing a record from module ID to capability implementations.\n   */\n  atomByModule<T>(interfaceDef: Capability.InterfaceDef<T>): Atom.Atom<Record<string, T[]>>;\n\n  /**\n   * Live view over all contributions for a capability interface.\n   * Stable per interface: repeated calls return the same object.\n   */\n  contributions<T>(interfaceDef: Capability.InterfaceDef<T>): Capability.Contributions<T>;\n\n  /**\n   * Lists capability interface identifiers that currently have at least one contribution.\n   */\n  listRegisteredIdentifiers(): string[];\n}\n\n/**\n * Internal implementation of CapabilityManager.\n */\nclass CapabilityManagerImpl implements CapabilityManager {\n  private readonly _registry: Registry.AtomRegistry;\n\n  private readonly _registeredIdentifiers = new Set<string>();\n\n  private readonly _contributionsViews = new Map<string, Capability.Contributions<unknown>>();\n\n  /** In-flight {@link waitForPromise} results, keyed by interface identifier. */\n  private readonly _waitPromises = new Map<string, Promise<unknown>>();\n\n  private readonly _capabilityEntries = Atom.family<string, Atom.Writable<CapabilityEntry<unknown>[]>>(() => {\n    return Atom.make<CapabilityEntry<unknown>[]>([]).pipe(Atom.keepAlive);\n  });\n\n  readonly _capabilities = Atom.family<string, Atom.Atom<unknown[]>>((id: string) => {\n    return Atom.make((get) => {\n      const current = get(this._capabilityEntries(id));\n      return current.map((c) => c.implementation);\n    }).pipe(Atom.keepAlive);\n  });\n\n  readonly _capabilitiesByModule = Atom.family<string, Atom.Atom<Record<string, unknown[]>>>((id: string) => {\n    return Atom.make((get) => {\n      const entries = get(this._capabilityEntries(id));\n      const result: Record<string, unknown[]> = {};\n      for (const entry of entries) {\n        (result[entry.moduleId] ??= []).push(entry.implementation);\n      }\n      return result;\n    }).pipe(Atom.keepAlive);\n  });\n\n  readonly _capability = Atom.family<string, Atom.Atom<unknown>>((id: string) => {\n    return Atom.make((get) => {\n      const current = get(this._capabilities(id));\n      if (current.length === 0) {\n        throw new CapabilityNotFoundError({ identifier: id, registered: this.listRegisteredIdentifiers() });\n      }\n      return current[0];\n    });\n  });\n\n  constructor({ registry }: CapabilityManagerOptions) {\n    this._registry = registry;\n  }\n\n  contribute<T>({\n    module: moduleId,\n    interface: interfaceDef,\n    implementation,\n  }: {\n    module: string;\n    interface: Capability.InterfaceDef<T>;\n    implementation: T;\n  }): void {\n    const current = this._registry.get(this._capabilityEntries(interfaceDef.identifier));\n    const isDuplicate = current.some((c) => c.moduleId === moduleId && c.implementation === implementation);\n    if (isDuplicate) {\n      log('capability already contributed, skipping', { id: interfaceDef.identifier, moduleId });\n      return;\n    }\n\n    const entry: CapabilityEntry<T> = { moduleId, implementation };\n    this._registry.set(this._capabilityEntries(interfaceDef.identifier), [...current, entry]);\n    this._registeredIdentifiers.add(interfaceDef.identifier);\n    log('capability contributed', {\n      id: interfaceDef.identifier,\n      moduleId,\n      count: current.length,\n    });\n  }\n\n  remove<T>(interfaceDef: Capability.InterfaceDef<T>, implementation: T): void {\n    const current = this._registry.get(this._capabilityEntries(interfaceDef.identifier));\n    if (current.length === 0) {\n      return;\n    }\n\n    const next = current.filter((c) => c.implementation !== implementation);\n    if (next.length !== current.length) {\n      this._registry.set(this._capabilityEntries(interfaceDef.identifier), next);\n      if (next.length === 0) {\n        this._registeredIdentifiers.delete(interfaceDef.identifier);\n      }\n      log('capability removed', { id: interfaceDef.identifier, count: current.length });\n    } else {\n      log.warn('capability not removed', { id: interfaceDef.identifier });\n    }\n  }\n\n  atom<T>(interfaceDef: Capability.InterfaceDef<T>): Atom.Atom<T[]> {\n    // NOTE: This the type-checking for capabilities is done at the time of contribution.\n    return this._capabilities(interfaceDef.identifier) as Atom.Atom<T[]>;\n  }\n\n  getAll<T>(interfaceDef: Capability.InterfaceDef<T>): T[] {\n    return this._registry.get(this.atom(interfaceDef));\n  }\n\n  get<T>(interfaceDef: Capability.InterfaceDef<T>): T {\n    const capabilities = this.getAll(interfaceDef);\n    if (capabilities.length === 0) {\n      log('capability not available', {\n        requested: interfaceDef.identifier,\n        registered: this.listRegisteredIdentifiers(),\n      });\n      throw new CapabilityNotFoundError({\n        identifier: interfaceDef.identifier,\n        registered: this.listRegisteredIdentifiers(),\n      });\n    }\n    return capabilities[0];\n  }\n\n  listRegisteredIdentifiers(): string[] {\n    return [...this._registeredIdentifiers].sort();\n  }\n\n  waitFor<T>(interfaceDef: Capability.InterfaceDef<T>): Effect.Effect<T> {\n    return Effect.gen({ self: this }, function* () {\n      const [capability] = this.getAll(interfaceDef);\n      if (capability) {\n        return capability;\n      }\n\n      const deferred = yield* Deferred.make<T>();\n      const cancel = this._registry.subscribe(this.atom(interfaceDef), (capabilities) => {\n        if (capabilities.length > 0) {\n          Effect.runSync(Deferred.succeed(deferred, capabilities[0]));\n        }\n      });\n      const result = yield* Deferred.await(deferred);\n      cancel();\n      return result;\n    });\n  }\n\n  waitForPromise<T>(interfaceDef: Capability.InterfaceDef<T>): Promise<T> {\n    const existing = this._waitPromises.get(interfaceDef.identifier);\n    if (existing) {\n      return existing as Promise<T>;\n    }\n    const promise = EffectEx.runPromise(this.waitFor(interfaceDef)).finally(() => {\n      // Drop it once settled so a capability that is removed and re-contributed can be waited on\n      // again; until then every suspended reader shares this one reference.\n      this._waitPromises.delete(interfaceDef.identifier);\n    });\n    this._waitPromises.set(interfaceDef.identifier, promise);\n    return promise;\n  }\n\n  atomByModule<T>(interfaceDef: Capability.InterfaceDef<T>): Atom.Atom<Record<string, T[]>> {\n    return this._capabilitiesByModule(interfaceDef.identifier) as Atom.Atom<Record<string, T[]>>;\n  }\n\n  contributions<T>(interfaceDef: Capability.InterfaceDef<T>): Capability.Contributions<T> {\n    const existing = this._contributionsViews.get(interfaceDef.identifier);\n    if (existing) {\n      // NOTE: The type-checking for capabilities is done at the time of contribution.\n      return existing as Capability.Contributions<T>;\n    }\n\n    const atom = this._capabilities(interfaceDef.identifier);\n    const view: Capability.Contributions<unknown> = {\n      atom,\n      get: () => this._registry.get(atom),\n      subscribe: (cb) => this._registry.subscribe(atom, cb),\n    };\n    this._contributionsViews.set(interfaceDef.identifier, view);\n    return view as Capability.Contributions<T>;\n  }\n}\n\n/**\n * Creates a new Capability Manager instance.\n */\nexport const make = (options: CapabilityManagerOptions): CapabilityManager => new CapabilityManagerImpl(options);\n"],"mappings":"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"}

package/dist/lib/chunk-capability2.mjs

@@ -1,6 +1,6 @@
 import { u as contribute, x as makeModule } from "./chunk-capability.mjs";
-import { HistoryTracker, OperationInvoker, UndoMapping, UndoRegistry } from "./common/capabilities.mjs";
-import { make } from "./plugin-process-manager/history/undo-registry.mjs";
+import { b as UndoRegistry, l as OperationInvoker, r as HistoryTracker, y as UndoMapping } from "./chunk-capabilities.mjs";
+import { t as make } from "./chunk-undo-registry.mjs";
 import { n as make$1 } from "./chunk-history-tracker.mjs";
 import * as Effect from "effect/Effect";
 //#region src/plugin-process-manager/history/capability.ts

package/dist/lib/chunk-capability2.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"chunk-capability2.mjs","names":[],"sources":["../../src/plugin-process-manager/history/capability.ts"],"sourcesContent":["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Effect from 'effect/Effect';\n\nimport { OperationInvoker } from '@dxos/operation';\n\nimport { Capabilities } from '../../common/index.ts';\nimport { Capability } from '../../core/index.ts';\nimport * as HistoryTracker from './history-tracker.ts';\nimport * as UndoRegistry from './undo-registry.ts';\n\n//\n// Capability Module - contributes both UndoRegistry and HistoryTracker.\n//\n\nexport default Capability.makeModule(\n  Effect.fnUntraced(function* () {\n    // Create UndoRegistry over the live mapping contributions (synchronous access in callbacks).\n    const undoMappings = yield* Capabilities.UndoMapping;\n    const undoRegistry = UndoRegistry.make(() => undoMappings.get().flat());\n\n    // Create HistoryTracker (depends on UndoRegistry and OperationInvoker).\n    const invoker = yield* Capabilities.OperationInvoker;\n    // Cast to internal type - the factory always returns OperationInvokerInternal.\n    const historyTracker = HistoryTracker.make(invoker as OperationInvoker.OperationInvokerInternal, undoRegistry);\n\n    return [\n      Capability.contribute(Capabilities.UndoRegistry, undoRegistry),\n      Capability.contribute(Capabilities.HistoryTracker, historyTracker),\n    ];\n  }),\n);\n"],"mappings":";;;;;;AAiBA,IAAA,qBAAe,WACb,OAAO,WAAW,aAAa;CAE7B,MAAM,eAAe,OAAO;CAC5B,MAAM,eAAe,WAAwB,aAAa,IAAI,CAAC,CAAC,KAAK,CAAC;CAGtE,MAAM,UAAU,OAAO;CAEvB,MAAM,iBAAiB,OAAoB,SAAsD,YAAY;CAE7G,OAAO,CACL,WAAsB,cAA2B,YAAY,GAC7D,WAAsB,gBAA6B,cAAc,CACnE;AACF,CAAC,CACH"}
+{"version":3,"file":"chunk-capability2.mjs","names":["Capability.makeModule","Capabilities.UndoMapping","UndoRegistry.make","Capabilities.OperationInvoker","HistoryTracker.make","Capability.contribute","Capabilities.UndoRegistry","Capabilities.HistoryTracker"],"sources":["../../src/plugin-process-manager/history/capability.ts"],"sourcesContent":["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Effect from 'effect/Effect';\n\nimport { OperationInvoker } from '@dxos/operation';\n\nimport { Capabilities } from '../../common/index.ts';\nimport { Capability } from '../../core/index.ts';\nimport * as HistoryTracker from './history-tracker.ts';\nimport * as UndoRegistry from './undo-registry.ts';\n\n//\n// Capability Module - contributes both UndoRegistry and HistoryTracker.\n//\n\nexport default Capability.makeModule(\n  Effect.fnUntraced(function* () {\n    // Create UndoRegistry over the live mapping contributions (synchronous access in callbacks).\n    const undoMappings = yield* Capabilities.UndoMapping;\n    const undoRegistry = UndoRegistry.make(() => undoMappings.get().flat());\n\n    // Create HistoryTracker (depends on UndoRegistry and OperationInvoker).\n    const invoker = yield* Capabilities.OperationInvoker;\n    // Cast to internal type - the factory always returns OperationInvokerInternal.\n    const historyTracker = HistoryTracker.make(invoker as OperationInvoker.OperationInvokerInternal, undoRegistry);\n\n    return [\n      Capability.contribute(Capabilities.UndoRegistry, undoRegistry),\n      Capability.contribute(Capabilities.HistoryTracker, historyTracker),\n    ];\n  }),\n);\n"],"mappings":";;;;;;AAiBA,IAAA,qBAAeA,WACb,OAAO,WAAW,aAAa;CAE7B,MAAM,eAAe,OAAOC;CAC5B,MAAM,eAAeC,WAAwB,aAAa,IAAI,CAAC,CAAC,KAAK,CAAC;CAGtE,MAAM,UAAU,OAAOC;CAEvB,MAAM,iBAAiBC,OAAoB,SAAsD,YAAY;CAE7G,OAAO,CACLC,WAAsBC,cAA2B,YAAY,GAC7DD,WAAsBE,gBAA6B,cAAc,CACnE;AACF,CAAC,CACH"}

package/dist/lib/chunk-history-tracker.mjs

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "./chunk-rolldown-runtime.mjs";
-import { resolveMessage } from "./plugin-process-manager/history/undo-mapping.mjs";
+import { n as resolveMessage } from "./chunk-undo-mapping.mjs";
 import * as Effect from "effect/Effect";
 import * as EffectEx from "@dxos/effect/EffectEx";
 import { log } from "@dxos/log";

package/dist/lib/chunk-hooks.mjs

@@ -1,11 +1,11 @@
 import { d as SurfaceManagerProvider, t as SurfaceManager } from "./chunk-SurfaceManager.mjs";
 import { r as make } from "./chunk-plugin-manager.mjs";
 import { t as PluginManagerContext } from "./chunk-context.mjs";
-import { AtomRegistry, OperationHandlers, OperationInvoker, PluginManager, ProcessManagerRuntime, ReactContext, ReactRoot } from "./common/capabilities.mjs";
-import { Startup } from "./common/activation-events.mjs";
+import { c as OperationHandlers, f as ProcessManagerRuntime, l as OperationInvoker, m as ReactRoot, p as ReactContext, t as AtomRegistry, u as PluginManager } from "./chunk-capabilities.mjs";
+import { a as Startup } from "./chunk-activation-events.mjs";
 import { PluginManagerProvider, useOptionalPluginManager, usePluginManager } from "./PluginManagerProvider.mjs";
 import { t as Context } from "./chunk-Surface.mjs";
-import { setup } from "./ns/Devtools.mjs";
+import { n as setup } from "./chunk-Devtools.mjs";
 import { t as topologicalSort } from "./chunk-helpers.mjs";
 import { Suspense, use, useCallback, useContext, useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
 import { useAtomValue } from "@effect/atom-react/Hooks";
@@ -376,7 +376,7 @@ var useApp = ({ pluginManager, pluginLoader: pluginLoaderProp, onPluginRemove, p
 					setError(withContext(error$, diagnostics));
 					reportFailure(diagnostics);
 				}
-			})), Effect.forever));
+			})), Effect.forever({ disableYield: true })));
 			yield* Effect.all([...setupEvents.map((event) => manager.activate(event)), manager.activate(Startup)]);
 			return yield* Fiber.join(listener);
 		}).pipe(Effect.scoped, Effect.runFork);
@@ -384,7 +384,7 @@ var useApp = ({ pluginManager, pluginLoader: pluginLoaderProp, onPluginRemove, p
 			log("useApp: effect cleanup", void 0, {
 				"~LogMeta": "~LogMeta",
 				F: __dxlog_file,
-				L: 453,
+				L: 454,
 				S: void 0
 			});
 			watchdog.dispose();