@ekrooh/bare 0.4.0 → 0.5.0

package/dist/index.mjs

@@ -1,512 +1 @@
-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 };
+export { h as CoreError, g as ErrorCode, _ as MAX_FRAME_BYTES, v as MAX_HEADER_BYTES, o as MessageProtocol, y as MessageType, b as VERSION, f as coerceErrorCode, n as createBareRuntimeContext, l as createPluginBus, u as createPluginRegistry, d as createPluginRouter, s as createProtocolMessenger, r as definePlugin, i as dispatchEvent, p as err, t as installWebConsoleCapture, a as invokeEvent, m as ok } from "./messages-BbpF3wNH.mjs";