@ekrooh/bare 0.1.0

package/dist/index.mjs

@@ -0,0 +1,512 @@
+import { TextDecoder as TextDecoder$1, TextEncoder as TextEncoder$1 } from "bare-encoding";
+//#region core/messages/constants.ts
+const VERSION = 1;
+const MessageType = { ENVELOPE: 1 };
+/** Canonical error codes. Everything the framework throws uses these; peers
+* may carry arbitrary codes over the wire, and consumers may return app-scoped
+* codes (e.g. `app.photos/not-found`) which are preserved verbatim. Keep
+* `android/src/main/.../ErrorCodes.kt` in sync with the canonical union. */
+const ErrorCode = {
+	UNSUPPORTED_CAPABILITY: "UNSUPPORTED_CAPABILITY",
+	UNSUPPORTED_EVENT: "UNSUPPORTED_EVENT",
+	HOST_ERROR: "HOST_ERROR",
+	TRANSPORT_ERROR: "TRANSPORT_ERROR",
+	PLUGIN_ERROR: "PLUGIN_ERROR",
+	INVALID_RESPONSE: "INVALID_RESPONSE",
+	FRAME_TOO_LARGE: "FRAME_TOO_LARGE",
+	FRAME_INVALID: "FRAME_INVALID",
+	TIMEOUT: "TIMEOUT"
+};
+/** A JSON header must fit a 16-bit big-endian length field. */
+const MAX_HEADER_BYTES = 65535;
+/** Upper bound on one encoded frame. Large binary transfers are a plugin-level
+* concern (out-of-band handles), not an in-band payload. */
+const MAX_FRAME_BYTES = 16777216;
+//#endregion
+//#region core/messages/types.ts
+var CoreError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.name = "CoreError";
+		this.code = code;
+	}
+};
+//#endregion
+//#region core/messages/errors.ts
+/** Success half of an `Either` tuple. */
+function ok(result) {
+	return [null, result];
+}
+/** Failure half of an `Either` tuple. Accepts a canonical error code or any
+* app-scoped code (`app.photos/not-found`) — the code is preserved verbatim. */
+function err(code, message) {
+	return [new CoreError(code, message), null];
+}
+/** Convenience for constructing a `CoreError` from a possibly-non-canonical
+* wire code: preserves known codes, maps anything else to `PLUGIN_ERROR`.
+* Framework callers that want app codes preserved construct the error
+* directly instead. */
+function coerceErrorCode(code) {
+	if (code && code in ErrorCode) return code;
+	return ErrorCode.PLUGIN_ERROR;
+}
+//#endregion
+//#region core/messages/plugin-kernel.ts
+function createPluginRegistry() {
+	const plugins = /* @__PURE__ */ new Map();
+	return {
+		register(plugin) {
+			if (!plugin.id.includes(".")) throw new Error(`plugin id must be namespaced (example: "vendor.plugin"), got "${plugin.id}"`);
+			if (plugins.has(plugin.id)) throw new Error(`plugin id "${plugin.id}" is already registered`);
+			plugins.set(plugin.id, plugin);
+		},
+		resolve(pluginId, runtime) {
+			return plugins.get(pluginId)?.runtimes[runtime];
+		},
+		get(pluginId) {
+			return plugins.get(pluginId);
+		},
+		listCapabilities(runtime) {
+			const rows = [];
+			for (const plugin of plugins.values()) {
+				const runtimes = Object.keys(plugin.runtimes);
+				if (runtime && !runtimes.includes(runtime)) continue;
+				rows.push({
+					pluginId: plugin.id,
+					capabilities: plugin.capabilities ?? [],
+					events: plugin.events ?? [],
+					runtimes
+				});
+			}
+			return rows;
+		}
+	};
+}
+/** Whether the router may synthesize an UNSUPPORTED_EVENT response. Events are
+* only gated when the manifest declares them; undeclared plugins opt out of
+* validation for backward compatibility. */
+function declaresEvent(plugin, event) {
+	return plugin?.events ? plugin.events.includes(event) : true;
+}
+function createPluginRouter(registry, runtime, options) {
+	const logger = options?.logger ?? console;
+	return { async route(header, payload) {
+		const plugin = isPluginEnvelopeHeader(header) ? registry.get(header.pluginId) : void 0;
+		if (isPluginEnvelopeHeader(header)) {
+			if (!declaresEvent(plugin, header.event)) {
+				const error = new CoreError(ErrorCode.UNSUPPORTED_EVENT, `Unsupported event ${header.pluginId}.${header.event} on ${runtime}`);
+				if (isPluginDispatchHeader(header)) logger.warn(error.message);
+				return invokeErrorResponse(header, error);
+			}
+		}
+		if (isPluginDispatchHeader(header)) {
+			const runtimeAdapter = registry.resolve(header.pluginId, runtime);
+			if (!runtimeAdapter?.dispatch) {
+				const error = new CoreError(ErrorCode.UNSUPPORTED_CAPABILITY, `Unsupported capability ${header.pluginId}.${header.event} on ${runtime}`);
+				logger.warn(error.message);
+				return invokeErrorResponse(header, error);
+			}
+			try {
+				await runtimeAdapter.dispatch(header.event, header.args, {
+					runtime,
+					payload
+				});
+				return null;
+			} catch (e) {
+				const error = new CoreError(ErrorCode.PLUGIN_ERROR, e instanceof Error ? e.message : String(e));
+				logger.error(`dispatch ${header.pluginId}.${header.event} failed: ${error.message}`);
+				return invokeErrorResponse(header, error);
+			}
+		}
+		if (isPluginInvokeRequestHeader(header)) {
+			const runtimeAdapter = registry.resolve(header.pluginId, runtime);
+			if (runtimeAdapter?.invoke) try {
+				const [error, okResult] = await runtimeAdapter.invoke(header.event, header.args, {
+					runtime,
+					payload
+				});
+				return {
+					type: "INVOKE_RESPONSE",
+					pluginId: header.pluginId,
+					event: header.event,
+					requestId: header.requestId,
+					result: okResult ?? void 0,
+					error: error ? {
+						code: error.code,
+						message: error.message
+					} : void 0
+				};
+			} catch (e) {
+				const error = new CoreError(ErrorCode.PLUGIN_ERROR, e instanceof Error ? e.message : String(e));
+				logger.error(`invoke ${header.pluginId}.${header.event} failed: ${error.message}`);
+				return invokeErrorResponse(header, error);
+			}
+			if (header.requestId && options?.delegateToHost) try {
+				const delegated = await options.delegateToHost(header, payload);
+				if (delegated) return delegated;
+			} catch (e) {
+				return invokeErrorResponse(header, new CoreError(ErrorCode.HOST_ERROR, e instanceof Error ? e.message : String(e)));
+			}
+			return invokeErrorResponse(header, new CoreError(ErrorCode.UNSUPPORTED_CAPABILITY, `Unsupported capability ${header.pluginId}.${header.event} on ${runtime}`));
+		}
+		return null;
+	} };
+}
+function createPluginBus(messenger) {
+	return {
+		dispatch(envelope) {
+			return messenger.dispatch({
+				type: "DISPATCH",
+				pluginId: envelope.pluginId,
+				event: envelope.event,
+				args: envelope.args
+			});
+		},
+		async invoke(envelope) {
+			const response = await messenger.invoke({
+				type: "INVOKE_REQUEST",
+				pluginId: envelope.pluginId,
+				event: envelope.event,
+				args: envelope.args
+			}, envelope.payload ?? null, envelope.timeoutMs);
+			if (isPluginInvokeResponseHeader(response)) {
+				if (response.error) return [new CoreError(response.error.code, String(response.error.message ?? "Plugin invoke failed")), null];
+				return [null, response.result];
+			}
+			return [new CoreError(ErrorCode.INVALID_RESPONSE, `Unexpected response type ${response.type}`), null];
+		}
+	};
+}
+function invokeErrorResponse(header, error) {
+	return {
+		type: "INVOKE_RESPONSE",
+		pluginId: header.pluginId,
+		event: header.event,
+		requestId: header.requestId,
+		error: {
+			code: error.code,
+			message: error.message
+		}
+	};
+}
+function isPluginDispatchHeader(header) {
+	return header.type === "DISPATCH" && typeof header.pluginId === "string" && typeof header.event === "string";
+}
+function isPluginEnvelopeHeader(header) {
+	return isPluginDispatchHeader(header) || isPluginInvokeRequestHeader(header);
+}
+function isPluginInvokeRequestHeader(header) {
+	return header.type === "INVOKE_REQUEST" && typeof header.pluginId === "string" && typeof header.event === "string";
+}
+function isPluginInvokeResponseHeader(header) {
+	return header.type === "INVOKE_RESPONSE" && typeof header.pluginId === "string" && typeof header.event === "string";
+}
+//#endregion
+//#region core/messages/rpc-messenger.ts
+function createProtocolMessenger(send) {
+	const pending = /* @__PURE__ */ new Map();
+	return {
+		dispatch(request, payload) {
+			const requestWithId = withRequestId(request);
+			send(requestWithId, payload);
+			return requestWithId.requestId;
+		},
+		invoke(request, payload, timeoutMs = 5e3) {
+			const requestWithId = withRequestId(request);
+			const { requestId } = requestWithId;
+			return new Promise((resolvePromise, rejectPromise) => {
+				const timer = setTimeout(() => {
+					pending.delete(requestId);
+					rejectPromise(/* @__PURE__ */ new Error(`invoke timeout for ${request.type} (${requestId})`));
+				}, timeoutMs);
+				pending.set(requestId, {
+					resolve: resolvePromise,
+					reject: rejectPromise,
+					timer
+				});
+				send(requestWithId, payload);
+			});
+		},
+		handleIncoming(header) {
+			if (!header.requestId) return;
+			const pendingCall = pending.get(header.requestId);
+			if (!pendingCall) return;
+			clearTimeout(pendingCall.timer);
+			pending.delete(header.requestId);
+			pendingCall.resolve(header);
+		}
+	};
+}
+function createRequestId() {
+	return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function withRequestId(request) {
+	return {
+		...request,
+		requestId: createRequestId()
+	};
+}
+//#endregion
+//#region core/messages/wire-codec.ts
+var MessageProtocol = class {
+	encodeStr;
+	decodeStr;
+	allowUnknownTypes;
+	maxFrameBytes;
+	constructor(options) {
+		this.encodeStr = options?.encode || ((str) => new TextEncoder().encode(str));
+		this.decodeStr = options?.decode || ((bytes) => new TextDecoder().decode(bytes));
+		this.allowUnknownTypes = options?.allowUnknownTypes ?? false;
+		this.maxFrameBytes = options?.maxFrameBytes ?? 16777216;
+	}
+	encode(type, header, payload) {
+		const headerJson = JSON.stringify(header);
+		const headerBytes = this.encodeStr(headerJson);
+		if (headerBytes.byteLength > 65535) throw new Error(`Header too large: ${headerBytes.byteLength} bytes, maximum is ${MAX_HEADER_BYTES}`);
+		let payloadBytes;
+		if (payload == null) payloadBytes = /* @__PURE__ */ new Uint8Array(0);
+		else if (typeof payload === "string") payloadBytes = this.encodeStr(payload);
+		else if (payload instanceof ArrayBuffer) payloadBytes = new Uint8Array(payload);
+		else payloadBytes = payload;
+		const hLen = headerBytes.byteLength;
+		const pLen = payloadBytes.byteLength;
+		const totalLength = 4 + hLen + pLen;
+		if (totalLength > this.maxFrameBytes) throw new Error(`Frame too large: ${totalLength} bytes, maximum is ${this.maxFrameBytes}`);
+		let buffer;
+		if (typeof Buffer !== "undefined" && typeof Buffer.allocUnsafe === "function") buffer = Buffer.allocUnsafe(totalLength);
+		else buffer = new Uint8Array(totalLength);
+		buffer[0] = 1;
+		buffer[1] = type;
+		buffer[2] = hLen >> 8 & 255;
+		buffer[3] = hLen & 255;
+		buffer.set(headerBytes, 4);
+		if (pLen > 0) buffer.set(payloadBytes, 4 + hLen);
+		return buffer;
+	}
+	decode(data) {
+		const view = data instanceof Uint8Array ? data : new Uint8Array(data);
+		const byteLength = view.byteLength;
+		if (byteLength < 4) throw new Error(`Message too short: ${byteLength} bytes`);
+		if (byteLength > this.maxFrameBytes) throw new Error(`Frame too large: ${byteLength} bytes, maximum is ${this.maxFrameBytes}`);
+		const version = view[0];
+		if (version !== 1) throw new Error(`Unsupported version: ${version}. Expected 1`);
+		const type = view[1];
+		if (!this.allowUnknownTypes && !isKnownMessageType(type)) throw new Error(`Unsupported message type: ${type}`);
+		const headerLen = view[2] << 8 | view[3];
+		if (byteLength < 4 + headerLen) throw new Error(`Message too short for header: ${byteLength} bytes, expected at least ${4 + headerLen}`);
+		return {
+			type,
+			header: parseAndValidateHeader(this.decodeStr(view.subarray(4, 4 + headerLen))),
+			payload: view.subarray(4 + headerLen)
+		};
+	}
+};
+function isKnownMessageType(type) {
+	return Object.values(MessageType).includes(type);
+}
+function parseAndValidateHeader(headerJson) {
+	const parsed = JSON.parse(headerJson);
+	if (!parsed || typeof parsed !== "object") throw new Error("Invalid header: expected object");
+	const header = parsed;
+	switch (header.type) {
+		case "DISPATCH":
+			if (isValidPluginHeaderFields(header)) return mergeHeader(header, {
+				type: "DISPATCH",
+				pluginId: header.pluginId,
+				event: header.event,
+				requestId: asOptionalString(header.requestId),
+				args: asOptionalRecord(header.args)
+			});
+			break;
+		case "INVOKE_REQUEST":
+			if (isValidPluginHeaderFields(header)) return mergeHeader(header, {
+				type: "INVOKE_REQUEST",
+				pluginId: header.pluginId,
+				event: header.event,
+				requestId: asOptionalString(header.requestId),
+				args: asOptionalRecord(header.args)
+			});
+			break;
+		case "INVOKE_RESPONSE":
+			if (isValidPluginHeaderFields(header)) return mergeHeader(header, {
+				type: "INVOKE_RESPONSE",
+				pluginId: header.pluginId,
+				event: header.event,
+				requestId: asOptionalString(header.requestId),
+				result: header.result,
+				error: parseCoreErrorWire(header.error)
+			});
+			break;
+		case "HOST_CAPABILITIES_QUERY":
+			if (typeof header.requestId === "string") return mergeHeader(header, {
+				type: "HOST_CAPABILITIES_QUERY",
+				requestId: header.requestId
+			});
+			break;
+		case "HOST_CAPABILITIES_RESPONSE":
+			if (typeof header.requestId === "string") return mergeHeader(header, {
+				type: "HOST_CAPABILITIES_RESPONSE",
+				requestId: header.requestId,
+				capabilities: parseCapabilityDescriptors(header.capabilities)
+			});
+			break;
+		case "HOST_INVOKE_REQUEST":
+			if (typeof header.requestId === "string" && typeof header.pluginId === "string" && typeof header.event === "string") return mergeHeader(header, {
+				type: "HOST_INVOKE_REQUEST",
+				requestId: header.requestId,
+				pluginId: header.pluginId,
+				event: header.event,
+				args: asOptionalRecord(header.args)
+			});
+			break;
+		case "HOST_INVOKE_RESPONSE": if (typeof header.requestId === "string" && typeof header.pluginId === "string" && typeof header.event === "string") return mergeHeader(header, {
+			type: "HOST_INVOKE_RESPONSE",
+			requestId: header.requestId,
+			pluginId: header.pluginId,
+			event: header.event,
+			result: header.result,
+			error: parseCoreErrorWire(header.error)
+		});
+	}
+	throw new Error(`Unsupported header type: ${String(header.type)}`);
+}
+/** Validated known fields win, unknown fields pass through untouched so
+* forward-compatible peers can relay envelopes without losing data. */
+function mergeHeader(parsed, known) {
+	return {
+		...parsed,
+		...known
+	};
+}
+function isValidPluginHeaderFields(header) {
+	return typeof header.pluginId === "string" && typeof header.event === "string";
+}
+function asOptionalString(value) {
+	return typeof value === "string" ? value : void 0;
+}
+function asOptionalRecord(value) {
+	return value && typeof value === "object" ? value : void 0;
+}
+function parseCoreErrorWire(value) {
+	if (!value || typeof value !== "object") return void 0;
+	const candidate = value;
+	if (typeof candidate.code !== "string" || typeof candidate.message !== "string") return void 0;
+	return {
+		code: candidate.code,
+		message: candidate.message
+	};
+}
+const RUNTIME_TARGETS = /* @__PURE__ */ new Set([
+	"web",
+	"android",
+	"ios",
+	"bare"
+]);
+function parseRuntimeTarget(value) {
+	if (typeof value !== "string") return null;
+	return RUNTIME_TARGETS.has(value) ? value : null;
+}
+function parseCapabilityDescriptors(value) {
+	if (!Array.isArray(value)) return [];
+	const out = [];
+	for (const row of value) {
+		if (!row || typeof row !== "object") continue;
+		const r = row;
+		if (typeof r.pluginId !== "string") continue;
+		const events = Array.isArray(r.events) ? r.events.filter((e) => typeof e === "string") : [];
+		const caps = Array.isArray(r.capabilities) ? r.capabilities.filter((c) => typeof c === "string") : [];
+		const runtimes = [];
+		if (Array.isArray(r.runtimes)) for (const rt of r.runtimes) {
+			const parsed = parseRuntimeTarget(rt);
+			if (parsed) runtimes.push(parsed);
+		}
+		out.push({
+			pluginId: r.pluginId,
+			capabilities: caps,
+			events,
+			runtimes
+		});
+	}
+	return out;
+}
+//#endregion
+//#region core/messages/define-plugin.ts
+/**
+* Builds a {@link PluginManifest} from an event spec table. The `events` list
+* is derived from the specs and handlers are dispatched by event name — no
+* hand-written if-chains. Handlers receive typed args. Plugins with no local
+* handlers (host-delegated, e.g. `core.permissions`) pass no `invoke`/`dispatch`.
+*/
+function definePlugin(id, specs, options = {}) {
+	const invokeByEvent = /* @__PURE__ */ new Map();
+	const dispatchByEvent = /* @__PURE__ */ new Map();
+	const events = [];
+	for (const key of Object.keys(specs)) {
+		const spec = specs[key];
+		if (spec.pluginId !== id) throw new Error(`event spec ${spec.name} belongs to ${spec.pluginId}, not ${id}`);
+		events.push(spec.name);
+		const invoker = options.invoke?.[key];
+		if (invoker) invokeByEvent.set(spec.name, invoker);
+		const dispatcher = options.dispatch?.[key];
+		if (dispatcher) dispatchByEvent.set(spec.name, dispatcher);
+	}
+	const adapter = {};
+	if (invokeByEvent.size > 0) adapter.invoke = (event, args, context) => {
+		const handler = invokeByEvent.get(event);
+		if (!handler) throw new Error(`Unhandled invoke event ${event}`);
+		return handler(args, context);
+	};
+	if (dispatchByEvent.size > 0) adapter.dispatch = (event, args, context) => {
+		const handler = dispatchByEvent.get(event);
+		if (!handler) throw new Error(`Unhandled dispatch event ${event}`);
+		return handler(args, context);
+	};
+	const runtimes = {};
+	if (invokeByEvent.size > 0 || dispatchByEvent.size > 0) runtimes.bare = adapter;
+	return {
+		id,
+		capabilities: options.capabilities,
+		events,
+		runtimes
+	};
+}
+/** Typed builder: an invoke envelope for a spec's event. */
+function invokeEvent(spec, args, payload, timeoutMs) {
+	return {
+		kind: "invoke",
+		pluginId: spec.pluginId,
+		event: spec.name,
+		args,
+		payload,
+		timeoutMs
+	};
+}
+/** Typed builder: a dispatch envelope for a spec's event. */
+function dispatchEvent(spec, args, payload) {
+	return {
+		kind: "dispatch",
+		pluginId: spec.pluginId,
+		event: spec.name,
+		args,
+		payload
+	};
+}
+//#endregion
+//#region core/messages/create-bare-runtime-context.ts
+function createBareRuntimeContext(plugins = [], routerOptions) {
+	const runtime = "bare";
+	const protocol = new MessageProtocol({
+		encode: (str) => new TextEncoder$1().encode(str),
+		decode: (bytes) => new TextDecoder$1().decode(bytes)
+	});
+	const pluginRegistry = createPluginRegistry();
+	for (const plugin of plugins) pluginRegistry.register(plugin);
+	return {
+		protocol,
+		pluginRegistry,
+		pluginRouter: createPluginRouter(pluginRegistry, runtime, routerOptions)
+	};
+}
+//#endregion
+export { CoreError, ErrorCode, MAX_FRAME_BYTES, MAX_HEADER_BYTES, MessageProtocol, MessageType, VERSION, coerceErrorCode, createBareRuntimeContext, createPluginBus, createPluginRegistry, createPluginRouter, createProtocolMessenger, definePlugin, dispatchEvent, err, invokeEvent, ok };

package/dist/plugins-1KweEBct.mjs

@@ -0,0 +1,125 @@
+import { ErrorCode, definePlugin, err, ok } from "./index.mjs";
+import { discoverySpecs } from "./plugins-discovery-events.mjs";
+import { healthSpecs } from "./plugins-health-events.mjs";
+import { mediaSpecs } from "./plugins-media-events.mjs";
+import { permissionSpecs } from "./plugins-permissions-events.mjs";
+//#region plugins/discovery/plugin.ts
+function mergeCapabilityRows(a, b) {
+	const map = /* @__PURE__ */ new Map();
+	for (const row of [...a, ...b]) {
+		const existing = map.get(row.pluginId);
+		if (!existing) map.set(row.pluginId, {
+			pluginId: row.pluginId,
+			capabilities: [...row.capabilities],
+			events: [...row.events],
+			runtimes: [...row.runtimes]
+		});
+		else {
+			const ev = /* @__PURE__ */ new Set([...existing.events, ...row.events]);
+			const rt = /* @__PURE__ */ new Set([...existing.runtimes, ...row.runtimes]);
+			const caps = /* @__PURE__ */ new Set([...existing.capabilities, ...row.capabilities]);
+			map.set(row.pluginId, {
+				pluginId: row.pluginId,
+				capabilities: [...caps],
+				events: [...ev],
+				runtimes: [...rt]
+			});
+		}
+	}
+	return [...map.values()];
+}
+function createDiscoveryPlugin(deps) {
+	return definePlugin("core.discovery", discoverySpecs, {
+		capabilities: ["discovery"],
+		invoke: { list: async () => {
+			const merged = mergeCapabilityRows(deps.listBareCapabilities(), await deps.queryHostCapabilities());
+			return ok({
+				schemaVersion: 1,
+				capabilities: merged
+			});
+		} }
+	});
+}
+//#endregion
+//#region plugins/health/plugin.ts
+function createHealthPlugin() {
+	return definePlugin("core.health", healthSpecs, {
+		capabilities: ["health"],
+		invoke: {
+			ping: (args) => ok({
+				message: args?.message ?? "pong",
+				ts: Date.now()
+			}),
+			payloadEcho: (args, context) => ok({
+				label: args?.label ?? "payload",
+				payloadSize: context.payload.byteLength
+			}),
+			roundtrip: () => ok({
+				pong: true,
+				ts: Date.now()
+			})
+		}
+	});
+}
+//#endregion
+//#region plugins/media/plugin.ts
+function newRequestId() {
+	return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+/**
+* `vendor.media` — reference plugin demonstrating out-of-band binary transfer.
+* The native host picks/captures a file (returns its path); the worklet mounts
+* it on its loopback HTTP server and hands the web layer a plain URL. No media
+* bytes ever cross the wire protocol or a WebView bridge, and the serving code
+* is identical on every runtime.
+*/
+function createMediaPlugin(deps) {
+	const serve = async (event, args) => {
+		const host = await deps.invokeOnHost({
+			type: "INVOKE_REQUEST",
+			pluginId: "vendor.media",
+			event,
+			requestId: newRequestId(),
+			args
+		}, /* @__PURE__ */ new Uint8Array(0));
+		if (!host) return err(ErrorCode.HOST_ERROR, `Host did not answer ${event}`);
+		if (host.error) return err(host.error.code || ErrorCode.HOST_ERROR, host.error.message ?? `Host failed ${event}`);
+		const path = host.result?.path;
+		if (!path) return err(ErrorCode.HOST_ERROR, `Host returned no path for ${event}`);
+		const id = `${args?.kind ?? "media"}-${newRequestId()}`;
+		deps.staticServer.mount(`/media/${id}`, path);
+		const url = await deps.staticServer.url(`/media/${id}`);
+		return ok({
+			url,
+			path
+		});
+	};
+	return definePlugin("vendor.media", mediaSpecs, {
+		capabilities: ["media"],
+		invoke: {
+			pick: async (args) => serve("media.pick", args),
+			capture: async (args) => serve("media.capture", args)
+		}
+	});
+}
+//#endregion
+//#region plugins/permissions/plugin.ts
+/**
+* Declares host-only permission events. Handlers are registered on the Android host
+* via {@code HostPluginRegistry}; the worklet delegates invokes here over IPC.
+*/
+function createPermissionsPluginStub() {
+	return definePlugin("core.permissions", permissionSpecs, { capabilities: ["permissions"] });
+}
+//#endregion
+//#region plugins/index.ts
+function createDefaultPlugins(deps) {
+	return [
+		createHealthPlugin(),
+		createDiscoveryPlugin(deps),
+		createPermissionsPluginStub(),
+		createMediaPlugin(deps)
+	];
+}
+//#endregion
+export { createDefaultPlugins as t };

package/dist/plugins-discovery-events.d.mts

@@ -0,0 +1,21 @@
+import { A as CapabilityDescriptor, B as InvokeEnvelope } from "./index-DjulYFJL.mjs";
+//#region plugins/discovery/events.d.ts
+type DiscoveryListResult = {
+  schemaVersion: 1;
+  capabilities: CapabilityDescriptor[];
+};
+declare const discoverySpecs: {
+  readonly list: {
+    readonly pluginId: 'core.discovery';
+    readonly name: 'discovery.list';
+    readonly args: Record<string, never>;
+    readonly result: DiscoveryListResult;
+  };
+};
+declare const discoveryEvents: {
+  discovery: {
+    list(): InvokeEnvelope<"discovery.list", Record<string, never>, DiscoveryListResult>;
+  };
+};
+//#endregion
+export { DiscoveryListResult, discoveryEvents, discoverySpecs };

package/dist/plugins-discovery-events.mjs

@@ -0,0 +1,13 @@
+import { invokeEvent } from "./index.mjs";
+//#region plugins/discovery/events.ts
+const discoverySpecs = { list: {
+	pluginId: "core.discovery",
+	name: "discovery.list",
+	args: {},
+	result: {}
+} };
+const discoveryEvents = { discovery: { list() {
+	return invokeEvent(discoverySpecs.list, {});
+} } };
+//#endregion
+export { discoveryEvents, discoverySpecs };