@shaper.org/core 1.1.1 → 1.2.0-0

package/dist/client/index.d.mts

@@ -1,58 +1,159 @@
 import { ErrorPayload, FullReloadPayload, PrunePayload, UpdatePayload } from "vite/types/hmrPayload.js";
 import { ViteHotContext } from "vite/types/hot.js";
 
-//#region src/client/iframe-post-message.d.ts
-type PostMessageType = "server-ready" | "all-routes" | "route-change" | "route-refresh" | "error" | "inspector-tree-update" | "inspector-selected-node" | "inspector-reset-inline-style";
-interface PostMessage {
+//#region src/client/vite-hook.d.ts
+type ViteUpdateCallback = ((data: UpdatePayload, timestamp: number) => void) | null;
+type VitePruneCallback = ((data: PrunePayload, timestamp: number) => void) | null;
+type VitFullReloadCallback = ((data: FullReloadPayload, timestamp: number) => void) | null;
+type ViteErrorCallback = ((data: ErrorPayload, timestamp: number) => void) | null;
+type ViteInvalidateCallback = ((data: any, timestamp: number) => void) | null;
+type ViteWebSocketConnectCallback = ((data: any, timestamp: number) => void) | null;
+type ViteWebSocketDisconnectCallback = ((data: any, timestamp: number) => void) | null;
+declare class ViteHook {
+  private hmr;
+  constructor();
+  hotExists(hmr: ViteHotContext | undefined): hmr is ViteHotContext;
+  onBeforeUpdate(fn?: ViteUpdateCallback): void;
+  onAfterUpdate(fn?: ViteUpdateCallback): void;
+  onBeforePrune(fn?: VitePruneCallback): void;
+  onBeforeFullReload(fn?: VitFullReloadCallback): void;
+  onError(fn?: ViteErrorCallback): void;
+  onInvalidate(fn?: ViteInvalidateCallback): void;
+  onWsConnect(fn?: ViteWebSocketConnectCallback): void;
+  onWsDisconnect(fn?: ViteWebSocketDisconnectCallback): void;
+}
+//#endregion
+//#region src/client/types/base.d.ts
+interface BasePostMessage {
   message: any;
-  type: PostMessageType;
+  type: string;
   object: "shaper-post-message";
 }
-interface RouteInfo {
-  name: string;
-  path: string;
-  file: string;
-}
-interface ServerReadyMessage extends PostMessage {
+interface ServerReadyMessage extends BasePostMessage {
   type: "server-ready";
   message: {
     satus: "ok";
   };
 }
-interface AllRoutesMessage extends PostMessage {
+//#endregion
+//#region src/client/types/inspector.d.ts
+interface SelectedNode {
+  file: string;
+  line: number;
+  column: number;
+  attributes: Record<string, string>;
+}
+interface InspectorSelectedNodeMessage extends BasePostMessage {
+  type: "inspector-selected-node";
+  message: SelectedNode;
+}
+interface InspectorNode {
+  id: string;
+  tag: string;
+  children: InspectorNode[];
+}
+interface InspectorTreeUpdateMessage extends BasePostMessage {
+  type: "inspector-tree-update";
+  message: {
+    tree: InspectorNode;
+  };
+}
+//#endregion
+//#region src/client/types/network.d.ts
+interface NetworkRequest {
+  url: string;
+  method: string;
+  status: number;
+  statusText: string;
+  requestBody: string | undefined;
+  timestamp: string;
+  origin: string;
+  headers: Record<string, string>;
+  responseBody: string | undefined;
+  duration: number;
+}
+interface NetworkRequestMessage extends BasePostMessage {
+  message: NetworkRequest;
+  type: "network-request";
+}
+interface NetworkRequestChunkMessage extends BasePostMessage {
+  message: NetworkRequest;
+  type: "network-request-chunk";
+}
+//#endregion
+//#region src/client/types/route-event.d.ts
+interface RouteInfo {
+  name: string;
+  path: string;
+  file: string;
+}
+interface AllRoutesMessage extends BasePostMessage {
   type: "all-routes";
   message: {
     routes: RouteInfo[];
   };
 }
-interface RouteChangeMessage extends PostMessage {
+interface RouteChangeMessage extends BasePostMessage {
   type: "route-change";
   message: RouteInfo;
 }
-interface RouteRefreshMessage extends PostMessage {
+interface RouteRefreshMessage extends BasePostMessage {
   type: "route-refresh";
   message: RouteInfo;
 }
-interface ErrorInfo {
-  errorType: string;
+//#endregion
+//#region src/client/types/runtime.d.ts
+interface ConsoleLog {
+  level: "log" | "warn" | "error";
+  message: string;
+  fingerprint: string;
   timestamp: number;
-  lineno?: number;
-  colno?: number;
+  type: "CONSOLE";
+}
+interface ConsoleMessage extends BasePostMessage {
+  message: ConsoleLog;
+  type: "console";
+}
+interface UnhandledRejection {
+  message: string;
   stack: string;
-  has_blank_screen: boolean;
-  filename?: string;
+  readyState: string;
+  userAgent: string;
+  rootPresent: boolean;
+  hasBlankScreen: boolean;
+  scripts: string[];
+  fingerprint: string;
+  timestamp: number;
+  type: "UNHANDLED_REJECTION";
 }
-interface SelectedNode {
-  file: string;
-  line: number;
-  column: number;
-  attributes: Record<string, string>;
+interface UnhandledRejectionMessage extends BasePostMessage {
+  message: UnhandledRejection;
+  type: "unhandled-rejection";
 }
-interface InspectorNode {
-  id: string;
-  tag: string;
-  children: InspectorNode[];
+interface RuntimeError {
+  message: string;
+  lineno: number;
+  colno: number;
+  filename: string | undefined;
+  stack: string;
+  readyState: DocumentReadyState;
+  userAgent: string;
+  rootPresent: boolean;
+  scripts: string[];
+  hasBlankScreen: boolean;
+  fingerprint: string;
+  timestamp: number;
+  type: "RUNTIME_ERROR";
 }
+interface RuntimeErrorMessage extends BasePostMessage {
+  message: RuntimeError;
+  type: "runtime-error";
+}
+//#endregion
+//#region src/client/types/message.d.ts
+type PostMessage = ConsoleMessage | UnhandledRejectionMessage | RuntimeErrorMessage | AllRoutesMessage | RouteRefreshMessage | RouteChangeMessage | ServerReadyMessage | InspectorSelectedNodeMessage | InspectorTreeUpdateMessage | NetworkRequestMessage | NetworkRequestChunkMessage;
+//#endregion
+//#region src/client/iframe-post-message.d.ts
 declare class IframePostMessageClient {
   authHost: string;
   private receiveCallbacks;
@@ -68,8 +169,10 @@ declare class IframePostMessageClient {
   sendAllRoutes(routes: RouteInfo[]): void;
   sendRouteChange(route: RouteInfo): void;
   sendRouteRefresh(route: RouteInfo): void;
-  sendError(errorInfo: ErrorInfo): void;
-  sendConsole(): void;
+  sendRuntimeError(runtimeError: RuntimeError): void;
+  sendUnhandledRejection(error: UnhandledRejection): void;
+  sendConsoleMessage(consoleMessage: ConsoleLog): void;
+  sendNetworkRequest(request: NetworkRequest): void;
   sendSelectedNode(node: SelectedNode): void;
   sendTree(tree: InspectorNode): void;
 }
@@ -86,59 +189,114 @@ interface WorkspaceModeMessage extends ReceiveBaseMessage {
   };
 }
 declare const isWorkspaceModeEvent: (event: MessageEvent<any>) => event is MessageEvent<WorkspaceModeMessage>;
-interface NodeAttributesPatchMessage extends ReceiveBaseMessage {
-  type: "NODE_ATTRIBUTES_PATCH";
+interface SetSelectNodeMessage extends ReceiveBaseMessage {
+  type: "SET_SELECT_NODE";
+  data: {
+    id: string;
+  };
+}
+declare const isSetSelectNodeEvent: (event: MessageEvent<any>) => event is MessageEvent<SetSelectNodeMessage>;
+interface SetHoverNodeMessage extends ReceiveBaseMessage {
+  type: "SET_HOVER_NODE";
   data: {
     id: string;
-    property: string;
-    value: string;
   };
 }
-declare const isNodeAttributesPatchEvent: (event: MessageEvent<any>) => event is MessageEvent<NodeAttributesPatchMessage>;
-interface NodeAttributesPatchBatchMessage extends ReceiveBaseMessage {
-  type: "NODE_ATTRIBUTES_PATCH_BATCH";
+declare const isSetHoverNodeEvent: (event: MessageEvent<any>) => event is MessageEvent<SetSelectNodeMessage>;
+interface UpdatePropsEvent {
+  type: "update_props";
   data: {
-    selector: string;
+    id: string;
     property: string;
     value: string;
-  }[];
+  };
 }
-declare const isNodeAttributesPatchBatchEvent: (event: MessageEvent<any>) => event is MessageEvent<NodeAttributesPatchBatchMessage>;
-interface SetSelectNodeMessage extends ReceiveBaseMessage {
-  type: "SET_SELECT_NODE";
+interface AddFontEvent {
+  type: "add_font";
   data: {
     id: string;
+    url: string;
   };
 }
-declare const isSetSelectNodeEvent: (event: MessageEvent<any>) => event is MessageEvent<SetSelectNodeMessage>;
-interface SetHoverNodeMessage extends ReceiveBaseMessage {
-  type: "SET_HOVER_NODE";
+interface SetTextContentEvent {
+  type: "set_text_content";
   data: {
     id: string;
+    content: string;
   };
 }
-declare const isSetHoverNodeEvent: (event: MessageEvent<any>) => event is MessageEvent<SetSelectNodeMessage>;
-//#endregion
-//#region src/client/vite-hook.d.ts
-type ViteUpdateCallback = ((data: UpdatePayload, timestamp: number) => void) | null;
-type VitePruneCallback = ((data: PrunePayload, timestamp: number) => void) | null;
-type VitFullReloadCallback = ((data: FullReloadPayload, timestamp: number) => void) | null;
-type ViteErrorCallback = ((data: ErrorPayload, timestamp: number) => void) | null;
-type ViteInvalidateCallback = ((data: any, timestamp: number) => void) | null;
-type ViteWebSocketConnectCallback = ((data: any, timestamp: number) => void) | null;
-type ViteWebSocketDisconnectCallback = ((data: any, timestamp: number) => void) | null;
-declare class ViteHook {
-  private hmr;
-  constructor();
-  hotExists(hmr: ViteHotContext | undefined): hmr is ViteHotContext;
-  onBeforeUpdate(fn?: ViteUpdateCallback): void;
-  onAfterUpdate(fn?: ViteUpdateCallback): void;
-  onBeforePrune(fn?: VitePruneCallback): void;
-  onBeforeFullReload(fn?: VitFullReloadCallback): void;
-  onError(fn?: ViteErrorCallback): void;
-  onInvalidate(fn?: ViteInvalidateCallback): void;
-  onWsConnect(fn?: ViteWebSocketConnectCallback): void;
-  onWsDisconnect(fn?: ViteWebSocketDisconnectCallback): void;
+type PatchEvent = UpdatePropsEvent | AddFontEvent | SetTextContentEvent;
+interface UpdateBatchMessage extends ReceiveBaseMessage {
+  type: "UPDATE_BATCH";
+  data: {
+    events: PatchEvent[];
+  };
 }
+declare const isUpdateBatchEvent: (event: MessageEvent<any>) => event is MessageEvent<UpdateBatchMessage>;
+//#endregion
+//#region src/client/error-parser.d.ts
+declare function serialize(value: unknown, depth?: number, maxDepth?: number, seen?: WeakSet<any>): any;
+declare function hasMatchingStackFrame(error: unknown): boolean;
+declare function formatReason(response: Response): string;
+declare function extractResourceError(event: Event): {
+  message: string;
+  lineno: number;
+  colno: number;
+  filename: string;
+  stack: string;
+  readyState: DocumentReadyState;
+  userAgent: string;
+  rootPresent: boolean;
+  scripts: string[];
+} | null;
+declare function getRuntimeFingerprint(errorEvent: ErrorEvent): string;
+declare function parseError({
+  message,
+  lineno,
+  colno,
+  filename,
+  error
+}: {
+  message: string;
+  lineno: number;
+  colno: number;
+  filename?: string;
+  error?: any;
+}): {
+  message: string;
+  lineno: number;
+  colno: number;
+  filename: string | undefined;
+  stack: any;
+  readyState: DocumentReadyState;
+  userAgent: string;
+  rootPresent: boolean;
+  scripts: string[];
+};
+declare function parseViteError({
+  message,
+  lineno,
+  colno,
+  filename,
+  stack,
+  frame
+}: {
+  message: string;
+  lineno?: number;
+  colno?: number;
+  filename?: string;
+  stack: any;
+  frame?: string;
+}): {
+  message: string;
+  lineno: number;
+  colno: number;
+  filename: string | undefined;
+  stack: any;
+  readyState: DocumentReadyState;
+  userAgent: string;
+  rootPresent: boolean;
+  scripts: string[];
+};
 //#endregion
-export { AllRoutesMessage, IframePostMessageClient, InspectorNode, NodeAttributesPatchBatchMessage, NodeAttributesPatchMessage, PostMessage, PostMessageType, RouteChangeMessage, RouteInfo, RouteRefreshMessage, ServerReadyMessage, SetHoverNodeMessage, SetSelectNodeMessage, ViteHook, isNodeAttributesPatchBatchEvent, isNodeAttributesPatchEvent, isSetHoverNodeEvent, isSetSelectNodeEvent, isWorkspaceModeEvent };
+export { AddFontEvent, AllRoutesMessage, BasePostMessage, ConsoleLog, ConsoleMessage, IframePostMessageClient, InspectorNode, InspectorSelectedNodeMessage, InspectorTreeUpdateMessage, NetworkRequest, NetworkRequestChunkMessage, NetworkRequestMessage, PatchEvent, PostMessage, ReceiveBaseMessage, RouteChangeMessage, RouteInfo, RouteRefreshMessage, RuntimeError, RuntimeErrorMessage, SelectedNode, ServerReadyMessage, SetHoverNodeMessage, SetSelectNodeMessage, SetTextContentEvent, UnhandledRejection, UnhandledRejectionMessage, UpdateBatchMessage, UpdatePropsEvent, ViteHook, WorkspaceModeMessage, extractResourceError, formatReason, getRuntimeFingerprint, hasMatchingStackFrame, isSetHoverNodeEvent, isSetSelectNodeEvent, isUpdateBatchEvent, isWorkspaceModeEvent, parseError, parseViteError, serialize };

package/dist/client/index.mjs

@@ -1,3 +1,81 @@
+//#region src/client/vite-hook.ts
+var ViteHook = class {
+	hmr;
+	constructor() {
+		this.hmr = import.meta.hot;
+	}
+	hotExists(hmr) {
+		if (hmr) return true;
+		console.error("HotContext does not exists");
+		return false;
+	}
+	onBeforeUpdate(fn = null) {
+		if (!this.hotExists(this.hmr)) return;
+		this.hmr.on("vite:beforeUpdate", (data) => {
+			const timestamp = Date.now();
+			console.debug("beforeUpdate");
+			fn && fn(data, timestamp);
+		});
+	}
+	onAfterUpdate(fn = null) {
+		if (!this.hotExists(this.hmr)) return;
+		this.hmr.on("vite:afterUpdate", (data) => {
+			const timestamp = Date.now();
+			console.debug("afterUpdate");
+			fn && fn(data, timestamp);
+		});
+	}
+	onBeforePrune(fn = null) {
+		if (!this.hotExists(this.hmr)) return;
+		this.hmr.on("vite:beforePrune", (data) => {
+			const timestamp = Date.now();
+			console.debug("beforePrune");
+			fn && fn(data, timestamp);
+		});
+	}
+	onBeforeFullReload(fn = null) {
+		if (!this.hotExists(this.hmr)) return;
+		this.hmr.on("vite:beforeFullReload", (data) => {
+			const timestamp = Date.now();
+			console.debug("beforeFullReload");
+			fn && fn(data, timestamp);
+		});
+	}
+	onError(fn = null) {
+		if (!this.hotExists(this.hmr)) return;
+		this.hmr.on("vite:error", (data) => {
+			const timestamp = Date.now();
+			console.debug("error");
+			fn && fn(data, timestamp);
+		});
+	}
+	onInvalidate(fn = null) {
+		if (!this.hotExists(this.hmr)) return;
+		this.hmr.on("vite:invalidate", (data) => {
+			const timestamp = Date.now();
+			console.debug("invalidate");
+			fn && fn(data, timestamp);
+		});
+	}
+	onWsConnect(fn = null) {
+		if (!this.hotExists(this.hmr)) return;
+		this.hmr.on("vite:ws:connect", (data) => {
+			const timestamp = Date.now();
+			console.debug("ws:connect");
+			fn && fn(data, timestamp);
+		});
+	}
+	onWsDisconnect(fn = null) {
+		if (!this.hotExists(this.hmr)) return;
+		this.hmr.on("vite:ws:disconnect", (data) => {
+			const timestamp = Date.now();
+			console.debug(":ws:disconnect");
+			fn && fn(data, timestamp);
+		});
+	}
+};
+
+//#endregion
 //#region src/client/iframe-post-message.ts
 var IframePostMessageClient = class {
 	authHost;
@@ -14,7 +92,20 @@ var IframePostMessageClient = class {
 		if (!route.file.startsWith("src")) throw Error(`Invalid route file, route file should be relative to the root got: ${route.file}`);
 	}
 	_send(message) {
-		window.parent.postMessage(message, this.authHost);
+		if (!window.parent || !message || typeof message !== "object" || !message.object) return;
+		if ((() => {
+			try {
+				const fromAncestor = window.location?.ancestorOrigins?.item?.(0);
+				if (fromAncestor) return new URL(fromAncestor).origin;
+			} catch {}
+			try {
+				if (document.referrer) return new URL(document.referrer).origin;
+			} catch {}
+			return null;
+		})() !== this.authHost) return;
+		try {
+			window.parent.postMessage(message, this.authHost);
+		} catch {}
 	}
 	/**
 	* Allow consumers to register callbacks for incoming messages.
@@ -47,12 +138,14 @@ var IframePostMessageClient = class {
 		this._send(message);
 	}
 	sendRouteChange(route) {
+		console.log("routechange client", route);
 		this._ensure_route_file(route);
 		const message = {
 			type: "route-change",
 			message: { ...route },
 			object: "shaper-post-message"
 		};
+		console.log("routechange client message", message);
 		this._send(message);
 	}
 	sendRouteRefresh(route) {
@@ -64,15 +157,38 @@ var IframePostMessageClient = class {
 		};
 		this._send(message);
 	}
-	sendError(errorInfo) {
+	sendRuntimeError(runtimeError) {
+		const message = {
+			type: "runtime-error",
+			message: runtimeError,
+			object: "shaper-post-message"
+		};
+		this._send(message);
+	}
+	sendUnhandledRejection(error) {
+		const message = {
+			type: "unhandled-rejection",
+			message: error,
+			object: "shaper-post-message"
+		};
+		this._send(message);
+	}
+	sendConsoleMessage(consoleMessage) {
 		const message = {
-			type: "error",
-			message: errorInfo,
+			type: "console",
+			message: consoleMessage,
+			object: "shaper-post-message"
+		};
+		this._send(message);
+	}
+	sendNetworkRequest(request) {
+		const message = {
+			type: "network-request",
+			message: request,
 			object: "shaper-post-message"
 		};
 		this._send(message);
 	}
-	sendConsole() {}
 	sendSelectedNode(node) {
 		const message = {
 			type: "inspector-selected-node",
@@ -93,96 +209,156 @@ var IframePostMessageClient = class {
 const isWorkspaceModeEvent = (event) => {
 	return event.data.type === "WORKSPACE_MODE";
 };
-const isNodeAttributesPatchEvent = (event) => {
-	return event.data.type === "NODE_ATTRIBUTES_PATCH";
-};
-const isNodeAttributesPatchBatchEvent = (event) => {
-	return event.data.type === "NODE_ATTRIBUTES_PATCH_BATCH";
-};
 const isSetSelectNodeEvent = (event) => {
 	return event.data.type === "SET_SELECT_NODE";
 };
 const isSetHoverNodeEvent = (event) => {
 	return event.data.type === "SET_HOVER_NODE";
 };
+const isUpdateBatchEvent = (event) => {
+	return event.data.type === "UPDATE_BATCH";
+};
 
 //#endregion
-//#region src/client/vite-hook.ts
-var ViteHook = class {
-	hmr;
-	constructor() {
-		this.hmr = import.meta.hot;
-	}
-	hotExists(hmr) {
-		if (hmr) return true;
-		console.error("HotContext does not exists");
-		return false;
-	}
-	onBeforeUpdate(fn = null) {
-		if (!this.hotExists(this.hmr)) return;
-		this.hmr.on("vite:beforeUpdate", (data) => {
-			const timestamp = Date.now();
-			console.debug("beforeUpdate");
-			fn && fn(data, timestamp);
-		});
-	}
-	onAfterUpdate(fn = null) {
-		if (!this.hotExists(this.hmr)) return;
-		this.hmr.on("vite:afterUpdate", (data) => {
-			const timestamp = Date.now();
-			console.debug("afterUpdate");
-			fn && fn(data, timestamp);
-		});
-	}
-	onBeforePrune(fn = null) {
-		if (!this.hotExists(this.hmr)) return;
-		this.hmr.on("vite:beforePrune", (data) => {
-			const timestamp = Date.now();
-			console.debug("beforePrune");
-			fn && fn(data, timestamp);
-		});
-	}
-	onBeforeFullReload(fn = null) {
-		if (!this.hotExists(this.hmr)) return;
-		this.hmr.on("vite:beforeFullReload", (data) => {
-			const timestamp = Date.now();
-			console.debug("beforeFullReload");
-			fn && fn(data, timestamp);
-		});
-	}
-	onError(fn = null) {
-		if (!this.hotExists(this.hmr)) return;
-		this.hmr.on("vite:error", (data) => {
-			const timestamp = Date.now();
-			console.debug("error");
-			fn && fn(data, timestamp);
-		});
-	}
-	onInvalidate(fn = null) {
-		if (!this.hotExists(this.hmr)) return;
-		this.hmr.on("vite:invalidate", (data) => {
-			const timestamp = Date.now();
-			console.debug("invalidate");
-			fn && fn(data, timestamp);
-		});
-	}
-	onWsConnect(fn = null) {
-		if (!this.hotExists(this.hmr)) return;
-		this.hmr.on("vite:ws:connect", (data) => {
-			const timestamp = Date.now();
-			console.debug("ws:connect");
-			fn && fn(data, timestamp);
-		});
-	}
-	onWsDisconnect(fn = null) {
-		if (!this.hotExists(this.hmr)) return;
-		this.hmr.on("vite:ws:disconnect", (data) => {
-			const timestamp = Date.now();
-			console.debug(":ws:disconnect");
-			fn && fn(data, timestamp);
-		});
+//#region src/client/error-parser.ts
+const VITE_DEP_PATH_REGEX = /\/(?:node_modules\/)?\.vite\/deps\//i;
+const DYNAMIC_IMPORT_FAILURE_REGEX = /failed to fetch dynamically imported module|error loading dynamically imported module|failed to load module script|importing a module script failed|expected a javascript-or-wasm module script|failed to load resource|resource load failed|disallowed mime type|net::err_aborted/i;
+const DIRECT_ERROR_FIELDS = [
+	"message",
+	"stack",
+	"filename",
+	"url",
+	"src",
+	"href"
+];
+const NESTED_ERROR_FIELDS = [
+	"error",
+	"reason",
+	"cause"
+];
+function serialize(value, depth = 0, maxDepth = 5, seen = /* @__PURE__ */ new WeakSet()) {
+	if (depth > maxDepth) return "[MaxDepthReached]";
+	if (value === null || value === void 0) return value;
+	if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
+	if (typeof value === "bigint") return value.toString();
+	if (typeof value === "function") return `[Function ${value.name || "anonymous"}]`;
+	if (typeof value === "symbol") return value.toString();
+	if (typeof value === "object") {
+		if (seen.has(value)) return "[Circular]";
+		seen.add(value);
+		if (value instanceof Error) return {
+			name: value.name,
+			message: value.message,
+			stack: value.stack
+		};
+		if (Array.isArray(value)) return value.slice(0, 100).map((v) => serialize(v, depth + 1, maxDepth, seen));
+		const out = {};
+		for (const k of Object.keys(value).slice(0, 100)) out[k] = serialize(value[k], depth + 1, maxDepth, seen);
+		return out;
 	}
-};
+	return String(value);
+}
+/**
+* Converts arbitrary values into readable text.
+*/
+function stringifyError(value) {
+	if (!value) return "";
+	if (typeof value === "string") return value;
+	if (Array.isArray(value)) return value.map(stringifyError).join("\n");
+	if (value instanceof Error) return [value.message, value.stack].filter(Boolean).join("\n");
+	if (typeof value === "object") return Object.values(value).map(stringifyError).join("\n");
+	return JSON.stringify(value);
+}
+/**
+* Recursively extracts error-related strings
+* from arbitrary nested structures.
+*/
+function extractStackLines(value) {
+	if (!value) return [];
+	if (typeof value === "string") return [value];
+	if (value instanceof Error) return [stringifyError(value)];
+	if (Array.isArray(value)) return value.flatMap(extractStackLines);
+	if (typeof value !== "object") return [];
+	const object = value;
+	const directText = DIRECT_ERROR_FIELDS.map((field) => stringifyError(object[field])).filter(Boolean).join("\n");
+	const nestedText = NESTED_ERROR_FIELDS.flatMap((field) => extractStackLines(object[field]));
+	return directText ? [directText, ...nestedText] : nestedText;
+}
+function hasMatchingStackFrame(error) {
+	return extractStackLines(error).some((line) => {
+		const matchesViteChunkPath = VITE_DEP_PATH_REGEX.test(line);
+		const matchesDynamicImportFailure = DYNAMIC_IMPORT_FAILURE_REGEX.test(line);
+		return matchesViteChunkPath && matchesDynamicImportFailure;
+	});
+}
+function formatReason(response) {
+	const cleanedUrl = response.url ?? "";
+	const statusText = response.statusText && response.statusText.length > 0 ? response.statusText : "(no status text)";
+	let message = `Server responded with ${response.status} ${statusText}`;
+	if (cleanedUrl) message += ` at ${cleanedUrl}`;
+	return message;
+}
+function extractResourceError(event) {
+	const target = event.target;
+	if (!(target instanceof HTMLElement)) return null;
+	let url = "";
+	if ("src" in target && typeof target.src === "string") url = target.src;
+	else if ("href" in target && typeof target.href === "string") url = target.href;
+	if (!url) return null;
+	const payload = {
+		message: `Failed to load resource: ${url}`,
+		lineno: 0,
+		colno: 0,
+		filename: url,
+		stack: `Resource load failed at ${url}`,
+		readyState: document.readyState,
+		userAgent: navigator.userAgent,
+		rootPresent: !!document.getElementById("root"),
+		scripts: Array.from(document.scripts || []).slice(0, 25).map((script) => script.src ? script.src : script.textContent?.slice(0, 80) || "inline")
+	};
+	return hasMatchingStackFrame(payload) ? payload : null;
+}
+function getRuntimeFingerprint(errorEvent) {
+	const { lineno, colno, filename, message } = errorEvent;
+	return `${message}|${filename}|${lineno}|${colno}`;
+}
+function formatResponseError(response) {
+	const url = response.url ?? "";
+	const baseMessage = `Server responded with ${response.status} ${response.statusText || "(no status text)"}`;
+	return url ? `${baseMessage} at ${url}` : baseMessage;
+}
+function parseError({ message, lineno, colno, filename, error }) {
+	const scriptsSnapshot = Array.from(document.scripts || []).slice(0, 25).map((script) => script.src ? script.src : script.textContent?.slice(0, 80) || "inline");
+	let finalMessage = message;
+	if (error instanceof Response || message.includes("[object Response]") && error && typeof error === "object" && "status" in error) finalMessage = formatResponseError(error);
+	return {
+		message: finalMessage,
+		lineno,
+		colno,
+		filename: filename ?? void 0,
+		stack: error?.stack,
+		readyState: document.readyState,
+		userAgent: navigator.userAgent,
+		rootPresent: !!document.getElementById("root"),
+		scripts: scriptsSnapshot
+	};
+}
+function parseViteError({ message, lineno, colno, filename, stack, frame }) {
+	const scriptsSnapshot = Array.from(document.scripts || []).slice(0, 25).map((script) => script.src ? script.src : script.textContent?.slice(0, 80) || "inline");
+	let finalMessage = message;
+	if (frame) finalMessage = `${frame}\n${finalMessage}\n`;
+	return {
+		message: finalMessage,
+		lineno: lineno ?? 0,
+		colno: colno ?? 0,
+		filename: filename ?? void 0,
+		stack: stack ?? void 0,
+		readyState: document.readyState,
+		userAgent: navigator.userAgent,
+		rootPresent: !!document.getElementById("root"),
+		scripts: scriptsSnapshot
+	};
+}
 
 //#endregion
-export { IframePostMessageClient, ViteHook, isNodeAttributesPatchBatchEvent, isNodeAttributesPatchEvent, isSetHoverNodeEvent, isSetSelectNodeEvent, isWorkspaceModeEvent };
+export { IframePostMessageClient, ViteHook, extractResourceError, formatReason, getRuntimeFingerprint, hasMatchingStackFrame, isSetHoverNodeEvent, isSetSelectNodeEvent, isUpdateBatchEvent, isWorkspaceModeEvent, parseError, parseViteError, serialize };

package/dist/runtime/error-tracker.ts

@@ -1,5 +1,14 @@
-import { IframePostMessageClient, ViteHook } from "../client";
-import { ErrorInfo } from "src/client/iframe-post-message";
+import {
+    serialize,
+    hasMatchingStackFrame,
+    formatReason,
+    IframePostMessageClient,
+    ViteHook,
+    extractResourceError,
+    parseError,
+    getRuntimeFingerprint,
+    parseViteError,
+} from "../client";
 
 class ErrorTracker {
     public vHook: ViteHook;
@@ -23,54 +32,49 @@ class ErrorTracker {
     }
 
     formatConsoleMessage(args: unknown[]): string {
-        let error;
-        const texts = [];
-        for (let arg of args) {
-            if (arg instanceof Error) {
-                error = arg;
-            } else {
-                texts.push(arg);
-            }
-        }
-
-        if (error) {
-            return error.stack || error.message;
-        }
-
-        return texts.map((text) => String(text)).join(" ");
+        let stack = null;
+        const err = new Error();
+        if (err.stack) stack = err.stack.split("\n").slice(2).join("\n");
+
+        const raw = args.map((a) => serialize(a));
+        const text = raw
+            .map((m) =>
+                typeof m === "string"
+                    ? m
+                    : JSON.stringify(m, null, 2)?.slice(0, 10_000),
+            )
+            .join(" ");
+
+        const message = (stack ? `${text}\n${stack}` : text).slice(0, 10_000);
+
+        return message;
     }
 
     handleConsoleInterception() {
-        type LogLevel = keyof typeof originalConsole;
+        type level = keyof typeof original;
 
-        const originalConsole = {
+        const original = {
             log: console.log,
             warn: console.warn,
             error: console.error,
             trace: console.trace,
-            //   debug: console.debug,
         };
-        for (let logLevel of Object.keys(originalConsole) as LogLevel[]) {
-            console[logLevel] = function (
-                this: ErrorTracker,
-                ...args: unknown[]
-            ) {
-                originalConsole[logLevel].apply(this, args);
+        for (let level of Object.keys(original) as level[]) {
+            console[level] = (...args: unknown[]) => {
+                original[level].apply(console, args);
 
                 const message = this.formatConsoleMessage(args);
-
                 if (!message) return;
-
-                if (logLevel === "error") {
-                    console.debug("[vite-shaper] console error", message);
-                    this.iframeClient.sendError({
-                        errorType: "RUNTIME_ERROR",
+                if (level === "error" || level === "warn") {
+                    this.iframeClient.sendConsoleMessage({
+                        level,
+                        message,
+                        fingerprint: `${level}|${message}`,
                         timestamp: Date.now(),
-                        stack: message,
-                        has_blank_screen: this.isBlankScreen(),
+                        type: "CONSOLE",
                     });
                 }
-            }.bind(this);
+            };
         }
     }
 
@@ -78,55 +82,111 @@ class ErrorTracker {
         this.vHook.onError((data) => {
             console.debug("[vite-shaper] vite:error", data);
 
-            let error: ErrorInfo = {
-                errorType: "RUNTIME_ERROR",
+            const message = data.err.message;
+            const filename = data.err.loc?.file;
+            const lineno = data.err.loc?.line;
+            const colno = data.err.loc?.column;
+            const stack = data.err.stack;
+            const frame = data.err.frame;
+
+            const dataError = parseViteError({
+                message,
+                filename,
+                lineno,
+                colno,
+                stack,
+                frame,
+            });
+
+            this.iframeClient.sendRuntimeError({
+                ...dataError,
+                hasBlankScreen: this.isBlankScreen(),
+                fingerprint: `${dataError.message}|${dataError.filename}|${dataError.lineno}|${dataError.colno}`,
+                type: "RUNTIME_ERROR",
                 timestamp: Date.now(),
-                stack: data.err.message,
-                has_blank_screen: this.isBlankScreen(),
-            };
-            if (data.err.loc) {
-                error = {
-                    ...error,
-                    lineno: data.err.loc.line,
-                    colno: data.err.loc.column,
-                    filename: data.err.loc.file,
-                };
-            }
-            this.iframeClient.sendError(error);
+            });
         });
     }
 
     handleUnhandledrejection() {
-        window.addEventListener("unhandledrejection", (evt) => {
-            console.debug("[vite-shaper] handleUnhandledrejection", evt);
-            this.iframeClient.sendError({
-                errorType: "RUNTIME_ERROR",
+        window.addEventListener("unhandledrejection", (event) => {
+            const reason = event.reason;
+
+            const isResponseError = reason instanceof Response;
+            const shouldIgnore = hasMatchingStackFrame(reason);
+
+            if (!isResponseError && !reason?.stack && !shouldIgnore) return;
+
+            const fingerprint = isResponseError
+                ? `Response|${reason.status}|${reason.url}`
+                : reason?.stack || reason?.message || String(reason);
+
+            const message = isResponseError
+                ? formatReason(reason)
+                : reason?.message ||
+                  String(reason || "Unhandled promise rejection");
+
+            const stack = isResponseError
+                ? `Response ${reason.status} at ${reason.url ?? "(unknown)"}`
+                : reason?.stack || String(reason);
+
+            const scripts = Array.from(document.scripts || [])
+                .slice(0, 25)
+                .map((script) => {
+                    if (script.src) return script.src;
+                    return script.textContent?.slice(0, 80) || "inline";
+                });
+
+            this.iframeClient.sendUnhandledRejection({
+                message,
+                stack,
+                readyState: document.readyState,
+                userAgent: navigator.userAgent,
+                rootPresent: !!document.getElementById("root"),
+                hasBlankScreen: this.isBlankScreen(),
+                scripts,
+                fingerprint,
                 timestamp: Date.now(),
-                stack: evt.reason.stack || evt.reason.message,
-                has_blank_screen: this.isBlankScreen(),
+                type: "UNHANDLED_REJECTION",
             });
         });
     }
 
     handleError() {
-        window.addEventListener("error", (evt) => {
-            console.debug("[vite-shaper] handleError", evt);
-            let message;
-            if (evt.error) {
-                message = evt.error.stack || evt.error.message;
-            } else {
-                message = evt.message;
-            }
-            this.iframeClient.sendError({
-                errorType: "RUNTIME_ERROR",
-                timestamp: Date.now(),
-                stack: message,
-                has_blank_screen: this.isBlankScreen(),
-                lineno: evt.lineno,
-                colno: evt.colno,
-                filename: evt.filename,
-            });
-        });
+        window.addEventListener(
+            "error",
+            (event) => {
+                if (!(event instanceof ErrorEvent)) {
+                    const resourceError = extractResourceError(event);
+
+                    if (!resourceError) return;
+
+                    const fingerprint = `resource|${resourceError.filename}`;
+
+                    this.iframeClient.sendRuntimeError({
+                        ...resourceError,
+                        hasBlankScreen: this.isBlankScreen(),
+                        fingerprint,
+                        timestamp: Date.now(),
+                        type: "RUNTIME_ERROR",
+                    });
+
+                    return;
+                }
+
+                const fingerprint = getRuntimeFingerprint(event);
+                const errorData = parseError(event);
+
+                this.iframeClient.sendRuntimeError({
+                    ...errorData,
+                    hasBlankScreen: this.isBlankScreen(),
+                    fingerprint,
+                    timestamp: Date.now(),
+                    type: "RUNTIME_ERROR",
+                });
+            },
+            true,
+        );
     }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shaper.org/core",
-  "version": "1.1.1",
+  "version": "1.2.0-0",
   "description": "",
   "type": "module",
   "private": false,