@dxos/app-framework 0.10.0 → 0.11.1

package/dist/lib/common/capabilities.mjs

@@ -0,0 +1,184 @@
+import { t as __exportAll } from "../chunk-rolldown-runtime.mjs";
+import { get, make } from "../core/capability.mjs";
+import * as Effect from "effect/Effect";
+//#region src/common/capabilities.ts
+var capabilities_exports = /* @__PURE__ */ __exportAll({
+	AtomRegistry: () => AtomRegistry,
+	Command: () => Command,
+	HistoryTracker: () => HistoryTracker,
+	Layer: () => Layer,
+	LayerSpec: () => LayerSpec,
+	ManagedRuntime: () => ManagedRuntime,
+	Null: () => Null,
+	OperationHandler: () => OperationHandler,
+	OperationInvoker: () => OperationInvoker,
+	PluginManager: () => PluginManager,
+	ProcessManagerRuntime: () => ProcessManagerRuntime,
+	ProcessMonitor: () => ProcessMonitor,
+	ReactContext: () => ReactContext,
+	ReactRoot: () => ReactRoot,
+	ReactSurface: () => ReactSurface,
+	RemoteTraceMonitor: () => RemoteTraceMonitor,
+	ServiceResolver: () => ServiceResolver,
+	TraceSink: () => TraceSink,
+	UndoMapping: () => UndoMapping,
+	UndoRegistry: () => UndoRegistry,
+	getAtomValue: () => getAtomValue,
+	subscribeAtom: () => subscribeAtom,
+	updateAtomValue: () => updateAtomValue
+});
+/**
+* Null capability.
+* @category Capability
+*/
+var Null = make("org.dxos.app-framework.capability.null");
+/**
+* @category Capability
+*/
+var PluginManager = make("org.dxos.app-framework.capability.pluginManager");
+/**
+* @category Capability
+*/
+var AtomRegistry = make("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 ProcessMonitor} 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 = make("org.dxos.app-framework.capability.serviceResolver");
+/**
+* Process monitor backing the shared {@link ProcessManagerRuntime}. Exposes the
+* live process tree (including inactive/terminated entries) via
+* {@link Process$.Monitor#processTreeAtom}.
+*
+* @category Capability
+*/
+var ProcessMonitor = make("org.dxos.app-framework.capability.processMonitor");
+/**
+* @category Capability
+*/
+var ProcessManagerRuntime = make("org.dxos.app-framework.capability.processManagerRuntime");
+/**
+* @category Capability
+*/
+var ManagedRuntime = make("org.dxos.app-framework.capability.managedRuntime");
+var OperationHandler = make("org.dxos.app-framework.capability.operationHandler");
+/**
+* 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 = make("org.dxos.app-framework.capability.operationInvoker");
+/**
+* Undo registry - provided by ProcessManagerPlugin.
+* @category Capability
+*/
+var UndoRegistry = make("org.dxos.app-framework.capability.undoRegistry");
+/**
+* History tracker - provided by ProcessManagerPlugin.
+* @category Capability
+*/
+var HistoryTracker = make("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);
+});
+/**
+* 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 { AtomRegistry, Command, HistoryTracker, Layer, LayerSpec, ManagedRuntime, Null, OperationHandler, OperationInvoker, PluginManager, ProcessManagerRuntime, ProcessMonitor, ReactContext, ReactRoot, ReactSurface, RemoteTraceMonitor, ServiceResolver, TraceSink, UndoMapping, UndoRegistry, getAtomValue, subscribeAtom, capabilities_exports as t, updateAtomValue };
+
+//# sourceMappingURL=capabilities.mjs.map

package/dist/lib/common/capabilities.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"capabilities.mjs","names":[],"sources":["../../../src/common/capabilities.ts"],"sourcesContent":["//\n// Copyright 2025 DXOS.org\n//\n\nimport { type Atom, type Registry } from '@effect-atom/atom';\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 type * as Runtime$ from 'effect/Runtime';\nimport type { FC, PropsWithChildren } from 'react';\n\nimport type {\n  OperationHandlerSet,\n  LayerSpec as LayerSpec$,\n  Operation as Operation$,\n  Process as Process$,\n  ServiceResolver as ServiceResolver$,\n  Trace as Trace$,\n} from '@dxos/compute';\nimport type {\n  ProcessManager as ProcessManager$,\n  RemoteTraceMonitor as RemoteTraceMonitor$,\n} from '@dxos/compute-runtime';\nimport { OperationInvoker as OperationInvoker$ } from '@dxos/operation';\n\nimport { Capability as Capability$, Plugin as Plugin$, type PluginManager as PluginManager$ } from '../core';\nimport type {\n  HistoryTracker as HistoryTracker$,\n  UndoMapping as UndoMapping$,\n  UndoRegistry as UndoRegistry$,\n} from '../plugin-process-manager';\nimport type { Surface } from '../ui';\n\n/**\n * Null capability.\n * @category Capability\n */\nexport const Null = Capability$.make<null>('org.dxos.app-framework.capability.null');\n\n/**\n * @category Capability\n */\nexport const PluginManager = Capability$.make<PluginManager$.PluginManager>(\n  'org.dxos.app-framework.capability.pluginManager',\n);\n\n/**\n * @category Capability\n */\nexport const AtomRegistry = Capability$.make<Registry.Registry>('org.dxos.app-framework.capability.atomRegistry');\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\nexport type AnyCommand = Command$.Command<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 */\nexport const Layer = Capability$.make<Layer$.Layer<any, any, any>>('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<LayerSpec$.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: ServiceResolver$.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 ProcessMonitor} 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$.make<ServiceResolver$.ServiceResolver>(\n  'org.dxos.app-framework.capability.serviceResolver',\n);\n\n/**\n * Process monitor backing the shared {@link ProcessManagerRuntime}. Exposes the\n * live process tree (including inactive/terminated entries) via\n * {@link Process$.Monitor#processTreeAtom}.\n *\n * @category Capability\n */\nexport const ProcessMonitor = Capability$.make<Process$.Monitor>('org.dxos.app-framework.capability.processMonitor');\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  | ProcessManager$.ProcessOperationInvoker.Service\n  | ServiceResolver$.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?: Runtime$.RunForkOptions,\n  ): Fiber$.RuntimeFiber<A, E>;\n  runSync<A, E>(effect: Effect.Effect<A, E, ProcessManagerRuntimeServices>): A;\n}\n\n/**\n * @category Capability\n */\nexport const ProcessManagerRuntime = Capability$.make<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$.make<ManagedRuntime>('org.dxos.app-framework.capability.managedRuntime');\n\n//\n// Operation System Capabilities\n//\n\nexport const OperationHandler = Capability$.make<OperationHandlerSet.OperationHandlerSet>(\n  'org.dxos.app-framework.capability.operationHandler',\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 {@link ProcessManager$.ProcessOperationInvoker}.\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$.make<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$.make<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$.make<HistoryTracker>('org.dxos.app-framework.capability.historyTracker');\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 * 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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwCA,IAAa,OAAO,KAAuB,wCAAwC;;;;AAKnF,IAAa,gBAAgB,KAC3B,iDACF;;;;AAKA,IAAa,eAAe,KAAoC,gDAAgD;;;;AAWhH,IAAa,eAAe,KAA+B,gDAAgD;;;;AAO3G,IAAa,YAAY,KAA4B,6CAA6C;;;;AAUlG,IAAa,eAAe,KAA+B,gDAAgD;;;;AAO3G,IAAa,UAAU,KAA6B,2CAA2C;;;;AAK/F,IAAa,QAAQ,KAA8C,yCAAyC;;;;;;;;;;AAW5G,IAAa,YAAY,KAAuC,6CAA6C;;;;;;;;;;;;;AAmC7G,IAAa,YAAY,KAAmC,6CAA6C;;;;;;;;;AAUzG,IAAa,qBAAqB,KAChC,sDACF;;;;;;;;;;;;;;;;;;;;;;AAuBA,IAAa,kBAAkB,KAC7B,mDACF;;;;;;;;AASA,IAAa,iBAAiB,KAAmC,kDAAkD;;;;AAuCnH,IAAa,wBAAwB,KACnC,yDACF;;;;AAOA,IAAa,iBAAiB,KAAiC,kDAAkD;AAMjH,IAAa,mBAAmB,KAC9B,oDACF;;;;;AAQA,IAAa,cAAc,KAAgC,+CAA+C;;;;;AAY1G,IAAa,mBAAmB,KAC9B,oDACF;;;;;AAQA,IAAa,eAAe,KAA+B,gDAAgD;;;;;AAQ3G,IAAa,iBAAiB,KAAiC,kDAAkD;;;;;AAUjH,IAAa,gBACX,mBAEA,OAAO,IAAI,aAAa;CACtB,MAAM,WAAW,OAAO,IAAgB,YAAY;CACpD,MAAM,OAAO,OAAO,IAAgB,cAAc;CAClD,OAAO,SAAS,IAAI,IAAI;AAC1B,CAAC;;;;;AAMH,IAAa,mBACX,gBACA,OAEA,OAAO,IAAI,aAAa;CACtB,MAAM,WAAW,OAAO,IAAgB,YAAY;CACpD,MAAM,OAAO,OAAO,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,OAAO,IAAgB,YAAY;CACpD,MAAM,OAAO,OAAO,IAAgB,cAAc;CAClD,OAAO,SAAS,UAAU,YAAY,SAAS,SAAS,IAAI,IAAI,CAAC,CAAC;AACpE,CAAC"}

package/dist/lib/config.mjs

@@ -0,0 +1,2 @@
+import { Config2 } from "@dxos/protocols";
+export { Config2 };

package/dist/lib/core/activation-event.mjs

@@ -0,0 +1,55 @@
+import { t as __exportAll } from "../chunk-rolldown-runtime.mjs";
+import { DXN } from "@dxos/keys";
+import { compositeKey } from "@dxos/util";
+//#region src/core/activation-event.ts
+var activation_event_exports = /* @__PURE__ */ __exportAll({
+	allOf: () => allOf,
+	eventKey: () => eventKey,
+	getEvents: () => getEvents,
+	isAllOf: () => isAllOf,
+	isOneOf: () => isOneOf,
+	make: () => make,
+	oneOf: () => oneOf
+});
+/**
+* Helper to define an activation event from an NSID.
+* Static NSID strings are validated at compile time via {@link DXN.Name}.
+*/
+var make = (nsid, specifier) => ({
+	id: DXN.make(nsid),
+	specifier
+});
+/**
+* Helper to create an activation event key.
+*/
+var eventKey = (event) => event.specifier ? compositeKey(event.id, event.specifier) : event.id;
+/**
+* Helper to create an activation event that triggers when any of the given events are activated.
+*/
+var oneOf = (...events) => ({
+	type: "one-of",
+	events
+});
+/**
+* Helper to create an activation event that triggers when all of the given events are activated.
+*/
+var allOf = (...events) => ({
+	type: "all-of",
+	events
+});
+/**
+* Helper to check if an activation event is a one-of event.
+*/
+var isOneOf = (events) => "type" in events && events.type === "one-of";
+/**
+* Helper to check if an activation event is an all-of event.
+*/
+var isAllOf = (events) => "type" in events && events.type === "all-of";
+/**
+* Helper to get the events from an activation event.
+*/
+var getEvents = (events) => "type" in events ? events.events : [events];
+//#endregion
+export { allOf, eventKey, getEvents, isAllOf, isOneOf, make, oneOf, activation_event_exports as t };
+
+//# sourceMappingURL=activation-event.mjs.map

package/dist/lib/core/activation-event.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"activation-event.mjs","names":[],"sources":["../../../src/core/activation-event.ts"],"sourcesContent":["//\n// Copyright 2025 DXOS.org\n//\n\nimport { DXN } from '@dxos/keys';\nimport { compositeKey } from '@dxos/util';\n\n/**\n * A unique DXN identifier representing an event.\n *\n * @example dxn:org.dxos.plugin.example.event.ready\n */\nexport type ActivationEvent = {\n  id: DXN.DXN;\n  specifier?: string;\n};\n\n/**\n * An activation event that can be a single event, or a combination of events.\n */\nexport type Events =\n  | ActivationEvent\n  | { type: 'one-of'; events: ActivationEvent[] }\n  | { type: 'all-of'; events: ActivationEvent[] };\n\n/**\n * Helper to define an activation event from an NSID.\n * Static NSID strings are validated at compile time via {@link DXN.Name}.\n */\nexport const make: {\n  <T extends string>(\n    nsid: [DXN.Name<T>] extends [never] ? `Invalid NSID \"${T}\": final segment must be camelCase (no hyphens)` : T,\n    specifier?: string,\n  ): ActivationEvent;\n} = (nsid: string, specifier?: string): ActivationEvent => ({\n  id: DXN.make(nsid),\n  specifier,\n});\n\n/**\n * Helper to create an activation event key.\n */\nexport const eventKey = (event: ActivationEvent) =>\n  event.specifier ? compositeKey(event.id, event.specifier) : event.id;\n\n/**\n * Helper to create an activation event that triggers when any of the given events are activated.\n */\nexport const oneOf = (...events: ActivationEvent[]) => ({ type: 'one-of' as const, events });\n\n/**\n * Helper to create an activation event that triggers when all of the given events are activated.\n */\nexport const allOf = (...events: ActivationEvent[]) => ({ type: 'all-of' as const, events });\n\n/**\n * Helper to check if an activation event is a one-of event.\n */\nexport const isOneOf = (events: Events): events is { type: 'one-of'; events: ActivationEvent[] } =>\n  'type' in events && events.type === 'one-of';\n\n/**\n * Helper to check if an activation event is an all-of event.\n */\nexport const isAllOf = (events: Events): events is { type: 'all-of'; events: ActivationEvent[] } =>\n  'type' in events && events.type === 'all-of';\n\n/**\n * Helper to get the events from an activation event.\n */\nexport const getEvents = (events: Events) => ('type' in events ? events.events : [events]);\n"],"mappings":";;;;;;;;;;;;;;;;;AA6BA,IAAa,QAKR,MAAc,eAAyC;CAC1D,IAAI,IAAI,KAAK,IAAI;CACjB;AACF;;;;AAKA,IAAa,YAAY,UACvB,MAAM,YAAY,aAAa,MAAM,IAAI,MAAM,SAAS,IAAI,MAAM;;;;AAKpE,IAAa,SAAS,GAAG,YAA+B;CAAE,MAAM;CAAmB;AAAO;;;;AAK1F,IAAa,SAAS,GAAG,YAA+B;CAAE,MAAM;CAAmB;AAAO;;;;AAK1F,IAAa,WAAW,WACtB,UAAU,UAAU,OAAO,SAAS;;;;AAKtC,IAAa,WAAW,WACtB,UAAU,UAAU,OAAO,SAAS;;;;AAKtC,IAAa,aAAa,WAAoB,UAAU,SAAS,OAAO,SAAS,CAAC,MAAM"}

package/dist/lib/core/capability.mjs

@@ -0,0 +1,189 @@
+import { t as __exportAll } from "../chunk-rolldown-runtime.mjs";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+//#region src/core/capability.ts
+var capability_exports = /* @__PURE__ */ __exportAll({
+	ModuleTag: () => ModuleTag,
+	Service: () => Service,
+	asLayer: () => asLayer,
+	atom: () => atom,
+	atomByModule: () => atomByModule,
+	contributes: () => contributes,
+	get: () => get,
+	getAll: () => getAll,
+	getModuleTag: () => getModuleTag,
+	getOption: () => getOption,
+	layerWith: () => layerWith,
+	lazy: () => lazy,
+	make: () => make,
+	makeModule: () => makeModule,
+	waitFor: () => waitFor
+});
+/**
+* Effect Context.Tag for accessing CapabilityManager via the Effect layer system.
+* This allows capability modules to access the capability manager without having it passed as an argument.
+*/
+var Service = class extends Context.Tag("@dxos/app-framework/CapabilityManager")() {};
+/**
+* Get a single capability from the capability manager.
+* @param interfaceDef The interface definition of the capability.
+* @returns The capability implementation.
+* @throws If no capability is found.
+*/
+var get = (interfaceDef) => Effect.flatMap(Service, (manager) => Effect.try({
+	try: () => manager.get(interfaceDef),
+	catch: (error) => error instanceof Error ? error : new Error(String(error))
+}));
+/**
+* Get all capabilities from the capability manager for a given interface.
+* @param interfaceDef The interface definition of the capability.
+* @returns An array of capability implementations.
+*/
+var getAll = (interfaceDef) => Effect.map(Service, (manager) => manager.getAll(interfaceDef));
+/**
+* Get a single capability from the capability manager, if one is contributed.
+* Never fails — use this over {@link get} when the capability's absence (e.g. an optional plugin
+* isn't loaded) is a legitimate case to handle rather than an error.
+* @param interfaceDef The interface definition of the capability.
+* @returns The first capability implementation, or `Option.none()` if none is contributed.
+*/
+var getOption = (interfaceDef) => Effect.map(getAll(interfaceDef), (all) => Option.fromNullable(all[0]));
+/**
+* Wait for a capability to be available.
+* @param interfaceDef The interface definition of the capability.
+* @returns The capability implementation once available.
+*/
+var waitFor = (interfaceDef) => Effect.flatMap(Service, (manager) => manager.waitFor(interfaceDef));
+/**
+* Get the Atom reference to capabilities for reactive access.
+* @param interfaceDef The interface definition of the capability.
+* @returns An Atom containing the array of capability implementations.
+*/
+var atom = (interfaceDef) => Effect.map(Service, (manager) => manager.atom(interfaceDef));
+/**
+* Get capabilities grouped by the module that contributed them.
+* @param interfaceDef The interface definition of the capability.
+* @returns An Atom containing a record from module ID to capability implementations.
+*/
+var atomByModule = (interfaceDef) => Effect.map(Service, (manager) => manager.atomByModule(interfaceDef));
+/**
+* Constructs a layer that will request its interface implementation from the capability manager.
+*/
+var asLayer = (interfaceDef, tag) => Layer.effect(tag, get(interfaceDef).pipe(Effect.orDie));
+/**
+* Constructs a layer from a capability by resolving it from the capability manager and passing the
+* value to `build`. Lets a consumer depend on a canonical service (e.g. `Identity.Service`) and
+* have it provided from a capability without the consumer referencing the capability system:
+*
+* ```ts
+* effect.pipe(
+*   Effect.provide(Capability.layerWith(ClientCapabilities.IdentityService, (service) =>
+*     Layer.succeed(Identity.Service, service),
+*   )),
+* );
+* ```
+*/
+var layerWith = (interfaceDef, build) => Layer.unwrapEffect(get(interfaceDef).pipe(Effect.orDie, Effect.map(build)));
+/**
+* Symbol used to tag lazy capability functions with their module ID.
+*/
+var ModuleTag = Symbol.for("@dxos/app-framework/ModuleTag");
+/**
+* Helper to define the interface of a capability.
+* Static NSID strings are validated at compile time via {@link DXN.Name}.
+*/
+var make = (identifier) => {
+	return { identifier };
+};
+/**
+* Helper to define the implementation of a capability.
+* Returns the opaque base type so callers cannot discriminate on capability kind,
+* keeping d.ts emit portable across packages.
+*/
+var contributes = (interfaceDef, implementation, deactivate) => {
+	return {
+		interface: interfaceDef,
+		implementation,
+		deactivate
+	};
+};
+/**
+* Helper to define a lazily loaded implementation of a capability.
+* Supports single capabilities, arrays, and tuples of different capability types.
+* @param name The export name (e.g., 'AppGraphBuilder') - used to auto-compute module IDs.
+* @param loader The lazy loader function.
+* @returns A lazy capability function with ModuleTag symbol attached.
+*/
+var lazy = (name, c) => {
+	const lazyFn = (props) => Effect.gen(function* () {
+		const { default: getCapability } = yield* Effect.promise(() => c());
+		const result = yield* getCapability(props);
+		return result == null ? [] : Array.isArray(result) ? Array.from(result) : [result];
+	});
+	return Object.assign(lazyFn, { [ModuleTag]: name });
+};
+/**
+* Gets the module tag (export name) from a lazy capability function.
+* @param capability The lazy capability function.
+* @returns The module tag if present, undefined otherwise.
+*/
+var getModuleTag = (capability) => {
+	return capability && typeof capability === "function" && ModuleTag in capability ? String(capability[ModuleTag]) : void 0;
+};
+/**
+* Helper to define a capability module with explicit typing.
+* Wraps the default export function to provide better type inference and make the pattern explicit.
+*
+* This helper provides explicit typing for the module activation function,
+* making it clear that the function should:
+* - Access CapabilityManager via the Effect layer system (Capability.get, Capability.getAll, etc.)
+* - Return a capability, array of capabilities, or tuple of different capability types (sync or async)
+*
+* Supports returning multiple capabilities of different types as a tuple, which will be normalized
+* to an array at runtime for compatibility with the plugin system.
+*
+* @example
+* ```ts
+* // Module without options - single capability
+* export default Capability.makeModule(
+*   Effect.fnUntraced(function* () {
+*     const client = yield* Capability.get(ClientCapabilities.Client);
+*     return contributes(Capabilities.SettingsStore, store);
+*   })
+* );
+*
+* // Module with multiple capabilities
+* export default Capability.makeModule(
+*   Effect.fnUntraced(function* () {
+*     return [
+*       contributes(Capabilities.SettingsStore, store),
+*       contributes(Capabilities.Translations, translations),
+*     ];
+*   })
+* );
+*
+* // Module with required options (context accessed via layer)
+* export default Capability.makeModule(
+*   Effect.fnUntraced(function* (props: { observability: boolean }) {
+*     const invoker = yield* Capability.get(Capabilities.OperationInvoker);
+*     return contributes(Capabilities.OperationHandler, ...);
+*   })
+* );
+*
+* // Module with scoped resources (closed automatically on deactivation)
+* export default Capability.makeModule(
+*   Effect.fnUntraced(function* () {
+*     const scope = yield* Scope.Scope;
+*     yield* Scope.addFinalizer(scope, Effect.sync(() => cleanup()));
+*     return contributes(Capabilities.MyCapability, implementation);
+*   })
+* );
+* ```
+*/
+var makeModule = (fn) => fn;
+//#endregion
+export { ModuleTag, Service, asLayer, atom, atomByModule, contributes, get, getAll, getModuleTag, getOption, layerWith, lazy, make, makeModule, capability_exports as t, waitFor };
+
+//# sourceMappingURL=capability.mjs.map

package/dist/lib/core/capability.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"capability.mjs","names":[],"sources":["../../../src/core/capability.ts"],"sourcesContent":["//\n// Copyright 2025 DXOS.org\n//\n\nimport { type Atom } from '@effect-atom/atom';\nimport * as Context from 'effect/Context';\nimport * as Effect from 'effect/Effect';\nimport * as Layer from 'effect/Layer';\nimport * as Option from 'effect/Option';\nimport type * as Scope from 'effect/Scope';\n\nimport type { DXN } from '@dxos/keys';\n\nimport type * as CapabilityManager from './capability-manager';\nimport type * as Plugin from './plugin';\n\n//\n// Capability Service Layer\n//\n\n/**\n * Effect Context.Tag for accessing CapabilityManager via the Effect layer system.\n * This allows capability modules to access the capability manager without having it passed as an argument.\n */\nexport class Service extends Context.Tag('@dxos/app-framework/CapabilityManager')<\n  Service,\n  CapabilityManager.CapabilityManager\n>() {}\n\n/**\n * Get a single capability from the capability manager.\n * @param interfaceDef The interface definition of the capability.\n * @returns The capability implementation.\n * @throws If no capability is found.\n */\n// TODO(wittjosiah): Add custom tagged errors (Data.TaggedError) for app-framework to enable\n//   type-safe error handling with Effect. Consider CapabilityNotFoundError, ModuleActivationError, etc.\nexport const get = <T>(interfaceDef: InterfaceDef<T>): Effect.Effect<T, Error, Service> =>\n  Effect.flatMap(Service, (manager) =>\n    Effect.try({\n      try: () => manager.get(interfaceDef),\n      catch: (error) => (error instanceof Error ? error : new Error(String(error))),\n    }),\n  );\n\n/**\n * Get all capabilities from the capability manager for a given interface.\n * @param interfaceDef The interface definition of the capability.\n * @returns An array of capability implementations.\n */\nexport const getAll = <T>(interfaceDef: InterfaceDef<T>): Effect.Effect<T[], never, Service> =>\n  Effect.map(Service, (manager) => manager.getAll(interfaceDef));\n\n/**\n * Get a single capability from the capability manager, if one is contributed.\n * Never fails — use this over {@link get} when the capability's absence (e.g. an optional plugin\n * isn't loaded) is a legitimate case to handle rather than an error.\n * @param interfaceDef The interface definition of the capability.\n * @returns The first capability implementation, or `Option.none()` if none is contributed.\n */\nexport const getOption = <T>(interfaceDef: InterfaceDef<T>): Effect.Effect<Option.Option<T>, never, Service> =>\n  Effect.map(getAll(interfaceDef), (all) => Option.fromNullable(all[0]));\n\n/**\n * Wait for a capability to be available.\n * @param interfaceDef The interface definition of the capability.\n * @returns The capability implementation once available.\n */\nexport const waitFor = <T>(interfaceDef: InterfaceDef<T>): Effect.Effect<T, Error, Service> =>\n  Effect.flatMap(Service, (manager) => manager.waitFor(interfaceDef));\n\n/**\n * Get the Atom reference to capabilities for reactive access.\n * @param interfaceDef The interface definition of the capability.\n * @returns An Atom containing the array of capability implementations.\n */\nexport const atom = <T>(interfaceDef: InterfaceDef<T>): Effect.Effect<Atom.Atom<T[]>, never, Service> =>\n  Effect.map(Service, (manager) => manager.atom(interfaceDef));\n\n/**\n * Get capabilities grouped by the module that contributed them.\n * @param interfaceDef The interface definition of the capability.\n * @returns An Atom containing a record from module ID to capability implementations.\n */\nexport const atomByModule = <T>(\n  interfaceDef: InterfaceDef<T>,\n): Effect.Effect<Atom.Atom<Record<string, T[]>>, never, Service> =>\n  Effect.map(Service, (manager) => manager.atomByModule(interfaceDef));\n\n/**\n * Constructs a layer that will request its interface implementation from the capability manager.\n */\nexport const asLayer = <T, I>(interfaceDef: InterfaceDef<T>, tag: Context.Tag<I, T>): Layer.Layer<I, never, Service> =>\n  Layer.effect(tag, get(interfaceDef).pipe(Effect.orDie));\n\n/**\n * Constructs a layer from a capability by resolving it from the capability manager and passing the\n * value to `build`. Lets a consumer depend on a canonical service (e.g. `Identity.Service`) and\n * have it provided from a capability without the consumer referencing the capability system:\n *\n * ```ts\n * effect.pipe(\n *   Effect.provide(Capability.layerWith(ClientCapabilities.IdentityService, (service) =>\n *     Layer.succeed(Identity.Service, service),\n *   )),\n * );\n * ```\n */\nexport const layerWith = <T, A, E, R>(\n  interfaceDef: InterfaceDef<T>,\n  build: (value: T) => Layer.Layer<A, E, R>,\n): Layer.Layer<A, E, R | Service> => Layer.unwrapEffect(get(interfaceDef).pipe(Effect.orDie, Effect.map(build)));\n\nconst InterfaceDefTypeId: unique symbol = Symbol.for('InterfaceDefTypeId');\n\n/**\n * Symbol used to tag lazy capability functions with their module ID.\n */\nexport const ModuleTag: unique symbol = Symbol.for('@dxos/app-framework/ModuleTag');\n\n/**\n * The interface definition of a capability.\n */\nexport type InterfaceDef<T> = {\n  [InterfaceDefTypeId]: T;\n  identifier: string;\n};\n\nexport namespace InterfaceDef {\n  export type Implementation<I extends InterfaceDef<any>> = I extends InterfaceDef<infer T> ? T : never;\n}\n\n/**\n * Helper to define the interface of a capability.\n * Static NSID strings are validated at compile time via {@link DXN.Name}.\n */\nexport const make: {\n  <T, S extends string = string>(\n    identifier: [DXN.Name<S>] extends [never] ? `Invalid NSID \"${S}\": final segment must be camelCase (no hyphens)` : S,\n  ): InterfaceDef<T>;\n} = <T>(identifier: string): InterfaceDef<T> => {\n  return { identifier } as InterfaceDef<T>;\n};\n\n/**\n * A unique string identifier with a Typescript type associated with it.\n * When a capability is contributed to the application an implementation of the interface is provided.\n */\nexport type Capability<T> = {\n  /**\n   * The interface definition of the capability.\n   */\n  readonly interface: InterfaceDef<T>;\n\n  /**\n   * The implementation of the capability.\n   */\n  readonly implementation: T;\n\n  /**\n   * Called when the capability is deactivated.\n   */\n  readonly deactivate?: () => Effect.Effect<void, Error>;\n};\n\nexport type Any = Capability<any>;\n\n/**\n * Union type representing all valid return types for a capability module.\n * Supports single capabilities, arrays, and tuples of different capability types.\n */\nexport type ModuleReturn = void | Any | Any[] | readonly Any[] | [Any, ...Any[]] | readonly [Any, ...Any[]];\n\n/**\n * Helper to define the implementation of a capability.\n * Returns the opaque base type so callers cannot discriminate on capability kind,\n * keeping d.ts emit portable across packages.\n */\nexport const contributes = <I extends InterfaceDef<any>>(\n  interfaceDef: I,\n  implementation: Capability<InterfaceDef.Implementation<I>>['implementation'],\n  deactivate?: Capability<InterfaceDef.Implementation<I>>['deactivate'],\n): Any => {\n  return {\n    interface: interfaceDef,\n    implementation,\n    deactivate,\n  } satisfies Capability<I>;\n};\n\ntype LoadCapability<Props, Capabilities extends ModuleReturn = ModuleReturn> = () => Promise<{\n  default: (props: Props) => Effect.Effect<Capabilities, Error, Service | Plugin.Service | Scope.Scope | never>;\n}>;\ntype LoadCapabilities<Props, Capabilities extends ModuleReturn = ModuleReturn> = () => Promise<{\n  default: (props: Props) => Effect.Effect<Capabilities, Error, Service | Plugin.Service | Scope.Scope | never>;\n}>;\n\ntype NormalizeReturn<R> = R extends readonly (infer A)[]\n  ? A[]\n  : R extends (infer A)[]\n    ? A[]\n    : R extends Any\n      ? [R]\n      : Any[];\n\nexport type LazyCapability<Props = void, Capabilities extends ModuleReturn = ModuleReturn, E extends Error = Error> = (\n  props: Props,\n) => Effect.Effect<NormalizeReturn<Capabilities>, E, Service | Plugin.Service | Scope.Scope | never>;\n\n/**\n * Helper to define a lazily loaded implementation of a capability.\n * Supports single capabilities, arrays, and tuples of different capability types.\n * @param name The export name (e.g., 'AppGraphBuilder') - used to auto-compute module IDs.\n * @param loader The lazy loader function.\n * @returns A lazy capability function with ModuleTag symbol attached.\n */\nexport const lazy = <T = void, R extends ModuleReturn = ModuleReturn>(\n  name: string,\n  c: LoadCapability<T, R> | LoadCapabilities<T, R>,\n): LazyCapability<T> => {\n  const lazyFn = (props: T) =>\n    Effect.gen(function* () {\n      const { default: getCapability } = yield* Effect.promise(() => c());\n      const result = yield* getCapability(props);\n      const normalized = result == null ? [] : Array.isArray(result) ? Array.from(result) : [result];\n      return normalized as NormalizeReturn<R>;\n    });\n\n  // Props (T) are preserved so callers pass correctly-typed options, but the contributed\n  // Capabilities type is widened to the opaque base. The concrete capability type often traces to a\n  // module-internal source path that TypeScript cannot name in declaration files (TS2883); the base\n  // type is portable. The contributed type is checked at Capability.contributes regardless.\n  return Object.assign(lazyFn, { [ModuleTag]: name }) as LazyCapability<T>;\n};\n\n/**\n * Gets the module tag (export name) from a lazy capability function.\n * @param capability The lazy capability function.\n * @returns The module tag if present, undefined otherwise.\n */\n// TODO(wittjosiah): Stricter type for capability.\nexport const getModuleTag = (capability: unknown): string | undefined => {\n  return capability && typeof capability === 'function' && ModuleTag in capability\n    ? String(capability[ModuleTag])\n    : undefined;\n};\n\n/**\n * Helper to define a capability module with explicit typing.\n * Wraps the default export function to provide better type inference and make the pattern explicit.\n *\n * This helper provides explicit typing for the module activation function,\n * making it clear that the function should:\n * - Access CapabilityManager via the Effect layer system (Capability.get, Capability.getAll, etc.)\n * - Return a capability, array of capabilities, or tuple of different capability types (sync or async)\n *\n * Supports returning multiple capabilities of different types as a tuple, which will be normalized\n * to an array at runtime for compatibility with the plugin system.\n *\n * @example\n * ```ts\n * // Module without options - single capability\n * export default Capability.makeModule(\n *   Effect.fnUntraced(function* () {\n *     const client = yield* Capability.get(ClientCapabilities.Client);\n *     return contributes(Capabilities.SettingsStore, store);\n *   })\n * );\n *\n * // Module with multiple capabilities\n * export default Capability.makeModule(\n *   Effect.fnUntraced(function* () {\n *     return [\n *       contributes(Capabilities.SettingsStore, store),\n *       contributes(Capabilities.Translations, translations),\n *     ];\n *   })\n * );\n *\n * // Module with required options (context accessed via layer)\n * export default Capability.makeModule(\n *   Effect.fnUntraced(function* (props: { observability: boolean }) {\n *     const invoker = yield* Capability.get(Capabilities.OperationInvoker);\n *     return contributes(Capabilities.OperationHandler, ...);\n *   })\n * );\n *\n * // Module with scoped resources (closed automatically on deactivation)\n * export default Capability.makeModule(\n *   Effect.fnUntraced(function* () {\n *     const scope = yield* Scope.Scope;\n *     yield* Scope.addFinalizer(scope, Effect.sync(() => cleanup()));\n *     return contributes(Capabilities.MyCapability, implementation);\n *   })\n * );\n * ```\n */\nexport const makeModule = <\n  TProps = void,\n  TReturn extends ModuleReturn = ModuleReturn,\n  E extends Error = Error,\n  R extends Service | Plugin.Service | never = Service,\n>(\n  fn: (props: TProps) => Effect.Effect<TReturn, E, R | Scope.Scope>,\n): ((props: TProps) => Effect.Effect<TReturn, E, R | Scope.Scope>) => fn;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,IAAa,UAAb,cAA6B,QAAQ,IAAI,uCAAuC,CAAC,CAG/E,CAAC,CAAC,CAAC;;;;;;;AAUL,IAAa,OAAU,iBACrB,OAAO,QAAQ,UAAU,YACvB,OAAO,IAAI;CACT,WAAW,QAAQ,IAAI,YAAY;CACnC,QAAQ,UAAW,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,OAAO,KAAK,CAAC;AAC7E,CAAC,CACH;;;;;;AAOF,IAAa,UAAa,iBACxB,OAAO,IAAI,UAAU,YAAY,QAAQ,OAAO,YAAY,CAAC;;;;;;;;AAS/D,IAAa,aAAgB,iBAC3B,OAAO,IAAI,OAAO,YAAY,IAAI,QAAQ,OAAO,aAAa,IAAI,EAAE,CAAC;;;;;;AAOvE,IAAa,WAAc,iBACzB,OAAO,QAAQ,UAAU,YAAY,QAAQ,QAAQ,YAAY,CAAC;;;;;;AAOpE,IAAa,QAAW,iBACtB,OAAO,IAAI,UAAU,YAAY,QAAQ,KAAK,YAAY,CAAC;;;;;;AAO7D,IAAa,gBACX,iBAEA,OAAO,IAAI,UAAU,YAAY,QAAQ,aAAa,YAAY,CAAC;;;;AAKrE,IAAa,WAAiB,cAA+B,QAC3D,MAAM,OAAO,KAAK,IAAI,YAAY,CAAC,CAAC,KAAK,OAAO,KAAK,CAAC;;;;;;;;;;;;;;AAexD,IAAa,aACX,cACA,UACmC,MAAM,aAAa,IAAI,YAAY,CAAC,CAAC,KAAK,OAAO,OAAO,OAAO,IAAI,KAAK,CAAC,CAAC;;;;AAO/G,IAAa,YAA2B,OAAO,IAAI,+BAA+B;;;;;AAkBlF,IAAa,QAIL,eAAwC;CAC9C,OAAO,EAAE,WAAW;AACtB;;;;;;AAoCA,IAAa,eACX,cACA,gBACA,eACQ;CACR,OAAO;EACL,WAAW;EACX;EACA;CACF;AACF;;;;;;;;AA4BA,IAAa,QACX,MACA,MACsB;CACtB,MAAM,UAAU,UACd,OAAO,IAAI,aAAa;EACtB,MAAM,EAAE,SAAS,kBAAkB,OAAO,OAAO,cAAc,EAAE,CAAC;EAClE,MAAM,SAAS,OAAO,cAAc,KAAK;EAEzC,OADmB,UAAU,OAAO,CAAC,IAAI,MAAM,QAAQ,MAAM,IAAI,MAAM,KAAK,MAAM,IAAI,CAAC,MAAM;CAE/F,CAAC;CAMH,OAAO,OAAO,OAAO,QAAQ,GAAG,YAAY,KAAK,CAAC;AACpD;;;;;;AAQA,IAAa,gBAAgB,eAA4C;CACvE,OAAO,cAAc,OAAO,eAAe,cAAc,aAAa,aAClE,OAAO,WAAW,UAAU,IAC5B,KAAA;AACN;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoDA,IAAa,cAMX,OACoE"}

package/dist/lib/core/plugin-manager.mjs

@@ -0,0 +1,2 @@
+import { a as make, i as isManager, n as PluginInitializationError, r as PluginTimeoutError, t as ManagerTypeId } from "../chunk-plugin-manager.mjs";
+export { ManagerTypeId, PluginInitializationError, PluginTimeoutError, isManager, make };