@particle-academy/agent-integrations 0.2.4

package/dist/server-Bv985us3.d.cts

@@ -0,0 +1,173 @@
+/**
+ * Minimal MCP (Model Context Protocol) types — covers the subset this
+ * package implements: initialize, tools/list, tools/call, plus JSON-RPC.
+ *
+ * Aligned with the public MCP spec but trimmed to v0.1 needs. See
+ * https://spec.modelcontextprotocol.io/ for the full surface.
+ */
+type JsonValue = string | number | boolean | null | {
+    [key: string]: JsonValue;
+} | JsonValue[];
+type JsonObject = {
+    [key: string]: JsonValue;
+};
+type JsonRpcId = string | number | null;
+type JsonRpcRequest = {
+    jsonrpc: "2.0";
+    id: JsonRpcId;
+    method: string;
+    params?: JsonObject;
+};
+type JsonRpcNotification = {
+    jsonrpc: "2.0";
+    method: string;
+    params?: JsonObject;
+};
+type JsonRpcSuccess = {
+    jsonrpc: "2.0";
+    id: JsonRpcId;
+    result: JsonValue;
+};
+type JsonRpcError = {
+    jsonrpc: "2.0";
+    id: JsonRpcId;
+    error: {
+        code: number;
+        message: string;
+        data?: JsonValue;
+    };
+};
+type JsonRpcMessage = JsonRpcRequest | JsonRpcNotification | JsonRpcSuccess | JsonRpcError;
+declare const JSONRPC_PARSE_ERROR = -32700;
+declare const JSONRPC_INVALID_REQUEST = -32600;
+declare const JSONRPC_METHOD_NOT_FOUND = -32601;
+declare const JSONRPC_INVALID_PARAMS = -32602;
+declare const JSONRPC_INTERNAL_ERROR = -32603;
+type ServerCapabilities = {
+    tools?: {
+        listChanged?: boolean;
+    };
+    resources?: {
+        listChanged?: boolean;
+        subscribe?: boolean;
+    };
+    prompts?: {
+        listChanged?: boolean;
+    };
+    logging?: Record<string, never>;
+};
+type ServerInfo = {
+    name: string;
+    version: string;
+    title?: string;
+};
+type InitializeResult = {
+    protocolVersion: string;
+    capabilities: ServerCapabilities;
+    serverInfo: ServerInfo;
+    instructions?: string;
+};
+type ToolInputSchema = {
+    type: "object";
+    properties?: Record<string, JsonValue>;
+    required?: string[];
+    additionalProperties?: boolean;
+};
+type ToolDefinition = {
+    name: string;
+    title?: string;
+    description?: string;
+    inputSchema: ToolInputSchema;
+};
+type ContentBlock = {
+    type: "text";
+    text: string;
+} | {
+    type: "image";
+    data: string;
+    mimeType: string;
+} | {
+    type: "resource";
+    resource: {
+        uri: string;
+        text?: string;
+        mimeType?: string;
+    };
+};
+type CallToolResult = {
+    content: ContentBlock[];
+    isError?: boolean;
+    /** Structured tool output — non-spec but useful for typed bridges. */
+    structuredContent?: JsonValue;
+};
+/** Handler signature for a tool registered on the MicroMcpServer. */
+type ToolHandler = (args: JsonObject) => Promise<CallToolResult> | CallToolResult;
+/** Internal record kept by the server. */
+type RegisteredTool = {
+    definition: ToolDefinition;
+    handler: ToolHandler;
+};
+declare const MCP_PROTOCOL_VERSION = "2025-06-18";
+
+type McpServerOptions = {
+    info: ServerInfo;
+    /** Defaults to { tools: { listChanged: true } } */
+    capabilities?: ServerCapabilities;
+    /** Free-text instructions surfaced to clients during initialize. */
+    instructions?: string;
+};
+type Transport = {
+    /** Called by the server when it has a message to deliver to the client. */
+    send: (message: JsonRpcMessage) => void;
+    /** Called by the server when it's torn down so the transport can clean up. */
+    close?: () => void;
+};
+/**
+ * MicroMcpServer — protocol-level MCP server, transport-agnostic.
+ *
+ * Use it like:
+ *
+ *   const server = new MicroMcpServer({ info: { name: "session", version: "0.1" } });
+ *   server.registerTool({ name: "...", inputSchema: { type: "object" } }, async (args) => ({...}));
+ *   const transport = new InProcessTransport();
+ *   server.attach(transport);
+ *   transport.deliver({ ... }); // client → server frames
+ *
+ * The same server can serve multiple transports (e.g. an in-process agent
+ * AND a relayed external client) by attaching each one.
+ */
+declare class MicroMcpServer {
+    private tools;
+    private transports;
+    private notifyListChangedScheduled;
+    readonly info: ServerInfo;
+    readonly capabilities: ServerCapabilities;
+    readonly instructions?: string;
+    constructor(options: McpServerOptions);
+    attach(transport: Transport): () => void;
+    detach(transport: Transport): void;
+    registerTool(definition: ToolDefinition, handler: ToolHandler): () => void;
+    unregisterTool(name: string): void;
+    listTools(): ToolDefinition[];
+    /**
+     * Receive a JSON-RPC frame from a client (called by the transport).
+     * The transport is responsible for sending the response back.
+     */
+    receive(transport: Transport, message: JsonRpcMessage): Promise<void>;
+    private handle;
+    private scheduleListChangedNotification;
+    private broadcast;
+    private toRpcError;
+}
+declare function rpcError(code: number, message: string, data?: any): {
+    data?: any;
+    code: number;
+    message: string;
+};
+/**
+ * Helper to build a CallToolResult from a string or structured value.
+ */
+declare function textResult(text: string, structured?: any): CallToolResult;
+declare function errorResult(text: string): CallToolResult;
+
+export { type CallToolResult as C, type InitializeResult as I, type JsonObject as J, MicroMcpServer as M, type RegisteredTool as R, type ServerCapabilities as S, type ToolDefinition as T, type ContentBlock as a, type JsonRpcMessage as b, type JsonRpcNotification as c, type JsonRpcRequest as d, type JsonValue as e, MCP_PROTOCOL_VERSION as f, type McpServerOptions as g, type ServerInfo as h, type ToolHandler as i, type Transport as j, errorResult as k, JSONRPC_INTERNAL_ERROR as l, JSONRPC_INVALID_PARAMS as m, JSONRPC_INVALID_REQUEST as n, JSONRPC_METHOD_NOT_FOUND as o, JSONRPC_PARSE_ERROR as p, type JsonRpcError as q, rpcError as r, type JsonRpcId as s, textResult as t, type JsonRpcSuccess as u, type ToolInputSchema as v };

package/dist/server-Bv985us3.d.ts

@@ -0,0 +1,173 @@
+/**
+ * Minimal MCP (Model Context Protocol) types — covers the subset this
+ * package implements: initialize, tools/list, tools/call, plus JSON-RPC.
+ *
+ * Aligned with the public MCP spec but trimmed to v0.1 needs. See
+ * https://spec.modelcontextprotocol.io/ for the full surface.
+ */
+type JsonValue = string | number | boolean | null | {
+    [key: string]: JsonValue;
+} | JsonValue[];
+type JsonObject = {
+    [key: string]: JsonValue;
+};
+type JsonRpcId = string | number | null;
+type JsonRpcRequest = {
+    jsonrpc: "2.0";
+    id: JsonRpcId;
+    method: string;
+    params?: JsonObject;
+};
+type JsonRpcNotification = {
+    jsonrpc: "2.0";
+    method: string;
+    params?: JsonObject;
+};
+type JsonRpcSuccess = {
+    jsonrpc: "2.0";
+    id: JsonRpcId;
+    result: JsonValue;
+};
+type JsonRpcError = {
+    jsonrpc: "2.0";
+    id: JsonRpcId;
+    error: {
+        code: number;
+        message: string;
+        data?: JsonValue;
+    };
+};
+type JsonRpcMessage = JsonRpcRequest | JsonRpcNotification | JsonRpcSuccess | JsonRpcError;
+declare const JSONRPC_PARSE_ERROR = -32700;
+declare const JSONRPC_INVALID_REQUEST = -32600;
+declare const JSONRPC_METHOD_NOT_FOUND = -32601;
+declare const JSONRPC_INVALID_PARAMS = -32602;
+declare const JSONRPC_INTERNAL_ERROR = -32603;
+type ServerCapabilities = {
+    tools?: {
+        listChanged?: boolean;
+    };
+    resources?: {
+        listChanged?: boolean;
+        subscribe?: boolean;
+    };
+    prompts?: {
+        listChanged?: boolean;
+    };
+    logging?: Record<string, never>;
+};
+type ServerInfo = {
+    name: string;
+    version: string;
+    title?: string;
+};
+type InitializeResult = {
+    protocolVersion: string;
+    capabilities: ServerCapabilities;
+    serverInfo: ServerInfo;
+    instructions?: string;
+};
+type ToolInputSchema = {
+    type: "object";
+    properties?: Record<string, JsonValue>;
+    required?: string[];
+    additionalProperties?: boolean;
+};
+type ToolDefinition = {
+    name: string;
+    title?: string;
+    description?: string;
+    inputSchema: ToolInputSchema;
+};
+type ContentBlock = {
+    type: "text";
+    text: string;
+} | {
+    type: "image";
+    data: string;
+    mimeType: string;
+} | {
+    type: "resource";
+    resource: {
+        uri: string;
+        text?: string;
+        mimeType?: string;
+    };
+};
+type CallToolResult = {
+    content: ContentBlock[];
+    isError?: boolean;
+    /** Structured tool output — non-spec but useful for typed bridges. */
+    structuredContent?: JsonValue;
+};
+/** Handler signature for a tool registered on the MicroMcpServer. */
+type ToolHandler = (args: JsonObject) => Promise<CallToolResult> | CallToolResult;
+/** Internal record kept by the server. */
+type RegisteredTool = {
+    definition: ToolDefinition;
+    handler: ToolHandler;
+};
+declare const MCP_PROTOCOL_VERSION = "2025-06-18";
+
+type McpServerOptions = {
+    info: ServerInfo;
+    /** Defaults to { tools: { listChanged: true } } */
+    capabilities?: ServerCapabilities;
+    /** Free-text instructions surfaced to clients during initialize. */
+    instructions?: string;
+};
+type Transport = {
+    /** Called by the server when it has a message to deliver to the client. */
+    send: (message: JsonRpcMessage) => void;
+    /** Called by the server when it's torn down so the transport can clean up. */
+    close?: () => void;
+};
+/**
+ * MicroMcpServer — protocol-level MCP server, transport-agnostic.
+ *
+ * Use it like:
+ *
+ *   const server = new MicroMcpServer({ info: { name: "session", version: "0.1" } });
+ *   server.registerTool({ name: "...", inputSchema: { type: "object" } }, async (args) => ({...}));
+ *   const transport = new InProcessTransport();
+ *   server.attach(transport);
+ *   transport.deliver({ ... }); // client → server frames
+ *
+ * The same server can serve multiple transports (e.g. an in-process agent
+ * AND a relayed external client) by attaching each one.
+ */
+declare class MicroMcpServer {
+    private tools;
+    private transports;
+    private notifyListChangedScheduled;
+    readonly info: ServerInfo;
+    readonly capabilities: ServerCapabilities;
+    readonly instructions?: string;
+    constructor(options: McpServerOptions);
+    attach(transport: Transport): () => void;
+    detach(transport: Transport): void;
+    registerTool(definition: ToolDefinition, handler: ToolHandler): () => void;
+    unregisterTool(name: string): void;
+    listTools(): ToolDefinition[];
+    /**
+     * Receive a JSON-RPC frame from a client (called by the transport).
+     * The transport is responsible for sending the response back.
+     */
+    receive(transport: Transport, message: JsonRpcMessage): Promise<void>;
+    private handle;
+    private scheduleListChangedNotification;
+    private broadcast;
+    private toRpcError;
+}
+declare function rpcError(code: number, message: string, data?: any): {
+    data?: any;
+    code: number;
+    message: string;
+};
+/**
+ * Helper to build a CallToolResult from a string or structured value.
+ */
+declare function textResult(text: string, structured?: any): CallToolResult;
+declare function errorResult(text: string): CallToolResult;
+
+export { type CallToolResult as C, type InitializeResult as I, type JsonObject as J, MicroMcpServer as M, type RegisteredTool as R, type ServerCapabilities as S, type ToolDefinition as T, type ContentBlock as a, type JsonRpcMessage as b, type JsonRpcNotification as c, type JsonRpcRequest as d, type JsonValue as e, MCP_PROTOCOL_VERSION as f, type McpServerOptions as g, type ServerInfo as h, type ToolHandler as i, type Transport as j, errorResult as k, JSONRPC_INTERNAL_ERROR as l, JSONRPC_INVALID_PARAMS as m, JSONRPC_INVALID_REQUEST as n, JSONRPC_METHOD_NOT_FOUND as o, JSONRPC_PARSE_ERROR as p, type JsonRpcError as q, rpcError as r, type JsonRpcId as s, textResult as t, type JsonRpcSuccess as u, type ToolInputSchema as v };

package/dist/sharing/index.d.cts

@@ -0,0 +1,89 @@
+import { j as Transport, M as MicroMcpServer, b as JsonRpcMessage } from '../server-Bv985us3.cjs';
+
+/**
+ * Session-token utilities. The token is a high-entropy secret; possession
+ * grants read/write on the session. We don't HMAC frames — frames carry
+ * the token directly (which is fine for in-process / same-origin / TLS
+ * transports). For lower-trust transports, host apps can layer signing
+ * on top of the BroadcastChannelTransport.
+ */
+type SessionDescriptor = {
+    /** Stable session identifier. Channel name = `fai:share:${id}`. */
+    id: string;
+    /** Secret token. Treat as a password — anyone with it can read/write. */
+    token: string;
+    /** Pretty hash for display (first 8 chars of token). */
+    display: string;
+};
+declare function createSessionDescriptor(): SessionDescriptor;
+declare function describeSession(id: string, token: string): SessionDescriptor;
+/** Build the shareable URL for the current page (preserves path, adds session+token). */
+declare function buildShareUrl(descriptor: SessionDescriptor, baseUrl?: string): string;
+/** Build the JSON config form (suitable for Claude Desktop / Cline / etc.). */
+declare function buildShareConfig(descriptor: SessionDescriptor, transport?: string): {
+    name: string;
+    transport: string;
+    session: string;
+    token: string;
+    channel: string;
+    protocol_version: string;
+};
+/** Read session descriptor from current URL, or null if not a shared link. */
+declare function readSessionFromUrl(): SessionDescriptor | null;
+/** Constant-time string compare so a mismatched token leaks no timing info. */
+declare function constantTimeEqual(a: string, b: string): boolean;
+
+/**
+ * SseRelayTransport — bridges the in-page MicroMcpServer to a host-app
+ * relay broker over Server-Sent Events (inbound) + POST (outbound).
+ *
+ * Wire model:
+ *   - Browser opens an EventSource at `${baseUrl}/${sessionId}/events?token=…`.
+ *     Each `event: mcp` carries one JSON-RPC frame from a remote client.
+ *   - Browser POSTs JSON-RPC frames to `${baseUrl}/${sessionId}/outbox?token=…`
+ *     when the local server has a response/notification to send.
+ *
+ * The host provides the relay endpoint (any HTTP server). See the demo
+ * `WhiteboardShareController` for the reference implementation.
+ *
+ * Token authentication is the host's job — this transport just carries the
+ * token in the query string. For lower-trust deployments, layer signing on
+ * top by wrapping `send` / `deliverFromRemote`.
+ */
+type SseRelayOptions = {
+    baseUrl: string;
+    sessionId: string;
+    token: string;
+    /** Override fetch (testing / non-browser). Defaults to global fetch. */
+    fetch?: typeof fetch;
+};
+declare class SseRelayTransport implements Transport {
+    private server?;
+    private es?;
+    private opts;
+    private sendQueue;
+    private connected;
+    private listeners;
+    private state;
+    private expectedToken;
+    constructor(options: SseRelayOptions);
+    bindServer(server: MicroMcpServer): void;
+    /** Open the SSE channel. Idempotent. */
+    start(): void;
+    send(message: JsonRpcMessage): void;
+    close(): void;
+    onStateChange(listener: (state: RelayState) => void): () => void;
+    /**
+     * For relays that wrap each frame with auth metadata: hosts can call this
+     * directly when a frame arrives via a non-SSE path. The transport will
+     * dispatch it to the bound server.
+     */
+    deliverFromRemote(payload: JsonRpcMessage | string, token?: string): Promise<void>;
+    private postOut;
+    private handleInbound;
+    private setState;
+}
+type RelayState = "idle" | "connecting" | "open" | "closed" | "error";
+declare function attachSseRelay(server: MicroMcpServer, options: SseRelayOptions): SseRelayTransport;
+
+export { type RelayState, type SessionDescriptor, type SseRelayOptions, SseRelayTransport, attachSseRelay, buildShareConfig, buildShareUrl, constantTimeEqual, createSessionDescriptor, describeSession, readSessionFromUrl };

package/dist/sharing/index.d.ts

@@ -0,0 +1,89 @@
+import { j as Transport, M as MicroMcpServer, b as JsonRpcMessage } from '../server-Bv985us3.js';
+
+/**
+ * Session-token utilities. The token is a high-entropy secret; possession
+ * grants read/write on the session. We don't HMAC frames — frames carry
+ * the token directly (which is fine for in-process / same-origin / TLS
+ * transports). For lower-trust transports, host apps can layer signing
+ * on top of the BroadcastChannelTransport.
+ */
+type SessionDescriptor = {
+    /** Stable session identifier. Channel name = `fai:share:${id}`. */
+    id: string;
+    /** Secret token. Treat as a password — anyone with it can read/write. */
+    token: string;
+    /** Pretty hash for display (first 8 chars of token). */
+    display: string;
+};
+declare function createSessionDescriptor(): SessionDescriptor;
+declare function describeSession(id: string, token: string): SessionDescriptor;
+/** Build the shareable URL for the current page (preserves path, adds session+token). */
+declare function buildShareUrl(descriptor: SessionDescriptor, baseUrl?: string): string;
+/** Build the JSON config form (suitable for Claude Desktop / Cline / etc.). */
+declare function buildShareConfig(descriptor: SessionDescriptor, transport?: string): {
+    name: string;
+    transport: string;
+    session: string;
+    token: string;
+    channel: string;
+    protocol_version: string;
+};
+/** Read session descriptor from current URL, or null if not a shared link. */
+declare function readSessionFromUrl(): SessionDescriptor | null;
+/** Constant-time string compare so a mismatched token leaks no timing info. */
+declare function constantTimeEqual(a: string, b: string): boolean;
+
+/**
+ * SseRelayTransport — bridges the in-page MicroMcpServer to a host-app
+ * relay broker over Server-Sent Events (inbound) + POST (outbound).
+ *
+ * Wire model:
+ *   - Browser opens an EventSource at `${baseUrl}/${sessionId}/events?token=…`.
+ *     Each `event: mcp` carries one JSON-RPC frame from a remote client.
+ *   - Browser POSTs JSON-RPC frames to `${baseUrl}/${sessionId}/outbox?token=…`
+ *     when the local server has a response/notification to send.
+ *
+ * The host provides the relay endpoint (any HTTP server). See the demo
+ * `WhiteboardShareController` for the reference implementation.
+ *
+ * Token authentication is the host's job — this transport just carries the
+ * token in the query string. For lower-trust deployments, layer signing on
+ * top by wrapping `send` / `deliverFromRemote`.
+ */
+type SseRelayOptions = {
+    baseUrl: string;
+    sessionId: string;
+    token: string;
+    /** Override fetch (testing / non-browser). Defaults to global fetch. */
+    fetch?: typeof fetch;
+};
+declare class SseRelayTransport implements Transport {
+    private server?;
+    private es?;
+    private opts;
+    private sendQueue;
+    private connected;
+    private listeners;
+    private state;
+    private expectedToken;
+    constructor(options: SseRelayOptions);
+    bindServer(server: MicroMcpServer): void;
+    /** Open the SSE channel. Idempotent. */
+    start(): void;
+    send(message: JsonRpcMessage): void;
+    close(): void;
+    onStateChange(listener: (state: RelayState) => void): () => void;
+    /**
+     * For relays that wrap each frame with auth metadata: hosts can call this
+     * directly when a frame arrives via a non-SSE path. The transport will
+     * dispatch it to the bound server.
+     */
+    deliverFromRemote(payload: JsonRpcMessage | string, token?: string): Promise<void>;
+    private postOut;
+    private handleInbound;
+    private setState;
+}
+type RelayState = "idle" | "connecting" | "open" | "closed" | "error";
+declare function attachSseRelay(server: MicroMcpServer, options: SseRelayOptions): SseRelayTransport;
+
+export { type RelayState, type SessionDescriptor, type SseRelayOptions, SseRelayTransport, attachSseRelay, buildShareConfig, buildShareUrl, constantTimeEqual, createSessionDescriptor, describeSession, readSessionFromUrl };

package/dist/sharing.cjs

@@ -0,0 +1,166 @@
+'use strict';
+
+// src/sharing/token.ts
+var TOKEN_BYTES = 24;
+function createSessionDescriptor() {
+  const id = randomId(8);
+  const token = randomToken();
+  return { id, token, display: token.slice(0, 8) };
+}
+function describeSession(id, token) {
+  return { id, token, display: token.slice(0, 8) };
+}
+function buildShareUrl(descriptor, baseUrl = typeof window !== "undefined" ? window.location.href.split("?")[0] : "") {
+  const u = new URL(baseUrl);
+  u.searchParams.set("session", descriptor.id);
+  u.searchParams.set("token", descriptor.token);
+  return u.toString();
+}
+function buildShareConfig(descriptor, transport = "broadcast-channel") {
+  return {
+    name: `whiteboard-${descriptor.id}`,
+    transport,
+    session: descriptor.id,
+    token: descriptor.token,
+    channel: `fai:share:${descriptor.id}`,
+    protocol_version: "2025-06-18"
+  };
+}
+function readSessionFromUrl() {
+  if (typeof window === "undefined") return null;
+  const params = new URL(window.location.href).searchParams;
+  const id = params.get("session");
+  const token = params.get("token");
+  if (!id || !token) return null;
+  return describeSession(id, token);
+}
+function randomToken() {
+  const bytes = new Uint8Array(TOKEN_BYTES);
+  crypto.getRandomValues(bytes);
+  return base64Url(bytes);
+}
+function randomId(len) {
+  const bytes = new Uint8Array(Math.ceil(len * 3 / 4));
+  crypto.getRandomValues(bytes);
+  return base64Url(bytes).slice(0, len);
+}
+function base64Url(bytes) {
+  let s = "";
+  for (const b of bytes) s += String.fromCharCode(b);
+  return btoa(s).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function constantTimeEqual(a, b) {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  return diff === 0;
+}
+
+// src/sharing/sse-relay.ts
+var SseRelayTransport = class {
+  constructor(options) {
+    this.sendQueue = [];
+    this.connected = false;
+    this.listeners = /* @__PURE__ */ new Set();
+    this.state = "idle";
+    this.opts = options;
+    this.expectedToken = options.token;
+  }
+  bindServer(server) {
+    this.server = server;
+  }
+  /** Open the SSE channel. Idempotent. */
+  start() {
+    if (this.connected || typeof window === "undefined") return;
+    const url = `${this.opts.baseUrl}/${encodeURIComponent(this.opts.sessionId)}/events?token=${encodeURIComponent(this.opts.token)}`;
+    this.setState("connecting");
+    const es = new EventSource(url, { withCredentials: false });
+    this.es = es;
+    es.addEventListener("open", () => {
+      this.connected = true;
+      this.setState("open");
+      const queued = this.sendQueue.splice(0);
+      for (const msg of queued) this.postOut(msg);
+    });
+    es.addEventListener("mcp", (ev) => {
+      const raw = ev.data;
+      this.handleInbound(raw);
+    });
+    es.addEventListener("error", () => {
+      this.setState("error");
+    });
+  }
+  send(message) {
+    if (!this.connected) {
+      this.sendQueue.push(message);
+      return;
+    }
+    this.postOut(message);
+  }
+  close() {
+    this.es?.close();
+    this.es = void 0;
+    this.connected = false;
+    this.setState("closed");
+  }
+  onStateChange(listener) {
+    this.listeners.add(listener);
+    listener(this.state);
+    return () => this.listeners.delete(listener);
+  }
+  /**
+   * For relays that wrap each frame with auth metadata: hosts can call this
+   * directly when a frame arrives via a non-SSE path. The transport will
+   * dispatch it to the bound server.
+   */
+  async deliverFromRemote(payload, token) {
+    if (token !== void 0 && !constantTimeEqual(token, this.expectedToken)) return;
+    if (!this.server) throw new Error("SseRelayTransport has no bound server");
+    const message = typeof payload === "string" ? JSON.parse(payload) : payload;
+    await this.server.receive(this, message);
+  }
+  async postOut(message) {
+    const url = `${this.opts.baseUrl}/${encodeURIComponent(this.opts.sessionId)}/outbox?token=${encodeURIComponent(this.opts.token)}`;
+    const f = this.opts.fetch ?? fetch;
+    try {
+      await f(url, {
+        method: "POST",
+        headers: { "content-type": "application/json", "accept": "application/json" },
+        body: JSON.stringify(message)
+      });
+    } catch {
+    }
+  }
+  async handleInbound(raw) {
+    if (!this.server) return;
+    let message;
+    try {
+      message = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    await this.server.receive(this, message);
+  }
+  setState(state) {
+    this.state = state;
+    for (const l of this.listeners) l(state);
+  }
+};
+function attachSseRelay(server, options) {
+  const transport = new SseRelayTransport(options);
+  transport.bindServer(server);
+  server.attach(transport);
+  transport.start();
+  return transport;
+}
+
+exports.SseRelayTransport = SseRelayTransport;
+exports.attachSseRelay = attachSseRelay;
+exports.buildShareConfig = buildShareConfig;
+exports.buildShareUrl = buildShareUrl;
+exports.constantTimeEqual = constantTimeEqual;
+exports.createSessionDescriptor = createSessionDescriptor;
+exports.describeSession = describeSession;
+exports.readSessionFromUrl = readSessionFromUrl;
+//# sourceMappingURL=sharing.cjs.map
+//# sourceMappingURL=sharing.cjs.map