@elizaos/ui 2.0.0-alpha.85 → 2.0.0-beta.2

package/components/pages/useBrowserWorkspaceWalletBridge.js

@@ -0,0 +1,362 @@
+/**
+ * Browser workspace wallet bridge — hook + pure helpers.
+ *
+ * Iframes embedded by the browser workspace use window.postMessage to ask the
+ * host for wallet state and to request signing / transactions. This hook owns
+ * the origin verification, per-tab chain state, request dispatch, and the
+ * "ready" broadcast when state changes or an iframe loads.
+ *
+ * The caller passes in iframe refs, current tabs, and the wallet state it
+ * maintains; the hook returns a single `postBrowserWalletReady` function used
+ * for per-iframe onLoad and any other point-in-time broadcasts.
+ */
+import { useCallback, useEffect, useRef } from "react";
+import { client } from "../../api/index.js";
+import { BROWSER_WALLET_READY_TYPE, BROWSER_WALLET_RESPONSE_TYPE, isBrowserWorkspaceWalletRequest, } from "./browser-workspace-wallet.js";
+const DEFAULT_CHAIN_ID = 1;
+// ── Pure helpers ──────────────────────────────────────────────────────
+function resolveTargetOrigin(url) {
+    try {
+        const origin = new URL(url).origin;
+        return origin && origin !== "null" ? origin : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Verify a postMessage origin against the tab's known URL.
+ *
+ * With `allow-same-origin` in the iframe sandbox a malicious page could
+ * present the parent's origin. We mitigate by checking the message origin
+ * against the URL the user or agent explicitly navigated to; if they don't
+ * match we refuse to respond.
+ */
+export function resolveBrowserWorkspaceMessageOrigin(origin, tabUrl) {
+    if (!origin || origin === "null")
+        return null;
+    if (!tabUrl)
+        return origin;
+    try {
+        const expectedOrigin = new URL(tabUrl).origin;
+        if (!expectedOrigin || expectedOrigin === "null")
+            return null;
+        return origin === expectedOrigin ? origin : null;
+    }
+    catch {
+        return null;
+    }
+}
+function formatChainId(chainId) {
+    return `0x${chainId.toString(16)}`;
+}
+function parseChainId(value) {
+    if (typeof value === "number" && Number.isInteger(value) && value > 0) {
+        return value;
+    }
+    if (typeof value !== "string")
+        return null;
+    const trimmed = value.trim();
+    if (!trimmed)
+        return null;
+    const parsed = trimmed.startsWith("0x")
+        ? Number.parseInt(trimmed.slice(2), 16)
+        : Number(trimmed);
+    return Number.isInteger(parsed) && parsed > 0 ? parsed : null;
+}
+function resolveAccounts(state) {
+    return state.evmAddress ? [state.evmAddress] : [];
+}
+export function normalizeBrowserWorkspaceTxRequest(params, fallbackChainId) {
+    const raw = Array.isArray(params) && params.length > 0 ? params[0] : params;
+    if (!raw || typeof raw !== "object")
+        return null;
+    const value = raw;
+    const chainId = parseChainId(value.chainId) ?? fallbackChainId;
+    const to = typeof value.to === "string" ? value.to.trim() : "";
+    // `value` is optional — ERC-20 / contract calls legitimately omit it.
+    const amount = typeof value.value === "string"
+        ? value.value.trim()
+        : typeof value.value === "number"
+            ? String(value.value)
+            : "0x0";
+    if (!to || !chainId || !Number.isFinite(chainId))
+        return null;
+    return {
+        broadcast: value.broadcast !== false,
+        chainId,
+        data: typeof value.data === "string" ? value.data : undefined,
+        description: typeof value.description === "string" ? value.description : undefined,
+        to,
+        value: amount,
+    };
+}
+function resolveMessageToSign(params, address) {
+    if (typeof params === "string")
+        return params;
+    if (!Array.isArray(params) || params.length === 0)
+        return null;
+    const [first, second] = params;
+    if (typeof first === "string" && typeof second === "string" && address) {
+        if (first.toLowerCase() === address.toLowerCase())
+            return second;
+        if (second.toLowerCase() === address.toLowerCase())
+            return first;
+    }
+    return typeof first === "string" ? first : null;
+}
+async function dispatch(request, ctx) {
+    const { walletState } = ctx;
+    switch (request.method) {
+        case "getState":
+            return { ok: true, result: walletState };
+        case "requestAccounts":
+            return { ok: true, result: { accounts: resolveAccounts(walletState) } };
+        case "eth_accounts":
+        case "eth_requestAccounts":
+            return { ok: true, result: resolveAccounts(walletState) };
+        case "eth_chainId":
+            return { ok: true, result: formatChainId(ctx.tabChainId) };
+        case "solana_connect":
+            if (!walletState.solanaConnected || !walletState.solanaAddress) {
+                return { ok: false, error: "Solana wallet is unavailable." };
+            }
+            return { ok: true, result: { address: walletState.solanaAddress } };
+        case "solana_signMessage":
+            return handleSolanaSignMessage(request.params, walletState);
+        case "solana_signTransaction":
+            return handleSolanaSendTransaction(request.params, walletState, false);
+        case "solana_signAndSendTransaction":
+            return handleSolanaSendTransaction(request.params, walletState, true);
+        case "wallet_switchEthereumChain":
+            return handleSwitchChain(request.params, ctx);
+        case "personal_sign":
+        case "eth_sign":
+            return handleEthSign(request.params, walletState);
+        case "sendTransaction":
+        case "eth_sendTransaction":
+            return handleSendTransaction(request, ctx);
+        default:
+            return { ok: false, error: "Unsupported browser wallet request." };
+    }
+}
+async function handleSolanaSendTransaction(params, walletState, broadcast) {
+    if (!walletState.solanaTransactionSigningAvailable) {
+        return {
+            ok: false,
+            error: walletState.reason ||
+                "Solana browser wallet transaction signing is unavailable.",
+        };
+    }
+    const p = params && typeof params === "object"
+        ? params
+        : null;
+    const transactionBase64 = typeof p?.transactionBase64 === "string" ? p.transactionBase64 : null;
+    if (!transactionBase64) {
+        return {
+            ok: false,
+            error: "Solana browser wallet transaction signing requires transactionBase64.",
+        };
+    }
+    const cluster = p?.cluster === "devnet" ||
+        p?.cluster === "testnet" ||
+        p?.cluster === "mainnet"
+        ? p.cluster
+        : undefined;
+    const description = typeof p?.description === "string" ? p.description : undefined;
+    try {
+        const result = await client.sendBrowserSolanaTransaction({
+            transactionBase64,
+            broadcast,
+            ...(cluster ? { cluster } : {}),
+            ...(description ? { description } : {}),
+        });
+        return { ok: true, result };
+    }
+    catch (error) {
+        return { ok: false, error: errorMessage(error) };
+    }
+}
+async function handleSolanaSignMessage(params, walletState) {
+    if (!walletState.solanaMessageSigningAvailable) {
+        return {
+            ok: false,
+            error: walletState.reason || "Solana browser wallet signing is unavailable.",
+        };
+    }
+    const p = params && typeof params === "object"
+        ? params
+        : null;
+    const message = typeof p?.message === "string" ? p.message : undefined;
+    const messageBase64 = typeof p?.messageBase64 === "string" ? p.messageBase64 : undefined;
+    if (!message && !messageBase64) {
+        return {
+            ok: false,
+            error: "Solana browser wallet signing requires message or messageBase64.",
+        };
+    }
+    try {
+        const result = await client.signBrowserSolanaMessage({
+            ...(message ? { message } : {}),
+            ...(messageBase64 ? { messageBase64 } : {}),
+        });
+        return { ok: true, result };
+    }
+    catch (error) {
+        return { ok: false, error: errorMessage(error) };
+    }
+}
+function handleSwitchChain(params, ctx) {
+    if (!ctx.walletState.chainSwitchingAvailable) {
+        return {
+            ok: false,
+            error: ctx.walletState.reason ||
+                "Browser wallet chain switching is unavailable.",
+        };
+    }
+    const rawChainId = Array.isArray(params)
+        ? params[0]?.chainId
+        : params?.chainId;
+    const nextChainId = parseChainId(rawChainId);
+    if (!nextChainId) {
+        return {
+            ok: false,
+            error: "wallet_switchEthereumChain requires a valid chainId.",
+        };
+    }
+    ctx.setTabChainId(nextChainId);
+    // Use the ref (not the stale closure) so the dApp sees the most
+    // up-to-date wallet state after the chain switch.
+    ctx.postWalletReady(ctx.sourceTab, ctx.walletStateRef.current);
+    return { ok: true, result: null };
+}
+async function handleEthSign(params, walletState) {
+    if (!walletState.messageSigningAvailable) {
+        return {
+            ok: false,
+            error: walletState.mode === "steward"
+                ? "Browser message signing requires a local wallet key."
+                : walletState.reason ||
+                    "Browser wallet message signing is unavailable.",
+        };
+    }
+    const message = resolveMessageToSign(params, walletState.address);
+    if (!message) {
+        return {
+            ok: false,
+            error: "Browser wallet signing requires a message payload.",
+        };
+    }
+    try {
+        const result = await client.signBrowserWalletMessage(message);
+        // personal_sign / eth_sign expect the signature string directly.
+        return { ok: true, result: result.signature };
+    }
+    catch (error) {
+        return { ok: false, error: errorMessage(error) };
+    }
+}
+async function handleSendTransaction(request, ctx) {
+    if (!ctx.walletState.transactionSigningAvailable) {
+        return {
+            ok: false,
+            error: ctx.walletState.reason ||
+                "Browser wallet transaction signing is unavailable.",
+        };
+    }
+    const transaction = normalizeBrowserWorkspaceTxRequest(request.params, ctx.tabChainId);
+    if (!transaction) {
+        return {
+            ok: false,
+            error: "Browser wallet sendTransaction requires to, value, and chainId.",
+        };
+    }
+    try {
+        const result = await client.sendBrowserWalletTransaction(transaction);
+        const nextState = await ctx.loadWalletState();
+        ctx.postWalletReady(ctx.sourceTab, nextState);
+        // eth_sendTransaction expects the tx hash string; `sendTransaction`
+        // (Eliza flavor) returns the full result.
+        return {
+            ok: true,
+            result: request.method === "eth_sendTransaction"
+                ? (result.txHash ?? result.txId ?? null)
+                : result,
+        };
+    }
+    catch (error) {
+        return { ok: false, error: errorMessage(error) };
+    }
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+export function useBrowserWorkspaceWalletBridge({ iframeRefs, workspaceTabs, walletState, loadWalletState, }) {
+    const walletStateRef = useRef(walletState);
+    const workspaceTabsRef = useRef(workspaceTabs);
+    const chainIdByTabRef = useRef(new Map());
+    walletStateRef.current = walletState;
+    workspaceTabsRef.current = workspaceTabs;
+    const postBrowserWalletReady = useCallback((tab, state) => {
+        const iframeWindow = iframeRefs.current?.get(tab.id)?.contentWindow;
+        const targetOrigin = resolveTargetOrigin(tab.url);
+        if (!iframeWindow || !targetOrigin)
+            return;
+        iframeWindow.postMessage({ type: BROWSER_WALLET_READY_TYPE, state }, targetOrigin);
+    }, [iframeRefs]);
+    // Broadcast fresh state to every loaded iframe whenever the wallet state
+    // changes — so dApps see connection and chain updates without polling.
+    useEffect(() => {
+        for (const tab of workspaceTabs) {
+            postBrowserWalletReady(tab, walletState);
+        }
+    }, [walletState, postBrowserWalletReady, workspaceTabs]);
+    // Drop per-tab chain overrides for tabs that have closed.
+    useEffect(() => {
+        const knownTabIds = new Set(workspaceTabs.map((tab) => tab.id));
+        for (const tabId of chainIdByTabRef.current.keys()) {
+            if (!knownTabIds.has(tabId)) {
+                chainIdByTabRef.current.delete(tabId);
+            }
+        }
+    }, [workspaceTabs]);
+    useEffect(() => {
+        const onMessage = (event) => {
+            if (!isBrowserWorkspaceWalletRequest(event.data))
+                return;
+            const request = event.data;
+            const sourceTab = workspaceTabsRef.current.find((tab) => iframeRefs.current?.get(tab.id)?.contentWindow === event.source);
+            const sourceWindow = sourceTab
+                ? iframeRefs.current?.get(sourceTab.id)?.contentWindow
+                : null;
+            if (!sourceTab || !sourceWindow)
+                return;
+            const targetOrigin = resolveBrowserWorkspaceMessageOrigin(event.origin, sourceTab.url);
+            if (targetOrigin === null)
+                return;
+            const respond = (response) => {
+                sourceWindow.postMessage(response, targetOrigin);
+            };
+            void (async () => {
+                const ctx = {
+                    sourceTab,
+                    walletState: walletStateRef.current,
+                    tabChainId: chainIdByTabRef.current.get(sourceTab.id) ?? DEFAULT_CHAIN_ID,
+                    setTabChainId: (chainId) => chainIdByTabRef.current.set(sourceTab.id, chainId),
+                    loadWalletState,
+                    postWalletReady: postBrowserWalletReady,
+                    walletStateRef,
+                };
+                const result = await dispatch(request, ctx);
+                respond({
+                    type: BROWSER_WALLET_RESPONSE_TYPE,
+                    requestId: request.requestId,
+                    ...result,
+                });
+            })();
+        };
+        window.addEventListener("message", onMessage);
+        return () => window.removeEventListener("message", onMessage);
+    }, [iframeRefs, loadWalletState, postBrowserWalletReady]);
+    return { postBrowserWalletReady };
+}

package/components/pages/vector-browser-utils.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Vector Browser - pure functions, constants, and type definitions.
+ */
+export declare const PAGE_SIZE = 25;
+export declare const MAX_THREE_PIXEL_RATIO = 2;
+export type ViewMode = "list" | "graph" | "3d";
+/** The dimension columns in the elizaOS `embeddings` table. */
+export declare const DIM_COLUMNS: readonly ["dim_384", "dim_512", "dim_768", "dim_1024", "dim_1536", "dim_3072"];
+export interface MemoryRecord {
+    id: string;
+    content: string;
+    roomId: string;
+    entityId: string;
+    type: string;
+    createdAt: string;
+    unique: boolean;
+    embedding: number[] | null;
+    raw: Record<string, unknown>;
+}
+export declare function hasEmbedding(memory: MemoryRecord): memory is MemoryRecord & {
+    embedding: number[];
+};
+export interface VectorGraph2DBounds {
+    minX: number;
+    minY: number;
+    rangeX: number;
+    rangeY: number;
+}
+export interface VectorGraph2DLayout {
+    bounds: VectorGraph2DBounds;
+    points: [number, number][];
+    typeColors: Record<string, string>;
+    withEmbeddings: Array<MemoryRecord & {
+        embedding: number[];
+    }>;
+}
+export declare const VECTOR_GRAPH_2D_PALETTE: string[];
+/** Try to parse a JSON content field, returning the text content or the raw string. */
+export declare function parseContent(val: unknown): string;
+/** Parse an embedding from various storage formats (pgvector text, JSON, typed arrays). */
+export declare function parseEmbedding(val: unknown): number[] | null;
+export declare function rowToMemory(row: Record<string, unknown>): MemoryRecord;
+export declare function buildVectorGraph2DLayout(memories: MemoryRecord[]): VectorGraph2DLayout | null;
+export declare function toVectorGraph2DScreenX(x: number, width: number, padding: number, bounds: VectorGraph2DBounds): number;
+export declare function toVectorGraph2DScreenY(y: number, height: number, padding: number, bounds: VectorGraph2DBounds): number;
+/** Project high-dimensional vectors to 2D using the first two principal axes. */
+export declare function projectTo2D(vectors: number[][]): [number, number][];
+/** Project high-dimensional vectors to 3D using the first three principal axes. */
+export declare function projectTo3D(vectors: number[][]): [number, number, number][];
+//# sourceMappingURL=vector-browser-utils.d.ts.map

package/components/pages/vector-browser-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vector-browser-utils.d.ts","sourceRoot":"","sources":["../../../../../../src/components/pages/vector-browser-utils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,eAAO,MAAM,SAAS,KAAK,CAAC;AAC5B,eAAO,MAAM,qBAAqB,IAAI,CAAC;AAEvC,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC;AAE/C,+DAA+D;AAC/D,eAAO,MAAM,WAAW,gFAOd,CAAC;AAEX,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,OAAO,CAAC;IAChB,SAAS,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IAC3B,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC9B;AAED,wBAAgB,YAAY,CAC1B,MAAM,EAAE,YAAY,GACnB,MAAM,IAAI,YAAY,GAAG;IAAE,SAAS,EAAE,MAAM,EAAE,CAAA;CAAE,CAElD;AAED,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,mBAAmB,CAAC;IAC5B,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC;IAC3B,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnC,cAAc,EAAE,KAAK,CAAC,YAAY,GAAG;QAAE,SAAS,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC,CAAC;CAC/D;AAED,eAAO,MAAM,uBAAuB,UASnC,CAAC;AAEF,uFAAuF;AACvF,wBAAgB,YAAY,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAyBjD;AAED,2FAA2F;AAC3F,wBAAgB,cAAc,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,EAAE,GAAG,IAAI,CA4B5D;AAED,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,YAAY,CA8BtE;AAED,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,YAAY,EAAE,GACvB,mBAAmB,GAAG,IAAI,CAoC5B;AAED,wBAAgB,sBAAsB,CACpC,CAAC,EAAE,MAAM,EACT,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,mBAAmB,GAC1B,MAAM,CAER;AAED,wBAAgB,sBAAsB,CACpC,CAAC,EAAE,MAAM,EACT,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,mBAAmB,GAC1B,MAAM,CAER;AA6DD,iFAAiF;AACjF,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAUnE;AAED,mFAAmF;AACnF,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,CAc3E"}

package/components/pages/vector-browser-utils.js

@@ -0,0 +1,243 @@
+/**
+ * Vector Browser - pure functions, constants, and type definitions.
+ */
+export const PAGE_SIZE = 25;
+export const MAX_THREE_PIXEL_RATIO = 2;
+/** The dimension columns in the elizaOS `embeddings` table. */
+export const DIM_COLUMNS = [
+    "dim_384",
+    "dim_512",
+    "dim_768",
+    "dim_1024",
+    "dim_1536",
+    "dim_3072",
+];
+export function hasEmbedding(memory) {
+    return memory.embedding !== null;
+}
+export const VECTOR_GRAPH_2D_PALETTE = [
+    "#6cf",
+    "#f59e0b",
+    "#10b981",
+    "#ef4444",
+    "#8b5cf6",
+    "#ec4899",
+    "#06b6d4",
+    "#84cc16",
+];
+/** Try to parse a JSON content field, returning the text content or the raw string. */
+export function parseContent(val) {
+    if (typeof val !== "string") {
+        if (val && typeof val === "object") {
+            const record = val;
+            if (typeof record.text === "string")
+                return record.text;
+            if (typeof record.content === "string")
+                return record.content;
+            try {
+                return JSON.stringify(val, null, 2);
+            }
+            catch {
+                return String(val);
+            }
+        }
+        return String(val ?? "");
+    }
+    if (val.startsWith("{")) {
+        try {
+            const parsed = JSON.parse(val);
+            if (parsed.text)
+                return String(parsed.text);
+            if (parsed.content)
+                return String(parsed.content);
+            return val;
+        }
+        catch {
+            return val;
+        }
+    }
+    return val;
+}
+/** Parse an embedding from various storage formats (pgvector text, JSON, typed arrays). */
+export function parseEmbedding(val) {
+    if (!val)
+        return null;
+    if (Array.isArray(val))
+        return val;
+    // Handle typed arrays (Float32Array, Float64Array, Uint8Array etc.)
+    if (ArrayBuffer.isView(val)) {
+        return Array.from(val);
+    }
+    if (typeof val === "string" && val.length > 2) {
+        const trimmed = val.trim();
+        // pgvector text format: [0.1,0.2,0.3] - also valid JSON
+        // Also handle without brackets: 0.1,0.2,0.3
+        const inner = trimmed.startsWith("[") && trimmed.endsWith("]")
+            ? trimmed.slice(1, -1)
+            : trimmed;
+        if (!inner)
+            return null;
+        // Fast path: split by comma and parse floats
+        const parts = inner.split(",");
+        if (parts.length < 2)
+            return null;
+        const nums = [];
+        for (const p of parts) {
+            const n = Number.parseFloat(p);
+            if (Number.isNaN(n))
+                return null;
+            nums.push(n);
+        }
+        return nums;
+    }
+    return null;
+}
+export function rowToMemory(row) {
+    // Try explicit embedding/vector column first, then check elizaOS dim_* columns
+    let embeddingVal = row.embedding ?? row.vector ?? row.embeddings;
+    if (!embeddingVal) {
+        for (const dim of DIM_COLUMNS) {
+            if (row[dim]) {
+                embeddingVal = row[dim];
+                break;
+            }
+        }
+    }
+    return {
+        id: String(row.id ?? row.ID ?? row.memory_id ?? ""),
+        content: parseContent(row.content ?? row.body ?? row.text ?? ""),
+        roomId: String(row.roomId ?? row.room_id ?? row.roomID ?? ""),
+        entityId: String(row.entityId ??
+            row.entity_id ??
+            row.entityID ??
+            row.userId ??
+            row.user_id ??
+            ""),
+        type: String(row.type ?? row.memoryType ?? row.memory_type ?? ""),
+        createdAt: String(row.createdAt ?? row.created_at ?? row.timestamp ?? ""),
+        unique: row.unique === true || row.unique === 1 || row.isUnique === true,
+        embedding: parseEmbedding(embeddingVal),
+        raw: row,
+    };
+}
+export function buildVectorGraph2DLayout(memories) {
+    const withEmbeddings = memories.filter(hasEmbedding);
+    if (withEmbeddings.length < 2) {
+        return null;
+    }
+    const points = projectTo2D(withEmbeddings.map((memory) => memory.embedding));
+    let minX = Infinity;
+    let maxX = -Infinity;
+    let minY = Infinity;
+    let maxY = -Infinity;
+    for (const [x, y] of points) {
+        if (x < minX)
+            minX = x;
+        if (x > maxX)
+            maxX = x;
+        if (y < minY)
+            minY = y;
+        if (y > maxY)
+            maxY = y;
+    }
+    const typeColors = {};
+    const types = [...new Set(withEmbeddings.map((memory) => memory.type))];
+    for (let index = 0; index < types.length; index += 1) {
+        typeColors[types[index]] =
+            VECTOR_GRAPH_2D_PALETTE[index % VECTOR_GRAPH_2D_PALETTE.length];
+    }
+    return {
+        bounds: {
+            minX,
+            minY,
+            rangeX: maxX - minX || 1,
+            rangeY: maxY - minY || 1,
+        },
+        points,
+        typeColors,
+        withEmbeddings,
+    };
+}
+export function toVectorGraph2DScreenX(x, width, padding, bounds) {
+    return padding + ((x - bounds.minX) / bounds.rangeX) * (width - 2 * padding);
+}
+export function toVectorGraph2DScreenY(y, height, padding, bounds) {
+    return padding + ((y - bounds.minY) / bounds.rangeY) * (height - 2 * padding);
+}
+// PCA projection utilities.
+function dot(a, b) {
+    let s = 0;
+    for (let i = 0; i < a.length; i++)
+        s += a[i] * (b[i] ?? 0);
+    return s;
+}
+function powerIteration(data, dims, iters = 30) {
+    const v = new Float64Array(dims);
+    // Random init
+    for (let d = 0; d < dims; d++)
+        v[d] = Math.random() - 0.5;
+    normalize(v);
+    for (let iter = 0; iter < iters; iter++) {
+        const w = new Float64Array(dims);
+        for (const row of data) {
+            const d = dot(row, v);
+            for (let j = 0; j < dims; j++)
+                w[j] += d * row[j];
+        }
+        normalize(w);
+        for (let d = 0; d < dims; d++)
+            v[d] = w[d];
+    }
+    return v;
+}
+function normalize(v) {
+    let len = 0;
+    for (let i = 0; i < v.length; i++)
+        len += v[i] * v[i];
+    len = Math.sqrt(len) || 1;
+    for (let i = 0; i < v.length; i++)
+        v[i] /= len;
+}
+/** Compute mean and center data for PCA. */
+function centerData(vectors) {
+    const dims = vectors[0].length;
+    const n = vectors.length;
+    const mean = new Float64Array(dims);
+    for (const v of vectors) {
+        for (let d = 0; d < dims; d++)
+            mean[d] += v[d];
+    }
+    for (let d = 0; d < dims; d++)
+        mean[d] /= n;
+    const centered = vectors.map((v) => v.map((x, d) => x - mean[d]));
+    return { centered, mean };
+}
+/** Deflate data by removing projection onto a principal component. */
+function deflate(data, pc) {
+    const proj = data.map((v) => dot(v, pc));
+    return data.map((v, i) => v.map((x, d) => x - proj[i] * pc[d]));
+}
+/** Project high-dimensional vectors to 2D using the first two principal axes. */
+export function projectTo2D(vectors) {
+    if (vectors.length === 0)
+        return [];
+    const dims = vectors[0].length;
+    const { centered } = centerData(vectors);
+    const pc1 = powerIteration(centered, dims);
+    const deflated1 = deflate(centered, pc1);
+    const pc2 = powerIteration(deflated1, dims);
+    return centered.map((v) => [dot(v, pc1), dot(v, pc2)]);
+}
+/** Project high-dimensional vectors to 3D using the first three principal axes. */
+export function projectTo3D(vectors) {
+    if (vectors.length === 0)
+        return [];
+    const dims = vectors[0].length;
+    const { centered } = centerData(vectors);
+    const pc1 = powerIteration(centered, dims);
+    const deflated1 = deflate(centered, pc1);
+    const pc2 = powerIteration(deflated1, dims);
+    const deflated2 = deflate(deflated1, pc2);
+    const pc3 = powerIteration(deflated2, dims);
+    return centered.map((v) => [dot(v, pc1), dot(v, pc2), dot(v, pc3)]);
+}

package/components/pages/workflow-graph-events.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Cross-component event bus for "show me this workflow" deep-links.
+ *
+ * Dispatched from chat surfaces (e.g. when the agent replies about a
+ * workflow it just created or modified) and consumed by AutomationsFeed,
+ * which scrolls the matching row into view and opens its editor.
+ *
+ * Restored from the deleted AutomationsView.tsx — keep this file thin.
+ */
+export declare const VISUALIZE_WORKFLOW_EVENT = "eliza:automations:visualize-workflow";
+export interface VisualizeWorkflowEventDetail {
+    workflowId: string;
+}
+export declare function dispatchVisualizeWorkflow(workflowId: string): void;
+//# sourceMappingURL=workflow-graph-events.d.ts.map

package/components/pages/workflow-graph-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-graph-events.d.ts","sourceRoot":"","sources":["../../../../../../src/components/pages/workflow-graph-events.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,eAAO,MAAM,wBAAwB,yCAAyC,CAAC;AAE/E,MAAM,WAAW,4BAA4B;IAC3C,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,wBAAgB,yBAAyB,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAOlE"}