@statelyai/sdk 0.12.3 → 0.13.1

package/dist/inspect.mjs

@@ -1,306 +1,3 @@
-import { i as createPendingExportManager, n as createWebSocketTransport, r as createEventRegistry } from "./transport-DysvAtl5.mjs";
+import { n as createStatelyInspector, t as createInspector } from "./inspect-pcNCbL7j.mjs";
 
-//#region src/inspect.ts
-const defaultSerializeSnapshot = (snapshot) => ({
-	value: snapshot?.value,
-	status: snapshot?.status
-});
-const defaultExtractMachineConfig = (actor) => actor?.logic?.config ?? null;
-let nextManualId = 0;
-function generateSessionId() {
-	return `manual-${Date.now()}-${nextManualId++}`;
-}
-function createStatelyInspector(options = {}) {
-	const { url = "ws://localhost:4242", autoOpen = true, name, serializeSnapshot = defaultSerializeSnapshot, extractMachineConfig = defaultExtractMachineConfig, selectedActorId, panels, theme, readOnly, depth, capabilities, transport: injectedTransport } = options;
-	const sessionId = options.sessionId ?? generateSessionId();
-	const displayName = name ?? "system:manual";
-	let destroyed = false;
-	let initSent = false;
-	const pendingMessages = [];
-	const events = createEventRegistry();
-	const localListeners = {};
-	const transport = injectedTransport ?? createWebSocketTransport({
-		url,
-		role: "client",
-		sessionId,
-		metadata: { name: displayName }
-	});
-	const ownsTransport = !injectedTransport;
-	const exportManager = createPendingExportManager((message) => send(message));
-	function send(msg) {
-		if (!transport.ready) {
-			pendingMessages.push(msg);
-			return;
-		}
-		transport.send(msg);
-	}
-	transport.onReady(() => {
-		pendingMessages.length = 0;
-		initSent = false;
-		sendInit();
-		if (autoOpen) transport.send({
-			type: "@statelyai.requestOpen",
-			sessionId
-		});
-	});
-	transport.onMessage((msg) => {
-		if (destroyed) return;
-		switch (msg.type) {
-			case "@statelyai.retrieved":
-				exportManager.resolve(msg.requestId, msg.data);
-				break;
-			case "@statelyai.error":
-				exportManager.reject(new Error(msg.message), msg.requestId);
-				emitLocal("error", {
-					code: msg.code,
-					message: msg.message
-				});
-				events.emit("error", {
-					code: msg.code,
-					message: msg.message
-				});
-				break;
-			default: break;
-		}
-	});
-	function emitLocal(event, data) {
-		const set = localListeners[event];
-		if (!set) return;
-		for (const handler of set) handler(data);
-	}
-	const actors = /* @__PURE__ */ new Map();
-	/** Tracks which actors we've already emitted local 'register' events for. */
-	const locallyRegistered = /* @__PURE__ */ new Set();
-	/**
-	* Maps target actorId → source actorId for the most recent `@xstate.event`.
-	* Read + cleared by `handleSnapshot` so the source info propagates into the
-	* `actorSnapshot` message. xstate emits `@xstate.event` immediately before
-	* `@xstate.snapshot` for the same actor.
-	*/
-	const pendingEventSource = /* @__PURE__ */ new Map();
-	function emitRegisterOnce(entry) {
-		if (locallyRegistered.has(entry.actorId)) return;
-		locallyRegistered.add(entry.actorId);
-		emitLocal("register", entry);
-	}
-	function snapshotValue(actorRef) {
-		try {
-			return serializeSnapshot(actorRef.getSnapshot());
-		} catch {
-			return null;
-		}
-	}
-	function toEntry(actorRef, rootActorId) {
-		return {
-			actorId: actorRef.sessionId,
-			parentActorId: actorRef._parent?.sessionId ?? null,
-			rootId: rootActorId,
-			id: actorRef.id,
-			systemId: actorRef.systemId,
-			snapshot: snapshotValue(actorRef),
-			machineConfig: extractMachineConfig(actorRef)
-		};
-	}
-	function toSystemEntry(entry) {
-		return {
-			actorId: entry.actorId,
-			parentActorId: entry.parentActorId,
-			id: entry.id,
-			machine: entry.machineConfig,
-			snapshot: entry.snapshot ?? void 0
-		};
-	}
-	/**
-	* Walk the actor tree and populate the local `actors` map. Idempotent —
-	* existing entries stay in place but have their snapshot refreshed.
-	*/
-	function backfillActorTree(actorRef, rootActorId) {
-		const existing = actors.get(actorRef.sessionId);
-		const entry = existing ?? toEntry(actorRef, rootActorId);
-		if (existing) existing.snapshot = snapshotValue(actorRef);
-		else actors.set(entry.actorId, entry);
-		emitRegisterOnce(entry);
-		const children = actorRef.getSnapshot()?.children ?? {};
-		for (const child of Object.values(children)) if (child) backfillActorTree(child, rootActorId);
-	}
-	const inspectedRoots = /* @__PURE__ */ new Map();
-	function sendInit() {
-		for (const [rootActorId, { actor }] of inspectedRoots) backfillActorTree(actor, rootActorId);
-		send({
-			type: "@statelyai.system.init",
-			mode: "inspecting",
-			actors: Array.from(actors.values()).map(toSystemEntry),
-			selectedActorId: selectedActorId ?? inspectedRoots.keys().next().value ?? sessionId,
-			...theme && { theme },
-			...readOnly !== void 0 && { readOnly },
-			...depth !== void 0 && { depth },
-			...capabilities !== void 0 && { capabilities },
-			...panels?.leftPanels && { leftPanels: panels.leftPanels },
-			...panels?.rightPanels && { rightPanels: panels.rightPanels },
-			...panels?.activePanels && { activePanels: panels.activePanels }
-		});
-		initSent = true;
-	}
-	function handleActor(actorRef, rootActorId) {
-		if (actors.has(actorRef.sessionId)) return;
-		const entry = toEntry(actorRef, rootActorId);
-		actors.set(entry.actorId, entry);
-		if (!initSent) return;
-		send({
-			type: "@statelyai.system.actorRegistered",
-			actorId: entry.actorId,
-			parentActorId: entry.parentActorId,
-			id: entry.id,
-			machine: entry.machineConfig,
-			snapshot: entry.snapshot ?? void 0
-		});
-		emitRegisterOnce(entry);
-	}
-	function handleSnapshot(actorRef, snapshot, triggeringEvent, rootActorId) {
-		if (!actors.has(actorRef.sessionId)) handleActor(actorRef, rootActorId);
-		const entry = actors.get(actorRef.sessionId);
-		if (!entry) return;
-		const serialized = serializeSnapshot(snapshot);
-		entry.snapshot = serialized;
-		const sourceActorId = pendingEventSource.get(entry.actorId) ?? null;
-		pendingEventSource.delete(entry.actorId);
-		if (initSent) send({
-			type: "@statelyai.system.actorSnapshot",
-			actorId: entry.actorId,
-			snapshot: serialized,
-			event: triggeringEvent ?? null,
-			...sourceActorId ? { sourceActorId } : {}
-		});
-		emitLocal("snapshot", entry);
-		const status = snapshot?.status;
-		if (status === "done" || status === "stopped" || status === "error") {
-			actors.delete(entry.actorId);
-			pendingEventSource.delete(entry.actorId);
-			if (initSent) send({
-				type: "@statelyai.system.actorStopped",
-				actorId: entry.actorId
-			});
-			emitLocal("stopped", { actorId: entry.actorId });
-		}
-	}
-	function inspectActor(actor) {
-		const root = actor;
-		const rootActorId = root.sessionId;
-		const existing = inspectedRoots.get(rootActorId);
-		if (existing) return existing.subscription;
-		const subscription = root.system.inspect((inspectionEvent) => {
-			if (destroyed) return;
-			switch (inspectionEvent.type) {
-				case "@xstate.actor":
-					handleActor(inspectionEvent.actorRef, rootActorId);
-					break;
-				case "@xstate.event":
-					if (inspectionEvent.sourceRef) pendingEventSource.set(inspectionEvent.actorRef.sessionId, inspectionEvent.sourceRef.sessionId);
-					break;
-				case "@xstate.snapshot":
-					handleSnapshot(inspectionEvent.actorRef, inspectionEvent.snapshot, inspectionEvent.event, rootActorId);
-					break;
-				default: break;
-			}
-		});
-		inspectedRoots.set(rootActorId, {
-			actor: root,
-			subscription
-		});
-		backfillActorTree(root, rootActorId);
-		if (initSent) sendInit();
-		return { unsubscribe() {
-			subscription.unsubscribe();
-			inspectedRoots.delete(rootActorId);
-		} };
-	}
-	function manualRegister(id, opts) {
-		if (actors.has(id)) return;
-		const entry = {
-			actorId: id,
-			parentActorId: opts?.parent ?? null,
-			rootId: sessionId,
-			id,
-			systemId: opts?.systemId,
-			snapshot: opts?.snapshot ?? null,
-			machineConfig: opts?.machine ?? null
-		};
-		actors.set(id, entry);
-		if (initSent) send({
-			type: "@statelyai.system.actorRegistered",
-			actorId: id,
-			parentActorId: entry.parentActorId,
-			id,
-			machine: entry.machineConfig,
-			snapshot: entry.snapshot ?? void 0
-		});
-		emitRegisterOnce(entry);
-	}
-	function manualSnapshot(actorId, snapshot, event, sourceActorId) {
-		if (!actors.has(actorId)) manualRegister(actorId);
-		const entry = actors.get(actorId);
-		entry.snapshot = snapshot;
-		if (initSent) send({
-			type: "@statelyai.system.actorSnapshot",
-			actorId,
-			snapshot,
-			event: event ?? null,
-			...sourceActorId ? { sourceActorId } : {}
-		});
-		emitLocal("snapshot", entry);
-	}
-	function manualEvent(actorId, event, eventOpts) {
-		const eventObj = typeof event === "string" ? { type: event } : { ...event };
-		manualSnapshot(actorId, actors.get(actorId)?.snapshot ?? null, eventObj, eventOpts?.source ?? null);
-	}
-	function manualStop(actorId) {
-		if (!actors.has(actorId)) return;
-		actors.delete(actorId);
-		if (initSent) send({
-			type: "@statelyai.system.actorStopped",
-			actorId
-		});
-		emitLocal("stopped", { actorId });
-	}
-	return {
-		actors,
-		get sessionId() {
-			return sessionId;
-		},
-		inspect: inspectActor,
-		on(event, handler) {
-			if (!localListeners[event]) localListeners[event] = /* @__PURE__ */ new Set();
-			localListeners[event].add(handler);
-			return () => {
-				localListeners[event].delete(handler);
-			};
-		},
-		off(event, handler) {
-			localListeners[event]?.delete(handler);
-		},
-		export(format, callOptions) {
-			return exportManager.start(format, callOptions, "Inspector is destroyed", () => destroyed);
-		},
-		actor: manualRegister,
-		snapshot: manualSnapshot,
-		event: manualEvent,
-		stop: manualStop,
-		destroy() {
-			if (destroyed) return;
-			destroyed = true;
-			try {
-				for (const { subscription } of inspectedRoots.values()) subscription.unsubscribe();
-			} catch {}
-			if (ownsTransport) transport.destroy();
-			exportManager.clear("Inspector destroyed");
-			events.clear();
-			actors.clear();
-			inspectedRoots.clear();
-			pendingMessages.length = 0;
-			for (const set of Object.values(localListeners)) set?.clear();
-		}
-	};
-}
-
-//#endregion
-export { createStatelyInspector };
+export { createInspector, createStatelyInspector };

package/dist/patchTypes.d.mts

@@ -1,2 +1,2 @@
-import { a as EditorStateType, n as CanvasColor, o as GraphPatch, s as ImplementationSourceType, t as ActionLocation } from "./index-BRW2DecD.mjs";
+import { a as EditorStateType, n as CanvasColor, o as GraphPatch, s as ImplementationSourceType, t as ActionLocation } from "./index-DVjNSTuQ.mjs";
 export { type ActionLocation, type CanvasColor, type EditorStateType, type GraphPatch, type ImplementationSourceType };

package/dist/protocol.d.mts

@@ -338,8 +338,29 @@ interface ActorSystemEntry {
   /** Optional current snapshot (`{value, status, ...}`). */
   snapshot?: unknown;
 }
+/** JSON-safe record of an action executed during an inspected transition. */
+interface InspectionAction {
+  type: string;
+  params?: unknown;
+}
+/** JSON-safe identity of a state transition taken during a macrostep. */
+interface InspectionTakenTransition {
+  sourceStateId: string | null;
+  targetStateIds: string[];
+  eventType?: string;
+  reenter?: boolean;
+}
+/** JSON-safe record of an event sent or scheduled during a transition. */
+interface InspectionSentEvent {
+  targetActorId?: string;
+  targetId: string;
+  event: unknown;
+  delay?: number;
+  id?: string;
+}
 interface SystemInitMessage {
   type: "@statelyai.system.init";
+  protocolVersion?: number;
   /** All known actors at the moment the system is first streamed. */
   actors: ActorSystemEntry[];
   /** Actor id the viz should focus first. Defaults to the root. */
@@ -367,10 +388,18 @@ interface SystemActorRegisteredMessage {
 interface SystemActorSnapshotMessage {
   type: "@statelyai.system.actorSnapshot";
   actorId: string;
+  /** Snapshot before the event was processed. */
+  previousSnapshot?: unknown | null;
   snapshot: unknown;
   event?: unknown | null;
   /** The actorId of the actor that sent the triggering event, if known. */
   sourceActorId?: string | null;
+  /** Actions executed while processing the event. */
+  actions?: InspectionAction[];
+  /** State transitions taken across every microstep. */
+  transitions?: InspectionTakenTransition[];
+  /** Events sent or scheduled while processing the event. */
+  sent?: InspectionSentEvent[];
 }
 /** An actor reached a final state / was stopped. */
 interface SystemActorStoppedMessage {
@@ -468,6 +497,7 @@ type ClientMessage = InitMessage | SetApiKeyMessage | ProjectInitMessage | Proje
 type VizMessage = ReadyMessage | LoadedMessage | ChangeMessage | SaveMessage | ProjectMachineSelectedMessage | RetrievedMessage | ErrorMessage | CapabilityDeniedMessage | UploadRequestMessage;
 interface RegisterMessage {
   type: "@statelyai.register";
+  protocolVersion?: number;
   role: "client" | "viz";
   sessionId: string;
   metadata?: {
@@ -477,10 +507,7 @@ interface RegisterMessage {
 }
 interface RegisteredMessage {
   type: "@statelyai.registered";
-  sessionId: string;
-}
-interface RequestOpenMessage {
-  type: "@statelyai.requestOpen";
+  protocolVersion?: number;
   sessionId: string;
 }
 /**
@@ -508,9 +535,11 @@ interface SessionAddedMessage {
   sessionId: string;
 }
 /** All session-management messages for the WS relay. */
-type SessionMessage = RegisterMessage | RegisteredMessage | RequestOpenMessage | AddSessionMessage | SessionAddedMessage;
+type SessionMessage = RegisterMessage | RegisteredMessage | AddSessionMessage | SessionAddedMessage;
 /** Any valid protocol message. */
 type ProtocolMessage = ClientMessage | VizMessage | SessionMessage;
 declare const PREFIX = "@statelyai.";
+/** Current WebSocket inspection protocol version. */
+declare const INSPECTION_PROTOCOL_VERSION = 1;
 //#endregion
-export { ActorSystemEntry, AddSessionMessage, CapabilityDeniedCapability, CapabilityDeniedEvent, CapabilityDeniedMessage, ChangeMessage, ClientMessage, CommentsConfig, EditorCapabilities, EmbedEventHandler, EmbedEventMap, EmbedEventName, EmbedMode, ErrorMessage, ExportCallOptions, ExportFormat, ExportFormatMap, InitMessage, InitOptions, InspectSnapshotMessage, LoadedMessage, MachineInitOptions, MachineSourceLocations, PREFIX, ProjectEmbedMachine, ProjectInitMessage, ProjectInitOptions, ProjectMachineSelectedMessage, ProjectSelectMachineMessage, ProjectUpdateMessage, ProtocolMessage, ReadOnlyReason, ReadyMessage, RegisterMessage, RegisteredMessage, RequestOpenMessage, RetrieveMessage, RetrievedMessage, SaveMessage, SessionAddedMessage, SessionMessage, SetApiKeyMessage, SetModeMessage, SetSettingsMessage, SetThemeMessage, SourceLocation, SourceRange, StateSourceLocation, SystemActorRegisteredMessage, SystemActorSnapshotMessage, SystemActorStoppedMessage, SystemInitMessage, ToastMessage, UpdateMessage, UploadCapabilitiesMessage, UploadFileInfo, UploadRequestMessage, UploadResponseMessage, UploadResult, ValidationIssue, VizMessage };
+export { ActorSystemEntry, AddSessionMessage, CapabilityDeniedCapability, CapabilityDeniedEvent, CapabilityDeniedMessage, ChangeMessage, ClientMessage, CommentsConfig, EditorCapabilities, EmbedEventHandler, EmbedEventMap, EmbedEventName, EmbedMode, ErrorMessage, ExportCallOptions, ExportFormat, ExportFormatMap, INSPECTION_PROTOCOL_VERSION, InitMessage, InitOptions, InspectSnapshotMessage, InspectionAction, InspectionSentEvent, InspectionTakenTransition, LoadedMessage, MachineInitOptions, MachineSourceLocations, PREFIX, ProjectEmbedMachine, ProjectInitMessage, ProjectInitOptions, ProjectMachineSelectedMessage, ProjectSelectMachineMessage, ProjectUpdateMessage, ProtocolMessage, ReadOnlyReason, ReadyMessage, RegisterMessage, RegisteredMessage, RetrieveMessage, RetrievedMessage, SaveMessage, SessionAddedMessage, SessionMessage, SetApiKeyMessage, SetModeMessage, SetSettingsMessage, SetThemeMessage, SourceLocation, SourceRange, StateSourceLocation, SystemActorRegisteredMessage, SystemActorSnapshotMessage, SystemActorStoppedMessage, SystemInitMessage, ToastMessage, UpdateMessage, UploadCapabilitiesMessage, UploadFileInfo, UploadRequestMessage, UploadResponseMessage, UploadResult, ValidationIssue, VizMessage };

package/dist/protocol.mjs

@@ -1,5 +1,7 @@
 //#region src/protocol.ts
 const PREFIX = "@statelyai.";
+/** Current WebSocket inspection protocol version. */
+const INSPECTION_PROTOCOL_VERSION = 1;
 
 //#endregion
-export { PREFIX };
+export { INSPECTION_PROTOCOL_VERSION, PREFIX };

package/dist/relay.d.mts

@@ -0,0 +1,43 @@
+import { ProtocolMessage } from "./protocol.mjs";
+
+//#region src/relay.d.ts
+type InspectionRelayRole = 'client' | 'viz';
+interface InspectionRelayPeer {
+  id: string;
+  role: InspectionRelayRole;
+  primarySessionId: string;
+  sessionIds: string[];
+}
+interface InspectionRelaySnapshot {
+  sessions: Record<string, ProtocolMessage[]>;
+}
+type InspectionRelayEffect = {
+  type: 'send';
+  peerId: string;
+  message: ProtocolMessage;
+};
+interface InspectionRelay {
+  /** Restore a live peer after process/DO hibernation. */
+  connect(peer: InspectionRelayPeer): void;
+  disconnect(peerId: string): void;
+  clear(): void;
+  peer(peerId: string): InspectionRelayPeer | undefined;
+  receive(peerId: string, raw: unknown): InspectionRelayEffect[];
+  snapshot(): InspectionRelaySnapshot;
+}
+interface CreateInspectionRelayOptions {
+  snapshot?: InspectionRelaySnapshot;
+  maxReplayMessages?: number;
+  /** Maximum sessions retained for late-join replay. Default 100. */
+  maxReplaySessions?: number;
+}
+/**
+ * Runtime-neutral WebSocket inspection room.
+ *
+ * It owns protocol registration, routing, multiplexed session membership, and
+ * bounded late-join replay. Node and Durable Object adapters only translate
+ * `send` effects to their native WebSocket APIs and persist `snapshot()`.
+ */
+declare function createInspectionRelay(options?: CreateInspectionRelayOptions): InspectionRelay;
+//#endregion
+export { CreateInspectionRelayOptions, InspectionRelay, InspectionRelayEffect, InspectionRelayPeer, InspectionRelayRole, InspectionRelaySnapshot, createInspectionRelay };

package/dist/relay.mjs

@@ -0,0 +1,153 @@
+import { INSPECTION_PROTOCOL_VERSION, PREFIX } from "./protocol.mjs";
+
+//#region src/relay.ts
+function parseMessage(raw) {
+	if (raw instanceof ArrayBuffer) raw = new TextDecoder().decode(raw);
+	if (typeof raw === "string") try {
+		raw = JSON.parse(raw);
+	} catch {
+		return null;
+	}
+	if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+	const message = raw;
+	return typeof message.type === "string" && message.type.startsWith(PREFIX) ? message : null;
+}
+function errorMessage(code, message) {
+	return {
+		type: "@statelyai.error",
+		code,
+		message
+	};
+}
+function compactReplay(replay, message, max) {
+	const record = message;
+	const type = record.type;
+	if (type === "@statelyai.system.init") for (let index = replay.length - 1; index >= 0; index--) {
+		const replayType = replay[index].type;
+		if (replayType === "@statelyai.system.init" || replayType.startsWith("@statelyai.system.actor")) replay.splice(index, 1);
+	}
+	else if (type === "@statelyai.init") {
+		const index = replay.findIndex((entry) => entry.type === "@statelyai.init");
+		if (index >= 0) replay.splice(index, 1);
+	} else if (type === "@statelyai.system.actorSnapshot" || type === "@statelyai.inspectSnapshot") {
+		const actorId = record.actorId;
+		const index = replay.findIndex((entry) => {
+			const candidate = entry;
+			return candidate.type === type && candidate.actorId === actorId;
+		});
+		if (index >= 0) replay.splice(index, 1);
+	}
+	replay.push(message);
+	if (replay.length > max) replay.splice(0, replay.length - max);
+}
+/**
+* Runtime-neutral WebSocket inspection room.
+*
+* It owns protocol registration, routing, multiplexed session membership, and
+* bounded late-join replay. Node and Durable Object adapters only translate
+* `send` effects to their native WebSocket APIs and persist `snapshot()`.
+*/
+function createInspectionRelay(options = {}) {
+	const maxReplayMessages = options.maxReplayMessages ?? 200;
+	const maxReplaySessions = Math.max(1, options.maxReplaySessions ?? 100);
+	const peers = /* @__PURE__ */ new Map();
+	const sessions = new Map(Object.entries(options.snapshot?.sessions ?? {}).slice(-maxReplaySessions).map(([id, replay]) => [id, [...replay]]));
+	const send = (peerId, message) => ({
+		type: "send",
+		peerId,
+		message
+	});
+	function replayTo(peerId, sessionId) {
+		return (sessions.get(sessionId) ?? []).map((message) => send(peerId, message));
+	}
+	function oppositePeers(sender, sessionId) {
+		return Array.from(peers.values()).filter((peer) => peer.id !== sender.id && peer.role !== sender.role && peer.sessionIds.includes(sessionId));
+	}
+	function retainReplay(sessionId, replay) {
+		sessions.delete(sessionId);
+		sessions.set(sessionId, replay);
+		while (sessions.size > maxReplaySessions) {
+			const oldestSessionId = sessions.keys().next().value;
+			if (oldestSessionId === void 0) break;
+			sessions.delete(oldestSessionId);
+		}
+	}
+	return {
+		connect(peer) {
+			peers.set(peer.id, {
+				...peer,
+				sessionIds: Array.from(new Set([peer.primarySessionId, ...peer.sessionIds]))
+			});
+		},
+		disconnect(peerId) {
+			peers.delete(peerId);
+		},
+		clear() {
+			peers.clear();
+			sessions.clear();
+		},
+		peer(peerId) {
+			const peer = peers.get(peerId);
+			return peer ? {
+				...peer,
+				sessionIds: [...peer.sessionIds]
+			} : void 0;
+		},
+		receive(peerId, raw) {
+			const message = parseMessage(raw);
+			if (!message) return [];
+			if (message.type === "@statelyai.register") {
+				const role = message.role;
+				const sessionId = message.sessionId;
+				const protocolVersion = message.protocolVersion;
+				if (role !== "client" && role !== "viz" || typeof sessionId !== "string" || sessionId.length === 0) return [send(peerId, errorMessage("invalid_registration", "Invalid relay registration"))];
+				if (typeof protocolVersion === "number" && protocolVersion > INSPECTION_PROTOCOL_VERSION) return [send(peerId, errorMessage("unsupported_protocol", `Protocol ${protocolVersion} is not supported`))];
+				const peer = {
+					id: peerId,
+					role,
+					primarySessionId: sessionId,
+					sessionIds: [sessionId]
+				};
+				peers.set(peerId, peer);
+				const effects = [send(peerId, {
+					type: "@statelyai.registered",
+					protocolVersion: INSPECTION_PROTOCOL_VERSION,
+					sessionId
+				})];
+				if (role === "viz") effects.push(...replayTo(peerId, sessionId));
+				return effects;
+			}
+			const sender = peers.get(peerId);
+			if (!sender) return [send(peerId, errorMessage("not_registered", "Register before sending messages"))];
+			if (message.type === "@statelyai.addSession") {
+				const sessionId = message.sessionId;
+				if (typeof sessionId !== "string" || sessionId.length === 0) return [send(peerId, errorMessage("invalid_session", "Invalid session id"))];
+				if (!sender.sessionIds.includes(sessionId)) sender.sessionIds.push(sessionId);
+				const effects = [send(peerId, {
+					type: "@statelyai.sessionAdded",
+					sessionId
+				})];
+				if (sender.role === "viz") effects.push(...replayTo(peerId, sessionId));
+				return effects;
+			}
+			const sessionId = (typeof message.sessionId === "string" ? message.sessionId : void 0) ?? sender.primarySessionId;
+			if (!sender.sessionIds.includes(sessionId)) return [send(peerId, errorMessage("unknown_session", "Peer is not registered for session"))];
+			const stamped = {
+				...message,
+				sessionId
+			};
+			if (sender.role === "client") {
+				const replay = sessions.get(sessionId) ?? [];
+				compactReplay(replay, stamped, maxReplayMessages);
+				retainReplay(sessionId, replay);
+			}
+			return oppositePeers(sender, sessionId).map((peer) => send(peer.id, stamped));
+		},
+		snapshot() {
+			return { sessions: Object.fromEntries(Array.from(sessions, ([sessionId, replay]) => [sessionId, [...replay]])) };
+		}
+	};
+}
+
+//#endregion
+export { createInspectionRelay };

package/dist/studio.d.mts

@@ -1,4 +1,4 @@
-import { n as StatelyCredential, t as StatelyAuthMode } from "./auth-DO1-eQcU.mjs";
+import { n as StatelyCredential, t as StatelyAuthMode } from "./auth-DmPZiERd.mjs";
 
 //#region src/studio.d.ts
 interface StudioClientOptions {

package/dist/sync.d.mts

@@ -1,4 +1,4 @@
-import { b as DigraphConfig, i as StatelyGraph } from "./graph-Dq5ycdSq.mjs";
+import { b as DigraphConfig, i as StatelyGraph } from "./graph-R0sbxnZ7.mjs";
 import { CreateProjectInput, ProjectData, StudioClient, StudioMachineRecord, XStateVersion } from "./studio.mjs";
 import { GraphDiff } from "@statelyai/graph";
 

package/dist/sync.mjs

@@ -1,5 +1,5 @@
 import { createStatelyClient } from "./studio.mjs";
-import { d as xstateSourceToConfig, f as findStatelyPragmaAttachments, i as detectXStateSourceProfile, m as upsertStatelyPragma, p as getStatelyPragma, s as graphToXStateTS, t as INLINE_EXPRESSION_DIRECTIVE_FIELDS, u as serializeJS } from "./dist-C-AdA8Iw.mjs";
+import { d as xstateSourceToConfig, f as findStatelyPragmaAttachments, i as detectXStateSourceProfile, m as upsertStatelyPragma, p as getStatelyPragma, s as graphToXStateTS, t as INLINE_EXPRESSION_DIRECTIVE_FIELDS, u as serializeJS } from "./dist-CHGcvOdQ.mjs";
 import { fromStudioMachine, toStudioMachine } from "./graph.mjs";
 import * as ts$1 from "typescript";
 import ts from "typescript";