@stelis/say-ur-intent 0.0.0 → 0.0.2

package/dist/mcp/tools/session/executionResultTools.js

@@ -0,0 +1,92 @@
+import { z } from "zod";
+import { executionPollingStatusSchema, executionResultSchema } from "../../../core/action/schemas.js";
+import { waitForExecutionResult } from "../../../core/session/wait.js";
+import { errorToolResult, okToolResult } from "../../result.js";
+import { successOutputSchema } from "../../schemas.js";
+import { sessionStoreToolError } from "../../toolErrors.js";
+import { TOOL_NAMES } from "../../toolNames.js";
+import { executionResultUserAnswerUse } from "../../responseGuidance.js";
+import { userAnswerUseSchema } from "../read/commonSchemas.js";
+import { executionPollingHint, executionStatusCategory, getExecutionPollingStatus } from "../../../core/session/status.js";
+import { executionPollingHintSchema, executionStatusCategorySchema, waitExecutionInputSchema } from "./shared.js";
+export function registerExecutionResultTools(server, deps) {
+    server.registerTool(TOOL_NAMES.sessionGetExecutionResult, {
+        title: "Get execution polling result",
+        description: "Return execution polling status and any recorded result. No result exists until a signable adapter exists.",
+        inputSchema: { reviewSessionId: z.string().min(1) },
+        outputSchema: successOutputSchema({
+            reviewSessionId: z.string(),
+            status: executionPollingStatusSchema,
+            statusCategory: executionStatusCategorySchema(),
+            lastActivityAt: z.string(),
+            pollingHint: executionPollingHintSchema(),
+            executionResult: executionResultSchema.optional(),
+            userAnswerUse: userAnswerUseSchema
+        }),
+        annotations: { readOnlyHint: false, openWorldHint: false }
+    }, async ({ reviewSessionId }) => {
+        try {
+            const session = await deps.sessions.getReviewSession(reviewSessionId);
+            if (!session) {
+                return errorToolResult({
+                    kind: "session_not_found",
+                    details: { reviewSessionId }
+                });
+            }
+            const status = getExecutionPollingStatus(session);
+            return okToolResult({
+                reviewSessionId: session.id,
+                status,
+                statusCategory: executionStatusCategory(status),
+                lastActivityAt: session.lastActivityAt,
+                pollingHint: executionPollingHint(),
+                executionResult: session.executionResult,
+                userAnswerUse: executionResultUserAnswerUse({
+                    hasExecutionResult: session.executionResult !== undefined
+                })
+            });
+        }
+        catch (error) {
+            return sessionStoreToolError(error, deps.logger);
+        }
+    });
+    server.registerTool(TOOL_NAMES.sessionWaitExecutionResult, {
+        title: "Wait for execution polling result",
+        description: "Wait briefly for execution polling status to reach a wait-stopping status.",
+        inputSchema: waitExecutionInputSchema(),
+        outputSchema: successOutputSchema({
+            waitOutcome: z.enum(["status_reached", "timed_out"]),
+            reviewSessionId: z.string(),
+            status: executionPollingStatusSchema,
+            statusCategory: executionStatusCategorySchema(),
+            lastActivityAt: z.string(),
+            pollingHint: executionPollingHintSchema(),
+            executionResult: executionResultSchema.optional(),
+            userAnswerUse: userAnswerUseSchema
+        }),
+        annotations: { readOnlyHint: false, openWorldHint: false }
+    }, async ({ reviewSessionId, timeoutMs }, extra) => {
+        try {
+            const result = await waitForExecutionResult(deps.sessions, reviewSessionId, {
+                timeoutMs,
+                signal: extra.signal
+            });
+            return okToolResult({
+                waitOutcome: result.waitOutcome,
+                reviewSessionId: result.session.id,
+                status: result.status,
+                statusCategory: executionStatusCategory(result.status),
+                lastActivityAt: result.session.lastActivityAt,
+                pollingHint: executionPollingHint(),
+                executionResult: result.session.executionResult,
+                userAnswerUse: executionResultUserAnswerUse({
+                    hasExecutionResult: result.session.executionResult !== undefined,
+                    hasWaitOutcome: true
+                })
+            });
+        }
+        catch (error) {
+            return sessionStoreToolError(error, deps.logger);
+        }
+    });
+}

package/dist/mcp/tools/session/index.js

@@ -0,0 +1,8 @@
+import { registerExecutionResultTools } from "./executionResultTools.js";
+import { registerSessionStatusTools } from "./statusTools.js";
+import { registerWalletIdentityTools } from "./walletIdentityTools.js";
+export function registerSessionTools(server, deps) {
+    registerWalletIdentityTools(server, deps);
+    registerSessionStatusTools(server, deps);
+    registerExecutionResultTools(server, deps);
+}

package/dist/mcp/tools/session/shared.js

@@ -0,0 +1,79 @@
+import { z } from "zod";
+import { executionPollingStatusSchema } from "../../../core/action/schemas.js";
+import { EXECUTION_STATUS_CATEGORIES } from "../../../core/session/status.js";
+import { SUI_MAINNET_WALLET_CHAIN, walletIdentityFailureReasonSchema, walletIdentityPollingHint, walletIdentityStatusSchema } from "../../../core/session/walletIdentity.js";
+import { DEFAULT_WAIT_TIMEOUT_MS, MAX_WAIT_TIMEOUT_MS } from "../../../core/session/wait.js";
+export const INTERACTION_STATUS_LIMIT = 5;
+export function walletIdentityPollingHintSchema() {
+    return z.object({
+        nonTerminalStatuses: z.array(walletIdentityStatusSchema),
+        terminalStatuses: z.array(walletIdentityStatusSchema),
+        recommendedIntervalSeconds: z.number().int().positive()
+    });
+}
+export function executionPollingHintSchema() {
+    return z.object({
+        nonTerminalStatuses: z.array(executionPollingStatusSchema),
+        waitStoppingStatuses: z.array(executionPollingStatusSchema),
+        finalStatuses: z.array(executionPollingStatusSchema),
+        userActionRequiredStatuses: z.array(executionPollingStatusSchema),
+        recommendedIntervalSeconds: z.number().int().positive()
+    });
+}
+export function executionStatusCategorySchema() {
+    return z.enum(EXECUTION_STATUS_CATEGORIES);
+}
+export function waitWalletIdentityInputSchema() {
+    return {
+        walletSessionId: z.string().min(1),
+        timeoutMs: z.number().int().min(1).max(MAX_WAIT_TIMEOUT_MS).default(DEFAULT_WAIT_TIMEOUT_MS).optional()
+    };
+}
+export function waitExecutionInputSchema() {
+    return {
+        reviewSessionId: z.string().min(1),
+        timeoutMs: z.number().int().min(1).max(MAX_WAIT_TIMEOUT_MS).default(DEFAULT_WAIT_TIMEOUT_MS).optional()
+    };
+}
+export function walletIdentityResponse(session) {
+    return {
+        walletSessionId: session.id,
+        status: session.status,
+        account: session.status === "connected" ? session.account : undefined,
+        chain: session.status === "connected" ? session.chain : undefined,
+        walletName: session.status === "connected" || session.status === "rejected" || session.status === "failed"
+            ? session.walletName
+            : undefined,
+        walletId: session.status === "connected" || session.status === "rejected" || session.status === "failed"
+            ? session.walletId
+            : undefined,
+        failureReason: session.status === "rejected" || session.status === "failed" ? session.failureReason : undefined,
+        failureDetail: session.status === "rejected" || session.status === "failed" ? session.failureDetail : undefined,
+        expiresAt: session.expiresAt,
+        lastActivityAt: session.lastActivityAt,
+        pollingHint: walletIdentityPollingHint()
+    };
+}
+export function walletIdentityOutputSchema() {
+    return {
+        walletSessionId: z.string(),
+        status: walletIdentityStatusSchema,
+        account: z.string().optional(),
+        chain: z.literal(SUI_MAINNET_WALLET_CHAIN).optional(),
+        walletName: z.string().optional(),
+        walletId: z.string().optional(),
+        failureReason: walletIdentityFailureReasonSchema.optional(),
+        failureDetail: z.string().optional(),
+        expiresAt: z.string(),
+        lastActivityAt: z.string(),
+        pollingHint: walletIdentityPollingHintSchema()
+    };
+}
+export function latest(items) {
+    const sorted = [...items].sort((left, right) => right.lastActivityAt.localeCompare(left.lastActivityAt));
+    return {
+        limit: INTERACTION_STATUS_LIMIT,
+        items: sorted.slice(0, INTERACTION_STATUS_LIMIT),
+        truncated: sorted.length > INTERACTION_STATUS_LIMIT
+    };
+}

package/dist/mcp/tools/session/statusTools.js

@@ -0,0 +1,134 @@
+import { z } from "zod";
+import { executionPollingStatusSchema, internalSessionStatusSchema, reviewStateOutputSchema } from "../../../core/action/schemas.js";
+import { isTerminalWalletIdentityStatus, walletIdentityStatusSchema } from "../../../core/session/walletIdentity.js";
+import { activeAccountResponse, activeAccountResponseSchema } from "../../activeAccountResponse.js";
+import { errorToolResult, okToolResult } from "../../result.js";
+import { noParamsInputSchema, successOutputSchema } from "../../schemas.js";
+import { activityStoreToolError, sessionStoreToolError } from "../../toolErrors.js";
+import { TOOL_NAMES } from "../../toolNames.js";
+import { interactionStatusUserAnswerUse, reviewStatusUserAnswerUse } from "../../responseGuidance.js";
+import { userAnswerUseSchema } from "../read/commonSchemas.js";
+import { executionStatusCategory, getExecutionPollingStatus, isInteractionPendingReviewStatus } from "../../../core/session/status.js";
+import { executionStatusCategorySchema, latest } from "./shared.js";
+const INTERACTION_PENDING_REVIEW_STATUS_CATEGORIES = [
+    "user_action_required",
+    "awaiting_chain_result",
+    "non_terminal"
+];
+export function registerSessionStatusTools(server, deps) {
+    server.registerTool(TOOL_NAMES.sessionGetInteractionStatus, {
+        title: "Get local interaction status",
+        description: "Return active account context and pending local wallet or review interactions.",
+        inputSchema: noParamsInputSchema,
+        outputSchema: successOutputSchema({
+            activeAccount: activeAccountResponseSchema,
+            pendingWalletIdentitySessions: z.object({
+                limit: z.number().int().positive(),
+                items: z.array(z.object({
+                    walletSessionId: z.string(),
+                    status: walletIdentityStatusSchema,
+                    statusCategory: z.literal("non_terminal"),
+                    expiresAt: z.string(),
+                    lastActivityAt: z.string()
+                })),
+                truncated: z.boolean()
+            }),
+            pendingReviewSessions: z.object({
+                limit: z.number().int().positive(),
+                items: z.array(z.object({
+                    reviewSessionId: z.string(),
+                    internalStatus: internalSessionStatusSchema,
+                    status: executionPollingStatusSchema,
+                    statusCategory: z.enum(INTERACTION_PENDING_REVIEW_STATUS_CATEGORIES),
+                    lastActivityAt: z.string()
+                })),
+                truncated: z.boolean()
+            }),
+            userAnswerUse: userAnswerUseSchema
+        }),
+        annotations: { readOnlyHint: false, openWorldHint: false }
+    }, async () => {
+        let active;
+        try {
+            active = await deps.activityStore.getActiveAccount();
+        }
+        catch (error) {
+            return activityStoreToolError(error, deps.logger);
+        }
+        try {
+            const [walletSessions, reviewSessions] = await Promise.all([
+                deps.sessions.listWalletIdentitySessions(),
+                deps.sessions.listReviewSessions()
+            ]);
+            const pendingWallets = latest(walletSessions
+                .filter((session) => !isTerminalWalletIdentityStatus(session.status))
+                .map((session) => ({
+                walletSessionId: session.id,
+                status: session.status,
+                statusCategory: "non_terminal",
+                expiresAt: session.expiresAt,
+                lastActivityAt: session.lastActivityAt
+            })));
+            const pendingReviews = latest(reviewSessions
+                .map((session) => ({
+                session,
+                status: getExecutionPollingStatus(session)
+            }))
+                .filter(({ status }) => isInteractionPendingReviewStatus(status))
+                .map(({ session, status }) => ({
+                reviewSessionId: session.id,
+                internalStatus: session.status,
+                status,
+                statusCategory: executionStatusCategory(status),
+                lastActivityAt: session.lastActivityAt
+            })));
+            return okToolResult({
+                activeAccount: activeAccountResponse(active),
+                pendingWalletIdentitySessions: pendingWallets,
+                pendingReviewSessions: pendingReviews,
+                userAnswerUse: interactionStatusUserAnswerUse()
+            });
+        }
+        catch (error) {
+            return sessionStoreToolError(error, deps.logger);
+        }
+    });
+    server.registerTool(TOOL_NAMES.sessionGetReviewStatus, {
+        title: "Get review status",
+        description: "Return the current status for a review session.",
+        inputSchema: { reviewSessionId: z.string().min(1) },
+        outputSchema: successOutputSchema({
+            reviewSessionId: z.string(),
+            internalStatus: internalSessionStatusSchema,
+            pollingStatus: executionPollingStatusSchema,
+            statusCategory: executionStatusCategorySchema(),
+            lastActivityAt: z.string(),
+            userAnswerUse: userAnswerUseSchema,
+            reviewState: reviewStateOutputSchema.optional()
+        }),
+        annotations: { readOnlyHint: false, openWorldHint: false }
+    }, async ({ reviewSessionId }) => {
+        try {
+            const session = await deps.sessions.getReviewSession(reviewSessionId);
+            if (!session) {
+                return errorToolResult({
+                    kind: "session_not_found",
+                    details: { reviewSessionId }
+                });
+            }
+            const pollingStatus = getExecutionPollingStatus(session);
+            return okToolResult({
+                reviewSessionId: session.id,
+                internalStatus: session.status,
+                pollingStatus,
+                statusCategory: executionStatusCategory(pollingStatus),
+                lastActivityAt: session.lastActivityAt,
+                userAnswerUse: reviewStatusUserAnswerUse(session.reviewState !== undefined, session.reviewState?.adapterLifecycle !== undefined, session.reviewState?.humanReadableReview !== undefined, session.reviewState?.simulation !== undefined),
+                reviewState: session.reviewState
+            });
+        }
+        catch (error) {
+            return sessionStoreToolError(error, deps.logger);
+        }
+    });
+}

package/dist/mcp/tools/session/walletIdentityTools.js

@@ -0,0 +1,119 @@
+import { z } from "zod";
+import { SUI_MAINNET_WALLET_CHAIN, walletIdentityFailureReasonSchema, walletIdentityPollingHint, walletIdentityStatusSchema } from "../../../core/session/walletIdentity.js";
+import { waitForWalletIdentitySession } from "../../../core/session/wait.js";
+import { errorToolResult, okToolResult } from "../../result.js";
+import { noParamsInputSchema, successOutputSchema } from "../../schemas.js";
+import { sessionStoreToolError } from "../../toolErrors.js";
+import { TOOL_NAMES } from "../../toolNames.js";
+import { walletIdentityUserAnswerUse } from "../../responseGuidance.js";
+import { userAnswerUseSchema } from "../read/commonSchemas.js";
+import { waitWalletIdentityInputSchema, walletIdentityOutputSchema, walletIdentityPollingHintSchema, walletIdentityResponse } from "./shared.js";
+export function registerWalletIdentityTools(server, deps) {
+    server.registerTool(TOOL_NAMES.sessionCreateWalletIdentity, {
+        title: "Create wallet identity capture",
+        description: "Create a browser session that captures only a Sui mainnet address and chain identifier.",
+        inputSchema: noParamsInputSchema,
+        outputSchema: successOutputSchema({
+            walletSessionId: z.string(),
+            walletUrl: z.string(),
+            openTarget: z.literal("system_browser"),
+            accessScope: z.literal("same_machine_loopback"),
+            status: walletIdentityStatusSchema,
+            expiresAt: z.string(),
+            lastActivityAt: z.string(),
+            pollingHint: walletIdentityPollingHintSchema(),
+            userAnswerUse: userAnswerUseSchema
+        }),
+        annotations: { readOnlyHint: false, openWorldHint: false }
+    }, async () => {
+        try {
+            const created = await deps.sessions.createWalletIdentitySession();
+            return okToolResult({
+                walletSessionId: created.session.id,
+                walletUrl: `${deps.reviewBaseUrl}/analysis/${created.session.id}#${created.token}`,
+                openTarget: "system_browser",
+                accessScope: "same_machine_loopback",
+                status: created.session.status,
+                expiresAt: created.session.expiresAt,
+                lastActivityAt: created.session.lastActivityAt,
+                pollingHint: walletIdentityPollingHint(),
+                userAnswerUse: walletIdentityUserAnswerUse({ hasOpenFields: true })
+            });
+        }
+        catch (error) {
+            return sessionStoreToolError(error, deps.logger);
+        }
+    });
+    server.registerTool(TOOL_NAMES.sessionGetWalletIdentity, {
+        title: "Get wallet identity capture status",
+        description: "Return current status for a wallet identity capture session.",
+        inputSchema: { walletSessionId: z.string().min(1) },
+        outputSchema: successOutputSchema({
+            ...walletIdentityOutputSchema(),
+            userAnswerUse: userAnswerUseSchema
+        }),
+        annotations: { readOnlyHint: false, openWorldHint: false }
+    }, async ({ walletSessionId }) => {
+        try {
+            const session = await deps.sessions.getWalletIdentitySession(walletSessionId);
+            if (!session) {
+                return errorToolResult({
+                    kind: "session_not_found",
+                    details: { walletSessionId }
+                });
+            }
+            return okToolResult({
+                ...walletIdentityResponse(session),
+                userAnswerUse: walletIdentityUserAnswerUse({
+                    hasAccount: session.status === "connected",
+                    hasFailure: session.status === "rejected" || session.status === "failed"
+                })
+            });
+        }
+        catch (error) {
+            return sessionStoreToolError(error, deps.logger);
+        }
+    });
+    server.registerTool(TOOL_NAMES.sessionWaitWalletIdentity, {
+        title: "Wait for wallet identity capture",
+        description: "Wait briefly for a wallet identity capture session to reach a terminal status.",
+        inputSchema: waitWalletIdentityInputSchema(),
+        outputSchema: successOutputSchema({
+            waitOutcome: z.enum(["status_reached", "timed_out"]),
+            walletSessionId: z.string(),
+            status: walletIdentityStatusSchema,
+            statusCategory: z.enum(["terminal", "non_terminal"]),
+            account: z.string().optional(),
+            chain: z.literal(SUI_MAINNET_WALLET_CHAIN).optional(),
+            walletName: z.string().optional(),
+            walletId: z.string().optional(),
+            failureReason: walletIdentityFailureReasonSchema.optional(),
+            failureDetail: z.string().optional(),
+            expiresAt: z.string(),
+            lastActivityAt: z.string(),
+            pollingHint: walletIdentityPollingHintSchema(),
+            userAnswerUse: userAnswerUseSchema
+        }),
+        annotations: { readOnlyHint: false, openWorldHint: false }
+    }, async ({ walletSessionId, timeoutMs }, extra) => {
+        try {
+            const result = await waitForWalletIdentitySession(deps.sessions, walletSessionId, {
+                timeoutMs,
+                signal: extra.signal
+            });
+            return okToolResult({
+                waitOutcome: result.waitOutcome,
+                ...walletIdentityResponse(result.session),
+                statusCategory: result.statusCategory,
+                userAnswerUse: walletIdentityUserAnswerUse({
+                    hasAccount: result.session.status === "connected",
+                    hasFailure: result.session.status === "rejected" || result.session.status === "failed",
+                    hasWaitOutcome: true
+                })
+            });
+        }
+        catch (error) {
+            return sessionStoreToolError(error, deps.logger);
+        }
+    });
+}

package/dist/mcp/tools/settings/index.js

@@ -0,0 +1,64 @@
+import { z } from "zod";
+import { SETTINGS_APPLIES_AFTER_RESTART } from "../../../core/preferences/preferencesStore.js";
+import { registerSayUrIntentTool } from "../../registerTool.js";
+import { okToolResult } from "../../result.js";
+import { noParamsInputSchema, successOutputSchema } from "../../schemas.js";
+import { localSettingsToolError, sessionStoreToolError } from "../../toolErrors.js";
+import { TOOL_NAMES } from "../../toolNames.js";
+const endpointSettingSchema = z.object({
+    storedValue: z.string(),
+    effectiveValue: z.string(),
+    source: z.enum(["environment", "local_db", "builtin_default"]),
+    pendingStoredValue: z.string().optional(),
+    appliesAfter: z.literal(SETTINGS_APPLIES_AFTER_RESTART).optional()
+});
+export function registerSettingsTools(server, deps) {
+    server.registerTool(TOOL_NAMES.settingsCreateLocalSettingsSession, {
+        title: "Create local settings session",
+        description: "Create a local settings page session.",
+        inputSchema: noParamsInputSchema,
+        outputSchema: successOutputSchema({
+            settingsSessionId: z.string(),
+            settingsUrl: z.string(),
+            status: z.literal("created"),
+            openTarget: z.literal("system_browser"),
+            accessScope: z.literal("same_machine_loopback"),
+            expiresAt: z.string(),
+            lastActivityAt: z.string()
+        }),
+        annotations: { readOnlyHint: false, openWorldHint: false }
+    }, async () => {
+        try {
+            const created = await deps.sessions.createSettingsSession();
+            return okToolResult({
+                settingsSessionId: created.session.id,
+                settingsUrl: `${deps.reviewBaseUrl}/settings/${created.session.id}#${created.token}`,
+                status: "created",
+                openTarget: "system_browser",
+                accessScope: "same_machine_loopback",
+                expiresAt: created.session.expiresAt,
+                lastActivityAt: created.session.lastActivityAt
+            });
+        }
+        catch (error) {
+            return sessionStoreToolError(error, deps.logger);
+        }
+    });
+    registerSayUrIntentTool(server, TOOL_NAMES.settingsGetLocalSettings, {
+        title: "Get local settings",
+        description: "Read local Say Ur Intent settings.",
+        inputSchema: noParamsInputSchema,
+        outputSchema: successOutputSchema({
+            suiGrpcUrl: endpointSettingSchema,
+            suiGraphqlUrl: endpointSettingSchema
+        }),
+        annotations: { readOnlyHint: true, openWorldHint: false }
+    }, async () => {
+        try {
+            return okToolResult(await deps.localSettings.getLocalSettings());
+        }
+        catch (error) {
+            return localSettingsToolError(error, deps.logger);
+        }
+    });
+}

package/dist/review-app/analysis.css

@@ -0,0 +1 @@
+body{color:#15201b;background:#f7f8f6;margin:0;font-family:ui-sans-serif,system-ui,-apple-system,BlinkMacSystemFont,Segoe UI,sans-serif}.wallet-shell{max-width:560px;margin:48px auto;padding:0 20px}h1{margin:0 0 16px;font-size:28px;line-height:1.2}p{margin:0 0 16px;font-size:15px;line-height:1.5}.status{color:#47524c}.success{color:#11673e;overflow-wrap:anywhere}.error{color:#8a2f1f}.wallet-list{gap:10px;margin-top:20px;display:grid}button{color:#15201b;min-height:42px;font:inherit;text-align:left;cursor:pointer;background:#fff;border:1px solid #c9d3cc;border-radius:8px;padding:10px 12px}button:hover:not(:disabled){border-color:#6f8f7d}button:disabled{cursor:not-allowed;color:#7b857f}

package/dist/review-app/analysis.js

@@ -0,0 +1 @@
+import{n as e,r as t,t as n}from"./http-DMvwuuFk.js";import{a as r,c as i,i as a,n as o,o as s,r as c}from"./walletStatus-CcojOdGy.js";var l=document.querySelector(`#analysis-app`);if(!l)throw Error(`analysis app root missing`);var u=l,d=u.dataset.walletSessionId??``,f=window.location.hash.startsWith(`#`)?window.location.hash.slice(1):``,p=r(),m=!1,h=!1,g=!1,_,v=s();v&&window.setTimeout(()=>{v=!1,y()},2e3),S(`opened`).then(()=>y()).catch(e=>{_=t(e,`The local review server did not accept this wallet session.`),y()}),p.stores.$wallets.subscribe(()=>y()),p.stores.$connection.subscribe(()=>y());function y(){let e=p.stores.$connection.get(),n=p.stores.$wallets.get();u.innerHTML=``;let r=document.createElement(`section`);r.className=`wallet-shell`;let i=document.createElement(`h1`);i.textContent=`Say Ur Intent Analysis`,r.append(i);let a=document.createElement(`p`);a.textContent=`Connect a Sui mainnet wallet to provide the account address used for account-bound checks, then view a wallet asset snapshot and your stored local review records. This page only captures an address and prepares no transaction.`,r.append(a);let o=document.createElement(`p`);if(o.className=`status`,o.setAttribute(`aria-live`,`polite`),o.setAttribute(`aria-atomic`,`true`),o.textContent=P(),r.append(o),_){let e=document.createElement(`p`);e.className=`error`,e.textContent=`Return to your AI client and request a new wallet identity URL.`,r.append(e)}if(!f){let e=document.createElement(`p`);e.className=`error`,e.textContent=`Missing wallet session token. Open the wallet URL from your AI client again.`,r.append(e)}else if(e.status===`connected`){v=!1;let t=document.createElement(`p`);t.className=`success`,t.textContent=`Connected address: ${e.account.address}`,r.append(t);let n=document.createElement(`button`);n.type=`button`,n.className=`secondary`,n.disabled=h||g,n.textContent=`Disconnect / switch wallet`,n.onclick=()=>{p.disconnectWallet().then(()=>y())},r.append(n),r.append(O()),M()}else if(v||e.status===`connecting`){let e=document.createElement(`p`);e.className=`status`,e.textContent=`Reconnecting your wallet…`,r.append(e)}else if(n.length===0){let e=document.createElement(`p`);e.className=`error`,e.textContent=`No compatible Sui wallet was detected in this browser.`,r.append(e);let n=document.createElement(`button`);n.type=`button`,n.disabled=g,n.textContent=`Report no compatible wallet`,n.onclick=()=>{x(c()).then(()=>y()).catch(e=>{_=t(e,`The local review server did not accept this wallet identity result.`),y()})},r.append(n)}else{let e=document.createElement(`div`);e.className=`wallet-list`;for(let t of n){let n=document.createElement(`button`);n.type=`button`,n.disabled=h,n.textContent=t.name,n.onclick=()=>b(t),e.append(n)}r.append(e)}u.append(r)}async function b(e){if(h||g||m)return;h=!0,_=void 0,y();try{await S(`connecting`)}catch(e){_=t(e,`The local review server did not accept this wallet session.`),h=!1,y();return}let n;try{let t=(await p.connectWallet({wallet:e})).accounts[0];n=o(t,{walletName:e.name,walletId:i(e)})}catch(t){n=a(t,{walletName:e.name,walletId:i(e)})}try{await x(n)}catch(e){_=t(e,`The local review server did not accept this wallet identity result.`)}finally{h=!1,y()}}async function x(e){if(!(m||g)){g=!0,_=void 0,y();try{await C(`/api/wallet/${encodeURIComponent(d)}/result`,e),m=!0}finally{g=!1}}}async function S(e){f&&await C(`/api/wallet/${encodeURIComponent(d)}/${e}`,{})}async function C(t,r){let i=await fetch(t,{method:`POST`,headers:{"content-type":`application/json`,"x-say-ur-intent-token":f},body:JSON.stringify(r)});if(!i.ok)throw new n(i.status,await e(i))}var w=!1,T,E,D;function O(){let e=document.createElement(`div`);e.className=`analysis-panels`,e.append(k(`Wallet asset snapshot`,A())),e.append(k(`Local review records`,j()));let t=document.createElement(`p`);return t.className=`boundary-note`,t.textContent=`These panels show a wallet asset snapshot at its fetched time and stored local review records. They are not P&L, not tax or cost-basis data, not payment readiness, and not signing readiness.`,e.append(t),e}function k(e,t){let n=document.createElement(`section`);n.className=`analysis-panel`;let r=document.createElement(`h2`);return r.textContent=e,n.append(r),n.append(t),n}function A(){let e=document.createElement(`div`);if(D)return e.textContent=D,e;if(!T)return e.textContent=`Loading wallet asset snapshot from the local server.`,e;let t=typeof T.fetchedAt==`string`?T.fetchedAt:void 0;if(t){let n=document.createElement(`p`);n.textContent=`Checked at ${t}`,e.append(n)}let n=Array.isArray(T.balances)?T.balances:[];if(n.length===0){let t=document.createElement(`p`);return t.textContent=`No coin balances were returned for this account snapshot.`,e.append(t),e}let r=document.createElement(`ul`);for(let e of n){if(typeof e!=`object`||!e)continue;let t=e,n=document.createElement(`li`),i=typeof t.symbol==`string`?t.symbol:`(unknown symbol)`,a=typeof t.display==`string`?t.display:void 0,o=typeof t.raw==`string`?t.raw:void 0;n.textContent=a===void 0?`${i}: raw ${o??`unavailable`}`:`${i}: ${a}`,r.append(n)}return e.append(r),e}function j(){let e=document.createElement(`div`);if(D)return e.textContent=D,e;if(!E)return e.textContent=`Loading stored local review records from the local server.`,e;let t=document.createElement(`ul`);for(let[e,n]of Object.entries(E)){if(typeof n!=`number`&&typeof n!=`string`)continue;let r=document.createElement(`li`);r.textContent=`${e}: ${n}`,t.append(r)}return t.childElementCount===0?(e.textContent=`No stored local review records were returned.`,e):(e.append(t),e)}async function M(){if(!w){w=!0;try{let[e,t]=await Promise.all([N(`/api/analysis/${encodeURIComponent(d)}/assets`),N(`/api/analysis/${encodeURIComponent(d)}/review-activity`)]);T=e,E=t}catch(e){D=t(e,`The local server could not return analysis data for this session.`)}y()}}async function N(t){let r=await fetch(t,{headers:{"x-say-ur-intent-token":f}});if(!r.ok)throw new n(r.status,await e(r));return await r.json()}function P(){return _||(m?`Wallet identity result was sent to the local server.`:g?`Sending wallet identity result to the local server.`:h?`Finish or cancel the request in your wallet popup.`:`Choose a wallet to continue.`)}

package/dist/review-app/arc-BjIacwQm.js

@@ -0,0 +1 @@
+import{n as e,t}from"./path-AEo9W6mQ.js";import{a as n,c as r,d as i,f as a,i as o,l as s,n as c,p as l,r as u,s as d,t as f,u as p}from"./math-kmyYrkHL.js";function m(e){return e.innerRadius}function h(e){return e.outerRadius}function g(e){return e.startAngle}function _(e){return e.endAngle}function v(e){return e&&e.padAngle}function y(e,t,n,r,i,a,o,s){var c=n-e,l=r-t,u=o-i,d=s-a,f=d*c-u*l;if(!(f*f<1e-12))return f=(u*(t-a)-d*(e-i))/f,[e+f*c,t+f*l]}function b(e,t,n,i,o,s,c){var l=e-n,u=t-i,d=(c?s:-s)/a(l*l+u*u),f=d*u,p=-d*l,m=e+f,h=t+p,g=n+f,_=i+p,v=(m+g)/2,y=(h+_)/2,b=g-m,x=_-h,S=b*b+x*x,C=o-s,w=m*_-g*h,T=(x<0?-1:1)*a(r(0,C*C*S-w*w)),E=(w*x-b*T)/S,D=(-w*b-x*T)/S,O=(w*x+b*T)/S,k=(-w*b+x*T)/S,A=E-v,j=D-y,M=O-v,N=k-y;return A*A+j*j>M*M+N*N&&(E=O,D=k),{cx:E,cy:D,x01:-f,y01:-p,x11:E*(o/C-1),y11:D*(o/C-1)}}function x(){var r=m,x=h,S=e(0),C=null,w=g,T=_,E=v,D=null,O=t(k);function k(){var e,t,m=+r.apply(this,arguments),h=+x.apply(this,arguments),g=w.apply(this,arguments)-d,_=T.apply(this,arguments)-d,v=f(_-g),k=_>g;if(D||=e=O(),h<m&&(t=h,h=m,m=t),!(h>1e-12))D.moveTo(0,0);else if(v>l-1e-12)D.moveTo(h*n(g),h*i(g)),D.arc(0,0,h,g,_,!k),m>1e-12&&(D.moveTo(m*n(_),m*i(_)),D.arc(0,0,m,_,g,k));else{var A=g,j=_,M=g,N=_,P=v,F=v,I=E.apply(this,arguments)/2,L=I>1e-12&&(C?+C.apply(this,arguments):a(m*m+h*h)),R=s(f(h-m)/2,+S.apply(this,arguments)),z=R,B=R,V,H;if(L>1e-12){var U=u(L/m*i(I)),W=u(L/h*i(I));(P-=U*2)>1e-12?(U*=k?1:-1,M+=U,N-=U):(P=0,M=N=(g+_)/2),(F-=W*2)>1e-12?(W*=k?1:-1,A+=W,j-=W):(F=0,A=j=(g+_)/2)}var G=h*n(A),K=h*i(A),q=m*n(N),J=m*i(N);if(R>1e-12){var Y=h*n(j),X=h*i(j),Z=m*n(M),Q=m*i(M),$;if(v<p)if($=y(G,K,Z,Q,Y,X,q,J)){var ee=G-$[0],te=K-$[1],ne=Y-$[0],re=X-$[1],ie=1/i(c((ee*ne+te*re)/(a(ee*ee+te*te)*a(ne*ne+re*re)))/2),ae=a($[0]*$[0]+$[1]*$[1]);z=s(R,(m-ae)/(ie-1)),B=s(R,(h-ae)/(ie+1))}else z=B=0}F>1e-12?B>1e-12?(V=b(Z,Q,G,K,h,B,k),H=b(Y,X,q,J,h,B,k),D.moveTo(V.cx+V.x01,V.cy+V.y01),B<R?D.arc(V.cx,V.cy,B,o(V.y01,V.x01),o(H.y01,H.x01),!k):(D.arc(V.cx,V.cy,B,o(V.y01,V.x01),o(V.y11,V.x11),!k),D.arc(0,0,h,o(V.cy+V.y11,V.cx+V.x11),o(H.cy+H.y11,H.cx+H.x11),!k),D.arc(H.cx,H.cy,B,o(H.y11,H.x11),o(H.y01,H.x01),!k))):(D.moveTo(G,K),D.arc(0,0,h,A,j,!k)):D.moveTo(G,K),!(m>1e-12)||!(P>1e-12)?D.lineTo(q,J):z>1e-12?(V=b(q,J,Y,X,m,-z,k),H=b(G,K,Z,Q,m,-z,k),D.lineTo(V.cx+V.x01,V.cy+V.y01),z<R?D.arc(V.cx,V.cy,z,o(V.y01,V.x01),o(H.y01,H.x01),!k):(D.arc(V.cx,V.cy,z,o(V.y01,V.x01),o(V.y11,V.x11),!k),D.arc(0,0,m,o(V.cy+V.y11,V.cx+V.x11),o(H.cy+H.y11,H.cx+H.x11),k),D.arc(H.cx,H.cy,z,o(H.y11,H.x11),o(H.y01,H.x01),!k))):D.arc(0,0,m,N,M,k)}if(D.closePath(),e)return D=null,e+``||null}return k.centroid=function(){var e=(+r.apply(this,arguments)+ +x.apply(this,arguments))/2,t=(+w.apply(this,arguments)+ +T.apply(this,arguments))/2-p/2;return[n(t)*e,i(t)*e]},k.innerRadius=function(t){return arguments.length?(r=typeof t==`function`?t:e(+t),k):r},k.outerRadius=function(t){return arguments.length?(x=typeof t==`function`?t:e(+t),k):x},k.cornerRadius=function(t){return arguments.length?(S=typeof t==`function`?t:e(+t),k):S},k.padRadius=function(t){return arguments.length?(C=t==null?null:typeof t==`function`?t:e(+t),k):C},k.startAngle=function(t){return arguments.length?(w=typeof t==`function`?t:e(+t),k):w},k.endAngle=function(t){return arguments.length?(T=typeof t==`function`?t:e(+t),k):T},k.padAngle=function(t){return arguments.length?(E=typeof t==`function`?t:e(+t),k):E},k.context=function(e){return arguments.length?(D=e??null,k):D},k}export{x as t};

package/dist/review-app/architecture-U656AL7Q-aSB9x1OK.js

@@ -0,0 +1 @@
+import"./chunk-FPAJGGOC-DDHjQ09H.js";import{n as e}from"./chunk-O7ZBX7Z2-pxdK4Sa3.js";export{e as createArchitectureServices};