@dxos/app-framework 0.14.0 → 0.16.0

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

@@ -1,126 +1 @@
-import { t as __exportAll } from "../chunk-rolldown-runtime.mjs";
-import * as Effect from "effect/Effect";
-import { BaseError } from "@dxos/errors";
-import * as Schema from "effect/Schema";
-import { PLUGIN_ENTRY_FILENAME, PluginManifestSchema } from "@dxos/protocols";
-import * as FetchHttpClient from "effect/http/FetchHttpClient";
-import * as HttpClient from "effect/http/HttpClient";
-import * as HttpClientRequest from "effect/http/HttpClientRequest";
-import * as HttpClientResponse from "effect/http/HttpClientResponse";
-import * as Struct from "effect/Struct";
-//#region src/core/plugin-manifest.ts
-var plugin_manifest_exports = /* @__PURE__ */ __exportAll({
-	DEV_SERVER_PORT: () => DEV_SERVER_PORT,
-	Manifest: () => Manifest,
-	PluginManifestError: () => PluginManifestError,
-	fetchManifest: () => fetchManifest,
-	parse: () => parse
-});
-/**
-* Default port the Vite plugin (`composerPlugin`) binds the dev server to.
-*
-* Shared single source of truth — `composerPlugin` reads it as the default
-* port, and the host's "Load Dev Plugin" affordance pre-fills the manifest URL
-* with `http://localhost:${DEV_SERVER_PORT}/manifest.json`. Lives in
-* app-framework rather than `@dxos/protocols` because the constant is a
-* client-side convention (host loader + Vite plugin) rather than a wire-level
-* protocol.
-*/
-var DEV_SERVER_PORT = 3967;
-/**
-* Tagged error for manifest fetch / parse failures. Construction sites set
-* `context.manifestUrl` and `context.reason` (one of `'fetch-failed' |
-* 'http-error' | 'parse-failed' | 'invalid'`) so handlers can route on the
-* specific failure mode.
-*/
-var PluginManifestError = class extends BaseError.extend("PluginManifestError", "Plugin manifest is invalid") {};
-/**
-* Schema for a third-party plugin manifest.
-*
-* Production manifests are published as a sibling of the plugin's entry module
-* ({@link PLUGIN_ENTRY_FILENAME}) and advertise every file the plugin needs at
-* runtime so the host can eagerly cache them for offline use.
-*
-* Dev manifests (served by `vite dev` via {@link composerPlugin}) set `devEntry`
-* to point at the unbundled source entry. The host's loader treats the presence
-* of `devEntry` as the dev-mode signal: it imports the entry directly from the
-* dev server, skips eager asset caching, and skips static stylesheet injection
-* (Vite handles CSS via runtime `<style>` injection during HMR). `assets` is not
-* required to enumerate every file in dev mode — chunks and styles flow through
-* the dev server on demand.
-*/
-var Manifest = Schema.Struct({
-	...PluginManifestSchema.mapFields((fields) => Struct.omit(fields, ["assets"])).fields,
-	/**
-	* Relative asset paths. Relaxed vs the build `PluginManifestSchema` (which requires >= 1) because
-	* dev-server manifests list no assets — chunks/styles flow through the dev server on demand.
-	*/
-	assets: Schema.Array(Schema.String),
-	/** Present only for dev-server manifests; points at the unbundled source entry. */
-	devEntry: Schema.optional(Schema.String)
-});
-/**
-* Resolves a parsed manifest's relative asset paths against the manifest's URL.
-* In dev mode the entry comes from `devEntry`; otherwise it's the canonical
-* {@link PLUGIN_ENTRY_FILENAME} sitting next to the manifest.
-*/
-var resolve = (manifestUrl, manifest) => {
-	const dev = manifest.devEntry !== void 0;
-	return {
-		key: manifest.key,
-		name: manifest.name,
-		version: manifest.version,
-		entryUrl: new URL(dev ? manifest.devEntry : PLUGIN_ENTRY_FILENAME, manifestUrl).toString(),
-		assetUrls: manifest.assets.map((asset) => new URL(asset, manifestUrl).toString()),
-		dev,
-		...manifest.dependencies !== void 0 ? { dependencies: manifest.dependencies } : {}
-	};
-};
-/**
-* Synchronous decode + validate + resolve for an in-memory manifest payload. Used
-* by tests and tooling that have the manifest body already loaded; the runtime
-* path goes through {@link fetchManifest}.
-*/
-var parse = (manifestUrl, payload) => {
-	const manifest = Schema.decodeUnknownSync(Manifest)(payload);
-	if (manifest.devEntry === void 0 && !manifest.assets.includes(PLUGIN_ENTRY_FILENAME)) throw new Error(`Manifest at ${manifestUrl} does not list ${PLUGIN_ENTRY_FILENAME} in assets.`);
-	return resolve(manifestUrl, manifest);
-};
-/**
-* Fetches and parses a manifest from the given URL via Effect's HTTP client and
-* Schema-driven JSON decoding. All failure modes surface as a single tagged
-* {@link PluginManifestError}; callers route on `error.context.reason`.
-*/
-var fetchManifest = (manifestUrl) => Effect.gen(function* () {
-	const response = yield* HttpClientRequest.get(manifestUrl).pipe(HttpClient.execute, Effect.mapError((cause) => new PluginManifestError({
-		context: {
-			manifestUrl,
-			reason: "fetch-failed"
-		},
-		cause
-	})));
-	if (response.status >= 400) return yield* Effect.fail(new PluginManifestError({ context: {
-		manifestUrl,
-		reason: "http-error",
-		status: response.status
-	} }));
-	const manifest = yield* HttpClientResponse.schemaBodyJson(Manifest)(response).pipe(Effect.mapError((cause) => new PluginManifestError({
-		context: {
-			manifestUrl,
-			reason: "parse-failed"
-		},
-		cause
-	})));
-	if (manifest.devEntry === void 0 && !manifest.assets.includes(PLUGIN_ENTRY_FILENAME)) return yield* Effect.fail(new PluginManifestError({
-		context: {
-			manifestUrl,
-			reason: "invalid"
-		},
-		cause: `assets does not include ${PLUGIN_ENTRY_FILENAME}`
-	}));
-	return resolve(manifestUrl, manifest);
-}).pipe(Effect.scoped, Effect.provide(FetchHttpClient.layer));
-//#endregion
-export { DEV_SERVER_PORT, Manifest, PluginManifestError, fetchManifest, parse, plugin_manifest_exports as t };
-
-//# sourceMappingURL=plugin-manifest.mjs.map
+export { t as DEV_SERVER_PORT, n as Manifest, r as PluginManifestError, i as fetchManifest, a as parse } from "../chunk-plugin-manifest.mjs";

package/dist/lib/core/plugin.mjs

@@ -1,354 +1 @@
-import { t as __exportAll } from "../chunk-rolldown-runtime.mjs";
-import { Idle } from "./activation-event.mjs";
-import { h as getModuleTag, i as ModuleTag } from "../chunk-capability.mjs";
-import * as Effect from "effect/Effect";
-import * as Option from "effect/Option";
-import { DXN } from "@dxos/keys";
-import * as Context from "effect/Context";
-import { BaseError } from "@dxos/errors";
-import * as Pipeable from "effect/Pipeable";
-import * as Schema from "effect/Schema";
-import { invariant } from "@dxos/invariant";
-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.Service()("@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;
-	activation;
-	activate;
-	constructor(options) {
-		this.id = options.id;
-		this.activation = options.activation;
-		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(moduleOrOptionsOrBuilder, moduleOptions) {
-	if (moduleOrOptionsOrBuilder === void 0) return (builder) => builder;
-	if (typeof moduleOrOptionsOrBuilder === "function" && ModuleTag in moduleOrOptionsOrBuilder) {
-		const module = moduleOrOptionsOrBuilder;
-		const { id } = moduleOptions ?? {};
-		return (builder) => builder.addModule((pluginOptions) => ({
-			id: id ?? getModuleTag(module),
-			activatesOn: module.activatesOn,
-			requires: module.requires,
-			provides: module.provides,
-			activate: () => module(pluginOptions)
-		}));
-	}
-	if (moduleOptions !== void 0) return moduleOrOptionsOrBuilder.addModule(moduleOptions);
-	const moduleOpts = moduleOrOptionsOrBuilder;
-	return (builder) => builder.addModule(moduleOpts);
-}
-/**
-* Normalizes an authoring record to an {@link ActivationSpec} — the single boundary where the
-* optional authoring shape becomes the concrete runtime shape.
-*
-* Omitting `activatesOn` means the module belongs to the IDLE wave: a module that must run at
-* boot states `activatesOn: ActivationEvents.Startup` explicitly. Inverted from a startup default
-* so that forgetting the annotation costs post-paint responsiveness rather than time-to-
-* interactive — startup was the dumping ground, and its cost becomes the transitive demand
-* closure of the boot path, enforced by the capability graph instead of by remembering to
-* annotate. Un-annotated modules stay pullable as providers because the baseline wave is
-* `Startup u Idle`; see `ActivationScheduler.#isBaselineWave`, which moves with this default.
-*/
-var normalizeActivation = (options) => ({
-	activatesOn: options.activatesOn ?? Idle,
-	requires: options.requires ?? [],
-	provides: options.provides ?? []
-});
-/**
-* Resolves a module from either a module entry or a function that returns one.
-*/
-var resolveModule = (meta, module, options) => {
-	const moduleOptions = typeof module === "function" ? module(options) : module;
-	const pluginName = meta.profile.key;
-	return new PluginModuleImpl({
-		id: Option.fromNullishOr(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: 485,
-					S: void 0,
-					A: ["exportName", "`Plugin module missing name. Plugin: ${meta.profile.key}`"]
-				});
-				return computeModuleId(pluginName, exportName);
-			},
-			onSome: (id) => computeModuleId(pluginName, id)
-		})),
-		activation: normalizeActivation(moduleOptions),
-		activate: moduleOptions.activate
-	});
-};
-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: 513,
-		S: this,
-		A: ["!meta.profile.dependsOn?.includes(meta.profile.key)", "`Plugin ${meta.profile.key} declares itself as a dependency.`"]
-	});
-	const factory = (options) => {
-		const resolved = options ?? {};
-		const modules = builder.modules.map((module) => resolveModule(meta, module, resolved));
-		const ids = /* @__PURE__ */ new Set();
-		for (const module of modules) {
-			invariant(!ids.has(module.id), `Duplicate module id ${module.id} in plugin ${meta.profile.key}.`, {
-				"~LogMeta": "~LogMeta",
-				F: __dxlog_file,
-				L: 526,
-				S: this,
-				A: ["!ids.has(module.id)", "`Duplicate module id ${module.id} in plugin ${meta.profile.key}.`"]
-			});
-			ids.add(module.id);
-		}
-		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");
-function 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
+export { t as LazyPluginError, n as Meta, r as PluginDependencyError, i as PluginModuleTypeId, a as PluginTypeId, o as Profile, s as Release, c as Service, l as activate, u as addModule, d as define, f as getMetaFromConfig, p as getURI, m as isLazy, h as isPlugin, g as isPluginModule, _ as lazy, v as make, y as makeMeta, x as reset, S as resolveLazy, C as shutdown } from "../chunk-plugin.mjs";

package/dist/lib/core/registry.mjs

@@ -1,2 +1 @@
-import { r as EdgeRegistryPluginProvider, t as Manager } from "../chunk-registry.mjs";
-export { EdgeRegistryPluginProvider as EdgePluginProvider, Manager };
+export { r as EdgePluginProvider, t as Manager } from "../chunk-registry.mjs";