@dxos/app-framework 0.10.0 → 0.11.0

package/dist/lib/core/plugin.mjs

@@ -0,0 +1,340 @@
+import { t as __exportAll } from "../chunk-rolldown-runtime.mjs";
+import { getModuleTag } from "./capability.mjs";
+import { DXN } from "@dxos/keys";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { invariant } from "@dxos/invariant";
+import * as Pipeable from "effect/Pipeable";
+import * as Schema from "effect/Schema";
+import { BaseError } from "@dxos/errors";
+import { PluginProfileSchema, PluginReleaseSchema } from "@dxos/protocols";
+//#region src/core/plugin.ts
+var plugin_exports = /* @__PURE__ */ __exportAll({
+	LazyPluginError: () => LazyPluginError,
+	Meta: () => Meta,
+	PluginDependencyError: () => PluginDependencyError,
+	PluginModuleTypeId: () => PluginModuleTypeId,
+	PluginTypeId: () => PluginTypeId,
+	Profile: () => Profile,
+	Release: () => Release,
+	Service: () => Service,
+	activate: () => activate,
+	addModule: () => addModule,
+	define: () => define,
+	getMetaFromConfig: () => getMetaFromConfig,
+	getURI: () => getURI,
+	isLazy: () => isLazy,
+	isPlugin: () => isPlugin,
+	isPluginModule: () => isPluginModule,
+	lazy: () => lazy,
+	make: () => make,
+	makeMeta: () => makeMeta,
+	reset: () => reset,
+	resolveLazy: () => resolveLazy,
+	shutdown: () => shutdown
+});
+var __dxlog_file = "/__w/dxos/dxos/packages/sdk/app-framework/src/core/plugin.ts";
+/**
+* Effect Context.Tag for accessing PluginManager via the Effect layer system.
+* This allows lifecycle operations to access the plugin manager without having it passed as an argument.
+*/
+var Service = class extends Context.Tag("@dxos/app-framework/PluginManager")() {};
+/**
+* Activates plugins based on the activation event.
+* Accesses the PluginManager via the Effect layer system.
+* @param event The activation event.
+* @returns Whether the activation was successful.
+*/
+var activate = (event) => Effect.flatMap(Service, (manager) => manager.activate(event));
+/**
+* Re-activates the modules that were activated by the event.
+* Accesses the PluginManager via the Effect layer system.
+* @param event The activation event.
+* @returns Whether the reset was successful.
+*/
+var reset = (event) => Effect.flatMap(Service, (manager) => manager.reset(event));
+/**
+* Shuts down the plugin manager, deactivating all active modules and clearing lifecycle state.
+* Accesses the PluginManager via the Effect layer system.
+*/
+var shutdown = () => Effect.flatMap(Service, (manager) => manager.shutdown());
+/**
+* Computes a module ID from plugin ID and export name.
+*/
+var computeModuleId = (pluginId, moduleName) => {
+	return `${pluginId}.module.${moduleName}`;
+};
+/**
+* Identifier denoting a PluginModule.
+*/
+var PluginModuleTypeId = Symbol.for("@dxos/app-framework/PluginModule");
+/**
+* Type guard to check if a value is a PluginModule.
+*/
+var isPluginModule = (value) => {
+	return typeof value === "object" && value !== null && PluginModuleTypeId in value;
+};
+var PluginModuleImpl = class {
+	[PluginModuleTypeId] = PluginModuleTypeId;
+	id;
+	activatesOn;
+	firesBeforeActivation;
+	firesAfterActivation;
+	activate;
+	constructor(options) {
+		this.id = options.id;
+		this.activatesOn = options.activatesOn;
+		this.firesBeforeActivation = options.firesBeforeActivation;
+		this.firesAfterActivation = options.firesAfterActivation;
+		this.activate = options.activate;
+	}
+};
+/**
+* Runtime plugin metadata, derived from the `@dxos/protocols` registry schemas (protocols owns the
+* config + registry schemas; the runtime projection lives here).
+*
+* - {@link Profile}: version-independent identity + display + provenance — the wire `PluginProfileSchema`
+*   (which carries `key`, the display fields, `dependsOn`, `spec`) plus `author` (resolved at runtime
+*   from the publisher's handle/DID for registry plugins, or self-declared for bundled).
+* - {@link Release}: a specific hosted release — the wire `PluginReleaseSchema` (version, moduleUrl, dependencies).
+* - {@link Meta}: a resolved single-release view — `{ profile, release? }`, both nested. `release` is
+*   unset for bundled plugins (compiled in) and set for registry plugins.
+*/
+var Profile = Schema.Struct({
+	...PluginProfileSchema.fields,
+	author: Schema.optional(Schema.String)
+});
+var Release = PluginReleaseSchema;
+var Meta = Schema.Struct({
+	profile: Profile,
+	release: Schema.optional(Release)
+});
+/** Constructs a bundled-plugin {@link Meta} from a canonical DXN. `profile.key` is the bare NSID derived from `key`. */
+var makeMeta = (options) => {
+	const { key, ...rest } = options;
+	return { profile: {
+		...rest,
+		key: DXN.getName(key)
+	} };
+};
+/** Returns the plugin's canonical DXN URI, constructed from `meta.profile.key` and `meta.release?.version`. */
+var getURI = (meta) => DXN.make(meta.profile.key, meta.release?.version);
+/**
+* Derives a runtime {@link Meta} from a loaded `dx.config.ts` (the `@dxos/protocols` `Config2.Config`).
+* Maps the flat authoring config to the nested profile; bundled plugins have no `release`.
+*/
+var getMetaFromConfig = ({ plugin }) => {
+	const { key, ...rest } = plugin;
+	return makeMeta({
+		key: DXN.make(key),
+		...rest
+	});
+};
+/**
+* Identifier denoting a Plugin.
+*/
+var PluginTypeId = Symbol.for("@dxos/app-framework/Plugin");
+/**
+* Type guard to check if a value is a Plugin.
+*/
+var isPlugin = (value) => {
+	return typeof value === "object" && value !== null && PluginTypeId in value;
+};
+/**
+* Internal implementation of Plugin.
+* @internal
+*/
+var PluginImpl = class {
+	_meta;
+	_modules;
+	[PluginTypeId] = PluginTypeId;
+	constructor(_meta, _modules) {
+		this._meta = _meta;
+		this._modules = _modules;
+	}
+	get meta() {
+		return this._meta;
+	}
+	get modules() {
+		return this._modules;
+	}
+};
+/**
+* Builder implementation for creating plugins incrementally.
+*/
+var PluginBuilderImpl = class {
+	meta;
+	_modules = [];
+	constructor(meta) {
+		this.meta = meta;
+	}
+	get modules() {
+		return this._modules;
+	}
+	addModule(moduleOptions) {
+		this._modules.push(moduleOptions);
+		return this;
+	}
+	pipe() {
+		return Pipeable.pipeArguments(this, arguments);
+	}
+};
+/**
+* Creates a new PluginBuilder to start building a plugin.
+*/
+var define = (meta) => new PluginBuilderImpl(meta);
+function addModule(moduleOptionsOrBuilder, moduleOptions) {
+	if (moduleOptions !== void 0) return moduleOptionsOrBuilder.addModule(moduleOptions);
+	const moduleOpts = moduleOptionsOrBuilder;
+	return (builder) => builder.addModule(moduleOpts);
+}
+/**
+* Resolves a module from either PluginModuleOptions or a function that returns PluginModuleOptions.
+*/
+var resolveModule = (meta, module, options) => {
+	const moduleOptions = typeof module === "function" ? module(options) : module;
+	const pluginName = meta.profile.key;
+	const id = Option.fromNullable(moduleOptions.id).pipe(Option.match({
+		onNone: () => {
+			const exportName = getModuleTag(moduleOptions.activate);
+			invariant(exportName, `Plugin module missing name. Plugin: ${meta.profile.key}`, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 353,
+				S: void 0,
+				A: ["exportName", "`Plugin module missing name. Plugin: ${meta.profile.key}`"]
+			});
+			return computeModuleId(pluginName, exportName);
+		},
+		onSome: (id) => computeModuleId(pluginName, id)
+	}));
+	return new PluginModuleImpl({
+		...moduleOptions,
+		id
+	});
+};
+function make(builder) {
+	const meta = builder.meta;
+	invariant(!meta.profile.dependsOn?.includes(meta.profile.key), `Plugin ${meta.profile.key} declares itself as a dependency.`, {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file,
+		L: 372,
+		S: this,
+		A: ["!meta.profile.dependsOn?.includes(meta.profile.key)", "`Plugin ${meta.profile.key} declares itself as a dependency.`"]
+	});
+	const factory = (options) => {
+		const modules = builder.modules.map((module) => resolveModule(meta, module, options));
+		return new PluginImpl(meta, modules);
+	};
+	return Object.assign(factory, { meta });
+}
+/**
+* Symbol used to tag lazy plugin stubs with their loader closure.
+* Hidden from enumeration so plugin manager iteration / serialization paths
+* don't trip over it.
+*/
+var LazyTag = Symbol.for("@dxos/app-framework/Plugin/Lazy");
+/**
+* Defines a lazy plugin whose body is loaded on first enable.
+*
+* The returned factory produces a stub `Plugin` that exposes `meta`
+* synchronously (so callers can read `Plugin.meta.profile.key` for free) but defers
+* loading the real plugin's modules until the manager calls
+* `Plugin.resolveLazy`. This lets the plugin's main entry point ship as a
+* tiny meta-only chunk — the heavy capabilities, schema, React surfaces,
+* etc. live behind the dynamic `import()` and become a separate Rollup
+* chunk that is only fetched when the plugin is enabled.
+*
+* @example
+* ```ts
+* // plugin-markdown/src/index.ts
+* import { Plugin } from '@dxos/app-framework';
+* import { meta } from './meta';
+*
+* export const MarkdownPlugin = Plugin.lazy(meta, () => import('./MarkdownPlugin'));
+*
+* // plugin-markdown/src/MarkdownPlugin.tsx
+* export const MarkdownPlugin = Plugin.define(meta).pipe(...heavy modules..., Plugin.make);
+* export default MarkdownPlugin;
+* ```
+*/
+var lazy = (meta, loader) => {
+	const factory = (options) => {
+		const stub = new PluginImpl(meta, []);
+		Object.defineProperty(stub, LazyTag, {
+			value: {
+				loader,
+				options
+			},
+			enumerable: false
+		});
+		return stub;
+	};
+	return Object.assign(factory, { meta });
+};
+/**
+* Type guard for lazy plugin stubs produced by {@link lazy}.
+*/
+var isLazy = (plugin) => LazyTag in plugin;
+/**
+* Tagged error for failures during lazy plugin resolution. `context.id` is
+* the lazy plugin's `meta.profile.key`; `context.reason` discriminates the failure
+* mode (`'load-failed' | 'missing-default' | 'invalid-plugin' |
+* 'meta-mismatch'`) so callers can route on it.
+*/
+var LazyPluginError = class extends BaseError.extend("LazyPluginError", "Failed to resolve lazy plugin") {};
+/**
+* Tagged error for plugin-level dependency resolution failures.
+*
+* `context.id` is the plugin id the manager was acting on. `context.reason`
+* discriminates the failure mode:
+*  - `'missing'` — declared dep is neither registered nor in the catalog.
+*    `context.missing` lists offending ids.
+*  - `'install-failed'` — dep was found in the catalog but `add()` failed.
+*    `cause` carries the original error.
+*  - `'cycle'` — closure walk detected a cycle. `context.path` is the cycle path.
+*  - `'core-dependent'` — cascade-disable would have to disable a core plugin.
+*    `context.coreDependent` is the blocking id.
+*/
+var PluginDependencyError = class extends BaseError.extend("PluginDependencyError", "Plugin dependency resolution failed") {};
+/**
+* Resolves a lazy plugin stub to its real plugin.
+* Returns the plugin unchanged if it is not lazy. Failures surface as
+* {@link LazyPluginError} with `context.reason` indicating the failure mode
+* and (for loader failures) `cause` set to the original error.
+*/
+var resolveLazy = (plugin) => Effect.gen(function* () {
+	if (!isLazy(plugin)) return plugin;
+	const id = plugin.meta.profile.key;
+	const { loader, options } = plugin[LazyTag];
+	const mod = yield* Effect.tryPromise({
+		try: loader,
+		catch: (error) => new LazyPluginError({
+			context: {
+				id,
+				reason: "load-failed"
+			},
+			cause: error
+		})
+	});
+	if (!mod || typeof mod.default !== "function") return yield* Effect.fail(new LazyPluginError({ context: {
+		id,
+		reason: "missing-default"
+	} }));
+	const result = mod.default(options);
+	if (!isPlugin(result)) return yield* Effect.fail(new LazyPluginError({ context: {
+		id,
+		reason: "invalid-plugin"
+	} }));
+	if (result.meta.profile.key !== id) return yield* Effect.fail(new LazyPluginError({ context: {
+		id,
+		reason: "meta-mismatch",
+		returnedId: result.meta.profile.key
+	} }));
+	return result;
+});
+//#endregion
+export { LazyPluginError, Meta, PluginDependencyError, PluginModuleTypeId, PluginTypeId, Profile, Release, Service, activate, addModule, define, getMetaFromConfig, getURI, isLazy, isPlugin, isPluginModule, lazy, make, makeMeta, reset, resolveLazy, shutdown, plugin_exports as t };
+
+//# sourceMappingURL=plugin.mjs.map

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

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

package/dist/lib/core/url-loader.mjs

@@ -0,0 +1,2 @@
+import { a as make, c as uninstall, i as isLocalUrl, n as getInstalledVersion, o as preload, r as getRemoteEntries, s as setInstalledVersion, t as RemotePluginLoadError } from "../chunk-url-loader.mjs";
+export { RemotePluginLoadError, getInstalledVersion, getRemoteEntries, isLocalUrl, make, preload, setInstalledVersion, uninstall };

package/dist/lib/index.mjs

@@ -0,0 +1,134 @@
+import { t as __exportAll } from "./chunk-rolldown-runtime.mjs";
+import { t as activation_event_exports } from "./core/activation-event.mjs";
+import { lazy, t as capability_exports } from "./core/capability.mjs";
+import { c as capability_manager_exports, o as plugin_manager_exports, s as registry_exports } from "./chunk-plugin-manager.mjs";
+import { addModule, define, make as make$1, makeMeta, t as plugin_exports } from "./core/plugin.mjs";
+import { l as url_loader_exports, u as plugin_asset_cache_exports } from "./chunk-url-loader.mjs";
+import { r as plugin_manifest_exports, t as PLUGIN_DEV_SERVER_PORT } from "./chunk-plugin-manifest.mjs";
+import { t as capabilities_exports } from "./common/capabilities.mjs";
+import { ProcessManagerReady, SetupProcessManager, Startup, t as activation_events_exports } from "./common/activation-events.mjs";
+import { Config2 } from "./config.mjs";
+import { t as PluginManagerContext } from "./chunk-context.mjs";
+import { a as undo_mapping_exports, i as undo_registry_exports, o as EmptyHistoryError, t as history_tracker_exports } from "./chunk-history-tracker.mjs";
+import { DXN } from "@dxos/keys";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import { Context } from "@dxos/context";
+//#region src/core/edge-registry-plugin-provider.ts
+var __dxlog_file = "/__w/dxos/dxos/packages/sdk/app-framework/src/core/edge-registry-plugin-provider.ts";
+/**
+* Maps a wire-format `PluginView` (from `@dxos/protocols`) to a runtime `Plugin.Meta`: the nested
+* `profile` (the view's profile plus the resolved provenance `author`) and the latest `release`.
+*
+* This is the one translation seam between the nested wire view and the resolved runtime manifest.
+* `profile.key` is the composer plugin id — a valid NSID — so `DXN.make(profile.key, release.version)`
+* reconstructs the canonical plugin DXN.
+*/
+var toRegistryPlugin = (entry) => {
+	if (!entry.releases?.length) return null;
+	const latestRelease = entry.releases.find((release) => release.version === entry.latestVersion) ?? entry.releases[0];
+	return {
+		profile: {
+			...entry.profile,
+			author: entry.handle ?? entry.did
+		},
+		release: latestRelease
+	};
+};
+/**
+* Implements `Registry.PluginProvider` against the Edge `/registry` HTTP endpoints.
+*
+* Lives in app-framework (rather than the more obvious home of `@dxos/edge-client`)
+* because edge-client doesn't depend on app-framework; siting the implementation
+* here keeps the dependency arrow `app-framework → edge-client` and avoids a
+* cycle. The class needs only the public `EdgeHttpClient` type, so a one-way
+* type-import is enough.
+*
+* `listVersions` is served directly from the `releases` array inlined on each
+* entry — no separate endpoint is needed.
+*/
+var EdgeRegistryPluginProvider = class {
+	_client;
+	#cachedPlugins = [];
+	#cachedEntries = [];
+	constructor(_client) {
+		this._client = _client;
+	}
+	listPlugins() {
+		return Effect.tryPromise({
+			try: () => this._client.getRegistryPlugins(Context.default(void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 58
+			})),
+			catch: (error) => error instanceof Error ? error : new Error(String(error))
+		}).pipe(Effect.map((body) => {
+			this.#cachedEntries = body.plugins;
+			const plugins = body.plugins.map(toRegistryPlugin).filter((entry) => entry !== null);
+			this.#cachedPlugins = plugins;
+			return plugins;
+		}));
+	}
+	listVersions(id) {
+		const entry = this.#cachedEntries.find((candidate) => candidate.profile.key === id);
+		if (!entry) return Effect.fail(/* @__PURE__ */ new Error(`Plugin not found in catalog: ${id}`));
+		return Effect.succeed(entry.releases);
+	}
+	getPlugin(id, version) {
+		const plugin = this.#cachedPlugins.find((candidate) => candidate.profile.key === id);
+		if (!plugin) return Effect.fail(/* @__PURE__ */ new Error(`Plugin not found in catalog: ${id}`));
+		if (version && version !== plugin.release?.version) return Effect.fail(/* @__PURE__ */ new Error(`Version ${version} not available for ${id}; only ${plugin.release?.version} is cached`));
+		return Effect.succeed(plugin);
+	}
+};
+//#endregion
+//#region src/common/Role.ts
+var Role_exports = /* @__PURE__ */ __exportAll({ make: () => make });
+/**
+* Mints a typed role token. The NSID is validated at compile time via
+* {@link DXN.Name}: the final segment must be camelCase (no hyphens).
+* Dynamic NSIDs (template-literal / runtime strings) are validated at runtime.
+*
+* Identity is structural; all tokens with the same `role` string are
+* interchangeable at runtime.
+*/
+var make = (nsid) => {
+	if (typeof nsid !== "string" || !/^[a-zA-Z]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(\.[a-zA-Z][a-zA-Z0-9]{0,62})$/.test(nsid)) throw new Error(`Invalid role NSID: "${nsid}". Must be a dotted name with a camelCase final segment (no hyphens in the last segment).`);
+	return { role: nsid };
+};
+//#endregion
+//#region src/common/translations.ts
+/**
+* A Label represents translatable text - either a simple string or a tuple of [key, options].
+*/
+var Label = Schema.Union(Schema.String, Schema.mutable(Schema.Tuple(Schema.String, Schema.mutable(Schema.Struct({
+	ns: Schema.Union(Schema.String, Schema.Array(Schema.String)),
+	count: Schema.optional(Schema.Number),
+	defaultValue: Schema.optional(Schema.String)
+})))));
+//#endregion
+//#region src/plugin-process-manager/meta.ts
+var meta = makeMeta({
+	key: DXN.make("org.dxos.plugin.processManager"),
+	name: "Process Manager Plugin",
+	author: "DXOS",
+	description: "Hosts the process-manager runtime that composes contributed layer specs into a service resolver, exposes the operation invoker built on top of it, and registers undo/history tracking.",
+	tags: ["system"]
+});
+//#endregion
+//#region src/plugin-process-manager/ProcessManagerPlugin.ts
+var ProcessManagerCapability = lazy("ProcessManager", () => import("./chunk-process-manager-capability.mjs"));
+var HistoryCapabilities = lazy("HistoryCapabilities", () => import("./chunk-capability.mjs"));
+var ProcessManagerPlugin = define(meta).pipe(addModule({
+	activatesOn: Startup,
+	firesBeforeActivation: [SetupProcessManager],
+	firesAfterActivation: [ProcessManagerReady],
+	activate: ProcessManagerCapability
+}), addModule({
+	activatesOn: ProcessManagerReady,
+	activate: HistoryCapabilities
+}), make$1);
+//#endregion
+export { activation_event_exports as ActivationEvent, activation_events_exports as ActivationEvents, capabilities_exports as Capabilities, capability_exports as Capability, capability_manager_exports as CapabilityManager, Config2, EdgeRegistryPluginProvider, EmptyHistoryError, history_tracker_exports as HistoryTracker, Label, PLUGIN_DEV_SERVER_PORT, plugin_exports as Plugin, plugin_asset_cache_exports as PluginAssetCache, plugin_manager_exports as PluginManager, PluginManagerContext, plugin_manifest_exports as PluginManifest, ProcessManagerPlugin, registry_exports as Registry, Role_exports as Role, undo_mapping_exports as UndoMapping, undo_registry_exports as UndoRegistry, url_loader_exports as UrlLoader };
+
+//# sourceMappingURL=index.mjs.map

package/dist/lib/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/core/edge-registry-plugin-provider.ts","../../src/common/Role.ts","../../src/common/translations.ts","../../src/plugin-process-manager/meta.ts","../../src/plugin-process-manager/ProcessManagerPlugin.ts"],"sourcesContent":["//\n// Copyright 2026 DXOS.org\n//\n\nimport * as Effect from 'effect/Effect';\n\nimport { Context } from '@dxos/context';\nimport { type EdgeHttpClient } from '@dxos/edge-client';\nimport { type PluginView } from '@dxos/protocols';\n\nimport type * as Plugin from './plugin';\nimport * as Registry from './registry';\n\n/**\n * Maps a wire-format `PluginView` (from `@dxos/protocols`) to a runtime `Plugin.Meta`: the nested\n * `profile` (the view's profile plus the resolved provenance `author`) and the latest `release`.\n *\n * This is the one translation seam between the nested wire view and the resolved runtime manifest.\n * `profile.key` is the composer plugin id — a valid NSID — so `DXN.make(profile.key, release.version)`\n * reconstructs the canonical plugin DXN.\n */\nconst toRegistryPlugin = (entry: PluginView): Plugin.Meta | null => {\n  if (!entry.releases?.length) {\n    return null;\n  }\n  const latestRelease = entry.releases.find((release) => release.version === entry.latestVersion) ?? entry.releases[0];\n  return {\n    profile: {\n      ...entry.profile,\n      // Provenance: the verified publisher is the author (handle preferred, DID fallback).\n      author: entry.handle ?? entry.did,\n    },\n    release: latestRelease,\n  };\n};\n\n/**\n * Implements `Registry.PluginProvider` against the Edge `/registry` HTTP endpoints.\n *\n * Lives in app-framework (rather than the more obvious home of `@dxos/edge-client`)\n * because edge-client doesn't depend on app-framework; siting the implementation\n * here keeps the dependency arrow `app-framework → edge-client` and avoids a\n * cycle. The class needs only the public `EdgeHttpClient` type, so a one-way\n * type-import is enough.\n *\n * `listVersions` is served directly from the `releases` array inlined on each\n * entry — no separate endpoint is needed.\n */\nexport class EdgeRegistryPluginProvider implements Registry.PluginProvider {\n  // Cached on first load so getPlugin/listVersions can resolve without re-fetching.\n  #cachedPlugins: readonly Plugin.Meta[] = [];\n  #cachedEntries: readonly PluginView[] = [];\n\n  constructor(private readonly _client: EdgeHttpClient) {}\n\n  listPlugins(): Effect.Effect<readonly Plugin.Meta[], Error> {\n    return Effect.tryPromise({\n      try: () => this._client.getRegistryPlugins(Context.default()),\n      catch: (error) => (error instanceof Error ? error : new Error(String(error))),\n    }).pipe(\n      Effect.map((body) => {\n        this.#cachedEntries = body.plugins;\n        const plugins = body.plugins.map(toRegistryPlugin).filter((entry): entry is Plugin.Meta => entry !== null);\n        this.#cachedPlugins = plugins;\n        return plugins;\n      }),\n    );\n  }\n\n  listVersions(id: string): Effect.Effect<readonly Plugin.Release[], Error> {\n    const entry = this.#cachedEntries.find((candidate) => candidate.profile.key === id);\n    if (!entry) {\n      return Effect.fail(new Error(`Plugin not found in catalog: ${id}`));\n    }\n    // Releases are already `PluginRelease`-shaped on the wire view; serve them directly.\n    return Effect.succeed(entry.releases);\n  }\n\n  getPlugin(id: string, version?: string): Effect.Effect<Plugin.Meta, Error> {\n    const plugin = this.#cachedPlugins.find((candidate) => candidate.profile.key === id);\n    if (!plugin) {\n      return Effect.fail(new Error(`Plugin not found in catalog: ${id}`));\n    }\n    if (version && version !== plugin.release?.version) {\n      return Effect.fail(\n        new Error(`Version ${version} not available for ${id}; only ${plugin.release?.version} is cached`),\n      );\n    }\n    return Effect.succeed(plugin);\n  }\n}\n","//\n// Copyright 2023 DXOS.org\n//\n\n// @import-as-namespace\n\nimport type { DXN } from '@dxos/keys';\n\n/**\n * A typed role token. Carries a role NSID for runtime dispatch plus a phantom\n * data type so consumers using `type={SomeToken}` and providers using\n * `AppSurface.object(SomeToken, ...)` share a single type-level contract.\n *\n * Mint via {@link make}. The `role` field holds the bare NSID (e.g.\n * `org.dxos.role.article`) — the dispatch key, `data-role` attribute value,\n * and what `.role` comparisons inside matched components see.\n */\nexport type Role<TData> = {\n  readonly role: string;\n  /** Covariant phantom; never accessed at runtime. */\n  readonly _phantom?: TData;\n};\n\n/**\n * Narrow data type carried by a role token.\n */\nexport type Data<T> = T extends Role<infer D> ? D : never;\n\n/**\n * Mints a typed role token. The NSID is validated at compile time via\n * {@link DXN.Name}: the final segment must be camelCase (no hyphens).\n * Dynamic NSIDs (template-literal / runtime strings) are validated at runtime.\n *\n * Identity is structural; all tokens with the same `role` string are\n * interchangeable at runtime.\n */\nexport const make: {\n  <TData = unknown, T extends string = string>(\n    nsid: [DXN.Name<T>] extends [never] ? `Invalid NSID \"${T}\": final segment must be camelCase (no hyphens)` : T,\n  ): Role<TData>;\n} = <TData>(nsid: string): Role<TData> => {\n  // Runtime guard for dynamic NSIDs that bypass the compile-time DXN.Name<T> check.\n  if (\n    typeof nsid !== 'string' ||\n    !/^[a-zA-Z]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(\\.[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(\\.[a-zA-Z][a-zA-Z0-9]{0,62})$/.test(\n      nsid,\n    )\n  ) {\n    throw new Error(\n      `Invalid role NSID: \"${nsid}\". Must be a dotted name with a camelCase final segment (no hyphens in the last segment).`,\n    );\n  }\n  return { role: nsid };\n};\n","//\n// Copyright 2023 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\n\n/**\n * A Label represents translatable text - either a simple string or a tuple of [key, options].\n */\nexport const Label = Schema.Union(\n  Schema.String,\n  Schema.mutable(\n    Schema.Tuple(\n      Schema.String,\n      Schema.mutable(\n        Schema.Struct({\n          ns: Schema.Union(Schema.String, Schema.Array(Schema.String)),\n          count: Schema.optional(Schema.Number),\n          defaultValue: Schema.optional(Schema.String),\n        }),\n      ),\n    ),\n  ),\n);\nexport type Label = Schema.Schema.Type<typeof Label>;\n","//\n// Copyright 2025 DXOS.org\n//\n\nimport { DXN } from '@dxos/keys';\n\nimport { Plugin } from '../core';\n\nexport const meta = Plugin.makeMeta({\n  key: DXN.make('org.dxos.plugin.processManager'),\n  name: 'Process Manager Plugin',\n  author: 'DXOS',\n  description:\n    'Hosts the process-manager runtime that composes contributed layer specs into a service resolver, exposes the operation invoker built on top of it, and registers undo/history tracking.',\n  tags: ['system'],\n});\n","//\n// Copyright 2025 DXOS.org\n//\n\nimport { ActivationEvents } from '../common';\nimport { Capability, Plugin } from '../core';\nimport { meta } from './meta';\n\nconst ProcessManagerCapability = Capability.lazy('ProcessManager', () => import('./process-manager-capability'));\nconst HistoryCapabilities = Capability.lazy('HistoryCapabilities', () => import('./history/capability'));\n\nexport const ProcessManagerPlugin = Plugin.define(meta).pipe(\n  Plugin.addModule({\n    activatesOn: ActivationEvents.Startup,\n    firesBeforeActivation: [ActivationEvents.SetupProcessManager],\n    firesAfterActivation: [ActivationEvents.ProcessManagerReady],\n    activate: ProcessManagerCapability,\n  }),\n  Plugin.addModule({\n    activatesOn: ActivationEvents.ProcessManagerReady,\n    activate: HistoryCapabilities,\n  }),\n  Plugin.make,\n);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAqBA,IAAM,oBAAoB,UAA0C;CAClE,IAAI,CAAC,MAAM,UAAU,QACnB,OAAO;CAET,MAAM,gBAAgB,MAAM,SAAS,MAAM,YAAY,QAAQ,YAAY,MAAM,aAAa,KAAK,MAAM,SAAS;CAClH,OAAO;EACL,SAAS;GACP,GAAG,MAAM;GAET,QAAQ,MAAM,UAAU,MAAM;EAChC;EACA,SAAS;CACX;AACF;;;;;;;;;;;;;AAcA,IAAa,6BAAb,MAA2E;CAK5C;CAH7B,iBAAyC,CAAC;CAC1C,iBAAwC,CAAC;CAEzC,YAAY,SAA0C;EAAzB,KAAA,UAAA;CAA0B;CAEvD,cAA4D;EAC1D,OAAO,OAAO,WAAW;GACvB,WAAW,KAAK,QAAQ,mBAAmB,QAAQ,QAAO,KAAA,GAAA;IAAA,YAAA;IAAA,GAAA;IAAA,GAAA;GAAA,CAAC,CAAC;GAC5D,QAAQ,UAAW,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,OAAO,KAAK,CAAC;EAC7E,CAAC,CAAC,CAAC,KACD,OAAO,KAAK,SAAS;GACnB,KAAK,iBAAiB,KAAK;GAC3B,MAAM,UAAU,KAAK,QAAQ,IAAI,gBAAgB,CAAC,CAAC,QAAQ,UAAgC,UAAU,IAAI;GACzG,KAAK,iBAAiB;GACtB,OAAO;EACT,CAAC,CACH;CACF;CAEA,aAAa,IAA6D;EACxE,MAAM,QAAQ,KAAK,eAAe,MAAM,cAAc,UAAU,QAAQ,QAAQ,EAAE;EAClF,IAAI,CAAC,OACH,OAAO,OAAO,qBAAK,IAAI,MAAM,gCAAgC,IAAI,CAAC;EAGpE,OAAO,OAAO,QAAQ,MAAM,QAAQ;CACtC;CAEA,UAAU,IAAY,SAAqD;EACzE,MAAM,SAAS,KAAK,eAAe,MAAM,cAAc,UAAU,QAAQ,QAAQ,EAAE;EACnF,IAAI,CAAC,QACH,OAAO,OAAO,qBAAK,IAAI,MAAM,gCAAgC,IAAI,CAAC;EAEpE,IAAI,WAAW,YAAY,OAAO,SAAS,SACzC,OAAO,OAAO,qBACZ,IAAI,MAAM,WAAW,QAAQ,qBAAqB,GAAG,SAAS,OAAO,SAAS,QAAQ,WAAW,CACnG;EAEF,OAAO,OAAO,QAAQ,MAAM;CAC9B;AACF;;;;;;;;;;;;ACtDA,IAAa,QAID,SAA8B;CAExC,IACE,OAAO,SAAS,YAChB,CAAC,0HAA0H,KACzH,IACF,GAEA,MAAM,IAAI,MACR,uBAAuB,KAAK,0FAC9B;CAEF,OAAO,EAAE,MAAM,KAAK;AACtB;;;;;;AC5CA,IAAa,QAAQ,OAAO,MAC1B,OAAO,QACP,OAAO,QACL,OAAO,MACL,OAAO,QACP,OAAO,QACL,OAAO,OAAO;CACZ,IAAI,OAAO,MAAM,OAAO,QAAQ,OAAO,MAAM,OAAO,MAAM,CAAC;CAC3D,OAAO,OAAO,SAAS,OAAO,MAAM;CACpC,cAAc,OAAO,SAAS,OAAO,MAAM;AAC7C,CAAC,CACH,CACF,CACF,CACF;;;ACfA,IAAa,OAAO,SAAgB;CAClC,KAAK,IAAI,KAAK,gCAAgC;CAC9C,MAAM;CACN,QAAQ;CACR,aACE;CACF,MAAM,CAAC,QAAQ;AACjB,CAAC;;;ACPD,IAAM,2BAA2B,KAAgB,wBAAwB,OAAO,yCAA+B;AAC/G,IAAM,sBAAsB,KAAgB,6BAA6B,OAAO,yBAAuB;AAEvG,IAAa,uBAAuB,OAAc,IAAI,CAAC,CAAC,KACtD,UAAiB;CACf,aAAa;CACb,uBAAuB,CAAC,mBAAoC;CAC5D,sBAAsB,CAAC,mBAAoC;CAC3D,UAAU;AACZ,CAAC,GACD,UAAiB;CACf,aAAa;CACb,UAAU;AACZ,CAAC,GACD,MACF"}

package/dist/lib/testing/react.mjs

@@ -0,0 +1,70 @@
+import { ReactContext } from "../common/capabilities.mjs";
+import { t as PluginManagerContext } from "../chunk-context.mjs";
+import { C as topologicalSort, b as PluginManagerProvider, o as SurfaceComponent, p as SurfaceManagerProvider, t as SurfaceManager } from "../chunk-SurfaceManager.mjs";
+import { Fragment, useMemo } from "react";
+import { Fragment as Fragment$1, jsx } from "react/jsx-runtime";
+import { RegistryContext } from "@effect-atom/atom-react";
+import { ContextProtocolProvider } from "@dxos/web-context-react";
+import { render as render$1 } from "@testing-library/react";
+//#region src/testing/react.tsx
+/**
+* Renders `ui` wrapped in the same provider tree as `useApp` plus every contributed
+* `Capabilities.ReactContext`.
+*/
+var render = (harness, ui, options) => {
+	const { reactContexts = [], ...rest } = options ?? {};
+	const Wrapper = ({ children }) => /* @__PURE__ */ jsx(HarnessProviders, {
+		harness,
+		extra: reactContexts,
+		children
+	});
+	return render$1(/* @__PURE__ */ jsx(Fragment$1, { children: ui }), {
+		...rest,
+		wrapper: Wrapper
+	});
+};
+/**
+* Renders a `Surface` with the given role token/data inside the harness provider tree.
+*/
+var renderSurface = (harness, props, options) => {
+	const { type, data, limit, fallback, placeholder } = props;
+	return render(harness, /* @__PURE__ */ jsx(SurfaceComponent, {
+		type,
+		data,
+		limit,
+		fallback,
+		placeholder
+	}), options);
+};
+var HarnessProviders = ({ harness, extra, children }) => {
+	const ContributedContext = composeContexts(harness.getAll(ReactContext));
+	const ExtraContext = composeExtra(extra);
+	const surfaces = useMemo(() => new SurfaceManager(harness.manager.capabilities), [harness]);
+	return /* @__PURE__ */ jsx(PluginManagerProvider, {
+		value: harness.manager,
+		children: /* @__PURE__ */ jsx(ContextProtocolProvider, {
+			value: harness.manager,
+			context: PluginManagerContext,
+			children: /* @__PURE__ */ jsx(RegistryContext.Provider, {
+				value: harness.registry,
+				children: /* @__PURE__ */ jsx(SurfaceManagerProvider, {
+					value: surfaces,
+					children: /* @__PURE__ */ jsx(ContributedContext, { children: /* @__PURE__ */ jsx(ExtraContext, { children }) })
+				})
+			})
+		})
+	});
+};
+var composeContexts = (contexts) => {
+	if (contexts.length === 0) return Passthrough;
+	return topologicalSort(contexts).map(({ context }) => context).reduce((Acc, Next) => ({ children }) => /* @__PURE__ */ jsx(Acc, { children: /* @__PURE__ */ jsx(Next, { children }) }));
+};
+var composeExtra = (contexts) => {
+	if (contexts.length === 0) return Passthrough;
+	return contexts.reduce((Acc, Next) => ({ children }) => /* @__PURE__ */ jsx(Next, { children: /* @__PURE__ */ jsx(Acc, { children }) }), Passthrough);
+};
+var Passthrough = ({ children }) => /* @__PURE__ */ jsx(Fragment, { children });
+//#endregion
+export { render, renderSurface };
+
+//# sourceMappingURL=react.mjs.map

package/dist/lib/testing/react.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.mjs","names":[],"sources":["../../../src/testing/react.tsx"],"sourcesContent":["//\n// Copyright 2026 DXOS.org\n//\n\nimport { RegistryContext } from '@effect-atom/atom-react';\nimport { type RenderOptions, type RenderResult, render as rtlRender } from '@testing-library/react';\nimport React, { type FC, Fragment, type PropsWithChildren, type ReactNode, useMemo } from 'react';\n\nimport { ContextProtocolProvider } from '@dxos/web-context-react';\n\nimport { Capabilities } from '../common';\nimport * as Role from '../common/Role';\nimport { PluginManagerContext } from '../context';\nimport { topologicalSort } from '../helpers';\nimport { PluginManagerProvider } from '../ui/components/PluginManager/PluginManagerProvider';\nimport { SurfaceComponent } from '../ui/components/Surface/SurfaceComponent';\nimport { SurfaceManager } from '../ui/components/Surface/SurfaceManager';\nimport { SurfaceManagerProvider } from '../ui/components/Surface/SurfaceManagerContext';\nimport { type TestHarness } from './harness';\n\nexport type HarnessRenderOptions = Omit<RenderOptions, 'wrapper'> & {\n  /** Additional providers to wrap around the harness tree (applied innermost first). */\n  reactContexts?: FC<PropsWithChildren>[];\n};\n\n/**\n * Renders `ui` wrapped in the same provider tree as `useApp` plus every contributed\n * `Capabilities.ReactContext`.\n */\nexport const render = (harness: TestHarness, ui: ReactNode, options?: HarnessRenderOptions): RenderResult => {\n  const { reactContexts = [], ...rest } = options ?? {};\n  const Wrapper = ({ children }: PropsWithChildren) => (\n    <HarnessProviders harness={harness} extra={reactContexts}>\n      {children}\n    </HarnessProviders>\n  );\n  return rtlRender(<>{ui}</>, { ...rest, wrapper: Wrapper });\n};\n\nexport type RenderSurfaceProps<TToken extends Role.Role<any>> = {\n  type: TToken;\n  data?: TToken extends Role.Role<infer D> ? D : never;\n  limit?: number;\n  fallback?: FC<{ error: Error; data?: any }>;\n  placeholder?: ReactNode;\n};\n\n/**\n * Renders a `Surface` with the given role token/data inside the harness provider tree.\n */\nexport const renderSurface = <TToken extends Role.Role<any>>(\n  harness: TestHarness,\n  props: RenderSurfaceProps<TToken>,\n  options?: HarnessRenderOptions,\n): RenderResult => {\n  const { type, data, limit, fallback, placeholder } = props;\n  return render(\n    harness,\n    <SurfaceComponent type={type} data={data as any} limit={limit} fallback={fallback} placeholder={placeholder} />,\n    options,\n  );\n};\n\ntype HarnessProvidersProps = PropsWithChildren<{\n  harness: TestHarness;\n  extra: FC<PropsWithChildren>[];\n}>;\n\nconst HarnessProviders = ({ harness, extra, children }: HarnessProvidersProps) => {\n  const contributed = harness.getAll(Capabilities.ReactContext);\n  const ContributedContext = composeContexts(contributed);\n  const ExtraContext = composeExtra(extra);\n  // Mirror useApp's provider stack (see SurfaceManager) so the unit-test render path matches the app.\n  const surfaces = useMemo(() => new SurfaceManager(harness.manager.capabilities), [harness]);\n  return (\n    <PluginManagerProvider value={harness.manager}>\n      <ContextProtocolProvider value={harness.manager} context={PluginManagerContext}>\n        <RegistryContext.Provider value={harness.registry}>\n          <SurfaceManagerProvider value={surfaces}>\n            <ContributedContext>\n              <ExtraContext>{children}</ExtraContext>\n            </ContributedContext>\n          </SurfaceManagerProvider>\n        </RegistryContext.Provider>\n      </ContextProtocolProvider>\n    </PluginManagerProvider>\n  );\n};\n\nconst composeContexts = (contexts: Capabilities.ReactContext[]): FC<PropsWithChildren> => {\n  if (contexts.length === 0) {\n    return Passthrough;\n  }\n  return topologicalSort(contexts)\n    .map(({ context }) => context)\n    .reduce((Acc, Next) => ({ children }: PropsWithChildren) => (\n      <Acc>\n        <Next>{children}</Next>\n      </Acc>\n    ));\n};\n\n// Composes in innermost-first order: the first context in the array wraps\n// `children` directly; subsequent contexts wrap the accumulator.\nconst composeExtra = (contexts: FC<PropsWithChildren>[]): FC<PropsWithChildren> => {\n  if (contexts.length === 0) {\n    return Passthrough;\n  }\n  return contexts.reduce<FC<PropsWithChildren>>(\n    (Acc, Next) =>\n      ({ children }: PropsWithChildren) => (\n        <Next>\n          <Acc>{children}</Acc>\n        </Next>\n      ),\n    Passthrough,\n  );\n};\n\nconst Passthrough: FC<PropsWithChildren> = ({ children }) => <Fragment>{children}</Fragment>;\n"],"mappings":";;;;;;;;;;;;;AA6BA,IAAa,UAAU,SAAsB,IAAe,YAAiD;CAC3G,MAAM,EAAE,gBAAgB,CAAC,GAAG,GAAG,SAAS,WAAW,CAAC;CACpD,MAAM,WAAW,EAAE,eACjB,oBAAC,kBAAD;EAA2B;EAAS,OAAO;EACxC;CACe,CAAA;CAEpB,OAAO,SAAU,oBAAA,YAAA,EAAA,UAAG,GAAK,CAAA,GAAG;EAAE,GAAG;EAAM,SAAS;CAAQ,CAAC;AAC3D;;;;AAaA,IAAa,iBACX,SACA,OACA,YACiB;CACjB,MAAM,EAAE,MAAM,MAAM,OAAO,UAAU,gBAAgB;CACrD,OAAO,OACL,SACA,oBAAC,kBAAD;EAAwB;EAAY;EAAoB;EAAiB;EAAuB;CAAc,CAAA,GAC9G,OACF;AACF;AAOA,IAAM,oBAAoB,EAAE,SAAS,OAAO,eAAsC;CAEhF,MAAM,qBAAqB,gBADP,QAAQ,OAAO,YACQ,CAAW;CACtD,MAAM,eAAe,aAAa,KAAK;CAEvC,MAAM,WAAW,cAAc,IAAI,eAAe,QAAQ,QAAQ,YAAY,GAAG,CAAC,OAAO,CAAC;CAC1F,OACE,oBAAC,uBAAD;EAAuB,OAAO,QAAQ;YACpC,oBAAC,yBAAD;GAAyB,OAAO,QAAQ;GAAS,SAAS;aACxD,oBAAC,gBAAgB,UAAjB;IAA0B,OAAO,QAAQ;cACvC,oBAAC,wBAAD;KAAwB,OAAO;eAC7B,oBAAC,oBAAD,EAAA,UACE,oBAAC,cAAD,EAAe,SAAuB,CAAA,EACpB,CAAA;IACE,CAAA;GACA,CAAA;EACH,CAAA;CACJ,CAAA;AAE3B;AAEA,IAAM,mBAAmB,aAAiE;CACxF,IAAI,SAAS,WAAW,GACtB,OAAO;CAET,OAAO,gBAAgB,QAAQ,CAAA,CAC5B,KAAK,EAAE,cAAc,OAAO,CAAA,CAC5B,QAAQ,KAAK,UAAU,EAAE,eACxB,oBAAC,KAAD,EAAA,UACE,oBAAC,MAAD,EAAO,SAAe,CAAA,EACnB,CAAA,CACN;AACL;AAIA,IAAM,gBAAgB,aAA6D;CACjF,IAAI,SAAS,WAAW,GACtB,OAAO;CAET,OAAO,SAAS,QACb,KAAK,UACH,EAAE,eACD,oBAAC,MAAD,EAAA,UACE,oBAAC,KAAD,EAAM,SAAc,CAAA,EAChB,CAAA,GAEV,WACF;AACF;AAEA,IAAM,eAAsC,EAAE,eAAe,oBAAC,UAAD,EAAW,SAAmB,CAAA"}