@hulla/api-message-port 0.0.0-stage → 2.0.1

package/dist/desktop-BojxzZgV.js

@@ -0,0 +1,155 @@
+import { n as MESSAGE_PORT_PROTOCOL_VERSION, t as DEFAULT_MESSAGE_PORT_CHANNEL } from "./protocol-DrDtLBvi.js";
+
+//#region src/desktop-wire.ts
+function base64(bytes) {
+	let binary = "";
+	for (let offset = 0; offset < bytes.length; offset += 32768) binary += String.fromCharCode(...bytes.subarray(offset, offset + 32768));
+	return btoa(binary);
+}
+function bytes(value) {
+	if (typeof value !== "string") throw new TypeError("Invalid Desktop IPC binary value");
+	return Uint8Array.from(atob(value), (character) => character.charCodeAt(0));
+}
+async function encodeDesktopMessage(value) {
+	const seen = /* @__PURE__ */ new WeakSet();
+	async function encode(value) {
+		if (value === void 0) return ["undefined"];
+		if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+		if (typeof value === "number" && Number.isFinite(value)) return value;
+		if (typeof value !== "object" || value === null) throw new TypeError("Desktop IPC values must be JSON-compatible, bytes or FormData");
+		if (seen.has(value)) throw new TypeError("Desktop IPC values must not contain cycles");
+		seen.add(value);
+		try {
+			if (value instanceof Uint8Array) return ["bytes", base64(value)];
+			if (value instanceof FormData) {
+				const entries = [];
+				for (const [name, field] of value) entries.push([name, typeof field === "string" ? field : [
+					"file",
+					base64(new Uint8Array(await field.arrayBuffer())),
+					field.name,
+					field.type,
+					field.lastModified
+				]]);
+				return ["form-data", entries];
+			}
+			if (Array.isArray(value)) {
+				const entries = [];
+				for (const field of value) entries.push(await encode(field));
+				return ["array", entries];
+			}
+			if (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) throw new TypeError("Desktop IPC objects must be plain records; encode native values with a contract codec");
+			const entries = [];
+			for (const [name, field] of Object.entries(value)) entries.push([name, await encode(field)]);
+			return ["object", entries];
+		} finally {
+			seen.delete(value);
+		}
+	}
+	return JSON.stringify(await encode(value));
+}
+function decodeDesktopMessage(text) {
+	function decode(value) {
+		if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+		if (typeof value === "number" && Number.isFinite(value)) return value;
+		if (!Array.isArray(value)) throw new TypeError("Invalid Desktop IPC wire value");
+		if (value.length === 1 && value[0] === "undefined") return void 0;
+		if (value.length !== 2) throw new TypeError("Invalid Desktop IPC wire container");
+		if (value[0] === "bytes") return bytes(value[1]);
+		const entries = value[1];
+		if (!Array.isArray(entries)) throw new TypeError("Invalid Desktop IPC wire entries");
+		if (value[0] === "array") return entries.map(decode);
+		if (value[0] === "object" || value[0] === "form-data") {
+			const record = {};
+			const form = value[0] === "form-data" ? new FormData() : void 0;
+			for (const entry of entries) {
+				if (!Array.isArray(entry) || entry.length !== 2 || typeof entry[0] !== "string") throw new TypeError("Invalid Desktop IPC wire entry");
+				const [name, field] = entry;
+				if (form === void 0) {
+					if (Object.hasOwn(record, name)) throw new TypeError("Duplicate Desktop IPC object key");
+					Object.defineProperty(record, name, {
+						value: decode(field),
+						enumerable: true,
+						writable: true,
+						configurable: true
+					});
+				} else if (typeof field === "string") form.append(name, field);
+				else {
+					if (!Array.isArray(field) || field.length !== 5 || field[0] !== "file" || typeof field[2] !== "string" || typeof field[3] !== "string" || typeof field[4] !== "number") throw new TypeError("Invalid Desktop IPC multipart file");
+					form.append(name, new File([bytes(field[1])], field[2], {
+						type: field[3],
+						lastModified: field[4]
+					}));
+				}
+			}
+			return form ?? record;
+		}
+		throw new TypeError("Unknown Desktop IPC wire container");
+	}
+	return decode(JSON.parse(text));
+}
+
+//#endregion
+//#region src/desktop.ts
+/** JSON-safe bridge with ordered sends, async listener readiness, and explicit host lifetime. */
+function desktopEndpoint(bridge, options) {
+	let tail = Promise.resolve();
+	let subscribed = false;
+	let closed = false;
+	return {
+		send: (message) => {
+			const task = tail.then(async () => {
+				if (closed || options.signal.aborted) throw new Error("Desktop IPC endpoint closed");
+				await bridge.send(await encodeDesktopMessage(message));
+			});
+			tail = task.catch(() => {});
+			return task;
+		},
+		subscribe: async (listener) => {
+			if (subscribed) throw new Error("Desktop IPC endpoint supports one active session");
+			subscribed = true;
+			let active = true;
+			let unsubscribe;
+			const cleanup = async () => {
+				active = false;
+				closed = true;
+				options.signal.removeEventListener("abort", abort);
+				const release = unsubscribe;
+				unsubscribe = void 0;
+				await release?.();
+			};
+			const abort = () => {
+				if (!active) return;
+				listener({
+					protocol: 1,
+					channel: options.channel ?? "@hulla/api",
+					type: "close",
+					id: "desktop-close"
+				});
+				cleanup().catch(() => {});
+			};
+			options.signal.addEventListener("abort", abort, { once: true });
+			try {
+				if (options.signal.aborted) {
+					abort();
+					return cleanup;
+				}
+				unsubscribe = await bridge.subscribe((message) => {
+					if (!active) return;
+					try {
+						listener(decodeDesktopMessage(message));
+					} catch {
+						abort();
+					}
+				});
+				if (!active) await cleanup();
+				return cleanup;
+			} catch (error) {
+				await cleanup();
+				throw error;
+			}
+		}
+	};
+}
+
+//#endregion
+export { decodeDesktopMessage as n, encodeDesktopMessage as r, desktopEndpoint as t };

package/dist/desktop-q9GwZShg.d.ts

@@ -0,0 +1,21 @@
+import { r as MessageEndpointSubscription, t as MessageEndpoint } from "./endpoint-CPsj0RmN.js";
+//#region src/desktop-wire.d.ts
+declare function encodeDesktopMessage(value: unknown): Promise<string>;
+declare function decodeDesktopMessage(text: string): unknown;
+//#endregion
+//#region src/desktop.d.ts
+/** Host relays carry opaque strings without interpreting or reserializing their contents. */
+type DesktopBridge = {
+  readonly send: (message: string) => void | PromiseLike<void>;
+  readonly subscribe: (receive: (message: string) => void) => MessageEndpointSubscription | PromiseLike<MessageEndpointSubscription>;
+};
+type DesktopEndpointOptions = {
+  /** Abort on window destruction, native channel closure, or host shutdown. */
+  readonly signal: AbortSignal;
+  /** Must match the transport/adapter channel when overriding its default. */
+  readonly channel?: string;
+};
+/** JSON-safe bridge with ordered sends, async listener readiness, and explicit host lifetime. */
+declare function desktopEndpoint(bridge: DesktopBridge, options: DesktopEndpointOptions): MessageEndpoint;
+//#endregion
+export { encodeDesktopMessage as a, decodeDesktopMessage as i, DesktopEndpointOptions as n, desktopEndpoint as r, DesktopBridge as t };

package/dist/desktop.d.ts

@@ -0,0 +1,2 @@
+import { a as encodeDesktopMessage, i as decodeDesktopMessage, n as DesktopEndpointOptions, r as desktopEndpoint, t as DesktopBridge } from "./desktop-q9GwZShg.js";
+export { DesktopBridge, DesktopEndpointOptions, decodeDesktopMessage, desktopEndpoint, encodeDesktopMessage };

package/dist/desktop.js

@@ -0,0 +1,3 @@
+import { n as decodeDesktopMessage, r as encodeDesktopMessage, t as desktopEndpoint } from "./desktop-BojxzZgV.js";
+
+export { decodeDesktopMessage, desktopEndpoint, encodeDesktopMessage };

package/dist/dioxus.d.ts

@@ -0,0 +1,11 @@
+import { t as MessageEndpoint } from "./endpoint-CPsj0RmN.js";
+import { n as DesktopEndpointOptions } from "./desktop-q9GwZShg.js";
+//#region src/dioxus.d.ts
+/** The dioxus object injected into a document.eval script. One eval per API session. */
+type DioxusEval = {
+  readonly send: (message: string) => void | PromiseLike<void>;
+  readonly recv: () => PromiseLike<unknown>;
+};
+declare function dioxusEndpoint(evalChannel: DioxusEval, options: DesktopEndpointOptions): MessageEndpoint;
+//#endregion
+export { DioxusEval, dioxusEndpoint };

package/dist/dioxus.js

@@ -0,0 +1,37 @@
+import { t as desktopEndpoint } from "./desktop-BojxzZgV.js";
+
+//#region src/dioxus.ts
+function dioxusEndpoint(evalChannel, options) {
+	const lifetime = new AbortController();
+	const abort = () => lifetime.abort(options.signal.reason);
+	return desktopEndpoint({
+		send: (message) => evalChannel.send(message),
+		subscribe: (receive) => {
+			let active = true;
+			options.signal.addEventListener("abort", abort, { once: true });
+			if (options.signal.aborted) abort();
+			(async () => {
+				try {
+					while (active && !lifetime.signal.aborted) {
+						const message = await evalChannel.recv();
+						if (!active || lifetime.signal.aborted) break;
+						if (typeof message !== "string") throw new TypeError("Dioxus relay must send strings");
+						receive(message);
+					}
+				} catch {
+					lifetime.abort(/* @__PURE__ */ new Error("Dioxus eval channel closed"));
+				}
+			})();
+			return () => {
+				active = false;
+				options.signal.removeEventListener("abort", abort);
+			};
+		}
+	}, {
+		...options,
+		signal: lifetime.signal
+	});
+}
+
+//#endregion
+export { dioxusEndpoint };

package/dist/electron.d.ts

@@ -0,0 +1,2 @@
+import { a as messagePortEndpoint, i as MessagePortLike } from "./endpoint-CPsj0RmN.js";
+export { type MessagePortLike as ElectronPort, messagePortEndpoint as electronEndpoint };

package/dist/electron.js

@@ -0,0 +1,3 @@
+import { t as messagePortEndpoint } from "./endpoint-y_ZFW2WR.js";
+
+export { messagePortEndpoint as electronEndpoint };

package/dist/endpoint-CPsj0RmN.d.ts

@@ -0,0 +1,108 @@
+import { ResponseHeaderValues } from "@hulla/api";
+//#region src/protocol.d.ts
+declare const MESSAGE_PORT_PROTOCOL_VERSION: 1;
+declare const DEFAULT_MESSAGE_PORT_CHANNEL: '@hulla/api';
+type MessagePortFormDataFile = {
+  readonly kind: 'file';
+  readonly bytes: Uint8Array;
+  readonly name: string;
+  readonly type: string;
+  readonly lastModified: number;
+};
+type MessagePortFormDataEntry = readonly [name: string, value: string | MessagePortFormDataFile];
+type MessagePortBody = {
+  readonly kind: 'bytes' | 'json' | 'raw' | 'text';
+  readonly value: unknown;
+} | {
+  readonly kind: 'empty';
+} | {
+  readonly kind: 'form-data';
+  readonly value: readonly MessagePortFormDataEntry[];
+} | {
+  readonly kind: 'stream';
+};
+type MessagePortRequestBody = {
+  readonly kind: 'bytes' | 'json' | 'text';
+  readonly value: unknown;
+  readonly contentType: string;
+} | {
+  readonly kind: 'form-data';
+  readonly value: readonly MessagePortFormDataEntry[];
+  readonly contentType: string;
+};
+type MessagePortRequest = {
+  readonly key: readonly string[];
+  readonly method: string;
+  readonly path: string;
+  readonly query?: Readonly<Record<string, string | readonly string[] | undefined>>;
+  readonly headers: Readonly<Record<string, string>>;
+  readonly body?: MessagePortRequestBody;
+};
+type MessagePortEnvelope = {
+  readonly channel: string;
+  readonly protocol: typeof MESSAGE_PORT_PROTOCOL_VERSION;
+  readonly id: string;
+};
+type MessagePortRequestMessage = MessagePortEnvelope & {
+  readonly type: 'request';
+  readonly request: MessagePortRequest;
+};
+type MessagePortResponseMessage = MessagePortEnvelope & {
+  readonly type: 'response';
+  readonly response: {
+    readonly status: number;
+    readonly headers: ResponseHeaderValues;
+    readonly body: MessagePortBody;
+  };
+};
+type MessagePortCancelMessage = MessagePortEnvelope & {
+  readonly type: 'cancel';
+};
+type MessagePortStreamPullMessage = MessagePortEnvelope & {
+  readonly type: 'stream-pull';
+};
+type MessagePortStreamChunkMessage = MessagePortEnvelope & {
+  readonly type: 'stream-chunk';
+  readonly chunk: Uint8Array;
+};
+type MessagePortStreamEndMessage = MessagePortEnvelope & {
+  readonly type: 'stream-end';
+};
+type MessagePortErrorMessage = MessagePortEnvelope & {
+  readonly type: 'error' | 'stream-error';
+  readonly error: {
+    readonly message: string;
+    readonly name?: string;
+  };
+};
+type MessagePortCloseMessage = Omit<MessagePortEnvelope, 'id'> & {
+  readonly type: 'close';
+};
+type MessagePortMessage = MessagePortRequestMessage | MessagePortResponseMessage | MessagePortCancelMessage | MessagePortStreamPullMessage | MessagePortStreamChunkMessage | MessagePortStreamEndMessage | MessagePortErrorMessage | MessagePortCloseMessage;
+//#endregion
+//#region src/endpoint.d.ts
+type MessageEndpointSubscription = () => void | PromiseLike<void>;
+type MessageEndpointListener = (message: unknown) => void;
+/** An ordered, bidirectional message endpoint suitable for custom IPC bridges. */
+type MessageEndpoint = {
+  readonly send: (message: MessagePortMessage) => void | PromiseLike<void>;
+  readonly subscribe: (listener: MessageEndpointListener) => MessageEndpointSubscription | PromiseLike<MessageEndpointSubscription>;
+};
+type MessageEventLike = {
+  readonly data: unknown;
+};
+type MessagePortListener = (event: MessageEventLike) => void;
+/** The common surface shared by DOM MessagePort, worker_threads MessagePort, and Electron MessagePortMain. */
+type MessagePortLike = {
+  postMessage(message: unknown): void;
+  start?(): void;
+  addEventListener?(type: 'message', listener: MessagePortListener): void;
+  removeEventListener?(type: 'message', listener: MessagePortListener): void;
+  on?(type: 'message', listener: MessagePortListener): unknown;
+  off?(type: 'message', listener: MessagePortListener): unknown;
+  removeListener?(type: 'message', listener: MessagePortListener): unknown;
+};
+/** Normalizes browser, worker, Node, and Electron message ports to the async endpoint API. */
+declare function messagePortEndpoint(port: MessagePortLike): MessageEndpoint;
+//#endregion
+export { MessagePortRequestMessage as _, messagePortEndpoint as a, MessagePortStreamEndMessage as b, MessagePortBody as c, MessagePortErrorMessage as d, MessagePortFormDataEntry as f, MessagePortRequestBody as g, MessagePortRequest as h, MessagePortLike as i, MessagePortCancelMessage as l, MessagePortMessage as m, MessageEndpointListener as n, DEFAULT_MESSAGE_PORT_CHANNEL as o, MessagePortFormDataFile as p, MessageEndpointSubscription as r, MESSAGE_PORT_PROTOCOL_VERSION as s, MessageEndpoint as t, MessagePortCloseMessage as u, MessagePortResponseMessage as v, MessagePortStreamPullMessage as x, MessagePortStreamChunkMessage as y };

package/dist/endpoint-y_ZFW2WR.js

@@ -0,0 +1,34 @@
+//#region src/endpoint.ts
+function eventData(event) {
+	return typeof event === "object" && event !== null && "data" in event ? event.data : event;
+}
+/** Normalizes browser, worker, Node, and Electron message ports to the async endpoint API. */
+function messagePortEndpoint(port) {
+	if (typeof port.postMessage !== "function") throw new TypeError("Message port must provide postMessage()");
+	return {
+		send: (message) => port.postMessage(message),
+		subscribe: (listener) => {
+			const receive = (event) => listener(eventData(event));
+			if (typeof port.addEventListener === "function" && typeof port.removeEventListener === "function") {
+				port.addEventListener("message", receive);
+				port.start?.();
+				return () => port.removeEventListener?.("message", receive);
+			}
+			if (typeof port.on === "function" && (typeof port.off === "function" || typeof port.removeListener === "function")) {
+				port.on("message", receive);
+				port.start?.();
+				return () => {
+					if (typeof port.off === "function") port.off("message", receive);
+					else port.removeListener?.("message", receive);
+				};
+			}
+			throw new TypeError("Message port must provide EventTarget or EventEmitter message listeners");
+		}
+	};
+}
+function resolveMessageEndpoint(endpoint) {
+	return "send" in endpoint && "subscribe" in endpoint ? endpoint : messagePortEndpoint(endpoint);
+}
+
+//#endregion
+export { resolveMessageEndpoint as n, messagePortEndpoint as t };

package/dist/index.d.ts

@@ -0,0 +1,56 @@
+import { _ as MessagePortRequestMessage, a as messagePortEndpoint, b as MessagePortStreamEndMessage, c as MessagePortBody, d as MessagePortErrorMessage, f as MessagePortFormDataEntry, g as MessagePortRequestBody, h as MessagePortRequest, i as MessagePortLike, l as MessagePortCancelMessage, m as MessagePortMessage, n as MessageEndpointListener, o as DEFAULT_MESSAGE_PORT_CHANNEL, p as MessagePortFormDataFile, r as MessageEndpointSubscription, s as MESSAGE_PORT_PROTOCOL_VERSION, t as MessageEndpoint, u as MessagePortCloseMessage, v as MessagePortResponseMessage, x as MessagePortStreamPullMessage, y as MessagePortStreamChunkMessage } from "./endpoint-CPsj0RmN.js";
+import { AdapterErrorInput, AdapterResponse } from "@hulla/api/adapters";
+import { Awaitable, ServerAdapter, ServerContextInput, ServerExecutableFor } from "@hulla/api/server";
+import { Contract } from "@hulla/api";
+import { ClientTransport, ClientTransportRequest } from "@hulla/api/client";
+//#region src/client.d.ts
+type MessagePortTransportOptions = {
+  readonly channel?: string;
+};
+type MessagePortTransport = ClientTransport & {
+  /** Resolves after the endpoint listener has been installed. */
+  readonly ready: Promise<void>;
+  /** Stops listening and rejects all unfinished calls. The underlying endpoint remains open. */
+  readonly close: () => Promise<void>;
+};
+type MessagePortTransportErrorCode = 'closed' | 'invalid-message' | 'remote-error';
+declare class MessagePortTransportError extends Error {
+  readonly code: MessagePortTransportErrorCode;
+  constructor(code: MessagePortTransportErrorCode, message: string, options?: ErrorOptions);
+}
+/** Creates a concurrent request transport over a MessagePort or custom ordered IPC endpoint. */
+declare function messagePortTransport(port: MessagePortLike | MessageEndpoint, options?: MessagePortTransportOptions): MessagePortTransport;
+//#endregion
+//#region src/server.d.ts
+type MessagePortServerRequest = Omit<ClientTransportRequest, 'signal'> & {
+  readonly signal: AbortSignal;
+};
+type MessagePortAdapterContext = {
+  readonly endpoint: MessageEndpoint;
+  readonly message: MessagePortRequestMessage;
+  readonly port: MessagePortLike | MessageEndpoint;
+  readonly request: MessagePortServerRequest;
+};
+type MessagePortContextInput<ContractType extends Contract = Contract> = ServerContextInput<ContractType> & MessagePortAdapterContext;
+type MessagePortServerErrorInput = Omit<AdapterErrorInput, 'request'> & {
+  readonly request: MessagePortServerRequest;
+};
+type MessagePortAdapterOptions = {
+  readonly channel?: string;
+};
+type MessagePortMountOptions = {
+  readonly onError?: ((input: MessagePortServerErrorInput) => Awaitable<AdapterResponse | undefined | void>) | undefined;
+};
+type MessagePortServer = {
+  /** Resolves after the endpoint listener has been installed. */
+  readonly ready: Promise<void>;
+  /** Stops listening and cancels active handlers and streams. The underlying endpoint remains open. */
+  readonly close: () => Promise<void>;
+};
+type MessagePortAdapter = ServerAdapter<'message-port', MessagePortAdapterContext> & {
+  readonly mount: <const ContractType extends Contract, const Context extends object>(implementation: ServerExecutableFor<ContractType, Context, 'message-port', MessagePortAdapterContext>, options?: MessagePortMountOptions) => MessagePortServer;
+};
+/** Creates a server adapter over a MessagePort or custom ordered IPC endpoint. */
+declare function messagePortAdapter(port: MessagePortLike | MessageEndpoint, options?: MessagePortAdapterOptions): MessagePortAdapter;
+//#endregion
+export { DEFAULT_MESSAGE_PORT_CHANNEL, MESSAGE_PORT_PROTOCOL_VERSION, type MessageEndpoint, type MessageEndpointListener, type MessageEndpointSubscription, type MessagePortAdapter, type MessagePortAdapterOptions, type MessagePortBody, type MessagePortCancelMessage, type MessagePortCloseMessage, type MessagePortContextInput, type MessagePortErrorMessage, type MessagePortFormDataEntry, type MessagePortFormDataFile, type MessagePortLike, type MessagePortMessage, type MessagePortMountOptions, type MessagePortRequest, type MessagePortRequestBody, type MessagePortRequestMessage, type MessagePortResponseMessage, type MessagePortServer, type MessagePortServerErrorInput, type MessagePortServerRequest, type MessagePortStreamChunkMessage, type MessagePortStreamEndMessage, type MessagePortStreamPullMessage, type MessagePortTransport, MessagePortTransportError, type MessagePortTransportErrorCode, type MessagePortTransportOptions, messagePortAdapter, messagePortEndpoint, messagePortTransport };

package/dist/index.js

@@ -0,0 +1,685 @@
+import { n as resolveMessageEndpoint, t as messagePortEndpoint } from "./endpoint-y_ZFW2WR.js";
+import { a as isRecord, i as messagePortError, n as MESSAGE_PORT_PROTOCOL_VERSION, r as isMessagePortEnvelope, t as DEFAULT_MESSAGE_PORT_CHANNEL } from "./protocol-DrDtLBvi.js";
+import { createAdapterHandler } from "@hulla/api/adapters";
+import { assertAdapterContext, createServerAdapter, serverContextAdapterId } from "@hulla/api/server";
+
+//#region src/body.ts
+function isFile(value) {
+	return typeof File !== "undefined" && value instanceof File;
+}
+async function encodeFormData(value) {
+	if (!(value instanceof FormData)) throw new TypeError("Message-port form data must be FormData");
+	return Promise.all([...value.entries()].map(async ([name, entry]) => {
+		if (typeof entry === "string") return [name, entry];
+		return [name, {
+			kind: "file",
+			bytes: new Uint8Array(await entry.arrayBuffer()),
+			name: isFile(entry) ? entry.name : "blob",
+			type: entry.type,
+			lastModified: isFile(entry) ? entry.lastModified : 0
+		}];
+	}));
+}
+function decodeMessagePortFormData(entries) {
+	const formData = new FormData();
+	for (const [name, value] of entries) {
+		if (typeof value === "string") {
+			formData.append(name, value);
+			continue;
+		}
+		const bytes = value.bytes.slice().buffer;
+		const file = typeof File === "undefined" ? new Blob([bytes], { type: value.type }) : new File([bytes], value.name, {
+			type: value.type,
+			lastModified: value.lastModified
+		});
+		formData.append(name, file, value.name);
+	}
+	return formData;
+}
+async function encodeRequestBody(body) {
+	if (body.kind === "form-data") return {
+		kind: "form-data",
+		contentType: body.contentType,
+		value: await encodeFormData(body.value)
+	};
+	return {
+		kind: body.kind,
+		contentType: body.contentType,
+		value: body.value
+	};
+}
+async function encodeResponseBody(body) {
+	switch (body.kind) {
+		case "empty": return { kind: "empty" };
+		case "stream": return { kind: "stream" };
+		case "form-data": return {
+			kind: "form-data",
+			value: await encodeFormData(body.value)
+		};
+		case "bytes":
+		case "json":
+		case "raw":
+		case "text": return {
+			kind: body.kind,
+			value: body.value
+		};
+	}
+}
+
+//#endregion
+//#region src/client.ts
+var MessagePortTransportError = class extends Error {
+	code;
+	constructor(code, message, options) {
+		super(message, options);
+		this.name = "MessagePortTransportError";
+		this.code = code;
+	}
+};
+function channelName$1(options) {
+	const channel = options.channel ?? "@hulla/api";
+	if (channel.length === 0) throw new TypeError("Message-port channel must not be empty");
+	return channel;
+}
+function requestIdFactory() {
+	const prefix = globalThis.crypto?.randomUUID?.() ?? `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+	let sequence = 0;
+	return () => `${prefix}:${++sequence}`;
+}
+function remoteError(value, fallback) {
+	const error = isRecord(value) ? value : void 0;
+	const message = typeof error?.["message"] === "string" ? error["message"] : fallback;
+	const name = typeof error?.["name"] === "string" ? error["name"] : void 0;
+	return new MessagePortTransportError("remote-error", name === void 0 ? message : `${name}: ${message}`);
+}
+function stringHeaders(value) {
+	return isRecord(value) && Object.values(value).every((field) => typeof field === "string" || Array.isArray(field) && field.every((item) => typeof item === "string"));
+}
+function responseBody(value) {
+	if (!isRecord(value) || typeof value["kind"] !== "string") return void 0;
+	switch (value["kind"]) {
+		case "empty":
+		case "stream": return { kind: value["kind"] };
+		case "bytes": return value["value"] instanceof Uint8Array ? {
+			kind: "bytes",
+			value: value["value"]
+		} : void 0;
+		case "text": return typeof value["value"] === "string" ? {
+			kind: "text",
+			value: value["value"]
+		} : void 0;
+		case "form-data": return Array.isArray(value["value"]) ? value : void 0;
+		case "json":
+		case "raw": return {
+			kind: value["kind"],
+			value: value["value"]
+		};
+		default: return;
+	}
+}
+var MessagePortRemoteStream = class {
+	#channel;
+	#endpoint;
+	#id;
+	#onFinish;
+	#waiters = [];
+	#finished = false;
+	#failed = false;
+	#error;
+	constructor(endpoint, channel, id, onFinish) {
+		this.#endpoint = endpoint;
+		this.#channel = channel;
+		this.#id = id;
+		this.#onFinish = onFinish;
+	}
+	next() {
+		if (this.#failed) return Promise.reject(this.#error);
+		if (this.#finished) return Promise.resolve({
+			done: true,
+			value: void 0
+		});
+		const result = new Promise((resolve, reject) => {
+			this.#waiters.push({
+				resolve,
+				reject
+			});
+		});
+		try {
+			Promise.resolve(this.#endpoint.send({
+				protocol: 1,
+				channel: this.#channel,
+				type: "stream-pull",
+				id: this.#id
+			})).catch((error) => this.fail(error));
+		} catch (error) {
+			this.fail(error);
+		}
+		return result;
+	}
+	return() {
+		if (!this.#finished) {
+			this.#sendDetached({
+				protocol: 1,
+				channel: this.#channel,
+				type: "cancel",
+				id: this.#id
+			});
+			this.end();
+		}
+		return Promise.resolve({
+			done: true,
+			value: void 0
+		});
+	}
+	abort(error) {
+		if (this.#finished) return;
+		this.#sendDetached({
+			protocol: 1,
+			channel: this.#channel,
+			type: "cancel",
+			id: this.#id
+		});
+		this.fail(error);
+	}
+	[Symbol.asyncIterator]() {
+		return this;
+	}
+	#sendDetached(message) {
+		try {
+			Promise.resolve(this.#endpoint.send(message)).catch(() => {});
+		} catch {}
+	}
+	chunk(value) {
+		if (this.#finished) return;
+		if (!(value instanceof Uint8Array)) {
+			this.abort(new MessagePortTransportError("invalid-message", "Received a non-binary stream chunk"));
+			return;
+		}
+		const waiter = this.#waiters.shift();
+		if (waiter === void 0) {
+			this.abort(new MessagePortTransportError("invalid-message", "Received an unrequested stream chunk"));
+			return;
+		}
+		waiter.resolve({
+			done: false,
+			value
+		});
+	}
+	end() {
+		if (this.#finished) return;
+		this.#finished = true;
+		for (const waiter of this.#waiters.splice(0)) waiter.resolve({
+			done: true,
+			value: void 0
+		});
+		this.#onFinish();
+	}
+	fail(error) {
+		if (this.#finished) return;
+		this.#failed = true;
+		this.#error = error;
+		this.#finished = true;
+		for (const waiter of this.#waiters.splice(0)) waiter.reject(error);
+		this.#onFinish();
+	}
+};
+/** Creates a concurrent request transport over a MessagePort or custom ordered IPC endpoint. */
+function messagePortTransport(port, options = {}) {
+	const endpoint = resolveMessageEndpoint(port);
+	const channel = channelName$1(options);
+	const nextRequestId = requestIdFactory();
+	const pending = /* @__PURE__ */ new Map();
+	const streams = /* @__PURE__ */ new Map();
+	let closed = false;
+	let unsubscribe;
+	const sendDetached = (message) => {
+		try {
+			Promise.resolve(endpoint.send(message)).catch(() => {});
+		} catch {}
+	};
+	const clearPending = (id, request) => {
+		pending.delete(id);
+		if (request.signal !== void 0 && request.onAbort !== void 0) request.signal.removeEventListener("abort", request.onAbort);
+	};
+	const failAll = (error, notifyRemote) => {
+		for (const [id, request] of [...pending]) if (notifyRemote) request.cancel(error);
+		else {
+			clearPending(id, request);
+			request.reject(error);
+		}
+		for (const stream of [...streams.values()]) if (notifyRemote) stream.abort(error);
+		else stream.fail(error);
+		streams.clear();
+	};
+	const receive = (value) => {
+		if (!isMessagePortEnvelope(value, channel)) return;
+		if (value.type === "close") {
+			closed = true;
+			failAll(new MessagePortTransportError("closed", "The remote message-port server closed"), false);
+			const cleanup = unsubscribe;
+			unsubscribe = void 0;
+			if (cleanup !== void 0) Promise.resolve(cleanup()).catch(() => {});
+			return;
+		}
+		if (typeof value.id !== "string") return;
+		const stream = streams.get(value.id);
+		if (stream !== void 0) {
+			if (value.type === "stream-chunk") stream.chunk(value.chunk);
+			else if (value.type === "stream-end") stream.end();
+			else if (value.type === "stream-error") stream.fail(remoteError(value.error, "Remote stream failed"));
+			return;
+		}
+		const request = pending.get(value.id);
+		if (request === void 0) return;
+		if (value.type === "error") {
+			clearPending(value.id, request);
+			request.reject(remoteError(value.error, "Remote request failed"));
+			return;
+		}
+		if (value.type !== "response") return;
+		const responseValue = value.response;
+		const body = isRecord(responseValue) ? responseBody(responseValue["body"]) : void 0;
+		if (!isRecord(responseValue) || typeof responseValue["status"] !== "number" || !stringHeaders(responseValue["headers"]) || body === void 0) {
+			clearPending(value.id, request);
+			request.reject(new MessagePortTransportError("invalid-message", "Received an invalid response message"));
+			return;
+		}
+		pending.delete(value.id);
+		let streamAbort;
+		const finish = () => {
+			streams.delete(value.id);
+			const abortListener = streamAbort ?? request.onAbort;
+			if (request.signal !== void 0 && abortListener !== void 0) request.signal.removeEventListener("abort", abortListener);
+		};
+		const remoteStream = body.kind === "stream" ? new MessagePortRemoteStream(endpoint, channel, value.id, finish) : void 0;
+		if (remoteStream === void 0) finish();
+		else {
+			streams.set(value.id, remoteStream);
+			if (request.signal !== void 0) {
+				if (request.onAbort !== void 0) request.signal.removeEventListener("abort", request.onAbort);
+				streamAbort = () => remoteStream.abort(request.signal?.reason);
+				request.signal.addEventListener("abort", streamAbort, { once: true });
+				if (request.signal.aborted) streamAbort();
+			}
+		}
+		const response = {
+			status: responseValue["status"],
+			headers: responseValue["headers"],
+			native: value,
+			dispose: async () => {
+				await remoteStream?.return();
+			},
+			readBody: (kind) => {
+				if (body.kind !== kind) {
+					remoteStream?.return();
+					throw new TypeError(`Message-port response body is ${body.kind}, but the client selected ${kind}`);
+				}
+				if (body.kind === "stream") return remoteStream;
+				if (body.kind === "form-data") return decodeMessagePortFormData(body.value);
+				return body.value;
+			}
+		};
+		request.resolve(response);
+	};
+	const ready = Promise.resolve(endpoint.subscribe(receive)).then(async (subscription) => {
+		unsubscribe = subscription;
+		if (closed) {
+			unsubscribe = void 0;
+			await subscription();
+		}
+	});
+	const transport = (async (request) => {
+		if (closed) throw new MessagePortTransportError("closed", "Message-port transport is closed");
+		request.signal?.throwIfAborted();
+		await new Promise((resolve, reject) => {
+			const signal = request.signal;
+			const abort = () => {
+				signal?.removeEventListener("abort", abort);
+				reject(signal?.reason);
+			};
+			signal?.addEventListener("abort", abort, { once: true });
+			ready.then(() => {
+				signal?.removeEventListener("abort", abort);
+				resolve();
+			}, (error) => {
+				signal?.removeEventListener("abort", abort);
+				reject(error);
+			});
+			if (signal?.aborted) abort();
+		});
+		request.signal?.throwIfAborted();
+		const id = nextRequestId();
+		const encodedRequest = {
+			key: request.key,
+			method: request.method,
+			path: request.path,
+			...request.query === void 0 ? {} : { query: request.query },
+			headers: request.headers,
+			...request.body === void 0 ? {} : { body: await encodeRequestBody(request.body) }
+		};
+		if (closed) throw new MessagePortTransportError("closed", "Message-port transport is closed");
+		request.signal?.throwIfAborted();
+		return new Promise((resolve, reject) => {
+			const cancel = (error = request.signal?.reason) => {
+				const active = pending.get(id);
+				if (active === void 0) return;
+				clearPending(id, active);
+				sendDetached({
+					protocol: 1,
+					channel,
+					type: "cancel",
+					id
+				});
+				reject(error);
+			};
+			const onAbort = () => cancel(request.signal?.reason);
+			const active = {
+				resolve,
+				reject,
+				...request.signal === void 0 ? {} : {
+					signal: request.signal,
+					onAbort
+				},
+				cancel
+			};
+			pending.set(id, active);
+			request.signal?.addEventListener("abort", onAbort, { once: true });
+			if (request.signal?.aborted) {
+				cancel();
+				return;
+			}
+			const message = {
+				protocol: 1,
+				channel,
+				type: "request",
+				id,
+				request: encodedRequest
+			};
+			try {
+				Promise.resolve(endpoint.send(message)).catch((error) => {
+					if (pending.get(id) !== active) return;
+					clearPending(id, active);
+					reject(error);
+				});
+			} catch (error) {
+				clearPending(id, active);
+				reject(error);
+			}
+		});
+	});
+	Object.defineProperties(transport, {
+		ready: {
+			value: ready,
+			enumerable: true
+		},
+		close: {
+			enumerable: true,
+			value: async () => {
+				if (!closed) {
+					closed = true;
+					failAll(new MessagePortTransportError("closed", "Message-port transport is closed"), true);
+				}
+				await ready;
+				const cleanup = unsubscribe;
+				unsubscribe = void 0;
+				await cleanup?.();
+			}
+		}
+	});
+	return transport;
+}
+
+//#endregion
+//#region src/server.ts
+function channelName(options) {
+	const channel = options.channel ?? "@hulla/api";
+	if (channel.length === 0) throw new TypeError("Message-port channel must not be empty");
+	return channel;
+}
+function requestHeaders(value) {
+	return isRecord(value) && Object.values(value).every((field) => typeof field === "string");
+}
+function decodeRequest(message, signal) {
+	const request = message.request;
+	if (!isRecord(request) || !Array.isArray(request["key"]) || !request["key"].every((part) => typeof part === "string") || typeof request["method"] !== "string" || typeof request["path"] !== "string" || !requestHeaders(request["headers"])) throw new TypeError("Received an invalid message-port request");
+	const body = request["body"];
+	let decodedBody;
+	if (body !== void 0) {
+		if (!isRecord(body) || typeof body["contentType"] !== "string") throw new TypeError("Received an invalid message-port request body");
+		switch (body["kind"]) {
+			case "bytes":
+				if (!(body["value"] instanceof Uint8Array)) throw new TypeError("Message-port byte body must be Uint8Array");
+				decodedBody = {
+					kind: "bytes",
+					contentType: body["contentType"],
+					value: body["value"]
+				};
+				break;
+			case "text":
+				if (typeof body["value"] !== "string") throw new TypeError("Message-port text body must be a string");
+				decodedBody = {
+					kind: "text",
+					contentType: body["contentType"],
+					value: body["value"]
+				};
+				break;
+			case "json":
+				decodedBody = {
+					kind: "json",
+					contentType: body["contentType"],
+					value: body["value"]
+				};
+				break;
+			case "form-data":
+				if (!Array.isArray(body["value"])) throw new TypeError("Message-port form data body must contain entries");
+				decodedBody = {
+					kind: "form-data",
+					contentType: body["contentType"],
+					value: decodeMessagePortFormData(body["value"])
+				};
+				break;
+			default: throw new TypeError("Received an unsupported message-port request body");
+		}
+	}
+	return {
+		key: request["key"],
+		method: request["method"],
+		path: request["path"],
+		...request["query"] === void 0 ? {} : { query: request["query"] },
+		headers: request["headers"],
+		...decodedBody === void 0 ? {} : { body: decodedBody },
+		signal
+	};
+}
+function streamIterator(value) {
+	const source = value;
+	if (typeof source[Symbol.asyncIterator] === "function") return source[Symbol.asyncIterator]();
+	const iterator = source[Symbol.iterator]();
+	return {
+		next: async () => iterator.next(),
+		...iterator.return === void 0 ? {} : { return: async () => iterator.return() }
+	};
+}
+function createMessagePortServer(port, endpoint, channel, implementation, options) {
+	assertAdapterContext(implementation.context, "message-port");
+	const usesNativeContext = serverContextAdapterId(implementation.context) !== void 0;
+	const dispatch = createAdapterHandler(implementation, options.onError === void 0 ? {} : { onError: (input) => options.onError?.({
+		...input,
+		request: input.request
+	}) });
+	const active = /* @__PURE__ */ new Map();
+	let closed = false;
+	let unsubscribe;
+	const send = (message) => closed ? Promise.resolve() : Promise.resolve(endpoint.send(message));
+	const cancel = async (id, request) => {
+		if (request.cancelled) return;
+		request.cancelled = true;
+		request.controller.abort();
+		active.delete(id);
+		await request.iterator?.return?.();
+	};
+	const pump = async (id, request) => {
+		if (request.pumping || request.iterator === void 0) return;
+		request.pumping = true;
+		try {
+			while (!request.cancelled && request.pulls > 0) {
+				request.pulls--;
+				const result = await request.iterator.next();
+				if (request.cancelled) break;
+				if (result.done) {
+					active.delete(id);
+					await send({
+						protocol: 1,
+						channel,
+						type: "stream-end",
+						id
+					});
+					return;
+				}
+				if (!(result.value instanceof Uint8Array)) throw new TypeError("Message-port stream chunks must be Uint8Array");
+				await send({
+					protocol: 1,
+					channel,
+					type: "stream-chunk",
+					id,
+					chunk: result.value
+				});
+			}
+		} catch (error) {
+			try {
+				await cancel(id, request);
+			} catch {}
+			await send({
+				protocol: 1,
+				channel,
+				type: "stream-error",
+				id,
+				error: messagePortError(error)
+			});
+		} finally {
+			request.pumping = false;
+		}
+	};
+	const execute = async (message) => {
+		const id = message.id;
+		if (active.has(id)) {
+			await send({
+				protocol: 1,
+				channel,
+				type: "error",
+				id,
+				error: { message: "Duplicate message-port request id" }
+			});
+			return;
+		}
+		const state = {
+			controller: new AbortController(),
+			cancelled: false,
+			pulls: 0,
+			pumping: false
+		};
+		active.set(id, state);
+		try {
+			const request = decodeRequest(message, state.controller.signal);
+			const response = await dispatch({
+				request,
+				signal: request.signal,
+				...usesNativeContext ? { contextInput: {
+					endpoint,
+					message,
+					port,
+					request
+				} } : {},
+				method: request.method,
+				pathname: request.path,
+				headers: request.headers,
+				...request.query === void 0 ? {} : { query: request.query },
+				...request.body === void 0 ? {} : { body: {
+					value: request.body.value,
+					contentType: request.body.contentType
+				} }
+			});
+			if (state.cancelled) return;
+			if (response.body.kind === "stream") state.iterator = streamIterator(response.body.value);
+			const body = await encodeResponseBody(response.body);
+			if (state.cancelled) return;
+			await send({
+				protocol: 1,
+				channel,
+				type: "response",
+				id,
+				response: {
+					status: response.status,
+					headers: response.body.kind === "form-data" && response.headers["content-type"] === void 0 ? {
+						...response.headers,
+						"content-type": "multipart/form-data"
+					} : response.headers,
+					body
+				}
+			});
+			if (response.body.kind !== "stream") active.delete(id);
+		} catch (error) {
+			active.delete(id);
+			try {
+				await state.iterator?.return?.();
+			} catch {}
+			if (state.cancelled) return;
+			await send({
+				protocol: 1,
+				channel,
+				type: "error",
+				id,
+				error: messagePortError(error)
+			});
+		}
+	};
+	const receive = (value) => {
+		if (!isMessagePortEnvelope(value, channel) || value.type === "close") return;
+		if (typeof value.id !== "string") return;
+		if (value.type === "request") {
+			execute(value).catch(() => {});
+			return;
+		}
+		const request = active.get(value.id);
+		if (request === void 0) return;
+		if (value.type === "cancel") cancel(value.id, request).catch(() => {});
+		else if (value.type === "stream-pull" && request.iterator !== void 0) {
+			request.pulls++;
+			pump(value.id, request).catch(() => {});
+		}
+	};
+	const ready = Promise.resolve(endpoint.subscribe(receive)).then((subscription) => {
+		unsubscribe = subscription;
+		if (closed) return subscription();
+	});
+	return Object.freeze({
+		ready,
+		close: async () => {
+			if (closed) return;
+			await ready;
+			try {
+				await send({
+					protocol: 1,
+					channel,
+					type: "close"
+				});
+			} finally {
+				closed = true;
+				try {
+					await unsubscribe?.();
+				} finally {
+					await Promise.all([...active].map(([id, request]) => cancel(id, request)));
+				}
+			}
+		}
+	});
+}
+/** Creates a server adapter over a MessagePort or custom ordered IPC endpoint. */
+function messagePortAdapter(port, options = {}) {
+	const endpoint = resolveMessageEndpoint(port);
+	const channel = channelName(options);
+	return createServerAdapter("message-port", { mount: (implementation, mountOptions = {}) => createMessagePortServer(port, endpoint, channel, implementation, mountOptions) });
+}
+
+//#endregion
+export { DEFAULT_MESSAGE_PORT_CHANNEL, MESSAGE_PORT_PROTOCOL_VERSION, MessagePortTransportError, messagePortAdapter, messagePortEndpoint, messagePortTransport };

package/dist/protocol-DrDtLBvi.js

@@ -0,0 +1,21 @@
+//#region src/object.ts
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+//#endregion
+//#region src/protocol.ts
+const MESSAGE_PORT_PROTOCOL_VERSION = 1;
+const DEFAULT_MESSAGE_PORT_CHANNEL = "@hulla/api";
+function isMessagePortEnvelope(value, channel) {
+	return isRecord(value) && value["channel"] === channel && value["protocol"] === 1 && typeof value["type"] === "string";
+}
+function messagePortError(error) {
+	return error instanceof Error ? {
+		message: error.message,
+		...error.name === "Error" ? {} : { name: error.name }
+	} : { message: String(error) };
+}
+
+//#endregion
+export { isRecord as a, messagePortError as i, MESSAGE_PORT_PROTOCOL_VERSION as n, isMessagePortEnvelope as r, DEFAULT_MESSAGE_PORT_CHANNEL as t };

package/dist/tauri.d.ts

@@ -0,0 +1,19 @@
+import { t as MessageEndpoint } from "./endpoint-CPsj0RmN.js";
+import { n as DesktopEndpointOptions } from "./desktop-q9GwZShg.js";
+//#region src/tauri.d.ts
+type TauriMessageChannel = {
+  onmessage: (message: string) => void;
+};
+type TauriBridgeOptions = DesktopEndpointOptions & {
+  /** Dedicated Channel<string> supplied by @tauri-apps/api/core. */
+  readonly messages: TauriMessageChannel;
+  /** Register the channel with the native relay; resolve only when routing is ready. */
+  readonly connect: () => PromiseLike<unknown>;
+  /** Invoke an application command that forwards one opaque string to the peer. */
+  readonly send: (message: string) => PromiseLike<unknown>;
+  /** Unregister native routing for this session. Must also handle a failed connect. */
+  readonly disconnect: () => void | PromiseLike<void>;
+};
+declare function tauriEndpoint(options: TauriBridgeOptions): MessageEndpoint;
+//#endregion
+export { TauriBridgeOptions, TauriMessageChannel, tauriEndpoint };

package/dist/tauri.js

@@ -0,0 +1,28 @@
+import { t as desktopEndpoint } from "./desktop-BojxzZgV.js";
+
+//#region src/tauri.ts
+function tauriEndpoint(options) {
+	return desktopEndpoint({
+		send: async (message) => {
+			await options.send(message);
+		},
+		subscribe: async (receive) => {
+			const previous = options.messages.onmessage;
+			options.messages.onmessage = receive;
+			try {
+				await options.connect();
+			} catch (error) {
+				options.messages.onmessage = previous;
+				await options.disconnect();
+				throw error;
+			}
+			return async () => {
+				if (options.messages.onmessage === receive) options.messages.onmessage = previous;
+				await options.disconnect();
+			};
+		}
+	}, options);
+}
+
+//#endregion
+export { tauriEndpoint };

package/package.json

@@ -1,6 +1,58 @@
 {
   "name": "@hulla/api-message-port",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "2.0.1",
+  "description": "MessagePort and ordered IPC transport for @hulla/api",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hulladev/api.git",
+    "directory": "packages/message-port"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./desktop": {
+      "types": "./dist/desktop.d.ts",
+      "import": "./dist/desktop.js"
+    },
+    "./electron": {
+      "types": "./dist/electron.d.ts",
+      "import": "./dist/electron.js"
+    },
+    "./tauri": {
+      "types": "./dist/tauri.d.ts",
+      "import": "./dist/tauri.js"
+    },
+    "./dioxus": {
+      "types": "./dist/dioxus.d.ts",
+      "import": "./dist/dioxus.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "clean": "rm -rf dist coverage",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "@hulla/api": "2.0.1",
+    "@types/node": "^26.2.0",
+    "zod": "^4.4.3"
+  },
+  "peerDependencies": {
+    "@hulla/api": "^2.0.1"
+  }
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.