diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md
index 41aecc02..92a675a6 100644
--- a/docs/ARCHITECTURE.md
+++ b/docs/ARCHITECTURE.md
@@ -147,6 +147,21 @@ A Cloudflare Workers-based strategy switch console. The daily pages are the Reac
 
 **Dependency boundary:** The web app consumes generated assets (`config.js`, `strategy_profiles_asset.js`) and reads `platform-config.json` indirectly via the Worker API. It does **not** depend on Python scripts at runtime.
 
+The cockpit overview and health pages share `AuditHistory`, which follows the
+audit API's opaque `next_cursor` and deduplicates event IDs across pages. Refresh
+discards the old traversal; a failed continuation preserves loaded events and
+offers retry. Malformed or partial payloads cannot become a successful empty
+history. The adapter consumes `id`, `actor_alias`, structured `subject` and
+nullable string `revision` from `qsl.audit_events.v1`.
+
+The account overview reads `/api/runtime/readback?scope=platform:account-alias`.
+It displays the observed runtime switch, scheduler state and producer timestamp
+from `qsl.runtime_readback.v1`. Stale or unavailable observations remain unknown;
+configuration, decision receipts and application status do not substitute for
+runtime readback. These reads add no mutation or trading authority. Until the
+backend endpoints are available, 404/501 responses display unavailable and
+transport/server failures display a retryable read error.
+
 ---
 
 ## CI/CD: Independent Validation
diff --git a/tests/console_cockpit_decision_validation.mjs b/tests/console_cockpit_decision_validation.mjs
new file mode 100644
index 00000000..8cb3529e
--- /dev/null
+++ b/tests/console_cockpit_decision_validation.mjs
@@ -0,0 +1,162 @@
+import assert from "node:assert/strict";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import { build } from "../web/strategy-switch-console/frontend/node_modules/esbuild/lib/main.js";
+
+const root = fileURLToPath(new URL("../web/strategy-switch-console/frontend/", import.meta.url));
+const directory = await mkdtemp(join(tmpdir(), "cockpit-decision-"));
+try {
+  const outfile = join(directory, "cockpit.cjs");
+  await build({
+    stdin: {
+      resolveDir: root,
+      contents: `
+        import { createElement as h } from 'react';
+        import { renderToStaticMarkup } from 'react-dom/server';
+        import { I18nProvider } from './src/i18n';
+        import { actionBlockers, expiryState, MutationOutcomeUnknown } from './src/api/cockpit';
+        import { ApplicationStatus, DigestStatus, EffectivePolicyPanel, RiskTierSelector } from './src/components/cockpit';
+        export { actionBlockers, expiryState, MutationOutcomeUnknown };
+        const wrap = (language, node) => renderToStaticMarkup(h(I18nProvider, { language }, node));
+        export const tiers = (language) => wrap(language, h(RiskTierSelector, {
+          scope: 'demo_account', value: 'BALANCED_COMPOUNDING', savedValue: 'BALANCED_COMPOUNDING',
+          selectionRevision: 12, mappingAvailable: true, disabled: false, saving: false, dirty: false,
+          onChange: () => {}, onSave: () => {},
+        }));
+        const binding = {
+          scope: 'demo_account', selected_tier: 'GROWTH_COMPOUNDING', selection_revision: 12,
+          approved_tier: null, approved_policy_id: null, approved_policy_revision: null,
+          effective_tier: 'BALANCED_COMPOUNDING', effective_policy_id: 'demo-balanced-v3',
+          effective_policy_revision: 'r7', effective_observed_at: '2026-11-01T09:10:00Z',
+          temporary_restriction: { active: true, reason: 'Reduction only', until: null },
+          values: [{ key: 'max_gross_exposure', label_key: null, value: 45, unit: 'percent', status: 'known', source: 'server' }],
+        };
+        export const policy = (language) => wrap(language, h(EffectivePolicyPanel, { binding }));
+        const base = {
+          operation_id: 'op-1', request_id: 'req-1', decision_id: 'decision-1', decision_revision: 3,
+          action: 'approve', title_key: null, account_alias: null, platform: null, release_id: null,
+          target_id: null, state: 'applied', recorded_at: null, dispatched_at: null,
+          applied_at: '2026-11-01T10:00:05Z', applied_by: 'platform', runtime_confirmed_at: null,
+          runtime_state: 'unknown', failure_reason: null, unknown_reason: null,
+          readback_available: null, server_time: null,
+        };
+        export const applied = (language) => wrap(language, h(ApplicationStatus, { operation: base, status: 'ready' }));
+        export const confirmed = (language) => wrap(language, h(ApplicationStatus, {
+          operation: { ...base, runtime_confirmed_at: '2026-11-01T10:05:00Z', runtime_state: 'running' }, status: 'ready',
+        }));
+        export const operationMissing = (language) => wrap(language, h(ApplicationStatus, { operation: null, status: 'not_ready' }));
+        export const digestAccepted = (language) => wrap(language, h(DigestStatus, {
+          digest: {
+            business_day: '2026-11-01', timezone: 'America/New_York', expected_targets: 4,
+            covered_targets: 3, unavailable_targets: 1, delivery_state: 'accepted',
+            accepted_at: '2026-11-01T13:05:00Z', acknowledged_at: null,
+            source_as_of: '2026-11-01T13:00:00Z', legacy_receipts: false, targets: [],
+          },
+        }));
+      `,
+    },
+    bundle: true,
+    platform: "node",
+    format: "cjs",
+    outfile,
+    jsx: "automatic",
+    loader: { ".css": "empty" },
+    define: { "import.meta.env": "{}" },
+    logLevel: "silent",
+  });
+  const ui = createRequire(import.meta.url)(outfile);
+
+  // Expiry is derived from the server clock plus elapsed time only.
+  const received = "2026-11-01T10:00:00Z";
+  const receivedMs = Date.parse(received);
+  assert.equal(ui.expiryState("2026-11-01T10:30:00Z", "2026-11-01T10:00:00Z", received, receivedMs).state, "open");
+  assert.equal(ui.expiryState("2026-11-01T10:30:00Z", "2026-11-01T10:00:00Z", received, receivedMs + 31 * 60_000).state,
+    "expired", "a forward browser clock cannot extend server validity");
+  assert.equal(ui.expiryState("2026-11-01T10:30:00Z", "2026-11-01T10:00:00Z", received, receivedMs - 60 * 60_000).state,
+    "open", "a backward browser clock cannot expire a decision early");
+  assert.equal(ui.expiryState("2026-11-01T10:30:00Z", null, received, receivedMs).state, "unknown",
+    "without a server clock the boundary stays unconfirmed");
+  assert.equal(ui.expiryState(null, null, received, receivedMs).state, "none");
+
+  const decision = {
+    state: "pending", allowed_actions: ["approve"], expires_at: null, revision: 2,
+    policy: { selected_tier: "BALANCED_COMPOUNDING", policy_revision: "r7" },
+    evidence: { state: "current", qualification: "qualified", limitations: [] },
+  };
+  const view = { serverTime: "2026-11-01T10:00:00Z", receivedAt: received, now: receivedMs };
+  assert.deepEqual(ui.actionBlockers(decision, view), []);
+  assert.ok(ui.actionBlockers({ ...decision, evidence: { ...decision.evidence, state: "stale" } }, view).includes("evidence_stale"),
+    "stale supporting data blocks approval");
+  assert.ok(ui.actionBlockers({ ...decision, evidence: { ...decision.evidence, qualification: "unknown" } }, view).includes("evidence_unqualified"));
+  assert.ok(ui.actionBlockers({ ...decision, allowed_actions: [] }, view).includes("approval_not_allowed"),
+    "the server allow-list stays authoritative");
+  assert.ok(ui.actionBlockers({ ...decision, policy: null }, view).includes("policy_unavailable"));
+  assert.ok(ui.actionBlockers({ ...decision, policy: { selected_tier: null, policy_revision: null } }, view).includes("policy_binding_missing"));
+
+  const unknown = new ui.MutationOutcomeUnknown("req-1", "op-1");
+  assert.equal(unknown.requestId, "req-1");
+  assert.equal(unknown.operationId, "op-1");
+  assert.equal(unknown.message, "mutation_outcome_unknown");
+
+  // Selected preference, approved mapping and observed policy stay separate.
+  const policyEn = ui.policy("en");
+  assert.match(policyEn, /Growth compounding/, "the selected preference is shown");
+  assert.match(policyEn, /Balanced compounding/, "the observed policy is not overwritten by the selection");
+  assert.match(policyEn, /Reduction only/, "a temporary restriction is shown separately");
+  assert.match(policyEn, /Policy mapping unavailable/, "a missing approved mapping stays unavailable");
+
+  // Applied is not runtime-confirmed.
+  const applied = ui.applied("en");
+  assert.match(applied, /Platform reported applied; runtime confirmation pending/);
+  assert.doesNotMatch(applied, /Runtime confirmed/);
+  assert.match(ui.confirmed("en"), /Runtime confirmed/);
+  assert.match(ui.operationMissing("en"), /operation-status endpoint is not available/);
+
+  // Accepted delivery is not delivered, and coverage stays visible.
+  const digest = ui.digestAccepted("en");
+  assert.match(digest, /Accepted for delivery/);
+  assert.match(digest, /Targets 4 · covered 3 · unavailable 1/);
+  assert.match(digest, /Accepted is not delivered/);
+  assert.match(ui.tiers("zh"), /平衡复利/);
+  assert.match(ui.tiers("en"), /checked/);
+  assert.match(ui.tiers("en"), /No tier selected/, "clearing a tier preference stays possible");
+
+  // The promotion request no longer carries a client-chosen tier.
+  const decisions = await readFile(new URL("../web/strategy-switch-console/frontend/src/pages/decisions/DecisionsPage.tsx", import.meta.url), "utf8");
+  assert.doesNotMatch(decisions, /CAPITAL_PRESERVATION/, "the promotion request must not hard-code a tier");
+  assert.match(decisions, /promotionRiskBinding/);
+  assert.match(decisions, /risk\.policy_revision/);
+  assert.match(decisions, /allowed_actions/, "server allow-lists gate the client controls");
+
+  // Pages consume the cockpit surfaces instead of restating them.
+  const sources = await Promise.all([
+    "src/pages/overview/OverviewPage.tsx",
+    "src/pages/strategies/StrategiesPage.tsx",
+    "src/pages/accounts/AccountDetail.tsx",
+    "src/pages/accounts/RiskPreference.tsx",
+    "src/pages/health/HealthPage.tsx",
+  ].map(file => readFile(new URL(`../web/strategy-switch-console/frontend/${file}`, import.meta.url), "utf8")));
+  const [overview, strategies, accountDetail, riskPreference, health] = sources;
+  assert.match(overview, /function DecisionQueue/);
+  assert.match(overview, /queue_incomplete/, "a partial queue hides reassuring counts");
+  assert.match(overview, /AuditHistory/);
+  const activity = await readFile(join(root, "src/components/AuditHistory.tsx"), "utf8");
+  assert.match(activity, /loadAuditEvents\(cursor\)/);
+  assert.match(activity, /next_cursor/);
+  assert.match(strategies, /loadLifecycles/);
+  assert.match(strategies, /LifecycleStepper/);
+  assert.match(strategies, /binding\.present/, "absent lifecycle records stay absent");
+  assert.match(accountDetail, /loadPolicyBinding/);
+  assert.match(accountDetail, /EffectivePolicyPanel/);
+  assert.match(riskPreference, /RiskTierSelector/);
+  assert.doesNotMatch(riskPreference, /<select/, "the tier picker is no longer a bare select");
+  assert.match(health, /loadDigestStatus/);
+  assert.match(health, /DigestStatus/);
+  assert.match(health, /AuditHistory/);
+} finally {
+  await rm(directory, { recursive: true, force: true });
+}
+console.log("console_cockpit_decision_validation: PASS");
diff --git a/tests/console_cockpit_readback_validation.mjs b/tests/console_cockpit_readback_validation.mjs
new file mode 100644
index 00000000..c880f2ef
--- /dev/null
+++ b/tests/console_cockpit_readback_validation.mjs
@@ -0,0 +1,87 @@
+import assert from "node:assert/strict";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import { build } from "../web/strategy-switch-console/frontend/node_modules/esbuild/lib/main.js";
+
+const root = fileURLToPath(new URL("../web/strategy-switch-console/frontend/", import.meta.url));
+const directory = await mkdtemp(join(tmpdir(), "cockpit-readback-"));
+const originalFetch = globalThis.fetch, originalWindow = globalThis.window;
+try {
+  const outfile = join(directory, "readback.cjs");
+  await build({ stdin: { resolveDir: root, contents: `
+    import { createElement as h } from 'react';
+    import { renderToStaticMarkup } from 'react-dom/server';
+    import { I18nProvider } from './src/i18n';
+    import { AuditTimeline } from './src/components/cockpit';
+    import { RuntimeReadbackDetails } from './src/components/RuntimeReadbackPanel';
+    export { loadAuditEvents, loadRuntimeReadback } from './src/api/cockpit';
+    export { mergeAuditEvents } from './src/components/AuditHistory';
+    const wrap = node => renderToStaticMarkup(h(I18nProvider, { language: 'en' }, node));
+    export const timeline = events => wrap(h(AuditTimeline, { events, status: 'ready', hasMore: true, onMore() {} }));
+    export const runtime = value => wrap(h(RuntimeReadbackDetails, { value }));
+  ` }, bundle: true, platform: "node", format: "cjs", outfile, logLevel: "silent" });
+  const api = createRequire(import.meta.url)(outfile);
+  const event = { id: "durable_human_decision:demo", source: "durable_human_decision", occurred_at: "2026-11-01T00:00:00.000Z",
+    actor_alias: "user-demo", action: "record_owner_decision", subject: { kind: "owner_decision", id: "demo" },
+    revision: "demo-revision", outcome: "decided", ref: null };
+  const page = { schema_version: "qsl.audit_events.v1", data_status: "ready", events: [event], next_cursor: "opaque_cursor",
+    coverage: "durable_and_retained", errors: [], server_time: "2026-11-01T00:01:00.000Z" };
+  let path, method;
+  const respond = (body, status = 200) => { globalThis.fetch = async (url, options) => {
+    path = url; method = options.method; return Response.json(body, { status });
+  }; };
+  respond(page);
+  let read = await api.loadAuditEvents();
+  assert.equal(method, "GET");
+  assert.equal(path, "/api/audit-events?limit=25");
+  assert.equal(read.data.next_cursor, "opaque_cursor");
+  assert.equal(read.data.events[0].event_id, event.id);
+  assert.equal(read.data.events[0].actor, event.actor_alias);
+  assert.equal(read.data.events[0].subject, "owner_decision: demo");
+  assert.equal(read.data.events[0].revision, "demo-revision");
+  assert.match(api.timeline(read.data.events), /Load more/);
+  const first = read.data.events;
+  respond({ ...page, events: [{ ...event, id: "older" }], next_cursor: null });
+  read = await api.loadAuditEvents("opaque_cursor");
+  assert.equal(path, "/api/audit-events?limit=25&cursor=opaque_cursor");
+  assert.equal(read.data.next_cursor, null);
+  assert.deepEqual(api.mergeAuditEvents(first, [...first, ...read.data.events]).map(row => row.event_id), [event.id, "older"]);
+  for (const malformed of [ {}, { ...page, data_status: "partial" }, { ...page, events: null },
+    { ...page, next_cursor: undefined }, { ...page, events: [{}] }, { ...page, events: [event, event] },
+    { ...page, errors: ["source_unavailable"] }, { ...page, next_cursor: "" }, { ...page, events: [] } ]) {
+    respond(malformed); await assert.rejects(api.loadAuditEvents(), /invalid_|duplicate_/);
+  }
+  respond(page); await assert.rejects(api.loadAuditEvents("opaque_cursor"), /invalid_audit_page/);
+  respond({}, 404); assert.equal((await api.loadAuditEvents()).status, "not_ready");
+  respond({}, 503); await assert.rejects(api.loadAuditEvents());
+  globalThis.window = new EventTarget();
+  let invalidations = 0;
+  window.addEventListener("qsl-private-session-invalid", () => invalidations++);
+  for (const status of [401, 403]) { respond({}, status); await assert.rejects(api.loadAuditEvents()); }
+  assert.equal(invalidations, 2);
+  const runtime = { server_time: "2026-11-01T00:01:00.000Z", schema_version: "qsl.runtime_readback.v1", scope: "longbridge:demo", data_status: "ready",
+    observed_at: event.occurred_at, runtime_enabled: false, scheduler_state: "paused", strategy_profile: "demo",
+    source: "stored_runtime_target_lifecycle", policy: { read_only: true, no_order: true, execution_authority_granted: false } };
+  respond(runtime); read = await api.loadRuntimeReadback(runtime.scope);
+  assert.equal(path, "/api/runtime/readback?scope=longbridge%3Ademo");
+  assert.equal(read.data.runtime_enabled, false);
+  assert.match(api.runtime(read.data), /Disabled/);
+  respond({ ...runtime, data_status: "stale", runtime_enabled: null, scheduler_state: "unknown", strategy_profile: null });
+  read = await api.loadRuntimeReadback(runtime.scope);
+  assert.equal(read.data.runtime_enabled, null);
+  assert.match(api.runtime(read.data), /Unknown/);
+  assert.doesNotMatch(api.runtime(read.data), /Disabled/);
+  for (const malformed of [{ ...runtime, scope: "longbridge:other" }, { ...runtime, data_status: "stale" },
+    { ...runtime, observed_at: null }, { ...runtime, runtime_enabled: "false" }, { ...runtime, policy: {} }, {}]) {
+    respond(malformed); await assert.rejects(api.loadRuntimeReadback(runtime.scope), /invalid_runtime_readback/);
+  }
+  respond({}, 503); await assert.rejects(api.loadRuntimeReadback(runtime.scope));
+  respond({}, 404); assert.equal((await api.loadRuntimeReadback(runtime.scope)).status, "not_ready");
+  console.log("Cockpit audit and runtime readback validation passed");
+} finally {
+  globalThis.fetch = originalFetch; globalThis.window = originalWindow;
+  await rm(directory, { recursive: true, force: true });
+}
diff --git a/tests/console_display_gaps_validation.mjs b/tests/console_display_gaps_validation.mjs
index 0677fec6..870988c9 100644
--- a/tests/console_display_gaps_validation.mjs
+++ b/tests/console_display_gaps_validation.mjs
@@ -43,8 +43,16 @@ try {
     define: { "import.meta.env": "{}" }, plugins: [{ name: "controlled-read", setup(b) {
       b.onLoad({ filter: /\/lib\/hooks\.ts$/ }, () => ({ contents:
         "export const useApi = () => globalThis.__displayState;", loader: "js" }));
-      b.onLoad({ filter: /\/api\/client\.ts$/ }, () => ({ contents:
-        "export async function getJson() { if (globalThis.__displayError) throw Error('synthetic_read_failure'); return globalThis.__displayPayload; } export const readRevision = () => 0; export const postJson = () => { throw Error('writes_forbidden'); };", loader: "js" }));
+      b.onLoad({ filter: /\/api\/client\.ts$/ }, () => ({ contents: `
+        export class AccessError extends Error {
+          constructor(status) { super(status === 401 ? 'session_expired' : 'access_denied'); this.status = status; }
+        }
+        export class HttpError extends Error {
+          constructor(status, payload) { super(payload?.error || 'http_' + status); this.status = status; this.payload = payload; }
+        }
+        export async function getJson() { if (globalThis.__displayError) throw Error('synthetic_read_failure'); return globalThis.__displayPayload; }
+        export const readRevision = () => 0;
+        export const postJson = () => { throw Error('writes_forbidden'); };`, loader: "js" }));
       for (const [file, exports] of [["StrategiesPage", "CatalogTab, ResearchTab, parseResearchLeads, loadResearchLeads"],
         ["HealthPage", "StatStrip, CredentialsCard"], ["RunGrid", "DayDetail"]]) {
         b.onLoad({ filter: new RegExp(`/${file}\\.tsx$`) }, async ({ path }) => ({
diff --git a/tests/console_notification_receipts_ui_validation.mjs b/tests/console_notification_receipts_ui_validation.mjs
index 47f8fd59..29511833 100644
--- a/tests/console_notification_receipts_ui_validation.mjs
+++ b/tests/console_notification_receipts_ui_validation.mjs
@@ -8,15 +8,15 @@ import { build } from "../web/strategy-switch-console/frontend/node_modules/esbu
 import { createNotificationLogReader } from "../web/strategy-switch-console/application/console_api/notification_receipts.js";
 
 /*
- * The health page no longer presents a notification module: there is no
- * trustworthy source for "what is the current notification state", and the old
- * GitHub receipts are transport diagnostics, not run status. This file therefore
- * keeps two jobs:
+ * The health page presents no legacy notification module: the old GitHub
+ * receipts are transport diagnostics, not run status, and the page shows a
+ * labeled digest-delivery projection instead. This file therefore keeps two
+ * jobs:
  *
  * 1. Prove the read-only receipt API still exists and still classifies reads.
  *    Removing the UI is not retiring the API.
- * 2. Prove the health page renders no legacy/current notification module and
- *    issues no notification request, while keeping its other real states.
+ * 2. Prove the health page renders no legacy/current notification module, reads
+ *    the digest source at most once, and keeps its other real states.
  */
 
 const root = new URL("../web/strategy-switch-console/frontend/", import.meta.url).pathname;
@@ -76,7 +76,22 @@ try {
             globalThis.__calls.push('loadRuntimeDaily'); return globalThis.__fx.daily; });
           export const loadNotificationLog = named('loadNotificationLog', () => {
             globalThis.__notificationRequests += 1;
-            throw new Error('the health page must not request the notification log'); });`,
+            globalThis.__calls.push('loadNotificationLog');
+            return globalThis.__fx.notificationLog; });`,
+        loader: "js",
+      }));
+      // The digest adapter reads the legacy log but only surfaces a labeled
+      // projection; these adapters never reach the network during SSR.
+      builder.onLoad({ filter: /\/api\/client\.ts$/ }, () => ({
+        contents: `export class AccessError extends Error { constructor(status) { super('access'); this.status = status; } }
+          export class HttpError extends Error { constructor(status) { super('http'); this.status = status; } }
+          export const invalidatePrivateSession = () => {};
+          export const getJson = async path => {
+            globalThis.__calls.push('getJson:' + path);
+            if (path.startsWith('/api/audit-events')) return { schema_version: 'qsl.audit_events.v1', data_status: 'ready', events: [], next_cursor: null, coverage: 'synthetic', errors: [] };
+            throw new HttpError(404);
+          };
+          export const postJson = async () => { throw new HttpError(404); };`,
         loader: "js",
       }));
       // Call the loader during render so the counters above observe real calls.
@@ -84,7 +99,7 @@ try {
         contents: `export function useApi(loader) {
             try {
               const data = loader();
-              if (data && data.__loading) return { phase: 'loading', data: null, error: null, reload() {} };
+              if (data && (data.__loading || typeof data.then === 'function')) return { phase: 'loading', data: null, error: null, reload() {} };
               return { phase: 'ready', data, error: null, reload() {} };
             } catch (error) { return { phase: 'error', data: null, error, reload() {} }; }
           }
@@ -112,6 +127,10 @@ try {
     accounts: { accounts: [] },
     bindings: [],
     daily: null,
+    notificationLog: {
+      status: "ok", as_of: "2026-10-30T20:00:00Z", items: [], next_cursor: null,
+      coverage: "recent_daily_digest_public_receipts_only", unavailable_reason: null,
+    },
   };
 
   const render = (language, override = {}) => {
@@ -142,7 +161,7 @@ try {
   const titles = html => [...html.matchAll(/class="kpi-title">([^<]*)</g)].map(match => decode(match[1]));
 
   for (const language of ["zh", "en"]) {
-    test(`${language}: health renders no notification module and issues no notification request`, () => {
+    test(`${language}: health renders no legacy notification module and reads the digest source once`, () => {
       const html = render(language);
       for (const copy of REMOVED[language]) {
         assert.ok(!html.includes(copy), `removed notification copy is still rendered: ${copy}`);
@@ -158,8 +177,10 @@ try {
       assert.ok(!html.includes("notification-reason"), "the legacy reason disclosure is gone");
       assert.ok(!html.includes("actions/runs"), "no raw run/attempt link is rendered");
       assert.ok(!html.includes("data-state=\"unverified\""), "no faux current-notification badge is rendered");
-      assert.equal(globalThis.__notificationRequests, 0, "the page must not request the notification log");
-      assert.ok(!globalThis.__calls.includes("loadNotificationLog"), "no notification loader runs");
+      // The digest projection reads the same source, but only once, and the
+      // legacy receipt rows themselves never reach the page.
+      assert.equal(globalThis.__notificationRequests, 1, "the digest projection reads its source exactly once");
+      assert.equal(globalThis.__calls.filter(call => call === "loadNotificationLog").length, 1, "no second notification read");
       // Only the freshness and credential tables remain.
       assert.equal((html.match(/<table/g) || []).length, 2, "only freshness and credential tables remain");
       // The page itself is intact.
@@ -186,16 +207,18 @@ try {
       globalThis.__throw = "loadCredentialMaintenance";
       globalThis.__fx = { ...fixtures };
       globalThis.__calls = [];
+      globalThis.__notificationRequests = 0;
       const errorHtml = ui.render(language);
       assert.ok(errorHtml.includes(language === "zh" ? "重试" : "Retry"), "a failed credential read keeps its retry");
-      assert.equal(globalThis.__notificationRequests, 0);
+      assert.equal(globalThis.__notificationRequests, 1, "the digest source is still read exactly once per render");
 
       // Loading still shows skeletons rather than an empty page.
       globalThis.__fx = { ...fixtures };
       globalThis.__loading = ["loadTodayRuns"];
+      globalThis.__notificationRequests = 0;
       const loadingHtml = ui.render(language);
       assert.ok(loadingHtml.includes("skeleton"), "the loading state still renders skeletons");
-      assert.equal(globalThis.__notificationRequests, 0);
+      assert.equal(globalThis.__notificationRequests, 1, "the digest source is still read exactly once per render");
       globalThis.__loading = [];
       globalThis.__throw = null;
     });
diff --git a/tests/console_shell_unavailable_source_ui_validation.mjs b/tests/console_shell_unavailable_source_ui_validation.mjs
index 0a1478e9..b04f4790 100644
--- a/tests/console_shell_unavailable_source_ui_validation.mjs
+++ b/tests/console_shell_unavailable_source_ui_validation.mjs
@@ -34,7 +34,7 @@ try {
   // --- To-do badge ----------------------------------------------------------
   const unknownEn = ui.shell("en", null, "read_failed");
   assert.match(unknownEn, /nav-badge-unknown/, "an unreadable inbox marks the to-do item");
-  assert.match(unknownEn, /aria-label="To-dos · To-do count unavailable"/,
+  assert.match(unknownEn, /aria-label="Decisions · To-do count unavailable"/,
     "the unknown marker is announced, because the button label replaces its contents");
   assert.match(ui.shell("zh", null, "read_failed"), /待办数量不可读/, "zh: the unknown marker is localized");
   assert.doesNotMatch(ui.shell("en", null, "ok"), /nav-badge/, "a readable inbox with nothing pending stays blank");
diff --git a/web/strategy-switch-console/frontend/package-lock.json b/web/strategy-switch-console/frontend/package-lock.json
index 6974b71e..410a733c 100644
--- a/web/strategy-switch-console/frontend/package-lock.json
+++ b/web/strategy-switch-console/frontend/package-lock.json
@@ -15,7 +15,7 @@
         "@types/react": "19.1.10",
         "@types/react-dom": "19.1.7",
         "typescript": "5.9.2",
-        "vite": "7.3.6"
+        "vite": "7.3.7"
       }
     },
     "node_modules/@esbuild/aix-ppc64": {
@@ -1161,9 +1161,9 @@
       }
     },
     "node_modules/vite": {
-      "version": "7.3.6",
-      "resolved": "https://registry.npmjs.org/vite/-/vite-7.3.6.tgz",
-      "integrity": "sha512-4XP60spRGjSZFf1qYH+dJIkK2znL3zQfl9KkOV9MkkRR/3Dls0dxaBsQPTloEc5BLXWPL9vsOxopxyKoMmDueg==",
+      "version": "7.3.7",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-7.3.7.tgz",
+      "integrity": "sha512-AHEzTORMbi7/7aXp7w7KZ5+DCUdSeLsJz0grY8xHpc9DHdYb0vQu6DqJfm2tOw3gDExNgPgnJTXxM6syYFHaCA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
diff --git a/web/strategy-switch-console/frontend/package.json b/web/strategy-switch-console/frontend/package.json
index eaa4ba39..03c27104 100644
--- a/web/strategy-switch-console/frontend/package.json
+++ b/web/strategy-switch-console/frontend/package.json
@@ -6,7 +6,7 @@
   "scripts": {
     "build": "tsc --noEmit && vite build && node scripts/check-budget.mjs",
     "sync:v2-assets": "node scripts/sync-v2-asset-map.mjs",
-    "test:operations": "node --experimental-strip-types ../../../tests/console_v2_operations_validation.mjs && node --experimental-strip-types ../../../tests/console_v2_regressions_validation.mjs && node --experimental-strip-types ../../../tests/console_v2_preferences_accounts_validation.mjs && node ../../../tests/console_runtime_control_result_ui_validation.mjs && node ../../../tests/console_page_load_boundary_validation.mjs && node --test ../../../tests/fe8b_fix03_ui_validation.mjs ../../../tests/console_notification_receipts_ui_validation.mjs && npm run test:performance && node --test ../../../tests/console_execution_evidence_validation.mjs && node ../../../tests/console_strategy_execution_validation.mjs && node --experimental-strip-types ../../../tests/console_binance_wallet_cards_validation.mjs && node ../../../tests/console_tabs_scope_sources_ui_validation.mjs && node ../../../tests/console_shell_unavailable_source_ui_validation.mjs",
+    "test:operations": "node --experimental-strip-types ../../../tests/console_v2_operations_validation.mjs && node --experimental-strip-types ../../../tests/console_v2_regressions_validation.mjs && node --experimental-strip-types ../../../tests/console_v2_preferences_accounts_validation.mjs && node ../../../tests/console_runtime_control_result_ui_validation.mjs && node ../../../tests/console_page_load_boundary_validation.mjs && node --test ../../../tests/fe8b_fix03_ui_validation.mjs ../../../tests/console_notification_receipts_ui_validation.mjs && npm run test:performance && node --test ../../../tests/console_execution_evidence_validation.mjs && node ../../../tests/console_strategy_execution_validation.mjs && node --experimental-strip-types ../../../tests/console_binance_wallet_cards_validation.mjs && node ../../../tests/console_tabs_scope_sources_ui_validation.mjs && node ../../../tests/console_shell_unavailable_source_ui_validation.mjs && node ../../../tests/console_cockpit_decision_validation.mjs && node ../../../tests/console_cockpit_readback_validation.mjs",
     "dev:synthetic": "node scripts/dev-synthetic.mjs",
     "test:performance": "node --experimental-strip-types ../../../tests/console_performance_math_validation.mjs && node --experimental-strip-types ../../../tests/console_performance_data_validation.mjs && node --experimental-strip-types ../../../tests/console_calendar_pending_ui_validation.mjs && node ../../../tests/website_currency_ranking_validation.mjs && node ../../../tests/website_summary_request_validation.mjs && node ../../../tests/console_compact_summary_validation.mjs && node ../../../tests/native_daily_gap_ui_validation.mjs"
   },
@@ -18,6 +18,6 @@
     "@types/react": "19.1.10",
     "@types/react-dom": "19.1.7",
     "typescript": "5.9.2",
-    "vite": "7.3.6"
+    "vite": "7.3.7"
   }
 }
diff --git a/web/strategy-switch-console/frontend/src/api/cockpit.ts b/web/strategy-switch-console/frontend/src/api/cockpit.ts
new file mode 100644
index 00000000..721ef466
--- /dev/null
+++ b/web/strategy-switch-console/frontend/src/api/cockpit.ts
@@ -0,0 +1,812 @@
+import { AccessError, HttpError, getJson, postJson } from "./client";
+import type { Category, InboxItem, InboxResponse, NotificationSendLog, StrategySummary } from "./contracts";
+
+/**
+ * Decision-cockpit contracts and adapters.
+ *
+ * The backend paths are proposed in ARCHITECTURE.md and may not be deployed
+ * yet. Every adapter distinguishes "the server said no" from "the endpoint is
+ * not available": a 404/501 becomes `not_ready`, never fabricated data. Only a
+ * session explicitly marked synthetic may render the labeled fixtures below.
+ */
+
+export type RiskTier = "CAPITAL_PRESERVATION" | "BALANCED_COMPOUNDING" | "GROWTH_COMPOUNDING";
+export type ProductStage = "research" | "paper" | "small_live" | "full_live";
+export type StageAxis = ProductStage | "unclassified";
+export type DecisionState = "pending" | "approved" | "rejected" | "expired" | "superseded" | "withdrawn";
+export type DecisionAction = "approve" | "reject" | "withdraw";
+export type EvidenceState = "current" | "stale" | "missing" | "expired" | "unavailable";
+export type Qualification = "qualified" | "unqualified" | "unknown";
+export type OperatingState = "running" | "paused" | "reduction_only" | "reconcile_only" | "unknown";
+export type ApplicationState = "pending" | "applying" | "applied" | "rejected" | "failed" | "unknown";
+
+export interface EvidenceSummary {
+  evidence_id: string | null;
+  label_key: string | null;
+  observed_at: string | null;
+  valid_until: string | null;
+  state: EvidenceState;
+  qualification: Qualification;
+  limitations: string[];
+}
+
+export interface PolicyValue {
+  key: string;
+  label_key: string | null;
+  value: number | string | null;
+  unit: string | null;
+  status: "known" | "unknown" | "unavailable";
+  source: string | null;
+}
+
+export interface PolicyBinding {
+  scope: string;
+  selected_tier: RiskTier | null;
+  selection_revision: number | null;
+  approved_tier: RiskTier | null;
+  approved_policy_id: string | null;
+  approved_policy_revision: string | null;
+  effective_tier: RiskTier | null;
+  effective_policy_id: string | null;
+  effective_policy_revision: string | null;
+  effective_observed_at: string | null;
+  temporary_restriction: { active: boolean; reason: string | null; until: string | null } | null;
+  values: PolicyValue[];
+}
+
+export interface DecisionDetail {
+  decision_id: string;
+  short_id: string;
+  category: Category;
+  revision: number;
+  state: DecisionState;
+  title_key: string;
+  account_alias: string | null;
+  platform: string | null;
+  release_id: string | null;
+  target_id: string | null;
+  from_stage: ProductStage | null;
+  to_stage: ProductStage | null;
+  evidence: EvidenceSummary | null;
+  policy: {
+    selected_tier: RiskTier | null;
+    policy_id: string | null;
+    policy_revision: string | null;
+    summary: string | null;
+    values: PolicyValue[];
+  } | null;
+  created_at: string | null;
+  expires_at: string | null;
+  server_time: string | null;
+  allowed_actions: DecisionAction[];
+  blocking_reasons: string[];
+  operation_id: string | null;
+  receipt: { recorded_at: string | null; revision: number | null } | null;
+}
+
+export interface OperationRecord {
+  operation_id: string;
+  request_id: string;
+  decision_id: string | null;
+  decision_revision: number | null;
+  action: DecisionAction | null;
+  title_key: string | null;
+  account_alias: string | null;
+  platform: string | null;
+  release_id: string | null;
+  target_id: string | null;
+  state: ApplicationState;
+  recorded_at: string | null;
+  dispatched_at: string | null;
+  applied_at: string | null;
+  applied_by: "platform" | null;
+  runtime_confirmed_at: string | null;
+  runtime_state: OperatingState;
+  failure_reason: string | null;
+  unknown_reason: string | null;
+  readback_available: boolean | null;
+  server_time: string | null;
+}
+
+export interface LifecycleBinding {
+  profile: string;
+  account_alias: string | null;
+  platform: string | null;
+  target_id: string | null;
+  release_id: string | null;
+  /** False when the payload carried no lifecycle record; axes are then not inferred. */
+  present: boolean;
+  research_stage: StageAxis;
+  authorized_stage: StageAxis;
+  effective_stage: StageAxis;
+  operating_state: OperatingState;
+  application_state: ApplicationState;
+  observed_at: string | null;
+  evidence: EvidenceSummary | null;
+  regime_effect: string | null;
+}
+
+export interface DigestTargetCount {
+  label: string;
+  known: boolean;
+}
+
+export interface DigestStatus {
+  business_day: string | null;
+  timezone: string | null;
+  expected_targets: number | null;
+  covered_targets: number | null;
+  unavailable_targets: number | null;
+  delivery_state: "accepted" | "delivered" | "failed" | "unknown" | "unavailable";
+  accepted_at: string | null;
+  acknowledged_at: string | null;
+  source_as_of: string | null;
+  legacy_receipts: boolean;
+  targets: DigestTargetCount[];
+}
+
+export interface AuditEvent {
+  event_id: string;
+  occurred_at: string;
+  actor: string | null;
+  action: string;
+  subject: string | null;
+  revision: string | number | null;
+  decision_id: string | null;
+  operation_id: string | null;
+  outcome: string | null;
+}
+
+export interface AuditPage {
+  events: AuditEvent[];
+  next_cursor: string | null;
+  coverage: string;
+}
+
+export interface RuntimeReadback {
+  scope: string;
+  data_status: "ready" | "stale" | "unavailable";
+  observed_at: string | null;
+  runtime_enabled: boolean | null;
+  scheduler_state: "enabled" | "paused" | "mixed" | "missing" | "unknown" | "not_applicable";
+  strategy_profile: string | null;
+}
+
+export type CockpitRead<T> =
+  | { status: "ready"; data: T; synthetic: boolean }
+  | { status: "not_ready" };
+
+export class MutationOutcomeUnknown extends Error {
+  readonly requestId: string;
+  readonly operationId: string | null;
+  constructor(requestId: string, operationId: string | null) {
+    super("mutation_outcome_unknown");
+    this.requestId = requestId;
+    this.operationId = operationId;
+  }
+}
+
+export interface DecisionActionRequest {
+  decision_id: string;
+  action: DecisionAction;
+  expected_revision: number;
+  request_id: string;
+  /** The exact server-bound policy the confirmation displayed, never a client choice. */
+  selected_tier: RiskTier | null;
+  policy_revision: string | null;
+  note?: string;
+}
+
+export interface DecisionActionResponse {
+  operation: OperationRecord | null;
+  state: DecisionState | null;
+  revision: number | null;
+}
+
+export function isRiskTier(value: unknown): value is RiskTier {
+  return value === "CAPITAL_PRESERVATION" || value === "BALANCED_COMPOUNDING" || value === "GROWTH_COMPOUNDING";
+}
+
+export function isProductStage(value: unknown): value is ProductStage {
+  return value === "research" || value === "paper" || value === "small_live" || value === "full_live";
+}
+
+export function asStage(value: unknown): StageAxis {
+  return isProductStage(value) ? value : "unclassified";
+}
+
+export function asDecisionAction(value: unknown): DecisionAction | null {
+  return value === "approve" || value === "reject" || value === "withdraw" ? value : null;
+}
+
+export function newRequestId(): string {
+  const cryptoApi = globalThis.crypto;
+  if (cryptoApi?.randomUUID) return cryptoApi.randomUUID();
+  return `req-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+}
+
+/**
+ * Approval stays unavailable until the server says the action is allowed, the
+ * displayed revision is current, and the evidence is current and qualified.
+ * This is a presentation check only; the server remains authoritative.
+ */
+export function actionBlockers(
+  decision: Pick<DecisionDetail, "state" | "allowed_actions" | "expires_at" | "evidence" | "revision" | "policy">,
+  view: { serverTime: string | null; receivedAt: string; now: number },
+): string[] {
+  const blockers: string[] = [];
+  const expiry = expiryState(decision.expires_at, view.serverTime, view.receivedAt, view.now);
+  if (decision.state !== "pending") blockers.push(`state_${decision.state}`);
+  if (expiry.state === "expired") blockers.push("decision_expired");
+  if (expiry.state === "unknown" && decision.expires_at) blockers.push("expiry_unverified");
+  if (!decision.allowed_actions.includes("approve")) blockers.push("approval_not_allowed");
+  if (!decision.evidence) blockers.push("evidence_missing");
+  else if (decision.evidence.state !== "current") blockers.push(`evidence_${decision.evidence.state}`);
+  else if (decision.evidence.qualification !== "qualified") blockers.push("evidence_unqualified");
+  if (!decision.policy) blockers.push("policy_unavailable");
+  else if (!decision.policy.selected_tier || !decision.policy.policy_revision) blockers.push("policy_binding_missing");
+  if (!Number.isSafeInteger(decision.revision) || decision.revision < 0) blockers.push("revision_invalid");
+  return blockers;
+}
+
+export type ExpiryState =
+  | { state: "none" }
+  | { state: "unknown"; expiresAt: string }
+  | { state: "expired"; expiresAt: string; serverNow: number }
+  | { state: "open"; expiresAt: string; remainingMs: number };
+
+/**
+ * Expiry is evaluated against the server clock plus only the elapsed time
+ * since the bundle was received. A wrong local clock can make the warning
+ * later, never earlier; it can never extend the server-enforced window.
+ */
+export function expiryState(
+  expiresAt: string | null,
+  serverTime: string | null,
+  receivedAt: string,
+  now: number,
+): ExpiryState {
+  if (!expiresAt) return { state: "none" };
+  const expiry = Date.parse(expiresAt);
+  const server = serverTime ? Date.parse(serverTime) : Number.NaN;
+  const received = Date.parse(receivedAt);
+  if (!Number.isFinite(expiry) || !Number.isFinite(server) || !Number.isFinite(received)) {
+    return { state: "unknown", expiresAt };
+  }
+  const serverNow = server + Math.max(0, now - received);
+  if (serverNow >= expiry) return { state: "expired", expiresAt, serverNow };
+  return { state: "open", expiresAt, remainingMs: expiry - serverNow };
+}
+
+function notReady(error: unknown): boolean {
+  return error instanceof HttpError && (error.status === 404 || error.status === 501);
+}
+
+function asRecord(value: unknown): Record<string, unknown> | null {
+  return value !== null && typeof value === "object" ? value as Record<string, unknown> : null;
+}
+
+function asString(value: unknown): string | null {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+
+function asNumber(value: unknown): number | null {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+
+function asBoolean(value: unknown): boolean | null {
+  return typeof value === "boolean" ? value : null;
+}
+
+function normalizeEvidence(value: unknown): EvidenceSummary | null {
+  const raw = asRecord(value);
+  if (!raw) return null;
+  const state = raw.state === "current" || raw.state === "stale" || raw.state === "missing"
+    || raw.state === "expired" || raw.state === "unavailable" ? raw.state : "unavailable";
+  const qualification = raw.qualification === "qualified" || raw.qualification === "unqualified"
+    ? raw.qualification : "unknown";
+  const limitations = Array.isArray(raw.limitations)
+    ? raw.limitations.filter((item): item is string => typeof item === "string") : [];
+  return {
+    evidence_id: asString(raw.evidence_id),
+    label_key: asString(raw.label_key),
+    observed_at: asString(raw.observed_at),
+    valid_until: asString(raw.valid_until),
+    state,
+    qualification,
+    limitations,
+  };
+}
+
+function normalizeValues(value: unknown): PolicyValue[] {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((item): PolicyValue[] => {
+    const raw = asRecord(item);
+    if (!raw || typeof raw.key !== "string") return [];
+    const status = raw.status === "known" || raw.status === "unknown" || raw.status === "unavailable" ? raw.status : "unknown";
+    return [{
+      key: raw.key,
+      label_key: asString(raw.label_key),
+      value: typeof raw.value === "number" || typeof raw.value === "string" ? raw.value : null,
+      unit: asString(raw.unit),
+      status,
+      source: asString(raw.source),
+    }];
+  });
+}
+
+function normalizeOperation(value: unknown): OperationRecord | null {
+  const raw = asRecord(value);
+  if (!raw) return null;
+  const applicationStates: ApplicationState[] = ["pending", "applying", "applied", "rejected", "failed", "unknown"];
+  const operatingStates: OperatingState[] = ["running", "paused", "reduction_only", "reconcile_only", "unknown"];
+  const state = applicationStates.includes(raw.state as ApplicationState) ? raw.state as ApplicationState : "unknown";
+  const runtimeState = operatingStates.includes(raw.runtime_state as OperatingState) ? raw.runtime_state as OperatingState : "unknown";
+  return {
+    operation_id: asString(raw.operation_id) ?? "",
+    request_id: asString(raw.request_id) ?? "",
+    decision_id: asString(raw.decision_id),
+    decision_revision: asNumber(raw.decision_revision),
+    action: asDecisionAction(raw.action),
+    title_key: asString(raw.title_key),
+    account_alias: asString(raw.account_alias),
+    platform: asString(raw.platform),
+    release_id: asString(raw.release_id),
+    target_id: asString(raw.target_id),
+    state,
+    recorded_at: asString(raw.recorded_at),
+    dispatched_at: asString(raw.dispatched_at),
+    applied_at: asString(raw.applied_at),
+    applied_by: raw.applied_by === "platform" ? "platform" : null,
+    runtime_confirmed_at: asString(raw.runtime_confirmed_at),
+    runtime_state: runtimeState,
+    failure_reason: asString(raw.failure_reason),
+    unknown_reason: asString(raw.unknown_reason),
+    readback_available: asBoolean(raw.readback_available),
+    server_time: asString(raw.server_time),
+  };
+}
+
+function normalizeDecision(value: unknown, fallback: { id: string; shortId: string; category: Category; titleKey: string }): DecisionDetail {
+  const raw = asRecord(value) ?? {};
+  const states: DecisionState[] = ["pending", "approved", "rejected", "expired", "superseded", "withdrawn"];
+  const state = states.includes(raw.state as DecisionState) ? raw.state as DecisionState : "pending";
+  const allowed = Array.isArray(raw.allowed_actions)
+    ? raw.allowed_actions.map(asDecisionAction).filter((item): item is DecisionAction => item !== null)
+    : [];
+  const policy = asRecord(raw.policy);
+  const receipt = asRecord(raw.receipt);
+  const expiry = raw.expires_at === null || typeof raw.expires_at === "string" ? raw.expires_at : null;
+  return {
+    decision_id: asString(raw.decision_id) ?? fallback.id,
+    short_id: asString(raw.short_id) ?? fallback.shortId,
+    category: (typeof raw.category === "string" ? raw.category : fallback.category) as Category,
+    revision: asNumber(raw.revision) ?? -1,
+    state,
+    title_key: asString(raw.title_key) ?? fallback.titleKey,
+    account_alias: asString(raw.account_alias),
+    platform: asString(raw.platform),
+    release_id: asString(raw.release_id),
+    target_id: asString(raw.target_id),
+    from_stage: isProductStage(raw.from_stage) ? raw.from_stage : null,
+    to_stage: isProductStage(raw.to_stage) ? raw.to_stage : null,
+    evidence: normalizeEvidence(raw.evidence),
+    policy: policy ? {
+      selected_tier: isRiskTier(policy.selected_tier) ? policy.selected_tier : null,
+      policy_id: asString(policy.policy_id),
+      policy_revision: asString(policy.policy_revision),
+      summary: asString(policy.summary),
+      values: normalizeValues(policy.values),
+    } : null,
+    created_at: asString(raw.created_at),
+    expires_at: expiry,
+    server_time: asString(raw.server_time),
+    allowed_actions: allowed,
+    blocking_reasons: Array.isArray(raw.blocking_reasons)
+      ? raw.blocking_reasons.filter((item): item is string => typeof item === "string") : [],
+    operation_id: asString(raw.operation_id),
+    receipt: receipt ? { recorded_at: asString(receipt.recorded_at), revision: asNumber(receipt.revision) } : null,
+  };
+}
+
+type ExpandedInboxItem = InboxItem & {
+  revision?: unknown;
+  allowed_actions?: unknown;
+  from_stage?: unknown;
+  to_stage?: unknown;
+  risk_impact?: unknown;
+  evidence?: unknown;
+  operation_id?: unknown;
+  application_state?: unknown;
+};
+
+/** One authoritative bundle per decision. Synthetic data is produced only for a labeled synthetic session. */
+export async function loadDecisionDetail(
+  decisionId: string,
+  options: { synthetic?: boolean; inbox?: InboxResponse | null } = {},
+): Promise<CockpitRead<DecisionDetail>> {
+  if (options.synthetic) {
+    const fromInbox = options.inbox?.items.find(item => item.id === decisionId) as ExpandedInboxItem | undefined;
+    return { status: "ready", synthetic: true, data: syntheticDecision(fromInbox) };
+  }
+  try {
+    const payload = await getJson<unknown>(`/api/decisions/${encodeURIComponent(decisionId)}`);
+    const item = options.inbox?.items.find(entry => entry.id === decisionId);
+    return {
+      status: "ready",
+      synthetic: false,
+      data: normalizeDecision(payload, {
+        id: decisionId,
+        shortId: item?.short_id ?? decisionId,
+        category: item?.category ?? "owner_decision",
+        titleKey: item?.title_key ?? "decision.unknown",
+      }),
+    };
+  } catch (error) {
+    if (notReady(error)) return { status: "not_ready" };
+    throw error;
+  }
+}
+
+/**
+ * Submit an owner action bound to the displayed revision and a stable request
+ * identity. A timeout or transport failure is an unknown outcome, not a
+ * failure: the caller keeps the identity and reconciles, never resubmits.
+ */
+export async function submitDecisionAction(request: DecisionActionRequest): Promise<DecisionActionResponse> {
+  try {
+    const payload = await postJson<unknown>(`/api/decisions/${encodeURIComponent(request.decision_id)}/actions`, {
+      action: request.action,
+      expected_revision: request.expected_revision,
+      request_id: request.request_id,
+      selected_tier: request.selected_tier,
+      policy_revision: request.policy_revision,
+      ...(request.note ? { note: request.note } : {}),
+    });
+    const raw = asRecord(payload) ?? {};
+    const states: DecisionState[] = ["pending", "approved", "rejected", "expired", "superseded", "withdrawn"];
+    return {
+      operation: normalizeOperation(raw.operation),
+      state: states.includes(raw.state as DecisionState) ? raw.state as DecisionState : null,
+      revision: asNumber(raw.revision),
+    };
+  } catch (error) {
+    if (error instanceof AccessError || error instanceof HttpError) throw error;
+    throw new MutationOutcomeUnknown(request.request_id, null);
+  }
+}
+
+export async function loadOperation(operationId: string, synthetic = false): Promise<CockpitRead<OperationRecord>> {
+  if (synthetic) return { status: "ready", synthetic: true, data: syntheticOperation(operationId) };
+  try {
+    const payload = await getJson<unknown>(`/api/operations/${encodeURIComponent(operationId)}`);
+    const operation = normalizeOperation(payload);
+    return operation ? { status: "ready", data: operation, synthetic: false } : { status: "not_ready" };
+  } catch (error) {
+    if (notReady(error)) return { status: "not_ready" };
+    throw error;
+  }
+}
+
+function normalizeBinding(raw: Record<string, unknown>, scope: string): PolicyBinding {
+  const restriction = asRecord(raw.temporary_restriction);
+  return {
+    scope,
+    selected_tier: isRiskTier(raw.selected_tier) ? raw.selected_tier : null,
+    selection_revision: asNumber(raw.selection_revision),
+    approved_tier: isRiskTier(raw.approved_tier) ? raw.approved_tier : null,
+    approved_policy_id: asString(raw.approved_policy_id),
+    approved_policy_revision: asString(raw.approved_policy_revision),
+    effective_tier: isRiskTier(raw.effective_tier) ? raw.effective_tier : null,
+    effective_policy_id: asString(raw.effective_policy_id),
+    effective_policy_revision: asString(raw.effective_policy_revision),
+    effective_observed_at: asString(raw.effective_observed_at),
+    temporary_restriction: restriction ? {
+      active: restriction.active === true,
+      reason: asString(restriction.reason),
+      until: asString(restriction.until),
+    } : null,
+    values: normalizeValues(raw.values ?? raw.limits),
+  };
+}
+
+/** Selected, approved and effective policy stay separate; missing parts stay null. */
+export async function loadPolicyBinding(scope: string, synthetic = false): Promise<CockpitRead<PolicyBinding>> {
+  if (synthetic) return { status: "ready", synthetic: true, data: syntheticBinding(scope) };
+  try {
+    const params = new URLSearchParams({ scope });
+    const payload = await getJson<unknown>(`/api/risk-profiles?${params}`);
+    const raw = asRecord(payload);
+    const binding = asRecord(raw?.binding) ?? asRecord(raw?.policy_binding);
+    if (!binding) return { status: "not_ready" };
+    return { status: "ready", data: normalizeBinding(binding, scope), synthetic: false };
+  } catch (error) {
+    if (notReady(error)) return { status: "not_ready" };
+    throw error;
+  }
+}
+
+/** Per-release lifecycle axes; absent axes stay unclassified rather than inferred. */
+export async function loadLifecycles(summary: StrategySummary, synthetic = false): Promise<CockpitRead<LifecycleBinding[]>> {
+  if (synthetic) return { status: "ready", synthetic: true, data: syntheticLifecycles() };
+  const lifecycles: LifecycleBinding[] = [];
+  for (const strategy of summary.strategies) {
+    const raw = asRecord((strategy as unknown as Record<string, unknown>).lifecycle);
+    for (const account of strategy.configured_accounts) {
+      const perTarget = asRecord((account as unknown as Record<string, unknown>).lifecycle) ?? raw;
+      lifecycles.push({
+        profile: strategy.profile,
+        account_alias: account.account_alias,
+        platform: account.platform,
+        target_id: asString(perTarget?.target_id),
+        release_id: asString(perTarget?.release_id),
+        present: Boolean(perTarget),
+        research_stage: asStage(perTarget?.research_stage),
+        authorized_stage: asStage(perTarget?.authorized_stage),
+        effective_stage: asStage(perTarget?.effective_stage),
+        operating_state: ["running", "paused", "reduction_only", "reconcile_only", "unknown"]
+          .includes(perTarget?.operating_state as string) ? perTarget?.operating_state as OperatingState : "unknown",
+        application_state: ["pending", "applying", "applied", "rejected", "failed", "unknown"]
+          .includes(perTarget?.application_state as string) ? perTarget?.application_state as ApplicationState : "unknown",
+        observed_at: asString(perTarget?.observed_at),
+        evidence: normalizeEvidence(perTarget?.evidence),
+        regime_effect: asString(perTarget?.regime_effect),
+      });
+    }
+  }
+  return { status: "ready", data: lifecycles, synthetic: false };
+}
+
+/** Production digest projection; legacy GitHub Actions receipts are labeled, not merged. */
+export async function loadDigestStatus(log: NotificationSendLog, synthetic = false): Promise<CockpitRead<DigestStatus>> {
+  if (synthetic) return { status: "ready", synthetic: true, data: syntheticDigest() };
+  const raw = asRecord((log as unknown as Record<string, unknown>).digest);
+  if (!raw) {
+    return {
+      status: "ready",
+      synthetic: false,
+      data: {
+        business_day: null,
+        timezone: null,
+        expected_targets: null,
+        covered_targets: null,
+        unavailable_targets: null,
+        delivery_state: "unavailable",
+        accepted_at: null,
+        acknowledged_at: null,
+        source_as_of: log.as_of,
+        legacy_receipts: true,
+        targets: [],
+      },
+    };
+  }
+  const state = raw.delivery_state;
+  const delivery = state === "accepted" || state === "delivered" || state === "failed" || state === "unknown"
+    ? state : "unavailable";
+  return {
+    status: "ready",
+    synthetic: false,
+    data: {
+      business_day: asString(raw.business_day),
+      timezone: asString(raw.timezone),
+      expected_targets: asNumber(raw.expected_targets),
+      covered_targets: asNumber(raw.covered_targets),
+      unavailable_targets: asNumber(raw.unavailable_targets),
+      delivery_state: delivery,
+      accepted_at: asString(raw.accepted_at),
+      acknowledged_at: asString(raw.acknowledged_at),
+      source_as_of: asString(raw.source_as_of),
+      legacy_receipts: false,
+      targets: [],
+    },
+  };
+}
+
+export async function loadAuditEvents(cursor: string | null = null, synthetic = false): Promise<CockpitRead<AuditPage>> {
+  if (synthetic) return { status: "ready", synthetic: true, data: { events: syntheticAudit(), next_cursor: null, coverage: "synthetic" } };
+  try {
+    const params = new URLSearchParams({ limit: "25" });
+    if (cursor !== null) params.set("cursor", cursor);
+    const raw = asRecord(await getJson<unknown>(`/api/audit-events?${params}`));
+    if (raw?.schema_version !== "qsl.audit_events.v1" || raw.data_status !== "ready" || !Array.isArray(raw.events)
+      || !Array.isArray(raw.errors) || raw.errors.length || !asString(raw.coverage)
+      || !(raw.next_cursor === null || typeof raw.next_cursor === "string" && /^[A-Za-z0-9_-]{1,2048}$/.test(raw.next_cursor))
+      || raw.next_cursor !== null && (raw.events.length === 0 || raw.next_cursor === cursor)) throw Error("invalid_audit_page");
+    const events = raw.events.map((item): AuditEvent => {
+      const event = asRecord(item);
+      const subject = asRecord(event?.subject);
+      if (!event || !asString(event.id) || !asString(event.occurred_at) || !Number.isFinite(Date.parse(event.occurred_at as string))
+        || !asString(event.action) || !(event.actor_alias === null || typeof event.actor_alias === "string")
+        || !(event.revision === null || typeof event.revision === "string")
+        || !(event.outcome === null || typeof event.outcome === "string")
+        || !(event.subject === null || subject && asString(subject.kind) && asString(subject.id))) throw Error("invalid_audit_event");
+      return {
+        event_id: event.id as string,
+        occurred_at: event.occurred_at as string,
+        actor: asString(event.actor_alias),
+        action: event.action as string,
+        subject: subject ? `${subject.kind}: ${subject.id}` : null,
+        revision: asString(event.revision),
+        decision_id: null,
+        operation_id: null,
+        outcome: asString(event.outcome),
+      };
+    });
+    if (new Set(events.map(event => event.event_id)).size !== events.length) throw Error("duplicate_audit_event");
+    return { status: "ready", data: { events, next_cursor: raw.next_cursor as string | null, coverage: raw.coverage as string }, synthetic: false };
+  } catch (error) {
+    if (notReady(error)) return { status: "not_ready" };
+    throw error;
+  }
+}
+
+/** A readback cannot infer effective state from configuration or an approval. */
+export async function loadRuntimeReadback(scope: string): Promise<CockpitRead<RuntimeReadback>> {
+  try {
+    const raw = asRecord(await getJson<unknown>(`/api/runtime/readback?${new URLSearchParams({ scope })}`));
+    const policy = asRecord(raw?.policy);
+    const states = ["enabled", "paused", "mixed", "missing", "unknown", "not_applicable"];
+    if (raw?.schema_version !== "qsl.runtime_readback.v1" || raw.scope !== scope
+      || !["ready", "stale", "unavailable"].includes(raw.data_status as string)
+      || policy?.read_only !== true || policy.no_order !== true || policy.execution_authority_granted !== false
+      || typeof raw.server_time !== "string" || !Number.isFinite(Date.parse(raw.server_time))
+      || raw.source !== "stored_runtime_target_lifecycle"
+      || !(raw.observed_at === null || typeof raw.observed_at === "string" && Number.isFinite(Date.parse(raw.observed_at)))
+      || !(raw.runtime_enabled === null || typeof raw.runtime_enabled === "boolean")
+      || !states.includes(raw.scheduler_state as string)
+      || !(raw.strategy_profile === null || typeof raw.strategy_profile === "string")
+      || raw.data_status === "ready" && (raw.observed_at === null || raw.runtime_enabled === null || Date.parse(raw.observed_at as string) > Date.parse(raw.server_time as string))
+      || raw.data_status !== "ready" && (raw.runtime_enabled !== null || raw.scheduler_state !== "unknown" || raw.strategy_profile !== null)) {
+      throw Error("invalid_runtime_readback");
+    }
+    return { status: "ready", synthetic: false, data: {
+      scope, data_status: raw.data_status as RuntimeReadback["data_status"],
+      observed_at: asString(raw.observed_at), runtime_enabled: raw.runtime_enabled as boolean | null,
+      scheduler_state: raw.scheduler_state as RuntimeReadback["scheduler_state"], strategy_profile: asString(raw.strategy_profile),
+    } };
+  } catch (error) {
+    if (notReady(error)) return { status: "not_ready" };
+    throw error;
+  }
+}
+
+/* ---------- synthetic fixtures: fictional, labeled, never production ---------- */
+
+function syntheticDecision(item?: ExpandedInboxItem): DecisionDetail {
+  const id = item?.id ?? "synthetic-decision-001";
+  return normalizeDecision({
+    decision_id: id,
+    short_id: item?.short_id ?? "S-DEMO-1",
+    category: item?.category ?? "strategy_promotion",
+    revision: 3,
+    state: "pending",
+    title_key: "decision.promotion_title",
+    account_alias: "demo_account",
+    platform: "ibkr",
+    release_id: "demo-release-2026.10",
+    target_id: "demo-target",
+    from_stage: "paper",
+    to_stage: "small_live",
+    evidence: {
+      evidence_id: "synthetic-evidence",
+      observed_at: "2026-10-31T13:00:00Z",
+      valid_until: "2026-11-02T13:00:00Z",
+      state: "current",
+      qualification: "qualified",
+      limitations: [],
+    },
+    policy: {
+      selected_tier: "BALANCED_COMPOUNDING",
+      policy_id: "synthetic-policy",
+      policy_revision: "r7",
+      summary: null,
+      values: [
+        { key: "max_gross_exposure", value: 45, unit: "percent", status: "known", source: "server" },
+        { key: "cash_floor", value: 20, unit: "percent", status: "known", source: "server" },
+      ],
+    },
+    created_at: "2026-11-01T09:00:00Z",
+    expires_at: "2026-11-02T09:00:00Z",
+    server_time: new Date().toISOString(),
+    allowed_actions: ["approve", "reject"],
+    blocking_reasons: [],
+    operation_id: null,
+    receipt: null,
+  }, { id, shortId: item?.short_id ?? "S-DEMO-1", category: item?.category ?? "strategy_promotion", titleKey: "decision.promotion_title" });
+}
+
+function syntheticOperation(id: string): OperationRecord {
+  return {
+    operation_id: id,
+    request_id: "synthetic-request",
+    decision_id: "synthetic-decision-001",
+    decision_revision: 3,
+    action: "approve",
+    title_key: "decision.promotion_title",
+    account_alias: "demo_account",
+    platform: "ibkr",
+    release_id: "demo-release-2026.10",
+    target_id: "demo-target",
+    state: "applying",
+    recorded_at: "2026-11-01T10:00:00Z",
+    dispatched_at: "2026-11-01T10:00:05Z",
+    applied_at: null,
+    applied_by: null,
+    runtime_confirmed_at: null,
+    runtime_state: "unknown",
+    failure_reason: null,
+    unknown_reason: null,
+    readback_available: null,
+    server_time: new Date().toISOString(),
+  };
+}
+
+function syntheticBinding(scope: string): PolicyBinding {
+  return {
+    scope,
+    selected_tier: "BALANCED_COMPOUNDING",
+    selection_revision: 2,
+    approved_tier: "BALANCED_COMPOUNDING",
+    approved_policy_id: "synthetic-policy",
+    approved_policy_revision: "r7",
+    effective_tier: "BALANCED_COMPOUNDING",
+    effective_policy_id: "synthetic-policy",
+    effective_policy_revision: "r7",
+    effective_observed_at: "2026-11-01T09:30:00Z",
+    temporary_restriction: null,
+    values: [
+      { key: "max_gross_exposure", label_key: null, value: 45, unit: "percent", status: "known", source: "server" },
+      { key: "cash_floor", label_key: null, value: 20, unit: "percent", status: "known", source: "server" },
+    ],
+  };
+}
+
+function syntheticLifecycles(): LifecycleBinding[] {
+  return [{
+    profile: "demo_trend",
+    account_alias: "demo_account",
+    platform: "ibkr",
+    target_id: "demo-target",
+    release_id: "demo-release-2026.10",
+    present: true,
+    research_stage: "paper",
+    authorized_stage: "paper",
+    effective_stage: "paper",
+    operating_state: "running",
+    application_state: "applied",
+    observed_at: "2026-11-01T09:30:00Z",
+    evidence: {
+      evidence_id: "synthetic-evidence",
+      label_key: null,
+      observed_at: "2026-10-31T13:00:00Z",
+      valid_until: "2026-11-02T13:00:00Z",
+      state: "current",
+      qualification: "qualified",
+      limitations: [],
+    },
+    regime_effect: "risk_reduction_only",
+  }];
+}
+
+function syntheticDigest(): DigestStatus {
+  return {
+    business_day: "2026-11-01",
+    timezone: "America/New_York",
+    expected_targets: 4,
+    covered_targets: 3,
+    unavailable_targets: 1,
+    delivery_state: "accepted",
+    accepted_at: "2026-11-01T13:05:00Z",
+    acknowledged_at: null,
+    source_as_of: "2026-11-01T13:00:00Z",
+    legacy_receipts: false,
+    targets: [],
+  };
+}
+
+function syntheticAudit(): AuditEvent[] {
+  return [
+    { event_id: "synthetic-event-1", occurred_at: "2026-11-01T10:00:00Z", actor: "owner", action: "approval_recorded", subject: "synthetic-decision-001", revision: 3, decision_id: "synthetic-decision-001", operation_id: "synthetic-operation-1", outcome: "recorded" },
+    { event_id: "synthetic-event-2", occurred_at: "2026-11-01T10:00:05Z", actor: "platform", action: "application_dispatched", subject: "demo-target", revision: 3, decision_id: "synthetic-decision-001", operation_id: "synthetic-operation-1", outcome: "applying" },
+  ];
+}
diff --git a/web/strategy-switch-console/frontend/src/app/AppShell.tsx b/web/strategy-switch-console/frontend/src/app/AppShell.tsx
index 0a0ad8ee..9cc4ee11 100644
--- a/web/strategy-switch-console/frontend/src/app/AppShell.tsx
+++ b/web/strategy-switch-console/frontend/src/app/AppShell.tsx
@@ -1,6 +1,6 @@
 import { useEffect, useRef, useState } from "react";
 import type { ReactNode } from "react";
-import { useNavigate, usePrefs, useScope } from "../app/context";
+import { useNavigate, usePrefs } from "../app/context";
 import { UpdateNotice } from "./UpdateNotice";
 import { useLanguage, useT } from "../i18n";
 import { formatDateTime } from "../lib/format";
@@ -10,15 +10,17 @@ import type { PageId } from "./router";
 
 const NAV_ITEMS: { id: PageId; labelKey: string; icon: string }[] = [
   { id: "overview", labelKey: "nav.overview", icon: "M3 12 L12 4 L21 12 M6 10 V20 H18 V10" },
-  { id: "performance", labelKey: "nav.performance", icon: "M4 18 L10 10 L14 13 L20 5" },
   { id: "decisions", labelKey: "nav.decisions", icon: "M4 6 H20 M4 12 H20 M4 18 H14" },
-  { id: "accounts", labelKey: "nav.accounts", icon: "M12 12 m-4 0 a4 4 0 1 0 8 0 a4 4 0 1 0 -8 0 M4 20 c0-4 4-6 8-6 s8 2 8 6" },
   { id: "strategies", labelKey: "nav.strategies", icon: "M5 5 H19 V19 H5 Z M5 10 H19 M10 10 V19" },
+  { id: "accounts", labelKey: "nav.accounts", icon: "M12 12 m-4 0 a4 4 0 1 0 8 0 a4 4 0 1 0 -8 0 M4 20 c0-4 4-6 8-6 s8 2 8 6" },
+  { id: "performance", labelKey: "nav.performance", icon: "M4 18 L10 10 L14 13 L20 5" },
   { id: "health", labelKey: "nav.health", icon: "M3 12 H7 L10 5 L14 19 L17 12 H21" },
 ];
 
-const MOBILE_PRIMARY: PageId[] = ["overview", "performance", "decisions", "accounts"];
-const MOBILE_MORE: PageId[] = ["strategies", "health"];
+// Mobile navigation is deliberate: the queue and the cockpit are the two
+// destinations that need one tap; everything else lives behind More.
+const MOBILE_PRIMARY: PageId[] = ["overview", "decisions"];
+const MOBILE_MORE: PageId[] = ["strategies", "accounts", "performance", "health"];
 
 function NavIcon({ path }: { path: string }) {
   return (
@@ -52,8 +54,6 @@ export function AppShell({
   const navigate = useNavigate();
   const { prefs, setPrefs, resolvedTheme } = usePrefs();
   const dark = resolvedTheme === "dark";
-  useScope();
-  const [collapsed, setCollapsed] = useState(false);
   const [moreOpen, setMoreOpen] = useState(false);
   const [prefsOpen, setPrefsOpen] = useState(false);
   const userMenuRef = useRef<HTMLDetailsElement>(null);
@@ -105,7 +105,7 @@ export function AppShell({
       onClick={() => navigate({ page: item.id, account: null, tab: null })}
     >
       <NavIcon path={item.icon} />
-      <span className="nav-text">{t(item.labelKey)}</span>
+      <span className={extraClass === "topnav-item" ? "topnav-label" : "nav-text"}>{t(item.labelKey)}</span>
       {item.id === "decisions" && (badge || (todoUnknown && <span className="nav-badge nav-badge-unknown" aria-hidden="true">?</span>))}
     </button>
   );
@@ -113,21 +113,21 @@ export function AppShell({
   return (
     <div className="shell">
       <a className="skip-link" href="#main-content">{t("shell.skip_to_content")}</a>
-      <nav className={`sidenav${collapsed ? " collapsed" : ""}`} aria-label={t("nav.main")}>
-        <div className="brand">
-          <img src="/v2/assets/qsl-brand-icon.svg" alt="" width={28} height={28} />
-          <span className="brand-name">{t("app.name")}</span>
-        </div>
-        {NAV_ITEMS.map(item => navButton(item, "nav-item"))}
-        <button type="button" className="sidenav-collapse" onClick={() => setCollapsed(value => !value)} aria-label={t(collapsed ? "common.expand" : "common.collapse")}>
-          {collapsed ? "»" : "«"}
-        </button>
-      </nav>
       <div className="shell-main">
         <header className="topbar">
+          <button type="button" className="brand" aria-label={t("app.name")} onClick={() => navigate({ page: "overview", account: null, tab: null })}>
+            <img src="/v2/assets/qsl-brand-icon.svg" alt="" width={28} height={28} />
+            <span className="brand-copy">
+              <span className="brand-name">{t("app.name")}</span>
+              <span className="brand-subtitle">{t("shell.cockpit")}</span>
+            </span>
+          </button>
+          <nav className="topnav" aria-label={t("nav.main")}>
+            {NAV_ITEMS.map(item => navButton(item, "topnav-item"))}
+          </nav>
+          <span className="spacer" />
           {page !== "health" && <ScopeSwitcher />}
           {updated && <span className="topbar-updated">{t("common.updated_at", { value: `${updated.text}${updated.zone ? ` (${updated.zone})` : ""}` })}</span>}
-          <span className="spacer" />
           <button type="button" className="button button-secondary button-sm appearance-toggle lang-toggle" aria-label={t("prefs.language")} title={t("prefs.language")} onClick={() => setPrefs({ ...prefs, language: language === "zh" ? "en" : "zh" })}>
             {/* Narrow screens keep the control short; the full word stays for wide layouts. */}
             <span className="lang-label lang-label-full">{language === "zh" ? "English" : "中文"}</span>
@@ -176,7 +176,7 @@ export function AppShell({
       <nav className="bottom-tabs" aria-label={t("nav.main")}>
         <div className="bottom-tabs-inner">
           {MOBILE_PRIMARY.map(id => navButton(NAV_ITEMS.find(item => item.id === id)!, "bottom-tab"))}
-          <button type="button" ref={moreButtonRef} className={`bottom-tab${moreOpen || MOBILE_MORE.includes(page) ? " active" : ""}`} aria-expanded={moreOpen} aria-controls="more-sheet" onClick={() => setMoreOpen(value => !value)}>
+          <button type="button" ref={moreButtonRef} className={`bottom-tab${moreOpen || MOBILE_MORE.includes(page) ? " active" : ""}`} aria-expanded={moreOpen} aria-controls="more-sheet" aria-label={t("nav.more")} onClick={() => setMoreOpen(value => !value)}>
             <NavIcon path="M5 12 m-1.5 0 a1.5 1.5 0 1 0 3 0 a1.5 1.5 0 1 0 -3 0 M12 12 m-1.5 0 a1.5 1.5 0 1 0 3 0 a1.5 1.5 0 1 0 -3 0 M19 12 m-1.5 0 a1.5 1.5 0 1 0 3 0 a1.5 1.5 0 1 0 -3 0" />
             <span className="nav-text">{t("nav.more")}</span>
           </button>
diff --git a/web/strategy-switch-console/frontend/src/app/app.css b/web/strategy-switch-console/frontend/src/app/app.css
index f2218075..0533b0d7 100644
--- a/web/strategy-switch-console/frontend/src/app/app.css
+++ b/web/strategy-switch-console/frontend/src/app/app.css
@@ -1,57 +1,121 @@
 /* QuantStrategyLab console — rewritten UI (design tokens per console_design_spec.md §5). */
 
 :root {
-  --canvas: #F5F7FA;
+  /* Decision Cockpit semantic tokens, light theme (TOKENS-v2). Components use
+     these; the legacy aliases below keep existing surfaces and their checks. */
+  --background-canvas: #F7F8FA;
+  --background-chrome: #FFFFFF;
+  --surface-default: #FFFFFF;
+  --surface-subtle: #F0F2F5;
+  --surface-hover: #E8EBF0;
+  --border-divider: #DFE2E8;
+  --border-control: #858B98;
+  --text-primary: #18181B;
+  --text-secondary: #525763;
+  --text-muted: #646B78;
+  --accent-foreground: #5B4FD6;
+  --accent-surface: #EEEBFC;
+  --button-primary-bg: #18181B;
+  --button-primary-fg: #FFFFFF;
+  --button-primary-hover: #303034;
+  --button-primary-pressed: #0F1012;
+  --focus-ring: #5B4FD6;
+  --overlay-scrim: #00000066;
+  --status-attention: #805000;
+  --status-attention-bg: #FFF4DD;
+  --status-blocked: #A72E42;
+  --status-blocked-bg: #FCECEF;
+  --status-verified: #19624D;
+  --status-verified-bg: #EAF6EF;
+  --status-info: #136C9F;
+  --status-info-bg: #EAF4FC;
+  --chart-primary: #5B4FD6;
+  --chart-secondary: #136C9F;
+  --chart-benchmark: #646B78;
+  --chart-grid: #DFE2E8;
+
+  --canvas: #F7F8FA;
   --surface: #FFFFFF;
-  --surface-2: #EEF2F7;
-  --ink: #0F172A;
-  --muted: #52627A;
-  --line: rgba(15, 23, 42, 0.10);
-  --accent: #2563EB;
+  --surface-2: #F0F2F5;
+  --ink: #18181B;
+  --muted: #646B78;
+  --line: #DFE2E8;
+  --accent: #5B4FD6;
   --on-accent: #FFFFFF;
-  --up-green: #15803D;
-  --down-green: #DC2626;
+  --up-green: #19624D;
+  --down-green: #A72E42;
   --up: var(--up-green);
   --down: var(--down-green);
-  --status-ok: #0F766E;
-  --status-warn: #92400E;
+  --status-ok: #19624D;
+  --status-warn: #805000;
   --on-warn: #FFFFFF;
-  --status-error: #BE123C;
-  --status-unknown: #64748B;
-  --danger: #B91C1C;
-  --benchmark-1: #7C3AED;
-  --benchmark-2: #B45309;
-  --benchmark-3: #0E7490;
-  --benchmark-4: #475569;
-  --radius-s: 6px;
-  --radius-m: 10px;
-  --bottom-tabs-height: 56px;
-  --shadow: 0 1px 2px rgba(15, 23, 42, 0.06), 0 4px 16px rgba(15, 23, 42, 0.08);
+  --status-error: #A72E42;
+  --status-unknown: #646B78;
+  --danger: #A72E42;
+  --benchmark-1: #5B4FD6;
+  --benchmark-2: #136C9F;
+  --benchmark-3: #19624D;
+  --benchmark-4: #646B78;
+  --radius-s: 8px;
+  --radius-m: 12px;
+  --bottom-tabs-height: 64px;
+  --shadow: 0 12px 32px #18181B1A;
   color-scheme: light;
 }
 
 :root[data-theme="dark"] {
-  --canvas: #0B1016;
-  --surface: #131B25;
-  --surface-2: #192330;
-  --ink: #E8EEF7;
-  --muted: #93A0B5;
-  --line: rgba(148, 163, 184, 0.16);
-  --accent: #60A5FA;
-  --on-accent: #0B1016;
-  --up-green: #22C55E;
-  --down-green: #F87171;
-  --status-ok: #2DD4BF;
-  --status-warn: #FBBF24;
-  --on-warn: #0B1016;
-  --status-error: #FB7185;
-  --status-unknown: #94A3B8;
-  --danger: #F87171;
-  --benchmark-1: #C4B5FD;
-  --benchmark-2: #FBBF24;
-  --benchmark-3: #67E8F9;
-  --benchmark-4: #CBD5E1;
-  --shadow: 0 1px 2px rgba(0, 0, 0, 0.4), 0 4px 16px rgba(0, 0, 0, 0.35);
+  --background-canvas: #0F1012;
+  --background-chrome: #0F1012;
+  --surface-default: #17181C;
+  --surface-subtle: #1D1F24;
+  --surface-hover: #23262C;
+  --border-divider: #303238;
+  --border-control: #717684;
+  --text-primary: #F4F4F5;
+  --text-secondary: #B4B6BF;
+  --text-muted: #8D919E;
+  --accent-foreground: #B7ADFF;
+  --accent-surface: #29243B;
+  --button-primary-bg: #F4F4F5;
+  --button-primary-fg: #17181C;
+  --button-primary-hover: #FFFFFF;
+  --button-primary-pressed: #DEDEE4;
+  --focus-ring: #B7ADFF;
+  --overlay-scrim: #00000099;
+  --status-attention: #F3C677;
+  --status-attention-bg: #302718;
+  --status-blocked: #F1A5AD;
+  --status-blocked-bg: #321F23;
+  --status-verified: #8DCFB6;
+  --status-verified-bg: #182C25;
+  --status-info: #89C9EF;
+  --status-info-bg: #192B38;
+  --chart-primary: #B7ADFF;
+  --chart-secondary: #89C9EF;
+  --chart-benchmark: #9AA0AE;
+  --chart-grid: #303238;
+
+  --canvas: #0F1012;
+  --surface: #17181C;
+  --surface-2: #1D1F24;
+  --ink: #F4F4F5;
+  --muted: #8D919E;
+  --line: #303238;
+  --accent: #B7ADFF;
+  --on-accent: #17181C;
+  --up-green: #8DCFB6;
+  --down-green: #F1A5AD;
+  --status-ok: #8DCFB6;
+  --status-warn: #F3C677;
+  --on-warn: #17181C;
+  --status-error: #F1A5AD;
+  --status-unknown: #8D919E;
+  --danger: #F1A5AD;
+  --benchmark-1: #B7ADFF;
+  --benchmark-2: #89C9EF;
+  --benchmark-3: #8DCFB6;
+  --benchmark-4: #9AA0AE;
+  --shadow: 0 12px 32px #00000066;
   color-scheme: dark;
 }
 
@@ -66,11 +130,12 @@
 html, body {
   margin: 0;
   padding: 0;
-  background: var(--canvas);
-  color: var(--ink);
-  font-family: system-ui, -apple-system, "Segoe UI", Roboto, "PingFang SC", "Hiragino Sans GB", "Microsoft YaHei", sans-serif;
+  background: var(--background-canvas);
+  color: var(--text-primary);
+  font-family: "Geist", "Inter", "Noto Sans SC", system-ui, -apple-system, "Segoe UI", Roboto, "PingFang SC", "Hiragino Sans GB", "Microsoft YaHei", sans-serif;
   font-size: 14px;
   line-height: 1.5;
+  -webkit-font-smoothing: antialiased;
 }
 
 .num, .kpi-value, td.num, .money, .percent { font-variant-numeric: tabular-nums; }
@@ -113,32 +178,58 @@ button:disabled { cursor: not-allowed; opacity: 0.55; }
 }
 .skip-link:focus { top: 8px; }
 
-.shell { display: flex; min-height: 100vh; }
+.shell { display: flex; flex-direction: column; min-height: 100vh; background: var(--background-canvas); }
 
-.sidenav {
-  width: 208px;
+.shell-main { flex: 1 1 auto; min-width: 0; display: flex; flex-direction: column; }
+
+.brand {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  padding: 0;
+  text-align: left;
+  color: var(--text-primary);
   flex: 0 0 auto;
+}
+.brand img { width: 28px; height: 28px; flex: 0 0 auto; }
+.brand-copy { display: flex; flex-direction: column; line-height: 1.15; min-width: 0; }
+.brand-name { font-weight: 700; font-size: 14px; letter-spacing: -0.01em; white-space: nowrap; }
+.brand-subtitle { color: var(--text-muted); font-size: 11px; white-space: nowrap; }
+
+.topbar {
   display: flex;
-  flex-direction: column;
-  gap: 4px;
-  padding: 16px 12px;
-  border-right: 1px solid var(--line);
-  background: var(--surface);
+  align-items: center;
+  gap: 16px;
+  min-height: 64px;
+  padding: 0 24px;
+  border-bottom: 1px solid var(--border-divider);
+  background: var(--background-chrome);
   position: sticky;
   top: 0;
-  height: 100vh;
+  z-index: 20;
+  flex-wrap: nowrap;
 }
-.sidenav.collapsed { width: 64px; }
-.sidenav.collapsed .nav-text, .sidenav.collapsed .brand-name { display: none; }
+.topbar .spacer { flex: 1 1 auto; }
+.topbar-updated { color: var(--text-muted); font-size: 12px; white-space: nowrap; }
 
-.brand {
-  display: flex;
+.topnav { display: flex; align-items: stretch; gap: 2px; height: 64px; min-width: 0; }
+.topnav-item {
+  display: inline-flex;
   align-items: center;
-  gap: 8px;
-  padding: 4px 8px 16px;
+  gap: 7px;
+  padding: 0 12px;
+  min-height: 44px;
+  color: var(--text-secondary);
+  font-size: 14px;
+  font-weight: 500;
+  white-space: nowrap;
+  border-bottom: 2px solid transparent;
+  margin-bottom: -1px;
+  transition: color 120ms cubic-bezier(0.2, 0, 0, 1), background-color 120ms cubic-bezier(0.2, 0, 0, 1);
 }
-.brand img { width: 28px; height: 28px; }
-.brand-name { font-weight: 700; font-size: 14px; }
+.topnav-item:hover { color: var(--text-primary); background: var(--surface-subtle); }
+.topnav-item.active { color: var(--accent-foreground); border-bottom-color: var(--accent-foreground); }
+.topnav-item svg { flex: 0 0 auto; }
 
 .nav-item {
   display: flex;
@@ -146,15 +237,17 @@ button:disabled { cursor: not-allowed; opacity: 0.55; }
   gap: 10px;
   width: 100%;
   padding: 10px 12px;
+  min-height: 44px;
   border-radius: var(--radius-s);
-  color: var(--muted);
+  color: var(--text-secondary);
   text-align: left;
   position: relative;
+  transition: background-color 120ms cubic-bezier(0.2, 0, 0, 1), color 120ms cubic-bezier(0.2, 0, 0, 1);
 }
-.nav-item { transition: background-color 120ms ease, color 120ms ease; }
-.nav-item:hover { background: var(--surface-2); color: var(--ink); }
-.nav-item.active { background: color-mix(in srgb, var(--accent) 10%, var(--surface)); color: var(--accent); font-weight: 600; }
+.nav-item:hover { background: var(--surface-hover); color: var(--text-primary); }
+.nav-item.active { background: var(--accent-surface); color: var(--accent-foreground); font-weight: 600; }
 .nav-item svg { flex: 0 0 auto; }
+
 .nav-badge {
   margin-left: auto;
   min-width: 18px;
@@ -166,37 +259,14 @@ button:disabled { cursor: not-allowed; opacity: 0.55; }
   text-align: center;
   line-height: 18px;
 }
+.topnav-item .nav-badge { margin-left: 2px; }
 /* A count that could not be read is marked, never left blank: blank reads as "no to-dos". */
 .nav-badge-unknown { background: var(--surface-2); color: var(--muted); box-shadow: inset 0 0 0 1px var(--line); }
-.sidenav-collapse {
-  margin-top: auto;
-  padding: 8px 12px;
-  color: var(--muted);
-  border-radius: var(--radius-s);
-}
-.sidenav-collapse:hover { background: var(--surface-2); }
-
-.shell-main { flex: 1 1 auto; min-width: 0; display: flex; flex-direction: column; }
-
-.topbar {
-  display: flex;
-  align-items: center;
-  gap: 12px;
-  padding: 10px 16px;
-  border-bottom: 1px solid var(--line);
-  background: var(--surface);
-  position: sticky;
-  top: 0;
-  z-index: 20;
-  flex-wrap: wrap;
-}
-.topbar .spacer { flex: 1 1 auto; }
-.topbar-updated { color: var(--muted); font-size: 12px; white-space: nowrap; }
 
 .content {
   flex: 1 1 auto;
-  padding: 16px;
-  max-width: 1280px;
+  padding: 32px 24px 64px;
+  max-width: 1440px;
   width: 100%;
   margin: 0 auto;
 }
@@ -205,20 +275,20 @@ button:disabled { cursor: not-allowed; opacity: 0.55; }
   display: inline-flex;
   align-items: center;
   justify-content: center;
-  width: 32px; height: 32px;
+  width: 40px; height: 40px;
   border-radius: var(--radius-s);
-  color: var(--muted);
+  color: var(--text-secondary);
 }
-.icon-button:hover, .icon-button[aria-pressed="true"] { background: var(--surface-2); color: var(--ink); }
+.icon-button:hover, .icon-button[aria-pressed="true"] { background: var(--surface-hover); color: var(--text-primary); }
 
-/* Bottom tabs (mobile) */
+/* Bottom tabs (mobile): Overview, Decisions, More. */
 .bottom-tabs {
   display: none;
   position: fixed;
   left: 0; right: 0; bottom: 0;
   min-height: calc(var(--bottom-tabs-height) + env(safe-area-inset-bottom));
-  background: var(--surface);
-  border-top: 1px solid var(--line);
+  background: var(--background-chrome);
+  border-top: 1px solid var(--border-divider);
   z-index: 30;
   padding-bottom: env(safe-area-inset-bottom);
 }
@@ -228,22 +298,24 @@ button:disabled { cursor: not-allowed; opacity: 0.55; }
   display: flex;
   flex-direction: column;
   align-items: center;
-  gap: 2px;
+  justify-content: center;
+  gap: 3px;
+  min-height: 56px;
   padding: 8px 0 6px;
-  color: var(--muted);
+  color: var(--text-secondary);
   font-size: 12px;
   position: relative;
 }
-.bottom-tab.active { color: var(--accent); font-weight: 600; }
-.bottom-tab .nav-badge { position: absolute; top: 2px; right: calc(50% - 20px); margin: 0; }
+.bottom-tab.active { color: var(--accent-foreground); font-weight: 600; }
+.bottom-tab .nav-badge { position: absolute; top: 4px; right: calc(50% - 22px); margin: 0; }
 
 .more-sheet {
   position: fixed;
   left: 0; right: 0;
   /* Sits above the fixed tab bar instead of covering it. */
   bottom: calc(var(--bottom-tabs-height) + env(safe-area-inset-bottom));
-  background: var(--surface);
-  border-top: 1px solid var(--line);
+  background: var(--surface-default);
+  border-top: 1px solid var(--border-divider);
   border-radius: 16px 16px 0 0;
   padding: 8px 16px 16px;
   max-height: 70dvh;
@@ -251,7 +323,7 @@ button:disabled { cursor: not-allowed; opacity: 0.55; }
   z-index: 40;
   box-shadow: var(--shadow);
 }
-.more-sheet .nav-item { font-size: 16px; min-height: 44px; }
+.more-sheet .nav-item { font-size: 15px; min-height: 48px; }
 
 .lang-label-short { display: none; }
 
@@ -262,34 +334,39 @@ button:disabled { cursor: not-allowed; opacity: 0.55; }
   align-items: center;
   justify-content: center;
   gap: 6px;
-  min-height: 36px;
-  padding: 7px 15px;
-  border-radius: 7px;
+  min-height: 40px;
+  padding: 9px 16px;
+  border-radius: var(--radius-s);
   border: 1px solid transparent;
-  font-weight: 550;
+  font-size: 14px;
+  font-weight: 500;
   white-space: nowrap;
-  transition: background-color 120ms ease, border-color 120ms ease, color 120ms ease;
-}
-.button-primary { background: var(--accent); color: var(--on-accent); }
-.button-primary:hover:not(:disabled) { filter: brightness(1.08); }
-.button-secondary { border-color: var(--line); background: var(--surface); }
-.button-secondary:hover:not(:disabled) { border-color: color-mix(in srgb, var(--accent) 35%, var(--line)); background: var(--surface-2); }
-.button-danger { background: var(--danger); color: #fff; }
-.button-danger-outline { border-color: var(--danger); color: var(--danger); background: transparent; }
-.button-danger-outline:hover:not(:disabled) { background: color-mix(in srgb, var(--danger) 10%, transparent); }
-.button-sm { min-height: 30px; padding: 3px 10px; font-size: 13px; }
+  transition: background-color 120ms cubic-bezier(0.2, 0, 0, 1), border-color 120ms cubic-bezier(0.2, 0, 0, 1), color 120ms cubic-bezier(0.2, 0, 0, 1);
+}
+/* The primary action is neutral, not violet: violet marks selection, and a
+   neutral fill keeps "choose this object" distinct from "take this action". */
+.button-primary { background: var(--button-primary-bg); color: var(--button-primary-fg); }
+.button-primary:hover:not(:disabled) { background: var(--button-primary-hover); }
+.button-primary:active:not(:disabled) { background: var(--button-primary-pressed); }
+.button-secondary { border-color: var(--border-control); background: var(--surface-default); color: var(--text-primary); }
+.button-secondary:hover:not(:disabled) { background: var(--surface-hover); }
+.button-danger { background: var(--status-blocked); color: var(--status-blocked-bg); }
+.button-danger:hover:not(:disabled) { background: color-mix(in srgb, var(--status-blocked) 88%, var(--surface-default)); }
+.button-danger-outline { border-color: var(--status-blocked); color: var(--status-blocked); background: transparent; }
+.button-danger-outline:hover:not(:disabled) { background: var(--status-blocked-bg); }
+.button-sm { min-height: 32px; padding: 4px 11px; font-size: 13px; }
 
 /* ---------- Cards & KPI ---------- */
 
 .card {
-  background: var(--surface);
-  border: 1px solid var(--line);
-  border-radius: 12px;
-  padding: 18px 20px;
+  background: var(--surface-default);
+  border: 1px solid var(--border-divider);
+  border-radius: var(--radius-m);
+  padding: 24px;
   min-width: 0;
 }
-.card-title { margin: 0 0 12px; font-size: 16px; font-weight: 650; letter-spacing: -.01em; line-height: 1.35; }
-.card-note { color: var(--muted); font-size: 12px; margin: 8px 0 0; line-height: 1.55; }
+.card-title { margin: 0 0 12px; font-size: 20px; font-weight: 600; letter-spacing: -0.015em; line-height: 1.4; }
+.card-note { color: var(--text-muted); font-size: 12px; margin: 8px 0 0; line-height: 1.55; }
 
 .kpi-grid {
   display: grid;
@@ -297,13 +374,13 @@ button:disabled { cursor: not-allowed; opacity: 0.55; }
   gap: 12px;
 }
 .kpi-card {
-  background: var(--surface);
-  border: 1px solid var(--line);
-  border-radius: 11px;
-  padding: 14px 16px;
+  background: var(--surface-default);
+  border: 1px solid var(--border-divider);
+  border-radius: var(--radius-m);
+  padding: 18px 20px;
   display: flex;
   flex-direction: column;
-  gap: 5px;
+  gap: 6px;
   min-width: 0;
   text-align: left;
 }
@@ -324,19 +401,20 @@ button.kpi-card:hover { border-color: color-mix(in srgb, var(--accent) 45%, var(
   display: inline-flex;
   align-items: center;
   gap: 5px;
-  padding: 2px 9px;
+  min-height: 24px;
+  padding: 2px 8px;
   border-radius: 999px;
   font-size: 12px;
   font-weight: 500;
-  line-height: 17px;
+  line-height: 18px;
   white-space: nowrap;
 }
 .badge svg { flex: 0 0 auto; }
-.badge-ok { color: var(--status-ok); background: color-mix(in srgb, var(--status-ok) 12%, transparent); }
-.badge-warn { color: var(--status-warn); background: color-mix(in srgb, var(--status-warn) 14%, transparent); }
-.badge-error { color: var(--status-error); background: color-mix(in srgb, var(--status-error) 12%, transparent); }
-.badge-unknown { color: var(--status-unknown); background: color-mix(in srgb, var(--status-unknown) 14%, transparent); }
-.badge-accent { color: var(--accent); background: color-mix(in srgb, var(--accent) 12%, transparent); }
+.badge-ok { color: var(--status-verified); background: var(--status-verified-bg); }
+.badge-warn { color: var(--status-attention); background: var(--status-attention-bg); }
+.badge-error { color: var(--status-blocked); background: var(--status-blocked-bg); }
+.badge-unknown { color: var(--text-secondary); background: var(--surface-subtle); }
+.badge-accent { color: var(--accent-foreground); background: var(--accent-surface); }
 
 .up { color: var(--up); }
 .down { color: var(--down); }
@@ -432,10 +510,10 @@ button.kpi-card:hover { border-color: color-mix(in srgb, var(--accent) 45%, var(
 
 /* ---------- Layout helpers ---------- */
 
-.page { display: flex; flex-direction: column; gap: 18px; }
+.page { display: flex; flex-direction: column; gap: 24px; }
 .page-header { display: flex; align-items: center; gap: 10px 16px; flex-wrap: wrap; }
-.page-title { margin: 0; font-size: 24px; font-weight: 700; letter-spacing: -.025em; line-height: 1.2; }
-.page-subtitle { margin: -10px 0 0; color: var(--muted); font-size: 13px; line-height: 1.5; }
+.page-title { margin: 0; font-size: 32px; font-weight: 600; letter-spacing: -0.025em; line-height: 1.25; }
+.page-subtitle { margin: -12px 0 0; color: var(--text-secondary); font-size: 16px; line-height: 1.5; max-width: 72ch; }
 .page-header-actions { display: flex; align-items: center; gap: 8px 12px; flex-wrap: wrap; margin-left: auto; }
 .page-header-actions .segmented { max-width: 100%; }
 .grid-2 { display: grid; grid-template-columns: 1fr 1fr; gap: 18px; }
@@ -482,16 +560,17 @@ table.data-table { width: 100%; border-collapse: collapse; font-size: 13px; }
 .tabs { display: flex; gap: 2px; border-bottom: 1px solid var(--line); flex-wrap: wrap; overflow-x: auto; scrollbar-width: none; }
 .tabs::-webkit-scrollbar { display: none; }
 .tab {
-  min-height: 42px;
-  padding: 9px 14px;
-  color: var(--muted);
+  min-height: 44px;
+  padding: 11px 14px;
+  color: var(--text-secondary);
   border-bottom: 2px solid transparent;
   margin-bottom: -1px;
-  font-size: 13.5px;
+  font-size: 14px;
+  font-weight: 500;
   white-space: nowrap;
 }
-.tab:hover { color: var(--ink); }
-.tab.active { color: var(--accent); border-bottom-color: var(--accent); font-weight: 650; }
+.tab:hover { color: var(--text-primary); }
+.tab.active { color: var(--accent-foreground); border-bottom-color: var(--accent-foreground); font-weight: 600; }
 
 /* ---------- Segmented control ---------- */
 
@@ -517,17 +596,17 @@ table.data-table { width: 100%; border-collapse: collapse; font-size: 13px; }
 .field { display: flex; flex-direction: column; gap: 5px; margin-bottom: 12px; }
 .field > span { font-size: 12px; color: var(--muted); }
 .input, select.input {
-  min-height: 36px;
-  padding: 7px 10px;
-  border: 1px solid var(--line);
-  border-radius: 7px;
-  background: var(--surface);
-  color: var(--ink);
+  min-height: 40px;
+  padding: 9px 12px;
+  border: 1px solid var(--border-control);
+  border-radius: var(--radius-s);
+  background: var(--surface-default);
+  color: var(--text-primary);
   font: inherit;
   width: 100%;
 }
-.input:hover, select.input:hover { border-color: color-mix(in srgb, var(--accent) 30%, var(--line)); }
-.input:focus { outline: 2px solid var(--accent); outline-offset: 0; border-color: transparent; }
+.input:hover, select.input:hover { border-color: var(--accent-foreground); }
+.input:focus { outline: 2px solid var(--focus-ring); outline-offset: 0; border-color: transparent; }
 
 .checkbox-row { display: flex; align-items: flex-start; gap: 8px; font-size: 13px; }
 .checkbox-row input { margin-top: 3px; }
@@ -537,25 +616,25 @@ table.data-table { width: 100%; border-collapse: collapse; font-size: 13px; }
 .dialog-backdrop {
   position: fixed;
   inset: 0;
-  background: rgba(0, 0, 0, 0.45);
+  background: var(--overlay-scrim);
   display: flex;
   align-items: center;
   justify-content: center;
   padding: 16px;
-  z-index: 100;
+  z-index: 50;
 }
 .dialog {
-  background: var(--surface);
+  background: var(--surface-default);
   border-radius: var(--radius-m);
-  border: 1px solid var(--line);
+  border: 1px solid var(--border-divider);
   box-shadow: var(--shadow);
-  max-width: 520px;
+  max-width: 480px;
   width: 100%;
   max-height: 85vh;
   overflow: auto;
-  padding: 20px;
+  padding: 32px;
 }
-.dialog h2 { margin: 0 0 8px; font-size: 16px; }
+.dialog h2 { margin: 0 0 8px; font-size: 20px; line-height: 1.4; }
 .dialog .dialog-target { font-weight: 600; margin: 0 0 8px; }
 .dialog .dialog-summary { color: var(--muted); margin: 0 0 8px; }
 .dialog .dialog-consequence { margin: 0 0 12px; }
@@ -940,33 +1019,45 @@ table.data-table { width: 100%; border-collapse: collapse; font-size: 13px; }
   .stat-strip { grid-template-columns: repeat(3, minmax(0, 1fr)); }
 }
 
+/* Tablet: the header keeps every destination, but icon-only so the scope and
+   session controls retain their targets. Each button keeps its accessible name. */
+@media (max-width: 1180px) and (min-width: 769px) {
+  .topbar { gap: 10px; padding: 0 16px; }
+  .topnav-item { width: 44px; padding: 0; justify-content: center; }
+  .topnav-label { display: none; }
+}
+
 @media (max-width: 768px) {
   .stat-strip { grid-template-columns: repeat(2, minmax(0, 1fr)); }
-  .sidenav { display: none; }
+  .topnav { display: none; }
   .bottom-tabs { display: block; }
   /* The document is the scroll container: reserve the fixed tab bar plus the
      safe area, with a gap, so the last row of every page clears the nav. */
-  .content { padding: 14px 12px calc(var(--bottom-tabs-height) + 40px + env(safe-area-inset-bottom)); }
+  .content { padding: 20px 16px calc(var(--bottom-tabs-height) + 32px + env(safe-area-inset-bottom)); }
   .health-grid-hint { display: block; }
   .table-scroll-hint { display: block; }
-  .page { gap: 14px; }
+  .page { gap: 16px; }
   .page-header { gap: 10px; }
-  .page-title { font-size: 20px; }
+  .page-title { font-size: 28px; letter-spacing: -0.02em; }
+  .page-subtitle { margin-top: -8px; font-size: 14px; }
   .page-header-actions { margin-left: auto; justify-content: flex-end; }
   .page-header-actions:has(> .segmented) { width: 100%; margin-left: 0; }
   .page-header-actions > .button { flex: 0 0 auto; }
   .page-header-actions > .segmented { width: 100%; flex-wrap: nowrap; overflow-x: auto; scrollbar-width: none; }
   .page-header-actions > .segmented::-webkit-scrollbar { display: none; }
   .page-header-actions > .segmented .segment { flex: 1 1 auto; justify-content: center; white-space: nowrap; }
-  .card { padding: 14px; }
-  .card-title { font-size: 15px; margin-bottom: 10px; }
+  .card { padding: 16px; }
+  .card-title { font-size: 18px; margin-bottom: 10px; }
   .kpi-grid { grid-template-columns: repeat(2, minmax(0, 1fr)); }
-  .kpi-value { font-size: 21px; }
-  .kpi-card { padding: 12px 13px; }
+  .kpi-value { font-size: 22px; }
+  .kpi-card { padding: 14px; }
   .topbar-updated { display: none; }
   /* Topbar keeps one row: the scope trigger flexes and truncates, the icon
-     controls keep a 44px touch target. */
-  .topbar { flex-wrap: nowrap; gap: 8px; padding: 8px 12px; }
+     controls keep a 44px touch target. The brand copy is dropped on phones so
+     the scope keeps its width; the page title carries the context. */
+  .topbar { min-height: 56px; flex-wrap: nowrap; gap: 8px; padding: 6px 12px; }
+  .topbar .brand img { width: 24px; height: 24px; }
+  .brand-copy { display: none; }
   .topbar .scope-switcher { flex: 1 1 auto; min-width: 44px; }
   .topbar .spacer { display: none; }
   .lang-label-full { display: none; }
diff --git a/web/strategy-switch-console/frontend/src/components/AuditHistory.tsx b/web/strategy-switch-console/frontend/src/components/AuditHistory.tsx
new file mode 100644
index 00000000..78ad965a
--- /dev/null
+++ b/web/strategy-switch-console/frontend/src/components/AuditHistory.tsx
@@ -0,0 +1,40 @@
+import { useRef, useState } from "react";
+import { loadAuditEvents, type AuditEvent } from "../api/cockpit";
+import { useApi } from "../lib/hooks";
+import { useT } from "../i18n";
+import { AuditTimeline } from "./cockpit";
+
+export function mergeAuditEvents(previous: AuditEvent[], incoming: AuditEvent[]): AuditEvent[] {
+  const seen = new Set(previous.map(event => event.event_id));
+  return [...previous, ...incoming.filter(event => !seen.has(event.event_id))];
+}
+
+/** Remount on refresh; useApi discards responses from previous pages/unmounts. */
+export function AuditHistory() {
+  const t = useT();
+  const [cursor, setCursor] = useState<string | null>(null);
+  const [previous, setPrevious] = useState<AuditEvent[]>([]);
+  const requested = useRef<string | null>(null);
+  const read = useApi(() => loadAuditEvents(cursor), [cursor]);
+  const page = read.phase === "ready" && read.data.status === "ready" ? read.data.data : null;
+  const events = page ? mergeAuditEvents(previous, page.events) : previous;
+  const unavailable = read.phase === "ready" && read.data.status === "not_ready";
+  const status = events.length ? "ready" : read.phase === "loading" ? "loading"
+    : read.phase === "error" ? "error" : unavailable ? "not_ready" : "ready";
+  function more() {
+    if (!page?.next_cursor || requested.current === page.next_cursor) return;
+    requested.current = page.next_cursor;
+    setPrevious(events);
+    setCursor(page.next_cursor);
+  }
+  return <>
+    <AuditTimeline events={events} status={status} hasMore={Boolean(page?.next_cursor)}
+      loadingMore={read.phase === "loading"} onMore={more} />
+    {read.phase === "loading" && previous.length > 0 && <p role="status">{t("common.loading")}</p>}
+    {(read.phase === "error" || unavailable) && <>
+      {previous.length > 0 && <p role="alert">{t("cockpit.change_log.load_failed")}</p>}
+      <button className="button button-secondary button-sm" type="button" onClick={read.reload}>{t("common.retry")}</button>
+    </>}
+    {page && <p className="cockpit-note">{t("cockpit.change_log.coverage")}</p>}
+  </>;
+}
diff --git a/web/strategy-switch-console/frontend/src/components/Dialog.tsx b/web/strategy-switch-console/frontend/src/components/Dialog.tsx
index 9571275c..d31ed157 100644
--- a/web/strategy-switch-console/frontend/src/components/Dialog.tsx
+++ b/web/strategy-switch-console/frontend/src/components/Dialog.tsx
@@ -1,5 +1,6 @@
 import { useEffect, useRef, useState } from "react";
 import type { KeyboardEvent, ReactNode } from "react";
+import { expiryState } from "../api/cockpit";
 import { useT } from "../i18n";
 
 export interface ConfirmRequest {
@@ -14,6 +15,12 @@ export interface ConfirmRequest {
   /** Require typing this exact value (e.g. account alias) before confirming. */
   typeToConfirm?: { label: string; expected: string; mismatch: string };
   body?: ReactNode;
+  /** Server-bound validity. Pass only when the server clock is known. */
+  expiresAt?: string | null;
+  serverTime?: string | null;
+  receivedAt?: string;
+  /** Called once when the open dialog crosses the server expiry boundary. */
+  onExpiry?: () => void;
 }
 
 /** Unified confirmation dialog; supports acknowledgement checkbox and type-to-confirm. */
@@ -23,14 +30,35 @@ export function ConfirmationDialog({ request, onResolve }: { request: ConfirmReq
   const cancelRef = useRef<HTMLButtonElement>(null);
   const [acked, setAcked] = useState(false);
   const [typed, setTyped] = useState("");
+  const [now, setNow] = useState(() => Date.now());
+  const expiryFired = useRef(false);
 
   useEffect(() => {
     cancelRef.current?.focus();
   }, []);
 
+  useEffect(() => {
+    if (!request.expiresAt) return;
+    setNow(Date.now());
+    const id = window.setInterval(() => setNow(Date.now()), 1000);
+    return () => window.clearInterval(id);
+  }, [request.expiresAt]);
+
+  // Only a server-derived expiry is enforced. Without a server clock the
+  // dialog keeps the existing read-time validity check instead of guessing.
+  const expiry = request.expiresAt
+    ? expiryState(request.expiresAt, request.serverTime ?? null, request.receivedAt ?? new Date().toISOString(), now)
+    : ({ state: "none" } as const);
+  const expired = expiry.state === "expired";
+  useEffect(() => {
+    if (!expired || expiryFired.current) return;
+    expiryFired.current = true;
+    request.onExpiry?.();
+  }, [expired, request]);
+
   const typeOk = !request.typeToConfirm || typed.trim() === request.typeToConfirm.expected;
   const ackOk = !request.ackLabel || acked;
-  const canConfirm = typeOk && ackOk;
+  const canConfirm = typeOk && ackOk && !expired;
 
   const onKeyDown = (event: KeyboardEvent<HTMLDivElement>) => {
     if (event.key === "Escape") {
@@ -74,6 +102,13 @@ export function ConfirmationDialog({ request, onResolve }: { request: ConfirmReq
         {request.summary && <div className="dialog-summary">{request.summary}</div>}
         {request.body}
         {request.consequence && <p className={`dialog-consequence ${request.tone === "danger" ? "danger" : ""}`}>{request.consequence}</p>}
+        {request.expiresAt && (
+          <p className={`dialog-consequence ${expired ? "danger" : ""}`} role={expired ? "alert" : undefined}>
+            {expired
+              ? <>{t("cockpit.expiry.expired")} · {t("cockpit.expiry.boundary")}</>
+              : t("cockpit.expiry.at", { value: request.expiresAt })}
+          </p>
+        )}
         {request.ackLabel && (
           <label className="checkbox-row">
             <input type="checkbox" checked={acked} onChange={event => setAcked(event.target.checked)} />
diff --git a/web/strategy-switch-console/frontend/src/components/RuntimeReadbackPanel.tsx b/web/strategy-switch-console/frontend/src/components/RuntimeReadbackPanel.tsx
new file mode 100644
index 00000000..3c3fdbad
--- /dev/null
+++ b/web/strategy-switch-console/frontend/src/components/RuntimeReadbackPanel.tsx
@@ -0,0 +1,30 @@
+import { loadRuntimeReadback, type RuntimeReadback } from "../api/cockpit";
+import { useApi } from "../lib/hooks";
+import { useT } from "../i18n";
+import { AsOfStamp, ErrorState, Skeleton } from "./primitives";
+
+export function RuntimeReadbackDetails({ value }: { value: RuntimeReadback }) {
+  const t = useT();
+  return <>
+    {value.data_status !== "ready" && <p role="status">{t(`cockpit.freshness.${value.data_status}`)}</p>}
+    <dl className="cockpit-meta">
+      <dt>{t("cockpit.runtime.switch")}</dt>
+      <dd>{t(value.runtime_enabled === null ? "cockpit.unknown" : value.runtime_enabled ? "cockpit.runtime.enabled" : "cockpit.runtime.disabled")}</dd>
+      <dt>{t("cockpit.runtime.scheduler")}</dt>
+      <dd>{t(`cockpit.runtime.scheduler.${value.scheduler_state}`)}</dd>
+    </dl>
+    {value.observed_at && <AsOfStamp value={value.observed_at} />}
+  </>;
+}
+
+export function RuntimeReadbackPanel({ scope }: { scope: string }) {
+  const t = useT();
+  const read = useApi(() => loadRuntimeReadback(scope), [scope]);
+  return <section className="card">
+    <h3>{t("cockpit.runtime.title")}</h3>
+    {read.phase === "loading" ? <Skeleton height={64} /> : read.phase === "error"
+      ? <ErrorState onRetry={read.reload} /> : read.data.status === "not_ready"
+        ? <p>{t("cockpit.freshness.unavailable")}</p> : <RuntimeReadbackDetails value={read.data.data} />}
+    <p className="cockpit-note">{t("cockpit.runtime.boundary")}</p>
+  </section>;
+}
diff --git a/web/strategy-switch-console/frontend/src/components/cockpit.css b/web/strategy-switch-console/frontend/src/components/cockpit.css
new file mode 100644
index 00000000..58cc7eb2
--- /dev/null
+++ b/web/strategy-switch-console/frontend/src/components/cockpit.css
@@ -0,0 +1,469 @@
+/* Decision-cockpit primitives. Tokens only; no shadow except the docked strip. */
+
+.cockpit-section {
+  display: grid;
+  gap: 12px;
+  padding: 20px;
+  border: 1px solid var(--border-divider);
+  border-radius: var(--radius-m);
+  background: var(--surface-default);
+}
+
+.cockpit-section-title {
+  margin: 0;
+  font-size: 16px;
+  font-weight: 600;
+  color: var(--text-primary);
+}
+
+.cockpit-subtitle {
+  margin: 4px 0 0;
+  font-size: 13px;
+  font-weight: 600;
+  color: var(--text-secondary);
+}
+
+.cockpit-meta {
+  margin: 0;
+  font-size: 12px;
+  color: var(--text-muted);
+}
+
+.cockpit-note {
+  margin: 0;
+  font-size: 13px;
+  line-height: 1.5;
+  color: var(--text-secondary);
+}
+
+.cockpit-note.error {
+  color: var(--status-blocked);
+}
+
+.cockpit-unknown {
+  color: var(--text-muted);
+}
+
+.cockpit-sr-only {
+  position: absolute;
+  width: 1px;
+  height: 1px;
+  padding: 0;
+  margin: -1px;
+  overflow: hidden;
+  clip: rect(0 0 0 0);
+  white-space: nowrap;
+  border: 0;
+}
+
+.cockpit-badges,
+.cockpit-freshness,
+.cockpit-decision-support {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 8px;
+}
+
+.cockpit-kv {
+  display: grid;
+  gap: 8px;
+  margin: 0;
+}
+
+.cockpit-kv-pair {
+  display: grid;
+  grid-template-columns: minmax(120px, 180px) minmax(0, 1fr);
+  gap: 12px;
+}
+
+.cockpit-kv dt {
+  font-size: 12px;
+  color: var(--text-muted);
+}
+
+.cockpit-kv dd {
+  margin: 0;
+  font-size: 13px;
+  color: var(--text-primary);
+  overflow-wrap: anywhere;
+}
+
+.cockpit-toolbar {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 8px;
+}
+
+.cockpit-details {
+  font-size: 12px;
+  color: var(--text-secondary);
+}
+
+.cockpit-details summary {
+  cursor: pointer;
+  color: var(--text-muted);
+}
+
+.cockpit-details code {
+  font-size: 12px;
+  color: var(--text-secondary);
+  overflow-wrap: anywhere;
+}
+
+/* freshness + expiry */
+
+.cockpit-expiry {
+  display: grid;
+  gap: 4px;
+  margin: 0;
+  padding: 10px 12px;
+  border-left: 3px solid var(--border-control);
+  border-radius: var(--radius-s);
+  background: var(--surface-subtle);
+}
+
+.cockpit-expiry[data-state="under_five"],
+.cockpit-expiry[data-state="under_hour"] {
+  border-left-color: var(--status-attention);
+  background: var(--status-attention-bg);
+}
+
+.cockpit-expiry[data-state="expired"] {
+  border-left-color: var(--status-blocked);
+  background: var(--status-blocked-bg);
+}
+
+.cockpit-expiry[data-state="unknown"] {
+  border-left-color: var(--status-unknown);
+}
+
+.cockpit-expiry-line {
+  display: flex;
+  flex-wrap: wrap;
+  justify-content: space-between;
+  gap: 8px;
+  margin: 0;
+  font-size: 13px;
+  color: var(--text-primary);
+}
+
+.cockpit-expiry-remaining {
+  font-weight: 600;
+}
+
+.cockpit-expiry-utc {
+  font-size: 11px;
+  color: var(--text-muted);
+}
+
+/* tier selector */
+
+.cockpit-tier-group {
+  display: grid;
+  gap: 8px;
+  margin: 0;
+  padding: 0;
+  border: 0;
+}
+
+.cockpit-tier-option {
+  display: flex;
+  gap: 10px;
+  align-items: flex-start;
+  padding: 12px;
+  border: 1px solid var(--border-divider);
+  border-radius: var(--radius-s);
+  cursor: pointer;
+}
+
+.cockpit-tier-option:has(input:checked) {
+  border-color: var(--accent-foreground);
+  background: var(--accent-surface);
+}
+
+.cockpit-tier-option:has(input:disabled) {
+  cursor: not-allowed;
+}
+
+.cockpit-tier-option input {
+  margin-top: 3px;
+  accent-color: var(--accent-foreground);
+}
+
+.cockpit-tier-name {
+  display: block;
+  font-size: 13px;
+  font-weight: 600;
+  color: var(--text-primary);
+}
+
+.cockpit-tier-note {
+  display: block;
+  font-size: 12px;
+  color: var(--text-muted);
+}
+
+/* table */
+
+.cockpit-table {
+  width: 100%;
+  border-collapse: collapse;
+  font-size: 13px;
+}
+
+.cockpit-table th,
+.cockpit-table td {
+  padding: 8px 10px;
+  text-align: left;
+  border-bottom: 1px solid var(--border-divider);
+  vertical-align: top;
+}
+
+.cockpit-table thead th {
+  font-size: 12px;
+  font-weight: 500;
+  color: var(--text-muted);
+}
+
+.cockpit-table tbody th {
+  font-weight: 500;
+  color: var(--text-secondary);
+}
+
+/* lifecycle */
+
+.cockpit-stepper {
+  display: flex;
+  gap: 4px;
+  margin: 0;
+  padding: 0;
+  list-style: none;
+}
+
+.cockpit-step {
+  display: flex;
+  flex: 1 1 0;
+  align-items: center;
+  gap: 6px;
+  min-width: 0;
+  padding: 8px;
+  border-radius: var(--radius-s);
+  background: var(--surface-subtle);
+  font-size: 12px;
+  color: var(--text-muted);
+}
+
+.cockpit-step-dot {
+  width: 8px;
+  height: 8px;
+  flex: none;
+  border-radius: 50%;
+  background: var(--border-control);
+}
+
+.cockpit-step.complete .cockpit-step-dot {
+  background: var(--status-verified);
+}
+
+.cockpit-step.active {
+  background: var(--accent-surface);
+  color: var(--accent-foreground);
+  font-weight: 600;
+}
+
+.cockpit-step.active .cockpit-step-dot {
+  background: var(--accent-foreground);
+}
+
+/* operation */
+
+.cockpit-stages {
+  display: flex;
+  gap: 8px;
+  margin: 0;
+  padding: 0;
+  list-style: none;
+}
+
+.cockpit-stage {
+  flex: 1 1 0;
+  padding: 8px;
+  border-top: 3px solid var(--border-divider);
+  font-size: 12px;
+  color: var(--text-muted);
+}
+
+.cockpit-stage[data-state="active"] {
+  border-top-color: var(--status-attention);
+  color: var(--text-primary);
+}
+
+.cockpit-stage[data-state="complete"] {
+  border-top-color: var(--status-verified);
+  color: var(--text-primary);
+}
+
+.cockpit-stage[data-state="failed"] {
+  border-top-color: var(--status-blocked);
+  color: var(--status-blocked);
+}
+
+/* activity history */
+
+.cockpit-change-log {
+  display: grid;
+  gap: 12px;
+}
+
+.cockpit-timeline {
+  display: grid;
+  gap: 0;
+  margin: 0;
+  padding: 0;
+  list-style: none;
+}
+
+.cockpit-event {
+  display: grid;
+  grid-template-columns: minmax(130px, 180px) minmax(0, 1fr);
+  gap: 12px;
+  padding: 10px 0;
+  border-bottom: 1px solid var(--border-divider);
+}
+
+.cockpit-event time {
+  font-size: 12px;
+  color: var(--text-muted);
+}
+
+.cockpit-event-body {
+  display: grid;
+  gap: 2px;
+}
+
+.cockpit-event-action {
+  font-size: 13px;
+  font-weight: 500;
+  color: var(--text-primary);
+}
+
+.cockpit-targets {
+  display: grid;
+  gap: 4px;
+  margin: 0;
+  padding: 0;
+  list-style: none;
+}
+
+.cockpit-targets li {
+  display: flex;
+  justify-content: space-between;
+  gap: 12px;
+  font-size: 12px;
+}
+
+/* decision card */
+
+.cockpit-decision {
+  display: grid;
+  gap: 12px;
+  padding: 20px;
+  border: 1px solid var(--border-divider);
+  border-radius: var(--radius-m);
+  background: var(--surface-default);
+}
+
+.cockpit-decision.selected {
+  border-color: var(--accent-foreground);
+}
+
+.cockpit-decision-title {
+  margin: 0;
+  font-size: 16px;
+  font-weight: 600;
+  line-height: 1.35;
+  color: var(--text-primary);
+}
+
+.cockpit-blockers {
+  margin: 0;
+  padding-left: 18px;
+  font-size: 13px;
+  color: var(--status-blocked);
+}
+
+/* persistent operation strip */
+
+.cockpit-strip {
+  position: sticky;
+  top: 64px;
+  z-index: 20;
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 8px 12px;
+  padding: 10px 16px;
+  border: 1px solid var(--border-divider);
+  border-radius: var(--radius-m);
+  background: var(--surface-default);
+  box-shadow: var(--shadow);
+}
+
+.cockpit-strip[data-state="unknown"] {
+  border-color: var(--status-blocked);
+  background: var(--status-blocked-bg);
+}
+
+.cockpit-strip-title {
+  font-size: 12px;
+  font-weight: 600;
+  color: var(--text-primary);
+}
+
+.cockpit-strip-subject {
+  font-size: 13px;
+  color: var(--text-primary);
+  overflow-wrap: anywhere;
+}
+
+.cockpit-strip-actions {
+  display: flex;
+  gap: 8px;
+  margin-left: auto;
+}
+
+@media (max-width: 768px) {
+  .cockpit-section,
+  .cockpit-decision {
+    padding: 16px;
+  }
+
+  .cockpit-kv-pair {
+    grid-template-columns: 1fr;
+    gap: 2px;
+  }
+
+  .cockpit-stepper {
+    flex-wrap: wrap;
+  }
+
+  .cockpit-step {
+    flex: 1 1 45%;
+  }
+
+  .cockpit-event {
+    grid-template-columns: 1fr;
+    gap: 4px;
+  }
+
+  .cockpit-strip {
+    top: 56px;
+  }
+
+  .cockpit-strip-actions {
+    margin-left: 0;
+    width: 100%;
+  }
+}
diff --git a/web/strategy-switch-console/frontend/src/components/cockpit.tsx b/web/strategy-switch-console/frontend/src/components/cockpit.tsx
new file mode 100644
index 00000000..0d45f8c0
--- /dev/null
+++ b/web/strategy-switch-console/frontend/src/components/cockpit.tsx
@@ -0,0 +1,881 @@
+import { useEffect, useId, useRef, useState } from "react";
+import type {
+  AuditEvent,
+  DecisionDetail,
+  DigestStatus as DigestStatusData,
+  EvidenceSummary as EvidenceSummaryData,
+  LifecycleBinding,
+  OperationRecord,
+  PolicyBinding,
+  PolicyValue,
+  ProductStage,
+  RiskTier,
+} from "../api/cockpit";
+import { expiryState, isRiskTier } from "../api/cockpit";
+import { formatDateTime } from "../lib/format";
+import { useLanguage, useT } from "../i18n";
+import { Badge, Skeleton } from "./primitives";
+import "./cockpit.css";
+
+const TIERS: RiskTier[] = ["CAPITAL_PRESERVATION", "BALANCED_COMPOUNDING", "GROWTH_COMPOUNDING"];
+const STAGES: ProductStage[] = ["research", "paper", "small_live", "full_live"];
+
+export function tierLabel(value: string | null | undefined, t: ReturnType<typeof useT>): string {
+  if (value === "CAPITAL_PRESERVATION") return t("cockpit.tier.capital");
+  if (value === "BALANCED_COMPOUNDING") return t("cockpit.tier.balanced");
+  if (value === "GROWTH_COMPOUNDING") return t("cockpit.tier.growth");
+  return t("cockpit.not_set");
+}
+
+export function blockerLabel(reason: string, t: ReturnType<typeof useT>): string {
+  if (reason === "decision_expired") return t("cockpit.blocker.expired");
+  if (reason === "expiry_unverified") return t("cockpit.blocker.expiry");
+  if (reason === "approval_not_allowed") return t("cockpit.blocker.not_allowed");
+  if (reason === "evidence_missing") return t("cockpit.blocker.support_missing");
+  if (reason === "evidence_unqualified") return t("cockpit.blocker.unqualified");
+  if (reason.startsWith("evidence_")) return t("cockpit.blocker.support");
+  if (reason === "policy_unavailable") return t("cockpit.blocker.policy");
+  if (reason === "policy_binding_missing") return t("cockpit.blocker.binding");
+  if (reason === "revision_invalid") return t("cockpit.blocker.revision");
+  if (reason.startsWith("state_")) return t("cockpit.blocker.state");
+  return t("cockpit.blocker.other");
+}
+
+function useNow(active: boolean): number {
+  const [now, setNow] = useState(() => Date.now());
+  useEffect(() => {
+    if (!active) return;
+    const id = window.setInterval(() => setNow(Date.now()), 30_000);
+    return () => window.clearInterval(id);
+  }, [active]);
+  return now;
+}
+
+function remainingText(ms: number, language: "zh" | "en"): string {
+  const totalMinutes = Math.max(1, Math.ceil(ms / 60_000));
+  const hours = Math.floor(totalMinutes / 60);
+  const minutes = totalMinutes % 60;
+  if (hours === 0) return language === "zh" ? `${minutes} 分钟` : `${minutes}m`;
+  return language === "zh"
+    ? `${hours} 小时 ${String(minutes).padStart(2, "0")} 分`
+    : `${hours}h ${String(minutes).padStart(2, "0")}m`;
+}
+
+/* ---------- freshness ---------- */
+
+export function FreshnessBadge({
+  state,
+  observedAt,
+}: {
+  state: string | null | undefined;
+  observedAt?: string | null;
+}) {
+  const t = useT();
+  const language = useLanguage();
+  const known = state === "current" || state === "stale" || state === "missing" || state === "unknown"
+    || state === "partial" || state === "unavailable" || state === "read_failed" || state === "fresh" || state === "ready";
+  const normalized = state === "fresh" || state === "ready" ? "current" : known ? state : "unknown";
+  const tone = normalized === "current" ? "ok"
+    : normalized === "read_failed" ? "error"
+      : normalized === "stale" || normalized === "partial" ? "warn" : "unknown";
+  const observed = observedAt ? formatDateTime(observedAt, language) : null;
+  return (
+    <span className="cockpit-freshness" data-state={normalized}>
+      <Badge tone={tone}>{t(`cockpit.freshness.${normalized}`)}</Badge>
+      {observed && <span className="cockpit-meta">{t("cockpit.as_of", { value: observed.zone ? `${observed.text} (${observed.zone})` : observed.text })}</span>}
+    </span>
+  );
+}
+
+/* ---------- expiry ---------- */
+
+export function ExpiryIndicator({
+  expiresAt,
+  serverTime,
+  receivedAt,
+  onBoundary,
+  showConsequence = true,
+}: {
+  expiresAt: string | null;
+  serverTime: string | null;
+  receivedAt: string;
+  onBoundary?: () => void;
+  showConsequence?: boolean;
+}) {
+  const t = useT();
+  const language = useLanguage();
+  const now = useNow(Boolean(expiresAt));
+  const expiry = expiryState(expiresAt, serverTime, receivedAt, now);
+  const firedFor = useRef<string | null>(null);
+  useEffect(() => {
+    if (expiry.state === "expired" && firedFor.current !== expiresAt) {
+      firedFor.current = expiresAt;
+      onBoundary?.();
+    }
+  }, [expiry.state, expiresAt, onBoundary]);
+
+  if (expiry.state === "none") {
+    return <p className="cockpit-expiry" data-state="none">{t("cockpit.expiry.none")}</p>;
+  }
+  if (expiry.state === "unknown") {
+    return <p className="cockpit-expiry" data-state="unknown">{t("cockpit.expiry.unknown")}</p>;
+  }
+  const formatted = formatDateTime(expiry.expiresAt, language);
+  const exact = formatted.text === "—" ? expiry.expiresAt : formatted.zone ? `${formatted.text} (${formatted.zone})` : formatted.text;
+  const expired = expiry.state === "expired";
+  const remaining = expiry.state === "expired" ? 0 : expiry.remainingMs;
+  const urgency = expired ? "expired" : remaining < 5 * 60_000 ? "under_five" : remaining < 60 * 60_000 ? "under_hour" : "open";
+  const label = expired ? t("cockpit.expiry.expired")
+    : t(`cockpit.expiry.${urgency}`, { value: remainingText(remaining, language) });
+  return (
+    <div className="cockpit-expiry" data-state={urgency}>
+      <p className="cockpit-expiry-line">
+        <span>{t("cockpit.expiry.at", { value: exact })}</span>
+        <span className="cockpit-expiry-remaining">{label}</span>
+      </p>
+      <span className="cockpit-expiry-utc"><time dateTime={expiry.expiresAt}>{expiry.expiresAt}</time></span>
+      {showConsequence && (
+        <p className="cockpit-note">
+          {t("cockpit.expiry.inaction")} {!expired && t("cockpit.expiry.boundary")}
+        </p>
+      )}
+    </div>
+  );
+}
+
+/* ---------- supporting data ---------- */
+
+export function EvidenceSummary({
+  evidence,
+  status = "ready",
+}: {
+  evidence: EvidenceSummaryData | null;
+  status?: "loading" | "ready" | "unavailable";
+}) {
+  const t = useT();
+  const language = useLanguage();
+  if (status === "loading") return <Skeleton height={72} />;
+  if (status === "unavailable" || !evidence) {
+    return (
+      <section className="cockpit-section" aria-label={t("cockpit.support.title")}>
+        <h3 className="cockpit-section-title">{t("cockpit.support.title")}</h3>
+        <p className="cockpit-note error" role="status">{t("cockpit.support.missing")}</p>
+      </section>
+    );
+  }
+  const limitations = evidence.limitations;
+  const qualification = evidence.qualification === "qualified"
+    ? limitations.length > 0 ? t("cockpit.support.qualified_limited") : t("cockpit.support.qualified")
+    : evidence.qualification === "unqualified" ? t("cockpit.support.unqualified") : t("cockpit.support.unknown");
+  const tone = evidence.qualification === "qualified" ? limitations.length > 0 ? "warn" : "ok"
+    : evidence.qualification === "unqualified" ? "error" : "unknown";
+  const stateNotice = evidence.state === "stale" ? t("cockpit.support.stale")
+    : evidence.state === "expired" ? t("cockpit.support.expired")
+      : evidence.state === "unavailable" ? t("cockpit.support.unavailable")
+        : evidence.state === "missing" ? t("cockpit.support.missing") : null;
+  const observed = evidence.observed_at ? formatDateTime(evidence.observed_at, language) : null;
+  const valid = evidence.valid_until ? formatDateTime(evidence.valid_until, language) : null;
+  return (
+    <section className="cockpit-section" aria-label={t("cockpit.support.title")}>
+      <h3 className="cockpit-section-title">{t("cockpit.support.title")}</h3>
+      <div className="cockpit-badges">
+        <Badge tone={tone}>{qualification}</Badge>
+        <FreshnessBadge state={evidence.state} />
+      </div>
+      {stateNotice && <p className="cockpit-note error" role="status">{stateNotice}</p>}
+      <dl className="cockpit-kv">
+        {observed && (
+          <>
+            <dt>{t("cockpit.support.observed_label")}</dt>
+            <dd>{observed.zone ? `${observed.text} (${observed.zone})` : observed.text}</dd>
+          </>
+        )}
+        {valid && (
+          <>
+            <dt>{t("cockpit.support.valid_until_label")}</dt>
+            <dd>{valid.zone ? `${valid.text} (${valid.zone})` : valid.text}</dd>
+          </>
+        )}
+        <dt>{t("cockpit.support.limitations")}</dt>
+        <dd>{limitations.length > 0 ? limitations.join(" · ") : t("cockpit.support.no_limitations")}</dd>
+      </dl>
+      {evidence.evidence_id && (
+        <details className="cockpit-details">
+          <summary>{t("cockpit.support.provenance")}</summary>
+          <code>{evidence.evidence_id}</code>
+        </details>
+      )}
+    </section>
+  );
+}
+
+/* ---------- risk tier selector ---------- */
+
+export function RiskTierSelector({
+  scope,
+  value,
+  savedValue,
+  selectionRevision,
+  mappingAvailable,
+  disabled,
+  saving,
+  dirty,
+  onChange,
+  onSave,
+}: {
+  scope: string;
+  value: string;
+  savedValue: string;
+  selectionRevision: number | null;
+  mappingAvailable: boolean;
+  disabled: boolean;
+  saving: boolean;
+  dirty: boolean;
+  onChange: (tier: RiskTier | "") => void;
+  onSave: () => void;
+}) {
+  const t = useT();
+  const id = useId();
+  const unrecognized = value !== "" && !isRiskTier(value);
+  return (
+    <section className="cockpit-section" aria-label={t("cockpit.tier.title")}>
+      <h3 className="cockpit-section-title">{t("cockpit.tier.title")}</h3>
+      <p className="cockpit-meta">{t("cockpit.tier.scope", { value: scope })}</p>
+      <fieldset className="cockpit-tier-group" disabled={disabled || saving}>
+        <legend className="cockpit-sr-only">{t("cockpit.tier.title")}</legend>
+        {TIERS.map(tier => {
+          const noteKey = tier === "CAPITAL_PRESERVATION" ? "cockpit.tier.capital_note"
+            : tier === "BALANCED_COMPOUNDING" ? "cockpit.tier.balanced_note" : "cockpit.tier.growth_note";
+          return (
+            <label className="cockpit-tier-option" key={tier}>
+              <input
+                type="radio"
+                name={`${id}-tier`}
+                value={tier}
+                checked={value === tier}
+                aria-describedby={`${id}-${tier}`}
+                onChange={() => onChange(tier)}
+              />
+              <span>
+                <span className="cockpit-tier-name">{t(`cockpit.tier.${tier === "CAPITAL_PRESERVATION" ? "capital" : tier === "BALANCED_COMPOUNDING" ? "balanced" : "growth"}`)}</span>
+                <span className="cockpit-tier-note" id={`${id}-${tier}`}>{t(noteKey)}</span>
+              </span>
+            </label>
+          );
+        })}
+        <label className="cockpit-tier-option">
+          <input
+            type="radio"
+            name={`${id}-tier`}
+            value=""
+            checked={value === ""}
+            aria-describedby={`${id}-unset`}
+            onChange={() => onChange("")}
+          />
+          <span>
+            <span className="cockpit-tier-name">{t("cockpit.tier.unset")}</span>
+            <span className="cockpit-tier-note" id={`${id}-unset`}>{t("cockpit.tier.unset_note")}</span>
+          </span>
+        </label>
+      </fieldset>
+      {unrecognized && <p className="cockpit-note" role="status">{t("cockpit.unknown")}: {value}</p>}
+      {!mappingAvailable && <p className="cockpit-note error" role="status">{t("cockpit.policy.mapping_unavailable")}</p>}
+      <div className="cockpit-toolbar">
+        <button
+          type="button"
+          className="button button-primary button-sm"
+          disabled={disabled || saving || !dirty || !mappingAvailable}
+          onClick={onSave}
+        >
+          {t("cockpit.tier.save")}
+        </button>
+        <span className="cockpit-meta">{dirty ? t("cockpit.tier.dirty") : t("cockpit.tier.unchanged")}</span>
+        {selectionRevision !== null && (
+          <span className="cockpit-meta">{t("cockpit.tier.selection_revision", { value: selectionRevision })}</span>
+        )}
+      </div>
+      <p className="cockpit-meta">
+        {t("cockpit.decision.selected")}: {savedValue === "" ? t("cockpit.tier.unset") : tierLabel(savedValue, t)}
+      </p>
+      {!mappingAvailable && <p className="cockpit-note">{t("cockpit.policy.effective_note")}</p>}
+    </section>
+  );
+}
+
+/* ---------- effective policy ---------- */
+
+function PolicyValueCell({ value }: { value: PolicyValue }) {
+  const t = useT();
+  if (value.status !== "known" || value.value === null) {
+    return <span className="cockpit-unknown">{t("cockpit.policy.unknown_value")}</span>;
+  }
+  return <span>{String(value.value)}{value.unit ? ` ${value.unit}` : ""}</span>;
+}
+
+export function EffectivePolicyPanel({
+  binding,
+  status = "ready",
+  onRetry,
+}: {
+  binding: PolicyBinding | null;
+  status?: "loading" | "ready" | "not_ready" | "error";
+  onRetry?: () => void;
+}) {
+  const t = useT();
+  const language = useLanguage();
+  if (status === "loading") return <Skeleton height={96} />;
+  if (status === "error") {
+    return (
+      <section className="cockpit-section" aria-label={t("cockpit.policy.title")}>
+        <h3 className="cockpit-section-title">{t("cockpit.policy.title")}</h3>
+        <p className="cockpit-note error" role="alert">{t("cockpit.policy.read_failed")}</p>
+        {onRetry && <button type="button" className="button button-secondary button-sm" onClick={onRetry}>{t("common.retry")}</button>}
+      </section>
+    );
+  }
+  if (status === "not_ready" || !binding) {
+    return (
+      <section className="cockpit-section" aria-label={t("cockpit.policy.title")}>
+        <h3 className="cockpit-section-title">{t("cockpit.policy.title")}</h3>
+        <p className="cockpit-note error" role="status">{t("cockpit.policy.mapping_unavailable")}</p>
+      </section>
+    );
+  }
+  const restriction = binding.temporary_restriction;
+  const effectiveObserved = binding.effective_observed_at ? formatDateTime(binding.effective_observed_at, language) : null;
+  const since = restriction?.until ? formatDateTime(restriction.until, language) : null;
+  return (
+    <section className="cockpit-section" aria-label={t("cockpit.policy.title")}>
+      <h3 className="cockpit-section-title">{t("cockpit.policy.title")}</h3>
+      <dl className="cockpit-kv">
+        <dt>{t("cockpit.policy.selected")}</dt>
+        <dd>
+          {binding.selected_tier ? tierLabel(binding.selected_tier, t) : t("cockpit.unknown")}
+          {binding.selection_revision !== null && <span className="cockpit-meta"> · {t("cockpit.policy.revision", { value: binding.selection_revision })}</span>}
+        </dd>
+        <dt>{t("cockpit.policy.approved")}</dt>
+        <dd>
+          {binding.approved_policy_id || binding.approved_tier ? (
+            <>
+              {binding.approved_tier && <>{tierLabel(binding.approved_tier, t)} · </>}
+              {binding.approved_policy_id || t("cockpit.unknown")}
+              {binding.approved_policy_revision && <span className="cockpit-meta"> · {t("cockpit.policy.revision", { value: binding.approved_policy_revision })}</span>}
+            </>
+          ) : t("cockpit.policy.mapping_unavailable")}
+        </dd>
+        <dt>{t("cockpit.policy.effective")}</dt>
+        <dd>
+          {binding.effective_policy_id || binding.effective_tier ? (
+            <>
+              {binding.effective_tier && <>{tierLabel(binding.effective_tier, t)} · </>}
+              {binding.effective_policy_id || t("cockpit.unknown")}
+              {binding.effective_policy_revision && <span className="cockpit-meta"> · {t("cockpit.policy.revision", { value: binding.effective_policy_revision })}</span>}
+              {effectiveObserved && <span className="cockpit-meta"> · {t("cockpit.as_of", { value: effectiveObserved.text })}</span>}
+            </>
+          ) : t("cockpit.policy.not_observed")}
+        </dd>
+        <dt>{t("cockpit.policy.restriction")}</dt>
+        <dd>
+          {restriction?.active ? (
+            <>
+              {restriction.reason || t("cockpit.unknown")}
+              {since && <span className="cockpit-meta"> · {t("cockpit.policy.since", { value: since.text })}</span>}
+            </>
+          ) : t("cockpit.policy.restriction_none")}
+        </dd>
+      </dl>
+      <h4 className="cockpit-subtitle">{t("cockpit.policy.values")}</h4>
+      {binding.values.length === 0 ? (
+        <p className="cockpit-meta">{t("cockpit.policy.no_values")}</p>
+      ) : (
+        <table className="cockpit-table">
+          <thead>
+            <tr>
+              <th scope="col">{t("cockpit.policy.values")}</th>
+              <th scope="col">{t("cockpit.policy.source_label")}</th>
+            </tr>
+          </thead>
+          <tbody>
+            {binding.values.map(value => (
+              <tr key={value.key}>
+                <th scope="row">{value.label_key ? t(value.label_key) : value.key}</th>
+                <td>
+                  <PolicyValueCell value={value} />
+                  {value.source && <span className="cockpit-meta"> · {t("cockpit.policy.source", { value: value.source })}</span>}
+                </td>
+              </tr>
+            ))}
+          </tbody>
+        </table>
+      )}
+      <p className="cockpit-note">{t("cockpit.policy.effective_note")}</p>
+    </section>
+  );
+}
+
+/* ---------- lifecycle ---------- */
+
+export function LifecycleStepper({ binding }: { binding: LifecycleBinding }) {
+  const t = useT();
+  const highlight = STAGES.includes(binding.authorized_stage as ProductStage)
+    ? binding.authorized_stage as ProductStage
+    : STAGES.includes(binding.effective_stage as ProductStage)
+      ? binding.effective_stage as ProductStage
+      : null;
+  const highlightIndex = highlight ? STAGES.indexOf(highlight) : -1;
+  const axes: { key: string; value: string }[] = [
+    { key: "cockpit.lifecycle.axis.research", value: t(`cockpit.lifecycle.stage.${binding.research_stage}`) },
+    { key: "cockpit.lifecycle.axis.authorized", value: t(`cockpit.lifecycle.stage.${binding.authorized_stage}`) },
+    { key: "cockpit.lifecycle.axis.effective", value: t(`cockpit.lifecycle.stage.${binding.effective_stage}`) },
+    { key: "cockpit.lifecycle.axis.operating", value: t(`cockpit.lifecycle.operating.${binding.operating_state}`) },
+    { key: "cockpit.lifecycle.axis.application", value: t(`cockpit.lifecycle.application.${binding.application_state}`) },
+  ];
+  return (
+    <section className="cockpit-section" aria-label={t("cockpit.lifecycle.title")}>
+      <h3 className="cockpit-section-title">{t("cockpit.lifecycle.title")}</h3>
+      <p className="cockpit-meta">{t("cockpit.lifecycle.step")}</p>
+      <ol className="cockpit-stepper">
+        {STAGES.map((stage, index) => {
+          const active = highlightIndex >= 0 && index === highlightIndex;
+          const complete = highlightIndex >= 0 && index < highlightIndex;
+          return (
+            <li
+              key={stage}
+              className={`cockpit-step${active ? " active" : ""}${complete ? " complete" : ""}`}
+              aria-current={active ? "step" : undefined}
+            >
+              <span className="cockpit-step-dot" aria-hidden="true" />
+              <span>{t(`cockpit.lifecycle.stage.${stage}`)}</span>
+            </li>
+          );
+        })}
+      </ol>
+      {highlight === null && (
+        <p className="cockpit-note" role="status">{t("cockpit.lifecycle.stage.unclassified")}</p>
+      )}
+      <dl className="cockpit-kv">
+        {axes.map(axis => (
+          <div className="cockpit-kv-pair" key={axis.key}>
+            <dt>{t(axis.key)}</dt>
+            <dd>{axis.value}</dd>
+          </div>
+        ))}
+      </dl>
+      <p className="cockpit-note">{t("cockpit.lifecycle.note")}</p>
+    </section>
+  );
+}
+
+/* ---------- application / operation status ---------- */
+
+function operationLabel(operation: OperationRecord, t: ReturnType<typeof useT>): string {
+  if (operation.runtime_confirmed_at) return t("cockpit.operation.confirmed");
+  if (operation.state === "pending") return operation.dispatched_at ? t("cockpit.operation.applying") : t("cockpit.operation.accepted");
+  if (operation.state === "applying") return t("cockpit.operation.applying");
+  if (operation.state === "applied") return t("cockpit.operation.applied_unobserved");
+  if (operation.state === "rejected") return t("cockpit.operation.rejected");
+  if (operation.state === "failed") return t("cockpit.operation.failed");
+  return t("cockpit.operation.unknown");
+}
+
+function operationTone(operation: OperationRecord): "ok" | "warn" | "error" | "unknown" {
+  if (operation.runtime_confirmed_at) return "ok";
+  if (operation.state === "rejected" || operation.state === "failed") return "error";
+  if (operation.state === "applied" || operation.state === "applying" || operation.state === "pending") return "warn";
+  return "unknown";
+}
+
+export function ApplicationStatus({
+  operation,
+  status,
+  onRefresh,
+}: {
+  operation: OperationRecord | null;
+  status: "loading" | "ready" | "not_ready" | "error";
+  onRefresh?: () => void;
+}) {
+  const t = useT();
+  const language = useLanguage();
+  if (status === "loading") return <Skeleton height={72} />;
+  if (status === "not_ready") {
+    return (
+      <section className="cockpit-section" aria-label={t("cockpit.operation.title")}>
+        <h3 className="cockpit-section-title">{t("cockpit.operation.title")}</h3>
+        <p className="cockpit-note" role="status">{t("cockpit.operation.not_ready")}</p>
+      </section>
+    );
+  }
+  if (status === "error") {
+    return (
+      <section className="cockpit-section" aria-label={t("cockpit.operation.title")}>
+        <h3 className="cockpit-section-title">{t("cockpit.operation.title")}</h3>
+        <p className="cockpit-note error" role="alert">{t("cockpit.operation.read_failed")}</p>
+        {onRefresh && <button type="button" className="button button-secondary button-sm" onClick={onRefresh}>{t("cockpit.operation.refresh")}</button>}
+      </section>
+    );
+  }
+  if (!operation) {
+    return (
+      <section className="cockpit-section" aria-label={t("cockpit.operation.title")}>
+        <h3 className="cockpit-section-title">{t("cockpit.operation.title")}</h3>
+        <p className="cockpit-meta">{t("cockpit.operation.none")}</p>
+      </section>
+    );
+  }
+  const applied = operation.state === "applied" || Boolean(operation.runtime_confirmed_at);
+  const observed = Boolean(operation.runtime_confirmed_at);
+  const failed = operation.state === "rejected" || operation.state === "failed";
+  const stages = [
+    { label: t("cockpit.operation.decision"), state: "complete" },
+    { label: t("cockpit.operation.application"), state: failed ? "failed" : observed ? "complete" : applied ? "complete" : "active" },
+    { label: t("cockpit.operation.observation"), state: observed ? "complete" : applied ? "active" : "idle" },
+  ];
+  const lastUpdate = operation.applied_at ?? operation.runtime_confirmed_at ?? operation.dispatched_at ?? operation.recorded_at;
+  const lastUpdateText = lastUpdate ? formatDateTime(lastUpdate, language) : null;
+  return (
+    <section className="cockpit-section" aria-label={t("cockpit.operation.title")}>
+      <h3 className="cockpit-section-title">{t("cockpit.operation.title")}</h3>
+      <div className="cockpit-badges">
+        <Badge tone={operationTone(operation)}>{operationLabel(operation, t)}</Badge>
+        {lastUpdateText && <span className="cockpit-meta">{t("cockpit.as_of", { value: lastUpdateText.zone ? `${lastUpdateText.text} (${lastUpdateText.zone})` : lastUpdateText.text })}</span>}
+      </div>
+      <ol className="cockpit-stages">
+        {stages.map(stage => (
+          <li key={stage.label} className="cockpit-stage" data-state={stage.state}>{stage.label}</li>
+        ))}
+      </ol>
+      {(operation.failure_reason || operation.unknown_reason) && (
+        <p className={`cockpit-note ${failed ? "error" : ""}`} role="status">{operation.failure_reason || operation.unknown_reason}</p>
+      )}
+      {operation.state === "unknown" && <p className="cockpit-note" role="status">{t("cockpit.operation.no_retry")}</p>}
+      <details className="cockpit-details">
+        <summary>{t("cockpit.operation.id", { value: operation.operation_id || t("cockpit.unknown") })}</summary>
+        <p className="cockpit-meta">{t("cockpit.operation.request", { value: operation.request_id || t("cockpit.unknown") })}</p>
+        {operation.decision_revision !== null && (
+          <p className="cockpit-meta">{t("cockpit.operation.revision", { value: operation.decision_revision })}</p>
+        )}
+      </details>
+      {onRefresh && (
+        <button type="button" className="button button-secondary button-sm" onClick={onRefresh}>
+          {t("cockpit.operation.refresh")}
+        </button>
+      )}
+    </section>
+  );
+}
+
+/* ---------- pause / recovery ---------- */
+
+export function PauseControl({
+  operatingState,
+  canPause,
+  canResume,
+  pending,
+  reason,
+  onPause,
+  onResume,
+}: {
+  operatingState: string;
+  canPause: boolean;
+  canResume: boolean;
+  pending: boolean;
+  reason?: string | null;
+  onPause?: () => void;
+  onResume?: () => void;
+}) {
+  const t = useT();
+  const stateKey = operatingState === "running" ? "cockpit.pause.running"
+    : operatingState === "paused" ? "cockpit.pause.paused" : "cockpit.pause.unknown";
+  const blocked = !canPause && !canResume;
+  return (
+    <section className="cockpit-section" aria-label={t("cockpit.pause.title")}>
+      <h3 className="cockpit-section-title">{t("cockpit.pause.title")}</h3>
+      <div className="cockpit-badges">
+        <Badge tone={operatingState === "running" ? "ok" : operatingState === "paused" ? "warn" : "unknown"}>
+          {t(stateKey)}
+        </Badge>
+      </div>
+      <div className="cockpit-toolbar">
+        <button
+          type="button"
+          className="button button-secondary button-sm"
+          disabled={pending || !canPause}
+          onClick={onPause}
+        >
+          {t("cockpit.pause.pause")}
+        </button>
+        <button
+          type="button"
+          className="button button-secondary button-sm"
+          disabled={pending || !canResume}
+          onClick={onResume}
+        >
+          {t("cockpit.pause.resume")}
+        </button>
+        {pending && <span className="cockpit-meta" role="status">{t("cockpit.pause.pending")}</span>}
+      </div>
+      {blocked && <p className="cockpit-note">{reason || t("cockpit.pause.unavailable")}</p>}
+      <p className="cockpit-note">{t("cockpit.pause.note")}</p>
+    </section>
+  );
+}
+
+/* ---------- activity history ---------- */
+
+export function AuditTimeline({
+  events,
+  status,
+  hasMore = false,
+  loadingMore = false,
+  onMore,
+}: {
+  events: AuditEvent[] | null;
+  status: "loading" | "ready" | "not_ready" | "error";
+  hasMore?: boolean;
+  loadingMore?: boolean;
+  onMore?: () => void;
+}) {
+  const t = useT();
+  const language = useLanguage();
+  if (status === "loading") return <Skeleton height={96} />;
+  if (status === "not_ready") return <p className="cockpit-note">{t("cockpit.change_log.unavailable")}</p>;
+  if (status === "error") return <p className="cockpit-note error" role="alert">{t("cockpit.change_log.load_failed")}</p>;
+  if (!events || events.length === 0) return <p className="cockpit-meta">{t("cockpit.change_log.empty")}</p>;
+  return (
+    <div className="cockpit-change-log">
+      <ol className="cockpit-timeline">
+        {events.map(event => {
+          const time = formatDateTime(event.occurred_at, language);
+          return (
+            <li key={event.event_id} className="cockpit-event">
+              <time dateTime={event.occurred_at}>{time.zone ? `${time.text} (${time.zone})` : time.text}</time>
+              <div className="cockpit-event-body">
+                <span className="cockpit-event-action">{event.action.replace(/_/g, " ")}</span>
+                <span className="cockpit-meta">
+                  {event.actor ? t("cockpit.change_log.actor", { value: event.actor }) : t("cockpit.unknown")}
+                  {event.outcome && ` · ${t("cockpit.change_log.outcome", { value: event.outcome })}`}
+                </span>
+                {event.subject && <span className="cockpit-meta">{t("cockpit.change_log.subject", { value: event.subject })}</span>}
+                {event.revision !== null && <span className="cockpit-meta">{t("cockpit.change_log.revision", { value: event.revision })}</span>}
+              </div>
+            </li>
+          );
+        })}
+      </ol>
+      {hasMore && onMore && (
+        <button type="button" className="button button-secondary button-sm" disabled={loadingMore} onClick={onMore}>
+          {t("cockpit.change_log.more")}
+        </button>
+      )}
+    </div>
+  );
+}
+
+/* ---------- digest ---------- */
+
+export function DigestStatus({
+  digest,
+  status = "ready",
+  onRetry,
+}: {
+  digest: DigestStatusData | null;
+  status?: "loading" | "ready" | "not_ready" | "error";
+  onRetry?: () => void;
+}) {
+  const t = useT();
+  const language = useLanguage();
+  if (status === "loading") return <Skeleton height={96} />;
+  if (status === "error") {
+    return (
+      <section className="cockpit-section" aria-label={t("cockpit.digest.title")}>
+        <h3 className="cockpit-section-title">{t("cockpit.digest.title")}</h3>
+        <p className="cockpit-note error" role="alert">{t("cockpit.digest.read_failed")}</p>
+        {onRetry && <button type="button" className="button button-secondary button-sm" onClick={onRetry}>{t("common.retry")}</button>}
+      </section>
+    );
+  }
+  if (status === "not_ready" || !digest) {
+    return (
+      <section className="cockpit-section" aria-label={t("cockpit.digest.title")}>
+        <h3 className="cockpit-section-title">{t("cockpit.digest.title")}</h3>
+        <p className="cockpit-meta">{t("cockpit.digest.no_data")}</p>
+      </section>
+    );
+  }
+  const tone = digest.delivery_state === "delivered" ? "ok"
+    : digest.delivery_state === "failed" ? "error"
+      : digest.delivery_state === "accepted" ? "warn" : "unknown";
+  const accepted = digest.accepted_at ? formatDateTime(digest.accepted_at, language) : null;
+  const acknowledged = digest.acknowledged_at ? formatDateTime(digest.acknowledged_at, language) : null;
+  const count = (value: number | null) => value === null ? t("cockpit.unknown") : String(value);
+  return (
+    <section className="cockpit-section" aria-label={t("cockpit.digest.title")}>
+      <h3 className="cockpit-section-title">{t("cockpit.digest.title")}</h3>
+      <div className="cockpit-badges">
+        <Badge tone={tone}>{t(`cockpit.digest.${digest.delivery_state}`)}</Badge>
+        {digest.legacy_receipts && <Badge tone="unknown">{t("cockpit.digest.legacy")}</Badge>}
+      </div>
+      {(digest.business_day || digest.timezone) && (
+        <p className="cockpit-meta">
+          {t("cockpit.digest.window", {
+            day: digest.business_day || t("cockpit.unknown"),
+            zone: digest.timezone || t("cockpit.unknown"),
+          })}
+        </p>
+      )}
+      <p className="cockpit-meta">
+        {t("cockpit.digest.targets", {
+          expected: count(digest.expected_targets),
+          covered: count(digest.covered_targets),
+          unavailable: count(digest.unavailable_targets),
+        })}
+      </p>
+      {accepted && (
+        <p className="cockpit-meta">{t("cockpit.digest.accepted_at", { value: accepted.zone ? `${accepted.text} (${accepted.zone})` : accepted.text })}</p>
+      )}
+      <p className="cockpit-meta">
+        {t("cockpit.digest.ack")}: {acknowledged
+          ? t("cockpit.digest.ack_at", { value: acknowledged.zone ? `${acknowledged.text} (${acknowledged.zone})` : acknowledged.text })
+          : t("cockpit.digest.ack_unknown")}
+      </p>
+      {digest.targets.length > 0 && (
+        <ul className="cockpit-targets">
+          {digest.targets.map(target => (
+            <li key={target.label}>
+              <span>{target.label}</span>
+              <span className="cockpit-meta">{target.known ? "✓" : t("cockpit.unknown")}</span>
+            </li>
+          ))}
+        </ul>
+      )}
+      <p className="cockpit-note">{t("cockpit.digest.note")}</p>
+    </section>
+  );
+}
+
+/* ---------- persistent operation strip ---------- */
+
+export function operationNeedsAttention(operation: OperationRecord | null): boolean {
+  if (!operation) return false;
+  return operation.state === "pending" || operation.state === "applying" || operation.state === "unknown";
+}
+
+export function PersistentOperationStrip({
+  operation,
+  lastReadAt,
+  onView,
+  onAcknowledge,
+}: {
+  operation: OperationRecord;
+  lastReadAt: string | null;
+  onView: () => void;
+  onAcknowledge?: () => void;
+}) {
+  const t = useT();
+  const language = useLanguage();
+  const unknown = operation.state === "unknown";
+  const readAt = lastReadAt ? formatDateTime(lastReadAt, language) : null;
+  return (
+    <div className="cockpit-strip" data-state={operation.state} role={unknown ? "alert" : "status"}>
+      <span className="cockpit-strip-title">{t("cockpit.strip.title")}</span>
+      <span className="cockpit-strip-subject">
+        {operation.account_alias || operation.release_id || operation.operation_id}
+      </span>
+      <Badge tone={unknown ? "error" : "warn"}>{unknown ? t("cockpit.strip.unknown") : operationLabel(operation, t)}</Badge>
+      {readAt && <span className="cockpit-meta">{t("cockpit.strip.last_read", { value: readAt.text })}</span>}
+      <span className="cockpit-strip-actions">
+        <button type="button" className="button button-secondary button-sm" onClick={onView}>{t("cockpit.strip.view")}</button>
+        {unknown && onAcknowledge && (
+          <button type="button" className="button button-secondary button-sm" onClick={onAcknowledge}>{t("cockpit.strip.ack")}</button>
+        )}
+      </span>
+      <span className="cockpit-meta">{t("cockpit.strip.note")}</span>
+    </div>
+  );
+}
+
+/* ---------- decision card ---------- */
+
+export function DecisionCard({
+  decision,
+  operation,
+  receivedAt,
+  blockedReasons = [],
+  selected = false,
+  onSelect,
+}: {
+  decision: DecisionDetail;
+  operation?: OperationRecord | null;
+  receivedAt: string;
+  blockedReasons?: string[];
+  selected?: boolean;
+  onSelect: () => void;
+}) {
+  const t = useT();
+  const title = t(decision.title_key);
+  const blocked = blockedReasons.length > 0;
+  return (
+    <article className={`cockpit-decision${selected ? " selected" : ""}`} data-state={decision.state}>
+      <div className="cockpit-badges">
+        <Badge tone={decision.category === "reconciliation_recovery" ? "warn" : "accent"}>
+          {t(`category.${decision.category}`)}
+        </Badge>
+        <Badge tone={decision.state === "pending" ? "warn" : decision.state === "approved" ? "ok" : "unknown"}>
+          {t(`cockpit.decision.state.${decision.state}`)}
+        </Badge>
+        {blocked && <Badge tone="error">{t("cockpit.decision.blocked")}</Badge>}
+      </div>
+      <h3 className="cockpit-decision-title">{title === decision.title_key ? decision.short_id : title}</h3>
+      <dl className="cockpit-kv">
+        {decision.account_alias && (
+          <div className="cockpit-kv-pair">
+            <dt>{t("cockpit.decision.target")}</dt>
+            <dd>{decision.account_alias}{decision.platform ? ` · ${decision.platform}` : ""}</dd>
+          </div>
+        )}
+        {decision.release_id && (
+          <div className="cockpit-kv-pair">
+            <dt>{t("cockpit.decision.release")}</dt>
+            <dd>{decision.release_id}</dd>
+          </div>
+        )}
+        {decision.policy && (
+          <div className="cockpit-kv-pair">
+            <dt>{t("cockpit.decision.tier")}</dt>
+            <dd>
+              {tierLabel(decision.policy.selected_tier, t)}
+              {decision.policy.policy_revision && <span className="cockpit-meta"> · {t("cockpit.policy.revision", { value: decision.policy.policy_revision })}</span>}
+            </dd>
+          </div>
+        )}
+        {operation && (
+          <div className="cockpit-kv-pair">
+            <dt>{t("cockpit.decision.operation")}</dt>
+            <dd>{operationLabel(operation, t)}</dd>
+          </div>
+        )}
+      </dl>
+      {decision.evidence && (
+        <div className="cockpit-decision-support">
+          <span className="cockpit-meta">{t("cockpit.decision.qualification")}:</span>
+          <FreshnessBadge state={decision.evidence.state} />
+          <Badge tone={decision.evidence.qualification === "qualified" ? "ok" : decision.evidence.qualification === "unqualified" ? "error" : "unknown"}>
+            {decision.evidence.qualification === "qualified"
+              ? decision.evidence.limitations.length > 0 ? t("cockpit.support.qualified_limited") : t("cockpit.support.qualified")
+              : decision.evidence.qualification === "unqualified" ? t("cockpit.support.unqualified") : t("cockpit.support.unknown")}
+          </Badge>
+        </div>
+      )}
+      {blocked && (
+        <ul className="cockpit-blockers" aria-label={t("cockpit.decision.blocked")}>
+          {blockedReasons.map(reason => <li key={reason}>{blockerLabel(reason, t)}</li>)}
+        </ul>
+      )}
+      <ExpiryIndicator expiresAt={decision.expires_at} serverTime={decision.server_time} receivedAt={receivedAt} showConsequence={false} />
+      <p className="cockpit-note">{t("cockpit.decision.no_action")}</p>
+      <button type="button" className="button button-primary button-sm" onClick={onSelect}>
+        {t("cockpit.decision.review")}
+      </button>
+    </article>
+  );
+}
diff --git a/web/strategy-switch-console/frontend/src/i18n/en.ts b/web/strategy-switch-console/frontend/src/i18n/en.ts
index f67b3a1f..045865ae 100644
--- a/web/strategy-switch-console/frontend/src/i18n/en.ts
+++ b/web/strategy-switch-console/frontend/src/i18n/en.ts
@@ -7,14 +7,15 @@ export const en: Record<CoreMessageKey, string> = {
   "shell.update_available": "A new version is ready. Refresh to use it.",
   "shell.reload": "Refresh page",
   "app.name": "QuantStrategyLab",
+  "shell.cockpit": "Decision Cockpit",
 
   "nav.main": "Main navigation",
   "nav.overview": "Overview",
   "nav.performance": "Performance",
-  "nav.decisions": "To-dos",
+  "nav.decisions": "Decisions",
   "nav.accounts": "Accounts",
   "nav.strategies": "Strategies",
-  "nav.health": "Run status",
+  "nav.health": "Health",
   "nav.more": "More",
   "nav.todo_unavailable": "To-do count unavailable",
 
diff --git a/web/strategy-switch-console/frontend/src/i18n/index.tsx b/web/strategy-switch-console/frontend/src/i18n/index.tsx
index f50c6ce4..c5b2c5fa 100644
--- a/web/strategy-switch-console/frontend/src/i18n/index.tsx
+++ b/web/strategy-switch-console/frontend/src/i18n/index.tsx
@@ -10,6 +10,7 @@ import * as accounts from "./pages/accounts";
 import * as strategies from "./pages/strategies";
 import * as health from "./pages/health";
 import * as facts from "./pages/facts";
+import * as cockpit from "./pages/cockpit";
 
 const zh: Record<string, string> = {
   ...zhCN,
@@ -20,6 +21,7 @@ const zh: Record<string, string> = {
   ...strategies.zh,
   ...health.zh,
   ...facts.zh,
+  ...cockpit.zh,
 };
 const enMessages: Record<string, string> = {
   ...en,
@@ -30,6 +32,7 @@ const enMessages: Record<string, string> = {
   ...strategies.en,
   ...health.en,
   ...facts.en,
+  ...cockpit.en,
 };
 
 for (const key of Object.keys(zh)) {
diff --git a/web/strategy-switch-console/frontend/src/i18n/pages/cockpit.ts b/web/strategy-switch-console/frontend/src/i18n/pages/cockpit.ts
new file mode 100644
index 00000000..8acfc945
--- /dev/null
+++ b/web/strategy-switch-console/frontend/src/i18n/pages/cockpit.ts
@@ -0,0 +1,425 @@
+/** Decision-cockpit copy. Internal identifiers stay in code, not in visible text. */
+export const zh: Record<string, string> = {
+  "cockpit.change_log.coverage": "包含持久化决定与应用记录，以及保留范围内的操作日志。",
+  "cockpit.runtime.title": "运行状态读回",
+  "cockpit.runtime.switch": "运行开关",
+  "cockpit.runtime.enabled": "已启用",
+  "cockpit.runtime.disabled": "已停用",
+  "cockpit.runtime.scheduler": "调度器",
+  "cockpit.runtime.scheduler.enabled": "已启用",
+  "cockpit.runtime.scheduler.paused": "已暂停",
+  "cockpit.runtime.scheduler.mixed": "状态不一致",
+  "cockpit.runtime.scheduler.missing": "未找到",
+  "cockpit.runtime.scheduler.unknown": "未知",
+  "cockpit.runtime.scheduler.not_applicable": "不适用",
+  "cockpit.runtime.boundary": "来自最近保存的部署观测；不代表交易授权、订单或成交。",
+
+  "cockpit.synthetic": "示例数据",
+  "cockpit.unknown": "未知",
+  "cockpit.not_set": "未设置",
+  "cockpit.as_of": "截至 {value}",
+
+  "cockpit.freshness.current": "最新",
+  "cockpit.freshness.stale": "已过期",
+  "cockpit.freshness.missing": "未提供",
+  "cockpit.freshness.unknown": "未知",
+  "cockpit.freshness.partial": "部分覆盖",
+  "cockpit.freshness.unavailable": "暂不可用",
+  "cockpit.freshness.read_failed": "读取失败",
+
+  "cockpit.expiry.none": "无有效期限制",
+  "cockpit.expiry.unknown": "有效期无法确认",
+  "cockpit.expiry.at": "有效期至 {value}",
+  "cockpit.expiry.open": "{value} 后失效",
+  "cockpit.expiry.under_hour": "{value} 后失效（不足一小时）",
+  "cockpit.expiry.under_five": "{value} 后失效（不足五分钟）",
+  "cockpit.expiry.expired": "已失效",
+  "cockpit.expiry.inaction": "不处理则该决定到期后自动失效，不会执行任何变更。",
+  "cockpit.expiry.boundary": "到期后需重新读取决定，不会延长有效期。",
+
+  "cockpit.decision.review": "查看决定",
+  "cockpit.decision.qualification": "资格摘要",
+  "cockpit.decision.target": "目标",
+  "cockpit.decision.release": "版本",
+  "cockpit.decision.tier": "风险档位",
+  "cockpit.decision.policy": "策略版本",
+  "cockpit.decision.operation": "申请状态",
+  "cockpit.decision.expires": "有效期",
+  "cockpit.decision.no_action": "不处理：到期后自动失效，不产生变更。",
+  "cockpit.decision.blocked": "暂不可审批",
+  "cockpit.decision.selected": "当前已选",
+  "cockpit.decision.state.pending": "待处理",
+  "cockpit.decision.state.approved": "已批准",
+  "cockpit.decision.state.rejected": "已拒绝",
+  "cockpit.decision.state.expired": "已过期",
+  "cockpit.decision.state.superseded": "已被取代",
+  "cockpit.decision.state.withdrawn": "已撤回",
+
+  "cockpit.blocker.expired": "决定已到期。",
+  "cockpit.blocker.expiry": "有效期无法确认。",
+  "cockpit.blocker.not_allowed": "服务端当前不允许审批。",
+  "cockpit.blocker.support_missing": "支持资料缺失。",
+  "cockpit.blocker.support": "支持资料不是最新或不完整。",
+  "cockpit.blocker.unqualified": "支持资料未达到资格要求。",
+  "cockpit.blocker.policy": "风险策略不可用。",
+  "cockpit.blocker.binding": "风险档位或策略版本未绑定。",
+  "cockpit.blocker.revision": "决定修订无法确认。",
+  "cockpit.blocker.state": "该决定已不在待处理状态。",
+  "cockpit.blocker.other": "当前不可审批。",
+
+  "cockpit.support.title": "支持资料",
+  "cockpit.support.qualified": "合格",
+  "cockpit.support.qualified_limited": "合格但有限制",
+  "cockpit.support.unqualified": "不合格",
+  "cockpit.support.unknown": "资格未知",
+  "cockpit.support.observed": "观察时间 {value}",
+  "cockpit.support.observed_label": "观察时间",
+  "cockpit.support.valid_until": "有效至 {value}",
+  "cockpit.support.valid_until_label": "有效至",
+  "cockpit.support.limitations": "限制",
+  "cockpit.support.no_limitations": "未报告限制。",
+  "cockpit.support.missing": "支持资料未提供，审批保持关闭。",
+  "cockpit.support.unavailable": "支持资料暂不可用。",
+  "cockpit.support.stale": "支持资料已过期，需重新读取。",
+  "cockpit.support.expired": "支持资料已失效，不能用于审批。",
+  "cockpit.support.provenance": "来源标识",
+
+  "cockpit.policy.title": "风险策略",
+  "cockpit.policy.selected": "已选偏好",
+  "cockpit.policy.approved": "已批准策略",
+  "cockpit.policy.effective": "生效策略",
+  "cockpit.policy.restriction": "临时限制",
+  "cockpit.policy.not_observed": "尚未观察到",
+  "cockpit.policy.mapping_unavailable": "策略映射不可用",
+  "cockpit.policy.read_failed": "风险策略读取失败。",
+  "cockpit.policy.revision": "修订 {value}",
+  "cockpit.policy.values": "计算出的限制",
+  "cockpit.policy.no_values": "暂无计算值。",
+  "cockpit.policy.source": "来源：{value}",
+  "cockpit.policy.source_label": "来源",
+  "cockpit.policy.unknown_value": "未知",
+  "cockpit.policy.current": "映射已是最新",
+  "cockpit.policy.restriction_none": "无",
+  "cockpit.policy.since": "自 {value}",
+  "cockpit.policy.effective_note": "已选偏好与生效策略分开显示；观察确认前不会视为已生效。",
+
+  "cockpit.tier.title": "风险档位",
+  "cockpit.tier.capital": "资本保全",
+  "cockpit.tier.balanced": "平衡复利",
+  "cockpit.tier.growth": "成长复利",
+  "cockpit.tier.capital_note": "偏好较低风险；适用限制由已批准策略计算。",
+  "cockpit.tier.balanced_note": "兼顾成长与约束；适用限制由已批准策略计算。",
+  "cockpit.tier.growth_note": "接受较高风险；适用限制由已批准策略计算。",
+  "cockpit.tier.unset": "尚未选择",
+  "cockpit.tier.unset_note": "保存后表示暂不选择风险档位。",
+  "cockpit.tier.save": "保存档位选择",
+  "cockpit.tier.dirty": "已修改但未保存",
+  "cockpit.tier.unchanged": "未修改",
+  "cockpit.tier.gate": "当前不允许保存档位选择。",
+  "cockpit.tier.scope": "范围 {value}",
+  "cockpit.tier.selection_revision": "选择修订 {value}",
+
+  "cockpit.lifecycle.title": "生命周期",
+  "cockpit.lifecycle.step": "产品阶段",
+  "cockpit.lifecycle.axis.research": "研究阶段",
+  "cockpit.lifecycle.axis.authorized": "授权上限",
+  "cockpit.lifecycle.axis.effective": "实际观察",
+  "cockpit.lifecycle.axis.operating": "运行状态",
+  "cockpit.lifecycle.axis.application": "应用状态",
+  "cockpit.lifecycle.stage.research": "研究",
+  "cockpit.lifecycle.stage.paper": "模拟",
+  "cockpit.lifecycle.stage.small_live": "小规模实盘",
+  "cockpit.lifecycle.stage.full_live": "完整实盘",
+  "cockpit.lifecycle.stage.unclassified": "阶段未分类",
+  "cockpit.lifecycle.operating.running": "运行中",
+  "cockpit.lifecycle.operating.paused": "已暂停",
+  "cockpit.lifecycle.operating.reduction_only": "仅减仓",
+  "cockpit.lifecycle.operating.reconcile_only": "仅对账",
+  "cockpit.lifecycle.operating.unknown": "未知",
+  "cockpit.lifecycle.application.pending": "待应用",
+  "cockpit.lifecycle.application.applying": "应用中",
+  "cockpit.lifecycle.application.applied": "平台已应用",
+  "cockpit.lifecycle.application.rejected": "应用被拒绝",
+  "cockpit.lifecycle.application.failed": "应用失败",
+  "cockpit.lifecycle.application.unknown": "未知",
+  "cockpit.lifecycle.note": "阶段、授权、实际观察和运行状态分别显示；界面不会自行提升阶段。",
+  "cockpit.lifecycle.not_provided": "未提供该目标的生命周期阶段信息。",
+  "cockpit.lifecycle.identity": "版本 {release} · 目标 {target}",
+
+  "cockpit.operation.title": "申请状态",
+  "cockpit.operation.decision": "决定",
+  "cockpit.operation.application": "应用",
+  "cockpit.operation.observation": "运行观察",
+  "cockpit.operation.recorded": "决定已记录",
+  "cockpit.operation.accepted": "已接受，等待平台处理",
+  "cockpit.operation.applying": "应用进行中",
+  "cockpit.operation.rejected": "应用被拒绝",
+  "cockpit.operation.unknown": "结果未知",
+  "cockpit.operation.failed": "应用失败",
+  "cockpit.operation.applied_unobserved": "平台已报告应用，等待运行确认",
+  "cockpit.operation.confirmed": "运行已确认",
+  "cockpit.operation.refresh": "刷新状态",
+  "cockpit.operation.id": "操作标识 {value}",
+  "cockpit.operation.request": "请求标识 {value}",
+  "cockpit.operation.revision": "绑定修订 {value}",
+  "cockpit.operation.not_ready": "操作状态接口暂不可用，无法追查这次申请。",
+  "cockpit.operation.read_failed": "操作状态读取失败。",
+  "cockpit.operation.no_retry": "结果未知时不会自动重试；请先刷新状态确认。",
+  "cockpit.operation.none": "暂无操作记录。",
+
+  "cockpit.pause.title": "运行控制",
+  "cockpit.pause.pause": "暂停",
+  "cockpit.pause.resume": "恢复",
+  "cockpit.pause.pending": "控制请求处理中",
+  "cockpit.pause.unavailable": "当前不支持该操作。",
+  "cockpit.pause.note": "暂停与恢复使用平台已有语义；应用成功不等于运行已确认。",
+  "cockpit.pause.running": "运行中",
+  "cockpit.pause.paused": "已暂停",
+  "cockpit.pause.unknown": "运行状态未知",
+
+  "cockpit.change_log.title": "活动记录",
+  "cockpit.change_log.empty": "暂无活动记录。",
+  "cockpit.change_log.unavailable": "活动记录暂不可用。",
+  "cockpit.change_log.load_failed": "活动记录读取失败。",
+  "cockpit.change_log.more": "加载更多",
+  "cockpit.change_log.actor": "操作者 {value}",
+  "cockpit.change_log.subject": "对象 {value}",
+  "cockpit.change_log.revision": "修订 {value}",
+  "cockpit.change_log.outcome": "结果 {value}",
+
+  "cockpit.digest.title": "每日摘要发送",
+  "cockpit.digest.accepted": "已接受投递",
+  "cockpit.digest.delivered": "供应商已接受投递",
+  "cockpit.digest.failed": "发送失败",
+  "cockpit.digest.unknown": "投递结果未知",
+  "cockpit.digest.unavailable": "暂无法确认投递",
+  "cockpit.digest.window": "业务日 {day} · {zone}",
+  "cockpit.digest.targets": "目标 {expected} · 已覆盖 {covered} · 不可用 {unavailable}",
+  "cockpit.digest.accepted_at": "接受时间 {value}",
+  "cockpit.digest.ack": "接收方确认",
+  "cockpit.digest.ack_unknown": "未知",
+  "cockpit.digest.ack_at": "确认时间 {value}",
+  "cockpit.digest.legacy": "仅显示历史回执，不代表当前生产投递。",
+  "cockpit.digest.no_data": "暂无摘要投递记录。",
+  "cockpit.digest.read_failed": "摘要投递状态读取失败。",
+  "cockpit.digest.note": "已接受不等于已送达；送达也不等于人工确认。",
+
+  "cockpit.strip.title": "待确认操作",
+  "cockpit.strip.unknown": "结果未知，需确认",
+  "cockpit.strip.view": "查看操作",
+  "cockpit.strip.ack": "已知悉，继续显示原因",
+  "cockpit.strip.last_read": "状态读取于 {value}",
+  "cockpit.strip.note": "页面切换不会隐藏该操作。",
+};
+export const en: Record<string, string> = {
+  "cockpit.change_log.coverage": "Includes durable decisions and application records, plus retained activity logs.",
+  "cockpit.runtime.title": "Runtime readback",
+  "cockpit.runtime.switch": "Runtime switch",
+  "cockpit.runtime.enabled": "Enabled",
+  "cockpit.runtime.disabled": "Disabled",
+  "cockpit.runtime.scheduler": "Scheduler",
+  "cockpit.runtime.scheduler.enabled": "Enabled",
+  "cockpit.runtime.scheduler.paused": "Paused",
+  "cockpit.runtime.scheduler.mixed": "Mixed",
+  "cockpit.runtime.scheduler.missing": "Missing",
+  "cockpit.runtime.scheduler.unknown": "Unknown",
+  "cockpit.runtime.scheduler.not_applicable": "Not applicable",
+  "cockpit.runtime.boundary": "Last stored deployment observation; it does not establish trading authority, orders or fills.",
+
+  "cockpit.synthetic": "Synthetic data",
+  "cockpit.unknown": "Unknown",
+  "cockpit.not_set": "Not set",
+  "cockpit.as_of": "As of {value}",
+
+  "cockpit.freshness.current": "Current",
+  "cockpit.freshness.stale": "Stale",
+  "cockpit.freshness.missing": "Not provided",
+  "cockpit.freshness.unknown": "Unknown",
+  "cockpit.freshness.partial": "Partial coverage",
+  "cockpit.freshness.unavailable": "Unavailable",
+  "cockpit.freshness.read_failed": "Read failed",
+
+  "cockpit.expiry.none": "No expiry",
+  "cockpit.expiry.unknown": "Expiry unconfirmed",
+  "cockpit.expiry.at": "Expires {value}",
+  "cockpit.expiry.open": "Expires in {value}",
+  "cockpit.expiry.under_hour": "Expires in {value} (under one hour)",
+  "cockpit.expiry.under_five": "Expires in {value} (under five minutes)",
+  "cockpit.expiry.expired": "Expired",
+  "cockpit.expiry.inaction": "If left open, this decision expires without changing anything.",
+  "cockpit.expiry.boundary": "At expiry the decision must be re-read; validity is never extended.",
+
+  "cockpit.decision.review": "Review decision",
+  "cockpit.decision.qualification": "Qualification",
+  "cockpit.decision.target": "Target",
+  "cockpit.decision.release": "Release",
+  "cockpit.decision.tier": "Risk tier",
+  "cockpit.decision.policy": "Policy",
+  "cockpit.decision.operation": "Application",
+  "cockpit.decision.expires": "Expiry",
+  "cockpit.decision.no_action": "If no action is taken: it expires with no change.",
+  "cockpit.decision.blocked": "Approval unavailable",
+  "cockpit.decision.selected": "Selected",
+  "cockpit.decision.state.pending": "Pending",
+  "cockpit.decision.state.approved": "Approved",
+  "cockpit.decision.state.rejected": "Rejected",
+  "cockpit.decision.state.expired": "Expired",
+  "cockpit.decision.state.superseded": "Superseded",
+  "cockpit.decision.state.withdrawn": "Withdrawn",
+
+  "cockpit.blocker.expired": "This decision has expired.",
+  "cockpit.blocker.expiry": "The validity window cannot be confirmed.",
+  "cockpit.blocker.not_allowed": "The server does not allow approval right now.",
+  "cockpit.blocker.support_missing": "Supporting data is missing.",
+  "cockpit.blocker.support": "Supporting data is not current or complete.",
+  "cockpit.blocker.unqualified": "Supporting data does not meet the qualification requirement.",
+  "cockpit.blocker.policy": "The risk policy is unavailable.",
+  "cockpit.blocker.binding": "The risk tier or policy revision is not bound.",
+  "cockpit.blocker.revision": "The decision revision cannot be confirmed.",
+  "cockpit.blocker.state": "This decision is no longer pending.",
+  "cockpit.blocker.other": "Approval is unavailable.",
+
+  "cockpit.support.title": "Supporting data",
+  "cockpit.support.qualified": "Qualified",
+  "cockpit.support.qualified_limited": "Qualified with limitations",
+  "cockpit.support.unqualified": "Unqualified",
+  "cockpit.support.unknown": "Qualification unknown",
+  "cockpit.support.observed": "Observed {value}",
+  "cockpit.support.observed_label": "Observed",
+  "cockpit.support.valid_until": "Valid until {value}",
+  "cockpit.support.valid_until_label": "Valid until",
+  "cockpit.support.limitations": "Limitations",
+  "cockpit.support.no_limitations": "No limitations reported.",
+  "cockpit.support.missing": "Supporting data is not provided, so approval stays closed.",
+  "cockpit.support.unavailable": "Supporting data is unavailable.",
+  "cockpit.support.stale": "Supporting data is stale; re-read it.",
+  "cockpit.support.expired": "Supporting data has expired and cannot support approval.",
+  "cockpit.support.provenance": "Source identifier",
+
+  "cockpit.policy.title": "Risk policy",
+  "cockpit.policy.selected": "Selected preference",
+  "cockpit.policy.approved": "Approved policy",
+  "cockpit.policy.effective": "Effective policy",
+  "cockpit.policy.restriction": "Temporary restriction",
+  "cockpit.policy.not_observed": "Not yet observed",
+  "cockpit.policy.mapping_unavailable": "Policy mapping unavailable",
+  "cockpit.policy.read_failed": "The risk policy could not be read.",
+  "cockpit.policy.revision": "Revision {value}",
+  "cockpit.policy.values": "Computed limits",
+  "cockpit.policy.no_values": "No computed values.",
+  "cockpit.policy.source": "Source: {value}",
+  "cockpit.policy.source_label": "Source",
+  "cockpit.policy.unknown_value": "Unknown",
+  "cockpit.policy.current": "Mapping current",
+  "cockpit.policy.restriction_none": "None",
+  "cockpit.policy.since": "Since {value}",
+  "cockpit.policy.effective_note": "Selected preference and effective policy stay separate; a selection is not effective before observation.",
+
+  "cockpit.tier.title": "Risk tier",
+  "cockpit.tier.capital": "Capital preservation",
+  "cockpit.tier.balanced": "Balanced compounding",
+  "cockpit.tier.growth": "Growth compounding",
+  "cockpit.tier.capital_note": "Prefer lower risk; the approved policy computes the applicable limits.",
+  "cockpit.tier.balanced_note": "Balance growth and restraint; the approved policy computes the applicable limits.",
+  "cockpit.tier.growth_note": "Accept higher risk; the approved policy computes the applicable limits.",
+  "cockpit.tier.unset": "No tier selected",
+  "cockpit.tier.unset_note": "Saving leaves no risk tier selected.",
+  "cockpit.tier.save": "Save tier selection",
+  "cockpit.tier.dirty": "Changed, not saved",
+  "cockpit.tier.unchanged": "Unchanged",
+  "cockpit.tier.gate": "Tier selection cannot be saved right now.",
+  "cockpit.tier.scope": "Scope {value}",
+  "cockpit.tier.selection_revision": "Selection revision {value}",
+
+  "cockpit.lifecycle.title": "Lifecycle",
+  "cockpit.lifecycle.step": "Product stage",
+  "cockpit.lifecycle.axis.research": "Research stage",
+  "cockpit.lifecycle.axis.authorized": "Authorized ceiling",
+  "cockpit.lifecycle.axis.effective": "Observed stage",
+  "cockpit.lifecycle.axis.operating": "Operating state",
+  "cockpit.lifecycle.axis.application": "Application state",
+  "cockpit.lifecycle.stage.research": "Research",
+  "cockpit.lifecycle.stage.paper": "Paper",
+  "cockpit.lifecycle.stage.small_live": "Small live",
+  "cockpit.lifecycle.stage.full_live": "Full live",
+  "cockpit.lifecycle.stage.unclassified": "Stage unclassified",
+  "cockpit.lifecycle.operating.running": "Running",
+  "cockpit.lifecycle.operating.paused": "Paused",
+  "cockpit.lifecycle.operating.reduction_only": "Reduction only",
+  "cockpit.lifecycle.operating.reconcile_only": "Reconcile only",
+  "cockpit.lifecycle.operating.unknown": "Unknown",
+  "cockpit.lifecycle.application.pending": "Pending",
+  "cockpit.lifecycle.application.applying": "Applying",
+  "cockpit.lifecycle.application.applied": "Applied by platform",
+  "cockpit.lifecycle.application.rejected": "Rejected",
+  "cockpit.lifecycle.application.failed": "Failed",
+  "cockpit.lifecycle.application.unknown": "Unknown",
+  "cockpit.lifecycle.note": "Stage, authority, observation and operating state stay separate; the UI never promotes a stage.",
+  "cockpit.lifecycle.not_provided": "Lifecycle stages were not provided for this target.",
+  "cockpit.lifecycle.identity": "Release {release} · target {target}",
+
+  "cockpit.operation.title": "Application status",
+  "cockpit.operation.decision": "Decision",
+  "cockpit.operation.application": "Application",
+  "cockpit.operation.observation": "Runtime observation",
+  "cockpit.operation.recorded": "Decision recorded",
+  "cockpit.operation.accepted": "Accepted; waiting for platform dispatch",
+  "cockpit.operation.applying": "Application in progress",
+  "cockpit.operation.rejected": "Application rejected",
+  "cockpit.operation.unknown": "Outcome unknown",
+  "cockpit.operation.failed": "Application failed",
+  "cockpit.operation.applied_unobserved": "Platform reported applied; runtime confirmation pending",
+  "cockpit.operation.confirmed": "Runtime confirmed",
+  "cockpit.operation.refresh": "Refresh status",
+  "cockpit.operation.id": "Operation {value}",
+  "cockpit.operation.request": "Request {value}",
+  "cockpit.operation.revision": "Bound revision {value}",
+  "cockpit.operation.not_ready": "The operation-status endpoint is not available, so this application cannot be traced.",
+  "cockpit.operation.read_failed": "Operation status could not be read.",
+  "cockpit.operation.no_retry": "An unknown outcome is never retried automatically; refresh status first.",
+  "cockpit.operation.none": "No operation recorded.",
+
+  "cockpit.pause.title": "Runtime control",
+  "cockpit.pause.pause": "Pause",
+  "cockpit.pause.resume": "Resume",
+  "cockpit.pause.pending": "Control request pending",
+  "cockpit.pause.unavailable": "This action is not supported right now.",
+  "cockpit.pause.note": "Pause and resume use existing platform semantics; application success is not runtime confirmation.",
+  "cockpit.pause.running": "Running",
+  "cockpit.pause.paused": "Paused",
+  "cockpit.pause.unknown": "Runtime state unknown",
+
+  "cockpit.change_log.title": "Activity history",
+  "cockpit.change_log.empty": "No activity recorded.",
+  "cockpit.change_log.unavailable": "Activity history is unavailable.",
+  "cockpit.change_log.load_failed": "Activity history could not be read.",
+  "cockpit.change_log.more": "Load more",
+  "cockpit.change_log.actor": "Actor {value}",
+  "cockpit.change_log.subject": "Subject {value}",
+  "cockpit.change_log.revision": "Revision {value}",
+  "cockpit.change_log.outcome": "Outcome {value}",
+
+  "cockpit.digest.title": "Daily digest delivery",
+  "cockpit.digest.accepted": "Accepted for delivery",
+  "cockpit.digest.delivered": "Provider accepted delivery",
+  "cockpit.digest.failed": "Delivery failed",
+  "cockpit.digest.unknown": "Delivery outcome unknown",
+  "cockpit.digest.unavailable": "Delivery status unavailable",
+  "cockpit.digest.window": "Business day {day} · {zone}",
+  "cockpit.digest.targets": "Targets {expected} · covered {covered} · unavailable {unavailable}",
+  "cockpit.digest.accepted_at": "Accepted {value}",
+  "cockpit.digest.ack": "Recipient acknowledgment",
+  "cockpit.digest.ack_unknown": "Unknown",
+  "cockpit.digest.ack_at": "Acknowledged {value}",
+  "cockpit.digest.legacy": "Only legacy receipts are shown; they do not represent current production delivery.",
+  "cockpit.digest.no_data": "No digest delivery record.",
+  "cockpit.digest.read_failed": "Digest delivery status could not be read.",
+  "cockpit.digest.note": "Accepted is not delivered; delivery is not human acknowledgment.",
+
+  "cockpit.strip.title": "Pending operation",
+  "cockpit.strip.unknown": "Outcome unknown; confirmation required",
+  "cockpit.strip.view": "View operation",
+  "cockpit.strip.ack": "Acknowledge (stays visible)",
+  "cockpit.strip.last_read": "Status read {value}",
+  "cockpit.strip.note": "Navigation does not hide this operation.",
+};
diff --git a/web/strategy-switch-console/frontend/src/i18n/pages/decisions.ts b/web/strategy-switch-console/frontend/src/i18n/pages/decisions.ts
index d55854df..202aa9c9 100644
--- a/web/strategy-switch-console/frontend/src/i18n/pages/decisions.ts
+++ b/web/strategy-switch-console/frontend/src/i18n/pages/decisions.ts
@@ -88,6 +88,8 @@ export const zh: Record<string, string> = {
   "decisions.source.credential": "凭证",
   "decisions.technical_details": "参数详情",
   "decisions.account_unbound": "未绑定账户",
+  "decisions.policy_unbound": "该晋级方案尚未绑定风险档位与策略版本，暂时不能提交。",
+  "decisions.outcome_unknown": "请求结果无法确认；为避免重复提交，请先刷新并确认当前状态。",
 
   "initial_enrollment.title": "首次接入事实",
   "initial_enrollment.source_time": "来源时间",
@@ -246,6 +248,8 @@ export const en: Record<string, string> = {
   "decisions.source.credential": "Credentials",
   "decisions.technical_details": "Parameter details",
   "decisions.account_unbound": "No linked account",
+  "decisions.policy_unbound": "This promotion has no bound risk tier and policy revision, so it cannot be submitted yet.",
+  "decisions.outcome_unknown": "The request outcome cannot be confirmed. Refresh and confirm the current state before trying again.",
 
   "initial_enrollment.title": "First enrollment facts",
   "initial_enrollment.source_time": "Source time",
diff --git a/web/strategy-switch-console/frontend/src/i18n/pages/overview.ts b/web/strategy-switch-console/frontend/src/i18n/pages/overview.ts
index c0b9ef18..ed38ca5b 100644
--- a/web/strategy-switch-console/frontend/src/i18n/pages/overview.ts
+++ b/web/strategy-switch-console/frontend/src/i18n/pages/overview.ts
@@ -11,6 +11,16 @@ export const zh: Record<string, string> = {
   "overview.calendar_date": "纽约日期 {value}",
   "overview.no_records_for_day": "当前未观测到该业务日记录",
   "overview.non_trading_day_short": "非交易日",
+  "overview.decision_queue": "决定队列",
+  "overview.needs_review": "待你查看的决定：{count} 个",
+  "overview.queue_complete_empty": "没有需要处理的待办决定。",
+  "overview.queue_incomplete": "决定来源未完整读取，因此不显示计数。",
+  "overview.queue_read_failed": "决定队列读取失败。",
+  "overview.queue_blocked": "受阻：{count} 个",
+  "overview.queue_high_priority": "高优先级：{count} 个",
+  "overview.queue_more": "查看全部决定",
+  "overview.expires_plain": "有效期至 {value}",
+  "overview.latest_activity": "最近确认的活动",
 };
 export const en: Record<string, string> = {
   "overview.asset_summary": "Asset summary",
@@ -24,4 +34,14 @@ export const en: Record<string, string> = {
   "overview.calendar_date": "New York date {value}",
   "overview.no_records_for_day": "No records observed for this business day",
   "overview.non_trading_day_short": "Non-trading day",
+  "overview.decision_queue": "Decision queue",
+  "overview.needs_review": "Decisions awaiting your review: {count}",
+  "overview.queue_complete_empty": "No decisions need action.",
+  "overview.queue_incomplete": "Decision coverage is incomplete, so counts are hidden.",
+  "overview.queue_read_failed": "The decision queue could not be read.",
+  "overview.queue_blocked": "Blocked: {count}",
+  "overview.queue_high_priority": "High priority: {count}",
+  "overview.queue_more": "View all decisions",
+  "overview.expires_plain": "Expires {value}",
+  "overview.latest_activity": "Latest verified activity",
 };
diff --git a/web/strategy-switch-console/frontend/src/i18n/zh-CN.ts b/web/strategy-switch-console/frontend/src/i18n/zh-CN.ts
index 1e312f8f..d46014b7 100644
--- a/web/strategy-switch-console/frontend/src/i18n/zh-CN.ts
+++ b/web/strategy-switch-console/frontend/src/i18n/zh-CN.ts
@@ -5,14 +5,15 @@ export const zhCN = {
   "shell.update_available": "新版已就绪，刷新后使用。",
   "shell.reload": "刷新页面",
   "app.name": "QuantStrategyLab",
+  "shell.cockpit": "决策驾驶舱",
 
   "nav.main": "主导航",
   "nav.overview": "总览",
   "nav.performance": "收益分析",
-  "nav.decisions": "待办",
+  "nav.decisions": "决策",
   "nav.accounts": "账户",
   "nav.strategies": "策略",
-  "nav.health": "运行状态",
+  "nav.health": "健康",
   "nav.more": "更多",
   "nav.todo_unavailable": "待办数量不可读",
 
diff --git a/web/strategy-switch-console/frontend/src/pages/accounts/AccountDetail.tsx b/web/strategy-switch-console/frontend/src/pages/accounts/AccountDetail.tsx
index 10c2ce9b..f3c31e27 100644
--- a/web/strategy-switch-console/frontend/src/pages/accounts/AccountDetail.tsx
+++ b/web/strategy-switch-console/frontend/src/pages/accounts/AccountDetail.tsx
@@ -2,6 +2,9 @@ import { useDisplayNames } from "../../lib/useDisplayNames";
 import { useEffect, useRef, useState } from "react";
 import type { TodayRunSummary } from "../../api/contracts";
 import { loadSettingsDiff } from "../../api/endpoints";
+import { loadPolicyBinding } from "../../api/cockpit";
+import { RuntimeReadbackPanel } from "../../components/RuntimeReadbackPanel";
+import { EffectivePolicyPanel } from "../../components/cockpit";
 import { factEnvironment, factForAccount, userDeclarationOf } from "../../lib/accountFacts";
 import { useNavigate } from "../../app/context";
 import { setNavigationGuard } from "../../app/router";
@@ -31,6 +34,17 @@ function normalizeTab(tab: string | null): TabId {
   return (TAB_IDS as readonly string[]).includes(tab || "") ? (tab as TabId) : "overview";
 }
 
+/** Selected, approved and effective policy stay separate; a missing read is not inferred. */
+function PolicyReadback({ platform, accountKey }: { platform: string; accountKey: string }) {
+  const scope = `${platform}:${accountKey}`;
+  const read = useApi(() => loadPolicyBinding(scope, false), [scope]);
+  const status = read.phase === "loading" ? "loading" as const
+    : read.phase === "error" ? "error" as const
+      : read.data.status === "not_ready" ? "not_ready" as const : "ready" as const;
+  const binding = read.phase === "ready" && read.data.status === "ready" ? read.data.data : null;
+  return <EffectivePolicyPanel binding={binding} status={status} onRetry={read.reload} />;
+}
+
 export function AccountDetail({
   account,
   tab,
@@ -175,6 +189,8 @@ export function AccountDetail({
           </section>
         )}
         {active === "overview" && <RiskPreference platform={account.platform} accountKey={account.account_alias} />}
+        {active === "overview" && <RuntimeReadbackPanel key={`${account.platform}:${account.account_alias}`} scope={`${account.platform}:${account.account_alias}`} />}
+        {active === "overview" && <PolicyReadback platform={account.platform} accountKey={account.account_alias} />}
         {active === "overview" && <AccountDeclaration platform={account.platform} accountKey={account.account_alias} onSaved={onDeclarationSaved} />}
         {active === "strategy" && (
           <StrategyTab
diff --git a/web/strategy-switch-console/frontend/src/pages/accounts/RiskPreference.tsx b/web/strategy-switch-console/frontend/src/pages/accounts/RiskPreference.tsx
index dbf18722..e8f5d632 100644
--- a/web/strategy-switch-console/frontend/src/pages/accounts/RiskPreference.tsx
+++ b/web/strategy-switch-console/frontend/src/pages/accounts/RiskPreference.tsx
@@ -1,8 +1,9 @@
-import { useEffect, useId, useRef, useState } from "react";
+import { useEffect, useRef, useState } from "react";
 import { postJson } from "../../api/client";
 import { loadAccountSettings } from "../../api/endpoints";
 import { createAccountSettingsController, refreshAccountSettingsReadback, sameIdentity } from "../../accountSettingsState";
 import { Skeleton } from "../../components/primitives";
+import { RiskTierSelector } from "../../components/cockpit";
 import { useT } from "../../i18n";
 
 /**
@@ -13,15 +14,11 @@ import { useT } from "../../i18n";
  */
 const unresolvedSaves: Parameters<typeof createAccountSettingsController>[0] = new Map();
 
-const PREFERENCES = ["CAPITAL_PRESERVATION", "BALANCED_COMPOUNDING", "GROWTH_COMPOUNDING"] as const;
-
-
 type ReadError = "" | "denied" | "mismatch" | "unavailable";
 type Verify = "" | "saved" | "mismatch" | "unverified" | "conflict";
 
 export function RiskPreference({ platform, accountKey }: { platform: string; accountKey: string }) {
   const t = useT();
-  const selectId = useId();
   const controller = useRef(createAccountSettingsController(unresolvedSaves)).current;
   const [, setTick] = useState(0);
   const [readAttempt, setReadAttempt] = useState(0);
@@ -132,12 +129,7 @@ export function RiskPreference({ platform, accountKey }: { platform: string; acc
 
   const gateOpen = settings?.operations?.save_risk_preference === true;
   const currentValue = typeof settings?.risk?.preference === "string" ? settings?.risk?.preference : "";
-  const label = (value: string) =>
-    value === "CAPITAL_PRESERVATION" ? t("risk.capital")
-      : value === "BALANCED_COMPOUNDING" ? t("risk.balanced")
-        : value === "GROWTH_COMPOUNDING" ? t("risk.growth")
-          : t("risk.other");
-  const unrecognized = view.preference !== "" && !(PREFERENCES as readonly string[]).includes(view.preference);
+  const unrecognized = view.preference !== "" && !["CAPITAL_PRESERVATION", "BALANCED_COMPOUNDING", "GROWTH_COMPOUNDING"].includes(view.preference);
   const dirty = controller.riskDirty();
   const revisionReady = Boolean(settings?.identity && typeof settings.identity === "object" && Number.isSafeInteger(settings?.risk?.revision));
   const editable = readState === "ready" && gateOpen && !view.saving && verify !== "unverified" && verify !== "mismatch";
@@ -178,33 +170,23 @@ export function RiskPreference({ platform, accountKey }: { platform: string; acc
       {view.saving && <p className="accounts-inline-note" role="status">{t("risk.saving")}</p>}
       {readState !== "loading" && settings && (
         <>
-          <div className="accounts-field-rows">
-            <div className="accounts-field-row">
-              <label className="accounts-field-label" htmlFor={selectId}>{t("risk.field")}</label>
-              <div className="accounts-field-body">
-                <div className="accounts-field-control">
-                  <select
-                    id={selectId}
-                    className="input"
-                    value={view.preference}
-                    disabled={!editable}
-                    onChange={event => {
-                      setVerify("");
-                      controller.edit({ preference: event.target.value });
-                      sync();
-                    }}
-                  >
-                    <option value="">{t("risk.unset")}</option>
-                    {PREFERENCES.map(value => <option key={value} value={value}>{label(value)}</option>)}
-                    {unrecognized && <option value={view.preference}>{t("risk.other")}</option>}
-                  </select>
-                </div>
-                <span className="accounts-field-current">{t("risk.savedValue")} · {currentValue === "" ? t("risk.unset") : label(currentValue)}</span>
-              </div>
-            </div>
-          </div>
+          <RiskTierSelector
+            scope={`${platform}:${accountKey}`}
+            value={view.preference}
+            savedValue={currentValue}
+            selectionRevision={typeof settings?.risk?.revision === "number" ? settings.risk.revision : null}
+            mappingAvailable={!unrecognized}
+            disabled={!editable}
+            saving={Boolean(view.saving)}
+            dirty={dirty}
+            onChange={tier => {
+              setVerify("");
+              controller.edit({ preference: tier });
+              sync();
+            }}
+            onSave={() => { if (canSave) void save(); }}
+          />
           <div className="accounts-toolbar">
-            <button type="button" className="button button-primary" disabled={!canSave} onClick={() => void save()}>{t("risk.save")}</button>
             {dirty && (
               <button type="button" className="button button-secondary" onClick={() => { controller.revertRisk(); setVerify(""); sync(); }}>{t("risk.discard")}</button>
             )}
diff --git a/web/strategy-switch-console/frontend/src/pages/decisions/DecisionsPage.tsx b/web/strategy-switch-console/frontend/src/pages/decisions/DecisionsPage.tsx
index 6fe8b015..710ffb4b 100644
--- a/web/strategy-switch-console/frontend/src/pages/decisions/DecisionsPage.tsx
+++ b/web/strategy-switch-console/frontend/src/pages/decisions/DecisionsPage.tsx
@@ -31,6 +31,9 @@ import { DiffTable } from "../../components/DiffTable";
 import { Timeline } from "../../components/Timeline";
 import { ConfirmationDialog, useConfirmation } from "../../components/Dialog";
 import { useToast } from "../../components/Toast";
+import { expiryState, isRiskTier, loadOperation } from "../../api/cockpit";
+import type { EvidenceSummary as EvidenceSummaryData } from "../../api/cockpit";
+import { ApplicationStatus, EvidenceSummary, ExpiryIndicator, tierLabel } from "../../components/cockpit";
 import { resolveAccountChoice } from "./helpers";
 import { sourceConsequenceKey, sourceLabelKey } from "./sources";
 import { InitialEnrollmentFacts } from "./InitialEnrollmentFacts";
@@ -49,6 +52,15 @@ interface AccountChoice {
   mode: string;
 }
 
+/** Fields the expanded inbox may add; absent fields keep the legacy behaviour. */
+type ExpandedInboxItem = InboxItem & {
+  revision?: number;
+  allowed_actions?: string[];
+  server_time?: string | null;
+  operation_id?: string | null;
+  evidence?: EvidenceSummaryData | null;
+};
+
 const CATEGORY_TABS: Category[] = [
   "reconciliation_recovery",
   "strategy_promotion",
@@ -126,6 +138,35 @@ function accountOptionsOf(application: Record<string, any> | null | undefined, p
     }));
 }
 
+/**
+ * The promotion request must carry the tier and policy revision the server
+ * bound to this ticket. A missing binding blocks the request; the client never
+ * substitutes a default tier.
+ */
+function promotionRiskBinding(
+  application: Record<string, any> | null,
+  ticket: Record<string, any>,
+): { risk_profile: string; policy_revision: string | null } | null {
+  const sources = [
+    application?.risk_policy_binding,
+    application?.confirmation,
+    ticket.risk_policy_binding,
+    ticket,
+  ];
+  for (const source of sources) {
+    if (!source || typeof source !== "object") continue;
+    const tier = typeof source.selected_tier === "string" ? source.selected_tier
+      : typeof source.risk_profile === "string" ? source.risk_profile : null;
+    if (!tier || !isRiskTier(tier)) continue;
+    const revision = typeof source.policy_revision === "string" && source.policy_revision
+      ? source.policy_revision
+      : typeof source.approved_policy_revision === "string" && source.approved_policy_revision
+        ? source.approved_policy_revision : null;
+    return { risk_profile: tier, policy_revision: revision };
+  }
+  return null;
+}
+
 function freshnessKey(status: string | null | undefined): string {
   if (status === "fresh") return "state.fresh";
   if (status === "stale") return "state.stale";
@@ -227,6 +268,25 @@ function HistoryPanel({ epoch, category }: { epoch: number; category: CategoryFi
   );
 }
 
+/* ---------- operation trace (only when the queue supplies an operation id) ---------- */
+
+function DecisionOperation({ operationId }: { operationId: string }) {
+  const t = useT();
+  const [epoch, setEpoch] = useState(0);
+  const read = useApi(() => loadOperation(operationId, false), [operationId, epoch]);
+  const status = read.phase === "loading" ? "loading" as const
+    : read.phase === "error" ? "error" as const
+      : read.data.status === "not_ready" ? "not_ready" as const : "ready" as const;
+  const operation = read.phase === "ready" && read.data.status === "ready" ? read.data.data : null;
+  const synthetic = read.phase === "ready" && read.data.status === "ready" && read.data.synthetic;
+  return (
+    <div className="cockpit-operation">
+      {synthetic && <Badge tone="accent">{t("cockpit.synthetic")}</Badge>}
+      <ApplicationStatus operation={operation} status={status} onRefresh={() => setEpoch(value => value + 1)} />
+    </div>
+  );
+}
+
 /* ---------- page ---------- */
 
 export default function DecisionsPage() {
@@ -247,6 +307,10 @@ export default function DecisionsPage() {
   const inbox = useApi(() => loadInbox(epoch > 0), [epoch]);
   const session = useApi(() => loadSession(), []);
   const admin = session.phase === "ready" && session.data.admin === true;
+  // Expiry interpolation starts when this decision bundle arrives, never at an
+  // arbitrary later render, so the browser cannot extend server validity.
+  const inboxData = inbox.phase === "ready" ? inbox.data : null;
+  const receivedAt = useMemo(() => new Date().toISOString(), [inboxData]);
 
   const humanDecisions = useRef(createHumanDecisionController());
   const applyLocks = useRef(createRequestLock());
@@ -293,12 +357,29 @@ export default function DecisionsPage() {
     if (!Array.isArray(applications)) return null;
     return applications.find(entry => entry?.ticket_id === subjectIdOf(selected)) || null;
   }, [selected, promotions]);
+  const selectedTicket = useMemo(() => {
+    if (!selected || promotions.phase !== "ready" || !promotions.data) return null;
+    const tickets = (promotions.data as Record<string, any>).tickets;
+    if (!Array.isArray(tickets)) return null;
+    return tickets.find(entry => entry?.ticket_id === subjectIdOf(selected)) || null;
+  }, [selected, promotions]);
+  const selectedRiskBinding = useMemo(
+    () => (selectedTicket ? promotionRiskBinding(selectedApplication, selectedTicket) : null),
+    [selectedApplication, selectedTicket],
+  );
 
   const notice = (kind: "info" | "success" | "error", key: string) => toast({ kind, text: t(key) });
 
   const intentError = (error: unknown) => {
     if (error instanceof AccessError) return;
-    notice("error", error instanceof HttpError && error.status === 409 ? "error.conflict" : "error.generic");
+    if ((error as { message?: string })?.message === "session_invalidated") return;
+    if (error instanceof HttpError) {
+      notice("error", error.status === 409 ? "error.conflict" : "error.generic");
+    } else {
+      // A transport failure cannot prove the write did not commit. Keep the
+      // original request identity by refusing to resubmit until a reread.
+      notice("error", "decisions.outcome_unknown");
+    }
     // A failed response cannot prove the write did not commit; re-read the inbox.
     refresh();
   };
@@ -312,6 +393,7 @@ export default function DecisionsPage() {
     let body: Record<string, unknown>;
     let path: string;
     let targetAccount: AccountChoice | null = null;
+    let riskBinding: { risk_profile: string; policy_revision: string | null } | null = null;
     try {
       if (kind === "owner") {
         const payload = await getJson<Record<string, any>>("/api/owner-decisions");
@@ -370,12 +452,27 @@ export default function DecisionsPage() {
           }
           account = resolved;
           targetAccount = resolved;
+          if (item.category === "strategy_promotion") {
+            riskBinding = promotionRiskBinding(application, ticket);
+            if (!riskBinding) {
+              // Without the server-bound tier and policy revision there is
+              // nothing safe to submit; the client never invents a default.
+              notice("error", "decisions.policy_unbound");
+              return;
+            }
+          }
         }
         source = ticket;
         body = {
           ticket_id: ticket.ticket_id,
           decision: action === "adopt" ? "accept" : "reject",
-          confirmation: account ? { target_platform: account.platform, execution_mode: account.mode, risk_profile: "CAPITAL_PRESERVATION" } : null,
+          confirmation: account && riskBinding ? {
+            target_platform: account.platform,
+            execution_mode: account.mode,
+            risk_profile: riskBinding.risk_profile,
+            ...(riskBinding.policy_revision ? { policy_revision: riskBinding.policy_revision } : {}),
+          } : null,
+          ...(riskBinding?.policy_revision ? { expected_policy_revision: riskBinding.policy_revision } : {}),
           ...(account ? { selected_account: { platform: account.platform, key: account.key } } : {}),
           expected_proposed_params: ticket.proposed_params || {},
           expected_strategy_profile: ticket.strategy_profile,
@@ -410,8 +507,16 @@ export default function DecisionsPage() {
       refresh();
       return;
     }
-    if (!await confirmDecision(item, action, false, targetAccount)) return;
-    if (sessionEpoch !== humanDecisions.current.epoch() || isExpired(item)) return;
+    if (!await confirmDecision(item, action, false, targetAccount, riskBinding)) return;
+    if (sessionEpoch !== humanDecisions.current.epoch()) return;
+    const expanded = item as ExpandedInboxItem;
+    if (expanded.server_time && item.expires_at
+      && expiryState(item.expires_at, expanded.server_time, receivedAt, Date.now()).state === "expired") {
+      notice("info", "decisions.intent_not_pending");
+      refresh();
+      return;
+    }
+    if (isExpired(item)) return;
     const op = humanDecisions.current.start(expected);
     if (!op) return; // same decision already in flight
     const busyKey = `intent:${item.id}`;
@@ -440,6 +545,14 @@ export default function DecisionsPage() {
     const subject = subjectIdOf(item);
     const lockKey = `apply:${subject}`;
     if (!applyLocks.current.acquire(lockKey)) return;
+    const expanded = item as ExpandedInboxItem;
+    if (expanded.server_time && item.expires_at
+      && expiryState(item.expires_at, expanded.server_time, receivedAt, Date.now()).state === "expired") {
+      applyLocks.current.release(lockKey);
+      notice("info", "decisions.intent_not_pending");
+      refresh();
+      return;
+    }
     setBusy(current => ({ ...current, [lockKey]: true }));
     let submitted = false;
     try {
@@ -468,18 +581,41 @@ export default function DecisionsPage() {
     }
   };
 
-  const confirmDecision = (item: InboxItem, action: Action, paperAdopt: boolean, account: AccountChoice | null) => confirm({
-    title: t(action === "adopt" ? "decisions.confirm_adopt_title" : "decisions.confirm_decline_title"),
-    target: account ? `${itemTitle(item, t)} · ${account.label} (${account.platform} / ${account.key} / ${account.mode})` : itemTitle(item, t),
-    summary: t(paperAdopt ? "decisions.apply_note" : "decisions.confirm_body"),
-    body: <DiffTable rows={item.diff.map(row => ({ ...row, label: t(row.label_key) === row.label_key ? row.field : t(row.label_key), affectsLive: row.affects_live }))} />,
-    consequence: t("decisions.intent_note"),
-    tone: action === "adopt" ? "normal" : "danger",
-    confirmLabel: t(action === "adopt" ? "decisions.confirm_adopt_label" : "decisions.confirm_decline_label"),
-  });
+  const confirmDecision = (
+    item: InboxItem,
+    action: Action,
+    paperAdopt: boolean,
+    account: AccountChoice | null,
+    risk: { risk_profile: string; policy_revision: string | null } | null,
+  ) => {
+    const expanded = item as ExpandedInboxItem;
+    // The confirmation names the exact server-bound tier and policy revision
+    // from the same fresh read that recordIntent submits.
+    const riskText = risk
+      ? ` · ${tierLabel(risk.risk_profile, t)}${risk.policy_revision ? ` · ${t("cockpit.policy.revision", { value: risk.policy_revision })}` : ""}`
+      : "";
+    const target = account
+      ? `${itemTitle(item, t)} · ${account.label} (${account.platform} / ${account.key} / ${account.mode})${riskText}`
+      : `${itemTitle(item, t)}${riskText}`;
+    return confirm({
+      title: t(action === "adopt" ? "decisions.confirm_adopt_title" : "decisions.confirm_decline_title"),
+      target,
+      summary: t(paperAdopt ? "decisions.apply_note" : "decisions.confirm_body"),
+      body: <DiffTable rows={item.diff.map(row => ({ ...row, label: t(row.label_key) === row.label_key ? row.field : t(row.label_key), affectsLive: row.affects_live }))} />,
+      consequence: t("decisions.intent_note"),
+      tone: action === "adopt" ? "normal" : "danger",
+      confirmLabel: t(action === "adopt" ? "decisions.confirm_adopt_label" : "decisions.confirm_decline_label"),
+      expiresAt: expanded.server_time ? item.expires_at : null,
+      serverTime: expanded.server_time ?? null,
+      receivedAt,
+      onExpiry: refresh,
+    });
+  };
 
   const onDecide = async (item: InboxItem, action: Action) => {
     if (!admin || item.status !== "pending" || isExpired(item)) return;
+    const allowed = (item as ExpandedInboxItem).allowed_actions;
+    if (allowed && !allowed.includes(action === "adopt" ? "approve" : "reject")) return;
     const lockKey = `confirm:${item.id}`;
     if (!applyLocks.current.acquire(lockKey)) return;
     const busyKey = `intent:${item.id}`;
@@ -493,7 +629,7 @@ export default function DecisionsPage() {
         return;
       }
       if (paperAdopt && choice) {
-        if (await confirmDecision(item, action, true, choice)) await applyPaper(item, choice.id);
+        if (await confirmDecision(item, action, true, choice, null)) await applyPaper(item, choice.id);
       } else {
         await recordIntent(item, action, choice?.id ?? null);
       }
@@ -539,6 +675,21 @@ export default function DecisionsPage() {
     const strategyRow = item.diff.find(row => row.field === "strategy");
     const reviewedStrategy = item.presentation?.strategy_profile
       || (strategyRow && typeof strategyRow.after === "string" ? strategyRow.after : null);
+    const expanded = item as ExpandedInboxItem;
+    const allowed = expanded.allowed_actions;
+    const approveAllowed = !allowed || allowed.includes("approve");
+    const rejectAllowed = !allowed || allowed.includes("reject");
+    const support: EvidenceSummaryData | null = expanded.evidence ?? (item.evidence_freshness ? {
+      evidence_id: null,
+      label_key: null,
+      observed_at: item.evidence_freshness.as_of,
+      valid_until: null,
+      state: item.evidence_freshness.status === "stale" ? "stale"
+        : item.evidence_freshness.status === "fresh" || item.evidence_freshness.status === "ready" ? "current"
+          : "unavailable",
+      qualification: "unknown",
+      limitations: [],
+    } : null);
 
     let actions: ReactNode = null;
     if (pending && admin && !(initialEnrollmentMode && enrollmentBlocked)) {
@@ -580,7 +731,7 @@ export default function DecisionsPage() {
                     <button
                       type="button"
                       className="button button-primary"
-                      disabled={anyBusy || !ready || applyLocks.current.isLocked(`apply:${subjectIdOf(item)}`)}
+                      disabled={anyBusy || !ready || !approveAllowed || applyLocks.current.isLocked(`apply:${subjectIdOf(item)}`)}
                       onClick={() => void onDecide(item, "adopt")}
                     >
                       {busyApply ? t("decisions.submitting") : t("decisions.adopt_intent")}
@@ -589,7 +740,7 @@ export default function DecisionsPage() {
                   <button
                     type="button"
                     className="button button-secondary"
-                    disabled={anyBusy}
+                    disabled={anyBusy || !rejectAllowed}
                     onClick={() => void onDecide(item, "decline")}
                   >
                     {busyIntent ? t("decisions.submitting") : t("decisions.decline_intent")}
@@ -603,6 +754,7 @@ export default function DecisionsPage() {
       } else {
         const options = item.category === "strategy_promotion" ? accountOptionsOf(selectedApplication, false) : [];
         const chosen = resolveAccountChoice(options, accountChoice[item.id])?.id ?? "";
+        const promotionUnbound = item.category === "strategy_promotion" && !selectedRiskBinding;
         actions = (
           <>
             {options.length > 1 && (
@@ -623,7 +775,7 @@ export default function DecisionsPage() {
               <button
                 type="button"
                 className="button button-primary"
-                disabled={anyBusy || (item.category === "strategy_promotion" && !chosen)}
+                disabled={anyBusy || !approveAllowed || (item.category === "strategy_promotion" && (!chosen || promotionUnbound))}
                 onClick={() => void onDecide(item, "adopt")}
               >
                 {busyIntent ? t("decisions.submitting") : t("decisions.adopt_intent")}
@@ -631,11 +783,13 @@ export default function DecisionsPage() {
               <button
                 type="button"
                 className="button button-secondary"
-                disabled={anyBusy}
+                disabled={anyBusy || !rejectAllowed}
                 onClick={() => void onDecide(item, "decline")}
               >
                 {busyIntent ? t("decisions.submitting") : t("decisions.decline_intent")}
               </button>
+              {!approveAllowed && <p className="decision-note">{t("cockpit.blocker.not_allowed")}</p>}
+              {promotionUnbound && <p className="decision-note">{t("decisions.policy_unbound")}</p>}
               <p className="decision-note">{t("decisions.intent_note")}</p>
             </div>
           </>
@@ -687,6 +841,16 @@ export default function DecisionsPage() {
             <DiffTable rows={diffRows} />
           </>
         )}
+        {expanded.server_time && item.expires_at && (
+          <ExpiryIndicator
+            expiresAt={item.expires_at}
+            serverTime={expanded.server_time}
+            receivedAt={receivedAt}
+            onBoundary={() => { setSelectedId(null); refresh(); }}
+          />
+        )}
+        {support && <EvidenceSummary evidence={support} />}
+        {expanded.operation_id && <DecisionOperation operationId={expanded.operation_id} />}
         {initialEnrollmentMode && (
           <InitialEnrollmentFacts
             account={item.account_alias ? names.account(item.account_alias, item.platform) : null}
diff --git a/web/strategy-switch-console/frontend/src/pages/health/HealthPage.tsx b/web/strategy-switch-console/frontend/src/pages/health/HealthPage.tsx
index 339afb26..de0118e1 100644
--- a/web/strategy-switch-console/frontend/src/pages/health/HealthPage.tsx
+++ b/web/strategy-switch-console/frontend/src/pages/health/HealthPage.tsx
@@ -4,10 +4,13 @@ import type { TodayRunSummary } from "../../api/contracts";
 import {
   loadAccounts,
   loadCredentialMaintenance,
+  loadNotificationLog,
   loadTodayRuns,
   loadRuntimeDailyBindings,
   type CredentialMaintenance,
 } from "../../api/endpoints";
+import { loadDigestStatus } from "../../api/cockpit";
+import { AuditHistory } from "../../components/AuditHistory";
 import { useLanguage, useT } from "../../i18n";
 import { useApi, type AsyncState } from "../../lib/hooks";
 import { formatDateTime } from "../../lib/format";
@@ -21,6 +24,7 @@ import {
   Skeleton,
   StatusBadge,
 } from "../../components/primitives";
+import { DigestStatus } from "../../components/cockpit";
 import { RunGrid } from "./RunGrid";
 import { runActivityCounts, runActivityLabelKey, runActivityState, todayFailures, weekendWithoutScheduledRuns } from "./status";
 import { groupAccounts } from "../../lib/accountDirectory";
@@ -83,8 +87,7 @@ function StatStrip({
   return (
     <>
       {/* Four KPIs only: accounts with complete data, accounts with records,
-          failed accounts, credentials. This page has no trustworthy source for
-          a current notification, so it states no notification status at all. */}
+          failed accounts, credentials. Digest delivery is a separate read below. */}
       <div className="stat-strip health-kpis">
         <KpiCard
           title={t("health.kpi.today_runs")}
@@ -272,6 +275,11 @@ export default function HealthPage() {
   const [epoch, setEpoch] = useState(0);
   const summary = useApi(() => loadTodayRuns(), [epoch]);
   const credential = useApi(() => loadCredentialMaintenance(), [epoch]);
+  const digest = useApi(async () => loadDigestStatus(await loadNotificationLog(1), false), [epoch]);
+  const digestStatus = digest.phase === "loading" ? "loading" as const
+    : digest.phase === "error" ? "error" as const
+      : digest.data.status === "not_ready" ? "not_ready" as const : "ready" as const;
+  const digestData = digest.phase === "ready" && digest.data.status === "ready" ? digest.data.data : null;
 
   return (
     <div className="page">
@@ -309,6 +317,15 @@ export default function HealthPage() {
         <h2 className="card-title">{t("health.credentials_title")}</h2>
         <div className="health-credentials"><CredentialsCard credential={credential} /></div>
       </section>
+
+      <section className="card health-digest">
+        <DigestStatus digest={digestData} status={digestStatus} onRetry={digest.reload} />
+      </section>
+
+      <section className="card health-activity">
+        <h2 className="card-title">{t("overview.latest_activity")}</h2>
+        <AuditHistory key={epoch} />
+      </section>
     </div>
   );
 }
diff --git a/web/strategy-switch-console/frontend/src/pages/overview/OverviewPage.tsx b/web/strategy-switch-console/frontend/src/pages/overview/OverviewPage.tsx
index df3a1e9d..36221c42 100644
--- a/web/strategy-switch-console/frontend/src/pages/overview/OverviewPage.tsx
+++ b/web/strategy-switch-console/frontend/src/pages/overview/OverviewPage.tsx
@@ -7,6 +7,7 @@ import type {
   CalendarCell,
   CalendarResponse,
   HistoryCoverage,
+  InboxItem,
   InboxResponse,
   Point,
   Reason,
@@ -27,8 +28,11 @@ import { useApi } from "../../lib/hooks";
 import type { AsyncState } from "../../lib/hooks";
 import { latestAssetBalance } from "../../lib/performance";
 import { renderableStatus } from "../../lib/status";
+import { formatDateTime } from "../../lib/format";
+import { AuditHistory } from "../../components/AuditHistory";
+import { FreshnessBadge } from "../../components/cockpit";
 import { useNavigate, useScope } from "../../app/context";
-import { useT } from "../../i18n";
+import { useLanguage, useT } from "../../i18n";
 import { useScopeLabel } from "../../lib/useScopeLabel";
 import {
   AsOfStamp,
@@ -469,6 +473,100 @@ export function TrendCard({ returns, assets }: { returns: Api<ReturnsResponse>;
   );
 }
 
+const QUEUE_PRIORITY: Record<string, number> = { high: 0, medium: 1, normal: 2 };
+
+/** Recovery first, then the server priority, then newest; no client urgency score. */
+function queueOrder(a: InboxItem, b: InboxItem): number {
+  const recovery = Number(b.category === "reconciliation_recovery") - Number(a.category === "reconciliation_recovery");
+  if (recovery !== 0) return recovery;
+  return (QUEUE_PRIORITY[a.priority] ?? 3) - (QUEUE_PRIORITY[b.priority] ?? 3)
+    || (b.created_at || "").localeCompare(a.created_at || "");
+}
+
+function QueueRow({ item, onOpen }: { item: InboxItem; onOpen: () => void }) {
+  const t = useT();
+  const language = useLanguage();
+  const title = t(item.title_key);
+  const expires = item.expires_at ? formatDateTime(item.expires_at, language) : null;
+  return (
+    <li className="overview-queue-item">
+      <button type="button" className="overview-queue-open" onClick={onOpen}>
+        <span className="overview-queue-main">
+          <span className="overview-queue-title">{title === item.title_key ? item.short_id : title}</span>
+          <span className="overview-queue-meta">
+            <Badge tone={item.category === "reconciliation_recovery" ? "warn" : "accent"}>{t(`category.${item.category}`)}</Badge>
+            <span>{item.account_alias || t("decisions.account_unbound")}</span>
+            <span>{t("decisions.ref", { id: item.short_id })}</span>
+            {expires && <span>{t("overview.expires_plain", { value: expires.zone ? `${expires.text} (${expires.zone})` : expires.text })}</span>}
+          </span>
+        </span>
+        <FreshnessBadge state={item.evidence_freshness?.status} observedAt={item.evidence_freshness?.as_of} />
+      </button>
+    </li>
+  );
+}
+
+/**
+ * Owner decisions lead the page. Counts appear only when every decision source
+ * was read; a partial read lists what is known and says coverage is incomplete.
+ */
+function DecisionQueue({ inbox, onRetry }: { inbox: Api<InboxResponse>; onRetry: () => void }) {
+  const t = useT();
+  const navigate = useNavigate();
+  const open = () => navigate({ page: "decisions" });
+  let body: ReactNode;
+  if (inbox.phase === "loading") {
+    body = <Skeleton height={88} />;
+  } else if (inbox.phase === "error" || (inbox.phase === "ready" && inbox.data.status === "read_failed" && inbox.data.items.length === 0)) {
+    body = (
+      <>
+        <p className="cockpit-note error" role="status">{t("overview.queue_read_failed")}</p>
+        <button type="button" className="button button-secondary button-sm" onClick={onRetry}>{t("common.retry")}</button>
+      </>
+    );
+  } else {
+    const data = inbox.data;
+    const complete = data.status === "ok" && data.sources.every(source => source.status === "ok");
+    const now = Date.now();
+    const actionable = data.items
+      .filter(item => item.status === "pending" && !(item.expires_at && Date.parse(item.expires_at) < now))
+      .sort(queueOrder);
+    const blocked = actionable.filter(item => !["fresh", "ready"].includes(item.evidence_freshness?.status ?? "")).length;
+    const urgent = actionable.filter(item => item.priority === "high").length;
+    body = (
+      <>
+        <p className="overview-queue-lede">
+          {complete
+            ? actionable.length === 0 ? t("overview.queue_complete_empty") : t("overview.needs_review", { count: actionable.length })
+            : t("overview.queue_incomplete")}
+        </p>
+        {complete && actionable.length > 0 && (
+          <p className="overview-queue-counts">
+            <span>{t("overview.queue_blocked", { count: blocked })}</span>
+            <span>{t("overview.queue_high_priority", { count: urgent })}</span>
+          </p>
+        )}
+        {actionable.length > 0 && (
+          <ul className="overview-queue-list">
+            {actionable.slice(0, 3).map(item => <QueueRow key={item.id} item={item} onOpen={open} />)}
+          </ul>
+        )}
+        <button type="button" className="button button-secondary button-sm" onClick={open}>
+          {t("overview.queue_more")}
+        </button>
+      </>
+    );
+  }
+  return (
+    <section className="card overview-queue" aria-label={t("overview.decision_queue")}>
+      <div className="overview-card-head">
+        <h2 className="card-title">{t("overview.decision_queue")}</h2>
+      </div>
+      {body}
+    </section>
+  );
+}
+
 /* ---------- page ---------- */
 
 export default function OverviewPage() {
@@ -504,6 +602,7 @@ export default function OverviewPage() {
           </button>
         </div>
       </div>
+      <DecisionQueue inbox={inbox} onRetry={inbox.reload} />
       <section className="overview-summary" aria-label={t("overview.asset_summary")}>
         <div className="overview-primary-kpi"><AssetKpi state={assets} /></div>
         <div className="overview-secondary-kpis">
@@ -514,6 +613,12 @@ export default function OverviewPage() {
         </div>
       </section>
       <TrendCard returns={returns} assets={assets} />
+      <section className="card overview-activity" aria-label={t("overview.latest_activity")}>
+        <div className="overview-card-head">
+          <h2 className="card-title">{t("overview.latest_activity")}</h2>
+        </div>
+        <AuditHistory key={epoch} />
+      </section>
     </div>
   );
 }
diff --git a/web/strategy-switch-console/frontend/src/pages/overview/overview.css b/web/strategy-switch-console/frontend/src/pages/overview/overview.css
index 8f5b5341..027bdd48 100644
--- a/web/strategy-switch-console/frontend/src/pages/overview/overview.css
+++ b/web/strategy-switch-console/frontend/src/pages/overview/overview.css
@@ -43,6 +43,27 @@
 .overview-secondary-kpis .kpi-foot { gap: 4px 8px; margin-top: auto; }
 
 .overview-trend-card { min-height: 260px; }
+.overview-queue, .overview-activity { display: flex; flex-direction: column; gap: 10px; }
+.overview-queue-lede { margin: 0; color: var(--ink); font-size: 14px; font-weight: 600; }
+.overview-queue-counts { display: flex; flex-wrap: wrap; gap: 4px 16px; margin: 0; color: var(--muted); font-size: 12.5px; }
+.overview-queue-list { display: flex; flex-direction: column; margin: 0; padding: 0; list-style: none; }
+.overview-queue-item + .overview-queue-item { border-top: 1px solid var(--line); }
+.overview-queue-open {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 10px 16px;
+  width: 100%;
+  min-height: 44px;
+  padding: 10px 2px;
+  text-align: left;
+}
+.overview-queue-open:hover .overview-queue-title { color: var(--accent); }
+.overview-queue-main { display: flex; flex-direction: column; min-width: 0; gap: 4px; }
+.overview-queue-title { color: var(--ink); font-size: 13.5px; font-weight: 600; }
+.overview-queue-meta { display: flex; flex-wrap: wrap; align-items: center; gap: 4px 10px; color: var(--muted); font-size: 12px; }
+.overview-queue .button { align-self: flex-start; }
+.overview-activity .cockpit-change-log { margin: 0; }
 .overview-card-head {
   display: flex;
   align-items: flex-start;
diff --git a/web/strategy-switch-console/frontend/src/pages/strategies/StrategiesPage.tsx b/web/strategy-switch-console/frontend/src/pages/strategies/StrategiesPage.tsx
index 6947365c..94563e5e 100644
--- a/web/strategy-switch-console/frontend/src/pages/strategies/StrategiesPage.tsx
+++ b/web/strategy-switch-console/frontend/src/pages/strategies/StrategiesPage.tsx
@@ -5,11 +5,14 @@ import { useDisplayNames } from "../../lib/useDisplayNames";
 import { useState } from "react";
 import { getJson } from "../../api/client";
 import { loadStrategySummary } from "../../api/endpoints";
+import { loadLifecycles } from "../../api/cockpit";
+import type { LifecycleBinding } from "../../api/cockpit";
 import type { M0ResearchDashboard, StrategySummary } from "../../api/contracts";
 import { useNavigate } from "../../app/context";
 import { useT } from "../../i18n";
 import { useApi } from "../../lib/hooks";
 import { AsOfStamp, Badge, EmptyState, ErrorState, Skeleton, StatusBadge } from "../../components/primitives";
+import { EvidenceSummary, LifecycleStepper } from "../../components/cockpit";
 import { Tabs } from "../../components/Tabs";
 import "./strategies.css";
 
@@ -62,7 +65,11 @@ function AccountExecution({ accounts }: { accounts: Strategy["configured_account
   );
 }
 
-function StrategyCard({ strategy, assignmentKnown = true }: { strategy: Strategy; assignmentKnown?: boolean }) {
+function StrategyCard({ strategy, assignmentKnown = true, lifecycles }: {
+  strategy: Strategy;
+  assignmentKnown?: boolean;
+  lifecycles?: LifecycleBinding[];
+}) {
   const t = useT();
   const names = useDisplayNames();
   const modes = strategy.allowed_execution_modes.length > 0 ? strategy.allowed_execution_modes.map(names.lane).join(" · ") : t("common.na");
@@ -119,6 +126,35 @@ function StrategyCard({ strategy, assignmentKnown = true }: { strategy: Strategy
           </div>
         </details>
       )}
+      {lifecycles && lifecycles.length > 0 && (
+        <details className="strategy-details">
+          <summary>{t("cockpit.lifecycle.title")}</summary>
+          <div className="strategy-details-body">
+            {lifecycles.map((binding, index) => (
+              <div className="strategy-lifecycle" key={`${binding.account_alias}/${binding.platform}/${binding.release_id ?? index}`}>
+                <p className="cockpit-meta">
+                  {binding.platform && <>{names.platform(binding.platform)} · </>}
+                  {binding.account_alias
+                    ? names.account(binding.account_alias, binding.platform ?? "")
+                    : t("decisions.account_unbound")}
+                  {" · "}
+                  {t("cockpit.lifecycle.identity", {
+                    release: binding.release_id ?? t("cockpit.unknown"),
+                    target: binding.target_id ?? t("cockpit.unknown"),
+                  })}
+                </p>
+                {binding.present ? (
+                  <>
+                    <LifecycleStepper binding={binding} />
+                    {binding.evidence && <EvidenceSummary evidence={binding.evidence} />}
+                    {binding.regime_effect && <p className="cockpit-note">{binding.regime_effect}</p>}
+                  </>
+                ) : <p className="cockpit-note">{t("cockpit.lifecycle.not_provided")}</p>}
+              </div>
+            ))}
+          </div>
+        </details>
+      )}
       {(strategy.status !== "ok" || strategy.as_of) && <div className="strategy-card-foot">
         {strategy.status !== "ok" && <StatusBadge status={strategy.status} reason={strategy.unavailable_reason} />}
         {strategy.as_of && <AsOfStamp value={strategy.as_of} prefix="strategies.health_as_of" />}
@@ -132,6 +168,13 @@ function CatalogTab({ refreshEpoch }: { refreshEpoch: number }) {
   const names = useDisplayNames();
   const navigate = useNavigate();
   const state = useApi(loadStrategySummary, [refreshEpoch]);
+  // Lifecycle axes come from the same summary read; absent records stay absent.
+  const lifecycleRead = useApi(
+    () => state.phase === "ready"
+      ? loadLifecycles(state.data)
+      : Promise.resolve({ status: "ready" as const, data: [] as LifecycleBinding[], synthetic: false }),
+    [state.phase === "ready" ? state.data : null],
+  );
   if (state.phase === "loading") {
     return (
       <div className="strategy-grid" aria-busy="true">
@@ -149,6 +192,14 @@ function CatalogTab({ refreshEpoch }: { refreshEpoch: number }) {
   if (state.phase === "error") return <ErrorState onRetry={state.reload} />;
   const summary = state.data;
   if (summary.status === "read_failed") return <ErrorState onRetry={state.reload} />;
+  const lifecyclesByProfile = new Map<string, LifecycleBinding[]>();
+  if (lifecycleRead.phase === "ready" && lifecycleRead.data.status === "ready") {
+    for (const binding of lifecycleRead.data.data) {
+      const list = lifecyclesByProfile.get(binding.profile);
+      if (list) list.push(binding);
+      else lifecyclesByProfile.set(binding.profile, [binding]);
+    }
+  }
   if (summary.strategies.length === 0) {
     if (summary.status === "not_connected") {
       return <EmptyState title={t("state.not_connected")} body={t("reason.strategy_health_not_connected")} />;
@@ -201,7 +252,7 @@ function CatalogTab({ refreshEpoch }: { refreshEpoch: number }) {
       )}
       {!assignmentKnown ? <>
         <p className="card-note" role="status">{t("strategies.assignment_unavailable")}</p>
-        <div className="strategy-grid">{summary.strategies.map(strategy => <StrategyCard key={strategy.profile} strategy={strategy} assignmentKnown={false} />)}</div>
+        <div className="strategy-grid">{summary.strategies.map(strategy => <StrategyCard key={strategy.profile} strategy={strategy} assignmentKnown={false} lifecycles={lifecyclesByProfile.get(strategy.profile)} />)}</div>
       </> : <><section className="strategy-section">
         <div className="strategy-section-head">
           <h2 className="strategy-section-title">{t("strategies.configured_section")}</h2>
@@ -210,7 +261,7 @@ function CatalogTab({ refreshEpoch }: { refreshEpoch: number }) {
         {configured.length > 0
           ? <div className="strategy-grid">
               {configured.map(strategy => (
-                <StrategyCard key={strategy.profile} strategy={strategy} />
+                <StrategyCard key={strategy.profile} strategy={strategy} lifecycles={lifecyclesByProfile.get(strategy.profile)} />
               ))}
             </div>
           : <p className="card-note strategy-section-empty">{t("strategies.no_configured")}</p>}
@@ -223,7 +274,7 @@ function CatalogTab({ refreshEpoch }: { refreshEpoch: number }) {
           </div>
           <div className="strategy-grid">
             {catalogOnly.map(strategy => (
-              <StrategyCard key={strategy.profile} strategy={strategy} />
+              <StrategyCard key={strategy.profile} strategy={strategy} lifecycles={lifecyclesByProfile.get(strategy.profile)} />
             ))}
           </div>
         </section>
diff --git a/web/strategy-switch-console/frontend/src/pages/strategies/strategies.css b/web/strategy-switch-console/frontend/src/pages/strategies/strategies.css
index 1bcce70b..15e20981 100644
--- a/web/strategy-switch-console/frontend/src/pages/strategies/strategies.css
+++ b/web/strategy-switch-console/frontend/src/pages/strategies/strategies.css
@@ -77,6 +77,8 @@
 .strategy-details summary:hover { color: var(--ink); }
 .strategy-details-body { display: flex; flex-direction: column; gap: 8px; padding-top: 4px; }
 .strategy-details-body .strategy-execution { padding: 0; border: 0; background: transparent; }
+.strategy-lifecycle + .strategy-lifecycle { border-top: 1px solid var(--line); padding-top: 10px; }
+.strategy-lifecycle .cockpit-section { padding: 0; border: 0; background: transparent; }
 
 .research-list { display: flex; flex-direction: column; gap: 10px; }
 .research-item { display: flex; flex-direction: column; gap: 8px; padding: 16px 18px; }
diff --git a/web/strategy-switch-console/package-lock.json b/web/strategy-switch-console/package-lock.json
index b86fa425..69ce5f26 100644
--- a/web/strategy-switch-console/package-lock.json
+++ b/web/strategy-switch-console/package-lock.json
@@ -129,9 +129,9 @@
       }
     },
     "node_modules/@img/sharp-darwin-arm64": {
-      "version": "0.35.2",
-      "resolved": "https://registry.npmjs.org/@img/sharp-darwin-arm64/-/sharp-darwin-arm64-0.35.2.tgz",
-      "integrity": "sha512-eEieHsMksAW4IiO5NzauESRl2D2qz3J/kwUxUrSfV06A93eEaRfMpHXyUb1mAqrR7i8U9A0GRqE9pjn6u1Jjpg==",
+      "version": "0.35.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-darwin-arm64/-/sharp-darwin-arm64-0.35.5.tgz",
+      "integrity": "sha512-QRUlFQ0WxvdWyqqG/WtI3iupfD5rBzmCHXSdPsY91sAtVtTo7Q4cb6zOccZ3gqEqkr0f1As1ehLqmEpDsRf+lg==",
       "cpu": [
         "arm64"
       ],
@@ -148,13 +148,13 @@
         "url": "https://opencollective.com/libvips"
       },
       "optionalDependencies": {
-        "@img/sharp-libvips-darwin-arm64": "1.3.1"
+        "@img/sharp-libvips-darwin-arm64": "1.3.4"
       }
     },
     "node_modules/@img/sharp-darwin-x64": {
-      "version": "0.35.2",
-      "resolved": "https://registry.npmjs.org/@img/sharp-darwin-x64/-/sharp-darwin-x64-0.35.2.tgz",
-      "integrity": "sha512-BaktuGPCeHJMARpodR8jK4uKiZrPAy9WrfQW0sdI37clracq8Bp01AYS3SZgi5FS/y5twa9t4+LIuuxQjqRrWw==",
+      "version": "0.35.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-darwin-x64/-/sharp-darwin-x64-0.35.5.tgz",
+      "integrity": "sha512-+BR255RhDlpygUpOc/Jdt1nT6DQ3XG/ERo5wbcdOf5Q320dKtPCKPLR1LJs9VGXRaMa8l1uUa0tkCNOXiAxZUw==",
       "cpu": [
         "x64"
       ],
@@ -171,13 +171,13 @@
         "url": "https://opencollective.com/libvips"
       },
       "optionalDependencies": {
-        "@img/sharp-libvips-darwin-x64": "1.3.1"
+        "@img/sharp-libvips-darwin-x64": "1.3.4"
       }
     },
     "node_modules/@img/sharp-freebsd-wasm32": {
-      "version": "0.35.2",
-      "resolved": "https://registry.npmjs.org/@img/sharp-freebsd-wasm32/-/sharp-freebsd-wasm32-0.35.2.tgz",
-      "integrity": "sha512-YoAxdnd8hPUkvLHd3bWY+YA8nw3xM/RyRopYucNsWHVSan8NLVM3X2volsfoRDcXdUJPg6tXahSd7HXPK7lRnw==",
+      "version": "0.35.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-freebsd-wasm32/-/sharp-freebsd-wasm32-0.35.5.tgz",
+      "integrity": "sha512-Y/z91nEZ4uIBX5X3nfTovjU9lHNKFYbL2lpHCLVNmXQK03VIZvXBBt0KxbPGp2SdGSF+2mQU4e+hQaWOt86iAw==",
       "dev": true,
       "license": "Apache-2.0",
       "optional": true,
@@ -185,7 +185,7 @@
         "freebsd"
       ],
       "dependencies": {
-        "@img/sharp-wasm32": "0.35.2"
+        "@img/sharp-wasm32": "0.35.5"
       },
       "engines": {
         "node": ">=20.9.0"
@@ -195,9 +195,9 @@
       }
     },
     "node_modules/@img/sharp-libvips-darwin-arm64": {
-      "version": "1.3.1",
-      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-darwin-arm64/-/sharp-libvips-darwin-arm64-1.3.1.tgz",
-      "integrity": "sha512-4V/M3roRMTYjiwZY9IOVQOE8OyeCxFAkYmyZDrZl51uOKjibm3oeEJ4WAmLxutAfzFbC9jqUiPs2gbnGflH+7g==",
+      "version": "1.3.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-darwin-arm64/-/sharp-libvips-darwin-arm64-1.3.4.tgz",
+      "integrity": "sha512-5R89nBYiRdUlSWJxPhO+GVtaXzXSxKnRu/xqMn3KTA3L9EB9Oy/P+Nn2f2vlhPuUdy/Zusb2DarbyTpGCfEDuw==",
       "cpu": [
         "arm64"
       ],
@@ -212,9 +212,9 @@
       }
     },
     "node_modules/@img/sharp-libvips-darwin-x64": {
-      "version": "1.3.1",
-      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-darwin-x64/-/sharp-libvips-darwin-x64-1.3.1.tgz",
-      "integrity": "sha512-c0/DxItpJv2+dGhgycJBBgotdqruGYDvA79drdh0MD1dFpy7JzJ/PlXwi1H4rFf0eTy8tgbI91aHDnZIceY3jQ==",
+      "version": "1.3.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-darwin-x64/-/sharp-libvips-darwin-x64-1.3.4.tgz",
+      "integrity": "sha512-iR2OKH80yi0U+dUplyh3/xdpFvps6YkCwsXenIJxqxR1v9o+xtKTGbS9H7cps+2Vxjc8B1j96p75NmTGjIhtpQ==",
       "cpu": [
         "x64"
       ],
@@ -229,16 +229,13 @@
       }
     },
     "node_modules/@img/sharp-libvips-linux-arm": {
-      "version": "1.3.1",
-      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-arm/-/sharp-libvips-linux-arm-1.3.1.tgz",
-      "integrity": "sha512-aGGy9aWzXgHBG7HNyQPWorZthlp7+x6fDRoPAQbGO3ThcttuTyKIx3NuSHb6zb4gBNq6/yNn9f1cy9nFKS/Vmg==",
+      "version": "1.3.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-arm/-/sharp-libvips-linux-arm-1.3.4.tgz",
+      "integrity": "sha512-LmRtTsOHuvM2+wlO2Db37dx5MiZhB0FvSunciw48YjdOkZz9KAiRbm8ujeMOA1INqmei5NapFxYEK1D1ZSidmw==",
       "cpu": [
         "arm"
       ],
       "dev": true,
-      "libc": [
-        "glibc"
-      ],
       "license": "LGPL-3.0-or-later",
       "optional": true,
       "os": [
@@ -249,16 +246,13 @@
       }
     },
     "node_modules/@img/sharp-libvips-linux-arm64": {
-      "version": "1.3.1",
-      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-arm64/-/sharp-libvips-linux-arm64-1.3.1.tgz",
-      "integrity": "sha512-JznefmcK9j1JKPz8AkQDh89kjojubyfOasWBPKfzMIhPwsgDy9evpE/naJTXXXmghS1iFwR8u/kTwh/I2/+GCw==",
+      "version": "1.3.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-arm64/-/sharp-libvips-linux-arm64-1.3.4.tgz",
+      "integrity": "sha512-Y3dgX/6lE2QhQb+Gxy0WZxfg9MEm/JBjamZpS2IklP7xIQoKN4hzAm7KcMVGtaVDt3neE9OKBC7vAfonA/Lr1A==",
       "cpu": [
         "arm64"
       ],
       "dev": true,
-      "libc": [
-        "glibc"
-      ],
       "license": "LGPL-3.0-or-later",
       "optional": true,
       "os": [
@@ -269,16 +263,13 @@
       }
     },
     "node_modules/@img/sharp-libvips-linux-ppc64": {
-      "version": "1.3.1",
-      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-ppc64/-/sharp-libvips-linux-ppc64-1.3.1.tgz",
-      "integrity": "sha512-1EkwGNCZk6iWNCMWqrvdJ+r1j0PT1zIz60CNPhYnJlK/zyeWqlsPZIe+ocBVqPF8k/Ssee/NCk+tE9Ryrko6ng==",
+      "version": "1.3.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-ppc64/-/sharp-libvips-linux-ppc64-1.3.4.tgz",
+      "integrity": "sha512-Le6boB8Tai0Nis+gIxIpKx68UDVVIqdR8Tin5Yf1z2LJJQLDJvCDRqRu+jC2qCoD+eIomonmOwB4smBRxfVpYQ==",
       "cpu": [
         "ppc64"
       ],
       "dev": true,
-      "libc": [
-        "glibc"
-      ],
       "license": "LGPL-3.0-or-later",
       "optional": true,
       "os": [
@@ -289,16 +280,13 @@
       }
     },
     "node_modules/@img/sharp-libvips-linux-riscv64": {
-      "version": "1.3.1",
-      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-riscv64/-/sharp-libvips-linux-riscv64-1.3.1.tgz",
-      "integrity": "sha512-Ilays+w2bXdnxzxtQdmXR62u8o8GYa3eL4+Gr+1KiE4xperMZUslRaVPJwwPkzlHEjGfXAfRVAa/7CYCtSqsBw==",
+      "version": "1.3.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-riscv64/-/sharp-libvips-linux-riscv64-1.3.4.tgz",
+      "integrity": "sha512-aHkkIEHPRdQEegJN20MLmGtxYD9R2wQr3Cwpddnu5+YKMt6Uzax7S9h5gpZTo8wyrGuZSlfQ63OevL5mTyOC7Q==",
       "cpu": [
         "riscv64"
       ],
       "dev": true,
-      "libc": [
-        "glibc"
-      ],
       "license": "LGPL-3.0-or-later",
       "optional": true,
       "os": [
@@ -309,16 +297,13 @@
       }
     },
     "node_modules/@img/sharp-libvips-linux-s390x": {
-      "version": "1.3.1",
-      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-s390x/-/sharp-libvips-linux-s390x-1.3.1.tgz",
-      "integrity": "sha512-VfBwVHQTbRoj4XlpA/KLZ7ltgMpz+4WSejFzQ+GnoImjo1PtEJ59QB2qR1xQEeRPYIkNrPIm2L4cICMvz4C2ew==",
+      "version": "1.3.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-s390x/-/sharp-libvips-linux-s390x-1.3.4.tgz",
+      "integrity": "sha512-ra/mB6MikESDUO7Yg+Mi95bFBb9GsObURuhnOv3OqknjGe9sZrG8tCe9q0xSIGrtLgvgw0gKnFWcK4blSgQOuQ==",
       "cpu": [
         "s390x"
       ],
       "dev": true,
-      "libc": [
-        "glibc"
-      ],
       "license": "LGPL-3.0-or-later",
       "optional": true,
       "os": [
@@ -329,16 +314,13 @@
       }
     },
     "node_modules/@img/sharp-libvips-linux-x64": {
-      "version": "1.3.1",
-      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-x64/-/sharp-libvips-linux-x64-1.3.1.tgz",
-      "integrity": "sha512-+c8ukgwU62DS54nCAjw7keOfHUkmr0B5QHEdcOqRnodF/MNXJbVI8Eopoj4B/0H8Asr65I+A4Amrn7a85/md6A==",
+      "version": "1.3.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-x64/-/sharp-libvips-linux-x64-1.3.4.tgz",
+      "integrity": "sha512-GJ//SSXbnwSDes02umB3nDJLFcQzw8a18V8fyhqr6tV515tOEMdImjjxj1AoafMRz56F3PHgftnj1QEKSU1zkw==",
       "cpu": [
         "x64"
       ],
       "dev": true,
-      "libc": [
-        "glibc"
-      ],
       "license": "LGPL-3.0-or-later",
       "optional": true,
       "os": [
@@ -349,16 +331,13 @@
       }
     },
     "node_modules/@img/sharp-libvips-linuxmusl-arm64": {
-      "version": "1.3.1",
-      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linuxmusl-arm64/-/sharp-libvips-linuxmusl-arm64-1.3.1.tgz",
-      "integrity": "sha512-qlKb/pwbkAi1WMsJrYHk7CuDrd12s27U2QnRhFYUoJNrRCmkosMTttuRFat/DDB3IlDm5qE1TJgZ4JDnHX8Ldw==",
+      "version": "1.3.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linuxmusl-arm64/-/sharp-libvips-linuxmusl-arm64-1.3.4.tgz",
+      "integrity": "sha512-hvulFwtjUcagsis6BBxHwGFwWoNZjgYmULGVrZcyfNbjA8hKILbRxGg15/7w5HDyXHXUos/j6baAWqnCyQ2DWA==",
       "cpu": [
         "arm64"
       ],
       "dev": true,
-      "libc": [
-        "musl"
-      ],
       "license": "LGPL-3.0-or-later",
       "optional": true,
       "os": [
@@ -369,16 +348,13 @@
       }
     },
     "node_modules/@img/sharp-libvips-linuxmusl-x64": {
-      "version": "1.3.1",
-      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linuxmusl-x64/-/sharp-libvips-linuxmusl-x64-1.3.1.tgz",
-      "integrity": "sha512-yO21HwoUVLN8Qa+/SBjQLMYwBWAVJjeGPNe+hc0OUeMeifEtJqu5a1c4HayE1nNpDih9y3/KkoltfkDodmKAlg==",
+      "version": "1.3.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linuxmusl-x64/-/sharp-libvips-linuxmusl-x64-1.3.4.tgz",
+      "integrity": "sha512-6zXKeE/p39I1AmA3cJG35eyBGNqNddLnUXjhwBnsGjFPWqf5VKkDBEqaEkPDoTEtkxwi2vv8Tcr2mDyP4So7Fg==",
       "cpu": [
         "x64"
       ],
       "dev": true,
-      "libc": [
-        "musl"
-      ],
       "license": "LGPL-3.0-or-later",
       "optional": true,
       "os": [
@@ -389,16 +365,13 @@
       }
     },
     "node_modules/@img/sharp-linux-arm": {
-      "version": "0.35.2",
-      "resolved": "https://registry.npmjs.org/@img/sharp-linux-arm/-/sharp-linux-arm-0.35.2.tgz",
-      "integrity": "sha512-SE4kzF2mepn6z+6E7L6lsV8FzuLL6IPQdyX8ZiwROAG/G8td+hP/m7FsFPwidtrF19gvajuC9l6TxAVcsA4S7A==",
+      "version": "0.35.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linux-arm/-/sharp-linux-arm-0.35.5.tgz",
+      "integrity": "sha512-LEaXK2WdXVK5ykcw0buWyPMsmLLL2vpHLD6yrNSW+JGEL3BZPA4tpKN6iaMc4AxTTAoaX/sU1rOL51lcIz48ZQ==",
       "cpu": [
         "arm"
       ],
       "dev": true,
-      "libc": [
-        "glibc"
-      ],
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -411,20 +384,17 @@
         "url": "https://opencollective.com/libvips"
       },
       "optionalDependencies": {
-        "@img/sharp-libvips-linux-arm": "1.3.1"
+        "@img/sharp-libvips-linux-arm": "1.3.4"
       }
     },
     "node_modules/@img/sharp-linux-arm64": {
-      "version": "0.35.2",
-      "resolved": "https://registry.npmjs.org/@img/sharp-linux-arm64/-/sharp-linux-arm64-0.35.2.tgz",
-      "integrity": "sha512-af12Pnd0ZGu2HfP8NayB0kk6eC/lrfbQE6HlR4jD+34wdJ1Vw9TF6TMn6ZvffT+WgqVsl0hRbmNvz2u/23VmwA==",
+      "version": "0.35.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linux-arm64/-/sharp-linux-arm64-0.35.5.tgz",
+      "integrity": "sha512-LYVx5JTsOM2CBzmxreh+nl64/3H6Xb09iSLknqH47z2T2DFFxDeFLP5y4dJwe6H7uGQlHPyEEtIqyo3DYsRwdQ==",
       "cpu": [
         "arm64"
       ],
       "dev": true,
-      "libc": [
-        "glibc"
-      ],
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -437,20 +407,17 @@
         "url": "https://opencollective.com/libvips"
       },
       "optionalDependencies": {
-        "@img/sharp-libvips-linux-arm64": "1.3.1"
+        "@img/sharp-libvips-linux-arm64": "1.3.4"
       }
     },
     "node_modules/@img/sharp-linux-ppc64": {
-      "version": "0.35.2",
-      "resolved": "https://registry.npmjs.org/@img/sharp-linux-ppc64/-/sharp-linux-ppc64-0.35.2.tgz",
-      "integrity": "sha512-hYSBm7zcNtDCozCxQHYZJiu63b/bXsgRZuOxCIBZsStMM9Vap47iFHdbX4kCvQsblPB/k+clhELpdQJHQLSHvg==",
+      "version": "0.35.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linux-ppc64/-/sharp-linux-ppc64-0.35.5.tgz",
+      "integrity": "sha512-QVxAAq8evVRI9ia2vqgwrmWucn5Dfv+JdWzj75pD8omHLPSP7f8p20O8jxzjCcuCEQEOtYOZUmX1hkiZ0kdevA==",
       "cpu": [
         "ppc64"
       ],
       "dev": true,
-      "libc": [
-        "glibc"
-      ],
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -463,20 +430,17 @@
         "url": "https://opencollective.com/libvips"
       },
       "optionalDependencies": {
-        "@img/sharp-libvips-linux-ppc64": "1.3.1"
+        "@img/sharp-libvips-linux-ppc64": "1.3.4"
       }
     },
     "node_modules/@img/sharp-linux-riscv64": {
-      "version": "0.35.2",
-      "resolved": "https://registry.npmjs.org/@img/sharp-linux-riscv64/-/sharp-linux-riscv64-0.35.2.tgz",
-      "integrity": "sha512-qQt0Kc13+Hoan/Awq/qMSQw3L+RI1NCRPgD5cUJ/1WSSmIoysLOc72jlRM3E0OHN9Yr313jgeQ2T+zW+F03QFA==",
+      "version": "0.35.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linux-riscv64/-/sharp-linux-riscv64-0.35.5.tgz",
+      "integrity": "sha512-LtdreXguaavKODPIfzJ4kffx7UNt1omwtK0rch4EBbbSTXPnxWmYSayXdLJw0fJzQ97kHt1gL/yh4tvU+nCyRQ==",
       "cpu": [
         "riscv64"
       ],
       "dev": true,
-      "libc": [
-        "glibc"
-      ],
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -489,20 +453,17 @@
         "url": "https://opencollective.com/libvips"
       },
       "optionalDependencies": {
-        "@img/sharp-libvips-linux-riscv64": "1.3.1"
+        "@img/sharp-libvips-linux-riscv64": "1.3.4"
       }
     },
     "node_modules/@img/sharp-linux-s390x": {
-      "version": "0.35.2",
-      "resolved": "https://registry.npmjs.org/@img/sharp-linux-s390x/-/sharp-linux-s390x-0.35.2.tgz",
-      "integrity": "sha512-E4fLLfRPzDLlEeDaTzI98OFLcv++WL5ChLLMwPoVd0CIoZQqupBSNbOisPL5am9XsbQ9T84+iiMpUvbFtkunbA==",
+      "version": "0.35.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linux-s390x/-/sharp-linux-s390x-0.35.5.tgz",
+      "integrity": "sha512-UZasTOFiYzotTsGOCu42BfUzP6Tu6Do/947iRm1RsLKvlllxwGcn4RN27LibGWceix4Y+Pmw3jsnTcCQIgWjqA==",
       "cpu": [
         "s390x"
       ],
       "dev": true,
-      "libc": [
-        "glibc"
-      ],
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -515,20 +476,17 @@
         "url": "https://opencollective.com/libvips"
       },
       "optionalDependencies": {
-        "@img/sharp-libvips-linux-s390x": "1.3.1"
+        "@img/sharp-libvips-linux-s390x": "1.3.4"
       }
     },
     "node_modules/@img/sharp-linux-x64": {
-      "version": "0.35.2",
-      "resolved": "https://registry.npmjs.org/@img/sharp-linux-x64/-/sharp-linux-x64-0.35.2.tgz",
-      "integrity": "sha512-gi0zFJJRLswfCZmHtJdikXPOc5u7qamSOS3NHedLqLd4W8Q0NqjdBr6TTRIgsfFjqfTsHFgdfvJ9LwqSgcHiAA==",
+      "version": "0.35.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linux-x64/-/sharp-linux-x64-0.35.5.tgz",
+      "integrity": "sha512-SxFtLTeJInhAA9Q836kux2vZNeOBQEx658qvbboZScr0wIARym3IcGmW7KpVD5sbVg0Ojy+udFQdayYIZyoNog==",
       "cpu": [
         "x64"
       ],
       "dev": true,
-      "libc": [
-        "glibc"
-      ],
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -541,20 +499,17 @@
         "url": "https://opencollective.com/libvips"
       },
       "optionalDependencies": {
-        "@img/sharp-libvips-linux-x64": "1.3.1"
+        "@img/sharp-libvips-linux-x64": "1.3.4"
       }
     },
     "node_modules/@img/sharp-linuxmusl-arm64": {
-      "version": "0.35.2",
-      "resolved": "https://registry.npmjs.org/@img/sharp-linuxmusl-arm64/-/sharp-linuxmusl-arm64-0.35.2.tgz",
-      "integrity": "sha512-siWbOW1u6HFnFLrp0waKyW7VEf7jYvcDWdrXEFa8AkdAQgEvuu5Fz8/Y70w9EeqAdwDtfU012BhEHHaDqvQNzg==",
+      "version": "0.35.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linuxmusl-arm64/-/sharp-linuxmusl-arm64-0.35.5.tgz",
+      "integrity": "sha512-9HbMclmI1zlNkFRs3z9/eBtDjfD0sGlrX1z6b1qwmiFY5ElDLh4BC0LPBdVp7z1DXFiKlIcznf+ZlsuZzLxQqg==",
       "cpu": [
         "arm64"
       ],
       "dev": true,
-      "libc": [
-        "musl"
-      ],
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -567,20 +522,17 @@
         "url": "https://opencollective.com/libvips"
       },
       "optionalDependencies": {
-        "@img/sharp-libvips-linuxmusl-arm64": "1.3.1"
+        "@img/sharp-libvips-linuxmusl-arm64": "1.3.4"
       }
     },
     "node_modules/@img/sharp-linuxmusl-x64": {
-      "version": "0.35.2",
-      "resolved": "https://registry.npmjs.org/@img/sharp-linuxmusl-x64/-/sharp-linuxmusl-x64-0.35.2.tgz",
-      "integrity": "sha512-YBqMMcjDi4QGYiSn4vNOYBhmlC4z5AXqkOUUqI2e0AFA4urNv4ESgOgwNl3K+4etQhha0twXlzeF20bbULm9Yg==",
+      "version": "0.35.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linuxmusl-x64/-/sharp-linuxmusl-x64-0.35.5.tgz",
+      "integrity": "sha512-4KOphqB035HrVdqLZfCgMzzERrQkkzOwRhl4OAkRO1YCldbaFjySXMaK534Mo0V+LndnlJk+sbUyLeU0ULyD1A==",
       "cpu": [
         "x64"
       ],
       "dev": true,
-      "libc": [
-        "musl"
-      ],
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -593,18 +545,18 @@
         "url": "https://opencollective.com/libvips"
       },
       "optionalDependencies": {
-        "@img/sharp-libvips-linuxmusl-x64": "1.3.1"
+        "@img/sharp-libvips-linuxmusl-x64": "1.3.4"
       }
     },
     "node_modules/@img/sharp-wasm32": {
-      "version": "0.35.2",
-      "resolved": "https://registry.npmjs.org/@img/sharp-wasm32/-/sharp-wasm32-0.35.2.tgz",
-      "integrity": "sha512-Mrv4JQNYVQ94xH+jzZ9r+gowleN8mv2FTgKT+PI6bx5C0G8TdNYndu161pg2i7uoBwxy2ImPMHrJOM2LZef7Bw==",
+      "version": "0.35.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-wasm32/-/sharp-wasm32-0.35.5.tgz",
+      "integrity": "sha512-Ptsga1su4tQx+LLF1ECS9U6nz5kmrXKo6XVbtR48Ke3ZRxxgaWBu7IDtEe1quo8hiupwm6WFqxVlXaSf7IINGQ==",
       "dev": true,
       "license": "Apache-2.0 AND LGPL-3.0-or-later AND MIT",
       "optional": true,
       "dependencies": {
-        "@emnapi/runtime": "^1.11.1"
+        "@emnapi/runtime": "^1.11.3"
       },
       "engines": {
         "node": ">=20.9.0"
@@ -614,9 +566,9 @@
       }
     },
     "node_modules/@img/sharp-webcontainers-wasm32": {
-      "version": "0.35.2",
-      "resolved": "https://registry.npmjs.org/@img/sharp-webcontainers-wasm32/-/sharp-webcontainers-wasm32-0.35.2.tgz",
-      "integrity": "sha512-QNV27pxs9wpApEiCfvHM1RDoP1w1+2KrUWWDPEhEwg+latvOrfuhWrHWZKwdSFwU6jh3myjw/yOCRsUIuOft3g==",
+      "version": "0.35.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-webcontainers-wasm32/-/sharp-webcontainers-wasm32-0.35.5.tgz",
+      "integrity": "sha512-hfhF/FmoQyTUkA0bIKFOtw536BQSeBMe6BF6QyWlrPxT754+TFLaZ7sKKTfvvM0yJgKgaYTwnFCIZ/GuDw5SUA==",
       "cpu": [
         "wasm32"
       ],
@@ -624,7 +576,7 @@
       "license": "Apache-2.0",
       "optional": true,
       "dependencies": {
-        "@img/sharp-wasm32": "0.35.2"
+        "@img/sharp-wasm32": "0.35.5"
       },
       "engines": {
         "node": ">=20.9.0"
@@ -634,9 +586,9 @@
       }
     },
     "node_modules/@img/sharp-win32-arm64": {
-      "version": "0.35.2",
-      "resolved": "https://registry.npmjs.org/@img/sharp-win32-arm64/-/sharp-win32-arm64-0.35.2.tgz",
-      "integrity": "sha512-BiVRYc/t6/Vl3e1hBx0hugG4oN9Pydf4fgMSpxTQJmwGUg/YoXTWHiFeRymHfCZzifxu4F4rpk/I67D0LQ20wQ==",
+      "version": "0.35.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-win32-arm64/-/sharp-win32-arm64-0.35.5.tgz",
+      "integrity": "sha512-X4t7g+7ZA5DKblCBEXGjUqqemj4vczING/5viFwAL8h4N3qYeyjwdCvRLHi4EdOUI+2Z7UFlp1VM+p/AuEtm6Q==",
       "cpu": [
         "arm64"
       ],
@@ -654,9 +606,9 @@
       }
     },
     "node_modules/@img/sharp-win32-ia32": {
-      "version": "0.35.2",
-      "resolved": "https://registry.npmjs.org/@img/sharp-win32-ia32/-/sharp-win32-ia32-0.35.2.tgz",
-      "integrity": "sha512-YYEhx9PImCC7T0tI8JDMi4DB9LwLCXCU5OWNYEXAxh5Q1ShKkyC6byxzoBJ3gEFDnH2lQckWuDe70G7mB2XJog==",
+      "version": "0.35.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-win32-ia32/-/sharp-win32-ia32-0.35.5.tgz",
+      "integrity": "sha512-5Zm82LoBc43nhwNybZlG7Y1KO//Zhsn306fQl29ZOuStHLGTo3BWL83q3cznX0poxSAMuYL1On/BHBxkBeKr6A==",
       "cpu": [
         "ia32"
       ],
@@ -674,9 +626,9 @@
       }
     },
     "node_modules/@img/sharp-win32-x64": {
-      "version": "0.35.2",
-      "resolved": "https://registry.npmjs.org/@img/sharp-win32-x64/-/sharp-win32-x64-0.35.2.tgz",
-      "integrity": "sha512-imoOyBcoM/iiUr4J6VPpCNjPnjvP/Gks95898yB8YqoGGYmHYbOyCuNv9FMhFgtaiHFGbHW8bxKqRV6VjtXThQ==",
+      "version": "0.35.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-win32-x64/-/sharp-win32-x64-0.35.5.tgz",
+      "integrity": "sha512-x76eH0vEiHlcMQu8Y8IenntaACtddpT6W0wmXtWrnKcnKI7ME5DdgqhAD6SEWOEl1v2zDvkZDhFA9KnURwpfqg==",
       "cpu": [
         "x64"
       ],
@@ -849,15 +801,15 @@
       }
     },
     "node_modules/sharp": {
-      "version": "0.35.2",
-      "resolved": "https://registry.npmjs.org/sharp/-/sharp-0.35.2.tgz",
-      "integrity": "sha512-FVtFjtBCMiJS6yb5CX7Sop45WFMpeGw6oRKuJnXYgf/f1ms/D7LE/ZUSNxnW7rZ/dbslQWYkoqFHGPaDBtaK4w==",
+      "version": "0.35.5",
+      "resolved": "https://registry.npmjs.org/sharp/-/sharp-0.35.5.tgz",
+      "integrity": "sha512-Ywn4OnzGukp7CDMrp08RQ50YKmuwG47brZgIVPTvBaaAfQlRlygrRqSrxdCiL9M+LlzLBiJ68IR1QqvzHyjC7g==",
       "dev": true,
       "license": "Apache-2.0",
       "dependencies": {
         "@img/colour": "^1.1.0",
         "detect-libc": "^2.1.2",
-        "semver": "^7.8.4"
+        "semver": "^7.8.5"
       },
       "engines": {
         "node": ">=20.9.0"
@@ -866,31 +818,36 @@
         "url": "https://opencollective.com/libvips"
       },
       "optionalDependencies": {
-        "@img/sharp-darwin-arm64": "0.35.2",
-        "@img/sharp-darwin-x64": "0.35.2",
-        "@img/sharp-freebsd-wasm32": "0.35.2",
-        "@img/sharp-libvips-darwin-arm64": "1.3.1",
-        "@img/sharp-libvips-darwin-x64": "1.3.1",
-        "@img/sharp-libvips-linux-arm": "1.3.1",
-        "@img/sharp-libvips-linux-arm64": "1.3.1",
-        "@img/sharp-libvips-linux-ppc64": "1.3.1",
-        "@img/sharp-libvips-linux-riscv64": "1.3.1",
-        "@img/sharp-libvips-linux-s390x": "1.3.1",
-        "@img/sharp-libvips-linux-x64": "1.3.1",
-        "@img/sharp-libvips-linuxmusl-arm64": "1.3.1",
-        "@img/sharp-libvips-linuxmusl-x64": "1.3.1",
-        "@img/sharp-linux-arm": "0.35.2",
-        "@img/sharp-linux-arm64": "0.35.2",
-        "@img/sharp-linux-ppc64": "0.35.2",
-        "@img/sharp-linux-riscv64": "0.35.2",
-        "@img/sharp-linux-s390x": "0.35.2",
-        "@img/sharp-linux-x64": "0.35.2",
-        "@img/sharp-linuxmusl-arm64": "0.35.2",
-        "@img/sharp-linuxmusl-x64": "0.35.2",
-        "@img/sharp-webcontainers-wasm32": "0.35.2",
-        "@img/sharp-win32-arm64": "0.35.2",
-        "@img/sharp-win32-ia32": "0.35.2",
-        "@img/sharp-win32-x64": "0.35.2"
+        "@img/sharp-darwin-arm64": "0.35.5",
+        "@img/sharp-darwin-x64": "0.35.5",
+        "@img/sharp-freebsd-wasm32": "0.35.5",
+        "@img/sharp-libvips-darwin-arm64": "1.3.4",
+        "@img/sharp-libvips-darwin-x64": "1.3.4",
+        "@img/sharp-libvips-linux-arm": "1.3.4",
+        "@img/sharp-libvips-linux-arm64": "1.3.4",
+        "@img/sharp-libvips-linux-ppc64": "1.3.4",
+        "@img/sharp-libvips-linux-riscv64": "1.3.4",
+        "@img/sharp-libvips-linux-s390x": "1.3.4",
+        "@img/sharp-libvips-linux-x64": "1.3.4",
+        "@img/sharp-libvips-linuxmusl-arm64": "1.3.4",
+        "@img/sharp-libvips-linuxmusl-x64": "1.3.4",
+        "@img/sharp-linux-arm": "0.35.5",
+        "@img/sharp-linux-arm64": "0.35.5",
+        "@img/sharp-linux-ppc64": "0.35.5",
+        "@img/sharp-linux-riscv64": "0.35.5",
+        "@img/sharp-linux-s390x": "0.35.5",
+        "@img/sharp-linux-x64": "0.35.5",
+        "@img/sharp-linuxmusl-arm64": "0.35.5",
+        "@img/sharp-linuxmusl-x64": "0.35.5",
+        "@img/sharp-webcontainers-wasm32": "0.35.5",
+        "@img/sharp-win32-arm64": "0.35.5",
+        "@img/sharp-win32-ia32": "0.35.5",
+        "@img/sharp-win32-x64": "0.35.5"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        }
       }
     },
     "node_modules/supports-color": {
@@ -907,17 +864,17 @@
       }
     },
     "node_modules/tslib": {
-      "version": "2.8.1",
-      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
-      "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
+      "version": "2.9.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.9.1.tgz",
+      "integrity": "sha512-a4Ux9VKuIMHsOS7ENbEq6hK2ZGYIT27Rtl0E4eD9KqwxhKiQeMZE/9xb3IdYwWaSOyIBQLExhQgXDTYoiCxnWA==",
       "dev": true,
       "license": "0BSD",
       "optional": true
     },
     "node_modules/undici": {
-      "version": "7.29.0",
-      "resolved": "https://registry.npmjs.org/undici/-/undici-7.29.0.tgz",
-      "integrity": "sha512-IDxfleLmmbSskfWSUATiN1nfn2rDuvnMOqb5CWR92iIfojA0Ud+ulOAAEQ57LPr9rWmsreUyf5lwyao+7GNNVw==",
+      "version": "7.30.1",
+      "resolved": "https://registry.npmjs.org/undici/-/undici-7.30.1.tgz",
+      "integrity": "sha512-03KrMbjIFDWQR5RNPrSw3bd1r12JpyFQl9/yxjUbJtqkjmllqC5lFjZh6ujeuJCKr8EOQvRW872Oy/az+nLYxg==",
       "dev": true,
       "license": "MIT",
       "engines": {
diff --git a/web/strategy-switch-console/package.json b/web/strategy-switch-console/package.json
index f2fa9ce1..d51f89cd 100644
--- a/web/strategy-switch-console/package.json
+++ b/web/strategy-switch-console/package.json
@@ -7,7 +7,8 @@
   },
   "overrides": {
     "miniflare": {
-      "undici": "7.29.0"
+      "undici": "7.30.1",
+      "sharp": "0.35.5"
     }
   }
 }
diff --git a/web/strategy-switch-console/v2_asset_map.js b/web/strategy-switch-console/v2_asset_map.js
index ab8d8c7f..b749a088 100644
--- a/web/strategy-switch-console/v2_asset_map.js
+++ b/web/strategy-switch-console/v2_asset_map.js
@@ -1,31 +1,33 @@
 // Generated by frontend/scripts/sync-v2-asset-map.mjs; do not edit.
-export const V2_BUILD_ID = "c4107b5109d29b6ba7aa3e39925cd46b5224451c31914aa88d9161fe97b4134b";
-export const V2_PAGE_HTML = "<!doctype html>\n<html lang=\"zh-CN\" data-updown=\"green-up\">\n  <head>\n    <meta charset=\"UTF-8\" />\n    <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\" />\n    <meta name=\"color-scheme\" content=\"light dark\" />\n    <meta name=\"description\" content=\"QuantStrategyLab 策略控制台\" />\n    <link rel=\"icon\" type=\"image/svg+xml\" href=\"/v2/assets/qsl-brand-icon.svg\" />\n    <title>总览 · QuantStrategyLab</title>\n    <script type=\"module\" crossorigin src=\"/v2/assets/index-Ds_XXLsn.js\"></script>\n    <link rel=\"stylesheet\" crossorigin href=\"/v2/assets/index-B36Qy5rG.css\">\n  <meta name=\"qsl-console-build\" content=\"c4107b5109d29b6ba7aa3e39925cd46b5224451c31914aa88d9161fe97b4134b\" />\n  </head>\n  <body>\n    <div id=\"root\"></div>\n  </body>\n</html>\n";
+export const V2_BUILD_ID = "deff6f20b8fc6cc170bec728eecca413a30e827aca426282d3eca60eca48ea7e";
+export const V2_PAGE_HTML = "<!doctype html>\n<html lang=\"zh-CN\" data-updown=\"green-up\">\n  <head>\n    <meta charset=\"UTF-8\" />\n    <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\" />\n    <meta name=\"color-scheme\" content=\"light dark\" />\n    <meta name=\"description\" content=\"QuantStrategyLab 策略控制台\" />\n    <link rel=\"icon\" type=\"image/svg+xml\" href=\"/v2/assets/qsl-brand-icon.svg\" />\n    <title>总览 · QuantStrategyLab</title>\n    <script type=\"module\" crossorigin src=\"/v2/assets/index-CwQsWZdm.js\"></script>\n    <link rel=\"stylesheet\" crossorigin href=\"/v2/assets/index-CMzizWMv.css\">\n  <meta name=\"qsl-console-build\" content=\"deff6f20b8fc6cc170bec728eecca413a30e827aca426282d3eca60eca48ea7e\" />\n  </head>\n  <body>\n    <div id=\"root\"></div>\n  </body>\n</html>\n";
 export const V2_ASSETS = Object.freeze({
+  "/v2/assets/AccountsPage-BFP5IP6M.js": { contentType: "text/javascript; charset=utf-8", base64: "import{u as z,j as n,B as be,g as J,A as xe,s as Ye,v as Ze,p as ke,N as ht,O as gt,Q as Se,T as Xe,E as le,k as Qe,r as D,D as Re,U as et,V as ie,W as bt,L as xt,X as kt,J as ne,Y as $e,c as tt,S as de,b as nt,Z as Fe,_ as jt,$ as Nt,a0 as wt,F as St,h as Tt,a1 as Ot,a2 as Ct}from"./index-CwQsWZdm.js";import{E as At}from"./ExecutionEvidence-CDki-xbb.js";import{u as Z}from"./hooks-9usXmJc_.js";import{b as Rt,R as Dt,c as Et,d as It}from"./cockpit-Cax-GxP0.js";import{D as Pt,T as Bt,d as ee,e as Mt,f as $t,g as Ft,u as Lt,v as Vt,C as qt}from"./Dialog-Nx1EjiqV.js";import{T as Kt}from"./Tabs-BP4xZNhq.js";import"./runtime_daily_contract-xW43mZQY.js";const Ut=/^-?(?:0|[1-9]\d*)(?:\.\d+)?$/;function De(t){return typeof t=="string"&&Ut.test(t)}function fe(t){return De(t)?t:null}function at(t,a){if(!De(t))return"—";const s=t.startsWith("-"),e=s?t.slice(1):t,[c,o=""]=e.split("."),i=c.replace(/\B(?=(\d{3})+(?!\d))/g,","),j=`${s?"-":""}${i}.${o?o.padEnd(2,"0"):"00"}`;return a?`${a} ${j}`:j}function Le(t){if(!t.length||!t.every(De))return"";const a=Math.max(...t.map(c=>(c.split(".")[1]||"").length)),s=t.reduce((c,o)=>{const[i,j=""]=o.replace(/^-/,"").split("."),r=BigInt(i+j.padEnd(a,"0"));return c+(o.startsWith("-")?-r:r)},0n),e=(s<0n?-s:s).toString().padStart(a+1,"0");return`${s<0n?"-":""}${a?`${e.slice(0,-a)}.${e.slice(-a)}`.replace(/\.?0+$/,""):e}`}function Ee(t,a,s){if(!t)return null;const e=t.filter(c=>c&&c.platform===a&&c.account_key===s);return e.length===1?e[0]:null}function Te(t){return!!t&&t.binding_status==="bound"&&t.identity_mismatch!==!0&&(t.data_status==="fresh"||t.data_status==="stale")}function st(t){return rt(t)==="paper"}function Ie(t){if(!t)return null;const a=[t.broker_environment,t.account_scope,t.binding_environment].filter(s=>s==="paper"||s==="live");return new Set(a).size===1?a[0]:null}function rt(t){if(!t)return null;const a=Ie(t);return a||(["live","paper"].includes(t.broker_environment??"")||["live","paper"].includes(t.account_scope??"")||["live","paper"].includes(t.binding_environment??"")?null:ve(t)?.environment??null)}function ot(t,a){const s=(Array.isArray(t.cash)?t.cash:[]).find(c=>c?.currency===a);if(s&&typeof s.cash_balance=="string")return fe(s.cash_balance);const e=(Array.isArray(t.balances)?t.balances:[]).find(c=>c?.currency===a);return e&&typeof e.total_cash=="string"?fe(e.total_cash):null}function Gt(t){if(!t||t.binding_status==="missing")return{kind:"not_connected"};if(t.binding_status==="duplicate"||t.identity_mismatch===!0)return{kind:"identity_unverified"};if(t.binding_status!=="bound")return{kind:"unknown"};if(t.data_status==="unavailable")return{kind:"no_data"};if(t.data_status!=="fresh"&&t.data_status!=="stale")return{kind:"unknown"};const a=Array.isArray(t.balances)?t.balances:[],s=Array.isArray(t.cash)?t.cash:[],e=new Set;for(const c of s)c&&typeof c.currency=="string"&&typeof c.cash_balance=="string"&&e.add(c.currency);for(const c of a)c&&typeof c.currency=="string"&&typeof c.total_cash=="string"&&e.add(c.currency);return{kind:"ready",stale:t.data_status==="stale",asOf:typeof t.observed_finished_at=="string"?t.observed_finished_at:null,balances:a.filter(c=>c&&typeof c.currency=="string").map(c=>({currency:c.currency,netAssets:fe(c.net_assets)})),cash:[...[...e].sort().map(c=>({currency:c,cashBalance:ot(t,c)})),...t.platform==="longbridge"?s.filter(c=>typeof c?.currency=="string"&&typeof c.available_cash=="string").map(c=>({currency:c.currency,cashBalance:fe(c.available_cash),available:!0})):[]]}}function zt(t,a){return Array.isArray(t.balances)&&t.balances.some(s=>s?.currency===a)||Array.isArray(t.cash)&&t.cash.some(s=>s?.currency===a)}function Wt(t,a){if(!t.length||a<1)return[];const s=[...new Set(t)],e=s.filter(d=>d.aggregation_status!=="duplicate"&&!st(d)),c=Math.max(0,a-(s.length-e.length)),o=e.filter(Te),i=o.filter(d=>d.aggregation_status==="included"&&rt(d)==="live"),j=o.some(d=>d.aggregation_status==="conflict");if(!i.length)return[];const r=new Set;for(const d of i){for(const u of Array.isArray(d.balances)?d.balances:[])u&&typeof u.currency=="string"&&r.add(u.currency);for(const u of Array.isArray(d.cash)?d.cash:[])u&&typeof u.currency=="string"&&typeof u.cash_balance=="string"&&r.add(u.currency)}return[...r].sort().map(d=>{const u=i.filter(g=>zt(g,d)),p=u.filter(g=>typeof g.observation_date=="string"&&g.observation_date.length>0),l=p.length?p.map(g=>g.observation_date).sort().pop():null,_=l?p.filter(g=>g.observation_date===l):[],v=g=>(Array.isArray(g.balances)?g.balances:[]).find(I=>I?.currency===d),b=_.map(g=>fe(v(g)?.net_assets)),m=_.length>0&&b.every(g=>g!==null)?Le(b):null,h=_.map(g=>ot(g,d)),T=_.length>0&&h.every(g=>g!==null)?Le(h):null,y=m!==null||T!==null?_.length:0;return{currency:d,netAssets:m,cashBalance:T,covered:y,expected:c,complete:!j&&c>0&&y===c&&_.length===u.length&&m!==null,stale:_.some(g=>g.data_status==="stale"),observationDate:l}})}function ve(t){const a=t?.user_declaration;if(!a||a.source!=="user_declared")return null;const s=a.environment==="live"||a.environment==="paper"?a.environment:null,e=a.account_type==="cash"||a.account_type==="margin"?a.account_type:null;return s===null&&e===null?null:{environment:s,accountType:e}}function Ht(t){const a=new Set;for(const s of t){const e=ve(s)?.environment;e&&a.add(e)}return a.size>1?{value:null,conflict:!0}:t.some(s=>!ve(s)?.environment)?{value:null,conflict:!1}:{value:a.size===1?[...a][0]:null,conflict:!1}}const Jt="GET /sapi/v1/asset/wallet/balance",Yt="provider_returned_wallet_rows",Zt="spot+flexible_earn",Xt=/^(?:0|[1-9]\d*)(?:\.\d+)?$/,Qt=/^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.\d{1,9})?(Z|[+-]\d{2}:\d{2})$/;function ue(t){return typeof t=="string"&&Xt.test(t)}function en(t){return/[1-9]/.test(t)}function ct(t){if(typeof t!="string")return null;const a=Qt.exec(t);if(!a||Number(a[4])>23||Number(a[5])>59||Number(a[6])>59)return null;if(a[7]!=="Z"){const[e,c]=a[7].slice(1).split(":");if(Number(e)>23||Number(c)>59)return null}const s=Date.parse(t);return Number.isFinite(s)?s:null}function tn(t){if(!t||typeof t!="object"||Array.isArray(t))return!1;const a=t;return typeof a.asset=="string"&&a.asset.length>0&&ue(a.quantity)&&ue(a.spot_free)&&ue(a.spot_locked)&&ue(a.flexible_earn)}function nn(t,a){if(t===void 0)return{kind:"none"};if(!t||typeof t!="object"||Array.isArray(t))return{kind:"none",invalid:!0};const s=t;if(s.status==="unavailable")return{kind:"none",reason:typeof s.reason_code=="string"?s.reason_code:void 0};if(s.status!=="available")return{kind:"none",invalid:!0};const e=s.amount,c=s.wallet_count,o=typeof s.observed_at=="string"?s.observed_at:null,i=o===null?null:ct(o);return s.source!==Jt||s.scope!==Yt||s.currency!=="USDT"||!ue(e)||typeof c!="number"||!Number.isInteger(c)||c<1||c>32||o===null||i===null||i>a?{kind:"none",invalid:!0}:{kind:"available",amount:e,currency:"USDT",observedAt:o}}function an(t,a){const s=new Set(t.filter(e=>e.platform===a).map(e=>e.account_alias));return s.size===1?[...s][0]:null}function sn(t,a,s){if(a!=="binance")return{kind:"no_data"};if(t.phase==="loading")return{kind:"loading"};if(t.phase==="error")return{kind:"read_failed"};if(t.status==="missing")return{kind:"no_data"};if(t.status==="expired")return{kind:"pending"};if(t.status!=="available")return{kind:"unavailable"};const e=t.report;if(!e||typeof e!="object")return{kind:"unavailable"};if(!s)return{kind:"unavailable"};if(e.platform!=="binance")return{kind:"unavailable"};if(e.account_key!==s)return{kind:"no_data"};if(e.scope!==Zt)return{kind:"unavailable"};const c=ct(e.observed_finished_at);return c===null||!Array.isArray(e.assets)?{kind:"unavailable"}:e.assets.every(tn)?{kind:"ready",assetCount:e.assets.filter(o=>en(o.quantity)).length,observedAt:e.observed_finished_at,valuation:nn(e.wallet_valuation,c)}:{kind:"unavailable"}}function it({environment:t}){const a=z();return t?n.jsx(be,{tone:t==="paper"?"accent":"warn",children:a(t==="paper"?"common.paper_badge":"strategies.execution.live")}):null}function rn(t,a=null){if(!t.length)return a;const s=t.map(Ie),e=new Set(s.filter(c=>c!==null));return s.every(c=>c!==null)&&e.size===1?[...e][0]:null}const on=new Set(["state.read_failed","state.not_connected","state.no_data","state.unknown_status"]);function Y({label:t,stateKey:a}){const s=z(),e=on.has(a);return n.jsx("div",{className:"account-facts account-facts-state","data-state":a,children:n.jsxs("span",{className:"account-row",children:[n.jsx("span",{children:t}),n.jsxs("span",{className:"account-facts-state-value",children:[n.jsx("span",{className:"money flat",children:"—"}),n.jsx("span",{className:"account-state-label",children:s(e?a:"facts.amount_unavailable")})]})]})})}function he({value:t,currency:a}){const{prefs:s}=Ye();return t===null?n.jsx("span",{className:"money flat",children:"—"}):s.hideAmounts?n.jsx("span",{className:"money",children:Ze(t)}):n.jsx("span",{className:"money flat",children:at(t,a??null)})}function lt({fact:t,phase:a,conflict:s=!1,ambiguous:e=!1}){const c=z();if(a==="loading")return n.jsx("div",{className:"account-facts",children:n.jsx(J,{height:14})});if(a==="error")return n.jsx(Y,{label:c("facts.assets"),stateKey:"state.read_failed"});if(s)return n.jsx(Y,{label:c("facts.assets"),stateKey:"facts.observation_conflict"});if(e)return n.jsx(Y,{label:c("facts.assets"),stateKey:"facts.identity_unverified"});const o=Gt(t);return o.kind==="not_connected"?n.jsx(Y,{label:c("facts.assets"),stateKey:"state.not_connected"}):o.kind==="identity_unverified"?n.jsx(Y,{label:c("facts.assets"),stateKey:"facts.identity_unverified"}):o.kind==="unknown"?n.jsx(Y,{label:c("facts.assets"),stateKey:"state.unknown_status"}):o.kind==="no_data"?n.jsx(Y,{label:c("facts.assets"),stateKey:"state.no_data"}):!o.balances.length&&!o.cash.length?n.jsx(Y,{label:c("facts.assets"),stateKey:"state.no_data"}):n.jsxs("div",{className:"account-facts",children:[o.balances.map(i=>n.jsxs("span",{className:"account-row account-facts-assets",children:[n.jsxs("span",{children:[c("facts.assets")," · ",i.currency]}),n.jsx(he,{value:i.netAssets,currency:i.currency})]},`assets-${i.currency}`)),o.cash.map(i=>n.jsxs("span",{className:"account-row account-facts-cash",children:[n.jsxs("span",{children:[c(i.available?"facts.available_cash":"facts.cash")," · ",i.currency]}),n.jsx(he,{value:i.cashBalance,currency:i.currency})]},`cash-${i.available?"available-":""}${i.currency}`)),(o.asOf||o.stale)&&n.jsx("div",{className:"kpi-foot account-facts-freshness",children:o.asOf?n.jsx(xe,{value:o.asOf,prefix:o.stale?"facts.as_of_stale":"common.as_of"}):n.jsx("span",{className:"asof",children:c("facts.stale_pending")})})]})}function cn({rows:t,expected:a,phase:s}){const e=z();if(s==="loading")return n.jsx("div",{className:"account-facts",children:n.jsx(J,{height:14})});if(s==="error")return n.jsx(Y,{label:e("facts.platform_total_live"),stateKey:"state.read_failed"});const c=Wt(t,a);if(!c.length){const o=t.filter(d=>!st(d)),i=o.some(d=>Te(d)&&d.aggregation_status==="included"),j=o.some(Te),r=t.length?i?"state.no_data":j?"facts.platform_identity_unverified":"state.no_data":"state.not_connected";return n.jsx(Y,{label:e("facts.platform_total_live"),stateKey:r})}return n.jsx("div",{className:"account-facts account-facts-platform",children:c.map(o=>n.jsxs("div",{className:"account-facts-currency",children:[n.jsxs("span",{className:"account-row account-facts-assets",children:[n.jsxs("span",{title:e("facts.platform_scope_note"),children:[e(o.complete?"facts.platform_total_live":"facts.platform_subtotal_live")," · ",o.currency]}),n.jsx(he,{value:o.netAssets,currency:o.currency})]}),n.jsxs("span",{className:"account-row account-facts-cash",children:[n.jsxs("span",{children:[e("facts.cash")," · ",o.currency]}),n.jsx(he,{value:o.cashBalance,currency:o.currency})]}),n.jsxs("div",{className:"kpi-foot account-facts-freshness",children:[o.covered<o.expected&&n.jsx("span",{className:"asof",children:e("facts.coverage",{covered:o.covered,expected:o.expected})}),o.observationDate?n.jsx("span",{className:"asof",children:e(o.stale?"facts.as_of_stale":"common.as_of",{value:o.observationDate})}):o.stale&&n.jsx("span",{className:"asof",children:e("facts.stale_pending")})]})]},o.currency))})}const ln={read_failed:"facts.wallet_read_failed",no_data:"facts.wallet_no_data",pending:"facts.wallet_pending",unavailable:"facts.wallet_unavailable"};function dn({amount:t}){const{prefs:a}=Ye();return a.hideAmounts?n.jsx("span",{className:"money",children:Ze(t)}):n.jsx("span",{className:"money flat",children:at(t,null)})}function dt({platform:t,accountKey:a,view:s}){const e=z();if(t!=="binance"||!s)return null;const c=sn(s,t,a);if(c.kind==="loading")return n.jsx("div",{className:"account-facts account-facts-binance","data-state":"loading","data-scope":"spot+flexible_earn",children:n.jsx(J,{height:14})});if(c.kind!=="ready")return n.jsx("div",{className:"account-facts account-facts-binance","data-state":c.kind,"data-scope":"spot+flexible_earn",children:n.jsxs("span",{className:"account-row account-facts-assets",children:[n.jsxs("span",{title:e("facts.wallet_scope_note"),children:[e("facts.wallet_valuation")," · USDT"]}),n.jsxs("span",{className:"account-facts-state-value",children:[n.jsx("span",{className:"money flat",children:"—"}),n.jsx("span",{className:"account-state-label",children:e(ln[c.kind])})]})]})});const{valuation:o}=c,i=o.kind==="available";return n.jsxs("div",{className:"account-facts account-facts-binance","data-state":i?"available":"valuation_unavailable","data-scope":"spot+flexible_earn","data-wallet-scope":"provider_returned_wallet_rows","data-reason":i?void 0:o.invalid?"invalid_valuation":o.reason,children:[!i&&n.jsx("span",{className:"account-row account-facts-binance-holdings",title:e("facts.wallet_holdings_scope_note"),children:n.jsx("span",{children:e("facts.wallet_holdings",{count:c.assetCount})})}),n.jsxs("span",{className:"account-row account-facts-assets",children:[n.jsxs("span",{title:e("facts.wallet_scope_note"),children:[e("facts.wallet_valuation")," · USDT"]}),i?n.jsx(dn,{amount:o.amount}):n.jsxs("span",{className:"account-facts-state-value",children:[n.jsx("span",{className:"money flat",children:"—"}),n.jsx("span",{className:"account-state-label",children:e("facts.wallet_unavailable")})]})]}),n.jsx("div",{className:"kpi-foot account-facts-freshness",children:n.jsx(xe,{value:i?o.observedAt:c.observedAt})})]})}const un=["live","paper","unknown"];function fn(t){return t?.broker_environment==="paper"||t?.broker_environment==="live"?t.broker_environment:null}function pn(t,a){const s=new Set,e=new Set;for(const c of t)for(const o of c.rows){const i=Ee(a,o.platform,o.account_alias);i?s.add(i):e.add(Se(o))}return{rows:[...s],expected:s.size+e.size}}function mn(t){return t??"unknown"}function _n({accounts:t,config:a,facts:s,onSelect:e}){const c=ke(a),o=z();return n.jsx("div",{className:"section-stack account-groups",children:ht(t,a).map(i=>{const j=s?pn(i.accounts,s.rows):null,r=i.accounts.map(u=>{const p=[...new Set(u.rows.map(S=>Ee(s?.rows??[],S.platform,S.account_alias)).filter(S=>!!S))],l=p.filter(S=>S.aggregation_status!=="duplicate"),_=l.length===1?l[0]:l.length===0&&p.length===1?p[0]:null,v=new Set(u.rows.map(S=>fn(a?.currentStrategies?.[S.platform]?.[S.account_alias]?.execution_evidence)).filter(S=>S!==null)),b=p.some(S=>S.broker_environment==="paper"||S.broker_environment==="live"||S.account_scope==="paper"||S.account_scope==="live"||S.binding_environment==="paper"||S.binding_environment==="live"),m=rn(p),h=v.size===1?[...v][0]:null,T=m&&h&&m!==h?null:m??(!b&&v.size===1?h:null),y=b||v.size>0,g=Ht(p),I=T??(y?null:g.value),E=!!(T&&g.value&&T!==g.value||g.conflict&&!y),B=i.platform==="binance"?an(u.rows,i.platform):null;return{account:u,canonical:l,representative:_,environment:I,declarationConflict:E,binanceKey:B}}),d=un.map(u=>({environment:u,cards:r.filter(p=>mn(p.environment)===u)})).filter(u=>u.cards.length>0);return n.jsxs("section",{className:"account-platform-group",children:[n.jsx("div",{className:"account-platform-head",children:n.jsx("h2",{className:"account-platform-title",children:c.platform(i.platform)})}),d.map(u=>n.jsxs("section",{className:"account-environment-section","data-environment":u.environment,children:[n.jsxs("div",{className:"account-environment-head",children:[n.jsx("h3",{className:"account-environment-title",children:o(`accounts.environment.${u.environment}`)}),n.jsx("span",{className:"card-note",children:o("accounts.environment_count",{count:u.cards.length})}),u.environment==="live"&&s&&j&&i.platform!=="binance"?n.jsx("div",{className:"account-platform-summary",children:n.jsx(cn,{rows:j.rows,expected:j.expected,phase:s.phase})}):null]}),u.environment!=="live"&&n.jsx("p",{className:"card-note account-environment-note",children:o(`accounts.environment.${u.environment}_note`)}),n.jsx("div",{className:"account-grid",children:u.cards.map(({account:p,canonical:l,representative:_,environment:v,declarationConflict:b,binanceKey:m})=>n.jsxs("article",{className:"card account-group-card",children:[n.jsxs("div",{className:"account-card-head",children:[n.jsx("h3",{className:"account-broker-title",children:c.account(p.rows[0].account_alias,i.platform)}),n.jsx(it,{environment:v})]}),b&&n.jsx("p",{className:"accounts-inline-note error",role:"alert",children:o("accounts.declaration.conflict_notice")}),s&&n.jsx("div",{className:"account-card-facts",children:i.platform==="binance"?n.jsx(dt,{platform:i.platform,accountKey:m,view:s.binance}):n.jsx(lt,{fact:_,phase:s.phase,ambiguous:l.length>1})}),p.rows.map(h=>{const T=c.currentStrategy(h),y=a?.currentStrategies?.[h.platform]?.[h.account_alias]?.execution_evidence,g=a?.currentStrategies?.[h.platform]?.[h.account_alias]?.runtime_target_enabled;return n.jsxs("div",{className:"account-strategy-block",children:[n.jsxs("button",{type:"button",className:"account-strategy-link","aria-label":o("accounts.open_strategy",{account:c.account(h.account_alias,h.platform),strategy:T?c.strategy(T):o("common.unknown")}),onClick:()=>e(Se(h)),children:[n.jsxs("span",{className:"account-strategy-head",children:[n.jsx("span",{className:"account-strategy-name",children:T?c.strategy(T):o("common.unknown")}),n.jsx("span",{className:"account-strategy-chevron","aria-hidden":"true",children:"›"})]}),typeof g=="boolean"&&n.jsxs("span",{className:"account-row",children:[n.jsx("span",{title:o("accounts.execution.runtime_target_note"),children:o("accounts.activation_setting")}),n.jsx("span",{children:o(g?"overview.runtime_enabled":"overview.runtime_disabled")})]}),h.pending_draft_count>0&&n.jsxs("span",{className:"account-row",children:[n.jsx("span",{children:o("accounts.col.drafts")}),n.jsx("span",{children:h.pending_draft_count})]}),h.pending_decision_count!==null&&h.pending_decision_count>0&&n.jsxs("span",{className:"account-row",children:[n.jsx("span",{children:o("accounts.col.todos")}),n.jsx("span",{children:h.pending_decision_count})]}),n.jsxs("span",{className:"account-row",children:[n.jsx("span",{children:o("accounts.col.last_change")}),n.jsx(gt,{value:h.last_change_at})]})]}),n.jsx(At,{evidence:y,compact:!0})]},Se(h))})]},p.identity))})]},u.environment))]},i.platform)})})}const yn=["strategy","dca","cash_reserve","income_layer"];function vn(t,a){return t?.platformMeta?.[a]?.label||a}function pe(t,a,s){return t?.accountOptions?.[a]?.find(c=>c.key===s)?.target_name||s}function hn(t,a){return(t?.strategyProfiles||[]).filter(s=>typeof s?.profile=="string"&&s.profile.length>0).map(s=>({profile:s.profile,label:Xe(s.profile,a,a==="zh"?s.label_zh:s.label_en)}))}function Oe(t,a){const s=t(a.label_key);return s===a.label_key?t(`accounts.field.${a.field}`):s}function Pe(t,a){return t(`accounts.section.${a}`)}function Ce(t,a,s,e=!1,c="en"){return e?t("common.unknown"):s==null||s===""?t("common.na"):typeof s=="boolean"?t(s?"accounts.bool.on":"accounts.bool.off"):a==="dca_mode"&&(s==="fixed"||s==="smart")?t(`accounts.dca_mode.${s}`):a==="strategy_profile"?Xe(String(s),c):String(s)}function Ve(t,a){if(Object.prototype.hasOwnProperty.call(a,t.field)){const s=a[t.field];return s===null||s===void 0?t.current:s}return t.overridden?t.draft:t.current}function qe(t){return t==null?null:typeof t=="number"?String(t):t}function Ke(t,a){const s={};for(const e of t){if(e.field==="option_overlay_enabled"){e.overridden&&(s.option_overlay_enabled=null);continue}Object.prototype.hasOwnProperty.call(a,e.field)?s[e.field]=qe(a[e.field]):e.overridden&&(s[e.field]=qe(e.draft))}return s}function Be(t){const a=[];for(const s of yn){const e=t.filter(c=>c.section===s);e.length&&a.push({section:s,rows:e})}return a}function ut(t){return/^\d+(?:\.\d+)?$/.test(t)&&Number.isFinite(Number(t))}function gn(t){if(!ut(t))return!1;const a=Number(t);return a>=0&&a<=1}function bn(t){return t.length<=32&&/^(?:0|[1-9]\d*)(?:\.\d+)?$/.test(t)&&Number.isFinite(Number(t))&&Number(t)>0}function xn({value:t}){const a=z();return n.jsxs(n.Fragment,{children:[t.data_status!=="ready"&&n.jsx("p",{role:"status",children:a(`cockpit.freshness.${t.data_status}`)}),n.jsxs("dl",{className:"cockpit-meta",children:[n.jsx("dt",{children:a("cockpit.runtime.switch")}),n.jsx("dd",{children:a(t.runtime_enabled===null?"cockpit.unknown":t.runtime_enabled?"cockpit.runtime.enabled":"cockpit.runtime.disabled")}),n.jsx("dt",{children:a("cockpit.runtime.scheduler")}),n.jsx("dd",{children:a(`cockpit.runtime.scheduler.${t.scheduler_state}`)})]}),t.observed_at&&n.jsx(xe,{value:t.observed_at})]})}function kn({scope:t}){const a=z(),s=Z(()=>Rt(t),[t]);return n.jsxs("section",{className:"card",children:[n.jsx("h3",{children:a("cockpit.runtime.title")}),s.phase==="loading"?n.jsx(J,{height:64}):s.phase==="error"?n.jsx(le,{onRetry:s.reload}):s.data.status==="not_ready"?n.jsx("p",{children:a("cockpit.freshness.unavailable")}):n.jsx(xn,{value:s.data.data}),n.jsx("p",{className:"cockpit-note",children:a("cockpit.runtime.boundary")})]})}const je=["dca_mode","dca_base_investment_usd"];function me(t,a){return Object.prototype.hasOwnProperty.call(t,a)}function ft({rows:t,t:a}){const s=Qe();return n.jsx(n.Fragment,{children:Be(t).map(e=>n.jsxs("section",{className:"accounts-diff-section",children:[n.jsx("h3",{children:Pe(a,e.section)}),n.jsx("div",{className:"accounts-field-rows",children:e.rows.map(c=>n.jsxs("div",{className:"accounts-field-row",children:[n.jsx("span",{className:"accounts-field-label",children:Oe(a,c)}),n.jsxs("div",{className:"accounts-field-body",children:[n.jsx("span",{className:"accounts-field-value",children:Ce(a,c.field,c.current,c.current_status==="unknown",s)}),c.overridden&&n.jsx("span",{className:"accounts-field-current",children:a("accounts.draft_value",{value:Ce(a,c.field,c.draft,!1,s)})})]})]},c.field))})]},e.section))})}function jn({rows:t,t:a}){return n.jsx(n.Fragment,{children:Be(t).map(s=>n.jsxs("div",{className:"accounts-diff-section",children:[n.jsx("h3",{children:Pe(a,s.section)}),n.jsx(Pt,{rows:s.rows})]},s.section))})}function Nn({account:t,diffState:a,config:s,editing:e,setEditing:c,edits:o,setEdits:i,confirm:j}){const r=Qe(),d=ke(s),u=D.useId(),p=f=>`${u}-${f}`,l=z(),_=Re(),[v,b]=D.useState(!1),[m,h]=D.useState(!1),[T,y]=D.useState(null),[g,I]=D.useState({});if(a.phase==="loading")return n.jsx(J,{height:220});if(a.phase==="error")return n.jsx(le,{onRetry:a.reload});const E=a.data,B=E.rows,S=B.some(f=>f.field==="option_overlay_enabled"&&f.overridden),$=E.identity_status==="identity_conflict",C=hn(s,r),M=Object.keys(o).length>0,V=(f,N)=>{I(R=>({...R,[f]:void 0})),i(R=>{const w={...R,[f]:N};if(je.includes(f)){const P=f==="dca_mode"?"dca_base_investment_usd":"dca_mode";if(!me(w,P)){const K=B.find(U=>U.field===P);K&&(w[P]=K.overridden?K.draft:K.current)}}return w})},F=f=>{I(N=>({...N,[f]:void 0})),i(N=>{const R={...N};return delete R[f],je.includes(f)&&delete R[f==="dca_mode"?"dca_base_investment_usd":"dca_mode"],R})},q=f=>{if(je.includes(f)){I(N=>({...N,dca_mode:void 0,dca_base_investment_usd:void 0})),i(N=>({...N,dca_mode:null,dca_base_investment_usd:null}));return}V(f,null)},x=()=>{const f={};for(const P of Object.keys(o)){const K=o[P];if(K==null)continue;const U=String(K);P==="strategy_profile"&&!U.trim()&&(f[P]=l("accounts.form.select_profile")),P==="reserved_cash_floor"&&!ut(U)&&(f[P]=l("accounts.form.invalid_decimal")),P==="reserved_cash_ratio"&&!gn(U)&&(f[P]=l("accounts.form.invalid_ratio")),P==="dca_base_investment_usd"&&!bn(U)&&(f[P]=l("accounts.form.invalid_dca_amount"))}const N=Ke(B,o),R=typeof N.dca_mode=="string"&&N.dca_mode.length>0,w=typeof N.dca_base_investment_usd=="string"&&N.dca_base_investment_usd.length>0;return R!==w&&(f.dca_mode=l("accounts.form.dca_pair_required")),I(f),Object.keys(f).length===0},k=async f=>{h(!0),y(null);let N;try{const R=await ie(t.platform,t.account_alias);if(!R.identity||typeof R.identity!="object"||Array.isArray(R.identity))throw new Error("identity_missing");N=R.identity}catch{y({kind:"error",text:l("error.generic")}),h(!1);return}try{await bt({platform:t.platform,key:t.account_alias,identity:N,expected_draft_revision:f.draft_revision,overrides:Ke(f.rows,o)}),i({}),c(!1),y({kind:"success",text:`${l("accounts.draft_saved")} ${l("accounts.draft_note")}`}),a.reload()}catch(R){if(R instanceof xt&&R.status===409){const w=R.payload?.error,P=l(w==="account_settings_draft_revision_conflict"?"accounts.conflict":w==="account_settings_identity_conflict"?"accounts.identity_conflict":"error.conflict");y({kind:"error",text:P}),a.reload()}else y({kind:"error",text:l("accounts.save_unknown")})}finally{h(!1)}},O=async()=>{if(x()){b(!0),y(null);try{const f=await et(t.account_alias,t.platform);if(f.identity_status==="identity_conflict"){y({kind:"error",text:l("accounts.identity_conflict")}),a.reload();return}const N=f.rows.filter(w=>{const P=w.overridden?w.draft:w.current,K=me(o,w.field)?o[w.field]:P;return String(K??"")!==String(P??"")}).map(w=>{const P=me(o,w.field)&&o[w.field]===null,K=P?w.current:Ve(w,o);return{section:w.section,field:w.field,label:Oe(l,w),before:w.current_status==="unknown"?null:w.current,after:P?l("accounts.form.inherit"):K,affectsLive:w.affects_live}});if(!N.length){_({kind:"info",text:l("accounts.no_changes")});return}await j({title:l("accounts.diff_dialog_title"),target:d.account(t.account_alias,t.platform),summary:l("accounts.draft_note"),body:n.jsx(jn,{rows:N,t:l}),ackLabel:N.some(w=>w.affectsLive)?l("accounts.ack_live"):void 0,confirmLabel:l("accounts.save_draft"),tone:"normal"})&&await k(f)}catch{_({kind:"error",text:l("error.generic")})}finally{b(!1)}}},A=async()=>{M&&!await j({title:l("common.unsaved_guard_title"),summary:l("common.unsaved_guard_body"),tone:"normal"})||(i({}),I({}),c(!1))},L=f=>{const N=Ve(f,o),R=me(o,f.field),w=N==null?"":String(N),P=g[f.field],K={id:p(f.field),"aria-invalid":!!P,"aria-describedby":P?`${p(f.field)}-error`:void 0};let U;if(f.field==="strategy_profile"){const W=C.some(H=>H.profile===w);U=n.jsxs("select",{...K,className:"input",value:w,onChange:H=>V(f.field,H.target.value),children:[!w&&n.jsx("option",{value:"",disabled:!0,children:l("accounts.form.select_profile")}),w&&!W&&n.jsx("option",{value:w,children:w}),C.map(H=>n.jsx("option",{value:H.profile,children:H.label},H.profile))]})}else f.field==="dca_mode"?U=n.jsxs("select",{...K,className:"input",value:w,onChange:W=>V(f.field,W.target.value),children:[!w&&n.jsx("option",{value:"",disabled:!0,children:l("common.na")}),n.jsx("option",{value:"fixed",children:l("accounts.dca_mode.fixed")}),n.jsx("option",{value:"smart",children:l("accounts.dca_mode.smart")})]}):f.field==="income_layer_enabled"?U=n.jsxs("select",{...K,className:"input",value:w,onChange:W=>V(f.field,W.target.value==="true"),children:[!w&&n.jsx("option",{value:"",disabled:!0,children:l("common.na")}),n.jsx("option",{value:"true",children:l("accounts.bool.on")}),n.jsx("option",{value:"false",children:l("accounts.bool.off")})]}):U=n.jsx("input",{...K,className:"input",value:w,inputMode:"decimal",maxLength:32,onChange:W=>V(f.field,W.target.value)});return n.jsxs("div",{className:"accounts-field-body",children:[n.jsxs("div",{className:"accounts-field-control",children:[U,R&&n.jsx("button",{type:"button",className:"button button-secondary button-sm",onClick:()=>F(f.field),children:l("accounts.form.undo")}),!R&&f.overridden&&n.jsx("button",{type:"button",className:"button button-secondary button-sm",onClick:()=>q(f.field),children:l("accounts.form.clear_override")})]}),n.jsxs("span",{className:"accounts-field-current",children:[l("decisions.col.current")," · ",Ce(l,f.field,f.current,f.current_status==="unknown",r)]}),P&&n.jsx("span",{id:`${p(f.field)}-error`,className:"accounts-field-error",children:P})]})};return n.jsxs("section",{className:"card",children:[n.jsxs("div",{className:"accounts-toolbar",children:[n.jsx(be,{tone:e?"accent":"unknown",children:l(e?"accounts.editing":"accounts.viewing")}),n.jsx("span",{className:"asof",children:l("accounts.draft_revision",{value:E.draft_revision})}),n.jsx("span",{style:{flex:1}}),!e&&n.jsx("button",{type:"button",className:"button button-secondary",onClick:()=>c(!0),children:l("accounts.edit")}),e&&n.jsxs(n.Fragment,{children:[n.jsx("button",{type:"button",className:"button button-primary",disabled:v||m||$,onClick:()=>{O()},children:l(v?"accounts.checking":"accounts.check_changes")}),n.jsx("button",{type:"button",className:"button button-secondary",disabled:v||m,onClick:()=>{A()},children:l("common.cancel")})]})]}),S&&n.jsx("p",{className:"accounts-inline-note",children:l("accounts.retired_option_draft")}),$&&n.jsxs("p",{className:"accounts-inline-note error",role:"alert",children:[l("accounts.identity_conflict")," ",n.jsx("button",{type:"button",className:"accounts-alias-button",onClick:a.reload,children:l("common.refresh")})]}),T&&n.jsxs("p",{className:`accounts-inline-note ${T.kind}`,role:"status",children:[T.text," ",T.kind==="error"&&n.jsx("button",{type:"button",className:"accounts-alias-button",onClick:a.reload,children:l("common.refresh")})]}),m&&n.jsx("p",{className:"accounts-inline-note",role:"status",children:l("accounts.saving")}),e?Be(B).map(f=>n.jsxs("section",{className:"accounts-diff-section",children:[n.jsx("h3",{children:Pe(l,f.section)}),n.jsx("div",{className:"accounts-field-rows",children:f.rows.map(N=>n.jsxs("div",{className:"accounts-field-row",children:[n.jsx("label",{className:"accounts-field-label",htmlFor:p(N.field),children:Oe(l,N)}),L(N)]},N.field))})]},f.section)):n.jsx(ft,{rows:B,t:l})]})}function wn({children:t}){const a=z();return n.jsxs("section",{className:"danger-zone","aria-label":a("controls.title"),children:[n.jsx("h3",{className:"danger-zone-title",children:a("controls.title")}),n.jsx("p",{className:"card-note",style:{margin:0},children:a("controls.danger_note")}),t]})}function Sn({title:t,summary:a,action:s,unavailableReason:e}){const c=z();return n.jsxs("div",{className:"danger-row",children:[n.jsxs("div",{className:"danger-row-text",children:[n.jsx("strong",{children:t}),n.jsx("p",{children:a}),e&&n.jsx("p",{children:c("controls.unavailable",{reason:e})})]}),n.jsx("div",{children:s})]})}const Tn=new Set(["ibkr","schwab"]),Ue=new Set(["reserved","accepted","unknown","partial"]),On=new Set(["applied","protected","rejected"]),Cn=[{name:"enable",titleKey:"controls.enable",summaryKey:"controls.enable_summary"},{name:"stop",titleKey:"controls.stop",summaryKey:"controls.stop_summary"},{name:"resume",titleKey:"controls.resume",summaryKey:"controls.resume_summary"},{name:"approve_application",titleKey:"controls.approve_application",summaryKey:"controls.approve_summary"}];function An({account:t,config:a,confirm:s}){const e=z(),c=Re(),o=ke(a),i=Z(()=>kt(t.account_alias,t.platform),[t.account_alias,t.platform]),[j,r]=D.useState(null),[d,u]=D.useState({}),p=`${t.platform}:${t.account_alias}`,[l,_]=D.useState(null),[v,b]=D.useState(null);if(D.useEffect(()=>{if(i.phase!=="ready"||!l||l.targetKey!==p||i.data.account_alias!==t.account_alias||i.data.platform!==t.platform)return;const k=i.data.runtime_control;!k||k.request_id!==l.requestId||On.has(k.phase||"")&&_(null)},[i,l,p]),i.phase==="loading")return n.jsx(J,{height:200});if(i.phase==="error")return n.jsx(le,{onRetry:i.reload});const m=i.data;if(m.account_alias!==t.account_alias||m.platform!==t.platform)return n.jsx(J,{height:200});const h=Tn.has(t.platform.toLowerCase()),T=k=>{const O=`reason.${k}`,A=e(O);return A===O?k:A},y=m.runtime_control,g=l?.targetKey===p||!!(y&&Ue.has(y.phase||"")),I=y?.unavailable_reason?T(y.unavailable_reason):y&&(y.phase==="unknown"||y.phase==="partial")?e("controls.unknown_result"):e("controls.submitted"),E=y?.phase==="applied"&&y.platform_applied===!0&&(y.action==="enable"||y.action==="disable")?e(y.action==="enable"?"controls.result.enable":"controls.result.disable"):null,B=async()=>{try{await ne("/api/runtime-stop",{platform:t.platform,target_name:pe(a,t.platform,t.account_alias),operation:"inspect",confirm:"READ_ONLY"})}catch{}finally{i.reload()}},S=()=>{if(u({}),!h||!y||!Ue.has(y.phase||"")){i.reload();return}B()},$=(k,O)=>{u(A=>({...A,[k]:O?"submitted":"unknown"})),c({kind:O?"success":"error",text:e(O?"controls.submitted":"controls.unknown_result")})},C=async()=>{if(h){await F("disable");return}if(await s({title:e("controls.stop_confirm_title"),target:o.account(t.account_alias,t.platform),summary:e("controls.stop_summary"),consequence:e("controls.stop_consequence"),tone:"danger",confirmLabel:e("controls.stop"),typeToConfirm:{label:e("controls.stop_type_alias",{alias:t.account_alias}),expected:t.account_alias,mismatch:e("controls.alias_mismatch")}})){r("stop");try{await ne("/api/runtime-stop",{platform:t.platform,target_name:pe(a,t.platform,t.account_alias),confirm:"STOP_ONLY"}),$("stop",!0)}catch{$("stop",!1)}finally{r(null)}}},M=async()=>{const k=m.resume_binding?.runtime_target_sha256;if(!(typeof k!="string"||!k||!await s({title:e("controls.confirm.resume_title"),target:o.account(t.account_alias,t.platform),summary:e("controls.resume_summary"),tone:"danger",confirmLabel:e("controls.resume")}))){r("resume");try{await ne("/api/runtime-resume",{platform:t.platform,target_name:pe(a,t.platform,t.account_alias),runtime_target_sha256:k,confirm:"RESUME_EXISTING"}),$("resume",!0)}catch{$("resume",!1)}finally{r(null)}}},V=async()=>{if(await s({title:e("controls.confirm.approve_title"),target:o.account(t.account_alias,t.platform),summary:e("controls.approve_summary"),tone:"danger",confirmLabel:e("controls.approve_application")})){r("approve_application");try{const O=await ie(t.platform,t.account_alias),A=O.draft?.overrides||{},L=Object.keys(A),f=typeof A.strategy_profile=="string"?A.strategy_profile.trim():"",N=O.effective?.strategy_profile,R=N?.status==="known"&&typeof N.value=="string"?N.value.trim():"";if(!!!(O.identity&&Number.isSafeInteger(O.instance_revision)&&Number.isSafeInteger(O.draft?.revision)&&L.length===1&&L[0]==="strategy_profile"&&f&&R&&f!==R)){c({kind:"error",text:e("controls.approve_not_ready")});return}await ne("/api/account-settings/profile-application/approve",{platform:t.platform,key:t.account_alias,request_key:crypto.randomUUID(),identity:O.identity,expected_instance_revision:O.instance_revision,expected_draft_revision:O.draft?.revision,old_profile:R,new_profile:f}),$("approve_application",!0)}catch{$("approve_application",!1)}finally{r(null)}}},F=async k=>{const O=k==="enable"?"enable":"stop";if(!await s(k==="enable"?{title:e("controls.confirm.enable_title"),target:o.account(t.account_alias,t.platform),summary:e("controls.enable_summary"),consequence:e("controls.enable_control_note"),tone:"normal",confirmLabel:e("controls.enable")}:{title:e("controls.stop_confirm_title"),target:o.account(t.account_alias,t.platform),summary:e("controls.stop_summary"),consequence:e("controls.stop_consequence"),tone:"danger",confirmLabel:e("controls.stop"),typeToConfirm:{label:e("controls.stop_type_alias",{alias:t.account_alias}),expected:t.account_alias,mismatch:e("controls.alias_mismatch")}}))return;const L=crypto.randomUUID();_({requestId:L,targetKey:p}),b({name:O,targetKey:p});try{await ne("/api/runtime-stop",{platform:t.platform,target_name:pe(a,t.platform,t.account_alias),operation:k,request_id:L,confirm:"CONTROL_ONLY"}),c({kind:"success",text:e("controls.submitted")})}catch{c({kind:"error",text:e("controls.unknown_result")})}finally{b(f=>f?.targetKey===p?null:f),i.reload()}},x={enable:async()=>{if(h){await F("enable");return}await s({title:e("controls.confirm.enable_title"),target:o.account(t.account_alias,t.platform),summary:e("controls.enable_summary"),consequence:e("controls.enable_note"),tone:"normal",confirmLabel:e("common.close")})},stop:C,resume:M,approve_application:V};return n.jsxs("div",{className:"section-stack",children:[h&&y?.phase==="rejected"&&y.unavailable_reason&&n.jsx("p",{className:"card-note",children:T(y.unavailable_reason)}),h&&y?.phase==="protected"&&n.jsx("p",{className:"card-note",children:e("controls.protected")}),h&&E&&n.jsx("p",{className:"card-note",children:E}),n.jsx(wn,{children:Cn.map(({name:k,titleKey:O,summaryKey:A})=>{const L=m.actions[k],f=d[k],N=g&&(k==="enable"||k==="stop"),R=j!==null||v?.targetKey===p||!!f||N||!L.enabled,w=f?e(f==="submitted"?"controls.submitted":"controls.unknown_result"):N?I:L.enabled?null:T(L.reason);return n.jsx(Sn,{title:e(O),summary:e(A),unavailableReason:w,action:n.jsx("button",{type:"button",className:`button ${k==="stop"||k==="resume"?"button-danger-outline":"button-secondary"}`,disabled:R,onClick:()=>{x[k]()},children:j===k||v?.targetKey===p&&v.name===k?e("controls.submitting"):e(O)})},k)})}),n.jsx("p",{className:"card-note",children:n.jsx("button",{type:"button",className:"accounts-alias-button",onClick:S,children:e("common.refresh")})})]})}function Rn({account:t}){const a=z(),s=Re(),e=Z(()=>$e(t.account_alias,t.platform),[t.account_alias,t.platform]),[c,o]=D.useState([]),[i,j]=D.useState(null),[r,d]=D.useState(null),[u,p]=D.useState(!1);if(D.useEffect(()=>{e.phase==="ready"&&(o(e.data.items),j(e.data.next_cursor),d(e.data.availability))},[e.phase,e.data]),e.phase==="loading")return n.jsx(J,{height:200});if(e.phase==="error")return n.jsx(le,{onRetry:e.reload});const l=async()=>{if(i){p(!0);try{const m=await $e(t.account_alias,t.platform,25,i);o(h=>[...h,...m.items]),j(m.next_cursor),d(m.availability)}catch{s({kind:"error",text:a("error.generic")})}finally{p(!1)}}},_=m=>m.event==="draft_saved"?a("accounts.event.draft_saved"):m.event==="approved"?a("accounts.event.approved"):a("accounts.event.unrecorded"),v=c.map(m=>{const h=[m.actor_alias||a("accounts.event.unrecorded"),m.draft_revision===null?null:a("accounts.draft_revision",{value:m.draft_revision}),m.source?null:a("accounts.event.unrecorded"),a("decisions.ref",{id:m.short_id})].filter(Boolean),T=h.filter((y,g)=>y!==h[g-1]).join(" · ");return{id:m.id,time:m.time,title:_(m),detail:T}}),b=r?.effect_verification;return n.jsxs("section",{className:"card",children:[n.jsx("h2",{className:"card-title",children:a("accounts.tab.history")}),c.length===0?n.jsx(tt,{title:a("accounts.history.empty")}):n.jsx(Bt,{items:v}),i&&n.jsx("div",{style:{marginTop:12},children:n.jsx("button",{type:"button",className:"button button-secondary",disabled:u,onClick:()=>{l()},children:a(u?"common.loading":"common.load_more")})}),b&&b.status!=="ok"&&n.jsxs("div",{className:"card-note",role:"status","data-state":b.status,children:[n.jsx("p",{children:a("accounts.effect_unconfirmed")}),n.jsx(de,{status:b.status,reason:b.unavailable_reason}),b.unavailable_reason&&n.jsx("span",{className:"state-short",children:a(`reason.${b.unavailable_reason}`)})]})]})}function Dn(){let t=0;return{begin(){return t+=1,t},isCurrent(a){return a===t},invalidate(){t+=1}}}async function pt(t,a,s){try{const e=await s();return t.isCurrent(a)?t.applyRefresh(a,e)?{status:"ready"}:(t.abandon(a),{status:"failed",message:"设置读回与所选账户不一致，请重新读取。"}):{status:"superseded"}}catch(e){if(!t.isCurrent(a))return{status:"superseded"};t.abandon(a);const c=Number(e?.status||0);return{status:"failed",message:c===401||c===403?"没有权限读取这项设置。":"账户设置暂时读不到。"}}}function G(t){return!!t&&typeof t=="object"&&!Array.isArray(t)}function re(t){return JSON.parse(JSON.stringify(t))}function Q(t,a){const s=e=>Array.isArray(e)?e.map(s):G(e)?Object.fromEntries(Object.keys(e).sort().map(c=>[c,s(e[c])])):e;return JSON.stringify(s(t))===JSON.stringify(s(a))}function mt(t){return G(t)&&["empty","current","identity_conflict"].includes(t.status)&&t.source==="user_declared"&&Number.isSafeInteger(t.revision)&&t.revision>=0&&[null,"live","paper"].includes(t.environment)&&[null,"cash","margin"].includes(t.account_type)}function Ne(t,a){const s=t.body;if(!G(a)||a.ok!==!0||a.platform!==s.platform||a.key!==s.key||!G(a.identity)||!Q(a.identity,s.identity)||a.adopted!==!1||a.no_order!==!0||a.execution_authority_granted!==!1||!G(a.draft)||!["empty","current","identity_conflict"].includes(a.draft.status)||!Number.isSafeInteger(a.draft.revision)||a.draft.revision<0||!G(a.draft.overrides)||!G(a.draft.current_identity)||!Q(a.draft.current_identity,s.identity)||!G(a.risk)||!Number.isSafeInteger(a.risk.revision)||a.risk.revision<0||typeof t.risk.scope_id!="string"||!t.risk.scope_id||a.risk.scope_id!==t.risk.scope_id||![null,"CAPITAL_PRESERVATION","BALANCED_COMPOUNDING","GROWTH_COMPOUNDING"].includes(a.risk.preference))return!1;const e=a.declaration,c=Object.prototype.hasOwnProperty.call(s,"declaration");if(t.declaration.present||c){if(!mt(e))return!1;if(c){if(!G(s.declaration)||e.status!=="current"||e.revision!==t.declaration.revision+1||e.environment!==s.declaration.environment||e.account_type!==s.declaration.account_type)return!1}else if(e.revision<t.declaration.revision||e.revision===t.declaration.revision&&!Q({status:e.status,revision:e.revision,environment:e.environment,account_type:e.account_type,source:e.source},{status:t.declaration.status,revision:t.declaration.revision,environment:t.declaration.environment,account_type:t.declaration.account_type,source:t.declaration.source}))return!1}if(!Object.prototype.hasOwnProperty.call(s,"overrides")){const o=a.draft;if(o.revision<t.draft.revision||o.revision===t.draft.revision&&!Q({status:o.status,revision:o.revision,identity:o.identity,current_identity:o.current_identity,overrides:o.overrides},t.draft))return!1}if(!Object.prototype.hasOwnProperty.call(s,"risk_preference")){const o=a.risk;if(o.revision<t.risk.revision||o.revision===t.risk.revision&&o.preference!==t.risk.preference)return!1}if(Object.prototype.hasOwnProperty.call(s,"overrides")){const o=a.draft;if(!G(o)||o.status!=="current"||!G(o.overrides)||!G(o.identity)||!Q(o.identity,s.identity)||!G(o.current_identity)||!Q(o.current_identity,s.identity))return!1;const i=t.draft.status==="identity_conflict"&&s.acknowledge_identity_conflict===!0,j=i?{}:{...t.draft.overrides};for(const[u,p]of Object.entries(s.overrides))p===null?delete j[u]:j[u]=p;const r=t.draft.status==="empty"||i||!Q(j,t.draft.overrides),d=t.draft.revision+(r?1:0);if(!Number.isSafeInteger(d)||d<0||o.revision!==d||!Q(o.overrides,j))return!1}if(Object.prototype.hasOwnProperty.call(s,"risk_preference")){const o=a.risk;if(!G(o)||typeof t.risk.scope_id!="string"||!t.risk.scope_id||o.scope_id!==t.risk.scope_id||o.preference!==s.risk_preference||!Number.isSafeInteger(o.revision)||o.revision<0)return!1;const i=s.risk_preference!==t.risk.preference,j=t.risk.revision+(i?1:0),r=!i&&s.risk_preference!==null&&o.revision===j+1;if(!Number.isSafeInteger(j)||o.revision!==j&&!r)return!1}return!0}function _t(){return{strategy:"",floor:"",ratio:"",percent:"",income:"",option:"",dcaMode:"",dcaAmount:"",dcaProfile:"",strategyTouched:!1,incomeTouched:!1,optionTouched:!1,floorTouched:!1,ratioTouched:!1,dcaTouched:!1,clearStrategy:!1,clearFloor:!1,clearRatio:!1,clearDca:!1,cashMode:"",acknowledge:!1}}function Ae(){return{draft:!1,risk:!1,declaration:!1}}function ye(t,a){return!t||!Object.prototype.hasOwnProperty.call(t,a)?"":t[a]===!0?"true":t[a]===!1?"false":""}function Ge(t){return ye(t,"income_layer_enabled")}function X(t,a){const s=t?.effective?.[a];return s?.status==="known"&&typeof s.value=="string"?s.value:""}function ge(t,a){return JSON.stringify(t??null)===JSON.stringify(a??null)}function te(t){const a=G(t)?t:{};return{environment:a.environment==="live"||a.environment==="paper"?a.environment:"",accountType:a.account_type==="cash"||a.account_type==="margin"?a.account_type:""}}function oe(t){return Object.prototype.hasOwnProperty.call(t,"risk_preference")?"risk":Object.prototype.hasOwnProperty.call(t,"declaration")?"declaration":"draft"}function ze(t){if(t.body&&Object.prototype.hasOwnProperty.call(t.body,"declaration"))return"declaration";if(t.body&&Object.prototype.hasOwnProperty.call(t.body,"risk_preference"))return"risk";const a=t.body?.overrides;if(!a||typeof a!="object"||Array.isArray(a))return"";const s=a;return Object.prototype.hasOwnProperty.call(s,"strategy_profile")||Object.prototype.hasOwnProperty.call(s,"dca_mode")||Object.prototype.hasOwnProperty.call(s,"dca_base_investment_usd")?"strategy":Object.prototype.hasOwnProperty.call(s,"option_overlay_enabled")?"option":Object.prototype.hasOwnProperty.call(s,"income_layer_enabled")?"income":Object.prototype.hasOwnProperty.call(s,"reserved_cash_floor")||Object.prototype.hasOwnProperty.call(s,"reserved_cash_ratio")?"cash":""}function We(){return{account:null,settings:null,preference:"",declaration:{environment:"",accountType:""},notice:"",noticeGroup:"",unavailable:"",saving:"",review:Ae(),draft:_t()}}function we(t){return/^\d+(?:\.\d+)?$/.test(t)&&Number.isFinite(Number(t))}function En(t){return t.length<=32&&/^(?:0|[1-9]\d*)(?:\.\d+)?$/.test(t)&&Number.isFinite(Number(t))&&Number(t)>0}function ce(t){return t.strategyTouched===!0||t.dcaTouched===!0||t.clearDca===!0}function He(t){return t.cashMode==="ratio"||t.cashMode==="both"||t.percent!==""?Mt(t.percent):$t(t.ratio)}function Je(t,a="all"){const s={},e=a==="all"||a==="strategy",c=a==="all"||a==="income",o=a==="all"||a==="cash";if(e){if(t.clearDca)s.dca_mode=null,s.dca_base_investment_usd=null;else if(t.dcaTouched){if(t.dcaMode!=="fixed"&&t.dcaMode!=="smart"||!En(t.dcaAmount))return null;s.dca_mode=t.dcaMode,s.dca_base_investment_usd=t.dcaAmount}t.clearStrategy?s.strategy_profile=null:t.strategyTouched&&t.strategy?s.strategy_profile=t.strategy:(t.dcaTouched||t.clearDca)&&t.dcaProfile&&(s.strategy_profile=t.dcaProfile)}if(c&&(t.incomeTouched&&t.income==="true"?s.income_layer_enabled=!0:t.incomeTouched&&t.income==="false"?s.income_layer_enabled=!1:t.incomeTouched&&t.income==="clear"&&(s.income_layer_enabled=null)),o)if(t.cashMode==="inherit")s.reserved_cash_floor=null,s.reserved_cash_ratio=null;else if(t.cashMode==="floor"){if(!we(t.floor))return null;s.reserved_cash_floor=t.floor,s.reserved_cash_ratio="0"}else if(t.cashMode==="ratio"||t.cashMode==="both"){const i=He(t);if(!i||t.cashMode==="both"&&!we(t.floor))return null;s.reserved_cash_floor=t.cashMode==="ratio"?"0":t.floor,s.reserved_cash_ratio=i}else{if(t.clearFloor)s.reserved_cash_floor=null;else if(t.floorTouched){if(!we(t.floor))return null;s.reserved_cash_floor=t.floor}if(t.clearRatio)s.reserved_cash_ratio=null;else if(t.ratioTouched){const i=He(t);if(!i)return null;s.reserved_cash_ratio=i}}return s}function yt(t=new Map){const a=Dn();let s=null,e=We(),c=null,o=null;const i=r=>!!(s&&r&&s.platform===r.platform&&s.key===r.key),j=r=>!!(r&&a.isCurrent(r.token)&&i(r.account));return{selectedId(){return s?`${s.platform}:${s.key}`:""},view(){const r=t.get(this.selectedId());if(r){const d=oe(r.body);e={...e,review:{...e.review,[d]:!0}}}return e},riskDirty(){const r=e.settings||c;return(e.preference||"")!==(typeof r?.risk?.preference=="string"?r.risk.preference:"")},declarationDirty(){const r=e.settings||c,d=te(r?.declaration);return e.declaration.environment!==d.environment||e.declaration.accountType!==d.accountType},select(r){const d=!i(r);return s={platform:r.platform,key:r.key},d&&(a.invalidate(),e={...We(),account:s},c=null,o=null),this.start("read")},start(r){if(!s)throw new Error("account_settings_account_required");return{token:a.begin(),account:{platform:s.platform,key:s.key},kind:r}},isCurrent(r){return j(r)},abandon(r){j(r)&&a.invalidate()},applyRead(r,d,u={}){if(!j(r)||d?.platform!==r.account.platform||d?.key!==r.account.key)return!1;const p=t.get(this.selectedId());if((G((e.settings||c)?.declaration)||p?.declaration.present||Object.prototype.hasOwnProperty.call(d,"declaration"))&&!mt(d.declaration))return!1;const _=p&&Ne(p,d);_&&t.delete(this.selectedId());const v=d.draft?.overrides||{},b=typeof(e.settings||c)?.risk?.preference=="string"?(e.settings||c).risk.preference:"",m=u.keepCash===!0&&ee(e.draft),h=te((e.settings||c)?.declaration),T=u.keepDeclaration===!0&&(e.declaration.environment!==h.environment||e.declaration.accountType!==h.accountType),y=u.keepPreference===!0&&(e.preference||"")!==b,g=u.keepIncome===!0&&e.draft.incomeTouched===!0,I=u.keepStrategy===!0&&ce(e.draft),E=u.keepOption===!0&&e.draft.optionTouched===!0;if(c=d,e={account:{platform:r.account.platform,key:r.account.key},settings:d,preference:y?e.preference:d.risk?.preference||"",declaration:T?e.declaration:te(d.declaration),notice:u.preserveNotice?e.notice:"",noticeGroup:u.preserveNotice?e.noticeGroup:"",unavailable:"",saving:"",review:Ae(),draft:{strategy:I?e.draft.strategy:typeof v.strategy_profile=="string"?v.strategy_profile:"",floor:m?e.draft.floor:typeof v.reserved_cash_floor=="string"?v.reserved_cash_floor:"",ratio:m?e.draft.ratio:typeof v.reserved_cash_ratio=="string"?v.reserved_cash_ratio:"",percent:m?e.draft.percent:"",income:g?e.draft.income:Ge(v),option:E?e.draft.option:ye(v,"option_overlay_enabled"),dcaMode:I?e.draft.dcaMode:v.dca_mode==="fixed"||v.dca_mode==="smart"?v.dca_mode:d.current_dca_supported===!0?X(d,"dca_mode"):"",dcaAmount:I?e.draft.dcaAmount:typeof v.dca_base_investment_usd=="string"?v.dca_base_investment_usd:d.current_dca_supported===!0?X(d,"dca_base_investment_usd"):"",dcaProfile:I?e.draft.dcaProfile:typeof v.strategy_profile=="string"?v.strategy_profile:d.current_dca_supported===!0?X(d,"strategy_profile"):"",strategyTouched:I?e.draft.strategyTouched:!1,incomeTouched:g,optionTouched:E,floorTouched:m?e.draft.floorTouched:!1,ratioTouched:m?e.draft.ratioTouched:!1,dcaTouched:I?e.draft.dcaTouched:!1,clearStrategy:I?e.draft.clearStrategy:!1,clearDca:I?e.draft.clearDca:!1,clearFloor:m?e.draft.clearFloor:!1,clearRatio:m?e.draft.clearRatio:!1,cashMode:m?e.draft.cashMode:"",acknowledge:!1}},p){const B=oe(p.body);e={...e,notice:_?B==="risk"?"偏好已保存":B==="declaration"?"声明已保存":"草案已保存":"状态未知",noticeGroup:_?ze({...r,body:p.body}):"",review:{...e.review,[B]:!_}}}return!0},applyUnavailable(r,d){return j(r)?(e={...e,settings:null,unavailable:d,saving:""},!0):!1},edit(r){if(!e.settings||!i(e.account))return!1;const{preference:d,...u}=r;return e={...e,preference:d===void 0?e.preference:d,draft:{...e.draft,...u}},!0},editDeclaration(r){return!e.settings||!i(e.account)?!1:(e={...e,declaration:{...e.declaration,...r}},!0)},startSave(r){if(e.saving||t.has(this.selectedId())||!s||!e.settings||!i(e.account)||e.settings.platform!==s.platform||e.settings.key!==s.key||!e.settings.identity||typeof e.settings.identity!="object")return null;const d={platform:s.platform,key:s.key};let u;if(r==="declaration"){if(e.settings.operations?.save_declaration!==!0||e.review?.declaration||!Number.isSafeInteger(e.settings.declaration?.revision))return null;const l=te(e.settings.declaration);if(e.declaration.environment===l.environment&&e.declaration.accountType===l.accountType)return null;u={platform:d.platform,key:d.key,identity:e.settings.identity,expected_declaration_revision:e.settings.declaration.revision,declaration:{environment:e.declaration.environment||null,account_type:e.declaration.accountType||null}}}else if(r==="risk"){if(e.settings.operations?.save_risk_preference!==!0||e.review?.risk||!Number.isSafeInteger(e.settings.risk?.revision))return null;u={platform:d.platform,key:d.key,identity:e.settings.identity,expected_risk_revision:e.settings.risk.revision,risk_preference:e.preference||null}}else{if(e.settings.operations?.save_draft!==!0||r==="option"&&(e.draft.option==="true"||e.draft.option==="false")&&e.settings.operations?.save_option_draft!==!0||e.review?.draft||e.settings.draft?.status==="identity_conflict"&&!e.draft.acknowledge)return null;const l=r==="income"||r==="cash"||r==="option"||r==="strategy"?r:"all",_=Je(e.draft,l);if(r==="strategy"&&!Object.prototype.hasOwnProperty.call(_||{},"strategy_profile")||!_||!Object.keys(_).length||!Number.isSafeInteger(e.settings.draft?.revision))return null;Object.prototype.hasOwnProperty.call(e.settings.draft?.overrides||{},"option_overlay_enabled")&&(_.option_overlay_enabled=null),u={platform:d.platform,key:d.key,...Ft({expectedDraftRevision:e.settings.draft.revision,identity:e.settings.identity,overrides:_,acknowledgeIdentityConflict:e.settings.draft?.status==="identity_conflict"&&e.draft.acknowledge})}}if(u.platform!==d.platform||u.key!==d.key)return null;const p=a.begin();return o={token:p,body:re(u),draft:re({status:e.settings.draft.status,revision:e.settings.draft.revision,identity:e.settings.draft.identity,current_identity:e.settings.draft.current_identity,overrides:e.settings.draft.overrides||{}}),risk:re({revision:e.settings.risk.revision,scope_id:e.settings.risk.scope_id,preference:e.settings.risk.preference||null}),declaration:re({present:G(e.settings.declaration),status:typeof e.settings.declaration?.status=="string"?e.settings.declaration.status:"empty",source:typeof e.settings.declaration?.source=="string"?e.settings.declaration.source:null,revision:Number.isSafeInteger(e.settings.declaration?.revision)?e.settings.declaration.revision:0,environment:e.settings.declaration?.environment==="live"||e.settings.declaration?.environment==="paper"?e.settings.declaration.environment:null,account_type:e.settings.declaration?.account_type==="cash"||e.settings.declaration?.account_type==="margin"?e.settings.declaration.account_type:null})},{token:p,account:d,kind:"save",body:re(u)}},requestBody(r){return!r?.body||!j(r)||r.body.platform!==r.account.platform||r.body.key!==r.account.key?null:r.body},markSaving(r,d){return e.saving||!j(r)?!1:(o?.token===r.token&&t.set(this.selectedId(),o),e={...e,saving:d,notice:""},!0)},applySave(r,d,u){if(!j(r))return!1;const p=t.get(this.selectedId());if(p&&p!==o||e.saving&&!p)return!1;if(!o||o.token!==r.token||!Q(r.body,o.body)||!Ne(o,d)){o?.token===r.token&&t.set(this.selectedId(),o);const se=o?.token===r.token?oe(o.body):"draft";return e={...e,notice:"状态未知",noticeGroup:"",review:{...e.review,[se]:!0}},!1}t.delete(this.selectedId());const l=r.body?.overrides,_=Je(e.draft,"cash"),v=!!(l&&(Object.prototype.hasOwnProperty.call(l,"reserved_cash_floor")||Object.prototype.hasOwnProperty.call(l,"reserved_cash_ratio"))),b=!!(l&&Object.prototype.hasOwnProperty.call(l,"income_layer_enabled")),m=!!(l&&Object.prototype.hasOwnProperty.call(l,"option_overlay_enabled")),h=!!(l&&Object.prototype.hasOwnProperty.call(l,"strategy_profile")),T=!!(l&&(Object.prototype.hasOwnProperty.call(l,"dca_mode")||Object.prototype.hasOwnProperty.call(l,"dca_base_investment_usd"))),y=!!(r.body&&Object.prototype.hasOwnProperty.call(r.body,"risk_preference")),g=!!(r.body&&Object.prototype.hasOwnProperty.call(r.body,"declaration")),I=e.draft.income==="true"?!0:e.draft.income==="false"?!1:null,E=e.draft.option==="true"?!0:e.draft.option==="false"?!1:null,B=ee(e.draft)&&(_===null||["reserved_cash_floor","reserved_cash_ratio"].some(se=>Object.prototype.hasOwnProperty.call(_,se)?!l||!Object.prototype.hasOwnProperty.call(l,se)||l[se]!==_[se]:!1)),S=e.draft.incomeTouched===!0&&!(b&&l?.income_layer_enabled===I),$=e.draft.optionTouched===!0&&!(m&&l?.option_overlay_enabled===E),C=h&&(e.draft.clearStrategy&&l?.strategy_profile===null||e.draft.strategyTouched&&l?.strategy_profile===e.draft.strategy||(e.draft.dcaTouched||e.draft.clearDca)&&l?.strategy_profile===e.draft.dcaProfile),M=e.draft.strategyTouched===!0&&!C,V=T&&(e.draft.clearDca&&l?.dca_mode===null&&l?.dca_base_investment_usd===null||!e.draft.clearDca&&l?.dca_mode===e.draft.dcaMode&&l?.dca_base_investment_usd===e.draft.dcaAmount),F=(e.draft.dcaTouched===!0||e.draft.clearDca===!0)&&!V,q=M||F,x=typeof(e.settings||c)?.risk?.preference=="string"?(e.settings||c).risk.preference:"",k=y?(e.preference||"")!==(r.body?.risk_preference||""):(e.preference||"")!==x,O=e.review||Ae(),A=e.settings||c,L=!ge(A?.identity,d?.identity),f=ee(e.draft)||e.draft.incomeTouched===!0||e.draft.optionTouched===!0||ce(e.draft),N=!v&&!b&&!m&&!h&&!T&&f&&(L||A?.draft?.revision!==d?.draft?.revision),R=!y&&k&&(L||A?.risk?.revision!==d?.risk?.revision),w=r.body?.declaration&&typeof r.body.declaration=="object"?r.body.declaration:{},P=typeof w.environment=="string"?w.environment:"",K=typeof w.account_type=="string"?w.account_type:"",U=te(A?.declaration),W=g?e.declaration.environment!==P||e.declaration.accountType!==K:e.declaration.environment!==U.environment||e.declaration.accountType!==U.accountType,H=!g&&W&&(L||A?.declaration?.revision!==d?.declaration?.revision);if(!this.applyRead(r,d,{keepCash:v?B:ee(e.draft),keepIncome:b?S:e.draft.incomeTouched===!0,keepOption:m?$:e.draft.optionTouched===!0,keepStrategy:h||T?q:ce(e.draft),keepPreference:k,keepDeclaration:W}))return!1;const ae=v||b||m||h||T,Me=v&&(S||$||q)||b&&(B||$||q)||m&&(B||S||q)||(h||T)&&(B||S||$);return e={...e,notice:u,noticeGroup:ze(r),saving:"",review:{draft:ae?!!(L&&Me):O.draft||N,risk:y?!1:O.risk||R,declaration:g?!1:O.declaration||H}},!0},fail(r,d,u=!1){if(!j(r))return!1;const p=t.get(this.selectedId());if(p&&p!==o||u&&!p)return!1;u?o?.token===r.token&&t.set(this.selectedId(),o):t.delete(this.selectedId());const l=o?oe(o.body):"draft";return e={...e,notice:u?"状态未知":d,noticeGroup:"",saving:"",review:u?{...e.review,[l]:!0}:e.review},!0},applyRefresh(r,d){if(!j(r))return!1;const u=e,p=t.get(this.selectedId());if(p&&Ne(p,d)){o={...p,token:r.token},t.set(this.selectedId(),o);const C=oe(p.body);return this.applySave({...r,body:re(p.body)},d,C==="risk"?"偏好已保存":C==="declaration"?"声明已保存":"草案已保存")}const l=p?"状态未知":u.notice,_=u.settings||c,v=ee(u.draft),b=u.draft.incomeTouched===!0,m=u.draft.optionTouched===!0,h=ce(u.draft),T=typeof _?.risk?.preference=="string"?_.risk.preference:"",y=(u.preference||"")!==T,g=te(_?.declaration),I=u.declaration.environment!==g.environment||u.declaration.accountType!==g.accountType,E=!ge(_?.identity,d?.identity),B=Number(_?.draft?.revision)!==Number(d?.draft?.revision),S=Number(_?.risk?.revision)!==Number(d?.risk?.revision),$=Number(_?.declaration?.revision)!==Number(d?.declaration?.revision);return this.applyRead(r,d,{preserveNotice:!0,keepCash:!0,keepPreference:!0,keepIncome:!0,keepOption:!0,keepStrategy:!0,keepDeclaration:!0})?(e={...e,notice:l,saving:"",review:{draft:!!u.review?.draft||(v||b||m||h)&&(E||B),risk:!!u.review?.risk||y&&(E||S),declaration:!!u.review?.declaration||I&&(E||$)}},!0):!1},acknowledgeReview(r){const d=t.get(this.selectedId());return d&&oe(d.body)===r||!e.review?.[r]?!1:(e={...e,review:{...e.review,[r]:!1}},!0)},revertDraft(){if(!e.settings)return!1;const r=e.settings.draft?.overrides||{};return e={...e,review:{draft:!1,risk:!!e.review?.risk,declaration:!!e.review?.declaration},draft:{..._t(),strategy:typeof r.strategy_profile=="string"?r.strategy_profile:"",dcaMode:r.dca_mode==="fixed"||r.dca_mode==="smart"?r.dca_mode:e.settings.current_dca_supported===!0?X(e.settings,"dca_mode"):"",dcaAmount:typeof r.dca_base_investment_usd=="string"?r.dca_base_investment_usd:e.settings.current_dca_supported===!0?X(e.settings,"dca_base_investment_usd"):"",dcaProfile:typeof r.strategy_profile=="string"?r.strategy_profile:e.settings.current_dca_supported===!0?X(e.settings,"strategy_profile"):"",floor:typeof r.reserved_cash_floor=="string"?r.reserved_cash_floor:"",ratio:typeof r.reserved_cash_ratio=="string"?r.reserved_cash_ratio:"",income:Ge(r),option:ye(r,"option_overlay_enabled")}},!0},revertCash(){if(!e.settings)return!1;const r=e.settings.draft?.overrides||{},d=e.draft.incomeTouched===!0||e.draft.optionTouched===!0||ce(e.draft);return e={...e,review:{draft:d?!!e.review?.draft:!1,risk:!!e.review?.risk,declaration:!!e.review?.declaration},draft:{...e.draft,floor:typeof r.reserved_cash_floor=="string"?r.reserved_cash_floor:"",ratio:typeof r.reserved_cash_ratio=="string"?r.reserved_cash_ratio:"",percent:"",floorTouched:!1,ratioTouched:!1,clearFloor:!1,clearRatio:!1,cashMode:""}},!0},revertStrategy(){if(!e.settings)return!1;const r=e.settings.draft?.overrides||{},d=ee(e.draft)||e.draft.incomeTouched===!0||e.draft.optionTouched===!0,u=e.settings.draft?.overrides||{};return e={...e,review:{draft:d?!!e.review?.draft:!1,risk:!!e.review?.risk,declaration:!!e.review?.declaration},draft:{...e.draft,strategy:typeof r.strategy_profile=="string"?r.strategy_profile:"",dcaMode:u.dca_mode==="fixed"||u.dca_mode==="smart"?u.dca_mode:e.settings.current_dca_supported===!0?X(e.settings,"dca_mode"):"",dcaAmount:typeof u.dca_base_investment_usd=="string"?u.dca_base_investment_usd:e.settings.current_dca_supported===!0?X(e.settings,"dca_base_investment_usd"):"",dcaProfile:typeof u.strategy_profile=="string"?u.strategy_profile:e.settings.current_dca_supported===!0?X(e.settings,"strategy_profile"):"",strategyTouched:!1,dcaTouched:!1,clearStrategy:!1,clearDca:!1}},!0},revertOption(){if(!e.settings)return!1;const r=e.settings.draft?.overrides||{},d=ee(e.draft)||e.draft.incomeTouched===!0||ce(e.draft);return e={...e,review:{draft:d?!!e.review?.draft:!1,risk:!!e.review?.risk,declaration:!!e.review?.declaration},draft:{...e.draft,option:ye(r,"option_overlay_enabled"),optionTouched:!1}},!0},revertRisk(){return e.settings?(e={...e,preference:typeof e.settings.risk?.preference=="string"?e.settings.risk.preference:"",review:{draft:!!e.review?.draft,risk:!1,declaration:!!e.review?.declaration}},!0):!1},revertDeclaration(){return e.settings?(e={...e,declaration:te(e.settings.declaration),review:{...e.review,declaration:!1}},!0):!1},finish(r){return j(r)?(e={...e,saving:""},!0):!1}}}const In=new Map;function Pn({platform:t,accountKey:a}){const s=z(),e=D.useRef(yt(In)).current,[,c]=D.useState(0),[o,i]=D.useState(0),[j,r]=D.useState("loading"),[d,u]=D.useState(""),[p,l]=D.useState(""),_=()=>c(C=>C+1),v=e.view(),b=v.settings;D.useEffect(()=>{const C=`${t}:${a}`,M=e.selectedId()===C;if(M&&e.view().saving)return;const V=M&&!!e.view().settings,F=M?e.start("refresh"):e.select({platform:t,key:a});r(V?"refreshing":"loading"),u(""),l("");let q=!1;return(async()=>{try{const x=await ie(t,a);if(q)return;if(!(M?e.applyRefresh(F,x):e.applyRead(F,x))){if(e.isCurrent(F))throw new Error("account_settings_readback_mismatch");return}r("ready"),_()}catch(x){if(q)return;const k=Number(x?.status||0),O=k===401||k===403?"denied":x?.message==="account_settings_readback_mismatch"?"mismatch":"unavailable";if(V){if(!e.isCurrent(F))return;e.abandon(F),u(O),r("stale"),_();return}if(!e.applyUnavailable(F,""))return;r("failed"),_()}})(),()=>{q=!0,e.abandon(F)}},[t,a,o,e]);const m=async()=>{const C=e.startSave("risk"),M=e.requestBody(C);if(!C||!M||!e.markSaving(C,"risk"))return;l(""),_();let V=!1,F="",q=null;try{const f=await ne("/api/account-settings",M);if(!e.isCurrent(C))return;V=e.applySave(C,f,""),V&&(q=f.risk?.revision),V||(F="unknown")}catch(f){f?.status===409?(F="conflict",e.fail(C,"",!1)):(F="unknown",e.fail(C,"",!0))}finally{e.finish(C)&&_()}if(!e.isCurrent(C))return;_();const x=e.start("refresh"),k=await pt(e,x,()=>ie(t,a));if(_(),k.status==="superseded")return;if(k.status==="failed"){l(V?"unverified":F==="conflict"?"conflict":"");return}if(F==="conflict"){l("conflict");return}if(!V){e.view().review.risk||l("saved");return}const O=e.view().settings,A=typeof O?.risk?.preference=="string"?O?.risk?.preference:"",L=M.risk_preference===null||M.risk_preference===void 0?"":String(M.risk_preference);l(A===L&&ge(O?.identity,M.identity)&&O?.risk?.revision===q?"saved":"mismatch")},h=b?.operations?.save_risk_preference===!0,T=typeof b?.risk?.preference=="string"?b?.risk?.preference:"",y=v.preference!==""&&!["CAPITAL_PRESERVATION","BALANCED_COMPOUNDING","GROWTH_COMPOUNDING"].includes(v.preference),g=e.riskDirty(),I=!!(b?.identity&&typeof b.identity=="object"&&Number.isSafeInteger(b?.risk?.revision)),E=j==="ready"&&h&&!v.saving&&p!=="unverified"&&p!=="mismatch",B=E&&I&&g&&!v.review.risk&&!y,S=p==="conflict"?{tone:"error",text:s("risk.conflict")}:p==="mismatch"?{tone:"error",text:s("risk.mismatch")}:p==="unverified"?{tone:"error",text:s("risk.unverified")}:p==="saved"?{tone:"success",text:s("risk.saved")}:v.review.risk?{tone:"error",text:s("risk.review")}:null,$=s(d==="denied"?"risk.denied":d==="mismatch"?"risk.readMismatch":"risk.readFailed");return n.jsxs("section",{className:"card",children:[n.jsx("h2",{className:"card-title",children:s("risk.title")}),n.jsx("p",{className:"card-note",children:s("risk.note")}),j==="loading"&&n.jsx(J,{height:96}),j==="failed"&&n.jsxs("p",{className:"accounts-inline-note error",role:"alert",children:[$," ",n.jsx("button",{type:"button",className:"accounts-alias-button",onClick:()=>i(C=>C+1),children:s("risk.reread")})]}),j==="stale"&&n.jsxs("p",{className:"accounts-inline-note error",role:"alert",children:[$," ",s("risk.stale")," ",n.jsx("button",{type:"button",className:"accounts-alias-button",onClick:()=>i(C=>C+1),children:s("risk.reread")})]}),S&&n.jsxs("p",{className:`accounts-inline-note ${S.tone}`,role:S.tone==="success"?"status":"alert",children:[S.text," ",S.tone!=="success"&&n.jsx("button",{type:"button",className:"accounts-alias-button",onClick:()=>i(C=>C+1),children:s("risk.reread")})]}),v.saving&&n.jsx("p",{className:"accounts-inline-note",role:"status",children:s("risk.saving")}),j!=="loading"&&b&&n.jsxs(n.Fragment,{children:[n.jsx(Dt,{scope:`${t}:${a}`,value:v.preference,savedValue:T,selectionRevision:typeof b?.risk?.revision=="number"?b.risk.revision:null,mappingAvailable:!y,disabled:!E,saving:!!v.saving,dirty:g,onChange:C=>{l(""),e.edit({preference:C}),_()},onSave:()=>{B&&m()}}),n.jsxs("div",{className:"accounts-toolbar",children:[g&&n.jsx("button",{type:"button",className:"button button-secondary",onClick:()=>{e.revertRisk(),l(""),_()},children:s("risk.discard")}),!h&&n.jsx("span",{className:"card-note",children:s("risk.gate")})]}),v.review.risk&&n.jsx("button",{type:"button",className:"button button-secondary button-sm",onClick:()=>{e.acknowledgeReview("risk")||i(C=>C+1),_()},children:s("risk.ack")})]})]})}const Bn=new Map,Mn=["live","paper"],$n=["cash","margin"];function _e(t){return t==="live"||t==="paper"||t==="cash"||t==="margin"?t:""}function Fn({platform:t,accountKey:a,onSaved:s}){const e=z(),c=D.useId(),o=D.useId(),i=D.useRef(yt(Bn)).current,[,j]=D.useState(0),[r,d]=D.useState(0),[u,p]=D.useState("loading"),[l,_]=D.useState(""),[v,b]=D.useState(""),m=()=>j(x=>x+1),h=i.view(),T=h.settings;D.useEffect(()=>{const x=`${t}:${a}`,k=i.selectedId()===x;if(k&&i.view().saving)return;const O=k&&!!i.view().settings,A=k?i.start("refresh"):i.select({platform:t,key:a});p(O?"refreshing":"loading"),_(""),b("");let L=!1;return(async()=>{try{const f=await ie(t,a);if(L)return;if(!(k?i.applyRefresh(A,f):i.applyRead(A,f))){if(i.isCurrent(A))throw new Error("account_settings_readback_mismatch");return}p("ready"),m()}catch(f){if(L)return;const N=Number(f?.status||0),R=N===401||N===403?"denied":f?.message==="account_settings_readback_mismatch"?"mismatch":"unavailable";if(O){if(!i.isCurrent(A))return;i.abandon(A),_(R),p("stale"),m();return}if(!i.applyUnavailable(A,""))return;p("failed"),m()}})(),()=>{L=!0,i.abandon(A)}},[t,a,r,i]);const y=async()=>{const x=i.startSave("declaration"),k=i.requestBody(x);if(!x||!k||!i.markSaving(x,"declaration"))return;b(""),m();let O=!1,A="",L=null;try{const ae=await ne("/api/account-settings",k);if(!i.isCurrent(x))return;O=i.applySave(x,ae,""),O&&(L=ae.declaration?.revision),O||(A="unknown")}catch(ae){ae?.status===409?(A="conflict",i.fail(x,"",!1)):(A="unknown",i.fail(x,"",!0))}finally{i.finish(x)&&m()}if(!i.isCurrent(x))return;m();const f=i.start("refresh"),N=await pt(i,f,()=>ie(t,a));if(m(),N.status==="superseded")return;if(N.status==="failed"){b(O?"unverified":A==="conflict"?"conflict":"");return}if(A==="conflict"){b("conflict");return}if(!O){i.view().review.declaration||(b("saved"),s());return}const R=i.view().settings,w=k.declaration,P=w.environment??"",K=w.account_type??"",U=_e(R?.declaration?.environment),W=_e(R?.declaration?.account_type),H=U===P&&W===K&&ge(R?.identity,k.identity)&&R?.declaration?.revision===L;b(H?"saved":"mismatch"),H&&s()},g=T?.operations?.save_declaration===!0,I=_e(T?.declaration?.environment),E=_e(T?.declaration?.account_type),B=i.declarationDirty(),S=!!(T?.identity&&typeof T.identity=="object"&&Number.isSafeInteger(T?.declaration?.revision)),$=u==="ready"&&T?.declaration?.status!=="identity_conflict"&&g&&!h.saving&&v!=="unverified"&&v!=="mismatch",C=$&&S&&B&&!h.review.declaration,M=v==="conflict"?{tone:"error",text:e("accounts.declaration.conflict")}:v==="mismatch"?{tone:"error",text:e("accounts.declaration.mismatch")}:v==="unverified"?{tone:"error",text:e("accounts.declaration.unverified")}:v==="saved"?{tone:"success",text:e("accounts.declaration.saved")}:h.review.declaration?{tone:"error",text:e("accounts.declaration.review")}:null,V=e(l==="denied"?"accounts.declaration.denied":l==="mismatch"?"accounts.declaration.readMismatch":"accounts.declaration.readFailed"),F=x=>e(x==="live"?"accounts.declaration.env.live":x==="paper"?"accounts.declaration.env.paper":"accounts.declaration.unset"),q=x=>e(x==="cash"?"accounts.declaration.type.cash":x==="margin"?"accounts.declaration.type.margin":"accounts.declaration.unset");return n.jsxs("section",{className:"card",children:[n.jsx("h2",{className:"card-title",children:e("accounts.declaration.title")}),n.jsx("p",{className:"card-note",children:e("accounts.declaration.note")}),u==="loading"&&n.jsx(J,{height:96}),u==="failed"&&n.jsxs("p",{className:"accounts-inline-note error",role:"alert",children:[V," ",n.jsx("button",{type:"button",className:"accounts-alias-button",onClick:()=>d(x=>x+1),children:e("accounts.declaration.reread")})]}),u==="stale"&&n.jsxs("p",{className:"accounts-inline-note error",role:"alert",children:[V," ",e("accounts.declaration.stale")," ",n.jsx("button",{type:"button",className:"accounts-alias-button",onClick:()=>d(x=>x+1),children:e("accounts.declaration.reread")})]}),M&&n.jsxs("p",{className:`accounts-inline-note ${M.tone}`,role:M.tone==="success"?"status":"alert",children:[M.text," ",M.tone!=="success"&&n.jsx("button",{type:"button",className:"accounts-alias-button",onClick:()=>d(x=>x+1),children:e("accounts.declaration.reread")})]}),h.saving&&n.jsx("p",{className:"accounts-inline-note",role:"status",children:e("accounts.declaration.saving")}),u!=="loading"&&T&&n.jsxs(n.Fragment,{children:[n.jsxs("div",{className:"accounts-field-rows",children:[n.jsxs("div",{className:"accounts-field-row",children:[n.jsx("label",{className:"accounts-field-label",htmlFor:c,children:e("accounts.declaration.environment")}),n.jsxs("div",{className:"accounts-field-body",children:[n.jsx("div",{className:"accounts-field-control",children:n.jsxs("select",{id:c,className:"input",value:h.declaration.environment,disabled:!$,onChange:x=>{b(""),i.editDeclaration({environment:x.target.value}),m()},children:[n.jsx("option",{value:"",children:e("accounts.declaration.unset")}),Mn.map(x=>n.jsx("option",{value:x,children:F(x)},x))]})}),n.jsxs("span",{className:"accounts-field-current",children:[e("accounts.declaration.savedValue")," · ",I===""?e("accounts.declaration.unset"):F(I)]})]})]}),t!=="binance"&&n.jsxs("div",{className:"accounts-field-row",children:[n.jsx("label",{className:"accounts-field-label",htmlFor:o,children:e("accounts.declaration.account_type")}),n.jsxs("div",{className:"accounts-field-body",children:[n.jsx("div",{className:"accounts-field-control",children:n.jsxs("select",{id:o,className:"input",value:h.declaration.accountType,disabled:!$,onChange:x=>{b(""),i.editDeclaration({accountType:x.target.value}),m()},children:[n.jsx("option",{value:"",children:e("accounts.declaration.unset")}),$n.map(x=>n.jsx("option",{value:x,children:q(x)},x))]})}),n.jsxs("span",{className:"accounts-field-current",children:[e("accounts.declaration.savedValue")," · ",E===""?e("accounts.declaration.unset"):q(E)]})]})]})]}),n.jsxs("div",{className:"accounts-toolbar",children:[n.jsx("button",{type:"button",className:"button button-primary",disabled:!C,onClick:()=>{y()},children:e("accounts.declaration.save")}),B&&n.jsx("button",{type:"button",className:"button button-secondary",onClick:()=>{i.revertDeclaration(),b(""),m()},children:e("accounts.declaration.discard")}),!g&&n.jsx("span",{className:"card-note",children:e("accounts.declaration.gate")})]}),h.review.declaration&&n.jsx("button",{type:"button",className:"button button-secondary button-sm",onClick:()=>{i.acknowledgeReview("declaration")||d(x=>x+1),m()},children:e("accounts.declaration.ack")})]})]})}const vt=["overview","strategy","controls","history"];function Ln(t){return vt.includes(t||"")?t:"overview"}function Vn({platform:t,accountKey:a}){const s=`${t}:${a}`,e=Z(()=>Et(s,!1),[s]),c=e.phase==="loading"?"loading":e.phase==="error"?"error":e.data.status==="not_ready"?"not_ready":"ready",o=e.phase==="ready"&&e.data.status==="ready"?e.data.data:null;return n.jsx(It,{binding:o,status:c,onRetry:e.reload})}function qn({account:t,tab:a,config:s,todayRun:e,todayFailed:c,facts:o,onBack:i,onDeclarationSaved:j}){const r=z(),d=ke(s),u=nt(),{confirmRequest:p,confirm:l,resolveConfirm:_}=Lt(),[v,b]=D.useState(!1),[m,h]=D.useState({}),T=v&&Object.keys(m).length>0,y=Z(()=>et(t.account_alias,t.platform),[t.account_alias,t.platform]),g=D.useRef(l);g.current=l;const I=D.useRef(r);I.current=r,D.useEffect(()=>{if(T)return Fe(()=>g.current({title:I.current("common.unsaved_guard_title"),summary:I.current("common.unsaved_guard_body"),tone:"normal"})),()=>Fe(null)},[T]);const E=Ln(a),B=jt(s,t.platform,t.account_alias)?.account_selector?.trim(),S=Ee(o.rows,t.platform,t.account_alias),$=s?.currentStrategies?.[t.platform]?.[t.account_alias]?.execution_evidence?.broker_environment,C=Ie(S),M=$==="paper"||$==="live"?$:null,V=S?.broker_environment==="live"||S?.broker_environment==="paper"||S?.account_scope==="live"||S?.account_scope==="paper"||S?.binding_environment==="live"||S?.binding_environment==="paper",F=C&&M&&C!==M?null:C??(V?null:M),q=ve(S),x=F??(V||M?null:q?.environment??null),k=Vt(t.platform,S?.data_status,S?.broker_account_type)?.toLowerCase(),O=k==="cash"||k==="margin"?k:null,A=O??q?.accountType??null,L=!!(F&&q?.environment&&F!==q.environment||O&&q?.accountType&&O!==q.accountType),f=c?n.jsx(de,{status:"read_failed"}):e?n.jsxs(n.Fragment,{children:[n.jsx(de,{status:e.status,reason:e.unavailable_reason}),n.jsx(xe,{value:e.as_of})]}):n.jsx(de,{status:"no_data"});return n.jsxs("div",{className:"accounts-detail section-stack",children:[n.jsx("div",{children:n.jsxs("button",{type:"button",className:"button button-secondary button-sm accounts-mobile-back",onClick:i,children:["← ",r("accounts.back_to_list")]})}),n.jsxs("section",{className:"card",children:[n.jsxs("div",{className:"accounts-detail-head",children:[n.jsx("h2",{className:"card-title",children:d.account(t.account_alias,t.platform)}),n.jsx(it,{environment:x})]}),L&&n.jsx("p",{className:"accounts-inline-note error",role:"alert",children:r("accounts.declaration.conflict_notice")}),n.jsxs("div",{className:"accounts-summary-rows",children:[n.jsxs("div",{className:"accounts-summary-row",children:[n.jsx("span",{children:r("common.platform")}),n.jsx("span",{children:vn(s,t.platform)})]}),B&&n.jsxs("div",{className:"accounts-summary-row",children:[n.jsx("span",{children:r("accounts.identity")}),n.jsx("span",{className:"num",children:B})]}),n.jsxs("div",{className:"accounts-summary-row",children:[n.jsx("span",{children:r("accounts.run_state")}),n.jsx("span",{style:{display:"inline-flex",gap:8,alignItems:"center",flexWrap:"wrap"},children:f})]}),t.platform!=="binance"&&A&&n.jsxs("div",{className:"accounts-summary-row",children:[n.jsx("span",{children:r("accounts.declaration.account_type")}),n.jsx("span",{children:r(`accounts.declaration.type.${A}`)})]})]}),t.platform==="binance"?n.jsx(dt,{platform:t.platform,accountKey:t.account_alias,view:o.binance}):n.jsx(lt,{fact:S,phase:o.phase})]}),n.jsx(Kt,{id:"account-detail",items:vt.map(N=>({id:N,label:r(`accounts.tab.${N}`)})),active:E,onChange:N=>u({tab:N}),ariaLabel:r("accounts.title")}),n.jsxs("div",{id:"account-detail-panel",className:"section-stack",role:"tabpanel","aria-labelledby":`account-detail-tab-${E}`,tabIndex:0,children:[E==="overview"&&n.jsxs("section",{className:"card",children:[n.jsx("h2",{className:"card-title",children:r("accounts.tab.overview")}),y.phase==="loading"&&n.jsx("div",{className:"skeleton",style:{height:200},"aria-hidden":"true"}),y.phase==="error"&&n.jsx(le,{onRetry:y.reload}),y.phase==="ready"&&n.jsxs(n.Fragment,{children:[y.data.identity_status==="identity_conflict"&&n.jsx("p",{className:"accounts-inline-note error",role:"alert",children:r("accounts.identity_conflict")}),n.jsx(ft,{rows:y.data.rows,t:r}),n.jsxs("p",{className:"card-note",style:{display:"flex",gap:8,alignItems:"center",flexWrap:"wrap"},children:[n.jsx(be,{tone:"unknown",children:r("accounts.draft_revision",{value:y.data.draft_revision})}),y.data.status!=="ok"&&n.jsx(de,{status:y.data.status})]})]})]}),E==="overview"&&n.jsx(Pn,{platform:t.platform,accountKey:t.account_alias}),E==="overview"&&n.jsx(kn,{scope:`${t.platform}:${t.account_alias}`},`${t.platform}:${t.account_alias}`),E==="overview"&&n.jsx(Vn,{platform:t.platform,accountKey:t.account_alias}),E==="overview"&&n.jsx(Fn,{platform:t.platform,accountKey:t.account_alias,onSaved:j}),E==="strategy"&&n.jsx(Nn,{account:t,diffState:y,config:s,editing:v,setEditing:b,edits:m,setEdits:h,confirm:l}),E==="controls"&&n.jsx(An,{account:t,config:s,confirm:l}),E==="history"&&n.jsx(Rn,{account:t})]}),p&&n.jsx(qt,{request:p,onResolve:_})]})}function Yn({account:t,tab:a}){const s=z(),e=nt(),[c,o]=D.useState(0),i=Z(()=>wt(),[c]),j=Z(()=>St("/api/config").catch(()=>null),[c]),r=Z(()=>Tt(),[c]),d=Z(()=>Ot(),[c]),u=Z(()=>Ct(),[c]),p=j.phase==="ready"?j.data:null,l=i.phase==="ready"?i.data.accounts:[],_=t?Nt(l,t):void 0,v=u.phase==="ready"?{phase:"ready",status:u.data.report_status,report:u.data.report}:{phase:u.phase,status:null,report:null},b=d.phase==="ready"?{rows:d.data.accounts,phase:"ready",binance:v}:{rows:[],phase:d.phase,binance:v},m=r.phase==="error"||r.phase==="ready"&&r.data.status==="read_failed",h=_&&r.phase==="ready"&&!m?r.data.accounts.find(g=>g.account_alias===_.account_alias&&g.platform===_.platform):void 0,T=g=>e({account:g});let y;return i.phase==="loading"?y=n.jsx(J,{height:240}):i.phase==="error"?y=n.jsx(le,{onRetry:i.reload}):l.length===0?y=n.jsx(tt,{title:s("overview.no_accounts")}):y=n.jsx(_n,{accounts:l,config:p,facts:b,onSelect:T}),n.jsxs("div",{className:"page",children:[n.jsxs("header",{className:"page-header",children:[n.jsx("h1",{className:"page-title",children:s("accounts.title")}),i.phase==="ready"&&i.data.status==="partial"&&n.jsx(be,{tone:"warn",children:s("state.partial_valuation")}),n.jsx("div",{className:"page-header-actions",children:n.jsx("button",{type:"button",className:"button button-secondary",onClick:()=>o(g=>g+1),children:s("common.refresh")})})]}),!_&&i.phase==="ready"&&i.data.unassigned_decision_count>0&&n.jsxs("p",{className:"card-note accounts-unassigned",children:[s("accounts.unassigned_note",{count:i.data.unassigned_decision_count}),n.jsx("button",{type:"button",className:"button button-secondary button-sm",onClick:()=>e({page:"decisions"}),children:s("accounts.go_todos")})]}),n.jsxs("div",{className:`accounts-split${_?" detail-open":""}`,children:[n.jsx("div",{className:"accounts-list",children:y}),_&&n.jsx(qn,{account:_,tab:a,config:p,todayRun:h,todayFailed:m,facts:b,onDeclarationSaved:d.reload,onBack:()=>e({account:null})},`${_.platform}/${_.account_alias}`)]})]})}export{Yn as default};
" },
   "/v2/assets/AccountsPage-CaB9EVDF.css": { contentType: "text/css; charset=utf-8", base64: ".account-facts{display:grid;gap:5px;min-width:0;margin-top:8px;padding-top:8px;border-top:1px solid var(--line)}.account-facts .account-row{display:flex;justify-content:space-between;align-items:baseline;gap:4px 12px;flex-wrap:wrap;min-height:22px;font-size:13px;line-height:1.45}.account-facts .account-row>span{min-width:0;overflow-wrap:anywhere}.account-facts .account-row>span:first-child{color:var(--muted)}.account-facts .account-row>span:last-child{margin-left:auto;text-align:right}.account-facts .kpi-foot{justify-content:flex-start}.account-facts-freshness{gap:3px 12px;line-height:1.4}.account-facts-state-value{display:inline-flex;flex-wrap:wrap;align-items:baseline;justify-content:flex-end;gap:3px 6px}.account-state-label{color:var(--muted);font-size:12px}.account-facts-details{margin-top:2px}.account-facts-state>.button{justify-self:start;margin-top:2px}.account-facts-assets .money{color:var(--ink);font-size:16px;font-weight:650}.account-facts-cash .money{font-size:13px}.account-group-card{min-width:0;padding:16px}.account-card-head{display:flex;align-items:center;justify-content:space-between;gap:8px 12px;margin-bottom:10px}.account-card-head .account-broker-title{margin:0;min-width:0;overflow-wrap:anywhere}@media(min-width:900px){.account-group-card:only-child{display:grid;grid-template-columns:minmax(0,1fr) minmax(0,1fr);column-gap:28px;align-items:start}.account-group-card:only-child .account-card-head{grid-column:1 / -1}.account-group-card:only-child .account-card-facts{grid-column:2;grid-row:2;align-self:start}.account-group-card:only-child .account-strategy-block,.account-group-card:only-child .account-card-caveat{grid-column:1}}.account-card-facts{margin-bottom:4px}.account-card-facts .account-facts{margin:0 0 8px;padding:0 0 12px;border-top:0;border-bottom:1px solid var(--soft-line, var(--line))}.account-card-facts .account-facts:not(.account-facts-state){display:grid;grid-template-columns:minmax(0,1fr);gap:5px}.account-card-facts .account-facts-assets .money{font-size:18px}.account-card-caveat{margin:6px 0 0}.account-platform-head{display:flex;flex-wrap:wrap;align-items:baseline;gap:8px 20px;margin-bottom:12px;padding:12px 14px;border:1px solid var(--soft-line, var(--line));border-radius:var(--radius-m);background:color-mix(in srgb,var(--surface-2) 62%,var(--surface))}.account-platform-head .account-platform-title{flex:0 0 auto;margin:0;font-size:15px;letter-spacing:-.01em}.account-platform-summary{flex:1 1 280px;min-width:0}.account-platform-summary .account-facts{margin:0;padding:0;border:0}.account-environment-section+.account-environment-section{margin-top:14px}.account-environment-head{display:flex;flex-wrap:wrap;align-items:baseline;gap:6px 16px;margin:10px 0 8px}.account-environment-title{margin:0;font-size:13px;font-weight:650;letter-spacing:.01em}.account-environment-head .card-note{margin:0}.account-environment-head .account-platform-summary{flex:1 1 280px;min-width:0}.account-environment-note{margin:0 0 8px}.account-facts-platform{display:flex;flex-wrap:wrap;justify-content:flex-end;align-items:start;gap:10px 20px}.account-facts-currency{display:grid;align-content:start;flex:0 1 260px;gap:4px;min-width:0}.account-facts-platform .account-row{min-height:20px}.account-facts-platform .account-platform-notes{flex-basis:100%}.account-facts-platform-state{justify-items:start}.account-platform-summary .button{margin-top:4px}.account-group-card .account-row,.account-card-facts .account-facts .account-row{display:flex;flex-wrap:wrap;justify-content:space-between;align-items:baseline;gap:2px 12px}.account-group-card .account-row>span,.account-card-facts .account-facts .account-row>span{min-width:0;overflow-wrap:anywhere}.account-group-card .account-row>span:last-child{margin-left:auto;text-align:right}.account-strategy-block{min-width:0;padding:8px 0}.account-strategy-block+.account-strategy-block{border-top:1px solid var(--soft-line, var(--line))}.account-strategy-block .account-strategy-link{gap:4px;padding:4px 0 8px}.account-strategy-block .account-row{line-height:1.45}.execution-evidence-compact{display:flex;flex-wrap:wrap;align-items:center;gap:4px 12px;margin-top:2px;color:var(--muted);font-size:12px;line-height:1.45}.execution-evidence-compact .account-row{width:100%;gap:8px}.execution-mode-row>span:last-child{color:var(--ink);font-weight:550}.execution-mode-row>span.execution-value-unknown{color:var(--muted);font-weight:400}.execution-environment{overflow-wrap:anywhere}.execution-evidence-notes{flex-basis:100%;margin-top:2px}.account-card-notes{margin-top:8px}.execution-evidence-note{display:grid;gap:3px;margin-top:6px}.execution-evidence-note .account-row{font-size:12px}.execution-evidence-note p{margin:2px 0;color:var(--muted);font-size:12px;line-height:1.5}.account-facts-notes p{margin:4px 0 0}@media(max-width:768px){.account-platform-head{flex-direction:column;align-items:stretch;gap:8px}.account-platform-summary{flex-basis:auto}.account-facts-platform{flex-direction:column;align-items:stretch}.account-facts-currency{flex-basis:auto}}@media(max-width:480px){.account-platform-head{padding:10px 12px}.account-group-card{padding:14px}.account-card-facts .account-facts-assets .money{font-size:16px}.account-card-facts .account-facts:not(.account-facts-state){display:grid}}.accounts-split{display:grid;grid-template-columns:minmax(320px,400px) minmax(0,1fr);gap:18px;align-items:start}.accounts-list-cards{display:none}.accounts-split:not(.detail-open){grid-template-columns:minmax(0,1fr)}.accounts-list,.accounts-detail{min-width:0}.accounts-alias-button{color:var(--accent);font-weight:600;text-align:left;padding:0}.accounts-alias-button:hover{text-decoration:underline}.accounts-mobile-back{display:none;margin-bottom:12px}.accounts-unassigned{display:flex;align-items:center;gap:8px;flex-wrap:wrap;margin:0}.accounts-detail-head{display:flex;align-items:center;justify-content:space-between;gap:8px 12px;margin-bottom:10px}.accounts-detail-head>.card-title{margin:0;font-size:19px;letter-spacing:-.02em;min-width:0;overflow-wrap:anywhere}.accounts-summary-rows{display:flex;flex-direction:column;gap:0}.accounts-summary-row{display:flex;justify-content:space-between;gap:12px;min-height:38px;padding:9px 0;border-bottom:1px solid var(--soft-line, var(--line));font-size:13px;align-items:baseline;flex-wrap:wrap}.accounts-summary-row:last-child{border-bottom:0}.accounts-summary-row>span:first-child{color:var(--muted)}.accounts-summary-row>span:last-child{text-align:right;font-variant-numeric:tabular-nums}.accounts-field-rows{display:flex;flex-direction:column}.accounts-field-row{display:grid;grid-template-columns:minmax(140px,220px) 1fr;gap:12px;align-items:start;padding:10px 0;border-bottom:1px solid var(--line)}.accounts-field-row:last-child{border-bottom:none}.accounts-field-label{color:var(--muted);font-size:13px;padding-top:8px}.accounts-field-body{display:flex;flex-direction:column;gap:4px;min-width:0}.accounts-field-value{font-variant-numeric:tabular-nums;overflow-wrap:anywhere}.accounts-field-control{display:flex;gap:8px;align-items:center;flex-wrap:wrap}.accounts-field-control .input{max-width:280px}.accounts-field-error{color:var(--status-error);font-size:12px}.accounts-field-current{color:var(--muted);font-size:12px}.accounts-toolbar{display:flex;gap:8px;align-items:center;margin-bottom:12px;flex-wrap:wrap}.accounts-inline-note{font-size:13px;margin:8px 0}.accounts-inline-note.error{color:var(--status-error)}.accounts-inline-note.success{color:var(--status-ok)}.accounts-diff-section+.accounts-diff-section{margin-top:12px}.accounts-diff-section h3{margin:0 0 6px;font-size:13px;color:var(--muted)}@media(max-width:768px){.accounts-split{display:block}.accounts-list-table{display:none}.accounts-list-cards{display:flex;flex-direction:column;gap:8px}.accounts-split.detail-open .accounts-list{display:none}.accounts-split:not(.detail-open) .accounts-detail{display:none}.accounts-mobile-back{display:inline-flex}.accounts-detail-head>.card-title{font-size:18px}.accounts-field-row{grid-template-columns:1fr;gap:4px}.accounts-field-label{padding-top:0}.accounts-field-control .input{max-width:none}}@media(max-width:480px){.accounts-summary-row{padding:8px 0}}
" },
-  "/v2/assets/AccountsPage-CsdJjpqu.js": { contentType: "text/javascript; charset=utf-8", base64: "import{u as z,j as n,B as be,f as Y,A as Ae,q as Ze,t as Xe,o as xe,N as gt,O as bt,Q as we,T as Qe,k as et,r as R,D as De,E as fe,U as tt,V as ie,W as xt,L as kt,X as jt,J as ne,Y as $e,c as nt,S as le,b as at,Z as Le,_ as Nt,$ as wt,a0 as St,F as Ot,h as Tt,a1 as Ct,a2 as At}from"./index-Ds_XXLsn.js";import{E as Dt}from"./ExecutionEvidence-BafFTQfM.js";import{u as Q}from"./hooks-DCo9_b70.js";import{D as Rt,T as Et,d as ee,e as It,f as Pt,g as Bt,u as Mt,v as $t,C as Lt}from"./Dialog-JHiHwrz3.js";import{T as Ft}from"./Tabs-DBQ5AQB9.js";import"./runtime_daily_contract-xW43mZQY.js";const Vt=/^-?(?:0|[1-9]\d*)(?:\.\d+)?$/;function Re(t){return typeof t=="string"&&Vt.test(t)}function ue(t){return Re(t)?t:null}function st(t,s){if(!Re(t))return"—";const a=t.startsWith("-"),e=a?t.slice(1):t,[r,o=""]=e.split("."),i=r.replace(/\B(?=(\d{3})+(?!\d))/g,","),j=`${a?"-":""}${i}.${o?o.padEnd(2,"0"):"00"}`;return s?`${s} ${j}`:j}function Fe(t){if(!t.length||!t.every(Re))return"";const s=Math.max(...t.map(r=>(r.split(".")[1]||"").length)),a=t.reduce((r,o)=>{const[i,j=""]=o.replace(/^-/,"").split("."),c=BigInt(i+j.padEnd(s,"0"));return r+(o.startsWith("-")?-c:c)},0n),e=(a<0n?-a:a).toString().padStart(s+1,"0");return`${a<0n?"-":""}${s?`${e.slice(0,-s)}.${e.slice(-s)}`.replace(/\.?0+$/,""):e}`}function Ee(t,s,a){if(!t)return null;const e=t.filter(r=>r&&r.platform===s&&r.account_key===a);return e.length===1?e[0]:null}function Se(t){return!!t&&t.binding_status==="bound"&&t.identity_mismatch!==!0&&(t.data_status==="fresh"||t.data_status==="stale")}function rt(t){return ct(t)==="paper"}function Ie(t){if(!t)return null;const s=[t.broker_environment,t.account_scope,t.binding_environment].filter(a=>a==="paper"||a==="live");return new Set(s).size===1?s[0]:null}function ct(t){if(!t)return null;const s=Ie(t);return s||(["live","paper"].includes(t.broker_environment??"")||["live","paper"].includes(t.account_scope??"")||["live","paper"].includes(t.binding_environment??"")?null:ve(t)?.environment??null)}function ot(t,s){const a=(Array.isArray(t.cash)?t.cash:[]).find(r=>r?.currency===s);if(a&&typeof a.cash_balance=="string")return ue(a.cash_balance);const e=(Array.isArray(t.balances)?t.balances:[]).find(r=>r?.currency===s);return e&&typeof e.total_cash=="string"?ue(e.total_cash):null}function qt(t){if(!t||t.binding_status==="missing")return{kind:"not_connected"};if(t.binding_status==="duplicate"||t.identity_mismatch===!0)return{kind:"identity_unverified"};if(t.binding_status!=="bound")return{kind:"unknown"};if(t.data_status==="unavailable")return{kind:"no_data"};if(t.data_status!=="fresh"&&t.data_status!=="stale")return{kind:"unknown"};const s=Array.isArray(t.balances)?t.balances:[],a=Array.isArray(t.cash)?t.cash:[],e=new Set;for(const r of a)r&&typeof r.currency=="string"&&typeof r.cash_balance=="string"&&e.add(r.currency);for(const r of s)r&&typeof r.currency=="string"&&typeof r.total_cash=="string"&&e.add(r.currency);return{kind:"ready",stale:t.data_status==="stale",asOf:typeof t.observed_finished_at=="string"?t.observed_finished_at:null,balances:s.filter(r=>r&&typeof r.currency=="string").map(r=>({currency:r.currency,netAssets:ue(r.net_assets)})),cash:[...[...e].sort().map(r=>({currency:r,cashBalance:ot(t,r)})),...t.platform==="longbridge"?a.filter(r=>typeof r?.currency=="string"&&typeof r.available_cash=="string").map(r=>({currency:r.currency,cashBalance:ue(r.available_cash),available:!0})):[]]}}function Gt(t,s){return Array.isArray(t.balances)&&t.balances.some(a=>a?.currency===s)||Array.isArray(t.cash)&&t.cash.some(a=>a?.currency===s)}function Ut(t,s){if(!t.length||s<1)return[];const a=[...new Set(t)],e=a.filter(d=>d.aggregation_status!=="duplicate"&&!rt(d)),r=Math.max(0,s-(a.length-e.length)),o=e.filter(Se),i=o.filter(d=>d.aggregation_status==="included"&&ct(d)==="live"),j=o.some(d=>d.aggregation_status==="conflict");if(!i.length)return[];const c=new Set;for(const d of i){for(const u of Array.isArray(d.balances)?d.balances:[])u&&typeof u.currency=="string"&&c.add(u.currency);for(const u of Array.isArray(d.cash)?d.cash:[])u&&typeof u.currency=="string"&&typeof u.cash_balance=="string"&&c.add(u.currency)}return[...c].sort().map(d=>{const u=i.filter(g=>Gt(g,d)),m=u.filter(g=>typeof g.observation_date=="string"&&g.observation_date.length>0),l=m.length?m.map(g=>g.observation_date).sort().pop():null,_=l?m.filter(g=>g.observation_date===l):[],v=g=>(Array.isArray(g.balances)?g.balances:[]).find(E=>E?.currency===d),x=_.map(g=>ue(v(g)?.net_assets)),p=_.length>0&&x.every(g=>g!==null)?Fe(x):null,h=_.map(g=>ot(g,d)),S=_.length>0&&h.every(g=>g!==null)?Fe(h):null,y=p!==null||S!==null?_.length:0;return{currency:d,netAssets:p,cashBalance:S,covered:y,expected:r,complete:!j&&r>0&&y===r&&_.length===u.length&&p!==null,stale:_.some(g=>g.data_status==="stale"),observationDate:l}})}function ve(t){const s=t?.user_declaration;if(!s||s.source!=="user_declared")return null;const a=s.environment==="live"||s.environment==="paper"?s.environment:null,e=s.account_type==="cash"||s.account_type==="margin"?s.account_type:null;return a===null&&e===null?null:{environment:a,accountType:e}}function Kt(t){const s=new Set;for(const a of t){const e=ve(a)?.environment;e&&s.add(e)}return s.size>1?{value:null,conflict:!0}:t.some(a=>!ve(a)?.environment)?{value:null,conflict:!1}:{value:s.size===1?[...s][0]:null,conflict:!1}}const zt="GET /sapi/v1/asset/wallet/balance",Wt="provider_returned_wallet_rows",Ht="spot+flexible_earn",Jt=/^(?:0|[1-9]\d*)(?:\.\d+)?$/,Yt=/^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.\d{1,9})?(Z|[+-]\d{2}:\d{2})$/;function de(t){return typeof t=="string"&&Jt.test(t)}function Zt(t){return/[1-9]/.test(t)}function it(t){if(typeof t!="string")return null;const s=Yt.exec(t);if(!s||Number(s[4])>23||Number(s[5])>59||Number(s[6])>59)return null;if(s[7]!=="Z"){const[e,r]=s[7].slice(1).split(":");if(Number(e)>23||Number(r)>59)return null}const a=Date.parse(t);return Number.isFinite(a)?a:null}function Xt(t){if(!t||typeof t!="object"||Array.isArray(t))return!1;const s=t;return typeof s.asset=="string"&&s.asset.length>0&&de(s.quantity)&&de(s.spot_free)&&de(s.spot_locked)&&de(s.flexible_earn)}function Qt(t,s){if(t===void 0)return{kind:"none"};if(!t||typeof t!="object"||Array.isArray(t))return{kind:"none",invalid:!0};const a=t;if(a.status==="unavailable")return{kind:"none",reason:typeof a.reason_code=="string"?a.reason_code:void 0};if(a.status!=="available")return{kind:"none",invalid:!0};const e=a.amount,r=a.wallet_count,o=typeof a.observed_at=="string"?a.observed_at:null,i=o===null?null:it(o);return a.source!==zt||a.scope!==Wt||a.currency!=="USDT"||!de(e)||typeof r!="number"||!Number.isInteger(r)||r<1||r>32||o===null||i===null||i>s?{kind:"none",invalid:!0}:{kind:"available",amount:e,currency:"USDT",observedAt:o}}function en(t,s){const a=new Set(t.filter(e=>e.platform===s).map(e=>e.account_alias));return a.size===1?[...a][0]:null}function tn(t,s,a){if(s!=="binance")return{kind:"no_data"};if(t.phase==="loading")return{kind:"loading"};if(t.phase==="error")return{kind:"read_failed"};if(t.status==="missing")return{kind:"no_data"};if(t.status==="expired")return{kind:"pending"};if(t.status!=="available")return{kind:"unavailable"};const e=t.report;if(!e||typeof e!="object")return{kind:"unavailable"};if(!a)return{kind:"unavailable"};if(e.platform!=="binance")return{kind:"unavailable"};if(e.account_key!==a)return{kind:"no_data"};if(e.scope!==Ht)return{kind:"unavailable"};const r=it(e.observed_finished_at);return r===null||!Array.isArray(e.assets)?{kind:"unavailable"}:e.assets.every(Xt)?{kind:"ready",assetCount:e.assets.filter(o=>Zt(o.quantity)).length,observedAt:e.observed_finished_at,valuation:Qt(e.wallet_valuation,r)}:{kind:"unavailable"}}function lt({environment:t}){const s=z();return t?n.jsx(be,{tone:t==="paper"?"accent":"warn",children:s(t==="paper"?"common.paper_badge":"strategies.execution.live")}):null}function nn(t,s=null){if(!t.length)return s;const a=t.map(Ie),e=new Set(a.filter(r=>r!==null));return a.every(r=>r!==null)&&e.size===1?[...e][0]:null}const an=new Set(["state.read_failed","state.not_connected","state.no_data","state.unknown_status"]);function J({label:t,stateKey:s}){const a=z(),e=an.has(s);return n.jsx("div",{className:"account-facts account-facts-state","data-state":s,children:n.jsxs("span",{className:"account-row",children:[n.jsx("span",{children:t}),n.jsxs("span",{className:"account-facts-state-value",children:[n.jsx("span",{className:"money flat",children:"—"}),n.jsx("span",{className:"account-state-label",children:a(e?s:"facts.amount_unavailable")})]})]})})}function he({value:t,currency:s}){const{prefs:a}=Ze();return t===null?n.jsx("span",{className:"money flat",children:"—"}):a.hideAmounts?n.jsx("span",{className:"money",children:Xe(t)}):n.jsx("span",{className:"money flat",children:st(t,s??null)})}function dt({fact:t,phase:s,conflict:a=!1,ambiguous:e=!1}){const r=z();if(s==="loading")return n.jsx("div",{className:"account-facts",children:n.jsx(Y,{height:14})});if(s==="error")return n.jsx(J,{label:r("facts.assets"),stateKey:"state.read_failed"});if(a)return n.jsx(J,{label:r("facts.assets"),stateKey:"facts.observation_conflict"});if(e)return n.jsx(J,{label:r("facts.assets"),stateKey:"facts.identity_unverified"});const o=qt(t);return o.kind==="not_connected"?n.jsx(J,{label:r("facts.assets"),stateKey:"state.not_connected"}):o.kind==="identity_unverified"?n.jsx(J,{label:r("facts.assets"),stateKey:"facts.identity_unverified"}):o.kind==="unknown"?n.jsx(J,{label:r("facts.assets"),stateKey:"state.unknown_status"}):o.kind==="no_data"?n.jsx(J,{label:r("facts.assets"),stateKey:"state.no_data"}):!o.balances.length&&!o.cash.length?n.jsx(J,{label:r("facts.assets"),stateKey:"state.no_data"}):n.jsxs("div",{className:"account-facts",children:[o.balances.map(i=>n.jsxs("span",{className:"account-row account-facts-assets",children:[n.jsxs("span",{children:[r("facts.assets")," · ",i.currency]}),n.jsx(he,{value:i.netAssets,currency:i.currency})]},`assets-${i.currency}`)),o.cash.map(i=>n.jsxs("span",{className:"account-row account-facts-cash",children:[n.jsxs("span",{children:[r(i.available?"facts.available_cash":"facts.cash")," · ",i.currency]}),n.jsx(he,{value:i.cashBalance,currency:i.currency})]},`cash-${i.available?"available-":""}${i.currency}`)),(o.asOf||o.stale)&&n.jsx("div",{className:"kpi-foot account-facts-freshness",children:o.asOf?n.jsx(Ae,{value:o.asOf,prefix:o.stale?"facts.as_of_stale":"common.as_of"}):n.jsx("span",{className:"asof",children:r("facts.stale_pending")})})]})}function sn({rows:t,expected:s,phase:a}){const e=z();if(a==="loading")return n.jsx("div",{className:"account-facts",children:n.jsx(Y,{height:14})});if(a==="error")return n.jsx(J,{label:e("facts.platform_total_live"),stateKey:"state.read_failed"});const r=Ut(t,s);if(!r.length){const o=t.filter(d=>!rt(d)),i=o.some(d=>Se(d)&&d.aggregation_status==="included"),j=o.some(Se),c=t.length?i?"state.no_data":j?"facts.platform_identity_unverified":"state.no_data":"state.not_connected";return n.jsx(J,{label:e("facts.platform_total_live"),stateKey:c})}return n.jsx("div",{className:"account-facts account-facts-platform",children:r.map(o=>n.jsxs("div",{className:"account-facts-currency",children:[n.jsxs("span",{className:"account-row account-facts-assets",children:[n.jsxs("span",{title:e("facts.platform_scope_note"),children:[e(o.complete?"facts.platform_total_live":"facts.platform_subtotal_live")," · ",o.currency]}),n.jsx(he,{value:o.netAssets,currency:o.currency})]}),n.jsxs("span",{className:"account-row account-facts-cash",children:[n.jsxs("span",{children:[e("facts.cash")," · ",o.currency]}),n.jsx(he,{value:o.cashBalance,currency:o.currency})]}),n.jsxs("div",{className:"kpi-foot account-facts-freshness",children:[o.covered<o.expected&&n.jsx("span",{className:"asof",children:e("facts.coverage",{covered:o.covered,expected:o.expected})}),o.observationDate?n.jsx("span",{className:"asof",children:e(o.stale?"facts.as_of_stale":"common.as_of",{value:o.observationDate})}):o.stale&&n.jsx("span",{className:"asof",children:e("facts.stale_pending")})]})]},o.currency))})}const rn={read_failed:"facts.wallet_read_failed",no_data:"facts.wallet_no_data",pending:"facts.wallet_pending",unavailable:"facts.wallet_unavailable"};function cn({amount:t}){const{prefs:s}=Ze();return s.hideAmounts?n.jsx("span",{className:"money",children:Xe(t)}):n.jsx("span",{className:"money flat",children:st(t,null)})}function ut({platform:t,accountKey:s,view:a}){const e=z();if(t!=="binance"||!a)return null;const r=tn(a,t,s);if(r.kind==="loading")return n.jsx("div",{className:"account-facts account-facts-binance","data-state":"loading","data-scope":"spot+flexible_earn",children:n.jsx(Y,{height:14})});if(r.kind!=="ready")return n.jsx("div",{className:"account-facts account-facts-binance","data-state":r.kind,"data-scope":"spot+flexible_earn",children:n.jsxs("span",{className:"account-row account-facts-assets",children:[n.jsxs("span",{title:e("facts.wallet_scope_note"),children:[e("facts.wallet_valuation")," · USDT"]}),n.jsxs("span",{className:"account-facts-state-value",children:[n.jsx("span",{className:"money flat",children:"—"}),n.jsx("span",{className:"account-state-label",children:e(rn[r.kind])})]})]})});const{valuation:o}=r,i=o.kind==="available";return n.jsxs("div",{className:"account-facts account-facts-binance","data-state":i?"available":"valuation_unavailable","data-scope":"spot+flexible_earn","data-wallet-scope":"provider_returned_wallet_rows","data-reason":i?void 0:o.invalid?"invalid_valuation":o.reason,children:[!i&&n.jsx("span",{className:"account-row account-facts-binance-holdings",title:e("facts.wallet_holdings_scope_note"),children:n.jsx("span",{children:e("facts.wallet_holdings",{count:r.assetCount})})}),n.jsxs("span",{className:"account-row account-facts-assets",children:[n.jsxs("span",{title:e("facts.wallet_scope_note"),children:[e("facts.wallet_valuation")," · USDT"]}),i?n.jsx(cn,{amount:o.amount}):n.jsxs("span",{className:"account-facts-state-value",children:[n.jsx("span",{className:"money flat",children:"—"}),n.jsx("span",{className:"account-state-label",children:e("facts.wallet_unavailable")})]})]}),n.jsx("div",{className:"kpi-foot account-facts-freshness",children:n.jsx(Ae,{value:i?o.observedAt:r.observedAt})})]})}const on=["live","paper","unknown"];function ln(t){return t?.broker_environment==="paper"||t?.broker_environment==="live"?t.broker_environment:null}function dn(t,s){const a=new Set,e=new Set;for(const r of t)for(const o of r.rows){const i=Ee(s,o.platform,o.account_alias);i?a.add(i):e.add(we(o))}return{rows:[...a],expected:a.size+e.size}}function un(t){return t??"unknown"}function fn({accounts:t,config:s,facts:a,onSelect:e}){const r=xe(s),o=z();return n.jsx("div",{className:"section-stack account-groups",children:gt(t,s).map(i=>{const j=a?dn(i.accounts,a.rows):null,c=i.accounts.map(u=>{const m=[...new Set(u.rows.map(C=>Ee(a?.rows??[],C.platform,C.account_alias)).filter(C=>!!C))],l=m.filter(C=>C.aggregation_status!=="duplicate"),_=l.length===1?l[0]:l.length===0&&m.length===1?m[0]:null,v=new Set(u.rows.map(C=>ln(s?.currentStrategies?.[C.platform]?.[C.account_alias]?.execution_evidence)).filter(C=>C!==null)),x=m.some(C=>C.broker_environment==="paper"||C.broker_environment==="live"||C.account_scope==="paper"||C.account_scope==="live"||C.binding_environment==="paper"||C.binding_environment==="live"),p=nn(m),h=v.size===1?[...v][0]:null,S=p&&h&&p!==h?null:p??(!x&&v.size===1?h:null),y=x||v.size>0,g=Kt(m),E=S??(y?null:g.value),I=!!(S&&g.value&&S!==g.value||g.conflict&&!y),M=i.platform==="binance"?en(u.rows,i.platform):null;return{account:u,canonical:l,representative:_,environment:E,declarationConflict:I,binanceKey:M}}),d=on.map(u=>({environment:u,cards:c.filter(m=>un(m.environment)===u)})).filter(u=>u.cards.length>0);return n.jsxs("section",{className:"account-platform-group",children:[n.jsx("div",{className:"account-platform-head",children:n.jsx("h2",{className:"account-platform-title",children:r.platform(i.platform)})}),d.map(u=>n.jsxs("section",{className:"account-environment-section","data-environment":u.environment,children:[n.jsxs("div",{className:"account-environment-head",children:[n.jsx("h3",{className:"account-environment-title",children:o(`accounts.environment.${u.environment}`)}),n.jsx("span",{className:"card-note",children:o("accounts.environment_count",{count:u.cards.length})}),u.environment==="live"&&a&&j&&i.platform!=="binance"?n.jsx("div",{className:"account-platform-summary",children:n.jsx(sn,{rows:j.rows,expected:j.expected,phase:a.phase})}):null]}),u.environment!=="live"&&n.jsx("p",{className:"card-note account-environment-note",children:o(`accounts.environment.${u.environment}_note`)}),n.jsx("div",{className:"account-grid",children:u.cards.map(({account:m,canonical:l,representative:_,environment:v,declarationConflict:x,binanceKey:p})=>n.jsxs("article",{className:"card account-group-card",children:[n.jsxs("div",{className:"account-card-head",children:[n.jsx("h3",{className:"account-broker-title",children:r.account(m.rows[0].account_alias,i.platform)}),n.jsx(lt,{environment:v})]}),x&&n.jsx("p",{className:"accounts-inline-note error",role:"alert",children:o("accounts.declaration.conflict_notice")}),a&&n.jsx("div",{className:"account-card-facts",children:i.platform==="binance"?n.jsx(ut,{platform:i.platform,accountKey:p,view:a.binance}):n.jsx(dt,{fact:_,phase:a.phase,ambiguous:l.length>1})}),m.rows.map(h=>{const S=r.currentStrategy(h),y=s?.currentStrategies?.[h.platform]?.[h.account_alias]?.execution_evidence,g=s?.currentStrategies?.[h.platform]?.[h.account_alias]?.runtime_target_enabled;return n.jsxs("div",{className:"account-strategy-block",children:[n.jsxs("button",{type:"button",className:"account-strategy-link","aria-label":o("accounts.open_strategy",{account:r.account(h.account_alias,h.platform),strategy:S?r.strategy(S):o("common.unknown")}),onClick:()=>e(we(h)),children:[n.jsxs("span",{className:"account-strategy-head",children:[n.jsx("span",{className:"account-strategy-name",children:S?r.strategy(S):o("common.unknown")}),n.jsx("span",{className:"account-strategy-chevron","aria-hidden":"true",children:"›"})]}),typeof g=="boolean"&&n.jsxs("span",{className:"account-row",children:[n.jsx("span",{title:o("accounts.execution.runtime_target_note"),children:o("accounts.activation_setting")}),n.jsx("span",{children:o(g?"overview.runtime_enabled":"overview.runtime_disabled")})]}),h.pending_draft_count>0&&n.jsxs("span",{className:"account-row",children:[n.jsx("span",{children:o("accounts.col.drafts")}),n.jsx("span",{children:h.pending_draft_count})]}),h.pending_decision_count!==null&&h.pending_decision_count>0&&n.jsxs("span",{className:"account-row",children:[n.jsx("span",{children:o("accounts.col.todos")}),n.jsx("span",{children:h.pending_decision_count})]}),n.jsxs("span",{className:"account-row",children:[n.jsx("span",{children:o("accounts.col.last_change")}),n.jsx(bt,{value:h.last_change_at})]})]}),n.jsx(Dt,{evidence:y,compact:!0})]},we(h))})]},m.identity))})]},u.environment))]},i.platform)})})}const pn=["strategy","dca","cash_reserve","income_layer"];function mn(t,s){return t?.platformMeta?.[s]?.label||s}function pe(t,s,a){return t?.accountOptions?.[s]?.find(r=>r.key===a)?.target_name||a}function _n(t,s){return(t?.strategyProfiles||[]).filter(a=>typeof a?.profile=="string"&&a.profile.length>0).map(a=>({profile:a.profile,label:Qe(a.profile,s,s==="zh"?a.label_zh:a.label_en)}))}function Oe(t,s){const a=t(s.label_key);return a===s.label_key?t(`accounts.field.${s.field}`):a}function Pe(t,s){return t(`accounts.section.${s}`)}function Te(t,s,a,e=!1,r="en"){return e?t("common.unknown"):a==null||a===""?t("common.na"):typeof a=="boolean"?t(a?"accounts.bool.on":"accounts.bool.off"):s==="dca_mode"&&(a==="fixed"||a==="smart")?t(`accounts.dca_mode.${a}`):s==="strategy_profile"?Qe(String(a),r):String(a)}function Ve(t,s){if(Object.prototype.hasOwnProperty.call(s,t.field)){const a=s[t.field];return a===null||a===void 0?t.current:a}return t.overridden?t.draft:t.current}function qe(t){return t==null?null:typeof t=="number"?String(t):t}function Ge(t,s){const a={};for(const e of t){if(e.field==="option_overlay_enabled"){e.overridden&&(a.option_overlay_enabled=null);continue}Object.prototype.hasOwnProperty.call(s,e.field)?a[e.field]=qe(s[e.field]):e.overridden&&(a[e.field]=qe(e.draft))}return a}function Be(t){const s=[];for(const a of pn){const e=t.filter(r=>r.section===a);e.length&&s.push({section:a,rows:e})}return s}function ft(t){return/^\d+(?:\.\d+)?$/.test(t)&&Number.isFinite(Number(t))}function yn(t){if(!ft(t))return!1;const s=Number(t);return s>=0&&s<=1}function vn(t){return t.length<=32&&/^(?:0|[1-9]\d*)(?:\.\d+)?$/.test(t)&&Number.isFinite(Number(t))&&Number(t)>0}const ke=["dca_mode","dca_base_investment_usd"];function me(t,s){return Object.prototype.hasOwnProperty.call(t,s)}function pt({rows:t,t:s}){const a=et();return n.jsx(n.Fragment,{children:Be(t).map(e=>n.jsxs("section",{className:"accounts-diff-section",children:[n.jsx("h3",{children:Pe(s,e.section)}),n.jsx("div",{className:"accounts-field-rows",children:e.rows.map(r=>n.jsxs("div",{className:"accounts-field-row",children:[n.jsx("span",{className:"accounts-field-label",children:Oe(s,r)}),n.jsxs("div",{className:"accounts-field-body",children:[n.jsx("span",{className:"accounts-field-value",children:Te(s,r.field,r.current,r.current_status==="unknown",a)}),r.overridden&&n.jsx("span",{className:"accounts-field-current",children:s("accounts.draft_value",{value:Te(s,r.field,r.draft,!1,a)})})]})]},r.field))})]},e.section))})}function hn({rows:t,t:s}){return n.jsx(n.Fragment,{children:Be(t).map(a=>n.jsxs("div",{className:"accounts-diff-section",children:[n.jsx("h3",{children:Pe(s,a.section)}),n.jsx(Rt,{rows:a.rows})]},a.section))})}function gn({account:t,diffState:s,config:a,editing:e,setEditing:r,edits:o,setEdits:i,confirm:j}){const c=et(),d=xe(a),u=R.useId(),m=f=>`${u}-${f}`,l=z(),_=De(),[v,x]=R.useState(!1),[p,h]=R.useState(!1),[S,y]=R.useState(null),[g,E]=R.useState({});if(s.phase==="loading")return n.jsx(Y,{height:220});if(s.phase==="error")return n.jsx(fe,{onRetry:s.reload});const I=s.data,M=I.rows,C=M.some(f=>f.field==="option_overlay_enabled"&&f.overridden),$=I.identity_status==="identity_conflict",V=_n(a,c),G=Object.keys(o).length>0,T=(f,N)=>{E(D=>({...D,[f]:void 0})),i(D=>{const w={...D,[f]:N};if(ke.includes(f)){const B=f==="dca_mode"?"dca_base_investment_usd":"dca_mode";if(!me(w,B)){const q=M.find(U=>U.field===B);q&&(w[B]=q.overridden?q.draft:q.current)}}return w})},F=f=>{E(N=>({...N,[f]:void 0})),i(N=>{const D={...N};return delete D[f],ke.includes(f)&&delete D[f==="dca_mode"?"dca_base_investment_usd":"dca_mode"],D})},L=f=>{if(ke.includes(f)){E(N=>({...N,dca_mode:void 0,dca_base_investment_usd:void 0})),i(N=>({...N,dca_mode:null,dca_base_investment_usd:null}));return}T(f,null)},b=()=>{const f={};for(const B of Object.keys(o)){const q=o[B];if(q==null)continue;const U=String(q);B==="strategy_profile"&&!U.trim()&&(f[B]=l("accounts.form.select_profile")),B==="reserved_cash_floor"&&!ft(U)&&(f[B]=l("accounts.form.invalid_decimal")),B==="reserved_cash_ratio"&&!yn(U)&&(f[B]=l("accounts.form.invalid_ratio")),B==="dca_base_investment_usd"&&!vn(U)&&(f[B]=l("accounts.form.invalid_dca_amount"))}const N=Ge(M,o),D=typeof N.dca_mode=="string"&&N.dca_mode.length>0,w=typeof N.dca_base_investment_usd=="string"&&N.dca_base_investment_usd.length>0;return D!==w&&(f.dca_mode=l("accounts.form.dca_pair_required")),E(f),Object.keys(f).length===0},k=async f=>{h(!0),y(null);let N;try{const D=await ie(t.platform,t.account_alias);if(!D.identity||typeof D.identity!="object"||Array.isArray(D.identity))throw new Error("identity_missing");N=D.identity}catch{y({kind:"error",text:l("error.generic")}),h(!1);return}try{await xt({platform:t.platform,key:t.account_alias,identity:N,expected_draft_revision:f.draft_revision,overrides:Ge(f.rows,o)}),i({}),r(!1),y({kind:"success",text:`${l("accounts.draft_saved")} ${l("accounts.draft_note")}`}),s.reload()}catch(D){if(D instanceof kt&&D.status===409){const w=D.payload?.error,B=l(w==="account_settings_draft_revision_conflict"?"accounts.conflict":w==="account_settings_identity_conflict"?"accounts.identity_conflict":"error.conflict");y({kind:"error",text:B}),s.reload()}else y({kind:"error",text:l("accounts.save_unknown")})}finally{h(!1)}},O=async()=>{if(b()){x(!0),y(null);try{const f=await tt(t.account_alias,t.platform);if(f.identity_status==="identity_conflict"){y({kind:"error",text:l("accounts.identity_conflict")}),s.reload();return}const N=f.rows.filter(w=>{const B=w.overridden?w.draft:w.current,q=me(o,w.field)?o[w.field]:B;return String(q??"")!==String(B??"")}).map(w=>{const B=me(o,w.field)&&o[w.field]===null,q=B?w.current:Ve(w,o);return{section:w.section,field:w.field,label:Oe(l,w),before:w.current_status==="unknown"?null:w.current,after:B?l("accounts.form.inherit"):q,affectsLive:w.affects_live}});if(!N.length){_({kind:"info",text:l("accounts.no_changes")});return}await j({title:l("accounts.diff_dialog_title"),target:d.account(t.account_alias,t.platform),summary:l("accounts.draft_note"),body:n.jsx(hn,{rows:N,t:l}),ackLabel:N.some(w=>w.affectsLive)?l("accounts.ack_live"):void 0,confirmLabel:l("accounts.save_draft"),tone:"normal"})&&await k(f)}catch{_({kind:"error",text:l("error.generic")})}finally{x(!1)}}},A=async()=>{G&&!await j({title:l("common.unsaved_guard_title"),summary:l("common.unsaved_guard_body"),tone:"normal"})||(i({}),E({}),r(!1))},P=f=>{const N=Ve(f,o),D=me(o,f.field),w=N==null?"":String(N),B=g[f.field],q={id:m(f.field),"aria-invalid":!!B,"aria-describedby":B?`${m(f.field)}-error`:void 0};let U;if(f.field==="strategy_profile"){const W=V.some(H=>H.profile===w);U=n.jsxs("select",{...q,className:"input",value:w,onChange:H=>T(f.field,H.target.value),children:[!w&&n.jsx("option",{value:"",disabled:!0,children:l("accounts.form.select_profile")}),w&&!W&&n.jsx("option",{value:w,children:w}),V.map(H=>n.jsx("option",{value:H.profile,children:H.label},H.profile))]})}else f.field==="dca_mode"?U=n.jsxs("select",{...q,className:"input",value:w,onChange:W=>T(f.field,W.target.value),children:[!w&&n.jsx("option",{value:"",disabled:!0,children:l("common.na")}),n.jsx("option",{value:"fixed",children:l("accounts.dca_mode.fixed")}),n.jsx("option",{value:"smart",children:l("accounts.dca_mode.smart")})]}):f.field==="income_layer_enabled"?U=n.jsxs("select",{...q,className:"input",value:w,onChange:W=>T(f.field,W.target.value==="true"),children:[!w&&n.jsx("option",{value:"",disabled:!0,children:l("common.na")}),n.jsx("option",{value:"true",children:l("accounts.bool.on")}),n.jsx("option",{value:"false",children:l("accounts.bool.off")})]}):U=n.jsx("input",{...q,className:"input",value:w,inputMode:"decimal",maxLength:32,onChange:W=>T(f.field,W.target.value)});return n.jsxs("div",{className:"accounts-field-body",children:[n.jsxs("div",{className:"accounts-field-control",children:[U,D&&n.jsx("button",{type:"button",className:"button button-secondary button-sm",onClick:()=>F(f.field),children:l("accounts.form.undo")}),!D&&f.overridden&&n.jsx("button",{type:"button",className:"button button-secondary button-sm",onClick:()=>L(f.field),children:l("accounts.form.clear_override")})]}),n.jsxs("span",{className:"accounts-field-current",children:[l("decisions.col.current")," · ",Te(l,f.field,f.current,f.current_status==="unknown",c)]}),B&&n.jsx("span",{id:`${m(f.field)}-error`,className:"accounts-field-error",children:B})]})};return n.jsxs("section",{className:"card",children:[n.jsxs("div",{className:"accounts-toolbar",children:[n.jsx(be,{tone:e?"accent":"unknown",children:l(e?"accounts.editing":"accounts.viewing")}),n.jsx("span",{className:"asof",children:l("accounts.draft_revision",{value:I.draft_revision})}),n.jsx("span",{style:{flex:1}}),!e&&n.jsx("button",{type:"button",className:"button button-secondary",onClick:()=>r(!0),children:l("accounts.edit")}),e&&n.jsxs(n.Fragment,{children:[n.jsx("button",{type:"button",className:"button button-primary",disabled:v||p||$,onClick:()=>{O()},children:l(v?"accounts.checking":"accounts.check_changes")}),n.jsx("button",{type:"button",className:"button button-secondary",disabled:v||p,onClick:()=>{A()},children:l("common.cancel")})]})]}),C&&n.jsx("p",{className:"accounts-inline-note",children:l("accounts.retired_option_draft")}),$&&n.jsxs("p",{className:"accounts-inline-note error",role:"alert",children:[l("accounts.identity_conflict")," ",n.jsx("button",{type:"button",className:"accounts-alias-button",onClick:s.reload,children:l("common.refresh")})]}),S&&n.jsxs("p",{className:`accounts-inline-note ${S.kind}`,role:"status",children:[S.text," ",S.kind==="error"&&n.jsx("button",{type:"button",className:"accounts-alias-button",onClick:s.reload,children:l("common.refresh")})]}),p&&n.jsx("p",{className:"accounts-inline-note",role:"status",children:l("accounts.saving")}),e?Be(M).map(f=>n.jsxs("section",{className:"accounts-diff-section",children:[n.jsx("h3",{children:Pe(l,f.section)}),n.jsx("div",{className:"accounts-field-rows",children:f.rows.map(N=>n.jsxs("div",{className:"accounts-field-row",children:[n.jsx("label",{className:"accounts-field-label",htmlFor:m(N.field),children:Oe(l,N)}),P(N)]},N.field))})]},f.section)):n.jsx(pt,{rows:M,t:l})]})}function bn({children:t}){const s=z();return n.jsxs("section",{className:"danger-zone","aria-label":s("controls.title"),children:[n.jsx("h3",{className:"danger-zone-title",children:s("controls.title")}),n.jsx("p",{className:"card-note",style:{margin:0},children:s("controls.danger_note")}),t]})}function xn({title:t,summary:s,action:a,unavailableReason:e}){const r=z();return n.jsxs("div",{className:"danger-row",children:[n.jsxs("div",{className:"danger-row-text",children:[n.jsx("strong",{children:t}),n.jsx("p",{children:s}),e&&n.jsx("p",{children:r("controls.unavailable",{reason:e})})]}),n.jsx("div",{children:a})]})}const kn=new Set(["ibkr","schwab"]),Ue=new Set(["reserved","accepted","unknown","partial"]),jn=new Set(["applied","protected","rejected"]),Nn=[{name:"enable",titleKey:"controls.enable",summaryKey:"controls.enable_summary"},{name:"stop",titleKey:"controls.stop",summaryKey:"controls.stop_summary"},{name:"resume",titleKey:"controls.resume",summaryKey:"controls.resume_summary"},{name:"approve_application",titleKey:"controls.approve_application",summaryKey:"controls.approve_summary"}];function wn({account:t,config:s,confirm:a}){const e=z(),r=De(),o=xe(s),i=Q(()=>jt(t.account_alias,t.platform),[t.account_alias,t.platform]),[j,c]=R.useState(null),[d,u]=R.useState({}),m=`${t.platform}:${t.account_alias}`,[l,_]=R.useState(null),[v,x]=R.useState(null);if(R.useEffect(()=>{if(i.phase!=="ready"||!l||l.targetKey!==m||i.data.account_alias!==t.account_alias||i.data.platform!==t.platform)return;const k=i.data.runtime_control;!k||k.request_id!==l.requestId||jn.has(k.phase||"")&&_(null)},[i,l,m]),i.phase==="loading")return n.jsx(Y,{height:200});if(i.phase==="error")return n.jsx(fe,{onRetry:i.reload});const p=i.data;if(p.account_alias!==t.account_alias||p.platform!==t.platform)return n.jsx(Y,{height:200});const h=kn.has(t.platform.toLowerCase()),S=k=>{const O=`reason.${k}`,A=e(O);return A===O?k:A},y=p.runtime_control,g=l?.targetKey===m||!!(y&&Ue.has(y.phase||"")),E=y?.unavailable_reason?S(y.unavailable_reason):y&&(y.phase==="unknown"||y.phase==="partial")?e("controls.unknown_result"):e("controls.submitted"),I=y?.phase==="applied"&&y.platform_applied===!0&&(y.action==="enable"||y.action==="disable")?e(y.action==="enable"?"controls.result.enable":"controls.result.disable"):null,M=async()=>{try{await ne("/api/runtime-stop",{platform:t.platform,target_name:pe(s,t.platform,t.account_alias),operation:"inspect",confirm:"READ_ONLY"})}catch{}finally{i.reload()}},C=()=>{if(u({}),!h||!y||!Ue.has(y.phase||"")){i.reload();return}M()},$=(k,O)=>{u(A=>({...A,[k]:O?"submitted":"unknown"})),r({kind:O?"success":"error",text:e(O?"controls.submitted":"controls.unknown_result")})},V=async()=>{if(h){await F("disable");return}if(await a({title:e("controls.stop_confirm_title"),target:o.account(t.account_alias,t.platform),summary:e("controls.stop_summary"),consequence:e("controls.stop_consequence"),tone:"danger",confirmLabel:e("controls.stop"),typeToConfirm:{label:e("controls.stop_type_alias",{alias:t.account_alias}),expected:t.account_alias,mismatch:e("controls.alias_mismatch")}})){c("stop");try{await ne("/api/runtime-stop",{platform:t.platform,target_name:pe(s,t.platform,t.account_alias),confirm:"STOP_ONLY"}),$("stop",!0)}catch{$("stop",!1)}finally{c(null)}}},G=async()=>{const k=p.resume_binding?.runtime_target_sha256;if(!(typeof k!="string"||!k||!await a({title:e("controls.confirm.resume_title"),target:o.account(t.account_alias,t.platform),summary:e("controls.resume_summary"),tone:"danger",confirmLabel:e("controls.resume")}))){c("resume");try{await ne("/api/runtime-resume",{platform:t.platform,target_name:pe(s,t.platform,t.account_alias),runtime_target_sha256:k,confirm:"RESUME_EXISTING"}),$("resume",!0)}catch{$("resume",!1)}finally{c(null)}}},T=async()=>{if(await a({title:e("controls.confirm.approve_title"),target:o.account(t.account_alias,t.platform),summary:e("controls.approve_summary"),tone:"danger",confirmLabel:e("controls.approve_application")})){c("approve_application");try{const O=await ie(t.platform,t.account_alias),A=O.draft?.overrides||{},P=Object.keys(A),f=typeof A.strategy_profile=="string"?A.strategy_profile.trim():"",N=O.effective?.strategy_profile,D=N?.status==="known"&&typeof N.value=="string"?N.value.trim():"";if(!!!(O.identity&&Number.isSafeInteger(O.instance_revision)&&Number.isSafeInteger(O.draft?.revision)&&P.length===1&&P[0]==="strategy_profile"&&f&&D&&f!==D)){r({kind:"error",text:e("controls.approve_not_ready")});return}await ne("/api/account-settings/profile-application/approve",{platform:t.platform,key:t.account_alias,request_key:crypto.randomUUID(),identity:O.identity,expected_instance_revision:O.instance_revision,expected_draft_revision:O.draft?.revision,old_profile:D,new_profile:f}),$("approve_application",!0)}catch{$("approve_application",!1)}finally{c(null)}}},F=async k=>{const O=k==="enable"?"enable":"stop";if(!await a(k==="enable"?{title:e("controls.confirm.enable_title"),target:o.account(t.account_alias,t.platform),summary:e("controls.enable_summary"),consequence:e("controls.enable_control_note"),tone:"normal",confirmLabel:e("controls.enable")}:{title:e("controls.stop_confirm_title"),target:o.account(t.account_alias,t.platform),summary:e("controls.stop_summary"),consequence:e("controls.stop_consequence"),tone:"danger",confirmLabel:e("controls.stop"),typeToConfirm:{label:e("controls.stop_type_alias",{alias:t.account_alias}),expected:t.account_alias,mismatch:e("controls.alias_mismatch")}}))return;const P=crypto.randomUUID();_({requestId:P,targetKey:m}),x({name:O,targetKey:m});try{await ne("/api/runtime-stop",{platform:t.platform,target_name:pe(s,t.platform,t.account_alias),operation:k,request_id:P,confirm:"CONTROL_ONLY"}),r({kind:"success",text:e("controls.submitted")})}catch{r({kind:"error",text:e("controls.unknown_result")})}finally{x(f=>f?.targetKey===m?null:f),i.reload()}},b={enable:async()=>{if(h){await F("enable");return}await a({title:e("controls.confirm.enable_title"),target:o.account(t.account_alias,t.platform),summary:e("controls.enable_summary"),consequence:e("controls.enable_note"),tone:"normal",confirmLabel:e("common.close")})},stop:V,resume:G,approve_application:T};return n.jsxs("div",{className:"section-stack",children:[h&&y?.phase==="rejected"&&y.unavailable_reason&&n.jsx("p",{className:"card-note",children:S(y.unavailable_reason)}),h&&y?.phase==="protected"&&n.jsx("p",{className:"card-note",children:e("controls.protected")}),h&&I&&n.jsx("p",{className:"card-note",children:I}),n.jsx(bn,{children:Nn.map(({name:k,titleKey:O,summaryKey:A})=>{const P=p.actions[k],f=d[k],N=g&&(k==="enable"||k==="stop"),D=j!==null||v?.targetKey===m||!!f||N||!P.enabled,w=f?e(f==="submitted"?"controls.submitted":"controls.unknown_result"):N?E:P.enabled?null:S(P.reason);return n.jsx(xn,{title:e(O),summary:e(A),unavailableReason:w,action:n.jsx("button",{type:"button",className:`button ${k==="stop"||k==="resume"?"button-danger-outline":"button-secondary"}`,disabled:D,onClick:()=>{b[k]()},children:j===k||v?.targetKey===m&&v.name===k?e("controls.submitting"):e(O)})},k)})}),n.jsx("p",{className:"card-note",children:n.jsx("button",{type:"button",className:"accounts-alias-button",onClick:C,children:e("common.refresh")})})]})}function Sn({account:t}){const s=z(),a=De(),e=Q(()=>$e(t.account_alias,t.platform),[t.account_alias,t.platform]),[r,o]=R.useState([]),[i,j]=R.useState(null),[c,d]=R.useState(null),[u,m]=R.useState(!1);if(R.useEffect(()=>{e.phase==="ready"&&(o(e.data.items),j(e.data.next_cursor),d(e.data.availability))},[e.phase,e.data]),e.phase==="loading")return n.jsx(Y,{height:200});if(e.phase==="error")return n.jsx(fe,{onRetry:e.reload});const l=async()=>{if(i){m(!0);try{const p=await $e(t.account_alias,t.platform,25,i);o(h=>[...h,...p.items]),j(p.next_cursor),d(p.availability)}catch{a({kind:"error",text:s("error.generic")})}finally{m(!1)}}},_=p=>p.event==="draft_saved"?s("accounts.event.draft_saved"):p.event==="approved"?s("accounts.event.approved"):s("accounts.event.unrecorded"),v=r.map(p=>{const h=[p.actor_alias||s("accounts.event.unrecorded"),p.draft_revision===null?null:s("accounts.draft_revision",{value:p.draft_revision}),p.source?null:s("accounts.event.unrecorded"),s("decisions.ref",{id:p.short_id})].filter(Boolean),S=h.filter((y,g)=>y!==h[g-1]).join(" · ");return{id:p.id,time:p.time,title:_(p),detail:S}}),x=c?.effect_verification;return n.jsxs("section",{className:"card",children:[n.jsx("h2",{className:"card-title",children:s("accounts.tab.history")}),r.length===0?n.jsx(nt,{title:s("accounts.history.empty")}):n.jsx(Et,{items:v}),i&&n.jsx("div",{style:{marginTop:12},children:n.jsx("button",{type:"button",className:"button button-secondary",disabled:u,onClick:()=>{l()},children:s(u?"common.loading":"common.load_more")})}),x&&x.status!=="ok"&&n.jsxs("div",{className:"card-note",role:"status","data-state":x.status,children:[n.jsx("p",{children:s("accounts.effect_unconfirmed")}),n.jsx(le,{status:x.status,reason:x.unavailable_reason}),x.unavailable_reason&&n.jsx("span",{className:"state-short",children:s(`reason.${x.unavailable_reason}`)})]})]})}function On(){let t=0;return{begin(){return t+=1,t},isCurrent(s){return s===t},invalidate(){t+=1}}}async function mt(t,s,a){try{const e=await a();return t.isCurrent(s)?t.applyRefresh(s,e)?{status:"ready"}:(t.abandon(s),{status:"failed",message:"设置读回与所选账户不一致，请重新读取。"}):{status:"superseded"}}catch(e){if(!t.isCurrent(s))return{status:"superseded"};t.abandon(s);const r=Number(e?.status||0);return{status:"failed",message:r===401||r===403?"没有权限读取这项设置。":"账户设置暂时读不到。"}}}function K(t){return!!t&&typeof t=="object"&&!Array.isArray(t)}function re(t){return JSON.parse(JSON.stringify(t))}function X(t,s){const a=e=>Array.isArray(e)?e.map(a):K(e)?Object.fromEntries(Object.keys(e).sort().map(r=>[r,a(e[r])])):e;return JSON.stringify(a(t))===JSON.stringify(a(s))}function _t(t){return K(t)&&["empty","current","identity_conflict"].includes(t.status)&&t.source==="user_declared"&&Number.isSafeInteger(t.revision)&&t.revision>=0&&[null,"live","paper"].includes(t.environment)&&[null,"cash","margin"].includes(t.account_type)}function je(t,s){const a=t.body;if(!K(s)||s.ok!==!0||s.platform!==a.platform||s.key!==a.key||!K(s.identity)||!X(s.identity,a.identity)||s.adopted!==!1||s.no_order!==!0||s.execution_authority_granted!==!1||!K(s.draft)||!["empty","current","identity_conflict"].includes(s.draft.status)||!Number.isSafeInteger(s.draft.revision)||s.draft.revision<0||!K(s.draft.overrides)||!K(s.draft.current_identity)||!X(s.draft.current_identity,a.identity)||!K(s.risk)||!Number.isSafeInteger(s.risk.revision)||s.risk.revision<0||typeof t.risk.scope_id!="string"||!t.risk.scope_id||s.risk.scope_id!==t.risk.scope_id||![null,"CAPITAL_PRESERVATION","BALANCED_COMPOUNDING","GROWTH_COMPOUNDING"].includes(s.risk.preference))return!1;const e=s.declaration,r=Object.prototype.hasOwnProperty.call(a,"declaration");if(t.declaration.present||r){if(!_t(e))return!1;if(r){if(!K(a.declaration)||e.status!=="current"||e.revision!==t.declaration.revision+1||e.environment!==a.declaration.environment||e.account_type!==a.declaration.account_type)return!1}else if(e.revision<t.declaration.revision||e.revision===t.declaration.revision&&!X({status:e.status,revision:e.revision,environment:e.environment,account_type:e.account_type,source:e.source},{status:t.declaration.status,revision:t.declaration.revision,environment:t.declaration.environment,account_type:t.declaration.account_type,source:t.declaration.source}))return!1}if(!Object.prototype.hasOwnProperty.call(a,"overrides")){const o=s.draft;if(o.revision<t.draft.revision||o.revision===t.draft.revision&&!X({status:o.status,revision:o.revision,identity:o.identity,current_identity:o.current_identity,overrides:o.overrides},t.draft))return!1}if(!Object.prototype.hasOwnProperty.call(a,"risk_preference")){const o=s.risk;if(o.revision<t.risk.revision||o.revision===t.risk.revision&&o.preference!==t.risk.preference)return!1}if(Object.prototype.hasOwnProperty.call(a,"overrides")){const o=s.draft;if(!K(o)||o.status!=="current"||!K(o.overrides)||!K(o.identity)||!X(o.identity,a.identity)||!K(o.current_identity)||!X(o.current_identity,a.identity))return!1;const i=t.draft.status==="identity_conflict"&&a.acknowledge_identity_conflict===!0,j=i?{}:{...t.draft.overrides};for(const[u,m]of Object.entries(a.overrides))m===null?delete j[u]:j[u]=m;const c=t.draft.status==="empty"||i||!X(j,t.draft.overrides),d=t.draft.revision+(c?1:0);if(!Number.isSafeInteger(d)||d<0||o.revision!==d||!X(o.overrides,j))return!1}if(Object.prototype.hasOwnProperty.call(a,"risk_preference")){const o=s.risk;if(!K(o)||typeof t.risk.scope_id!="string"||!t.risk.scope_id||o.scope_id!==t.risk.scope_id||o.preference!==a.risk_preference||!Number.isSafeInteger(o.revision)||o.revision<0)return!1;const i=a.risk_preference!==t.risk.preference,j=t.risk.revision+(i?1:0),c=!i&&a.risk_preference!==null&&o.revision===j+1;if(!Number.isSafeInteger(j)||o.revision!==j&&!c)return!1}return!0}function yt(){return{strategy:"",floor:"",ratio:"",percent:"",income:"",option:"",dcaMode:"",dcaAmount:"",dcaProfile:"",strategyTouched:!1,incomeTouched:!1,optionTouched:!1,floorTouched:!1,ratioTouched:!1,dcaTouched:!1,clearStrategy:!1,clearFloor:!1,clearRatio:!1,clearDca:!1,cashMode:"",acknowledge:!1}}function Ce(){return{draft:!1,risk:!1,declaration:!1}}function ye(t,s){return!t||!Object.prototype.hasOwnProperty.call(t,s)?"":t[s]===!0?"true":t[s]===!1?"false":""}function Ke(t){return ye(t,"income_layer_enabled")}function Z(t,s){const a=t?.effective?.[s];return a?.status==="known"&&typeof a.value=="string"?a.value:""}function ge(t,s){return JSON.stringify(t??null)===JSON.stringify(s??null)}function te(t){const s=K(t)?t:{};return{environment:s.environment==="live"||s.environment==="paper"?s.environment:"",accountType:s.account_type==="cash"||s.account_type==="margin"?s.account_type:""}}function ce(t){return Object.prototype.hasOwnProperty.call(t,"risk_preference")?"risk":Object.prototype.hasOwnProperty.call(t,"declaration")?"declaration":"draft"}function ze(t){if(t.body&&Object.prototype.hasOwnProperty.call(t.body,"declaration"))return"declaration";if(t.body&&Object.prototype.hasOwnProperty.call(t.body,"risk_preference"))return"risk";const s=t.body?.overrides;if(!s||typeof s!="object"||Array.isArray(s))return"";const a=s;return Object.prototype.hasOwnProperty.call(a,"strategy_profile")||Object.prototype.hasOwnProperty.call(a,"dca_mode")||Object.prototype.hasOwnProperty.call(a,"dca_base_investment_usd")?"strategy":Object.prototype.hasOwnProperty.call(a,"option_overlay_enabled")?"option":Object.prototype.hasOwnProperty.call(a,"income_layer_enabled")?"income":Object.prototype.hasOwnProperty.call(a,"reserved_cash_floor")||Object.prototype.hasOwnProperty.call(a,"reserved_cash_ratio")?"cash":""}function We(){return{account:null,settings:null,preference:"",declaration:{environment:"",accountType:""},notice:"",noticeGroup:"",unavailable:"",saving:"",review:Ce(),draft:yt()}}function Ne(t){return/^\d+(?:\.\d+)?$/.test(t)&&Number.isFinite(Number(t))}function Tn(t){return t.length<=32&&/^(?:0|[1-9]\d*)(?:\.\d+)?$/.test(t)&&Number.isFinite(Number(t))&&Number(t)>0}function oe(t){return t.strategyTouched===!0||t.dcaTouched===!0||t.clearDca===!0}function He(t){return t.cashMode==="ratio"||t.cashMode==="both"||t.percent!==""?It(t.percent):Pt(t.ratio)}function Je(t,s="all"){const a={},e=s==="all"||s==="strategy",r=s==="all"||s==="income",o=s==="all"||s==="cash";if(e){if(t.clearDca)a.dca_mode=null,a.dca_base_investment_usd=null;else if(t.dcaTouched){if(t.dcaMode!=="fixed"&&t.dcaMode!=="smart"||!Tn(t.dcaAmount))return null;a.dca_mode=t.dcaMode,a.dca_base_investment_usd=t.dcaAmount}t.clearStrategy?a.strategy_profile=null:t.strategyTouched&&t.strategy?a.strategy_profile=t.strategy:(t.dcaTouched||t.clearDca)&&t.dcaProfile&&(a.strategy_profile=t.dcaProfile)}if(r&&(t.incomeTouched&&t.income==="true"?a.income_layer_enabled=!0:t.incomeTouched&&t.income==="false"?a.income_layer_enabled=!1:t.incomeTouched&&t.income==="clear"&&(a.income_layer_enabled=null)),o)if(t.cashMode==="inherit")a.reserved_cash_floor=null,a.reserved_cash_ratio=null;else if(t.cashMode==="floor"){if(!Ne(t.floor))return null;a.reserved_cash_floor=t.floor,a.reserved_cash_ratio="0"}else if(t.cashMode==="ratio"||t.cashMode==="both"){const i=He(t);if(!i||t.cashMode==="both"&&!Ne(t.floor))return null;a.reserved_cash_floor=t.cashMode==="ratio"?"0":t.floor,a.reserved_cash_ratio=i}else{if(t.clearFloor)a.reserved_cash_floor=null;else if(t.floorTouched){if(!Ne(t.floor))return null;a.reserved_cash_floor=t.floor}if(t.clearRatio)a.reserved_cash_ratio=null;else if(t.ratioTouched){const i=He(t);if(!i)return null;a.reserved_cash_ratio=i}}return a}function vt(t=new Map){const s=On();let a=null,e=We(),r=null,o=null;const i=c=>!!(a&&c&&a.platform===c.platform&&a.key===c.key),j=c=>!!(c&&s.isCurrent(c.token)&&i(c.account));return{selectedId(){return a?`${a.platform}:${a.key}`:""},view(){const c=t.get(this.selectedId());if(c){const d=ce(c.body);e={...e,review:{...e.review,[d]:!0}}}return e},riskDirty(){const c=e.settings||r;return(e.preference||"")!==(typeof c?.risk?.preference=="string"?c.risk.preference:"")},declarationDirty(){const c=e.settings||r,d=te(c?.declaration);return e.declaration.environment!==d.environment||e.declaration.accountType!==d.accountType},select(c){const d=!i(c);return a={platform:c.platform,key:c.key},d&&(s.invalidate(),e={...We(),account:a},r=null,o=null),this.start("read")},start(c){if(!a)throw new Error("account_settings_account_required");return{token:s.begin(),account:{platform:a.platform,key:a.key},kind:c}},isCurrent(c){return j(c)},abandon(c){j(c)&&s.invalidate()},applyRead(c,d,u={}){if(!j(c)||d?.platform!==c.account.platform||d?.key!==c.account.key)return!1;const m=t.get(this.selectedId());if((K((e.settings||r)?.declaration)||m?.declaration.present||Object.prototype.hasOwnProperty.call(d,"declaration"))&&!_t(d.declaration))return!1;const _=m&&je(m,d);_&&t.delete(this.selectedId());const v=d.draft?.overrides||{},x=typeof(e.settings||r)?.risk?.preference=="string"?(e.settings||r).risk.preference:"",p=u.keepCash===!0&&ee(e.draft),h=te((e.settings||r)?.declaration),S=u.keepDeclaration===!0&&(e.declaration.environment!==h.environment||e.declaration.accountType!==h.accountType),y=u.keepPreference===!0&&(e.preference||"")!==x,g=u.keepIncome===!0&&e.draft.incomeTouched===!0,E=u.keepStrategy===!0&&oe(e.draft),I=u.keepOption===!0&&e.draft.optionTouched===!0;if(r=d,e={account:{platform:c.account.platform,key:c.account.key},settings:d,preference:y?e.preference:d.risk?.preference||"",declaration:S?e.declaration:te(d.declaration),notice:u.preserveNotice?e.notice:"",noticeGroup:u.preserveNotice?e.noticeGroup:"",unavailable:"",saving:"",review:Ce(),draft:{strategy:E?e.draft.strategy:typeof v.strategy_profile=="string"?v.strategy_profile:"",floor:p?e.draft.floor:typeof v.reserved_cash_floor=="string"?v.reserved_cash_floor:"",ratio:p?e.draft.ratio:typeof v.reserved_cash_ratio=="string"?v.reserved_cash_ratio:"",percent:p?e.draft.percent:"",income:g?e.draft.income:Ke(v),option:I?e.draft.option:ye(v,"option_overlay_enabled"),dcaMode:E?e.draft.dcaMode:v.dca_mode==="fixed"||v.dca_mode==="smart"?v.dca_mode:d.current_dca_supported===!0?Z(d,"dca_mode"):"",dcaAmount:E?e.draft.dcaAmount:typeof v.dca_base_investment_usd=="string"?v.dca_base_investment_usd:d.current_dca_supported===!0?Z(d,"dca_base_investment_usd"):"",dcaProfile:E?e.draft.dcaProfile:typeof v.strategy_profile=="string"?v.strategy_profile:d.current_dca_supported===!0?Z(d,"strategy_profile"):"",strategyTouched:E?e.draft.strategyTouched:!1,incomeTouched:g,optionTouched:I,floorTouched:p?e.draft.floorTouched:!1,ratioTouched:p?e.draft.ratioTouched:!1,dcaTouched:E?e.draft.dcaTouched:!1,clearStrategy:E?e.draft.clearStrategy:!1,clearDca:E?e.draft.clearDca:!1,clearFloor:p?e.draft.clearFloor:!1,clearRatio:p?e.draft.clearRatio:!1,cashMode:p?e.draft.cashMode:"",acknowledge:!1}},m){const M=ce(m.body);e={...e,notice:_?M==="risk"?"偏好已保存":M==="declaration"?"声明已保存":"草案已保存":"状态未知",noticeGroup:_?ze({...c,body:m.body}):"",review:{...e.review,[M]:!_}}}return!0},applyUnavailable(c,d){return j(c)?(e={...e,settings:null,unavailable:d,saving:""},!0):!1},edit(c){if(!e.settings||!i(e.account))return!1;const{preference:d,...u}=c;return e={...e,preference:d===void 0?e.preference:d,draft:{...e.draft,...u}},!0},editDeclaration(c){return!e.settings||!i(e.account)?!1:(e={...e,declaration:{...e.declaration,...c}},!0)},startSave(c){if(e.saving||t.has(this.selectedId())||!a||!e.settings||!i(e.account)||e.settings.platform!==a.platform||e.settings.key!==a.key||!e.settings.identity||typeof e.settings.identity!="object")return null;const d={platform:a.platform,key:a.key};let u;if(c==="declaration"){if(e.settings.operations?.save_declaration!==!0||e.review?.declaration||!Number.isSafeInteger(e.settings.declaration?.revision))return null;const l=te(e.settings.declaration);if(e.declaration.environment===l.environment&&e.declaration.accountType===l.accountType)return null;u={platform:d.platform,key:d.key,identity:e.settings.identity,expected_declaration_revision:e.settings.declaration.revision,declaration:{environment:e.declaration.environment||null,account_type:e.declaration.accountType||null}}}else if(c==="risk"){if(e.settings.operations?.save_risk_preference!==!0||e.review?.risk||!Number.isSafeInteger(e.settings.risk?.revision))return null;u={platform:d.platform,key:d.key,identity:e.settings.identity,expected_risk_revision:e.settings.risk.revision,risk_preference:e.preference||null}}else{if(e.settings.operations?.save_draft!==!0||c==="option"&&(e.draft.option==="true"||e.draft.option==="false")&&e.settings.operations?.save_option_draft!==!0||e.review?.draft||e.settings.draft?.status==="identity_conflict"&&!e.draft.acknowledge)return null;const l=c==="income"||c==="cash"||c==="option"||c==="strategy"?c:"all",_=Je(e.draft,l);if(c==="strategy"&&!Object.prototype.hasOwnProperty.call(_||{},"strategy_profile")||!_||!Object.keys(_).length||!Number.isSafeInteger(e.settings.draft?.revision))return null;Object.prototype.hasOwnProperty.call(e.settings.draft?.overrides||{},"option_overlay_enabled")&&(_.option_overlay_enabled=null),u={platform:d.platform,key:d.key,...Bt({expectedDraftRevision:e.settings.draft.revision,identity:e.settings.identity,overrides:_,acknowledgeIdentityConflict:e.settings.draft?.status==="identity_conflict"&&e.draft.acknowledge})}}if(u.platform!==d.platform||u.key!==d.key)return null;const m=s.begin();return o={token:m,body:re(u),draft:re({status:e.settings.draft.status,revision:e.settings.draft.revision,identity:e.settings.draft.identity,current_identity:e.settings.draft.current_identity,overrides:e.settings.draft.overrides||{}}),risk:re({revision:e.settings.risk.revision,scope_id:e.settings.risk.scope_id,preference:e.settings.risk.preference||null}),declaration:re({present:K(e.settings.declaration),status:typeof e.settings.declaration?.status=="string"?e.settings.declaration.status:"empty",source:typeof e.settings.declaration?.source=="string"?e.settings.declaration.source:null,revision:Number.isSafeInteger(e.settings.declaration?.revision)?e.settings.declaration.revision:0,environment:e.settings.declaration?.environment==="live"||e.settings.declaration?.environment==="paper"?e.settings.declaration.environment:null,account_type:e.settings.declaration?.account_type==="cash"||e.settings.declaration?.account_type==="margin"?e.settings.declaration.account_type:null})},{token:m,account:d,kind:"save",body:re(u)}},requestBody(c){return!c?.body||!j(c)||c.body.platform!==c.account.platform||c.body.key!==c.account.key?null:c.body},markSaving(c,d){return e.saving||!j(c)?!1:(o?.token===c.token&&t.set(this.selectedId(),o),e={...e,saving:d,notice:""},!0)},applySave(c,d,u){if(!j(c))return!1;const m=t.get(this.selectedId());if(m&&m!==o||e.saving&&!m)return!1;if(!o||o.token!==c.token||!X(c.body,o.body)||!je(o,d)){o?.token===c.token&&t.set(this.selectedId(),o);const se=o?.token===c.token?ce(o.body):"draft";return e={...e,notice:"状态未知",noticeGroup:"",review:{...e.review,[se]:!0}},!1}t.delete(this.selectedId());const l=c.body?.overrides,_=Je(e.draft,"cash"),v=!!(l&&(Object.prototype.hasOwnProperty.call(l,"reserved_cash_floor")||Object.prototype.hasOwnProperty.call(l,"reserved_cash_ratio"))),x=!!(l&&Object.prototype.hasOwnProperty.call(l,"income_layer_enabled")),p=!!(l&&Object.prototype.hasOwnProperty.call(l,"option_overlay_enabled")),h=!!(l&&Object.prototype.hasOwnProperty.call(l,"strategy_profile")),S=!!(l&&(Object.prototype.hasOwnProperty.call(l,"dca_mode")||Object.prototype.hasOwnProperty.call(l,"dca_base_investment_usd"))),y=!!(c.body&&Object.prototype.hasOwnProperty.call(c.body,"risk_preference")),g=!!(c.body&&Object.prototype.hasOwnProperty.call(c.body,"declaration")),E=e.draft.income==="true"?!0:e.draft.income==="false"?!1:null,I=e.draft.option==="true"?!0:e.draft.option==="false"?!1:null,M=ee(e.draft)&&(_===null||["reserved_cash_floor","reserved_cash_ratio"].some(se=>Object.prototype.hasOwnProperty.call(_,se)?!l||!Object.prototype.hasOwnProperty.call(l,se)||l[se]!==_[se]:!1)),C=e.draft.incomeTouched===!0&&!(x&&l?.income_layer_enabled===E),$=e.draft.optionTouched===!0&&!(p&&l?.option_overlay_enabled===I),V=h&&(e.draft.clearStrategy&&l?.strategy_profile===null||e.draft.strategyTouched&&l?.strategy_profile===e.draft.strategy||(e.draft.dcaTouched||e.draft.clearDca)&&l?.strategy_profile===e.draft.dcaProfile),G=e.draft.strategyTouched===!0&&!V,T=S&&(e.draft.clearDca&&l?.dca_mode===null&&l?.dca_base_investment_usd===null||!e.draft.clearDca&&l?.dca_mode===e.draft.dcaMode&&l?.dca_base_investment_usd===e.draft.dcaAmount),F=(e.draft.dcaTouched===!0||e.draft.clearDca===!0)&&!T,L=G||F,b=typeof(e.settings||r)?.risk?.preference=="string"?(e.settings||r).risk.preference:"",k=y?(e.preference||"")!==(c.body?.risk_preference||""):(e.preference||"")!==b,O=e.review||Ce(),A=e.settings||r,P=!ge(A?.identity,d?.identity),f=ee(e.draft)||e.draft.incomeTouched===!0||e.draft.optionTouched===!0||oe(e.draft),N=!v&&!x&&!p&&!h&&!S&&f&&(P||A?.draft?.revision!==d?.draft?.revision),D=!y&&k&&(P||A?.risk?.revision!==d?.risk?.revision),w=c.body?.declaration&&typeof c.body.declaration=="object"?c.body.declaration:{},B=typeof w.environment=="string"?w.environment:"",q=typeof w.account_type=="string"?w.account_type:"",U=te(A?.declaration),W=g?e.declaration.environment!==B||e.declaration.accountType!==q:e.declaration.environment!==U.environment||e.declaration.accountType!==U.accountType,H=!g&&W&&(P||A?.declaration?.revision!==d?.declaration?.revision);if(!this.applyRead(c,d,{keepCash:v?M:ee(e.draft),keepIncome:x?C:e.draft.incomeTouched===!0,keepOption:p?$:e.draft.optionTouched===!0,keepStrategy:h||S?L:oe(e.draft),keepPreference:k,keepDeclaration:W}))return!1;const ae=v||x||p||h||S,Me=v&&(C||$||L)||x&&(M||$||L)||p&&(M||C||L)||(h||S)&&(M||C||$);return e={...e,notice:u,noticeGroup:ze(c),saving:"",review:{draft:ae?!!(P&&Me):O.draft||N,risk:y?!1:O.risk||D,declaration:g?!1:O.declaration||H}},!0},fail(c,d,u=!1){if(!j(c))return!1;const m=t.get(this.selectedId());if(m&&m!==o||u&&!m)return!1;u?o?.token===c.token&&t.set(this.selectedId(),o):t.delete(this.selectedId());const l=o?ce(o.body):"draft";return e={...e,notice:u?"状态未知":d,noticeGroup:"",saving:"",review:u?{...e.review,[l]:!0}:e.review},!0},applyRefresh(c,d){if(!j(c))return!1;const u=e,m=t.get(this.selectedId());if(m&&je(m,d)){o={...m,token:c.token},t.set(this.selectedId(),o);const V=ce(m.body);return this.applySave({...c,body:re(m.body)},d,V==="risk"?"偏好已保存":V==="declaration"?"声明已保存":"草案已保存")}const l=m?"状态未知":u.notice,_=u.settings||r,v=ee(u.draft),x=u.draft.incomeTouched===!0,p=u.draft.optionTouched===!0,h=oe(u.draft),S=typeof _?.risk?.preference=="string"?_.risk.preference:"",y=(u.preference||"")!==S,g=te(_?.declaration),E=u.declaration.environment!==g.environment||u.declaration.accountType!==g.accountType,I=!ge(_?.identity,d?.identity),M=Number(_?.draft?.revision)!==Number(d?.draft?.revision),C=Number(_?.risk?.revision)!==Number(d?.risk?.revision),$=Number(_?.declaration?.revision)!==Number(d?.declaration?.revision);return this.applyRead(c,d,{preserveNotice:!0,keepCash:!0,keepPreference:!0,keepIncome:!0,keepOption:!0,keepStrategy:!0,keepDeclaration:!0})?(e={...e,notice:l,saving:"",review:{draft:!!u.review?.draft||(v||x||p||h)&&(I||M),risk:!!u.review?.risk||y&&(I||C),declaration:!!u.review?.declaration||E&&(I||$)}},!0):!1},acknowledgeReview(c){const d=t.get(this.selectedId());return d&&ce(d.body)===c||!e.review?.[c]?!1:(e={...e,review:{...e.review,[c]:!1}},!0)},revertDraft(){if(!e.settings)return!1;const c=e.settings.draft?.overrides||{};return e={...e,review:{draft:!1,risk:!!e.review?.risk,declaration:!!e.review?.declaration},draft:{...yt(),strategy:typeof c.strategy_profile=="string"?c.strategy_profile:"",dcaMode:c.dca_mode==="fixed"||c.dca_mode==="smart"?c.dca_mode:e.settings.current_dca_supported===!0?Z(e.settings,"dca_mode"):"",dcaAmount:typeof c.dca_base_investment_usd=="string"?c.dca_base_investment_usd:e.settings.current_dca_supported===!0?Z(e.settings,"dca_base_investment_usd"):"",dcaProfile:typeof c.strategy_profile=="string"?c.strategy_profile:e.settings.current_dca_supported===!0?Z(e.settings,"strategy_profile"):"",floor:typeof c.reserved_cash_floor=="string"?c.reserved_cash_floor:"",ratio:typeof c.reserved_cash_ratio=="string"?c.reserved_cash_ratio:"",income:Ke(c),option:ye(c,"option_overlay_enabled")}},!0},revertCash(){if(!e.settings)return!1;const c=e.settings.draft?.overrides||{},d=e.draft.incomeTouched===!0||e.draft.optionTouched===!0||oe(e.draft);return e={...e,review:{draft:d?!!e.review?.draft:!1,risk:!!e.review?.risk,declaration:!!e.review?.declaration},draft:{...e.draft,floor:typeof c.reserved_cash_floor=="string"?c.reserved_cash_floor:"",ratio:typeof c.reserved_cash_ratio=="string"?c.reserved_cash_ratio:"",percent:"",floorTouched:!1,ratioTouched:!1,clearFloor:!1,clearRatio:!1,cashMode:""}},!0},revertStrategy(){if(!e.settings)return!1;const c=e.settings.draft?.overrides||{},d=ee(e.draft)||e.draft.incomeTouched===!0||e.draft.optionTouched===!0,u=e.settings.draft?.overrides||{};return e={...e,review:{draft:d?!!e.review?.draft:!1,risk:!!e.review?.risk,declaration:!!e.review?.declaration},draft:{...e.draft,strategy:typeof c.strategy_profile=="string"?c.strategy_profile:"",dcaMode:u.dca_mode==="fixed"||u.dca_mode==="smart"?u.dca_mode:e.settings.current_dca_supported===!0?Z(e.settings,"dca_mode"):"",dcaAmount:typeof u.dca_base_investment_usd=="string"?u.dca_base_investment_usd:e.settings.current_dca_supported===!0?Z(e.settings,"dca_base_investment_usd"):"",dcaProfile:typeof u.strategy_profile=="string"?u.strategy_profile:e.settings.current_dca_supported===!0?Z(e.settings,"strategy_profile"):"",strategyTouched:!1,dcaTouched:!1,clearStrategy:!1,clearDca:!1}},!0},revertOption(){if(!e.settings)return!1;const c=e.settings.draft?.overrides||{},d=ee(e.draft)||e.draft.incomeTouched===!0||oe(e.draft);return e={...e,review:{draft:d?!!e.review?.draft:!1,risk:!!e.review?.risk,declaration:!!e.review?.declaration},draft:{...e.draft,option:ye(c,"option_overlay_enabled"),optionTouched:!1}},!0},revertRisk(){return e.settings?(e={...e,preference:typeof e.settings.risk?.preference=="string"?e.settings.risk.preference:"",review:{draft:!!e.review?.draft,risk:!1,declaration:!!e.review?.declaration}},!0):!1},revertDeclaration(){return e.settings?(e={...e,declaration:te(e.settings.declaration),review:{...e.review,declaration:!1}},!0):!1},finish(c){return j(c)?(e={...e,saving:""},!0):!1}}}const Cn=new Map,Ye=["CAPITAL_PRESERVATION","BALANCED_COMPOUNDING","GROWTH_COMPOUNDING"];function An({platform:t,accountKey:s}){const a=z(),e=R.useId(),r=R.useRef(vt(Cn)).current,[,o]=R.useState(0),[i,j]=R.useState(0),[c,d]=R.useState("loading"),[u,m]=R.useState(""),[l,_]=R.useState(""),v=()=>o(T=>T+1),x=r.view(),p=x.settings;R.useEffect(()=>{const T=`${t}:${s}`,F=r.selectedId()===T;if(F&&r.view().saving)return;const L=F&&!!r.view().settings,b=F?r.start("refresh"):r.select({platform:t,key:s});d(L?"refreshing":"loading"),m(""),_("");let k=!1;return(async()=>{try{const O=await ie(t,s);if(k)return;if(!(F?r.applyRefresh(b,O):r.applyRead(b,O))){if(r.isCurrent(b))throw new Error("account_settings_readback_mismatch");return}d("ready"),v()}catch(O){if(k)return;const A=Number(O?.status||0),P=A===401||A===403?"denied":O?.message==="account_settings_readback_mismatch"?"mismatch":"unavailable";if(L){if(!r.isCurrent(b))return;r.abandon(b),m(P),d("stale"),v();return}if(!r.applyUnavailable(b,""))return;d("failed"),v()}})(),()=>{k=!0,r.abandon(b)}},[t,s,i,r]);const h=async()=>{const T=r.startSave("risk"),F=r.requestBody(T);if(!T||!F||!r.markSaving(T,"risk"))return;_(""),v();let L=!1,b="",k=null;try{const D=await ne("/api/account-settings",F);if(!r.isCurrent(T))return;L=r.applySave(T,D,""),L&&(k=D.risk?.revision),L||(b="unknown")}catch(D){D?.status===409?(b="conflict",r.fail(T,"",!1)):(b="unknown",r.fail(T,"",!0))}finally{r.finish(T)&&v()}if(!r.isCurrent(T))return;v();const O=r.start("refresh"),A=await mt(r,O,()=>ie(t,s));if(v(),A.status==="superseded")return;if(A.status==="failed"){_(L?"unverified":b==="conflict"?"conflict":"");return}if(b==="conflict"){_("conflict");return}if(!L){r.view().review.risk||_("saved");return}const P=r.view().settings,f=typeof P?.risk?.preference=="string"?P?.risk?.preference:"",N=F.risk_preference===null||F.risk_preference===void 0?"":String(F.risk_preference);_(f===N&&ge(P?.identity,F.identity)&&P?.risk?.revision===k?"saved":"mismatch")},S=p?.operations?.save_risk_preference===!0,y=typeof p?.risk?.preference=="string"?p?.risk?.preference:"",g=T=>a(T==="CAPITAL_PRESERVATION"?"risk.capital":T==="BALANCED_COMPOUNDING"?"risk.balanced":T==="GROWTH_COMPOUNDING"?"risk.growth":"risk.other"),E=x.preference!==""&&!Ye.includes(x.preference),I=r.riskDirty(),M=!!(p?.identity&&typeof p.identity=="object"&&Number.isSafeInteger(p?.risk?.revision)),C=c==="ready"&&S&&!x.saving&&l!=="unverified"&&l!=="mismatch",$=C&&M&&I&&!x.review.risk&&!E,V=l==="conflict"?{tone:"error",text:a("risk.conflict")}:l==="mismatch"?{tone:"error",text:a("risk.mismatch")}:l==="unverified"?{tone:"error",text:a("risk.unverified")}:l==="saved"?{tone:"success",text:a("risk.saved")}:x.review.risk?{tone:"error",text:a("risk.review")}:null,G=a(u==="denied"?"risk.denied":u==="mismatch"?"risk.readMismatch":"risk.readFailed");return n.jsxs("section",{className:"card",children:[n.jsx("h2",{className:"card-title",children:a("risk.title")}),n.jsx("p",{className:"card-note",children:a("risk.note")}),c==="loading"&&n.jsx(Y,{height:96}),c==="failed"&&n.jsxs("p",{className:"accounts-inline-note error",role:"alert",children:[G," ",n.jsx("button",{type:"button",className:"accounts-alias-button",onClick:()=>j(T=>T+1),children:a("risk.reread")})]}),c==="stale"&&n.jsxs("p",{className:"accounts-inline-note error",role:"alert",children:[G," ",a("risk.stale")," ",n.jsx("button",{type:"button",className:"accounts-alias-button",onClick:()=>j(T=>T+1),children:a("risk.reread")})]}),V&&n.jsxs("p",{className:`accounts-inline-note ${V.tone}`,role:V.tone==="success"?"status":"alert",children:[V.text," ",V.tone!=="success"&&n.jsx("button",{type:"button",className:"accounts-alias-button",onClick:()=>j(T=>T+1),children:a("risk.reread")})]}),x.saving&&n.jsx("p",{className:"accounts-inline-note",role:"status",children:a("risk.saving")}),c!=="loading"&&p&&n.jsxs(n.Fragment,{children:[n.jsx("div",{className:"accounts-field-rows",children:n.jsxs("div",{className:"accounts-field-row",children:[n.jsx("label",{className:"accounts-field-label",htmlFor:e,children:a("risk.field")}),n.jsxs("div",{className:"accounts-field-body",children:[n.jsx("div",{className:"accounts-field-control",children:n.jsxs("select",{id:e,className:"input",value:x.preference,disabled:!C,onChange:T=>{_(""),r.edit({preference:T.target.value}),v()},children:[n.jsx("option",{value:"",children:a("risk.unset")}),Ye.map(T=>n.jsx("option",{value:T,children:g(T)},T)),E&&n.jsx("option",{value:x.preference,children:a("risk.other")})]})}),n.jsxs("span",{className:"accounts-field-current",children:[a("risk.savedValue")," · ",y===""?a("risk.unset"):g(y)]})]})]})}),n.jsxs("div",{className:"accounts-toolbar",children:[n.jsx("button",{type:"button",className:"button button-primary",disabled:!$,onClick:()=>{h()},children:a("risk.save")}),I&&n.jsx("button",{type:"button",className:"button button-secondary",onClick:()=>{r.revertRisk(),_(""),v()},children:a("risk.discard")}),!S&&n.jsx("span",{className:"card-note",children:a("risk.gate")})]}),x.review.risk&&n.jsx("button",{type:"button",className:"button button-secondary button-sm",onClick:()=>{r.acknowledgeReview("risk")||j(T=>T+1),v()},children:a("risk.ack")})]})]})}const Dn=new Map,Rn=["live","paper"],En=["cash","margin"];function _e(t){return t==="live"||t==="paper"||t==="cash"||t==="margin"?t:""}function In({platform:t,accountKey:s,onSaved:a}){const e=z(),r=R.useId(),o=R.useId(),i=R.useRef(vt(Dn)).current,[,j]=R.useState(0),[c,d]=R.useState(0),[u,m]=R.useState("loading"),[l,_]=R.useState(""),[v,x]=R.useState(""),p=()=>j(b=>b+1),h=i.view(),S=h.settings;R.useEffect(()=>{const b=`${t}:${s}`,k=i.selectedId()===b;if(k&&i.view().saving)return;const O=k&&!!i.view().settings,A=k?i.start("refresh"):i.select({platform:t,key:s});m(O?"refreshing":"loading"),_(""),x("");let P=!1;return(async()=>{try{const f=await ie(t,s);if(P)return;if(!(k?i.applyRefresh(A,f):i.applyRead(A,f))){if(i.isCurrent(A))throw new Error("account_settings_readback_mismatch");return}m("ready"),p()}catch(f){if(P)return;const N=Number(f?.status||0),D=N===401||N===403?"denied":f?.message==="account_settings_readback_mismatch"?"mismatch":"unavailable";if(O){if(!i.isCurrent(A))return;i.abandon(A),_(D),m("stale"),p();return}if(!i.applyUnavailable(A,""))return;m("failed"),p()}})(),()=>{P=!0,i.abandon(A)}},[t,s,c,i]);const y=async()=>{const b=i.startSave("declaration"),k=i.requestBody(b);if(!b||!k||!i.markSaving(b,"declaration"))return;x(""),p();let O=!1,A="",P=null;try{const ae=await ne("/api/account-settings",k);if(!i.isCurrent(b))return;O=i.applySave(b,ae,""),O&&(P=ae.declaration?.revision),O||(A="unknown")}catch(ae){ae?.status===409?(A="conflict",i.fail(b,"",!1)):(A="unknown",i.fail(b,"",!0))}finally{i.finish(b)&&p()}if(!i.isCurrent(b))return;p();const f=i.start("refresh"),N=await mt(i,f,()=>ie(t,s));if(p(),N.status==="superseded")return;if(N.status==="failed"){x(O?"unverified":A==="conflict"?"conflict":"");return}if(A==="conflict"){x("conflict");return}if(!O){i.view().review.declaration||(x("saved"),a());return}const D=i.view().settings,w=k.declaration,B=w.environment??"",q=w.account_type??"",U=_e(D?.declaration?.environment),W=_e(D?.declaration?.account_type),H=U===B&&W===q&&ge(D?.identity,k.identity)&&D?.declaration?.revision===P;x(H?"saved":"mismatch"),H&&a()},g=S?.operations?.save_declaration===!0,E=_e(S?.declaration?.environment),I=_e(S?.declaration?.account_type),M=i.declarationDirty(),C=!!(S?.identity&&typeof S.identity=="object"&&Number.isSafeInteger(S?.declaration?.revision)),$=u==="ready"&&S?.declaration?.status!=="identity_conflict"&&g&&!h.saving&&v!=="unverified"&&v!=="mismatch",V=$&&C&&M&&!h.review.declaration,G=v==="conflict"?{tone:"error",text:e("accounts.declaration.conflict")}:v==="mismatch"?{tone:"error",text:e("accounts.declaration.mismatch")}:v==="unverified"?{tone:"error",text:e("accounts.declaration.unverified")}:v==="saved"?{tone:"success",text:e("accounts.declaration.saved")}:h.review.declaration?{tone:"error",text:e("accounts.declaration.review")}:null,T=e(l==="denied"?"accounts.declaration.denied":l==="mismatch"?"accounts.declaration.readMismatch":"accounts.declaration.readFailed"),F=b=>e(b==="live"?"accounts.declaration.env.live":b==="paper"?"accounts.declaration.env.paper":"accounts.declaration.unset"),L=b=>e(b==="cash"?"accounts.declaration.type.cash":b==="margin"?"accounts.declaration.type.margin":"accounts.declaration.unset");return n.jsxs("section",{className:"card",children:[n.jsx("h2",{className:"card-title",children:e("accounts.declaration.title")}),n.jsx("p",{className:"card-note",children:e("accounts.declaration.note")}),u==="loading"&&n.jsx(Y,{height:96}),u==="failed"&&n.jsxs("p",{className:"accounts-inline-note error",role:"alert",children:[T," ",n.jsx("button",{type:"button",className:"accounts-alias-button",onClick:()=>d(b=>b+1),children:e("accounts.declaration.reread")})]}),u==="stale"&&n.jsxs("p",{className:"accounts-inline-note error",role:"alert",children:[T," ",e("accounts.declaration.stale")," ",n.jsx("button",{type:"button",className:"accounts-alias-button",onClick:()=>d(b=>b+1),children:e("accounts.declaration.reread")})]}),G&&n.jsxs("p",{className:`accounts-inline-note ${G.tone}`,role:G.tone==="success"?"status":"alert",children:[G.text," ",G.tone!=="success"&&n.jsx("button",{type:"button",className:"accounts-alias-button",onClick:()=>d(b=>b+1),children:e("accounts.declaration.reread")})]}),h.saving&&n.jsx("p",{className:"accounts-inline-note",role:"status",children:e("accounts.declaration.saving")}),u!=="loading"&&S&&n.jsxs(n.Fragment,{children:[n.jsxs("div",{className:"accounts-field-rows",children:[n.jsxs("div",{className:"accounts-field-row",children:[n.jsx("label",{className:"accounts-field-label",htmlFor:r,children:e("accounts.declaration.environment")}),n.jsxs("div",{className:"accounts-field-body",children:[n.jsx("div",{className:"accounts-field-control",children:n.jsxs("select",{id:r,className:"input",value:h.declaration.environment,disabled:!$,onChange:b=>{x(""),i.editDeclaration({environment:b.target.value}),p()},children:[n.jsx("option",{value:"",children:e("accounts.declaration.unset")}),Rn.map(b=>n.jsx("option",{value:b,children:F(b)},b))]})}),n.jsxs("span",{className:"accounts-field-current",children:[e("accounts.declaration.savedValue")," · ",E===""?e("accounts.declaration.unset"):F(E)]})]})]}),t!=="binance"&&n.jsxs("div",{className:"accounts-field-row",children:[n.jsx("label",{className:"accounts-field-label",htmlFor:o,children:e("accounts.declaration.account_type")}),n.jsxs("div",{className:"accounts-field-body",children:[n.jsx("div",{className:"accounts-field-control",children:n.jsxs("select",{id:o,className:"input",value:h.declaration.accountType,disabled:!$,onChange:b=>{x(""),i.editDeclaration({accountType:b.target.value}),p()},children:[n.jsx("option",{value:"",children:e("accounts.declaration.unset")}),En.map(b=>n.jsx("option",{value:b,children:L(b)},b))]})}),n.jsxs("span",{className:"accounts-field-current",children:[e("accounts.declaration.savedValue")," · ",I===""?e("accounts.declaration.unset"):L(I)]})]})]})]}),n.jsxs("div",{className:"accounts-toolbar",children:[n.jsx("button",{type:"button",className:"button button-primary",disabled:!V,onClick:()=>{y()},children:e("accounts.declaration.save")}),M&&n.jsx("button",{type:"button",className:"button button-secondary",onClick:()=>{i.revertDeclaration(),x(""),p()},children:e("accounts.declaration.discard")}),!g&&n.jsx("span",{className:"card-note",children:e("accounts.declaration.gate")})]}),h.review.declaration&&n.jsx("button",{type:"button",className:"button button-secondary button-sm",onClick:()=>{i.acknowledgeReview("declaration")||d(b=>b+1),p()},children:e("accounts.declaration.ack")})]})]})}const ht=["overview","strategy","controls","history"];function Pn(t){return ht.includes(t||"")?t:"overview"}function Bn({account:t,tab:s,config:a,todayRun:e,todayFailed:r,facts:o,onBack:i,onDeclarationSaved:j}){const c=z(),d=xe(a),u=at(),{confirmRequest:m,confirm:l,resolveConfirm:_}=Mt(),[v,x]=R.useState(!1),[p,h]=R.useState({}),S=v&&Object.keys(p).length>0,y=Q(()=>tt(t.account_alias,t.platform),[t.account_alias,t.platform]),g=R.useRef(l);g.current=l;const E=R.useRef(c);E.current=c,R.useEffect(()=>{if(S)return Le(()=>g.current({title:E.current("common.unsaved_guard_title"),summary:E.current("common.unsaved_guard_body"),tone:"normal"})),()=>Le(null)},[S]);const I=Pn(s),M=Nt(a,t.platform,t.account_alias)?.account_selector?.trim(),C=Ee(o.rows,t.platform,t.account_alias),$=a?.currentStrategies?.[t.platform]?.[t.account_alias]?.execution_evidence?.broker_environment,V=Ie(C),G=$==="paper"||$==="live"?$:null,T=C?.broker_environment==="live"||C?.broker_environment==="paper"||C?.account_scope==="live"||C?.account_scope==="paper"||C?.binding_environment==="live"||C?.binding_environment==="paper",F=V&&G&&V!==G?null:V??(T?null:G),L=ve(C),b=F??(T||G?null:L?.environment??null),k=$t(t.platform,C?.data_status,C?.broker_account_type)?.toLowerCase(),O=k==="cash"||k==="margin"?k:null,A=O??L?.accountType??null,P=!!(F&&L?.environment&&F!==L.environment||O&&L?.accountType&&O!==L.accountType),f=r?n.jsx(le,{status:"read_failed"}):e?n.jsxs(n.Fragment,{children:[n.jsx(le,{status:e.status,reason:e.unavailable_reason}),n.jsx(Ae,{value:e.as_of})]}):n.jsx(le,{status:"no_data"});return n.jsxs("div",{className:"accounts-detail section-stack",children:[n.jsx("div",{children:n.jsxs("button",{type:"button",className:"button button-secondary button-sm accounts-mobile-back",onClick:i,children:["← ",c("accounts.back_to_list")]})}),n.jsxs("section",{className:"card",children:[n.jsxs("div",{className:"accounts-detail-head",children:[n.jsx("h2",{className:"card-title",children:d.account(t.account_alias,t.platform)}),n.jsx(lt,{environment:b})]}),P&&n.jsx("p",{className:"accounts-inline-note error",role:"alert",children:c("accounts.declaration.conflict_notice")}),n.jsxs("div",{className:"accounts-summary-rows",children:[n.jsxs("div",{className:"accounts-summary-row",children:[n.jsx("span",{children:c("common.platform")}),n.jsx("span",{children:mn(a,t.platform)})]}),M&&n.jsxs("div",{className:"accounts-summary-row",children:[n.jsx("span",{children:c("accounts.identity")}),n.jsx("span",{className:"num",children:M})]}),n.jsxs("div",{className:"accounts-summary-row",children:[n.jsx("span",{children:c("accounts.run_state")}),n.jsx("span",{style:{display:"inline-flex",gap:8,alignItems:"center",flexWrap:"wrap"},children:f})]}),t.platform!=="binance"&&A&&n.jsxs("div",{className:"accounts-summary-row",children:[n.jsx("span",{children:c("accounts.declaration.account_type")}),n.jsx("span",{children:c(`accounts.declaration.type.${A}`)})]})]}),t.platform==="binance"?n.jsx(ut,{platform:t.platform,accountKey:t.account_alias,view:o.binance}):n.jsx(dt,{fact:C,phase:o.phase})]}),n.jsx(Ft,{id:"account-detail",items:ht.map(N=>({id:N,label:c(`accounts.tab.${N}`)})),active:I,onChange:N=>u({tab:N}),ariaLabel:c("accounts.title")}),n.jsxs("div",{id:"account-detail-panel",className:"section-stack",role:"tabpanel","aria-labelledby":`account-detail-tab-${I}`,tabIndex:0,children:[I==="overview"&&n.jsxs("section",{className:"card",children:[n.jsx("h2",{className:"card-title",children:c("accounts.tab.overview")}),y.phase==="loading"&&n.jsx("div",{className:"skeleton",style:{height:200},"aria-hidden":"true"}),y.phase==="error"&&n.jsx(fe,{onRetry:y.reload}),y.phase==="ready"&&n.jsxs(n.Fragment,{children:[y.data.identity_status==="identity_conflict"&&n.jsx("p",{className:"accounts-inline-note error",role:"alert",children:c("accounts.identity_conflict")}),n.jsx(pt,{rows:y.data.rows,t:c}),n.jsxs("p",{className:"card-note",style:{display:"flex",gap:8,alignItems:"center",flexWrap:"wrap"},children:[n.jsx(be,{tone:"unknown",children:c("accounts.draft_revision",{value:y.data.draft_revision})}),y.data.status!=="ok"&&n.jsx(le,{status:y.data.status})]})]})]}),I==="overview"&&n.jsx(An,{platform:t.platform,accountKey:t.account_alias}),I==="overview"&&n.jsx(In,{platform:t.platform,accountKey:t.account_alias,onSaved:j}),I==="strategy"&&n.jsx(gn,{account:t,diffState:y,config:a,editing:v,setEditing:x,edits:p,setEdits:h,confirm:l}),I==="controls"&&n.jsx(wn,{account:t,config:a,confirm:l}),I==="history"&&n.jsx(Sn,{account:t})]}),m&&n.jsx(Lt,{request:m,onResolve:_})]})}function Gn({account:t,tab:s}){const a=z(),e=at(),[r,o]=R.useState(0),i=Q(()=>St(),[r]),j=Q(()=>Ot("/api/config").catch(()=>null),[r]),c=Q(()=>Tt(),[r]),d=Q(()=>Ct(),[r]),u=Q(()=>At(),[r]),m=j.phase==="ready"?j.data:null,l=i.phase==="ready"?i.data.accounts:[],_=t?wt(l,t):void 0,v=u.phase==="ready"?{phase:"ready",status:u.data.report_status,report:u.data.report}:{phase:u.phase,status:null,report:null},x=d.phase==="ready"?{rows:d.data.accounts,phase:"ready",binance:v}:{rows:[],phase:d.phase,binance:v},p=c.phase==="error"||c.phase==="ready"&&c.data.status==="read_failed",h=_&&c.phase==="ready"&&!p?c.data.accounts.find(g=>g.account_alias===_.account_alias&&g.platform===_.platform):void 0,S=g=>e({account:g});let y;return i.phase==="loading"?y=n.jsx(Y,{height:240}):i.phase==="error"?y=n.jsx(fe,{onRetry:i.reload}):l.length===0?y=n.jsx(nt,{title:a("overview.no_accounts")}):y=n.jsx(fn,{accounts:l,config:m,facts:x,onSelect:S}),n.jsxs("div",{className:"page",children:[n.jsxs("header",{className:"page-header",children:[n.jsx("h1",{className:"page-title",children:a("accounts.title")}),i.phase==="ready"&&i.data.status==="partial"&&n.jsx(be,{tone:"warn",children:a("state.partial_valuation")}),n.jsx("div",{className:"page-header-actions",children:n.jsx("button",{type:"button",className:"button button-secondary",onClick:()=>o(g=>g+1),children:a("common.refresh")})})]}),!_&&i.phase==="ready"&&i.data.unassigned_decision_count>0&&n.jsxs("p",{className:"card-note accounts-unassigned",children:[a("accounts.unassigned_note",{count:i.data.unassigned_decision_count}),n.jsx("button",{type:"button",className:"button button-secondary button-sm",onClick:()=>e({page:"decisions"}),children:a("accounts.go_todos")})]}),n.jsxs("div",{className:`accounts-split${_?" detail-open":""}`,children:[n.jsx("div",{className:"accounts-list",children:y}),_&&n.jsx(Bn,{account:_,tab:s,config:m,todayRun:h,todayFailed:p,facts:x,onDeclarationSaved:d.reload,onBack:()=>e({account:null})},`${_.platform}/${_.account_alias}`)]})]})}export{Gn as default};
" },
-  "/v2/assets/DataTable-Bs7KLM5-.js": { contentType: "text/javascript; charset=utf-8", base64: "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" },
+  "/v2/assets/DataTable-CNz0DyJ6.js": { contentType: "text/javascript; charset=utf-8", base64: "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" },
   "/v2/assets/DecisionsPage-CyeuTPhn.css": { contentType: "text/css; charset=utf-8", base64: "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" },
-  "/v2/assets/DecisionsPage-DjK85Y5B.js": { contentType: "text/javascript; charset=utf-8", base64: "import{u as re,k as oe,j as e,z as ee,B as P,C as Ne,o as Oe,b as Me,D as Ke,r as _,F as H,S as qe,g as Pe,G as ze,f as X,c as Fe,H as He,I as ke,A as Ge,J as we,K as Ve,L as Ue}from"./index-Ds_XXLsn.js";import{i as Je}from"./inboxFailure-DUO9CRup.js";import{u as Ye,c as Ze,a as We,C as Qe,T as Xe,p as Ce,D as Se,o as en,r as nn,h as tn,b as sn}from"./Dialog-JHiHwrz3.js";import{u as pe,c as an}from"./hooks-DCo9_b70.js";import{T as rn}from"./Tabs-DBQ5AQB9.js";import"./runtime_daily_contract-xW43mZQY.js";function De({data:n,error:i,onRetry:s}){const a=re(),o=oe(),N=Je(n,i),u=n?.directory?.complete===!1?n.directory.retry_at:null;return e.jsxs("div",{className:"error-state",role:"alert","data-state":N,children:[e.jsx("span",{className:"state-icon state-icon-error","aria-hidden":"true",children:e.jsxs("svg",{width:14,height:14,viewBox:"0 0 10 10",children:[e.jsx("circle",{cx:"5",cy:"5",r:"4",fill:"none",stroke:"currentColor",strokeWidth:"1.2"}),e.jsx("path",{d:"M3.2 3.2 L6.8 6.8 M6.8 3.2 L3.2 6.8",stroke:"currentColor",strokeWidth:"1.2",strokeLinecap:"round"})]})}),e.jsxs("div",{className:"state-copy",children:[e.jsx("div",{className:"error-title",children:a(`inbox.error.${N}.title`)}),e.jsx("p",{className:"state-short",children:a("inbox.count_unknown")}),N==="unauthorized"&&e.jsx("p",{className:"state-short",children:a("inbox.auth_hint")}),u!=null&&Number.isFinite(u)&&u>0&&e.jsx("p",{className:"state-short",children:a("inbox.retry_at",{value:ee(new Date(u).toISOString(),o).text})})]}),s&&N!=="unauthorized"&&e.jsx("div",{className:"state-action",children:e.jsx("button",{type:"button",className:"button button-secondary button-sm",onClick:s,children:a("inbox.retry")})})]})}function me(n,i){return n.find(s=>s.id===i)??(n.length===1?n[0]:null)}const on={owner:"owner_decision",promotion:"strategy_promotion",recovery:"reconciliation_recovery",credential:"credential_maintenance"};function cn(n){const i=on[n];return i?`category.${i}`:"decisions.unknown_source"}function ln(n){return n==="read_failed"?"decisions.partial_consequence.read_failed":n==="unavailable"?"decisions.partial_consequence.unavailable":"decisions.partial_consequence.stale"}const $e=["positions","cash","open_orders","recent_executions","local_execution_ledger"],dn={complete:"ok",partial:"warn",unknown:"unknown"},un=["kind","currency","window_start","window_end","limit_per_namespace","gateway_availability","truncated"],ae=n=>!!(n&&typeof n=="object"&&!Array.isArray(n));function pn(n){const i=ae(n)?n:null,s=a=>{const o=i?.[a];return typeof o=="string"?o:null};return{provided:i!==null,kind:s("kind"),currency:s("currency"),window_start:s("window_start"),window_end:s("window_end"),limit_per_namespace:s("limit_per_namespace"),gateway_availability:s("gateway_availability"),truncated:s("truncated")}}function mn(n){const i=ae(n)?n:null,s=pn(i?i.scope:null);return i?i.status==="complete"&&Array.isArray(i.items)?{status:"complete",items:i.items,scope:s}:i.status==="partial"?{status:"partial",items:Array.isArray(i.items)?i.items:null,scope:s}:{status:"unknown",items:null,scope:s}:{status:"unknown",items:null,scope:s}}function fn(n){return n.replace(/_/g," ").replace(/\s+/g," ").trim()||n}function hn(n,i){const s=`initial_enrollment.fact.${n}`,a=i(s);return a===s?fn(n):a}function _n(n,i,s){if(i===null||i==="")return s("common.unknown");if(n==="truncated"){if(i==="true")return s("initial_enrollment.value.true");if(i==="false")return s("initial_enrollment.value.false")}if(n==="gateway_availability"&&i==="current_broker_day")return s("initial_enrollment.current_broker_day");if(n==="kind"){const a=`initial_enrollment.scope_kind.${i}`,o=s(a);if(o!==a)return o}return i}function he({value:n,t:i}){if(n===null)return e.jsx(e.Fragment,{children:i("common.unknown")});if(typeof n=="string")return e.jsx(e.Fragment,{children:n||i("common.na")});if(typeof n=="number")return e.jsx(e.Fragment,{children:Number.isFinite(n)?String(n):i("common.unknown")});if(typeof n=="boolean")return e.jsx(e.Fragment,{children:i(n?"initial_enrollment.value.true":"initial_enrollment.value.false")});if(Array.isArray(n))return n.length===0?e.jsx(e.Fragment,{children:i("common.na")}):e.jsx("ul",{className:"initial-enrollment-list",children:n.map((a,o)=>e.jsx("li",{children:e.jsx(he,{value:a,t:i})},o))});const s=Object.entries(n);return s.length===0?e.jsx(e.Fragment,{children:i("common.na")}):e.jsx("dl",{className:"initial-enrollment-fields",children:s.map(([a,o])=>e.jsxs("div",{children:[e.jsx("dt",{children:hn(a,i)}),e.jsx("dd",{children:e.jsx(he,{value:o,t:i})})]},a))})}function xn({scope:n,t:i}){const s=un.filter(a=>n[a]!==null&&n[a]!=="");return!n.provided||!s.length?null:e.jsxs("details",{className:"initial-enrollment-scope-block",children:[e.jsx("summary",{children:i("initial_enrollment.scope")}),e.jsx("dl",{className:"initial-enrollment-scope",children:s.map(a=>e.jsxs("div",{"data-scope-field":a,children:[e.jsx("dt",{children:i(`initial_enrollment.scope_field.${a}`)}),e.jsx("dd",{children:_n(a,n[a],i)})]},a))})]})}function yn({surface:n,t:i}){if(n.status==="unknown")return e.jsx("p",{className:"decision-note","data-state":"unknown",children:i("common.unknown")});const s=n.items;return s===null?e.jsx("p",{className:"decision-note","data-state":"unavailable",children:i("initial_enrollment.partial_unavailable")}):s.length===0?e.jsx("p",{className:"decision-note","data-state":n.status==="complete"?"known_empty":"partial_unavailable",children:n.status==="complete"?i("initial_enrollment.known_empty"):i("initial_enrollment.partial_unavailable")}):e.jsxs(e.Fragment,{children:[n.status==="partial"&&e.jsx("p",{className:"decision-note",children:i("initial_enrollment.partial_notice")}),e.jsx("div",{className:"initial-enrollment-items","data-item-count":s.length,children:s.map((a,o)=>e.jsx("div",{className:"initial-enrollment-item",children:e.jsx(he,{value:a,t:i})},o))})]})}function jn({account:n,strategy:i,platform:s,facts:a,readiness:o,blockerCodes:N}){const u=re(),D=oe(),c=ae(a)?a:null,b=c?.observed_at,y=typeof b=="string"&&Number.isFinite(Date.parse(b))?b:null,C=y?ee(y,D):null,j=c&&ae(c.surfaces)?c.surfaces:null,O=o==="blocked"||!!N?.length,B=(N||[]).map(k=>/^initial_enrollment_(.+)_incomplete$/.exec(k)?.[1]).filter(k=>!!(k&&$e.includes(k)));return e.jsxs("section",{className:"initial-enrollment-facts","aria-label":u("initial_enrollment.title"),"data-material":"initial_enrollment","data-readiness":o??void 0,children:[e.jsx("h2",{className:"card-title",children:u("initial_enrollment.title")}),e.jsxs("div",{className:"decision-meta",children:[e.jsxs("span",{children:[u("common.account"),": ",n||u("common.unknown")]}),e.jsxs("span",{children:[u("common.strategy"),": ",i||u("common.unknown")]}),s&&e.jsxs("span",{children:[u("common.platform"),": ",s]}),e.jsxs("span",{children:[u("initial_enrollment.source_time"),":"," ",y&&C?e.jsx("time",{dateTime:y,children:C.zone?`${C.text} (${C.zone})`:C.text}):u("common.unknown")]})]}),e.jsx("p",{className:"decision-note",children:u("initial_enrollment.notice")}),O&&e.jsxs("p",{className:"decision-note initial-enrollment-blocked",role:"status","data-state":"blocked",children:[u("initial_enrollment.blocked"),B.length>0?` ${B.map(k=>u(`initial_enrollment.surface.${k}`)).join(" / ")}`:""]}),e.jsx("div",{className:"initial-enrollment-surfaces",children:$e.map(k=>{const p=mn(j?.[k]);return e.jsxs("section",{className:"initial-enrollment-surface","data-surface":k,"data-status":p.status,children:[e.jsxs("h3",{className:"initial-enrollment-surface-title",children:[u(`initial_enrollment.surface.${k}`)," ",e.jsx(P,{tone:dn[p.status],children:u(`initial_enrollment.status.${p.status}`)})]}),e.jsx(yn,{surface:p,t:u}),e.jsx(xn,{scope:p.scope,t:u})]},k)})})]})}function bn({data:n,language:i,t:s,itemId:a}){const o=n?.sources.find(c=>c.source==="recovery"),N=o?.current_reconciliation_observation,u=(n?.items||[]).filter(c=>c.category==="reconciliation_recovery"&&(!a||c.id===a)),D=c=>{if(!c||!Number.isFinite(Date.parse(c)))return s("common.unknown");const b=new Intl.DateTimeFormat(i==="zh"?"zh-CN":"en-US",{year:"numeric",month:"2-digit",day:"2-digit",hour:"2-digit",minute:"2-digit",hour12:!1,timeZoneName:"shortOffset"}).formatToParts(new Date(c)),y=b.find(j=>j.type==="timeZoneName")?.value||"",C=b.filter(j=>j.type!=="timeZoneName").map(j=>j.value).join("").trim();return e.jsx("time",{dateTime:c,children:y?`${C} (${y})`:C})};return e.jsxs("section",{className:"reconciliation-materials","aria-label":s("reconciliation.title"),children:[e.jsx("h2",{className:"card-title",children:s("reconciliation.current")}),e.jsx("p",{role:"status",children:N?.status_label[i]||s("reconciliation.not_connected")}),N?.last_observed_at&&e.jsxs("p",{children:[s("reconciliation.observed_at"),"：",D(N.last_observed_at)]}),e.jsx("p",{className:"decision-note",children:s("reconciliation.history_notice")}),e.jsx("h2",{className:"card-title",children:s("reconciliation.materials")}),o?.status!=="ok"&&e.jsx("p",{className:"decision-note",children:s(o?.status==="stale"?"reconciliation.stale":"reconciliation.read_unknown")}),!u.length&&e.jsx("p",{children:s("reconciliation.empty")}),u.map(c=>{const b=c.presentation,y=Ne("strategies",b?.strategy_profile||"",i,s("reconciliation.unnamed_strategy")),C=Ne("accounts",c.account_alias||"",i,s("common.account"),c.platform||"");return e.jsxs("article",{className:"reconciliation-material",children:[e.jsx("h3",{children:b?.label[i]||s("reconciliation.materials")}),e.jsxs("p",{children:[y," · ",C,!a&&e.jsxs(e.Fragment,{children:[" · ",e.jsx("span",{className:"reconciliation-ref",children:s("decisions.ref",{id:c.short_id})})]})]}),e.jsxs("dl",{children:[e.jsxs("div",{children:[e.jsx("dt",{children:s("reconciliation.decision_status")}),e.jsx("dd",{children:b?.decision_status_label[i]||s("reconciliation.decision_unknown")})]}),e.jsxs("div",{children:[e.jsx("dt",{children:s("reconciliation.freshness")}),e.jsx("dd",{children:s(c.evidence_freshness.status==="stale"?"state.stale":c.evidence_freshness.status==="ready"?"decisions.freshness.ready":"common.unknown")})]}),e.jsxs("div",{children:[e.jsx("dt",{children:s("reconciliation.observed_at")}),e.jsx("dd",{children:D(b?.last_observed_at||c.evidence_freshness.as_of)})]}),e.jsxs("div",{children:[e.jsx("dt",{children:s("reconciliation.generated_at")}),e.jsx("dd",{children:D(b?.source_generated_at)})]}),e.jsxs("div",{children:[e.jsx("dt",{children:s("reconciliation.computed_at")}),e.jsx("dd",{children:D(b?.source_computed_at)})]})]})]},c.id)})]})}const gn=["reconciliation_recovery","strategy_promotion","owner_decision","paper_account_application","credential_maintenance"],Ae={high:0,medium:1,normal:2},Ee=30*864e5;function vn(n){if(n.evidence_freshness?.status==="stale")return!0;const i=n.created_at?Date.parse(n.created_at):NaN;return Number.isFinite(i)&&Date.now()-i>Ee}function Nn(n){if(n.evidence_freshness?.status==="stale")return"decisions.stale_hint";const i=n.created_at?Date.parse(n.created_at):NaN;return Number.isFinite(i)&&Date.now()-i>Ee?"decisions.stale_visible_hint":null}function Z(n){const i=n.decision_binding;if(i&&typeof i.subject_id=="string"&&i.subject_id)return i.subject_id;const s=n.id.indexOf(":");return s>=0?n.id.slice(s+1):n.id}function W(n){if(n.status==="expired")return!0;const i=n.expires_at?Date.parse(n.expires_at):NaN;return Number.isFinite(i)&&i<Date.now()}function fe(n){return n.category==="reconciliation_recovery"&&(!!n.initial_enrollment||n.presentation?.material_kind==="initial_enrollment")}function kn(n){return[...n].sort((i,s)=>{const a=+(s.category==="reconciliation_recovery")-+(i.category==="reconciliation_recovery");if(a!==0)return a;const o=(Ae[i.priority]??3)-(Ae[s.priority]??3);return o!==0?o:(s.created_at||"").localeCompare(i.created_at||"")})}function Q(n,i){const s=n?.application_preparation?.account_options;return Array.isArray(s)?s.filter(a=>{if(!a||typeof a.platform!="string"||typeof a.key!="string"||!a.key.trim())return!1;const o=a.broker_environment;return i?a.platform==="longbridge"&&o==="paper":o==="live"||o==="paper"&&a.platform==="longbridge"}).map(a=>({id:`${a.platform}:${a.key}`,platform:String(a.platform),key:String(a.key),label:typeof a.label=="string"&&a.label.trim()?a.label:String(a.key),mode:String(a.broker_environment||"")})):[]}function wn(n){return n==="fresh"?"state.fresh":n==="stale"?"state.stale":n==="ready"?"decisions.freshness.ready":n==="unavailable"?"state.unavailable":"state.unknown"}function Cn({epoch:n,category:i}){const s=re(),a=oe(),[o,N]=_.useState(null),[u,D]=_.useState(null),[c,b]=_.useState(!1),[y,C]=_.useState(!1),j=_.useRef(an()),O=_.useCallback(()=>{const p=j.current.begin();N(null),b(!1),D(null),ke(25).then(E=>{j.current.isCurrent(p)&&(N(E.items),D(E.next_cursor))}).catch(()=>{j.current.isCurrent(p)&&b(!0)})},[]);_.useEffect(()=>O(),[O,n]);const B=()=>{if(!u||y)return;const p=j.current.begin();C(!0),ke(25,u).then(E=>{j.current.isCurrent(p)&&(N(G=>[...G||[],...E.items]),D(E.next_cursor))}).catch(()=>{j.current.isCurrent(p)&&b(!0)}).finally(()=>{j.current.isCurrent(p)&&C(!1)})};if(c&&!o?.length)return e.jsx(De,{onRetry:O});if(!o)return e.jsxs("div",{className:"card",children:[e.jsx(X,{height:56}),e.jsx("div",{style:{height:8}}),e.jsx(X,{height:56})]});const k=i==="all"?o:o.filter(p=>p.category===i);return k.length===0?e.jsx(Fe,{title:s("decisions.history.empty")}):e.jsxs("div",{className:"card",children:[e.jsx("h2",{className:"card-title",children:s("decisions.history_title")}),e.jsx(Xe,{items:k.map(p=>({id:p.id,time:p.time,title:e.jsxs(e.Fragment,{children:[p.actor_alias||s("common.unknown")," · ",s(`decisions.action.${p.action}`)]}),detail:e.jsxs(e.Fragment,{children:[s(`category.${p.category}`)," · ",s("decisions.ref",{id:p.item_short_id})," · ",ee(p.time,a).text]})}))}),u&&e.jsx("div",{className:"decision-history-more",children:e.jsx("button",{type:"button",className:"button button-secondary",disabled:y,onClick:B,children:s(y?"common.loading":"common.load_more")})}),c&&e.jsx("p",{className:"decision-note",children:s("error.generic")})]})}function Tn(){const n=re(),i=Oe(),s=oe(),a=Me(),o=Ke(),{confirmRequest:N,confirm:u,resolveConfirm:D}=Ye(),[c,b]=_.useState("all"),[y,C]=_.useState("pending"),[j,O]=_.useState(0),[B,k]=_.useState(null),[p,E]=_.useState({}),[G,_e]=_.useState({}),g=pe(()=>Pe(j>0),[j]),xe=pe(()=>ze(),[]),ye=xe.phase==="ready"&&xe.data.admin===!0,M=_.useRef(Ze()),V=_.useRef(We()),T=_.useCallback(()=>O(t=>t+1),[]),ne=_.useMemo(()=>g.phase==="ready"&&g.data.status!=="read_failed"?g.data.items:[],[g]),ce=_.useMemo(()=>kn(ne.filter(t=>t.status==="pending"||t.status==="expired")),[ne]),je=_.useMemo(()=>ne.filter(t=>t.status==="pending").length,[ne]),U=_.useMemo(()=>c==="all"?ce:ce.filter(t=>t.category===c),[ce,c]),le=_.useMemo(()=>g.phase==="ready"&&g.data.status!=="read_failed"?g.data.sources.filter(t=>t.status!=="ok"):[],[g]),$=U.find(t=>t.id===B)||null,be=t=>t.account_alias?i.account(t.account_alias,t.platform):n("decisions.account_unbound");_.useEffect(()=>{g.phase==="ready"&&B&&!U.some(t=>t.id===B)&&k(null)},[g.phase,B,U]);const ge=!!($&&$.status==="pending"&&!W($)&&($.category==="strategy_promotion"||$.category==="paper_account_application")),te=pe(()=>ge?H("/api/research-promotion-tickets"):Promise.resolve(null),[ge,$?.id,j]),J=_.useMemo(()=>{if(!$||te.phase!=="ready"||!te.data)return null;const t=te.data.applications;return Array.isArray(t)&&t.find(l=>l?.ticket_id===Z($))||null},[$,te]),A=(t,l)=>o({kind:t,text:n(l)}),de=t=>{t instanceof Ve||(A("error",t instanceof Ue&&t.status===409?"error.conflict":"error.generic"),T())},Te=async(t,l,v)=>{const m=Z(t),f=t.category==="owner_decision"?"owner":t.category==="reconciliation_recovery"?"recovery":"promotion";let S,h,w,R=null;try{if(f==="owner"){const d=((await H("/api/owner-decisions")).candidates||[]).find(F=>F?.candidate?.candidate_id===m);if(!d){A("info","decisions.intent_not_pending"),T();return}const x=en({...d.candidate,candidate_evidence_sha256:d.candidate_evidence_sha256},l==="adopt"?"approve_limited_live_canary":"keep_parked");if(!x){A(d.intent?"info":"error",d.intent?"decisions.intent_not_pending":"decisions.intent_unavailable"),T();return}S=d,h=x,w="/api/owner-decisions"}else if(f==="recovery"){const d=((await H("/api/reconciliation-recovery")).recoveries||[]).find(F=>F?.recovery?.recovery_id===m);if(!d){A("info","decisions.intent_not_pending"),T();return}const x=nn(d,l==="adopt"?"approve":"reject");if(!x){const F=!!(d.confirmation||d.rejection);A(F?"info":"error",F?"decisions.intent_not_pending":"decisions.intent_unavailable"),T();return}S=d,h=x,w="/api/reconciliation-recovery-confirmations"}else{const r=await H("/api/research-promotion-tickets"),d=(r.tickets||[]).find(F=>F?.ticket_id===m);if(!d){A("info","decisions.intent_not_pending"),T();return}let x=null;if(l==="adopt"){const F=(r.applications||[]).find(ue=>ue?.ticket_id===m),Y=Q(F,!1).find(ue=>ue.id===v);if(!Y){A("error","decisions.intent_unavailable");return}x=Y,R=Y}S=d,h={ticket_id:d.ticket_id,decision:l==="adopt"?"accept":"reject",confirmation:x?{target_platform:x.platform,execution_mode:x.mode,risk_profile:"CAPITAL_PRESERVATION"}:null,...x?{selected_account:{platform:x.platform,key:x.key}}:{},expected_proposed_params:d.proposed_params||{},expected_strategy_profile:d.strategy_profile,expected_domain:d.domain},w="/api/research-promotion-decisions"}}catch(r){de(r);return}const L=M.current.epoch(),I=await tn(f,S,h);if(L!==M.current.epoch())return;if(!I){A("error","decisions.intent_unavailable");return}if(h.mode==="initial_enrollment"){const r=t.initial_enrollment;if(!r||r.candidate_sha256!==h.candidate_sha256||r.facts_sha256!==h.facts_sha256){A("info","decisions.material_changed"),T();return}}if(!sn(t.decision_binding,I)){A("info","decisions.material_changed"),T();return}if(!await ve(t,l,!1,R)||L!==M.current.epoch()||W(t))return;const K=M.current.start(I);if(!K)return;const q=`intent:${t.id}`;E(r=>({...r,[q]:!0}));try{const r=await we(w,h.mode==="initial_enrollment"?h:{...h,expected_material_sha256:I.material_sha256,...I.review_sha256?{expected_review_sha256:I.review_sha256}:{}});if(!M.current.current(K))return;const d=await M.current.receive(K,r?.decision_receipt);A(d?"success":"error",d?"decisions.intent_recorded":"error.generic"),T()}catch(r){de(r)}finally{M.current.current(K)&&E(r=>({...r,[q]:!1}))}},Re=async(t,l)=>{const v=Z(t),m=`apply:${v}`;if(!V.current.acquire(m))return;E(S=>({...S,[m]:!0}));let f=!1;try{const h=((await H("/api/research-promotion-tickets")).applications||[]).find(L=>L?.ticket_id===v),w=Q(h,!0).find(L=>L.id===l);if(!h||!w||!Ce(h,l)){A("error","decisions.intent_unavailable");return}const R=await H("/api/admin/runtime-instances");f=!0,await we("/api/research-promotion-applications",{ticket_id:v,selected_account:{platform:w.platform,key:w.key},expected_revision:Number(R.revision)}),A("success","decisions.application_submitted"),T()}catch(S){de(S)}finally{E(S=>({...S,[m]:!1})),f||V.current.release(m)}},ve=(t,l,v,m)=>u({title:n(l==="adopt"?"decisions.confirm_adopt_title":"decisions.confirm_decline_title"),target:m?`${se(t,n)} · ${m.label} (${m.platform} / ${m.key} / ${m.mode})`:se(t,n),summary:n(v?"decisions.apply_note":"decisions.confirm_body"),body:e.jsx(Se,{rows:t.diff.map(f=>({...f,label:n(f.label_key)===f.label_key?f.field:n(f.label_key),affectsLive:f.affects_live}))}),consequence:n("decisions.intent_note"),tone:l==="adopt"?"normal":"danger",confirmLabel:n(l==="adopt"?"decisions.confirm_adopt_label":"decisions.confirm_decline_label")}),ie=async(t,l)=>{if(!ye||t.status!=="pending"||W(t))return;const v=`confirm:${t.id}`;if(!V.current.acquire(v))return;const m=`intent:${t.id}`;E(f=>({...f,[m]:!0}));try{const f=t.category==="paper_account_application"&&l==="adopt",S=Q(J,t.category==="paper_account_application"),h=me(S,G[t.id]);if(l==="adopt"&&(f||t.category==="strategy_promotion")&&!h){A("error","decisions.intent_unavailable");return}f&&h?await ve(t,l,!0,h)&&await Re(t,h.id):await Te(t,l,h?.id??null)}finally{V.current.release(v),E(f=>({...f,[m]:!1}))}};function se(t,l){if(fe(t))return l("decisions.initial_enrollment_title");const v=l(t.title_key);return v===t.title_key?t.short_id:v}const Ie=[{id:"all",label:n("decisions.filter.all")},...gn.map(t=>({id:t,label:n(`category.${t}`)}))],Be=()=>{if(!$)return null;const t=$,l=W(t),v=t.status==="pending"&&!l,m=t.diff.map(r=>{const d=n(r.label_key);return{field:r.field,label:d===r.label_key?r.field:d,before:r.before,after:r.after,affectsLive:r.affects_live}}),f=!!p[`intent:${t.id}`],S=!!p[`apply:${Z(t)}`],h=f||S,w=t.initial_enrollment??null,R=fe(t),L=R&&(!w||w.readiness!=="awaiting_human_confirmation"||!Array.isArray(w.blocker_codes)||w.blocker_codes.length>0||!["positions","cash","open_orders","recent_executions","local_execution_ledger"].every(r=>w.facts?.surfaces?.[r]?.status==="complete"&&Array.isArray(w.facts?.surfaces?.[r]?.items))),I=t.diff.find(r=>r.field==="strategy"),K=t.presentation?.strategy_profile||(I&&typeof I.after=="string"?I.after:null);let q=null;if(v&&ye&&!(R&&L))if(t.category==="credential_maintenance")q=e.jsx("button",{type:"button",className:"button button-secondary",onClick:()=>a({page:"health"}),children:n("decisions.open_health")});else if(t.category==="paper_account_application"){const r=Q(J,!0),d=me(r,G[t.id])?.id??"",x=t.application_status==="uncertain",F=!!(d&&J&&Ce(J,d));q=e.jsxs(e.Fragment,{children:[r.length>1&&e.jsxs("label",{className:"decision-account-picker",children:[e.jsx("span",{children:n("decisions.select_account")}),e.jsxs("select",{value:d,onChange:z=>_e(Y=>({...Y,[t.id]:z.target.value})),children:[e.jsxs("option",{value:"",children:[n("decisions.select_account"),"…"]}),r.map(z=>e.jsx("option",{value:z.id,children:z.label},z.id))]})]}),e.jsxs("div",{className:"inbox-actions",children:[x?e.jsx("p",{className:"decision-note",children:n("decisions.application_uncertain")}):e.jsxs(e.Fragment,{children:[r.length===0?e.jsx("p",{className:"decision-note",children:n("decisions.no_account_options")}):e.jsx("button",{type:"button",className:"button button-primary",disabled:h||!F||V.current.isLocked(`apply:${Z(t)}`),onClick:()=>{ie(t,"adopt")},children:n(S?"decisions.submitting":"decisions.adopt_intent")}),e.jsx("button",{type:"button",className:"button button-secondary",disabled:h,onClick:()=>{ie(t,"decline")},children:n(f?"decisions.submitting":"decisions.decline_intent")})]}),e.jsx("p",{className:"decision-note",children:n(r.length===0||x?"decisions.intent_note":"decisions.apply_note")})]})]})}else{const r=t.category==="strategy_promotion"?Q(J,!1):[],d=me(r,G[t.id])?.id??"";q=e.jsxs(e.Fragment,{children:[r.length>1&&e.jsxs("label",{className:"decision-account-picker",children:[e.jsx("span",{children:n("decisions.select_account")}),e.jsxs("select",{value:d,onChange:x=>_e(F=>({...F,[t.id]:x.target.value})),children:[e.jsxs("option",{value:"",children:[n("decisions.select_account"),"…"]}),r.map(x=>e.jsx("option",{value:x.id,children:x.label},x.id))]})]}),e.jsxs("div",{className:"inbox-actions",children:[e.jsx("button",{type:"button",className:"button button-primary",disabled:h||t.category==="strategy_promotion"&&!d,onClick:()=>{ie(t,"adopt")},children:n(f?"decisions.submitting":"decisions.adopt_intent")}),e.jsx("button",{type:"button",className:"button button-secondary",disabled:h,onClick:()=>{ie(t,"decline")},children:n(f?"decisions.submitting":"decisions.decline_intent")}),e.jsx("p",{className:"decision-note",children:n("decisions.intent_note")})]})]})}return e.jsxs("div",{className:"card inbox-detail",children:[e.jsxs("div",{className:"decision-detail-head",children:[e.jsx("button",{type:"button",className:"button button-secondary inbox-back",onClick:()=>k(null),children:n("common.back")}),e.jsxs("div",{className:"decision-badges",children:[e.jsx(P,{tone:t.category==="reconciliation_recovery"?"warn":"accent",children:n(`category.${t.category}`)}),e.jsx(P,{tone:t.status==="decided"?"ok":l?"unknown":"warn",children:n(`decisions.status.${l?"expired":t.status}`)}),t.affects_live&&e.jsx(P,{tone:"warn",children:n("decisions.col.affects_live")})]}),e.jsx("h2",{className:"card-title",style:{margin:0},children:se(t,n)}),e.jsx("p",{className:"decision-prompt",children:n(R?"decisions.prompt.initial_enrollment":`decisions.prompt.${t.category}`)}),e.jsxs("div",{className:"decision-meta",children:[e.jsx("span",{children:be(t)}),t.platform&&e.jsx("span",{children:i.platform(t.platform)}),e.jsx("span",{className:"decision-ref",children:n("decisions.ref",{id:t.short_id})}),t.created_at&&e.jsx("span",{children:n("decisions.created_at",{value:ee(t.created_at,s).text})}),t.expires_at&&e.jsx("span",{children:n("decisions.expires_at",{value:ee(t.expires_at,s).text})}),t.evidence_freshness&&e.jsx(P,{tone:t.evidence_freshness.status==="stale"?"warn":t.evidence_freshness.status==="ready"||t.evidence_freshness.status==="fresh"?"ok":"unknown",children:n(wn(t.evidence_freshness.status))}),vn(t)&&e.jsx("span",{className:"decision-stale-hint",children:n("decisions.stale_hint")})]})]}),m.length>0&&e.jsxs(e.Fragment,{children:[e.jsx("h3",{className:"decision-section-title",children:n("decisions.diff_title")}),e.jsx(Se,{rows:m})]}),R&&e.jsx(jn,{account:t.account_alias?i.account(t.account_alias,t.platform):null,strategy:K?i.strategy(K):null,platform:t.platform?i.platform(t.platform):null,facts:w?.facts??null,readiness:w?.readiness??null,blockerCodes:w?.blocker_codes??null}),t.category==="reconciliation_recovery"&&!R&&e.jsxs("details",{className:"decision-materials reconciliation-detail",children:[e.jsx("summary",{children:n("reconciliation.materials")}),e.jsx(bn,{data:g.phase==="ready"?g.data:null,language:s,t:n,itemId:t.id})]}),t.evidence_freshness?.as_of&&e.jsxs("details",{className:"decision-materials",children:[e.jsx("summary",{children:n("decisions.more_info")}),e.jsx(Ge,{value:t.evidence_freshness.as_of})]}),q]})},Le=()=>g.phase==="loading"?e.jsx("div",{className:"inbox list-only",children:e.jsxs("div",{className:"inbox-list",children:[e.jsx(X,{height:64}),e.jsx(X,{height:64}),e.jsx(X,{height:64})]})}):g.phase==="error"||g.data.status==="read_failed"?e.jsx(De,{data:g.data,error:g.error,onRetry:g.phase==="error"?g.reload:T}):e.jsx(e.Fragment,{children:U.length===0?e.jsx(Fe,{title:n("decisions.empty_pending")}):e.jsxs("div",{className:`inbox${$?" detail-open":" list-only"}`,children:[e.jsx("div",{className:"inbox-list",role:"list",children:U.map(t=>{const l=W(t),v=He(t.created_at,s),m=Nn(t);return e.jsxs("button",{type:"button",role:"listitem",className:`inbox-item${$?.id===t.id?" active":""}${l?" is-expired":""}`,onClick:()=>k(t.id),children:[e.jsx("span",{className:`priority-dot priority-${t.priority}`,"aria-hidden":"true"}),e.jsxs("span",{className:"item-main",children:[e.jsx("span",{className:"item-title",children:se(t,n)}),e.jsxs("span",{className:"item-meta",children:[fe(t)&&e.jsx(P,{tone:"warn",children:n("category.reconciliation_recovery")}),t.platform&&e.jsx("span",{children:i.platform(t.platform)}),e.jsx("span",{children:be(t)})]}),(v||m)&&e.jsxs("span",{className:"item-meta item-meta-secondary",children:[v&&e.jsx("span",{children:v}),m&&e.jsx("span",{className:"decision-stale-hint",children:n(m)})]})]}),e.jsx(P,{tone:l?"unknown":"warn",children:n(`decisions.status.${l?"expired":t.status}`)})]},t.id)})}),$&&Be()]})});return e.jsxs("div",{className:"page",children:[e.jsxs("div",{className:"page-header",children:[e.jsx("h1",{className:"page-title",children:n("decisions.title")}),e.jsx("div",{className:"page-header-actions",children:e.jsx("button",{type:"button",className:"button button-secondary",onClick:T,children:n("common.refresh")})})]}),e.jsxs("div",{className:"decisions-filters",children:[e.jsx("div",{className:"decisions-view-row",children:e.jsxs("div",{className:"segmented",role:"group","aria-label":n("decisions.title"),children:[e.jsxs("button",{type:"button","aria-pressed":y==="pending",className:`segment${y==="pending"?" active":""}`,onClick:()=>C("pending"),children:[n("decisions.tab.pending"),je>0&&e.jsx("span",{className:"segment-sub",children:je})]}),e.jsx("button",{type:"button","aria-pressed":y==="decided",className:`segment${y==="decided"?" active":""}`,onClick:()=>C("decided"),children:n("decisions.tab.decided")})]})}),e.jsx("div",{className:"decisions-category-row",children:e.jsx(rn,{id:"decisions",items:Ie,active:c,onChange:t=>b(t),ariaLabel:n("decisions.title")})})]}),y==="pending"&&le.length>0&&e.jsxs("div",{className:"decision-degraded-note",role:"status","data-state":"partial","data-degraded-count":le.length,children:[e.jsx(qe,{status:"partial"}),e.jsxs("div",{className:"decision-degraded-body",children:[e.jsx("span",{children:n("decisions.partial_notice")}),e.jsx("ul",{className:"decision-degraded-sources","aria-label":n("decisions.partial_affected"),children:le.map(t=>e.jsxs("li",{"data-source":t.source,children:[e.jsx("strong",{children:n(cn(t.source))}),e.jsxs("span",{children:[" · ",n(`state.${t.status}`)," — ",n(ln(t.status))]})]},t.source))})]})]}),e.jsx("div",{id:"decisions-panel",role:"tabpanel","aria-labelledby":`decisions-tab-${c}`,tabIndex:0,children:y==="pending"?Le():e.jsx(Cn,{epoch:j,category:c})}),N&&e.jsx(Qe,{request:N,onResolve:D})]})}export{Tn as default};
" },
-  "/v2/assets/Dialog-JHiHwrz3.js": { contentType: "text/javascript; charset=utf-8", base64: "import{u as w,j as n,B as O,O as T,r as f}from"./index-Ds_XXLsn.js";import{R as z}from"./runtime_daily_contract-xW43mZQY.js";function G(e){const a={};Object.prototype.hasOwnProperty.call(e.overrides,"strategy_profile")&&(a.strategy_profile=e.overrides.strategy_profile??null),Object.prototype.hasOwnProperty.call(e.overrides,"dca_mode")&&(a.dca_mode=e.overrides.dca_mode??null),Object.prototype.hasOwnProperty.call(e.overrides,"dca_base_investment_usd")&&(a.dca_base_investment_usd=e.overrides.dca_base_investment_usd??null),Object.prototype.hasOwnProperty.call(e.overrides,"income_layer_enabled")&&(a.income_layer_enabled=e.overrides.income_layer_enabled??null),e.overrides.option_overlay_enabled===null&&(a.option_overlay_enabled=null),Object.prototype.hasOwnProperty.call(e.overrides,"reserved_cash_floor")&&(a.reserved_cash_floor=e.overrides.reserved_cash_floor??null),Object.prototype.hasOwnProperty.call(e.overrides,"reserved_cash_ratio")&&(a.reserved_cash_ratio=e.overrides.reserved_cash_ratio??null);const l={expected_draft_revision:e.expectedDraftRevision,identity:e.identity,overrides:a};return e.acknowledgeIdentityConflict&&(l.acknowledge_identity_conflict=!0),l}function B(e,a){const l=e.candidate_evidence_sha256||e.owner_decision?.candidate_evidence_sha256;return!e.candidate_id||!/^[a-f0-9]{64}$/.test(String(l||""))||!["approve_limited_live_canary","keep_parked"].includes(a)?null:{candidate_id:e.candidate_id,candidate_evidence_sha256:l,decision:a}}function A(e,a="approve"){const l=e?.recovery||{};return a!=="approve"&&a!=="reject"||l.mode!=="initial_enrollment"||e.freshness?.data_status!=="ready"||e.confirmation||e.rejection||l.readiness!=="awaiting_human_confirmation"||!Array.isArray(l.blocker_codes)||l.blocker_codes.length||typeof l.recovery_id!="string"||!l.recovery_id||!/^[a-f0-9]{64}$/.test(String(l.candidate_sha256||""))||!/^[a-f0-9]{64}$/.test(String(l.facts_sha256||""))?null:{mode:"initial_enrollment",decision:a,recovery_id:l.recovery_id,candidate_sha256:l.candidate_sha256,facts_sha256:l.facts_sha256}}function Q(e,a="approve"){if(e?.recovery?.mode==="initial_enrollment")return A(e,a);const l=e.recovery||{};return a!=="approve"&&a!=="reject"||e.freshness?.data_status!=="ready"||e.confirmation||e.rejection||l.readiness!=="awaiting_human_confirmation"||!Array.isArray(l.blocker_codes)||l.blocker_codes.length||!/^[a-f0-9]{64}$/.test(String(l.candidate_sha256||""))||l.dual_review?.evidence_binding_sha256!==l.candidate_sha256?null:{decision:a,recovery_id:l.recovery_id,candidate_sha256:l.candidate_sha256,dual_review_binding_sha256:l.dual_review.evidence_binding_sha256}}function H(){const e=new Set;return{acquire(a){return e.has(a)?!1:(e.add(a),!0)},release(a){e.delete(a)},isLocked(a){return e.has(a)},hasAny(a){return a.some(l=>e.has(l))},hasAnyWithPrefixes(a){return[...e].some(l=>a.some(r=>l.startsWith(r)))},clear(){e.clear()}}}function N(e){return e?e.status==="rejected":!0}const h=/^[0-9a-f]{64}$/,y=e=>!!(e&&typeof e=="object"&&!Array.isArray(e));function m(e){if(e===null||typeof e=="string"||typeof e=="boolean"||typeof e=="number"&&Number.isFinite(e))return JSON.stringify(e);if(Array.isArray(e))return`[${e.map(m).join(",")}]`;if(!y(e))throw new Error("human_decision_material_invalid");return`{${Object.keys(e).sort().map(a=>`${JSON.stringify(a)}:${m(e[a])}`).join(",")}}`}async function g(e){const a=await crypto.subtle.digest("SHA-256",new TextEncoder().encode(m(e)));return[...new Uint8Array(a)].map(l=>l.toString(16).padStart(2,"0")).join("")}function D(e){const a=e?.decision_binding;return a?.kind==="promotion"&&a.subject_id===e.ticket_id&&typeof a.material_sha256=="string"&&h.test(a.material_sha256)&&(a.review_binding==null||a.review_binding.schema_version==="qsl_promotion_review_binding.v2"&&typeof a.review_binding.review_sha256=="string"&&h.test(a.review_binding.review_sha256))}function M(e,a){if(!y(e)||e.kind!==a.kind||e.subject_id!==a.subject_id||e.material_sha256!==a.material_sha256)return!1;const l=e.review_binding;return a.review_sha256===null?l==null:y(l)&&l.schema_version==="qsl_promotion_review_binding.v2"&&l.review_sha256===a.review_sha256}async function X(e,a,l){try{const r=a?.decision_binding;let i,t,_,o=null;if(e==="owner"){if(i=l.candidate_id,t=null,_={decision:l.decision},!["approve_limited_live_canary","keep_parked"].includes(l.decision)||a.candidate?.candidate_id!==i||a.candidate_evidence_sha256!==l.candidate_evidence_sha256)return null}else if(e==="recovery"){if(i=l.recovery_id,!["approve","reject"].includes(l.decision)||a.recovery?.recovery_id!==i||a.recovery.candidate_sha256!==l.candidate_sha256)return null;if(l.mode==="initial_enrollment"){if(a.recovery.mode!=="initial_enrollment"||a.recovery.facts_sha256!==l.facts_sha256||typeof l.facts_sha256!="string"||!h.test(l.facts_sha256))return null;t={mode:"initial_enrollment",recovery_id:i,candidate_sha256:l.candidate_sha256,facts_sha256:l.facts_sha256}}else{if(a.recovery.dual_review?.evidence_binding_sha256!==l.dual_review_binding_sha256)return null;t={recovery_id:i,candidate_sha256:l.candidate_sha256,dual_review_binding_sha256:l.dual_review_binding_sha256}}_={decision:l.decision}}else{if(i=l.ticket_id,!D(a)||a.ticket_id!==i||!["accept","reject"].includes(l.decision))return null;if(t=Object.fromEntries(["ticket_id","strategy_profile","domain","proposed_params","shadow_passed","shadow_evidence_kind"].map(b=>[b,a[b]])),r.review_binding!=null){const b={schema_version:"qsl_promotion_review_material.v2",...t,...Object.fromEntries(["drift_status","drift_score","budget","search_iterations","suggested_risk_profile","notification_subject","notification_body","notes"].map(p=>[p,a[p]])),research_summary:a.research_summary||null};if(o=await g(b),o!==r.review_binding.review_sha256)return null}const d=l.selected_account??null,u=l.confirmation??null;if(l.decision==="accept"&&(!y(d)||!y(u)||d.platform!==u.target_platform))return null;_={selected_account:d,confirmation:u}}const s=e==="owner"?l.candidate_evidence_sha256:await g(t);return typeof i!="string"||!i||typeof s!="string"||!h.test(s)||r?.kind!==e||r.subject_id!==i||r.material_sha256!==s?null:JSON.parse(JSON.stringify({kind:e,subject_id:i,material_sha256:s,review_sha256:o,action:l.decision,target:_}))}catch{return null}}async function j(e,a){try{if(!y(a)||!["qsl_human_decision_receipt.v1","qsl_human_decision_receipt.v2"].includes(a.schema_version)||a.kind!==e.kind||a.subject_id!==e.subject_id||a.material_sha256!==e.material_sha256||a.action!==e.action||m(a.target)!==m(e.target)||a.no_order!==!0||a.execution_authority_granted!==!1||typeof a.decided_by!="string"||!a.decided_by||a.decided_by.length>100||/[\u0000-\u001f\u007f]/.test(a.decided_by)||typeof a.decided_at!="string"||a.decided_at.length>40||!Number.isFinite(Date.parse(a.decided_at))||/[\u0000-\u001f\u007f]/.test(a.decided_at)||typeof a.receipt_sha256!="string"||!h.test(a.receipt_sha256))return!1;const l=a.schema_version==="qsl_human_decision_receipt.v2";if(l!==!!e.review_sha256||l&&(e.kind!=="promotion"||a.review_binding?.schema_version!=="qsl_promotion_review_binding.v2"||a.review_binding.review_sha256!==e.review_sha256))return!1;const r={schema_version:a.schema_version,...l?{review_binding:{schema_version:"qsl_promotion_review_binding.v2",review_sha256:e.review_sha256}}:{},kind:e.kind,subject_id:e.subject_id,material_sha256:e.material_sha256,action:e.action,target:e.target,decided_at:a.decided_at,decided_by:a.decided_by,no_order:!0,execution_authority_granted:!1};return m(a)===m({...r,receipt_sha256:await g(r)})}catch{return!1}}function J(){const e=new Map,a=new Map,l=i=>`${i.kind}:${i.subject_id}:${i.material_sha256}`;let r=0;return{epoch(){return r},clear(){r++,e.clear(),a.clear()},entries(){return[...e.values()].map(i=>JSON.parse(JSON.stringify(i)))},start(i){const t=l(i);return e.has(t)?null:(e.set(t,{expected:JSON.parse(JSON.stringify(i)),status:"unresolved",receipt:null,queueConfirmed:!1}),{id:t,generation:r})},current(i){return i.generation===r&&e.has(i.id)&&(i.sequence===void 0||a.get(i.id)===i.sequence)},async receive(i,t,_){const o=e.get(i.id);if(!o||!this.current(i))return!1;const s=await j(o.expected,t);return this.current(i)?!s||o.receipt&&o.receipt.receipt_sha256!==t.receipt_sha256?(o.status="unresolved",o.queueConfirmed=!1,!1):(o.receipt=JSON.parse(JSON.stringify(t)),o.queueConfirmed=_??o.queueConfirmed,o.status=o.queueConfirmed?"recorded":"unresolved",!0):!1},beginRead(i){const t=l(i),_=(a.get(t)||0)+1;return a.set(t,_),{id:t,generation:r,sequence:_}},async readback(i,t,_){const o=e.get(i.id),s=t?.decision_readback,d=()=>this.current(i)&&a.get(i.id)===i.sequence;if(!o||!d())return!1;if(t?.ok!==!0||s?.schema_version!=="qsl_human_decision_readback.v1"||s.source!=="durable_human_decision_record"||s.kind!==o.expected.kind||s.subject_id!==o.expected.subject_id||s.requested_material_sha256!==o.expected.material_sha256||typeof s.observed_at!="string"||!Number.isFinite(Date.parse(s.observed_at))||s.lookup_status!=="found")return o.status="unresolved",o.queueConfirmed=!1,!1;const u=await j(o.expected,s.receipt);return d()?this.receive(i,u?s.receipt:null,_):!1},readFailed(i){if(!this.current(i)||a.get(i.id)!==i.sequence)return!1;const t=e.get(i.id);return t.status="unresolved",t.queueConfirmed=!1,!0}}}const q=Object.freeze([Object.freeze({option_scope:"paper",payload_scope:"PAPER"}),Object.freeze({option_scope:"HK",payload_scope:"HK"}),Object.freeze({option_scope:"sg",payload_scope:"SG"})]);Object.freeze(q.map(e=>e.option_scope));Object.freeze(q.map(e=>e.payload_scope));const E=Object.freeze(["max_finance_amount","remaining_finance_amount","init_margin","maintenance_margin","margin_call","buy_power"]);Object.freeze(["currency",...E,"risk_level"]);const S=[{profile:"tqqq_growth_income",label:"纳斯达克增长收益",label_en:"NASDAQ Growth Income",label_zh:"纳斯达克增长收益",domain:"us_equity",runtime_enabled:!0,income_layer_enabled:!0,option_overlay_enabled:!1,combo_enabled:!1,lifecycle_stage:"runtime_enabled",can_switch_live:!0,allowed_execution_modes:["paper","dry_run","live"],blocked_live_reason:"",live_continuity:{eligible:!0,allowed_platforms:["ibkr"]},income_layer_start_usd:"250000",income_layer_max_ratio:"0.55",income_layer_allocations:{SCHD:.3,DGRO:.2,SGOV:.4,SPYI:.08,QQQI:.02}},{profile:"soxl_soxx_trend_income",label:"半导体趋势收益",label_en:"Semiconductor Trend Income",label_zh:"半导体趋势收益",domain:"us_equity",runtime_enabled:!0,income_layer_enabled:!0,option_overlay_enabled:!1,combo_enabled:!1,lifecycle_stage:"runtime_enabled",can_switch_live:!0,allowed_execution_modes:["paper","dry_run","live"],blocked_live_reason:"",live_continuity:{eligible:!0,allowed_platforms:["longbridge","ibkr","schwab"]},income_layer_start_usd:"150000",income_layer_max_ratio:"0.95",income_layer_allocations:{SCHD:.15,DGRO:.1,SGOV:.7,SPYI:.04,QQQI:.01}},{profile:"soxl_soxx_core_only_p2_v7_longterm_compounding_cash_reserve",label:"SOXL/SOXX 核心复利（现金保留）",label_en:"SOXL/SOXX Core Compounding (Cash Reserve)",label_zh:"SOXL/SOXX 核心复利（现金保留）",domain:"us_equity",runtime_enabled:!1,income_layer_enabled:!1,option_overlay_enabled:!1,combo_enabled:!1,lifecycle_stage:"research_active",can_switch_live:!1,allowed_execution_modes:["paper","dry_run"],blocked_live_reason:"research_only_named_profile",live_continuity:{eligible:!1,allowed_platforms:[]},research_candidate_identity:{candidate_id:"soxl_soxx_core_only_p2_v7_longterm_compounding_cash_reserve",config_sha256:"843ab4e93e81985c2b3becc61a2f0b971508ccf25afa59acf402e75f574514d1"}},{profile:"nasdaq_sp500_smart_dca",label:"纳指标普定投",label_en:"NASDAQ/S&P 500 DCA",label_zh:"纳指标普定投",domain:"us_equity",runtime_enabled:!1,income_layer_enabled:!1,option_overlay_enabled:!1,combo_enabled:!1,lifecycle_stage:"research_active",can_switch_live:!1,allowed_execution_modes:["paper","dry_run"],blocked_live_reason:"missing_current_promotion_evidence_and_preauthorized_autonomy_policy",live_continuity:{eligible:!1,allowed_platforms:[]},dca_enabled:!0,dca_default_mode:"fixed",dca_default_base_investment_usd:"1000"},{profile:"ibit_smart_dca",label:"IBIT比特币定投",label_en:"IBIT Bitcoin DCA",label_zh:"IBIT比特币定投",domain:"us_equity",runtime_enabled:!0,income_layer_enabled:!1,option_overlay_enabled:!1,combo_enabled:!1,lifecycle_stage:"runtime_enabled",can_switch_live:!0,allowed_execution_modes:["paper","dry_run","live"],blocked_live_reason:"",live_continuity:{eligible:!0,allowed_platforms:["firstrade"]},dca_enabled:!0,dca_default_mode:"fixed",dca_default_base_investment_usd:"1000"},{profile:"global_etf_rotation",label:"全球ETF轮动",label_en:"Global ETF Rotation",label_zh:"全球ETF轮动",domain:"us_equity",runtime_enabled:!1,income_layer_enabled:!0,option_overlay_enabled:!1,combo_enabled:!1,frozen:!0,lifecycle_stage:"research_active",can_switch_live:!1,allowed_execution_modes:["dry_run"],blocked_live_reason:"research_backtest_only_requires_evidence_package",live_continuity:{eligible:!0,allowed_platforms:["ibkr"]},income_layer_start_usd:"500000",income_layer_max_ratio:"0.15",income_layer_allocations:{SCHD:.4,DGRO:.25,SGOV:.3,SPYI:.05}},{profile:"russell_top50_leader_rotation",label:"罗素Top50领涨",label_en:"Russell Top50 Leaders",label_zh:"罗素Top50领涨",domain:"us_equity",runtime_enabled:!0,income_layer_enabled:!0,option_overlay_enabled:!1,combo_enabled:!1,lifecycle_stage:"runtime_enabled",can_switch_live:!0,allowed_execution_modes:["paper","dry_run","live"],blocked_live_reason:"",live_continuity:{eligible:!0,allowed_platforms:["ibkr","longbridge"]},income_layer_start_usd:"300000",income_layer_max_ratio:"0.25",income_layer_allocations:{SCHD:.45,DGRO:.3,SGOV:.25}},{profile:"tecl_xlk_trend_income",label:"TECL/XLK趋势收益",label_en:"TECL/XLK Trend Income",label_zh:"TECL/XLK趋势收益",domain:"us_equity",runtime_enabled:!1,income_layer_enabled:!1,option_overlay_enabled:!1,combo_enabled:!1,frozen:!0,lifecycle_stage:"research_active",can_switch_live:!1,allowed_execution_modes:["dry_run"],blocked_live_reason:"failed_promotion_vs_live_profiles",live_continuity:{eligible:!1,allowed_platforms:[]}},{profile:"us_equity_combo",label:"美股核心收益组合",label_en:"US Core Income Combo",label_zh:"美股核心收益组合",domain:"us_equity",runtime_enabled:!1,income_layer_enabled:!0,option_overlay_enabled:!1,combo_enabled:!0,lifecycle_stage:"shadow_active",can_switch_live:!1,allowed_execution_modes:["paper","dry_run"],blocked_live_reason:"shadow_candidate_requires_evidence_package",live_continuity:{eligible:!1,allowed_platforms:[]},combo_mode:"dynamic",income_layer_start_usd:"300000",income_layer_max_ratio:"0.25",income_layer_allocations:{SCHD:.25,DGRO:.25,SGOV:.2,SPYI:.15,QQQI:.15}},{profile:"us_equity_combo_core",label:"美股核心组合",label_en:"US Core Combo",label_zh:"美股核心组合",domain:"us_equity",runtime_enabled:!1,income_layer_enabled:!1,option_overlay_enabled:!1,combo_enabled:!0,lifecycle_stage:"shadow_active",can_switch_live:!1,allowed_execution_modes:["paper","dry_run"],blocked_live_reason:"shadow_candidate_requires_evidence_package",live_continuity:{eligible:!1,allowed_platforms:[]},combo_mode:"dynamic"},{profile:"us_equity_combo_leveraged",label:"美股加速组合",label_en:"US Alpha Combo",label_zh:"美股加速组合",domain:"us_equity",runtime_enabled:!1,income_layer_enabled:!1,option_overlay_enabled:!1,combo_enabled:!0,lifecycle_stage:"shadow_active",can_switch_live:!1,allowed_execution_modes:["paper","dry_run"],blocked_live_reason:"shadow_candidate_requires_evidence_package",live_continuity:{eligible:!1,allowed_platforms:[]},combo_mode:"dynamic"},{profile:"hk_global_etf_tactical_rotation",label:"港股ETF战术轮动",label_en:"HK ETF Tactical Rotation",label_zh:"港股ETF战术轮动",domain:"hk_equity",runtime_enabled:!1,income_layer_enabled:!1,option_overlay_enabled:!1,combo_enabled:!1,frozen:!0,lifecycle_stage:"research_active",can_switch_live:!1,allowed_execution_modes:["dry_run"],blocked_live_reason:"research_backtest_only_requires_evidence_package",live_continuity:{eligible:!1,allowed_platforms:[]}},{profile:"hk_low_vol_dividend_quality_snapshot",label:"港股红利质量",label_en:"HK Dividend Quality",label_zh:"港股红利质量",domain:"hk_equity",runtime_enabled:!1,income_layer_enabled:!1,option_overlay_enabled:!1,combo_enabled:!1,frozen:!0,lifecycle_stage:"research_active",can_switch_live:!1,allowed_execution_modes:["paper","dry_run"],blocked_live_reason:"missing_current_promotion_evidence_and_preauthorized_autonomy_policy",live_continuity:{eligible:!1,allowed_platforms:[]}},{profile:"hk_equity_combo",label:"港股恒生组合",label_en:"HK Core Combo",label_zh:"港股恒生组合",domain:"hk_equity",runtime_enabled:!1,income_layer_enabled:!1,option_overlay_enabled:!1,combo_enabled:!0,frozen:!0,lifecycle_stage:"research_active",can_switch_live:!1,allowed_execution_modes:["dry_run"],blocked_live_reason:"research_backtest_only_requires_evidence_package",live_continuity:{eligible:!1,allowed_platforms:[]},combo_mode:"dynamic"},{profile:"cn_industry_etf_rotation",label:"A股行业ETF轮动",label_en:"CN Industry ETF Rotation",label_zh:"A股行业ETF轮动",domain:"cn_equity",runtime_enabled:!1,income_layer_enabled:!1,option_overlay_enabled:!1,combo_enabled:!1,frozen:!0,lifecycle_stage:"research_active",can_switch_live:!1,allowed_execution_modes:["paper","dry_run"],blocked_live_reason:"missing_current_promotion_evidence_and_preauthorized_autonomy_policy",live_continuity:{eligible:!1,allowed_platforms:[]}},{profile:"cn_industry_etf_rotation_aggressive",label:"A股ETF轮动",label_en:"CN ETF Rotation",label_zh:"A股ETF轮动",domain:"cn_equity",runtime_enabled:!1,income_layer_enabled:!1,option_overlay_enabled:!1,combo_enabled:!1,frozen:!0,lifecycle_stage:"live_candidate",can_switch_live:!1,allowed_execution_modes:["paper","dry_run"],blocked_live_reason:"live_candidate_requires_evidence_package",live_continuity:{eligible:!1,allowed_platforms:[]}},{profile:"cn_index_etf_tactical_rotation",label:"A股宽基ETF战术轮动",label_en:"CN Index ETF Tactical Rotation",label_zh:"A股宽基ETF战术轮动",domain:"cn_equity",runtime_enabled:!1,income_layer_enabled:!1,option_overlay_enabled:!1,combo_enabled:!1,frozen:!0,lifecycle_stage:"research_active",can_switch_live:!1,allowed_execution_modes:["dry_run"],blocked_live_reason:"research_backtest_only_requires_evidence_package",live_continuity:{eligible:!1,allowed_platforms:[]}},{profile:"cn_chinext_tactical_rotation",label:"创业板战术轮动",label_en:"CN ChiNext Tactical Rotation",label_zh:"创业板战术轮动",domain:"cn_equity",runtime_enabled:!1,income_layer_enabled:!1,option_overlay_enabled:!1,combo_enabled:!1,frozen:!0,lifecycle_stage:"research_active",can_switch_live:!1,allowed_execution_modes:["dry_run"],blocked_live_reason:"research_backtest_only_requires_evidence_package",live_continuity:{eligible:!1,allowed_platforms:[]}},{profile:"cn_chinext_growth_momentum_quality",label:"创业板成长动量质量",label_en:"CN ChiNext Growth Momentum Quality",label_zh:"创业板成长动量质量",domain:"cn_equity",runtime_enabled:!1,income_layer_enabled:!1,option_overlay_enabled:!1,combo_enabled:!1,frozen:!0,lifecycle_stage:"research_active",can_switch_live:!1,allowed_execution_modes:["dry_run"],blocked_live_reason:"research_backtest_only_requires_evidence_package",live_continuity:{eligible:!1,allowed_platforms:[]}},{profile:"cn_dividend_quality_snapshot",label:"A股红利质量",label_en:"CN Dividend Quality",label_zh:"A股红利质量",domain:"cn_equity",runtime_enabled:!1,income_layer_enabled:!1,option_overlay_enabled:!1,combo_enabled:!1,frozen:!0,lifecycle_stage:"research_active",can_switch_live:!1,allowed_execution_modes:["dry_run"],blocked_live_reason:"research_backtest_only_requires_evidence_package",live_continuity:{eligible:!1,allowed_platforms:[]}},{profile:"cn_chinext_growth_momentum_quality_snapshot",label:"创业板成长质量快照",label_en:"CN ChiNext Growth Quality Snapshot",label_zh:"创业板成长质量快照",domain:"cn_equity",runtime_enabled:!1,income_layer_enabled:!1,option_overlay_enabled:!1,combo_enabled:!1,frozen:!0,lifecycle_stage:"research_active",can_switch_live:!1,allowed_execution_modes:["dry_run"],blocked_live_reason:"research_backtest_only_requires_evidence_package",live_continuity:{eligible:!1,allowed_platforms:[]}},{profile:"cn_star_growth_momentum_quality",label:"科创板成长动量质量",label_en:"CN STAR Growth Momentum Quality",label_zh:"科创板成长动量质量",domain:"cn_equity",runtime_enabled:!1,income_layer_enabled:!1,option_overlay_enabled:!1,combo_enabled:!1,frozen:!0,lifecycle_stage:"research_active",can_switch_live:!1,allowed_execution_modes:["dry_run"],blocked_live_reason:"research_backtest_only_requires_evidence_package",live_continuity:{eligible:!1,allowed_platforms:[]}},{profile:"cn_equity_combo",label:"A股进取组合",label_en:"CN Alpha Combo",label_zh:"A股进取组合",domain:"cn_equity",runtime_enabled:!1,income_layer_enabled:!1,option_overlay_enabled:!1,combo_enabled:!0,frozen:!0,lifecycle_stage:"research_active",can_switch_live:!1,allowed_execution_modes:["dry_run"],blocked_live_reason:"research_backtest_only_requires_evidence_package",live_continuity:{eligible:!1,allowed_platforms:[]},combo_mode:"dynamic"},{profile:"crypto_live_pool_rotation",label:"加密池轮动",label_en:"Crypto Pool Rotation",label_zh:"加密池轮动",domain:"crypto",runtime_enabled:!1,income_layer_enabled:!1,option_overlay_enabled:!1,combo_enabled:!1,lifecycle_stage:"research_active",can_switch_live:!1,allowed_execution_modes:["paper","dry_run"],blocked_live_reason:"missing_current_promotion_evidence_and_preauthorized_autonomy_policy",live_continuity:{eligible:!0,allowed_platforms:["binance"]}},{profile:"crypto_btc_dca",label:"BTC定投",label_en:"BTC DCA",label_zh:"BTC定投",domain:"crypto",runtime_enabled:!1,income_layer_enabled:!1,option_overlay_enabled:!1,combo_enabled:!1,lifecycle_stage:"shadow_active",can_switch_live:!1,allowed_execution_modes:["paper","dry_run"],blocked_live_reason:"shadow_candidate_requires_evidence_package",live_continuity:{eligible:!1,allowed_platforms:[]}},{profile:"crypto_trend_rotation",label:"山寨趋势轮动",label_en:"Altcoin Trend",label_zh:"山寨趋势轮动",domain:"crypto",runtime_enabled:!1,income_layer_enabled:!1,option_overlay_enabled:!1,combo_enabled:!1,lifecycle_stage:"research_active",can_switch_live:!1,allowed_execution_modes:["dry_run"],blocked_live_reason:"research_backtest_only_requires_evidence_package",live_continuity:{eligible:!1,allowed_platforms:[]}},{profile:"crypto_equity_combo",label:"加密动量组合",label_en:"Crypto Core Combo",label_zh:"加密动量组合",domain:"crypto",runtime_enabled:!1,income_layer_enabled:!1,option_overlay_enabled:!1,combo_enabled:!0,lifecycle_stage:"research_active",can_switch_live:!1,allowed_execution_modes:["dry_run"],blocked_live_reason:"research_backtest_only_requires_evidence_package",live_continuity:{eligible:!1,allowed_platforms:[]},combo_mode:"dynamic"}];z.platform;const R=new Set(S.map(e=>e.profile));new Map(S.filter(e=>R.has(e.profile)).map(e=>[e.profile,{label_zh:e.label_zh,label_en:e.label_en}]));function I(e){return(e?.application_preparation?.account_options||[]).filter(a=>a?.platform==="longbridge"&&a?.broker_environment==="paper"&&typeof a.key=="string"&&a.key.trim()).map(a=>({id:`${a.platform}:${a.key}`,label:typeof a.label=="string"&&a.label.trim()?a.label:String(a.key)}))}function F(e){const a=e?.application_preparation?.blocker_codes;return Array.isArray(a)&&a.length>0}function K(e,a){if(!e||!N(e.application))return!1;const l=e.application_preparation||{};return F(e)||l.preflight_status!=="ready"||!l.preview_request?!1:I(e).some(r=>r.id===a)}function U(e,a,l){if(e!=="schwab"||a!=="fresh"||!l||typeof l!="object")return null;const r=l;if(Object.keys(r).length!==2||!Object.prototype.hasOwnProperty.call(r,"value")||!Object.prototype.hasOwnProperty.call(r,"source_tag"))return null;const i=r.value;if(r.source_tag!=="securitiesAccount.type"||typeof i!="string"||i.length<1||i.length>32)return null;for(const _ of i)if(!(_>="A"&&_<="Z"||_>="a"&&_<="z"||_==="_"))return null;return i}function Y(e){return e?.floorTouched===!0||e?.clearFloor===!0||e?.ratioTouched===!0||e?.clearRatio===!0||typeof e?.cashMode=="string"&&e.cashMode!==""}function L(e){if(typeof e!="string"||e.length>32||!/^(?:0|[1-9]\d*)(?:\.\d+)?$/.test(e))return null;const[a,l=""]=e.split(".");return a==="0"||a==="1"&&(l===""||/^0+$/.test(l))?e:null}function V(e){const a=e.trim();if(!/^\d+(?:\.\d+)?$/.test(a))return null;const[l,r=""]=a.split("."),i=l.replace(/^0+(?=\d)/,"")||"0";if(i.length>3||i.length===3&&i!=="100"||i==="100"&&/[1-9]/.test(r))return null;const t=`${i}${r}`.replace(/^0+(?=\d)/,"")||"0",_=r.length+2,o=t.padStart(_+1,"0"),s=o.length-_,d=o.slice(0,s).replace(/^0+(?=\d)/,"")||"0",u=o.slice(s).replace(/0+$/,"");return L(u?`${d}.${u}`:d)}function C({value:e}){const a=w();return e==null?n.jsx("span",{className:"flat",children:a("decisions.not_set")}):typeof e=="boolean"?n.jsx(n.Fragment,{children:e?"✓":"✕"}):n.jsx("span",{className:"num",children:String(e)})}function W({rows:e}){const a=w();return n.jsx("div",{className:"table-wrap",children:n.jsxs("table",{className:"data-table",children:[n.jsx("thead",{children:n.jsxs("tr",{children:[n.jsx("th",{children:a("decisions.col.field")}),n.jsx("th",{children:a("decisions.col.current")}),n.jsx("th",{children:a("decisions.col.proposed")}),n.jsx("th",{children:a("decisions.col.affects_live")})]})}),n.jsx("tbody",{children:e.map(l=>n.jsxs("tr",{children:[n.jsx("td",{title:l.label!==l.field?l.field:void 0,children:l.label}),n.jsx("td",{children:n.jsx(C,{value:l.before})}),n.jsx("td",{children:n.jsx(C,{value:l.after})}),n.jsx("td",{className:l.affectsLive?"diff-affects-live":"",children:n.jsx(O,{tone:l.affectsLive?"warn":"unknown",children:l.affectsLive?a("decisions.affects_live_required"):a("decisions.affects_live_none")})})]},l.field))})]})})}function Z({items:e}){return n.jsx("ul",{className:"timeline",children:e.map(a=>n.jsxs("li",{children:[n.jsx("div",{children:a.title}),a.detail&&n.jsx("div",{style:{color:"var(--muted)",fontSize:13},children:a.detail}),n.jsx("div",{className:"timeline-time",children:n.jsx(T,{value:a.time})})]},a.id))})}function ee({request:e,onResolve:a}){const l=w(),r=f.useRef(null),i=f.useRef(null),[t,_]=f.useState(!1),[o,s]=f.useState("");f.useEffect(()=>{i.current?.focus()},[]);const d=!e.typeToConfirm||o.trim()===e.typeToConfirm.expected,u=!e.ackLabel||t,b=d&&u,p=c=>{if(c.key==="Escape"){c.preventDefault(),a(!1);return}if(c.key!=="Tab")return;const v=r.current?.querySelectorAll('button:not(:disabled), [href], input:not(:disabled), select:not(:disabled), textarea:not(:disabled), [tabindex]:not([tabindex="-1"])');if(!v?.length)return;const k=v[0],x=v[v.length-1];c.shiftKey&&document.activeElement===k?(c.preventDefault(),x.focus()):!c.shiftKey&&document.activeElement===x&&(c.preventDefault(),k.focus())};return n.jsx("div",{className:"dialog-backdrop",onMouseDown:c=>{c.target===c.currentTarget&&a(!1)},children:n.jsxs("div",{className:"dialog",role:"dialog","aria-modal":"true","aria-labelledby":"confirm-title",ref:r,onKeyDown:p,children:[n.jsx("h2",{id:"confirm-title",children:e.title}),e.target&&n.jsx("p",{className:"dialog-target",children:e.target}),e.summary&&n.jsx("div",{className:"dialog-summary",children:e.summary}),e.body,e.consequence&&n.jsx("p",{className:`dialog-consequence ${e.tone==="danger"?"danger":""}`,children:e.consequence}),e.ackLabel&&n.jsxs("label",{className:"checkbox-row",children:[n.jsx("input",{type:"checkbox",checked:t,onChange:c=>_(c.target.checked)}),n.jsx("span",{children:e.ackLabel})]}),e.typeToConfirm&&n.jsxs("label",{className:"field",style:{marginTop:12},children:[n.jsx("span",{children:e.typeToConfirm.label}),n.jsx("input",{className:"input",value:o,onChange:c=>s(c.target.value),autoComplete:"off","aria-invalid":!d&&o.length>0}),!d&&o.length>0&&n.jsx("span",{style:{color:"var(--danger)",fontSize:12},children:e.typeToConfirm.mismatch})]}),n.jsxs("div",{className:"dialog-actions",children:[n.jsx("button",{ref:i,className:"button button-secondary",type:"button",onClick:()=>a(!1),children:l("common.cancel")}),n.jsx("button",{className:`button ${e.tone==="danger"?"button-danger":"button-primary"}`,type:"button",disabled:!b,onClick:()=>a(!0),children:e.confirmLabel||l("common.confirm")})]})]})})}function ae(){const[e,a]=f.useState(null),l=f.useRef(null);return{confirmRequest:e,confirm:t=>new Promise(_=>{l.current?.(!1),l.current=_,a(t)}),resolveConfirm:t=>{l.current?.(t),l.current=null,a(null)}}}export{ee as C,W as D,Z as T,H as a,M as b,J as c,Y as d,V as e,L as f,G as g,X as h,B as o,K as p,Q as r,ae as u,U as v};
" },
-  "/v2/assets/ExecutionEvidence-BafFTQfM.js": { contentType: "text/javascript; charset=utf-8", base64: "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" },
-  "/v2/assets/HealthPage-C3MhtCXB.js": { contentType: "text/javascript; charset=utf-8", base64: "import{u as b,o as F,r as N,a4 as P,j as e,c as O,f as k,k as H,m as z,B as K,S as V,z as R,A as L,h as G,a5 as U,a0 as q,a6 as W,E as D,N as Y}from"./index-Ds_XXLsn.js";import{u as A}from"./hooks-DCo9_b70.js";import{K as S}from"./KpiCard-Dxqixf9c.js";import{D as M}from"./DataTable-Bs7KLM5-.js";import{c as I,t as Z,r as J,w as Q,a as B,b as X}from"./status-B_UXUo8G.js";import{r as ee}from"./runtime_daily_contract-xW43mZQY.js";function ae(n){const s=n;return s?.status===409&&s?.message==="runtime_daily_binding_changed"}const w={ok:"health.grid.ok",failed:"health.grid.failed",blocked:"health.run_state.blocked","not-run":"health.grid.not_run","no-record":"health.grid.no_record",unknown:"state.unknown",incomplete:"health.grid.incomplete",stale:"state.stale","read-failed":"state.read_failed","binding-changed":"health.grid.binding_changed"},T={ok:"✓",failed:"✗",blocked:"⊘","not-run":"–","no-record":"",unknown:"?",incomplete:"…",stale:"~","read-failed":"!","binding-changed":"↻"};function C(n,s){return`${n.platform}/${n.account_alias}/${s}`}function te(n,s){const a=[];let l=Date.parse(`${n}T00:00:00Z`);for(;a.length<s;){const i=new Date(l).getUTCDay();i!==0&&i!==6&&a.unshift(new Date(l).toISOString().slice(0,10)),l-=864e5}return a}function se({selection:n,cell:s}){const a=b(),l=F(),i=H(),t=z(n.date,i);let o;if(!s||s.phase==="loading")o=e.jsx(k,{height:16,width:240});else if(s.phase==="binding-changed")o=e.jsx("span",{className:"health-grid-note health-grid-note-info",children:a("health.grid.binding_changed_detail")});else if(s.phase==="error")o=e.jsx("span",{className:"health-grid-note",children:a("state.read_failed")});else if(!s.snapshot.record)o=e.jsx("span",{children:a("health.grid.no_record")});else{const h=s.snapshot.record,f=h.runs??[],u=new Map;for(const d of f){const x=d.activity==="blocked"?"health.run_state.blocked":`state.${d.activity||"unknown"}`,j=a(x);u.set(j,(u.get(j)||0)+1)}o=e.jsxs(e.Fragment,{children:[e.jsxs("div",{className:"health-day-detail-meta",children:[h.status==="blocked"?e.jsx(K,{tone:"warn",children:a("health.run_state.blocked")}):e.jsx(V,{status:h.status}),I(s.snapshot)==="blocked"&&e.jsx("span",{children:a(h.block_reason_code?`reason.${h.block_reason_code}`:"reason.unknown")}),e.jsx("span",{children:a("health.day_detail_summary",{count:h.runs?f.length:0})}),[...u].map(([d,x])=>e.jsxs("span",{className:"card-note",children:[x," ",d]},d))]}),f.length>0&&e.jsxs("details",{className:"health-day-runs",children:[e.jsx("summary",{children:a("health.day_detail_runs")}),e.jsx("ul",{children:f.map((d,x)=>{const j=R(d.started_at,i).text,r=R(d.finished_at,i).text;return e.jsxs("li",{children:[e.jsxs("span",{className:"num",children:[a("health.detail.started")," ",j]}),e.jsxs("span",{className:"num",children:[a("health.detail.finished")," ",r]}),e.jsx("span",{children:a(d.activity==="blocked"?"health.run_state.blocked":`state.${d.activity||"unknown"}`)}),d.errors_present===!0&&d.activity!=="blocked"&&e.jsx(K,{tone:"error",children:a("health.grid.failed")})]},x)})})]})]})}return e.jsxs("div",{className:"health-day-detail",children:[e.jsxs("div",{className:"health-day-detail-head",children:[e.jsx("strong",{children:a("health.day_detail")}),e.jsx("span",{children:l.account(n.account.account_alias,n.account.platform)}),e.jsx("span",{className:"num",children:t})]}),o]})}function ne({accounts:n,epoch:s}){const a=b(),l=F(),i=N.useMemo(()=>te(ee(),14),[s]),[t,o]=N.useState({}),[h,f]=N.useState(!1),[u,d]=N.useState(null);if(N.useEffect(()=>{if(!n.length)return;let r=!1;const p={};for(const g of n)for(const c of i)p[C(g,c)]={phase:"loading"};return o(p),f(!1),d(null),(async()=>{let g=!1;for(const c of i){const m=await Promise.allSettled(n.map(_=>P(c,_.platform,_.account_alias,!1)));if(r)return;const y={};m.forEach((_,$)=>{const v=C(n[$],c);_.status==="fulfilled"?y[v]={phase:"ready",snapshot:_.value}:ae(_.reason)?y[v]={phase:"binding-changed"}:(y[v]={phase:"error"},g=!0)}),o(_=>({..._,...y}))}!r&&g&&f(!0)})().catch(()=>{r||f(!0)}),()=>{r=!0}},[n,i,s]),!n.length)return e.jsx(O,{title:a("state.no_data")});const x=Object.keys(w),j=Object.values(t).some(r=>r.phase==="binding-changed");return e.jsxs(e.Fragment,{children:[e.jsx("p",{className:"health-grid-hint",children:a("health.grid_scroll_hint")}),e.jsx("div",{className:"health-grid",tabIndex:0,role:"region","aria-label":a("health.grid_title"),children:e.jsxs("table",{children:[e.jsx("caption",{className:"sr-only",children:a("health.grid_title")}),e.jsx("thead",{children:e.jsxs("tr",{children:[e.jsx("th",{scope:"col",children:a("health.col.account")}),i.map(r=>e.jsx("th",{scope:"col",className:"num",children:r.slice(5)},r))]})}),e.jsx("tbody",{children:n.map(r=>e.jsxs("tr",{children:[e.jsxs("th",{scope:"row",children:[l.account(r.account_alias,r.platform),e.jsxs("span",{className:"card-note",children:[" · ",l.platform(r.platform)]})]}),i.map(p=>{const g=C(r,p),c=t[g],m=u?.account.platform===r.platform&&u.account.account_alias===r.account_alias&&u.date===p;if(!c||c.phase==="loading")return e.jsx("td",{children:e.jsx(k,{height:26,width:26})},p);if(c.phase==="binding-changed"||c.phase==="error"){const $=c.phase==="error"?"read-failed":"binding-changed",v=a(w[$]);return e.jsx("td",{children:e.jsx("button",{type:"button",className:`health-cell ${$}${m?" selected":""}`,title:v,"aria-label":`${l.account(r.account_alias,r.platform)} ${p}: ${v}`,onClick:()=>d({account:r,date:p}),children:T[$]})},p)}const y=I(c.snapshot),_=a(w[y]);return e.jsx("td",{children:e.jsx("button",{type:"button",className:`health-cell ${y}${m?" selected":""}`,title:_,"aria-label":`${l.account(r.account_alias,r.platform)} ${p}: ${_}`,"aria-pressed":m,onClick:()=>d({account:r,date:p}),children:T[y]})},p)})]},`${r.platform}/${r.account_alias}`))})]})}),e.jsx("div",{className:"health-legend",children:x.map(r=>e.jsxs("span",{children:[e.jsx("span",{className:`health-cell ${r}`,"aria-hidden":"true",children:T[r]}),a(w[r])]},r))}),h&&e.jsx("p",{className:"health-grid-note",children:a("health.grid_read_failed_note")}),j&&e.jsx("p",{className:"health-grid-note health-grid-note-info",children:a("health.grid_binding_changed_note")}),u&&e.jsx(se,{selection:u,cell:t[C(u.account,u.date)]})]})}function le(n,s){return n.filter(a=>{if(s.some(i=>i.platform===a.platform&&i.status==="read_failed"))return!1;const l=s.filter(i=>i.platform===a.platform&&i.account_key===a.account_alias);return l.length===1&&l[0].status==="bound"&&!!l[0].target_key})}const re=["30","7","1","expired"],ie={expired:"error",1:"error",7:"warn",30:"warn",not_due:"ok",unknown:"unknown"};function E({state:n,render:s}){const a=b();return n.phase==="loading"?e.jsx(k,{height:24,width:90}):n.phase==="error"||n.phase==="ready"&&n.data!==null&&typeof n.data=="object"&&"status"in n.data&&n.data.status==="read_failed"?e.jsx("span",{className:"kpi-state",children:a("state.read_failed")}):e.jsx(e.Fragment,{children:s()})}function oe({summary:n,credential:s}){const a=b(),l=n.phase==="ready"?n.data:null,i=l?l.accounts.filter(c=>c.status==="ok").length:0,t=l?Z(l):{count:0,complete:!1},o=l?J(l.accounts):null,h=l?Q(l):!1,f=o&&(o.not_connected>0||o.no_data>0)?a("health.kpi.today_runs_note",{not_connected:o.not_connected,no_data:o.no_data}):void 0,u=s.phase==="ready"?s.data:null,d=u?.requires_action===!0||u&&re.includes(u.phase)?1:0,x=!u||u.phase==="unknown",j=["succeeded","failed","read_failed","incomplete"],r=o?Object.entries(o):[],p=r.filter(([c])=>j.includes(c)),g=r.filter(([c,m])=>!j.includes(c)&&m>0);return e.jsxs(e.Fragment,{children:[e.jsxs("div",{className:"stat-strip health-kpis",children:[e.jsx(S,{title:a("health.kpi.today_runs"),value:e.jsx(E,{state:n,render:()=>h&&(l?.counts.observed??0)===0?"—":a("health.account_fraction",{count:i,total:l?.counts.configured??0})}),sub:h?e.jsx("span",{children:a("health.non_trading_day_short")}):f?e.jsx("span",{title:a("health.kpi.today_runs_note_title"),children:f}):void 0,footer:l?.as_of?e.jsx(L,{value:l.as_of}):void 0}),e.jsx(S,{title:a("health.kpi.observed"),value:e.jsx(E,{state:n,render:()=>a("health.account_fraction",{count:l?.counts.observed??0,total:l?.counts.configured??0})})}),e.jsx(S,{title:a("health.kpi.recent_failure"),value:e.jsx(E,{state:n,render:()=>h&&t.count===0?"—":t.complete?String(t.count):t.count>0?a("health.failure_at_least",{count:t.count}):a("state.unknown")}),sub:h?a("health.non_trading_day_short"):void 0}),e.jsx(S,{title:a("health.kpi.credentials"),value:e.jsx(E,{state:s,render:()=>x?a("state.unknown"):String(d)}),sub:a("health.kpi.credentials_unit")})]}),o&&e.jsxs("div",{className:"health-state-summary",children:[e.jsx("ul",{className:"health-state-counts","aria-label":a("health.state_counts"),children:p.map(([c,m])=>e.jsxs("li",{children:[a(B(c)),": ",e.jsx("span",{className:"num",children:m})]},c))}),g.length>0&&e.jsx("ul",{className:"health-state-counts health-state-secondary",children:g.map(([c,m])=>e.jsxs("li",{children:[a(B(c)),": ",e.jsx("span",{className:"num",children:m})]},c))})]}),e.jsxs("p",{className:"metric-note",title:a("health.failure_window_detail"),children:[a("health.failure_window",{date:l?.date??"—"}),h?` · ${a("health.non_trading_day_short")}`:!t.complete&&` · ${a("health.failure_incomplete")}`]})]})}function ce({summary:n}){const s=b(),a=F();if(n.phase==="loading")return e.jsx(k,{height:120});if(n.phase==="error")return e.jsx(D,{onRetry:n.reload});const l=[{id:"account",header:s("health.col.account"),cell:t=>e.jsx(e.Fragment,{children:a.account(t.account_alias,t.platform)}),sortValue:t=>`${a.account(t.account_alias,t.platform)}:${t.account_alias}`},{id:"status",header:s("health.col.status"),cell:t=>t.unavailable_reason==="runtime_daily_binding_conflict"?e.jsx("span",{children:s("reason.runtime_daily_binding_conflict")}):e.jsx(V,{status:t.freshness??(t.stale===!0?"stale":t.fresh===!0?"fresh":t.status),reason:t.unavailable_reason}),sortValue:t=>t.status},{id:"activity",header:s("health.activity"),cell:t=>{const o=X(t);return e.jsx("span",{"data-state":o,title:t.run_status_reason?s(`reason.${t.run_status_reason}`):void 0,children:s(B(o))})}},{id:"run_count",header:s("health.run_count"),numeric:!0,cell:t=>t.run_count===null?"—":t.run_count,sortValue:t=>t.run_count},{id:"as_of",header:s("health.col.as_of"),cell:t=>e.jsx(L,{value:t.as_of,prefix:"common.as_of"}),sortValue:t=>t.as_of}],i=Y(n.data.accounts,a.config).sort((t,o)=>a.platform(t.platform).localeCompare(a.platform(o.platform)));return e.jsxs(e.Fragment,{children:[n.data.status==="read_failed"&&e.jsx("p",{role:"alert",children:s("state.read_failed")}),i.map(t=>e.jsxs("section",{className:"health-platform-group",children:[e.jsx("h3",{children:a.platform(t.platform)}),e.jsx(M,{columns:l,rows:t.accounts.flatMap(o=>o.rows),rowKey:o=>`${o.platform}/${o.account_alias}`,defaultSort:{column:"account",direction:"asc"},scrollHint:!0,caption:`${s("health.freshness_title")} · ${a.platform(t.platform)}`})]},t.platform)),!i.length&&e.jsx(O,{title:s("state.no_data")})]})}function de({credential:n}){const s=b(),a=H();if(n.phase==="loading")return e.jsx(k,{height:72});if(n.phase==="error")return e.jsx(D,{onRetry:n.reload});const l=n.data,i=[{id:"id",header:s("health.col.credential"),cell:t=>s(t.id==="ibkr_flex"?"health.credential_ibkr_report":"health.credential_other")},{id:"phase",header:s("health.col.phase"),cell:t=>e.jsx(K,{tone:ie[t.phase],children:s(`health.credential_phase.${t.phase}`)})},{id:"expires",header:s("health.col.expires"),cell:t=>{if(!t.expires_at)return"—";const{text:o,zone:h}=R(t.expires_at,a,!0);return s("health.credential_expires",{value:h?`${o} (${h})`:o})},sortValue:t=>t.expires_at}];return e.jsx(M,{columns:i,rows:[l],rowKey:t=>t.id,scrollHint:!0,caption:s("health.credentials_title")})}function he(){const n=b(),s=A(()=>q(),[]),a=A(()=>W(),[]),l=N.useMemo(()=>s.phase==="ready"&&a.phase==="ready"?le(s.data.accounts,a.data):[],[s.phase,s.data,a.phase,a.data]);return e.jsxs("section",{className:"card",children:[e.jsx("h2",{className:"card-title",children:n("health.grid_title")}),(s.phase==="loading"||a.phase==="loading")&&e.jsx(k,{height:160}),s.phase==="error"&&e.jsx(D,{onRetry:s.reload}),a.phase==="error"&&e.jsx(D,{onRetry:a.reload}),a.phase==="ready"&&a.data.some(i=>i.status==="read_failed")&&e.jsx("p",{role:"alert",children:n("state.read_failed")}),s.phase==="ready"&&a.phase==="ready"&&(l.length>0||!a.data.some(i=>i.status==="read_failed"))&&e.jsx(ne,{accounts:l,epoch:0})]})}function je(){const n=b(),[s,a]=N.useState(0),l=A(()=>G(),[s]),i=A(()=>U(),[s]);return e.jsxs("div",{className:"page",children:[e.jsxs("header",{className:"page-header",children:[e.jsx("h1",{className:"page-title",children:n("health.title")}),e.jsx("div",{className:"page-header-actions",children:e.jsx("button",{type:"button",className:"button button-secondary",onClick:()=>a(t=>t+1),children:n("common.refresh")})})]}),e.jsx("p",{className:"card-note",children:n("health.global_scope_note")}),e.jsxs("div",{className:"health-day-context",children:[l.phase==="loading"?e.jsx(k,{height:18,width:240}):l.phase==="error"?e.jsx("span",{className:"health-business-day","data-state":"read_failed",children:n("state.read_failed")}):e.jsx("span",{className:"health-business-day",children:n("health.business_date",{value:`${l.data.date} · ${l.data.timezone}`})}),l.phase==="ready"&&l.data.as_of&&e.jsx(L,{value:l.data.as_of}),l.phase==="ready"&&l.data.market_session==="weekend"&&e.jsx("span",{className:"health-business-day","data-state":"non_trading",children:n("health.non_trading_day")})]}),e.jsx(oe,{summary:l,credential:i}),e.jsx(he,{},s),e.jsxs("section",{className:"card",children:[e.jsx("h2",{className:"card-title",children:n("health.freshness_title")}),e.jsx("div",{className:"health-freshness",children:e.jsx(ce,{summary:l})})]}),e.jsxs("section",{className:"card",children:[e.jsx("h2",{className:"card-title",children:n("health.credentials_title")}),e.jsx("div",{className:"health-credentials",children:e.jsx(de,{credential:i})})]})]})}export{je as default};
" },
+  "/v2/assets/DecisionsPage-SP8nEoQr.js": { contentType: "text/javascript; charset=utf-8", base64: "import{u as re,k as me,j as e,m as ae,B as G,C as Ae,p as Je,b as Ye,D as Ze,r as p,F as Q,S as We,d as Qe,G as Xe,g as se,c as Le,H as en,I as Ce,A as nn,J as De,K as tn,L as sn}from"./index-CwQsWZdm.js";import{i as an}from"./inboxFailure-B9PDJ1HN.js";import{u as rn,c as on,a as cn,C as ln,T as dn,p as Fe,D as Ee,o as un,r as pn,h as mn,b as _n}from"./Dialog-Nx1EjiqV.js";import{u as ue,c as fn}from"./hooks-9usXmJc_.js";import{T as hn}from"./Tabs-BP4xZNhq.js";import{i as yn,E as xn,a as gn,l as jn,A as bn,e as Te,t as vn}from"./cockpit-Cax-GxP0.js";import"./runtime_daily_contract-xW43mZQY.js";function Me({data:n,error:i,onRetry:s}){const a=re(),r=me(),y=an(n,i),d=n?.directory?.complete===!1?n.directory.retry_at:null;return e.jsxs("div",{className:"error-state",role:"alert","data-state":y,children:[e.jsx("span",{className:"state-icon state-icon-error","aria-hidden":"true",children:e.jsxs("svg",{width:14,height:14,viewBox:"0 0 10 10",children:[e.jsx("circle",{cx:"5",cy:"5",r:"4",fill:"none",stroke:"currentColor",strokeWidth:"1.2"}),e.jsx("path",{d:"M3.2 3.2 L6.8 6.8 M6.8 3.2 L3.2 6.8",stroke:"currentColor",strokeWidth:"1.2",strokeLinecap:"round"})]})}),e.jsxs("div",{className:"state-copy",children:[e.jsx("div",{className:"error-title",children:a(`inbox.error.${y}.title`)}),e.jsx("p",{className:"state-short",children:a("inbox.count_unknown")}),y==="unauthorized"&&e.jsx("p",{className:"state-short",children:a("inbox.auth_hint")}),d!=null&&Number.isFinite(d)&&d>0&&e.jsx("p",{className:"state-short",children:a("inbox.retry_at",{value:ae(new Date(d).toISOString(),r).text})})]}),s&&y!=="unauthorized"&&e.jsx("div",{className:"state-action",children:e.jsx("button",{type:"button",className:"button button-secondary button-sm",onClick:s,children:a("inbox.retry")})})]})}function xe(n,i){return n.find(s=>s.id===i)??(n.length===1?n[0]:null)}const kn={owner:"owner_decision",promotion:"strategy_promotion",recovery:"reconciliation_recovery",credential:"credential_maintenance"};function Nn(n){const i=kn[n];return i?`category.${i}`:"decisions.unknown_source"}function wn(n){return n==="read_failed"?"decisions.partial_consequence.read_failed":n==="unavailable"?"decisions.partial_consequence.unavailable":"decisions.partial_consequence.stale"}const Re=["positions","cash","open_orders","recent_executions","local_execution_ledger"],Sn={complete:"ok",partial:"warn",unknown:"unknown"},$n=["kind","currency","window_start","window_end","limit_per_namespace","gateway_availability","truncated"],pe=n=>!!(n&&typeof n=="object"&&!Array.isArray(n));function An(n){const i=pe(n)?n:null,s=a=>{const r=i?.[a];return typeof r=="string"?r:null};return{provided:i!==null,kind:s("kind"),currency:s("currency"),window_start:s("window_start"),window_end:s("window_end"),limit_per_namespace:s("limit_per_namespace"),gateway_availability:s("gateway_availability"),truncated:s("truncated")}}function Cn(n){const i=pe(n)?n:null,s=An(i?i.scope:null);return i?i.status==="complete"&&Array.isArray(i.items)?{status:"complete",items:i.items,scope:s}:i.status==="partial"?{status:"partial",items:Array.isArray(i.items)?i.items:null,scope:s}:{status:"unknown",items:null,scope:s}:{status:"unknown",items:null,scope:s}}function Dn(n){return n.replace(/_/g," ").replace(/\s+/g," ").trim()||n}function Fn(n,i){const s=`initial_enrollment.fact.${n}`,a=i(s);return a===s?Dn(n):a}function En(n,i,s){if(i===null||i==="")return s("common.unknown");if(n==="truncated"){if(i==="true")return s("initial_enrollment.value.true");if(i==="false")return s("initial_enrollment.value.false")}if(n==="gateway_availability"&&i==="current_broker_day")return s("initial_enrollment.current_broker_day");if(n==="kind"){const a=`initial_enrollment.scope_kind.${i}`,r=s(a);if(r!==a)return r}return i}function je({value:n,t:i}){if(n===null)return e.jsx(e.Fragment,{children:i("common.unknown")});if(typeof n=="string")return e.jsx(e.Fragment,{children:n||i("common.na")});if(typeof n=="number")return e.jsx(e.Fragment,{children:Number.isFinite(n)?String(n):i("common.unknown")});if(typeof n=="boolean")return e.jsx(e.Fragment,{children:i(n?"initial_enrollment.value.true":"initial_enrollment.value.false")});if(Array.isArray(n))return n.length===0?e.jsx(e.Fragment,{children:i("common.na")}):e.jsx("ul",{className:"initial-enrollment-list",children:n.map((a,r)=>e.jsx("li",{children:e.jsx(je,{value:a,t:i})},r))});const s=Object.entries(n);return s.length===0?e.jsx(e.Fragment,{children:i("common.na")}):e.jsx("dl",{className:"initial-enrollment-fields",children:s.map(([a,r])=>e.jsxs("div",{children:[e.jsx("dt",{children:Fn(a,i)}),e.jsx("dd",{children:e.jsx(je,{value:r,t:i})})]},a))})}function Tn({scope:n,t:i}){const s=$n.filter(a=>n[a]!==null&&n[a]!=="");return!n.provided||!s.length?null:e.jsxs("details",{className:"initial-enrollment-scope-block",children:[e.jsx("summary",{children:i("initial_enrollment.scope")}),e.jsx("dl",{className:"initial-enrollment-scope",children:s.map(a=>e.jsxs("div",{"data-scope-field":a,children:[e.jsx("dt",{children:i(`initial_enrollment.scope_field.${a}`)}),e.jsx("dd",{children:En(a,n[a],i)})]},a))})]})}function Rn({surface:n,t:i}){if(n.status==="unknown")return e.jsx("p",{className:"decision-note","data-state":"unknown",children:i("common.unknown")});const s=n.items;return s===null?e.jsx("p",{className:"decision-note","data-state":"unavailable",children:i("initial_enrollment.partial_unavailable")}):s.length===0?e.jsx("p",{className:"decision-note","data-state":n.status==="complete"?"known_empty":"partial_unavailable",children:n.status==="complete"?i("initial_enrollment.known_empty"):i("initial_enrollment.partial_unavailable")}):e.jsxs(e.Fragment,{children:[n.status==="partial"&&e.jsx("p",{className:"decision-note",children:i("initial_enrollment.partial_notice")}),e.jsx("div",{className:"initial-enrollment-items","data-item-count":s.length,children:s.map((a,r)=>e.jsx("div",{className:"initial-enrollment-item",children:e.jsx(je,{value:a,t:i})},r))})]})}function Bn({account:n,strategy:i,platform:s,facts:a,readiness:r,blockerCodes:y}){const d=re(),T=me(),o=pe(a)?a:null,k=o?.observed_at,j=typeof k=="string"&&Number.isFinite(Date.parse(k))?k:null,F=j?ae(j,T):null,b=o&&pe(o.surfaces)?o.surfaces:null,U=r==="blocked"||!!y?.length,O=(y||[]).map(N=>/^initial_enrollment_(.+)_incomplete$/.exec(N)?.[1]).filter(N=>!!(N&&Re.includes(N)));return e.jsxs("section",{className:"initial-enrollment-facts","aria-label":d("initial_enrollment.title"),"data-material":"initial_enrollment","data-readiness":r??void 0,children:[e.jsx("h2",{className:"card-title",children:d("initial_enrollment.title")}),e.jsxs("div",{className:"decision-meta",children:[e.jsxs("span",{children:[d("common.account"),": ",n||d("common.unknown")]}),e.jsxs("span",{children:[d("common.strategy"),": ",i||d("common.unknown")]}),s&&e.jsxs("span",{children:[d("common.platform"),": ",s]}),e.jsxs("span",{children:[d("initial_enrollment.source_time"),":"," ",j&&F?e.jsx("time",{dateTime:j,children:F.zone?`${F.text} (${F.zone})`:F.text}):d("common.unknown")]})]}),e.jsx("p",{className:"decision-note",children:d("initial_enrollment.notice")}),U&&e.jsxs("p",{className:"decision-note initial-enrollment-blocked",role:"status","data-state":"blocked",children:[d("initial_enrollment.blocked"),O.length>0?` ${O.map(N=>d(`initial_enrollment.surface.${N}`)).join(" / ")}`:""]}),e.jsx("div",{className:"initial-enrollment-surfaces",children:Re.map(N=>{const h=Cn(b?.[N]);return e.jsxs("section",{className:"initial-enrollment-surface","data-surface":N,"data-status":h.status,children:[e.jsxs("h3",{className:"initial-enrollment-surface-title",children:[d(`initial_enrollment.surface.${N}`)," ",e.jsx(G,{tone:Sn[h.status],children:d(`initial_enrollment.status.${h.status}`)})]}),e.jsx(Rn,{surface:h,t:d}),e.jsx(Tn,{scope:h.scope,t:d})]},N)})})]})}function In({data:n,language:i,t:s,itemId:a}){const r=n?.sources.find(o=>o.source==="recovery"),y=r?.current_reconciliation_observation,d=(n?.items||[]).filter(o=>o.category==="reconciliation_recovery"&&(!a||o.id===a)),T=o=>{if(!o||!Number.isFinite(Date.parse(o)))return s("common.unknown");const k=new Intl.DateTimeFormat(i==="zh"?"zh-CN":"en-US",{year:"numeric",month:"2-digit",day:"2-digit",hour:"2-digit",minute:"2-digit",hour12:!1,timeZoneName:"shortOffset"}).formatToParts(new Date(o)),j=k.find(b=>b.type==="timeZoneName")?.value||"",F=k.filter(b=>b.type!=="timeZoneName").map(b=>b.value).join("").trim();return e.jsx("time",{dateTime:o,children:j?`${F} (${j})`:F})};return e.jsxs("section",{className:"reconciliation-materials","aria-label":s("reconciliation.title"),children:[e.jsx("h2",{className:"card-title",children:s("reconciliation.current")}),e.jsx("p",{role:"status",children:y?.status_label[i]||s("reconciliation.not_connected")}),y?.last_observed_at&&e.jsxs("p",{children:[s("reconciliation.observed_at"),"：",T(y.last_observed_at)]}),e.jsx("p",{className:"decision-note",children:s("reconciliation.history_notice")}),e.jsx("h2",{className:"card-title",children:s("reconciliation.materials")}),r?.status!=="ok"&&e.jsx("p",{className:"decision-note",children:s(r?.status==="stale"?"reconciliation.stale":"reconciliation.read_unknown")}),!d.length&&e.jsx("p",{children:s("reconciliation.empty")}),d.map(o=>{const k=o.presentation,j=Ae("strategies",k?.strategy_profile||"",i,s("reconciliation.unnamed_strategy")),F=Ae("accounts",o.account_alias||"",i,s("common.account"),o.platform||"");return e.jsxs("article",{className:"reconciliation-material",children:[e.jsx("h3",{children:k?.label[i]||s("reconciliation.materials")}),e.jsxs("p",{children:[j," · ",F,!a&&e.jsxs(e.Fragment,{children:[" · ",e.jsx("span",{className:"reconciliation-ref",children:s("decisions.ref",{id:o.short_id})})]})]}),e.jsxs("dl",{children:[e.jsxs("div",{children:[e.jsx("dt",{children:s("reconciliation.decision_status")}),e.jsx("dd",{children:k?.decision_status_label[i]||s("reconciliation.decision_unknown")})]}),e.jsxs("div",{children:[e.jsx("dt",{children:s("reconciliation.freshness")}),e.jsx("dd",{children:s(o.evidence_freshness.status==="stale"?"state.stale":o.evidence_freshness.status==="ready"?"decisions.freshness.ready":"common.unknown")})]}),e.jsxs("div",{children:[e.jsx("dt",{children:s("reconciliation.observed_at")}),e.jsx("dd",{children:T(k?.last_observed_at||o.evidence_freshness.as_of)})]}),e.jsxs("div",{children:[e.jsx("dt",{children:s("reconciliation.generated_at")}),e.jsx("dd",{children:T(k?.source_generated_at)})]}),e.jsxs("div",{children:[e.jsx("dt",{children:s("reconciliation.computed_at")}),e.jsx("dd",{children:T(k?.source_computed_at)})]})]})]},o.id)})]})}const Ln=["reconciliation_recovery","strategy_promotion","owner_decision","paper_account_application","credential_maintenance"],Be={high:0,medium:1,normal:2},Oe=30*864e5;function Mn(n){if(n.evidence_freshness?.status==="stale")return!0;const i=n.created_at?Date.parse(n.created_at):NaN;return Number.isFinite(i)&&Date.now()-i>Oe}function On(n){if(n.evidence_freshness?.status==="stale")return"decisions.stale_hint";const i=n.created_at?Date.parse(n.created_at):NaN;return Number.isFinite(i)&&Date.now()-i>Oe?"decisions.stale_visible_hint":null}function X(n){const i=n.decision_binding;if(i&&typeof i.subject_id=="string"&&i.subject_id)return i.subject_id;const s=n.id.indexOf(":");return s>=0?n.id.slice(s+1):n.id}function te(n){if(n.status==="expired")return!0;const i=n.expires_at?Date.parse(n.expires_at):NaN;return Number.isFinite(i)&&i<Date.now()}function ge(n){return n.category==="reconciliation_recovery"&&(!!n.initial_enrollment||n.presentation?.material_kind==="initial_enrollment")}function Kn(n){return[...n].sort((i,s)=>{const a=+(s.category==="reconciliation_recovery")-+(i.category==="reconciliation_recovery");if(a!==0)return a;const r=(Be[i.priority]??3)-(Be[s.priority]??3);return r!==0?r:(s.created_at||"").localeCompare(i.created_at||"")})}function ie(n,i){const s=n?.application_preparation?.account_options;return Array.isArray(s)?s.filter(a=>{if(!a||typeof a.platform!="string"||typeof a.key!="string"||!a.key.trim())return!1;const r=a.broker_environment;return i?a.platform==="longbridge"&&r==="paper":r==="live"||r==="paper"&&a.platform==="longbridge"}).map(a=>({id:`${a.platform}:${a.key}`,platform:String(a.platform),key:String(a.key),label:typeof a.label=="string"&&a.label.trim()?a.label:String(a.key),mode:String(a.broker_environment||"")})):[]}function Ie(n,i){const s=[n?.risk_policy_binding,n?.confirmation,i.risk_policy_binding,i];for(const a of s){if(!a||typeof a!="object")continue;const r=typeof a.selected_tier=="string"?a.selected_tier:typeof a.risk_profile=="string"?a.risk_profile:null;if(!r||!yn(r))continue;const y=typeof a.policy_revision=="string"&&a.policy_revision?a.policy_revision:typeof a.approved_policy_revision=="string"&&a.approved_policy_revision?a.approved_policy_revision:null;return{risk_profile:r,policy_revision:y}}return null}function qn(n){return n==="fresh"?"state.fresh":n==="stale"?"state.stale":n==="ready"?"decisions.freshness.ready":n==="unavailable"?"state.unavailable":"state.unknown"}function Pn({epoch:n,category:i}){const s=re(),a=me(),[r,y]=p.useState(null),[d,T]=p.useState(null),[o,k]=p.useState(!1),[j,F]=p.useState(!1),b=p.useRef(fn()),U=p.useCallback(()=>{const h=b.current.begin();y(null),k(!1),T(null),Ce(25).then(B=>{b.current.isCurrent(h)&&(y(B.items),T(B.next_cursor))}).catch(()=>{b.current.isCurrent(h)&&k(!0)})},[]);p.useEffect(()=>U(),[U,n]);const O=()=>{if(!d||j)return;const h=b.current.begin();F(!0),Ce(25,d).then(B=>{b.current.isCurrent(h)&&(y(ee=>[...ee||[],...B.items]),T(B.next_cursor))}).catch(()=>{b.current.isCurrent(h)&&k(!0)}).finally(()=>{b.current.isCurrent(h)&&F(!1)})};if(o&&!r?.length)return e.jsx(Me,{onRetry:U});if(!r)return e.jsxs("div",{className:"card",children:[e.jsx(se,{height:56}),e.jsx("div",{style:{height:8}}),e.jsx(se,{height:56})]});const N=i==="all"?r:r.filter(h=>h.category===i);return N.length===0?e.jsx(Le,{title:s("decisions.history.empty")}):e.jsxs("div",{className:"card",children:[e.jsx("h2",{className:"card-title",children:s("decisions.history_title")}),e.jsx(dn,{items:N.map(h=>({id:h.id,time:h.time,title:e.jsxs(e.Fragment,{children:[h.actor_alias||s("common.unknown")," · ",s(`decisions.action.${h.action}`)]}),detail:e.jsxs(e.Fragment,{children:[s(`category.${h.category}`)," · ",s("decisions.ref",{id:h.item_short_id})," · ",ae(h.time,a).text]})}))}),d&&e.jsx("div",{className:"decision-history-more",children:e.jsx("button",{type:"button",className:"button button-secondary",disabled:j,onClick:O,children:s(j?"common.loading":"common.load_more")})}),o&&e.jsx("p",{className:"decision-note",children:s("error.generic")})]})}function zn({operationId:n}){const i=re(),[s,a]=p.useState(0),r=ue(()=>jn(n,!1),[n,s]),y=r.phase==="loading"?"loading":r.phase==="error"?"error":r.data.status==="not_ready"?"not_ready":"ready",d=r.phase==="ready"&&r.data.status==="ready"?r.data.data:null,T=r.phase==="ready"&&r.data.status==="ready"&&r.data.synthetic;return e.jsxs("div",{className:"cockpit-operation",children:[T&&e.jsx(G,{tone:"accent",children:i("cockpit.synthetic")}),e.jsx(bn,{operation:d,status:y,onRefresh:()=>a(o=>o+1)})]})}function Wn(){const n=re(),i=Je(),s=me(),a=Ye(),r=Ze(),{confirmRequest:y,confirm:d,resolveConfirm:T}=rn(),[o,k]=p.useState("all"),[j,F]=p.useState("pending"),[b,U]=p.useState(0),[O,N]=p.useState(null),[h,B]=p.useState({}),[ee,be]=p.useState({}),x=ue(()=>Qe(b>0),[b]),ve=ue(()=>Xe(),[]),ke=ve.phase==="ready"&&ve.data.admin===!0,Ke=x.phase==="ready"?x.data:null,oe=p.useMemo(()=>new Date().toISOString(),[Ke]),V=p.useRef(on()),Z=p.useRef(cn()),E=p.useCallback(()=>U(t=>t+1),[]),ce=p.useMemo(()=>x.phase==="ready"&&x.data.status!=="read_failed"?x.data.items:[],[x]),_e=p.useMemo(()=>Kn(ce.filter(t=>t.status==="pending"||t.status==="expired")),[ce]),Ne=p.useMemo(()=>ce.filter(t=>t.status==="pending").length,[ce]),ne=p.useMemo(()=>o==="all"?_e:_e.filter(t=>t.category===o),[_e,o]),fe=p.useMemo(()=>x.phase==="ready"&&x.data.status!=="read_failed"?x.data.sources.filter(t=>t.status!=="ok"):[],[x]),D=ne.find(t=>t.id===O)||null,we=t=>t.account_alias?i.account(t.account_alias,t.platform):n("decisions.account_unbound");p.useEffect(()=>{x.phase==="ready"&&O&&!ne.some(t=>t.id===O)&&N(null)},[x.phase,O,ne]);const Se=!!(D&&D.status==="pending"&&!te(D)&&(D.category==="strategy_promotion"||D.category==="paper_account_application")),H=ue(()=>Se?Q("/api/research-promotion-tickets"):Promise.resolve(null),[Se,D?.id,b]),J=p.useMemo(()=>{if(!D||H.phase!=="ready"||!H.data)return null;const t=H.data.applications;return Array.isArray(t)&&t.find(c=>c?.ticket_id===X(D))||null},[D,H]),he=p.useMemo(()=>{if(!D||H.phase!=="ready"||!H.data)return null;const t=H.data.tickets;return Array.isArray(t)&&t.find(c=>c?.ticket_id===X(D))||null},[D,H]),qe=p.useMemo(()=>he?Ie(J,he):null,[J,he]),A=(t,c)=>r({kind:t,text:n(c)}),ye=t=>{t instanceof tn||t?.message!=="session_invalidated"&&(t instanceof sn?A("error",t.status===409?"error.conflict":"error.generic"):A("error","decisions.outcome_unknown"),E())},Pe=async(t,c,w)=>{const m=X(t),S=t.category==="owner_decision"?"owner":t.category==="reconciliation_recovery"?"recovery":"promotion";let v,u,_,$=null,R=null;try{if(S==="owner"){const f=((await Q("/api/owner-decisions")).candidates||[]).find(l=>l?.candidate?.candidate_id===m);if(!f){A("info","decisions.intent_not_pending"),E();return}const C=un({...f.candidate,candidate_evidence_sha256:f.candidate_evidence_sha256},c==="adopt"?"approve_limited_live_canary":"keep_parked");if(!C){A(f.intent?"info":"error",f.intent?"decisions.intent_not_pending":"decisions.intent_unavailable"),E();return}v=f,u=C,_="/api/owner-decisions"}else if(S==="recovery"){const f=((await Q("/api/reconciliation-recovery")).recoveries||[]).find(l=>l?.recovery?.recovery_id===m);if(!f){A("info","decisions.intent_not_pending"),E();return}const C=pn(f,c==="adopt"?"approve":"reject");if(!C){const l=!!(f.confirmation||f.rejection);A(l?"info":"error",l?"decisions.intent_not_pending":"decisions.intent_unavailable"),E();return}v=f,u=C,_="/api/reconciliation-recovery-confirmations"}else{const g=await Q("/api/research-promotion-tickets"),f=(g.tickets||[]).find(l=>l?.ticket_id===m);if(!f){A("info","decisions.intent_not_pending"),E();return}let C=null;if(c==="adopt"){const l=(g.applications||[]).find(I=>I?.ticket_id===m),z=ie(l,!1).find(I=>I.id===w);if(!z){A("error","decisions.intent_unavailable");return}if(C=z,$=z,t.category==="strategy_promotion"&&(R=Ie(l,f),!R)){A("error","decisions.policy_unbound");return}}v=f,u={ticket_id:f.ticket_id,decision:c==="adopt"?"accept":"reject",confirmation:C&&R?{target_platform:C.platform,execution_mode:C.mode,risk_profile:R.risk_profile,...R.policy_revision?{policy_revision:R.policy_revision}:{}}:null,...R?.policy_revision?{expected_policy_revision:R.policy_revision}:{},...C?{selected_account:{platform:C.platform,key:C.key}}:{},expected_proposed_params:f.proposed_params||{},expected_strategy_profile:f.strategy_profile,expected_domain:f.domain},_="/api/research-promotion-decisions"}}catch(g){ye(g);return}const L=V.current.epoch(),K=await mn(S,v,u);if(L!==V.current.epoch())return;if(!K){A("error","decisions.intent_unavailable");return}if(u.mode==="initial_enrollment"){const g=t.initial_enrollment;if(!g||g.candidate_sha256!==u.candidate_sha256||g.facts_sha256!==u.facts_sha256){A("info","decisions.material_changed"),E();return}}if(!_n(t.decision_binding,K)){A("info","decisions.material_changed"),E();return}if(!await $e(t,c,!1,$,R)||L!==V.current.epoch())return;const q=t;if(q.server_time&&t.expires_at&&Te(t.expires_at,q.server_time,oe,Date.now()).state==="expired"){A("info","decisions.intent_not_pending"),E();return}if(te(t))return;const P=V.current.start(K);if(!P)return;const W=`intent:${t.id}`;B(g=>({...g,[W]:!0}));try{const g=await De(_,u.mode==="initial_enrollment"?u:{...u,expected_material_sha256:K.material_sha256,...K.review_sha256?{expected_review_sha256:K.review_sha256}:{}});if(!V.current.current(P))return;const f=await V.current.receive(P,g?.decision_receipt);A(f?"success":"error",f?"decisions.intent_recorded":"error.generic"),E()}catch(g){ye(g)}finally{V.current.current(P)&&B(g=>({...g,[W]:!1}))}},ze=async(t,c)=>{const w=X(t),m=`apply:${w}`;if(!Z.current.acquire(m))return;const S=t;if(S.server_time&&t.expires_at&&Te(t.expires_at,S.server_time,oe,Date.now()).state==="expired"){Z.current.release(m),A("info","decisions.intent_not_pending"),E();return}B(u=>({...u,[m]:!0}));let v=!1;try{const _=((await Q("/api/research-promotion-tickets")).applications||[]).find(L=>L?.ticket_id===w),$=ie(_,!0).find(L=>L.id===c);if(!_||!$||!Fe(_,c)){A("error","decisions.intent_unavailable");return}const R=await Q("/api/admin/runtime-instances");v=!0,await De("/api/research-promotion-applications",{ticket_id:w,selected_account:{platform:$.platform,key:$.key},expected_revision:Number(R.revision)}),A("success","decisions.application_submitted"),E()}catch(u){ye(u)}finally{B(u=>({...u,[m]:!1})),v||Z.current.release(m)}},$e=(t,c,w,m,S)=>{const v=t,u=S?` · ${vn(S.risk_profile,n)}${S.policy_revision?` · ${n("cockpit.policy.revision",{value:S.policy_revision})}`:""}`:"",_=m?`${de(t,n)} · ${m.label} (${m.platform} / ${m.key} / ${m.mode})${u}`:`${de(t,n)}${u}`;return d({title:n(c==="adopt"?"decisions.confirm_adopt_title":"decisions.confirm_decline_title"),target:_,summary:n(w?"decisions.apply_note":"decisions.confirm_body"),body:e.jsx(Ee,{rows:t.diff.map($=>({...$,label:n($.label_key)===$.label_key?$.field:n($.label_key),affectsLive:$.affects_live}))}),consequence:n("decisions.intent_note"),tone:c==="adopt"?"normal":"danger",confirmLabel:n(c==="adopt"?"decisions.confirm_adopt_label":"decisions.confirm_decline_label"),expiresAt:v.server_time?t.expires_at:null,serverTime:v.server_time??null,receivedAt:oe,onExpiry:E})},le=async(t,c)=>{if(!ke||t.status!=="pending"||te(t))return;const w=t.allowed_actions;if(w&&!w.includes(c==="adopt"?"approve":"reject"))return;const m=`confirm:${t.id}`;if(!Z.current.acquire(m))return;const S=`intent:${t.id}`;B(v=>({...v,[S]:!0}));try{const v=t.category==="paper_account_application"&&c==="adopt",u=ie(J,t.category==="paper_account_application"),_=xe(u,ee[t.id]);if(c==="adopt"&&(v||t.category==="strategy_promotion")&&!_){A("error","decisions.intent_unavailable");return}v&&_?await $e(t,c,!0,_,null)&&await ze(t,_.id):await Pe(t,c,_?.id??null)}finally{Z.current.release(m),B(v=>({...v,[S]:!1}))}};function de(t,c){if(ge(t))return c("decisions.initial_enrollment_title");const w=c(t.title_key);return w===t.title_key?t.short_id:w}const He=[{id:"all",label:n("decisions.filter.all")},...Ln.map(t=>({id:t,label:n(`category.${t}`)}))],Ge=()=>{if(!D)return null;const t=D,c=te(t),w=t.status==="pending"&&!c,m=t.diff.map(l=>{const M=n(l.label_key);return{field:l.field,label:M===l.label_key?l.field:M,before:l.before,after:l.after,affectsLive:l.affects_live}}),S=!!h[`intent:${t.id}`],v=!!h[`apply:${X(t)}`],u=S||v,_=t.initial_enrollment??null,$=ge(t),R=$&&(!_||_.readiness!=="awaiting_human_confirmation"||!Array.isArray(_.blocker_codes)||_.blocker_codes.length>0||!["positions","cash","open_orders","recent_executions","local_execution_ledger"].every(l=>_.facts?.surfaces?.[l]?.status==="complete"&&Array.isArray(_.facts?.surfaces?.[l]?.items))),L=t.diff.find(l=>l.field==="strategy"),K=t.presentation?.strategy_profile||(L&&typeof L.after=="string"?L.after:null),q=t,P=q.allowed_actions,W=!P||P.includes("approve"),g=!P||P.includes("reject"),f=q.evidence??(t.evidence_freshness?{evidence_id:null,label_key:null,observed_at:t.evidence_freshness.as_of,valid_until:null,state:t.evidence_freshness.status==="stale"?"stale":t.evidence_freshness.status==="fresh"||t.evidence_freshness.status==="ready"?"current":"unavailable",qualification:"unknown",limitations:[]}:null);let C=null;if(w&&ke&&!($&&R))if(t.category==="credential_maintenance")C=e.jsx("button",{type:"button",className:"button button-secondary",onClick:()=>a({page:"health"}),children:n("decisions.open_health")});else if(t.category==="paper_account_application"){const l=ie(J,!0),M=xe(l,ee[t.id])?.id??"",z=t.application_status==="uncertain",I=!!(M&&J&&Fe(J,M));C=e.jsxs(e.Fragment,{children:[l.length>1&&e.jsxs("label",{className:"decision-account-picker",children:[e.jsx("span",{children:n("decisions.select_account")}),e.jsxs("select",{value:M,onChange:Y=>be(Ve=>({...Ve,[t.id]:Y.target.value})),children:[e.jsxs("option",{value:"",children:[n("decisions.select_account"),"…"]}),l.map(Y=>e.jsx("option",{value:Y.id,children:Y.label},Y.id))]})]}),e.jsxs("div",{className:"inbox-actions",children:[z?e.jsx("p",{className:"decision-note",children:n("decisions.application_uncertain")}):e.jsxs(e.Fragment,{children:[l.length===0?e.jsx("p",{className:"decision-note",children:n("decisions.no_account_options")}):e.jsx("button",{type:"button",className:"button button-primary",disabled:u||!I||!W||Z.current.isLocked(`apply:${X(t)}`),onClick:()=>{le(t,"adopt")},children:n(v?"decisions.submitting":"decisions.adopt_intent")}),e.jsx("button",{type:"button",className:"button button-secondary",disabled:u||!g,onClick:()=>{le(t,"decline")},children:n(S?"decisions.submitting":"decisions.decline_intent")})]}),e.jsx("p",{className:"decision-note",children:n(l.length===0||z?"decisions.intent_note":"decisions.apply_note")})]})]})}else{const l=t.category==="strategy_promotion"?ie(J,!1):[],M=xe(l,ee[t.id])?.id??"",z=t.category==="strategy_promotion"&&!qe;C=e.jsxs(e.Fragment,{children:[l.length>1&&e.jsxs("label",{className:"decision-account-picker",children:[e.jsx("span",{children:n("decisions.select_account")}),e.jsxs("select",{value:M,onChange:I=>be(Y=>({...Y,[t.id]:I.target.value})),children:[e.jsxs("option",{value:"",children:[n("decisions.select_account"),"…"]}),l.map(I=>e.jsx("option",{value:I.id,children:I.label},I.id))]})]}),e.jsxs("div",{className:"inbox-actions",children:[e.jsx("button",{type:"button",className:"button button-primary",disabled:u||!W||t.category==="strategy_promotion"&&(!M||z),onClick:()=>{le(t,"adopt")},children:n(S?"decisions.submitting":"decisions.adopt_intent")}),e.jsx("button",{type:"button",className:"button button-secondary",disabled:u||!g,onClick:()=>{le(t,"decline")},children:n(S?"decisions.submitting":"decisions.decline_intent")}),!W&&e.jsx("p",{className:"decision-note",children:n("cockpit.blocker.not_allowed")}),z&&e.jsx("p",{className:"decision-note",children:n("decisions.policy_unbound")}),e.jsx("p",{className:"decision-note",children:n("decisions.intent_note")})]})]})}return e.jsxs("div",{className:"card inbox-detail",children:[e.jsxs("div",{className:"decision-detail-head",children:[e.jsx("button",{type:"button",className:"button button-secondary inbox-back",onClick:()=>N(null),children:n("common.back")}),e.jsxs("div",{className:"decision-badges",children:[e.jsx(G,{tone:t.category==="reconciliation_recovery"?"warn":"accent",children:n(`category.${t.category}`)}),e.jsx(G,{tone:t.status==="decided"?"ok":c?"unknown":"warn",children:n(`decisions.status.${c?"expired":t.status}`)}),t.affects_live&&e.jsx(G,{tone:"warn",children:n("decisions.col.affects_live")})]}),e.jsx("h2",{className:"card-title",style:{margin:0},children:de(t,n)}),e.jsx("p",{className:"decision-prompt",children:n($?"decisions.prompt.initial_enrollment":`decisions.prompt.${t.category}`)}),e.jsxs("div",{className:"decision-meta",children:[e.jsx("span",{children:we(t)}),t.platform&&e.jsx("span",{children:i.platform(t.platform)}),e.jsx("span",{className:"decision-ref",children:n("decisions.ref",{id:t.short_id})}),t.created_at&&e.jsx("span",{children:n("decisions.created_at",{value:ae(t.created_at,s).text})}),t.expires_at&&e.jsx("span",{children:n("decisions.expires_at",{value:ae(t.expires_at,s).text})}),t.evidence_freshness&&e.jsx(G,{tone:t.evidence_freshness.status==="stale"?"warn":t.evidence_freshness.status==="ready"||t.evidence_freshness.status==="fresh"?"ok":"unknown",children:n(qn(t.evidence_freshness.status))}),Mn(t)&&e.jsx("span",{className:"decision-stale-hint",children:n("decisions.stale_hint")})]})]}),m.length>0&&e.jsxs(e.Fragment,{children:[e.jsx("h3",{className:"decision-section-title",children:n("decisions.diff_title")}),e.jsx(Ee,{rows:m})]}),q.server_time&&t.expires_at&&e.jsx(xn,{expiresAt:t.expires_at,serverTime:q.server_time,receivedAt:oe,onBoundary:()=>{N(null),E()}}),f&&e.jsx(gn,{evidence:f}),q.operation_id&&e.jsx(zn,{operationId:q.operation_id}),$&&e.jsx(Bn,{account:t.account_alias?i.account(t.account_alias,t.platform):null,strategy:K?i.strategy(K):null,platform:t.platform?i.platform(t.platform):null,facts:_?.facts??null,readiness:_?.readiness??null,blockerCodes:_?.blocker_codes??null}),t.category==="reconciliation_recovery"&&!$&&e.jsxs("details",{className:"decision-materials reconciliation-detail",children:[e.jsx("summary",{children:n("reconciliation.materials")}),e.jsx(In,{data:x.phase==="ready"?x.data:null,language:s,t:n,itemId:t.id})]}),t.evidence_freshness?.as_of&&e.jsxs("details",{className:"decision-materials",children:[e.jsx("summary",{children:n("decisions.more_info")}),e.jsx(nn,{value:t.evidence_freshness.as_of})]}),C]})},Ue=()=>x.phase==="loading"?e.jsx("div",{className:"inbox list-only",children:e.jsxs("div",{className:"inbox-list",children:[e.jsx(se,{height:64}),e.jsx(se,{height:64}),e.jsx(se,{height:64})]})}):x.phase==="error"||x.data.status==="read_failed"?e.jsx(Me,{data:x.data,error:x.error,onRetry:x.phase==="error"?x.reload:E}):e.jsx(e.Fragment,{children:ne.length===0?e.jsx(Le,{title:n("decisions.empty_pending")}):e.jsxs("div",{className:`inbox${D?" detail-open":" list-only"}`,children:[e.jsx("div",{className:"inbox-list",role:"list",children:ne.map(t=>{const c=te(t),w=en(t.created_at,s),m=On(t);return e.jsxs("button",{type:"button",role:"listitem",className:`inbox-item${D?.id===t.id?" active":""}${c?" is-expired":""}`,onClick:()=>N(t.id),children:[e.jsx("span",{className:`priority-dot priority-${t.priority}`,"aria-hidden":"true"}),e.jsxs("span",{className:"item-main",children:[e.jsx("span",{className:"item-title",children:de(t,n)}),e.jsxs("span",{className:"item-meta",children:[ge(t)&&e.jsx(G,{tone:"warn",children:n("category.reconciliation_recovery")}),t.platform&&e.jsx("span",{children:i.platform(t.platform)}),e.jsx("span",{children:we(t)})]}),(w||m)&&e.jsxs("span",{className:"item-meta item-meta-secondary",children:[w&&e.jsx("span",{children:w}),m&&e.jsx("span",{className:"decision-stale-hint",children:n(m)})]})]}),e.jsx(G,{tone:c?"unknown":"warn",children:n(`decisions.status.${c?"expired":t.status}`)})]},t.id)})}),D&&Ge()]})});return e.jsxs("div",{className:"page",children:[e.jsxs("div",{className:"page-header",children:[e.jsx("h1",{className:"page-title",children:n("decisions.title")}),e.jsx("div",{className:"page-header-actions",children:e.jsx("button",{type:"button",className:"button button-secondary",onClick:E,children:n("common.refresh")})})]}),e.jsxs("div",{className:"decisions-filters",children:[e.jsx("div",{className:"decisions-view-row",children:e.jsxs("div",{className:"segmented",role:"group","aria-label":n("decisions.title"),children:[e.jsxs("button",{type:"button","aria-pressed":j==="pending",className:`segment${j==="pending"?" active":""}`,onClick:()=>F("pending"),children:[n("decisions.tab.pending"),Ne>0&&e.jsx("span",{className:"segment-sub",children:Ne})]}),e.jsx("button",{type:"button","aria-pressed":j==="decided",className:`segment${j==="decided"?" active":""}`,onClick:()=>F("decided"),children:n("decisions.tab.decided")})]})}),e.jsx("div",{className:"decisions-category-row",children:e.jsx(hn,{id:"decisions",items:He,active:o,onChange:t=>k(t),ariaLabel:n("decisions.title")})})]}),j==="pending"&&fe.length>0&&e.jsxs("div",{className:"decision-degraded-note",role:"status","data-state":"partial","data-degraded-count":fe.length,children:[e.jsx(We,{status:"partial"}),e.jsxs("div",{className:"decision-degraded-body",children:[e.jsx("span",{children:n("decisions.partial_notice")}),e.jsx("ul",{className:"decision-degraded-sources","aria-label":n("decisions.partial_affected"),children:fe.map(t=>e.jsxs("li",{"data-source":t.source,children:[e.jsx("strong",{children:n(Nn(t.source))}),e.jsxs("span",{children:[" · ",n(`state.${t.status}`)," — ",n(wn(t.status))]})]},t.source))})]})]}),e.jsx("div",{id:"decisions-panel",role:"tabpanel","aria-labelledby":`decisions-tab-${o}`,tabIndex:0,children:j==="pending"?Ue():e.jsx(Pn,{epoch:b,category:o})}),y&&e.jsx(ln,{request:y,onResolve:T})]})}export{Wn as default};
" },
+  "/v2/assets/Dialog-Nx1EjiqV.js": { contentType: "text/javascript; charset=utf-8", base64: "import{u as x,j as n,B as D,O as E,r as f}from"./index-CwQsWZdm.js";import{R}from"./runtime_daily_contract-xW43mZQY.js";import{e as I}from"./cockpit-Cax-GxP0.js";function K(e){const a={};Object.prototype.hasOwnProperty.call(e.overrides,"strategy_profile")&&(a.strategy_profile=e.overrides.strategy_profile??null),Object.prototype.hasOwnProperty.call(e.overrides,"dca_mode")&&(a.dca_mode=e.overrides.dca_mode??null),Object.prototype.hasOwnProperty.call(e.overrides,"dca_base_investment_usd")&&(a.dca_base_investment_usd=e.overrides.dca_base_investment_usd??null),Object.prototype.hasOwnProperty.call(e.overrides,"income_layer_enabled")&&(a.income_layer_enabled=e.overrides.income_layer_enabled??null),e.overrides.option_overlay_enabled===null&&(a.option_overlay_enabled=null),Object.prototype.hasOwnProperty.call(e.overrides,"reserved_cash_floor")&&(a.reserved_cash_floor=e.overrides.reserved_cash_floor??null),Object.prototype.hasOwnProperty.call(e.overrides,"reserved_cash_ratio")&&(a.reserved_cash_ratio=e.overrides.reserved_cash_ratio??null);const l={expected_draft_revision:e.expectedDraftRevision,identity:e.identity,overrides:a};return e.acknowledgeIdentityConflict&&(l.acknowledge_identity_conflict=!0),l}function U(e,a){const l=e.candidate_evidence_sha256||e.owner_decision?.candidate_evidence_sha256;return!e.candidate_id||!/^[a-f0-9]{64}$/.test(String(l||""))||!["approve_limited_live_canary","keep_parked"].includes(a)?null:{candidate_id:e.candidate_id,candidate_evidence_sha256:l,decision:a}}function F(e,a="approve"){const l=e?.recovery||{};return a!=="approve"&&a!=="reject"||l.mode!=="initial_enrollment"||e.freshness?.data_status!=="ready"||e.confirmation||e.rejection||l.readiness!=="awaiting_human_confirmation"||!Array.isArray(l.blocker_codes)||l.blocker_codes.length||typeof l.recovery_id!="string"||!l.recovery_id||!/^[a-f0-9]{64}$/.test(String(l.candidate_sha256||""))||!/^[a-f0-9]{64}$/.test(String(l.facts_sha256||""))?null:{mode:"initial_enrollment",decision:a,recovery_id:l.recovery_id,candidate_sha256:l.candidate_sha256,facts_sha256:l.facts_sha256}}function Y(e,a="approve"){if(e?.recovery?.mode==="initial_enrollment")return F(e,a);const l=e.recovery||{};return a!=="approve"&&a!=="reject"||e.freshness?.data_status!=="ready"||e.confirmation||e.rejection||l.readiness!=="awaiting_human_confirmation"||!Array.isArray(l.blocker_codes)||l.blocker_codes.length||!/^[a-f0-9]{64}$/.test(String(l.candidate_sha256||""))||l.dual_review?.evidence_binding_sha256!==l.candidate_sha256?null:{decision:a,recovery_id:l.recovery_id,candidate_sha256:l.candidate_sha256,dual_review_binding_sha256:l.dual_review.evidence_binding_sha256}}function V(){const e=new Set;return{acquire(a){return e.has(a)?!1:(e.add(a),!0)},release(a){e.delete(a)},isLocked(a){return e.has(a)},hasAny(a){return a.some(l=>e.has(l))},hasAnyWithPrefixes(a){return[...e].some(l=>a.some(r=>l.startsWith(r)))},clear(){e.clear()}}}function L(e){return e?e.status==="rejected":!0}const h=/^[0-9a-f]{64}$/,p=e=>!!(e&&typeof e=="object"&&!Array.isArray(e));function b(e){if(e===null||typeof e=="string"||typeof e=="boolean"||typeof e=="number"&&Number.isFinite(e))return JSON.stringify(e);if(Array.isArray(e))return`[${e.map(b).join(",")}]`;if(!p(e))throw new Error("human_decision_material_invalid");return`{${Object.keys(e).sort().map(a=>`${JSON.stringify(a)}:${b(e[a])}`).join(",")}}`}async function k(e){const a=await crypto.subtle.digest("SHA-256",new TextEncoder().encode(b(e)));return[...new Uint8Array(a)].map(l=>l.toString(16).padStart(2,"0")).join("")}function $(e){const a=e?.decision_binding;return a?.kind==="promotion"&&a.subject_id===e.ticket_id&&typeof a.material_sha256=="string"&&h.test(a.material_sha256)&&(a.review_binding==null||a.review_binding.schema_version==="qsl_promotion_review_binding.v2"&&typeof a.review_binding.review_sha256=="string"&&h.test(a.review_binding.review_sha256))}function W(e,a){if(!p(e)||e.kind!==a.kind||e.subject_id!==a.subject_id||e.material_sha256!==a.material_sha256)return!1;const l=e.review_binding;return a.review_sha256===null?l==null:p(l)&&l.schema_version==="qsl_promotion_review_binding.v2"&&l.review_sha256===a.review_sha256}async function Z(e,a,l){try{const r=a?.decision_binding;let i,t,_,o=null;if(e==="owner"){if(i=l.candidate_id,t=null,_={decision:l.decision},!["approve_limited_live_canary","keep_parked"].includes(l.decision)||a.candidate?.candidate_id!==i||a.candidate_evidence_sha256!==l.candidate_evidence_sha256)return null}else if(e==="recovery"){if(i=l.recovery_id,!["approve","reject"].includes(l.decision)||a.recovery?.recovery_id!==i||a.recovery.candidate_sha256!==l.candidate_sha256)return null;if(l.mode==="initial_enrollment"){if(a.recovery.mode!=="initial_enrollment"||a.recovery.facts_sha256!==l.facts_sha256||typeof l.facts_sha256!="string"||!h.test(l.facts_sha256))return null;t={mode:"initial_enrollment",recovery_id:i,candidate_sha256:l.candidate_sha256,facts_sha256:l.facts_sha256}}else{if(a.recovery.dual_review?.evidence_binding_sha256!==l.dual_review_binding_sha256)return null;t={recovery_id:i,candidate_sha256:l.candidate_sha256,dual_review_binding_sha256:l.dual_review_binding_sha256}}_={decision:l.decision}}else{if(i=l.ticket_id,!$(a)||a.ticket_id!==i||!["accept","reject"].includes(l.decision))return null;if(t=Object.fromEntries(["ticket_id","strategy_profile","domain","proposed_params","shadow_passed","shadow_evidence_kind"].map(m=>[m,a[m]])),r.review_binding!=null){const m={schema_version:"qsl_promotion_review_material.v2",...t,...Object.fromEntries(["drift_status","drift_score","budget","search_iterations","suggested_risk_profile","notification_subject","notification_body","notes"].map(g=>[g,a[g]])),research_summary:a.research_summary||null};if(o=await k(m),o!==r.review_binding.review_sha256)return null}const d=l.selected_account??null,u=l.confirmation??null;if(l.decision==="accept"&&(!p(d)||!p(u)||d.platform!==u.target_platform))return null;_={selected_account:d,confirmation:u}}const s=e==="owner"?l.candidate_evidence_sha256:await k(t);return typeof i!="string"||!i||typeof s!="string"||!h.test(s)||r?.kind!==e||r.subject_id!==i||r.material_sha256!==s?null:JSON.parse(JSON.stringify({kind:e,subject_id:i,material_sha256:s,review_sha256:o,action:l.decision,target:_}))}catch{return null}}async function C(e,a){try{if(!p(a)||!["qsl_human_decision_receipt.v1","qsl_human_decision_receipt.v2"].includes(a.schema_version)||a.kind!==e.kind||a.subject_id!==e.subject_id||a.material_sha256!==e.material_sha256||a.action!==e.action||b(a.target)!==b(e.target)||a.no_order!==!0||a.execution_authority_granted!==!1||typeof a.decided_by!="string"||!a.decided_by||a.decided_by.length>100||/[\u0000-\u001f\u007f]/.test(a.decided_by)||typeof a.decided_at!="string"||a.decided_at.length>40||!Number.isFinite(Date.parse(a.decided_at))||/[\u0000-\u001f\u007f]/.test(a.decided_at)||typeof a.receipt_sha256!="string"||!h.test(a.receipt_sha256))return!1;const l=a.schema_version==="qsl_human_decision_receipt.v2";if(l!==!!e.review_sha256||l&&(e.kind!=="promotion"||a.review_binding?.schema_version!=="qsl_promotion_review_binding.v2"||a.review_binding.review_sha256!==e.review_sha256))return!1;const r={schema_version:a.schema_version,...l?{review_binding:{schema_version:"qsl_promotion_review_binding.v2",review_sha256:e.review_sha256}}:{},kind:e.kind,subject_id:e.subject_id,material_sha256:e.material_sha256,action:e.action,target:e.target,decided_at:a.decided_at,decided_by:a.decided_by,no_order:!0,execution_authority_granted:!1};return b(a)===b({...r,receipt_sha256:await k(r)})}catch{return!1}}function ee(){const e=new Map,a=new Map,l=i=>`${i.kind}:${i.subject_id}:${i.material_sha256}`;let r=0;return{epoch(){return r},clear(){r++,e.clear(),a.clear()},entries(){return[...e.values()].map(i=>JSON.parse(JSON.stringify(i)))},start(i){const t=l(i);return e.has(t)?null:(e.set(t,{expected:JSON.parse(JSON.stringify(i)),status:"unresolved",receipt:null,queueConfirmed:!1}),{id:t,generation:r})},current(i){return i.generation===r&&e.has(i.id)&&(i.sequence===void 0||a.get(i.id)===i.sequence)},async receive(i,t,_){const o=e.get(i.id);if(!o||!this.current(i))return!1;const s=await C(o.expected,t);return this.current(i)?!s||o.receipt&&o.receipt.receipt_sha256!==t.receipt_sha256?(o.status="unresolved",o.queueConfirmed=!1,!1):(o.receipt=JSON.parse(JSON.stringify(t)),o.queueConfirmed=_??o.queueConfirmed,o.status=o.queueConfirmed?"recorded":"unresolved",!0):!1},beginRead(i){const t=l(i),_=(a.get(t)||0)+1;return a.set(t,_),{id:t,generation:r,sequence:_}},async readback(i,t,_){const o=e.get(i.id),s=t?.decision_readback,d=()=>this.current(i)&&a.get(i.id)===i.sequence;if(!o||!d())return!1;if(t?.ok!==!0||s?.schema_version!=="qsl_human_decision_readback.v1"||s.source!=="durable_human_decision_record"||s.kind!==o.expected.kind||s.subject_id!==o.expected.subject_id||s.requested_material_sha256!==o.expected.material_sha256||typeof s.observed_at!="string"||!Number.isFinite(Date.parse(s.observed_at))||s.lookup_status!=="found")return o.status="unresolved",o.queueConfirmed=!1,!1;const u=await C(o.expected,s.receipt);return d()?this.receive(i,u?s.receipt:null,_):!1},readFailed(i){if(!this.current(i)||a.get(i.id)!==i.sequence)return!1;const t=e.get(i.id);return t.status="unresolved",t.queueConfirmed=!1,!0}}}const T=Object.freeze([Object.freeze({option_scope:"paper",payload_scope:"PAPER"}),Object.freeze({option_scope:"HK",payload_scope:"HK"}),Object.freeze({option_scope:"sg",payload_scope:"SG"})]);Object.freeze(T.map(e=>e.option_scope));Object.freeze(T.map(e=>e.payload_scope));const P=Object.freeze(["max_finance_amount","remaining_finance_amount","init_margin","maintenance_margin","margin_call","buy_power"]);Object.freeze(["currency",...P,"risk_level"]);const A=[{profile:"tqqq_growth_income",label:"纳斯达克增长收益",label_en:"NASDAQ Growth Income",label_zh:"纳斯达克增长收益",domain:"us_equity",runtime_enabled:!0,income_layer_enabled:!0,option_overlay_enabled:!1,combo_enabled:!1,lifecycle_stage:"runtime_enabled",can_switch_live:!0,allowed_execution_modes:["paper","dry_run","live"],blocked_live_reason:"",live_continuity:{eligible:!0,allowed_platforms:["ibkr"]},income_layer_start_usd:"250000",income_layer_max_ratio:"0.55",income_layer_allocations:{SCHD:.3,DGRO:.2,SGOV:.4,SPYI:.08,QQQI:.02}},{profile:"soxl_soxx_trend_income",label:"半导体趋势收益",label_en:"Semiconductor Trend Income",label_zh:"半导体趋势收益",domain:"us_equity",runtime_enabled:!0,income_layer_enabled:!0,option_overlay_enabled:!1,combo_enabled:!1,lifecycle_stage:"runtime_enabled",can_switch_live:!0,allowed_execution_modes:["paper","dry_run","live"],blocked_live_reason:"",live_continuity:{eligible:!0,allowed_platforms:["longbridge","ibkr","schwab"]},income_layer_start_usd:"150000",income_layer_max_ratio:"0.95",income_layer_allocations:{SCHD:.15,DGRO:.1,SGOV:.7,SPYI:.04,QQQI:.01}},{profile:"soxl_soxx_core_only_p2_v7_longterm_compounding_cash_reserve",label:"SOXL/SOXX 核心复利（现金保留）",label_en:"SOXL/SOXX Core Compounding (Cash Reserve)",label_zh:"SOXL/SOXX 核心复利（现金保留）",domain:"us_equity",runtime_enabled:!1,income_layer_enabled:!1,option_overlay_enabled:!1,combo_enabled:!1,lifecycle_stage:"research_active",can_switch_live:!1,allowed_execution_modes:["paper","dry_run"],blocked_live_reason:"research_only_named_profile",live_continuity:{eligible:!1,allowed_platforms:[]},research_candidate_identity:{candidate_id:"soxl_soxx_core_only_p2_v7_longterm_compounding_cash_reserve",config_sha256:"843ab4e93e81985c2b3becc61a2f0b971508ccf25afa59acf402e75f574514d1"}},{profile:"nasdaq_sp500_smart_dca",label:"纳指标普定投",label_en:"NASDAQ/S&P 500 DCA",label_zh:"纳指标普定投",domain:"us_equity",runtime_enabled:!1,income_layer_enabled:!1,option_overlay_enabled:!1,combo_enabled:!1,lifecycle_stage:"research_active",can_switch_live:!1,allowed_execution_modes:["paper","dry_run"],blocked_live_reason:"missing_current_promotion_evidence_and_preauthorized_autonomy_policy",live_continuity:{eligible:!1,allowed_platforms:[]},dca_enabled:!0,dca_default_mode:"fixed",dca_default_base_investment_usd:"1000"},{profile:"ibit_smart_dca",label:"IBIT比特币定投",label_en:"IBIT Bitcoin DCA",label_zh:"IBIT比特币定投",domain:"us_equity",runtime_enabled:!0,income_layer_enabled:!1,option_overlay_enabled:!1,combo_enabled:!1,lifecycle_stage:"runtime_enabled",can_switch_live:!0,allowed_execution_modes:["paper","dry_run","live"],blocked_live_reason:"",live_continuity:{eligible:!0,allowed_platforms:["firstrade"]},dca_enabled:!0,dca_default_mode:"fixed",dca_default_base_investment_usd:"1000"},{profile:"global_etf_rotation",label:"全球ETF轮动",label_en:"Global ETF Rotation",label_zh:"全球ETF轮动",domain:"us_equity",runtime_enabled:!1,income_layer_enabled:!0,option_overlay_enabled:!1,combo_enabled:!1,frozen:!0,lifecycle_stage:"research_active",can_switch_live:!1,allowed_execution_modes:["dry_run"],blocked_live_reason:"research_backtest_only_requires_evidence_package",live_continuity:{eligible:!0,allowed_platforms:["ibkr"]},income_layer_start_usd:"500000",income_layer_max_ratio:"0.15",income_layer_allocations:{SCHD:.4,DGRO:.25,SGOV:.3,SPYI:.05}},{profile:"russell_top50_leader_rotation",label:"罗素Top50领涨",label_en:"Russell Top50 Leaders",label_zh:"罗素Top50领涨",domain:"us_equity",runtime_enabled:!0,income_layer_enabled:!0,option_overlay_enabled:!1,combo_enabled:!1,lifecycle_stage:"runtime_enabled",can_switch_live:!0,allowed_execution_modes:["paper","dry_run","live"],blocked_live_reason:"",live_continuity:{eligible:!0,allowed_platforms:["ibkr","longbridge"]},income_layer_start_usd:"300000",income_layer_max_ratio:"0.25",income_layer_allocations:{SCHD:.45,DGRO:.3,SGOV:.25}},{profile:"tecl_xlk_trend_income",label:"TECL/XLK趋势收益",label_en:"TECL/XLK Trend Income",label_zh:"TECL/XLK趋势收益",domain:"us_equity",runtime_enabled:!1,income_layer_enabled:!1,option_overlay_enabled:!1,combo_enabled:!1,frozen:!0,lifecycle_stage:"research_active",can_switch_live:!1,allowed_execution_modes:["dry_run"],blocked_live_reason:"failed_promotion_vs_live_profiles",live_continuity:{eligible:!1,allowed_platforms:[]}},{profile:"us_equity_combo",label:"美股核心收益组合",label_en:"US Core Income Combo",label_zh:"美股核心收益组合",domain:"us_equity",runtime_enabled:!1,income_layer_enabled:!0,option_overlay_enabled:!1,combo_enabled:!0,lifecycle_stage:"shadow_active",can_switch_live:!1,allowed_execution_modes:["paper","dry_run"],blocked_live_reason:"shadow_candidate_requires_evidence_package",live_continuity:{eligible:!1,allowed_platforms:[]},combo_mode:"dynamic",income_layer_start_usd:"300000",income_layer_max_ratio:"0.25",income_layer_allocations:{SCHD:.25,DGRO:.25,SGOV:.2,SPYI:.15,QQQI:.15}},{profile:"us_equity_combo_core",label:"美股核心组合",label_en:"US Core Combo",label_zh:"美股核心组合",domain:"us_equity",runtime_enabled:!1,income_layer_enabled:!1,option_overlay_enabled:!1,combo_enabled:!0,lifecycle_stage:"shadow_active",can_switch_live:!1,allowed_execution_modes:["paper","dry_run"],blocked_live_reason:"shadow_candidate_requires_evidence_package",live_continuity:{eligible:!1,allowed_platforms:[]},combo_mode:"dynamic"},{profile:"us_equity_combo_leveraged",label:"美股加速组合",label_en:"US Alpha Combo",label_zh:"美股加速组合",domain:"us_equity",runtime_enabled:!1,income_layer_enabled:!1,option_overlay_enabled:!1,combo_enabled:!0,lifecycle_stage:"shadow_active",can_switch_live:!1,allowed_execution_modes:["paper","dry_run"],blocked_live_reason:"shadow_candidate_requires_evidence_package",live_continuity:{eligible:!1,allowed_platforms:[]},combo_mode:"dynamic"},{profile:"hk_global_etf_tactical_rotation",label:"港股ETF战术轮动",label_en:"HK ETF Tactical Rotation",label_zh:"港股ETF战术轮动",domain:"hk_equity",runtime_enabled:!1,income_layer_enabled:!1,option_overlay_enabled:!1,combo_enabled:!1,frozen:!0,lifecycle_stage:"research_active",can_switch_live:!1,allowed_execution_modes:["dry_run"],blocked_live_reason:"research_backtest_only_requires_evidence_package",live_continuity:{eligible:!1,allowed_platforms:[]}},{profile:"hk_low_vol_dividend_quality_snapshot",label:"港股红利质量",label_en:"HK Dividend Quality",label_zh:"港股红利质量",domain:"hk_equity",runtime_enabled:!1,income_layer_enabled:!1,option_overlay_enabled:!1,combo_enabled:!1,frozen:!0,lifecycle_stage:"research_active",can_switch_live:!1,allowed_execution_modes:["paper","dry_run"],blocked_live_reason:"missing_current_promotion_evidence_and_preauthorized_autonomy_policy",live_continuity:{eligible:!1,allowed_platforms:[]}},{profile:"hk_equity_combo",label:"港股恒生组合",label_en:"HK Core Combo",label_zh:"港股恒生组合",domain:"hk_equity",runtime_enabled:!1,income_layer_enabled:!1,option_overlay_enabled:!1,combo_enabled:!0,frozen:!0,lifecycle_stage:"research_active",can_switch_live:!1,allowed_execution_modes:["dry_run"],blocked_live_reason:"research_backtest_only_requires_evidence_package",live_continuity:{eligible:!1,allowed_platforms:[]},combo_mode:"dynamic"},{profile:"cn_industry_etf_rotation",label:"A股行业ETF轮动",label_en:"CN Industry ETF Rotation",label_zh:"A股行业ETF轮动",domain:"cn_equity",runtime_enabled:!1,income_layer_enabled:!1,option_overlay_enabled:!1,combo_enabled:!1,frozen:!0,lifecycle_stage:"research_active",can_switch_live:!1,allowed_execution_modes:["paper","dry_run"],blocked_live_reason:"missing_current_promotion_evidence_and_preauthorized_autonomy_policy",live_continuity:{eligible:!1,allowed_platforms:[]}},{profile:"cn_industry_etf_rotation_aggressive",label:"A股ETF轮动",label_en:"CN ETF Rotation",label_zh:"A股ETF轮动",domain:"cn_equity",runtime_enabled:!1,income_layer_enabled:!1,option_overlay_enabled:!1,combo_enabled:!1,frozen:!0,lifecycle_stage:"live_candidate",can_switch_live:!1,allowed_execution_modes:["paper","dry_run"],blocked_live_reason:"live_candidate_requires_evidence_package",live_continuity:{eligible:!1,allowed_platforms:[]}},{profile:"cn_index_etf_tactical_rotation",label:"A股宽基ETF战术轮动",label_en:"CN Index ETF Tactical Rotation",label_zh:"A股宽基ETF战术轮动",domain:"cn_equity",runtime_enabled:!1,income_layer_enabled:!1,option_overlay_enabled:!1,combo_enabled:!1,frozen:!0,lifecycle_stage:"research_active",can_switch_live:!1,allowed_execution_modes:["dry_run"],blocked_live_reason:"research_backtest_only_requires_evidence_package",live_continuity:{eligible:!1,allowed_platforms:[]}},{profile:"cn_chinext_tactical_rotation",label:"创业板战术轮动",label_en:"CN ChiNext Tactical Rotation",label_zh:"创业板战术轮动",domain:"cn_equity",runtime_enabled:!1,income_layer_enabled:!1,option_overlay_enabled:!1,combo_enabled:!1,frozen:!0,lifecycle_stage:"research_active",can_switch_live:!1,allowed_execution_modes:["dry_run"],blocked_live_reason:"research_backtest_only_requires_evidence_package",live_continuity:{eligible:!1,allowed_platforms:[]}},{profile:"cn_chinext_growth_momentum_quality",label:"创业板成长动量质量",label_en:"CN ChiNext Growth Momentum Quality",label_zh:"创业板成长动量质量",domain:"cn_equity",runtime_enabled:!1,income_layer_enabled:!1,option_overlay_enabled:!1,combo_enabled:!1,frozen:!0,lifecycle_stage:"research_active",can_switch_live:!1,allowed_execution_modes:["dry_run"],blocked_live_reason:"research_backtest_only_requires_evidence_package",live_continuity:{eligible:!1,allowed_platforms:[]}},{profile:"cn_dividend_quality_snapshot",label:"A股红利质量",label_en:"CN Dividend Quality",label_zh:"A股红利质量",domain:"cn_equity",runtime_enabled:!1,income_layer_enabled:!1,option_overlay_enabled:!1,combo_enabled:!1,frozen:!0,lifecycle_stage:"research_active",can_switch_live:!1,allowed_execution_modes:["dry_run"],blocked_live_reason:"research_backtest_only_requires_evidence_package",live_continuity:{eligible:!1,allowed_platforms:[]}},{profile:"cn_chinext_growth_momentum_quality_snapshot",label:"创业板成长质量快照",label_en:"CN ChiNext Growth Quality Snapshot",label_zh:"创业板成长质量快照",domain:"cn_equity",runtime_enabled:!1,income_layer_enabled:!1,option_overlay_enabled:!1,combo_enabled:!1,frozen:!0,lifecycle_stage:"research_active",can_switch_live:!1,allowed_execution_modes:["dry_run"],blocked_live_reason:"research_backtest_only_requires_evidence_package",live_continuity:{eligible:!1,allowed_platforms:[]}},{profile:"cn_star_growth_momentum_quality",label:"科创板成长动量质量",label_en:"CN STAR Growth Momentum Quality",label_zh:"科创板成长动量质量",domain:"cn_equity",runtime_enabled:!1,income_layer_enabled:!1,option_overlay_enabled:!1,combo_enabled:!1,frozen:!0,lifecycle_stage:"research_active",can_switch_live:!1,allowed_execution_modes:["dry_run"],blocked_live_reason:"research_backtest_only_requires_evidence_package",live_continuity:{eligible:!1,allowed_platforms:[]}},{profile:"cn_equity_combo",label:"A股进取组合",label_en:"CN Alpha Combo",label_zh:"A股进取组合",domain:"cn_equity",runtime_enabled:!1,income_layer_enabled:!1,option_overlay_enabled:!1,combo_enabled:!0,frozen:!0,lifecycle_stage:"research_active",can_switch_live:!1,allowed_execution_modes:["dry_run"],blocked_live_reason:"research_backtest_only_requires_evidence_package",live_continuity:{eligible:!1,allowed_platforms:[]},combo_mode:"dynamic"},{profile:"crypto_live_pool_rotation",label:"加密池轮动",label_en:"Crypto Pool Rotation",label_zh:"加密池轮动",domain:"crypto",runtime_enabled:!1,income_layer_enabled:!1,option_overlay_enabled:!1,combo_enabled:!1,lifecycle_stage:"research_active",can_switch_live:!1,allowed_execution_modes:["paper","dry_run"],blocked_live_reason:"missing_current_promotion_evidence_and_preauthorized_autonomy_policy",live_continuity:{eligible:!0,allowed_platforms:["binance"]}},{profile:"crypto_btc_dca",label:"BTC定投",label_en:"BTC DCA",label_zh:"BTC定投",domain:"crypto",runtime_enabled:!1,income_layer_enabled:!1,option_overlay_enabled:!1,combo_enabled:!1,lifecycle_stage:"shadow_active",can_switch_live:!1,allowed_execution_modes:["paper","dry_run"],blocked_live_reason:"shadow_candidate_requires_evidence_package",live_continuity:{eligible:!1,allowed_platforms:[]}},{profile:"crypto_trend_rotation",label:"山寨趋势轮动",label_en:"Altcoin Trend",label_zh:"山寨趋势轮动",domain:"crypto",runtime_enabled:!1,income_layer_enabled:!1,option_overlay_enabled:!1,combo_enabled:!1,lifecycle_stage:"research_active",can_switch_live:!1,allowed_execution_modes:["dry_run"],blocked_live_reason:"research_backtest_only_requires_evidence_package",live_continuity:{eligible:!1,allowed_platforms:[]}},{profile:"crypto_equity_combo",label:"加密动量组合",label_en:"Crypto Core Combo",label_zh:"加密动量组合",domain:"crypto",runtime_enabled:!1,income_layer_enabled:!1,option_overlay_enabled:!1,combo_enabled:!0,lifecycle_stage:"research_active",can_switch_live:!1,allowed_execution_modes:["dry_run"],blocked_live_reason:"research_backtest_only_requires_evidence_package",live_continuity:{eligible:!1,allowed_platforms:[]},combo_mode:"dynamic"}];R.platform;const G=new Set(A.map(e=>e.profile));new Map(A.filter(e=>G.has(e.profile)).map(e=>[e.profile,{label_zh:e.label_zh,label_en:e.label_en}]));function B(e){return(e?.application_preparation?.account_options||[]).filter(a=>a?.platform==="longbridge"&&a?.broker_environment==="paper"&&typeof a.key=="string"&&a.key.trim()).map(a=>({id:`${a.platform}:${a.key}`,label:typeof a.label=="string"&&a.label.trim()?a.label:String(a.key)}))}function Q(e){const a=e?.application_preparation?.blocker_codes;return Array.isArray(a)&&a.length>0}function ae(e,a){if(!e||!L(e.application))return!1;const l=e.application_preparation||{};return Q(e)||l.preflight_status!=="ready"||!l.preview_request?!1:B(e).some(r=>r.id===a)}function le(e,a,l){if(e!=="schwab"||a!=="fresh"||!l||typeof l!="object")return null;const r=l;if(Object.keys(r).length!==2||!Object.prototype.hasOwnProperty.call(r,"value")||!Object.prototype.hasOwnProperty.call(r,"source_tag"))return null;const i=r.value;if(r.source_tag!=="securitiesAccount.type"||typeof i!="string"||i.length<1||i.length>32)return null;for(const _ of i)if(!(_>="A"&&_<="Z"||_>="a"&&_<="z"||_==="_"))return null;return i}function ie(e){return e?.floorTouched===!0||e?.clearFloor===!0||e?.ratioTouched===!0||e?.clearRatio===!0||typeof e?.cashMode=="string"&&e.cashMode!==""}function H(e){if(typeof e!="string"||e.length>32||!/^(?:0|[1-9]\d*)(?:\.\d+)?$/.test(e))return null;const[a,l=""]=e.split(".");return a==="0"||a==="1"&&(l===""||/^0+$/.test(l))?e:null}function ne(e){const a=e.trim();if(!/^\d+(?:\.\d+)?$/.test(a))return null;const[l,r=""]=a.split("."),i=l.replace(/^0+(?=\d)/,"")||"0";if(i.length>3||i.length===3&&i!=="100"||i==="100"&&/[1-9]/.test(r))return null;const t=`${i}${r}`.replace(/^0+(?=\d)/,"")||"0",_=r.length+2,o=t.padStart(_+1,"0"),s=o.length-_,d=o.slice(0,s).replace(/^0+(?=\d)/,"")||"0",u=o.slice(s).replace(/0+$/,"");return H(u?`${d}.${u}`:d)}function O({value:e}){const a=x();return e==null?n.jsx("span",{className:"flat",children:a("decisions.not_set")}):typeof e=="boolean"?n.jsx(n.Fragment,{children:e?"✓":"✕"}):n.jsx("span",{className:"num",children:String(e)})}function te({rows:e}){const a=x();return n.jsx("div",{className:"table-wrap",children:n.jsxs("table",{className:"data-table",children:[n.jsx("thead",{children:n.jsxs("tr",{children:[n.jsx("th",{children:a("decisions.col.field")}),n.jsx("th",{children:a("decisions.col.current")}),n.jsx("th",{children:a("decisions.col.proposed")}),n.jsx("th",{children:a("decisions.col.affects_live")})]})}),n.jsx("tbody",{children:e.map(l=>n.jsxs("tr",{children:[n.jsx("td",{title:l.label!==l.field?l.field:void 0,children:l.label}),n.jsx("td",{children:n.jsx(O,{value:l.before})}),n.jsx("td",{children:n.jsx(O,{value:l.after})}),n.jsx("td",{className:l.affectsLive?"diff-affects-live":"",children:n.jsx(D,{tone:l.affectsLive?"warn":"unknown",children:l.affectsLive?a("decisions.affects_live_required"):a("decisions.affects_live_none")})})]},l.field))})]})})}function re({items:e}){return n.jsx("ul",{className:"timeline",children:e.map(a=>n.jsxs("li",{children:[n.jsx("div",{children:a.title}),a.detail&&n.jsx("div",{style:{color:"var(--muted)",fontSize:13},children:a.detail}),n.jsx("div",{className:"timeline-time",children:n.jsx(E,{value:a.time})})]},a.id))})}function oe({request:e,onResolve:a}){const l=x(),r=f.useRef(null),i=f.useRef(null),[t,_]=f.useState(!1),[o,s]=f.useState(""),[d,u]=f.useState(()=>Date.now()),m=f.useRef(!1);f.useEffect(()=>{i.current?.focus()},[]),f.useEffect(()=>{if(!e.expiresAt)return;u(Date.now());const c=window.setInterval(()=>u(Date.now()),1e3);return()=>window.clearInterval(c)},[e.expiresAt]);const y=(e.expiresAt?I(e.expiresAt,e.serverTime??null,e.receivedAt??new Date().toISOString(),d):{state:"none"}).state==="expired";f.useEffect(()=>{!y||m.current||(m.current=!0,e.onExpiry?.())},[y,e]);const w=!e.typeToConfirm||o.trim()===e.typeToConfirm.expected,q=!e.ackLabel||t,z=w&&q&&!y,N=c=>{if(c.key==="Escape"){c.preventDefault(),a(!1);return}if(c.key!=="Tab")return;const v=r.current?.querySelectorAll('button:not(:disabled), [href], input:not(:disabled), select:not(:disabled), textarea:not(:disabled), [tabindex]:not([tabindex="-1"])');if(!v?.length)return;const j=v[0],S=v[v.length-1];c.shiftKey&&document.activeElement===j?(c.preventDefault(),S.focus()):!c.shiftKey&&document.activeElement===S&&(c.preventDefault(),j.focus())};return n.jsx("div",{className:"dialog-backdrop",onMouseDown:c=>{c.target===c.currentTarget&&a(!1)},children:n.jsxs("div",{className:"dialog",role:"dialog","aria-modal":"true","aria-labelledby":"confirm-title",ref:r,onKeyDown:N,children:[n.jsx("h2",{id:"confirm-title",children:e.title}),e.target&&n.jsx("p",{className:"dialog-target",children:e.target}),e.summary&&n.jsx("div",{className:"dialog-summary",children:e.summary}),e.body,e.consequence&&n.jsx("p",{className:`dialog-consequence ${e.tone==="danger"?"danger":""}`,children:e.consequence}),e.expiresAt&&n.jsx("p",{className:`dialog-consequence ${y?"danger":""}`,role:y?"alert":void 0,children:y?n.jsxs(n.Fragment,{children:[l("cockpit.expiry.expired")," · ",l("cockpit.expiry.boundary")]}):l("cockpit.expiry.at",{value:e.expiresAt})}),e.ackLabel&&n.jsxs("label",{className:"checkbox-row",children:[n.jsx("input",{type:"checkbox",checked:t,onChange:c=>_(c.target.checked)}),n.jsx("span",{children:e.ackLabel})]}),e.typeToConfirm&&n.jsxs("label",{className:"field",style:{marginTop:12},children:[n.jsx("span",{children:e.typeToConfirm.label}),n.jsx("input",{className:"input",value:o,onChange:c=>s(c.target.value),autoComplete:"off","aria-invalid":!w&&o.length>0}),!w&&o.length>0&&n.jsx("span",{style:{color:"var(--danger)",fontSize:12},children:e.typeToConfirm.mismatch})]}),n.jsxs("div",{className:"dialog-actions",children:[n.jsx("button",{ref:i,className:"button button-secondary",type:"button",onClick:()=>a(!1),children:l("common.cancel")}),n.jsx("button",{className:`button ${e.tone==="danger"?"button-danger":"button-primary"}`,type:"button",disabled:!z,onClick:()=>a(!0),children:e.confirmLabel||l("common.confirm")})]})]})})}function _e(){const[e,a]=f.useState(null),l=f.useRef(null);return{confirmRequest:e,confirm:t=>new Promise(_=>{l.current?.(!1),l.current=_,a(t)}),resolveConfirm:t=>{l.current?.(t),l.current=null,a(null)}}}export{oe as C,te as D,re as T,V as a,W as b,ee as c,ie as d,ne as e,H as f,K as g,Z as h,U as o,ae as p,Y as r,_e as u,le as v};
" },
+  "/v2/assets/ExecutionEvidence-CDki-xbb.js": { contentType: "text/javascript; charset=utf-8", base64: "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" },
+  "/v2/assets/HealthPage-BqIJ5fp5.js": { contentType: "text/javascript; charset=utf-8", base64: "import{u as b,p as L,r as N,a4 as P,j as e,c as O,g as k,k as H,n as z,B as R,S as V,m as K,A as F,h as G,a5 as U,a6 as q,a0 as W,a7 as Y,E as A,N as Z}from"./index-CwQsWZdm.js";import{D as J,g as Q}from"./cockpit-Cax-GxP0.js";import{c as M,A as X,t as ee,r as ae,w as te,a as B,b as se}from"./status-DxL8ZWrC.js";import{u as S}from"./hooks-9usXmJc_.js";import{K as w}from"./KpiCard-DmeG7oeQ.js";import{D as I}from"./DataTable-CNz0DyJ6.js";import{r as ne}from"./runtime_daily_contract-xW43mZQY.js";function le(n){const s=n;return s?.status===409&&s?.message==="runtime_daily_binding_changed"}const C={ok:"health.grid.ok",failed:"health.grid.failed",blocked:"health.run_state.blocked","not-run":"health.grid.not_run","no-record":"health.grid.no_record",unknown:"state.unknown",incomplete:"health.grid.incomplete",stale:"state.stale","read-failed":"state.read_failed","binding-changed":"health.grid.binding_changed"},T={ok:"✓",failed:"✗",blocked:"⊘","not-run":"–","no-record":"",unknown:"?",incomplete:"…",stale:"~","read-failed":"!","binding-changed":"↻"};function D(n,s){return`${n.platform}/${n.account_alias}/${s}`}function re(n,s){const a=[];let l=Date.parse(`${n}T00:00:00Z`);for(;a.length<s;){const o=new Date(l).getUTCDay();o!==0&&o!==6&&a.unshift(new Date(l).toISOString().slice(0,10)),l-=864e5}return a}function ie({selection:n,cell:s}){const a=b(),l=L(),o=H(),t=z(n.date,o);let i;if(!s||s.phase==="loading")i=e.jsx(k,{height:16,width:240});else if(s.phase==="binding-changed")i=e.jsx("span",{className:"health-grid-note health-grid-note-info",children:a("health.grid.binding_changed_detail")});else if(s.phase==="error")i=e.jsx("span",{className:"health-grid-note",children:a("state.read_failed")});else if(!s.snapshot.record)i=e.jsx("span",{children:a("health.grid.no_record")});else{const d=s.snapshot.record,f=d.runs??[],u=new Map;for(const h of f){const x=h.activity==="blocked"?"health.run_state.blocked":`state.${h.activity||"unknown"}`,j=a(x);u.set(j,(u.get(j)||0)+1)}i=e.jsxs(e.Fragment,{children:[e.jsxs("div",{className:"health-day-detail-meta",children:[d.status==="blocked"?e.jsx(R,{tone:"warn",children:a("health.run_state.blocked")}):e.jsx(V,{status:d.status}),M(s.snapshot)==="blocked"&&e.jsx("span",{children:a(d.block_reason_code?`reason.${d.block_reason_code}`:"reason.unknown")}),e.jsx("span",{children:a("health.day_detail_summary",{count:d.runs?f.length:0})}),[...u].map(([h,x])=>e.jsxs("span",{className:"card-note",children:[x," ",h]},h))]}),f.length>0&&e.jsxs("details",{className:"health-day-runs",children:[e.jsx("summary",{children:a("health.day_detail_runs")}),e.jsx("ul",{children:f.map((h,x)=>{const j=K(h.started_at,o).text,r=K(h.finished_at,o).text;return e.jsxs("li",{children:[e.jsxs("span",{className:"num",children:[a("health.detail.started")," ",j]}),e.jsxs("span",{className:"num",children:[a("health.detail.finished")," ",r]}),e.jsx("span",{children:a(h.activity==="blocked"?"health.run_state.blocked":`state.${h.activity||"unknown"}`)}),h.errors_present===!0&&h.activity!=="blocked"&&e.jsx(R,{tone:"error",children:a("health.grid.failed")})]},x)})})]})]})}return e.jsxs("div",{className:"health-day-detail",children:[e.jsxs("div",{className:"health-day-detail-head",children:[e.jsx("strong",{children:a("health.day_detail")}),e.jsx("span",{children:l.account(n.account.account_alias,n.account.platform)}),e.jsx("span",{className:"num",children:t})]}),i]})}function oe({accounts:n,epoch:s}){const a=b(),l=L(),o=N.useMemo(()=>re(ne(),14),[s]),[t,i]=N.useState({}),[d,f]=N.useState(!1),[u,h]=N.useState(null);if(N.useEffect(()=>{if(!n.length)return;let r=!1;const p={};for(const g of n)for(const c of o)p[D(g,c)]={phase:"loading"};return i(p),f(!1),h(null),(async()=>{let g=!1;for(const c of o){const m=await Promise.allSettled(n.map(_=>P(c,_.platform,_.account_alias,!1)));if(r)return;const y={};m.forEach((_,$)=>{const v=D(n[$],c);_.status==="fulfilled"?y[v]={phase:"ready",snapshot:_.value}:le(_.reason)?y[v]={phase:"binding-changed"}:(y[v]={phase:"error"},g=!0)}),i(_=>({..._,...y}))}!r&&g&&f(!0)})().catch(()=>{r||f(!0)}),()=>{r=!0}},[n,o,s]),!n.length)return e.jsx(O,{title:a("state.no_data")});const x=Object.keys(C),j=Object.values(t).some(r=>r.phase==="binding-changed");return e.jsxs(e.Fragment,{children:[e.jsx("p",{className:"health-grid-hint",children:a("health.grid_scroll_hint")}),e.jsx("div",{className:"health-grid",tabIndex:0,role:"region","aria-label":a("health.grid_title"),children:e.jsxs("table",{children:[e.jsx("caption",{className:"sr-only",children:a("health.grid_title")}),e.jsx("thead",{children:e.jsxs("tr",{children:[e.jsx("th",{scope:"col",children:a("health.col.account")}),o.map(r=>e.jsx("th",{scope:"col",className:"num",children:r.slice(5)},r))]})}),e.jsx("tbody",{children:n.map(r=>e.jsxs("tr",{children:[e.jsxs("th",{scope:"row",children:[l.account(r.account_alias,r.platform),e.jsxs("span",{className:"card-note",children:[" · ",l.platform(r.platform)]})]}),o.map(p=>{const g=D(r,p),c=t[g],m=u?.account.platform===r.platform&&u.account.account_alias===r.account_alias&&u.date===p;if(!c||c.phase==="loading")return e.jsx("td",{children:e.jsx(k,{height:26,width:26})},p);if(c.phase==="binding-changed"||c.phase==="error"){const $=c.phase==="error"?"read-failed":"binding-changed",v=a(C[$]);return e.jsx("td",{children:e.jsx("button",{type:"button",className:`health-cell ${$}${m?" selected":""}`,title:v,"aria-label":`${l.account(r.account_alias,r.platform)} ${p}: ${v}`,onClick:()=>h({account:r,date:p}),children:T[$]})},p)}const y=M(c.snapshot),_=a(C[y]);return e.jsx("td",{children:e.jsx("button",{type:"button",className:`health-cell ${y}${m?" selected":""}`,title:_,"aria-label":`${l.account(r.account_alias,r.platform)} ${p}: ${_}`,"aria-pressed":m,onClick:()=>h({account:r,date:p}),children:T[y]})},p)})]},`${r.platform}/${r.account_alias}`))})]})}),e.jsx("div",{className:"health-legend",children:x.map(r=>e.jsxs("span",{children:[e.jsx("span",{className:`health-cell ${r}`,"aria-hidden":"true",children:T[r]}),a(C[r])]},r))}),d&&e.jsx("p",{className:"health-grid-note",children:a("health.grid_read_failed_note")}),j&&e.jsx("p",{className:"health-grid-note health-grid-note-info",children:a("health.grid_binding_changed_note")}),u&&e.jsx(ie,{selection:u,cell:t[D(u.account,u.date)]})]})}function ce(n,s){return n.filter(a=>{if(s.some(o=>o.platform===a.platform&&o.status==="read_failed"))return!1;const l=s.filter(o=>o.platform===a.platform&&o.account_key===a.account_alias);return l.length===1&&l[0].status==="bound"&&!!l[0].target_key})}const de=["30","7","1","expired"],he={expired:"error",1:"error",7:"warn",30:"warn",not_due:"ok",unknown:"unknown"};function E({state:n,render:s}){const a=b();return n.phase==="loading"?e.jsx(k,{height:24,width:90}):n.phase==="error"||n.phase==="ready"&&n.data!==null&&typeof n.data=="object"&&"status"in n.data&&n.data.status==="read_failed"?e.jsx("span",{className:"kpi-state",children:a("state.read_failed")}):e.jsx(e.Fragment,{children:s()})}function ue({summary:n,credential:s}){const a=b(),l=n.phase==="ready"?n.data:null,o=l?l.accounts.filter(c=>c.status==="ok").length:0,t=l?ee(l):{count:0,complete:!1},i=l?ae(l.accounts):null,d=l?te(l):!1,f=i&&(i.not_connected>0||i.no_data>0)?a("health.kpi.today_runs_note",{not_connected:i.not_connected,no_data:i.no_data}):void 0,u=s.phase==="ready"?s.data:null,h=u?.requires_action===!0||u&&de.includes(u.phase)?1:0,x=!u||u.phase==="unknown",j=["succeeded","failed","read_failed","incomplete"],r=i?Object.entries(i):[],p=r.filter(([c])=>j.includes(c)),g=r.filter(([c,m])=>!j.includes(c)&&m>0);return e.jsxs(e.Fragment,{children:[e.jsxs("div",{className:"stat-strip health-kpis",children:[e.jsx(w,{title:a("health.kpi.today_runs"),value:e.jsx(E,{state:n,render:()=>d&&(l?.counts.observed??0)===0?"—":a("health.account_fraction",{count:o,total:l?.counts.configured??0})}),sub:d?e.jsx("span",{children:a("health.non_trading_day_short")}):f?e.jsx("span",{title:a("health.kpi.today_runs_note_title"),children:f}):void 0,footer:l?.as_of?e.jsx(F,{value:l.as_of}):void 0}),e.jsx(w,{title:a("health.kpi.observed"),value:e.jsx(E,{state:n,render:()=>a("health.account_fraction",{count:l?.counts.observed??0,total:l?.counts.configured??0})})}),e.jsx(w,{title:a("health.kpi.recent_failure"),value:e.jsx(E,{state:n,render:()=>d&&t.count===0?"—":t.complete?String(t.count):t.count>0?a("health.failure_at_least",{count:t.count}):a("state.unknown")}),sub:d?a("health.non_trading_day_short"):void 0}),e.jsx(w,{title:a("health.kpi.credentials"),value:e.jsx(E,{state:s,render:()=>x?a("state.unknown"):String(h)}),sub:a("health.kpi.credentials_unit")})]}),i&&e.jsxs("div",{className:"health-state-summary",children:[e.jsx("ul",{className:"health-state-counts","aria-label":a("health.state_counts"),children:p.map(([c,m])=>e.jsxs("li",{children:[a(B(c)),": ",e.jsx("span",{className:"num",children:m})]},c))}),g.length>0&&e.jsx("ul",{className:"health-state-counts health-state-secondary",children:g.map(([c,m])=>e.jsxs("li",{children:[a(B(c)),": ",e.jsx("span",{className:"num",children:m})]},c))})]}),e.jsxs("p",{className:"metric-note",title:a("health.failure_window_detail"),children:[a("health.failure_window",{date:l?.date??"—"}),d?` · ${a("health.non_trading_day_short")}`:!t.complete&&` · ${a("health.failure_incomplete")}`]})]})}function pe({summary:n}){const s=b(),a=L();if(n.phase==="loading")return e.jsx(k,{height:120});if(n.phase==="error")return e.jsx(A,{onRetry:n.reload});const l=[{id:"account",header:s("health.col.account"),cell:t=>e.jsx(e.Fragment,{children:a.account(t.account_alias,t.platform)}),sortValue:t=>`${a.account(t.account_alias,t.platform)}:${t.account_alias}`},{id:"status",header:s("health.col.status"),cell:t=>t.unavailable_reason==="runtime_daily_binding_conflict"?e.jsx("span",{children:s("reason.runtime_daily_binding_conflict")}):e.jsx(V,{status:t.freshness??(t.stale===!0?"stale":t.fresh===!0?"fresh":t.status),reason:t.unavailable_reason}),sortValue:t=>t.status},{id:"activity",header:s("health.activity"),cell:t=>{const i=se(t);return e.jsx("span",{"data-state":i,title:t.run_status_reason?s(`reason.${t.run_status_reason}`):void 0,children:s(B(i))})}},{id:"run_count",header:s("health.run_count"),numeric:!0,cell:t=>t.run_count===null?"—":t.run_count,sortValue:t=>t.run_count},{id:"as_of",header:s("health.col.as_of"),cell:t=>e.jsx(F,{value:t.as_of,prefix:"common.as_of"}),sortValue:t=>t.as_of}],o=Z(n.data.accounts,a.config).sort((t,i)=>a.platform(t.platform).localeCompare(a.platform(i.platform)));return e.jsxs(e.Fragment,{children:[n.data.status==="read_failed"&&e.jsx("p",{role:"alert",children:s("state.read_failed")}),o.map(t=>e.jsxs("section",{className:"health-platform-group",children:[e.jsx("h3",{children:a.platform(t.platform)}),e.jsx(I,{columns:l,rows:t.accounts.flatMap(i=>i.rows),rowKey:i=>`${i.platform}/${i.account_alias}`,defaultSort:{column:"account",direction:"asc"},scrollHint:!0,caption:`${s("health.freshness_title")} · ${a.platform(t.platform)}`})]},t.platform)),!o.length&&e.jsx(O,{title:s("state.no_data")})]})}function fe({credential:n}){const s=b(),a=H();if(n.phase==="loading")return e.jsx(k,{height:72});if(n.phase==="error")return e.jsx(A,{onRetry:n.reload});const l=n.data,o=[{id:"id",header:s("health.col.credential"),cell:t=>s(t.id==="ibkr_flex"?"health.credential_ibkr_report":"health.credential_other")},{id:"phase",header:s("health.col.phase"),cell:t=>e.jsx(R,{tone:he[t.phase],children:s(`health.credential_phase.${t.phase}`)})},{id:"expires",header:s("health.col.expires"),cell:t=>{if(!t.expires_at)return"—";const{text:i,zone:d}=K(t.expires_at,a,!0);return s("health.credential_expires",{value:d?`${i} (${d})`:i})},sortValue:t=>t.expires_at}];return e.jsx(I,{columns:o,rows:[l],rowKey:t=>t.id,scrollHint:!0,caption:s("health.credentials_title")})}function me(){const n=b(),s=S(()=>W(),[]),a=S(()=>Y(),[]),l=N.useMemo(()=>s.phase==="ready"&&a.phase==="ready"?ce(s.data.accounts,a.data):[],[s.phase,s.data,a.phase,a.data]);return e.jsxs("section",{className:"card",children:[e.jsx("h2",{className:"card-title",children:n("health.grid_title")}),(s.phase==="loading"||a.phase==="loading")&&e.jsx(k,{height:160}),s.phase==="error"&&e.jsx(A,{onRetry:s.reload}),a.phase==="error"&&e.jsx(A,{onRetry:a.reload}),a.phase==="ready"&&a.data.some(o=>o.status==="read_failed")&&e.jsx("p",{role:"alert",children:n("state.read_failed")}),s.phase==="ready"&&a.phase==="ready"&&(l.length>0||!a.data.some(o=>o.status==="read_failed"))&&e.jsx(oe,{accounts:l,epoch:0})]})}function ke(){const n=b(),[s,a]=N.useState(0),l=S(()=>G(),[s]),o=S(()=>U(),[s]),t=S(async()=>Q(await q(1),!1),[s]),i=t.phase==="loading"?"loading":t.phase==="error"?"error":t.data.status==="not_ready"?"not_ready":"ready",d=t.phase==="ready"&&t.data.status==="ready"?t.data.data:null;return e.jsxs("div",{className:"page",children:[e.jsxs("header",{className:"page-header",children:[e.jsx("h1",{className:"page-title",children:n("health.title")}),e.jsx("div",{className:"page-header-actions",children:e.jsx("button",{type:"button",className:"button button-secondary",onClick:()=>a(f=>f+1),children:n("common.refresh")})})]}),e.jsx("p",{className:"card-note",children:n("health.global_scope_note")}),e.jsxs("div",{className:"health-day-context",children:[l.phase==="loading"?e.jsx(k,{height:18,width:240}):l.phase==="error"?e.jsx("span",{className:"health-business-day","data-state":"read_failed",children:n("state.read_failed")}):e.jsx("span",{className:"health-business-day",children:n("health.business_date",{value:`${l.data.date} · ${l.data.timezone}`})}),l.phase==="ready"&&l.data.as_of&&e.jsx(F,{value:l.data.as_of}),l.phase==="ready"&&l.data.market_session==="weekend"&&e.jsx("span",{className:"health-business-day","data-state":"non_trading",children:n("health.non_trading_day")})]}),e.jsx(ue,{summary:l,credential:o}),e.jsx(me,{},s),e.jsxs("section",{className:"card",children:[e.jsx("h2",{className:"card-title",children:n("health.freshness_title")}),e.jsx("div",{className:"health-freshness",children:e.jsx(pe,{summary:l})})]}),e.jsxs("section",{className:"card",children:[e.jsx("h2",{className:"card-title",children:n("health.credentials_title")}),e.jsx("div",{className:"health-credentials",children:e.jsx(fe,{credential:o})})]}),e.jsx("section",{className:"card health-digest",children:e.jsx(J,{digest:d,status:i,onRetry:t.reload})}),e.jsxs("section",{className:"card health-activity",children:[e.jsx("h2",{className:"card-title",children:n("overview.latest_activity")}),e.jsx(X,{},s)]})]})}export{ke as default};
" },
   "/v2/assets/HealthPage-DWOwvlJZ.css": { contentType: "text/css; charset=utf-8", base64: "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" },
-  "/v2/assets/KpiCard-Dxqixf9c.js": { contentType: "text/javascript; charset=utf-8", base64: "aW1wb3J0e2ogYXMgc31mcm9tIi4vaW5kZXgtRHNfWFhMc24uanMiO2Z1bmN0aW9uIHgoe3RpdGxlOnQsdmFsdWU6cCxzdWI6bixmb290ZXI6YSxkZXRhaWw6bCxvbkNsaWNrOmUsY2xhc3NOYW1lOml9KXtjb25zdCByPWQ9PnMuanN4cyhzLkZyYWdtZW50LHtjaGlsZHJlbjpbcy5qc3goInNwYW4iLHtjbGFzc05hbWU6ImtwaS10aXRsZSIsY2hpbGRyZW46dH0pLHMuanN4KGQse2NsYXNzTmFtZToia3BpLXZhbHVlIG51bSIsY2hpbGRyZW46cH0pLG4mJnMuanN4KCJzcGFuIix7Y2xhc3NOYW1lOiJrcGktc3ViIixjaGlsZHJlbjpufSksYSYmcy5qc3goInNwYW4iLHtjbGFzc05hbWU6ImtwaS1mb290IixjaGlsZHJlbjphfSldfSksYz1pP2BrcGktY2FyZCAke2l9YDoia3BpLWNhcmQiO3JldHVybiBlP3MuanN4KCJidXR0b24iLHt0eXBlOiJidXR0b24iLGNsYXNzTmFtZTpjLG9uQ2xpY2s6ZSxjaGlsZHJlbjpyKCJzcGFuIil9KTpzLmpzeHMoImRpdiIse2NsYXNzTmFtZTpjLGNoaWxkcmVuOltyKCJkaXYiKSxsXX0pfWV4cG9ydHt4IGFzIEt9Owo=" },
-  "/v2/assets/OverviewPage-C345eb1E.css": { contentType: "text/css; charset=utf-8", base64: "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" },
-  "/v2/assets/OverviewPage-DLmRzWCy.js": { contentType: "text/javascript; charset=utf-8", base64: "import{u as j,a as D,r as A,l as L,j as e,b as C,E as K,B,S as y,A as b,c as M,M as E,d as Y,P as R,e as I,f as N,g as H,h as q,i as Q}from"./index-Ds_XXLsn.js";import{i as U}from"./inboxFailure-DUO9CRup.js";import{r as F,u as W,c as O,L as z,A as G,C as V,D as X,U as Z}from"./cashflowMethod-H7Uq4Mrs.js";import{u as g}from"./hooks-DCo9_b70.js";import{K as v}from"./KpiCard-Dxqixf9c.js";import{w as J}from"./status-B_UXUo8G.js";import"./runtime_daily_contract-xW43mZQY.js";function ee(a){if(!F(a.status)||a.unavailable_reason==="mixed_currency"||!a.currency)return null;const t=a.points.reduce((n,s)=>!n||s.date>=n.date?s:n,null);return t&&Number.isFinite(t.value)?t.value:null}const w="YTD";function ae(){const a=new Date,t=String(a.getMonth()+1).padStart(2,"0"),n=String(a.getDate()).padStart(2,"0");return`${a.getFullYear()}-${t}-${n}`}function P(a){const t=ae();return a.filter(n=>typeof n.date=="string"&&n.date<=t&&(n.amount!==null||n.return_percent!==null))}function te(a){if(a.month===null||P(a.cells).length>0)return null;const t=/^(\d{4})-(\d{2})-\d{2}$/.exec(a.as_of??"");if(!t)return null;const n=Number(t[1]),s=Number(t[2]);if(s<1||s>12)return null;const r=`${a.year}-${String(a.month).padStart(2,"0")}`;return`${n}-${String(s).padStart(2,"0")}`<r?{year:n,month:s}:null}const k=F;function x({status:a}){const t=j();return e.jsxs("span",{className:"flat kpi-empty-value","data-state":a,children:["—",e.jsx("span",{className:"sr-only",children:t(`state.${a}`)})]})}function $(a){return e.jsx(v,{title:a,value:e.jsx(N,{height:28,width:"70%"})})}function S(a,t){return t==="mixed_currency"?a("overview.mixed_currency_short"):t?a(`reason.${t}`):void 0}function se({state:a}){const t=j(),n=t("overview.total_assets");if(a.phase==="loading")return $(n);if(a.phase==="error")return e.jsx(v,{title:n,value:e.jsx(x,{status:"read_failed"}),sub:t("state.read_failed")});const s=a.data;if(s.per_currency?.length&&s.unavailable_reason!=="stored_records_unreadable")return e.jsx(v,{title:n,value:e.jsx(V,{totals:s.per_currency,freshness:s.freshness_summary})});const r=ee(s),i=r===null&&k(s.status)?"unavailable":s.status,o=r!==null?e.jsx(E,{value:r,currency:s.currency}):e.jsx(x,{status:i}),l=r===null?S(t,s.unavailable_reason)||t(`state.${i}`):void 0,u=i!=="ok"||s.as_of?e.jsxs(e.Fragment,{children:[i!=="ok"&&e.jsx(y,{status:i,reason:s.unavailable_reason}),s.as_of&&e.jsx(b,{value:s.as_of})]}):void 0;return e.jsx(v,{title:n,value:o,sub:l,footer:u})}function ne(a,t){const n=O(a);return t(n==="dietz_approx"?X:n==="unknown"?Z:"overview.twr_tag")}function re({state:a}){const t=j(),n=t("overview.range_return",{range:t(`perf.range.${w}`)});if(a.phase==="loading")return $(n);if(a.phase==="error")return e.jsx(v,{title:n,value:e.jsx(x,{status:"read_failed"}),sub:t("state.read_failed")});const s=a.data;if(!k(s.status))return e.jsx(v,{title:n,value:e.jsx(x,{status:s.status}),sub:S(t,s.unavailable_reason)||t(`state.${s.status}`),footer:s.as_of?e.jsx(b,{value:s.as_of}):void 0});const r=s.status!=="ok",i=s.metric_reasons?.twr||s.unavailable_reason,o=r?e.jsx(y,{status:s.status,reason:s.unavailable_reason}):void 0,l=o||s.as_of?e.jsxs(e.Fragment,{children:[o,s.as_of&&e.jsx(b,{value:s.as_of})]}):void 0;return s.twr_return_percent===null?e.jsx(v,{title:n,value:e.jsx(x,{status:"unavailable"}),sub:S(t,i)||t("state.unavailable"),footer:l}):e.jsx(v,{title:n,value:e.jsx(R,{value:s.twr_return_percent}),sub:ne(s,t),footer:l})}function oe({state:a,carryover:t,carryoverState:n}){const s=j(),r=s("overview.last_day_change");let i=a;if(t&&n?.phase!=="error"&&(i=n?.phase==="ready"&&n.data?{phase:"ready",data:n.data,error:null}:{phase:"loading",data:null,error:null}),i.phase==="loading")return $(r);if(i.phase==="error")return e.jsx(v,{title:r,value:e.jsx(x,{status:"read_failed"}),sub:s("state.read_failed")});const o=i.data;if(!k(o.status))return e.jsx(v,{title:r,value:e.jsx(x,{status:o.status}),sub:S(s,o.unavailable_reason)||s(`state.${o.status}`),footer:o.as_of?e.jsx(b,{value:o.as_of}):void 0});const u=o.status!=="ok"?e.jsx(y,{status:o.status,reason:o.unavailable_reason}):void 0,h=u||o.as_of?e.jsxs(e.Fragment,{children:[u,o.as_of&&e.jsx(b,{value:o.as_of})]}):void 0,f=P(o.cells).sort((c,d)=>c.date<d.date?1:-1)[0];if(!f)return e.jsx(v,{title:r,value:e.jsx("span",{className:"flat",children:"—"}),sub:S(s,o.unavailable_reason)||s("state.no_data"),footer:h});const p=f.amount!==null?e.jsx(E,{value:f.amount,currency:f.currency,signed:!0}):e.jsx(R,{value:f.return_percent}),m=f.value_kind==="pnl"?s("perf.value_kind_pnl"):s("perf.value_kind_asset_change");return e.jsx(v,{title:r,value:p,sub:m,footer:h})}function ie({state:a}){const t=j(),n=C(),s=()=>n({page:"decisions"}),r=t("overview.todos");if(a.phase==="loading")return e.jsx(v,{title:r,value:e.jsx(N,{height:28,width:"70%"}),onClick:s});if(a.phase==="error"||a.data.status==="read_failed")return e.jsx(v,{title:r,value:e.jsx(x,{status:"read_failed"}),sub:t(`inbox.error.${U(a.data,a.error)}.title`),onClick:s});const i=a.data,o=i.items.filter(u=>u.status==="pending"),l=o.filter(u=>u.priority==="high").length;return e.jsx(v,{title:r,value:o.length,sub:t("overview.todos_urgent",{count:l}),footer:i.status==="partial"?e.jsx(y,{status:"partial"}):void 0,onClick:s})}function le({state:a}){const t=j(),n=C(),s=()=>n({page:"health"}),r=t("overview.runs_card_title");if(a.phase==="loading")return e.jsx(v,{title:r,value:e.jsx(N,{height:28,width:"70%"}),onClick:s});if(a.phase==="error"||a.data.status==="read_failed")return e.jsx(v,{title:r,value:e.jsx(x,{status:"read_failed"}),sub:t("state.read_failed"),onClick:s});const i=a.data,{configured:o,observed:l}=i.counts,u=Number.isSafeInteger(o)&&o>0&&Number.isSafeInteger(l)&&l>=0,h=u?`${l}/${o}`:e.jsx(x,{status:"unknown"}),f=new Set((i.accounts??[]).map(_=>_.unavailable_reason).filter(_=>typeof _=="string"&&_!=="")),p=f.has("runtime_daily_binding_conflict")?"runtime_daily_binding_conflict":f.has("runtime_daily_not_connected")?"runtime_daily_not_connected":void 0,m=J(i),c=i.market_session==="trading_day"?"overview.business_date":"overview.calendar_date",d=u?e.jsxs(e.Fragment,{children:[t(c,{value:i.date}),!m&&l===0&&e.jsxs(e.Fragment,{children:[" · ",t("overview.no_records_for_day")]})]}):t("state.no_data");return e.jsx(v,{title:r,value:h,sub:d,footer:m?e.jsx(B,{tone:"unknown",children:t("overview.non_trading_day_short")}):i.status==="partial"?e.jsx(y,{status:"partial",reason:p}):void 0,onClick:s})}function ue(a){if(!a)return[];const t=a.curve_status??a.status,n=a.curve_unavailable_reason===void 0?a.unavailable_reason:a.curve_unavailable_reason;return(a.history_per_currency?.length?a.history_per_currency.map(r=>({currency:r.currency,status:r.status,reason:r.unavailable_reason,asOf:r.as_of,coverage:r.coverage,points:r.points})):[{currency:a.currency??"",status:t,reason:n,asOf:a.as_of,coverage:a.curve_coverage,points:a.points}]).flatMap(r=>{const i=[];let o=!1;for(const l of r.points){if(!Number.isFinite(l.value)){o=!0;continue}i.push(o&&!l.breakBefore?{...l,breakBefore:!0}:l),o=!1}return!k(r.status)||!r.currency||i.length===0?[]:[{currency:r.currency,status:r.status,reason:r.reason,asOf:r.asOf,points:i,partial:i.some(l=>l.partial)||!!r.coverage?.truncated||!!r.coverage?.read_failures?.length}]})}function ce(a,t){return a.length?a.find(n=>n.currency===t)??a[0]:null}function de({returns:a,assets:t}){const n=j(),s=C(),r=W(),[i,o]=A.useState(null),l=()=>s({page:"performance"});let u,h=n("overview.equity_trend"),f=null,p=null;const m=a.phase==="ready"&&k(a.data.status)&&a.data.points.length>0;if(a.phase==="loading")u=e.jsx(N,{height:220});else if(a.phase==="error")u=e.jsx(K,{onRetry:a.reload});else if(m){const c=a.data;c.return_kind==="twr"&&O(c)!=="unknown"||(h=n("perf.asset_change_title"));const _=[{id:"main",label:r,color:"var(--accent)",points:c.points,primary:!0}];u=e.jsx(z,{series:_,mode:"cumulative",ariaLabel:h,alignStart:c.aligned_start}),(c.status==="partial"||c.status==="stale")&&(p=e.jsxs("div",{className:"card-note overview-trend-note",children:[c.status==="partial"?e.jsx(B,{tone:"warn",children:n("state.partial_valuation")}):e.jsx(y,{status:c.status}),c.as_of&&e.jsx(b,{value:c.as_of})]}))}else{const c=ue(t.phase==="ready"?t.data:null),d=ce(c,i);t.phase==="loading"?u=e.jsx(N,{height:220}):t.phase==="error"?u=e.jsx(K,{onRetry:t.reload}):d?(h=n("perf.asset_balance_title"),c.length>1&&(f=e.jsx("div",{className:"overview-currency-switch",children:e.jsx("div",{className:"segmented",role:"group","aria-label":n("perf.currency_switch"),children:c.map(_=>e.jsx("button",{type:"button",className:`segment${_.currency===d.currency?" active":""}`,"aria-pressed":_.currency===d.currency,onClick:()=>o(_.currency),children:_.currency},_.currency))})})),u=e.jsx(G,{points:d.points,currency:d.currency,ariaLabel:h}),(d.status!=="ok"||d.partial)&&(p=e.jsxs("div",{className:"card-note overview-trend-note",children:[e.jsx(y,{status:d.status==="ok"?"partial":d.status,reason:d.reason}),d.asOf&&e.jsx(b,{value:d.asOf})]}))):u=e.jsx(M,{title:n(`state.${k(a.data.status)?"no_data":a.data.status}`)})}return e.jsxs("div",{className:"card overview-link-card overview-trend-card",children:[e.jsxs("div",{className:"overview-card-head",children:[e.jsx("h2",{className:"card-title",children:h}),e.jsxs("button",{type:"button",className:"overview-trend-open",onClick:l,children:[n("overview.open_performance")," ",e.jsx("span",{"aria-hidden":"true",children:"→"})]})]}),f,u,p]})}function je(){const a=j(),{scope:t}=D(),[n,s]=A.useState(0),r=()=>s(T=>T+1),i=new Date,o=i.getFullYear(),l=i.getMonth()+1,u=g(()=>Y(t,w),[t,n]),h=g(()=>I(t,w),[t,n]),f=g(()=>L(t,w,o,l),[t,n]),p=f.phase==="ready"?te(f.data):null,m=g(()=>p?L(t,w,p.year,p.month):Promise.resolve(null),[t,n,p?`${p.year}-${p.month}`:""]),c=g(()=>H(n>0),[n]),d=g(()=>q(),[n]),_=g(()=>Q(t,w),[t,n]);return e.jsxs("div",{className:"page",children:[e.jsxs("div",{className:"page-header",children:[e.jsx("h1",{className:"page-title",children:a("nav.overview")}),e.jsx("div",{className:"page-header-actions",children:e.jsx("button",{type:"button",className:"button button-secondary",onClick:r,children:a("common.refresh")})})]}),e.jsxs("section",{className:"overview-summary","aria-label":a("overview.asset_summary"),children:[e.jsx("div",{className:"overview-primary-kpi",children:e.jsx(se,{state:u})}),e.jsxs("div",{className:"overview-secondary-kpis",children:[e.jsx(re,{state:h}),e.jsx(oe,{state:f,carryover:p,carryoverState:m}),e.jsx(ie,{state:c}),e.jsx(le,{state:d})]})]}),e.jsx(de,{returns:_,assets:u})]})}export{de as TrendCard,ue as assetBalanceHistories,te as carryoverMonthForLatestDay,je as default,ce as selectAssetHistory};
" },
+  "/v2/assets/KpiCard-DmeG7oeQ.js": { contentType: "text/javascript; charset=utf-8", base64: "aW1wb3J0e2ogYXMgc31mcm9tIi4vaW5kZXgtQ3dRc1daZG0uanMiO2Z1bmN0aW9uIHgoe3RpdGxlOnQsdmFsdWU6cCxzdWI6bixmb290ZXI6YSxkZXRhaWw6bCxvbkNsaWNrOmUsY2xhc3NOYW1lOml9KXtjb25zdCByPWQ9PnMuanN4cyhzLkZyYWdtZW50LHtjaGlsZHJlbjpbcy5qc3goInNwYW4iLHtjbGFzc05hbWU6ImtwaS10aXRsZSIsY2hpbGRyZW46dH0pLHMuanN4KGQse2NsYXNzTmFtZToia3BpLXZhbHVlIG51bSIsY2hpbGRyZW46cH0pLG4mJnMuanN4KCJzcGFuIix7Y2xhc3NOYW1lOiJrcGktc3ViIixjaGlsZHJlbjpufSksYSYmcy5qc3goInNwYW4iLHtjbGFzc05hbWU6ImtwaS1mb290IixjaGlsZHJlbjphfSldfSksYz1pP2BrcGktY2FyZCAke2l9YDoia3BpLWNhcmQiO3JldHVybiBlP3MuanN4KCJidXR0b24iLHt0eXBlOiJidXR0b24iLGNsYXNzTmFtZTpjLG9uQ2xpY2s6ZSxjaGlsZHJlbjpyKCJzcGFuIil9KTpzLmpzeHMoImRpdiIse2NsYXNzTmFtZTpjLGNoaWxkcmVuOltyKCJkaXYiKSxsXX0pfWV4cG9ydHt4IGFzIEt9Owo=" },
+  "/v2/assets/OverviewPage-CDp0o79F.css": { contentType: "text/css; charset=utf-8", base64: "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" },
+  "/v2/assets/OverviewPage-CGYvI0GD.js": { contentType: "text/javascript; charset=utf-8", base64: "import{u as j,a as P,r as E,l as R,j as e,b as C,E as A,B as $,S as y,A as b,c as M,d as Y,M as F,e as I,P as B,f as Q,g as N,h as H,i as U,k as z,m as W}from"./index-CwQsWZdm.js";import{i as G}from"./inboxFailure-B9PDJ1HN.js";import{r as D,u as V,c as K,L as X,A as Z,C as J,D as ee,U as ae}from"./cashflowMethod-BoxXysdG.js";import{u as g}from"./hooks-9usXmJc_.js";import{A as se,w as te}from"./status-DxL8ZWrC.js";import{F as ne}from"./cockpit-Cax-GxP0.js";import{K as h}from"./KpiCard-DmeG7oeQ.js";import"./runtime_daily_contract-xW43mZQY.js";function re(a){if(!D(a.status)||a.unavailable_reason==="mixed_currency"||!a.currency)return null;const t=a.points.reduce((s,n)=>!s||n.date>=s.date?n:s,null);return t&&Number.isFinite(t.value)?t.value:null}const w="YTD";function oe(){const a=new Date,t=String(a.getMonth()+1).padStart(2,"0"),s=String(a.getDate()).padStart(2,"0");return`${a.getFullYear()}-${t}-${s}`}function O(a){const t=oe();return a.filter(s=>typeof s.date=="string"&&s.date<=t&&(s.amount!==null||s.return_percent!==null))}function ie(a){if(a.month===null||O(a.cells).length>0)return null;const t=/^(\d{4})-(\d{2})-\d{2}$/.exec(a.as_of??"");if(!t)return null;const s=Number(t[1]),n=Number(t[2]);if(n<1||n>12)return null;const r=`${a.year}-${String(a.month).padStart(2,"0")}`;return`${s}-${String(n).padStart(2,"0")}`<r?{year:s,month:n}:null}const k=D;function m({status:a}){const t=j();return e.jsxs("span",{className:"flat kpi-empty-value","data-state":a,children:["—",e.jsx("span",{className:"sr-only",children:t(`state.${a}`)})]})}function q(a){return e.jsx(h,{title:a,value:e.jsx(N,{height:28,width:"70%"})})}function S(a,t){return t==="mixed_currency"?a("overview.mixed_currency_short"):t?a(`reason.${t}`):void 0}function ce({state:a}){const t=j(),s=t("overview.total_assets");if(a.phase==="loading")return q(s);if(a.phase==="error")return e.jsx(h,{title:s,value:e.jsx(m,{status:"read_failed"}),sub:t("state.read_failed")});const n=a.data;if(n.per_currency?.length&&n.unavailable_reason!=="stored_records_unreadable")return e.jsx(h,{title:s,value:e.jsx(J,{totals:n.per_currency,freshness:n.freshness_summary})});const r=re(n),o=r===null&&k(n.status)?"unavailable":n.status,i=r!==null?e.jsx(F,{value:r,currency:n.currency}):e.jsx(m,{status:o}),c=r===null?S(t,n.unavailable_reason)||t(`state.${o}`):void 0,l=o!=="ok"||n.as_of?e.jsxs(e.Fragment,{children:[o!=="ok"&&e.jsx(y,{status:o,reason:n.unavailable_reason}),n.as_of&&e.jsx(b,{value:n.as_of})]}):void 0;return e.jsx(h,{title:s,value:i,sub:c,footer:l})}function le(a,t){const s=K(a);return t(s==="dietz_approx"?ee:s==="unknown"?ae:"overview.twr_tag")}function ue({state:a}){const t=j(),s=t("overview.range_return",{range:t(`perf.range.${w}`)});if(a.phase==="loading")return q(s);if(a.phase==="error")return e.jsx(h,{title:s,value:e.jsx(m,{status:"read_failed"}),sub:t("state.read_failed")});const n=a.data;if(!k(n.status))return e.jsx(h,{title:s,value:e.jsx(m,{status:n.status}),sub:S(t,n.unavailable_reason)||t(`state.${n.status}`),footer:n.as_of?e.jsx(b,{value:n.as_of}):void 0});const r=n.status!=="ok",o=n.metric_reasons?.twr||n.unavailable_reason,i=r?e.jsx(y,{status:n.status,reason:n.unavailable_reason}):void 0,c=i||n.as_of?e.jsxs(e.Fragment,{children:[i,n.as_of&&e.jsx(b,{value:n.as_of})]}):void 0;return n.twr_return_percent===null?e.jsx(h,{title:s,value:e.jsx(m,{status:"unavailable"}),sub:S(t,o)||t("state.unavailable"),footer:c}):e.jsx(h,{title:s,value:e.jsx(B,{value:n.twr_return_percent}),sub:le(n,t),footer:c})}function de({state:a,carryover:t,carryoverState:s}){const n=j(),r=n("overview.last_day_change");let o=a;if(t&&s?.phase!=="error"&&(o=s?.phase==="ready"&&s.data?{phase:"ready",data:s.data,error:null}:{phase:"loading",data:null,error:null}),o.phase==="loading")return q(r);if(o.phase==="error")return e.jsx(h,{title:r,value:e.jsx(m,{status:"read_failed"}),sub:n("state.read_failed")});const i=o.data;if(!k(i.status))return e.jsx(h,{title:r,value:e.jsx(m,{status:i.status}),sub:S(n,i.unavailable_reason)||n(`state.${i.status}`),footer:i.as_of?e.jsx(b,{value:i.as_of}):void 0});const l=i.status!=="ok"?e.jsx(y,{status:i.status,reason:i.unavailable_reason}):void 0,v=l||i.as_of?e.jsxs(e.Fragment,{children:[l,i.as_of&&e.jsx(b,{value:i.as_of})]}):void 0,f=O(i.cells).sort((u,p)=>u.date<p.date?1:-1)[0];if(!f)return e.jsx(h,{title:r,value:e.jsx("span",{className:"flat",children:"—"}),sub:S(n,i.unavailable_reason)||n("state.no_data"),footer:v});const _=f.amount!==null?e.jsx(F,{value:f.amount,currency:f.currency,signed:!0}):e.jsx(B,{value:f.return_percent}),d=f.value_kind==="pnl"?n("perf.value_kind_pnl"):n("perf.value_kind_asset_change");return e.jsx(h,{title:r,value:_,sub:d,footer:v})}function ve({state:a}){const t=j(),s=C(),n=()=>s({page:"decisions"}),r=t("overview.todos");if(a.phase==="loading")return e.jsx(h,{title:r,value:e.jsx(N,{height:28,width:"70%"}),onClick:n});if(a.phase==="error"||a.data.status==="read_failed")return e.jsx(h,{title:r,value:e.jsx(m,{status:"read_failed"}),sub:t(`inbox.error.${G(a.data,a.error)}.title`),onClick:n});const o=a.data,i=o.items.filter(l=>l.status==="pending"),c=i.filter(l=>l.priority==="high").length;return e.jsx(h,{title:r,value:i.length,sub:t("overview.todos_urgent",{count:c}),footer:o.status==="partial"?e.jsx(y,{status:"partial"}):void 0,onClick:n})}function pe({state:a}){const t=j(),s=C(),n=()=>s({page:"health"}),r=t("overview.runs_card_title");if(a.phase==="loading")return e.jsx(h,{title:r,value:e.jsx(N,{height:28,width:"70%"}),onClick:n});if(a.phase==="error"||a.data.status==="read_failed")return e.jsx(h,{title:r,value:e.jsx(m,{status:"read_failed"}),sub:t("state.read_failed"),onClick:n});const o=a.data,{configured:i,observed:c}=o.counts,l=Number.isSafeInteger(i)&&i>0&&Number.isSafeInteger(c)&&c>=0,v=l?`${c}/${i}`:e.jsx(m,{status:"unknown"}),f=new Set((o.accounts??[]).map(x=>x.unavailable_reason).filter(x=>typeof x=="string"&&x!=="")),_=f.has("runtime_daily_binding_conflict")?"runtime_daily_binding_conflict":f.has("runtime_daily_not_connected")?"runtime_daily_not_connected":void 0,d=te(o),u=o.market_session==="trading_day"?"overview.business_date":"overview.calendar_date",p=l?e.jsxs(e.Fragment,{children:[t(u,{value:o.date}),!d&&c===0&&e.jsxs(e.Fragment,{children:[" · ",t("overview.no_records_for_day")]})]}):t("state.no_data");return e.jsx(h,{title:r,value:v,sub:p,footer:d?e.jsx($,{tone:"unknown",children:t("overview.non_trading_day_short")}):o.status==="partial"?e.jsx(y,{status:"partial",reason:_}):void 0,onClick:n})}function fe(a){if(!a)return[];const t=a.curve_status??a.status,s=a.curve_unavailable_reason===void 0?a.unavailable_reason:a.curve_unavailable_reason;return(a.history_per_currency?.length?a.history_per_currency.map(r=>({currency:r.currency,status:r.status,reason:r.unavailable_reason,asOf:r.as_of,coverage:r.coverage,points:r.points})):[{currency:a.currency??"",status:t,reason:s,asOf:a.as_of,coverage:a.curve_coverage,points:a.points}]).flatMap(r=>{const o=[];let i=!1;for(const c of r.points){if(!Number.isFinite(c.value)){i=!0;continue}o.push(i&&!c.breakBefore?{...c,breakBefore:!0}:c),i=!1}return!k(r.status)||!r.currency||o.length===0?[]:[{currency:r.currency,status:r.status,reason:r.reason,asOf:r.asOf,points:o,partial:o.some(c=>c.partial)||!!r.coverage?.truncated||!!r.coverage?.read_failures?.length}]})}function he(a,t){return a.length?a.find(s=>s.currency===t)??a[0]:null}function _e({returns:a,assets:t}){const s=j(),n=C(),r=V(),[o,i]=E.useState(null),c=()=>n({page:"performance"});let l,v=s("overview.equity_trend"),f=null,_=null;const d=a.phase==="ready"&&k(a.data.status)&&a.data.points.length>0;if(a.phase==="loading")l=e.jsx(N,{height:220});else if(a.phase==="error")l=e.jsx(A,{onRetry:a.reload});else if(d){const u=a.data;u.return_kind==="twr"&&K(u)!=="unknown"||(v=s("perf.asset_change_title"));const x=[{id:"main",label:r,color:"var(--accent)",points:u.points,primary:!0}];l=e.jsx(X,{series:x,mode:"cumulative",ariaLabel:v,alignStart:u.aligned_start}),(u.status==="partial"||u.status==="stale")&&(_=e.jsxs("div",{className:"card-note overview-trend-note",children:[u.status==="partial"?e.jsx($,{tone:"warn",children:s("state.partial_valuation")}):e.jsx(y,{status:u.status}),u.as_of&&e.jsx(b,{value:u.as_of})]}))}else{const u=fe(t.phase==="ready"?t.data:null),p=he(u,o);t.phase==="loading"?l=e.jsx(N,{height:220}):t.phase==="error"?l=e.jsx(A,{onRetry:t.reload}):p?(v=s("perf.asset_balance_title"),u.length>1&&(f=e.jsx("div",{className:"overview-currency-switch",children:e.jsx("div",{className:"segmented",role:"group","aria-label":s("perf.currency_switch"),children:u.map(x=>e.jsx("button",{type:"button",className:`segment${x.currency===p.currency?" active":""}`,"aria-pressed":x.currency===p.currency,onClick:()=>i(x.currency),children:x.currency},x.currency))})})),l=e.jsx(Z,{points:p.points,currency:p.currency,ariaLabel:v}),(p.status!=="ok"||p.partial)&&(_=e.jsxs("div",{className:"card-note overview-trend-note",children:[e.jsx(y,{status:p.status==="ok"?"partial":p.status,reason:p.reason}),p.asOf&&e.jsx(b,{value:p.asOf})]}))):l=e.jsx(M,{title:s(`state.${k(a.data.status)?"no_data":a.data.status}`)})}return e.jsxs("div",{className:"card overview-link-card overview-trend-card",children:[e.jsxs("div",{className:"overview-card-head",children:[e.jsx("h2",{className:"card-title",children:v}),e.jsxs("button",{type:"button",className:"overview-trend-open",onClick:c,children:[s("overview.open_performance")," ",e.jsx("span",{"aria-hidden":"true",children:"→"})]})]}),f,l,_]})}const L={high:0,medium:1,normal:2};function xe(a,t){const s=+(t.category==="reconciliation_recovery")-+(a.category==="reconciliation_recovery");return s!==0?s:(L[a.priority]??3)-(L[t.priority]??3)||(t.created_at||"").localeCompare(a.created_at||"")}function me({item:a,onOpen:t}){const s=j(),n=z(),r=s(a.title_key),o=a.expires_at?W(a.expires_at,n):null;return e.jsx("li",{className:"overview-queue-item",children:e.jsxs("button",{type:"button",className:"overview-queue-open",onClick:t,children:[e.jsxs("span",{className:"overview-queue-main",children:[e.jsx("span",{className:"overview-queue-title",children:r===a.title_key?a.short_id:r}),e.jsxs("span",{className:"overview-queue-meta",children:[e.jsx($,{tone:a.category==="reconciliation_recovery"?"warn":"accent",children:s(`category.${a.category}`)}),e.jsx("span",{children:a.account_alias||s("decisions.account_unbound")}),e.jsx("span",{children:s("decisions.ref",{id:a.short_id})}),o&&e.jsx("span",{children:s("overview.expires_plain",{value:o.zone?`${o.text} (${o.zone})`:o.text})})]})]}),e.jsx(ne,{state:a.evidence_freshness?.status,observedAt:a.evidence_freshness?.as_of})]})})}function je({inbox:a,onRetry:t}){const s=j(),n=C(),r=()=>n({page:"decisions"});let o;if(a.phase==="loading")o=e.jsx(N,{height:88});else if(a.phase==="error"||a.phase==="ready"&&a.data.status==="read_failed"&&a.data.items.length===0)o=e.jsxs(e.Fragment,{children:[e.jsx("p",{className:"cockpit-note error",role:"status",children:s("overview.queue_read_failed")}),e.jsx("button",{type:"button",className:"button button-secondary button-sm",onClick:t,children:s("common.retry")})]});else{const i=a.data,c=i.status==="ok"&&i.sources.every(d=>d.status==="ok"),l=Date.now(),v=i.items.filter(d=>d.status==="pending"&&!(d.expires_at&&Date.parse(d.expires_at)<l)).sort(xe),f=v.filter(d=>!["fresh","ready"].includes(d.evidence_freshness?.status??"")).length,_=v.filter(d=>d.priority==="high").length;o=e.jsxs(e.Fragment,{children:[e.jsx("p",{className:"overview-queue-lede",children:c?v.length===0?s("overview.queue_complete_empty"):s("overview.needs_review",{count:v.length}):s("overview.queue_incomplete")}),c&&v.length>0&&e.jsxs("p",{className:"overview-queue-counts",children:[e.jsx("span",{children:s("overview.queue_blocked",{count:f})}),e.jsx("span",{children:s("overview.queue_high_priority",{count:_})})]}),v.length>0&&e.jsx("ul",{className:"overview-queue-list",children:v.slice(0,3).map(d=>e.jsx(me,{item:d,onOpen:r},d.id))}),e.jsx("button",{type:"button",className:"button button-secondary button-sm",onClick:r,children:s("overview.queue_more")})]})}return e.jsxs("section",{className:"card overview-queue","aria-label":s("overview.decision_queue"),children:[e.jsx("div",{className:"overview-card-head",children:e.jsx("h2",{className:"card-title",children:s("overview.decision_queue")})}),o]})}function $e(){const a=j(),{scope:t}=P(),[s,n]=E.useState(0),r=()=>n(T=>T+1),o=new Date,i=o.getFullYear(),c=o.getMonth()+1,l=g(()=>I(t,w),[t,s]),v=g(()=>Q(t,w),[t,s]),f=g(()=>R(t,w,i,c),[t,s]),_=f.phase==="ready"?ie(f.data):null,d=g(()=>_?R(t,w,_.year,_.month):Promise.resolve(null),[t,s,_?`${_.year}-${_.month}`:""]),u=g(()=>Y(s>0),[s]),p=g(()=>H(),[s]),x=g(()=>U(t,w),[t,s]);return e.jsxs("div",{className:"page",children:[e.jsxs("div",{className:"page-header",children:[e.jsx("h1",{className:"page-title",children:a("nav.overview")}),e.jsx("div",{className:"page-header-actions",children:e.jsx("button",{type:"button",className:"button button-secondary",onClick:r,children:a("common.refresh")})})]}),e.jsx(je,{inbox:u,onRetry:u.reload}),e.jsxs("section",{className:"overview-summary","aria-label":a("overview.asset_summary"),children:[e.jsx("div",{className:"overview-primary-kpi",children:e.jsx(ce,{state:l})}),e.jsxs("div",{className:"overview-secondary-kpis",children:[e.jsx(ue,{state:v}),e.jsx(de,{state:f,carryover:_,carryoverState:d}),e.jsx(ve,{state:u}),e.jsx(pe,{state:p})]})]}),e.jsx(_e,{returns:x,assets:l}),e.jsxs("section",{className:"card overview-activity","aria-label":a("overview.latest_activity"),children:[e.jsx("div",{className:"overview-card-head",children:e.jsx("h2",{className:"card-title",children:a("overview.latest_activity")})}),e.jsx(se,{},s)]})]})}export{_e as TrendCard,fe as assetBalanceHistories,ie as carryoverMonthForLatestDay,$e as default,he as selectAssetHistory};
" },
+  "/v2/assets/PerformancePage-B3t2Ex7X.js": { contentType: "text/javascript; charset=utf-8", base64: "import{u as C,a as re,j as e,g as L,E as F,S as z,A as U,P as ae,M as Y,k as V,n as J,o as pe,p as ne,r as P,c as R,q as Fe,e as Pe,s as le,t as se,v as Ae,l as ze,B as qe,w as Oe,x as Ve,y as He,R as Ie,f as Ye,i as Ue}from"./index-CwQsWZdm.js";import{u as O}from"./hooks-9usXmJc_.js";import{K as S}from"./KpiCard-DmeG7oeQ.js";import{c as H,r as j,D as ce,U as ie,u as Te,i as me,L as Re,C as We,A as _e,F as Ze}from"./cashflowMethod-BoxXysdG.js";import{D as Me}from"./DataTable-CNz0DyJ6.js";import{T as Qe}from"./Tabs-BP4xZNhq.js";const Xe=["纳斯达克100","标普500"];function De(a,n,l){let r;if(a==="all"){const i=l.filter(p=>p.paper===!1);r=(i.length>0?i:l).map(p=>p.platform)}else{const i=n||a.slice(0,Math.max(0,a.indexOf(":")));r=i?[i]:[]}r=[...new Set(r.filter(Boolean))];const t=r.includes("binance"),o=r.some(i=>i!=="binance");return t?{enabled:!1,reason:o?"mixed":"crypto",defaults:[]}:{enabled:!0,reason:null,defaults:Xe}}function Ge(a){return!a||a==="USD"}function Je(a){return a.twr_return_percent===null&&a.amount===null&&a.max_drawdown.percent===null&&(a.per_currency??[]).every(n=>n.max_drawdown.percent===null)&&a.excess_returns.every(n=>n.percentage_points===null)&&a.best_day===null&&a.worst_day===null}function W({status:a}){const n=C();return e.jsxs("span",{className:"flat kpi-empty-value","data-state":a,children:["—",e.jsx("span",{className:"sr-only",children:n(`state.${a}`)})]})}function ea({data:a}){const n=C(),l=H(a),r=n(l==="unknown"?"perf.card.return_value":"perf.card.twr");if(!j(a.status))return e.jsx(S,{title:r,value:e.jsx(W,{status:a.status})});if(a.twr_return_percent===null){const o=a.metric_reasons?.twr??a.unavailable_reason;return e.jsx(S,{title:r,value:e.jsx("span",{className:"flat","data-state":"unavailable","data-reason":o??void 0,children:"—"}),sub:n("state.unavailable")})}const t=l==="dietz_approx"?n(ce):l==="unknown"?n(ie):void 0;return e.jsx(S,{title:r,value:e.jsx(ae,{value:a.twr_return_percent}),sub:t})}function aa({data:a}){const n=C(),l=a.value_kind==="pnl"?n("perf.card.amount"):n("perf.card.amount_asset_change");return j(a.status)?a.unavailable_reason==="mixed_currency"||a.amount===null?e.jsx(S,{title:l,value:e.jsx("span",{className:"flat",children:"—"}),sub:n("state.unavailable")}):e.jsx(S,{title:l,value:e.jsx(Y,{value:a.amount,currency:a.currency,signed:!0})}):e.jsx(S,{title:l,value:e.jsx(W,{status:a.status})})}function fe(a,n){const l=H(a);return l==="dietz_approx"?n(ce):l==="unknown"?n(ie):null}function sa({data:a}){const n=C(),l=V(),r=n(H(a)==="unknown"?"perf.drawdown_plain_title":"perf.drawdown_twr_title");if(a.per_currency?.length&&a.unavailable_reason!=="stored_records_unreadable")return e.jsx(S,{title:r,value:e.jsx("span",{className:"currency-totals",children:a.per_currency.map(p=>{const u=p.max_drawdown,h=u.percent,_=h!==null,y=_?fe(p,n):null,k=_?null:u.unavailable_reason?n(`reason.${u.unavailable_reason}`):n("state.unavailable"),x=_&&u.peak_date&&u.trough_date?n("perf.card.max_drawdown_dates",{peak:J(u.peak_date,l),trough:J(u.trough_date,l)}):null;return e.jsxs("span",{className:"currency-total","data-state":u.unavailable_reason||void 0,children:[e.jsx("span",{className:"kpi-sub",children:p.currency}),y&&e.jsx("span",{className:"kpi-sub",children:y}),h===null?e.jsx("span",{className:"flat","data-reason":u.unavailable_reason??void 0,children:"—"}):e.jsx(ae,{value:-h||0}),k&&e.jsx("span",{className:"kpi-sub",children:k}),x&&e.jsx("span",{className:"kpi-sub",children:x})]},p.currency)})})});if(!j(a.status))return e.jsx(S,{title:r,value:e.jsx(W,{status:a.status})});const t=a.max_drawdown;if(t.percent===null)return e.jsx(S,{title:r,value:e.jsx("span",{className:"flat",children:"—"}),sub:n("state.unavailable")});const o=t.peak_date&&t.trough_date?n("perf.card.max_drawdown_dates",{peak:J(t.peak_date,l),trough:J(t.trough_date,l)}):void 0,s=[fe(a,n),o].filter(Boolean).join(" · ")||void 0;return e.jsx(S,{title:r,value:e.jsx(ae,{value:-t.percent||0}),sub:s})}function na({data:a,policy:n}){const l=C(),r=V(),t=l("perf.card.excess");if(!j(a.status))return e.jsx(S,{title:t,value:e.jsx(W,{status:a.status})});if(!n.enabled)return e.jsx(S,{title:t,value:e.jsx("span",{className:"flat",children:"—"}),sub:l("perf.benchmark_not_applicable")});const o=n.defaults.flatMap(h=>a.excess_returns.filter(_=>_.benchmark===h)),i=o.find(h=>h.percentage_points!==null);if(!i||i.percentage_points===null)return e.jsx(S,{title:t,value:e.jsx("span",{className:"flat",children:"—"}),sub:l("state.unavailable")});const s=i.percentage_points,p=o.filter(h=>h!==i&&h.percentage_points!==null),u=p.length?e.jsx("span",{className:"perf-excess-list",children:p.map(h=>e.jsxs("span",{children:[h.benchmark," ",pe(h.percentage_points,r)]},h.benchmark))}):i.benchmark;return e.jsx(S,{title:t,value:e.jsx("span",{className:s>0?"up":s<0?"down":"flat",children:pe(s,r)}),sub:u})}function he({data:a,field:n,titleKey:l}){const r=C(),t=r(l);if(!j(a.status))return e.jsx(S,{title:t,value:e.jsx(W,{status:a.status})});const o=a[n];if(!o||!j(o.status))return e.jsx(S,{title:t,value:e.jsx("span",{className:"flat",children:"—"}),sub:r("state.no_data")});const i=o.amount!==null?e.jsx(Y,{value:o.amount,currency:a.currency,signed:!0}):e.jsx(ae,{value:o.return_percent}),s=o.value_kind==="asset_change"?` · ${r("perf.value_kind_asset_change")}`:"";return e.jsx(S,{title:t,value:i,sub:`${o.date}${s}`})}function ta({scope:a,platform:n,state:l,chartAvailable:r}){const t=C(),{options:o}=re(),i=De(a,n,o);if(l.phase==="loading"){const y=["perf.card.twr","perf.card.amount","perf.card.max_drawdown","perf.card.excess","perf.card.best_day","perf.card.worst_day"];return e.jsx("div",{className:"perf-kpi-grid",children:y.map(k=>e.jsx(S,{title:t(k),value:e.jsx(L,{height:28,width:"70%"})},k))})}if(l.phase==="error")return e.jsx(F,{onRetry:l.reload});const s=l.data,p=Je(s),u=s.coverage,h=!!u&&!Array.isArray(u)&&u!=="fills_not_connected"&&u.fx==="not_applied",_=s.unavailable_reason==="mixed_currency"?t(h?"perf.mixed_currency_unavailable":"perf.mixed_currency_native"):p&&r?t("perf.combined_metrics_unavailable"):null;return e.jsxs("div",{className:"section-stack",children:[(s.status!=="ok"||s.unavailable_reason||s.as_of||_)&&e.jsxs("div",{className:"metric-note perf-summary-note","data-state":s.status,"data-reason":s.unavailable_reason??void 0,children:[s.status!=="ok"&&e.jsx(z,{status:s.status}),_&&e.jsx("span",{className:"state-short",children:_}),s.as_of&&e.jsx(U,{value:s.as_of})]}),e.jsxs("div",{className:"perf-kpi-grid",children:[e.jsx(ea,{data:s}),e.jsx(aa,{data:s}),e.jsx(sa,{data:s}),e.jsx(na,{data:s,policy:i}),e.jsx(he,{data:s,field:"best_day",titleKey:"perf.card.best_day"}),e.jsx(he,{data:s,field:"worst_day",titleKey:"perf.card.worst_day"})]})]})}const ra=["var(--benchmark-1)","var(--benchmark-2)","var(--benchmark-3)","var(--benchmark-4)"],xe={标普500:"perf.benchmark_sp500",纳斯达克100:"perf.benchmark_nasdaq100",道琼斯工业平均指数:"perf.benchmark_dow",罗素2000:"perf.benchmark_russell2000"},ee={series:[],defaults:[],disabled:[]};function be(a){return a.points.length>0?{points:a.points,fallback:null}:{points:a.asset_change?.points??[],fallback:a.asset_change??null}}function la(a){if(!a)return!1;const n=a.coverage;return!n||typeof n!="object"||Array.isArray(n)?!1:n.native_daily_only===!0}function ca(a){if(typeof a!="string"||a==="")return null;const n=Date.parse(`${a}T00:00:00Z`);return Number.isFinite(n)?n:null}function Ee(a){const n=[],l=new Map;for(const t of a)l.set(t.date,(l.get(t.date)??0)+1);let r=!1;for(const t of a){const o=t.daily_return_percent;if(ca(t.date)===null||l.get(t.date)!==1||typeof o!="number"||!Number.isFinite(o)||o<-100){r=!0;continue}n.push({date:t.date,value:t.value,daily_return_percent:o,breakBefore:t.breakBefore===!0||r}),r=!1}return n}function ye(a){return a.some(n=>{const l=n.daily_return_percent;return typeof l=="number"&&Number.isFinite(l)&&l>=-100})}function ve(a,n){return n?"perf.native_daily_title":a.returnKind==="unadjusted_asset_ratio"?"perf.asset_change_title":"perf.returns_title"}function ia(a,n){if(a==="unadjusted_asset_ratio")return"perf.asset_change_tag";const l=H(n);return l==="dietz_approx"?ce:l==="unknown"?ie:"perf.return_kind_twr"}function je(a,n){if(!(n.enabled&&a.returnKind==="twr"&&H(a.method)!=="unknown"&&Ge(a.currency)))return ee;const r=a.benchmarks.filter(t=>t.points.length>0);return{series:r,defaults:n.defaults.filter(t=>r.some(o=>o.id===t)),disabled:a.disabled.filter(t=>n.defaults.includes(t.id))}}function ge({view:a,seriesLabel:n,mode:l,ariaLabel:r,benchmarks:t,disabled:o,nativeDailyOnly:i}){const s=C(),p=[{id:"main",label:n,color:"var(--accent)",points:a.points,primary:!0},...t.series.map((u,h)=>({id:u.id,label:s(xe[u.id]||"perf.benchmark_unknown"),color:ra[h],points:u.points}))];return e.jsxs("div",{"data-state":a.status,"data-reason":a.unavailableReason??void 0,children:[e.jsxs("p",{className:"card-note",style:{marginTop:0},children:[e.jsx("span",{className:"perf-kind",children:s(ia(a.returnKind,a.method))}),i&&e.jsxs("span",{className:"perf-kind","data-native-daily-tag":"true",children:[" · ",s("perf.native_daily_tag")]}),a.currency&&e.jsxs("span",{className:"perf-currency",children:[" · ",a.currency]})]}),e.jsx(Re,{series:p,mode:l,ariaLabel:r,alignStart:a.alignedStart,defaultVisible:t.series.length>0?t.defaults:void 0},`${a.currency??"native"}:${t.series.map(u=>u.id).join(",")}`),i&&e.jsx("p",{className:"card-note","data-native-daily-only":"true",children:s("perf.native_daily_note")}),o.length>0&&e.jsxs("details",{className:"perf-benchmarks-off",children:[e.jsx("summary",{children:s("perf.benchmarks_unavailable",{count:o.length})}),e.jsx("div",{className:"perf-benchmarks-off-list",children:o.map(u=>e.jsxs("span",{className:"perf-benchmark-off",title:u.unavailable_reason?s(`reason.${u.unavailable_reason}`):void 0,children:[s(xe[u.id]||"perf.benchmark_unknown")," · ",s(`state.${u.status}`)]},u.id))})]})]})}function oa({scope:a,platform:n,state:l}){const r=C(),{options:t}=re(),o=Te(a),i=ne(),[s,p]=P.useState("cumulative"),[u,h]=P.useState(null),_=l.phase==="ready"?l.data:null,y=la(_),k=d=>s==="daily"&&ye(d)?"daily":"cumulative",x=De(a,n,t),c=_?.per_account?.filter(d=>j(d.status)&&d.return_kind==="twr"&&d.points.length>0)??[],m=[];if(a==="all"&&_?.per_account)for(const d of _.per_account){if(!j(d.status)||d.return_kind!=="twr")continue;const E=Ee(d.points);E.length!==0&&m.push({key:`${d.platform}:${d.account_alias}`,platform:d.platform,accountAlias:d.account_alias,currency:d.currency??null,points:E})}const g=new Set(m.map(d=>d.key)),N=c.filter(d=>!g.has(`${d.platform}:${d.account_alias}`)),b=!!(_&&a==="all"&&_.per_currency.length>0&&(j(_.status)||_.unavailable_reason==="mixed_currency")),f=b&&_?_.per_currency.find(d=>d.currency===u)??_.per_currency.find(d=>j(d.status)&&(d.points.length>0||(d.asset_change?.points.length??0)>0))??_.per_currency[0]??null:null;let v=null,w=ee,A;if(l.phase==="loading")A=e.jsx(L,{height:280});else if(l.phase==="error")A=e.jsx(F,{onRetry:l.reload});else{const d=l.data,E=d.benchmark_availability.filter($=>!j($.status)),Q=be(d),D=Q.fallback;if(b&&f){const $=f,de=e.jsx("div",{className:"perf-currency-switch",children:e.jsx("div",{className:"segmented",role:"group","aria-label":r("perf.currency_switch"),children:d.per_currency.map(T=>e.jsx("button",{type:"button",className:`segment${T.currency===$.currency?" active":""}`,"aria-pressed":T.currency===$.currency,onClick:()=>h(T.currency),children:T.currency},T.currency))})}),X=be($),M=X.fallback,G=M?M.status:$.status,I=M?M.unavailable_reason:$.unavailable_reason;if(j(G)&&X.points.length>0){const T={points:X.points,benchmarks:M?[]:$.benchmarks,returnKind:M?"unadjusted_asset_ratio":$.return_kind,method:$,alignedStart:M?M.aligned_start:$.aligned_start,currency:$.currency,status:G,unavailableReason:I,asOf:M?M.as_of:$.as_of??null,disabled:E};v=T,w=y||M?ee:je(T,x),A=e.jsxs("div",{children:[de,M&&e.jsx("p",{className:"card-note",children:r("perf.mixed_currency_asset_change")}),e.jsx(ge,{view:T,seriesLabel:`${o} · ${$.currency}`,mode:y?"daily":k(X.points),ariaLabel:`${r(ve(T,y))} ${$.currency}`,benchmarks:w,disabled:w.disabled,nativeDailyOnly:y})]})}else{const T=j(G)?"no_data":G;A=e.jsxs("div",{children:[de,e.jsx("div",{"data-reason":I??void 0,children:e.jsx(R,{title:r(T==="no_data"&&I==="external_cashflow_required"?"perf.missing_cashflow_records":`state.${T}`),state:T,body:I?r(`reason.${I}`):void 0})})]})}}else if(!j(d.status))A=e.jsx("div",{"data-reason":d.unavailable_reason??void 0,children:e.jsx(R,{title:r(`state.${d.status}`),state:d.status,body:d.unavailable_reason?r(`reason.${d.unavailable_reason}`):void 0})});else if(Q.points.length===0)A=e.jsx("div",{"data-reason":d.unavailable_reason??void 0,children:e.jsx(R,{title:r(d.unavailable_reason==="external_cashflow_required"?"perf.missing_cashflow_records":"state.no_data"),state:"no_data",body:d.unavailable_reason?r(`reason.${d.unavailable_reason}`):void 0})});else{const $={points:Q.points,benchmarks:D?[]:d.no_common_date?[]:d.benchmarks,returnKind:D?"unadjusted_asset_ratio":d.return_kind,method:d,alignedStart:D?D.aligned_start:d.aligned_start,currency:d.currency??null,status:D?D.status:d.status,unavailableReason:D?D.unavailable_reason:d.unavailable_reason,asOf:D?D.as_of:d.as_of??null,disabled:E};v=$,w=y||D||d.no_common_date?ee:je($,x),A=e.jsx(ge,{view:$,seriesLabel:o,mode:y?"daily":k(Q.points),ariaLabel:r(ve($,y)),benchmarks:w,disabled:w.disabled,nativeDailyOnly:y})}}const q=v?.returnKind==="unadjusted_asset_ratio",te=w.series.length>0,Z=r(v?y?"perf.native_daily_title":q?"perf.asset_change_title":te?"perf.returns_title":"perf.returns_title_plain":"perf.returns_title"),Ke=!!(v&&!y&&!q&&j(v.status)&&v.points.length>0&&ye(v.points)),Le=y?"perf.method_body_native_daily":v&&q?"perf.method_body_asset_change":_&&[_,..._.per_currency].some(d=>H(d)==="unknown")?"perf.method_body_unknown":_&&(me(_)||_.per_currency.some(me))?"perf.method_body_dietz":"perf.method_body",oe=!!(v&&j(v.status)&&v.points.length>0),ue=m.length>0?e.jsxs("section",{className:"perf-account-daily","data-account-daily-count":m.length,children:[e.jsx("div",{className:"perf-card-head",children:e.jsx("h3",{className:"card-title",children:r("perf.per_account_daily_title")})}),e.jsx("p",{className:"card-note",children:r("perf.per_account_daily_note")}),m.map(d=>{const E=`${i.platform(d.platform)} · ${i.account(d.accountAlias,d.platform)}`;return e.jsxs("div",{className:"perf-account-daily-item","data-account":d.accountAlias,children:[e.jsxs("p",{className:"card-note",children:[e.jsx("span",{className:"perf-kind",children:E}),d.currency&&e.jsxs("span",{className:"perf-currency",children:[" · ",d.currency]})]}),e.jsx(Re,{series:[{id:"main",label:E,color:"var(--accent)",points:d.points,primary:!0}],mode:"daily",ariaLabel:`${r("perf.per_account_daily_title")} · ${E}`})]},d.key)})]}):null;return e.jsxs("div",{className:"card",children:[e.jsxs("div",{className:"perf-card-head",children:[e.jsx("h2",{className:"card-title",children:Z}),Ke&&e.jsx("div",{className:"perf-mode-toggle",children:e.jsxs("div",{className:"segmented",role:"group","aria-label":Z,children:[e.jsx("button",{type:"button",className:`segment${s==="cumulative"?" active":""}`,"aria-pressed":s==="cumulative",onClick:()=>p("cumulative"),children:r("perf.returns_cumulative")}),e.jsx("button",{type:"button",className:`segment${s==="daily"?" active":""}`,"aria-pressed":s==="daily",onClick:()=>p("daily"),children:r("perf.returns_daily")})]})}),e.jsxs("span",{className:"perf-head-meta",children:[v&&v.status!=="ok"&&j(v.status)&&e.jsx(z,{status:v.status,reason:v.unavailableReason}),v&&j(v.status)&&e.jsx(U,{value:v.asOf})]})]}),!oe&&ue,A,oe&&ue,N.length>0?e.jsx("p",{className:"card-note","data-native-return-accounts":N.length,children:r("perf.native_return_accounts",{accounts:N.map(d=>`${i.platform(d.platform)} · ${i.account(d.account_alias,d.platform)}`).join("、")})}):null,e.jsx(Fe,{titleKey:"perf.how_calculated",bodyKey:Le})]})}function Ne({status:a,points:n,coverage:l,reason:r}){const t=C(),o=n.some(u=>(u.forward_filled_accounts?.length||0)>0),i=o||n.some(u=>u.partial)||!!l?.truncated||!!l?.read_failures?.length,s=a==="ok"?i?"partial":"ok":a;if(s==="ok")return null;const p=[...new Set([...n.flatMap(u=>[...u.missing_accounts||[],...u.forward_filled_accounts||[]]),...l?.missing_accounts||[],...l?.excluded_accounts||[],...l?.read_failures||[]])];return e.jsxs("span",{className:"history-notice",role:"status","data-state":s,"data-reason":r??void 0,"data-affected-count":p.length||void 0,children:[e.jsx(z,{status:s}),p.length>0&&e.jsx("span",{className:"card-note",children:t("perf.history_affected_accounts",{count:p.length})}),o&&e.jsx("span",{className:"card-note",children:t("perf.history_carried_balances")}),r&&e.jsx("span",{className:"card-note",children:t(`reason.${r}`)})]})}function ua({scope:a,platform:n,range:l,epoch:r}){const t=C(),[o,i]=P.useState(null),s=O(()=>Pe(a,l,n),[a,n,l,r]);let p,u,h,_=null,y=null,k=null;if(s.phase==="loading")h=e.jsx(L,{height:220});else if(s.phase==="error")h=e.jsx(F,{onRetry:s.reload});else{const x=s.data;p=x.per_currency?.length&&x.unavailable_reason!=="stored_records_unreadable"?e.jsx(We,{totals:x.per_currency,freshness:x.freshness_summary,notes:x.per_currency.length>1?t("perf.native_totals_note"):void 0}):null,_=x.status,y=x.unavailable_reason,k=x.as_of;const c=x.curve_status||x.status,m=x.curve_unavailable_reason===void 0?x.unavailable_reason:x.curve_unavailable_reason,g=x.history_per_currency?.length?x.history_per_currency:[{currency:x.currency,status:c,coverage:x.curve_coverage,points:x.points,unavailable_reason:x.curve_unavailable_reason??x.unavailable_reason}];if(x.per_currency?.length&&m==="mixed_currency"){const N=g.filter(f=>f.points.length>0),b=N.find(f=>f.currency===o)??N[0];b?(u=e.jsx(Ne,{status:b.status,points:b.points,coverage:b.coverage,reason:b.unavailable_reason}),h=e.jsxs("div",{children:[e.jsx("div",{className:"perf-currency-switch",children:e.jsx("div",{className:"segmented",role:"group","aria-label":t("perf.currency_switch"),children:N.map(f=>e.jsx("button",{type:"button",className:`segment${f.currency===b.currency?" active":""}`,"aria-pressed":f.currency===b.currency,onClick:()=>i(f.currency??null),children:f.currency||t("perf.currency_switch")},f.currency||"native"))})}),e.jsx(_e,{points:b.points,currency:b.currency,ariaLabel:t("perf.asset_balance_title")})]})):h=e.jsx("div",{"data-reason":"mixed_currency",children:e.jsx(R,{title:t("perf.mixed_currency_title"),state:"unavailable"})})}else if(u=j(c)?g.map(N=>e.jsx(Ne,{status:g.length===1?c:N.status,points:N.points,coverage:N.coverage,reason:N.unavailable_reason},N.currency||"history")):null,!j(c))h=e.jsx("div",{"data-reason":m??void 0,children:e.jsx(R,{title:t(`state.${c}`),state:c,body:m?t(`reason.${m}`):void 0})});else if(m==="mixed_currency")h=e.jsx("div",{"data-reason":"mixed_currency",children:e.jsx(R,{title:t("perf.mixed_currency_title"),state:"unavailable"})});else if(x.points.length===0)h=e.jsx("div",{"data-reason":x.unavailable_reason??void 0,children:e.jsx(R,{title:t("state.no_data"),state:"no_data",body:m?t(`reason.${m}`):void 0})});else{const N=x.points;h=e.jsx(_e,{points:N,currency:x.currency,ariaLabel:t("perf.asset_balance_title")})}}return e.jsxs("div",{className:"card",children:[e.jsxs("div",{className:"perf-card-head",children:[e.jsx("h2",{className:"card-title",children:t("perf.asset_balance_title")}),e.jsxs("span",{className:"perf-head-meta",children:[_&&_!=="ok"&&j(_)&&e.jsx(z,{status:_,reason:y}),_&&j(_)&&k&&e.jsx(U,{value:k})]})]}),p,u,h]})}const da=["Mon","Tue","Wed","Thu","Fri","Sat","Sun"],pa={Mon:"一",Tue:"二",Wed:"三",Thu:"四",Fri:"五",Sat:"六",Sun:"日"};function K(a){return typeof a=="number"&&Number.isFinite(a)?a:null}function ke(a){const n=K(a.return_percent);return n===null?"":n>0?"up":n<0?"down":"flat"}function $e(a,n){const l=K(a.return_percent);if(l===null||l===0||n<=0)return;const r=Math.min(1,Math.abs(l)/n),t=8+Math.round(r*40);return`color-mix(in srgb, var(--${l>0?"up":"down"}) ${t}%, transparent)`}function ma({year:a,month:n,cells:l,onNavigate:r}){const t=C(),o=V(),{prefs:i}=le(),s=Math.max(0,...l.map(m=>{const g=K(m.return_percent);return g===null?0:Math.abs(g)})),p=new Date,u=`${p.getFullYear()}-${String(p.getMonth()+1).padStart(2,"0")}-${String(p.getDate()).padStart(2,"0")}`,h=u.slice(0,7),_=m=>{const g=K(m.return_percent);if(g!==null)return se(g,o);const N=K(m.amount);return N!==null?i.hideAmounts?Ae(N):String(Math.round(N)):""};if(n===null)return e.jsxs("div",{children:[e.jsxs("div",{className:"calendar-nav",children:[e.jsx("button",{type:"button",className:"button button-secondary button-sm",onClick:()=>r(a-1,null),"aria-label":"‹",children:"‹"}),e.jsx("span",{className:"current num",children:a}),e.jsx("button",{type:"button",className:"button button-secondary button-sm",onClick:()=>r(a+1,null),"aria-label":"›",children:"›"})]}),e.jsx("div",{className:"calendar-year-grid",style:{marginTop:12},children:l.map(m=>{const g=m.unavailable_reason,N=g==="snapshot_pending",b=g==="future_date"||!N&&!!(m.month&&m.month>h);return e.jsxs("button",{type:"button",className:`calendar-cell${b?" cell-future":""}${N?" cell-pending":""}${K(m.return_percent)===null&&K(m.amount)===null?" cell-empty":""}`,style:{background:b?void 0:$e(m,s)},title:b?void 0:N?t("reason.snapshot_pending"):m.unavailable_reason?t(`reason.${m.unavailable_reason}`):void 0,onClick:()=>m.month&&r(a,Number(m.month.split("-")[1])),children:[e.jsx("span",{className:"cell-date",children:m.month}),e.jsx("span",{className:`cell-value ${b?"":ke(m)}`,children:b?" ":_(m)||" "}),N&&e.jsx("span",{className:"sr-only",children:t("reason.snapshot_pending")})]},m.month)})})]});const y=new Map(l.filter(m=>m.date).map(m=>[m.date,m])),k=new Date(Date.UTC(a,n,0)).getUTCDate(),x=[];let c=[];for(let m=1;m<=k;m++){const g=`${a}-${String(n).padStart(2,"0")}-${String(m).padStart(2,"0")}`,b=(new Date(`${g}T00:00:00Z`).getUTCDay()+6)%7;for(b===0&&c.length&&(x.push(c),c=[]);c.length<b;)c.push(null);c.push(y.get(g)||{date:g,amount:null,return_percent:null,currency:null,status:"no_data",value_kind:"asset_change",unavailable_reason:null})}return c.length&&x.push(c),e.jsxs("div",{children:[e.jsxs("div",{className:"calendar-nav",children:[e.jsx("button",{type:"button",className:"button button-secondary button-sm",onClick:()=>r(...n===1?[a-1,12]:[a,n-1]),"aria-label":"‹",children:"‹"}),e.jsxs("button",{type:"button",className:"current button button-sm",onClick:()=>r(a,null),"aria-label":t("perf.calendar_year"),children:[a,"-",String(n).padStart(2,"0")]}),e.jsx("button",{type:"button",className:"button button-secondary button-sm",onClick:()=>r(...n===12?[a+1,1]:[a,n+1]),"aria-label":"›",children:"›"})]}),e.jsx("div",{className:"calendar-scroll",style:{marginTop:12},children:e.jsxs("div",{className:"calendar-month-grid",children:[da.map(m=>e.jsx("div",{className:"calendar-weekday",children:o==="zh"?pa[m]:m},m)),x.flatMap((m,g)=>[0,1,2,3,4,5,6].map(N=>{const b=m[N];if(!b)return e.jsx("div",{},`${g}-${N}`);const f=String(b.status),v=b.unavailable_reason,w=v==="snapshot_pending",A=v==="future_date"||!w&&!!(b.date&&b.date>u),q=!A&&(K(b.return_percent)!==null||K(b.amount)!==null),te=!A&&(f==="market_closed"||v==="market_closed"||v==="non_trading_weekend"),Z=A?void 0:w?t("reason.snapshot_pending"):f==="market_closed"||v==="market_closed"?t("state.market_closed"):v==="non_trading_weekend"?t("reason.non_trading_weekend"):b.unavailable_reason?t(`reason.${b.unavailable_reason}`):void 0;return e.jsxs("div",{className:`calendar-cell${A?" cell-future":""}${w?" cell-pending":""}${te?" cell-closed":""}${q?"":" cell-empty"}`,style:{background:A?void 0:$e(b,s)},title:Z,tabIndex:w?0:void 0,children:[e.jsx("span",{className:"cell-date num",children:b.date?Number(b.date.slice(8)):""}),q&&e.jsx("span",{className:`cell-value ${ke(b)}`,children:_(b)}),w&&e.jsx("span",{className:"sr-only",children:t("reason.snapshot_pending")})]},b.date)}))]})})]})}function _a({scope:a,platform:n,range:l,epoch:r}){const t=C(),o=new Date,[i,s]=P.useState({year:o.getFullYear(),month:o.getMonth()+1}),[p,u]=P.useState(null),h=p?.scope===a&&p.platform===n?p.currency:void 0,_=O(()=>ze(a,l,i.year,i.month,n,h),[a,n,l,i.year,i.month,h,r]);let y,k=null,x=null,c=null,m=!1,g=!1,N=!1,b;if(_.phase==="loading")y=e.jsx(L,{height:220});else if(_.phase==="error")y=e.jsx(F,{onRetry:_.reload});else{const f=_.data;k=f.status,x=f.unavailable_reason,c=f.as_of,m=f.value_kind==="asset_change",g=!!f.coverage&&typeof f.coverage=="object"&&!Array.isArray(f.coverage)&&f.coverage.asset_change_fallback===!0,N=f.cells.some(v=>v.observed_amount!==null&&v.observed_amount!==void 0),(f.available_currencies?.length||0)>1&&(b=e.jsx("div",{className:"perf-currency-switch",children:e.jsx("div",{className:"segmented",role:"group","aria-label":t("perf.currency_switch"),children:f.available_currencies.map(v=>e.jsx("button",{type:"button",className:`segment${v===f.currency?" active":""}`,"aria-pressed":v===f.currency,onClick:()=>u({scope:a,platform:n,currency:v}),children:v},v))})})),j(f.status)?f.cells.length===0?y=e.jsx("div",{"data-reason":f.unavailable_reason??void 0,children:e.jsx(R,{title:t("state.no_data"),state:"no_data",body:f.unavailable_reason?t(`reason.${f.unavailable_reason}`):void 0})}):y=e.jsx(ma,{year:f.year,month:f.month,cells:f.cells,onNavigate:(v,w)=>s({year:v,month:w})}):y=e.jsx("div",{"data-reason":f.unavailable_reason??void 0,children:e.jsx(R,{title:t(`state.${f.status}`),state:f.status,body:f.unavailable_reason?t(`reason.${f.unavailable_reason}`):void 0})})}return e.jsxs("div",{className:"card",children:[e.jsxs("div",{className:"perf-card-head",children:[e.jsx("h2",{className:"card-title",children:t(m?"perf.asset_change_title":"perf.calendar_title")}),e.jsxs("div",{className:"segmented",role:"group","aria-label":t("perf.calendar_title"),children:[e.jsx("button",{type:"button",className:`segment${i.month!==null?" active":""}`,"aria-pressed":i.month!==null,onClick:()=>s(f=>({...f,month:f.month??new Date().getMonth()+1})),children:t("perf.calendar_month")}),e.jsx("button",{type:"button",className:`segment${i.month===null?" active":""}`,"aria-pressed":i.month===null,onClick:()=>s(f=>({...f,month:null})),children:t("perf.calendar_year")})]}),e.jsxs("span",{className:"perf-head-meta",children:[m&&e.jsx(qe,{tone:"accent",title:t("perf.asset_change_note"),children:t("perf.asset_change_calendar_tag")}),k&&k!=="ok"&&j(k)&&e.jsx(z,{status:k,reason:x}),k&&j(k)&&e.jsx(U,{value:c})]})]}),b,y,g&&e.jsx("p",{className:"card-note","data-asset-change-fallback":"true",children:t("perf.calendar_fallback_note")}),N&&e.jsx("p",{className:"card-note",children:t("perf.calendar_deposit_note")})]})}function Se({items:a}){const n=V(),l=Math.max(1e-9,...a.map(r=>Math.abs(r.value)));return e.jsx("div",{className:"barlist",children:a.map(r=>{const t=Math.abs(r.value)/l*50,o=r.value>0;return e.jsxs("div",{className:"barlist-row",children:[e.jsx("span",{className:"barlist-label",title:r.label,children:r.label}),e.jsx("div",{className:"barlist-track",role:"img","aria-label":`${r.label} ${se(r.value,n)}`,children:e.jsx("div",{className:"barlist-fill",style:{background:o?"var(--up)":"var(--down)",width:`${t}%`,left:o?"50%":`${50-t}%`}})}),e.jsx("span",{className:`barlist-value ${o?"up":r.value<0?"down":"flat"}`,children:se(r.value,n)})]},r.id)})})}const Ce=5;function fa({value:a}){const n=V();return e.jsx("span",{className:"num",children:He(a,n)})}function ha({state:a}){const n=C(),l=ne();if(a.phase==="loading")return e.jsxs("div",{className:"section-stack",children:[e.jsx(L,{height:32}),e.jsx(L,{height:32}),e.jsx(L,{height:32})]});if(a.phase==="error")return e.jsx(F,{onRetry:a.reload});const r=a.data;if(!j(r.status))return e.jsx(R,{title:n(`state.${r.status}`),state:r.status});const t=[{id:"account",header:n("perf.col.account"),cell:s=>l.account(s.account_alias,s.platform),sortValue:s=>s.account_alias},{id:"symbol",header:n("perf.col.symbol"),cell:s=>e.jsx("span",{className:"holding-symbol",children:s.symbol}),sortValue:s=>s.symbol},{id:"quantity",header:n("perf.col.quantity"),numeric:!0,cell:s=>j(s.status)?e.jsx(fa,{value:s.quantity}):"—",sortValue:s=>s.quantity},{id:"market_value",header:`${n("perf.col.market_value")} (${n("perf.col.currency")})`,numeric:!0,cell:s=>j(s.status)?e.jsx(Y,{value:s.market_value,currency:s.currency}):"—",sortValue:s=>s.market_value},{id:"avg_cost",header:n("perf.col.cost_basis"),numeric:!0,cell:s=>j(s.status)?s.avg_cost!==null&&Number.isFinite(s.avg_cost)?e.jsx(Y,{value:s.avg_cost,currency:s.currency}):we(s)!==null?e.jsxs("div",{className:"holding-broker-cost",children:[e.jsx(B,{value:we(s),currency:s.currency}),e.jsx("small",{children:n("perf.broker_cost_label")})]}):"—":"—",sortValue:s=>s.avg_cost},{id:"unrealized_pnl",header:n("perf.col.unrealized_pnl"),numeric:!0,cell:s=>j(s.status)?e.jsx(Y,{value:s.unrealized_pnl,currency:s.currency,signed:!0}):"—",sortValue:s=>s.unrealized_pnl},{id:"status",header:n("common.status"),cell:s=>e.jsxs("div",{className:"holding-status",children:[s.status!=="ok"&&e.jsx(z,{status:s.status,reason:s.unavailable_reason}),j(s.status)&&["quantity","market_value","avg_cost","unrealized_pnl"].some(p=>s[p]===null)&&e.jsx("small",{children:n("perf.fields_not_provided",{fields:["quantity","market_value","avg_cost","unrealized_pnl"].filter(p=>s[p]===null).map(p=>n(p==="avg_cost"?"perf.average_cost_field":`perf.col.${p}`)).join(" / ")})})]})}],o=r.coverage,i=Array.isArray(o)?o.length:o&&typeof o=="object"&&Array.isArray(o.account_aliases)?o.account_aliases.length:void 0;return e.jsxs("div",{className:"holdings-view","data-state":r.status,"data-reason":r.unavailable_reason??void 0,"data-coverage-count":i,children:[e.jsxs("p",{className:"card-note",style:{marginTop:0},children:[n(r.label_key),r.status!=="ok"&&e.jsxs(e.Fragment,{children:[" · ",e.jsx(z,{status:r.status})]})]}),r.rows.some(s=>j(s.status)&&[s.market_value,s.avg_cost,s.unrealized_pnl].some(p=>p===null))&&e.jsx("p",{className:"card-note",children:n("perf.holdings_missing_fields")}),e.jsx("p",{className:"card-note holdings-scroll-hint",children:n("perf.holdings_scroll_hint")}),e.jsx(Me,{columns:t,rows:r.rows,rowKey:s=>`${s.platform}:${s.account_alias}|${s.symbol}`,defaultSort:{column:"market_value",direction:"desc"},caption:n("perf.holdings_title")})]})}function xa(a){if(!j(a.status))return null;const n=a.unrealized_pnl,l=a.unrealized_pnl_percent;if(typeof n!="number"||!Number.isFinite(n)||typeof l!="number"||!Number.isFinite(l))return null;const r=typeof a.currency=="string"&&a.currency.trim()?a.currency.trim():null;return{row:a,id:`${a.platform}:${a.account_alias}|${a.symbol}`,symbol:a.symbol,currency:r,pnl:n,value:l}}function ba(a,n){const l=a.map(xa).filter(i=>i!==null),r=l.filter(i=>i.currency===null).length,t=new Map;for(const i of l){if(i.currency===null)continue;const s=t.get(i.currency);s?s.push(i):t.set(i.currency,[i])}return{groups:[...t.entries()].sort(([i],[s])=>i.localeCompare(s)).map(([i,s])=>{const p=u=>({id:u.id,label:`${u.symbol} · ${n(u.row)}`,value:u.value});return{currency:i,winners:s.filter(u=>u.pnl>0).sort((u,h)=>h.pnl-u.pnl).slice(0,Ce).map(p),losers:s.filter(u=>u.pnl<0).sort((u,h)=>u.pnl-h.pnl).slice(0,Ce).map(p)}}).filter(i=>i.winners.length>0||i.losers.length>0),rankedCount:l.length-r,missingCurrencyCount:r}}function ya({state:a}){const n=C(),l=ne();if(a.phase==="loading")return e.jsx(L,{height:160});if(a.phase==="error")return e.jsx(F,{onRetry:a.reload});const r=a.data;if(!j(r.status))return e.jsx(R,{title:n(`state.${r.status}`),state:r.status});const{groups:t,rankedCount:o,missingCurrencyCount:i}=ba(r.rows,s=>l.account(s.account_alias,s.platform));if(!t.length){const s=i>0?n("perf.ranking_missing_currency"):o>0?void 0:r.rows.length>0?n("perf.ranking_missing_fields"):r.unavailable_reason?n(`reason.${r.unavailable_reason}`):n("reason.positions_not_connected");return e.jsx(R,{title:n(o>0?"perf.ranking_no_movement":"perf.ranking_unavailable"),body:s})}return e.jsxs("div",{children:[t.map(s=>e.jsxs("section",{className:"perf-ranking-currency","data-currency":s.currency,children:[e.jsx("h3",{className:"perf-ranking-heading perf-ranking-currency-heading",children:s.currency}),s.winners.length>0&&e.jsxs("div",{className:"perf-ranking-section",children:[e.jsx("h4",{className:"perf-ranking-heading",children:n("perf.ranking_winners")}),e.jsx(Se,{items:s.winners})]}),s.losers.length>0&&e.jsxs("div",{className:"perf-ranking-section",children:[e.jsx("h4",{className:"perf-ranking-heading",children:n("perf.ranking_losers")}),e.jsx(Se,{items:s.losers})]})]},s.currency)),i>0&&e.jsx("p",{className:"card-note",children:n("perf.ranking_missing_currency")}),e.jsx("p",{className:"card-note",children:n("perf.native_totals_note")}),e.jsx("p",{className:"card-note",children:n("perf.ranking_note")})]})}const Be=/^-?(?:0|[1-9]\d*)(?:\.\d+)?$/;function we(a){return a.platform==="longbridge"&&a.broker_cost_method==="broker_configured"&&typeof a.broker_cost_price=="string"&&Be.test(a.broker_cost_price)?a.broker_cost_price:null}function va(a){const n=a.startsWith("-"),l=n?a.slice(1):a,[r,t]=l.split("."),o=r.replace(/\B(?=(\d{3})+(?!\d))/g,",");return`${n?"-":""}${o}${t===void 0?"":`.${t}`}`}function B({value:a,currency:n}){const{prefs:l}=le();return typeof a!="string"||!Be.test(a)?e.jsx("span",{className:"flat",children:"—"}):l.hideAmounts?e.jsx("span",{className:"money",children:Ae(a)}):e.jsxs("span",{className:"num",title:a,children:[va(a),n?` ${n}`:""]})}function ja({scope:a,platform:n,range:l,epoch:r}){const t=C(),o=ne(),i=O(()=>Ve(a,l,n),[a,n,l,r]);if(i.phase==="loading")return e.jsx(L,{height:48});if(i.phase==="error")return e.jsx(F,{onRetry:i.reload});const s=i.data;if(!s||!Array.isArray(s.rows))return e.jsx(F,{onRetry:i.reload});const p=s.rows;if(!p.length&&s.status==="not_connected")return e.jsx(R,{title:t("state.not_connected"),body:t("reason.fills_not_connected"),state:"not_connected"});const u=[...p].sort((c,m)=>String(m.trade_date??"").localeCompare(String(c.trade_date??""))),h=c=>c.side==="BUY"?t("perf.side.buy"):c.side==="SELL"?t("perf.side.sell"):"—",_=[{id:"trade_date",header:t("perf.col.date"),cell:c=>e.jsxs(e.Fragment,{children:[e.jsx("span",{className:"num","data-asset-category":c.asset_category,"data-execution-ref":c.execution_ref,children:c.trade_date}),c.local_time&&e.jsxs("small",{className:"trade-time",children:[c.local_time.slice(11),c.time_zone?` · ${c.time_zone}`:""]})]}),sortValue:c=>c.trade_date},{id:"account",header:t("perf.col.account"),cell:c=>e.jsxs(e.Fragment,{children:[o.account(c.account_alias,c.platform),e.jsx("small",{className:"trade-time",children:o.platform(c.platform)})]}),sortValue:c=>`${c.platform}:${c.account_alias}`},{id:"symbol",header:t("perf.col.symbol"),cell:c=>c.symbol,sortValue:c=>c.symbol},{id:"side",header:t("perf.col.side"),cell:h},{id:"quantity",header:t("perf.col.quantity"),numeric:!0,cell:c=>e.jsx(B,{value:c.quantity})},{id:"price",header:t("perf.col.price"),numeric:!0,cell:c=>e.jsx(B,{value:c.price,currency:c.currency})},{id:"commission",header:t("perf.col.commission"),numeric:!0,cell:c=>e.jsx(B,{value:c.commission,currency:c.commission_currency})},{id:"taxes",header:t("perf.col.taxes"),numeric:!0,cell:c=>e.jsx(B,{value:c.taxes,currency:c.currency})}],y=s.reported_execution_count??p.length,k=s.status==="partial"||s.status==="ok"?"no_data":s.status,x=s.status==="partial"?t("perf.executions_empty_partial"):s.status==="ok"?void 0:s.unavailable_reason?t(`reason.${s.unavailable_reason}`):void 0;return e.jsxs("div",{className:"trade-view","data-state":s.status,"data-reason":s.unavailable_reason??void 0,children:[e.jsxs("div",{className:"trade-summary",children:[y>0&&e.jsx("span",{className:"card-note",children:t("perf.executions_count",{count:y})}),s.status==="partial"&&e.jsx("span",{className:"state-short",title:t("perf.executions_partial"),children:t("perf.executions_partial_short")}),s.as_of&&e.jsx(U,{value:s.as_of})]}),u.length?e.jsxs(e.Fragment,{children:[e.jsx("div",{className:"trade-table",children:e.jsx(Me,{columns:_,rows:u,rowKey:c=>`${c.platform}:${c.account_alias}:${c.execution_ref}`,defaultSort:{column:"trade_date",direction:"desc"},caption:t("perf.trades_title")})}),e.jsx("ul",{className:"trade-cards","aria-label":t("perf.trades_title"),children:u.map(c=>e.jsxs("li",{className:"trade-card","data-asset-category":c.asset_category,"data-execution-ref":c.execution_ref,children:[e.jsxs("div",{className:"trade-card-head",children:[e.jsx("span",{className:"trade-card-date num",children:c.trade_date}),e.jsx("span",{className:"trade-card-symbol",children:c.symbol}),e.jsx("span",{className:"trade-side",children:h(c)}),c.local_time&&e.jsxs("span",{className:"trade-card-time",children:[c.local_time.slice(11),c.time_zone?` · ${c.time_zone}`:""]})]}),e.jsx("div",{className:"trade-card-account",children:o.account(c.account_alias,c.platform)}),e.jsxs("dl",{className:"trade-card-figures",children:[e.jsxs("div",{className:"trade-figure",children:[e.jsx("dt",{children:t("perf.col.quantity")}),e.jsx("dd",{children:e.jsx(B,{value:c.quantity})})]}),e.jsxs("div",{className:"trade-figure",children:[e.jsx("dt",{children:t("perf.col.price")}),e.jsx("dd",{children:e.jsx(B,{value:c.price,currency:c.currency})})]}),e.jsxs("div",{className:"trade-figure",children:[e.jsx("dt",{children:t("perf.col.commission")}),e.jsx("dd",{children:e.jsx(B,{value:c.commission,currency:c.commission_currency})})]}),e.jsxs("div",{className:"trade-figure",children:[e.jsx("dt",{children:t("perf.col.taxes")}),e.jsx("dd",{children:e.jsx(B,{value:c.taxes,currency:c.currency})})]})]})]},`${c.platform}:${c.account_alias}:${c.execution_ref}`))})]}):e.jsx(R,{title:t(`state.${k}`),body:x,state:k})]})}function ga({scope:a,platform:n,range:l,epoch:r}){const t=C(),[o,i]=P.useState("holdings"),s=O(()=>Oe(a,l,n),[a,n,l,r]);let p;return o==="holdings"?p=e.jsx(ha,{state:s}):o==="ranking"?p=e.jsx(ya,{state:s}):p=e.jsx(ja,{scope:a,platform:n,range:l,epoch:r}),e.jsxs("div",{className:"card",children:[e.jsx(Qe,{id:"performance",items:[{id:"holdings",label:t("perf.holdings_title")},{id:"ranking",label:t("perf.ranking_title")},{id:"trades",label:t("perf.trades_title")}],active:o,onChange:i,ariaLabel:t("nav.performance")}),e.jsxs("div",{id:"performance-panel",className:"perf-tab-body",role:"tabpanel","aria-labelledby":`performance-tab-${o}`,tabIndex:0,children:[o!=="trades"&&s.phase==="ready"&&e.jsx("p",{className:"card-note",children:e.jsx(Ze,{counts:s.data.freshness_summary})}),p]})]})}function Aa(){const a=C(),n=V(),{prefs:l}=le(),{scope:r,options:t}=re(),o=Te(r),i=r==="all"?void 0:t.find(g=>`${g.platform}:${g.alias}`===r)?.platform,[s,p]=P.useState(l.defaultRange),[u,h]=P.useState(0),_=()=>h(g=>g+1),y=O(()=>Ye(r,s,i),[r,i,s,u]),k=O(()=>Ue(r,s,i),[r,i,s,u]),x=r==="all"&&k.phase==="ready"&&(k.data.per_account??[]).some(g=>j(g.status)&&g.return_kind==="twr"&&Ee(g.points).length>0),c=y.phase==="ready"&&j(y.data.status)&&y.data.twr_return_percent!==null?se(y.data.twr_return_percent,n):null,m=y.phase==="ready"?{[s]:c}:void 0;return e.jsxs("div",{className:"page",children:[e.jsxs("div",{className:"page-header",children:[e.jsx("h1",{className:"page-title",children:a("nav.performance")}),e.jsxs("div",{className:"page-header-actions",children:[e.jsx(Ie,{value:s,onChange:p,returns:m}),e.jsx("button",{type:"button",className:"button button-secondary",onClick:_,children:a("common.refresh")})]})]}),e.jsxs("p",{className:"page-subtitle",children:[o," · ",a(`perf.range.${s}`)]}),e.jsx(ta,{scope:r,platform:i,state:y,chartAvailable:x}),e.jsx(oa,{scope:r,platform:i,state:k}),e.jsxs("div",{className:"perf-duo-grid",children:[e.jsx(ua,{scope:r,platform:i,range:s,epoch:u}),e.jsx(_a,{scope:r,platform:i,range:s,epoch:u})]}),e.jsx(ga,{scope:r,platform:i,range:s,epoch:u})]})}export{Aa as default};
" },
   "/v2/assets/PerformancePage-BMNSw_qo.css": { contentType: "text/css; charset=utf-8", base64: ".perf-kpi-grid{display:grid;grid-template-columns:repeat(3,minmax(0,1fr));align-items:stretch;gap:12px}.perf-kpi-grid>.kpi-card{height:100%;min-height:96px;padding:14px 16px;gap:4px;border-radius:10px}.perf-kpi-grid .kpi-title{min-height:2.7em;line-height:1.35}.perf-kpi-grid .kpi-value{font-size:23px;line-height:1.18}.perf-kpi-grid .kpi-empty-value{font-size:20px}.perf-kpi-grid .kpi-reason{font-size:12px;font-weight:400;line-height:1.45;color:var(--muted)}.perf-summary-note{display:flex;flex-wrap:wrap;align-items:center;gap:4px 10px;margin:0;max-width:88ch;line-height:1.55}.history-notice{display:flex;flex-wrap:wrap;align-items:center;gap:4px 10px;margin-top:8px}.perf-kpi-grid .kpi-sub,.perf-kpi-grid .kpi-reason,.perf-summary-note{overflow-wrap:anywhere}.perf-card-head{display:flex;align-items:flex-start;gap:8px 12px;flex-wrap:wrap;margin-bottom:14px}.perf-card-head .card-title{margin:0;font-size:16px;line-height:1.35}.perf-head-meta{margin-left:auto;align-self:center;display:flex;align-items:center;gap:8px;flex-wrap:wrap}.perf-kind,.perf-currency{font-size:12px;color:var(--muted)}.kpi-foot .kpi-reason{flex-basis:100%;font-size:12px;color:var(--muted)}.perf-mode-toggle{margin-left:auto}.perf-benchmarks-off{margin-top:6px}.perf-benchmarks-off>summary{width:fit-content;min-height:28px;padding:4px 0;color:var(--muted);font-size:12px;cursor:pointer}.perf-benchmarks-off>summary:hover{color:var(--ink)}.perf-benchmarks-off-list{display:flex;flex-wrap:wrap;gap:4px 16px;margin-top:2px}.perf-benchmark-off{font-size:12px;color:var(--muted);cursor:help}.perf-currency-switch{margin:0 0 10px}.perf-currency-switch .segmented{max-width:100%}.perf-excess-list{display:flex;flex-direction:column;gap:2px}.perf-tab-body{margin-top:14px}.trade-summary{display:flex;flex-wrap:wrap;align-items:center;gap:4px 12px;margin:0 0 10px}.trade-summary .card-note{margin:0}.trade-time{display:block;color:var(--muted);font-size:12px;line-height:1.45;overflow-wrap:anywhere}.trade-cards{display:none;margin:0;padding:0;list-style:none}.trade-card{display:flex;flex-direction:column;gap:6px;min-width:0;padding:10px 12px;border:1px solid var(--line);border-radius:10px;background:var(--surface)}.trade-card-head{display:flex;flex-wrap:wrap;align-items:center;gap:4px 8px;min-width:0}.trade-card-date{font-size:13px;white-space:nowrap}.trade-card-time{color:var(--muted);font-size:12px;overflow-wrap:break-word}.trade-card-symbol{font-size:14px;font-weight:600;overflow-wrap:break-word}.trade-side{padding:0 6px;border:1px solid var(--line);border-radius:999px;color:var(--muted);font-size:12px;line-height:1.6;white-space:nowrap}.trade-card-account{font-size:13px;line-height:1.45;overflow-wrap:break-word}.trade-card-figures{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:4px 8px;margin:0}.trade-figure{display:flex;flex-wrap:wrap;align-items:baseline;justify-content:space-between;gap:0 4px;min-width:0}.trade-figure dt{color:var(--muted);font-size:12px}.trade-figure dd{margin:0;font-size:13px;overflow-wrap:break-word}.perf-ranking-section+.perf-ranking-section{margin-top:18px}.perf-ranking-heading{margin:0 0 8px;font-size:13px;font-weight:600;color:var(--muted)}.perf-ranking-currency+.perf-ranking-currency{margin-top:22px}.perf-ranking-currency-heading{font-size:14px;letter-spacing:.02em}.perf-ranking-currency .barlist-row{grid-template-columns:minmax(0,1fr) minmax(55px,1fr) auto}.perf-ranking-currency .barlist-label{white-space:normal;overflow-wrap:anywhere}.perf-duo-grid{display:grid;grid-template-columns:minmax(0,1.15fr) minmax(0,.85fr);align-items:start;gap:18px}.perf-duo-grid>.card{min-width:0}.calendar-month-grid{max-width:520px;margin-inline:auto}.calendar-year-grid{max-width:600px;margin-inline:auto}.method-note{margin-top:10px}.method-note summary{cursor:pointer;color:var(--accent);font-size:13px;min-height:28px;padding:4px 0}.method-note[open] .card-note{max-height:40vh;overflow-y:auto}.perf-account-daily{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:12px 18px;margin-top:14px}.perf-account-daily>.perf-card-head,.perf-account-daily>.card-note{grid-column:1 / -1;margin:0}.perf-account-daily-item{min-width:0}@media(max-width:900px){.perf-account-daily{grid-template-columns:minmax(0,1fr)}}@media(max-width:1100px){.perf-duo-grid{grid-template-columns:minmax(0,1fr)}}@media(max-width:900px){.perf-kpi-grid{grid-template-columns:repeat(2,minmax(0,1fr))}}@media(max-width:768px){.perf-card-head{align-items:flex-start}.perf-head-meta{margin-left:auto}.perf-mode-toggle{order:3;width:100%;margin-left:0}.perf-mode-toggle .segmented{display:flex;width:100%}.perf-mode-toggle .segment{flex:1 1 auto;justify-content:center}.perf-currency-switch .segmented{display:flex;width:100%}.perf-currency-switch .segment{flex:1 1 auto;justify-content:center}.calendar-month-grid{max-width:520px}.calendar-year-grid{max-width:600px}.trade-table{display:none}.trade-cards{display:flex;flex-direction:column;gap:8px}}.holdings-view .table-wrap{max-width:100%;overflow-x:auto}.holdings-view .data-table{min-width:920px}.holdings-view .data-table th,.holdings-view .data-table td{white-space:nowrap;overflow-wrap:normal;word-break:normal}.holdings-scroll-hint{display:none}@media(max-width:1000px){.holdings-scroll-hint{display:block}}@media(max-width:480px){.perf-kpi-grid{gap:8px}.perf-kpi-grid>.kpi-card{padding:11px 12px}.perf-kpi-grid .kpi-value{font-size:20px}.perf-card-head .card-title{font-size:15px}.method-note[open] .card-note{max-height:32vh}}@media(max-width:480px){.calendar-scroll{overflow-x:auto;overscroll-behavior-x:contain;padding:2px;margin:-2px}.calendar-month-grid{grid-template-columns:repeat(7,minmax(auto,1fr));gap:2px;max-width:100%}.calendar-cell{padding:3px 2px;gap:1px}.calendar-cell .cell-date{font-size:10px}.calendar-cell .cell-value{font-size:10px;white-space:nowrap}}.holding-status{display:flex;flex-direction:column;gap:4px}.holding-status small{font-size:12px;color:var(--muted)}.holding-broker-cost{display:flex;flex-direction:column;align-items:flex-end;gap:3px}.holding-broker-cost small{font-size:12px;color:var(--muted)}
" },
-  "/v2/assets/PerformancePage-DuxiG9dq.js": { contentType: "text/javascript; charset=utf-8", base64: "import{u as C,a as re,j as e,f as L,E as F,S as z,A as U,P as ae,M as Y,k as V,m as J,n as pe,o as ne,r as P,c as R,p as Fe,d as Pe,q as le,s as se,t as Ae,l as ze,B as qe,v as Oe,w as Ve,x as He,R as Ie,e as Ye,i as Ue}from"./index-Ds_XXLsn.js";import{u as O}from"./hooks-DCo9_b70.js";import{K as S}from"./KpiCard-Dxqixf9c.js";import{c as H,r as j,D as ce,U as ie,u as Te,i as me,L as Re,C as We,A as _e,F as Ze}from"./cashflowMethod-H7Uq4Mrs.js";import{D as Me}from"./DataTable-Bs7KLM5-.js";import{T as Qe}from"./Tabs-DBQ5AQB9.js";const Xe=["纳斯达克100","标普500"];function De(a,n,l){let r;if(a==="all"){const i=l.filter(p=>p.paper===!1);r=(i.length>0?i:l).map(p=>p.platform)}else{const i=n||a.slice(0,Math.max(0,a.indexOf(":")));r=i?[i]:[]}r=[...new Set(r.filter(Boolean))];const t=r.includes("binance"),o=r.some(i=>i!=="binance");return t?{enabled:!1,reason:o?"mixed":"crypto",defaults:[]}:{enabled:!0,reason:null,defaults:Xe}}function Ge(a){return!a||a==="USD"}function Je(a){return a.twr_return_percent===null&&a.amount===null&&a.max_drawdown.percent===null&&(a.per_currency??[]).every(n=>n.max_drawdown.percent===null)&&a.excess_returns.every(n=>n.percentage_points===null)&&a.best_day===null&&a.worst_day===null}function W({status:a}){const n=C();return e.jsxs("span",{className:"flat kpi-empty-value","data-state":a,children:["—",e.jsx("span",{className:"sr-only",children:n(`state.${a}`)})]})}function ea({data:a}){const n=C(),l=H(a),r=n(l==="unknown"?"perf.card.return_value":"perf.card.twr");if(!j(a.status))return e.jsx(S,{title:r,value:e.jsx(W,{status:a.status})});if(a.twr_return_percent===null){const o=a.metric_reasons?.twr??a.unavailable_reason;return e.jsx(S,{title:r,value:e.jsx("span",{className:"flat","data-state":"unavailable","data-reason":o??void 0,children:"—"}),sub:n("state.unavailable")})}const t=l==="dietz_approx"?n(ce):l==="unknown"?n(ie):void 0;return e.jsx(S,{title:r,value:e.jsx(ae,{value:a.twr_return_percent}),sub:t})}function aa({data:a}){const n=C(),l=a.value_kind==="pnl"?n("perf.card.amount"):n("perf.card.amount_asset_change");return j(a.status)?a.unavailable_reason==="mixed_currency"||a.amount===null?e.jsx(S,{title:l,value:e.jsx("span",{className:"flat",children:"—"}),sub:n("state.unavailable")}):e.jsx(S,{title:l,value:e.jsx(Y,{value:a.amount,currency:a.currency,signed:!0})}):e.jsx(S,{title:l,value:e.jsx(W,{status:a.status})})}function fe(a,n){const l=H(a);return l==="dietz_approx"?n(ce):l==="unknown"?n(ie):null}function sa({data:a}){const n=C(),l=V(),r=n(H(a)==="unknown"?"perf.drawdown_plain_title":"perf.drawdown_twr_title");if(a.per_currency?.length&&a.unavailable_reason!=="stored_records_unreadable")return e.jsx(S,{title:r,value:e.jsx("span",{className:"currency-totals",children:a.per_currency.map(p=>{const u=p.max_drawdown,h=u.percent,_=h!==null,y=_?fe(p,n):null,k=_?null:u.unavailable_reason?n(`reason.${u.unavailable_reason}`):n("state.unavailable"),x=_&&u.peak_date&&u.trough_date?n("perf.card.max_drawdown_dates",{peak:J(u.peak_date,l),trough:J(u.trough_date,l)}):null;return e.jsxs("span",{className:"currency-total","data-state":u.unavailable_reason||void 0,children:[e.jsx("span",{className:"kpi-sub",children:p.currency}),y&&e.jsx("span",{className:"kpi-sub",children:y}),h===null?e.jsx("span",{className:"flat","data-reason":u.unavailable_reason??void 0,children:"—"}):e.jsx(ae,{value:-h||0}),k&&e.jsx("span",{className:"kpi-sub",children:k}),x&&e.jsx("span",{className:"kpi-sub",children:x})]},p.currency)})})});if(!j(a.status))return e.jsx(S,{title:r,value:e.jsx(W,{status:a.status})});const t=a.max_drawdown;if(t.percent===null)return e.jsx(S,{title:r,value:e.jsx("span",{className:"flat",children:"—"}),sub:n("state.unavailable")});const o=t.peak_date&&t.trough_date?n("perf.card.max_drawdown_dates",{peak:J(t.peak_date,l),trough:J(t.trough_date,l)}):void 0,s=[fe(a,n),o].filter(Boolean).join(" · ")||void 0;return e.jsx(S,{title:r,value:e.jsx(ae,{value:-t.percent||0}),sub:s})}function na({data:a,policy:n}){const l=C(),r=V(),t=l("perf.card.excess");if(!j(a.status))return e.jsx(S,{title:t,value:e.jsx(W,{status:a.status})});if(!n.enabled)return e.jsx(S,{title:t,value:e.jsx("span",{className:"flat",children:"—"}),sub:l("perf.benchmark_not_applicable")});const o=n.defaults.flatMap(h=>a.excess_returns.filter(_=>_.benchmark===h)),i=o.find(h=>h.percentage_points!==null);if(!i||i.percentage_points===null)return e.jsx(S,{title:t,value:e.jsx("span",{className:"flat",children:"—"}),sub:l("state.unavailable")});const s=i.percentage_points,p=o.filter(h=>h!==i&&h.percentage_points!==null),u=p.length?e.jsx("span",{className:"perf-excess-list",children:p.map(h=>e.jsxs("span",{children:[h.benchmark," ",pe(h.percentage_points,r)]},h.benchmark))}):i.benchmark;return e.jsx(S,{title:t,value:e.jsx("span",{className:s>0?"up":s<0?"down":"flat",children:pe(s,r)}),sub:u})}function he({data:a,field:n,titleKey:l}){const r=C(),t=r(l);if(!j(a.status))return e.jsx(S,{title:t,value:e.jsx(W,{status:a.status})});const o=a[n];if(!o||!j(o.status))return e.jsx(S,{title:t,value:e.jsx("span",{className:"flat",children:"—"}),sub:r("state.no_data")});const i=o.amount!==null?e.jsx(Y,{value:o.amount,currency:a.currency,signed:!0}):e.jsx(ae,{value:o.return_percent}),s=o.value_kind==="asset_change"?` · ${r("perf.value_kind_asset_change")}`:"";return e.jsx(S,{title:t,value:i,sub:`${o.date}${s}`})}function ta({scope:a,platform:n,state:l,chartAvailable:r}){const t=C(),{options:o}=re(),i=De(a,n,o);if(l.phase==="loading"){const y=["perf.card.twr","perf.card.amount","perf.card.max_drawdown","perf.card.excess","perf.card.best_day","perf.card.worst_day"];return e.jsx("div",{className:"perf-kpi-grid",children:y.map(k=>e.jsx(S,{title:t(k),value:e.jsx(L,{height:28,width:"70%"})},k))})}if(l.phase==="error")return e.jsx(F,{onRetry:l.reload});const s=l.data,p=Je(s),u=s.coverage,h=!!u&&!Array.isArray(u)&&u!=="fills_not_connected"&&u.fx==="not_applied",_=s.unavailable_reason==="mixed_currency"?t(h?"perf.mixed_currency_unavailable":"perf.mixed_currency_native"):p&&r?t("perf.combined_metrics_unavailable"):null;return e.jsxs("div",{className:"section-stack",children:[(s.status!=="ok"||s.unavailable_reason||s.as_of||_)&&e.jsxs("div",{className:"metric-note perf-summary-note","data-state":s.status,"data-reason":s.unavailable_reason??void 0,children:[s.status!=="ok"&&e.jsx(z,{status:s.status}),_&&e.jsx("span",{className:"state-short",children:_}),s.as_of&&e.jsx(U,{value:s.as_of})]}),e.jsxs("div",{className:"perf-kpi-grid",children:[e.jsx(ea,{data:s}),e.jsx(aa,{data:s}),e.jsx(sa,{data:s}),e.jsx(na,{data:s,policy:i}),e.jsx(he,{data:s,field:"best_day",titleKey:"perf.card.best_day"}),e.jsx(he,{data:s,field:"worst_day",titleKey:"perf.card.worst_day"})]})]})}const ra=["var(--benchmark-1)","var(--benchmark-2)","var(--benchmark-3)","var(--benchmark-4)"],xe={标普500:"perf.benchmark_sp500",纳斯达克100:"perf.benchmark_nasdaq100",道琼斯工业平均指数:"perf.benchmark_dow",罗素2000:"perf.benchmark_russell2000"},ee={series:[],defaults:[],disabled:[]};function be(a){return a.points.length>0?{points:a.points,fallback:null}:{points:a.asset_change?.points??[],fallback:a.asset_change??null}}function la(a){if(!a)return!1;const n=a.coverage;return!n||typeof n!="object"||Array.isArray(n)?!1:n.native_daily_only===!0}function ca(a){if(typeof a!="string"||a==="")return null;const n=Date.parse(`${a}T00:00:00Z`);return Number.isFinite(n)?n:null}function Ee(a){const n=[],l=new Map;for(const t of a)l.set(t.date,(l.get(t.date)??0)+1);let r=!1;for(const t of a){const o=t.daily_return_percent;if(ca(t.date)===null||l.get(t.date)!==1||typeof o!="number"||!Number.isFinite(o)||o<-100){r=!0;continue}n.push({date:t.date,value:t.value,daily_return_percent:o,breakBefore:t.breakBefore===!0||r}),r=!1}return n}function ye(a){return a.some(n=>{const l=n.daily_return_percent;return typeof l=="number"&&Number.isFinite(l)&&l>=-100})}function ve(a,n){return n?"perf.native_daily_title":a.returnKind==="unadjusted_asset_ratio"?"perf.asset_change_title":"perf.returns_title"}function ia(a,n){if(a==="unadjusted_asset_ratio")return"perf.asset_change_tag";const l=H(n);return l==="dietz_approx"?ce:l==="unknown"?ie:"perf.return_kind_twr"}function je(a,n){if(!(n.enabled&&a.returnKind==="twr"&&H(a.method)!=="unknown"&&Ge(a.currency)))return ee;const r=a.benchmarks.filter(t=>t.points.length>0);return{series:r,defaults:n.defaults.filter(t=>r.some(o=>o.id===t)),disabled:a.disabled.filter(t=>n.defaults.includes(t.id))}}function ge({view:a,seriesLabel:n,mode:l,ariaLabel:r,benchmarks:t,disabled:o,nativeDailyOnly:i}){const s=C(),p=[{id:"main",label:n,color:"var(--accent)",points:a.points,primary:!0},...t.series.map((u,h)=>({id:u.id,label:s(xe[u.id]||"perf.benchmark_unknown"),color:ra[h],points:u.points}))];return e.jsxs("div",{"data-state":a.status,"data-reason":a.unavailableReason??void 0,children:[e.jsxs("p",{className:"card-note",style:{marginTop:0},children:[e.jsx("span",{className:"perf-kind",children:s(ia(a.returnKind,a.method))}),i&&e.jsxs("span",{className:"perf-kind","data-native-daily-tag":"true",children:[" · ",s("perf.native_daily_tag")]}),a.currency&&e.jsxs("span",{className:"perf-currency",children:[" · ",a.currency]})]}),e.jsx(Re,{series:p,mode:l,ariaLabel:r,alignStart:a.alignedStart,defaultVisible:t.series.length>0?t.defaults:void 0},`${a.currency??"native"}:${t.series.map(u=>u.id).join(",")}`),i&&e.jsx("p",{className:"card-note","data-native-daily-only":"true",children:s("perf.native_daily_note")}),o.length>0&&e.jsxs("details",{className:"perf-benchmarks-off",children:[e.jsx("summary",{children:s("perf.benchmarks_unavailable",{count:o.length})}),e.jsx("div",{className:"perf-benchmarks-off-list",children:o.map(u=>e.jsxs("span",{className:"perf-benchmark-off",title:u.unavailable_reason?s(`reason.${u.unavailable_reason}`):void 0,children:[s(xe[u.id]||"perf.benchmark_unknown")," · ",s(`state.${u.status}`)]},u.id))})]})]})}function oa({scope:a,platform:n,state:l}){const r=C(),{options:t}=re(),o=Te(a),i=ne(),[s,p]=P.useState("cumulative"),[u,h]=P.useState(null),_=l.phase==="ready"?l.data:null,y=la(_),k=d=>s==="daily"&&ye(d)?"daily":"cumulative",x=De(a,n,t),c=_?.per_account?.filter(d=>j(d.status)&&d.return_kind==="twr"&&d.points.length>0)??[],m=[];if(a==="all"&&_?.per_account)for(const d of _.per_account){if(!j(d.status)||d.return_kind!=="twr")continue;const E=Ee(d.points);E.length!==0&&m.push({key:`${d.platform}:${d.account_alias}`,platform:d.platform,accountAlias:d.account_alias,currency:d.currency??null,points:E})}const g=new Set(m.map(d=>d.key)),N=c.filter(d=>!g.has(`${d.platform}:${d.account_alias}`)),b=!!(_&&a==="all"&&_.per_currency.length>0&&(j(_.status)||_.unavailable_reason==="mixed_currency")),f=b&&_?_.per_currency.find(d=>d.currency===u)??_.per_currency.find(d=>j(d.status)&&(d.points.length>0||(d.asset_change?.points.length??0)>0))??_.per_currency[0]??null:null;let v=null,w=ee,A;if(l.phase==="loading")A=e.jsx(L,{height:280});else if(l.phase==="error")A=e.jsx(F,{onRetry:l.reload});else{const d=l.data,E=d.benchmark_availability.filter($=>!j($.status)),Q=be(d),D=Q.fallback;if(b&&f){const $=f,de=e.jsx("div",{className:"perf-currency-switch",children:e.jsx("div",{className:"segmented",role:"group","aria-label":r("perf.currency_switch"),children:d.per_currency.map(T=>e.jsx("button",{type:"button",className:`segment${T.currency===$.currency?" active":""}`,"aria-pressed":T.currency===$.currency,onClick:()=>h(T.currency),children:T.currency},T.currency))})}),X=be($),M=X.fallback,G=M?M.status:$.status,I=M?M.unavailable_reason:$.unavailable_reason;if(j(G)&&X.points.length>0){const T={points:X.points,benchmarks:M?[]:$.benchmarks,returnKind:M?"unadjusted_asset_ratio":$.return_kind,method:$,alignedStart:M?M.aligned_start:$.aligned_start,currency:$.currency,status:G,unavailableReason:I,asOf:M?M.as_of:$.as_of??null,disabled:E};v=T,w=y||M?ee:je(T,x),A=e.jsxs("div",{children:[de,M&&e.jsx("p",{className:"card-note",children:r("perf.mixed_currency_asset_change")}),e.jsx(ge,{view:T,seriesLabel:`${o} · ${$.currency}`,mode:y?"daily":k(X.points),ariaLabel:`${r(ve(T,y))} ${$.currency}`,benchmarks:w,disabled:w.disabled,nativeDailyOnly:y})]})}else{const T=j(G)?"no_data":G;A=e.jsxs("div",{children:[de,e.jsx("div",{"data-reason":I??void 0,children:e.jsx(R,{title:r(T==="no_data"&&I==="external_cashflow_required"?"perf.missing_cashflow_records":`state.${T}`),state:T,body:I?r(`reason.${I}`):void 0})})]})}}else if(!j(d.status))A=e.jsx("div",{"data-reason":d.unavailable_reason??void 0,children:e.jsx(R,{title:r(`state.${d.status}`),state:d.status,body:d.unavailable_reason?r(`reason.${d.unavailable_reason}`):void 0})});else if(Q.points.length===0)A=e.jsx("div",{"data-reason":d.unavailable_reason??void 0,children:e.jsx(R,{title:r(d.unavailable_reason==="external_cashflow_required"?"perf.missing_cashflow_records":"state.no_data"),state:"no_data",body:d.unavailable_reason?r(`reason.${d.unavailable_reason}`):void 0})});else{const $={points:Q.points,benchmarks:D?[]:d.no_common_date?[]:d.benchmarks,returnKind:D?"unadjusted_asset_ratio":d.return_kind,method:d,alignedStart:D?D.aligned_start:d.aligned_start,currency:d.currency??null,status:D?D.status:d.status,unavailableReason:D?D.unavailable_reason:d.unavailable_reason,asOf:D?D.as_of:d.as_of??null,disabled:E};v=$,w=y||D||d.no_common_date?ee:je($,x),A=e.jsx(ge,{view:$,seriesLabel:o,mode:y?"daily":k(Q.points),ariaLabel:r(ve($,y)),benchmarks:w,disabled:w.disabled,nativeDailyOnly:y})}}const q=v?.returnKind==="unadjusted_asset_ratio",te=w.series.length>0,Z=r(v?y?"perf.native_daily_title":q?"perf.asset_change_title":te?"perf.returns_title":"perf.returns_title_plain":"perf.returns_title"),Ke=!!(v&&!y&&!q&&j(v.status)&&v.points.length>0&&ye(v.points)),Le=y?"perf.method_body_native_daily":v&&q?"perf.method_body_asset_change":_&&[_,..._.per_currency].some(d=>H(d)==="unknown")?"perf.method_body_unknown":_&&(me(_)||_.per_currency.some(me))?"perf.method_body_dietz":"perf.method_body",oe=!!(v&&j(v.status)&&v.points.length>0),ue=m.length>0?e.jsxs("section",{className:"perf-account-daily","data-account-daily-count":m.length,children:[e.jsx("div",{className:"perf-card-head",children:e.jsx("h3",{className:"card-title",children:r("perf.per_account_daily_title")})}),e.jsx("p",{className:"card-note",children:r("perf.per_account_daily_note")}),m.map(d=>{const E=`${i.platform(d.platform)} · ${i.account(d.accountAlias,d.platform)}`;return e.jsxs("div",{className:"perf-account-daily-item","data-account":d.accountAlias,children:[e.jsxs("p",{className:"card-note",children:[e.jsx("span",{className:"perf-kind",children:E}),d.currency&&e.jsxs("span",{className:"perf-currency",children:[" · ",d.currency]})]}),e.jsx(Re,{series:[{id:"main",label:E,color:"var(--accent)",points:d.points,primary:!0}],mode:"daily",ariaLabel:`${r("perf.per_account_daily_title")} · ${E}`})]},d.key)})]}):null;return e.jsxs("div",{className:"card",children:[e.jsxs("div",{className:"perf-card-head",children:[e.jsx("h2",{className:"card-title",children:Z}),Ke&&e.jsx("div",{className:"perf-mode-toggle",children:e.jsxs("div",{className:"segmented",role:"group","aria-label":Z,children:[e.jsx("button",{type:"button",className:`segment${s==="cumulative"?" active":""}`,"aria-pressed":s==="cumulative",onClick:()=>p("cumulative"),children:r("perf.returns_cumulative")}),e.jsx("button",{type:"button",className:`segment${s==="daily"?" active":""}`,"aria-pressed":s==="daily",onClick:()=>p("daily"),children:r("perf.returns_daily")})]})}),e.jsxs("span",{className:"perf-head-meta",children:[v&&v.status!=="ok"&&j(v.status)&&e.jsx(z,{status:v.status,reason:v.unavailableReason}),v&&j(v.status)&&e.jsx(U,{value:v.asOf})]})]}),!oe&&ue,A,oe&&ue,N.length>0?e.jsx("p",{className:"card-note","data-native-return-accounts":N.length,children:r("perf.native_return_accounts",{accounts:N.map(d=>`${i.platform(d.platform)} · ${i.account(d.account_alias,d.platform)}`).join("、")})}):null,e.jsx(Fe,{titleKey:"perf.how_calculated",bodyKey:Le})]})}function Ne({status:a,points:n,coverage:l,reason:r}){const t=C(),o=n.some(u=>(u.forward_filled_accounts?.length||0)>0),i=o||n.some(u=>u.partial)||!!l?.truncated||!!l?.read_failures?.length,s=a==="ok"?i?"partial":"ok":a;if(s==="ok")return null;const p=[...new Set([...n.flatMap(u=>[...u.missing_accounts||[],...u.forward_filled_accounts||[]]),...l?.missing_accounts||[],...l?.excluded_accounts||[],...l?.read_failures||[]])];return e.jsxs("span",{className:"history-notice",role:"status","data-state":s,"data-reason":r??void 0,"data-affected-count":p.length||void 0,children:[e.jsx(z,{status:s}),p.length>0&&e.jsx("span",{className:"card-note",children:t("perf.history_affected_accounts",{count:p.length})}),o&&e.jsx("span",{className:"card-note",children:t("perf.history_carried_balances")}),r&&e.jsx("span",{className:"card-note",children:t(`reason.${r}`)})]})}function ua({scope:a,platform:n,range:l,epoch:r}){const t=C(),[o,i]=P.useState(null),s=O(()=>Pe(a,l,n),[a,n,l,r]);let p,u,h,_=null,y=null,k=null;if(s.phase==="loading")h=e.jsx(L,{height:220});else if(s.phase==="error")h=e.jsx(F,{onRetry:s.reload});else{const x=s.data;p=x.per_currency?.length&&x.unavailable_reason!=="stored_records_unreadable"?e.jsx(We,{totals:x.per_currency,freshness:x.freshness_summary,notes:x.per_currency.length>1?t("perf.native_totals_note"):void 0}):null,_=x.status,y=x.unavailable_reason,k=x.as_of;const c=x.curve_status||x.status,m=x.curve_unavailable_reason===void 0?x.unavailable_reason:x.curve_unavailable_reason,g=x.history_per_currency?.length?x.history_per_currency:[{currency:x.currency,status:c,coverage:x.curve_coverage,points:x.points,unavailable_reason:x.curve_unavailable_reason??x.unavailable_reason}];if(x.per_currency?.length&&m==="mixed_currency"){const N=g.filter(f=>f.points.length>0),b=N.find(f=>f.currency===o)??N[0];b?(u=e.jsx(Ne,{status:b.status,points:b.points,coverage:b.coverage,reason:b.unavailable_reason}),h=e.jsxs("div",{children:[e.jsx("div",{className:"perf-currency-switch",children:e.jsx("div",{className:"segmented",role:"group","aria-label":t("perf.currency_switch"),children:N.map(f=>e.jsx("button",{type:"button",className:`segment${f.currency===b.currency?" active":""}`,"aria-pressed":f.currency===b.currency,onClick:()=>i(f.currency??null),children:f.currency||t("perf.currency_switch")},f.currency||"native"))})}),e.jsx(_e,{points:b.points,currency:b.currency,ariaLabel:t("perf.asset_balance_title")})]})):h=e.jsx("div",{"data-reason":"mixed_currency",children:e.jsx(R,{title:t("perf.mixed_currency_title"),state:"unavailable"})})}else if(u=j(c)?g.map(N=>e.jsx(Ne,{status:g.length===1?c:N.status,points:N.points,coverage:N.coverage,reason:N.unavailable_reason},N.currency||"history")):null,!j(c))h=e.jsx("div",{"data-reason":m??void 0,children:e.jsx(R,{title:t(`state.${c}`),state:c,body:m?t(`reason.${m}`):void 0})});else if(m==="mixed_currency")h=e.jsx("div",{"data-reason":"mixed_currency",children:e.jsx(R,{title:t("perf.mixed_currency_title"),state:"unavailable"})});else if(x.points.length===0)h=e.jsx("div",{"data-reason":x.unavailable_reason??void 0,children:e.jsx(R,{title:t("state.no_data"),state:"no_data",body:m?t(`reason.${m}`):void 0})});else{const N=x.points;h=e.jsx(_e,{points:N,currency:x.currency,ariaLabel:t("perf.asset_balance_title")})}}return e.jsxs("div",{className:"card",children:[e.jsxs("div",{className:"perf-card-head",children:[e.jsx("h2",{className:"card-title",children:t("perf.asset_balance_title")}),e.jsxs("span",{className:"perf-head-meta",children:[_&&_!=="ok"&&j(_)&&e.jsx(z,{status:_,reason:y}),_&&j(_)&&k&&e.jsx(U,{value:k})]})]}),p,u,h]})}const da=["Mon","Tue","Wed","Thu","Fri","Sat","Sun"],pa={Mon:"一",Tue:"二",Wed:"三",Thu:"四",Fri:"五",Sat:"六",Sun:"日"};function K(a){return typeof a=="number"&&Number.isFinite(a)?a:null}function ke(a){const n=K(a.return_percent);return n===null?"":n>0?"up":n<0?"down":"flat"}function $e(a,n){const l=K(a.return_percent);if(l===null||l===0||n<=0)return;const r=Math.min(1,Math.abs(l)/n),t=8+Math.round(r*40);return`color-mix(in srgb, var(--${l>0?"up":"down"}) ${t}%, transparent)`}function ma({year:a,month:n,cells:l,onNavigate:r}){const t=C(),o=V(),{prefs:i}=le(),s=Math.max(0,...l.map(m=>{const g=K(m.return_percent);return g===null?0:Math.abs(g)})),p=new Date,u=`${p.getFullYear()}-${String(p.getMonth()+1).padStart(2,"0")}-${String(p.getDate()).padStart(2,"0")}`,h=u.slice(0,7),_=m=>{const g=K(m.return_percent);if(g!==null)return se(g,o);const N=K(m.amount);return N!==null?i.hideAmounts?Ae(N):String(Math.round(N)):""};if(n===null)return e.jsxs("div",{children:[e.jsxs("div",{className:"calendar-nav",children:[e.jsx("button",{type:"button",className:"button button-secondary button-sm",onClick:()=>r(a-1,null),"aria-label":"‹",children:"‹"}),e.jsx("span",{className:"current num",children:a}),e.jsx("button",{type:"button",className:"button button-secondary button-sm",onClick:()=>r(a+1,null),"aria-label":"›",children:"›"})]}),e.jsx("div",{className:"calendar-year-grid",style:{marginTop:12},children:l.map(m=>{const g=m.unavailable_reason,N=g==="snapshot_pending",b=g==="future_date"||!N&&!!(m.month&&m.month>h);return e.jsxs("button",{type:"button",className:`calendar-cell${b?" cell-future":""}${N?" cell-pending":""}${K(m.return_percent)===null&&K(m.amount)===null?" cell-empty":""}`,style:{background:b?void 0:$e(m,s)},title:b?void 0:N?t("reason.snapshot_pending"):m.unavailable_reason?t(`reason.${m.unavailable_reason}`):void 0,onClick:()=>m.month&&r(a,Number(m.month.split("-")[1])),children:[e.jsx("span",{className:"cell-date",children:m.month}),e.jsx("span",{className:`cell-value ${b?"":ke(m)}`,children:b?" ":_(m)||" "}),N&&e.jsx("span",{className:"sr-only",children:t("reason.snapshot_pending")})]},m.month)})})]});const y=new Map(l.filter(m=>m.date).map(m=>[m.date,m])),k=new Date(Date.UTC(a,n,0)).getUTCDate(),x=[];let c=[];for(let m=1;m<=k;m++){const g=`${a}-${String(n).padStart(2,"0")}-${String(m).padStart(2,"0")}`,b=(new Date(`${g}T00:00:00Z`).getUTCDay()+6)%7;for(b===0&&c.length&&(x.push(c),c=[]);c.length<b;)c.push(null);c.push(y.get(g)||{date:g,amount:null,return_percent:null,currency:null,status:"no_data",value_kind:"asset_change",unavailable_reason:null})}return c.length&&x.push(c),e.jsxs("div",{children:[e.jsxs("div",{className:"calendar-nav",children:[e.jsx("button",{type:"button",className:"button button-secondary button-sm",onClick:()=>r(...n===1?[a-1,12]:[a,n-1]),"aria-label":"‹",children:"‹"}),e.jsxs("button",{type:"button",className:"current button button-sm",onClick:()=>r(a,null),"aria-label":t("perf.calendar_year"),children:[a,"-",String(n).padStart(2,"0")]}),e.jsx("button",{type:"button",className:"button button-secondary button-sm",onClick:()=>r(...n===12?[a+1,1]:[a,n+1]),"aria-label":"›",children:"›"})]}),e.jsx("div",{className:"calendar-scroll",style:{marginTop:12},children:e.jsxs("div",{className:"calendar-month-grid",children:[da.map(m=>e.jsx("div",{className:"calendar-weekday",children:o==="zh"?pa[m]:m},m)),x.flatMap((m,g)=>[0,1,2,3,4,5,6].map(N=>{const b=m[N];if(!b)return e.jsx("div",{},`${g}-${N}`);const f=String(b.status),v=b.unavailable_reason,w=v==="snapshot_pending",A=v==="future_date"||!w&&!!(b.date&&b.date>u),q=!A&&(K(b.return_percent)!==null||K(b.amount)!==null),te=!A&&(f==="market_closed"||v==="market_closed"||v==="non_trading_weekend"),Z=A?void 0:w?t("reason.snapshot_pending"):f==="market_closed"||v==="market_closed"?t("state.market_closed"):v==="non_trading_weekend"?t("reason.non_trading_weekend"):b.unavailable_reason?t(`reason.${b.unavailable_reason}`):void 0;return e.jsxs("div",{className:`calendar-cell${A?" cell-future":""}${w?" cell-pending":""}${te?" cell-closed":""}${q?"":" cell-empty"}`,style:{background:A?void 0:$e(b,s)},title:Z,tabIndex:w?0:void 0,children:[e.jsx("span",{className:"cell-date num",children:b.date?Number(b.date.slice(8)):""}),q&&e.jsx("span",{className:`cell-value ${ke(b)}`,children:_(b)}),w&&e.jsx("span",{className:"sr-only",children:t("reason.snapshot_pending")})]},b.date)}))]})})]})}function _a({scope:a,platform:n,range:l,epoch:r}){const t=C(),o=new Date,[i,s]=P.useState({year:o.getFullYear(),month:o.getMonth()+1}),[p,u]=P.useState(null),h=p?.scope===a&&p.platform===n?p.currency:void 0,_=O(()=>ze(a,l,i.year,i.month,n,h),[a,n,l,i.year,i.month,h,r]);let y,k=null,x=null,c=null,m=!1,g=!1,N=!1,b;if(_.phase==="loading")y=e.jsx(L,{height:220});else if(_.phase==="error")y=e.jsx(F,{onRetry:_.reload});else{const f=_.data;k=f.status,x=f.unavailable_reason,c=f.as_of,m=f.value_kind==="asset_change",g=!!f.coverage&&typeof f.coverage=="object"&&!Array.isArray(f.coverage)&&f.coverage.asset_change_fallback===!0,N=f.cells.some(v=>v.observed_amount!==null&&v.observed_amount!==void 0),(f.available_currencies?.length||0)>1&&(b=e.jsx("div",{className:"perf-currency-switch",children:e.jsx("div",{className:"segmented",role:"group","aria-label":t("perf.currency_switch"),children:f.available_currencies.map(v=>e.jsx("button",{type:"button",className:`segment${v===f.currency?" active":""}`,"aria-pressed":v===f.currency,onClick:()=>u({scope:a,platform:n,currency:v}),children:v},v))})})),j(f.status)?f.cells.length===0?y=e.jsx("div",{"data-reason":f.unavailable_reason??void 0,children:e.jsx(R,{title:t("state.no_data"),state:"no_data",body:f.unavailable_reason?t(`reason.${f.unavailable_reason}`):void 0})}):y=e.jsx(ma,{year:f.year,month:f.month,cells:f.cells,onNavigate:(v,w)=>s({year:v,month:w})}):y=e.jsx("div",{"data-reason":f.unavailable_reason??void 0,children:e.jsx(R,{title:t(`state.${f.status}`),state:f.status,body:f.unavailable_reason?t(`reason.${f.unavailable_reason}`):void 0})})}return e.jsxs("div",{className:"card",children:[e.jsxs("div",{className:"perf-card-head",children:[e.jsx("h2",{className:"card-title",children:t(m?"perf.asset_change_title":"perf.calendar_title")}),e.jsxs("div",{className:"segmented",role:"group","aria-label":t("perf.calendar_title"),children:[e.jsx("button",{type:"button",className:`segment${i.month!==null?" active":""}`,"aria-pressed":i.month!==null,onClick:()=>s(f=>({...f,month:f.month??new Date().getMonth()+1})),children:t("perf.calendar_month")}),e.jsx("button",{type:"button",className:`segment${i.month===null?" active":""}`,"aria-pressed":i.month===null,onClick:()=>s(f=>({...f,month:null})),children:t("perf.calendar_year")})]}),e.jsxs("span",{className:"perf-head-meta",children:[m&&e.jsx(qe,{tone:"accent",title:t("perf.asset_change_note"),children:t("perf.asset_change_calendar_tag")}),k&&k!=="ok"&&j(k)&&e.jsx(z,{status:k,reason:x}),k&&j(k)&&e.jsx(U,{value:c})]})]}),b,y,g&&e.jsx("p",{className:"card-note","data-asset-change-fallback":"true",children:t("perf.calendar_fallback_note")}),N&&e.jsx("p",{className:"card-note",children:t("perf.calendar_deposit_note")})]})}function Se({items:a}){const n=V(),l=Math.max(1e-9,...a.map(r=>Math.abs(r.value)));return e.jsx("div",{className:"barlist",children:a.map(r=>{const t=Math.abs(r.value)/l*50,o=r.value>0;return e.jsxs("div",{className:"barlist-row",children:[e.jsx("span",{className:"barlist-label",title:r.label,children:r.label}),e.jsx("div",{className:"barlist-track",role:"img","aria-label":`${r.label} ${se(r.value,n)}`,children:e.jsx("div",{className:"barlist-fill",style:{background:o?"var(--up)":"var(--down)",width:`${t}%`,left:o?"50%":`${50-t}%`}})}),e.jsx("span",{className:`barlist-value ${o?"up":r.value<0?"down":"flat"}`,children:se(r.value,n)})]},r.id)})})}const Ce=5;function fa({value:a}){const n=V();return e.jsx("span",{className:"num",children:He(a,n)})}function ha({state:a}){const n=C(),l=ne();if(a.phase==="loading")return e.jsxs("div",{className:"section-stack",children:[e.jsx(L,{height:32}),e.jsx(L,{height:32}),e.jsx(L,{height:32})]});if(a.phase==="error")return e.jsx(F,{onRetry:a.reload});const r=a.data;if(!j(r.status))return e.jsx(R,{title:n(`state.${r.status}`),state:r.status});const t=[{id:"account",header:n("perf.col.account"),cell:s=>l.account(s.account_alias,s.platform),sortValue:s=>s.account_alias},{id:"symbol",header:n("perf.col.symbol"),cell:s=>e.jsx("span",{className:"holding-symbol",children:s.symbol}),sortValue:s=>s.symbol},{id:"quantity",header:n("perf.col.quantity"),numeric:!0,cell:s=>j(s.status)?e.jsx(fa,{value:s.quantity}):"—",sortValue:s=>s.quantity},{id:"market_value",header:`${n("perf.col.market_value")} (${n("perf.col.currency")})`,numeric:!0,cell:s=>j(s.status)?e.jsx(Y,{value:s.market_value,currency:s.currency}):"—",sortValue:s=>s.market_value},{id:"avg_cost",header:n("perf.col.cost_basis"),numeric:!0,cell:s=>j(s.status)?s.avg_cost!==null&&Number.isFinite(s.avg_cost)?e.jsx(Y,{value:s.avg_cost,currency:s.currency}):we(s)!==null?e.jsxs("div",{className:"holding-broker-cost",children:[e.jsx(B,{value:we(s),currency:s.currency}),e.jsx("small",{children:n("perf.broker_cost_label")})]}):"—":"—",sortValue:s=>s.avg_cost},{id:"unrealized_pnl",header:n("perf.col.unrealized_pnl"),numeric:!0,cell:s=>j(s.status)?e.jsx(Y,{value:s.unrealized_pnl,currency:s.currency,signed:!0}):"—",sortValue:s=>s.unrealized_pnl},{id:"status",header:n("common.status"),cell:s=>e.jsxs("div",{className:"holding-status",children:[s.status!=="ok"&&e.jsx(z,{status:s.status,reason:s.unavailable_reason}),j(s.status)&&["quantity","market_value","avg_cost","unrealized_pnl"].some(p=>s[p]===null)&&e.jsx("small",{children:n("perf.fields_not_provided",{fields:["quantity","market_value","avg_cost","unrealized_pnl"].filter(p=>s[p]===null).map(p=>n(p==="avg_cost"?"perf.average_cost_field":`perf.col.${p}`)).join(" / ")})})]})}],o=r.coverage,i=Array.isArray(o)?o.length:o&&typeof o=="object"&&Array.isArray(o.account_aliases)?o.account_aliases.length:void 0;return e.jsxs("div",{className:"holdings-view","data-state":r.status,"data-reason":r.unavailable_reason??void 0,"data-coverage-count":i,children:[e.jsxs("p",{className:"card-note",style:{marginTop:0},children:[n(r.label_key),r.status!=="ok"&&e.jsxs(e.Fragment,{children:[" · ",e.jsx(z,{status:r.status})]})]}),r.rows.some(s=>j(s.status)&&[s.market_value,s.avg_cost,s.unrealized_pnl].some(p=>p===null))&&e.jsx("p",{className:"card-note",children:n("perf.holdings_missing_fields")}),e.jsx("p",{className:"card-note holdings-scroll-hint",children:n("perf.holdings_scroll_hint")}),e.jsx(Me,{columns:t,rows:r.rows,rowKey:s=>`${s.platform}:${s.account_alias}|${s.symbol}`,defaultSort:{column:"market_value",direction:"desc"},caption:n("perf.holdings_title")})]})}function xa(a){if(!j(a.status))return null;const n=a.unrealized_pnl,l=a.unrealized_pnl_percent;if(typeof n!="number"||!Number.isFinite(n)||typeof l!="number"||!Number.isFinite(l))return null;const r=typeof a.currency=="string"&&a.currency.trim()?a.currency.trim():null;return{row:a,id:`${a.platform}:${a.account_alias}|${a.symbol}`,symbol:a.symbol,currency:r,pnl:n,value:l}}function ba(a,n){const l=a.map(xa).filter(i=>i!==null),r=l.filter(i=>i.currency===null).length,t=new Map;for(const i of l){if(i.currency===null)continue;const s=t.get(i.currency);s?s.push(i):t.set(i.currency,[i])}return{groups:[...t.entries()].sort(([i],[s])=>i.localeCompare(s)).map(([i,s])=>{const p=u=>({id:u.id,label:`${u.symbol} · ${n(u.row)}`,value:u.value});return{currency:i,winners:s.filter(u=>u.pnl>0).sort((u,h)=>h.pnl-u.pnl).slice(0,Ce).map(p),losers:s.filter(u=>u.pnl<0).sort((u,h)=>u.pnl-h.pnl).slice(0,Ce).map(p)}}).filter(i=>i.winners.length>0||i.losers.length>0),rankedCount:l.length-r,missingCurrencyCount:r}}function ya({state:a}){const n=C(),l=ne();if(a.phase==="loading")return e.jsx(L,{height:160});if(a.phase==="error")return e.jsx(F,{onRetry:a.reload});const r=a.data;if(!j(r.status))return e.jsx(R,{title:n(`state.${r.status}`),state:r.status});const{groups:t,rankedCount:o,missingCurrencyCount:i}=ba(r.rows,s=>l.account(s.account_alias,s.platform));if(!t.length){const s=i>0?n("perf.ranking_missing_currency"):o>0?void 0:r.rows.length>0?n("perf.ranking_missing_fields"):r.unavailable_reason?n(`reason.${r.unavailable_reason}`):n("reason.positions_not_connected");return e.jsx(R,{title:n(o>0?"perf.ranking_no_movement":"perf.ranking_unavailable"),body:s})}return e.jsxs("div",{children:[t.map(s=>e.jsxs("section",{className:"perf-ranking-currency","data-currency":s.currency,children:[e.jsx("h3",{className:"perf-ranking-heading perf-ranking-currency-heading",children:s.currency}),s.winners.length>0&&e.jsxs("div",{className:"perf-ranking-section",children:[e.jsx("h4",{className:"perf-ranking-heading",children:n("perf.ranking_winners")}),e.jsx(Se,{items:s.winners})]}),s.losers.length>0&&e.jsxs("div",{className:"perf-ranking-section",children:[e.jsx("h4",{className:"perf-ranking-heading",children:n("perf.ranking_losers")}),e.jsx(Se,{items:s.losers})]})]},s.currency)),i>0&&e.jsx("p",{className:"card-note",children:n("perf.ranking_missing_currency")}),e.jsx("p",{className:"card-note",children:n("perf.native_totals_note")}),e.jsx("p",{className:"card-note",children:n("perf.ranking_note")})]})}const Be=/^-?(?:0|[1-9]\d*)(?:\.\d+)?$/;function we(a){return a.platform==="longbridge"&&a.broker_cost_method==="broker_configured"&&typeof a.broker_cost_price=="string"&&Be.test(a.broker_cost_price)?a.broker_cost_price:null}function va(a){const n=a.startsWith("-"),l=n?a.slice(1):a,[r,t]=l.split("."),o=r.replace(/\B(?=(\d{3})+(?!\d))/g,",");return`${n?"-":""}${o}${t===void 0?"":`.${t}`}`}function B({value:a,currency:n}){const{prefs:l}=le();return typeof a!="string"||!Be.test(a)?e.jsx("span",{className:"flat",children:"—"}):l.hideAmounts?e.jsx("span",{className:"money",children:Ae(a)}):e.jsxs("span",{className:"num",title:a,children:[va(a),n?` ${n}`:""]})}function ja({scope:a,platform:n,range:l,epoch:r}){const t=C(),o=ne(),i=O(()=>Ve(a,l,n),[a,n,l,r]);if(i.phase==="loading")return e.jsx(L,{height:48});if(i.phase==="error")return e.jsx(F,{onRetry:i.reload});const s=i.data;if(!s||!Array.isArray(s.rows))return e.jsx(F,{onRetry:i.reload});const p=s.rows;if(!p.length&&s.status==="not_connected")return e.jsx(R,{title:t("state.not_connected"),body:t("reason.fills_not_connected"),state:"not_connected"});const u=[...p].sort((c,m)=>String(m.trade_date??"").localeCompare(String(c.trade_date??""))),h=c=>c.side==="BUY"?t("perf.side.buy"):c.side==="SELL"?t("perf.side.sell"):"—",_=[{id:"trade_date",header:t("perf.col.date"),cell:c=>e.jsxs(e.Fragment,{children:[e.jsx("span",{className:"num","data-asset-category":c.asset_category,"data-execution-ref":c.execution_ref,children:c.trade_date}),c.local_time&&e.jsxs("small",{className:"trade-time",children:[c.local_time.slice(11),c.time_zone?` · ${c.time_zone}`:""]})]}),sortValue:c=>c.trade_date},{id:"account",header:t("perf.col.account"),cell:c=>e.jsxs(e.Fragment,{children:[o.account(c.account_alias,c.platform),e.jsx("small",{className:"trade-time",children:o.platform(c.platform)})]}),sortValue:c=>`${c.platform}:${c.account_alias}`},{id:"symbol",header:t("perf.col.symbol"),cell:c=>c.symbol,sortValue:c=>c.symbol},{id:"side",header:t("perf.col.side"),cell:h},{id:"quantity",header:t("perf.col.quantity"),numeric:!0,cell:c=>e.jsx(B,{value:c.quantity})},{id:"price",header:t("perf.col.price"),numeric:!0,cell:c=>e.jsx(B,{value:c.price,currency:c.currency})},{id:"commission",header:t("perf.col.commission"),numeric:!0,cell:c=>e.jsx(B,{value:c.commission,currency:c.commission_currency})},{id:"taxes",header:t("perf.col.taxes"),numeric:!0,cell:c=>e.jsx(B,{value:c.taxes,currency:c.currency})}],y=s.reported_execution_count??p.length,k=s.status==="partial"||s.status==="ok"?"no_data":s.status,x=s.status==="partial"?t("perf.executions_empty_partial"):s.status==="ok"?void 0:s.unavailable_reason?t(`reason.${s.unavailable_reason}`):void 0;return e.jsxs("div",{className:"trade-view","data-state":s.status,"data-reason":s.unavailable_reason??void 0,children:[e.jsxs("div",{className:"trade-summary",children:[y>0&&e.jsx("span",{className:"card-note",children:t("perf.executions_count",{count:y})}),s.status==="partial"&&e.jsx("span",{className:"state-short",title:t("perf.executions_partial"),children:t("perf.executions_partial_short")}),s.as_of&&e.jsx(U,{value:s.as_of})]}),u.length?e.jsxs(e.Fragment,{children:[e.jsx("div",{className:"trade-table",children:e.jsx(Me,{columns:_,rows:u,rowKey:c=>`${c.platform}:${c.account_alias}:${c.execution_ref}`,defaultSort:{column:"trade_date",direction:"desc"},caption:t("perf.trades_title")})}),e.jsx("ul",{className:"trade-cards","aria-label":t("perf.trades_title"),children:u.map(c=>e.jsxs("li",{className:"trade-card","data-asset-category":c.asset_category,"data-execution-ref":c.execution_ref,children:[e.jsxs("div",{className:"trade-card-head",children:[e.jsx("span",{className:"trade-card-date num",children:c.trade_date}),e.jsx("span",{className:"trade-card-symbol",children:c.symbol}),e.jsx("span",{className:"trade-side",children:h(c)}),c.local_time&&e.jsxs("span",{className:"trade-card-time",children:[c.local_time.slice(11),c.time_zone?` · ${c.time_zone}`:""]})]}),e.jsx("div",{className:"trade-card-account",children:o.account(c.account_alias,c.platform)}),e.jsxs("dl",{className:"trade-card-figures",children:[e.jsxs("div",{className:"trade-figure",children:[e.jsx("dt",{children:t("perf.col.quantity")}),e.jsx("dd",{children:e.jsx(B,{value:c.quantity})})]}),e.jsxs("div",{className:"trade-figure",children:[e.jsx("dt",{children:t("perf.col.price")}),e.jsx("dd",{children:e.jsx(B,{value:c.price,currency:c.currency})})]}),e.jsxs("div",{className:"trade-figure",children:[e.jsx("dt",{children:t("perf.col.commission")}),e.jsx("dd",{children:e.jsx(B,{value:c.commission,currency:c.commission_currency})})]}),e.jsxs("div",{className:"trade-figure",children:[e.jsx("dt",{children:t("perf.col.taxes")}),e.jsx("dd",{children:e.jsx(B,{value:c.taxes,currency:c.currency})})]})]})]},`${c.platform}:${c.account_alias}:${c.execution_ref}`))})]}):e.jsx(R,{title:t(`state.${k}`),body:x,state:k})]})}function ga({scope:a,platform:n,range:l,epoch:r}){const t=C(),[o,i]=P.useState("holdings"),s=O(()=>Oe(a,l,n),[a,n,l,r]);let p;return o==="holdings"?p=e.jsx(ha,{state:s}):o==="ranking"?p=e.jsx(ya,{state:s}):p=e.jsx(ja,{scope:a,platform:n,range:l,epoch:r}),e.jsxs("div",{className:"card",children:[e.jsx(Qe,{id:"performance",items:[{id:"holdings",label:t("perf.holdings_title")},{id:"ranking",label:t("perf.ranking_title")},{id:"trades",label:t("perf.trades_title")}],active:o,onChange:i,ariaLabel:t("nav.performance")}),e.jsxs("div",{id:"performance-panel",className:"perf-tab-body",role:"tabpanel","aria-labelledby":`performance-tab-${o}`,tabIndex:0,children:[o!=="trades"&&s.phase==="ready"&&e.jsx("p",{className:"card-note",children:e.jsx(Ze,{counts:s.data.freshness_summary})}),p]})]})}function Aa(){const a=C(),n=V(),{prefs:l}=le(),{scope:r,options:t}=re(),o=Te(r),i=r==="all"?void 0:t.find(g=>`${g.platform}:${g.alias}`===r)?.platform,[s,p]=P.useState(l.defaultRange),[u,h]=P.useState(0),_=()=>h(g=>g+1),y=O(()=>Ye(r,s,i),[r,i,s,u]),k=O(()=>Ue(r,s,i),[r,i,s,u]),x=r==="all"&&k.phase==="ready"&&(k.data.per_account??[]).some(g=>j(g.status)&&g.return_kind==="twr"&&Ee(g.points).length>0),c=y.phase==="ready"&&j(y.data.status)&&y.data.twr_return_percent!==null?se(y.data.twr_return_percent,n):null,m=y.phase==="ready"?{[s]:c}:void 0;return e.jsxs("div",{className:"page",children:[e.jsxs("div",{className:"page-header",children:[e.jsx("h1",{className:"page-title",children:a("nav.performance")}),e.jsxs("div",{className:"page-header-actions",children:[e.jsx(Ie,{value:s,onChange:p,returns:m}),e.jsx("button",{type:"button",className:"button button-secondary",onClick:_,children:a("common.refresh")})]})]}),e.jsxs("p",{className:"page-subtitle",children:[o," · ",a(`perf.range.${s}`)]}),e.jsx(ta,{scope:r,platform:i,state:y,chartAvailable:x}),e.jsx(oa,{scope:r,platform:i,state:k}),e.jsxs("div",{className:"perf-duo-grid",children:[e.jsx(ua,{scope:r,platform:i,range:s,epoch:u}),e.jsx(_a,{scope:r,platform:i,range:s,epoch:u})]}),e.jsx(ga,{scope:r,platform:i,range:s,epoch:u})]})}export{Aa as default};
" },
-  "/v2/assets/StrategiesPage-CGEC27nb.css": { contentType: "text/css; charset=utf-8", base64: "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" },
-  "/v2/assets/StrategiesPage-DcL-BLIE.js": { contentType: "text/javascript; charset=utf-8", base64: "import{u as o,r as b,j as e,o as N,b as k,a3 as E,f as g,E as v,c as _,S as j,A as x,Q as f,B as p,F as S}from"./index-Ds_XXLsn.js";import{E as $}from"./ExecutionEvidence-BafFTQfM.js";import{u as w}from"./hooks-DCo9_b70.js";import{T as R}from"./Tabs-DBQ5AQB9.js";function C(t,s){return t.execution_evidence?.value||"unknown"}function T({accounts:t}){const s=o(),a=N(),n=k();return t.length===0?e.jsx(e.Fragment,{children:s("common.none")}):e.jsx("span",{className:"strategy-accounts",children:t.map(c=>e.jsxs("button",{type:"button",className:"strategy-account-link",onClick:()=>n({page:"accounts",account:f(c)}),children:[a.platform(c.platform)," · ",a.account(c.account_alias,c.platform)]},f(c)))})}function F({strategy:t}){const s=o();return t.health_score===null?e.jsx(e.Fragment,{children:s("common.na")}):e.jsx("span",{className:"num",children:s("strategies.health_score",{value:t.health_score})})}function L({accounts:t}){const s=o(),a=N();return t.length===0?null:e.jsxs("div",{className:"strategy-execution",children:[e.jsx("div",{className:"strategy-execution-title",children:s("strategies.account_execution")}),t.map(n=>e.jsxs("div",{className:"strategy-execution-account",children:[e.jsxs("span",{children:[a.platform(n.platform)," · ",a.account(n.account_alias,n.platform)]}),e.jsx($,{evidence:n.execution_evidence,showState:!0})]},f(n)))]})}function y({strategy:t,assignmentKnown:s=!0}){const a=o(),n=N(),c=t.allowed_execution_modes.length>0?t.allowed_execution_modes.map(n.lane).join(" · "):a("common.na"),i=t.configured_accounts.filter(d=>!d.execution_evidence?.value||d.execution_evidence.value==="unknown").length,l=i>0;return e.jsxs("article",{className:"card strategy-card",children:[e.jsxs("div",{className:"strategy-card-head",children:[e.jsx("h3",{className:"strategy-card-title",children:n.strategy(t.profile)}),e.jsxs("span",{className:"strategy-health-tag",children:[e.jsx("span",{className:"strategy-health-label",children:a("strategies.health_label")}),t.health_status?e.jsx(j,{status:t.health_status}):e.jsx(p,{tone:"unknown",children:a("strategies.health_not_provided")})]})]}),e.jsxs("dl",{className:"strategy-rows",children:[e.jsxs("div",{className:"strategy-row",children:[e.jsx("dt",{children:a("strategies.domain")}),e.jsx("dd",{children:n.domain(t.domain)})]}),e.jsxs("div",{className:"strategy-row",children:[e.jsx("dt",{children:a("strategies.modes")}),e.jsx("dd",{children:c})]}),t.configured_accounts.length===0&&e.jsxs("div",{className:"strategy-row","data-binding":s?"unbound":"unknown",children:[e.jsx("dt",{children:a("strategies.binding")}),e.jsx("dd",{children:s?e.jsx("span",{className:"strategy-unbound",title:a("strategies.unbound_note"),children:a("strategies.unbound")}):e.jsx("span",{children:a("strategies.assignment_unknown")})})]}),t.configured_accounts.length>0&&e.jsxs("div",{className:"strategy-row",children:[e.jsx("dt",{children:a("strategies.accounts_using")}),e.jsx("dd",{children:e.jsx(T,{accounts:t.configured_accounts})})]}),t.health_score!==null&&e.jsxs("div",{className:"strategy-row",children:[e.jsx("dt",{children:a("strategies.health")}),e.jsx("dd",{children:e.jsx(F,{strategy:t})})]})]}),t.configured_accounts.length>0&&e.jsxs("details",{className:"strategy-details",children:[e.jsxs("summary",{children:[a("strategies.execution_section"),l?` · ${a("strategies.execution.unknown")} ${i}`:""]}),e.jsxs("div",{className:"strategy-details-body",children:[e.jsx(L,{accounts:t.configured_accounts}),l&&e.jsx("p",{className:"card-note",children:a("strategies.execution_unknown_note")})]})]}),(t.status!=="ok"||t.as_of)&&e.jsxs("div",{className:"strategy-card-foot",children:[t.status!=="ok"&&e.jsx(j,{status:t.status,reason:t.unavailable_reason}),t.as_of&&e.jsx(x,{value:t.as_of,prefix:"strategies.health_as_of"})]})]})}function B({refreshEpoch:t}){const s=o(),a=N(),n=k(),c=w(E,[t]);if(c.phase==="loading")return e.jsx("div",{className:"strategy-grid","aria-busy":"true",children:[0,1,2].map(r=>e.jsxs("div",{className:"card strategy-card",children:[e.jsx(g,{height:18,width:"55%"}),e.jsx(g,{height:12}),e.jsx(g,{height:12}),e.jsx(g,{height:12,width:"70%"})]},r))});if(c.phase==="error")return e.jsx(v,{onRetry:c.reload});const i=c.data;if(i.status==="read_failed")return e.jsx(v,{onRetry:c.reload});if(i.strategies.length===0)return i.status==="not_connected"?e.jsx(_,{title:s("state.not_connected"),body:s("reason.strategy_health_not_connected")}):e.jsx(_,{title:s("strategies.empty")});const l=i.account_assignment_status===void 0||i.account_assignment_status==="complete",d=i.strategies.some(r=>r.configured_accounts.some(A=>C(A)==="live")),m=i.strategies.filter(r=>r.configured_accounts.length>0),u=i.strategies.filter(r=>r.configured_accounts.length===0),h=i.unmatched_strategy_assignments||[];return e.jsxs("section",{className:"section-stack",children:[e.jsxs("div",{className:"catalog-meta",children:[i.status!=="ok"&&e.jsx(j,{status:i.status}),e.jsx(x,{value:i.as_of})]}),e.jsx("p",{className:"card-note strategy-domain-note",children:s("strategies.domain_note")}),h.length>0&&e.jsxs("section",{className:"strategy-section","data-binding":"unmatched",children:[e.jsxs("div",{className:"strategy-section-head",children:[e.jsx("h2",{className:"strategy-section-title",children:s("strategies.unmatched_title")}),e.jsx("span",{className:"card-note",children:s("strategies.section_count",{count:h.length})})]}),e.jsx("p",{className:"card-note",role:"status",children:s("strategies.unmatched_note")}),e.jsx("ul",{className:"strategy-unmatched",children:h.map(r=>e.jsxs("li",{children:[e.jsxs("button",{type:"button",className:"strategy-account-link",onClick:()=>n({page:"accounts",account:f(r)}),children:[a.platform(r.platform)," · ",a.account(r.account_alias,r.platform)]}),e.jsx("code",{title:s("strategies.unmatched_profile"),children:r.strategy_profile})]},f(r)))})]}),d&&e.jsxs("div",{className:"card-note strategy-live-note",children:[e.jsx(p,{tone:"warn",children:s("strategies.execution.live")}),e.jsx("span",{children:s("strategies.live_exposure")}),e.jsx("span",{className:"state-short",children:s("strategies.execution_source")})]}),l?e.jsxs(e.Fragment,{children:[e.jsxs("section",{className:"strategy-section",children:[e.jsxs("div",{className:"strategy-section-head",children:[e.jsx("h2",{className:"strategy-section-title",children:s("strategies.configured_section")}),e.jsx("span",{className:"card-note",children:s("strategies.section_count",{count:m.length})})]}),m.length>0?e.jsx("div",{className:"strategy-grid",children:m.map(r=>e.jsx(y,{strategy:r},r.profile))}):e.jsx("p",{className:"card-note strategy-section-empty",children:s("strategies.no_configured")})]}),u.length>0&&e.jsxs("section",{className:"strategy-section",children:[e.jsxs("div",{className:"strategy-section-head",children:[e.jsx("h2",{className:"strategy-section-title",children:s("strategies.catalog_section")}),e.jsx("span",{className:"card-note",children:s("strategies.section_count",{count:u.length})})]}),e.jsx("div",{className:"strategy-grid",children:u.map(r=>e.jsx(y,{strategy:r},r.profile))})]})]}):e.jsxs(e.Fragment,{children:[e.jsx("p",{className:"card-note",role:"status",children:s("strategies.assignment_unavailable")}),e.jsx("div",{className:"strategy-grid",children:i.strategies.map(r=>e.jsx(y,{strategy:r,assignmentKnown:!1},r.profile))})]})]})}function K(t){if(!t||typeof t!="object")return{status:"read_failed"};const s=t;return s.schema_version!=="qsl_m0_research_dashboard.v1"||!["ready","stale","unavailable"].includes(s.data_status)||!Array.isArray(s.subjects)||!Array.isArray(s.errors)?{status:"read_failed"}:s.errors.some(a=>typeof a!="string"||/failed|unreadable|invalid/.test(a))?{status:"read_failed"}:s.data_status==="unavailable"?{status:"unavailable"}:s.subjects.every(a=>a?.subject&&typeof a.subject.identifier=="string"&&Array.isArray(a.observations)&&a.observations.every(n=>n&&Array.isArray(n.source_ids)&&n.source_ids.every(c=>typeof c=="string")&&typeof n.generated_at=="string"&&typeof n.expires_at=="string"&&typeof n.as_of=="string"&&typeof n.research_context?.state=="string"&&typeof n.freshness?.status=="string"))?{status:s.data_status,dashboard:s}:{status:"read_failed"}}async function O(){return K(await S("/api/m0-research"))}function q({refreshEpoch:t}){const s=o(),a=w(O,[t]);if(a.phase==="loading")return e.jsxs("div",{className:"section-stack","aria-busy":"true",children:[e.jsx(g,{height:72}),e.jsx(g,{height:72})]});if(a.phase==="error"||a.data.status==="read_failed")return e.jsx(v,{onRetry:a.reload});if(a.data.status==="unavailable")return e.jsx(_,{title:s("strategies.research_unavailable")});const n=a.data.dashboard;return n.subjects.length===0?e.jsx(_,{title:s("strategies.research_empty")}):e.jsxs("section",{className:"section-stack",children:[e.jsxs("div",{className:"catalog-meta",children:[e.jsx(p,{tone:"accent",children:s("strategies.research_only")}),a.data.status==="stale"&&e.jsx(j,{status:"stale"}),e.jsx(x,{value:n.source_generated_at})]}),e.jsx("div",{className:"research-list",children:n.subjects.map((c,i)=>e.jsxs("article",{className:"card research-item",children:[e.jsx("div",{className:"research-item-head",children:e.jsx("span",{className:"research-item-title",children:c.subject.identifier})}),c.observations.map((l,d)=>{const m=l.source_ids.map(u=>{const h=`research.source.${u}`,r=s(h);return r===h?u:r});return e.jsxs("div",{className:"section-stack",children:[e.jsxs("div",{className:"catalog-meta",children:[e.jsx(p,{tone:l.freshness.status==="stale"?"warn":"accent",title:s(`state.${l.freshness.status}`),children:s(`research.state.${l.research_context.state}`)}),l.freshness.status!=="fresh"&&e.jsx(j,{status:l.freshness.status})]}),e.jsx("p",{className:"research-item-summary",children:s("strategies.research_sources",{value:m.join(" · ")||s("common.unknown")})}),e.jsx("p",{className:"research-item-summary",children:s("strategies.research_as_of",{value:l.as_of})}),e.jsx(x,{value:l.generated_at}),e.jsx(x,{value:l.expires_at,prefix:"strategies.research_expires"})]},d)})]},`${c.subject.kind}/${c.subject.identifier}/${i}`))})]})}function M(){const t=o(),[s,a]=b.useState("catalog"),[n,c]=b.useState(0);return e.jsxs("div",{className:"page",children:[e.jsxs("header",{className:"page-header",children:[e.jsx("h1",{className:"page-title",children:t("strategies.title")}),e.jsx("div",{className:"page-header-actions",children:e.jsx("button",{type:"button",className:"button button-secondary",onClick:()=>c(i=>i+1),children:t("common.refresh")})})]}),e.jsx(R,{id:"strategies",items:[{id:"catalog",label:t("strategies.tab.catalog")},{id:"research",label:t("strategies.tab.research")}],active:s,onChange:i=>a(i),ariaLabel:t("strategies.title")}),e.jsx("div",{id:"strategies-panel",role:"tabpanel","aria-labelledby":`strategies-tab-${s}`,tabIndex:0,children:s==="catalog"?e.jsx(B,{refreshEpoch:n}):e.jsx(q,{refreshEpoch:n})})]})}export{M as default};
" },
-  "/v2/assets/Tabs-DBQ5AQB9.js": { contentType: "text/javascript; charset=utf-8", base64: "aW1wb3J0e3IgYXMgaSxqIGFzIGR9ZnJvbSIuL2luZGV4LURzX1hYTHNuLmpzIjtmdW5jdGlvbiB4KGwscixlKXtpZihyPj1lKXJldHVybiBsO2NvbnN0IGM9bCtyO3JldHVybiBsPDA/bDpjPmU/Yy1lOjB9ZnVuY3Rpb24gaCh7aWQ6bCxpdGVtczpyLGFjdGl2ZTplLG9uQ2hhbmdlOmMsYXJpYUxhYmVsOmZ9KXtjb25zdCB1PWkudXNlUmVmKG51bGwpO3JldHVybiBpLnVzZUVmZmVjdCgoKT0+e2NvbnN0IHQ9dS5jdXJyZW50O2lmKCF0fHx0LnNjcm9sbFdpZHRoPD10LmNsaWVudFdpZHRoKXJldHVybjtjb25zdCBuPXQucXVlcnlTZWxlY3RvcignW3JvbGU9InRhYiJdW2FyaWEtc2VsZWN0ZWQ9InRydWUiXScpO2lmKCFuKXJldHVybjtjb25zdCBzPXQuZ2V0Qm91bmRpbmdDbGllbnRSZWN0KCksbz1uLmdldEJvdW5kaW5nQ2xpZW50UmVjdCgpLGE9eChvLmxlZnQtcy5sZWZ0LG8ud2lkdGgsdC5jbGllbnRXaWR0aCk7YSE9PTAmJih0LnNjcm9sbExlZnQ9TWF0aC5tYXgoMCx0LnNjcm9sbExlZnQrYSkpfSxbZV0pLGQuanN4KCJkaXYiLHtjbGFzc05hbWU6InRhYnMiLHJvbGU6InRhYmxpc3QiLCJhcmlhLWxhYmVsIjpmLHJlZjp1LGNoaWxkcmVuOnIubWFwKHQ9PmQuanN4KCJidXR0b24iLHt0eXBlOiJidXR0b24iLHJvbGU6InRhYiIsaWQ6YCR7bH0tdGFiLSR7dC5pZH1gLCJhcmlhLWNvbnRyb2xzIjpgJHtsfS1wYW5lbGAsImFyaWEtc2VsZWN0ZWQiOnQuaWQ9PT1lLHRhYkluZGV4OnQuaWQ9PT1lPzA6LTEsY2xhc3NOYW1lOmB0YWIke3QuaWQ9PT1lPyIgYWN0aXZlIjoiIn1gLG9uQ2xpY2s6KCk9PmModC5pZCksb25LZXlEb3duOm49Pntjb25zdCBzPXIuZmluZEluZGV4KGI9PmIuaWQ9PT10LmlkKSxvPW4ua2V5PT09IkhvbWUiPzA6bi5rZXk9PT0iRW5kIj9yLmxlbmd0aC0xOm4ua2V5PT09IkFycm93UmlnaHQiPyhzKzEpJXIubGVuZ3RoOm4ua2V5PT09IkFycm93TGVmdCI/KHMtMStyLmxlbmd0aCklci5sZW5ndGg6bnVsbDtpZihvPT09bnVsbClyZXR1cm47bi5wcmV2ZW50RGVmYXVsdCgpLG4uY3VycmVudFRhcmdldC5wYXJlbnRFbGVtZW50Py5xdWVyeVNlbGVjdG9yQWxsKCdbcm9sZT0idGFiIl0nKT8uW29dPy5mb2N1cygpLGMocltvXS5pZCl9LGNoaWxkcmVuOnQubGFiZWx9LHQuaWQpKX0pfWV4cG9ydHtoIGFzIFR9Owo=" },
+  "/v2/assets/StrategiesPage-CeZkxG_N.css": { contentType: "text/css; charset=utf-8", base64: "LmNhdGFsb2ctbWV0YXtkaXNwbGF5OmZsZXg7YWxpZ24taXRlbXM6Y2VudGVyO2dhcDo4cHggMTJweDtmbGV4LXdyYXA6d3JhcH0uc3RyYXRlZ3ktZG9tYWluLW5vdGV7bWFyZ2luOjA7bWF4LXdpZHRoOjg4Y2h9LnN0cmF0ZWd5LXNlY3Rpb24taGVhZHtkaXNwbGF5OmZsZXg7YWxpZ24taXRlbXM6YmFzZWxpbmU7anVzdGlmeS1jb250ZW50OnNwYWNlLWJldHdlZW47Z2FwOjhweCAxMnB4O2ZsZXgtd3JhcDp3cmFwO21hcmdpbi1ib3R0b206MTBweH0uc3RyYXRlZ3ktc2VjdGlvbi10aXRsZXttYXJnaW46MDtmb250LXNpemU6MTVweDtmb250LXdlaWdodDo2NTA7bGV0dGVyLXNwYWNpbmc6LS4wMWVtfS5zdHJhdGVneS1zZWN0aW9uLWhlYWQgLmNhcmQtbm90ZXttYXJnaW46MH0uc3RyYXRlZ3ktc2VjdGlvbi1lbXB0eXttYXJnaW46MDtwYWRkaW5nOjEwcHggMH0uc3RyYXRlZ3ktdW5tYXRjaGVke2xpc3Qtc3R5bGU6bm9uZTttYXJnaW46OHB4IDAgMDtwYWRkaW5nOjA7ZGlzcGxheTpmbGV4O2ZsZXgtZGlyZWN0aW9uOmNvbHVtbjtnYXA6NnB4fS5zdHJhdGVneS11bm1hdGNoZWQgbGl7ZGlzcGxheTpmbGV4O2FsaWduLWl0ZW1zOmNlbnRlcjtnYXA6OHB4IDEycHg7ZmxleC13cmFwOndyYXB9LnN0cmF0ZWd5LXVubWF0Y2hlZCBjb2Rle2NvbG9yOnZhcigtLW11dGVkKTtmb250LXNpemU6MTJweDtvdmVyZmxvdy13cmFwOmFueXdoZXJlfS5zdHJhdGVneS1jYXJke2Rpc3BsYXk6ZmxleDtmbGV4LWRpcmVjdGlvbjpjb2x1bW47Z2FwOjEycHg7bWluLXdpZHRoOjA7cGFkZGluZzoxNnB4IDE4cHh9LnN0cmF0ZWd5LWNhcmQtaGVhZHtkaXNwbGF5OmZsZXg7YWxpZ24taXRlbXM6ZmxleC1zdGFydDtqdXN0aWZ5LWNvbnRlbnQ6c3BhY2UtYmV0d2VlbjtnYXA6MTBweDtmbGV4LXdyYXA6d3JhcH0uc3RyYXRlZ3ktY2FyZC10aXRsZXttYXJnaW46MDtmb250LXNpemU6MTZweDtmb250LXdlaWdodDo2NTA7bGluZS1oZWlnaHQ6MS4zNTtvdmVyZmxvdy13cmFwOmFueXdoZXJlfS5zdHJhdGVneS1oZWFsdGgtdGFne2Rpc3BsYXk6aW5saW5lLWZsZXg7YWxpZ24taXRlbXM6Y2VudGVyO2dhcDo2cHg7ZmxleC13cmFwOndyYXB9LnN0cmF0ZWd5LWhlYWx0aC1sYWJlbHtjb2xvcjp2YXIoLS1tdXRlZCk7Zm9udC1zaXplOjEycHh9LnN0cmF0ZWd5LXJvd3N7bWFyZ2luOjA7ZGlzcGxheTpmbGV4O2ZsZXgtZGlyZWN0aW9uOmNvbHVtbjtnYXA6MH0uc3RyYXRlZ3ktcm93e2Rpc3BsYXk6ZmxleDtqdXN0aWZ5LWNvbnRlbnQ6c3BhY2UtYmV0d2VlbjtnYXA6MTRweDtwYWRkaW5nOjZweCAwO2JvcmRlci1ib3R0b206MXB4IHNvbGlkIHZhcigtLXNvZnQtbGluZSwgdmFyKC0tbGluZSkpO2ZvbnQtc2l6ZToxM3B4O2FsaWduLWl0ZW1zOmJhc2VsaW5lfS5zdHJhdGVneS1yb3c6bGFzdC1jaGlsZHtib3JkZXItYm90dG9tOjB9LnN0cmF0ZWd5LXJvdyBkdHtjb2xvcjp2YXIoLS1tdXRlZCk7ZmxleDowIDAgYXV0bztmb250LXNpemU6MTJweH0uc3RyYXRlZ3ktcm93IGRke21hcmdpbjowO3RleHQtYWxpZ246cmlnaHQ7b3ZlcmZsb3ctd3JhcDphbnl3aGVyZTtkaXNwbGF5OmZsZXg7Z2FwOjZweDtmbGV4LXdyYXA6d3JhcDtqdXN0aWZ5LWNvbnRlbnQ6ZmxleC1lbmQ7YWxpZ24taXRlbXM6Y2VudGVyfS5zdHJhdGVneS11bmJvdW5ke2NvbG9yOnZhcigtLW11dGVkKTtmb250LXdlaWdodDo1MDB9LnN0cmF0ZWd5LWFjY291bnRze2Rpc3BsYXk6aW5saW5lLWZsZXg7Z2FwOjRweCA4cHg7ZmxleC13cmFwOndyYXA7anVzdGlmeS1jb250ZW50OmZsZXgtZW5kfS5zdHJhdGVneS1hY2NvdW50LWxpbmt7ZGlzcGxheTppbmxpbmUtZmxleDthbGlnbi1pdGVtczpjZW50ZXI7bWluLWhlaWdodDozMnB4O2NvbG9yOnZhcigtLWFjY2VudCk7cGFkZGluZzo0cHggNnB4O2JvcmRlci1yYWRpdXM6NHB4fS5zdHJhdGVneS1hY2NvdW50LWxpbms6aG92ZXJ7dGV4dC1kZWNvcmF0aW9uOnVuZGVybGluZX0uc3RyYXRlZ3ktY2FyZC1mb290e2Rpc3BsYXk6ZmxleDthbGlnbi1pdGVtczpjZW50ZXI7Z2FwOjhweDtmbGV4LXdyYXA6d3JhcDttYXJnaW4tdG9wOmF1dG99LnN0cmF0ZWd5LWV4ZWN1dGlvbntkaXNwbGF5OmZsZXg7ZmxleC1kaXJlY3Rpb246Y29sdW1uO2dhcDo4cHg7cGFkZGluZzoxMHB4IDEycHg7Ym9yZGVyOjFweCBzb2xpZCB2YXIoLS1zb2Z0LWxpbmUsIHZhcigtLWxpbmUpKTtib3JkZXItcmFkaXVzOjlweDtiYWNrZ3JvdW5kOnZhcigtLXN1cmZhY2UtMik7Zm9udC1zaXplOjEzcHh9LnN0cmF0ZWd5LWV4ZWN1dGlvbi10aXRsZSwuc3RyYXRlZ3ktZXhlY3V0aW9uLW5vdGV7Y29sb3I6dmFyKC0tbXV0ZWQpfS5zdHJhdGVneS1leGVjdXRpb24tdGl0bGV7Zm9udC1zaXplOjEycHg7Zm9udC13ZWlnaHQ6NjAwfS5zdHJhdGVneS1leGVjdXRpb24tYWNjb3VudHtkaXNwbGF5OmZsZXg7Z2FwOjZweCAxMnB4O2ZsZXgtd3JhcDp3cmFwO2p1c3RpZnktY29udGVudDpzcGFjZS1iZXR3ZWVuO2FsaWduLWl0ZW1zOmZsZXgtc3RhcnR9LnN0cmF0ZWd5LWV4ZWN1dGlvbi1ub3Rle21hcmdpbjowO2xpbmUtaGVpZ2h0OjEuNX0uc3RyYXRlZ3ktbGl2ZS1ub3Rle2Rpc3BsYXk6ZmxleDthbGlnbi1pdGVtczpmbGV4LXN0YXJ0O2dhcDo4cHg7ZmxleC13cmFwOndyYXB9LnN0cmF0ZWd5LWxpdmUtbm90ZSBkZXRhaWxze2ZsZXgtYmFzaXM6MTAwJX0uc3RyYXRlZ3ktbGl2ZS1ub3RlIHN1bW1hcnksLnJlc2VhcmNoLWl0ZW0tbW9yZSBzdW1tYXJ5e2N1cnNvcjpwb2ludGVyO2NvbG9yOnZhcigtLWFjY2VudCk7Zm9udC1zaXplOjEycHh9LnN0cmF0ZWd5LWxpdmUtbm90ZSBwe21hcmdpbjo0cHggMCAwfS5yZXNlYXJjaC1pdGVtLW1vcmV7Zm9udC1zaXplOjEycHg7Y29sb3I6dmFyKC0tbXV0ZWQpfS5yZXNlYXJjaC1pdGVtLW1vcmUgcHttYXJnaW46NHB4IDAgMDtvdmVyZmxvdy13cmFwOmFueXdoZXJlfS5zdHJhdGVneS1kZXRhaWxze2JvcmRlci10b3A6MXB4IHNvbGlkIHZhcigtLWxpbmUpO3BhZGRpbmctdG9wOjhweDttYXJnaW4tdG9wOmF1dG99LnN0cmF0ZWd5LWRldGFpbHMgc3VtbWFyeXtjdXJzb3I6cG9pbnRlcjtjb2xvcjp2YXIoLS1tdXRlZCk7Zm9udC1zaXplOjEzcHg7bWluLWhlaWdodDozMnB4O3BhZGRpbmc6NnB4IDB9LnN0cmF0ZWd5LWRldGFpbHMgc3VtbWFyeTpob3Zlcntjb2xvcjp2YXIoLS1pbmspfS5zdHJhdGVneS1kZXRhaWxzLWJvZHl7ZGlzcGxheTpmbGV4O2ZsZXgtZGlyZWN0aW9uOmNvbHVtbjtnYXA6OHB4O3BhZGRpbmctdG9wOjRweH0uc3RyYXRlZ3ktZGV0YWlscy1ib2R5IC5zdHJhdGVneS1leGVjdXRpb257cGFkZGluZzowO2JvcmRlcjowO2JhY2tncm91bmQ6dHJhbnNwYXJlbnR9LnN0cmF0ZWd5LWxpZmVjeWNsZSsuc3RyYXRlZ3ktbGlmZWN5Y2xle2JvcmRlci10b3A6MXB4IHNvbGlkIHZhcigtLWxpbmUpO3BhZGRpbmctdG9wOjEwcHh9LnN0cmF0ZWd5LWxpZmVjeWNsZSAuY29ja3BpdC1zZWN0aW9ue3BhZGRpbmc6MDtib3JkZXI6MDtiYWNrZ3JvdW5kOnRyYW5zcGFyZW50fS5yZXNlYXJjaC1saXN0e2Rpc3BsYXk6ZmxleDtmbGV4LWRpcmVjdGlvbjpjb2x1bW47Z2FwOjEwcHh9LnJlc2VhcmNoLWl0ZW17ZGlzcGxheTpmbGV4O2ZsZXgtZGlyZWN0aW9uOmNvbHVtbjtnYXA6OHB4O3BhZGRpbmc6MTZweCAxOHB4fS5yZXNlYXJjaC1pdGVtLWhlYWR7ZGlzcGxheTpmbGV4O2FsaWduLWl0ZW1zOmNlbnRlcjtqdXN0aWZ5LWNvbnRlbnQ6c3BhY2UtYmV0d2VlbjtnYXA6OHB4O2ZsZXgtd3JhcDp3cmFwfS5yZXNlYXJjaC1pdGVtLXRpdGxle2ZvbnQtc2l6ZToxNXB4O2ZvbnQtd2VpZ2h0OjYwMDtvdmVyZmxvdy13cmFwOmFueXdoZXJlfS5yZXNlYXJjaC1pdGVtLXN1bW1hcnl7bWFyZ2luOjA7Y29sb3I6dmFyKC0tbXV0ZWQpO2ZvbnQtc2l6ZToxM3B4O2xpbmUtaGVpZ2h0OjEuNTU7b3ZlcmZsb3ctd3JhcDphbnl3aGVyZX1AbWVkaWEobWF4LXdpZHRoOjc2OHB4KXsuc3RyYXRlZ3ktZ3JpZHtnYXA6MTJweH0uc3RyYXRlZ3ktY2FyZCwucmVzZWFyY2gtaXRlbXtwYWRkaW5nOjE0cHggMTZweH19QG1lZGlhKG1heC13aWR0aDo2MDBweCl7LnN0cmF0ZWd5LWdyaWR7Z3JpZC10ZW1wbGF0ZS1jb2x1bW5zOm1pbm1heCgwLDFmcil9LnN0cmF0ZWd5LXJvd3tmbGV4LWRpcmVjdGlvbjpjb2x1bW47Z2FwOjJweH0uc3RyYXRlZ3ktcm93IGRke2p1c3RpZnktY29udGVudDpmbGV4LXN0YXJ0O3RleHQtYWxpZ246bGVmdH0uc3RyYXRlZ3ktYWNjb3VudHN7anVzdGlmeS1jb250ZW50OmZsZXgtc3RhcnR9fQo=" },
+  "/v2/assets/StrategiesPage-DUHVXLhP.js": { contentType: "text/javascript; charset=utf-8", base64: "import{u,r as S,j as e,p as v,b as A,a3 as $,g,E as w,c as y,S as f,A as j,Q as p,B as N,F as R}from"./index-CwQsWZdm.js";import{E as L}from"./ExecutionEvidence-CDki-xbb.js";import{f as C,L as F,a as T}from"./cockpit-Cax-GxP0.js";import{u as E}from"./hooks-9usXmJc_.js";import{T as B}from"./Tabs-BP4xZNhq.js";function P(t,s){return t.execution_evidence?.value||"unknown"}function K({accounts:t}){const s=u(),n=v(),a=A();return t.length===0?e.jsx(e.Fragment,{children:s("common.none")}):e.jsx("span",{className:"strategy-accounts",children:t.map(r=>e.jsxs("button",{type:"button",className:"strategy-account-link",onClick:()=>a({page:"accounts",account:p(r)}),children:[n.platform(r.platform)," · ",n.account(r.account_alias,r.platform)]},p(r)))})}function M({strategy:t}){const s=u();return t.health_score===null?e.jsx(e.Fragment,{children:s("common.na")}):e.jsx("span",{className:"num",children:s("strategies.health_score",{value:t.health_score})})}function O({accounts:t}){const s=u(),n=v();return t.length===0?null:e.jsxs("div",{className:"strategy-execution",children:[e.jsx("div",{className:"strategy-execution-title",children:s("strategies.account_execution")}),t.map(a=>e.jsxs("div",{className:"strategy-execution-account",children:[e.jsxs("span",{children:[n.platform(a.platform)," · ",n.account(a.account_alias,a.platform)]}),e.jsx(L,{evidence:a.execution_evidence,showState:!0})]},p(a)))]})}function k({strategy:t,assignmentKnown:s=!0,lifecycles:n}){const a=u(),r=v(),o=t.allowed_execution_modes.length>0?t.allowed_execution_modes.map(r.lane).join(" · "):a("common.na"),i=t.configured_accounts.filter(l=>!l.execution_evidence?.value||l.execution_evidence.value==="unknown").length,d=i>0;return e.jsxs("article",{className:"card strategy-card",children:[e.jsxs("div",{className:"strategy-card-head",children:[e.jsx("h3",{className:"strategy-card-title",children:r.strategy(t.profile)}),e.jsxs("span",{className:"strategy-health-tag",children:[e.jsx("span",{className:"strategy-health-label",children:a("strategies.health_label")}),t.health_status?e.jsx(f,{status:t.health_status}):e.jsx(N,{tone:"unknown",children:a("strategies.health_not_provided")})]})]}),e.jsxs("dl",{className:"strategy-rows",children:[e.jsxs("div",{className:"strategy-row",children:[e.jsx("dt",{children:a("strategies.domain")}),e.jsx("dd",{children:r.domain(t.domain)})]}),e.jsxs("div",{className:"strategy-row",children:[e.jsx("dt",{children:a("strategies.modes")}),e.jsx("dd",{children:o})]}),t.configured_accounts.length===0&&e.jsxs("div",{className:"strategy-row","data-binding":s?"unbound":"unknown",children:[e.jsx("dt",{children:a("strategies.binding")}),e.jsx("dd",{children:s?e.jsx("span",{className:"strategy-unbound",title:a("strategies.unbound_note"),children:a("strategies.unbound")}):e.jsx("span",{children:a("strategies.assignment_unknown")})})]}),t.configured_accounts.length>0&&e.jsxs("div",{className:"strategy-row",children:[e.jsx("dt",{children:a("strategies.accounts_using")}),e.jsx("dd",{children:e.jsx(K,{accounts:t.configured_accounts})})]}),t.health_score!==null&&e.jsxs("div",{className:"strategy-row",children:[e.jsx("dt",{children:a("strategies.health")}),e.jsx("dd",{children:e.jsx(M,{strategy:t})})]})]}),t.configured_accounts.length>0&&e.jsxs("details",{className:"strategy-details",children:[e.jsxs("summary",{children:[a("strategies.execution_section"),d?` · ${a("strategies.execution.unknown")} ${i}`:""]}),e.jsxs("div",{className:"strategy-details-body",children:[e.jsx(O,{accounts:t.configured_accounts}),d&&e.jsx("p",{className:"card-note",children:a("strategies.execution_unknown_note")})]})]}),n&&n.length>0&&e.jsxs("details",{className:"strategy-details",children:[e.jsx("summary",{children:a("cockpit.lifecycle.title")}),e.jsx("div",{className:"strategy-details-body",children:n.map((l,h)=>e.jsxs("div",{className:"strategy-lifecycle",children:[e.jsxs("p",{className:"cockpit-meta",children:[l.platform&&e.jsxs(e.Fragment,{children:[r.platform(l.platform)," · "]}),l.account_alias?r.account(l.account_alias,l.platform??""):a("decisions.account_unbound")," · ",a("cockpit.lifecycle.identity",{release:l.release_id??a("cockpit.unknown"),target:l.target_id??a("cockpit.unknown")})]}),l.present?e.jsxs(e.Fragment,{children:[e.jsx(F,{binding:l}),l.evidence&&e.jsx(T,{evidence:l.evidence}),l.regime_effect&&e.jsx("p",{className:"cockpit-note",children:l.regime_effect})]}):e.jsx("p",{className:"cockpit-note",children:a("cockpit.lifecycle.not_provided")})]},`${l.account_alias}/${l.platform}/${l.release_id??h}`))})]}),(t.status!=="ok"||t.as_of)&&e.jsxs("div",{className:"strategy-card-foot",children:[t.status!=="ok"&&e.jsx(f,{status:t.status,reason:t.unavailable_reason}),t.as_of&&e.jsx(j,{value:t.as_of,prefix:"strategies.health_as_of"})]})]})}function q({refreshEpoch:t}){const s=u(),n=v(),a=A(),r=E($,[t]),o=E(()=>r.phase==="ready"?C(r.data):Promise.resolve({status:"ready",data:[],synthetic:!1}),[r.phase==="ready"?r.data:null]);if(r.phase==="loading")return e.jsx("div",{className:"strategy-grid","aria-busy":"true",children:[0,1,2].map(c=>e.jsxs("div",{className:"card strategy-card",children:[e.jsx(g,{height:18,width:"55%"}),e.jsx(g,{height:12}),e.jsx(g,{height:12}),e.jsx(g,{height:12,width:"70%"})]},c))});if(r.phase==="error")return e.jsx(w,{onRetry:r.reload});const i=r.data;if(i.status==="read_failed")return e.jsx(w,{onRetry:r.reload});const d=new Map;if(o.phase==="ready"&&o.data.status==="ready")for(const c of o.data.data){const _=d.get(c.profile);_?_.push(c):d.set(c.profile,[c])}if(i.strategies.length===0)return i.status==="not_connected"?e.jsx(y,{title:s("state.not_connected"),body:s("reason.strategy_health_not_connected")}):e.jsx(y,{title:s("strategies.empty")});const l=i.account_assignment_status===void 0||i.account_assignment_status==="complete",h=i.strategies.some(c=>c.configured_accounts.some(_=>P(_)==="live")),m=i.strategies.filter(c=>c.configured_accounts.length>0),x=i.strategies.filter(c=>c.configured_accounts.length===0),b=i.unmatched_strategy_assignments||[];return e.jsxs("section",{className:"section-stack",children:[e.jsxs("div",{className:"catalog-meta",children:[i.status!=="ok"&&e.jsx(f,{status:i.status}),e.jsx(j,{value:i.as_of})]}),e.jsx("p",{className:"card-note strategy-domain-note",children:s("strategies.domain_note")}),b.length>0&&e.jsxs("section",{className:"strategy-section","data-binding":"unmatched",children:[e.jsxs("div",{className:"strategy-section-head",children:[e.jsx("h2",{className:"strategy-section-title",children:s("strategies.unmatched_title")}),e.jsx("span",{className:"card-note",children:s("strategies.section_count",{count:b.length})})]}),e.jsx("p",{className:"card-note",role:"status",children:s("strategies.unmatched_note")}),e.jsx("ul",{className:"strategy-unmatched",children:b.map(c=>e.jsxs("li",{children:[e.jsxs("button",{type:"button",className:"strategy-account-link",onClick:()=>a({page:"accounts",account:p(c)}),children:[n.platform(c.platform)," · ",n.account(c.account_alias,c.platform)]}),e.jsx("code",{title:s("strategies.unmatched_profile"),children:c.strategy_profile})]},p(c)))})]}),h&&e.jsxs("div",{className:"card-note strategy-live-note",children:[e.jsx(N,{tone:"warn",children:s("strategies.execution.live")}),e.jsx("span",{children:s("strategies.live_exposure")}),e.jsx("span",{className:"state-short",children:s("strategies.execution_source")})]}),l?e.jsxs(e.Fragment,{children:[e.jsxs("section",{className:"strategy-section",children:[e.jsxs("div",{className:"strategy-section-head",children:[e.jsx("h2",{className:"strategy-section-title",children:s("strategies.configured_section")}),e.jsx("span",{className:"card-note",children:s("strategies.section_count",{count:m.length})})]}),m.length>0?e.jsx("div",{className:"strategy-grid",children:m.map(c=>e.jsx(k,{strategy:c,lifecycles:d.get(c.profile)},c.profile))}):e.jsx("p",{className:"card-note strategy-section-empty",children:s("strategies.no_configured")})]}),x.length>0&&e.jsxs("section",{className:"strategy-section",children:[e.jsxs("div",{className:"strategy-section-head",children:[e.jsx("h2",{className:"strategy-section-title",children:s("strategies.catalog_section")}),e.jsx("span",{className:"card-note",children:s("strategies.section_count",{count:x.length})})]}),e.jsx("div",{className:"strategy-grid",children:x.map(c=>e.jsx(k,{strategy:c,lifecycles:d.get(c.profile)},c.profile))})]})]}):e.jsxs(e.Fragment,{children:[e.jsx("p",{className:"card-note",role:"status",children:s("strategies.assignment_unavailable")}),e.jsx("div",{className:"strategy-grid",children:i.strategies.map(c=>e.jsx(k,{strategy:c,assignmentKnown:!1,lifecycles:d.get(c.profile)},c.profile))})]})]})}function D(t){if(!t||typeof t!="object")return{status:"read_failed"};const s=t;return s.schema_version!=="qsl_m0_research_dashboard.v1"||!["ready","stale","unavailable"].includes(s.data_status)||!Array.isArray(s.subjects)||!Array.isArray(s.errors)?{status:"read_failed"}:s.errors.some(n=>typeof n!="string"||/failed|unreadable|invalid/.test(n))?{status:"read_failed"}:s.data_status==="unavailable"?{status:"unavailable"}:s.subjects.every(n=>n?.subject&&typeof n.subject.identifier=="string"&&Array.isArray(n.observations)&&n.observations.every(a=>a&&Array.isArray(a.source_ids)&&a.source_ids.every(r=>typeof r=="string")&&typeof a.generated_at=="string"&&typeof a.expires_at=="string"&&typeof a.as_of=="string"&&typeof a.research_context?.state=="string"&&typeof a.freshness?.status=="string"))?{status:s.data_status,dashboard:s}:{status:"read_failed"}}async function H(){return D(await R("/api/m0-research"))}function I({refreshEpoch:t}){const s=u(),n=E(H,[t]);if(n.phase==="loading")return e.jsxs("div",{className:"section-stack","aria-busy":"true",children:[e.jsx(g,{height:72}),e.jsx(g,{height:72})]});if(n.phase==="error"||n.data.status==="read_failed")return e.jsx(w,{onRetry:n.reload});if(n.data.status==="unavailable")return e.jsx(y,{title:s("strategies.research_unavailable")});const a=n.data.dashboard;return a.subjects.length===0?e.jsx(y,{title:s("strategies.research_empty")}):e.jsxs("section",{className:"section-stack",children:[e.jsxs("div",{className:"catalog-meta",children:[e.jsx(N,{tone:"accent",children:s("strategies.research_only")}),n.data.status==="stale"&&e.jsx(f,{status:"stale"}),e.jsx(j,{value:a.source_generated_at})]}),e.jsx("div",{className:"research-list",children:a.subjects.map((r,o)=>e.jsxs("article",{className:"card research-item",children:[e.jsx("div",{className:"research-item-head",children:e.jsx("span",{className:"research-item-title",children:r.subject.identifier})}),r.observations.map((i,d)=>{const l=i.source_ids.map(h=>{const m=`research.source.${h}`,x=s(m);return x===m?h:x});return e.jsxs("div",{className:"section-stack",children:[e.jsxs("div",{className:"catalog-meta",children:[e.jsx(N,{tone:i.freshness.status==="stale"?"warn":"accent",title:s(`state.${i.freshness.status}`),children:s(`research.state.${i.research_context.state}`)}),i.freshness.status!=="fresh"&&e.jsx(f,{status:i.freshness.status})]}),e.jsx("p",{className:"research-item-summary",children:s("strategies.research_sources",{value:l.join(" · ")||s("common.unknown")})}),e.jsx("p",{className:"research-item-summary",children:s("strategies.research_as_of",{value:i.as_of})}),e.jsx(j,{value:i.generated_at}),e.jsx(j,{value:i.expires_at,prefix:"strategies.research_expires"})]},d)})]},`${r.subject.kind}/${r.subject.identifier}/${o}`))})]})}function G(){const t=u(),[s,n]=S.useState("catalog"),[a,r]=S.useState(0);return e.jsxs("div",{className:"page",children:[e.jsxs("header",{className:"page-header",children:[e.jsx("h1",{className:"page-title",children:t("strategies.title")}),e.jsx("div",{className:"page-header-actions",children:e.jsx("button",{type:"button",className:"button button-secondary",onClick:()=>r(o=>o+1),children:t("common.refresh")})})]}),e.jsx(B,{id:"strategies",items:[{id:"catalog",label:t("strategies.tab.catalog")},{id:"research",label:t("strategies.tab.research")}],active:s,onChange:o=>n(o),ariaLabel:t("strategies.title")}),e.jsx("div",{id:"strategies-panel",role:"tabpanel","aria-labelledby":`strategies-tab-${s}`,tabIndex:0,children:s==="catalog"?e.jsx(q,{refreshEpoch:a}):e.jsx(I,{refreshEpoch:a})})]})}export{G as default};
" },
+  "/v2/assets/Tabs-BP4xZNhq.js": { contentType: "text/javascript; charset=utf-8", base64: "aW1wb3J0e3IgYXMgaSxqIGFzIGR9ZnJvbSIuL2luZGV4LUN3UXNXWmRtLmpzIjtmdW5jdGlvbiB4KGwscixlKXtpZihyPj1lKXJldHVybiBsO2NvbnN0IGM9bCtyO3JldHVybiBsPDA/bDpjPmU/Yy1lOjB9ZnVuY3Rpb24gaCh7aWQ6bCxpdGVtczpyLGFjdGl2ZTplLG9uQ2hhbmdlOmMsYXJpYUxhYmVsOmZ9KXtjb25zdCB1PWkudXNlUmVmKG51bGwpO3JldHVybiBpLnVzZUVmZmVjdCgoKT0+e2NvbnN0IHQ9dS5jdXJyZW50O2lmKCF0fHx0LnNjcm9sbFdpZHRoPD10LmNsaWVudFdpZHRoKXJldHVybjtjb25zdCBuPXQucXVlcnlTZWxlY3RvcignW3JvbGU9InRhYiJdW2FyaWEtc2VsZWN0ZWQ9InRydWUiXScpO2lmKCFuKXJldHVybjtjb25zdCBzPXQuZ2V0Qm91bmRpbmdDbGllbnRSZWN0KCksbz1uLmdldEJvdW5kaW5nQ2xpZW50UmVjdCgpLGE9eChvLmxlZnQtcy5sZWZ0LG8ud2lkdGgsdC5jbGllbnRXaWR0aCk7YSE9PTAmJih0LnNjcm9sbExlZnQ9TWF0aC5tYXgoMCx0LnNjcm9sbExlZnQrYSkpfSxbZV0pLGQuanN4KCJkaXYiLHtjbGFzc05hbWU6InRhYnMiLHJvbGU6InRhYmxpc3QiLCJhcmlhLWxhYmVsIjpmLHJlZjp1LGNoaWxkcmVuOnIubWFwKHQ9PmQuanN4KCJidXR0b24iLHt0eXBlOiJidXR0b24iLHJvbGU6InRhYiIsaWQ6YCR7bH0tdGFiLSR7dC5pZH1gLCJhcmlhLWNvbnRyb2xzIjpgJHtsfS1wYW5lbGAsImFyaWEtc2VsZWN0ZWQiOnQuaWQ9PT1lLHRhYkluZGV4OnQuaWQ9PT1lPzA6LTEsY2xhc3NOYW1lOmB0YWIke3QuaWQ9PT1lPyIgYWN0aXZlIjoiIn1gLG9uQ2xpY2s6KCk9PmModC5pZCksb25LZXlEb3duOm49Pntjb25zdCBzPXIuZmluZEluZGV4KGI9PmIuaWQ9PT10LmlkKSxvPW4ua2V5PT09IkhvbWUiPzA6bi5rZXk9PT0iRW5kIj9yLmxlbmd0aC0xOm4ua2V5PT09IkFycm93UmlnaHQiPyhzKzEpJXIubGVuZ3RoOm4ua2V5PT09IkFycm93TGVmdCI/KHMtMStyLmxlbmd0aCklci5sZW5ndGg6bnVsbDtpZihvPT09bnVsbClyZXR1cm47bi5wcmV2ZW50RGVmYXVsdCgpLG4uY3VycmVudFRhcmdldC5wYXJlbnRFbGVtZW50Py5xdWVyeVNlbGVjdG9yQWxsKCdbcm9sZT0idGFiIl0nKT8uW29dPy5mb2N1cygpLGMocltvXS5pZCl9LGNoaWxkcmVuOnQubGFiZWx9LHQuaWQpKX0pfWV4cG9ydHtoIGFzIFR9Owo=" },
+  "/v2/assets/cashflowMethod-BoxXysdG.js": { contentType: "text/javascript; charset=utf-8", base64: "import{u as Y,p as ee,j as s,M as ne,A as O,S as U,B as se,a as re,k as te,s as oe,r as k,v as le,z as ce,t as J}from"./index-CwQsWZdm.js";function je({counts:t}){return!t||t.stale<=0?null:s.jsx("span",{"data-state":"stale","data-stale-count":t.stale,children:s.jsx(U,{status:"stale"})})}function be({totals:t,freshness:u,notes:c}){const r=Y(),h=ee(),p=u?.stale??0;return s.jsxs("div",{className:"currency-totals","data-stale-count":p>0?p:void 0,children:[t.map(n=>{const f=n.total===null&&n.status==="ok"?"unavailable":n.status,x=n.latest_as_of!==void 0,j=n.expected_account_count>0&&(x||n.account_count<n.expected_account_count)?n:null,m=!!(n.as_of&&n.latest_as_of&&n.as_of!==n.latest_as_of);return s.jsxs("div",{className:"currency-total","data-state":f,"data-reason":n.unavailable_reason??void 0,"data-excluded-count":n.excluded_account_count||void 0,children:[s.jsxs("span",{className:"currency-total-head",children:[s.jsx("span",{className:"kpi-sub",children:r(x?n.status==="partial"?"perf.latest_balance_subtotal":"perf.latest_balance_total":n.status==="partial"?"perf.currency_subtotal":"perf.currency_total",{currency:n.currency})}),s.jsx("span",{className:"num",children:n.total===null?"—":s.jsx(ne,{value:n.total,currency:n.currency})})]}),s.jsxs("span",{className:"currency-meta",children:[j&&s.jsx("span",{className:"kpi-sub",children:r("facts.coverage",{covered:j.account_count,expected:j.expected_account_count})}),n.as_of&&(x?s.jsxs("span",{className:"currency-observation-time",children:[s.jsx(O,{value:n.as_of,prefix:m?"perf.balance_oldest_time":"perf.balance_source_time"}),m&&s.jsx(O,{value:n.latest_as_of,prefix:"perf.balance_latest_time"})]}):s.jsx(O,{value:n.as_of})),n.stale&&f!=="stale"&&s.jsx(U,{status:"stale"}),f==="partial"?!j&&s.jsx(se,{tone:"warn",children:r("perf.partial_accounts")}):f!=="ok"&&s.jsx(U,{status:f})]}),n.account_coverage?.length?s.jsxs("details",{className:"currency-details",children:[s.jsx("summary",{children:r("perf.coverage_details")}),s.jsx("ul",{className:"currency-coverage-list",children:n.account_coverage.map(l=>s.jsxs("li",{children:[s.jsxs("span",{className:"currency-detail-name",children:[l.platform?`${h.platform(l.platform)} · `:"",h.account(l.account_alias,l.platform)]}),s.jsxs("span",{children:[r(l.included?"perf.account_included":"perf.account_excluded"),l.unavailable_reason?` · ${r(`reason.${l.unavailable_reason}`)}`:""]}),s.jsx("span",{children:l.observation_date?r("perf.valuation_date",{date:l.observation_date}):r("reason.no_snapshot")}),l.as_of&&s.jsx(O,{value:l.as_of}),(x||l.freshness!=="fresh")&&s.jsx(U,{status:l.freshness||"unknown"})]},`${l.platform}:${l.account_alias}`))})]}):n.unavailable_reason&&f!=="ok"?s.jsx("p",{className:"card-note",children:r(`reason.${n.unavailable_reason}`)}):null]},n.currency)}),c&&s.jsx("p",{className:"card-note currency-note",children:c})]})}function we(t){return t==="ok"||t==="partial"||t==="stale"}function ke(t){const{scope:u,options:c}=re(),r=ee(),h=Y(),p=t??u;if(!p||p==="all")return h("perf.portfolio_series");const n=c.find(x=>`${x.platform}:${x.alias}`===p);if(n)return r.account(n.alias,n.platform);const f=p.indexOf(":");return f>=0?r.account(p.slice(f+1),p.slice(0,f)):r.account(p)}const ie=800,K=220,E={top:12,right:12,bottom:24,left:64};function X(t){return Date.parse(`${t}T00:00:00Z`)}function Q(t){return t.breakBefore===!0||t.membership_changed===!0}function Ne({points:t,currency:u,ariaLabel:c}){const r=te(),h=Y(),{prefs:p}=oe(),[n,f]=k.useState(null),x=k.useRef(null),[j,m]=k.useState(ie);k.useEffect(()=>{const e=x.current;if(!e)return;const o=new ResizeObserver(([M])=>{M.contentRect.width>0&&m(M.contentRect.width)});return o.observe(e),()=>o.disconnect()},[]);const{yMin:l,yMax:y}=k.useMemo(()=>{if(!t.length)return{yMin:0,yMax:1};let e=1/0,o=-1/0;for(const A of t)A.value<e&&(e=A.value),A.value>o&&(o=A.value);e===o&&(e-=1,o+=1);const M=(o-e)*.08;return{yMin:e-M,yMax:o+M}},[t]),v=e=>p.hideAmounts?le(e):ce(e,u,r),T=[0,1,2,3,4].map(e=>l+(y-l)*e/4),_={left:Math.max(E.left,...T.map(e=>v(e).length*8+16))},$=Math.max(j,_.left+80),b=$-_.left-E.right,L=t.length?X(t[0].date):0,B=(t.length?X(t.at(-1).date):0)-L,N=e=>{if(t.length<=1||!(B>0))return _.left+b/2;const o=(X(t[e].date)-L)/B;return _.left+Math.min(Math.max(o,0),1)*b},w=e=>E.top+(1-(e-l)/(y-l))*(K-E.top-E.bottom),q=t.map((e,o)=>`${Q(e)||o===0?"M":"L"}${N(o).toFixed(2)},${w(e.value).toFixed(2)}`).join(""),D=[];t.forEach((e,o)=>{(o===0||Q(e))&&D.push([]),D.at(-1).push(o)});const I=D.filter(e=>e.length>=3).map(e=>`M${N(e[0]).toFixed(2)},${w(l).toFixed(2)}${e.map(o=>`L${N(o).toFixed(2)},${w(t[o].value).toFixed(2)}`).join("")}L${N(e.at(-1)).toFixed(2)},${w(l).toFixed(2)}Z`).join(""),F=e=>{const o=x.current;if(!o||t.length===0)return;const M=o.getBoundingClientRect(),A=(e-M.left)/M.width*$,a=Math.min(Math.max(A,_.left),_.left+b),i=B>0?L+(a-_.left)/b*B:L;let d=0,g=1/0;t.forEach((z,P)=>{const H=Math.abs(X(z.date)-i);H<g&&(g=H,d=P)}),f(d)},C=e=>{if(t.length!==0&&(e.key==="ArrowLeft"||e.key==="ArrowRight")){e.preventDefault();const o=e.key==="ArrowRight"?1:-1;f(M=>Math.max(0,Math.min(t.length-1,(M??0)+o)))}},G=(()=>{const e=t.length;if(e===0)return[];const o=$<480?2:$<760?3:5;return[...new Set(Array.from({length:o},(M,A)=>Math.round(A/Math.max(1,o-1)*(e-1))))].map(M=>({i:M,date:t[M].date,anchor:M===0?"start":M===e-1?"end":"middle"}))})(),W=n!==null?t[n]:null;return s.jsxs("div",{className:"chart-frame",ref:x,children:[s.jsxs("svg",{className:"chart",viewBox:`0 0 ${$} ${K}`,role:"img","aria-label":c,tabIndex:0,onKeyDown:C,onMouseMove:e=>F(e.clientX),onMouseLeave:()=>f(null),onPointerDown:e=>{e.pointerType!=="mouse"&&F(e.clientX)},onPointerMove:e=>{e.pointerType!=="mouse"&&F(e.clientX)},onFocus:()=>f(e=>e??0),onBlur:()=>f(null),children:[T.map((e,o)=>s.jsxs("g",{children:[s.jsx("line",{x1:_.left,x2:$-E.right,y1:w(e),y2:w(e),stroke:"var(--line)",strokeWidth:"1"}),s.jsx("text",{x:_.left-6,y:w(e)+4,textAnchor:"end",fontSize:"13",fill:"var(--muted)",children:v(e)})]},o)),G.map(e=>s.jsx("text",{x:N(e.i),y:K-6,textAnchor:e.anchor,fontSize:"11",fill:"var(--muted)",children:e.date.slice(5)},e.i)),t.length>0&&s.jsxs(s.Fragment,{children:[s.jsx("path",{d:I,fill:"var(--accent)",opacity:"0.12"}),s.jsx("path",{d:q,fill:"none",stroke:"var(--accent)",strokeWidth:"2.5",strokeLinejoin:"round",strokeLinecap:"round"}),D.filter(e=>e.length<3).flatMap(e=>e.map(o=>s.jsx("circle",{cx:N(o),cy:w(t[o].value),r:e.length===1?4.5:3,fill:"var(--accent)",stroke:"var(--surface)",strokeWidth:e.length===1?1.5:0},t[o].date))),t.map((e,o)=>e.externalFlow?s.jsx("g",{children:s.jsx("circle",{cx:N(o),cy:w(e.value),r:"4",fill:"var(--surface)",stroke:"var(--accent)",strokeWidth:"2",children:s.jsx("title",{children:`${e.date} · ${h("perf.assets_flow_mark")}`})})},e.date):null)]}),n!==null&&W&&s.jsx("line",{x1:N(n),x2:N(n),y1:E.top,y2:K-E.bottom,stroke:"var(--muted)",strokeWidth:"1"})]}),n!==null&&W&&s.jsxs("div",{className:"chart-tooltip",style:{left:`${Math.min(Math.max(N(n)/$*100,8),80)}%`,top:8},children:[s.jsx("div",{className:"tooltip-date",children:W.date}),s.jsx("div",{className:"tooltip-row",children:s.jsx("strong",{children:v(W.value)})}),W.externalFlow?s.jsxs("div",{className:"tooltip-row",children:[h("perf.assets_flow_mark"),": ",v(W.externalFlow)]}):null]})]})}const ue=[1,2,2.5,5,10];function de(t){if(!(t>0)||!Number.isFinite(t))return 1;const u=10**Math.floor(Math.log10(t)),c=t/u;return(ue.find(h=>c<=h)??10)*u}function fe(t){let u=Math.max(0,-Math.floor(Math.log10(t)));const c=t*10**u;return Math.abs(c-Math.round(c))>1e-9&&(u+=1),Math.min(u,4)}function V(t,u){const c=10**u,r=Math.round(t*c)/c;return Object.is(r,-0)?0:r}function he(t,u=4){const c=t.filter(y=>Number.isFinite(y));if(c.length===0)return{min:-1,max:1,step:.5,digits:1,ticks:[-1,-.5,0,.5,1]};let r=Math.min(0,...c),h=Math.max(0,...c);if(r===h)r=-1,h=1;else{const y=(h-r)*.05,v=c.every(_=>_>=0),T=c.every(_=>_<=0);r=v?0:r-y,h=T?0:h+y}const p=Math.max(2,u);let n=de((h-r)/p),f=Math.floor(r/n)*n,x=Math.ceil(h/n)*n;for(let y=0;y<8&&(x-f)/n>p+3;y++)n*=2,f=Math.floor(r/n)*n,x=Math.ceil(h/n)*n;const j=fe(n),m=[],l=Math.round((x-f)/n);for(let y=0;y<=l;y++)m.push(V(f+y*n,j));return{min:f,max:x,step:V(n,j),digits:j,ticks:m}}const xe=800,pe=280,me=280,R={top:12,right:12,bottom:24,left:48};function Z(t){return Date.parse(`${t}T00:00:00Z`)}function ae(t){return t.breakBefore===!0||t.membership_changed===!0}function ve(t){let u="";for(const c of t)u+=`${c.breakBefore||u===""?"M":"L"}${c.x.toFixed(2)},${c.y.toFixed(2)}`;return u}function ge(t,u){const c=t.filter(p=>!u||p.date>=u),r=[];let h=!0;for(const p of c){ae(p)&&(h=!0);const n=p.daily_return_percent,f=typeof n=="number"&&Number.isFinite(n)&&n>=-100?n:null;if(f===null){h=!0;continue}r.push({date:p.date,value:f,breakBefore:h}),h=!1}return r}function ye(t,u,c=null){const r=t.filter(m=>m.points.length>0),h=r.map(m=>new Set(m.points.map(l=>l.date))),p=r.length>0?[...h[0]].filter(m=>h.every(l=>l.has(m))).sort()[0]??null:null,n=c??p??r[0]?.points[0]?.date??null,f=r.map(m=>{if(u==="daily")return{...m,points:ge(m.points,n)};const l=m.points.filter(y=>(!n||y.date>=n)&&Number.isFinite(y.value)).slice().sort((y,v)=>y.date.localeCompare(v.date)).map(y=>({date:y.date,value:y.value,breakBefore:ae(y)}));return{...m,points:l}}),x=[...new Set(f.flatMap(m=>m.points.map(l=>l.date)))].sort(),j=new Map(x.map((m,l)=>[m,l]));return{dates:x,index:j,series:f}}function $e({series:t,mode:u="cumulative",ariaLabel:c,alignStart:r=null,defaultVisible:h}){const p=te(),[n,f]=k.useState(()=>{const a=h?new Set(h):null;return new Set(t.filter(i=>!i.primary&&(!a||!a.has(i.id))).map(i=>i.id))}),[x,j]=k.useState(null),m=k.useRef(null),[l,y]=k.useState(xe);k.useEffect(()=>{const a=m.current;if(!a)return;const i=new ResizeObserver(([d])=>{d.contentRect.width>0&&y(d.contentRect.width)});return i.observe(a),()=>i.disconnect()},[]);const v=k.useMemo(()=>ye(t,u,r),[t,u,r]),T=v.series.filter(a=>!n.has(a.id)&&a.points.length>0),_=k.useMemo(()=>{const a=[];for(const i of T)for(const d of i.points)a.push(d.value);return he(a,4)},[T]),$=k.useMemo(()=>_.ticks.map(a=>({value:a,label:J(a,p,_.digits)})),[_,p]),b=Math.max(l,me),L=b<480?220:pe,S=Math.max(R.left,...$.map(a=>a.label.length*7+12)),B=Math.max(1,b-S-R.right),N=L-R.top-R.bottom,w=v.dates.length?Z(v.dates[0]):0,D=(v.dates.length?Z(v.dates.at(-1)):0)-w,I=a=>{if(v.dates.length<=1||!(D>0))return S+B/2;const i=(Z(v.dates[a])-w)/D;return S+Math.min(Math.max(i,0),1)*B},F=a=>R.top+(1-(a-_.min)/(_.max-_.min))*N,C=(a,i)=>a.points.find(d=>d.date===i)?.value??null,G=a=>{let i=0,d=1/0;return v.dates.forEach((g,z)=>{const P=Math.abs(Z(g)-a);P<d&&(d=P,i=z)}),i},W=a=>{const i=m.current;if(!i||v.dates.length===0)return;const d=i.getBoundingClientRect(),g=d.width>0?(a-d.left)/d.width:0,z=Math.min(Math.max(g,0),1)*b,P=Math.min(Math.max(z,S),S+B),H=D>0?w+(P-S)/B*D:w;j(G(H))},e=a=>{if(v.dates.length!==0&&(a.key==="ArrowLeft"||a.key==="ArrowRight")){a.preventDefault();const i=a.key==="ArrowRight"?1:-1;j(d=>Math.max(0,Math.min(v.dates.length-1,(d??0)+i)))}},o=k.useMemo(()=>{const a=v.dates.length;if(a===0)return[];const i=b<480?2:b<760?3:5;return[...new Set(Array.from({length:i},(d,g)=>Math.round(g/Math.max(1,i-1)*(a-1))))].map(d=>({i:d,date:v.dates[d],anchor:d===0?"start":d===a-1?"end":"middle"}))},[v.dates,b]),M=x!==null?v.dates[x]:null,A=x!==null?I(x)/b*100:0;return s.jsxs("div",{children:[s.jsxs("div",{className:"chart-frame",ref:m,children:[s.jsxs("svg",{className:"chart",viewBox:`0 0 ${b} ${L}`,role:"img","aria-label":c,tabIndex:0,onKeyDown:e,onMouseMove:a=>W(a.clientX),onMouseLeave:()=>j(null),onFocus:()=>j(a=>a??0),onBlur:()=>j(null),children:[$.map(a=>s.jsxs("g",{children:[s.jsx("line",{x1:S,x2:b-R.right,y1:F(a.value),y2:F(a.value),stroke:"var(--line)",strokeWidth:"1"}),s.jsx("text",{x:S-6,y:F(a.value)+4,textAnchor:"end",fontSize:"11",fill:"var(--muted)",children:a.label})]},a.value)),s.jsx("line",{x1:S,x2:b-R.right,y1:F(0),y2:F(0),stroke:"var(--muted)",strokeWidth:"1",strokeDasharray:"3 3"}),o.map(a=>s.jsx("text",{x:I(a.i),y:L-6,textAnchor:a.anchor,fontSize:"11",fill:"var(--muted)",children:a.date.slice(5)},a.i)),T.map(a=>{const i=a.points.map(g=>({...g,x:I(v.index.get(g.date)),y:F(g.value)})),d=[];for(const g of i)(!d.length||g.breakBefore)&&d.push([]),d.at(-1).push(g);return s.jsxs("g",{children:[s.jsx("path",{d:ve(i),fill:"none",stroke:a.color,strokeWidth:a.primary?2.5:1.4,strokeLinejoin:"round",strokeLinecap:"round"}),d.filter(g=>g.length===1).map(([g])=>s.jsx("circle",{cx:g.x,cy:g.y,r:"3",fill:a.color},g.date))]},a.id)}),x!==null&&s.jsx("line",{x1:I(x),x2:I(x),y1:R.top,y2:L-R.bottom,stroke:"var(--muted)",strokeWidth:"1"})]}),x!==null&&M&&s.jsxs("div",{className:"chart-tooltip",style:{left:`${Math.min(Math.max(A,8),88)}%`,top:8},children:[s.jsx("div",{className:"tooltip-date",children:M}),T.map(a=>s.jsxs("div",{className:"tooltip-row",children:[s.jsx("span",{className:"legend-swatch",style:{background:a.color}}),s.jsx("span",{children:a.label}),s.jsx("strong",{children:C(a,M)===null?"—":J(C(a,M),p)})]},a.id))]})]}),s.jsx("div",{className:"chart-legend",children:v.series.map(a=>{const i=n.has(a.id);return s.jsxs("button",{type:"button",className:i?"off":"","aria-pressed":!i,onClick:()=>f(d=>{const g=new Set(d);return g.has(a.id)?g.delete(a.id):g.add(a.id),g}),children:[s.jsx("span",{className:"legend-swatch",style:{background:a.color}}),a.label]},a.id)})})]})}const Se="perf.method_dietz_approx",Fe="perf.method_unknown";function Me(t){if(!t)return"absent";const u=t.cashflow_method,c=t.approximate;return u===void 0&&c===void 0?"absent":u==="modified_dietz"&&c===!0?"dietz_approx":"unknown"}function Ae(t){return Me(t)==="dietz_approx"}export{Ne as A,be as C,Se as D,je as F,$e as L,Fe as U,Me as c,Ae as i,we as r,ke as u};
" },
   "/v2/assets/cashflowMethod-Gm8aPj9t.css": { contentType: "text/css; charset=utf-8", base64: "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" },
-  "/v2/assets/cashflowMethod-H7Uq4Mrs.js": { contentType: "text/javascript; charset=utf-8", base64: "import{u as Y,o as ee,j as s,M as ne,A as O,S as U,B as se,a as re,k as te,q as oe,r as k,t as le,y as ce,s as J}from"./index-Ds_XXLsn.js";function je({counts:t}){return!t||t.stale<=0?null:s.jsx("span",{"data-state":"stale","data-stale-count":t.stale,children:s.jsx(U,{status:"stale"})})}function be({totals:t,freshness:u,notes:c}){const r=Y(),h=ee(),p=u?.stale??0;return s.jsxs("div",{className:"currency-totals","data-stale-count":p>0?p:void 0,children:[t.map(n=>{const f=n.total===null&&n.status==="ok"?"unavailable":n.status,x=n.latest_as_of!==void 0,j=n.expected_account_count>0&&(x||n.account_count<n.expected_account_count)?n:null,m=!!(n.as_of&&n.latest_as_of&&n.as_of!==n.latest_as_of);return s.jsxs("div",{className:"currency-total","data-state":f,"data-reason":n.unavailable_reason??void 0,"data-excluded-count":n.excluded_account_count||void 0,children:[s.jsxs("span",{className:"currency-total-head",children:[s.jsx("span",{className:"kpi-sub",children:r(x?n.status==="partial"?"perf.latest_balance_subtotal":"perf.latest_balance_total":n.status==="partial"?"perf.currency_subtotal":"perf.currency_total",{currency:n.currency})}),s.jsx("span",{className:"num",children:n.total===null?"—":s.jsx(ne,{value:n.total,currency:n.currency})})]}),s.jsxs("span",{className:"currency-meta",children:[j&&s.jsx("span",{className:"kpi-sub",children:r("facts.coverage",{covered:j.account_count,expected:j.expected_account_count})}),n.as_of&&(x?s.jsxs("span",{className:"currency-observation-time",children:[s.jsx(O,{value:n.as_of,prefix:m?"perf.balance_oldest_time":"perf.balance_source_time"}),m&&s.jsx(O,{value:n.latest_as_of,prefix:"perf.balance_latest_time"})]}):s.jsx(O,{value:n.as_of})),n.stale&&f!=="stale"&&s.jsx(U,{status:"stale"}),f==="partial"?!j&&s.jsx(se,{tone:"warn",children:r("perf.partial_accounts")}):f!=="ok"&&s.jsx(U,{status:f})]}),n.account_coverage?.length?s.jsxs("details",{className:"currency-details",children:[s.jsx("summary",{children:r("perf.coverage_details")}),s.jsx("ul",{className:"currency-coverage-list",children:n.account_coverage.map(l=>s.jsxs("li",{children:[s.jsxs("span",{className:"currency-detail-name",children:[l.platform?`${h.platform(l.platform)} · `:"",h.account(l.account_alias,l.platform)]}),s.jsxs("span",{children:[r(l.included?"perf.account_included":"perf.account_excluded"),l.unavailable_reason?` · ${r(`reason.${l.unavailable_reason}`)}`:""]}),s.jsx("span",{children:l.observation_date?r("perf.valuation_date",{date:l.observation_date}):r("reason.no_snapshot")}),l.as_of&&s.jsx(O,{value:l.as_of}),(x||l.freshness!=="fresh")&&s.jsx(U,{status:l.freshness||"unknown"})]},`${l.platform}:${l.account_alias}`))})]}):n.unavailable_reason&&f!=="ok"?s.jsx("p",{className:"card-note",children:r(`reason.${n.unavailable_reason}`)}):null]},n.currency)}),c&&s.jsx("p",{className:"card-note currency-note",children:c})]})}function we(t){return t==="ok"||t==="partial"||t==="stale"}function ke(t){const{scope:u,options:c}=re(),r=ee(),h=Y(),p=t??u;if(!p||p==="all")return h("perf.portfolio_series");const n=c.find(x=>`${x.platform}:${x.alias}`===p);if(n)return r.account(n.alias,n.platform);const f=p.indexOf(":");return f>=0?r.account(p.slice(f+1),p.slice(0,f)):r.account(p)}const ie=800,K=220,E={top:12,right:12,bottom:24,left:64};function X(t){return Date.parse(`${t}T00:00:00Z`)}function Q(t){return t.breakBefore===!0||t.membership_changed===!0}function Ne({points:t,currency:u,ariaLabel:c}){const r=te(),h=Y(),{prefs:p}=oe(),[n,f]=k.useState(null),x=k.useRef(null),[j,m]=k.useState(ie);k.useEffect(()=>{const e=x.current;if(!e)return;const o=new ResizeObserver(([M])=>{M.contentRect.width>0&&m(M.contentRect.width)});return o.observe(e),()=>o.disconnect()},[]);const{yMin:l,yMax:y}=k.useMemo(()=>{if(!t.length)return{yMin:0,yMax:1};let e=1/0,o=-1/0;for(const A of t)A.value<e&&(e=A.value),A.value>o&&(o=A.value);e===o&&(e-=1,o+=1);const M=(o-e)*.08;return{yMin:e-M,yMax:o+M}},[t]),g=e=>p.hideAmounts?le(e):ce(e,u,r),T=[0,1,2,3,4].map(e=>l+(y-l)*e/4),_={left:Math.max(E.left,...T.map(e=>g(e).length*8+16))},$=Math.max(j,_.left+80),b=$-_.left-E.right,L=t.length?X(t[0].date):0,B=(t.length?X(t.at(-1).date):0)-L,N=e=>{if(t.length<=1||!(B>0))return _.left+b/2;const o=(X(t[e].date)-L)/B;return _.left+Math.min(Math.max(o,0),1)*b},w=e=>E.top+(1-(e-l)/(y-l))*(K-E.top-E.bottom),q=t.map((e,o)=>`${Q(e)||o===0?"M":"L"}${N(o).toFixed(2)},${w(e.value).toFixed(2)}`).join(""),D=[];t.forEach((e,o)=>{(o===0||Q(e))&&D.push([]),D.at(-1).push(o)});const I=D.filter(e=>e.length>=3).map(e=>`M${N(e[0]).toFixed(2)},${w(l).toFixed(2)}${e.map(o=>`L${N(o).toFixed(2)},${w(t[o].value).toFixed(2)}`).join("")}L${N(e.at(-1)).toFixed(2)},${w(l).toFixed(2)}Z`).join(""),F=e=>{const o=x.current;if(!o||t.length===0)return;const M=o.getBoundingClientRect(),A=(e-M.left)/M.width*$,a=Math.min(Math.max(A,_.left),_.left+b),i=B>0?L+(a-_.left)/b*B:L;let d=0,v=1/0;t.forEach((C,P)=>{const H=Math.abs(X(C.date)-i);H<v&&(v=H,d=P)}),f(d)},z=e=>{if(t.length!==0&&(e.key==="ArrowLeft"||e.key==="ArrowRight")){e.preventDefault();const o=e.key==="ArrowRight"?1:-1;f(M=>Math.max(0,Math.min(t.length-1,(M??0)+o)))}},G=(()=>{const e=t.length;if(e===0)return[];const o=$<480?2:$<760?3:5;return[...new Set(Array.from({length:o},(M,A)=>Math.round(A/Math.max(1,o-1)*(e-1))))].map(M=>({i:M,date:t[M].date,anchor:M===0?"start":M===e-1?"end":"middle"}))})(),W=n!==null?t[n]:null;return s.jsxs("div",{className:"chart-frame",ref:x,children:[s.jsxs("svg",{className:"chart",viewBox:`0 0 ${$} ${K}`,role:"img","aria-label":c,tabIndex:0,onKeyDown:z,onMouseMove:e=>F(e.clientX),onMouseLeave:()=>f(null),onPointerDown:e=>{e.pointerType!=="mouse"&&F(e.clientX)},onPointerMove:e=>{e.pointerType!=="mouse"&&F(e.clientX)},onFocus:()=>f(e=>e??0),onBlur:()=>f(null),children:[T.map((e,o)=>s.jsxs("g",{children:[s.jsx("line",{x1:_.left,x2:$-E.right,y1:w(e),y2:w(e),stroke:"var(--line)",strokeWidth:"1"}),s.jsx("text",{x:_.left-6,y:w(e)+4,textAnchor:"end",fontSize:"13",fill:"var(--muted)",children:g(e)})]},o)),G.map(e=>s.jsx("text",{x:N(e.i),y:K-6,textAnchor:e.anchor,fontSize:"11",fill:"var(--muted)",children:e.date.slice(5)},e.i)),t.length>0&&s.jsxs(s.Fragment,{children:[s.jsx("path",{d:I,fill:"var(--accent)",opacity:"0.12"}),s.jsx("path",{d:q,fill:"none",stroke:"var(--accent)",strokeWidth:"2.5",strokeLinejoin:"round",strokeLinecap:"round"}),D.filter(e=>e.length<3).flatMap(e=>e.map(o=>s.jsx("circle",{cx:N(o),cy:w(t[o].value),r:e.length===1?4.5:3,fill:"var(--accent)",stroke:"var(--surface)",strokeWidth:e.length===1?1.5:0},t[o].date))),t.map((e,o)=>e.externalFlow?s.jsx("g",{children:s.jsx("circle",{cx:N(o),cy:w(e.value),r:"4",fill:"var(--surface)",stroke:"var(--accent)",strokeWidth:"2",children:s.jsx("title",{children:`${e.date} · ${h("perf.assets_flow_mark")}`})})},e.date):null)]}),n!==null&&W&&s.jsx("line",{x1:N(n),x2:N(n),y1:E.top,y2:K-E.bottom,stroke:"var(--muted)",strokeWidth:"1"})]}),n!==null&&W&&s.jsxs("div",{className:"chart-tooltip",style:{left:`${Math.min(Math.max(N(n)/$*100,8),80)}%`,top:8},children:[s.jsx("div",{className:"tooltip-date",children:W.date}),s.jsx("div",{className:"tooltip-row",children:s.jsx("strong",{children:g(W.value)})}),W.externalFlow?s.jsxs("div",{className:"tooltip-row",children:[h("perf.assets_flow_mark"),": ",g(W.externalFlow)]}):null]})]})}const ue=[1,2,2.5,5,10];function de(t){if(!(t>0)||!Number.isFinite(t))return 1;const u=10**Math.floor(Math.log10(t)),c=t/u;return(ue.find(h=>c<=h)??10)*u}function fe(t){let u=Math.max(0,-Math.floor(Math.log10(t)));const c=t*10**u;return Math.abs(c-Math.round(c))>1e-9&&(u+=1),Math.min(u,4)}function V(t,u){const c=10**u,r=Math.round(t*c)/c;return Object.is(r,-0)?0:r}function he(t,u=4){const c=t.filter(y=>Number.isFinite(y));if(c.length===0)return{min:-1,max:1,step:.5,digits:1,ticks:[-1,-.5,0,.5,1]};let r=Math.min(0,...c),h=Math.max(0,...c);if(r===h)r=-1,h=1;else{const y=(h-r)*.05,g=c.every(_=>_>=0),T=c.every(_=>_<=0);r=g?0:r-y,h=T?0:h+y}const p=Math.max(2,u);let n=de((h-r)/p),f=Math.floor(r/n)*n,x=Math.ceil(h/n)*n;for(let y=0;y<8&&(x-f)/n>p+3;y++)n*=2,f=Math.floor(r/n)*n,x=Math.ceil(h/n)*n;const j=fe(n),m=[],l=Math.round((x-f)/n);for(let y=0;y<=l;y++)m.push(V(f+y*n,j));return{min:f,max:x,step:V(n,j),digits:j,ticks:m}}const xe=800,pe=280,me=280,R={top:12,right:12,bottom:24,left:48};function Z(t){return Date.parse(`${t}T00:00:00Z`)}function ae(t){return t.breakBefore===!0||t.membership_changed===!0}function ge(t){let u="";for(const c of t)u+=`${c.breakBefore||u===""?"M":"L"}${c.x.toFixed(2)},${c.y.toFixed(2)}`;return u}function ve(t,u){const c=t.filter(p=>!u||p.date>=u),r=[];let h=!0;for(const p of c){ae(p)&&(h=!0);const n=p.daily_return_percent,f=typeof n=="number"&&Number.isFinite(n)&&n>=-100?n:null;if(f===null){h=!0;continue}r.push({date:p.date,value:f,breakBefore:h}),h=!1}return r}function ye(t,u,c=null){const r=t.filter(m=>m.points.length>0),h=r.map(m=>new Set(m.points.map(l=>l.date))),p=r.length>0?[...h[0]].filter(m=>h.every(l=>l.has(m))).sort()[0]??null:null,n=c??p??r[0]?.points[0]?.date??null,f=r.map(m=>{if(u==="daily")return{...m,points:ve(m.points,n)};const l=m.points.filter(y=>(!n||y.date>=n)&&Number.isFinite(y.value)).slice().sort((y,g)=>y.date.localeCompare(g.date)).map(y=>({date:y.date,value:y.value,breakBefore:ae(y)}));return{...m,points:l}}),x=[...new Set(f.flatMap(m=>m.points.map(l=>l.date)))].sort(),j=new Map(x.map((m,l)=>[m,l]));return{dates:x,index:j,series:f}}function $e({series:t,mode:u="cumulative",ariaLabel:c,alignStart:r=null,defaultVisible:h}){const p=te(),[n,f]=k.useState(()=>{const a=h?new Set(h):null;return new Set(t.filter(i=>!i.primary&&(!a||!a.has(i.id))).map(i=>i.id))}),[x,j]=k.useState(null),m=k.useRef(null),[l,y]=k.useState(xe);k.useEffect(()=>{const a=m.current;if(!a)return;const i=new ResizeObserver(([d])=>{d.contentRect.width>0&&y(d.contentRect.width)});return i.observe(a),()=>i.disconnect()},[]);const g=k.useMemo(()=>ye(t,u,r),[t,u,r]),T=g.series.filter(a=>!n.has(a.id)&&a.points.length>0),_=k.useMemo(()=>{const a=[];for(const i of T)for(const d of i.points)a.push(d.value);return he(a,4)},[T]),$=k.useMemo(()=>_.ticks.map(a=>({value:a,label:J(a,p,_.digits)})),[_,p]),b=Math.max(l,me),L=b<480?220:pe,S=Math.max(R.left,...$.map(a=>a.label.length*7+12)),B=Math.max(1,b-S-R.right),N=L-R.top-R.bottom,w=g.dates.length?Z(g.dates[0]):0,D=(g.dates.length?Z(g.dates.at(-1)):0)-w,I=a=>{if(g.dates.length<=1||!(D>0))return S+B/2;const i=(Z(g.dates[a])-w)/D;return S+Math.min(Math.max(i,0),1)*B},F=a=>R.top+(1-(a-_.min)/(_.max-_.min))*N,z=(a,i)=>a.points.find(d=>d.date===i)?.value??null,G=a=>{let i=0,d=1/0;return g.dates.forEach((v,C)=>{const P=Math.abs(Z(v)-a);P<d&&(d=P,i=C)}),i},W=a=>{const i=m.current;if(!i||g.dates.length===0)return;const d=i.getBoundingClientRect(),v=d.width>0?(a-d.left)/d.width:0,C=Math.min(Math.max(v,0),1)*b,P=Math.min(Math.max(C,S),S+B),H=D>0?w+(P-S)/B*D:w;j(G(H))},e=a=>{if(g.dates.length!==0&&(a.key==="ArrowLeft"||a.key==="ArrowRight")){a.preventDefault();const i=a.key==="ArrowRight"?1:-1;j(d=>Math.max(0,Math.min(g.dates.length-1,(d??0)+i)))}},o=k.useMemo(()=>{const a=g.dates.length;if(a===0)return[];const i=b<480?2:b<760?3:5;return[...new Set(Array.from({length:i},(d,v)=>Math.round(v/Math.max(1,i-1)*(a-1))))].map(d=>({i:d,date:g.dates[d],anchor:d===0?"start":d===a-1?"end":"middle"}))},[g.dates,b]),M=x!==null?g.dates[x]:null,A=x!==null?I(x)/b*100:0;return s.jsxs("div",{children:[s.jsxs("div",{className:"chart-frame",ref:m,children:[s.jsxs("svg",{className:"chart",viewBox:`0 0 ${b} ${L}`,role:"img","aria-label":c,tabIndex:0,onKeyDown:e,onMouseMove:a=>W(a.clientX),onMouseLeave:()=>j(null),onFocus:()=>j(a=>a??0),onBlur:()=>j(null),children:[$.map(a=>s.jsxs("g",{children:[s.jsx("line",{x1:S,x2:b-R.right,y1:F(a.value),y2:F(a.value),stroke:"var(--line)",strokeWidth:"1"}),s.jsx("text",{x:S-6,y:F(a.value)+4,textAnchor:"end",fontSize:"11",fill:"var(--muted)",children:a.label})]},a.value)),s.jsx("line",{x1:S,x2:b-R.right,y1:F(0),y2:F(0),stroke:"var(--muted)",strokeWidth:"1",strokeDasharray:"3 3"}),o.map(a=>s.jsx("text",{x:I(a.i),y:L-6,textAnchor:a.anchor,fontSize:"11",fill:"var(--muted)",children:a.date.slice(5)},a.i)),T.map(a=>{const i=a.points.map(v=>({...v,x:I(g.index.get(v.date)),y:F(v.value)})),d=[];for(const v of i)(!d.length||v.breakBefore)&&d.push([]),d.at(-1).push(v);return s.jsxs("g",{children:[s.jsx("path",{d:ge(i),fill:"none",stroke:a.color,strokeWidth:a.primary?2.5:1.4,strokeLinejoin:"round",strokeLinecap:"round"}),d.filter(v=>v.length===1).map(([v])=>s.jsx("circle",{cx:v.x,cy:v.y,r:"3",fill:a.color},v.date))]},a.id)}),x!==null&&s.jsx("line",{x1:I(x),x2:I(x),y1:R.top,y2:L-R.bottom,stroke:"var(--muted)",strokeWidth:"1"})]}),x!==null&&M&&s.jsxs("div",{className:"chart-tooltip",style:{left:`${Math.min(Math.max(A,8),88)}%`,top:8},children:[s.jsx("div",{className:"tooltip-date",children:M}),T.map(a=>s.jsxs("div",{className:"tooltip-row",children:[s.jsx("span",{className:"legend-swatch",style:{background:a.color}}),s.jsx("span",{children:a.label}),s.jsx("strong",{children:z(a,M)===null?"—":J(z(a,M),p)})]},a.id))]})]}),s.jsx("div",{className:"chart-legend",children:g.series.map(a=>{const i=n.has(a.id);return s.jsxs("button",{type:"button",className:i?"off":"","aria-pressed":!i,onClick:()=>f(d=>{const v=new Set(d);return v.has(a.id)?v.delete(a.id):v.add(a.id),v}),children:[s.jsx("span",{className:"legend-swatch",style:{background:a.color}}),a.label]},a.id)})})]})}const Se="perf.method_dietz_approx",Fe="perf.method_unknown";function Me(t){if(!t)return"absent";const u=t.cashflow_method,c=t.approximate;return u===void 0&&c===void 0?"absent":u==="modified_dietz"&&c===!0?"dietz_approx":"unknown"}function Ae(t){return Me(t)==="dietz_approx"}export{Ne as A,be as C,Se as D,je as F,$e as L,Fe as U,Me as c,Ae as i,we as r,ke as u};
" },
-  "/v2/assets/hooks-DCo9_b70.js": { contentType: "text/javascript; charset=utf-8", base64: "aW1wb3J0e3J9ZnJvbSIuL2luZGV4LURzX1hYTHNuLmpzIjtmdW5jdGlvbiBwKCl7bGV0IGU9MDtyZXR1cm57YmVnaW4oKXtyZXR1cm4gZSs9MSxlfSxpc0N1cnJlbnQoYSl7cmV0dXJuIGE9PT1lfSxpbnZhbGlkYXRlKCl7ZSs9MX19fWZ1bmN0aW9uIGcoZSxhKXtjb25zdFtsLHVdPXIudXNlU3RhdGUoe3BoYXNlOiJsb2FkaW5nIixkYXRhOm51bGwsZXJyb3I6bnVsbH0pLHM9ci51c2VSZWYocCgpKSxbaSxmXT1yLnVzZVN0YXRlKDApLGM9ci51c2VSZWYoZSk7Yy5jdXJyZW50PWUsci51c2VFZmZlY3QoKCk9Pntjb25zdCB0PXMuY3VycmVudC5iZWdpbigpO3Uoe3BoYXNlOiJsb2FkaW5nIixkYXRhOm51bGwsZXJyb3I6bnVsbH0pO2xldCBvPSExO3JldHVybiBjLmN1cnJlbnQoKS50aGVuKG49PnshbyYmcy5jdXJyZW50LmlzQ3VycmVudCh0KSYmdSh7cGhhc2U6InJlYWR5IixkYXRhOm4sZXJyb3I6bnVsbH0pfSkuY2F0Y2gobj0+eyFvJiZzLmN1cnJlbnQuaXNDdXJyZW50KHQpJiZ1KHtwaGFzZToiZXJyb3IiLGRhdGE6bnVsbCxlcnJvcjpuIGluc3RhbmNlb2YgRXJyb3I/bjpuZXcgRXJyb3IoInJlcXVlc3RfZmFpbGVkIil9KX0pLCgpPT57bz0hMH19LFsuLi5hLGldKTtjb25zdCBkPXIudXNlQ2FsbGJhY2soKCk9PmYodD0+dCsxKSxbXSk7cmV0dXJuey4uLmwscmVsb2FkOmR9fWV4cG9ydHtwIGFzIGMsZyBhcyB1fTsK" },
-  "/v2/assets/inboxFailure-DUO9CRup.js": { contentType: "text/javascript; charset=utf-8", base64: "aW1wb3J0e0sgYXMgbyxMIGFzIGl9ZnJvbSIuL2luZGV4LURzX1hYTHNuLmpzIjtjb25zdCByPW5ldyBTZXQoWyJxdW90YV9leGhhdXN0ZWQiLCJ1bmF1dGhvcml6ZWQiLCJpbmRleF9taXNzaW5nIiwiaW5kZXhfaW5jb21wbGV0ZSIsImluZGV4X3VuYXZhaWxhYmxlIiwidW5rbm93biJdKTtmdW5jdGlvbiBhKGUsdCl7aWYodCBpbnN0YW5jZW9mIG8pcmV0dXJuInVuYXV0aG9yaXplZCI7aWYodCBpbnN0YW5jZW9mIGkpe2NvbnN0IG49dC5wYXlsb2FkPy5lcnJvcl9zdGF0ZTtpZihuJiZyLmhhcyhuKSlyZXR1cm4gbn1yZXR1cm4gZT8uZXJyb3Jfc3RhdGUmJnIuaGFzKGUuZXJyb3Jfc3RhdGUpP2UuZXJyb3Jfc3RhdGU6InVua25vd24ifWV4cG9ydHthIGFzIGl9Owo=" },
-  "/v2/assets/index-B36Qy5rG.css": { contentType: "text/css; charset=utf-8", base64: ":root{--canvas: #F5F7FA;--surface: #FFFFFF;--surface-2: #EEF2F7;--ink: #0F172A;--muted: #52627A;--line: rgba(15, 23, 42, .1);--accent: #2563EB;--on-accent: #FFFFFF;--up-green: #15803D;--down-green: #DC2626;--up: var(--up-green);--down: var(--down-green);--status-ok: #0F766E;--status-warn: #92400E;--on-warn: #FFFFFF;--status-error: #BE123C;--status-unknown: #64748B;--danger: #B91C1C;--benchmark-1: #7C3AED;--benchmark-2: #B45309;--benchmark-3: #0E7490;--benchmark-4: #475569;--radius-s: 6px;--radius-m: 10px;--bottom-tabs-height: 56px;--shadow: 0 1px 2px rgba(15, 23, 42, .06), 0 4px 16px rgba(15, 23, 42, .08);color-scheme:light}:root[data-theme=dark]{--canvas: #0B1016;--surface: #131B25;--surface-2: #192330;--ink: #E8EEF7;--muted: #93A0B5;--line: rgba(148, 163, 184, .16);--accent: #60A5FA;--on-accent: #0B1016;--up-green: #22C55E;--down-green: #F87171;--status-ok: #2DD4BF;--status-warn: #FBBF24;--on-warn: #0B1016;--status-error: #FB7185;--status-unknown: #94A3B8;--danger: #F87171;--benchmark-1: #C4B5FD;--benchmark-2: #FBBF24;--benchmark-3: #67E8F9;--benchmark-4: #CBD5E1;--shadow: 0 1px 2px rgba(0, 0, 0, .4), 0 4px 16px rgba(0, 0, 0, .35);color-scheme:dark}:root[data-updown=red-up]{--up: var(--down-green);--down: var(--up-green)}*{box-sizing:border-box}html,body{margin:0;padding:0;background:var(--canvas);color:var(--ink);font-family:system-ui,-apple-system,Segoe UI,Roboto,PingFang SC,Hiragino Sans GB,Microsoft YaHei,sans-serif;font-size:14px;line-height:1.5}.num,.kpi-value,td.num,.money,.percent{font-variant-numeric:tabular-nums}a{color:var(--accent);text-decoration:none}a:hover{text-decoration:underline}button{font:inherit;color:inherit;cursor:pointer;border:none;background:none}button:disabled{cursor:not-allowed;opacity:.55}:focus-visible{outline:2px solid var(--accent);outline-offset:2px}.sr-only{position:absolute;width:1px;height:1px;margin:-1px;padding:0;overflow:hidden;clip:rect(0 0 0 0);white-space:nowrap;border:0}.skip-link{position:absolute;left:8px;top:-48px;padding:8px 12px;background:var(--accent);color:var(--on-accent);border-radius:var(--radius-s);z-index:100;transition:top .15s}.skip-link:focus{top:8px}.shell{display:flex;min-height:100vh}.sidenav{width:208px;flex:0 0 auto;display:flex;flex-direction:column;gap:4px;padding:16px 12px;border-right:1px solid var(--line);background:var(--surface);position:sticky;top:0;height:100vh}.sidenav.collapsed{width:64px}.sidenav.collapsed .nav-text,.sidenav.collapsed .brand-name{display:none}.brand{display:flex;align-items:center;gap:8px;padding:4px 8px 16px}.brand img{width:28px;height:28px}.brand-name{font-weight:700;font-size:14px}.nav-item{display:flex;align-items:center;gap:10px;width:100%;padding:10px 12px;border-radius:var(--radius-s);color:var(--muted);text-align:left;position:relative}.nav-item{transition:background-color .12s ease,color .12s ease}.nav-item:hover{background:var(--surface-2);color:var(--ink)}.nav-item.active{background:color-mix(in srgb,var(--accent) 10%,var(--surface));color:var(--accent);font-weight:600}.nav-item svg{flex:0 0 auto}.nav-badge{margin-left:auto;min-width:18px;padding:0 5px;border-radius:9px;background:var(--status-warn);color:var(--on-warn);font-size:12px;text-align:center;line-height:18px}.nav-badge-unknown{background:var(--surface-2);color:var(--muted);box-shadow:inset 0 0 0 1px var(--line)}.sidenav-collapse{margin-top:auto;padding:8px 12px;color:var(--muted);border-radius:var(--radius-s)}.sidenav-collapse:hover{background:var(--surface-2)}.shell-main{flex:1 1 auto;min-width:0;display:flex;flex-direction:column}.topbar{display:flex;align-items:center;gap:12px;padding:10px 16px;border-bottom:1px solid var(--line);background:var(--surface);position:sticky;top:0;z-index:20;flex-wrap:wrap}.topbar .spacer{flex:1 1 auto}.topbar-updated{color:var(--muted);font-size:12px;white-space:nowrap}.content{flex:1 1 auto;padding:16px;max-width:1280px;width:100%;margin:0 auto}.icon-button{display:inline-flex;align-items:center;justify-content:center;width:32px;height:32px;border-radius:var(--radius-s);color:var(--muted)}.icon-button:hover,.icon-button[aria-pressed=true]{background:var(--surface-2);color:var(--ink)}.bottom-tabs{display:none;position:fixed;left:0;right:0;bottom:0;min-height:calc(var(--bottom-tabs-height) + env(safe-area-inset-bottom));background:var(--surface);border-top:1px solid var(--line);z-index:30;padding-bottom:env(safe-area-inset-bottom)}.bottom-tabs-inner{display:flex}.bottom-tab{flex:1 1 0;display:flex;flex-direction:column;align-items:center;gap:2px;padding:8px 0 6px;color:var(--muted);font-size:12px;position:relative}.bottom-tab.active{color:var(--accent);font-weight:600}.bottom-tab .nav-badge{position:absolute;top:2px;right:calc(50% - 20px);margin:0}.more-sheet{position:fixed;left:0;right:0;bottom:calc(var(--bottom-tabs-height) + env(safe-area-inset-bottom));background:var(--surface);border-top:1px solid var(--line);border-radius:16px 16px 0 0;padding:8px 16px 16px;max-height:70dvh;overflow-y:auto;z-index:40;box-shadow:var(--shadow)}.more-sheet .nav-item{font-size:16px;min-height:44px}.lang-label-short{display:none}.button{display:inline-flex;align-items:center;justify-content:center;gap:6px;min-height:36px;padding:7px 15px;border-radius:7px;border:1px solid transparent;font-weight:550;white-space:nowrap;transition:background-color .12s ease,border-color .12s ease,color .12s ease}.button-primary{background:var(--accent);color:var(--on-accent)}.button-primary:hover:not(:disabled){filter:brightness(1.08)}.button-secondary{border-color:var(--line);background:var(--surface)}.button-secondary:hover:not(:disabled){border-color:color-mix(in srgb,var(--accent) 35%,var(--line));background:var(--surface-2)}.button-danger{background:var(--danger);color:#fff}.button-danger-outline{border-color:var(--danger);color:var(--danger);background:transparent}.button-danger-outline:hover:not(:disabled){background:color-mix(in srgb,var(--danger) 10%,transparent)}.button-sm{min-height:30px;padding:3px 10px;font-size:13px}.card{background:var(--surface);border:1px solid var(--line);border-radius:12px;padding:18px 20px;min-width:0}.card-title{margin:0 0 12px;font-size:16px;font-weight:650;letter-spacing:-.01em;line-height:1.35}.card-note{color:var(--muted);font-size:12px;margin:8px 0 0;line-height:1.55}.kpi-grid{display:grid;grid-template-columns:repeat(5,minmax(0,1fr));gap:12px}.kpi-card{background:var(--surface);border:1px solid var(--line);border-radius:11px;padding:14px 16px;display:flex;flex-direction:column;gap:5px;min-width:0;text-align:left}button.kpi-card{transition:border-color .12s ease,background-color .12s ease}button.kpi-card:hover{border-color:color-mix(in srgb,var(--accent) 45%,var(--line));background:color-mix(in srgb,var(--accent) 3%,var(--surface))}.kpi-title{font-size:12px;font-weight:500;color:var(--muted)}.kpi-value{font-size:25px;font-weight:700;line-height:1.2;letter-spacing:-.015em;overflow-wrap:anywhere}.kpi-value .flat{font-size:20px;font-weight:500}.kpi-state{font-size:15px;font-weight:500;color:var(--muted)}.metric-note{margin:0;font-size:13px;color:var(--muted);line-height:1.6}.kpi-sub{font-size:12px;color:var(--muted);line-height:1.45;overflow-wrap:anywhere}.kpi-foot{display:flex;align-items:center;gap:6px 10px;margin-top:2px;flex-wrap:wrap}.kpi-foot .badge{max-width:100%;white-space:normal;overflow-wrap:anywhere}.badge{display:inline-flex;align-items:center;gap:5px;padding:2px 9px;border-radius:999px;font-size:12px;font-weight:500;line-height:17px;white-space:nowrap}.badge svg{flex:0 0 auto}.badge-ok{color:var(--status-ok);background:color-mix(in srgb,var(--status-ok) 12%,transparent)}.badge-warn{color:var(--status-warn);background:color-mix(in srgb,var(--status-warn) 14%,transparent)}.badge-error{color:var(--status-error);background:color-mix(in srgb,var(--status-error) 12%,transparent)}.badge-unknown{color:var(--status-unknown);background:color-mix(in srgb,var(--status-unknown) 14%,transparent)}.badge-accent{color:var(--accent);background:color-mix(in srgb,var(--accent) 12%,transparent)}.up{color:var(--up)}.down{color:var(--down)}.flat{color:var(--muted)}.asof{color:var(--muted);font-size:12px}.empty-state,.error-state{min-height:0;padding:12px 14px;display:flex;flex-wrap:wrap;align-items:center;gap:8px 10px;text-align:left;color:var(--muted);border-radius:10px}.empty-state{border:1px dashed color-mix(in srgb,var(--line) 90%,transparent);background:color-mix(in srgb,var(--surface-2) 30%,transparent)}.error-state{border:1px solid var(--line);background:color-mix(in srgb,var(--surface-2) 18%,var(--surface))}.state-icon{flex:none;width:26px;height:26px;display:grid;place-items:center;border-radius:50%;color:var(--muted);background:color-mix(in srgb,var(--muted) 9%,transparent)}.state-icon-error{color:var(--muted)}.state-copy{flex:1 1 180px;min-width:0;display:flex;flex-wrap:wrap;align-items:center;gap:2px 8px}.state-copy>.state-details{flex:0 1 auto;min-width:0;margin-top:0}.state-copy>.state-details[open]{flex:1 1 auto}.empty-state .empty-title,.error-state .error-title{margin:0;font-weight:600;line-height:1.4}.empty-state .empty-title,.error-state .error-title{color:var(--ink)}.state-action{flex:none;margin-left:auto;display:flex;flex-wrap:wrap;align-items:center;gap:6px}.state-details{margin-top:3px}.state-details>summary{display:inline-flex;align-items:center;gap:4px;color:var(--muted);font-size:12px;line-height:1.4;cursor:pointer;list-style:none}.state-details>summary::-webkit-details-marker{display:none}.state-details>summary:before{content:"›";display:inline-block;transition:transform .12s ease}.state-details[open]>summary:before{transform:rotate(90deg)}.state-details>p{margin:5px 0 0;max-width:62ch;font-size:12.5px;line-height:1.55;overflow-wrap:anywhere}.state-details ul{margin:6px 0 0;padding-left:18px;font-size:12.5px;line-height:1.55}.state-copy .state-short{margin:0;font-size:12.5px;line-height:1.45}.state-short{color:var(--muted);font-size:12px;line-height:1.45;overflow-wrap:anywhere}.state-inline{display:flex;flex-wrap:wrap;align-items:center;gap:4px 10px;margin-top:8px}.state-inline .state-details{margin-top:0}.skeleton{border-radius:var(--radius-s);background:linear-gradient(90deg,var(--surface-2) 25%,color-mix(in srgb,var(--surface-2) 60%,var(--surface)) 50%,var(--surface-2) 75%);background-size:200% 100%;animation:skeleton-sweep 1.4s infinite;min-height:16px}@keyframes skeleton-sweep{0%{background-position:200% 0}to{background-position:-200% 0}}.page{display:flex;flex-direction:column;gap:18px}.page-header{display:flex;align-items:center;gap:10px 16px;flex-wrap:wrap}.page-title{margin:0;font-size:24px;font-weight:700;letter-spacing:-.025em;line-height:1.2}.page-subtitle{margin:-10px 0 0;color:var(--muted);font-size:13px;line-height:1.5}.page-header-actions{display:flex;align-items:center;gap:8px 12px;flex-wrap:wrap;margin-left:auto}.page-header-actions .segmented{max-width:100%}.grid-2{display:grid;grid-template-columns:1fr 1fr;gap:18px}.section-stack{display:flex;flex-direction:column;gap:16px}.table-wrap{overflow-x:auto;border:1px solid var(--line);border-radius:10px;background:var(--surface)}table.data-table{width:100%;border-collapse:collapse;font-size:13px}.data-table th,.data-table td{padding:10px 14px;text-align:left;border-bottom:1px solid var(--soft-line, var(--line));vertical-align:middle}.data-table thead th{position:sticky;top:0;background:color-mix(in srgb,var(--surface-2) 55%,var(--surface));color:var(--muted);font-weight:600;font-size:12px;letter-spacing:.01em;white-space:nowrap;z-index:1;border-bottom:1px solid var(--line)}.data-table tbody tr{transition:background-color .1s ease}.data-table tbody tr:hover{background:color-mix(in srgb,var(--accent) 4%,var(--surface))}.data-table tbody tr:last-child td{border-bottom:none}.table-sort{border:0;padding:0;background:none;color:inherit;font:inherit;cursor:pointer;text-align:inherit}.table-sort{min-height:24px}.data-table th.sortable{cursor:pointer;-webkit-user-select:none;user-select:none}.data-table th.sortable:hover{color:var(--ink)}.data-table td.num,.data-table th.num{text-align:right;font-variant-numeric:tabular-nums}.card-details{margin-top:6px;font-size:12px;color:var(--muted)}.card-details>summary{cursor:pointer}.card-details p{margin:4px 0 0}.account-facts-notes{margin-top:4px;font-size:12px;color:var(--muted)}.account-facts-notes summary{cursor:pointer}@media(max-width:768px){.data-table th,.data-table td{white-space:normal;overflow-wrap:anywhere}}.tabs{display:flex;gap:2px;border-bottom:1px solid var(--line);flex-wrap:wrap;overflow-x:auto;scrollbar-width:none}.tabs::-webkit-scrollbar{display:none}.tab{min-height:42px;padding:9px 14px;color:var(--muted);border-bottom:2px solid transparent;margin-bottom:-1px;font-size:13.5px;white-space:nowrap}.tab:hover{color:var(--ink)}.tab.active{color:var(--accent);border-bottom-color:var(--accent);font-weight:650}.segmented{display:inline-flex;background:var(--surface-2);border-radius:8px;padding:3px;gap:2px;flex-wrap:wrap}.segmented .segment{min-height:28px;padding:4px 11px;border-radius:6px;color:var(--muted);display:flex;flex-direction:column;align-items:center;justify-content:center;line-height:1.3;transition:background-color .1s ease,color .1s ease}.segmented .segment:hover:not(.active){color:var(--ink)}.segmented .segment .segment-sub{font-size:12px;font-variant-numeric:tabular-nums}.segmented .segment.active{background:var(--surface);color:var(--ink);font-weight:600;box-shadow:0 1px 3px #0f172a1a}.field{display:flex;flex-direction:column;gap:5px;margin-bottom:12px}.field>span{font-size:12px;color:var(--muted)}.input,select.input{min-height:36px;padding:7px 10px;border:1px solid var(--line);border-radius:7px;background:var(--surface);color:var(--ink);font:inherit;width:100%}.input:hover,select.input:hover{border-color:color-mix(in srgb,var(--accent) 30%,var(--line))}.input:focus{outline:2px solid var(--accent);outline-offset:0;border-color:transparent}.checkbox-row{display:flex;align-items:flex-start;gap:8px;font-size:13px}.checkbox-row input{margin-top:3px}.dialog-backdrop{position:fixed;inset:0;background:#00000073;display:flex;align-items:center;justify-content:center;padding:16px;z-index:100}.dialog{background:var(--surface);border-radius:var(--radius-m);border:1px solid var(--line);box-shadow:var(--shadow);max-width:520px;width:100%;max-height:85vh;overflow:auto;padding:20px}.dialog h2{margin:0 0 8px;font-size:16px}.dialog .dialog-target{font-weight:600;margin:0 0 8px}.dialog .dialog-summary{color:var(--muted);margin:0 0 8px}.dialog .dialog-consequence{margin:0 0 12px}.dialog .dialog-consequence.danger{color:var(--danger)}.dialog-actions{display:flex;justify-content:flex-end;gap:8px;margin-top:16px}.toast-stack{position:fixed;bottom:16px;right:16px;display:flex;flex-direction:column;gap:8px;z-index:120;max-width:min(420px,calc(100vw - 32px))}.toast{background:var(--surface);border:1px solid var(--line);border-left:4px solid var(--accent);border-radius:var(--radius-s);box-shadow:var(--shadow);padding:10px 12px;display:flex;gap:8px;align-items:flex-start;font-size:13px}.toast.error{border-left-color:var(--status-error)}.toast.success{border-left-color:var(--status-ok)}.toast button{color:var(--muted);flex:0 0 auto}.diff-affects-live{color:var(--danger);font-weight:600}.timeline{list-style:none;margin:0;padding:0}.timeline li{position:relative;padding:0 0 16px 20px;border-left:2px solid var(--line);margin-left:6px}.timeline li:last-child{padding-bottom:0}.timeline li:before{content:"";position:absolute;left:-6px;top:4px;width:10px;height:10px;border-radius:50%;background:var(--accent)}.timeline .timeline-time{color:var(--muted);font-size:12px}.danger-zone{border:1px solid var(--danger);border-radius:var(--radius-m);padding:16px;display:flex;flex-direction:column;gap:12px}.danger-zone-title{color:var(--danger);font-weight:700;margin:0;font-size:14px}.danger-row{display:flex;align-items:flex-start;justify-content:space-between;gap:16px;flex-wrap:wrap}.danger-row .danger-row-text{flex:1 1 320px}.danger-row .danger-row-text strong{display:block;margin-bottom:2px}.danger-row .danger-row-text p{margin:0;color:var(--muted);font-size:13px}.chart{width:100%}.chart-legend{display:flex;flex-wrap:wrap;gap:8px 16px;margin-top:8px}.chart-legend button{display:inline-flex;align-items:center;gap:6px;color:var(--muted);font-size:12px;padding:2px 4px;border-radius:4px;max-width:100%;min-width:0;white-space:normal;overflow-wrap:anywhere;text-align:left}.chart-legend button:hover{background:var(--surface-2)}.chart-legend button.off{opacity:.4;text-decoration:line-through}.chart-legend .legend-swatch{flex:0 0 14px;width:14px;height:3px;border-radius:2px;display:inline-block}.chart-tooltip{background:var(--surface);border:1px solid var(--line);border-radius:var(--radius-s);box-shadow:var(--shadow);padding:8px 10px;font-size:12px;pointer-events:none;position:absolute;z-index:10;max-width:min(240px,70vw);white-space:normal;overflow-wrap:anywhere}.chart-tooltip .tooltip-date{color:var(--muted);margin-bottom:4px}.chart-tooltip .tooltip-row{display:flex;align-items:center;gap:6px;font-variant-numeric:tabular-nums}.chart-frame{position:relative}.calendar-month-grid{display:grid;grid-template-columns:repeat(7,minmax(36px,1fr));gap:4px}.calendar-cell{min-height:40px;border-radius:var(--radius-s);border:1px solid var(--line);padding:4px 6px;font-size:12px;display:flex;flex-direction:column;gap:2px;background:var(--surface)}.calendar-cell .cell-date{color:var(--muted);font-size:11px}.calendar-cell .cell-value{font-variant-numeric:tabular-nums;font-weight:600}.calendar-cell.cell-empty{border-style:dashed;background:repeating-linear-gradient(135deg,transparent 0 6px,var(--surface-2) 6px 12px)}.calendar-year-grid{display:grid;grid-template-columns:repeat(4,minmax(0,1fr));gap:8px}.calendar-nav{display:flex;align-items:center;justify-content:center;gap:8px}.calendar-nav .current{font-weight:600;min-width:110px;text-align:center}.calendar-weekday{color:var(--muted);font-size:12px;text-align:center}.barlist{display:flex;flex-direction:column;gap:8px}.barlist-row{display:grid;grid-template-columns:90px 1fr 90px;align-items:center;gap:8px;font-size:13px}.barlist-label{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.barlist-track{position:relative;height:14px;background:var(--surface-2);border-radius:4px;overflow:hidden}.barlist-fill{position:absolute;top:0;bottom:0;border-radius:4px}.barlist-value{text-align:right;font-variant-numeric:tabular-nums}.inbox{display:grid;grid-template-columns:minmax(280px,380px) 1fr;gap:16px;align-items:start}.inbox.list-only{grid-template-columns:minmax(0,1fr)}.inbox.list-only .inbox-list{max-width:none}.inbox-list{display:flex;flex-direction:column;gap:8px}.inbox-item{display:flex;gap:10px;align-items:flex-start;padding:10px 12px;background:var(--surface);border:1px solid var(--line);border-radius:var(--radius-m);text-align:left;width:100%}.inbox-item:hover{border-color:var(--accent)}.inbox-item.active{border-color:var(--accent);box-shadow:inset 0 0 0 1px var(--accent)}.priority-dot{width:8px;height:8px;border-radius:50%;margin-top:6px;flex:0 0 auto}.priority-high{background:var(--status-error)}.priority-medium{background:var(--status-warn)}.priority-normal{background:var(--status-unknown)}.inbox-item .item-main{min-width:0;flex:1 1 auto}.inbox-item .item-title{font-weight:600;overflow-wrap:anywhere}.inbox-item .item-meta{color:var(--muted);font-size:12px;display:flex;gap:8px;flex-wrap:wrap}.inbox-detail{position:sticky;top:72px}.inbox-actions{position:sticky;bottom:0;display:flex;gap:8px;padding-top:12px;margin-top:12px;border-top:1px solid var(--line);background:var(--surface);flex-wrap:wrap}.account-grid{display:grid;grid-template-columns:repeat(auto-fit,minmax(260px,1fr));gap:12px}.account-card{background:var(--surface);border:1px solid var(--line);border-radius:var(--radius-m);padding:14px 16px;text-align:left;display:flex;flex-direction:column;gap:6px}.account-card:hover{border-color:var(--accent)}.account-card .account-title{font-weight:700;display:flex;align-items:center;gap:8px}.account-card .account-row{display:flex;justify-content:space-between;gap:8px;font-size:13px}.account-card .account-row span:first-child{color:var(--muted)}.accounts-layout{display:grid;grid-template-columns:minmax(300px,420px) 1fr;gap:16px;align-items:start}.strategy-grid{display:grid;grid-template-columns:repeat(3,minmax(0,1fr));gap:12px}@media(max-width:1000px){.strategy-grid{grid-template-columns:repeat(2,minmax(0,1fr))}}@media(max-width:700px){.account-grid,.strategy-grid{grid-template-columns:minmax(0,1fr)}}.health-grid{max-width:100%;overflow-x:auto;-webkit-overflow-scrolling:touch;overscroll-behavior-x:contain;scrollbar-width:thin;padding-bottom:2px}.health-grid table{width:max-content;min-width:100%;border-collapse:collapse;font-size:12px}.health-grid-hint{display:none;margin:0 0 8px;color:var(--muted);font-size:12px;line-height:1.45}.table-scroll-hint{display:none;margin:0 0 6px;color:var(--muted);font-size:12px;line-height:1.45}.health-grid th,.health-grid td{padding:4px;text-align:center}.health-grid th{color:var(--muted);font-weight:500;white-space:nowrap}.health-cell{width:26px;height:26px;border-radius:4px;display:inline-flex;align-items:center;justify-content:center;border:1px solid var(--line);font-size:11px}.health-cell.ok{background:color-mix(in srgb,var(--status-ok) 20%,transparent);color:var(--status-ok)}.health-cell.failed{background:color-mix(in srgb,var(--status-error) 20%,transparent);color:var(--status-error)}.health-cell.not-run{background:var(--surface-2);color:var(--muted)}.health-cell.no-record{background:repeating-linear-gradient(135deg,transparent 0 4px,var(--surface-2) 4px 8px);color:var(--muted)}.health-cell:hover,.health-cell:focus-visible{outline:2px solid var(--accent)}.health-legend{display:flex;gap:16px;flex-wrap:wrap;font-size:12px;color:var(--muted)}.health-legend span{display:inline-flex;align-items:center;gap:6px}.stat-strip{display:grid;grid-template-columns:repeat(5,minmax(0,1fr));gap:12px}.scope-switcher{position:relative;min-width:0}.scope-trigger{max-width:100%;min-width:0}.scope-trigger-label{min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.scope-panel{position:absolute;top:calc(100% + 4px);left:0;min-width:220px;background:var(--surface);border:1px solid var(--line);border-radius:var(--radius-m);box-shadow:var(--shadow);padding:6px;z-index:50;max-height:320px;overflow:auto}.scope-group{padding:4px 8px;color:var(--muted);font-size:12px}.scope-option{display:flex;align-items:center;gap:8px;width:100%;padding:8px;border-radius:var(--radius-s);text-align:left;min-width:0}.scope-option-label{flex:1 1 auto;min-width:0;white-space:normal;overflow-wrap:anywhere;line-height:1.4}.scope-option .badge{flex:none}.scope-panel-text{flex:1 1 auto;min-width:0;overflow-wrap:anywhere}.scope-option:hover{background:var(--surface-2)}.scope-option.active{color:var(--accent);font-weight:600}.user-menu{position:relative}.user-menu>summary{list-style:none;width:32px;height:32px;border-radius:50%;background:var(--accent);color:var(--on-accent);display:flex;align-items:center;justify-content:center;font-weight:700;cursor:pointer}.user-menu>summary::-webkit-details-marker{display:none}.user-menu-panel{position:absolute;right:0;top:calc(100% + 4px);background:var(--surface);border:1px solid var(--line);border-radius:var(--radius-m);box-shadow:var(--shadow);padding:8px;min-width:200px;z-index:50;display:flex;flex-direction:column;gap:2px}.user-menu-panel .menu-item{display:flex;align-items:center;gap:8px;width:100%;padding:8px;border-radius:var(--radius-s);text-align:left}.user-menu-panel .menu-item:hover{background:var(--surface-2)}.user-menu-name{padding:4px 8px 8px;border-bottom:1px solid var(--line);margin-bottom:4px}.prefs-grid{display:flex;flex-direction:column;gap:16px}.prefs-row{display:flex;align-items:center;justify-content:space-between;gap:16px}.prefs-row>span{font-weight:500}.boot-screen,.access-screen{min-height:100vh;display:flex;flex-direction:column;align-items:center;justify-content:center;gap:12px;text-align:center;padding:24px}.access-screen img{width:48px;height:48px}.access-screen h1{margin:0;font-size:24px}.access-screen p{color:var(--muted);max-width:420px;margin:0}.global-notice{display:flex;align-items:center;gap:12px;justify-content:space-between;padding:8px 16px;background:color-mix(in srgb,var(--status-warn) 12%,var(--surface));border-bottom:1px solid var(--line);font-size:13px}@media(max-width:1024px){.kpi-grid{grid-template-columns:repeat(3,minmax(0,1fr))}.grid-2,.accounts-layout,.inbox{grid-template-columns:1fr}.inbox-detail{position:static}}@media(max-width:1100px){.stat-strip{grid-template-columns:repeat(3,minmax(0,1fr))}}@media(max-width:768px){.stat-strip{grid-template-columns:repeat(2,minmax(0,1fr))}.sidenav{display:none}.bottom-tabs{display:block}.content{padding:14px 12px calc(var(--bottom-tabs-height) + 40px + env(safe-area-inset-bottom))}.health-grid-hint,.table-scroll-hint{display:block}.page{gap:14px}.page-header{gap:10px}.page-title{font-size:20px}.page-header-actions{margin-left:auto;justify-content:flex-end}.page-header-actions:has(>.segmented){width:100%;margin-left:0}.page-header-actions>.button{flex:0 0 auto}.page-header-actions>.segmented{width:100%;flex-wrap:nowrap;overflow-x:auto;scrollbar-width:none}.page-header-actions>.segmented::-webkit-scrollbar{display:none}.page-header-actions>.segmented .segment{flex:1 1 auto;justify-content:center;white-space:nowrap}.card{padding:14px}.card-title{font-size:15px;margin-bottom:10px}.kpi-grid{grid-template-columns:repeat(2,minmax(0,1fr))}.kpi-value{font-size:21px}.kpi-card{padding:12px 13px}.topbar-updated{display:none}.topbar{flex-wrap:nowrap;gap:8px;padding:8px 12px}.topbar .scope-switcher{flex:1 1 auto;min-width:44px}.topbar .spacer,.lang-label-full{display:none}.lang-label-short{display:inline}.topbar .theme-toggle-label{display:none}.topbar .appearance-toggle,.topbar .icon-button,.topbar .user-menu>summary{min-width:44px;min-height:44px}.topbar .scope-trigger{width:100%;min-width:44px;min-height:44px}.scope-panel{width:min(340px,calc(100vw - 24px));max-height:60dvh}.scope-option{min-height:44px}.calendar-year-grid{grid-template-columns:repeat(3,minmax(0,1fr))}.inbox-actions{position:static}.empty-state,.error-state{padding:11px 12px}.state-icon{width:24px;height:24px}.data-table th,.data-table td{padding:9px 11px}}@media(max-width:430px){.topbar:has(>.scope-switcher):has(>.topbar-synthetic){flex-wrap:wrap}.topbar:has(>.scope-switcher):has(>.topbar-synthetic)>.topbar-synthetic{order:10;flex:1 1 100%;display:flex;justify-content:center}}.update-notice{display:flex;flex-wrap:wrap;align-items:center;justify-content:space-between;gap:8px;padding:12px 20px;background:var(--surface-2)}@media(prefers-reduced-motion:reduce){*,*:before,*:after{animation-duration:.01ms!important;animation-iteration-count:1!important;transition-duration:.01ms!important}}.appearance-toggle{flex:0 0 auto;white-space:nowrap}.account-platform-group+.account-platform-group{margin-top:20px}.account-platform-title{margin:0 0 10px;font-size:16px}.account-strategy-link{display:flex;flex-direction:column;text-align:left;width:100%;gap:6px;padding:10px 8px;margin:0 -8px;border-radius:8px;transition:background-color .12s ease}.account-strategy-link+.account-strategy-link{border-top:1px solid var(--line)}.account-strategy-link:hover .account-strategy-name{color:var(--accent);text-decoration:underline}.account-strategy-link:hover,.account-strategy-link:focus-visible{background:color-mix(in srgb,var(--accent) 6%,transparent)}.account-strategy-head{display:flex;align-items:center;justify-content:space-between;gap:8px;min-width:0}.account-strategy-chevron{flex:0 0 auto;color:var(--muted);font-size:16px;line-height:1;transition:color .12s ease,transform .12s ease}.account-strategy-link:hover .account-strategy-chevron,.account-strategy-link:focus-visible .account-strategy-chevron{color:var(--accent);transform:translate(2px)}.account-strategy-name{font-weight:600;overflow-wrap:anywhere}.account-broker-title{margin:0 0 8px;font-size:15px;overflow-wrap:anywhere}.account-identity-note{color:var(--muted);font-size:12px}@media(max-width:768px){.topbar{gap:8px;padding-inline:12px}.topbar .scope-switcher{min-width:44px}.scope-switcher>button{max-width:100%;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.account-strategy-link{min-height:44px}}.account-group-card .account-row{display:flex;justify-content:space-between;gap:12px;font-size:13px}.account-group-card .account-row>span:first-child{color:var(--muted)}.account-strategy-link>.badge{align-self:flex-start}.calendar-cell.cell-future{border-style:solid;background:color-mix(in srgb,var(--surface-2) 55%,var(--surface))}.calendar-cell.cell-closed{border-style:solid;background:var(--surface-2)}.calendar-cell.cell-pending{position:relative;border-style:solid;border-color:color-mix(in srgb,var(--accent) 45%,var(--line));background:var(--surface)}.calendar-cell.cell-pending:after{content:"";position:absolute;top:5px;right:5px;width:5px;height:5px;border-radius:50%;background:var(--accent);opacity:.65}
" },
-  "/v2/assets/index-Ds_XXLsn.js": { contentType: "text/javascript; charset=utf-8", base64: "const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["assets/OverviewPage-DLmRzWCy.js","assets/inboxFailure-DUO9CRup.js","assets/cashflowMethod-H7Uq4Mrs.js","assets/cashflowMethod-Gm8aPj9t.css","assets/hooks-DCo9_b70.js","assets/KpiCard-Dxqixf9c.js","assets/status-B_UXUo8G.js","assets/runtime_daily_contract-xW43mZQY.js","assets/OverviewPage-C345eb1E.css","assets/PerformancePage-DuxiG9dq.js","assets/DataTable-Bs7KLM5-.js","assets/Tabs-DBQ5AQB9.js","assets/PerformancePage-BMNSw_qo.css","assets/DecisionsPage-DjK85Y5B.js","assets/Dialog-JHiHwrz3.js","assets/DecisionsPage-CyeuTPhn.css","assets/AccountsPage-CsdJjpqu.js","assets/ExecutionEvidence-BafFTQfM.js","assets/AccountsPage-CaB9EVDF.css","assets/StrategiesPage-DcL-BLIE.js","assets/StrategiesPage-CGEC27nb.css","assets/HealthPage-C3MhtCXB.js","assets/HealthPage-DWOwvlJZ.css"])))=>i.map(i=>d[i]);
(function(){const s=document.createElement("link").relList;if(s&&s.supports&&s.supports("modulepreload"))return;for(const E of document.querySelectorAll('link[rel="modulepreload"]'))r(E);new MutationObserver(E=>{for(const R of E)if(R.type==="childList")for(const C of R.addedNodes)C.tagName==="LINK"&&C.rel==="modulepreload"&&r(C)}).observe(document,{childList:!0,subtree:!0});function m(E){const R={};return E.integrity&&(R.integrity=E.integrity),E.referrerPolicy&&(R.referrerPolicy=E.referrerPolicy),E.crossOrigin==="use-credentials"?R.credentials="include":E.crossOrigin==="anonymous"?R.credentials="omit":R.credentials="same-origin",R}function r(E){if(E.ep)return;E.ep=!0;const R=m(E);fetch(E.href,R)}})();var _o={exports:{}},Tl={};var zd;function H_(){if(zd)return Tl;zd=1;var u=Symbol.for("react.transitional.element"),s=Symbol.for("react.fragment");function m(r,E,R){var C=null;if(R!==void 0&&(C=""+R),E.key!==void 0&&(C=""+E.key),"key"in E){R={};for(var U in E)U!=="key"&&(R[U]=E[U])}else R=E;return E=R.ref,{$$typeof:u,type:r,key:C,ref:E!==void 0?E:null,props:R}}return Tl.Fragment=s,Tl.jsx=m,Tl.jsxs=m,Tl}var Rd;function B_(){return Rd||(Rd=1,_o.exports=H_()),_o.exports}var _=B_(),po={exports:{}},El={},go={exports:{}},vo={};var Nd;function L_(){return Nd||(Nd=1,(function(u){function s(A,q){var Y=A.length;A.push(q);e:for(;0<Y;){var ce=Y-1>>>1,d=A[ce];if(0<E(d,q))A[ce]=q,A[Y]=d,Y=ce;else break e}}function m(A){return A.length===0?null:A[0]}function r(A){if(A.length===0)return null;var q=A[0],Y=A.pop();if(Y!==q){A[0]=Y;e:for(var ce=0,d=A.length,T=d>>>1;ce<T;){var D=2*(ce+1)-1,M=A[D],k=D+1,F=A[k];if(0>E(M,Y))k<d&&0>E(F,M)?(A[ce]=F,A[k]=Y,ce=k):(A[ce]=M,A[D]=Y,ce=D);else if(k<d&&0>E(F,Y))A[ce]=F,A[k]=Y,ce=k;else break e}}return q}function E(A,q){var Y=A.sortIndex-q.sortIndex;return Y!==0?Y:A.id-q.id}if(u.unstable_now=void 0,typeof performance=="object"&&typeof performance.now=="function"){var R=performance;u.unstable_now=function(){return R.now()}}else{var C=Date,U=C.now();u.unstable_now=function(){return C.now()-U}}var v=[],x=[],O=1,L=null,K=3,_e=!1,ie=!1,ye=!1,De=!1,Ae=typeof setTimeout=="function"?setTimeout:null,we=typeof clearTimeout=="function"?clearTimeout:null,be=typeof setImmediate<"u"?setImmediate:null;function Ue(A){for(var q=m(x);q!==null;){if(q.callback===null)r(x);else if(q.startTime<=A)r(x),q.sortIndex=q.expirationTime,s(v,q);else break;q=m(x)}}function V(A){if(ye=!1,Ue(A),!ie)if(m(v)!==null)ie=!0,J||(J=!0,$());else{var q=m(x);q!==null&&Se(V,q.startTime-A)}}var J=!1,me=-1,ze=5,Ye=-1;function nt(){return De?!0:!(u.unstable_now()-Ye<ze)}function $e(){if(De=!1,J){var A=u.unstable_now();Ye=A;var q=!0;try{e:{ie=!1,ye&&(ye=!1,we(me),me=-1),_e=!0;var Y=K;try{t:{for(Ue(A),L=m(v);L!==null&&!(L.expirationTime>A&&nt());){var ce=L.callback;if(typeof ce=="function"){L.callback=null,K=L.priorityLevel;var d=ce(L.expirationTime<=A);if(A=u.unstable_now(),typeof d=="function"){L.callback=d,Ue(A),q=!0;break t}L===m(v)&&r(v),Ue(A)}else r(v);L=m(v)}if(L!==null)q=!0;else{var T=m(x);T!==null&&Se(V,T.startTime-A),q=!1}}break e}finally{L=null,K=Y,_e=!1}q=void 0}}finally{q?$():J=!1}}}var $;if(typeof be=="function")$=function(){be($e)};else if(typeof MessageChannel<"u"){var je=new MessageChannel,Ge=je.port2;je.port1.onmessage=$e,$=function(){Ge.postMessage(null)}}else $=function(){Ae($e,0)};function Se(A,q){me=Ae(function(){A(u.unstable_now())},q)}u.unstable_IdlePriority=5,u.unstable_ImmediatePriority=1,u.unstable_LowPriority=4,u.unstable_NormalPriority=3,u.unstable_Profiling=null,u.unstable_UserBlockingPriority=2,u.unstable_cancelCallback=function(A){A.callback=null},u.unstable_forceFrameRate=function(A){0>A||125<A?console.error("forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported"):ze=0<A?Math.floor(1e3/A):5},u.unstable_getCurrentPriorityLevel=function(){return K},u.unstable_next=function(A){switch(K){case 1:case 2:case 3:var q=3;break;default:q=K}var Y=K;K=q;try{return A()}finally{K=Y}},u.unstable_requestPaint=function(){De=!0},u.unstable_runWithPriority=function(A,q){switch(A){case 1:case 2:case 3:case 4:case 5:break;default:A=3}var Y=K;K=A;try{return q()}finally{K=Y}},u.unstable_scheduleCallback=function(A,q,Y){var ce=u.unstable_now();switch(typeof Y=="object"&&Y!==null?(Y=Y.delay,Y=typeof Y=="number"&&0<Y?ce+Y:ce):Y=ce,A){case 1:var d=-1;break;case 2:d=250;break;case 5:d=1073741823;break;case 4:d=1e4;break;default:d=5e3}return d=Y+d,A={id:O++,callback:q,priorityLevel:A,startTime:Y,expirationTime:d,sortIndex:-1},Y>ce?(A.sortIndex=Y,s(x,A),m(v)===null&&A===m(x)&&(ye?(we(me),me=-1):ye=!0,Se(V,Y-ce))):(A.sortIndex=d,s(v,A),ie||_e||(ie=!0,J||(J=!0,$()))),A},u.unstable_shouldYield=nt,u.unstable_wrapCallback=function(A){var q=K;return function(){var Y=K;K=q;try{return A.apply(this,arguments)}finally{K=Y}}}})(vo)),vo}var Dd;function Y_(){return Dd||(Dd=1,go.exports=L_()),go.exports}var yo={exports:{}},W={};var Md;function G_(){if(Md)return W;Md=1;var u=Symbol.for("react.transitional.element"),s=Symbol.for("react.portal"),m=Symbol.for("react.fragment"),r=Symbol.for("react.strict_mode"),E=Symbol.for("react.profiler"),R=Symbol.for("react.consumer"),C=Symbol.for("react.context"),U=Symbol.for("react.forward_ref"),v=Symbol.for("react.suspense"),x=Symbol.for("react.memo"),O=Symbol.for("react.lazy"),L=Symbol.iterator;function K(d){return d===null||typeof d!="object"?null:(d=L&&d[L]||d["@@iterator"],typeof d=="function"?d:null)}var _e={isMounted:function(){return!1},enqueueForceUpdate:function(){},enqueueReplaceState:function(){},enqueueSetState:function(){}},ie=Object.assign,ye={};function De(d,T,D){this.props=d,this.context=T,this.refs=ye,this.updater=D||_e}De.prototype.isReactComponent={},De.prototype.setState=function(d,T){if(typeof d!="object"&&typeof d!="function"&&d!=null)throw Error("takes an object of state variables to update or a function which returns an object of state variables.");this.updater.enqueueSetState(this,d,T,"setState")},De.prototype.forceUpdate=function(d){this.updater.enqueueForceUpdate(this,d,"forceUpdate")};function Ae(){}Ae.prototype=De.prototype;function we(d,T,D){this.props=d,this.context=T,this.refs=ye,this.updater=D||_e}var be=we.prototype=new Ae;be.constructor=we,ie(be,De.prototype),be.isPureReactComponent=!0;var Ue=Array.isArray,V={H:null,A:null,T:null,S:null,V:null},J=Object.prototype.hasOwnProperty;function me(d,T,D,M,k,F){return D=F.ref,{$$typeof:u,type:d,key:T,ref:D!==void 0?D:null,props:F}}function ze(d,T){return me(d.type,T,void 0,void 0,void 0,d.props)}function Ye(d){return typeof d=="object"&&d!==null&&d.$$typeof===u}function nt(d){var T={"=":"=0",":":"=2"};return"$"+d.replace(/[=:]/g,function(D){return T[D]})}var $e=/\/+/g;function $(d,T){return typeof d=="object"&&d!==null&&d.key!=null?nt(""+d.key):T.toString(36)}function je(){}function Ge(d){switch(d.status){case"fulfilled":return d.value;case"rejected":throw d.reason;default:switch(typeof d.status=="string"?d.then(je,je):(d.status="pending",d.then(function(T){d.status==="pending"&&(d.status="fulfilled",d.value=T)},function(T){d.status==="pending"&&(d.status="rejected",d.reason=T)})),d.status){case"fulfilled":return d.value;case"rejected":throw d.reason}}throw d}function Se(d,T,D,M,k){var F=typeof d;(F==="undefined"||F==="boolean")&&(d=null);var Z=!1;if(d===null)Z=!0;else switch(F){case"bigint":case"string":case"number":Z=!0;break;case"object":switch(d.$$typeof){case u:case s:Z=!0;break;case O:return Z=d._init,Se(Z(d._payload),T,D,M,k)}}if(Z)return k=k(d),Z=M===""?"."+$(d,0):M,Ue(k)?(D="",Z!=null&&(D=Z.replace($e,"$&/")+"/"),Se(k,T,D,"",function(Jt){return Jt})):k!=null&&(Ye(k)&&(k=ze(k,D+(k.key==null||d&&d.key===k.key?"":(""+k.key).replace($e,"$&/")+"/")+Z)),T.push(k)),1;Z=0;var lt=M===""?".":M+":";if(Ue(d))for(var pe=0;pe<d.length;pe++)M=d[pe],F=lt+$(M,pe),Z+=Se(M,T,D,F,k);else if(pe=K(d),typeof pe=="function")for(d=pe.call(d),pe=0;!(M=d.next()).done;)M=M.value,F=lt+$(M,pe++),Z+=Se(M,T,D,F,k);else if(F==="object"){if(typeof d.then=="function")return Se(Ge(d),T,D,M,k);throw T=String(d),Error("Objects are not valid as a React child (found: "+(T==="[object Object]"?"object with keys {"+Object.keys(d).join(", ")+"}":T)+"). If you meant to render a collection of children, use an array instead.")}return Z}function A(d,T,D){if(d==null)return d;var M=[],k=0;return Se(d,M,"","",function(F){return T.call(D,F,k++)}),M}function q(d){if(d._status===-1){var T=d._result;T=T(),T.then(function(D){(d._status===0||d._status===-1)&&(d._status=1,d._result=D)},function(D){(d._status===0||d._status===-1)&&(d._status=2,d._result=D)}),d._status===-1&&(d._status=0,d._result=T)}if(d._status===1)return d._result.default;throw d._result}var Y=typeof reportError=="function"?reportError:function(d){if(typeof window=="object"&&typeof window.ErrorEvent=="function"){var T=new window.ErrorEvent("error",{bubbles:!0,cancelable:!0,message:typeof d=="object"&&d!==null&&typeof d.message=="string"?String(d.message):String(d),error:d});if(!window.dispatchEvent(T))return}else if(typeof process=="object"&&typeof process.emit=="function"){process.emit("uncaughtException",d);return}console.error(d)};function ce(){}return W.Children={map:A,forEach:function(d,T,D){A(d,function(){T.apply(this,arguments)},D)},count:function(d){var T=0;return A(d,function(){T++}),T},toArray:function(d){return A(d,function(T){return T})||[]},only:function(d){if(!Ye(d))throw Error("React.Children.only expected to receive a single React element child.");return d}},W.Component=De,W.Fragment=m,W.Profiler=E,W.PureComponent=we,W.StrictMode=r,W.Suspense=v,W.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE=V,W.__COMPILER_RUNTIME={__proto__:null,c:function(d){return V.H.useMemoCache(d)}},W.cache=function(d){return function(){return d.apply(null,arguments)}},W.cloneElement=function(d,T,D){if(d==null)throw Error("The argument must be a React element, but you passed "+d+".");var M=ie({},d.props),k=d.key,F=void 0;if(T!=null)for(Z in T.ref!==void 0&&(F=void 0),T.key!==void 0&&(k=""+T.key),T)!J.call(T,Z)||Z==="key"||Z==="__self"||Z==="__source"||Z==="ref"&&T.ref===void 0||(M[Z]=T[Z]);var Z=arguments.length-2;if(Z===1)M.children=D;else if(1<Z){for(var lt=Array(Z),pe=0;pe<Z;pe++)lt[pe]=arguments[pe+2];M.children=lt}return me(d.type,k,void 0,void 0,F,M)},W.createContext=function(d){return d={$$typeof:C,_currentValue:d,_currentValue2:d,_threadCount:0,Provider:null,Consumer:null},d.Provider=d,d.Consumer={$$typeof:R,_context:d},d},W.createElement=function(d,T,D){var M,k={},F=null;if(T!=null)for(M in T.key!==void 0&&(F=""+T.key),T)J.call(T,M)&&M!=="key"&&M!=="__self"&&M!=="__source"&&(k[M]=T[M]);var Z=arguments.length-2;if(Z===1)k.children=D;else if(1<Z){for(var lt=Array(Z),pe=0;pe<Z;pe++)lt[pe]=arguments[pe+2];k.children=lt}if(d&&d.defaultProps)for(M in Z=d.defaultProps,Z)k[M]===void 0&&(k[M]=Z[M]);return me(d,F,void 0,void 0,null,k)},W.createRef=function(){return{current:null}},W.forwardRef=function(d){return{$$typeof:U,render:d}},W.isValidElement=Ye,W.lazy=function(d){return{$$typeof:O,_payload:{_status:-1,_result:d},_init:q}},W.memo=function(d,T){return{$$typeof:x,type:d,compare:T===void 0?null:T}},W.startTransition=function(d){var T=V.T,D={};V.T=D;try{var M=d(),k=V.S;k!==null&&k(D,M),typeof M=="object"&&M!==null&&typeof M.then=="function"&&M.then(ce,Y)}catch(F){Y(F)}finally{V.T=T}},W.unstable_useCacheRefresh=function(){return V.H.useCacheRefresh()},W.use=function(d){return V.H.use(d)},W.useActionState=function(d,T,D){return V.H.useActionState(d,T,D)},W.useCallback=function(d,T){return V.H.useCallback(d,T)},W.useContext=function(d){return V.H.useContext(d)},W.useDebugValue=function(){},W.useDeferredValue=function(d,T){return V.H.useDeferredValue(d,T)},W.useEffect=function(d,T,D){var M=V.H;if(typeof D=="function")throw Error("useEffect CRUD overload is not enabled in this build of React.");return M.useEffect(d,T)},W.useId=function(){return V.H.useId()},W.useImperativeHandle=function(d,T,D){return V.H.useImperativeHandle(d,T,D)},W.useInsertionEffect=function(d,T){return V.H.useInsertionEffect(d,T)},W.useLayoutEffect=function(d,T){return V.H.useLayoutEffect(d,T)},W.useMemo=function(d,T){return V.H.useMemo(d,T)},W.useOptimistic=function(d,T){return V.H.useOptimistic(d,T)},W.useReducer=function(d,T,D){return V.H.useReducer(d,T,D)},W.useRef=function(d){return V.H.useRef(d)},W.useState=function(d){return V.H.useState(d)},W.useSyncExternalStore=function(d,T,D){return V.H.useSyncExternalStore(d,T,D)},W.useTransition=function(){return V.H.useTransition()},W.version="19.1.1",W}var Od;function zo(){return Od||(Od=1,yo.exports=G_()),yo.exports}var bo={exports:{}},Je={};var Ud;function Q_(){if(Ud)return Je;Ud=1;var u=zo();function s(v){var x="https://react.dev/errors/"+v;if(1<arguments.length){x+="?args[]="+encodeURIComponent(arguments[1]);for(var O=2;O<arguments.length;O++)x+="&args[]="+encodeURIComponent(arguments[O])}return"Minified React error #"+v+"; visit "+x+" for the full message or use the non-minified dev environment for full errors and additional helpful warnings."}function m(){}var r={d:{f:m,r:function(){throw Error(s(522))},D:m,C:m,L:m,m,X:m,S:m,M:m},p:0,findDOMNode:null},E=Symbol.for("react.portal");function R(v,x,O){var L=3<arguments.length&&arguments[3]!==void 0?arguments[3]:null;return{$$typeof:E,key:L==null?null:""+L,children:v,containerInfo:x,implementation:O}}var C=u.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE;function U(v,x){if(v==="font")return"";if(typeof x=="string")return x==="use-credentials"?x:""}return Je.__DOM_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE=r,Je.createPortal=function(v,x){var O=2<arguments.length&&arguments[2]!==void 0?arguments[2]:null;if(!x||x.nodeType!==1&&x.nodeType!==9&&x.nodeType!==11)throw Error(s(299));return R(v,x,null,O)},Je.flushSync=function(v){var x=C.T,O=r.p;try{if(C.T=null,r.p=2,v)return v()}finally{C.T=x,r.p=O,r.d.f()}},Je.preconnect=function(v,x){typeof v=="string"&&(x?(x=x.crossOrigin,x=typeof x=="string"?x==="use-credentials"?x:"":void 0):x=null,r.d.C(v,x))},Je.prefetchDNS=function(v){typeof v=="string"&&r.d.D(v)},Je.preinit=function(v,x){if(typeof v=="string"&&x&&typeof x.as=="string"){var O=x.as,L=U(O,x.crossOrigin),K=typeof x.integrity=="string"?x.integrity:void 0,_e=typeof x.fetchPriority=="string"?x.fetchPriority:void 0;O==="style"?r.d.S(v,typeof x.precedence=="string"?x.precedence:void 0,{crossOrigin:L,integrity:K,fetchPriority:_e}):O==="script"&&r.d.X(v,{crossOrigin:L,integrity:K,fetchPriority:_e,nonce:typeof x.nonce=="string"?x.nonce:void 0})}},Je.preinitModule=function(v,x){if(typeof v=="string")if(typeof x=="object"&&x!==null){if(x.as==null||x.as==="script"){var O=U(x.as,x.crossOrigin);r.d.M(v,{crossOrigin:O,integrity:typeof x.integrity=="string"?x.integrity:void 0,nonce:typeof x.nonce=="string"?x.nonce:void 0})}}else x==null&&r.d.M(v)},Je.preload=function(v,x){if(typeof v=="string"&&typeof x=="object"&&x!==null&&typeof x.as=="string"){var O=x.as,L=U(O,x.crossOrigin);r.d.L(v,O,{crossOrigin:L,integrity:typeof x.integrity=="string"?x.integrity:void 0,nonce:typeof x.nonce=="string"?x.nonce:void 0,type:typeof x.type=="string"?x.type:void 0,fetchPriority:typeof x.fetchPriority=="string"?x.fetchPriority:void 0,referrerPolicy:typeof x.referrerPolicy=="string"?x.referrerPolicy:void 0,imageSrcSet:typeof x.imageSrcSet=="string"?x.imageSrcSet:void 0,imageSizes:typeof x.imageSizes=="string"?x.imageSizes:void 0,media:typeof x.media=="string"?x.media:void 0})}},Je.preloadModule=function(v,x){if(typeof v=="string")if(x){var O=U(x.as,x.crossOrigin);r.d.m(v,{as:typeof x.as=="string"&&x.as!=="script"?x.as:void 0,crossOrigin:O,integrity:typeof x.integrity=="string"?x.integrity:void 0})}else r.d.m(v)},Je.requestFormReset=function(v){r.d.r(v)},Je.unstable_batchedUpdates=function(v,x){return v(x)},Je.useFormState=function(v,x,O){return C.H.useFormState(v,x,O)},Je.useFormStatus=function(){return C.H.useHostTransitionStatus()},Je.version="19.1.1",Je}var Cd;function X_(){if(Cd)return bo.exports;Cd=1;function u(){if(!(typeof __REACT_DEVTOOLS_GLOBAL_HOOK__>"u"||typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE!="function"))try{__REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE(u)}catch(s){console.error(s)}}return u(),bo.exports=Q_(),bo.exports}var qd;function Z_(){if(qd)return El;qd=1;var u=Y_(),s=zo(),m=X_();function r(e){var t="https://react.dev/errors/"+e;if(1<arguments.length){t+="?args[]="+encodeURIComponent(arguments[1]);for(var a=2;a<arguments.length;a++)t+="&args[]="+encodeURIComponent(arguments[a])}return"Minified React error #"+e+"; visit "+t+" for the full message or use the non-minified dev environment for full errors and additional helpful warnings."}function E(e){return!(!e||e.nodeType!==1&&e.nodeType!==9&&e.nodeType!==11)}function R(e){var t=e,a=e;if(e.alternate)for(;t.return;)t=t.return;else{e=t;do t=e,(t.flags&4098)!==0&&(a=t.return),e=t.return;while(e)}return t.tag===3?a:null}function C(e){if(e.tag===13){var t=e.memoizedState;if(t===null&&(e=e.alternate,e!==null&&(t=e.memoizedState)),t!==null)return t.dehydrated}return null}function U(e){if(R(e)!==e)throw Error(r(188))}function v(e){var t=e.alternate;if(!t){if(t=R(e),t===null)throw Error(r(188));return t!==e?null:e}for(var a=e,n=t;;){var l=a.return;if(l===null)break;var i=l.alternate;if(i===null){if(n=l.return,n!==null){a=n;continue}break}if(l.child===i.child){for(i=l.child;i;){if(i===a)return U(l),e;if(i===n)return U(l),t;i=i.sibling}throw Error(r(188))}if(a.return!==n.return)a=l,n=i;else{for(var c=!1,o=l.child;o;){if(o===a){c=!0,a=l,n=i;break}if(o===n){c=!0,n=l,a=i;break}o=o.sibling}if(!c){for(o=i.child;o;){if(o===a){c=!0,a=i,n=l;break}if(o===n){c=!0,n=i,a=l;break}o=o.sibling}if(!c)throw Error(r(189))}}if(a.alternate!==n)throw Error(r(190))}if(a.tag!==3)throw Error(r(188));return a.stateNode.current===a?e:t}function x(e){var t=e.tag;if(t===5||t===26||t===27||t===6)return e;for(e=e.child;e!==null;){if(t=x(e),t!==null)return t;e=e.sibling}return null}var O=Object.assign,L=Symbol.for("react.element"),K=Symbol.for("react.transitional.element"),_e=Symbol.for("react.portal"),ie=Symbol.for("react.fragment"),ye=Symbol.for("react.strict_mode"),De=Symbol.for("react.profiler"),Ae=Symbol.for("react.provider"),we=Symbol.for("react.consumer"),be=Symbol.for("react.context"),Ue=Symbol.for("react.forward_ref"),V=Symbol.for("react.suspense"),J=Symbol.for("react.suspense_list"),me=Symbol.for("react.memo"),ze=Symbol.for("react.lazy"),Ye=Symbol.for("react.activity"),nt=Symbol.for("react.memo_cache_sentinel"),$e=Symbol.iterator;function $(e){return e===null||typeof e!="object"?null:(e=$e&&e[$e]||e["@@iterator"],typeof e=="function"?e:null)}var je=Symbol.for("react.client.reference");function Ge(e){if(e==null)return null;if(typeof e=="function")return e.$$typeof===je?null:e.displayName||e.name||null;if(typeof e=="string")return e;switch(e){case ie:return"Fragment";case De:return"Profiler";case ye:return"StrictMode";case V:return"Suspense";case J:return"SuspenseList";case Ye:return"Activity"}if(typeof e=="object")switch(e.$$typeof){case _e:return"Portal";case be:return(e.displayName||"Context")+".Provider";case we:return(e._context.displayName||"Context")+".Consumer";case Ue:var t=e.render;return e=e.displayName,e||(e=t.displayName||t.name||"",e=e!==""?"ForwardRef("+e+")":"ForwardRef"),e;case me:return t=e.displayName||null,t!==null?t:Ge(e.type)||"Memo";case ze:t=e._payload,e=e._init;try{return Ge(e(t))}catch{}}return null}var Se=Array.isArray,A=s.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE,q=m.__DOM_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE,Y={pending:!1,data:null,method:null,action:null},ce=[],d=-1;function T(e){return{current:e}}function D(e){0>d||(e.current=ce[d],ce[d]=null,d--)}function M(e,t){d++,ce[d]=e.current,e.current=t}var k=T(null),F=T(null),Z=T(null),lt=T(null);function pe(e,t){switch(M(Z,t),M(F,e),M(k,null),t.nodeType){case 9:case 11:e=(e=t.documentElement)&&(e=e.namespaceURI)?td(e):0;break;default:if(e=t.tagName,t=t.namespaceURI)t=td(t),e=ad(t,e);else switch(e){case"svg":e=1;break;case"math":e=2;break;default:e=0}}D(k),M(k,e)}function Jt(){D(k),D(F),D(Z)}function Ii(e){e.memoizedState!==null&&M(lt,e);var t=k.current,a=ad(t,e.type);t!==a&&(M(F,e),M(k,a))}function Dl(e){F.current===e&&(D(k),D(F)),lt.current===e&&(D(lt),vl._currentValue=Y)}var ec=Object.prototype.hasOwnProperty,tc=u.unstable_scheduleCallback,ac=u.unstable_cancelCallback,ph=u.unstable_shouldYield,gh=u.unstable_requestPaint,wt=u.unstable_now,vh=u.unstable_getCurrentPriorityLevel,Co=u.unstable_ImmediatePriority,qo=u.unstable_UserBlockingPriority,Ml=u.unstable_NormalPriority,yh=u.unstable_LowPriority,jo=u.unstable_IdlePriority,bh=u.log,Sh=u.unstable_setDisableYieldValue,wn=null,it=null;function $t(e){if(typeof bh=="function"&&Sh(e),it&&typeof it.setStrictMode=="function")try{it.setStrictMode(wn,e)}catch{}}var ct=Math.clz32?Math.clz32:Eh,xh=Math.log,Th=Math.LN2;function Eh(e){return e>>>=0,e===0?32:31-(xh(e)/Th|0)|0}var Ol=256,Ul=4194304;function ya(e){var t=e&42;if(t!==0)return t;switch(e&-e){case 1:return 1;case 2:return 2;case 4:return 4;case 8:return 8;case 16:return 16;case 32:return 32;case 64:return 64;case 128:return 128;case 256:case 512:case 1024:case 2048:case 4096:case 8192:case 16384:case 32768:case 65536:case 131072:case 262144:case 524288:case 1048576:case 2097152:return e&4194048;case 4194304:case 8388608:case 16777216:case 33554432:return e&62914560;case 67108864:return 67108864;case 134217728:return 134217728;case 268435456:return 268435456;case 536870912:return 536870912;case 1073741824:return 0;default:return e}}function Cl(e,t,a){var n=e.pendingLanes;if(n===0)return 0;var l=0,i=e.suspendedLanes,c=e.pingedLanes;e=e.warmLanes;var o=n&134217727;return o!==0?(n=o&~i,n!==0?l=ya(n):(c&=o,c!==0?l=ya(c):a||(a=o&~e,a!==0&&(l=ya(a))))):(o=n&~i,o!==0?l=ya(o):c!==0?l=ya(c):a||(a=n&~e,a!==0&&(l=ya(a)))),l===0?0:t!==0&&t!==l&&(t&i)===0&&(i=l&-l,a=t&-t,i>=a||i===32&&(a&4194048)!==0)?t:l}function zn(e,t){return(e.pendingLanes&~(e.suspendedLanes&~e.pingedLanes)&t)===0}function Ah(e,t){switch(e){case 1:case 2:case 4:case 8:case 64:return t+250;case 16:case 32:case 128:case 256:case 512:case 1024:case 2048:case 4096:case 8192:case 16384:case 32768:case 65536:case 131072:case 262144:case 524288:case 1048576:case 2097152:return t+5e3;case 4194304:case 8388608:case 16777216:case 33554432:return-1;case 67108864:case 134217728:case 268435456:case 536870912:case 1073741824:return-1;default:return-1}}function ko(){var e=Ol;return Ol<<=1,(Ol&4194048)===0&&(Ol=256),e}function Ho(){var e=Ul;return Ul<<=1,(Ul&62914560)===0&&(Ul=4194304),e}function nc(e){for(var t=[],a=0;31>a;a++)t.push(e);return t}function Rn(e,t){e.pendingLanes|=t,t!==268435456&&(e.suspendedLanes=0,e.pingedLanes=0,e.warmLanes=0)}function wh(e,t,a,n,l,i){var c=e.pendingLanes;e.pendingLanes=a,e.suspendedLanes=0,e.pingedLanes=0,e.warmLanes=0,e.expiredLanes&=a,e.entangledLanes&=a,e.errorRecoveryDisabledLanes&=a,e.shellSuspendCounter=0;var o=e.entanglements,f=e.expirationTimes,y=e.hiddenUpdates;for(a=c&~a;0<a;){var w=31-ct(a),N=1<<w;o[w]=0,f[w]=-1;var b=y[w];if(b!==null)for(y[w]=null,w=0;w<b.length;w++){var S=b[w];S!==null&&(S.lane&=-536870913)}a&=~N}n!==0&&Bo(e,n,0),i!==0&&l===0&&e.tag!==0&&(e.suspendedLanes|=i&~(c&~t))}function Bo(e,t,a){e.pendingLanes|=t,e.suspendedLanes&=~t;var n=31-ct(t);e.entangledLanes|=t,e.entanglements[n]=e.entanglements[n]|1073741824|a&4194090}function Lo(e,t){var a=e.entangledLanes|=t;for(e=e.entanglements;a;){var n=31-ct(a),l=1<<n;l&t|e[n]&t&&(e[n]|=t),a&=~l}}function lc(e){switch(e){case 2:e=1;break;case 8:e=4;break;case 32:e=16;break;case 256:case 512:case 1024:case 2048:case 4096:case 8192:case 16384:case 32768:case 65536:case 131072:case 262144:case 524288:case 1048576:case 2097152:case 4194304:case 8388608:case 16777216:case 33554432:e=128;break;case 268435456:e=134217728;break;default:e=0}return e}function ic(e){return e&=-e,2<e?8<e?(e&134217727)!==0?32:268435456:8:2}function Yo(){var e=q.p;return e!==0?e:(e=window.event,e===void 0?32:Sd(e.type))}function zh(e,t){var a=q.p;try{return q.p=e,t()}finally{q.p=a}}var Wt=Math.random().toString(36).slice(2),Ve="__reactFiber$"+Wt,Fe="__reactProps$"+Wt,Ha="__reactContainer$"+Wt,cc="__reactEvents$"+Wt,Rh="__reactListeners$"+Wt,Nh="__reactHandles$"+Wt,Go="__reactResources$"+Wt,Nn="__reactMarker$"+Wt;function uc(e){delete e[Ve],delete e[Fe],delete e[cc],delete e[Rh],delete e[Nh]}function Ba(e){var t=e[Ve];if(t)return t;for(var a=e.parentNode;a;){if(t=a[Ha]||a[Ve]){if(a=t.alternate,t.child!==null||a!==null&&a.child!==null)for(e=cd(e);e!==null;){if(a=e[Ve])return a;e=cd(e)}return t}e=a,a=e.parentNode}return null}function La(e){if(e=e[Ve]||e[Ha]){var t=e.tag;if(t===5||t===6||t===13||t===26||t===27||t===3)return e}return null}function Dn(e){var t=e.tag;if(t===5||t===26||t===27||t===6)return e.stateNode;throw Error(r(33))}function Ya(e){var t=e[Go];return t||(t=e[Go]={hoistableStyles:new Map,hoistableScripts:new Map}),t}function ke(e){e[Nn]=!0}var Qo=new Set,Xo={};function ba(e,t){Ga(e,t),Ga(e+"Capture",t)}function Ga(e,t){for(Xo[e]=t,e=0;e<t.length;e++)Qo.add(t[e])}var Dh=RegExp("^[:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD][:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040]*$"),Zo={},Vo={};function Mh(e){return ec.call(Vo,e)?!0:ec.call(Zo,e)?!1:Dh.test(e)?Vo[e]=!0:(Zo[e]=!0,!1)}function ql(e,t,a){if(Mh(t))if(a===null)e.removeAttribute(t);else{switch(typeof a){case"undefined":case"function":case"symbol":e.removeAttribute(t);return;case"boolean":var n=t.toLowerCase().slice(0,5);if(n!=="data-"&&n!=="aria-"){e.removeAttribute(t);return}}e.setAttribute(t,""+a)}}function jl(e,t,a){if(a===null)e.removeAttribute(t);else{switch(typeof a){case"undefined":case"function":case"symbol":case"boolean":e.removeAttribute(t);return}e.setAttribute(t,""+a)}}function Ut(e,t,a,n){if(n===null)e.removeAttribute(a);else{switch(typeof n){case"undefined":case"function":case"symbol":case"boolean":e.removeAttribute(a);return}e.setAttributeNS(t,a,""+n)}}var oc,Ko;function Qa(e){if(oc===void 0)try{throw Error()}catch(a){var t=a.stack.trim().match(/\n( *(at )?)/);oc=t&&t[1]||"",Ko=-1<a.stack.indexOf(`
    at`)?" (<anonymous>)":-1<a.stack.indexOf("@")?"@unknown:0:0":""}return`
`+oc+e+Ko}var sc=!1;function rc(e,t){if(!e||sc)return"";sc=!0;var a=Error.prepareStackTrace;Error.prepareStackTrace=void 0;try{var n={DetermineComponentFrameRoot:function(){try{if(t){var N=function(){throw Error()};if(Object.defineProperty(N.prototype,"props",{set:function(){throw Error()}}),typeof Reflect=="object"&&Reflect.construct){try{Reflect.construct(N,[])}catch(S){var b=S}Reflect.construct(e,[],N)}else{try{N.call()}catch(S){b=S}e.call(N.prototype)}}else{try{throw Error()}catch(S){b=S}(N=e())&&typeof N.catch=="function"&&N.catch(function(){})}}catch(S){if(S&&b&&typeof S.stack=="string")return[S.stack,b.stack]}return[null,null]}};n.DetermineComponentFrameRoot.displayName="DetermineComponentFrameRoot";var l=Object.getOwnPropertyDescriptor(n.DetermineComponentFrameRoot,"name");l&&l.configurable&&Object.defineProperty(n.DetermineComponentFrameRoot,"name",{value:"DetermineComponentFrameRoot"});var i=n.DetermineComponentFrameRoot(),c=i[0],o=i[1];if(c&&o){var f=c.split(`
`),y=o.split(`
`);for(l=n=0;n<f.length&&!f[n].includes("DetermineComponentFrameRoot");)n++;for(;l<y.length&&!y[l].includes("DetermineComponentFrameRoot");)l++;if(n===f.length||l===y.length)for(n=f.length-1,l=y.length-1;1<=n&&0<=l&&f[n]!==y[l];)l--;for(;1<=n&&0<=l;n--,l--)if(f[n]!==y[l]){if(n!==1||l!==1)do if(n--,l--,0>l||f[n]!==y[l]){var w=`
`+f[n].replace(" at new "," at ");return e.displayName&&w.includes("<anonymous>")&&(w=w.replace("<anonymous>",e.displayName)),w}while(1<=n&&0<=l);break}}}finally{sc=!1,Error.prepareStackTrace=a}return(a=e?e.displayName||e.name:"")?Qa(a):""}function Oh(e){switch(e.tag){case 26:case 27:case 5:return Qa(e.type);case 16:return Qa("Lazy");case 13:return Qa("Suspense");case 19:return Qa("SuspenseList");case 0:case 15:return rc(e.type,!1);case 11:return rc(e.type.render,!1);case 1:return rc(e.type,!0);case 31:return Qa("Activity");default:return""}}function Jo(e){try{var t="";do t+=Oh(e),e=e.return;while(e);return t}catch(a){return`
Error generating stack: `+a.message+`
`+a.stack}}function mt(e){switch(typeof e){case"bigint":case"boolean":case"number":case"string":case"undefined":return e;case"object":return e;default:return""}}function $o(e){var t=e.type;return(e=e.nodeName)&&e.toLowerCase()==="input"&&(t==="checkbox"||t==="radio")}function Uh(e){var t=$o(e)?"checked":"value",a=Object.getOwnPropertyDescriptor(e.constructor.prototype,t),n=""+e[t];if(!e.hasOwnProperty(t)&&typeof a<"u"&&typeof a.get=="function"&&typeof a.set=="function"){var l=a.get,i=a.set;return Object.defineProperty(e,t,{configurable:!0,get:function(){return l.call(this)},set:function(c){n=""+c,i.call(this,c)}}),Object.defineProperty(e,t,{enumerable:a.enumerable}),{getValue:function(){return n},setValue:function(c){n=""+c},stopTracking:function(){e._valueTracker=null,delete e[t]}}}}function kl(e){e._valueTracker||(e._valueTracker=Uh(e))}function Wo(e){if(!e)return!1;var t=e._valueTracker;if(!t)return!0;var a=t.getValue(),n="";return e&&(n=$o(e)?e.checked?"true":"false":e.value),e=n,e!==a?(t.setValue(e),!0):!1}function Hl(e){if(e=e||(typeof document<"u"?document:void 0),typeof e>"u")return null;try{return e.activeElement||e.body}catch{return e.body}}var Ch=/[\n"\\]/g;function _t(e){return e.replace(Ch,function(t){return"\\"+t.charCodeAt(0).toString(16)+" "})}function fc(e,t,a,n,l,i,c,o){e.name="",c!=null&&typeof c!="function"&&typeof c!="symbol"&&typeof c!="boolean"?e.type=c:e.removeAttribute("type"),t!=null?c==="number"?(t===0&&e.value===""||e.value!=t)&&(e.value=""+mt(t)):e.value!==""+mt(t)&&(e.value=""+mt(t)):c!=="submit"&&c!=="reset"||e.removeAttribute("value"),t!=null?dc(e,c,mt(t)):a!=null?dc(e,c,mt(a)):n!=null&&e.removeAttribute("value"),l==null&&i!=null&&(e.defaultChecked=!!i),l!=null&&(e.checked=l&&typeof l!="function"&&typeof l!="symbol"),o!=null&&typeof o!="function"&&typeof o!="symbol"&&typeof o!="boolean"?e.name=""+mt(o):e.removeAttribute("name")}function Fo(e,t,a,n,l,i,c,o){if(i!=null&&typeof i!="function"&&typeof i!="symbol"&&typeof i!="boolean"&&(e.type=i),t!=null||a!=null){if(!(i!=="submit"&&i!=="reset"||t!=null))return;a=a!=null?""+mt(a):"",t=t!=null?""+mt(t):a,o||t===e.value||(e.value=t),e.defaultValue=t}n=n??l,n=typeof n!="function"&&typeof n!="symbol"&&!!n,e.checked=o?e.checked:!!n,e.defaultChecked=!!n,c!=null&&typeof c!="function"&&typeof c!="symbol"&&typeof c!="boolean"&&(e.name=c)}function dc(e,t,a){t==="number"&&Hl(e.ownerDocument)===e||e.defaultValue===""+a||(e.defaultValue=""+a)}function Xa(e,t,a,n){if(e=e.options,t){t={};for(var l=0;l<a.length;l++)t["$"+a[l]]=!0;for(a=0;a<e.length;a++)l=t.hasOwnProperty("$"+e[a].value),e[a].selected!==l&&(e[a].selected=l),l&&n&&(e[a].defaultSelected=!0)}else{for(a=""+mt(a),t=null,l=0;l<e.length;l++){if(e[l].value===a){e[l].selected=!0,n&&(e[l].defaultSelected=!0);return}t!==null||e[l].disabled||(t=e[l])}t!==null&&(t.selected=!0)}}function Po(e,t,a){if(t!=null&&(t=""+mt(t),t!==e.value&&(e.value=t),a==null)){e.defaultValue!==t&&(e.defaultValue=t);return}e.defaultValue=a!=null?""+mt(a):""}function Io(e,t,a,n){if(t==null){if(n!=null){if(a!=null)throw Error(r(92));if(Se(n)){if(1<n.length)throw Error(r(93));n=n[0]}a=n}a==null&&(a=""),t=a}a=mt(t),e.defaultValue=a,n=e.textContent,n===a&&n!==""&&n!==null&&(e.value=n)}function Za(e,t){if(t){var a=e.firstChild;if(a&&a===e.lastChild&&a.nodeType===3){a.nodeValue=t;return}}e.textContent=t}var qh=new Set("animationIterationCount aspectRatio borderImageOutset borderImageSlice borderImageWidth boxFlex boxFlexGroup boxOrdinalGroup columnCount columns flex flexGrow flexPositive flexShrink flexNegative flexOrder gridArea gridRow gridRowEnd gridRowSpan gridRowStart gridColumn gridColumnEnd gridColumnSpan gridColumnStart fontWeight lineClamp lineHeight opacity order orphans scale tabSize widows zIndex zoom fillOpacity floodOpacity stopOpacity strokeDasharray strokeDashoffset strokeMiterlimit strokeOpacity strokeWidth MozAnimationIterationCount MozBoxFlex MozBoxFlexGroup MozLineClamp msAnimationIterationCount msFlex msZoom msFlexGrow msFlexNegative msFlexOrder msFlexPositive msFlexShrink msGridColumn msGridColumnSpan msGridRow msGridRowSpan WebkitAnimationIterationCount WebkitBoxFlex WebKitBoxFlexGroup WebkitBoxOrdinalGroup WebkitColumnCount WebkitColumns WebkitFlex WebkitFlexGrow WebkitFlexPositive WebkitFlexShrink WebkitLineClamp".split(" "));function es(e,t,a){var n=t.indexOf("--")===0;a==null||typeof a=="boolean"||a===""?n?e.setProperty(t,""):t==="float"?e.cssFloat="":e[t]="":n?e.setProperty(t,a):typeof a!="number"||a===0||qh.has(t)?t==="float"?e.cssFloat=a:e[t]=(""+a).trim():e[t]=a+"px"}function ts(e,t,a){if(t!=null&&typeof t!="object")throw Error(r(62));if(e=e.style,a!=null){for(var n in a)!a.hasOwnProperty(n)||t!=null&&t.hasOwnProperty(n)||(n.indexOf("--")===0?e.setProperty(n,""):n==="float"?e.cssFloat="":e[n]="");for(var l in t)n=t[l],t.hasOwnProperty(l)&&a[l]!==n&&es(e,l,n)}else for(var i in t)t.hasOwnProperty(i)&&es(e,i,t[i])}function hc(e){if(e.indexOf("-")===-1)return!1;switch(e){case"annotation-xml":case"color-profile":case"font-face":case"font-face-src":case"font-face-uri":case"font-face-format":case"font-face-name":case"missing-glyph":return!1;default:return!0}}var jh=new Map([["acceptCharset","accept-charset"],["htmlFor","for"],["httpEquiv","http-equiv"],["crossOrigin","crossorigin"],["accentHeight","accent-height"],["alignmentBaseline","alignment-baseline"],["arabicForm","arabic-form"],["baselineShift","baseline-shift"],["capHeight","cap-height"],["clipPath","clip-path"],["clipRule","clip-rule"],["colorInterpolation","color-interpolation"],["colorInterpolationFilters","color-interpolation-filters"],["colorProfile","color-profile"],["colorRendering","color-rendering"],["dominantBaseline","dominant-baseline"],["enableBackground","enable-background"],["fillOpacity","fill-opacity"],["fillRule","fill-rule"],["floodColor","flood-color"],["floodOpacity","flood-opacity"],["fontFamily","font-family"],["fontSize","font-size"],["fontSizeAdjust","font-size-adjust"],["fontStretch","font-stretch"],["fontStyle","font-style"],["fontVariant","font-variant"],["fontWeight","font-weight"],["glyphName","glyph-name"],["glyphOrientationHorizontal","glyph-orientation-horizontal"],["glyphOrientationVertical","glyph-orientation-vertical"],["horizAdvX","horiz-adv-x"],["horizOriginX","horiz-origin-x"],["imageRendering","image-rendering"],["letterSpacing","letter-spacing"],["lightingColor","lighting-color"],["markerEnd","marker-end"],["markerMid","marker-mid"],["markerStart","marker-start"],["overlinePosition","overline-position"],["overlineThickness","overline-thickness"],["paintOrder","paint-order"],["panose-1","panose-1"],["pointerEvents","pointer-events"],["renderingIntent","rendering-intent"],["shapeRendering","shape-rendering"],["stopColor","stop-color"],["stopOpacity","stop-opacity"],["strikethroughPosition","strikethrough-position"],["strikethroughThickness","strikethrough-thickness"],["strokeDasharray","stroke-dasharray"],["strokeDashoffset","stroke-dashoffset"],["strokeLinecap","stroke-linecap"],["strokeLinejoin","stroke-linejoin"],["strokeMiterlimit","stroke-miterlimit"],["strokeOpacity","stroke-opacity"],["strokeWidth","stroke-width"],["textAnchor","text-anchor"],["textDecoration","text-decoration"],["textRendering","text-rendering"],["transformOrigin","transform-origin"],["underlinePosition","underline-position"],["underlineThickness","underline-thickness"],["unicodeBidi","unicode-bidi"],["unicodeRange","unicode-range"],["unitsPerEm","units-per-em"],["vAlphabetic","v-alphabetic"],["vHanging","v-hanging"],["vIdeographic","v-ideographic"],["vMathematical","v-mathematical"],["vectorEffect","vector-effect"],["vertAdvY","vert-adv-y"],["vertOriginX","vert-origin-x"],["vertOriginY","vert-origin-y"],["wordSpacing","word-spacing"],["writingMode","writing-mode"],["xmlnsXlink","xmlns:xlink"],["xHeight","x-height"]]),kh=/^[\u0000-\u001F ]*j[\r\n\t]*a[\r\n\t]*v[\r\n\t]*a[\r\n\t]*s[\r\n\t]*c[\r\n\t]*r[\r\n\t]*i[\r\n\t]*p[\r\n\t]*t[\r\n\t]*:/i;function Bl(e){return kh.test(""+e)?"javascript:throw new Error('React has blocked a javascript: URL as a security precaution.')":e}var mc=null;function _c(e){return e=e.target||e.srcElement||window,e.correspondingUseElement&&(e=e.correspondingUseElement),e.nodeType===3?e.parentNode:e}var Va=null,Ka=null;function as(e){var t=La(e);if(t&&(e=t.stateNode)){var a=e[Fe]||null;e:switch(e=t.stateNode,t.type){case"input":if(fc(e,a.value,a.defaultValue,a.defaultValue,a.checked,a.defaultChecked,a.type,a.name),t=a.name,a.type==="radio"&&t!=null){for(a=e;a.parentNode;)a=a.parentNode;for(a=a.querySelectorAll('input[name="'+_t(""+t)+'"][type="radio"]'),t=0;t<a.length;t++){var n=a[t];if(n!==e&&n.form===e.form){var l=n[Fe]||null;if(!l)throw Error(r(90));fc(n,l.value,l.defaultValue,l.defaultValue,l.checked,l.defaultChecked,l.type,l.name)}}for(t=0;t<a.length;t++)n=a[t],n.form===e.form&&Wo(n)}break e;case"textarea":Po(e,a.value,a.defaultValue);break e;case"select":t=a.value,t!=null&&Xa(e,!!a.multiple,t,!1)}}}var pc=!1;function ns(e,t,a){if(pc)return e(t,a);pc=!0;try{var n=e(t);return n}finally{if(pc=!1,(Va!==null||Ka!==null)&&(Ei(),Va&&(t=Va,e=Ka,Ka=Va=null,as(t),e)))for(t=0;t<e.length;t++)as(e[t])}}function Mn(e,t){var a=e.stateNode;if(a===null)return null;var n=a[Fe]||null;if(n===null)return null;a=n[t];e:switch(t){case"onClick":case"onClickCapture":case"onDoubleClick":case"onDoubleClickCapture":case"onMouseDown":case"onMouseDownCapture":case"onMouseMove":case"onMouseMoveCapture":case"onMouseUp":case"onMouseUpCapture":case"onMouseEnter":(n=!n.disabled)||(e=e.type,n=!(e==="button"||e==="input"||e==="select"||e==="textarea")),e=!n;break e;default:e=!1}if(e)return null;if(a&&typeof a!="function")throw Error(r(231,t,typeof a));return a}var Ct=!(typeof window>"u"||typeof window.document>"u"||typeof window.document.createElement>"u"),gc=!1;if(Ct)try{var On={};Object.defineProperty(On,"passive",{get:function(){gc=!0}}),window.addEventListener("test",On,On),window.removeEventListener("test",On,On)}catch{gc=!1}var Ft=null,vc=null,Ll=null;function ls(){if(Ll)return Ll;var e,t=vc,a=t.length,n,l="value"in Ft?Ft.value:Ft.textContent,i=l.length;for(e=0;e<a&&t[e]===l[e];e++);var c=a-e;for(n=1;n<=c&&t[a-n]===l[i-n];n++);return Ll=l.slice(e,1<n?1-n:void 0)}function Yl(e){var t=e.keyCode;return"charCode"in e?(e=e.charCode,e===0&&t===13&&(e=13)):e=t,e===10&&(e=13),32<=e||e===13?e:0}function Gl(){return!0}function is(){return!1}function Pe(e){function t(a,n,l,i,c){this._reactName=a,this._targetInst=l,this.type=n,this.nativeEvent=i,this.target=c,this.currentTarget=null;for(var o in e)e.hasOwnProperty(o)&&(a=e[o],this[o]=a?a(i):i[o]);return this.isDefaultPrevented=(i.defaultPrevented!=null?i.defaultPrevented:i.returnValue===!1)?Gl:is,this.isPropagationStopped=is,this}return O(t.prototype,{preventDefault:function(){this.defaultPrevented=!0;var a=this.nativeEvent;a&&(a.preventDefault?a.preventDefault():typeof a.returnValue!="unknown"&&(a.returnValue=!1),this.isDefaultPrevented=Gl)},stopPropagation:function(){var a=this.nativeEvent;a&&(a.stopPropagation?a.stopPropagation():typeof a.cancelBubble!="unknown"&&(a.cancelBubble=!0),this.isPropagationStopped=Gl)},persist:function(){},isPersistent:Gl}),t}var Sa={eventPhase:0,bubbles:0,cancelable:0,timeStamp:function(e){return e.timeStamp||Date.now()},defaultPrevented:0,isTrusted:0},Ql=Pe(Sa),Un=O({},Sa,{view:0,detail:0}),Hh=Pe(Un),yc,bc,Cn,Xl=O({},Un,{screenX:0,screenY:0,clientX:0,clientY:0,pageX:0,pageY:0,ctrlKey:0,shiftKey:0,altKey:0,metaKey:0,getModifierState:xc,button:0,buttons:0,relatedTarget:function(e){return e.relatedTarget===void 0?e.fromElement===e.srcElement?e.toElement:e.fromElement:e.relatedTarget},movementX:function(e){return"movementX"in e?e.movementX:(e!==Cn&&(Cn&&e.type==="mousemove"?(yc=e.screenX-Cn.screenX,bc=e.screenY-Cn.screenY):bc=yc=0,Cn=e),yc)},movementY:function(e){return"movementY"in e?e.movementY:bc}}),cs=Pe(Xl),Bh=O({},Xl,{dataTransfer:0}),Lh=Pe(Bh),Yh=O({},Un,{relatedTarget:0}),Sc=Pe(Yh),Gh=O({},Sa,{animationName:0,elapsedTime:0,pseudoElement:0}),Qh=Pe(Gh),Xh=O({},Sa,{clipboardData:function(e){return"clipboardData"in e?e.clipboardData:window.clipboardData}}),Zh=Pe(Xh),Vh=O({},Sa,{data:0}),us=Pe(Vh),Kh={Esc:"Escape",Spacebar:" ",Left:"ArrowLeft",Up:"ArrowUp",Right:"ArrowRight",Down:"ArrowDown",Del:"Delete",Win:"OS",Menu:"ContextMenu",Apps:"ContextMenu",Scroll:"ScrollLock",MozPrintableKey:"Unidentified"},Jh={8:"Backspace",9:"Tab",12:"Clear",13:"Enter",16:"Shift",17:"Control",18:"Alt",19:"Pause",20:"CapsLock",27:"Escape",32:" ",33:"PageUp",34:"PageDown",35:"End",36:"Home",37:"ArrowLeft",38:"ArrowUp",39:"ArrowRight",40:"ArrowDown",45:"Insert",46:"Delete",112:"F1",113:"F2",114:"F3",115:"F4",116:"F5",117:"F6",118:"F7",119:"F8",120:"F9",121:"F10",122:"F11",123:"F12",144:"NumLock",145:"ScrollLock",224:"Meta"},$h={Alt:"altKey",Control:"ctrlKey",Meta:"metaKey",Shift:"shiftKey"};function Wh(e){var t=this.nativeEvent;return t.getModifierState?t.getModifierState(e):(e=$h[e])?!!t[e]:!1}function xc(){return Wh}var Fh=O({},Un,{key:function(e){if(e.key){var t=Kh[e.key]||e.key;if(t!=="Unidentified")return t}return e.type==="keypress"?(e=Yl(e),e===13?"Enter":String.fromCharCode(e)):e.type==="keydown"||e.type==="keyup"?Jh[e.keyCode]||"Unidentified":""},code:0,location:0,ctrlKey:0,shiftKey:0,altKey:0,metaKey:0,repeat:0,locale:0,getModifierState:xc,charCode:function(e){return e.type==="keypress"?Yl(e):0},keyCode:function(e){return e.type==="keydown"||e.type==="keyup"?e.keyCode:0},which:function(e){return e.type==="keypress"?Yl(e):e.type==="keydown"||e.type==="keyup"?e.keyCode:0}}),Ph=Pe(Fh),Ih=O({},Xl,{pointerId:0,width:0,height:0,pressure:0,tangentialPressure:0,tiltX:0,tiltY:0,twist:0,pointerType:0,isPrimary:0}),os=Pe(Ih),em=O({},Un,{touches:0,targetTouches:0,changedTouches:0,altKey:0,metaKey:0,ctrlKey:0,shiftKey:0,getModifierState:xc}),tm=Pe(em),am=O({},Sa,{propertyName:0,elapsedTime:0,pseudoElement:0}),nm=Pe(am),lm=O({},Xl,{deltaX:function(e){return"deltaX"in e?e.deltaX:"wheelDeltaX"in e?-e.wheelDeltaX:0},deltaY:function(e){return"deltaY"in e?e.deltaY:"wheelDeltaY"in e?-e.wheelDeltaY:"wheelDelta"in e?-e.wheelDelta:0},deltaZ:0,deltaMode:0}),im=Pe(lm),cm=O({},Sa,{newState:0,oldState:0}),um=Pe(cm),om=[9,13,27,32],Tc=Ct&&"CompositionEvent"in window,qn=null;Ct&&"documentMode"in document&&(qn=document.documentMode);var sm=Ct&&"TextEvent"in window&&!qn,ss=Ct&&(!Tc||qn&&8<qn&&11>=qn),rs=" ",fs=!1;function ds(e,t){switch(e){case"keyup":return om.indexOf(t.keyCode)!==-1;case"keydown":return t.keyCode!==229;case"keypress":case"mousedown":case"focusout":return!0;default:return!1}}function hs(e){return e=e.detail,typeof e=="object"&&"data"in e?e.data:null}var Ja=!1;function rm(e,t){switch(e){case"compositionend":return hs(t);case"keypress":return t.which!==32?null:(fs=!0,rs);case"textInput":return e=t.data,e===rs&&fs?null:e;default:return null}}function fm(e,t){if(Ja)return e==="compositionend"||!Tc&&ds(e,t)?(e=ls(),Ll=vc=Ft=null,Ja=!1,e):null;switch(e){case"paste":return null;case"keypress":if(!(t.ctrlKey||t.altKey||t.metaKey)||t.ctrlKey&&t.altKey){if(t.char&&1<t.char.length)return t.char;if(t.which)return String.fromCharCode(t.which)}return null;case"compositionend":return ss&&t.locale!=="ko"?null:t.data;default:return null}}var dm={color:!0,date:!0,datetime:!0,"datetime-local":!0,email:!0,month:!0,number:!0,password:!0,range:!0,search:!0,tel:!0,text:!0,time:!0,url:!0,week:!0};function ms(e){var t=e&&e.nodeName&&e.nodeName.toLowerCase();return t==="input"?!!dm[e.type]:t==="textarea"}function _s(e,t,a,n){Va?Ka?Ka.push(n):Ka=[n]:Va=n,t=Di(t,"onChange"),0<t.length&&(a=new Ql("onChange","change",null,a,n),e.push({event:a,listeners:t}))}var jn=null,kn=null;function hm(e){Wf(e,0)}function Zl(e){var t=Dn(e);if(Wo(t))return e}function ps(e,t){if(e==="change")return t}var gs=!1;if(Ct){var Ec;if(Ct){var Ac="oninput"in document;if(!Ac){var vs=document.createElement("div");vs.setAttribute("oninput","return;"),Ac=typeof vs.oninput=="function"}Ec=Ac}else Ec=!1;gs=Ec&&(!document.documentMode||9<document.documentMode)}function ys(){jn&&(jn.detachEvent("onpropertychange",bs),kn=jn=null)}function bs(e){if(e.propertyName==="value"&&Zl(kn)){var t=[];_s(t,kn,e,_c(e)),ns(hm,t)}}function mm(e,t,a){e==="focusin"?(ys(),jn=t,kn=a,jn.attachEvent("onpropertychange",bs)):e==="focusout"&&ys()}function _m(e){if(e==="selectionchange"||e==="keyup"||e==="keydown")return Zl(kn)}function pm(e,t){if(e==="click")return Zl(t)}function gm(e,t){if(e==="input"||e==="change")return Zl(t)}function vm(e,t){return e===t&&(e!==0||1/e===1/t)||e!==e&&t!==t}var ut=typeof Object.is=="function"?Object.is:vm;function Hn(e,t){if(ut(e,t))return!0;if(typeof e!="object"||e===null||typeof t!="object"||t===null)return!1;var a=Object.keys(e),n=Object.keys(t);if(a.length!==n.length)return!1;for(n=0;n<a.length;n++){var l=a[n];if(!ec.call(t,l)||!ut(e[l],t[l]))return!1}return!0}function Ss(e){for(;e&&e.firstChild;)e=e.firstChild;return e}function xs(e,t){var a=Ss(e);e=0;for(var n;a;){if(a.nodeType===3){if(n=e+a.textContent.length,e<=t&&n>=t)return{node:a,offset:t-e};e=n}e:{for(;a;){if(a.nextSibling){a=a.nextSibling;break e}a=a.parentNode}a=void 0}a=Ss(a)}}function Ts(e,t){return e&&t?e===t?!0:e&&e.nodeType===3?!1:t&&t.nodeType===3?Ts(e,t.parentNode):"contains"in e?e.contains(t):e.compareDocumentPosition?!!(e.compareDocumentPosition(t)&16):!1:!1}function Es(e){e=e!=null&&e.ownerDocument!=null&&e.ownerDocument.defaultView!=null?e.ownerDocument.defaultView:window;for(var t=Hl(e.document);t instanceof e.HTMLIFrameElement;){try{var a=typeof t.contentWindow.location.href=="string"}catch{a=!1}if(a)e=t.contentWindow;else break;t=Hl(e.document)}return t}function wc(e){var t=e&&e.nodeName&&e.nodeName.toLowerCase();return t&&(t==="input"&&(e.type==="text"||e.type==="search"||e.type==="tel"||e.type==="url"||e.type==="password")||t==="textarea"||e.contentEditable==="true")}var ym=Ct&&"documentMode"in document&&11>=document.documentMode,$a=null,zc=null,Bn=null,Rc=!1;function As(e,t,a){var n=a.window===a?a.document:a.nodeType===9?a:a.ownerDocument;Rc||$a==null||$a!==Hl(n)||(n=$a,"selectionStart"in n&&wc(n)?n={start:n.selectionStart,end:n.selectionEnd}:(n=(n.ownerDocument&&n.ownerDocument.defaultView||window).getSelection(),n={anchorNode:n.anchorNode,anchorOffset:n.anchorOffset,focusNode:n.focusNode,focusOffset:n.focusOffset}),Bn&&Hn(Bn,n)||(Bn=n,n=Di(zc,"onSelect"),0<n.length&&(t=new Ql("onSelect","select",null,t,a),e.push({event:t,listeners:n}),t.target=$a)))}function xa(e,t){var a={};return a[e.toLowerCase()]=t.toLowerCase(),a["Webkit"+e]="webkit"+t,a["Moz"+e]="moz"+t,a}var Wa={animationend:xa("Animation","AnimationEnd"),animationiteration:xa("Animation","AnimationIteration"),animationstart:xa("Animation","AnimationStart"),transitionrun:xa("Transition","TransitionRun"),transitionstart:xa("Transition","TransitionStart"),transitioncancel:xa("Transition","TransitionCancel"),transitionend:xa("Transition","TransitionEnd")},Nc={},ws={};Ct&&(ws=document.createElement("div").style,"AnimationEvent"in window||(delete Wa.animationend.animation,delete Wa.animationiteration.animation,delete Wa.animationstart.animation),"TransitionEvent"in window||delete Wa.transitionend.transition);function Ta(e){if(Nc[e])return Nc[e];if(!Wa[e])return e;var t=Wa[e],a;for(a in t)if(t.hasOwnProperty(a)&&a in ws)return Nc[e]=t[a];return e}var zs=Ta("animationend"),Rs=Ta("animationiteration"),Ns=Ta("animationstart"),bm=Ta("transitionrun"),Sm=Ta("transitionstart"),xm=Ta("transitioncancel"),Ds=Ta("transitionend"),Ms=new Map,Dc="abort auxClick beforeToggle cancel canPlay canPlayThrough click close contextMenu copy cut drag dragEnd dragEnter dragExit dragLeave dragOver dragStart drop durationChange emptied encrypted ended error gotPointerCapture input invalid keyDown keyPress keyUp load loadedData loadedMetadata loadStart lostPointerCapture mouseDown mouseMove mouseOut mouseOver mouseUp paste pause play playing pointerCancel pointerDown pointerMove pointerOut pointerOver pointerUp progress rateChange reset resize seeked seeking stalled submit suspend timeUpdate touchCancel touchEnd touchStart volumeChange scroll toggle touchMove waiting wheel".split(" ");Dc.push("scrollEnd");function Tt(e,t){Ms.set(e,t),ba(t,[e])}var Os=new WeakMap;function pt(e,t){if(typeof e=="object"&&e!==null){var a=Os.get(e);return a!==void 0?a:(t={value:e,source:t,stack:Jo(t)},Os.set(e,t),t)}return{value:e,source:t,stack:Jo(t)}}var gt=[],Fa=0,Mc=0;function Vl(){for(var e=Fa,t=Mc=Fa=0;t<e;){var a=gt[t];gt[t++]=null;var n=gt[t];gt[t++]=null;var l=gt[t];gt[t++]=null;var i=gt[t];if(gt[t++]=null,n!==null&&l!==null){var c=n.pending;c===null?l.next=l:(l.next=c.next,c.next=l),n.pending=l}i!==0&&Us(a,l,i)}}function Kl(e,t,a,n){gt[Fa++]=e,gt[Fa++]=t,gt[Fa++]=a,gt[Fa++]=n,Mc|=n,e.lanes|=n,e=e.alternate,e!==null&&(e.lanes|=n)}function Oc(e,t,a,n){return Kl(e,t,a,n),Jl(e)}function Pa(e,t){return Kl(e,null,null,t),Jl(e)}function Us(e,t,a){e.lanes|=a;var n=e.alternate;n!==null&&(n.lanes|=a);for(var l=!1,i=e.return;i!==null;)i.childLanes|=a,n=i.alternate,n!==null&&(n.childLanes|=a),i.tag===22&&(e=i.stateNode,e===null||e._visibility&1||(l=!0)),e=i,i=i.return;return e.tag===3?(i=e.stateNode,l&&t!==null&&(l=31-ct(a),e=i.hiddenUpdates,n=e[l],n===null?e[l]=[t]:n.push(t),t.lane=a|536870912),i):null}function Jl(e){if(50<rl)throw rl=0,Hu=null,Error(r(185));for(var t=e.return;t!==null;)e=t,t=e.return;return e.tag===3?e.stateNode:null}var Ia={};function Tm(e,t,a,n){this.tag=e,this.key=a,this.sibling=this.child=this.return=this.stateNode=this.type=this.elementType=null,this.index=0,this.refCleanup=this.ref=null,this.pendingProps=t,this.dependencies=this.memoizedState=this.updateQueue=this.memoizedProps=null,this.mode=n,this.subtreeFlags=this.flags=0,this.deletions=null,this.childLanes=this.lanes=0,this.alternate=null}function ot(e,t,a,n){return new Tm(e,t,a,n)}function Uc(e){return e=e.prototype,!(!e||!e.isReactComponent)}function qt(e,t){var a=e.alternate;return a===null?(a=ot(e.tag,t,e.key,e.mode),a.elementType=e.elementType,a.type=e.type,a.stateNode=e.stateNode,a.alternate=e,e.alternate=a):(a.pendingProps=t,a.type=e.type,a.flags=0,a.subtreeFlags=0,a.deletions=null),a.flags=e.flags&65011712,a.childLanes=e.childLanes,a.lanes=e.lanes,a.child=e.child,a.memoizedProps=e.memoizedProps,a.memoizedState=e.memoizedState,a.updateQueue=e.updateQueue,t=e.dependencies,a.dependencies=t===null?null:{lanes:t.lanes,firstContext:t.firstContext},a.sibling=e.sibling,a.index=e.index,a.ref=e.ref,a.refCleanup=e.refCleanup,a}function Cs(e,t){e.flags&=65011714;var a=e.alternate;return a===null?(e.childLanes=0,e.lanes=t,e.child=null,e.subtreeFlags=0,e.memoizedProps=null,e.memoizedState=null,e.updateQueue=null,e.dependencies=null,e.stateNode=null):(e.childLanes=a.childLanes,e.lanes=a.lanes,e.child=a.child,e.subtreeFlags=0,e.deletions=null,e.memoizedProps=a.memoizedProps,e.memoizedState=a.memoizedState,e.updateQueue=a.updateQueue,e.type=a.type,t=a.dependencies,e.dependencies=t===null?null:{lanes:t.lanes,firstContext:t.firstContext}),e}function $l(e,t,a,n,l,i){var c=0;if(n=e,typeof e=="function")Uc(e)&&(c=1);else if(typeof e=="string")c=A_(e,a,k.current)?26:e==="html"||e==="head"||e==="body"?27:5;else e:switch(e){case Ye:return e=ot(31,a,t,l),e.elementType=Ye,e.lanes=i,e;case ie:return Ea(a.children,l,i,t);case ye:c=8,l|=24;break;case De:return e=ot(12,a,t,l|2),e.elementType=De,e.lanes=i,e;case V:return e=ot(13,a,t,l),e.elementType=V,e.lanes=i,e;case J:return e=ot(19,a,t,l),e.elementType=J,e.lanes=i,e;default:if(typeof e=="object"&&e!==null)switch(e.$$typeof){case Ae:case be:c=10;break e;case we:c=9;break e;case Ue:c=11;break e;case me:c=14;break e;case ze:c=16,n=null;break e}c=29,a=Error(r(130,e===null?"null":typeof e,"")),n=null}return t=ot(c,a,t,l),t.elementType=e,t.type=n,t.lanes=i,t}function Ea(e,t,a,n){return e=ot(7,e,n,t),e.lanes=a,e}function Cc(e,t,a){return e=ot(6,e,null,t),e.lanes=a,e}function qc(e,t,a){return t=ot(4,e.children!==null?e.children:[],e.key,t),t.lanes=a,t.stateNode={containerInfo:e.containerInfo,pendingChildren:null,implementation:e.implementation},t}var en=[],tn=0,Wl=null,Fl=0,vt=[],yt=0,Aa=null,jt=1,kt="";function wa(e,t){en[tn++]=Fl,en[tn++]=Wl,Wl=e,Fl=t}function qs(e,t,a){vt[yt++]=jt,vt[yt++]=kt,vt[yt++]=Aa,Aa=e;var n=jt;e=kt;var l=32-ct(n)-1;n&=~(1<<l),a+=1;var i=32-ct(t)+l;if(30<i){var c=l-l%5;i=(n&(1<<c)-1).toString(32),n>>=c,l-=c,jt=1<<32-ct(t)+l|a<<l|n,kt=i+e}else jt=1<<i|a<<l|n,kt=e}function jc(e){e.return!==null&&(wa(e,1),qs(e,1,0))}function kc(e){for(;e===Wl;)Wl=en[--tn],en[tn]=null,Fl=en[--tn],en[tn]=null;for(;e===Aa;)Aa=vt[--yt],vt[yt]=null,kt=vt[--yt],vt[yt]=null,jt=vt[--yt],vt[yt]=null}var We=null,xe=null,le=!1,za=null,zt=!1,Hc=Error(r(519));function Ra(e){var t=Error(r(418,""));throw Gn(pt(t,e)),Hc}function js(e){var t=e.stateNode,a=e.type,n=e.memoizedProps;switch(t[Ve]=e,t[Fe]=n,a){case"dialog":te("cancel",t),te("close",t);break;case"iframe":case"object":case"embed":te("load",t);break;case"video":case"audio":for(a=0;a<dl.length;a++)te(dl[a],t);break;case"source":te("error",t);break;case"img":case"image":case"link":te("error",t),te("load",t);break;case"details":te("toggle",t);break;case"input":te("invalid",t),Fo(t,n.value,n.defaultValue,n.checked,n.defaultChecked,n.type,n.name,!0),kl(t);break;case"select":te("invalid",t);break;case"textarea":te("invalid",t),Io(t,n.value,n.defaultValue,n.children),kl(t)}a=n.children,typeof a!="string"&&typeof a!="number"&&typeof a!="bigint"||t.textContent===""+a||n.suppressHydrationWarning===!0||ed(t.textContent,a)?(n.popover!=null&&(te("beforetoggle",t),te("toggle",t)),n.onScroll!=null&&te("scroll",t),n.onScrollEnd!=null&&te("scrollend",t),n.onClick!=null&&(t.onclick=Mi),t=!0):t=!1,t||Ra(e)}function ks(e){for(We=e.return;We;)switch(We.tag){case 5:case 13:zt=!1;return;case 27:case 3:zt=!0;return;default:We=We.return}}function Ln(e){if(e!==We)return!1;if(!le)return ks(e),le=!0,!1;var t=e.tag,a;if((a=t!==3&&t!==27)&&((a=t===5)&&(a=e.type,a=!(a!=="form"&&a!=="button")||eo(e.type,e.memoizedProps)),a=!a),a&&xe&&Ra(e),ks(e),t===13){if(e=e.memoizedState,e=e!==null?e.dehydrated:null,!e)throw Error(r(317));e:{for(e=e.nextSibling,t=0;e;){if(e.nodeType===8)if(a=e.data,a==="/$"){if(t===0){xe=At(e.nextSibling);break e}t--}else a!=="$"&&a!=="$!"&&a!=="$?"||t++;e=e.nextSibling}xe=null}}else t===27?(t=xe,ha(e.type)?(e=lo,lo=null,xe=e):xe=t):xe=We?At(e.stateNode.nextSibling):null;return!0}function Yn(){xe=We=null,le=!1}function Hs(){var e=za;return e!==null&&(tt===null?tt=e:tt.push.apply(tt,e),za=null),e}function Gn(e){za===null?za=[e]:za.push(e)}var Bc=T(null),Na=null,Ht=null;function Pt(e,t,a){M(Bc,t._currentValue),t._currentValue=a}function Bt(e){e._currentValue=Bc.current,D(Bc)}function Lc(e,t,a){for(;e!==null;){var n=e.alternate;if((e.childLanes&t)!==t?(e.childLanes|=t,n!==null&&(n.childLanes|=t)):n!==null&&(n.childLanes&t)!==t&&(n.childLanes|=t),e===a)break;e=e.return}}function Yc(e,t,a,n){var l=e.child;for(l!==null&&(l.return=e);l!==null;){var i=l.dependencies;if(i!==null){var c=l.child;i=i.firstContext;e:for(;i!==null;){var o=i;i=l;for(var f=0;f<t.length;f++)if(o.context===t[f]){i.lanes|=a,o=i.alternate,o!==null&&(o.lanes|=a),Lc(i.return,a,e),n||(c=null);break e}i=o.next}}else if(l.tag===18){if(c=l.return,c===null)throw Error(r(341));c.lanes|=a,i=c.alternate,i!==null&&(i.lanes|=a),Lc(c,a,e),c=null}else c=l.child;if(c!==null)c.return=l;else for(c=l;c!==null;){if(c===e){c=null;break}if(l=c.sibling,l!==null){l.return=c.return,c=l;break}c=c.return}l=c}}function Qn(e,t,a,n){e=null;for(var l=t,i=!1;l!==null;){if(!i){if((l.flags&524288)!==0)i=!0;else if((l.flags&262144)!==0)break}if(l.tag===10){var c=l.alternate;if(c===null)throw Error(r(387));if(c=c.memoizedProps,c!==null){var o=l.type;ut(l.pendingProps.value,c.value)||(e!==null?e.push(o):e=[o])}}else if(l===lt.current){if(c=l.alternate,c===null)throw Error(r(387));c.memoizedState.memoizedState!==l.memoizedState.memoizedState&&(e!==null?e.push(vl):e=[vl])}l=l.return}e!==null&&Yc(t,e,a,n),t.flags|=262144}function Pl(e){for(e=e.firstContext;e!==null;){if(!ut(e.context._currentValue,e.memoizedValue))return!0;e=e.next}return!1}function Da(e){Na=e,Ht=null,e=e.dependencies,e!==null&&(e.firstContext=null)}function Ke(e){return Bs(Na,e)}function Il(e,t){return Na===null&&Da(e),Bs(e,t)}function Bs(e,t){var a=t._currentValue;if(t={context:t,memoizedValue:a,next:null},Ht===null){if(e===null)throw Error(r(308));Ht=t,e.dependencies={lanes:0,firstContext:t},e.flags|=524288}else Ht=Ht.next=t;return a}var Em=typeof AbortController<"u"?AbortController:function(){var e=[],t=this.signal={aborted:!1,addEventListener:function(a,n){e.push(n)}};this.abort=function(){t.aborted=!0,e.forEach(function(a){return a()})}},Am=u.unstable_scheduleCallback,wm=u.unstable_NormalPriority,Ce={$$typeof:be,Consumer:null,Provider:null,_currentValue:null,_currentValue2:null,_threadCount:0};function Gc(){return{controller:new Em,data:new Map,refCount:0}}function Xn(e){e.refCount--,e.refCount===0&&Am(wm,function(){e.controller.abort()})}var Zn=null,Qc=0,an=0,nn=null;function zm(e,t){if(Zn===null){var a=Zn=[];Qc=0,an=Zu(),nn={status:"pending",value:void 0,then:function(n){a.push(n)}}}return Qc++,t.then(Ls,Ls),t}function Ls(){if(--Qc===0&&Zn!==null){nn!==null&&(nn.status="fulfilled");var e=Zn;Zn=null,an=0,nn=null;for(var t=0;t<e.length;t++)(0,e[t])()}}function Rm(e,t){var a=[],n={status:"pending",value:null,reason:null,then:function(l){a.push(l)}};return e.then(function(){n.status="fulfilled",n.value=t;for(var l=0;l<a.length;l++)(0,a[l])(t)},function(l){for(n.status="rejected",n.reason=l,l=0;l<a.length;l++)(0,a[l])(void 0)}),n}var Ys=A.S;A.S=function(e,t){typeof t=="object"&&t!==null&&typeof t.then=="function"&&zm(e,t),Ys!==null&&Ys(e,t)};var Ma=T(null);function Xc(){var e=Ma.current;return e!==null?e:he.pooledCache}function ei(e,t){t===null?M(Ma,Ma.current):M(Ma,t.pool)}function Gs(){var e=Xc();return e===null?null:{parent:Ce._currentValue,pool:e}}var Vn=Error(r(460)),Qs=Error(r(474)),ti=Error(r(542)),Zc={then:function(){}};function Xs(e){return e=e.status,e==="fulfilled"||e==="rejected"}function ai(){}function Zs(e,t,a){switch(a=e[a],a===void 0?e.push(t):a!==t&&(t.then(ai,ai),t=a),t.status){case"fulfilled":return t.value;case"rejected":throw e=t.reason,Ks(e),e;default:if(typeof t.status=="string")t.then(ai,ai);else{if(e=he,e!==null&&100<e.shellSuspendCounter)throw Error(r(482));e=t,e.status="pending",e.then(function(n){if(t.status==="pending"){var l=t;l.status="fulfilled",l.value=n}},function(n){if(t.status==="pending"){var l=t;l.status="rejected",l.reason=n}})}switch(t.status){case"fulfilled":return t.value;case"rejected":throw e=t.reason,Ks(e),e}throw Kn=t,Vn}}var Kn=null;function Vs(){if(Kn===null)throw Error(r(459));var e=Kn;return Kn=null,e}function Ks(e){if(e===Vn||e===ti)throw Error(r(483))}var It=!1;function Vc(e){e.updateQueue={baseState:e.memoizedState,firstBaseUpdate:null,lastBaseUpdate:null,shared:{pending:null,lanes:0,hiddenCallbacks:null},callbacks:null}}function Kc(e,t){e=e.updateQueue,t.updateQueue===e&&(t.updateQueue={baseState:e.baseState,firstBaseUpdate:e.firstBaseUpdate,lastBaseUpdate:e.lastBaseUpdate,shared:e.shared,callbacks:null})}function ea(e){return{lane:e,tag:0,payload:null,callback:null,next:null}}function ta(e,t,a){var n=e.updateQueue;if(n===null)return null;if(n=n.shared,(ue&2)!==0){var l=n.pending;return l===null?t.next=t:(t.next=l.next,l.next=t),n.pending=t,t=Jl(e),Us(e,null,a),t}return Kl(e,n,t,a),Jl(e)}function Jn(e,t,a){if(t=t.updateQueue,t!==null&&(t=t.shared,(a&4194048)!==0)){var n=t.lanes;n&=e.pendingLanes,a|=n,t.lanes=a,Lo(e,a)}}function Jc(e,t){var a=e.updateQueue,n=e.alternate;if(n!==null&&(n=n.updateQueue,a===n)){var l=null,i=null;if(a=a.firstBaseUpdate,a!==null){do{var c={lane:a.lane,tag:a.tag,payload:a.payload,callback:null,next:null};i===null?l=i=c:i=i.next=c,a=a.next}while(a!==null);i===null?l=i=t:i=i.next=t}else l=i=t;a={baseState:n.baseState,firstBaseUpdate:l,lastBaseUpdate:i,shared:n.shared,callbacks:n.callbacks},e.updateQueue=a;return}e=a.lastBaseUpdate,e===null?a.firstBaseUpdate=t:e.next=t,a.lastBaseUpdate=t}var $c=!1;function $n(){if($c){var e=nn;if(e!==null)throw e}}function Wn(e,t,a,n){$c=!1;var l=e.updateQueue;It=!1;var i=l.firstBaseUpdate,c=l.lastBaseUpdate,o=l.shared.pending;if(o!==null){l.shared.pending=null;var f=o,y=f.next;f.next=null,c===null?i=y:c.next=y,c=f;var w=e.alternate;w!==null&&(w=w.updateQueue,o=w.lastBaseUpdate,o!==c&&(o===null?w.firstBaseUpdate=y:o.next=y,w.lastBaseUpdate=f))}if(i!==null){var N=l.baseState;c=0,w=y=f=null,o=i;do{var b=o.lane&-536870913,S=b!==o.lane;if(S?(ae&b)===b:(n&b)===b){b!==0&&b===an&&($c=!0),w!==null&&(w=w.next={lane:0,tag:o.tag,payload:o.payload,callback:null,next:null});e:{var X=e,G=o;b=t;var fe=a;switch(G.tag){case 1:if(X=G.payload,typeof X=="function"){N=X.call(fe,N,b);break e}N=X;break e;case 3:X.flags=X.flags&-65537|128;case 0:if(X=G.payload,b=typeof X=="function"?X.call(fe,N,b):X,b==null)break e;N=O({},N,b);break e;case 2:It=!0}}b=o.callback,b!==null&&(e.flags|=64,S&&(e.flags|=8192),S=l.callbacks,S===null?l.callbacks=[b]:S.push(b))}else S={lane:b,tag:o.tag,payload:o.payload,callback:o.callback,next:null},w===null?(y=w=S,f=N):w=w.next=S,c|=b;if(o=o.next,o===null){if(o=l.shared.pending,o===null)break;S=o,o=S.next,S.next=null,l.lastBaseUpdate=S,l.shared.pending=null}}while(!0);w===null&&(f=N),l.baseState=f,l.firstBaseUpdate=y,l.lastBaseUpdate=w,i===null&&(l.shared.lanes=0),sa|=c,e.lanes=c,e.memoizedState=N}}function Js(e,t){if(typeof e!="function")throw Error(r(191,e));e.call(t)}function $s(e,t){var a=e.callbacks;if(a!==null)for(e.callbacks=null,e=0;e<a.length;e++)Js(a[e],t)}var ln=T(null),ni=T(0);function Ws(e,t){e=Vt,M(ni,e),M(ln,t),Vt=e|t.baseLanes}function Wc(){M(ni,Vt),M(ln,ln.current)}function Fc(){Vt=ni.current,D(ln),D(ni)}var aa=0,P=null,se=null,Me=null,li=!1,cn=!1,Oa=!1,ii=0,Fn=0,un=null,Nm=0;function Re(){throw Error(r(321))}function Pc(e,t){if(t===null)return!1;for(var a=0;a<t.length&&a<e.length;a++)if(!ut(e[a],t[a]))return!1;return!0}function Ic(e,t,a,n,l,i){return aa=i,P=t,t.memoizedState=null,t.updateQueue=null,t.lanes=0,A.H=e===null||e.memoizedState===null?Ur:Cr,Oa=!1,i=a(n,l),Oa=!1,cn&&(i=Ps(t,a,n,l)),Fs(e),i}function Fs(e){A.H=fi;var t=se!==null&&se.next!==null;if(aa=0,Me=se=P=null,li=!1,Fn=0,un=null,t)throw Error(r(300));e===null||He||(e=e.dependencies,e!==null&&Pl(e)&&(He=!0))}function Ps(e,t,a,n){P=e;var l=0;do{if(cn&&(un=null),Fn=0,cn=!1,25<=l)throw Error(r(301));if(l+=1,Me=se=null,e.updateQueue!=null){var i=e.updateQueue;i.lastEffect=null,i.events=null,i.stores=null,i.memoCache!=null&&(i.memoCache.index=0)}A.H=jm,i=t(a,n)}while(cn);return i}function Dm(){var e=A.H,t=e.useState()[0];return t=typeof t.then=="function"?Pn(t):t,e=e.useState()[0],(se!==null?se.memoizedState:null)!==e&&(P.flags|=1024),t}function eu(){var e=ii!==0;return ii=0,e}function tu(e,t,a){t.updateQueue=e.updateQueue,t.flags&=-2053,e.lanes&=~a}function au(e){if(li){for(e=e.memoizedState;e!==null;){var t=e.queue;t!==null&&(t.pending=null),e=e.next}li=!1}aa=0,Me=se=P=null,cn=!1,Fn=ii=0,un=null}function Ie(){var e={memoizedState:null,baseState:null,baseQueue:null,queue:null,next:null};return Me===null?P.memoizedState=Me=e:Me=Me.next=e,Me}function Oe(){if(se===null){var e=P.alternate;e=e!==null?e.memoizedState:null}else e=se.next;var t=Me===null?P.memoizedState:Me.next;if(t!==null)Me=t,se=e;else{if(e===null)throw P.alternate===null?Error(r(467)):Error(r(310));se=e,e={memoizedState:se.memoizedState,baseState:se.baseState,baseQueue:se.baseQueue,queue:se.queue,next:null},Me===null?P.memoizedState=Me=e:Me=Me.next=e}return Me}function nu(){return{lastEffect:null,events:null,stores:null,memoCache:null}}function Pn(e){var t=Fn;return Fn+=1,un===null&&(un=[]),e=Zs(un,e,t),t=P,(Me===null?t.memoizedState:Me.next)===null&&(t=t.alternate,A.H=t===null||t.memoizedState===null?Ur:Cr),e}function ci(e){if(e!==null&&typeof e=="object"){if(typeof e.then=="function")return Pn(e);if(e.$$typeof===be)return Ke(e)}throw Error(r(438,String(e)))}function lu(e){var t=null,a=P.updateQueue;if(a!==null&&(t=a.memoCache),t==null){var n=P.alternate;n!==null&&(n=n.updateQueue,n!==null&&(n=n.memoCache,n!=null&&(t={data:n.data.map(function(l){return l.slice()}),index:0})))}if(t==null&&(t={data:[],index:0}),a===null&&(a=nu(),P.updateQueue=a),a.memoCache=t,a=t.data[t.index],a===void 0)for(a=t.data[t.index]=Array(e),n=0;n<e;n++)a[n]=nt;return t.index++,a}function Lt(e,t){return typeof t=="function"?t(e):t}function ui(e){var t=Oe();return iu(t,se,e)}function iu(e,t,a){var n=e.queue;if(n===null)throw Error(r(311));n.lastRenderedReducer=a;var l=e.baseQueue,i=n.pending;if(i!==null){if(l!==null){var c=l.next;l.next=i.next,i.next=c}t.baseQueue=l=i,n.pending=null}if(i=e.baseState,l===null)e.memoizedState=i;else{t=l.next;var o=c=null,f=null,y=t,w=!1;do{var N=y.lane&-536870913;if(N!==y.lane?(ae&N)===N:(aa&N)===N){var b=y.revertLane;if(b===0)f!==null&&(f=f.next={lane:0,revertLane:0,action:y.action,hasEagerState:y.hasEagerState,eagerState:y.eagerState,next:null}),N===an&&(w=!0);else if((aa&b)===b){y=y.next,b===an&&(w=!0);continue}else N={lane:0,revertLane:y.revertLane,action:y.action,hasEagerState:y.hasEagerState,eagerState:y.eagerState,next:null},f===null?(o=f=N,c=i):f=f.next=N,P.lanes|=b,sa|=b;N=y.action,Oa&&a(i,N),i=y.hasEagerState?y.eagerState:a(i,N)}else b={lane:N,revertLane:y.revertLane,action:y.action,hasEagerState:y.hasEagerState,eagerState:y.eagerState,next:null},f===null?(o=f=b,c=i):f=f.next=b,P.lanes|=N,sa|=N;y=y.next}while(y!==null&&y!==t);if(f===null?c=i:f.next=o,!ut(i,e.memoizedState)&&(He=!0,w&&(a=nn,a!==null)))throw a;e.memoizedState=i,e.baseState=c,e.baseQueue=f,n.lastRenderedState=i}return l===null&&(n.lanes=0),[e.memoizedState,n.dispatch]}function cu(e){var t=Oe(),a=t.queue;if(a===null)throw Error(r(311));a.lastRenderedReducer=e;var n=a.dispatch,l=a.pending,i=t.memoizedState;if(l!==null){a.pending=null;var c=l=l.next;do i=e(i,c.action),c=c.next;while(c!==l);ut(i,t.memoizedState)||(He=!0),t.memoizedState=i,t.baseQueue===null&&(t.baseState=i),a.lastRenderedState=i}return[i,n]}function Is(e,t,a){var n=P,l=Oe(),i=le;if(i){if(a===void 0)throw Error(r(407));a=a()}else a=t();var c=!ut((se||l).memoizedState,a);c&&(l.memoizedState=a,He=!0),l=l.queue;var o=ar.bind(null,n,l,e);if(In(2048,8,o,[e]),l.getSnapshot!==t||c||Me!==null&&Me.memoizedState.tag&1){if(n.flags|=2048,on(9,oi(),tr.bind(null,n,l,a,t),null),he===null)throw Error(r(349));i||(aa&124)!==0||er(n,t,a)}return a}function er(e,t,a){e.flags|=16384,e={getSnapshot:t,value:a},t=P.updateQueue,t===null?(t=nu(),P.updateQueue=t,t.stores=[e]):(a=t.stores,a===null?t.stores=[e]:a.push(e))}function tr(e,t,a,n){t.value=a,t.getSnapshot=n,nr(t)&&lr(e)}function ar(e,t,a){return a(function(){nr(t)&&lr(e)})}function nr(e){var t=e.getSnapshot;e=e.value;try{var a=t();return!ut(e,a)}catch{return!0}}function lr(e){var t=Pa(e,2);t!==null&&ht(t,e,2)}function uu(e){var t=Ie();if(typeof e=="function"){var a=e;if(e=a(),Oa){$t(!0);try{a()}finally{$t(!1)}}}return t.memoizedState=t.baseState=e,t.queue={pending:null,lanes:0,dispatch:null,lastRenderedReducer:Lt,lastRenderedState:e},t}function ir(e,t,a,n){return e.baseState=a,iu(e,se,typeof n=="function"?n:Lt)}function Mm(e,t,a,n,l){if(ri(e))throw Error(r(485));if(e=t.action,e!==null){var i={payload:l,action:e,next:null,isTransition:!0,status:"pending",value:null,reason:null,listeners:[],then:function(c){i.listeners.push(c)}};A.T!==null?a(!0):i.isTransition=!1,n(i),a=t.pending,a===null?(i.next=t.pending=i,cr(t,i)):(i.next=a.next,t.pending=a.next=i)}}function cr(e,t){var a=t.action,n=t.payload,l=e.state;if(t.isTransition){var i=A.T,c={};A.T=c;try{var o=a(l,n),f=A.S;f!==null&&f(c,o),ur(e,t,o)}catch(y){ou(e,t,y)}finally{A.T=i}}else try{i=a(l,n),ur(e,t,i)}catch(y){ou(e,t,y)}}function ur(e,t,a){a!==null&&typeof a=="object"&&typeof a.then=="function"?a.then(function(n){or(e,t,n)},function(n){return ou(e,t,n)}):or(e,t,a)}function or(e,t,a){t.status="fulfilled",t.value=a,sr(t),e.state=a,t=e.pending,t!==null&&(a=t.next,a===t?e.pending=null:(a=a.next,t.next=a,cr(e,a)))}function ou(e,t,a){var n=e.pending;if(e.pending=null,n!==null){n=n.next;do t.status="rejected",t.reason=a,sr(t),t=t.next;while(t!==n)}e.action=null}function sr(e){e=e.listeners;for(var t=0;t<e.length;t++)(0,e[t])()}function rr(e,t){return t}function fr(e,t){if(le){var a=he.formState;if(a!==null){e:{var n=P;if(le){if(xe){t:{for(var l=xe,i=zt;l.nodeType!==8;){if(!i){l=null;break t}if(l=At(l.nextSibling),l===null){l=null;break t}}i=l.data,l=i==="F!"||i==="F"?l:null}if(l){xe=At(l.nextSibling),n=l.data==="F!";break e}}Ra(n)}n=!1}n&&(t=a[0])}}return a=Ie(),a.memoizedState=a.baseState=t,n={pending:null,lanes:0,dispatch:null,lastRenderedReducer:rr,lastRenderedState:t},a.queue=n,a=Dr.bind(null,P,n),n.dispatch=a,n=uu(!1),i=hu.bind(null,P,!1,n.queue),n=Ie(),l={state:t,dispatch:null,action:e,pending:null},n.queue=l,a=Mm.bind(null,P,l,i,a),l.dispatch=a,n.memoizedState=e,[t,a,!1]}function dr(e){var t=Oe();return hr(t,se,e)}function hr(e,t,a){if(t=iu(e,t,rr)[0],e=ui(Lt)[0],typeof t=="object"&&t!==null&&typeof t.then=="function")try{var n=Pn(t)}catch(c){throw c===Vn?ti:c}else n=t;t=Oe();var l=t.queue,i=l.dispatch;return a!==t.memoizedState&&(P.flags|=2048,on(9,oi(),Om.bind(null,l,a),null)),[n,i,e]}function Om(e,t){e.action=t}function mr(e){var t=Oe(),a=se;if(a!==null)return hr(t,a,e);Oe(),t=t.memoizedState,a=Oe();var n=a.queue.dispatch;return a.memoizedState=e,[t,n,!1]}function on(e,t,a,n){return e={tag:e,create:a,deps:n,inst:t,next:null},t=P.updateQueue,t===null&&(t=nu(),P.updateQueue=t),a=t.lastEffect,a===null?t.lastEffect=e.next=e:(n=a.next,a.next=e,e.next=n,t.lastEffect=e),e}function oi(){return{destroy:void 0,resource:void 0}}function _r(){return Oe().memoizedState}function si(e,t,a,n){var l=Ie();n=n===void 0?null:n,P.flags|=e,l.memoizedState=on(1|t,oi(),a,n)}function In(e,t,a,n){var l=Oe();n=n===void 0?null:n;var i=l.memoizedState.inst;se!==null&&n!==null&&Pc(n,se.memoizedState.deps)?l.memoizedState=on(t,i,a,n):(P.flags|=e,l.memoizedState=on(1|t,i,a,n))}function pr(e,t){si(8390656,8,e,t)}function gr(e,t){In(2048,8,e,t)}function vr(e,t){return In(4,2,e,t)}function yr(e,t){return In(4,4,e,t)}function br(e,t){if(typeof t=="function"){e=e();var a=t(e);return function(){typeof a=="function"?a():t(null)}}if(t!=null)return e=e(),t.current=e,function(){t.current=null}}function Sr(e,t,a){a=a!=null?a.concat([e]):null,In(4,4,br.bind(null,t,e),a)}function su(){}function xr(e,t){var a=Oe();t=t===void 0?null:t;var n=a.memoizedState;return t!==null&&Pc(t,n[1])?n[0]:(a.memoizedState=[e,t],e)}function Tr(e,t){var a=Oe();t=t===void 0?null:t;var n=a.memoizedState;if(t!==null&&Pc(t,n[1]))return n[0];if(n=e(),Oa){$t(!0);try{e()}finally{$t(!1)}}return a.memoizedState=[n,t],n}function ru(e,t,a){return a===void 0||(aa&1073741824)!==0?e.memoizedState=t:(e.memoizedState=a,e=zf(),P.lanes|=e,sa|=e,a)}function Er(e,t,a,n){return ut(a,t)?a:ln.current!==null?(e=ru(e,a,n),ut(e,t)||(He=!0),e):(aa&42)===0?(He=!0,e.memoizedState=a):(e=zf(),P.lanes|=e,sa|=e,t)}function Ar(e,t,a,n,l){var i=q.p;q.p=i!==0&&8>i?i:8;var c=A.T,o={};A.T=o,hu(e,!1,t,a);try{var f=l(),y=A.S;if(y!==null&&y(o,f),f!==null&&typeof f=="object"&&typeof f.then=="function"){var w=Rm(f,n);el(e,t,w,dt(e))}else el(e,t,n,dt(e))}catch(N){el(e,t,{then:function(){},status:"rejected",reason:N},dt())}finally{q.p=i,A.T=c}}function Um(){}function fu(e,t,a,n){if(e.tag!==5)throw Error(r(476));var l=wr(e).queue;Ar(e,l,t,Y,a===null?Um:function(){return zr(e),a(n)})}function wr(e){var t=e.memoizedState;if(t!==null)return t;t={memoizedState:Y,baseState:Y,baseQueue:null,queue:{pending:null,lanes:0,dispatch:null,lastRenderedReducer:Lt,lastRenderedState:Y},next:null};var a={};return t.next={memoizedState:a,baseState:a,baseQueue:null,queue:{pending:null,lanes:0,dispatch:null,lastRenderedReducer:Lt,lastRenderedState:a},next:null},e.memoizedState=t,e=e.alternate,e!==null&&(e.memoizedState=t),t}function zr(e){var t=wr(e).next.queue;el(e,t,{},dt())}function du(){return Ke(vl)}function Rr(){return Oe().memoizedState}function Nr(){return Oe().memoizedState}function Cm(e){for(var t=e.return;t!==null;){switch(t.tag){case 24:case 3:var a=dt();e=ea(a);var n=ta(t,e,a);n!==null&&(ht(n,t,a),Jn(n,t,a)),t={cache:Gc()},e.payload=t;return}t=t.return}}function qm(e,t,a){var n=dt();a={lane:n,revertLane:0,action:a,hasEagerState:!1,eagerState:null,next:null},ri(e)?Mr(t,a):(a=Oc(e,t,a,n),a!==null&&(ht(a,e,n),Or(a,t,n)))}function Dr(e,t,a){var n=dt();el(e,t,a,n)}function el(e,t,a,n){var l={lane:n,revertLane:0,action:a,hasEagerState:!1,eagerState:null,next:null};if(ri(e))Mr(t,l);else{var i=e.alternate;if(e.lanes===0&&(i===null||i.lanes===0)&&(i=t.lastRenderedReducer,i!==null))try{var c=t.lastRenderedState,o=i(c,a);if(l.hasEagerState=!0,l.eagerState=o,ut(o,c))return Kl(e,t,l,0),he===null&&Vl(),!1}catch{}if(a=Oc(e,t,l,n),a!==null)return ht(a,e,n),Or(a,t,n),!0}return!1}function hu(e,t,a,n){if(n={lane:2,revertLane:Zu(),action:n,hasEagerState:!1,eagerState:null,next:null},ri(e)){if(t)throw Error(r(479))}else t=Oc(e,a,n,2),t!==null&&ht(t,e,2)}function ri(e){var t=e.alternate;return e===P||t!==null&&t===P}function Mr(e,t){cn=li=!0;var a=e.pending;a===null?t.next=t:(t.next=a.next,a.next=t),e.pending=t}function Or(e,t,a){if((a&4194048)!==0){var n=t.lanes;n&=e.pendingLanes,a|=n,t.lanes=a,Lo(e,a)}}var fi={readContext:Ke,use:ci,useCallback:Re,useContext:Re,useEffect:Re,useImperativeHandle:Re,useLayoutEffect:Re,useInsertionEffect:Re,useMemo:Re,useReducer:Re,useRef:Re,useState:Re,useDebugValue:Re,useDeferredValue:Re,useTransition:Re,useSyncExternalStore:Re,useId:Re,useHostTransitionStatus:Re,useFormState:Re,useActionState:Re,useOptimistic:Re,useMemoCache:Re,useCacheRefresh:Re},Ur={readContext:Ke,use:ci,useCallback:function(e,t){return Ie().memoizedState=[e,t===void 0?null:t],e},useContext:Ke,useEffect:pr,useImperativeHandle:function(e,t,a){a=a!=null?a.concat([e]):null,si(4194308,4,br.bind(null,t,e),a)},useLayoutEffect:function(e,t){return si(4194308,4,e,t)},useInsertionEffect:function(e,t){si(4,2,e,t)},useMemo:function(e,t){var a=Ie();t=t===void 0?null:t;var n=e();if(Oa){$t(!0);try{e()}finally{$t(!1)}}return a.memoizedState=[n,t],n},useReducer:function(e,t,a){var n=Ie();if(a!==void 0){var l=a(t);if(Oa){$t(!0);try{a(t)}finally{$t(!1)}}}else l=t;return n.memoizedState=n.baseState=l,e={pending:null,lanes:0,dispatch:null,lastRenderedReducer:e,lastRenderedState:l},n.queue=e,e=e.dispatch=qm.bind(null,P,e),[n.memoizedState,e]},useRef:function(e){var t=Ie();return e={current:e},t.memoizedState=e},useState:function(e){e=uu(e);var t=e.queue,a=Dr.bind(null,P,t);return t.dispatch=a,[e.memoizedState,a]},useDebugValue:su,useDeferredValue:function(e,t){var a=Ie();return ru(a,e,t)},useTransition:function(){var e=uu(!1);return e=Ar.bind(null,P,e.queue,!0,!1),Ie().memoizedState=e,[!1,e]},useSyncExternalStore:function(e,t,a){var n=P,l=Ie();if(le){if(a===void 0)throw Error(r(407));a=a()}else{if(a=t(),he===null)throw Error(r(349));(ae&124)!==0||er(n,t,a)}l.memoizedState=a;var i={value:a,getSnapshot:t};return l.queue=i,pr(ar.bind(null,n,i,e),[e]),n.flags|=2048,on(9,oi(),tr.bind(null,n,i,a,t),null),a},useId:function(){var e=Ie(),t=he.identifierPrefix;if(le){var a=kt,n=jt;a=(n&~(1<<32-ct(n)-1)).toString(32)+a,t="«"+t+"R"+a,a=ii++,0<a&&(t+="H"+a.toString(32)),t+="»"}else a=Nm++,t="«"+t+"r"+a.toString(32)+"»";return e.memoizedState=t},useHostTransitionStatus:du,useFormState:fr,useActionState:fr,useOptimistic:function(e){var t=Ie();t.memoizedState=t.baseState=e;var a={pending:null,lanes:0,dispatch:null,lastRenderedReducer:null,lastRenderedState:null};return t.queue=a,t=hu.bind(null,P,!0,a),a.dispatch=t,[e,t]},useMemoCache:lu,useCacheRefresh:function(){return Ie().memoizedState=Cm.bind(null,P)}},Cr={readContext:Ke,use:ci,useCallback:xr,useContext:Ke,useEffect:gr,useImperativeHandle:Sr,useInsertionEffect:vr,useLayoutEffect:yr,useMemo:Tr,useReducer:ui,useRef:_r,useState:function(){return ui(Lt)},useDebugValue:su,useDeferredValue:function(e,t){var a=Oe();return Er(a,se.memoizedState,e,t)},useTransition:function(){var e=ui(Lt)[0],t=Oe().memoizedState;return[typeof e=="boolean"?e:Pn(e),t]},useSyncExternalStore:Is,useId:Rr,useHostTransitionStatus:du,useFormState:dr,useActionState:dr,useOptimistic:function(e,t){var a=Oe();return ir(a,se,e,t)},useMemoCache:lu,useCacheRefresh:Nr},jm={readContext:Ke,use:ci,useCallback:xr,useContext:Ke,useEffect:gr,useImperativeHandle:Sr,useInsertionEffect:vr,useLayoutEffect:yr,useMemo:Tr,useReducer:cu,useRef:_r,useState:function(){return cu(Lt)},useDebugValue:su,useDeferredValue:function(e,t){var a=Oe();return se===null?ru(a,e,t):Er(a,se.memoizedState,e,t)},useTransition:function(){var e=cu(Lt)[0],t=Oe().memoizedState;return[typeof e=="boolean"?e:Pn(e),t]},useSyncExternalStore:Is,useId:Rr,useHostTransitionStatus:du,useFormState:mr,useActionState:mr,useOptimistic:function(e,t){var a=Oe();return se!==null?ir(a,se,e,t):(a.baseState=e,[e,a.queue.dispatch])},useMemoCache:lu,useCacheRefresh:Nr},sn=null,tl=0;function di(e){var t=tl;return tl+=1,sn===null&&(sn=[]),Zs(sn,e,t)}function al(e,t){t=t.props.ref,e.ref=t!==void 0?t:null}function hi(e,t){throw t.$$typeof===L?Error(r(525)):(e=Object.prototype.toString.call(t),Error(r(31,e==="[object Object]"?"object with keys {"+Object.keys(t).join(", ")+"}":e)))}function qr(e){var t=e._init;return t(e._payload)}function jr(e){function t(p,h){if(e){var g=p.deletions;g===null?(p.deletions=[h],p.flags|=16):g.push(h)}}function a(p,h){if(!e)return null;for(;h!==null;)t(p,h),h=h.sibling;return null}function n(p){for(var h=new Map;p!==null;)p.key!==null?h.set(p.key,p):h.set(p.index,p),p=p.sibling;return h}function l(p,h){return p=qt(p,h),p.index=0,p.sibling=null,p}function i(p,h,g){return p.index=g,e?(g=p.alternate,g!==null?(g=g.index,g<h?(p.flags|=67108866,h):g):(p.flags|=67108866,h)):(p.flags|=1048576,h)}function c(p){return e&&p.alternate===null&&(p.flags|=67108866),p}function o(p,h,g,z){return h===null||h.tag!==6?(h=Cc(g,p.mode,z),h.return=p,h):(h=l(h,g),h.return=p,h)}function f(p,h,g,z){var H=g.type;return H===ie?w(p,h,g.props.children,z,g.key):h!==null&&(h.elementType===H||typeof H=="object"&&H!==null&&H.$$typeof===ze&&qr(H)===h.type)?(h=l(h,g.props),al(h,g),h.return=p,h):(h=$l(g.type,g.key,g.props,null,p.mode,z),al(h,g),h.return=p,h)}function y(p,h,g,z){return h===null||h.tag!==4||h.stateNode.containerInfo!==g.containerInfo||h.stateNode.implementation!==g.implementation?(h=qc(g,p.mode,z),h.return=p,h):(h=l(h,g.children||[]),h.return=p,h)}function w(p,h,g,z,H){return h===null||h.tag!==7?(h=Ea(g,p.mode,z,H),h.return=p,h):(h=l(h,g),h.return=p,h)}function N(p,h,g){if(typeof h=="string"&&h!==""||typeof h=="number"||typeof h=="bigint")return h=Cc(""+h,p.mode,g),h.return=p,h;if(typeof h=="object"&&h!==null){switch(h.$$typeof){case K:return g=$l(h.type,h.key,h.props,null,p.mode,g),al(g,h),g.return=p,g;case _e:return h=qc(h,p.mode,g),h.return=p,h;case ze:var z=h._init;return h=z(h._payload),N(p,h,g)}if(Se(h)||$(h))return h=Ea(h,p.mode,g,null),h.return=p,h;if(typeof h.then=="function")return N(p,di(h),g);if(h.$$typeof===be)return N(p,Il(p,h),g);hi(p,h)}return null}function b(p,h,g,z){var H=h!==null?h.key:null;if(typeof g=="string"&&g!==""||typeof g=="number"||typeof g=="bigint")return H!==null?null:o(p,h,""+g,z);if(typeof g=="object"&&g!==null){switch(g.$$typeof){case K:return g.key===H?f(p,h,g,z):null;case _e:return g.key===H?y(p,h,g,z):null;case ze:return H=g._init,g=H(g._payload),b(p,h,g,z)}if(Se(g)||$(g))return H!==null?null:w(p,h,g,z,null);if(typeof g.then=="function")return b(p,h,di(g),z);if(g.$$typeof===be)return b(p,h,Il(p,g),z);hi(p,g)}return null}function S(p,h,g,z,H){if(typeof z=="string"&&z!==""||typeof z=="number"||typeof z=="bigint")return p=p.get(g)||null,o(h,p,""+z,H);if(typeof z=="object"&&z!==null){switch(z.$$typeof){case K:return p=p.get(z.key===null?g:z.key)||null,f(h,p,z,H);case _e:return p=p.get(z.key===null?g:z.key)||null,y(h,p,z,H);case ze:var I=z._init;return z=I(z._payload),S(p,h,g,z,H)}if(Se(z)||$(z))return p=p.get(g)||null,w(h,p,z,H,null);if(typeof z.then=="function")return S(p,h,g,di(z),H);if(z.$$typeof===be)return S(p,h,g,Il(h,z),H);hi(h,z)}return null}function X(p,h,g,z){for(var H=null,I=null,B=h,Q=h=0,Le=null;B!==null&&Q<g.length;Q++){B.index>Q?(Le=B,B=null):Le=B.sibling;var ne=b(p,B,g[Q],z);if(ne===null){B===null&&(B=Le);break}e&&B&&ne.alternate===null&&t(p,B),h=i(ne,h,Q),I===null?H=ne:I.sibling=ne,I=ne,B=Le}if(Q===g.length)return a(p,B),le&&wa(p,Q),H;if(B===null){for(;Q<g.length;Q++)B=N(p,g[Q],z),B!==null&&(h=i(B,h,Q),I===null?H=B:I.sibling=B,I=B);return le&&wa(p,Q),H}for(B=n(B);Q<g.length;Q++)Le=S(B,p,Q,g[Q],z),Le!==null&&(e&&Le.alternate!==null&&B.delete(Le.key===null?Q:Le.key),h=i(Le,h,Q),I===null?H=Le:I.sibling=Le,I=Le);return e&&B.forEach(function(va){return t(p,va)}),le&&wa(p,Q),H}function G(p,h,g,z){if(g==null)throw Error(r(151));for(var H=null,I=null,B=h,Q=h=0,Le=null,ne=g.next();B!==null&&!ne.done;Q++,ne=g.next()){B.index>Q?(Le=B,B=null):Le=B.sibling;var va=b(p,B,ne.value,z);if(va===null){B===null&&(B=Le);break}e&&B&&va.alternate===null&&t(p,B),h=i(va,h,Q),I===null?H=va:I.sibling=va,I=va,B=Le}if(ne.done)return a(p,B),le&&wa(p,Q),H;if(B===null){for(;!ne.done;Q++,ne=g.next())ne=N(p,ne.value,z),ne!==null&&(h=i(ne,h,Q),I===null?H=ne:I.sibling=ne,I=ne);return le&&wa(p,Q),H}for(B=n(B);!ne.done;Q++,ne=g.next())ne=S(B,p,Q,ne.value,z),ne!==null&&(e&&ne.alternate!==null&&B.delete(ne.key===null?Q:ne.key),h=i(ne,h,Q),I===null?H=ne:I.sibling=ne,I=ne);return e&&B.forEach(function(k_){return t(p,k_)}),le&&wa(p,Q),H}function fe(p,h,g,z){if(typeof g=="object"&&g!==null&&g.type===ie&&g.key===null&&(g=g.props.children),typeof g=="object"&&g!==null){switch(g.$$typeof){case K:e:{for(var H=g.key;h!==null;){if(h.key===H){if(H=g.type,H===ie){if(h.tag===7){a(p,h.sibling),z=l(h,g.props.children),z.return=p,p=z;break e}}else if(h.elementType===H||typeof H=="object"&&H!==null&&H.$$typeof===ze&&qr(H)===h.type){a(p,h.sibling),z=l(h,g.props),al(z,g),z.return=p,p=z;break e}a(p,h);break}else t(p,h);h=h.sibling}g.type===ie?(z=Ea(g.props.children,p.mode,z,g.key),z.return=p,p=z):(z=$l(g.type,g.key,g.props,null,p.mode,z),al(z,g),z.return=p,p=z)}return c(p);case _e:e:{for(H=g.key;h!==null;){if(h.key===H)if(h.tag===4&&h.stateNode.containerInfo===g.containerInfo&&h.stateNode.implementation===g.implementation){a(p,h.sibling),z=l(h,g.children||[]),z.return=p,p=z;break e}else{a(p,h);break}else t(p,h);h=h.sibling}z=qc(g,p.mode,z),z.return=p,p=z}return c(p);case ze:return H=g._init,g=H(g._payload),fe(p,h,g,z)}if(Se(g))return X(p,h,g,z);if($(g)){if(H=$(g),typeof H!="function")throw Error(r(150));return g=H.call(g),G(p,h,g,z)}if(typeof g.then=="function")return fe(p,h,di(g),z);if(g.$$typeof===be)return fe(p,h,Il(p,g),z);hi(p,g)}return typeof g=="string"&&g!==""||typeof g=="number"||typeof g=="bigint"?(g=""+g,h!==null&&h.tag===6?(a(p,h.sibling),z=l(h,g),z.return=p,p=z):(a(p,h),z=Cc(g,p.mode,z),z.return=p,p=z),c(p)):a(p,h)}return function(p,h,g,z){try{tl=0;var H=fe(p,h,g,z);return sn=null,H}catch(B){if(B===Vn||B===ti)throw B;var I=ot(29,B,null,p.mode);return I.lanes=z,I.return=p,I}}}var rn=jr(!0),kr=jr(!1),bt=T(null),Rt=null;function na(e){var t=e.alternate;M(qe,qe.current&1),M(bt,e),Rt===null&&(t===null||ln.current!==null||t.memoizedState!==null)&&(Rt=e)}function Hr(e){if(e.tag===22){if(M(qe,qe.current),M(bt,e),Rt===null){var t=e.alternate;t!==null&&t.memoizedState!==null&&(Rt=e)}}else la()}function la(){M(qe,qe.current),M(bt,bt.current)}function Yt(e){D(bt),Rt===e&&(Rt=null),D(qe)}var qe=T(0);function mi(e){for(var t=e;t!==null;){if(t.tag===13){var a=t.memoizedState;if(a!==null&&(a=a.dehydrated,a===null||a.data==="$?"||no(a)))return t}else if(t.tag===19&&t.memoizedProps.revealOrder!==void 0){if((t.flags&128)!==0)return t}else if(t.child!==null){t.child.return=t,t=t.child;continue}if(t===e)break;for(;t.sibling===null;){if(t.return===null||t.return===e)return null;t=t.return}t.sibling.return=t.return,t=t.sibling}return null}function mu(e,t,a,n){t=e.memoizedState,a=a(n,t),a=a==null?t:O({},t,a),e.memoizedState=a,e.lanes===0&&(e.updateQueue.baseState=a)}var _u={enqueueSetState:function(e,t,a){e=e._reactInternals;var n=dt(),l=ea(n);l.payload=t,a!=null&&(l.callback=a),t=ta(e,l,n),t!==null&&(ht(t,e,n),Jn(t,e,n))},enqueueReplaceState:function(e,t,a){e=e._reactInternals;var n=dt(),l=ea(n);l.tag=1,l.payload=t,a!=null&&(l.callback=a),t=ta(e,l,n),t!==null&&(ht(t,e,n),Jn(t,e,n))},enqueueForceUpdate:function(e,t){e=e._reactInternals;var a=dt(),n=ea(a);n.tag=2,t!=null&&(n.callback=t),t=ta(e,n,a),t!==null&&(ht(t,e,a),Jn(t,e,a))}};function Br(e,t,a,n,l,i,c){return e=e.stateNode,typeof e.shouldComponentUpdate=="function"?e.shouldComponentUpdate(n,i,c):t.prototype&&t.prototype.isPureReactComponent?!Hn(a,n)||!Hn(l,i):!0}function Lr(e,t,a,n){e=t.state,typeof t.componentWillReceiveProps=="function"&&t.componentWillReceiveProps(a,n),typeof t.UNSAFE_componentWillReceiveProps=="function"&&t.UNSAFE_componentWillReceiveProps(a,n),t.state!==e&&_u.enqueueReplaceState(t,t.state,null)}function Ua(e,t){var a=t;if("ref"in t){a={};for(var n in t)n!=="ref"&&(a[n]=t[n])}if(e=e.defaultProps){a===t&&(a=O({},a));for(var l in e)a[l]===void 0&&(a[l]=e[l])}return a}var _i=typeof reportError=="function"?reportError:function(e){if(typeof window=="object"&&typeof window.ErrorEvent=="function"){var t=new window.ErrorEvent("error",{bubbles:!0,cancelable:!0,message:typeof e=="object"&&e!==null&&typeof e.message=="string"?String(e.message):String(e),error:e});if(!window.dispatchEvent(t))return}else if(typeof process=="object"&&typeof process.emit=="function"){process.emit("uncaughtException",e);return}console.error(e)};function Yr(e){_i(e)}function Gr(e){console.error(e)}function Qr(e){_i(e)}function pi(e,t){try{var a=e.onUncaughtError;a(t.value,{componentStack:t.stack})}catch(n){setTimeout(function(){throw n})}}function Xr(e,t,a){try{var n=e.onCaughtError;n(a.value,{componentStack:a.stack,errorBoundary:t.tag===1?t.stateNode:null})}catch(l){setTimeout(function(){throw l})}}function pu(e,t,a){return a=ea(a),a.tag=3,a.payload={element:null},a.callback=function(){pi(e,t)},a}function Zr(e){return e=ea(e),e.tag=3,e}function Vr(e,t,a,n){var l=a.type.getDerivedStateFromError;if(typeof l=="function"){var i=n.value;e.payload=function(){return l(i)},e.callback=function(){Xr(t,a,n)}}var c=a.stateNode;c!==null&&typeof c.componentDidCatch=="function"&&(e.callback=function(){Xr(t,a,n),typeof l!="function"&&(ra===null?ra=new Set([this]):ra.add(this));var o=n.stack;this.componentDidCatch(n.value,{componentStack:o!==null?o:""})})}function km(e,t,a,n,l){if(a.flags|=32768,n!==null&&typeof n=="object"&&typeof n.then=="function"){if(t=a.alternate,t!==null&&Qn(t,a,l,!0),a=bt.current,a!==null){switch(a.tag){case 13:return Rt===null?Lu():a.alternate===null&&Te===0&&(Te=3),a.flags&=-257,a.flags|=65536,a.lanes=l,n===Zc?a.flags|=16384:(t=a.updateQueue,t===null?a.updateQueue=new Set([n]):t.add(n),Gu(e,n,l)),!1;case 22:return a.flags|=65536,n===Zc?a.flags|=16384:(t=a.updateQueue,t===null?(t={transitions:null,markerInstances:null,retryQueue:new Set([n])},a.updateQueue=t):(a=t.retryQueue,a===null?t.retryQueue=new Set([n]):a.add(n)),Gu(e,n,l)),!1}throw Error(r(435,a.tag))}return Gu(e,n,l),Lu(),!1}if(le)return t=bt.current,t!==null?((t.flags&65536)===0&&(t.flags|=256),t.flags|=65536,t.lanes=l,n!==Hc&&(e=Error(r(422),{cause:n}),Gn(pt(e,a)))):(n!==Hc&&(t=Error(r(423),{cause:n}),Gn(pt(t,a))),e=e.current.alternate,e.flags|=65536,l&=-l,e.lanes|=l,n=pt(n,a),l=pu(e.stateNode,n,l),Jc(e,l),Te!==4&&(Te=2)),!1;var i=Error(r(520),{cause:n});if(i=pt(i,a),sl===null?sl=[i]:sl.push(i),Te!==4&&(Te=2),t===null)return!0;n=pt(n,a),a=t;do{switch(a.tag){case 3:return a.flags|=65536,e=l&-l,a.lanes|=e,e=pu(a.stateNode,n,e),Jc(a,e),!1;case 1:if(t=a.type,i=a.stateNode,(a.flags&128)===0&&(typeof t.getDerivedStateFromError=="function"||i!==null&&typeof i.componentDidCatch=="function"&&(ra===null||!ra.has(i))))return a.flags|=65536,l&=-l,a.lanes|=l,l=Zr(l),Vr(l,e,a,n),Jc(a,l),!1}a=a.return}while(a!==null);return!1}var Kr=Error(r(461)),He=!1;function Qe(e,t,a,n){t.child=e===null?kr(t,null,a,n):rn(t,e.child,a,n)}function Jr(e,t,a,n,l){a=a.render;var i=t.ref;if("ref"in n){var c={};for(var o in n)o!=="ref"&&(c[o]=n[o])}else c=n;return Da(t),n=Ic(e,t,a,c,i,l),o=eu(),e!==null&&!He?(tu(e,t,l),Gt(e,t,l)):(le&&o&&jc(t),t.flags|=1,Qe(e,t,n,l),t.child)}function $r(e,t,a,n,l){if(e===null){var i=a.type;return typeof i=="function"&&!Uc(i)&&i.defaultProps===void 0&&a.compare===null?(t.tag=15,t.type=i,Wr(e,t,i,n,l)):(e=$l(a.type,null,n,t,t.mode,l),e.ref=t.ref,e.return=t,t.child=e)}if(i=e.child,!Eu(e,l)){var c=i.memoizedProps;if(a=a.compare,a=a!==null?a:Hn,a(c,n)&&e.ref===t.ref)return Gt(e,t,l)}return t.flags|=1,e=qt(i,n),e.ref=t.ref,e.return=t,t.child=e}function Wr(e,t,a,n,l){if(e!==null){var i=e.memoizedProps;if(Hn(i,n)&&e.ref===t.ref)if(He=!1,t.pendingProps=n=i,Eu(e,l))(e.flags&131072)!==0&&(He=!0);else return t.lanes=e.lanes,Gt(e,t,l)}return gu(e,t,a,n,l)}function Fr(e,t,a){var n=t.pendingProps,l=n.children,i=e!==null?e.memoizedState:null;if(n.mode==="hidden"){if((t.flags&128)!==0){if(n=i!==null?i.baseLanes|a:a,e!==null){for(l=t.child=e.child,i=0;l!==null;)i=i|l.lanes|l.childLanes,l=l.sibling;t.childLanes=i&~n}else t.childLanes=0,t.child=null;return Pr(e,t,n,a)}if((a&536870912)!==0)t.memoizedState={baseLanes:0,cachePool:null},e!==null&&ei(t,i!==null?i.cachePool:null),i!==null?Ws(t,i):Wc(),Hr(t);else return t.lanes=t.childLanes=536870912,Pr(e,t,i!==null?i.baseLanes|a:a,a)}else i!==null?(ei(t,i.cachePool),Ws(t,i),la(),t.memoizedState=null):(e!==null&&ei(t,null),Wc(),la());return Qe(e,t,l,a),t.child}function Pr(e,t,a,n){var l=Xc();return l=l===null?null:{parent:Ce._currentValue,pool:l},t.memoizedState={baseLanes:a,cachePool:l},e!==null&&ei(t,null),Wc(),Hr(t),e!==null&&Qn(e,t,n,!0),null}function gi(e,t){var a=t.ref;if(a===null)e!==null&&e.ref!==null&&(t.flags|=4194816);else{if(typeof a!="function"&&typeof a!="object")throw Error(r(284));(e===null||e.ref!==a)&&(t.flags|=4194816)}}function gu(e,t,a,n,l){return Da(t),a=Ic(e,t,a,n,void 0,l),n=eu(),e!==null&&!He?(tu(e,t,l),Gt(e,t,l)):(le&&n&&jc(t),t.flags|=1,Qe(e,t,a,l),t.child)}function Ir(e,t,a,n,l,i){return Da(t),t.updateQueue=null,a=Ps(t,n,a,l),Fs(e),n=eu(),e!==null&&!He?(tu(e,t,i),Gt(e,t,i)):(le&&n&&jc(t),t.flags|=1,Qe(e,t,a,i),t.child)}function ef(e,t,a,n,l){if(Da(t),t.stateNode===null){var i=Ia,c=a.contextType;typeof c=="object"&&c!==null&&(i=Ke(c)),i=new a(n,i),t.memoizedState=i.state!==null&&i.state!==void 0?i.state:null,i.updater=_u,t.stateNode=i,i._reactInternals=t,i=t.stateNode,i.props=n,i.state=t.memoizedState,i.refs={},Vc(t),c=a.contextType,i.context=typeof c=="object"&&c!==null?Ke(c):Ia,i.state=t.memoizedState,c=a.getDerivedStateFromProps,typeof c=="function"&&(mu(t,a,c,n),i.state=t.memoizedState),typeof a.getDerivedStateFromProps=="function"||typeof i.getSnapshotBeforeUpdate=="function"||typeof i.UNSAFE_componentWillMount!="function"&&typeof i.componentWillMount!="function"||(c=i.state,typeof i.componentWillMount=="function"&&i.componentWillMount(),typeof i.UNSAFE_componentWillMount=="function"&&i.UNSAFE_componentWillMount(),c!==i.state&&_u.enqueueReplaceState(i,i.state,null),Wn(t,n,i,l),$n(),i.state=t.memoizedState),typeof i.componentDidMount=="function"&&(t.flags|=4194308),n=!0}else if(e===null){i=t.stateNode;var o=t.memoizedProps,f=Ua(a,o);i.props=f;var y=i.context,w=a.contextType;c=Ia,typeof w=="object"&&w!==null&&(c=Ke(w));var N=a.getDerivedStateFromProps;w=typeof N=="function"||typeof i.getSnapshotBeforeUpdate=="function",o=t.pendingProps!==o,w||typeof i.UNSAFE_componentWillReceiveProps!="function"&&typeof i.componentWillReceiveProps!="function"||(o||y!==c)&&Lr(t,i,n,c),It=!1;var b=t.memoizedState;i.state=b,Wn(t,n,i,l),$n(),y=t.memoizedState,o||b!==y||It?(typeof N=="function"&&(mu(t,a,N,n),y=t.memoizedState),(f=It||Br(t,a,f,n,b,y,c))?(w||typeof i.UNSAFE_componentWillMount!="function"&&typeof i.componentWillMount!="function"||(typeof i.componentWillMount=="function"&&i.componentWillMount(),typeof i.UNSAFE_componentWillMount=="function"&&i.UNSAFE_componentWillMount()),typeof i.componentDidMount=="function"&&(t.flags|=4194308)):(typeof i.componentDidMount=="function"&&(t.flags|=4194308),t.memoizedProps=n,t.memoizedState=y),i.props=n,i.state=y,i.context=c,n=f):(typeof i.componentDidMount=="function"&&(t.flags|=4194308),n=!1)}else{i=t.stateNode,Kc(e,t),c=t.memoizedProps,w=Ua(a,c),i.props=w,N=t.pendingProps,b=i.context,y=a.contextType,f=Ia,typeof y=="object"&&y!==null&&(f=Ke(y)),o=a.getDerivedStateFromProps,(y=typeof o=="function"||typeof i.getSnapshotBeforeUpdate=="function")||typeof i.UNSAFE_componentWillReceiveProps!="function"&&typeof i.componentWillReceiveProps!="function"||(c!==N||b!==f)&&Lr(t,i,n,f),It=!1,b=t.memoizedState,i.state=b,Wn(t,n,i,l),$n();var S=t.memoizedState;c!==N||b!==S||It||e!==null&&e.dependencies!==null&&Pl(e.dependencies)?(typeof o=="function"&&(mu(t,a,o,n),S=t.memoizedState),(w=It||Br(t,a,w,n,b,S,f)||e!==null&&e.dependencies!==null&&Pl(e.dependencies))?(y||typeof i.UNSAFE_componentWillUpdate!="function"&&typeof i.componentWillUpdate!="function"||(typeof i.componentWillUpdate=="function"&&i.componentWillUpdate(n,S,f),typeof i.UNSAFE_componentWillUpdate=="function"&&i.UNSAFE_componentWillUpdate(n,S,f)),typeof i.componentDidUpdate=="function"&&(t.flags|=4),typeof i.getSnapshotBeforeUpdate=="function"&&(t.flags|=1024)):(typeof i.componentDidUpdate!="function"||c===e.memoizedProps&&b===e.memoizedState||(t.flags|=4),typeof i.getSnapshotBeforeUpdate!="function"||c===e.memoizedProps&&b===e.memoizedState||(t.flags|=1024),t.memoizedProps=n,t.memoizedState=S),i.props=n,i.state=S,i.context=f,n=w):(typeof i.componentDidUpdate!="function"||c===e.memoizedProps&&b===e.memoizedState||(t.flags|=4),typeof i.getSnapshotBeforeUpdate!="function"||c===e.memoizedProps&&b===e.memoizedState||(t.flags|=1024),n=!1)}return i=n,gi(e,t),n=(t.flags&128)!==0,i||n?(i=t.stateNode,a=n&&typeof a.getDerivedStateFromError!="function"?null:i.render(),t.flags|=1,e!==null&&n?(t.child=rn(t,e.child,null,l),t.child=rn(t,null,a,l)):Qe(e,t,a,l),t.memoizedState=i.state,e=t.child):e=Gt(e,t,l),e}function tf(e,t,a,n){return Yn(),t.flags|=256,Qe(e,t,a,n),t.child}var vu={dehydrated:null,treeContext:null,retryLane:0,hydrationErrors:null};function yu(e){return{baseLanes:e,cachePool:Gs()}}function bu(e,t,a){return e=e!==null?e.childLanes&~a:0,t&&(e|=St),e}function af(e,t,a){var n=t.pendingProps,l=!1,i=(t.flags&128)!==0,c;if((c=i)||(c=e!==null&&e.memoizedState===null?!1:(qe.current&2)!==0),c&&(l=!0,t.flags&=-129),c=(t.flags&32)!==0,t.flags&=-33,e===null){if(le){if(l?na(t):la(),le){var o=xe,f;if(f=o){e:{for(f=o,o=zt;f.nodeType!==8;){if(!o){o=null;break e}if(f=At(f.nextSibling),f===null){o=null;break e}}o=f}o!==null?(t.memoizedState={dehydrated:o,treeContext:Aa!==null?{id:jt,overflow:kt}:null,retryLane:536870912,hydrationErrors:null},f=ot(18,null,null,0),f.stateNode=o,f.return=t,t.child=f,We=t,xe=null,f=!0):f=!1}f||Ra(t)}if(o=t.memoizedState,o!==null&&(o=o.dehydrated,o!==null))return no(o)?t.lanes=32:t.lanes=536870912,null;Yt(t)}return o=n.children,n=n.fallback,l?(la(),l=t.mode,o=vi({mode:"hidden",children:o},l),n=Ea(n,l,a,null),o.return=t,n.return=t,o.sibling=n,t.child=o,l=t.child,l.memoizedState=yu(a),l.childLanes=bu(e,c,a),t.memoizedState=vu,n):(na(t),Su(t,o))}if(f=e.memoizedState,f!==null&&(o=f.dehydrated,o!==null)){if(i)t.flags&256?(na(t),t.flags&=-257,t=xu(e,t,a)):t.memoizedState!==null?(la(),t.child=e.child,t.flags|=128,t=null):(la(),l=n.fallback,o=t.mode,n=vi({mode:"visible",children:n.children},o),l=Ea(l,o,a,null),l.flags|=2,n.return=t,l.return=t,n.sibling=l,t.child=n,rn(t,e.child,null,a),n=t.child,n.memoizedState=yu(a),n.childLanes=bu(e,c,a),t.memoizedState=vu,t=l);else if(na(t),no(o)){if(c=o.nextSibling&&o.nextSibling.dataset,c)var y=c.dgst;c=y,n=Error(r(419)),n.stack="",n.digest=c,Gn({value:n,source:null,stack:null}),t=xu(e,t,a)}else if(He||Qn(e,t,a,!1),c=(a&e.childLanes)!==0,He||c){if(c=he,c!==null&&(n=a&-a,n=(n&42)!==0?1:lc(n),n=(n&(c.suspendedLanes|a))!==0?0:n,n!==0&&n!==f.retryLane))throw f.retryLane=n,Pa(e,n),ht(c,e,n),Kr;o.data==="$?"||Lu(),t=xu(e,t,a)}else o.data==="$?"?(t.flags|=192,t.child=e.child,t=null):(e=f.treeContext,xe=At(o.nextSibling),We=t,le=!0,za=null,zt=!1,e!==null&&(vt[yt++]=jt,vt[yt++]=kt,vt[yt++]=Aa,jt=e.id,kt=e.overflow,Aa=t),t=Su(t,n.children),t.flags|=4096);return t}return l?(la(),l=n.fallback,o=t.mode,f=e.child,y=f.sibling,n=qt(f,{mode:"hidden",children:n.children}),n.subtreeFlags=f.subtreeFlags&65011712,y!==null?l=qt(y,l):(l=Ea(l,o,a,null),l.flags|=2),l.return=t,n.return=t,n.sibling=l,t.child=n,n=l,l=t.child,o=e.child.memoizedState,o===null?o=yu(a):(f=o.cachePool,f!==null?(y=Ce._currentValue,f=f.parent!==y?{parent:y,pool:y}:f):f=Gs(),o={baseLanes:o.baseLanes|a,cachePool:f}),l.memoizedState=o,l.childLanes=bu(e,c,a),t.memoizedState=vu,n):(na(t),a=e.child,e=a.sibling,a=qt(a,{mode:"visible",children:n.children}),a.return=t,a.sibling=null,e!==null&&(c=t.deletions,c===null?(t.deletions=[e],t.flags|=16):c.push(e)),t.child=a,t.memoizedState=null,a)}function Su(e,t){return t=vi({mode:"visible",children:t},e.mode),t.return=e,e.child=t}function vi(e,t){return e=ot(22,e,null,t),e.lanes=0,e.stateNode={_visibility:1,_pendingMarkers:null,_retryCache:null,_transitions:null},e}function xu(e,t,a){return rn(t,e.child,null,a),e=Su(t,t.pendingProps.children),e.flags|=2,t.memoizedState=null,e}function nf(e,t,a){e.lanes|=t;var n=e.alternate;n!==null&&(n.lanes|=t),Lc(e.return,t,a)}function Tu(e,t,a,n,l){var i=e.memoizedState;i===null?e.memoizedState={isBackwards:t,rendering:null,renderingStartTime:0,last:n,tail:a,tailMode:l}:(i.isBackwards=t,i.rendering=null,i.renderingStartTime=0,i.last=n,i.tail=a,i.tailMode=l)}function lf(e,t,a){var n=t.pendingProps,l=n.revealOrder,i=n.tail;if(Qe(e,t,n.children,a),n=qe.current,(n&2)!==0)n=n&1|2,t.flags|=128;else{if(e!==null&&(e.flags&128)!==0)e:for(e=t.child;e!==null;){if(e.tag===13)e.memoizedState!==null&&nf(e,a,t);else if(e.tag===19)nf(e,a,t);else if(e.child!==null){e.child.return=e,e=e.child;continue}if(e===t)break e;for(;e.sibling===null;){if(e.return===null||e.return===t)break e;e=e.return}e.sibling.return=e.return,e=e.sibling}n&=1}switch(M(qe,n),l){case"forwards":for(a=t.child,l=null;a!==null;)e=a.alternate,e!==null&&mi(e)===null&&(l=a),a=a.sibling;a=l,a===null?(l=t.child,t.child=null):(l=a.sibling,a.sibling=null),Tu(t,!1,l,a,i);break;case"backwards":for(a=null,l=t.child,t.child=null;l!==null;){if(e=l.alternate,e!==null&&mi(e)===null){t.child=l;break}e=l.sibling,l.sibling=a,a=l,l=e}Tu(t,!0,a,null,i);break;case"together":Tu(t,!1,null,null,void 0);break;default:t.memoizedState=null}return t.child}function Gt(e,t,a){if(e!==null&&(t.dependencies=e.dependencies),sa|=t.lanes,(a&t.childLanes)===0)if(e!==null){if(Qn(e,t,a,!1),(a&t.childLanes)===0)return null}else return null;if(e!==null&&t.child!==e.child)throw Error(r(153));if(t.child!==null){for(e=t.child,a=qt(e,e.pendingProps),t.child=a,a.return=t;e.sibling!==null;)e=e.sibling,a=a.sibling=qt(e,e.pendingProps),a.return=t;a.sibling=null}return t.child}function Eu(e,t){return(e.lanes&t)!==0?!0:(e=e.dependencies,!!(e!==null&&Pl(e)))}function Hm(e,t,a){switch(t.tag){case 3:pe(t,t.stateNode.containerInfo),Pt(t,Ce,e.memoizedState.cache),Yn();break;case 27:case 5:Ii(t);break;case 4:pe(t,t.stateNode.containerInfo);break;case 10:Pt(t,t.type,t.memoizedProps.value);break;case 13:var n=t.memoizedState;if(n!==null)return n.dehydrated!==null?(na(t),t.flags|=128,null):(a&t.child.childLanes)!==0?af(e,t,a):(na(t),e=Gt(e,t,a),e!==null?e.sibling:null);na(t);break;case 19:var l=(e.flags&128)!==0;if(n=(a&t.childLanes)!==0,n||(Qn(e,t,a,!1),n=(a&t.childLanes)!==0),l){if(n)return lf(e,t,a);t.flags|=128}if(l=t.memoizedState,l!==null&&(l.rendering=null,l.tail=null,l.lastEffect=null),M(qe,qe.current),n)break;return null;case 22:case 23:return t.lanes=0,Fr(e,t,a);case 24:Pt(t,Ce,e.memoizedState.cache)}return Gt(e,t,a)}function cf(e,t,a){if(e!==null)if(e.memoizedProps!==t.pendingProps)He=!0;else{if(!Eu(e,a)&&(t.flags&128)===0)return He=!1,Hm(e,t,a);He=(e.flags&131072)!==0}else He=!1,le&&(t.flags&1048576)!==0&&qs(t,Fl,t.index);switch(t.lanes=0,t.tag){case 16:e:{e=t.pendingProps;var n=t.elementType,l=n._init;if(n=l(n._payload),t.type=n,typeof n=="function")Uc(n)?(e=Ua(n,e),t.tag=1,t=ef(null,t,n,e,a)):(t.tag=0,t=gu(null,t,n,e,a));else{if(n!=null){if(l=n.$$typeof,l===Ue){t.tag=11,t=Jr(null,t,n,e,a);break e}else if(l===me){t.tag=14,t=$r(null,t,n,e,a);break e}}throw t=Ge(n)||n,Error(r(306,t,""))}}return t;case 0:return gu(e,t,t.type,t.pendingProps,a);case 1:return n=t.type,l=Ua(n,t.pendingProps),ef(e,t,n,l,a);case 3:e:{if(pe(t,t.stateNode.containerInfo),e===null)throw Error(r(387));n=t.pendingProps;var i=t.memoizedState;l=i.element,Kc(e,t),Wn(t,n,null,a);var c=t.memoizedState;if(n=c.cache,Pt(t,Ce,n),n!==i.cache&&Yc(t,[Ce],a,!0),$n(),n=c.element,i.isDehydrated)if(i={element:n,isDehydrated:!1,cache:c.cache},t.updateQueue.baseState=i,t.memoizedState=i,t.flags&256){t=tf(e,t,n,a);break e}else if(n!==l){l=pt(Error(r(424)),t),Gn(l),t=tf(e,t,n,a);break e}else for(e=t.stateNode.containerInfo,e.nodeType===9?e=e.body:e=e.nodeName==="HTML"?e.ownerDocument.body:e,xe=At(e.firstChild),We=t,le=!0,za=null,zt=!0,a=kr(t,null,n,a),t.child=a;a;)a.flags=a.flags&-3|4096,a=a.sibling;else{if(Yn(),n===l){t=Gt(e,t,a);break e}Qe(e,t,n,a)}t=t.child}return t;case 26:return gi(e,t),e===null?(a=rd(t.type,null,t.pendingProps,null))?t.memoizedState=a:le||(a=t.type,e=t.pendingProps,n=Oi(Z.current).createElement(a),n[Ve]=t,n[Fe]=e,Ze(n,a,e),ke(n),t.stateNode=n):t.memoizedState=rd(t.type,e.memoizedProps,t.pendingProps,e.memoizedState),null;case 27:return Ii(t),e===null&&le&&(n=t.stateNode=ud(t.type,t.pendingProps,Z.current),We=t,zt=!0,l=xe,ha(t.type)?(lo=l,xe=At(n.firstChild)):xe=l),Qe(e,t,t.pendingProps.children,a),gi(e,t),e===null&&(t.flags|=4194304),t.child;case 5:return e===null&&le&&((l=n=xe)&&(n=d_(n,t.type,t.pendingProps,zt),n!==null?(t.stateNode=n,We=t,xe=At(n.firstChild),zt=!1,l=!0):l=!1),l||Ra(t)),Ii(t),l=t.type,i=t.pendingProps,c=e!==null?e.memoizedProps:null,n=i.children,eo(l,i)?n=null:c!==null&&eo(l,c)&&(t.flags|=32),t.memoizedState!==null&&(l=Ic(e,t,Dm,null,null,a),vl._currentValue=l),gi(e,t),Qe(e,t,n,a),t.child;case 6:return e===null&&le&&((e=a=xe)&&(a=h_(a,t.pendingProps,zt),a!==null?(t.stateNode=a,We=t,xe=null,e=!0):e=!1),e||Ra(t)),null;case 13:return af(e,t,a);case 4:return pe(t,t.stateNode.containerInfo),n=t.pendingProps,e===null?t.child=rn(t,null,n,a):Qe(e,t,n,a),t.child;case 11:return Jr(e,t,t.type,t.pendingProps,a);case 7:return Qe(e,t,t.pendingProps,a),t.child;case 8:return Qe(e,t,t.pendingProps.children,a),t.child;case 12:return Qe(e,t,t.pendingProps.children,a),t.child;case 10:return n=t.pendingProps,Pt(t,t.type,n.value),Qe(e,t,n.children,a),t.child;case 9:return l=t.type._context,n=t.pendingProps.children,Da(t),l=Ke(l),n=n(l),t.flags|=1,Qe(e,t,n,a),t.child;case 14:return $r(e,t,t.type,t.pendingProps,a);case 15:return Wr(e,t,t.type,t.pendingProps,a);case 19:return lf(e,t,a);case 31:return n=t.pendingProps,a=t.mode,n={mode:n.mode,children:n.children},e===null?(a=vi(n,a),a.ref=t.ref,t.child=a,a.return=t,t=a):(a=qt(e.child,n),a.ref=t.ref,t.child=a,a.return=t,t=a),t;case 22:return Fr(e,t,a);case 24:return Da(t),n=Ke(Ce),e===null?(l=Xc(),l===null&&(l=he,i=Gc(),l.pooledCache=i,i.refCount++,i!==null&&(l.pooledCacheLanes|=a),l=i),t.memoizedState={parent:n,cache:l},Vc(t),Pt(t,Ce,l)):((e.lanes&a)!==0&&(Kc(e,t),Wn(t,null,null,a),$n()),l=e.memoizedState,i=t.memoizedState,l.parent!==n?(l={parent:n,cache:n},t.memoizedState=l,t.lanes===0&&(t.memoizedState=t.updateQueue.baseState=l),Pt(t,Ce,n)):(n=i.cache,Pt(t,Ce,n),n!==l.cache&&Yc(t,[Ce],a,!0))),Qe(e,t,t.pendingProps.children,a),t.child;case 29:throw t.pendingProps}throw Error(r(156,t.tag))}function Qt(e){e.flags|=4}function uf(e,t){if(t.type!=="stylesheet"||(t.state.loading&4)!==0)e.flags&=-16777217;else if(e.flags|=16777216,!_d(t)){if(t=bt.current,t!==null&&((ae&4194048)===ae?Rt!==null:(ae&62914560)!==ae&&(ae&536870912)===0||t!==Rt))throw Kn=Zc,Qs;e.flags|=8192}}function yi(e,t){t!==null&&(e.flags|=4),e.flags&16384&&(t=e.tag!==22?Ho():536870912,e.lanes|=t,mn|=t)}function nl(e,t){if(!le)switch(e.tailMode){case"hidden":t=e.tail;for(var a=null;t!==null;)t.alternate!==null&&(a=t),t=t.sibling;a===null?e.tail=null:a.sibling=null;break;case"collapsed":a=e.tail;for(var n=null;a!==null;)a.alternate!==null&&(n=a),a=a.sibling;n===null?t||e.tail===null?e.tail=null:e.tail.sibling=null:n.sibling=null}}function ve(e){var t=e.alternate!==null&&e.alternate.child===e.child,a=0,n=0;if(t)for(var l=e.child;l!==null;)a|=l.lanes|l.childLanes,n|=l.subtreeFlags&65011712,n|=l.flags&65011712,l.return=e,l=l.sibling;else for(l=e.child;l!==null;)a|=l.lanes|l.childLanes,n|=l.subtreeFlags,n|=l.flags,l.return=e,l=l.sibling;return e.subtreeFlags|=n,e.childLanes=a,t}function Bm(e,t,a){var n=t.pendingProps;switch(kc(t),t.tag){case 31:case 16:case 15:case 0:case 11:case 7:case 8:case 12:case 9:case 14:return ve(t),null;case 1:return ve(t),null;case 3:return a=t.stateNode,n=null,e!==null&&(n=e.memoizedState.cache),t.memoizedState.cache!==n&&(t.flags|=2048),Bt(Ce),Jt(),a.pendingContext&&(a.context=a.pendingContext,a.pendingContext=null),(e===null||e.child===null)&&(Ln(t)?Qt(t):e===null||e.memoizedState.isDehydrated&&(t.flags&256)===0||(t.flags|=1024,Hs())),ve(t),null;case 26:return a=t.memoizedState,e===null?(Qt(t),a!==null?(ve(t),uf(t,a)):(ve(t),t.flags&=-16777217)):a?a!==e.memoizedState?(Qt(t),ve(t),uf(t,a)):(ve(t),t.flags&=-16777217):(e.memoizedProps!==n&&Qt(t),ve(t),t.flags&=-16777217),null;case 27:Dl(t),a=Z.current;var l=t.type;if(e!==null&&t.stateNode!=null)e.memoizedProps!==n&&Qt(t);else{if(!n){if(t.stateNode===null)throw Error(r(166));return ve(t),null}e=k.current,Ln(t)?js(t):(e=ud(l,n,a),t.stateNode=e,Qt(t))}return ve(t),null;case 5:if(Dl(t),a=t.type,e!==null&&t.stateNode!=null)e.memoizedProps!==n&&Qt(t);else{if(!n){if(t.stateNode===null)throw Error(r(166));return ve(t),null}if(e=k.current,Ln(t))js(t);else{switch(l=Oi(Z.current),e){case 1:e=l.createElementNS("http://www.w3.org/2000/svg",a);break;case 2:e=l.createElementNS("http://www.w3.org/1998/Math/MathML",a);break;default:switch(a){case"svg":e=l.createElementNS("http://www.w3.org/2000/svg",a);break;case"math":e=l.createElementNS("http://www.w3.org/1998/Math/MathML",a);break;case"script":e=l.createElement("div"),e.innerHTML="<script><\/script>",e=e.removeChild(e.firstChild);break;case"select":e=typeof n.is=="string"?l.createElement("select",{is:n.is}):l.createElement("select"),n.multiple?e.multiple=!0:n.size&&(e.size=n.size);break;default:e=typeof n.is=="string"?l.createElement(a,{is:n.is}):l.createElement(a)}}e[Ve]=t,e[Fe]=n;e:for(l=t.child;l!==null;){if(l.tag===5||l.tag===6)e.appendChild(l.stateNode);else if(l.tag!==4&&l.tag!==27&&l.child!==null){l.child.return=l,l=l.child;continue}if(l===t)break e;for(;l.sibling===null;){if(l.return===null||l.return===t)break e;l=l.return}l.sibling.return=l.return,l=l.sibling}t.stateNode=e;e:switch(Ze(e,a,n),a){case"button":case"input":case"select":case"textarea":e=!!n.autoFocus;break e;case"img":e=!0;break e;default:e=!1}e&&Qt(t)}}return ve(t),t.flags&=-16777217,null;case 6:if(e&&t.stateNode!=null)e.memoizedProps!==n&&Qt(t);else{if(typeof n!="string"&&t.stateNode===null)throw Error(r(166));if(e=Z.current,Ln(t)){if(e=t.stateNode,a=t.memoizedProps,n=null,l=We,l!==null)switch(l.tag){case 27:case 5:n=l.memoizedProps}e[Ve]=t,e=!!(e.nodeValue===a||n!==null&&n.suppressHydrationWarning===!0||ed(e.nodeValue,a)),e||Ra(t)}else e=Oi(e).createTextNode(n),e[Ve]=t,t.stateNode=e}return ve(t),null;case 13:if(n=t.memoizedState,e===null||e.memoizedState!==null&&e.memoizedState.dehydrated!==null){if(l=Ln(t),n!==null&&n.dehydrated!==null){if(e===null){if(!l)throw Error(r(318));if(l=t.memoizedState,l=l!==null?l.dehydrated:null,!l)throw Error(r(317));l[Ve]=t}else Yn(),(t.flags&128)===0&&(t.memoizedState=null),t.flags|=4;ve(t),l=!1}else l=Hs(),e!==null&&e.memoizedState!==null&&(e.memoizedState.hydrationErrors=l),l=!0;if(!l)return t.flags&256?(Yt(t),t):(Yt(t),null)}if(Yt(t),(t.flags&128)!==0)return t.lanes=a,t;if(a=n!==null,e=e!==null&&e.memoizedState!==null,a){n=t.child,l=null,n.alternate!==null&&n.alternate.memoizedState!==null&&n.alternate.memoizedState.cachePool!==null&&(l=n.alternate.memoizedState.cachePool.pool);var i=null;n.memoizedState!==null&&n.memoizedState.cachePool!==null&&(i=n.memoizedState.cachePool.pool),i!==l&&(n.flags|=2048)}return a!==e&&a&&(t.child.flags|=8192),yi(t,t.updateQueue),ve(t),null;case 4:return Jt(),e===null&&$u(t.stateNode.containerInfo),ve(t),null;case 10:return Bt(t.type),ve(t),null;case 19:if(D(qe),l=t.memoizedState,l===null)return ve(t),null;if(n=(t.flags&128)!==0,i=l.rendering,i===null)if(n)nl(l,!1);else{if(Te!==0||e!==null&&(e.flags&128)!==0)for(e=t.child;e!==null;){if(i=mi(e),i!==null){for(t.flags|=128,nl(l,!1),e=i.updateQueue,t.updateQueue=e,yi(t,e),t.subtreeFlags=0,e=a,a=t.child;a!==null;)Cs(a,e),a=a.sibling;return M(qe,qe.current&1|2),t.child}e=e.sibling}l.tail!==null&&wt()>xi&&(t.flags|=128,n=!0,nl(l,!1),t.lanes=4194304)}else{if(!n)if(e=mi(i),e!==null){if(t.flags|=128,n=!0,e=e.updateQueue,t.updateQueue=e,yi(t,e),nl(l,!0),l.tail===null&&l.tailMode==="hidden"&&!i.alternate&&!le)return ve(t),null}else 2*wt()-l.renderingStartTime>xi&&a!==536870912&&(t.flags|=128,n=!0,nl(l,!1),t.lanes=4194304);l.isBackwards?(i.sibling=t.child,t.child=i):(e=l.last,e!==null?e.sibling=i:t.child=i,l.last=i)}return l.tail!==null?(t=l.tail,l.rendering=t,l.tail=t.sibling,l.renderingStartTime=wt(),t.sibling=null,e=qe.current,M(qe,n?e&1|2:e&1),t):(ve(t),null);case 22:case 23:return Yt(t),Fc(),n=t.memoizedState!==null,e!==null?e.memoizedState!==null!==n&&(t.flags|=8192):n&&(t.flags|=8192),n?(a&536870912)!==0&&(t.flags&128)===0&&(ve(t),t.subtreeFlags&6&&(t.flags|=8192)):ve(t),a=t.updateQueue,a!==null&&yi(t,a.retryQueue),a=null,e!==null&&e.memoizedState!==null&&e.memoizedState.cachePool!==null&&(a=e.memoizedState.cachePool.pool),n=null,t.memoizedState!==null&&t.memoizedState.cachePool!==null&&(n=t.memoizedState.cachePool.pool),n!==a&&(t.flags|=2048),e!==null&&D(Ma),null;case 24:return a=null,e!==null&&(a=e.memoizedState.cache),t.memoizedState.cache!==a&&(t.flags|=2048),Bt(Ce),ve(t),null;case 25:return null;case 30:return null}throw Error(r(156,t.tag))}function Lm(e,t){switch(kc(t),t.tag){case 1:return e=t.flags,e&65536?(t.flags=e&-65537|128,t):null;case 3:return Bt(Ce),Jt(),e=t.flags,(e&65536)!==0&&(e&128)===0?(t.flags=e&-65537|128,t):null;case 26:case 27:case 5:return Dl(t),null;case 13:if(Yt(t),e=t.memoizedState,e!==null&&e.dehydrated!==null){if(t.alternate===null)throw Error(r(340));Yn()}return e=t.flags,e&65536?(t.flags=e&-65537|128,t):null;case 19:return D(qe),null;case 4:return Jt(),null;case 10:return Bt(t.type),null;case 22:case 23:return Yt(t),Fc(),e!==null&&D(Ma),e=t.flags,e&65536?(t.flags=e&-65537|128,t):null;case 24:return Bt(Ce),null;case 25:return null;default:return null}}function of(e,t){switch(kc(t),t.tag){case 3:Bt(Ce),Jt();break;case 26:case 27:case 5:Dl(t);break;case 4:Jt();break;case 13:Yt(t);break;case 19:D(qe);break;case 10:Bt(t.type);break;case 22:case 23:Yt(t),Fc(),e!==null&&D(Ma);break;case 24:Bt(Ce)}}function ll(e,t){try{var a=t.updateQueue,n=a!==null?a.lastEffect:null;if(n!==null){var l=n.next;a=l;do{if((a.tag&e)===e){n=void 0;var i=a.create,c=a.inst;n=i(),c.destroy=n}a=a.next}while(a!==l)}}catch(o){de(t,t.return,o)}}function ia(e,t,a){try{var n=t.updateQueue,l=n!==null?n.lastEffect:null;if(l!==null){var i=l.next;n=i;do{if((n.tag&e)===e){var c=n.inst,o=c.destroy;if(o!==void 0){c.destroy=void 0,l=t;var f=a,y=o;try{y()}catch(w){de(l,f,w)}}}n=n.next}while(n!==i)}}catch(w){de(t,t.return,w)}}function sf(e){var t=e.updateQueue;if(t!==null){var a=e.stateNode;try{$s(t,a)}catch(n){de(e,e.return,n)}}}function rf(e,t,a){a.props=Ua(e.type,e.memoizedProps),a.state=e.memoizedState;try{a.componentWillUnmount()}catch(n){de(e,t,n)}}function il(e,t){try{var a=e.ref;if(a!==null){switch(e.tag){case 26:case 27:case 5:var n=e.stateNode;break;case 30:n=e.stateNode;break;default:n=e.stateNode}typeof a=="function"?e.refCleanup=a(n):a.current=n}}catch(l){de(e,t,l)}}function Nt(e,t){var a=e.ref,n=e.refCleanup;if(a!==null)if(typeof n=="function")try{n()}catch(l){de(e,t,l)}finally{e.refCleanup=null,e=e.alternate,e!=null&&(e.refCleanup=null)}else if(typeof a=="function")try{a(null)}catch(l){de(e,t,l)}else a.current=null}function ff(e){var t=e.type,a=e.memoizedProps,n=e.stateNode;try{e:switch(t){case"button":case"input":case"select":case"textarea":a.autoFocus&&n.focus();break e;case"img":a.src?n.src=a.src:a.srcSet&&(n.srcset=a.srcSet)}}catch(l){de(e,e.return,l)}}function Au(e,t,a){try{var n=e.stateNode;u_(n,e.type,a,t),n[Fe]=t}catch(l){de(e,e.return,l)}}function df(e){return e.tag===5||e.tag===3||e.tag===26||e.tag===27&&ha(e.type)||e.tag===4}function wu(e){e:for(;;){for(;e.sibling===null;){if(e.return===null||df(e.return))return null;e=e.return}for(e.sibling.return=e.return,e=e.sibling;e.tag!==5&&e.tag!==6&&e.tag!==18;){if(e.tag===27&&ha(e.type)||e.flags&2||e.child===null||e.tag===4)continue e;e.child.return=e,e=e.child}if(!(e.flags&2))return e.stateNode}}function zu(e,t,a){var n=e.tag;if(n===5||n===6)e=e.stateNode,t?(a.nodeType===9?a.body:a.nodeName==="HTML"?a.ownerDocument.body:a).insertBefore(e,t):(t=a.nodeType===9?a.body:a.nodeName==="HTML"?a.ownerDocument.body:a,t.appendChild(e),a=a._reactRootContainer,a!=null||t.onclick!==null||(t.onclick=Mi));else if(n!==4&&(n===27&&ha(e.type)&&(a=e.stateNode,t=null),e=e.child,e!==null))for(zu(e,t,a),e=e.sibling;e!==null;)zu(e,t,a),e=e.sibling}function bi(e,t,a){var n=e.tag;if(n===5||n===6)e=e.stateNode,t?a.insertBefore(e,t):a.appendChild(e);else if(n!==4&&(n===27&&ha(e.type)&&(a=e.stateNode),e=e.child,e!==null))for(bi(e,t,a),e=e.sibling;e!==null;)bi(e,t,a),e=e.sibling}function hf(e){var t=e.stateNode,a=e.memoizedProps;try{for(var n=e.type,l=t.attributes;l.length;)t.removeAttributeNode(l[0]);Ze(t,n,a),t[Ve]=e,t[Fe]=a}catch(i){de(e,e.return,i)}}var Xt=!1,Ne=!1,Ru=!1,mf=typeof WeakSet=="function"?WeakSet:Set,Be=null;function Ym(e,t){if(e=e.containerInfo,Pu=Hi,e=Es(e),wc(e)){if("selectionStart"in e)var a={start:e.selectionStart,end:e.selectionEnd};else e:{a=(a=e.ownerDocument)&&a.defaultView||window;var n=a.getSelection&&a.getSelection();if(n&&n.rangeCount!==0){a=n.anchorNode;var l=n.anchorOffset,i=n.focusNode;n=n.focusOffset;try{a.nodeType,i.nodeType}catch{a=null;break e}var c=0,o=-1,f=-1,y=0,w=0,N=e,b=null;t:for(;;){for(var S;N!==a||l!==0&&N.nodeType!==3||(o=c+l),N!==i||n!==0&&N.nodeType!==3||(f=c+n),N.nodeType===3&&(c+=N.nodeValue.length),(S=N.firstChild)!==null;)b=N,N=S;for(;;){if(N===e)break t;if(b===a&&++y===l&&(o=c),b===i&&++w===n&&(f=c),(S=N.nextSibling)!==null)break;N=b,b=N.parentNode}N=S}a=o===-1||f===-1?null:{start:o,end:f}}else a=null}a=a||{start:0,end:0}}else a=null;for(Iu={focusedElem:e,selectionRange:a},Hi=!1,Be=t;Be!==null;)if(t=Be,e=t.child,(t.subtreeFlags&1024)!==0&&e!==null)e.return=t,Be=e;else for(;Be!==null;){switch(t=Be,i=t.alternate,e=t.flags,t.tag){case 0:break;case 11:case 15:break;case 1:if((e&1024)!==0&&i!==null){e=void 0,a=t,l=i.memoizedProps,i=i.memoizedState,n=a.stateNode;try{var X=Ua(a.type,l,a.elementType===a.type);e=n.getSnapshotBeforeUpdate(X,i),n.__reactInternalSnapshotBeforeUpdate=e}catch(G){de(a,a.return,G)}}break;case 3:if((e&1024)!==0){if(e=t.stateNode.containerInfo,a=e.nodeType,a===9)ao(e);else if(a===1)switch(e.nodeName){case"HEAD":case"HTML":case"BODY":ao(e);break;default:e.textContent=""}}break;case 5:case 26:case 27:case 6:case 4:case 17:break;default:if((e&1024)!==0)throw Error(r(163))}if(e=t.sibling,e!==null){e.return=t.return,Be=e;break}Be=t.return}}function _f(e,t,a){var n=a.flags;switch(a.tag){case 0:case 11:case 15:ca(e,a),n&4&&ll(5,a);break;case 1:if(ca(e,a),n&4)if(e=a.stateNode,t===null)try{e.componentDidMount()}catch(c){de(a,a.return,c)}else{var l=Ua(a.type,t.memoizedProps);t=t.memoizedState;try{e.componentDidUpdate(l,t,e.__reactInternalSnapshotBeforeUpdate)}catch(c){de(a,a.return,c)}}n&64&&sf(a),n&512&&il(a,a.return);break;case 3:if(ca(e,a),n&64&&(e=a.updateQueue,e!==null)){if(t=null,a.child!==null)switch(a.child.tag){case 27:case 5:t=a.child.stateNode;break;case 1:t=a.child.stateNode}try{$s(e,t)}catch(c){de(a,a.return,c)}}break;case 27:t===null&&n&4&&hf(a);case 26:case 5:ca(e,a),t===null&&n&4&&ff(a),n&512&&il(a,a.return);break;case 12:ca(e,a);break;case 13:ca(e,a),n&4&&vf(e,a),n&64&&(e=a.memoizedState,e!==null&&(e=e.dehydrated,e!==null&&(a=Wm.bind(null,a),m_(e,a))));break;case 22:if(n=a.memoizedState!==null||Xt,!n){t=t!==null&&t.memoizedState!==null||Ne,l=Xt;var i=Ne;Xt=n,(Ne=t)&&!i?ua(e,a,(a.subtreeFlags&8772)!==0):ca(e,a),Xt=l,Ne=i}break;case 30:break;default:ca(e,a)}}function pf(e){var t=e.alternate;t!==null&&(e.alternate=null,pf(t)),e.child=null,e.deletions=null,e.sibling=null,e.tag===5&&(t=e.stateNode,t!==null&&uc(t)),e.stateNode=null,e.return=null,e.dependencies=null,e.memoizedProps=null,e.memoizedState=null,e.pendingProps=null,e.stateNode=null,e.updateQueue=null}var ge=null,et=!1;function Zt(e,t,a){for(a=a.child;a!==null;)gf(e,t,a),a=a.sibling}function gf(e,t,a){if(it&&typeof it.onCommitFiberUnmount=="function")try{it.onCommitFiberUnmount(wn,a)}catch{}switch(a.tag){case 26:Ne||Nt(a,t),Zt(e,t,a),a.memoizedState?a.memoizedState.count--:a.stateNode&&(a=a.stateNode,a.parentNode.removeChild(a));break;case 27:Ne||Nt(a,t);var n=ge,l=et;ha(a.type)&&(ge=a.stateNode,et=!1),Zt(e,t,a),ml(a.stateNode),ge=n,et=l;break;case 5:Ne||Nt(a,t);case 6:if(n=ge,l=et,ge=null,Zt(e,t,a),ge=n,et=l,ge!==null)if(et)try{(ge.nodeType===9?ge.body:ge.nodeName==="HTML"?ge.ownerDocument.body:ge).removeChild(a.stateNode)}catch(i){de(a,t,i)}else try{ge.removeChild(a.stateNode)}catch(i){de(a,t,i)}break;case 18:ge!==null&&(et?(e=ge,id(e.nodeType===9?e.body:e.nodeName==="HTML"?e.ownerDocument.body:e,a.stateNode),xl(e)):id(ge,a.stateNode));break;case 4:n=ge,l=et,ge=a.stateNode.containerInfo,et=!0,Zt(e,t,a),ge=n,et=l;break;case 0:case 11:case 14:case 15:Ne||ia(2,a,t),Ne||ia(4,a,t),Zt(e,t,a);break;case 1:Ne||(Nt(a,t),n=a.stateNode,typeof n.componentWillUnmount=="function"&&rf(a,t,n)),Zt(e,t,a);break;case 21:Zt(e,t,a);break;case 22:Ne=(n=Ne)||a.memoizedState!==null,Zt(e,t,a),Ne=n;break;default:Zt(e,t,a)}}function vf(e,t){if(t.memoizedState===null&&(e=t.alternate,e!==null&&(e=e.memoizedState,e!==null&&(e=e.dehydrated,e!==null))))try{xl(e)}catch(a){de(t,t.return,a)}}function Gm(e){switch(e.tag){case 13:case 19:var t=e.stateNode;return t===null&&(t=e.stateNode=new mf),t;case 22:return e=e.stateNode,t=e._retryCache,t===null&&(t=e._retryCache=new mf),t;default:throw Error(r(435,e.tag))}}function Nu(e,t){var a=Gm(e);t.forEach(function(n){var l=Fm.bind(null,e,n);a.has(n)||(a.add(n),n.then(l,l))})}function st(e,t){var a=t.deletions;if(a!==null)for(var n=0;n<a.length;n++){var l=a[n],i=e,c=t,o=c;e:for(;o!==null;){switch(o.tag){case 27:if(ha(o.type)){ge=o.stateNode,et=!1;break e}break;case 5:ge=o.stateNode,et=!1;break e;case 3:case 4:ge=o.stateNode.containerInfo,et=!0;break e}o=o.return}if(ge===null)throw Error(r(160));gf(i,c,l),ge=null,et=!1,i=l.alternate,i!==null&&(i.return=null),l.return=null}if(t.subtreeFlags&13878)for(t=t.child;t!==null;)yf(t,e),t=t.sibling}var Et=null;function yf(e,t){var a=e.alternate,n=e.flags;switch(e.tag){case 0:case 11:case 14:case 15:st(t,e),rt(e),n&4&&(ia(3,e,e.return),ll(3,e),ia(5,e,e.return));break;case 1:st(t,e),rt(e),n&512&&(Ne||a===null||Nt(a,a.return)),n&64&&Xt&&(e=e.updateQueue,e!==null&&(n=e.callbacks,n!==null&&(a=e.shared.hiddenCallbacks,e.shared.hiddenCallbacks=a===null?n:a.concat(n))));break;case 26:var l=Et;if(st(t,e),rt(e),n&512&&(Ne||a===null||Nt(a,a.return)),n&4){var i=a!==null?a.memoizedState:null;if(n=e.memoizedState,a===null)if(n===null)if(e.stateNode===null){e:{n=e.type,a=e.memoizedProps,l=l.ownerDocument||l;t:switch(n){case"title":i=l.getElementsByTagName("title")[0],(!i||i[Nn]||i[Ve]||i.namespaceURI==="http://www.w3.org/2000/svg"||i.hasAttribute("itemprop"))&&(i=l.createElement(n),l.head.insertBefore(i,l.querySelector("head > title"))),Ze(i,n,a),i[Ve]=e,ke(i),n=i;break e;case"link":var c=hd("link","href",l).get(n+(a.href||""));if(c){for(var o=0;o<c.length;o++)if(i=c[o],i.getAttribute("href")===(a.href==null||a.href===""?null:a.href)&&i.getAttribute("rel")===(a.rel==null?null:a.rel)&&i.getAttribute("title")===(a.title==null?null:a.title)&&i.getAttribute("crossorigin")===(a.crossOrigin==null?null:a.crossOrigin)){c.splice(o,1);break t}}i=l.createElement(n),Ze(i,n,a),l.head.appendChild(i);break;case"meta":if(c=hd("meta","content",l).get(n+(a.content||""))){for(o=0;o<c.length;o++)if(i=c[o],i.getAttribute("content")===(a.content==null?null:""+a.content)&&i.getAttribute("name")===(a.name==null?null:a.name)&&i.getAttribute("property")===(a.property==null?null:a.property)&&i.getAttribute("http-equiv")===(a.httpEquiv==null?null:a.httpEquiv)&&i.getAttribute("charset")===(a.charSet==null?null:a.charSet)){c.splice(o,1);break t}}i=l.createElement(n),Ze(i,n,a),l.head.appendChild(i);break;default:throw Error(r(468,n))}i[Ve]=e,ke(i),n=i}e.stateNode=n}else md(l,e.type,e.stateNode);else e.stateNode=dd(l,n,e.memoizedProps);else i!==n?(i===null?a.stateNode!==null&&(a=a.stateNode,a.parentNode.removeChild(a)):i.count--,n===null?md(l,e.type,e.stateNode):dd(l,n,e.memoizedProps)):n===null&&e.stateNode!==null&&Au(e,e.memoizedProps,a.memoizedProps)}break;case 27:st(t,e),rt(e),n&512&&(Ne||a===null||Nt(a,a.return)),a!==null&&n&4&&Au(e,e.memoizedProps,a.memoizedProps);break;case 5:if(st(t,e),rt(e),n&512&&(Ne||a===null||Nt(a,a.return)),e.flags&32){l=e.stateNode;try{Za(l,"")}catch(S){de(e,e.return,S)}}n&4&&e.stateNode!=null&&(l=e.memoizedProps,Au(e,l,a!==null?a.memoizedProps:l)),n&1024&&(Ru=!0);break;case 6:if(st(t,e),rt(e),n&4){if(e.stateNode===null)throw Error(r(162));n=e.memoizedProps,a=e.stateNode;try{a.nodeValue=n}catch(S){de(e,e.return,S)}}break;case 3:if(qi=null,l=Et,Et=Ui(t.containerInfo),st(t,e),Et=l,rt(e),n&4&&a!==null&&a.memoizedState.isDehydrated)try{xl(t.containerInfo)}catch(S){de(e,e.return,S)}Ru&&(Ru=!1,bf(e));break;case 4:n=Et,Et=Ui(e.stateNode.containerInfo),st(t,e),rt(e),Et=n;break;case 12:st(t,e),rt(e);break;case 13:st(t,e),rt(e),e.child.flags&8192&&e.memoizedState!==null!=(a!==null&&a.memoizedState!==null)&&(qu=wt()),n&4&&(n=e.updateQueue,n!==null&&(e.updateQueue=null,Nu(e,n)));break;case 22:l=e.memoizedState!==null;var f=a!==null&&a.memoizedState!==null,y=Xt,w=Ne;if(Xt=y||l,Ne=w||f,st(t,e),Ne=w,Xt=y,rt(e),n&8192)e:for(t=e.stateNode,t._visibility=l?t._visibility&-2:t._visibility|1,l&&(a===null||f||Xt||Ne||Ca(e)),a=null,t=e;;){if(t.tag===5||t.tag===26){if(a===null){f=a=t;try{if(i=f.stateNode,l)c=i.style,typeof c.setProperty=="function"?c.setProperty("display","none","important"):c.display="none";else{o=f.stateNode;var N=f.memoizedProps.style,b=N!=null&&N.hasOwnProperty("display")?N.display:null;o.style.display=b==null||typeof b=="boolean"?"":(""+b).trim()}}catch(S){de(f,f.return,S)}}}else if(t.tag===6){if(a===null){f=t;try{f.stateNode.nodeValue=l?"":f.memoizedProps}catch(S){de(f,f.return,S)}}}else if((t.tag!==22&&t.tag!==23||t.memoizedState===null||t===e)&&t.child!==null){t.child.return=t,t=t.child;continue}if(t===e)break e;for(;t.sibling===null;){if(t.return===null||t.return===e)break e;a===t&&(a=null),t=t.return}a===t&&(a=null),t.sibling.return=t.return,t=t.sibling}n&4&&(n=e.updateQueue,n!==null&&(a=n.retryQueue,a!==null&&(n.retryQueue=null,Nu(e,a))));break;case 19:st(t,e),rt(e),n&4&&(n=e.updateQueue,n!==null&&(e.updateQueue=null,Nu(e,n)));break;case 30:break;case 21:break;default:st(t,e),rt(e)}}function rt(e){var t=e.flags;if(t&2){try{for(var a,n=e.return;n!==null;){if(df(n)){a=n;break}n=n.return}if(a==null)throw Error(r(160));switch(a.tag){case 27:var l=a.stateNode,i=wu(e);bi(e,i,l);break;case 5:var c=a.stateNode;a.flags&32&&(Za(c,""),a.flags&=-33);var o=wu(e);bi(e,o,c);break;case 3:case 4:var f=a.stateNode.containerInfo,y=wu(e);zu(e,y,f);break;default:throw Error(r(161))}}catch(w){de(e,e.return,w)}e.flags&=-3}t&4096&&(e.flags&=-4097)}function bf(e){if(e.subtreeFlags&1024)for(e=e.child;e!==null;){var t=e;bf(t),t.tag===5&&t.flags&1024&&t.stateNode.reset(),e=e.sibling}}function ca(e,t){if(t.subtreeFlags&8772)for(t=t.child;t!==null;)_f(e,t.alternate,t),t=t.sibling}function Ca(e){for(e=e.child;e!==null;){var t=e;switch(t.tag){case 0:case 11:case 14:case 15:ia(4,t,t.return),Ca(t);break;case 1:Nt(t,t.return);var a=t.stateNode;typeof a.componentWillUnmount=="function"&&rf(t,t.return,a),Ca(t);break;case 27:ml(t.stateNode);case 26:case 5:Nt(t,t.return),Ca(t);break;case 22:t.memoizedState===null&&Ca(t);break;case 30:Ca(t);break;default:Ca(t)}e=e.sibling}}function ua(e,t,a){for(a=a&&(t.subtreeFlags&8772)!==0,t=t.child;t!==null;){var n=t.alternate,l=e,i=t,c=i.flags;switch(i.tag){case 0:case 11:case 15:ua(l,i,a),ll(4,i);break;case 1:if(ua(l,i,a),n=i,l=n.stateNode,typeof l.componentDidMount=="function")try{l.componentDidMount()}catch(y){de(n,n.return,y)}if(n=i,l=n.updateQueue,l!==null){var o=n.stateNode;try{var f=l.shared.hiddenCallbacks;if(f!==null)for(l.shared.hiddenCallbacks=null,l=0;l<f.length;l++)Js(f[l],o)}catch(y){de(n,n.return,y)}}a&&c&64&&sf(i),il(i,i.return);break;case 27:hf(i);case 26:case 5:ua(l,i,a),a&&n===null&&c&4&&ff(i),il(i,i.return);break;case 12:ua(l,i,a);break;case 13:ua(l,i,a),a&&c&4&&vf(l,i);break;case 22:i.memoizedState===null&&ua(l,i,a),il(i,i.return);break;case 30:break;default:ua(l,i,a)}t=t.sibling}}function Du(e,t){var a=null;e!==null&&e.memoizedState!==null&&e.memoizedState.cachePool!==null&&(a=e.memoizedState.cachePool.pool),e=null,t.memoizedState!==null&&t.memoizedState.cachePool!==null&&(e=t.memoizedState.cachePool.pool),e!==a&&(e!=null&&e.refCount++,a!=null&&Xn(a))}function Mu(e,t){e=null,t.alternate!==null&&(e=t.alternate.memoizedState.cache),t=t.memoizedState.cache,t!==e&&(t.refCount++,e!=null&&Xn(e))}function Dt(e,t,a,n){if(t.subtreeFlags&10256)for(t=t.child;t!==null;)Sf(e,t,a,n),t=t.sibling}function Sf(e,t,a,n){var l=t.flags;switch(t.tag){case 0:case 11:case 15:Dt(e,t,a,n),l&2048&&ll(9,t);break;case 1:Dt(e,t,a,n);break;case 3:Dt(e,t,a,n),l&2048&&(e=null,t.alternate!==null&&(e=t.alternate.memoizedState.cache),t=t.memoizedState.cache,t!==e&&(t.refCount++,e!=null&&Xn(e)));break;case 12:if(l&2048){Dt(e,t,a,n),e=t.stateNode;try{var i=t.memoizedProps,c=i.id,o=i.onPostCommit;typeof o=="function"&&o(c,t.alternate===null?"mount":"update",e.passiveEffectDuration,-0)}catch(f){de(t,t.return,f)}}else Dt(e,t,a,n);break;case 13:Dt(e,t,a,n);break;case 23:break;case 22:i=t.stateNode,c=t.alternate,t.memoizedState!==null?i._visibility&2?Dt(e,t,a,n):cl(e,t):i._visibility&2?Dt(e,t,a,n):(i._visibility|=2,fn(e,t,a,n,(t.subtreeFlags&10256)!==0)),l&2048&&Du(c,t);break;case 24:Dt(e,t,a,n),l&2048&&Mu(t.alternate,t);break;default:Dt(e,t,a,n)}}function fn(e,t,a,n,l){for(l=l&&(t.subtreeFlags&10256)!==0,t=t.child;t!==null;){var i=e,c=t,o=a,f=n,y=c.flags;switch(c.tag){case 0:case 11:case 15:fn(i,c,o,f,l),ll(8,c);break;case 23:break;case 22:var w=c.stateNode;c.memoizedState!==null?w._visibility&2?fn(i,c,o,f,l):cl(i,c):(w._visibility|=2,fn(i,c,o,f,l)),l&&y&2048&&Du(c.alternate,c);break;case 24:fn(i,c,o,f,l),l&&y&2048&&Mu(c.alternate,c);break;default:fn(i,c,o,f,l)}t=t.sibling}}function cl(e,t){if(t.subtreeFlags&10256)for(t=t.child;t!==null;){var a=e,n=t,l=n.flags;switch(n.tag){case 22:cl(a,n),l&2048&&Du(n.alternate,n);break;case 24:cl(a,n),l&2048&&Mu(n.alternate,n);break;default:cl(a,n)}t=t.sibling}}var ul=8192;function dn(e){if(e.subtreeFlags&ul)for(e=e.child;e!==null;)xf(e),e=e.sibling}function xf(e){switch(e.tag){case 26:dn(e),e.flags&ul&&e.memoizedState!==null&&z_(Et,e.memoizedState,e.memoizedProps);break;case 5:dn(e);break;case 3:case 4:var t=Et;Et=Ui(e.stateNode.containerInfo),dn(e),Et=t;break;case 22:e.memoizedState===null&&(t=e.alternate,t!==null&&t.memoizedState!==null?(t=ul,ul=16777216,dn(e),ul=t):dn(e));break;default:dn(e)}}function Tf(e){var t=e.alternate;if(t!==null&&(e=t.child,e!==null)){t.child=null;do t=e.sibling,e.sibling=null,e=t;while(e!==null)}}function ol(e){var t=e.deletions;if((e.flags&16)!==0){if(t!==null)for(var a=0;a<t.length;a++){var n=t[a];Be=n,Af(n,e)}Tf(e)}if(e.subtreeFlags&10256)for(e=e.child;e!==null;)Ef(e),e=e.sibling}function Ef(e){switch(e.tag){case 0:case 11:case 15:ol(e),e.flags&2048&&ia(9,e,e.return);break;case 3:ol(e);break;case 12:ol(e);break;case 22:var t=e.stateNode;e.memoizedState!==null&&t._visibility&2&&(e.return===null||e.return.tag!==13)?(t._visibility&=-3,Si(e)):ol(e);break;default:ol(e)}}function Si(e){var t=e.deletions;if((e.flags&16)!==0){if(t!==null)for(var a=0;a<t.length;a++){var n=t[a];Be=n,Af(n,e)}Tf(e)}for(e=e.child;e!==null;){switch(t=e,t.tag){case 0:case 11:case 15:ia(8,t,t.return),Si(t);break;case 22:a=t.stateNode,a._visibility&2&&(a._visibility&=-3,Si(t));break;default:Si(t)}e=e.sibling}}function Af(e,t){for(;Be!==null;){var a=Be;switch(a.tag){case 0:case 11:case 15:ia(8,a,t);break;case 23:case 22:if(a.memoizedState!==null&&a.memoizedState.cachePool!==null){var n=a.memoizedState.cachePool.pool;n!=null&&n.refCount++}break;case 24:Xn(a.memoizedState.cache)}if(n=a.child,n!==null)n.return=a,Be=n;else e:for(a=e;Be!==null;){n=Be;var l=n.sibling,i=n.return;if(pf(n),n===a){Be=null;break e}if(l!==null){l.return=i,Be=l;break e}Be=i}}}var Qm={getCacheForType:function(e){var t=Ke(Ce),a=t.data.get(e);return a===void 0&&(a=e(),t.data.set(e,a)),a}},Xm=typeof WeakMap=="function"?WeakMap:Map,ue=0,he=null,ee=null,ae=0,oe=0,ft=null,oa=!1,hn=!1,Ou=!1,Vt=0,Te=0,sa=0,qa=0,Uu=0,St=0,mn=0,sl=null,tt=null,Cu=!1,qu=0,xi=1/0,Ti=null,ra=null,Xe=0,fa=null,_n=null,pn=0,ju=0,ku=null,wf=null,rl=0,Hu=null;function dt(){if((ue&2)!==0&&ae!==0)return ae&-ae;if(A.T!==null){var e=an;return e!==0?e:Zu()}return Yo()}function zf(){St===0&&(St=(ae&536870912)===0||le?ko():536870912);var e=bt.current;return e!==null&&(e.flags|=32),St}function ht(e,t,a){(e===he&&(oe===2||oe===9)||e.cancelPendingCommit!==null)&&(gn(e,0),da(e,ae,St,!1)),Rn(e,a),((ue&2)===0||e!==he)&&(e===he&&((ue&2)===0&&(qa|=a),Te===4&&da(e,ae,St,!1)),Mt(e))}function Rf(e,t,a){if((ue&6)!==0)throw Error(r(327));var n=!a&&(t&124)===0&&(t&e.expiredLanes)===0||zn(e,t),l=n?Km(e,t):Yu(e,t,!0),i=n;do{if(l===0){hn&&!n&&da(e,t,0,!1);break}else{if(a=e.current.alternate,i&&!Zm(a)){l=Yu(e,t,!1),i=!1;continue}if(l===2){if(i=t,e.errorRecoveryDisabledLanes&i)var c=0;else c=e.pendingLanes&-536870913,c=c!==0?c:c&536870912?536870912:0;if(c!==0){t=c;e:{var o=e;l=sl;var f=o.current.memoizedState.isDehydrated;if(f&&(gn(o,c).flags|=256),c=Yu(o,c,!1),c!==2){if(Ou&&!f){o.errorRecoveryDisabledLanes|=i,qa|=i,l=4;break e}i=tt,tt=l,i!==null&&(tt===null?tt=i:tt.push.apply(tt,i))}l=c}if(i=!1,l!==2)continue}}if(l===1){gn(e,0),da(e,t,0,!0);break}e:{switch(n=e,i=l,i){case 0:case 1:throw Error(r(345));case 4:if((t&4194048)!==t)break;case 6:da(n,t,St,!oa);break e;case 2:tt=null;break;case 3:case 5:break;default:throw Error(r(329))}if((t&62914560)===t&&(l=qu+300-wt(),10<l)){if(da(n,t,St,!oa),Cl(n,0,!0)!==0)break e;n.timeoutHandle=nd(Nf.bind(null,n,a,tt,Ti,Cu,t,St,qa,mn,oa,i,2,-0,0),l);break e}Nf(n,a,tt,Ti,Cu,t,St,qa,mn,oa,i,0,-0,0)}}break}while(!0);Mt(e)}function Nf(e,t,a,n,l,i,c,o,f,y,w,N,b,S){if(e.timeoutHandle=-1,N=t.subtreeFlags,(N&8192||(N&16785408)===16785408)&&(gl={stylesheets:null,count:0,unsuspend:w_},xf(t),N=R_(),N!==null)){e.cancelPendingCommit=N(jf.bind(null,e,t,i,a,n,l,c,o,f,w,1,b,S)),da(e,i,c,!y);return}jf(e,t,i,a,n,l,c,o,f)}function Zm(e){for(var t=e;;){var a=t.tag;if((a===0||a===11||a===15)&&t.flags&16384&&(a=t.updateQueue,a!==null&&(a=a.stores,a!==null)))for(var n=0;n<a.length;n++){var l=a[n],i=l.getSnapshot;l=l.value;try{if(!ut(i(),l))return!1}catch{return!1}}if(a=t.child,t.subtreeFlags&16384&&a!==null)a.return=t,t=a;else{if(t===e)break;for(;t.sibling===null;){if(t.return===null||t.return===e)return!0;t=t.return}t.sibling.return=t.return,t=t.sibling}}return!0}function da(e,t,a,n){t&=~Uu,t&=~qa,e.suspendedLanes|=t,e.pingedLanes&=~t,n&&(e.warmLanes|=t),n=e.expirationTimes;for(var l=t;0<l;){var i=31-ct(l),c=1<<i;n[i]=-1,l&=~c}a!==0&&Bo(e,a,t)}function Ei(){return(ue&6)===0?(fl(0),!1):!0}function Bu(){if(ee!==null){if(oe===0)var e=ee.return;else e=ee,Ht=Na=null,au(e),sn=null,tl=0,e=ee;for(;e!==null;)of(e.alternate,e),e=e.return;ee=null}}function gn(e,t){var a=e.timeoutHandle;a!==-1&&(e.timeoutHandle=-1,s_(a)),a=e.cancelPendingCommit,a!==null&&(e.cancelPendingCommit=null,a()),Bu(),he=e,ee=a=qt(e.current,null),ae=t,oe=0,ft=null,oa=!1,hn=zn(e,t),Ou=!1,mn=St=Uu=qa=sa=Te=0,tt=sl=null,Cu=!1,(t&8)!==0&&(t|=t&32);var n=e.entangledLanes;if(n!==0)for(e=e.entanglements,n&=t;0<n;){var l=31-ct(n),i=1<<l;t|=e[l],n&=~i}return Vt=t,Vl(),a}function Df(e,t){P=null,A.H=fi,t===Vn||t===ti?(t=Vs(),oe=3):t===Qs?(t=Vs(),oe=4):oe=t===Kr?8:t!==null&&typeof t=="object"&&typeof t.then=="function"?6:1,ft=t,ee===null&&(Te=1,pi(e,pt(t,e.current)))}function Mf(){var e=A.H;return A.H=fi,e===null?fi:e}function Of(){var e=A.A;return A.A=Qm,e}function Lu(){Te=4,oa||(ae&4194048)!==ae&&bt.current!==null||(hn=!0),(sa&134217727)===0&&(qa&134217727)===0||he===null||da(he,ae,St,!1)}function Yu(e,t,a){var n=ue;ue|=2;var l=Mf(),i=Of();(he!==e||ae!==t)&&(Ti=null,gn(e,t)),t=!1;var c=Te;e:do try{if(oe!==0&&ee!==null){var o=ee,f=ft;switch(oe){case 8:Bu(),c=6;break e;case 3:case 2:case 9:case 6:bt.current===null&&(t=!0);var y=oe;if(oe=0,ft=null,vn(e,o,f,y),a&&hn){c=0;break e}break;default:y=oe,oe=0,ft=null,vn(e,o,f,y)}}Vm(),c=Te;break}catch(w){Df(e,w)}while(!0);return t&&e.shellSuspendCounter++,Ht=Na=null,ue=n,A.H=l,A.A=i,ee===null&&(he=null,ae=0,Vl()),c}function Vm(){for(;ee!==null;)Uf(ee)}function Km(e,t){var a=ue;ue|=2;var n=Mf(),l=Of();he!==e||ae!==t?(Ti=null,xi=wt()+500,gn(e,t)):hn=zn(e,t);e:do try{if(oe!==0&&ee!==null){t=ee;var i=ft;t:switch(oe){case 1:oe=0,ft=null,vn(e,t,i,1);break;case 2:case 9:if(Xs(i)){oe=0,ft=null,Cf(t);break}t=function(){oe!==2&&oe!==9||he!==e||(oe=7),Mt(e)},i.then(t,t);break e;case 3:oe=7;break e;case 4:oe=5;break e;case 7:Xs(i)?(oe=0,ft=null,Cf(t)):(oe=0,ft=null,vn(e,t,i,7));break;case 5:var c=null;switch(ee.tag){case 26:c=ee.memoizedState;case 5:case 27:var o=ee;if(!c||_d(c)){oe=0,ft=null;var f=o.sibling;if(f!==null)ee=f;else{var y=o.return;y!==null?(ee=y,Ai(y)):ee=null}break t}}oe=0,ft=null,vn(e,t,i,5);break;case 6:oe=0,ft=null,vn(e,t,i,6);break;case 8:Bu(),Te=6;break e;default:throw Error(r(462))}}Jm();break}catch(w){Df(e,w)}while(!0);return Ht=Na=null,A.H=n,A.A=l,ue=a,ee!==null?0:(he=null,ae=0,Vl(),Te)}function Jm(){for(;ee!==null&&!ph();)Uf(ee)}function Uf(e){var t=cf(e.alternate,e,Vt);e.memoizedProps=e.pendingProps,t===null?Ai(e):ee=t}function Cf(e){var t=e,a=t.alternate;switch(t.tag){case 15:case 0:t=Ir(a,t,t.pendingProps,t.type,void 0,ae);break;case 11:t=Ir(a,t,t.pendingProps,t.type.render,t.ref,ae);break;case 5:au(t);default:of(a,t),t=ee=Cs(t,Vt),t=cf(a,t,Vt)}e.memoizedProps=e.pendingProps,t===null?Ai(e):ee=t}function vn(e,t,a,n){Ht=Na=null,au(t),sn=null,tl=0;var l=t.return;try{if(km(e,l,t,a,ae)){Te=1,pi(e,pt(a,e.current)),ee=null;return}}catch(i){if(l!==null)throw ee=l,i;Te=1,pi(e,pt(a,e.current)),ee=null;return}t.flags&32768?(le||n===1?e=!0:hn||(ae&536870912)!==0?e=!1:(oa=e=!0,(n===2||n===9||n===3||n===6)&&(n=bt.current,n!==null&&n.tag===13&&(n.flags|=16384))),qf(t,e)):Ai(t)}function Ai(e){var t=e;do{if((t.flags&32768)!==0){qf(t,oa);return}e=t.return;var a=Bm(t.alternate,t,Vt);if(a!==null){ee=a;return}if(t=t.sibling,t!==null){ee=t;return}ee=t=e}while(t!==null);Te===0&&(Te=5)}function qf(e,t){do{var a=Lm(e.alternate,e);if(a!==null){a.flags&=32767,ee=a;return}if(a=e.return,a!==null&&(a.flags|=32768,a.subtreeFlags=0,a.deletions=null),!t&&(e=e.sibling,e!==null)){ee=e;return}ee=e=a}while(e!==null);Te=6,ee=null}function jf(e,t,a,n,l,i,c,o,f){e.cancelPendingCommit=null;do wi();while(Xe!==0);if((ue&6)!==0)throw Error(r(327));if(t!==null){if(t===e.current)throw Error(r(177));if(i=t.lanes|t.childLanes,i|=Mc,wh(e,a,i,c,o,f),e===he&&(ee=he=null,ae=0),_n=t,fa=e,pn=a,ju=i,ku=l,wf=n,(t.subtreeFlags&10256)!==0||(t.flags&10256)!==0?(e.callbackNode=null,e.callbackPriority=0,Pm(Ml,function(){return Yf(),null})):(e.callbackNode=null,e.callbackPriority=0),n=(t.flags&13878)!==0,(t.subtreeFlags&13878)!==0||n){n=A.T,A.T=null,l=q.p,q.p=2,c=ue,ue|=4;try{Ym(e,t,a)}finally{ue=c,q.p=l,A.T=n}}Xe=1,kf(),Hf(),Bf()}}function kf(){if(Xe===1){Xe=0;var e=fa,t=_n,a=(t.flags&13878)!==0;if((t.subtreeFlags&13878)!==0||a){a=A.T,A.T=null;var n=q.p;q.p=2;var l=ue;ue|=4;try{yf(t,e);var i=Iu,c=Es(e.containerInfo),o=i.focusedElem,f=i.selectionRange;if(c!==o&&o&&o.ownerDocument&&Ts(o.ownerDocument.documentElement,o)){if(f!==null&&wc(o)){var y=f.start,w=f.end;if(w===void 0&&(w=y),"selectionStart"in o)o.selectionStart=y,o.selectionEnd=Math.min(w,o.value.length);else{var N=o.ownerDocument||document,b=N&&N.defaultView||window;if(b.getSelection){var S=b.getSelection(),X=o.textContent.length,G=Math.min(f.start,X),fe=f.end===void 0?G:Math.min(f.end,X);!S.extend&&G>fe&&(c=fe,fe=G,G=c);var p=xs(o,G),h=xs(o,fe);if(p&&h&&(S.rangeCount!==1||S.anchorNode!==p.node||S.anchorOffset!==p.offset||S.focusNode!==h.node||S.focusOffset!==h.offset)){var g=N.createRange();g.setStart(p.node,p.offset),S.removeAllRanges(),G>fe?(S.addRange(g),S.extend(h.node,h.offset)):(g.setEnd(h.node,h.offset),S.addRange(g))}}}}for(N=[],S=o;S=S.parentNode;)S.nodeType===1&&N.push({element:S,left:S.scrollLeft,top:S.scrollTop});for(typeof o.focus=="function"&&o.focus(),o=0;o<N.length;o++){var z=N[o];z.element.scrollLeft=z.left,z.element.scrollTop=z.top}}Hi=!!Pu,Iu=Pu=null}finally{ue=l,q.p=n,A.T=a}}e.current=t,Xe=2}}function Hf(){if(Xe===2){Xe=0;var e=fa,t=_n,a=(t.flags&8772)!==0;if((t.subtreeFlags&8772)!==0||a){a=A.T,A.T=null;var n=q.p;q.p=2;var l=ue;ue|=4;try{_f(e,t.alternate,t)}finally{ue=l,q.p=n,A.T=a}}Xe=3}}function Bf(){if(Xe===4||Xe===3){Xe=0,gh();var e=fa,t=_n,a=pn,n=wf;(t.subtreeFlags&10256)!==0||(t.flags&10256)!==0?Xe=5:(Xe=0,_n=fa=null,Lf(e,e.pendingLanes));var l=e.pendingLanes;if(l===0&&(ra=null),ic(a),t=t.stateNode,it&&typeof it.onCommitFiberRoot=="function")try{it.onCommitFiberRoot(wn,t,void 0,(t.current.flags&128)===128)}catch{}if(n!==null){t=A.T,l=q.p,q.p=2,A.T=null;try{for(var i=e.onRecoverableError,c=0;c<n.length;c++){var o=n[c];i(o.value,{componentStack:o.stack})}}finally{A.T=t,q.p=l}}(pn&3)!==0&&wi(),Mt(e),l=e.pendingLanes,(a&4194090)!==0&&(l&42)!==0?e===Hu?rl++:(rl=0,Hu=e):rl=0,fl(0)}}function Lf(e,t){(e.pooledCacheLanes&=t)===0&&(t=e.pooledCache,t!=null&&(e.pooledCache=null,Xn(t)))}function wi(e){return kf(),Hf(),Bf(),Yf()}function Yf(){if(Xe!==5)return!1;var e=fa,t=ju;ju=0;var a=ic(pn),n=A.T,l=q.p;try{q.p=32>a?32:a,A.T=null,a=ku,ku=null;var i=fa,c=pn;if(Xe=0,_n=fa=null,pn=0,(ue&6)!==0)throw Error(r(331));var o=ue;if(ue|=4,Ef(i.current),Sf(i,i.current,c,a),ue=o,fl(0,!1),it&&typeof it.onPostCommitFiberRoot=="function")try{it.onPostCommitFiberRoot(wn,i)}catch{}return!0}finally{q.p=l,A.T=n,Lf(e,t)}}function Gf(e,t,a){t=pt(a,t),t=pu(e.stateNode,t,2),e=ta(e,t,2),e!==null&&(Rn(e,2),Mt(e))}function de(e,t,a){if(e.tag===3)Gf(e,e,a);else for(;t!==null;){if(t.tag===3){Gf(t,e,a);break}else if(t.tag===1){var n=t.stateNode;if(typeof t.type.getDerivedStateFromError=="function"||typeof n.componentDidCatch=="function"&&(ra===null||!ra.has(n))){e=pt(a,e),a=Zr(2),n=ta(t,a,2),n!==null&&(Vr(a,n,t,e),Rn(n,2),Mt(n));break}}t=t.return}}function Gu(e,t,a){var n=e.pingCache;if(n===null){n=e.pingCache=new Xm;var l=new Set;n.set(t,l)}else l=n.get(t),l===void 0&&(l=new Set,n.set(t,l));l.has(a)||(Ou=!0,l.add(a),e=$m.bind(null,e,t,a),t.then(e,e))}function $m(e,t,a){var n=e.pingCache;n!==null&&n.delete(t),e.pingedLanes|=e.suspendedLanes&a,e.warmLanes&=~a,he===e&&(ae&a)===a&&(Te===4||Te===3&&(ae&62914560)===ae&&300>wt()-qu?(ue&2)===0&&gn(e,0):Uu|=a,mn===ae&&(mn=0)),Mt(e)}function Qf(e,t){t===0&&(t=Ho()),e=Pa(e,t),e!==null&&(Rn(e,t),Mt(e))}function Wm(e){var t=e.memoizedState,a=0;t!==null&&(a=t.retryLane),Qf(e,a)}function Fm(e,t){var a=0;switch(e.tag){case 13:var n=e.stateNode,l=e.memoizedState;l!==null&&(a=l.retryLane);break;case 19:n=e.stateNode;break;case 22:n=e.stateNode._retryCache;break;default:throw Error(r(314))}n!==null&&n.delete(t),Qf(e,a)}function Pm(e,t){return tc(e,t)}var zi=null,yn=null,Qu=!1,Ri=!1,Xu=!1,ja=0;function Mt(e){e!==yn&&e.next===null&&(yn===null?zi=yn=e:yn=yn.next=e),Ri=!0,Qu||(Qu=!0,e_())}function fl(e,t){if(!Xu&&Ri){Xu=!0;do for(var a=!1,n=zi;n!==null;){if(e!==0){var l=n.pendingLanes;if(l===0)var i=0;else{var c=n.suspendedLanes,o=n.pingedLanes;i=(1<<31-ct(42|e)+1)-1,i&=l&~(c&~o),i=i&201326741?i&201326741|1:i?i|2:0}i!==0&&(a=!0,Kf(n,i))}else i=ae,i=Cl(n,n===he?i:0,n.cancelPendingCommit!==null||n.timeoutHandle!==-1),(i&3)===0||zn(n,i)||(a=!0,Kf(n,i));n=n.next}while(a);Xu=!1}}function Im(){Xf()}function Xf(){Ri=Qu=!1;var e=0;ja!==0&&(o_()&&(e=ja),ja=0);for(var t=wt(),a=null,n=zi;n!==null;){var l=n.next,i=Zf(n,t);i===0?(n.next=null,a===null?zi=l:a.next=l,l===null&&(yn=a)):(a=n,(e!==0||(i&3)!==0)&&(Ri=!0)),n=l}fl(e)}function Zf(e,t){for(var a=e.suspendedLanes,n=e.pingedLanes,l=e.expirationTimes,i=e.pendingLanes&-62914561;0<i;){var c=31-ct(i),o=1<<c,f=l[c];f===-1?((o&a)===0||(o&n)!==0)&&(l[c]=Ah(o,t)):f<=t&&(e.expiredLanes|=o),i&=~o}if(t=he,a=ae,a=Cl(e,e===t?a:0,e.cancelPendingCommit!==null||e.timeoutHandle!==-1),n=e.callbackNode,a===0||e===t&&(oe===2||oe===9)||e.cancelPendingCommit!==null)return n!==null&&n!==null&&ac(n),e.callbackNode=null,e.callbackPriority=0;if((a&3)===0||zn(e,a)){if(t=a&-a,t===e.callbackPriority)return t;switch(n!==null&&ac(n),ic(a)){case 2:case 8:a=qo;break;case 32:a=Ml;break;case 268435456:a=jo;break;default:a=Ml}return n=Vf.bind(null,e),a=tc(a,n),e.callbackPriority=t,e.callbackNode=a,t}return n!==null&&n!==null&&ac(n),e.callbackPriority=2,e.callbackNode=null,2}function Vf(e,t){if(Xe!==0&&Xe!==5)return e.callbackNode=null,e.callbackPriority=0,null;var a=e.callbackNode;if(wi()&&e.callbackNode!==a)return null;var n=ae;return n=Cl(e,e===he?n:0,e.cancelPendingCommit!==null||e.timeoutHandle!==-1),n===0?null:(Rf(e,n,t),Zf(e,wt()),e.callbackNode!=null&&e.callbackNode===a?Vf.bind(null,e):null)}function Kf(e,t){if(wi())return null;Rf(e,t,!0)}function e_(){r_(function(){(ue&6)!==0?tc(Co,Im):Xf()})}function Zu(){return ja===0&&(ja=ko()),ja}function Jf(e){return e==null||typeof e=="symbol"||typeof e=="boolean"?null:typeof e=="function"?e:Bl(""+e)}function $f(e,t){var a=t.ownerDocument.createElement("input");return a.name=t.name,a.value=t.value,e.id&&a.setAttribute("form",e.id),t.parentNode.insertBefore(a,t),e=new FormData(e),a.parentNode.removeChild(a),e}function t_(e,t,a,n,l){if(t==="submit"&&a&&a.stateNode===l){var i=Jf((l[Fe]||null).action),c=n.submitter;c&&(t=(t=c[Fe]||null)?Jf(t.formAction):c.getAttribute("formAction"),t!==null&&(i=t,c=null));var o=new Ql("action","action",null,n,l);e.push({event:o,listeners:[{instance:null,listener:function(){if(n.defaultPrevented){if(ja!==0){var f=c?$f(l,c):new FormData(l);fu(a,{pending:!0,data:f,method:l.method,action:i},null,f)}}else typeof i=="function"&&(o.preventDefault(),f=c?$f(l,c):new FormData(l),fu(a,{pending:!0,data:f,method:l.method,action:i},i,f))},currentTarget:l}]})}}for(var Vu=0;Vu<Dc.length;Vu++){var Ku=Dc[Vu],a_=Ku.toLowerCase(),n_=Ku[0].toUpperCase()+Ku.slice(1);Tt(a_,"on"+n_)}Tt(zs,"onAnimationEnd"),Tt(Rs,"onAnimationIteration"),Tt(Ns,"onAnimationStart"),Tt("dblclick","onDoubleClick"),Tt("focusin","onFocus"),Tt("focusout","onBlur"),Tt(bm,"onTransitionRun"),Tt(Sm,"onTransitionStart"),Tt(xm,"onTransitionCancel"),Tt(Ds,"onTransitionEnd"),Ga("onMouseEnter",["mouseout","mouseover"]),Ga("onMouseLeave",["mouseout","mouseover"]),Ga("onPointerEnter",["pointerout","pointerover"]),Ga("onPointerLeave",["pointerout","pointerover"]),ba("onChange","change click focusin focusout input keydown keyup selectionchange".split(" ")),ba("onSelect","focusout contextmenu dragend focusin keydown keyup mousedown mouseup selectionchange".split(" ")),ba("onBeforeInput",["compositionend","keypress","textInput","paste"]),ba("onCompositionEnd","compositionend focusout keydown keypress keyup mousedown".split(" ")),ba("onCompositionStart","compositionstart focusout keydown keypress keyup mousedown".split(" ")),ba("onCompositionUpdate","compositionupdate focusout keydown keypress keyup mousedown".split(" "));var dl="abort canplay canplaythrough durationchange emptied encrypted ended error loadeddata loadedmetadata loadstart pause play playing progress ratechange resize seeked seeking stalled suspend timeupdate volumechange waiting".split(" "),l_=new Set("beforetoggle cancel close invalid load scroll scrollend toggle".split(" ").concat(dl));function Wf(e,t){t=(t&4)!==0;for(var a=0;a<e.length;a++){var n=e[a],l=n.event;n=n.listeners;e:{var i=void 0;if(t)for(var c=n.length-1;0<=c;c--){var o=n[c],f=o.instance,y=o.currentTarget;if(o=o.listener,f!==i&&l.isPropagationStopped())break e;i=o,l.currentTarget=y;try{i(l)}catch(w){_i(w)}l.currentTarget=null,i=f}else for(c=0;c<n.length;c++){if(o=n[c],f=o.instance,y=o.currentTarget,o=o.listener,f!==i&&l.isPropagationStopped())break e;i=o,l.currentTarget=y;try{i(l)}catch(w){_i(w)}l.currentTarget=null,i=f}}}}function te(e,t){var a=t[cc];a===void 0&&(a=t[cc]=new Set);var n=e+"__bubble";a.has(n)||(Ff(t,e,2,!1),a.add(n))}function Ju(e,t,a){var n=0;t&&(n|=4),Ff(a,e,n,t)}var Ni="_reactListening"+Math.random().toString(36).slice(2);function $u(e){if(!e[Ni]){e[Ni]=!0,Qo.forEach(function(a){a!=="selectionchange"&&(l_.has(a)||Ju(a,!1,e),Ju(a,!0,e))});var t=e.nodeType===9?e:e.ownerDocument;t===null||t[Ni]||(t[Ni]=!0,Ju("selectionchange",!1,t))}}function Ff(e,t,a,n){switch(Sd(t)){case 2:var l=M_;break;case 8:l=O_;break;default:l=so}a=l.bind(null,t,a,e),l=void 0,!gc||t!=="touchstart"&&t!=="touchmove"&&t!=="wheel"||(l=!0),n?l!==void 0?e.addEventListener(t,a,{capture:!0,passive:l}):e.addEventListener(t,a,!0):l!==void 0?e.addEventListener(t,a,{passive:l}):e.addEventListener(t,a,!1)}function Wu(e,t,a,n,l){var i=n;if((t&1)===0&&(t&2)===0&&n!==null)e:for(;;){if(n===null)return;var c=n.tag;if(c===3||c===4){var o=n.stateNode.containerInfo;if(o===l)break;if(c===4)for(c=n.return;c!==null;){var f=c.tag;if((f===3||f===4)&&c.stateNode.containerInfo===l)return;c=c.return}for(;o!==null;){if(c=Ba(o),c===null)return;if(f=c.tag,f===5||f===6||f===26||f===27){n=i=c;continue e}o=o.parentNode}}n=n.return}ns(function(){var y=i,w=_c(a),N=[];e:{var b=Ms.get(e);if(b!==void 0){var S=Ql,X=e;switch(e){case"keypress":if(Yl(a)===0)break e;case"keydown":case"keyup":S=Ph;break;case"focusin":X="focus",S=Sc;break;case"focusout":X="blur",S=Sc;break;case"beforeblur":case"afterblur":S=Sc;break;case"click":if(a.button===2)break e;case"auxclick":case"dblclick":case"mousedown":case"mousemove":case"mouseup":case"mouseout":case"mouseover":case"contextmenu":S=cs;break;case"drag":case"dragend":case"dragenter":case"dragexit":case"dragleave":case"dragover":case"dragstart":case"drop":S=Lh;break;case"touchcancel":case"touchend":case"touchmove":case"touchstart":S=tm;break;case zs:case Rs:case Ns:S=Qh;break;case Ds:S=nm;break;case"scroll":case"scrollend":S=Hh;break;case"wheel":S=im;break;case"copy":case"cut":case"paste":S=Zh;break;case"gotpointercapture":case"lostpointercapture":case"pointercancel":case"pointerdown":case"pointermove":case"pointerout":case"pointerover":case"pointerup":S=os;break;case"toggle":case"beforetoggle":S=um}var G=(t&4)!==0,fe=!G&&(e==="scroll"||e==="scrollend"),p=G?b!==null?b+"Capture":null:b;G=[];for(var h=y,g;h!==null;){var z=h;if(g=z.stateNode,z=z.tag,z!==5&&z!==26&&z!==27||g===null||p===null||(z=Mn(h,p),z!=null&&G.push(hl(h,z,g))),fe)break;h=h.return}0<G.length&&(b=new S(b,X,null,a,w),N.push({event:b,listeners:G}))}}if((t&7)===0){e:{if(b=e==="mouseover"||e==="pointerover",S=e==="mouseout"||e==="pointerout",b&&a!==mc&&(X=a.relatedTarget||a.fromElement)&&(Ba(X)||X[Ha]))break e;if((S||b)&&(b=w.window===w?w:(b=w.ownerDocument)?b.defaultView||b.parentWindow:window,S?(X=a.relatedTarget||a.toElement,S=y,X=X?Ba(X):null,X!==null&&(fe=R(X),G=X.tag,X!==fe||G!==5&&G!==27&&G!==6)&&(X=null)):(S=null,X=y),S!==X)){if(G=cs,z="onMouseLeave",p="onMouseEnter",h="mouse",(e==="pointerout"||e==="pointerover")&&(G=os,z="onPointerLeave",p="onPointerEnter",h="pointer"),fe=S==null?b:Dn(S),g=X==null?b:Dn(X),b=new G(z,h+"leave",S,a,w),b.target=fe,b.relatedTarget=g,z=null,Ba(w)===y&&(G=new G(p,h+"enter",X,a,w),G.target=g,G.relatedTarget=fe,z=G),fe=z,S&&X)t:{for(G=S,p=X,h=0,g=G;g;g=bn(g))h++;for(g=0,z=p;z;z=bn(z))g++;for(;0<h-g;)G=bn(G),h--;for(;0<g-h;)p=bn(p),g--;for(;h--;){if(G===p||p!==null&&G===p.alternate)break t;G=bn(G),p=bn(p)}G=null}else G=null;S!==null&&Pf(N,b,S,G,!1),X!==null&&fe!==null&&Pf(N,fe,X,G,!0)}}e:{if(b=y?Dn(y):window,S=b.nodeName&&b.nodeName.toLowerCase(),S==="select"||S==="input"&&b.type==="file")var H=ps;else if(ms(b))if(gs)H=gm;else{H=_m;var I=mm}else S=b.nodeName,!S||S.toLowerCase()!=="input"||b.type!=="checkbox"&&b.type!=="radio"?y&&hc(y.elementType)&&(H=ps):H=pm;if(H&&(H=H(e,y))){_s(N,H,a,w);break e}I&&I(e,b,y),e==="focusout"&&y&&b.type==="number"&&y.memoizedProps.value!=null&&dc(b,"number",b.value)}switch(I=y?Dn(y):window,e){case"focusin":(ms(I)||I.contentEditable==="true")&&($a=I,zc=y,Bn=null);break;case"focusout":Bn=zc=$a=null;break;case"mousedown":Rc=!0;break;case"contextmenu":case"mouseup":case"dragend":Rc=!1,As(N,a,w);break;case"selectionchange":if(ym)break;case"keydown":case"keyup":As(N,a,w)}var B;if(Tc)e:{switch(e){case"compositionstart":var Q="onCompositionStart";break e;case"compositionend":Q="onCompositionEnd";break e;case"compositionupdate":Q="onCompositionUpdate";break e}Q=void 0}else Ja?ds(e,a)&&(Q="onCompositionEnd"):e==="keydown"&&a.keyCode===229&&(Q="onCompositionStart");Q&&(ss&&a.locale!=="ko"&&(Ja||Q!=="onCompositionStart"?Q==="onCompositionEnd"&&Ja&&(B=ls()):(Ft=w,vc="value"in Ft?Ft.value:Ft.textContent,Ja=!0)),I=Di(y,Q),0<I.length&&(Q=new us(Q,e,null,a,w),N.push({event:Q,listeners:I}),B?Q.data=B:(B=hs(a),B!==null&&(Q.data=B)))),(B=sm?rm(e,a):fm(e,a))&&(Q=Di(y,"onBeforeInput"),0<Q.length&&(I=new us("onBeforeInput","beforeinput",null,a,w),N.push({event:I,listeners:Q}),I.data=B)),t_(N,e,y,a,w)}Wf(N,t)})}function hl(e,t,a){return{instance:e,listener:t,currentTarget:a}}function Di(e,t){for(var a=t+"Capture",n=[];e!==null;){var l=e,i=l.stateNode;if(l=l.tag,l!==5&&l!==26&&l!==27||i===null||(l=Mn(e,a),l!=null&&n.unshift(hl(e,l,i)),l=Mn(e,t),l!=null&&n.push(hl(e,l,i))),e.tag===3)return n;e=e.return}return[]}function bn(e){if(e===null)return null;do e=e.return;while(e&&e.tag!==5&&e.tag!==27);return e||null}function Pf(e,t,a,n,l){for(var i=t._reactName,c=[];a!==null&&a!==n;){var o=a,f=o.alternate,y=o.stateNode;if(o=o.tag,f!==null&&f===n)break;o!==5&&o!==26&&o!==27||y===null||(f=y,l?(y=Mn(a,i),y!=null&&c.unshift(hl(a,y,f))):l||(y=Mn(a,i),y!=null&&c.push(hl(a,y,f)))),a=a.return}c.length!==0&&e.push({event:t,listeners:c})}var i_=/\r\n?/g,c_=/\u0000|\uFFFD/g;function If(e){return(typeof e=="string"?e:""+e).replace(i_,`
`).replace(c_,"")}function ed(e,t){return t=If(t),If(e)===t}function Mi(){}function re(e,t,a,n,l,i){switch(a){case"children":typeof n=="string"?t==="body"||t==="textarea"&&n===""||Za(e,n):(typeof n=="number"||typeof n=="bigint")&&t!=="body"&&Za(e,""+n);break;case"className":jl(e,"class",n);break;case"tabIndex":jl(e,"tabindex",n);break;case"dir":case"role":case"viewBox":case"width":case"height":jl(e,a,n);break;case"style":ts(e,n,i);break;case"data":if(t!=="object"){jl(e,"data",n);break}case"src":case"href":if(n===""&&(t!=="a"||a!=="href")){e.removeAttribute(a);break}if(n==null||typeof n=="function"||typeof n=="symbol"||typeof n=="boolean"){e.removeAttribute(a);break}n=Bl(""+n),e.setAttribute(a,n);break;case"action":case"formAction":if(typeof n=="function"){e.setAttribute(a,"javascript:throw new Error('A React form was unexpectedly submitted. If you called form.submit() manually, consider using form.requestSubmit() instead. If you\\'re trying to use event.stopPropagation() in a submit event handler, consider also calling event.preventDefault().')");break}else typeof i=="function"&&(a==="formAction"?(t!=="input"&&re(e,t,"name",l.name,l,null),re(e,t,"formEncType",l.formEncType,l,null),re(e,t,"formMethod",l.formMethod,l,null),re(e,t,"formTarget",l.formTarget,l,null)):(re(e,t,"encType",l.encType,l,null),re(e,t,"method",l.method,l,null),re(e,t,"target",l.target,l,null)));if(n==null||typeof n=="symbol"||typeof n=="boolean"){e.removeAttribute(a);break}n=Bl(""+n),e.setAttribute(a,n);break;case"onClick":n!=null&&(e.onclick=Mi);break;case"onScroll":n!=null&&te("scroll",e);break;case"onScrollEnd":n!=null&&te("scrollend",e);break;case"dangerouslySetInnerHTML":if(n!=null){if(typeof n!="object"||!("__html"in n))throw Error(r(61));if(a=n.__html,a!=null){if(l.children!=null)throw Error(r(60));e.innerHTML=a}}break;case"multiple":e.multiple=n&&typeof n!="function"&&typeof n!="symbol";break;case"muted":e.muted=n&&typeof n!="function"&&typeof n!="symbol";break;case"suppressContentEditableWarning":case"suppressHydrationWarning":case"defaultValue":case"defaultChecked":case"innerHTML":case"ref":break;case"autoFocus":break;case"xlinkHref":if(n==null||typeof n=="function"||typeof n=="boolean"||typeof n=="symbol"){e.removeAttribute("xlink:href");break}a=Bl(""+n),e.setAttributeNS("http://www.w3.org/1999/xlink","xlink:href",a);break;case"contentEditable":case"spellCheck":case"draggable":case"value":case"autoReverse":case"externalResourcesRequired":case"focusable":case"preserveAlpha":n!=null&&typeof n!="function"&&typeof n!="symbol"?e.setAttribute(a,""+n):e.removeAttribute(a);break;case"inert":case"allowFullScreen":case"async":case"autoPlay":case"controls":case"default":case"defer":case"disabled":case"disablePictureInPicture":case"disableRemotePlayback":case"formNoValidate":case"hidden":case"loop":case"noModule":case"noValidate":case"open":case"playsInline":case"readOnly":case"required":case"reversed":case"scoped":case"seamless":case"itemScope":n&&typeof n!="function"&&typeof n!="symbol"?e.setAttribute(a,""):e.removeAttribute(a);break;case"capture":case"download":n===!0?e.setAttribute(a,""):n!==!1&&n!=null&&typeof n!="function"&&typeof n!="symbol"?e.setAttribute(a,n):e.removeAttribute(a);break;case"cols":case"rows":case"size":case"span":n!=null&&typeof n!="function"&&typeof n!="symbol"&&!isNaN(n)&&1<=n?e.setAttribute(a,n):e.removeAttribute(a);break;case"rowSpan":case"start":n==null||typeof n=="function"||typeof n=="symbol"||isNaN(n)?e.removeAttribute(a):e.setAttribute(a,n);break;case"popover":te("beforetoggle",e),te("toggle",e),ql(e,"popover",n);break;case"xlinkActuate":Ut(e,"http://www.w3.org/1999/xlink","xlink:actuate",n);break;case"xlinkArcrole":Ut(e,"http://www.w3.org/1999/xlink","xlink:arcrole",n);break;case"xlinkRole":Ut(e,"http://www.w3.org/1999/xlink","xlink:role",n);break;case"xlinkShow":Ut(e,"http://www.w3.org/1999/xlink","xlink:show",n);break;case"xlinkTitle":Ut(e,"http://www.w3.org/1999/xlink","xlink:title",n);break;case"xlinkType":Ut(e,"http://www.w3.org/1999/xlink","xlink:type",n);break;case"xmlBase":Ut(e,"http://www.w3.org/XML/1998/namespace","xml:base",n);break;case"xmlLang":Ut(e,"http://www.w3.org/XML/1998/namespace","xml:lang",n);break;case"xmlSpace":Ut(e,"http://www.w3.org/XML/1998/namespace","xml:space",n);break;case"is":ql(e,"is",n);break;case"innerText":case"textContent":break;default:(!(2<a.length)||a[0]!=="o"&&a[0]!=="O"||a[1]!=="n"&&a[1]!=="N")&&(a=jh.get(a)||a,ql(e,a,n))}}function Fu(e,t,a,n,l,i){switch(a){case"style":ts(e,n,i);break;case"dangerouslySetInnerHTML":if(n!=null){if(typeof n!="object"||!("__html"in n))throw Error(r(61));if(a=n.__html,a!=null){if(l.children!=null)throw Error(r(60));e.innerHTML=a}}break;case"children":typeof n=="string"?Za(e,n):(typeof n=="number"||typeof n=="bigint")&&Za(e,""+n);break;case"onScroll":n!=null&&te("scroll",e);break;case"onScrollEnd":n!=null&&te("scrollend",e);break;case"onClick":n!=null&&(e.onclick=Mi);break;case"suppressContentEditableWarning":case"suppressHydrationWarning":case"innerHTML":case"ref":break;case"innerText":case"textContent":break;default:if(!Xo.hasOwnProperty(a))e:{if(a[0]==="o"&&a[1]==="n"&&(l=a.endsWith("Capture"),t=a.slice(2,l?a.length-7:void 0),i=e[Fe]||null,i=i!=null?i[a]:null,typeof i=="function"&&e.removeEventListener(t,i,l),typeof n=="function")){typeof i!="function"&&i!==null&&(a in e?e[a]=null:e.hasAttribute(a)&&e.removeAttribute(a)),e.addEventListener(t,n,l);break e}a in e?e[a]=n:n===!0?e.setAttribute(a,""):ql(e,a,n)}}}function Ze(e,t,a){switch(t){case"div":case"span":case"svg":case"path":case"a":case"g":case"p":case"li":break;case"img":te("error",e),te("load",e);var n=!1,l=!1,i;for(i in a)if(a.hasOwnProperty(i)){var c=a[i];if(c!=null)switch(i){case"src":n=!0;break;case"srcSet":l=!0;break;case"children":case"dangerouslySetInnerHTML":throw Error(r(137,t));default:re(e,t,i,c,a,null)}}l&&re(e,t,"srcSet",a.srcSet,a,null),n&&re(e,t,"src",a.src,a,null);return;case"input":te("invalid",e);var o=i=c=l=null,f=null,y=null;for(n in a)if(a.hasOwnProperty(n)){var w=a[n];if(w!=null)switch(n){case"name":l=w;break;case"type":c=w;break;case"checked":f=w;break;case"defaultChecked":y=w;break;case"value":i=w;break;case"defaultValue":o=w;break;case"children":case"dangerouslySetInnerHTML":if(w!=null)throw Error(r(137,t));break;default:re(e,t,n,w,a,null)}}Fo(e,i,o,f,y,c,l,!1),kl(e);return;case"select":te("invalid",e),n=c=i=null;for(l in a)if(a.hasOwnProperty(l)&&(o=a[l],o!=null))switch(l){case"value":i=o;break;case"defaultValue":c=o;break;case"multiple":n=o;default:re(e,t,l,o,a,null)}t=i,a=c,e.multiple=!!n,t!=null?Xa(e,!!n,t,!1):a!=null&&Xa(e,!!n,a,!0);return;case"textarea":te("invalid",e),i=l=n=null;for(c in a)if(a.hasOwnProperty(c)&&(o=a[c],o!=null))switch(c){case"value":n=o;break;case"defaultValue":l=o;break;case"children":i=o;break;case"dangerouslySetInnerHTML":if(o!=null)throw Error(r(91));break;default:re(e,t,c,o,a,null)}Io(e,n,l,i),kl(e);return;case"option":for(f in a)a.hasOwnProperty(f)&&(n=a[f],n!=null)&&(f==="selected"?e.selected=n&&typeof n!="function"&&typeof n!="symbol":re(e,t,f,n,a,null));return;case"dialog":te("beforetoggle",e),te("toggle",e),te("cancel",e),te("close",e);break;case"iframe":case"object":te("load",e);break;case"video":case"audio":for(n=0;n<dl.length;n++)te(dl[n],e);break;case"image":te("error",e),te("load",e);break;case"details":te("toggle",e);break;case"embed":case"source":case"link":te("error",e),te("load",e);case"area":case"base":case"br":case"col":case"hr":case"keygen":case"meta":case"param":case"track":case"wbr":case"menuitem":for(y in a)if(a.hasOwnProperty(y)&&(n=a[y],n!=null))switch(y){case"children":case"dangerouslySetInnerHTML":throw Error(r(137,t));default:re(e,t,y,n,a,null)}return;default:if(hc(t)){for(w in a)a.hasOwnProperty(w)&&(n=a[w],n!==void 0&&Fu(e,t,w,n,a,void 0));return}}for(o in a)a.hasOwnProperty(o)&&(n=a[o],n!=null&&re(e,t,o,n,a,null))}function u_(e,t,a,n){switch(t){case"div":case"span":case"svg":case"path":case"a":case"g":case"p":case"li":break;case"input":var l=null,i=null,c=null,o=null,f=null,y=null,w=null;for(S in a){var N=a[S];if(a.hasOwnProperty(S)&&N!=null)switch(S){case"checked":break;case"value":break;case"defaultValue":f=N;default:n.hasOwnProperty(S)||re(e,t,S,null,n,N)}}for(var b in n){var S=n[b];if(N=a[b],n.hasOwnProperty(b)&&(S!=null||N!=null))switch(b){case"type":i=S;break;case"name":l=S;break;case"checked":y=S;break;case"defaultChecked":w=S;break;case"value":c=S;break;case"defaultValue":o=S;break;case"children":case"dangerouslySetInnerHTML":if(S!=null)throw Error(r(137,t));break;default:S!==N&&re(e,t,b,S,n,N)}}fc(e,c,o,f,y,w,i,l);return;case"select":S=c=o=b=null;for(i in a)if(f=a[i],a.hasOwnProperty(i)&&f!=null)switch(i){case"value":break;case"multiple":S=f;default:n.hasOwnProperty(i)||re(e,t,i,null,n,f)}for(l in n)if(i=n[l],f=a[l],n.hasOwnProperty(l)&&(i!=null||f!=null))switch(l){case"value":b=i;break;case"defaultValue":o=i;break;case"multiple":c=i;default:i!==f&&re(e,t,l,i,n,f)}t=o,a=c,n=S,b!=null?Xa(e,!!a,b,!1):!!n!=!!a&&(t!=null?Xa(e,!!a,t,!0):Xa(e,!!a,a?[]:"",!1));return;case"textarea":S=b=null;for(o in a)if(l=a[o],a.hasOwnProperty(o)&&l!=null&&!n.hasOwnProperty(o))switch(o){case"value":break;case"children":break;default:re(e,t,o,null,n,l)}for(c in n)if(l=n[c],i=a[c],n.hasOwnProperty(c)&&(l!=null||i!=null))switch(c){case"value":b=l;break;case"defaultValue":S=l;break;case"children":break;case"dangerouslySetInnerHTML":if(l!=null)throw Error(r(91));break;default:l!==i&&re(e,t,c,l,n,i)}Po(e,b,S);return;case"option":for(var X in a)b=a[X],a.hasOwnProperty(X)&&b!=null&&!n.hasOwnProperty(X)&&(X==="selected"?e.selected=!1:re(e,t,X,null,n,b));for(f in n)b=n[f],S=a[f],n.hasOwnProperty(f)&&b!==S&&(b!=null||S!=null)&&(f==="selected"?e.selected=b&&typeof b!="function"&&typeof b!="symbol":re(e,t,f,b,n,S));return;case"img":case"link":case"area":case"base":case"br":case"col":case"embed":case"hr":case"keygen":case"meta":case"param":case"source":case"track":case"wbr":case"menuitem":for(var G in a)b=a[G],a.hasOwnProperty(G)&&b!=null&&!n.hasOwnProperty(G)&&re(e,t,G,null,n,b);for(y in n)if(b=n[y],S=a[y],n.hasOwnProperty(y)&&b!==S&&(b!=null||S!=null))switch(y){case"children":case"dangerouslySetInnerHTML":if(b!=null)throw Error(r(137,t));break;default:re(e,t,y,b,n,S)}return;default:if(hc(t)){for(var fe in a)b=a[fe],a.hasOwnProperty(fe)&&b!==void 0&&!n.hasOwnProperty(fe)&&Fu(e,t,fe,void 0,n,b);for(w in n)b=n[w],S=a[w],!n.hasOwnProperty(w)||b===S||b===void 0&&S===void 0||Fu(e,t,w,b,n,S);return}}for(var p in a)b=a[p],a.hasOwnProperty(p)&&b!=null&&!n.hasOwnProperty(p)&&re(e,t,p,null,n,b);for(N in n)b=n[N],S=a[N],!n.hasOwnProperty(N)||b===S||b==null&&S==null||re(e,t,N,b,n,S)}var Pu=null,Iu=null;function Oi(e){return e.nodeType===9?e:e.ownerDocument}function td(e){switch(e){case"http://www.w3.org/2000/svg":return 1;case"http://www.w3.org/1998/Math/MathML":return 2;default:return 0}}function ad(e,t){if(e===0)switch(t){case"svg":return 1;case"math":return 2;default:return 0}return e===1&&t==="foreignObject"?0:e}function eo(e,t){return e==="textarea"||e==="noscript"||typeof t.children=="string"||typeof t.children=="number"||typeof t.children=="bigint"||typeof t.dangerouslySetInnerHTML=="object"&&t.dangerouslySetInnerHTML!==null&&t.dangerouslySetInnerHTML.__html!=null}var to=null;function o_(){var e=window.event;return e&&e.type==="popstate"?e===to?!1:(to=e,!0):(to=null,!1)}var nd=typeof setTimeout=="function"?setTimeout:void 0,s_=typeof clearTimeout=="function"?clearTimeout:void 0,ld=typeof Promise=="function"?Promise:void 0,r_=typeof queueMicrotask=="function"?queueMicrotask:typeof ld<"u"?function(e){return ld.resolve(null).then(e).catch(f_)}:nd;function f_(e){setTimeout(function(){throw e})}function ha(e){return e==="head"}function id(e,t){var a=t,n=0,l=0;do{var i=a.nextSibling;if(e.removeChild(a),i&&i.nodeType===8)if(a=i.data,a==="/$"){if(0<n&&8>n){a=n;var c=e.ownerDocument;if(a&1&&ml(c.documentElement),a&2&&ml(c.body),a&4)for(a=c.head,ml(a),c=a.firstChild;c;){var o=c.nextSibling,f=c.nodeName;c[Nn]||f==="SCRIPT"||f==="STYLE"||f==="LINK"&&c.rel.toLowerCase()==="stylesheet"||a.removeChild(c),c=o}}if(l===0){e.removeChild(i),xl(t);return}l--}else a==="$"||a==="$?"||a==="$!"?l++:n=a.charCodeAt(0)-48;else n=0;a=i}while(a);xl(t)}function ao(e){var t=e.firstChild;for(t&&t.nodeType===10&&(t=t.nextSibling);t;){var a=t;switch(t=t.nextSibling,a.nodeName){case"HTML":case"HEAD":case"BODY":ao(a),uc(a);continue;case"SCRIPT":case"STYLE":continue;case"LINK":if(a.rel.toLowerCase()==="stylesheet")continue}e.removeChild(a)}}function d_(e,t,a,n){for(;e.nodeType===1;){var l=a;if(e.nodeName.toLowerCase()!==t.toLowerCase()){if(!n&&(e.nodeName!=="INPUT"||e.type!=="hidden"))break}else if(n){if(!e[Nn])switch(t){case"meta":if(!e.hasAttribute("itemprop"))break;return e;case"link":if(i=e.getAttribute("rel"),i==="stylesheet"&&e.hasAttribute("data-precedence"))break;if(i!==l.rel||e.getAttribute("href")!==(l.href==null||l.href===""?null:l.href)||e.getAttribute("crossorigin")!==(l.crossOrigin==null?null:l.crossOrigin)||e.getAttribute("title")!==(l.title==null?null:l.title))break;return e;case"style":if(e.hasAttribute("data-precedence"))break;return e;case"script":if(i=e.getAttribute("src"),(i!==(l.src==null?null:l.src)||e.getAttribute("type")!==(l.type==null?null:l.type)||e.getAttribute("crossorigin")!==(l.crossOrigin==null?null:l.crossOrigin))&&i&&e.hasAttribute("async")&&!e.hasAttribute("itemprop"))break;return e;default:return e}}else if(t==="input"&&e.type==="hidden"){var i=l.name==null?null:""+l.name;if(l.type==="hidden"&&e.getAttribute("name")===i)return e}else return e;if(e=At(e.nextSibling),e===null)break}return null}function h_(e,t,a){if(t==="")return null;for(;e.nodeType!==3;)if((e.nodeType!==1||e.nodeName!=="INPUT"||e.type!=="hidden")&&!a||(e=At(e.nextSibling),e===null))return null;return e}function no(e){return e.data==="$!"||e.data==="$?"&&e.ownerDocument.readyState==="complete"}function m_(e,t){var a=e.ownerDocument;if(e.data!=="$?"||a.readyState==="complete")t();else{var n=function(){t(),a.removeEventListener("DOMContentLoaded",n)};a.addEventListener("DOMContentLoaded",n),e._reactRetry=n}}function At(e){for(;e!=null;e=e.nextSibling){var t=e.nodeType;if(t===1||t===3)break;if(t===8){if(t=e.data,t==="$"||t==="$!"||t==="$?"||t==="F!"||t==="F")break;if(t==="/$")return null}}return e}var lo=null;function cd(e){e=e.previousSibling;for(var t=0;e;){if(e.nodeType===8){var a=e.data;if(a==="$"||a==="$!"||a==="$?"){if(t===0)return e;t--}else a==="/$"&&t++}e=e.previousSibling}return null}function ud(e,t,a){switch(t=Oi(a),e){case"html":if(e=t.documentElement,!e)throw Error(r(452));return e;case"head":if(e=t.head,!e)throw Error(r(453));return e;case"body":if(e=t.body,!e)throw Error(r(454));return e;default:throw Error(r(451))}}function ml(e){for(var t=e.attributes;t.length;)e.removeAttributeNode(t[0]);uc(e)}var xt=new Map,od=new Set;function Ui(e){return typeof e.getRootNode=="function"?e.getRootNode():e.nodeType===9?e:e.ownerDocument}var Kt=q.d;q.d={f:__,r:p_,D:g_,C:v_,L:y_,m:b_,X:x_,S:S_,M:T_};function __(){var e=Kt.f(),t=Ei();return e||t}function p_(e){var t=La(e);t!==null&&t.tag===5&&t.type==="form"?zr(t):Kt.r(e)}var Sn=typeof document>"u"?null:document;function sd(e,t,a){var n=Sn;if(n&&typeof t=="string"&&t){var l=_t(t);l='link[rel="'+e+'"][href="'+l+'"]',typeof a=="string"&&(l+='[crossorigin="'+a+'"]'),od.has(l)||(od.add(l),e={rel:e,crossOrigin:a,href:t},n.querySelector(l)===null&&(t=n.createElement("link"),Ze(t,"link",e),ke(t),n.head.appendChild(t)))}}function g_(e){Kt.D(e),sd("dns-prefetch",e,null)}function v_(e,t){Kt.C(e,t),sd("preconnect",e,t)}function y_(e,t,a){Kt.L(e,t,a);var n=Sn;if(n&&e&&t){var l='link[rel="preload"][as="'+_t(t)+'"]';t==="image"&&a&&a.imageSrcSet?(l+='[imagesrcset="'+_t(a.imageSrcSet)+'"]',typeof a.imageSizes=="string"&&(l+='[imagesizes="'+_t(a.imageSizes)+'"]')):l+='[href="'+_t(e)+'"]';var i=l;switch(t){case"style":i=xn(e);break;case"script":i=Tn(e)}xt.has(i)||(e=O({rel:"preload",href:t==="image"&&a&&a.imageSrcSet?void 0:e,as:t},a),xt.set(i,e),n.querySelector(l)!==null||t==="style"&&n.querySelector(_l(i))||t==="script"&&n.querySelector(pl(i))||(t=n.createElement("link"),Ze(t,"link",e),ke(t),n.head.appendChild(t)))}}function b_(e,t){Kt.m(e,t);var a=Sn;if(a&&e){var n=t&&typeof t.as=="string"?t.as:"script",l='link[rel="modulepreload"][as="'+_t(n)+'"][href="'+_t(e)+'"]',i=l;switch(n){case"audioworklet":case"paintworklet":case"serviceworker":case"sharedworker":case"worker":case"script":i=Tn(e)}if(!xt.has(i)&&(e=O({rel:"modulepreload",href:e},t),xt.set(i,e),a.querySelector(l)===null)){switch(n){case"audioworklet":case"paintworklet":case"serviceworker":case"sharedworker":case"worker":case"script":if(a.querySelector(pl(i)))return}n=a.createElement("link"),Ze(n,"link",e),ke(n),a.head.appendChild(n)}}}function S_(e,t,a){Kt.S(e,t,a);var n=Sn;if(n&&e){var l=Ya(n).hoistableStyles,i=xn(e);t=t||"default";var c=l.get(i);if(!c){var o={loading:0,preload:null};if(c=n.querySelector(_l(i)))o.loading=5;else{e=O({rel:"stylesheet",href:e,"data-precedence":t},a),(a=xt.get(i))&&io(e,a);var f=c=n.createElement("link");ke(f),Ze(f,"link",e),f._p=new Promise(function(y,w){f.onload=y,f.onerror=w}),f.addEventListener("load",function(){o.loading|=1}),f.addEventListener("error",function(){o.loading|=2}),o.loading|=4,Ci(c,t,n)}c={type:"stylesheet",instance:c,count:1,state:o},l.set(i,c)}}}function x_(e,t){Kt.X(e,t);var a=Sn;if(a&&e){var n=Ya(a).hoistableScripts,l=Tn(e),i=n.get(l);i||(i=a.querySelector(pl(l)),i||(e=O({src:e,async:!0},t),(t=xt.get(l))&&co(e,t),i=a.createElement("script"),ke(i),Ze(i,"link",e),a.head.appendChild(i)),i={type:"script",instance:i,count:1,state:null},n.set(l,i))}}function T_(e,t){Kt.M(e,t);var a=Sn;if(a&&e){var n=Ya(a).hoistableScripts,l=Tn(e),i=n.get(l);i||(i=a.querySelector(pl(l)),i||(e=O({src:e,async:!0,type:"module"},t),(t=xt.get(l))&&co(e,t),i=a.createElement("script"),ke(i),Ze(i,"link",e),a.head.appendChild(i)),i={type:"script",instance:i,count:1,state:null},n.set(l,i))}}function rd(e,t,a,n){var l=(l=Z.current)?Ui(l):null;if(!l)throw Error(r(446));switch(e){case"meta":case"title":return null;case"style":return typeof a.precedence=="string"&&typeof a.href=="string"?(t=xn(a.href),a=Ya(l).hoistableStyles,n=a.get(t),n||(n={type:"style",instance:null,count:0,state:null},a.set(t,n)),n):{type:"void",instance:null,count:0,state:null};case"link":if(a.rel==="stylesheet"&&typeof a.href=="string"&&typeof a.precedence=="string"){e=xn(a.href);var i=Ya(l).hoistableStyles,c=i.get(e);if(c||(l=l.ownerDocument||l,c={type:"stylesheet",instance:null,count:0,state:{loading:0,preload:null}},i.set(e,c),(i=l.querySelector(_l(e)))&&!i._p&&(c.instance=i,c.state.loading=5),xt.has(e)||(a={rel:"preload",as:"style",href:a.href,crossOrigin:a.crossOrigin,integrity:a.integrity,media:a.media,hrefLang:a.hrefLang,referrerPolicy:a.referrerPolicy},xt.set(e,a),i||E_(l,e,a,c.state))),t&&n===null)throw Error(r(528,""));return c}if(t&&n!==null)throw Error(r(529,""));return null;case"script":return t=a.async,a=a.src,typeof a=="string"&&t&&typeof t!="function"&&typeof t!="symbol"?(t=Tn(a),a=Ya(l).hoistableScripts,n=a.get(t),n||(n={type:"script",instance:null,count:0,state:null},a.set(t,n)),n):{type:"void",instance:null,count:0,state:null};default:throw Error(r(444,e))}}function xn(e){return'href="'+_t(e)+'"'}function _l(e){return'link[rel="stylesheet"]['+e+"]"}function fd(e){return O({},e,{"data-precedence":e.precedence,precedence:null})}function E_(e,t,a,n){e.querySelector('link[rel="preload"][as="style"]['+t+"]")?n.loading=1:(t=e.createElement("link"),n.preload=t,t.addEventListener("load",function(){return n.loading|=1}),t.addEventListener("error",function(){return n.loading|=2}),Ze(t,"link",a),ke(t),e.head.appendChild(t))}function Tn(e){return'[src="'+_t(e)+'"]'}function pl(e){return"script[async]"+e}function dd(e,t,a){if(t.count++,t.instance===null)switch(t.type){case"style":var n=e.querySelector('style[data-href~="'+_t(a.href)+'"]');if(n)return t.instance=n,ke(n),n;var l=O({},a,{"data-href":a.href,"data-precedence":a.precedence,href:null,precedence:null});return n=(e.ownerDocument||e).createElement("style"),ke(n),Ze(n,"style",l),Ci(n,a.precedence,e),t.instance=n;case"stylesheet":l=xn(a.href);var i=e.querySelector(_l(l));if(i)return t.state.loading|=4,t.instance=i,ke(i),i;n=fd(a),(l=xt.get(l))&&io(n,l),i=(e.ownerDocument||e).createElement("link"),ke(i);var c=i;return c._p=new Promise(function(o,f){c.onload=o,c.onerror=f}),Ze(i,"link",n),t.state.loading|=4,Ci(i,a.precedence,e),t.instance=i;case"script":return i=Tn(a.src),(l=e.querySelector(pl(i)))?(t.instance=l,ke(l),l):(n=a,(l=xt.get(i))&&(n=O({},a),co(n,l)),e=e.ownerDocument||e,l=e.createElement("script"),ke(l),Ze(l,"link",n),e.head.appendChild(l),t.instance=l);case"void":return null;default:throw Error(r(443,t.type))}else t.type==="stylesheet"&&(t.state.loading&4)===0&&(n=t.instance,t.state.loading|=4,Ci(n,a.precedence,e));return t.instance}function Ci(e,t,a){for(var n=a.querySelectorAll('link[rel="stylesheet"][data-precedence],style[data-precedence]'),l=n.length?n[n.length-1]:null,i=l,c=0;c<n.length;c++){var o=n[c];if(o.dataset.precedence===t)i=o;else if(i!==l)break}i?i.parentNode.insertBefore(e,i.nextSibling):(t=a.nodeType===9?a.head:a,t.insertBefore(e,t.firstChild))}function io(e,t){e.crossOrigin==null&&(e.crossOrigin=t.crossOrigin),e.referrerPolicy==null&&(e.referrerPolicy=t.referrerPolicy),e.title==null&&(e.title=t.title)}function co(e,t){e.crossOrigin==null&&(e.crossOrigin=t.crossOrigin),e.referrerPolicy==null&&(e.referrerPolicy=t.referrerPolicy),e.integrity==null&&(e.integrity=t.integrity)}var qi=null;function hd(e,t,a){if(qi===null){var n=new Map,l=qi=new Map;l.set(a,n)}else l=qi,n=l.get(a),n||(n=new Map,l.set(a,n));if(n.has(e))return n;for(n.set(e,null),a=a.getElementsByTagName(e),l=0;l<a.length;l++){var i=a[l];if(!(i[Nn]||i[Ve]||e==="link"&&i.getAttribute("rel")==="stylesheet")&&i.namespaceURI!=="http://www.w3.org/2000/svg"){var c=i.getAttribute(t)||"";c=e+c;var o=n.get(c);o?o.push(i):n.set(c,[i])}}return n}function md(e,t,a){e=e.ownerDocument||e,e.head.insertBefore(a,t==="title"?e.querySelector("head > title"):null)}function A_(e,t,a){if(a===1||t.itemProp!=null)return!1;switch(e){case"meta":case"title":return!0;case"style":if(typeof t.precedence!="string"||typeof t.href!="string"||t.href==="")break;return!0;case"link":if(typeof t.rel!="string"||typeof t.href!="string"||t.href===""||t.onLoad||t.onError)break;return t.rel==="stylesheet"?(e=t.disabled,typeof t.precedence=="string"&&e==null):!0;case"script":if(t.async&&typeof t.async!="function"&&typeof t.async!="symbol"&&!t.onLoad&&!t.onError&&t.src&&typeof t.src=="string")return!0}return!1}function _d(e){return!(e.type==="stylesheet"&&(e.state.loading&3)===0)}var gl=null;function w_(){}function z_(e,t,a){if(gl===null)throw Error(r(475));var n=gl;if(t.type==="stylesheet"&&(typeof a.media!="string"||matchMedia(a.media).matches!==!1)&&(t.state.loading&4)===0){if(t.instance===null){var l=xn(a.href),i=e.querySelector(_l(l));if(i){e=i._p,e!==null&&typeof e=="object"&&typeof e.then=="function"&&(n.count++,n=ji.bind(n),e.then(n,n)),t.state.loading|=4,t.instance=i,ke(i);return}i=e.ownerDocument||e,a=fd(a),(l=xt.get(l))&&io(a,l),i=i.createElement("link"),ke(i);var c=i;c._p=new Promise(function(o,f){c.onload=o,c.onerror=f}),Ze(i,"link",a),t.instance=i}n.stylesheets===null&&(n.stylesheets=new Map),n.stylesheets.set(t,e),(e=t.state.preload)&&(t.state.loading&3)===0&&(n.count++,t=ji.bind(n),e.addEventListener("load",t),e.addEventListener("error",t))}}function R_(){if(gl===null)throw Error(r(475));var e=gl;return e.stylesheets&&e.count===0&&uo(e,e.stylesheets),0<e.count?function(t){var a=setTimeout(function(){if(e.stylesheets&&uo(e,e.stylesheets),e.unsuspend){var n=e.unsuspend;e.unsuspend=null,n()}},6e4);return e.unsuspend=t,function(){e.unsuspend=null,clearTimeout(a)}}:null}function ji(){if(this.count--,this.count===0){if(this.stylesheets)uo(this,this.stylesheets);else if(this.unsuspend){var e=this.unsuspend;this.unsuspend=null,e()}}}var ki=null;function uo(e,t){e.stylesheets=null,e.unsuspend!==null&&(e.count++,ki=new Map,t.forEach(N_,e),ki=null,ji.call(e))}function N_(e,t){if(!(t.state.loading&4)){var a=ki.get(e);if(a)var n=a.get(null);else{a=new Map,ki.set(e,a);for(var l=e.querySelectorAll("link[data-precedence],style[data-precedence]"),i=0;i<l.length;i++){var c=l[i];(c.nodeName==="LINK"||c.getAttribute("media")!=="not all")&&(a.set(c.dataset.precedence,c),n=c)}n&&a.set(null,n)}l=t.instance,c=l.getAttribute("data-precedence"),i=a.get(c)||n,i===n&&a.set(null,l),a.set(c,l),this.count++,n=ji.bind(this),l.addEventListener("load",n),l.addEventListener("error",n),i?i.parentNode.insertBefore(l,i.nextSibling):(e=e.nodeType===9?e.head:e,e.insertBefore(l,e.firstChild)),t.state.loading|=4}}var vl={$$typeof:be,Provider:null,Consumer:null,_currentValue:Y,_currentValue2:Y,_threadCount:0};function D_(e,t,a,n,l,i,c,o){this.tag=1,this.containerInfo=e,this.pingCache=this.current=this.pendingChildren=null,this.timeoutHandle=-1,this.callbackNode=this.next=this.pendingContext=this.context=this.cancelPendingCommit=null,this.callbackPriority=0,this.expirationTimes=nc(-1),this.entangledLanes=this.shellSuspendCounter=this.errorRecoveryDisabledLanes=this.expiredLanes=this.warmLanes=this.pingedLanes=this.suspendedLanes=this.pendingLanes=0,this.entanglements=nc(0),this.hiddenUpdates=nc(null),this.identifierPrefix=n,this.onUncaughtError=l,this.onCaughtError=i,this.onRecoverableError=c,this.pooledCache=null,this.pooledCacheLanes=0,this.formState=o,this.incompleteTransitions=new Map}function pd(e,t,a,n,l,i,c,o,f,y,w,N){return e=new D_(e,t,a,c,o,f,y,N),t=1,i===!0&&(t|=24),i=ot(3,null,null,t),e.current=i,i.stateNode=e,t=Gc(),t.refCount++,e.pooledCache=t,t.refCount++,i.memoizedState={element:n,isDehydrated:a,cache:t},Vc(i),e}function gd(e){return e?(e=Ia,e):Ia}function vd(e,t,a,n,l,i){l=gd(l),n.context===null?n.context=l:n.pendingContext=l,n=ea(t),n.payload={element:a},i=i===void 0?null:i,i!==null&&(n.callback=i),a=ta(e,n,t),a!==null&&(ht(a,e,t),Jn(a,e,t))}function yd(e,t){if(e=e.memoizedState,e!==null&&e.dehydrated!==null){var a=e.retryLane;e.retryLane=a!==0&&a<t?a:t}}function oo(e,t){yd(e,t),(e=e.alternate)&&yd(e,t)}function bd(e){if(e.tag===13){var t=Pa(e,67108864);t!==null&&ht(t,e,67108864),oo(e,67108864)}}var Hi=!0;function M_(e,t,a,n){var l=A.T;A.T=null;var i=q.p;try{q.p=2,so(e,t,a,n)}finally{q.p=i,A.T=l}}function O_(e,t,a,n){var l=A.T;A.T=null;var i=q.p;try{q.p=8,so(e,t,a,n)}finally{q.p=i,A.T=l}}function so(e,t,a,n){if(Hi){var l=ro(n);if(l===null)Wu(e,t,n,Bi,a),xd(e,n);else if(C_(l,e,t,a,n))n.stopPropagation();else if(xd(e,n),t&4&&-1<U_.indexOf(e)){for(;l!==null;){var i=La(l);if(i!==null)switch(i.tag){case 3:if(i=i.stateNode,i.current.memoizedState.isDehydrated){var c=ya(i.pendingLanes);if(c!==0){var o=i;for(o.pendingLanes|=2,o.entangledLanes|=2;c;){var f=1<<31-ct(c);o.entanglements[1]|=f,c&=~f}Mt(i),(ue&6)===0&&(xi=wt()+500,fl(0))}}break;case 13:o=Pa(i,2),o!==null&&ht(o,i,2),Ei(),oo(i,2)}if(i=ro(n),i===null&&Wu(e,t,n,Bi,a),i===l)break;l=i}l!==null&&n.stopPropagation()}else Wu(e,t,n,null,a)}}function ro(e){return e=_c(e),fo(e)}var Bi=null;function fo(e){if(Bi=null,e=Ba(e),e!==null){var t=R(e);if(t===null)e=null;else{var a=t.tag;if(a===13){if(e=C(t),e!==null)return e;e=null}else if(a===3){if(t.stateNode.current.memoizedState.isDehydrated)return t.tag===3?t.stateNode.containerInfo:null;e=null}else t!==e&&(e=null)}}return Bi=e,null}function Sd(e){switch(e){case"beforetoggle":case"cancel":case"click":case"close":case"contextmenu":case"copy":case"cut":case"auxclick":case"dblclick":case"dragend":case"dragstart":case"drop":case"focusin":case"focusout":case"input":case"invalid":case"keydown":case"keypress":case"keyup":case"mousedown":case"mouseup":case"paste":case"pause":case"play":case"pointercancel":case"pointerdown":case"pointerup":case"ratechange":case"reset":case"resize":case"seeked":case"submit":case"toggle":case"touchcancel":case"touchend":case"touchstart":case"volumechange":case"change":case"selectionchange":case"textInput":case"compositionstart":case"compositionend":case"compositionupdate":case"beforeblur":case"afterblur":case"beforeinput":case"blur":case"fullscreenchange":case"focus":case"hashchange":case"popstate":case"select":case"selectstart":return 2;case"drag":case"dragenter":case"dragexit":case"dragleave":case"dragover":case"mousemove":case"mouseout":case"mouseover":case"pointermove":case"pointerout":case"pointerover":case"scroll":case"touchmove":case"wheel":case"mouseenter":case"mouseleave":case"pointerenter":case"pointerleave":return 8;case"message":switch(vh()){case Co:return 2;case qo:return 8;case Ml:case yh:return 32;case jo:return 268435456;default:return 32}default:return 32}}var ho=!1,ma=null,_a=null,pa=null,yl=new Map,bl=new Map,ga=[],U_="mousedown mouseup touchcancel touchend touchstart auxclick dblclick pointercancel pointerdown pointerup dragend dragstart drop compositionend compositionstart keydown keypress keyup input textInput copy cut paste click change contextmenu reset".split(" ");function xd(e,t){switch(e){case"focusin":case"focusout":ma=null;break;case"dragenter":case"dragleave":_a=null;break;case"mouseover":case"mouseout":pa=null;break;case"pointerover":case"pointerout":yl.delete(t.pointerId);break;case"gotpointercapture":case"lostpointercapture":bl.delete(t.pointerId)}}function Sl(e,t,a,n,l,i){return e===null||e.nativeEvent!==i?(e={blockedOn:t,domEventName:a,eventSystemFlags:n,nativeEvent:i,targetContainers:[l]},t!==null&&(t=La(t),t!==null&&bd(t)),e):(e.eventSystemFlags|=n,t=e.targetContainers,l!==null&&t.indexOf(l)===-1&&t.push(l),e)}function C_(e,t,a,n,l){switch(t){case"focusin":return ma=Sl(ma,e,t,a,n,l),!0;case"dragenter":return _a=Sl(_a,e,t,a,n,l),!0;case"mouseover":return pa=Sl(pa,e,t,a,n,l),!0;case"pointerover":var i=l.pointerId;return yl.set(i,Sl(yl.get(i)||null,e,t,a,n,l)),!0;case"gotpointercapture":return i=l.pointerId,bl.set(i,Sl(bl.get(i)||null,e,t,a,n,l)),!0}return!1}function Td(e){var t=Ba(e.target);if(t!==null){var a=R(t);if(a!==null){if(t=a.tag,t===13){if(t=C(a),t!==null){e.blockedOn=t,zh(e.priority,function(){if(a.tag===13){var n=dt();n=lc(n);var l=Pa(a,n);l!==null&&ht(l,a,n),oo(a,n)}});return}}else if(t===3&&a.stateNode.current.memoizedState.isDehydrated){e.blockedOn=a.tag===3?a.stateNode.containerInfo:null;return}}}e.blockedOn=null}function Li(e){if(e.blockedOn!==null)return!1;for(var t=e.targetContainers;0<t.length;){var a=ro(e.nativeEvent);if(a===null){a=e.nativeEvent;var n=new a.constructor(a.type,a);mc=n,a.target.dispatchEvent(n),mc=null}else return t=La(a),t!==null&&bd(t),e.blockedOn=a,!1;t.shift()}return!0}function Ed(e,t,a){Li(e)&&a.delete(t)}function q_(){ho=!1,ma!==null&&Li(ma)&&(ma=null),_a!==null&&Li(_a)&&(_a=null),pa!==null&&Li(pa)&&(pa=null),yl.forEach(Ed),bl.forEach(Ed)}function Yi(e,t){e.blockedOn===t&&(e.blockedOn=null,ho||(ho=!0,u.unstable_scheduleCallback(u.unstable_NormalPriority,q_)))}var Gi=null;function Ad(e){Gi!==e&&(Gi=e,u.unstable_scheduleCallback(u.unstable_NormalPriority,function(){Gi===e&&(Gi=null);for(var t=0;t<e.length;t+=3){var a=e[t],n=e[t+1],l=e[t+2];if(typeof n!="function"){if(fo(n||a)===null)continue;break}var i=La(a);i!==null&&(e.splice(t,3),t-=3,fu(i,{pending:!0,data:l,method:a.method,action:n},n,l))}}))}function xl(e){function t(f){return Yi(f,e)}ma!==null&&Yi(ma,e),_a!==null&&Yi(_a,e),pa!==null&&Yi(pa,e),yl.forEach(t),bl.forEach(t);for(var a=0;a<ga.length;a++){var n=ga[a];n.blockedOn===e&&(n.blockedOn=null)}for(;0<ga.length&&(a=ga[0],a.blockedOn===null);)Td(a),a.blockedOn===null&&ga.shift();if(a=(e.ownerDocument||e).$$reactFormReplay,a!=null)for(n=0;n<a.length;n+=3){var l=a[n],i=a[n+1],c=l[Fe]||null;if(typeof i=="function")c||Ad(a);else if(c){var o=null;if(i&&i.hasAttribute("formAction")){if(l=i,c=i[Fe]||null)o=c.formAction;else if(fo(l)!==null)continue}else o=c.action;typeof o=="function"?a[n+1]=o:(a.splice(n,3),n-=3),Ad(a)}}}function mo(e){this._internalRoot=e}Qi.prototype.render=mo.prototype.render=function(e){var t=this._internalRoot;if(t===null)throw Error(r(409));var a=t.current,n=dt();vd(a,n,e,t,null,null)},Qi.prototype.unmount=mo.prototype.unmount=function(){var e=this._internalRoot;if(e!==null){this._internalRoot=null;var t=e.containerInfo;vd(e.current,2,null,e,null,null),Ei(),t[Ha]=null}};function Qi(e){this._internalRoot=e}Qi.prototype.unstable_scheduleHydration=function(e){if(e){var t=Yo();e={blockedOn:null,target:e,priority:t};for(var a=0;a<ga.length&&t!==0&&t<ga[a].priority;a++);ga.splice(a,0,e),a===0&&Td(e)}};var wd=s.version;if(wd!=="19.1.1")throw Error(r(527,wd,"19.1.1"));q.findDOMNode=function(e){var t=e._reactInternals;if(t===void 0)throw typeof e.render=="function"?Error(r(188)):(e=Object.keys(e).join(","),Error(r(268,e)));return e=v(t),e=e!==null?x(e):null,e=e===null?null:e.stateNode,e};var j_={bundleType:0,version:"19.1.1",rendererPackageName:"react-dom",currentDispatcherRef:A,reconcilerVersion:"19.1.1"};if(typeof __REACT_DEVTOOLS_GLOBAL_HOOK__<"u"){var Xi=__REACT_DEVTOOLS_GLOBAL_HOOK__;if(!Xi.isDisabled&&Xi.supportsFiber)try{wn=Xi.inject(j_),it=Xi}catch{}}return El.createRoot=function(e,t){if(!E(e))throw Error(r(299));var a=!1,n="",l=Yr,i=Gr,c=Qr,o=null;return t!=null&&(t.unstable_strictMode===!0&&(a=!0),t.identifierPrefix!==void 0&&(n=t.identifierPrefix),t.onUncaughtError!==void 0&&(l=t.onUncaughtError),t.onCaughtError!==void 0&&(i=t.onCaughtError),t.onRecoverableError!==void 0&&(c=t.onRecoverableError),t.unstable_transitionCallbacks!==void 0&&(o=t.unstable_transitionCallbacks)),t=pd(e,1,!1,null,null,a,n,l,i,c,o,null),e[Ha]=t.current,$u(e),new mo(t)},El.hydrateRoot=function(e,t,a){if(!E(e))throw Error(r(299));var n=!1,l="",i=Yr,c=Gr,o=Qr,f=null,y=null;return a!=null&&(a.unstable_strictMode===!0&&(n=!0),a.identifierPrefix!==void 0&&(l=a.identifierPrefix),a.onUncaughtError!==void 0&&(i=a.onUncaughtError),a.onCaughtError!==void 0&&(c=a.onCaughtError),a.onRecoverableError!==void 0&&(o=a.onRecoverableError),a.unstable_transitionCallbacks!==void 0&&(f=a.unstable_transitionCallbacks),a.formState!==void 0&&(y=a.formState)),t=pd(e,1,!0,t,a??null,n,l,i,c,o,f,y),t.context=gd(null),a=t.current,n=dt(),n=lc(n),l=ea(n),l.callback=null,ta(a,l,n),a=n,t.current.lanes=a,Rn(t,a),Mt(t),e[Ha]=t.current,$u(e),new Qi(t)},El.version="19.1.1",El}var jd;function V_(){if(jd)return po.exports;jd=1;function u(){if(!(typeof __REACT_DEVTOOLS_GLOBAL_HOOK__>"u"||typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE!="function"))try{__REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE(u)}catch(s){console.error(s)}}return u(),po.exports=Z_(),po.exports}var K_=V_();const J_="modulepreload",$_=function(u){return"/v2/"+u},kd={},An=function(s,m,r){let E=Promise.resolve();if(m&&m.length>0){let v=function(x){return Promise.all(x.map(O=>Promise.resolve(O).then(L=>({status:"fulfilled",value:L}),L=>({status:"rejected",reason:L}))))};document.getElementsByTagName("link");const C=document.querySelector("meta[property=csp-nonce]"),U=C?.nonce||C?.getAttribute("nonce");E=v(m.map(x=>{if(x=$_(x),x in kd)return;kd[x]=!0;const O=x.endsWith(".css"),L=O?'[rel="stylesheet"]':"";if(document.querySelector(`link[href="${x}"]${L}`))return;const K=document.createElement("link");if(K.rel=O?"stylesheet":J_,O||(K.as="script"),K.crossOrigin="",K.href=x,U&&K.setAttribute("nonce",U),document.head.appendChild(K),O)return new Promise((_e,ie)=>{K.addEventListener("load",_e),K.addEventListener("error",()=>ie(new Error(`Unable to preload CSS for ${x}`)))})}))}function R(C){const U=new Event("vite:preloadError",{cancelable:!0});if(U.payload=C,window.dispatchEvent(U),!U.defaultPrevented)throw C}return E.then(C=>{for(const U of C||[])U.status==="rejected"&&R(U.reason);return s().catch(R)})};var j=zo();const W_={"shell.switch_light":"切换浅色模式","shell.switch_dark":"切换深色模式","shell.update_available":"新版已就绪，刷新后使用。","shell.reload":"刷新页面","app.name":"QuantStrategyLab","nav.main":"主导航","nav.overview":"总览","nav.performance":"收益分析","nav.decisions":"待办","nav.accounts":"账户","nav.strategies":"策略","nav.health":"运行状态","nav.more":"更多","nav.todo_unavailable":"待办数量不可读","common.loading":"正在读取…","common.retry":"重试","common.close":"关闭","common.cancel":"取消","common.confirm":"确认继续","common.save":"保存","common.edit":"编辑","common.back":"返回","common.all":"全部","common.none":"无","common.unknown":"未知","common.na":"—","common.as_of":"数据截至 {value}","common.updated_at":"页面刷新于 {value}","common.refresh":"刷新","common.refreshing":"正在刷新…","common.copy":"复制","common.copied":"已复制","common.view_all":"查看全部","common.load_more":"加载更多","common.table_scroll_hint":"左右滑动查看全部字段","common.expand":"展开","common.collapse":"收起","common.account":"账户","common.ibkr_account":"IBKR 账户","common.platform":"平台","common.strategy":"策略","common.time":"时间","common.status":"状态","common.details":"详情","common.synthetic_badge":"合成演示","common.paper_badge":"模拟","common.page_load_failed":"此页面无法加载","common.read_failed_banner":"部分数据读取失败，请稍后重试；读取失败不代表没有内容。","common.unsaved_guard_title":"放弃未保存的修改？","common.unsaved_guard_body":"当前有未保存的修改，离开后将丢失。","state.unknown_status":"未知状态","state.review":"待复核","state.watch":"需关注","state.critical":"严重","state.blocked":"运行受阻","state.failed":"运行失败","state.read_incomplete":"读取不完整","state.insufficient":"资料不足","state.previewed":"已预览","state.no_submission":"未提交订单","state.no_rebalance":"无需调仓","state.filled":"已成交","state.not_due":"尚未到运行时间","state.market_closed":"休市","state.outside_window":"不在运行时段","state.within_grace":"仍在等待期","state.missing_report":"缺少报告","state.error":"运行错误","state.healthy":"健康","state.no_signal":"无信号","state.ok":"正常","state.partial":"部分数据","state.partial_valuation":"估值不完整","state.partial_runtime":"运行未接入","state.stale":"数据偏旧","state.no_data":"暂无数据","state.not_connected":"未接入","state.unavailable":"暂不可计算","state.read_failed":"读取失败","state.load_failed":"暂时无法加载","reason.external_cashflow_required":"缺少完整出入金记录，暂不展示 TWR；金额按资产变动展示。","reason.fills_not_connected":"成交记录源未接入","reason.execution_coverage_unverified":"成交覆盖范围未核实","reason.avg_cost_missing":"缺少成本价，未实现盈亏暂不可计算","reason.mixed_currency":"多币种无法合并为单一金额；按币种分别展示","reason.snapshot_history_missing":"缺少历史资产快照","reason.snapshot_missing":"缺少资产快照","reason.snapshot_pending":"今日数据待更新","reason.previous_snapshot_missing":"缺少前一日的资产快照","reason.non_trading_weekend":"非交易日","reason.incomplete_month":"当月数据尚不完整","reason.insufficient_observations":"历史数据不足","reason.invalid_return_period":"区间端点无效","reason.positions_partial_coverage":"持仓仅覆盖部分资产","reason.positions_not_connected":"持仓数据源未接入","reason.positions_stale":"持仓数据偏旧","reason.benchmark_history_unreadable":"基准数据读取失败","reason.position_value_missing":"缺少持仓市值","reason.no_common_date":"与基准没有可对齐的共同日期","reason.benchmark_history_missing":"缺少基准历史数据","reason.stored_records_unreadable":"存储记录读取失败","reason.effect_verification_not_recorded":"暂无记录可用于确认变更结果。","reason.bounded_audit_log":"历史记录有保留上限，可能不完整","reason.no_closed_trades":"没有已平仓的交易","reason.notification_log_not_connected":"通知发送记录源未接入","reason.runtime_daily_not_connected":"运行记录源未接入","reason.runtime_daily_binding_conflict":"运行记录存在多个账户绑定，请检查配置","reason.today_record_missing":"今日暂无运行记录","reason.runtime_daily_stale":"运行记录已过期","reason.runtime_daily_incomplete":"运行记录不完整","reason.strategy_health_not_connected":"策略健康度来源未接入","reason.available":"可操作","reason.admin_required":"需要管理员权限","reason.dispatch_unavailable":"执行通道暂不可用","reason.stop_pending_or_identity_unavailable":"已有停用请求待确认或身份暂不可用","reason.strategy_application_not_connected":"策略应用通道未接入","reason.existing_recovery_not_available":"没有可用的既有恢复流程","reason.runtime_instances_not_bound":"运行实例未绑定","reason.account_settings_identity_conflict":"草案绑定的是旧身份，需先确认","reason.profile_draft_required":"请先保存当前账户的策略草案。","reason.profile_only_required":"仅支持策略档案类草案","reason.profile_not_selectable":"该策略档案不可选","reason.runtime_readback_unavailable":"运行状态读回不可用","reason.runtime_control_pending":"上次操作仍待确认","reason.runtime_control_result_unavailable":"结果暂未确认，请刷新查看。","reason.platform_result_unavailable":"平台结果暂未确认，请刷新查看。","reason.platform_dispatch_unverified":"平台请求结果暂未确认。","reason.platform_dispatch_rejected":"平台未接受请求，设置可能已保存。","reason.readback_dispatch_rejected":"暂时无法查询平台结果。","reason.runtime_control_workflow_permission_denied":"没有查询平台工作流的权限。","reason.runtime_control_workflow_unavailable":"平台工作流暂不可用。","reason.runtime_control_target_unsupported":"账户绑定与平台配置不一致。","reason.stop_source_permission_denied":"没有读取平台配置的权限。","reason.stop_source_not_accessible":"暂时无法读取平台配置。","reason.runtime_target_not_disabled":"运行目标尚未停用","reason.current_profile_conflict":"当前策略档案冲突","reason.profile_application_pending":"已有应用请求处理中","reason.synthetic_guard_blocked":"合成演示环境不提供该操作","reason.unknown":"原因未知","auth.login_title":"登录后继续使用","auth.login_body":"登录后可查看账户总览、收益分析、待办与运行状态。","auth.login":"登录","auth.denied_title":"没有访问权限","auth.denied_body":"当前账号未被允许访问此控制台。","auth.error_title":"暂时无法读取控制台","auth.error_body":"会话服务暂时不可用，请稍后重试。","shell.scope":"账户范围","shell.scope_error":"账户不可用","shell.scope_loading":"正在读取账户…","shell.scope_meta_error":"无法读取账户名称与模拟/实盘标记。","prefs.save_error":"无法保存偏好，刷新后可能失效。","shell.scope_all":"全部账户","shell.scope_paper_group":"模拟账户","shell.hide_amounts":"隐藏金额","shell.show_amounts":"显示金额","shell.user_menu":"用户菜单","shell.preferences":"偏好设置","shell.logout":"退出登录","shell.skip_to_content":"跳到主要内容","prefs.title":"偏好设置","prefs.theme":"主题","prefs.theme_light":"浅色","prefs.theme_dark":"深色","prefs.theme_system":"跟随系统","prefs.language":"语言","prefs.updown":"涨跌颜色","prefs.updown_green_up":"绿涨红跌","prefs.updown_red_up":"红涨绿跌","prefs.hide_amounts":"默认隐藏金额","prefs.default_range":"默认区间","prefs.note":"偏好仅保存在此浏览器中。","overview.total_assets":"总资产","overview.range_return":"区间收益 {range}","overview.last_day_change":"最近一日资产变动","overview.todos":"待办","overview.todos_urgent":"{count} 紧急","overview.runs_ok":"运行 {ok}/{total} 正常","overview.equity_trend":"收益走势","overview.todo_preview":"待办预览","overview.my_accounts":"我的账户","overview.account_strategy":"策略","overview.account_assets":"资产","overview.account_cash":"现金","overview.no_accounts":"暂无账户","overview.twr_tag":"时间加权收益","overview.open_performance":"打开收益分析","overview.open_health":"打开运行状态","overview.open_decisions":"打开待办","perf.value_kind_pnl":"盈亏","perf.value_kind_asset_change":"资产变动","perf.range.1M":"1月","perf.range.3M":"3月","perf.range.YTD":"年初至今","perf.range.1Y":"1年","perf.range.ALL":"全部","perf.range.label":"时间区间","perf.range.return_label":"{range} 收益","perf.card.twr":"累计收益（TWR）","perf.card.amount":"盈亏金额","perf.card.amount_asset_change":"资产变动","perf.card.max_drawdown":"最大回撤","perf.card.max_drawdown_dates":"{peak} → {trough}","perf.card.excess":"相对基准超额","perf.card.best_day":"最好的一天","perf.card.worst_day":"最差的一天","perf.returns_title":"收益率 vs 基准","perf.returns_cumulative":"累积","perf.returns_daily":"每日","perf.how_calculated":"如何计算？","perf.method_title":"收益如何计算","perf.method_body":"按时间加权（TWR）计算，已剔除出入金影响；区间起点归零。","perf.assets_title":"总资产","perf.assets_note":"仅展示当前账户范围的资产，不叠加基准。","perf.assets_flow_mark":"出入金","perf.calendar_title":"收益日历","perf.calendar_month":"月","perf.calendar_year":"年","perf.calendar_deposit_note":"出入金当日不计入盈亏","perf.holdings_title":"持仓","perf.holdings_note":"当前持仓 · 未实现盈亏","perf.ranking_title":"个股盈亏榜","perf.trades_title":"成交统计","perf.trades_not_connected":"成交统计未接入。","perf.mixed_currency_title":"多币种说明","perf.col.symbol":"标的","perf.col.quantity":"数量","perf.col.market_value":"市值","perf.col.currency":"币种","perf.col.avg_cost":"成本价","perf.col.unrealized_pnl":"未实现盈亏","perf.col.account":"账户","perf.col.date":"日期","perf.col.amount":"金额","perf.col.return":"收益率","decisions.title":"待办","decisions.filter.all":"全部","decisions.tab.pending":"待处理","decisions.tab.decided":"已处理","category.reconciliation_recovery":"对账恢复","category.strategy_promotion":"策略晋级","category.owner_decision":"负责人决定","category.credential_maintenance":"凭证维护","category.paper_account_application":"模拟账户应用","decisions.priority.high":"高","decisions.priority.medium":"中","decisions.priority.normal":"普通","decisions.status.pending":"待处理","decisions.status.decided":"已处理","decisions.status.expired":"已过期","decisions.question":"需要你决定","decisions.diff_title":"改前 → 改后","decisions.col.field":"字段","decisions.col.current":"当前","decisions.col.proposed":"建议","decisions.col.affects_live":"实盘影响","decisions.affects_live_yes":"是","decisions.affects_live_no":"否","decisions.materials":"材料","decisions.adopt_intent":"记录采用意向","decisions.decline_intent":"记录不采用意向","decisions.intent_note":"仅记录意向，不会下单。","decisions.confirm_adopt_title":"确认记录采用意向？","decisions.confirm_decline_title":"确认记录不采用意向？","decisions.confirm_body":"本次只记录意向，不会提交订单或改变交易权限。","decisions.history_title":"处理记录","decisions.history.empty":"暂无处理记录","decisions.action.adopt_intent":"记录采用意向","decisions.action.decline_intent":"记录不采用意向","decisions.empty_pending":"没有待处理的事项","decisions.account_global":"全部账户","decisions.ref":"编号 {id}","decisions.expires_at":"截止 {value}","decisions.created_at":"创建于 {value}","decisions.read_failed":"待办读取失败，请重试；这不代表没有待办。","decisions.application_status":"应用状态：{value}","accounts.title":"账户","accounts.col.alias":"别名","accounts.col.platform":"平台","accounts.col.strategy":"当前策略","accounts.col.run":"运行","accounts.col.drafts":"待生效草案","accounts.col.todos":"待办","accounts.col.last_change":"最近变更","accounts.tab.overview":"概览","accounts.tab.strategy":"策略与参数","risk.title":"风险偏好","risk.note":"用于记录投资偏好，不会改变交易设置。","risk.field":"偏好草案","risk.savedValue":"当前保存值","risk.unset":"未设置","risk.capital":"资本保全","risk.balanced":"稳健复利","risk.growth":"成长复利","risk.other":"未识别的值","risk.save":"保存风险偏好","risk.discard":"撤销","risk.saving":"正在保存风险偏好。","risk.gate":"当前账户不可编辑风险偏好。","risk.denied":"没有权限读取这项设置。","risk.readFailed":"风险偏好暂时读不到。","risk.readMismatch":"设置读回与所选账户不一致，请重新读取。","risk.reread":"重新读取","risk.stale":"显示上次成功读回值，当前状态未重新确认。","risk.saved":"偏好已保存，并已回读确认。","risk.mismatch":"回读与提交不一致，未确认已保存。","risk.unverified":"已提交，暂无法确认，请重新读取。","risk.conflict":"版本已变化，未覆盖已保存内容。","risk.review":"保存结果尚未确认，请重新读取。","risk.ack":"确认","accounts.tab.controls":"运行控制","accounts.tab.history":"变更记录","accounts.freshness":"数据新鲜度","accounts.run_state":"运行状态","accounts.edit":"编辑","accounts.check_changes":"检查变更","accounts.viewing":"查看态","accounts.editing":"编辑中","accounts.diff_dialog_title":"确认草案变更","accounts.col.draft":"草案","accounts.ack_live":"我已了解这些修改影响实盘","accounts.save_draft":"保存草案","accounts.draft_saved":"草案已保存。","accounts.draft_note":"保存草案不会下单、启用账户或改变交易权限；当前生效配置保持不变。","accounts.conflict":"版本冲突：草案已被其他人修改。请刷新确认最新差异后重试。","accounts.identity_conflict":"草案绑定的账户身份已变化，请先刷新确认。","accounts.no_changes":"没有修改","accounts.history.empty":"暂无变更记录","accounts.event.draft_saved":"草案保存","accounts.event.approved":"批准","accounts.event.unrecorded":"未记录","accounts.history.note":"变更记录有保留上限；批准或保存不代表已生效。","accounts.draft_revision":"草案版本 {value}","controls.title":"运行控制","controls.danger_note":"以下操作影响实盘运行，请确认后执行。","controls.enable":"启用","controls.stop":"停止","controls.resume":"恢复","controls.approve_application":"批准应用","controls.stop_summary":"停止只阻止新的触发，不会撤单、平仓或清除在途请求。","controls.resume_summary":"恢复既有运行目标，不修改策略或资金参数。","controls.approve_summary":"批准应用当前策略档案草案；提交后需确认实际生效状态，不会直接下单。","controls.enable_summary":"启用运行目标，使既有调度恢复触发。","controls.stop_confirm_title":"确认停止运行目标","controls.stop_type_alias":"输入账户别名 {alias} 以确认停止","controls.alias_mismatch":"输入的别名不一致","controls.submitted":"请求已提交；结果需读回确认，请勿重复提交。","controls.submit_failed":"提交未完成；请确认当前状态后再决定，避免重复提交。","controls.unknown_result":"上次提交结果未知，已锁定；请先刷新确认。","controls.unavailable":"不可用：{reason}","strategies.title":"策略","strategies.domain":"市场","strategies.modes":"新增启用／切换方式","strategies.accounts_using":"已配置账户","strategies.account_execution":"账户执行模式","strategies.execution.legacy_live":"实盘","strategies.execution.live":"实盘","strategies.execution.live_unknown":"实盘","strategies.execution.paper":"模拟","strategies.execution.dry_run":"演练","strategies.execution.unknown":"执行模式未知","strategies.live_exposure":"实盘策略使用真实资金；目录方式仅约束新增启用或切换。","strategies.execution_source":"模式来自账户配置；最近运行及成交状态未验证。","strategies.health":"健康度","strategies.health_score":"评分 {value}","strategies.last_promotion":"最近晋级","strategies.params_summary":"参数摘要","strategies.promotion_timeline":"晋级时间线","strategies.empty":"暂无策略","strategies.tab.catalog":"策略目录","strategies.tab.research":"研究线索","strategies.research_only":"仅研究，不下单","strategies.research_not_connected":"研究线索未接入。","health.title":"运行状态","health.stat.today_runs":"今日运行 {ok}/{total}","health.stat.observed":"已观测 {observed}/{configured}","health.stat.credentials":"凭证 {count} 项需关注","health.stat.recent_failure":"最近失败 {count}","health.grid_title":"近 14 个纽约业务日","health.grid.ok":"成功","health.grid.failed":"失败","health.grid.not_run":"未运行","health.grid.no_record":"无记录","health.day_detail":"当日记录","health.freshness_title":"数据新鲜度","health.credentials_title":"凭证到期","health.credential_ibkr_report":"IBKR 报表凭证","health.credential_other":"账户凭证","health.table_scroll_hint":"左右滑动查看完整表格","health.grid_scroll_hint":"左右滑动查看全部日期，账户列保持可见","health.credential_expires":"到期 {value}","health.credential_phase.expired":"已过期","health.credential_phase.30":"30 天内到期","health.credential_phase.7":"7 天内到期","health.credential_phase.1":"1 天内到期","health.credential_phase.not_due":"正常","health.credential_phase.unknown":"未知","health.activity":"活动","health.run_count":"运行次数","health.col.account":"账户","health.col.source":"来源","health.col.status":"状态","health.col.as_of":"数据时间","error.generic":"请求未完成；请刷新并确认当前状态。","error.session_expired":"会话已失效，请重新登录。","error.access_denied":"访问被拒绝。","error.conflict":"版本冲突；当前编辑已保留，请刷新确认。"},F_={"shell.switch_light":"Switch to light mode","shell.switch_dark":"Switch to dark mode","shell.update_available":"A new version is ready. Refresh to use it.","shell.reload":"Refresh page","app.name":"QuantStrategyLab","nav.main":"Main navigation","nav.overview":"Overview","nav.performance":"Performance","nav.decisions":"To-dos","nav.accounts":"Accounts","nav.strategies":"Strategies","nav.health":"Run status","nav.more":"More","nav.todo_unavailable":"To-do count unavailable","common.loading":"Loading…","common.retry":"Retry","common.close":"Close","common.cancel":"Cancel","common.confirm":"Confirm","common.save":"Save","common.edit":"Edit","common.back":"Back","common.all":"All","common.none":"None","common.unknown":"Unknown","common.na":"—","common.as_of":"Data as of {value}","common.updated_at":"Page refreshed {value}","common.refresh":"Refresh","common.refreshing":"Refreshing…","common.copy":"Copy","common.copied":"Copied","common.view_all":"View all","common.load_more":"Load more","common.table_scroll_hint":"Scroll sideways for all fields","common.expand":"Expand","common.collapse":"Collapse","common.account":"Account","common.ibkr_account":"IBKR account","common.platform":"Platform","common.strategy":"Strategy","common.time":"Time","common.status":"Status","common.details":"Details","common.synthetic_badge":"Synthetic demo","common.paper_badge":"Paper","common.page_load_failed":"This page could not be loaded","common.read_failed_banner":"Some data failed to load. A failed read does not mean there is nothing to show; please retry.","common.unsaved_guard_title":"Discard unsaved changes?","common.unsaved_guard_body":"You have unsaved changes that will be lost if you leave.","state.unknown_status":"Unknown status","state.review":"Needs review","state.watch":"Watch","state.critical":"Critical","state.blocked":"Blocked","state.failed":"Failed","state.read_incomplete":"Read incomplete","state.insufficient":"Insufficient data","state.previewed":"Previewed","state.no_submission":"No order submitted","state.no_rebalance":"No rebalance","state.filled":"Filled","state.not_due":"Not due yet","state.market_closed":"Market closed","state.outside_window":"Outside run window","state.within_grace":"Within grace period","state.missing_report":"Report missing","state.error":"Run error","state.healthy":"Healthy","state.no_signal":"No signal","state.ok":"OK","state.partial":"Partial","state.partial_valuation":"Valuation incomplete","state.partial_runtime":"Runtime not connected","state.stale":"Stale","state.no_data":"No data","state.not_connected":"Not connected","state.unavailable":"Unavailable","state.read_failed":"Read failed","state.load_failed":"Unable to load","reason.external_cashflow_required":"Complete cash-flow records are missing; TWR is unavailable and amounts are shown as asset change.","reason.fills_not_connected":"The fill source is not connected","reason.execution_coverage_unverified":"Execution coverage is unverified","reason.avg_cost_missing":"Average cost is missing, so unrealized P/L cannot be calculated","reason.mixed_currency":"Mixed currencies cannot be combined into one amount; each currency is shown separately","reason.snapshot_history_missing":"Historical asset snapshots are missing","reason.snapshot_missing":"Asset snapshot is missing","reason.snapshot_pending":"Today's data is pending update","reason.previous_snapshot_missing":"The previous day's asset snapshot is missing","reason.non_trading_weekend":"Non-trading day","reason.incomplete_month":"The month is still incomplete","reason.insufficient_observations":"Not enough history","reason.invalid_return_period":"Invalid range endpoints","reason.positions_partial_coverage":"Positions cover only part of the assets","reason.positions_not_connected":"The position source is not connected","reason.positions_stale":"Position data is stale","reason.benchmark_history_unreadable":"Benchmark data failed to load","reason.position_value_missing":"Position market value is missing","reason.no_common_date":"No common date to align with the benchmark","reason.benchmark_history_missing":"Benchmark history is missing","reason.stored_records_unreadable":"Stored records could not be read","reason.effect_verification_not_recorded":"No record is available to confirm whether the change took effect.","reason.bounded_audit_log":"History retention is bounded and may be incomplete","reason.no_closed_trades":"No closed trades","reason.notification_log_not_connected":"The notification log source is not connected","reason.runtime_daily_not_connected":"The run-record source is not connected","reason.runtime_daily_binding_conflict":"Multiple run-record bindings match this account; check configuration","reason.today_record_missing":"No run record for today","reason.runtime_daily_stale":"The run record is stale","reason.runtime_daily_incomplete":"The run record is incomplete","reason.strategy_health_not_connected":"The strategy health source is not connected","reason.available":"Available","reason.admin_required":"Admin permission required","reason.dispatch_unavailable":"Dispatch is unavailable","reason.stop_pending_or_identity_unavailable":"A stop request is pending or identity is unavailable","reason.strategy_application_not_connected":"The strategy application channel is not connected","reason.existing_recovery_not_available":"No existing recovery flow is available","reason.runtime_instances_not_bound":"Runtime instances are not bound","reason.account_settings_identity_conflict":"The draft is bound to an older identity; reconcile first","reason.profile_draft_required":"Save a strategy draft for this account first.","reason.profile_only_required":"Only strategy-profile drafts are supported","reason.profile_not_selectable":"This strategy profile cannot be selected","reason.runtime_readback_unavailable":"Runtime readback is unavailable","reason.runtime_control_pending":"The previous action is awaiting confirmation","reason.runtime_control_result_unavailable":"The result is unconfirmed. Refresh to check.","reason.platform_result_unavailable":"The platform result is unconfirmed. Refresh to check.","reason.platform_dispatch_unverified":"The platform request is unconfirmed.","reason.platform_dispatch_rejected":"The platform rejected the request; the setting may have been saved.","reason.readback_dispatch_rejected":"The platform result cannot be checked right now.","reason.runtime_control_workflow_permission_denied":"Permission to read the platform workflow is unavailable.","reason.runtime_control_workflow_unavailable":"The platform workflow is unavailable.","reason.runtime_control_target_unsupported":"The account binding does not match the platform configuration.","reason.stop_source_permission_denied":"Permission to read platform settings is unavailable.","reason.stop_source_not_accessible":"Platform settings cannot be read right now.","reason.runtime_target_not_disabled":"The runtime target is not disabled yet","reason.current_profile_conflict":"The current strategy profile conflicts","reason.profile_application_pending":"An application request is already pending","reason.synthetic_guard_blocked":"This action is not offered in the synthetic demo","reason.unknown":"Unknown reason","auth.login_title":"Sign in to continue","auth.login_body":"Sign in to view overview, performance, to-dos and run status.","auth.login":"Sign in","auth.denied_title":"No access","auth.denied_body":"This account is not allowed to use the console.","auth.error_title":"Console unavailable","auth.error_body":"The session service is temporarily unavailable. Please retry later.","shell.scope":"Account scope","shell.scope_error":"Accounts unavailable","shell.scope_loading":"Loading accounts…","shell.scope_meta_error":"Account names and paper/live labels are unavailable.","prefs.save_error":"Preferences could not be saved and may be lost after refresh.","shell.scope_all":"All accounts","shell.scope_paper_group":"Paper accounts","shell.hide_amounts":"Hide amounts","shell.show_amounts":"Show amounts","shell.user_menu":"User menu","shell.preferences":"Preferences","shell.logout":"Sign out","shell.skip_to_content":"Skip to content","prefs.title":"Preferences","prefs.theme":"Theme","prefs.theme_light":"Light","prefs.theme_dark":"Dark","prefs.theme_system":"System","prefs.language":"Language","prefs.updown":"Up/down colors","prefs.updown_green_up":"Green up / red down","prefs.updown_red_up":"Red up / green down","prefs.hide_amounts":"Hide amounts by default","prefs.default_range":"Default range","prefs.note":"Preferences are stored only in this browser.","overview.total_assets":"Total assets","overview.range_return":"Range return {range}","overview.last_day_change":"Latest daily asset change","overview.todos":"To-dos","overview.todos_urgent":"{count} urgent","overview.runs_ok":"Runs {ok}/{total} OK","overview.equity_trend":"Return trend","overview.todo_preview":"To-do preview","overview.my_accounts":"My accounts","overview.account_strategy":"Strategy","overview.account_assets":"Assets","overview.account_cash":"Cash","overview.no_accounts":"No accounts yet","overview.twr_tag":"Time-weighted return","overview.open_performance":"Open performance","overview.open_health":"Open run status","overview.open_decisions":"Open to-dos","perf.value_kind_pnl":"P/L","perf.value_kind_asset_change":"Asset change","perf.range.1M":"1M","perf.range.3M":"3M","perf.range.YTD":"YTD","perf.range.1Y":"1Y","perf.range.ALL":"All","perf.range.label":"Time range","perf.range.return_label":"{range} return","perf.card.twr":"Cumulative return (TWR)","perf.card.amount":"P/L amount","perf.card.amount_asset_change":"Asset change","perf.card.max_drawdown":"Max drawdown","perf.card.max_drawdown_dates":"{peak} → {trough}","perf.card.excess":"Excess vs benchmark","perf.card.best_day":"Best day","perf.card.worst_day":"Worst day","perf.returns_title":"Returns vs benchmarks","perf.returns_cumulative":"Cumulative","perf.returns_daily":"Daily","perf.how_calculated":"How is this calculated?","perf.method_title":"How returns are calculated","perf.method_body":"Time-weighted (TWR); cash flows are excluded and each range starts at zero.","perf.assets_title":"Total assets","perf.assets_note":"Shows assets of the selected scope only; no benchmarks.","perf.assets_flow_mark":"Cash flow","perf.calendar_title":"Return calendar","perf.calendar_month":"Month","perf.calendar_year":"Year","perf.calendar_deposit_note":"Cash-flow days do not count as P/L","perf.holdings_title":"Holdings","perf.holdings_note":"Current holdings · unrealized","perf.ranking_title":"Symbol P/L ranking","perf.trades_title":"Trade statistics","perf.trades_not_connected":"Trade statistics are not connected.","perf.mixed_currency_title":"Mixed currencies","perf.col.symbol":"Symbol","perf.col.quantity":"Quantity","perf.col.market_value":"Market value","perf.col.currency":"Currency","perf.col.avg_cost":"Avg cost","perf.col.unrealized_pnl":"Unrealized P/L","perf.col.account":"Account","perf.col.date":"Date","perf.col.amount":"Amount","perf.col.return":"Return","decisions.title":"To-dos","decisions.filter.all":"All","decisions.tab.pending":"Pending","decisions.tab.decided":"Decided","category.reconciliation_recovery":"Reconciliation recovery","category.strategy_promotion":"Strategy promotion","category.owner_decision":"Owner decision","category.credential_maintenance":"Credential maintenance","category.paper_account_application":"Paper account application","decisions.priority.high":"High","decisions.priority.medium":"Medium","decisions.priority.normal":"Normal","decisions.status.pending":"Pending","decisions.status.decided":"Decided","decisions.status.expired":"Expired","decisions.question":"Your decision","decisions.diff_title":"Before → after","decisions.col.field":"Field","decisions.col.current":"Current","decisions.col.proposed":"Proposed","decisions.col.affects_live":"Live impact","decisions.affects_live_yes":"Yes","decisions.affects_live_no":"No","decisions.materials":"Materials","decisions.adopt_intent":"Record adopt intent","decisions.decline_intent":"Record decline intent","decisions.intent_note":"Records intent only; no orders are placed.","decisions.confirm_adopt_title":"Record adopt intent?","decisions.confirm_decline_title":"Record decline intent?","decisions.confirm_body":"Only your intent is recorded. No order is submitted and no trading permission changes.","decisions.history_title":"History","decisions.history.empty":"No history yet","decisions.action.adopt_intent":"Adopt intent","decisions.action.decline_intent":"Decline intent","decisions.empty_pending":"Nothing pending","decisions.account_global":"All accounts","decisions.ref":"Ref {id}","decisions.expires_at":"Due {value}","decisions.created_at":"Created {value}","decisions.read_failed":"To-dos failed to load. This does not mean there is nothing pending; please retry.","decisions.application_status":"Application status: {value}","accounts.title":"Accounts","accounts.col.alias":"Alias","accounts.col.platform":"Platform","accounts.col.strategy":"Strategy","accounts.col.run":"Run","accounts.col.drafts":"Pending drafts","accounts.col.todos":"To-dos","accounts.col.last_change":"Last change","accounts.tab.overview":"Overview","accounts.tab.strategy":"Strategy & parameters","risk.title":"Risk preference","risk.note":"Records your investment preference without changing trading settings.","risk.field":"Preference draft","risk.savedValue":"Saved value","risk.unset":"Not set","risk.capital":"Capital preservation","risk.balanced":"Balanced compounding","risk.growth":"Growth compounding","risk.other":"Unrecognized value","risk.save":"Save risk preference","risk.discard":"Discard","risk.saving":"Saving risk preference.","risk.gate":"Risk preference is not editable for this account.","risk.denied":"You do not have permission to read this setting.","risk.readFailed":"Risk preference is unavailable right now.","risk.readMismatch":"The read did not match the selected account. Re-read.","risk.reread":"Re-read","risk.stale":"Showing the last successful read; current state is unconfirmed.","risk.saved":"Preference saved and confirmed by re-read.","risk.mismatch":"The re-read does not match the submission; not confirmed as saved.","risk.unverified":"Submitted, but the re-read could not confirm it. Re-read to check.","risk.conflict":"The revision changed; nothing was overwritten.","risk.review":"The save result or account source is unconfirmed. Re-read to check.","risk.ack":"I have checked","accounts.tab.controls":"Run controls","accounts.tab.history":"Change history","accounts.freshness":"Data freshness","accounts.run_state":"Run state","accounts.edit":"Edit","accounts.check_changes":"Review changes","accounts.viewing":"Viewing","accounts.editing":"Editing","accounts.diff_dialog_title":"Confirm draft changes","accounts.col.draft":"Draft","accounts.ack_live":"I understand these changes affect live trading","accounts.save_draft":"Save draft","accounts.draft_saved":"Draft saved.","accounts.draft_note":"Saving a draft places no orders, enables no account, and changes no trading permissions. The effective settings stay unchanged.","accounts.conflict":"Revision conflict: the draft was changed elsewhere. Refresh and review the latest diff before retrying.","accounts.identity_conflict":"The account identity behind the draft has changed. Refresh and reconcile first.","accounts.no_changes":"No changes","accounts.history.empty":"No changes recorded","accounts.event.draft_saved":"Draft saved","accounts.event.approved":"Approved","accounts.event.unrecorded":"Not recorded","accounts.history.note":"History retention is bounded; a save or approval does not prove the change took effect.","accounts.draft_revision":"Draft revision {value}","controls.title":"Run controls","controls.danger_note":"These actions affect live runs. Review before executing.","controls.enable":"Enable","controls.stop":"Stop","controls.resume":"Resume","controls.approve_application":"Approve application","controls.stop_summary":"Stopping only blocks new triggers. It does not cancel orders, close positions, or clear in-flight requests.","controls.resume_summary":"Resume the existing runtime target. No strategy or funding parameters change.","controls.approve_summary":"Approve applying the current strategy-profile draft. Verify the effective state after submission; this does not directly place orders.","controls.enable_summary":"Enable the runtime target so the existing schedule resumes triggering.","controls.stop_confirm_title":"Confirm stopping the runtime target","controls.stop_type_alias":"Type the account alias {alias} to confirm the stop","controls.alias_mismatch":"The alias does not match","controls.submitted":"Request submitted; the result needs read-back. Do not resubmit.","controls.submit_failed":"Submission did not complete. Verify the current state before deciding; avoid resubmitting blindly.","controls.unknown_result":"The previous submission's result is unknown and locked. Refresh and verify first.","controls.unavailable":"Unavailable: {reason}","strategies.title":"Strategies","strategies.domain":"Market","strategies.modes":"New activation / switch modes","strategies.accounts_using":"Configured accounts","strategies.account_execution":"Account execution mode","strategies.execution.legacy_live":"Live","strategies.execution.live":"Live","strategies.execution.live_unknown":"Live","strategies.execution.paper":"Paper","strategies.execution.dry_run":"Dry run","strategies.execution.unknown":"Execution mode unknown","strategies.live_exposure":"Live strategies use real money; catalog modes only constrain new activations or switches.","strategies.execution_source":"Modes come from account configuration; recent runs and fills are unverified.","strategies.health":"Health","strategies.health_score":"Score {value}","strategies.last_promotion":"Last promotion","strategies.params_summary":"Parameter summary","strategies.promotion_timeline":"Promotion timeline","strategies.empty":"No strategies yet","strategies.tab.catalog":"Catalog","strategies.tab.research":"Research leads","strategies.research_only":"Research only; no orders","strategies.research_not_connected":"Research leads are not connected.","health.title":"Run status","health.stat.today_runs":"Today {ok}/{total}","health.stat.observed":"Observed {observed}/{configured}","health.stat.credentials":"{count} credential(s) need attention","health.stat.recent_failure":"Recent failures {count}","health.grid_title":"Last 14 New York business days","health.grid.ok":"Succeeded","health.grid.failed":"Failed","health.grid.not_run":"Not run","health.grid.no_record":"No record","health.day_detail":"Day detail","health.freshness_title":"Data freshness","health.credentials_title":"Credential expiry","health.credential_ibkr_report":"IBKR report credential","health.credential_other":"Account credential","health.table_scroll_hint":"Scroll horizontally to see the full table","health.grid_scroll_hint":"Scroll for all dates; accounts stay visible","health.credential_expires":"Expires {value}","health.credential_phase.expired":"Expired","health.credential_phase.30":"Expires within 30 days","health.credential_phase.7":"Expires within 7 days","health.credential_phase.1":"Expires within 1 day","health.credential_phase.not_due":"Normal","health.credential_phase.unknown":"Unknown","health.activity":"Activity","health.run_count":"Run count","health.col.account":"Account","health.col.source":"Source","health.col.status":"Status","health.col.as_of":"As of","error.generic":"The request did not complete. Refresh and verify the current state.","error.session_expired":"Session expired. Please sign in again.","error.access_denied":"Access denied.","error.conflict":"Revision conflict. Your edits are kept; refresh and verify."},P_={"overview.asset_summary":"资产摘要","overview.runtime_target":"运行目标","overview.runtime_enabled":"已启用","overview.runtime_disabled":"已停用","overview.runtime_config_note":"自动运行显示的是配置状态，不代表今日运行结果。","overview.mixed_currency_short":"多币种","overview.runs_card_title":"今日有记录账户","overview.business_date":"纽约业务日 {value}","overview.calendar_date":"纽约日期 {value}","overview.no_records_for_day":"当前未观测到该业务日记录","overview.non_trading_day_short":"非交易日"},I_={"overview.asset_summary":"Asset summary","overview.runtime_target":"Runtime target","overview.runtime_enabled":"Enabled","overview.runtime_disabled":"Stopped","overview.runtime_config_note":"Automatic runs show configuration, not today's run result.","overview.mixed_currency_short":"Multiple currencies","overview.runs_card_title":"Accounts with records today","overview.business_date":"New York business day {value}","overview.calendar_date":"New York date {value}","overview.no_records_for_day":"No records observed for this business day","overview.non_trading_day_short":"Non-trading day"},ep={"perf.latest_balance_scope_note":"可能包含环境待确认账户，合计可能不完整。","perf.latest_balance_total":"{currency} 最近已知余额合计","perf.latest_balance_subtotal":"{currency} 最近已知余额小计","perf.balance_oldest_time":"最早数据 {value}","perf.balance_latest_time":"最晚数据 {value}","perf.balance_source_time":"余额数据 {value}","perf.average_cost_field":"平均成本","perf.col.cost_basis":"成本价","perf.broker_cost_label":"券商成本（按券商设置）","reason.currency_mismatch":"账户币种与当前币种不符，未计入合计。","perf.coverage_details":"查看计入与排除的账户","perf.account_included":"已计入","perf.account_excluded":"未计入","perf.valuation_date":"估值日期 {date}","perf.holdings_missing_fields":"“—”表示来源未提供该字段；数量已知不代表市值、成本价或盈亏齐全。","perf.holdings_scroll_hint":"左右滑动查看持仓全部字段。","perf.ranking_no_movement":"可排名持仓暂无盈亏变化","perf.ranking_unavailable":"暂无可排名的持仓","perf.ranking_missing_fields":"缺少可用于排行的持仓收益数据，可在持仓页查看。","perf.ranking_missing_currency":"未提供币种的持仓不参与排行，无法确认可比币种。","perf.fields_not_provided":"未提供：{fields}","perf.native_return_accounts":"以下账户已有原生收益：{accounts}。可从顶部切换单个账户查看；这些结果不代表全部账户的组合收益。","perf.per_account_daily_title":"各账户日收益率","perf.per_account_daily_note":"各账户分别展示，缺失日期留空。","perf.combined_metrics_unavailable":"组合指标暂不可计算，以下展示各账户日收益。","perf.mixed_currency_unavailable":"当前范围含多种币种，未进行汇率转换，组合指标不可计算；下方按账户和币种展示原生收益。","perf.mixed_currency_native":"当前范围含多种币种，组合指标不可计算；下方按账户和币种展示原生收益。","perf.mixed_currency_asset_change":"当前范围含多种币种，组合收益不可计算；下方按币种展示资产变化（含出入金影响），不代表时间加权收益。","reason.invalid_valuation_date":"估值日期无效，未计入合计。","reason.invalid_balance":"资产金额未确认，未计入合计。","reason.duplicate_currency":"同币种有重复余额，未计入合计。","reason.identity_mismatch":"账户身份不匹配，未计入合计。","reason.identity_not_bound":"账户身份尚未绑定，未计入合计。","reason.aggregation_duplicate":"与另一账户重复，未重复计入。","reason.aggregation_conflict":"账户归属存在冲突，未计入合计。","reason.account_facts_disabled":"该账户的数据读取未启用。","perf.history_incomplete":"部分历史数据未返回","perf.history_stale":"历史数据可能不是最新","perf.history_coverage_note":"部分账户缺少历史数据，曲线仅包含有数据的账户。","perf.history_affected_accounts":"{count} 个账户的历史数据不完整","perf.history_carried_balances":"部分日期包含沿用的此前余额，这些余额并非当日观测。","perf.currency_excluded_accounts":"另有 {count} 个账户的币种或金额未确认。","perf.drawdown_twr_title":"TWR 最大回撤","perf.native_totals_note":"按币种分别展示，不换汇。","perf.currency_subtotal":"{currency} 资产小计","perf.currency_total":"{currency} 资产合计","perf.partial_accounts":"未含全部账户","perf.currency_accounts":"合计含 {count} 个账户","perf.freshness_counts":"{stale} 个账户的数据可能不是最新","perf.freshness_threshold":"按各账户时间分别判断，超过 {hours} 小时视为可能不是最新。","perf.data_may_be_stale":"部分账户数据待更新","perf.as_of_not_refresh":"“截至”显示账户数据时间，不是页面刷新时间。","perf.data_notes":"数据说明","perf.history_details":"查看账户","perf.calendar_asset_balance":"资产余额","reason.no_cashflow_data":"缺少完整出入金记录，无法计算 TWR 及其回撤。","reason.insufficient_history":"至少需要两条有效估值记录。","reason.no_snapshot":"暂无可用估值。","reason.snapshot_stale":"该账户快照已超过时效阈值。","reason.valuation_date_mismatch":"部分账户估值日期不同，未计入合计。","reason.incomplete_account_coverage":"部分账户未纳入合计。","perf.benchmark_sp500":"标普500","perf.benchmark_nasdaq100":"纳斯达克100","perf.benchmark_dow":"道琼斯工业平均指数","perf.benchmark_russell2000":"罗素2000","perf.benchmark_unknown":"基准","performance.current_holdings_unrealized":"当前持仓 · 未实现盈亏","perf.return_kind_twr":"时间加权收益率（TWR）","perf.native_daily_title":"日收益率","perf.native_daily_tag":"每日","perf.native_daily_note":"部分日期缺失，暂无法计算区间累计收益。","perf.method_body_native_daily":"每日收益来自券商，缺失日期留空。","perf.method_dietz_approx":"Modified Dietz（近似）","perf.method_unknown":"收益计算方式未知","perf.card.return_value":"累计收益","perf.drawdown_plain_title":"最大回撤","perf.method_body_unknown":"收益计算方式尚未确认。数值按原结果展示，未确认为时间加权收益率（TWR）；未知收益不按 0 处理。","perf.method_body_dietz":"有出入金记录但无法逐日精确加权时，采用 Modified Dietz 近似法并标注「近似」。区间起点归零，出入金不计入收益；记录不完整时仅展示资产余额，不展示 TWR。","perf.method_body_asset_change":"缺少完整出入金记录，暂无法计算 TWR。图中仅展示资产变化（%），包含出入金影响，不代表时间加权收益，也不与基准比较。","perf.returns_title_plain":"收益率","perf.asset_balance_title":"资产余额","perf.missing_cashflow_records":"缺少入出金记录，暂无法计算收益","perf.asset_change_title":"资产变化","perf.asset_change_tag":"资产变化 · 含出入金影响","perf.asset_change_calendar_tag":"含出入金影响","perf.asset_change_note":"暂时无法计算收益，以下展示资产变化（%）。该变化包含出入金影响，不代表时间加权收益，也不与基准比较。","perf.calendar_fallback_note":"部分账户缺少当日快照，本月历按可用账户的资产变化展示（含出入金影响），不代表收益。","perf.portfolio_series":"组合","perf.currency_switch":"币种","perf.crypto_benchmark_note":"加密账户按 7×24 交易，暂不与美股指数比较；BTC 基准数据尚未接入。","perf.mixed_benchmark_note":"当前范围同时包含加密与美股账户，暂不与单一市场指数比较；可切换到单个账户查看。","perf.currency_benchmark_note":"该币种账户暂不与美股指数比较。","perf.no_common_date_note":"账户与基准没有共同日期，暂不叠加基准。","perf.benchmark_not_applicable":"该范围暂不设置基准","perf.holdings_coverage_accounts":"覆盖账户：{value}","perf.ranking_note":"按未实现盈亏金额排序；盈亏比例以平均成本为基准，缺少平均成本的持仓不参与排行。","perf.ranking_winners":"盈利靠前","perf.ranking_losers":"亏损靠前","perf.benchmarks_unavailable":"基准暂不可用（{count}）","perf.col.side":"方向","perf.col.price":"价格","perf.col.commission":"佣金","perf.col.taxes":"税费","perf.side.buy":"买入","perf.side.sell":"卖出","perf.executions_count":"已观测 {count} 条成交","perf.executions_partial_short":"部分记录","perf.executions_partial":"仅列出已观测成交；覆盖范围未核实，不代表完整历史。","perf.executions_empty_partial":"部分记录，当前范围内暂无可展示成交。"},tp={"perf.latest_balance_scope_note":"May include accounts with unconfirmed environments; the total may be incomplete.","perf.latest_balance_total":"{currency} latest known balance total","perf.latest_balance_subtotal":"{currency} latest known balance subtotal","perf.balance_oldest_time":"Earliest data {value}","perf.balance_latest_time":"Latest data {value}","perf.balance_source_time":"Balance data {value}","perf.average_cost_field":"Avg cost","perf.col.cost_basis":"Cost basis","perf.broker_cost_label":"Broker cost (broker settings)","reason.currency_mismatch":"The account currency differs from this total; excluded.","perf.coverage_details":"View included and excluded accounts","perf.account_included":"Included","perf.account_excluded":"Excluded","perf.valuation_date":"Valuation date {date}","perf.holdings_missing_fields":"“—” means the source did not provide that field. A known quantity does not establish market value, cost basis or P/L.","perf.holdings_scroll_hint":"Scroll horizontally to view all holding fields.","perf.ranking_no_movement":"Eligible holdings have no P/L movement","perf.ranking_unavailable":"No holdings are eligible for ranking","perf.ranking_missing_fields":"Eligible holding return data is unavailable; check the Holdings tab.","perf.ranking_missing_currency":"Holdings without a currency are not ranked because no comparable currency can be confirmed.","perf.fields_not_provided":"Not provided: {fields}","perf.native_return_accounts":"Native returns are available for: {accounts}. Select one account at the top to view them; these are not returns for the full portfolio.","perf.per_account_daily_title":"Daily returns by account","perf.per_account_daily_note":"Accounts are shown separately; missing dates are left blank.","perf.combined_metrics_unavailable":"Combined metrics are unavailable; daily returns are shown by account below.","perf.mixed_currency_unavailable":"This scope contains multiple currencies. No FX conversion was applied, so combined metrics are unavailable. Native returns are shown by account and currency below.","perf.mixed_currency_native":"This scope contains multiple currencies, so combined metrics are unavailable. Native returns are shown by account and currency below.","perf.mixed_currency_asset_change":"This scope contains multiple currencies, so a combined return is unavailable. Asset change (including cash-flow effects) is shown by currency; it is not a time-weighted return.","reason.invalid_valuation_date":"The valuation date is invalid; excluded from the total.","reason.invalid_balance":"The balance is unconfirmed; excluded from the total.","reason.duplicate_currency":"Duplicate balances for this currency; excluded from the total.","reason.identity_mismatch":"The account identity does not match; excluded from the total.","reason.identity_not_bound":"The account identity is not bound; excluded from the total.","reason.aggregation_duplicate":"Duplicates another account; not counted twice.","reason.aggregation_conflict":"Account ownership is conflicting; excluded from the total.","reason.account_facts_disabled":"Data reads are disabled for this account.","perf.history_incomplete":"Some history is unavailable","perf.history_stale":"History may not be up to date","perf.history_coverage_note":"Some accounts lack history; the curve includes only accounts with data.","perf.history_affected_accounts":"History is incomplete for {count} accounts","perf.history_carried_balances":"Some dates include earlier balances; those balances were not observed on those dates.","perf.currency_excluded_accounts":"Currency or balance is unconfirmed for {count} additional accounts.","perf.drawdown_twr_title":"Maximum TWR drawdown","perf.native_totals_note":"Shown by currency without FX conversion.","perf.currency_subtotal":"{currency} asset subtotal","perf.currency_total":"{currency} asset total","perf.partial_accounts":"Not all accounts","perf.currency_accounts":"Total includes {count} accounts","perf.freshness_counts":"Data may be out of date for {stale} accounts","perf.freshness_threshold":"Each account is checked separately; data older than {hours} hours is marked as possibly out of date.","perf.data_may_be_stale":"Some account data may be out of date","perf.as_of_not_refresh":"“As of” shows the account data time, not the page refresh time.","perf.data_notes":"Data notes","perf.history_details":"View accounts","perf.calendar_asset_balance":"Asset balance","reason.no_cashflow_data":"Complete cash-flow records are missing; TWR and its drawdown cannot be calculated.","reason.insufficient_history":"At least two valid valuation records are required.","reason.no_snapshot":"No valuation is available.","reason.snapshot_stale":"This account snapshot exceeds the freshness threshold.","reason.valuation_date_mismatch":"Some accounts have different valuation dates and are excluded from the total.","reason.incomplete_account_coverage":"Some accounts are not included in the total.","perf.benchmark_sp500":"S&P 500","perf.benchmark_nasdaq100":"Nasdaq-100","perf.benchmark_dow":"Dow Jones Industrial Average","perf.benchmark_russell2000":"Russell 2000","perf.benchmark_unknown":"Benchmark","performance.current_holdings_unrealized":"Current holdings · unrealized P/L","perf.return_kind_twr":"Time-weighted return (TWR)","perf.native_daily_title":"Daily returns","perf.native_daily_tag":"Daily","perf.native_daily_note":"Some dates are missing, so the period return is unavailable.","perf.method_body_native_daily":"Daily returns are reported by the broker; missing dates are left blank.","perf.method_dietz_approx":"Modified Dietz (approximate)","perf.method_unknown":"Return method unknown","perf.card.return_value":"Cumulative return","perf.drawdown_plain_title":"Maximum drawdown","perf.method_body_unknown":"The return method is unconfirmed. Values are shown as provided, but are not confirmed as time-weighted returns (TWR); unknown returns are not treated as zero.","perf.method_body_dietz":"When cash flows exist but exact daily weighting is unavailable, Modified Dietz is used and labeled as approximate. Each range starts at zero, and cash flows are excluded from returns. If records are incomplete, only asset balance is shown instead of TWR.","perf.method_body_asset_change":"Complete cash-flow records are missing, so TWR is unavailable. The chart shows asset change (%), including the effect of cash flows; it is not a time-weighted return and is not compared with benchmarks.","perf.returns_title_plain":"Returns","perf.asset_balance_title":"Asset balance","perf.missing_cashflow_records":"Cash-flow records are missing; returns cannot be calculated yet.","perf.asset_change_title":"Asset change","perf.asset_change_tag":"Asset change · includes cash flows","perf.asset_change_calendar_tag":"Includes cash flows","perf.asset_change_note":"Returns are unavailable; the chart shows asset change (%), including the effect of cash flows. It is not a time-weighted return and is not compared with benchmarks.","perf.calendar_fallback_note":"Some accounts are missing snapshots on these dates. This calendar shows asset change from the available accounts, including cash-flow effects; it is not a return.","perf.portfolio_series":"Portfolio","perf.currency_switch":"Currency","perf.crypto_benchmark_note":"Crypto accounts trade 24/7 and are not compared with US equity indices; BTC benchmark data is not available yet.","perf.mixed_benchmark_note":"This scope mixes crypto and US equity accounts, so no single market index applies. Open one account to compare benchmarks.","perf.currency_benchmark_note":"Accounts in this currency are not compared with US equity indices.","perf.no_common_date_note":"The account and benchmarks share no common date, so benchmarks are not overlaid.","perf.benchmark_not_applicable":"No benchmark for this scope","perf.holdings_coverage_accounts":"Covered accounts: {value}","perf.ranking_note":"Ranked by unrealized P/L amount; percentages use average cost. Holdings without an average cost are not ranked.","perf.ranking_winners":"Top gainers","perf.ranking_losers":"Top losers","perf.benchmarks_unavailable":"{count} benchmark(s) unavailable","perf.col.side":"Side","perf.col.price":"Price","perf.col.commission":"Commission","perf.col.taxes":"Taxes","perf.side.buy":"Buy","perf.side.sell":"Sell","perf.executions_count":"{count} observed executions","perf.executions_partial_short":"Partial records","perf.executions_partial":"Only observed executions are listed; coverage is unverified and this is not a complete history.","perf.executions_empty_partial":"Partial records; no executions to show in this range."},ap={"reconciliation.title":"历史对账信息","reconciliation.current":"当前对账状态","reconciliation.not_connected":"未接入 / 未知","reconciliation.history_notice":"历史恢复方案不代表当前对账状态。","reconciliation.materials":"恢复方案详情","reconciliation.stale":"数据可能不是最新","reconciliation.read_unknown":"恢复方案或处理状态暂未确认","reconciliation.empty":"暂无恢复记录。","reconciliation.unnamed_strategy":"未命名策略","reconciliation.decision_status":"处理状态","reconciliation.decision_unknown":"处理状态未知","reconciliation.freshness":"数据时效","reconciliation.observed_at":"数据时间","reconciliation.generated_at":"方案生成时间","reconciliation.computed_at":"计算时间","inbox.count_unknown":"待办与审批数量暂时无法确认。","inbox.error.quota_exhausted.title":"待办暂时无法读取","inbox.error.quota_exhausted.detail":"今日读取次数已达上限，完整待办暂时不可用。","inbox.error.unauthorized.title":"待办访问受限","inbox.error.unauthorized.detail":"登录已失效或当前账户没有读取权限。","inbox.error.index_missing.title":"待办列表尚未建立","inbox.error.index_missing.detail":"完整列表尚未准备好，无法确认待办与审批数量。","inbox.error.index_incomplete.title":"待办列表尚未更新完成","inbox.error.index_incomplete.detail":"部分旧记录尚未纳入列表，暂时无法确认全部待办与审批。","inbox.error.index_unavailable.title":"待办暂时无法读取","inbox.error.index_unavailable.detail":"现有列表无法完整读取，请稍后重试；若持续失败，请联系管理员。","inbox.error.unknown.title":"待办暂时无法读取","inbox.error.unknown.detail":"原因尚未确认，请稍后重试；若持续失败，请联系管理员。","inbox.retry_at":"最早重试时间：{value}，不保证届时恢复。","inbox.auth_hint":"请使用已有读取权限的账户重新登录。","inbox.retry_hint":"稍后可重新读取；一分钟内可能仍显示上次失败结果。","inbox.retry":"重新读取待办","state.fresh":"最新","state.unknown":"未知","decisions.partial_notice":"部分来源不可用或不是最新，对应类别的待办可能不完整。","decisions.partial_affected":"受影响来源","decisions.partial_consequence.stale":"数据偏旧，该类别的待办可能不完整。","decisions.partial_consequence.unavailable":"暂不可用，该类别的待办无法确认。","decisions.partial_consequence.read_failed":"读取失败，该类别的待办无法确认。","decisions.unknown_source":"其他来源","decisions.material_freshness":"数据时效：{value}","decisions.stale_hint":"数据可能不是最新","decisions.stale_visible_hint":"创建较早，请确认是否仍有效","decisions.affects_live_required":"需实盘确认","decisions.affects_live_none":"不影响实盘","decisions.more_info":"更多信息","decisions.not_set":"未设置","decisions.intent_recorded":"选择已记录。","decisions.material_changed":"内容已更新，请重新查看后再确认。","decisions.intent_not_pending":"该事项已不在待处理状态。","decisions.intent_unavailable":"暂时无法确认最新内容，无法提交；请刷新后重试。","decisions.reconciliation_recovery":"对账恢复确认","decisions.strategy_promotion":"策略晋级方案","decisions.owner_decision":"负责人决定","decisions.paper_account_application":"模拟账户应用","decisions.credential_maintenance":"凭证维护","decisions.strategy":"策略","decisions.version":"版本","decisions.parameters":"参数","decisions.shadow_passed":"模拟运行已通过","decisions.shadow":"模拟运行指标","decisions.prompt.reconciliation_recovery":"是否采用这份恢复方案？提交后不会直接启用账户。","decisions.prompt.strategy_promotion":"是否采用这项策略晋级方案？","decisions.prompt.owner_decision":"是否采用这个策略候选？","decisions.prompt.paper_account_application":"是否将这个方案应用到模拟账户？","decisions.prompt.credential_maintenance":"凭证需要维护，请在运行状态页处理。","decisions.initial_enrollment_title":"首次接入确认","decisions.prompt.initial_enrollment":"是否确认这份首次接入事实？确认只记录人工意图，不会自动启用账户。","decisions.select_prompt":"从左侧选择一条事项查看详情。","decisions.select_account":"目标账户","decisions.no_account_options":"暂无可用的模拟账户选项，无法提交应用。","decisions.apply_note":"只提交模拟账户应用请求，不会自动启用策略或下单。","decisions.application_submitted":"请求已提交，结果待确认，请勿重复提交。","decisions.application_uncertain":"此前的请求结果待确认，请勿重复提交。","decisions.open_health":"前往运行状态","decisions.submitting":"正在提交…","decisions.confirm_adopt_label":"确认采用","decisions.confirm_decline_label":"确认不采用","decisions.freshness.ready":"就绪","decisions.source.owner":"负责人决定","decisions.source.promotion":"策略晋级","decisions.source.recovery":"对账恢复","decisions.source.credential":"凭证","decisions.technical_details":"参数详情","decisions.account_unbound":"未绑定账户","initial_enrollment.title":"首次接入事实","initial_enrollment.source_time":"来源时间","initial_enrollment.status.complete":"完整","initial_enrollment.status.partial":"部分","initial_enrollment.status.unknown":"未知","initial_enrollment.surface.positions":"持仓","initial_enrollment.surface.cash":"现金","initial_enrollment.surface.open_orders":"未成交委托","initial_enrollment.surface.recent_executions":"近期成交","initial_enrollment.surface.local_execution_ledger":"本地执行账本","initial_enrollment.known_empty":"已确认无记录","initial_enrollment.partial_unavailable":"部分或暂不可用","initial_enrollment.partial_notice":"仅显示已返回的部分记录，不代表完整范围。","initial_enrollment.scope":"范围限定","initial_enrollment.scope_unavailable":"范围信息暂不可用；以下边界保持未知。","initial_enrollment.scope_field.kind":"范围类型","initial_enrollment.scope_field.currency":"币种","initial_enrollment.scope_field.window_start":"窗口开始","initial_enrollment.scope_field.window_end":"窗口结束","initial_enrollment.current_broker_day":"仅当前券商交易日","initial_enrollment.scope_field.limit_per_namespace":"每类记录上限","initial_enrollment.scope_field.gateway_availability":"网关可用性","initial_enrollment.scope_field.truncated":"结果是否截断","initial_enrollment.scope_kind.account_strategy_positions":"账户与策略持仓","initial_enrollment.scope_kind.returned_account_cash":"账户返回的现金","initial_enrollment.scope_kind.all_client_open_orders":"全部客户端未成交委托","initial_enrollment.scope_kind.broker_requested_window":"券商请求的时间窗口","initial_enrollment.scope_kind.bounded_live_claims_and_outcomes":"有界实盘声明与结果","initial_enrollment.value.true":"是","initial_enrollment.value.false":"否","initial_enrollment.blocked":"首次接入资料尚不完整，暂不能确认。","initial_enrollment.notice":"首次接入不构成历史对账，也不会自动启用账户、策略或交易。","initial_enrollment.fact.symbol":"代码","initial_enrollment.fact.underlier":"标的","initial_enrollment.fact.local_symbol":"本地代码","initial_enrollment.fact.expiration":"到期日","initial_enrollment.fact.right":"期权方向","initial_enrollment.fact.strike":"行权价","initial_enrollment.fact.quantity":"数量","initial_enrollment.fact.average_cost":"平均成本","initial_enrollment.fact.currency":"币种","initial_enrollment.fact.tags":"金额标签","initial_enrollment.fact.contract":"合约","initial_enrollment.fact.con_id":"合约标识","initial_enrollment.fact.sec_type":"证券类型","initial_enrollment.fact.perm_id":"永久委托标识","initial_enrollment.fact.action":"买卖方向","initial_enrollment.fact.order_type":"委托类型","initial_enrollment.fact.total_quantity":"委托总量","initial_enrollment.fact.limit_price":"限价","initial_enrollment.fact.aux_price":"附加价格","initial_enrollment.fact.status":"状态","initial_enrollment.fact.filled":"已成交数量","initial_enrollment.fact.remaining":"剩余数量","initial_enrollment.fact.execution_id":"成交标识","initial_enrollment.fact.order_id":"委托标识","initial_enrollment.fact.time":"成交时间","initial_enrollment.fact.side":"方向","initial_enrollment.fact.shares":"股数","initial_enrollment.fact.price":"价格","initial_enrollment.fact.record_count":"记录数","initial_enrollment.fact.CashBalance":"现金余额","initial_enrollment.fact.TotalCashBalance":"现金总额","initial_enrollment.fact.SettledCash":"已结算现金","initial_enrollment.fact.$LEDGER-CashBalance":"账本现金余额","initial_enrollment.fact.$LEDGER-TotalCashBalance":"账本现金总额"},np={"reconciliation.title":"Reconciliation history","reconciliation.current":"Current reconciliation status","reconciliation.not_connected":"Not connected / unknown","reconciliation.history_notice":"Historical recovery plans do not confirm the current reconciliation status.","reconciliation.materials":"Recovery plan details","reconciliation.stale":"Data may not be up to date","reconciliation.read_unknown":"Recovery plan or processing status is unconfirmed","reconciliation.empty":"No recovery records.","reconciliation.unnamed_strategy":"Unnamed strategy","reconciliation.decision_status":"Processing status","reconciliation.decision_unknown":"Processing status unknown","reconciliation.freshness":"Data freshness","reconciliation.observed_at":"Data time","reconciliation.generated_at":"Plan generated at","reconciliation.computed_at":"Calculated at","inbox.count_unknown":"Todo and approval counts cannot be confirmed right now.","inbox.error.quota_exhausted.title":"Todos could not be read","inbox.error.quota_exhausted.detail":"The daily read limit has been reached, so the complete inbox is temporarily unavailable.","inbox.error.unauthorized.title":"Todo access restricted","inbox.error.unauthorized.detail":"Your session has expired or this account lacks read access.","inbox.error.index_missing.title":"Todo list not ready","inbox.error.index_missing.detail":"A complete list is not ready, so todo and approval counts are unknown.","inbox.error.index_incomplete.title":"Todo list update incomplete","inbox.error.index_incomplete.detail":"Some older records are not included yet, so complete todo and approval coverage is unknown.","inbox.error.index_unavailable.title":"Todos could not be read","inbox.error.index_unavailable.detail":"The existing list could not be read completely. Try again later; contact an administrator if the problem persists.","inbox.error.unknown.title":"Todos could not be read","inbox.error.unknown.detail":"The cause is unconfirmed. Try again later; contact an administrator if the problem persists.","inbox.retry_at":"Earliest retry: {value}. Recovery by then is not guaranteed.","inbox.auth_hint":"Sign in again with an account that already has read access.","inbox.retry_hint":"Try again later. The previous failure may still appear for up to one minute.","inbox.retry":"Read todos again","state.fresh":"Fresh","state.unknown":"Unknown","decisions.partial_notice":"Some sources are unavailable or out of date; the affected categories may be incomplete.","decisions.partial_affected":"Affected sources","decisions.partial_consequence.stale":"out of date; this category may be incomplete.","decisions.partial_consequence.unavailable":"unavailable; this category's pending items cannot be confirmed.","decisions.partial_consequence.read_failed":"failed to load; this category's pending items cannot be confirmed.","decisions.unknown_source":"Other source","decisions.material_freshness":"Data freshness: {value}","decisions.stale_hint":"Data may not be up to date","decisions.stale_visible_hint":"Created earlier; verify whether it is still relevant","decisions.affects_live_required":"Live confirmation required","decisions.affects_live_none":"No live impact","decisions.more_info":"More info","decisions.not_set":"Not set","decisions.intent_recorded":"Choice recorded.","decisions.material_changed":"The content has changed. Review it again before confirming.","decisions.intent_not_pending":"This item is no longer pending.","decisions.intent_unavailable":"The latest content cannot be confirmed, so this cannot be submitted. Refresh and try again.","decisions.reconciliation_recovery":"Reconciliation recovery","decisions.strategy_promotion":"Strategy promotion","decisions.owner_decision":"Owner decision","decisions.paper_account_application":"Paper account application","decisions.credential_maintenance":"Credential maintenance","decisions.strategy":"Strategy","decisions.version":"Version","decisions.parameters":"Parameter","decisions.shadow_passed":"Simulation check passed","decisions.shadow":"Simulation metrics","decisions.prompt.reconciliation_recovery":"Adopt this recovery plan? Submitting will not enable the account directly.","decisions.prompt.strategy_promotion":"Adopt this strategy promotion?","decisions.prompt.owner_decision":"Adopt this strategy candidate?","decisions.prompt.paper_account_application":"Apply this proposal to a paper account?","decisions.prompt.credential_maintenance":"This credential needs maintenance; handle it on the Health page.","decisions.initial_enrollment_title":"Initial enrollment","decisions.prompt.initial_enrollment":"Confirm these first-enrollment facts? Confirming records human intent only and does not automatically enable the account.","decisions.select_prompt":"Select an item on the left to see details.","decisions.select_account":"Target account","decisions.no_account_options":"No paper account option is available, so no application can be submitted.","decisions.apply_note":"This only submits a paper account application request; it does not enable the strategy or place orders.","decisions.application_submitted":"Request submitted. The result still needs confirmation; do not resubmit.","decisions.application_uncertain":"An earlier request still needs confirmation. Do not resubmit.","decisions.open_health":"Open Health","decisions.submitting":"Submitting…","decisions.confirm_adopt_label":"Confirm adopt","decisions.confirm_decline_label":"Confirm decline","decisions.freshness.ready":"Ready","decisions.source.owner":"Owner decisions","decisions.source.promotion":"Strategy promotions","decisions.source.recovery":"Reconciliation recovery","decisions.source.credential":"Credentials","decisions.technical_details":"Parameter details","decisions.account_unbound":"No linked account","initial_enrollment.title":"First enrollment facts","initial_enrollment.source_time":"Source time","initial_enrollment.status.complete":"Complete","initial_enrollment.status.partial":"Partial","initial_enrollment.status.unknown":"Unknown","initial_enrollment.surface.positions":"Positions","initial_enrollment.surface.cash":"Cash","initial_enrollment.surface.open_orders":"Open orders","initial_enrollment.surface.recent_executions":"Recent executions","initial_enrollment.surface.local_execution_ledger":"Local execution ledger","initial_enrollment.known_empty":"No records (confirmed)","initial_enrollment.partial_unavailable":"Partial or unavailable","initial_enrollment.partial_notice":"Only the returned partial records are shown; they do not represent the complete scope.","initial_enrollment.scope":"Bounded scope","initial_enrollment.scope_unavailable":"Scope information is unavailable; the bounds below remain unknown.","initial_enrollment.scope_field.kind":"Scope type","initial_enrollment.scope_field.currency":"Currency","initial_enrollment.scope_field.window_start":"Window start","initial_enrollment.scope_field.window_end":"Window end","initial_enrollment.current_broker_day":"Current broker day only","initial_enrollment.scope_field.limit_per_namespace":"Limit per record type","initial_enrollment.scope_field.gateway_availability":"Gateway availability","initial_enrollment.scope_field.truncated":"Truncated","initial_enrollment.scope_kind.account_strategy_positions":"Account and strategy positions","initial_enrollment.scope_kind.returned_account_cash":"Returned account cash","initial_enrollment.scope_kind.all_client_open_orders":"All client open orders","initial_enrollment.scope_kind.broker_requested_window":"Broker-requested window","initial_enrollment.scope_kind.bounded_live_claims_and_outcomes":"Bounded live claims and outcomes","initial_enrollment.value.true":"Yes","initial_enrollment.value.false":"No","initial_enrollment.blocked":"First enrollment facts are incomplete, so they cannot be confirmed yet.","initial_enrollment.notice":"First enrollment is not a historical reconciliation and does not automatically enable the account, strategy or trading.","initial_enrollment.fact.symbol":"Symbol","initial_enrollment.fact.underlier":"Underlier","initial_enrollment.fact.local_symbol":"Local symbol","initial_enrollment.fact.expiration":"Expiration","initial_enrollment.fact.right":"Option right","initial_enrollment.fact.strike":"Strike","initial_enrollment.fact.quantity":"Quantity","initial_enrollment.fact.average_cost":"Average cost","initial_enrollment.fact.currency":"Currency","initial_enrollment.fact.tags":"Amount tags","initial_enrollment.fact.contract":"Contract","initial_enrollment.fact.con_id":"Contract ID","initial_enrollment.fact.sec_type":"Security type","initial_enrollment.fact.perm_id":"Permanent order ID","initial_enrollment.fact.action":"Action","initial_enrollment.fact.order_type":"Order type","initial_enrollment.fact.total_quantity":"Total quantity","initial_enrollment.fact.limit_price":"Limit price","initial_enrollment.fact.aux_price":"Auxiliary price","initial_enrollment.fact.status":"Status","initial_enrollment.fact.filled":"Filled","initial_enrollment.fact.remaining":"Remaining","initial_enrollment.fact.execution_id":"Execution ID","initial_enrollment.fact.order_id":"Order ID","initial_enrollment.fact.time":"Execution time","initial_enrollment.fact.side":"Side","initial_enrollment.fact.shares":"Shares","initial_enrollment.fact.price":"Price","initial_enrollment.fact.record_count":"Record count","initial_enrollment.fact.CashBalance":"Cash balance","initial_enrollment.fact.TotalCashBalance":"Total cash balance","initial_enrollment.fact.SettledCash":"Settled cash","initial_enrollment.fact.$LEDGER-CashBalance":"Ledger cash balance","initial_enrollment.fact.$LEDGER-TotalCashBalance":"Ledger total cash balance"},lp={"accounts.open_strategy":"查看 {account} 的 {strategy} 设置","accounts.retired_option_draft":"保存时会清除旧期权草稿，不会更改实盘配置。","accounts.execution.mode":"执行模式","accounts.execution.reason.evidence_missing":"执行方式尚未确认。","accounts.execution.broker_environment":"券商环境：{value}","accounts.execution.source":"配置来源：{value}","accounts.execution.observed":"配置检查时间：","accounts.execution.config_only":"仅说明已读取的配置，当前运行及成交状态未验证。","accounts.execution.runtime_target_note":"运行目标已启用只表示配置状态，不代表已实盘运行或今日已有成交。","accounts.activation_setting":"启用设置","accounts.execution.source.runtime_target":"运行目标配置","accounts.execution.source.service_target":"服务目标配置","accounts.execution.source.missing":"未提供执行配置来源","accounts.execution.reason.not_connected":"配置读取未接入","accounts.execution.reason.read_failed":"配置读取失败","accounts.execution.reason.permission_denied":"无权读取配置","accounts.execution.reason.broker_environment_missing":"账户目录缺少明确的券商环境","accounts.execution.reason.execution_config_missing":"缺少匹配账户的明确执行模式配置","accounts.execution.reason.dry_run_flag_missing":"缺少明确的演练限制配置","accounts.execution.reason.environment_conflict":"券商环境与执行配置冲突","accounts.environment.live":"实盘账户","accounts.environment.paper":"模拟账户","accounts.environment.unknown":"环境待确认","accounts.environment_count":"{count} 个账户","accounts.environment.paper_note":"模拟账户金额单列，不计入实盘合计。","accounts.environment.unknown_note":"环境未确认的账户不计入实盘合计；金额按各来源展示。","accounts.unassigned_note":"{count} 条待办未关联账户","accounts.go_todos":"去待办","accounts.select_account":"选择一个账户查看详情","accounts.select_account_hint":"从账户列表中选择要查看的账户。","accounts.back_to_list":"返回账户列表","accounts.identity":"账户标识","accounts.data_notes":"数据说明","accounts.draft_value":"草案：{value}","accounts.section.strategy":"策略","accounts.section.dca":"定投","accounts.section.cash_reserve":"资金预留","accounts.section.income_layer":"收入层","accounts.section.options_layer":"期权层","accounts.field.strategy_profile":"策略档案","accounts.field.dca_mode":"定投模式","accounts.field.dca_base_investment_usd":"定投基准金额（USD）","accounts.field.reserved_cash_floor":"预留现金下限（USD）","accounts.field.reserved_cash_ratio":"预留现金比例","accounts.field.income_layer_enabled":"收入层","accounts.field.option_overlay_enabled":"期权层","accounts.bool.on":"开启","accounts.bool.off":"关闭","accounts.dca_mode.fixed":"定额定投","accounts.dca_mode.smart":"智能定投","accounts.form.inherit":"跟随当前值","accounts.form.clear_override":"清除覆盖","accounts.form.undo":"撤销修改","accounts.form.select_profile":"请选择策略档案","accounts.form.dca_pair_required":"定投模式与金额需要一起填写","accounts.form.invalid_decimal":"需要是不小于 0 的数字","accounts.form.invalid_ratio":"比例需要在 0 到 1 之间，例如 0.15","accounts.form.invalid_dca_amount":"定投金额需为大于 0 的数字","accounts.checking":"正在检查最新配置…","accounts.saving":"正在保存…","accounts.save_unknown":"保存结果未知；请刷新确认当前草案，确认前不要重复提交。","controls.submitting":"正在提交…","controls.confirm.enable_title":"确认启用运行目标","controls.confirm.resume_title":"确认恢复运行目标","controls.confirm.approve_title":"确认批准策略应用","controls.enable_note":"当前页面暂不支持提交启用请求；运行目标状态保持不变。","controls.enable_control_note":"启用不会解除已有保护状态。","controls.protected":"已有保护状态仍然生效。","controls.approve_not_ready":"当前没有仅修改策略档案且可批准的草案；请刷新确认。","controls.stop_consequence":"停止只阻止新的触发；不会撤单、平仓或清除在途请求。","controls.result.enable":"已启用","controls.result.disable":"已停用","accounts.effect_unconfirmed":"暂时无法确认是否生效。","accounts.declaration.title":"账户声明","accounts.declaration.note":"用于账户展示，不会改变交易设置。","accounts.declaration.environment":"环境声明","accounts.declaration.account_type":"账户类型","accounts.declaration.env.live":"实盘","accounts.declaration.env.paper":"模拟","accounts.declaration.type.cash":"现金账户","accounts.declaration.type.margin":"保证金账户","accounts.declaration.unset":"未声明","accounts.declaration.savedValue":"已声明","accounts.declaration.save":"保存声明","accounts.declaration.discard":"撤销修改","accounts.declaration.saving":"正在保存声明…","accounts.declaration.saved":"声明已保存。","accounts.declaration.conflict":"保存冲突；请重新读取后再试。","accounts.declaration.mismatch":"读回结果与提交内容不一致。","accounts.declaration.unverified":"保存结果未知；请重新读取确认，确认前不要重复提交。","accounts.declaration.review":"保存结果未知；请重新读取确认。","accounts.declaration.gate":"当前不支持保存账户声明。","accounts.declaration.reread":"重新读取","accounts.declaration.denied":"没有权限读取账户声明。","accounts.declaration.readMismatch":"读回的账户与所选账户不一致。","accounts.declaration.readFailed":"账户声明暂时读不到。","accounts.declaration.stale":"显示的是上次读取的声明。","accounts.declaration.conflict_notice":"与已有信息不一致，请确认。","accounts.declaration.ack":"已了解"},ip={"accounts.open_strategy":"Open {strategy} settings for {account}","accounts.retired_option_draft":"Saving removes the old options draft without changing live configuration.","accounts.execution.mode":"Execution mode","accounts.execution.reason.evidence_missing":"Execution mode is not yet confirmed.","accounts.execution.broker_environment":"Broker environment: {value}","accounts.execution.source":"Configuration source: {value}","accounts.execution.observed":"Configuration checked at:","accounts.execution.config_only":"Describes the configuration read; current runs and fills are unverified.","accounts.execution.runtime_target_note":"An enabled runtime target is configuration state only; it does not mean live trading ran or produced fills today.","accounts.activation_setting":"Activation setting","accounts.execution.source.runtime_target":"Runtime target configuration","accounts.execution.source.service_target":"Service target configuration","accounts.execution.source.missing":"Execution configuration source unavailable","accounts.execution.reason.not_connected":"Configuration reader is not connected","accounts.execution.reason.read_failed":"Configuration read failed","accounts.execution.reason.permission_denied":"Configuration read permission denied","accounts.execution.reason.broker_environment_missing":"Account directory has no explicit broker environment","accounts.execution.reason.execution_config_missing":"No explicit execution mode in a matching account configuration","accounts.execution.reason.dry_run_flag_missing":"Explicit dry-run constraint is missing","accounts.execution.reason.environment_conflict":"Broker environment conflicts with execution configuration","accounts.environment.live":"Live accounts","accounts.environment.paper":"Paper accounts","accounts.environment.unknown":"Environment unconfirmed","accounts.environment_count":"{count} accounts","accounts.environment.paper_note":"Paper account amounts are listed separately and excluded from live totals.","accounts.environment.unknown_note":"Accounts with an unconfirmed environment are excluded from live totals; amounts are shown per source.","accounts.unassigned_note":"{count} to-dos are not linked to an account","accounts.go_todos":"Open to-dos","accounts.select_account":"Select an account to see details","accounts.select_account_hint":"Pick an account from the list.","accounts.back_to_list":"Back to accounts","accounts.identity":"Account ID","accounts.data_notes":"Data notes","accounts.draft_value":"Draft: {value}","accounts.section.strategy":"Strategy","accounts.section.dca":"DCA","accounts.section.cash_reserve":"Cash reserve","accounts.section.income_layer":"Income layer","accounts.section.options_layer":"Options layer","accounts.field.strategy_profile":"Strategy profile","accounts.field.dca_mode":"DCA mode","accounts.field.dca_base_investment_usd":"DCA base amount (USD)","accounts.field.reserved_cash_floor":"Reserved cash floor (USD)","accounts.field.reserved_cash_ratio":"Reserved cash ratio","accounts.field.income_layer_enabled":"Income layer","accounts.field.option_overlay_enabled":"Option overlay","accounts.bool.on":"On","accounts.bool.off":"Off","accounts.dca_mode.fixed":"Fixed amount","accounts.dca_mode.smart":"Smart","accounts.form.inherit":"Inherit current value","accounts.form.clear_override":"Clear override","accounts.form.undo":"Undo","accounts.form.select_profile":"Select a strategy profile","accounts.form.dca_pair_required":"DCA mode and amount must be provided together","accounts.form.invalid_decimal":"Must be a number greater than or equal to 0","accounts.form.invalid_ratio":"Ratio must be between 0 and 1, e.g. 0.15","accounts.form.invalid_dca_amount":"DCA amount must be a number greater than 0","accounts.checking":"Checking the latest settings…","accounts.saving":"Saving…","accounts.save_unknown":"The save result is unknown. Refresh and verify the current draft; do not resubmit until then.","controls.submitting":"Submitting…","controls.confirm.enable_title":"Confirm enabling the runtime target","controls.confirm.resume_title":"Confirm resuming the runtime target","controls.confirm.approve_title":"Confirm approving the strategy application","controls.enable_note":"This page cannot submit an enable request yet. The runtime target state stays unchanged.","controls.enable_control_note":"Enabling does not remove an existing protection state.","controls.protected":"The existing protection state remains active.","controls.approve_not_ready":"There is no approvable draft that changes only the strategy profile. Refresh and check again.","controls.stop_consequence":"Stopping only blocks new triggers; it does not cancel orders, close positions, or clear in-flight requests.","controls.result.enable":"Enabled","controls.result.disable":"Disabled","accounts.effect_unconfirmed":"Unable to confirm whether the change took effect.","accounts.declaration.title":"Account declaration","accounts.declaration.note":"Used for account display; trading settings are unchanged.","accounts.declaration.environment":"Environment declaration","accounts.declaration.account_type":"Account type","accounts.declaration.env.live":"Live","accounts.declaration.env.paper":"Paper","accounts.declaration.type.cash":"Cash account","accounts.declaration.type.margin":"Margin account","accounts.declaration.unset":"Not declared","accounts.declaration.savedValue":"Declared","accounts.declaration.save":"Save declaration","accounts.declaration.discard":"Discard changes","accounts.declaration.saving":"Saving declaration…","accounts.declaration.saved":"Declaration saved.","accounts.declaration.conflict":"Save conflict; re-read and try again.","accounts.declaration.mismatch":"The readback does not match what was submitted.","accounts.declaration.unverified":"The save result is unknown; re-read to confirm and do not resubmit until then.","accounts.declaration.review":"The save result is unknown; re-read to confirm.","accounts.declaration.gate":"Saving account declarations is not available.","accounts.declaration.reread":"Re-read","accounts.declaration.denied":"No permission to read the account declaration.","accounts.declaration.readMismatch":"The readback account does not match the selected account.","accounts.declaration.readFailed":"The account declaration is temporarily unavailable.","accounts.declaration.stale":"Showing the declaration from the last successful read.","accounts.declaration.conflict_notice":"This differs from available information. Please check.","accounts.declaration.ack":"Acknowledge"},cp={"strategies.assignment_unknown":"账户绑定待确认","strategies.assignment_unavailable":"账户配置未完整读取，暂无法确认策略绑定；已有健康数据仍按其来源日期展示。","strategies.health_as_of":"健康数据截至 {value}","strategies.health_label":"策略健康","strategies.health_not_provided":"未提供","strategies.execution_section":"账户执行模式","strategies.execution_unknown_note":"未知表示账户目录或运行目标还缺少明确的执行配置；补齐后会自动确认。","strategies.domain_note":"策略健康来自策略评估；执行模式来自账户配置。两者都不代表平台今日运行结果。","reason.strategy_health_stale":"策略健康数据已过期。","strategies.details":"详细信息","strategies.research_unavailable":"研究资料暂时不可用。","strategies.research_sources":"来源：{value}","strategies.research_as_of":"资料日期：{value}","strategies.research_expires":"有效期至 {value}","strategies.research_more":"查看说明","research.source.generic":"研究来源","research.source.quant-advisor-research":"量化研究信号","research.source.quant_advisor_research":"量化研究信号","research.state.context_only":"仅作背景","research.state.candidate":"研究候选","research.state.source_verification_required":"来源待核实","research.state.deferred":"暂缓研究","state.unknown":"未知","strategies.research_empty":"暂无研究资料。","strategies.configured_section":"已配置策略","strategies.catalog_section":"目录策略","strategies.section_count":"{count} 项","strategies.no_configured":"当前没有账户配置策略；可从下方目录继续查看。","strategies.binding":"账户绑定","strategies.unbound":"未绑定账户","strategies.unbound_note":"目录项尚未绑定账户；这不表示策略已停用或正在运行。","strategies.unmatched_title":"目录外策略绑定","strategies.unmatched_note":"以下账户绑定的策略不在当前策略目录中（可能已停用或改名）。此处只读展示绑定事实，不推断该策略仍可运行。","strategies.unmatched_profile":"目录中不存在的策略标识"},up={"strategies.assignment_unknown":"Account binding unconfirmed","strategies.assignment_unavailable":"Account configuration could not be read completely, so strategy bindings are unconfirmed. Available health data keeps its source date.","strategies.health_as_of":"Health data as of {value}","strategies.health_label":"Strategy health","strategies.health_not_provided":"Not provided","strategies.execution_section":"Account execution mode","strategies.execution_unknown_note":"Unknown means the account directory or runtime target still lacks explicit execution configuration; it confirms automatically once supplied.","strategies.domain_note":"Strategy health comes from strategy evaluation; execution mode comes from account configuration. Neither establishes today's platform run result.","reason.strategy_health_stale":"Strategy health data is stale.","strategies.details":"Details","strategies.research_unavailable":"Research data is temporarily unavailable.","strategies.research_sources":"Sources: {value}","strategies.research_as_of":"Data as of: {value}","strategies.research_expires":"Expires {value}","strategies.research_more":"View notes","research.source.generic":"Research source","research.source.quant-advisor-research":"Quant research signal","research.source.quant_advisor_research":"Quant research signal","research.state.context_only":"Context only","research.state.candidate":"Research candidate","research.state.source_verification_required":"Source verification required","research.state.deferred":"Research deferred","state.unknown":"Unknown","strategies.research_empty":"No research data yet.","strategies.configured_section":"Configured strategies","strategies.catalog_section":"Catalog strategies","strategies.section_count":"{count}","strategies.no_configured":"No account is configured with a strategy yet. Browse the catalog below.","strategies.binding":"Account binding","strategies.unbound":"No account linked","strategies.unbound_note":"This catalog entry has no linked account; it does not mean the strategy is stopped or running.","strategies.unmatched_title":"Bindings outside the catalog","strategies.unmatched_note":"These accounts are bound to a strategy the current catalog no longer declares (retired or renamed). The row reports the binding as configured; it does not claim the strategy can still run.","strategies.unmatched_profile":"Strategy identifier missing from the catalog"},op={"health.failure_at_least":"至少 {count}","health.failure_window":"{date} · 纽约时间","health.failure_window_detail":"仅统计今日，不含下方 14 日历史；纽约时间含夏令时。","health.failure_incomplete":"部分数据未返回","health.kpi.today_runs":"完整数据账户","health.kpi.today_runs_note":"未接入 {not_connected} · 暂无数据 {no_data}","health.kpi.today_runs_note_title":"未接入和暂无数据不计为失败。","health.kpi.observed":"今日有记录账户","health.kpi.credentials":"凭证","health.kpi.credentials_unit":"项需关注","health.kpi.recent_failure":"今日失败账户","health.business_date":"纽约业务日 {value}","health.non_trading_day":"非交易日：周末无计划运行；加密货币账户可能仍有记录。","health.non_trading_day_short":"非交易日","health.grid_read_failed_note":"部分日期读取失败，无法确认当天是否运行。","health.grid.binding_changed":"绑定已轮换","health.grid.binding_changed_detail":"该日期记录写于绑定轮换之前，无法与当前账户绑定匹配，因此不展示；这不代表当天未运行。","health.grid_binding_changed_note":"部分日期属于绑定轮换前的历史记录；记录已保留，但不会与当前账户绑定混用。","health.global_scope_note":"本页展示全部平台与账户的运行状态。","health.grid.incomplete":"未完成","health.col.credential":"凭证","health.col.phase":"阶段","health.col.expires":"到期时间","health.col.channel":"渠道","health.col.summary":"内容","health.detail.started":"开始","health.detail.finished":"结束","health.account_fraction":"{count}/{total}","health.state_counts":"今日账户状态（有数据）","health.state_details":"状态明细","health.day_detail_summary":"{count} 次运行","health.day_detail_runs":"查看每次运行","health.run_state.succeeded":"成功","health.run_state.failed":"失败","health.run_state.blocked":"被拦截","health.run_state.no_data":"暂无数据","health.run_state.not_connected":"未接入","health.run_state.not_run":"尚未到期或非运行时段","health.run_state.unknown":"未知","health.run_state.read_failed":"读取失败","health.run_state.incomplete":"读取不完整"},sp={"health.failure_at_least":"At least {count}","health.failure_window":"{date} · New York time","health.failure_window_detail":"Today only; excludes the 14-day history below. New York time observes DST.","health.failure_incomplete":"Some data was not returned","health.kpi.today_runs":"Accounts with complete data","health.kpi.today_runs_note":"Not connected: {not_connected} · no data: {no_data}","health.kpi.today_runs_note_title":"Not connected and no data do not count as failures.","health.kpi.observed":"Accounts with today's records","health.kpi.credentials":"Credentials","health.kpi.credentials_unit":"need attention","health.kpi.recent_failure":"Today's failed accounts","health.business_date":"New York business day {value}","health.non_trading_day":"Non-trading day: no scheduled weekend runs; crypto accounts may still report.","health.non_trading_day_short":"Non-trading day","health.grid_read_failed_note":"Some dates could not be read, so whether a run occurred is unknown.","health.grid.binding_changed":"Binding rotated","health.grid.binding_changed_detail":"This day was recorded under an earlier binding and no longer matches the current account binding, so it is not shown. It does not mean no run occurred.","health.grid_binding_changed_note":"Some dates predate a binding rotation; their records are retained but never mixed with the current account binding.","health.global_scope_note":"This page shows runtime status for all platforms and accounts.","health.grid.incomplete":"Incomplete","health.col.credential":"Credential","health.col.phase":"Phase","health.col.expires":"Expires","health.col.channel":"Channel","health.col.summary":"Summary","health.detail.started":"Started","health.detail.finished":"Finished","health.account_fraction":"{count}/{total}","health.state_counts":"Today's account states (with data)","health.state_details":"Status details","health.day_detail_summary":"{count} runs","health.day_detail_runs":"View individual runs","health.run_state.succeeded":"Succeeded","health.run_state.failed":"Failed","health.run_state.blocked":"Blocked","health.run_state.no_data":"No data","health.run_state.not_connected":"Not connected","health.run_state.not_run":"Not due or outside run window","health.run_state.unknown":"Unknown","health.run_state.read_failed":"Read failed","health.run_state.incomplete":"Read incomplete"},rp={"facts.assets":"资产","facts.cash":"现金","facts.available_cash":"可用现金","facts.cash_semantics":"券商提供的现金余额，不代表购买力、可用资金或保证金。","facts.identity_unverified":"账户身份未核验，金额暂不展示","facts.platform_identity_unverified":"平台合计不可用：有账户身份未核验","facts.observation_conflict":"同一账户身份的数据不一致，金额暂不展示","facts.amount_unavailable":"金额不可用","facts.platform_total":"平台合计","facts.platform_subtotal":"部分合计","facts.platform_total_live":"实盘合计","facts.platform_subtotal_live":"实盘小计","facts.platform_scope_note":"仅含实盘账户，不含模拟账户；仅合计已核验且估值日期一致的账户。","facts.platform_subtotal_note":"仅合计已核验且估值日期一致的账户。","facts.coverage":"已计入 {covered}/{expected} 个账户","facts.partial_badge":"估值不完整","facts.stale_pending":"待更新","facts.as_of_stale":"截至 {value} · 待更新","facts.identity_action":"去核验账户","facts.wallet_valuation":"钱包估值","facts.wallet_holdings":"持仓 · {count} 种资产","facts.wallet_scope_note":"Binance 返回的钱包估值，不代表完整账户净值或现金；不计入实盘账户合计。","facts.wallet_holdings_scope_note":"持仓数量仅覆盖现货与活期理财，不含资金账户、杠杆、合约及锁定理财。","facts.wallet_unavailable":"暂不可用","facts.wallet_no_data":"暂无数据","facts.wallet_pending":"待更新","facts.wallet_read_failed":"读取失败"},fp={"facts.assets":"Assets","facts.cash":"Cash","facts.available_cash":"Available cash","facts.cash_semantics":"Broker-reported cash balance; this is not buying power, available funds, or margin.","facts.identity_unverified":"Account identity unverified; amounts are hidden","facts.platform_identity_unverified":"Platform total unavailable: some account identities are unverified","facts.observation_conflict":"Data conflicts for the same account identity; amounts are hidden","facts.amount_unavailable":"Amount unavailable","facts.platform_total":"Platform total","facts.platform_subtotal":"Subtotal","facts.platform_total_live":"Live total","facts.platform_subtotal_live":"Live subtotal","facts.platform_scope_note":"Live accounts only; paper accounts are excluded. Only verified accounts with the same valuation date are summed.","facts.platform_subtotal_note":"Only verified accounts with the same valuation date are included.","facts.coverage":"Includes {covered} of {expected} accounts","facts.partial_badge":"Valuation incomplete","facts.stale_pending":"Update pending","facts.as_of_stale":"As of {value} · update pending","facts.identity_action":"Verify accounts","facts.wallet_valuation":"Wallet valuation","facts.wallet_holdings":"Holdings · {count} assets","facts.wallet_scope_note":"Provider-returned wallet valuation, not complete account NAV or cash; excluded from live-account totals.","facts.wallet_holdings_scope_note":"Quantities cover Spot and Flexible Earn only; funding, margin, futures, and locked Earn are excluded.","facts.wallet_unavailable":"Temporarily unavailable","facts.wallet_no_data":"No data","facts.wallet_pending":"Update pending","facts.wallet_read_failed":"Read failed"},Ki={...W_,...P_,...ep,...ap,...lp,...cp,...op,...rp},Ji={...F_,...I_,...tp,...np,...ip,...up,...sp,...fp};for(const u of Object.keys(Ki))if(!(u in Ji))throw new Error(`i18n: missing en translation for ${u}`);for(const u of Object.keys(Ji))if(!(u in Ki))throw new Error(`i18n: missing zh translation for ${u}`);function Jd(u,s,m={}){const r=u==="zh"?Ki:Ji,E=s.startsWith("state.")?"state.unknown_status":s.startsWith("reason.")?"reason.unknown":s.startsWith("research.state.")?"state.unknown_status":null;return(r[s]??(u==="zh"?Ji[s]:Ki[s])??(E?r[E]:s)).replace(/\{(\w+)\}/g,(C,U)=>U in m?String(m[U]):C)}const $d=j.createContext("zh");function Zi({language:u,children:s}){return _.jsx($d.Provider,{value:u,children:s})}function ka(){return j.useContext($d)}function at(){const u=ka();return(s,m)=>Jd(u,s,m)}const Rl={theme:"system",language:"en",upDown:"green-up",hideAmounts:!1,defaultRange:"YTD"},Ot={theme:"qsl-theme-preference",language:"qsl-switch-lang",upDown:"qsl-updown-preference",hideAmounts:"qsl-hide-amounts",defaultRange:"qsl-default-range"};function Al(u){try{return window.localStorage.getItem(u)}catch{return null}}function wl(u,s){try{return window.localStorage.setItem(u,s),window.localStorage.getItem(u)===s}catch{return!1}}function dp(u){return u==="light"||u==="dark"||u==="system"?u:Rl.theme}function hp(u){if(u==="zh"||u==="zh-CN")return"zh";if(u==="en")return"en";const s=typeof navigator>"u"?[]:navigator.languages?.length?navigator.languages:[navigator.language];for(const m of s){if(/^zh(?:-|$)/i.test(m))return"zh";if(/^en(?:-|$)/i.test(m))return"en"}return Rl.language}function mp(u){return u==="red-up"||u==="green-up"?u:Rl.upDown}function _p(u){return u==="1M"||u==="3M"||u==="YTD"||u==="1Y"||u==="ALL"?u:Rl.defaultRange}function Wd(){return{theme:dp(Al(Ot.theme)),language:hp(Al(Ot.language)),upDown:mp(Al(Ot.upDown)),hideAmounts:Al(Ot.hideAmounts)==="1",defaultRange:_p(Al(Ot.defaultRange))}}function pp(u){return[wl(Ot.theme,u.theme),wl(Ot.language,u.language),wl(Ot.upDown,u.upDown),wl(Ot.hideAmounts,u.hideAmounts?"1":"0"),wl(Ot.defaultRange,u.defaultRange)].every(Boolean)}function Fd(u,s){return u==="system"?s?"dark":"light":u}const Pd=j.createContext(null),Id=j.createContext({prefs:Rl,persistFailed:!1,resolvedTheme:"light",setPrefs:()=>{}});function Ro(){return j.useContext(Id)}const eh=j.createContext({scope:"all",options:[],setScope:()=>{},status:"ready",metaStatus:"ready",retry:()=>{}});function th(){return j.useContext(eh)}const ah=j.createContext(()=>{});function gp(){return j.useContext(ah)}const vp=["overview","performance","decisions","accounts","strategies","health"],nh="all";function Hd(u){const s=new URLSearchParams(u);let m=s.get("page");const r=s.get("workspace");return!m&&r==="research"&&(m="decisions"),!m&&r==="accounts"&&(m="accounts"),(!m||!vp.includes(m))&&(m="overview"),{page:m,scope:s.get("scope")||nh,account:s.get("account"),tab:s.get("tab")}}function yp(u){const s=new URLSearchParams;u.page!=="overview"&&s.set("page",u.page),u.scope!==nh&&s.set("scope",u.scope),u.account&&s.set("account",u.account),u.tab&&s.set("tab",u.tab);const m=s.toString();return m?`?${m}`:""}function Bd(u){const s=yp(u);window.history.pushState({qsl:u},"",`${window.location.pathname}${s}`)}let lh=null;function ig(u){lh=u}function Eo(){return lh}class No extends Error{status;constructor(s){super(s===401?"session_expired":"access_denied"),this.status=s}}class ih extends Error{status;payload;constructor(s,m){const r=m?.error;super(r||`http_${s}`),this.status=s,this.payload=m}}let Fi=0,Do=0;function bp(){return Do}function Mo(){Fi+=1,Do+=1,window.dispatchEvent(new Event("qsl-private-session-invalid"))}function $i(u){if(u!==Fi)throw new Error("session_invalidated")}async function Ee(u){const s=Fi,m=await fetch(u,{method:"GET",credentials:"same-origin",cache:"no-store",headers:{Accept:"application/json"}});if(m.status===401||m.status===403)throw Mo(),new No(m.status);if($i(s),!m.ok){const E=await m.json().catch(()=>({}));throw new ih(m.status,E)}const r=await m.json();return $i(s),r}async function ch(u,s){const m=Fi,r=await fetch(u,{method:"POST",credentials:"same-origin",cache:"no-store",headers:{Accept:"application/json","Content-Type":"application/json"},body:JSON.stringify(s)});if(r.status===401||r.status===403)throw Mo(),new No(r.status);$i(m);const E=await r.json().catch(()=>({}));if($i(m),!r.ok||E?.ok===!1)throw new ih(r.status,E);return Do+=1,E}function Ao(u){return`${u.platform}:${u.account_alias}`}function Sp(u,s){if(!s)return;const m=u.find(E=>Ao(E)===s);if(m)return m;const r=u.filter(E=>E.account_alias===s);return r.length===1?r[0]:void 0}function uh(u,s,m){return u?.accountOptions?.[s]?.find(r=>r.key===m)}function Ld(u,s){return uh(u,s.platform,s.account_alias)?.account_selector?.trim()||s.account_alias}function cg(u,s){const m=new Map;for(const r of u){let E=m.get(r.platform);E||m.set(r.platform,E=new Map);const C=Ld(s,r).toUpperCase(),U=E.get(C);U?U.push(r):E.set(C,[r])}return[...m].map(([r,E])=>({platform:r,accounts:[...E.values()].map(R=>({identity:Ld(s,R[0]),rows:R}))}))}function oh(u,s){const m=u.indexOf(":");return m>0?{scope:u.slice(m+1),platform:u.slice(0,m)}:{scope:u,platform:s}}const Yd={};function xp(){return Ee("/api/session")}let Vi=null,En=null;const wo=new Set;function Tp(u){return wo.add(u),()=>{wo.delete(u)}}function Ep(u){const s=Number(u?Yd?.VITE_INBOX_FAILURE_BACKOFF_MS:Yd?.VITE_INBOX_CACHE_MS);return Number.isFinite(s)&&s>=1e3&&s<=3e5?s:u?6e4:15e3}function Ap(u=!1){const s=bp();return En&&En.revision===s&&Date.now()<En.until&&(!u||En.value.status==="read_failed")?Promise.resolve(En.value):(Vi||(Vi=Ee("/api/decisions-inbox").then(m=>{En={value:m,until:Date.now()+Ep(m.status==="read_failed"),revision:s};for(const r of[...wo])r();return m}).finally(()=>{Vi=null})),Vi)}function ug(u=25,s){const m=new URLSearchParams({limit:String(u)});return s&&m.set("cursor",s),Ee(`/api/owner-decisions/history?${m}`)}function wp(){return Ee("/api/accounts")}function og(){return Ee("/api/account-facts")}function sg(){return Ee("/api/binance-account-facts")}function rg(u,s){const m=new URLSearchParams({account:u});return s&&m.set("platform",s),Ee(`/api/account-settings/diff?${m}`)}function fg(u,s,m=25,r){const E=new URLSearchParams({account:u,limit:String(m)});return s&&E.set("platform",s),r&&E.set("cursor",r),Ee(`/api/account-settings/history?${E}`)}function dg(u){return ch("/api/account-settings/draft",u)}function hg(u,s){const m=new URLSearchParams({platform:u,key:s});return Ee(`/api/account-settings?${m}`)}function mg(){return Ee("/api/runtime/today")}function _g(){return Ee("/api/strategies/summary")}function pg(u,s){const m=new URLSearchParams({account:u});return s&&m.set("platform",s),Ee(`/api/accounts/run-controls?${m}`)}function Nl(u,s,m){const r=oh(u,m),E=new URLSearchParams({scope:r.scope,range:s});return r.platform&&E.set("platform",r.platform),String(E)}function gg(u,s,m){return Ee(`/api/performance/summary?${Nl(u,s,m)}`)}function vg(u,s,m){return Ee(`/api/performance/returns?${Nl(u,s,m)}`)}function yg(u,s,m){return Ee(`/api/performance/assets?${Nl(u,s,m)}`)}function bg(u,s,m){return Ee(`/api/performance/holdings?${Nl(u,s,m)}`)}function Sg(u,s,m){return Ee(`/api/performance/trades?${Nl(u,s,m)}`)}function xg(u,s,m,r,E,R){const C=oh(u,E),U=new URLSearchParams({scope:C.scope,range:s,year:String(m)});return r!=null&&U.set("month",String(r)),C.platform&&U.set("platform",C.platform),R&&U.set("currency",R),Ee(`/api/performance/calendar?${U}`)}async function Tg(){return(await Ee("/api/config")).runtimeDailyBindings??[]}function Eg(u,s,m,r=!0){const E=new URLSearchParams({date:u});return s&&E.set("platform",s),m&&E.set("account_key",m),r||E.set("include_history","false"),Ee(`/api/runtime-daily?${E}`)}function Ag(){return Ee("/api/credential-maintenance")}async function zp(u,s=fetch){if(!/^[a-f0-9]{64}$/.test(u))return!1;const m=await s("/",{method:"HEAD",cache:"no-store",credentials:"omit"}),r=m.headers.get("X-Console-Build");return m.ok&&/^[a-f0-9]{64}$/.test(r||"")&&r!==u}function Rp(){const u=at(),[s,m]=j.useState(!1);if(j.useEffect(()=>{const E=document.querySelector('meta[name="qsl-console-build"]')?.content||"";let R=!1,C=!1,U=0;const v=async()=>{if(!(document.visibilityState!=="visible"||C||Date.now()-U<6e4)){C=!0,U=Date.now();try{await zp(E)&&!R&&m(!0)}catch{}finally{C=!1}}};return window.addEventListener("focus",v),document.addEventListener("visibilitychange",v),()=>{R=!0,window.removeEventListener("focus",v),document.removeEventListener("visibilitychange",v)}},[]),!s)return null;const r=async()=>{const E=Eo();(!E||await E())&&window.location.reload()};return _.jsxs("div",{className:"update-notice",role:"status",children:[_.jsx("span",{children:u("shell.update_available")}),_.jsx("button",{type:"button",className:"button button-secondary",onClick:()=>{r()},children:u("shell.reload")})]})}const Gd=new Map,Wi=new Map;function Oo(u){return u==="zh"?"zh-CN":"en-US"}function Pi(u,s){const m=`${u}:${JSON.stringify(s)}`;let r=Gd.get(m);return r||(r=new Intl.NumberFormat(Oo(u),s),Gd.set(m,r)),r}function Np(u,s,m=2){return u==null||!Number.isFinite(u)?"—":`${u>0?"+":u<0?"-":""}${Pi(s,{minimumFractionDigits:m,maximumFractionDigits:m}).format(Math.abs(u))}%`}function wg(u,s){return u==null||!Number.isFinite(u)?"—":`${u>0?"+":u<0?"-":""}${Pi(s,{minimumFractionDigits:2,maximumFractionDigits:2}).format(Math.abs(u))} pp`}function Dp(u,s,m){if(u==null||!Number.isFinite(u))return"—";const r=Pi(m,{minimumFractionDigits:2,maximumFractionDigits:2}).format(u);return s?`${s} ${r}`:r}const Mp=/^-?(?:0|[1-9]\d*)(?:\.\d+)?$/;function Op(u){return typeof u=="number"?Number.isFinite(u)?u<0?"−•••":"•••":"—":typeof u!="string"||!Mp.test(u)?"—":u.startsWith("-")&&/[1-9]/.test(u)?"−•••":"•••"}function zg(u,s){return u==null||!Number.isFinite(u)?"—":Pi(s,{maximumFractionDigits:6}).format(u)}const sh=/^\d{4}-\d{2}-\d{2}$/;function rh(u,s){if(!u)return"—";if(sh.test(u))return u;const m=Date.parse(u);if(!Number.isFinite(m))return"—";const r=`${s}:date`;let E=Wi.get(r);return E||(E=new Intl.DateTimeFormat(Oo(s),{year:"numeric",month:"2-digit",day:"2-digit"}),Wi.set(r,E)),E.format(new Date(m))}function fh(u,s,m=!1){if(!u)return{text:"—",zone:""};const r=Date.parse(u);if(!Number.isFinite(r))return{text:"—",zone:""};if(sh.test(u))return{text:rh(u,s),zone:""};const E=new Date(r),R=`${s}:datetime:${m}`;let C=Wi.get(R);C||(C=new Intl.DateTimeFormat(Oo(s),{year:m?"numeric":void 0,month:"2-digit",day:"2-digit",hour:"2-digit",minute:"2-digit",hour12:!1,timeZoneName:"shortOffset"}),Wi.set(R,C));const U=C.formatToParts(E),v=U.find(O=>O.type==="timeZoneName")?.value||"";return{text:U.filter(O=>O.type!=="timeZoneName").map(O=>O.value).join("").trim(),zone:v}}function Rg(u,s){if(!u)return null;const m=Date.parse(u);if(!Number.isFinite(m))return null;const r=Math.max(0,Math.round((Date.now()-m)/1e3));if(r<60)return s==="zh"?"刚刚":"just now";const E=Math.floor(r/60);if(E<60)return s==="zh"?`${E} 分钟前`:`${E}m ago`;const R=Math.floor(E/60);if(R<48)return s==="zh"?`${R} 小时前`:`${R}h ago`;const C=Math.floor(R/24);return s==="zh"?`${C} 天前`:`${C}d ago`}const So={account_aliases:{hk:{en:"HK",zh:"香港"},live:{en:"live",zh:"实盘"},paper:{en:"paper",zh:"模拟"},sg:{en:"SG",zh:"新加坡"},soxl:{en:"SOXL",zh:"SOXL"},tqqq:{en:"TQQQ",zh:"TQQQ"}},accounts:{binance:{Binance:{en:"live",zh:"实盘"},binance:{en:"live",zh:"实盘"},crypto_combo:{en:"live",zh:"实盘"},default:{en:"live",zh:"实盘"}}},domains:{cn_equity:{en:"CN A-share",zh:"A股"},crypto:{en:"Crypto",zh:"加密"},hk_equity:{en:"HK Equity",zh:"港股"},us_equity:{en:"US Equity",zh:"美股"}},lanes:{dry_run:{en:"dry run",zh:"演练"},live:{en:"live",zh:"实盘"},paper:{en:"paper",zh:"模拟"},research:{en:"research",zh:"研究"},shadow:{en:"shadow",zh:"影子"}},platforms:{binance:"Binance",firstrade:"Firstrade",ibkr:"IBKR",longbridge:"LongBridge",qmt:"QMT",schwab:"Schwab"},senders:{quant_sentinel:{en:"QuantSentinel",zh:"量化哨兵"}},strategies:{cn_chinext_growth_momentum_quality:{en:"CN ChiNext Growth Momentum Quality",zh:"创业板成长动量质量"},cn_chinext_growth_momentum_quality_snapshot:{en:"CN ChiNext Growth Quality Snapshot",zh:"创业板成长质量快照"},cn_chinext_tactical_rotation:{en:"CN ChiNext Tactical Rotation",zh:"创业板战术轮动"},cn_csi500_multi_factor_snapshot:{en:"CN CSI 500 Multi-Factor Snapshot",zh:"A股中证500多因子"},cn_dividend_quality_snapshot:{en:"CN Dividend Quality",zh:"A股红利质量"},cn_equity_combo:{en:"CN Alpha Combo",zh:"A股进取组合"},cn_index_etf_tactical_rotation:{en:"CN Index ETF Tactical Rotation",zh:"A股宽基ETF战术轮动"},cn_industry_etf_rotation:{en:"CN Industry ETF Rotation",zh:"A股行业ETF轮动"},cn_industry_etf_rotation_aggressive:{en:"CN ETF Rotation",zh:"A股ETF轮动"},cn_star_growth_momentum_quality:{en:"CN STAR Growth Momentum Quality",zh:"科创板成长动量质量"},cn_stock_momentum_rotation:{en:"CN Stock Momentum Rotation",zh:"A股股票动量轮动"},crypto_btc_dca:{en:"BTC DCA",zh:"BTC定投"},crypto_equity_combo:{en:"Crypto Core Combo",zh:"加密动量组合"},crypto_leader_rotation:{en:"Crypto Leader Rotation",zh:"加密领涨轮动"},crypto_live_pool_rotation:{en:"Crypto Pool Rotation",zh:"加密池轮动"},crypto_trend_rotation:{en:"Altcoin Trend",zh:"山寨趋势轮动"},global_etf_confidence_vol_gate:{en:"Global ETF Confidence Vol Gate",zh:"全球 ETF 置信波动门控"},global_etf_rotation:{en:"Global ETF Rotation",zh:"全球ETF轮动"},hk_equity_combo:{en:"HK Core Combo",zh:"港股恒生组合"},hk_global_etf_tactical_rotation:{en:"HK ETF Tactical Rotation",zh:"港股ETF战术轮动"},hk_low_vol_dividend_quality_snapshot:{en:"HK Dividend Quality",zh:"港股红利质量"},ibit_smart_dca:{en:"IBIT Bitcoin DCA",zh:"IBIT比特币定投"},nasdaq_sp500_smart_dca:{en:"NASDAQ/S&P 500 DCA",zh:"纳指标普定投"},qqq_tech_enhancement:{en:"Tech/Communication Pullback Enhancement",zh:"科技通信回调增强"},russell_top50_leader_rotation:{en:"Russell Top50 Leaders",zh:"罗素Top50领涨"},soxl_soxx_core_only_p2_v7_longterm_compounding_cash_reserve:{en:"SOXL/SOXX Core Compounding (Cash Reserve)",zh:"SOXL/SOXX 核心复利（现金保留）"},soxl_soxx_trend_income:{en:"Semiconductor Trend Income",zh:"半导体趋势收益"},tech_communication_pullback_enhancement:{en:"Tech/Communication Pullback Enhancement",zh:"科技通信回调增强"},tecl_xlk_trend_income:{en:"TECL/XLK Trend Income",zh:"TECL/XLK趋势收益"},tqqq_growth_income:{en:"NASDAQ Growth Income",zh:"纳斯达克增长收益"},us_equity_combo:{en:"US Core Income Combo",zh:"美股核心收益组合"},us_equity_combo_core:{en:"US Core Combo",zh:"美股核心组合"},us_equity_combo_leveraged:{en:"US Alpha Combo",zh:"美股加速组合"}},strategy_aliases:{bitcoin_etf_smart_dca:"ibit_smart_dca",global_etf_confidence_vol_gate:"global_etf_rotation",global_macro_etf_rotation:"global_etf_rotation"}},Up={BASE_URL:"/v2/",DEV:!1,MODE:"production",PROD:!0,SSR:!1};let dh={};try{const u=JSON.parse(Up?.VITE_QSL_DISPLAY_NAMES_JSON||"{}");u&&typeof u=="object"&&!Array.isArray(u)&&(dh=u)}catch{}function zl(u,s,m="en",r="",E="",R=dh){const C=R.strategy_aliases?.[s]||So.strategy_aliases?.[s]||s;for(const U of[R,So]){const v=u==="accounts"?U[u]?.[String(E).toLowerCase()]:U[u],O=v?.[U===So&&u==="strategies"?C:s]??(u==="strategies"?v?.[C]:null),L=typeof O=="object"&&O?O[String(m).startsWith("zh")?"zh":"en"]||O.en:O;if(typeof L=="string"&&L.trim())return L.trim()}return r||s||""}const Cp={"Global ETF":{en:"Global ETF",zh:"全球ETF"},"Russell Top 50":{en:"Russell Top 50",zh:"罗素Top50"}};function Qd(u,s="en",m){if(!u||m&&m.toLowerCase()!=="ibkr")return null;const r=Cp[u.trim()];return r?r[s.startsWith("zh")?"zh":"en"]:null}function qp(u,s,m="en",r=""){return zl("accounts",u||"",m,zl("account_aliases",u||"",m,r||u||""),s||"")}function jp(u,s,m=""){return zl("strategies",u,s,m||(s.startsWith("zh")?"未命名策略":"Unnamed strategy"))}function kp(u,s){return zl("lanes",u,s,s.startsWith("zh")?"未知":"Unknown")}function Hp(u,s){return zl("domains",u,s,s.startsWith("zh")?"未知市场":"Unknown market")}function Bp(u){const s=j.useContext(Pd),m=ka(),r=at(),E=u===void 0?s:u;return{config:E,account:(R,C)=>{if(!R)return r("common.account");const U=C?uh(E,C,R):void 0,v=C?.toLowerCase()==="ibkr"?U?.account_selector?.trim():void 0;if(v&&/^(?:DU|U)\d{5,}$/i.test(v))return v;const x=Qd(U?.label,m,C)||Qd(R,m,C),O=U?.label&&U.label!==R?U.label:R;return x||qp(R,C,m,O)},strategy:R=>{const C=E?.strategyProfiles?.find(U=>U.profile===R);return jp(R,m,m==="zh"?C?.label_zh:C?.label_en)},currentStrategy:R=>E?.currentStrategies?.[R.platform]?.[R.account_alias]?.strategy_profile,platform:R=>Lp(E?.platformMeta?.[R]?.label,R),lane:R=>kp(R,m),domain:R=>Hp(R,m)}}function Lp(u,s){return u||s}function Yp({onRetry:u}){const s=at();return _.jsxs("div",{className:"scope-error",role:"status","aria-live":"polite",style:{display:"flex",alignItems:"center",gap:8,padding:"6px 10px"},children:[_.jsx("span",{className:"scope-panel-text",children:s("shell.scope_meta_error")}),_.jsx("button",{type:"button",className:"button button-secondary button-sm",onClick:u,children:s("common.retry")})]})}function Gp(){const u=at(),s=Bp(),{scope:m,options:r,setScope:E,status:R,metaStatus:C,retry:U}=th(),[v,x]=j.useState(!1),O=j.useRef(null),L=j.useRef(null),K=j.useRef(null),_e=j.useRef(!1),ie=j.useRef(null),ye=u("shell.scope_error"),De=u("shell.scope_loading"),Ae=J=>{ie.current=J,x(!1)};j.useEffect(()=>{v?K.current?.querySelector(".scope-option, .scope-panel button")?.focus():_e.current&&ie.current!=="outside"&&L.current?.focus(),v||(ie.current=null),_e.current=v},[v]),j.useEffect(()=>{if(!v)return;const J=ze=>{O.current?.contains(ze.target)||Ae("outside")},me=ze=>{ze.key==="Escape"&&Ae("escape")};return document.addEventListener("pointerdown",J),document.addEventListener("keydown",me),()=>{document.removeEventListener("pointerdown",J),document.removeEventListener("keydown",me)}},[v]);const we=Sp(r.map(J=>({...J,account_alias:J.alias})),m),be=m==="all"?u("shell.scope_all"):we?`${s.platform(we.platform)} · ${s.account(we.alias,we.platform)}`:u("common.unknown"),Ue=[...new Set(r.map(J=>J.platform))],V=J=>_.jsxs("button",{type:"button",className:`scope-option${m===Ao({platform:J.platform,account_alias:J.alias})?" active":""}`,onClick:()=>{E(Ao({platform:J.platform,account_alias:J.alias})),Ae("select")},children:[_.jsx("span",{className:"scope-option-label",children:s.account(J.alias,J.platform)}),J.paper===!0&&_.jsx("span",{className:"badge badge-accent",children:u("common.paper_badge")})]},`${J.platform}:${J.alias}`);return _.jsxs("div",{className:"scope-switcher",ref:O,children:[_.jsx("button",{ref:L,type:"button",className:"button button-secondary button-sm scope-trigger","aria-haspopup":"listbox","aria-expanded":v,"aria-label":u("shell.scope"),onClick:()=>x(J=>!J),children:_.jsxs("span",{className:"scope-trigger-label",children:[R==="error"?ye:be," ▾"]})}),v&&_.jsxs("div",{className:"scope-panel",ref:K,role:"listbox","aria-label":u("shell.scope"),children:[R!=="ready"&&_.jsxs("div",{className:"scope-error",role:"status","aria-live":"polite",style:{display:"flex",alignItems:"center",gap:8,padding:"6px 10px"},children:[_.jsx("span",{className:"scope-panel-text",children:R==="error"?ye:De}),R==="error"&&_.jsx("button",{type:"button",className:"button button-secondary button-sm",onClick:U,children:u("common.retry")})]}),R==="ready"&&C==="error"&&_.jsx(Yp,{onRetry:U}),_.jsx("button",{type:"button",className:`scope-option${m==="all"?" active":""}`,onClick:()=>{E("all"),Ae("select")},children:u("shell.scope_all")}),Ue.map(J=>_.jsxs("div",{children:[_.jsx("div",{className:"scope-group",children:s.platform(J)}),r.filter(me=>me.platform===J).map(V)]},J))]})]})}const hh=["1M","3M","YTD","1Y","ALL"];function Ng({value:u,onChange:s,returns:m}){const r=at(),E=m?.[u]??null;return _.jsx("div",{className:"segmented",role:"group","aria-label":r("perf.range.label"),children:hh.map(R=>_.jsxs("button",{type:"button",className:`segment${R===u?" active":""}`,"aria-pressed":R===u,onClick:()=>s(R),children:[_.jsx("span",{children:r(`perf.range.${R}`)}),R===u&&E&&_.jsx("span",{className:"segment-sub",children:E})]},R))})}function Qp({onClose:u}){const s=at(),{prefs:m,setPrefs:r,persistFailed:E}=Ro(),R=j.useRef(null);j.useEffect(()=>{const v=document.activeElement instanceof HTMLElement?document.activeElement:null,x=v?.closest("details"),O=x&&!x.open?x.querySelector("summary"):v;return R.current?.querySelector("button")?.focus(),()=>{O instanceof HTMLElement&&O.isConnected&&O.focus()}},[]);const C=v=>{if(v.key==="Escape"){v.preventDefault(),u();return}if(v.key!=="Tab")return;const x=R.current?.querySelectorAll('button:not(:disabled), input:not(:disabled), [tabindex]:not([tabindex="-1"])');if(!x?.length)return;const O=x[0],L=x[x.length-1];v.shiftKey&&document.activeElement===O?(v.preventDefault(),L.focus()):!v.shiftKey&&document.activeElement===L&&(v.preventDefault(),O.focus())},U=(v,x)=>r({...m,[v]:x});return _.jsx("div",{className:"dialog-backdrop",onMouseDown:v=>v.target===v.currentTarget&&u(),children:_.jsxs("div",{className:"dialog",role:"dialog","aria-modal":"true","aria-labelledby":"prefs-title",ref:R,onKeyDown:C,children:[_.jsx("h2",{id:"prefs-title",children:s("prefs.title")}),_.jsxs("div",{className:"prefs-grid",children:[_.jsxs("div",{className:"prefs-row",children:[_.jsx("span",{children:s("prefs.theme")}),_.jsx("div",{className:"segmented",role:"group","aria-label":s("prefs.theme"),children:["light","dark","system"].map(v=>_.jsx("button",{type:"button",className:`segment${m.theme===v?" active":""}`,onClick:()=>U("theme",v),children:s(`prefs.theme_${v}`)},v))})]}),_.jsxs("div",{className:"prefs-row",children:[_.jsx("span",{children:s("prefs.language")}),_.jsx("div",{className:"segmented",role:"group","aria-label":s("prefs.language"),children:["zh","en"].map(v=>_.jsx("button",{type:"button",className:`segment${m.language===v?" active":""}`,onClick:()=>U("language",v),children:v==="zh"?"中文":"English"},v))})]}),_.jsxs("div",{className:"prefs-row",children:[_.jsx("span",{children:s("prefs.updown")}),_.jsx("div",{className:"segmented",role:"group","aria-label":s("prefs.updown"),children:["green-up","red-up"].map(v=>_.jsx("button",{type:"button",className:`segment${m.upDown===v?" active":""}`,onClick:()=>U("upDown",v),children:s(v==="green-up"?"prefs.updown_green_up":"prefs.updown_red_up")},v))})]}),_.jsxs("div",{className:"prefs-row",children:[_.jsx("span",{children:s("prefs.hide_amounts")}),_.jsx("input",{type:"checkbox",checked:m.hideAmounts,onChange:v=>U("hideAmounts",v.target.checked),"aria-label":s("prefs.hide_amounts")})]}),_.jsxs("div",{className:"prefs-row",children:[_.jsx("span",{children:s("prefs.default_range")}),_.jsx("div",{className:"segmented",role:"group","aria-label":s("prefs.default_range"),children:hh.map(v=>_.jsx("button",{type:"button",className:`segment${m.defaultRange===v?" active":""}`,onClick:()=>U("defaultRange",v),children:s(`perf.range.${v}`)},v))})]})]}),_.jsx("p",{className:"card-note",children:s("prefs.note")}),E&&_.jsx("p",{className:"card-note",role:"status",children:s("prefs.save_error")}),_.jsx("div",{className:"dialog-actions",children:_.jsx("button",{type:"button",className:"button button-primary",onClick:u,children:s("common.close")})})]})})}const xo=[{id:"overview",labelKey:"nav.overview",icon:"M3 12 L12 4 L21 12 M6 10 V20 H18 V10"},{id:"performance",labelKey:"nav.performance",icon:"M4 18 L10 10 L14 13 L20 5"},{id:"decisions",labelKey:"nav.decisions",icon:"M4 6 H20 M4 12 H20 M4 18 H14"},{id:"accounts",labelKey:"nav.accounts",icon:"M12 12 m-4 0 a4 4 0 1 0 8 0 a4 4 0 1 0 -8 0 M4 20 c0-4 4-6 8-6 s8 2 8 6"},{id:"strategies",labelKey:"nav.strategies",icon:"M5 5 H19 V19 H5 Z M5 10 H19 M10 10 V19"},{id:"health",labelKey:"nav.health",icon:"M3 12 H7 L10 5 L14 19 L17 12 H21"}],Xp=["overview","performance","decisions","accounts"],Xd=["strategies","health"];function To({path:u}){return _.jsx("svg",{width:"18",height:"18",viewBox:"0 0 24 24",fill:"none",stroke:"currentColor",strokeWidth:"1.8",strokeLinecap:"round",strokeLinejoin:"round","aria-hidden":"true",children:_.jsx("path",{d:u})})}function Zp({page:u,todoCount:s,todoStatus:m="ok",synthetic:r,login:E,updatedAt:R,onLogout:C,children:U}){const v=at(),x=ka(),O=gp(),{prefs:L,setPrefs:K,resolvedTheme:_e}=Ro(),ie=_e==="dark";th();const[ye,De]=j.useState(!1),[Ae,we]=j.useState(!1),[be,Ue]=j.useState(!1),V=j.useRef(null),J=j.useRef(null),me=j.useRef(!1);j.useEffect(()=>{V.current&&(V.current.open=!1),we(!1)},[u]),j.useEffect(()=>{me.current&&!Ae&&J.current?.focus(),me.current=Ae},[Ae]),j.useEffect(()=>{const $=Ge=>{const Se=V.current;Se?.open&&!Se.contains(Ge.target)&&(Se.open=!1)},je=Ge=>{Ge.key==="Escape"&&(V.current&&(V.current.open=!1),we(!1))};return document.addEventListener("pointerdown",$),document.addEventListener("keydown",je),()=>{document.removeEventListener("pointerdown",$),document.removeEventListener("keydown",je)}},[]);const ze=s!==null&&s>0?_.jsx("span",{className:"nav-badge",children:s}):null,Ye=m==="read_failed",nt=R?fh(R,x):null,$e=($,je="")=>_.jsxs("button",{type:"button",className:`${je}${u===$.id?" active":""}`,"aria-label":$.id==="decisions"&&Ye?`${v($.labelKey)} · ${v("nav.todo_unavailable")}`:v($.labelKey),"aria-current":u===$.id?"page":void 0,onClick:()=>O({page:$.id,account:null,tab:null}),children:[_.jsx(To,{path:$.icon}),_.jsx("span",{className:"nav-text",children:v($.labelKey)}),$.id==="decisions"&&(ze||Ye&&_.jsx("span",{className:"nav-badge nav-badge-unknown","aria-hidden":"true",children:"?"}))]},$.id);return _.jsxs("div",{className:"shell",children:[_.jsx("a",{className:"skip-link",href:"#main-content",children:v("shell.skip_to_content")}),_.jsxs("nav",{className:`sidenav${ye?" collapsed":""}`,"aria-label":v("nav.main"),children:[_.jsxs("div",{className:"brand",children:[_.jsx("img",{src:"/v2/assets/qsl-brand-icon.svg",alt:"",width:28,height:28}),_.jsx("span",{className:"brand-name",children:v("app.name")})]}),xo.map($=>$e($,"nav-item")),_.jsx("button",{type:"button",className:"sidenav-collapse",onClick:()=>De($=>!$),"aria-label":v(ye?"common.expand":"common.collapse"),children:ye?"»":"«"})]}),_.jsxs("div",{className:"shell-main",children:[_.jsxs("header",{className:"topbar",children:[u!=="health"&&_.jsx(Gp,{}),nt&&_.jsx("span",{className:"topbar-updated",children:v("common.updated_at",{value:`${nt.text}${nt.zone?` (${nt.zone})`:""}`})}),_.jsx("span",{className:"spacer"}),_.jsxs("button",{type:"button",className:"button button-secondary button-sm appearance-toggle lang-toggle","aria-label":v("prefs.language"),title:v("prefs.language"),onClick:()=>K({...L,language:x==="zh"?"en":"zh"}),children:[_.jsx("span",{className:"lang-label lang-label-full",children:x==="zh"?"English":"中文"}),_.jsx("span",{className:"lang-label lang-label-short","aria-hidden":"true",children:x==="zh"?"EN":"中"})]}),_.jsxs("button",{type:"button",className:"button button-secondary button-sm appearance-toggle","aria-label":v(ie?"shell.switch_light":"shell.switch_dark"),title:v(ie?"shell.switch_light":"shell.switch_dark"),onClick:()=>K({...L,theme:ie?"light":"dark"}),children:[_.jsx("span",{"aria-hidden":"true",children:ie?"☀":"☾"}),_.jsx("span",{className:"theme-toggle-label",children:v(ie?"prefs.theme_light":"prefs.theme_dark")})]}),r&&_.jsx("span",{className:"topbar-synthetic",children:_.jsx("span",{className:"badge badge-accent",children:v("common.synthetic_badge")})}),_.jsx("button",{type:"button",className:"icon-button","aria-pressed":L.hideAmounts,"aria-label":v(L.hideAmounts?"shell.show_amounts":"shell.hide_amounts"),title:v(L.hideAmounts?"shell.show_amounts":"shell.hide_amounts"),onClick:()=>K({...L,hideAmounts:!L.hideAmounts}),children:_.jsx("svg",{width:"18",height:"18",viewBox:"0 0 24 24",fill:"none",stroke:"currentColor",strokeWidth:"1.8",strokeLinecap:"round",strokeLinejoin:"round","aria-hidden":"true",children:L.hideAmounts?_.jsx("path",{d:"M3 3 L21 21 M10 5.5 C11.5 5 13 5 14 5.5 C18 7 21 12 21 12 C20 14 18.5 15.8 16.5 17 M6.5 6.8 C4 8.7 3 12 3 12 C3 12 6 18 12 18 C13 18 14 17.8 14.8 17.5"}):_.jsxs(_.Fragment,{children:[_.jsx("path",{d:"M2 12 C2 12 5.5 5 12 5 C18.5 5 22 12 22 12 C22 12 18.5 19 12 19 C5.5 19 2 12 2 12 Z"}),_.jsx("circle",{cx:"12",cy:"12",r:"3"})]})})}),_.jsxs("details",{className:"user-menu",ref:V,children:[_.jsx("summary",{"aria-label":v("shell.user_menu"),children:(E||"U").slice(0,1).toUpperCase()}),_.jsxs("div",{className:"user-menu-panel",children:[_.jsx("strong",{className:"user-menu-name",children:E||"—"}),_.jsx("button",{type:"button",className:"menu-item",onClick:()=>{Ue(!0),V.current&&(V.current.open=!1)},children:v("shell.preferences")}),_.jsx("button",{type:"button",className:"menu-item",onClick:C,children:v("shell.logout")})]})]})]}),_.jsx(Rp,{}),_.jsx("main",{className:"content",id:"main-content",children:U},u)]}),_.jsx("nav",{className:"bottom-tabs","aria-label":v("nav.main"),children:_.jsxs("div",{className:"bottom-tabs-inner",children:[Xp.map($=>$e(xo.find(je=>je.id===$),"bottom-tab")),_.jsxs("button",{type:"button",ref:J,className:`bottom-tab${Ae||Xd.includes(u)?" active":""}`,"aria-expanded":Ae,"aria-controls":"more-sheet",onClick:()=>we($=>!$),children:[_.jsx(To,{path:"M5 12 m-1.5 0 a1.5 1.5 0 1 0 3 0 a1.5 1.5 0 1 0 -3 0 M12 12 m-1.5 0 a1.5 1.5 0 1 0 3 0 a1.5 1.5 0 1 0 -3 0 M19 12 m-1.5 0 a1.5 1.5 0 1 0 3 0 a1.5 1.5 0 1 0 -3 0"}),_.jsx("span",{className:"nav-text",children:v("nav.more")})]})]})}),Ae&&_.jsxs("div",{className:"more-sheet",id:"more-sheet",role:"menu",children:[Xd.map($=>$e(xo.find(je=>je.id===$),"nav-item")),_.jsxs("button",{type:"button",className:"nav-item",onClick:()=>{Ue(!0),we(!1)},children:[_.jsx(To,{path:"M12 15 m-3 0 a3 3 0 1 0 6 0 a3 3 0 1 0 -6 0 M19 12 a7 7 0 0 0-.1-1.2 l2-1.5 -2-3.4 -2.3 1 a7 7 0 0 0-2-1.2 L14.2 3 H9.8 L9.4 5.7 a7 7 0 0 0-2 1.2 l-2.3-1 -2 3.4 2 1.5 A7 7 0 0 0 5 12"}),_.jsx("span",{className:"nav-text",children:v("shell.preferences")})]})]}),be&&_.jsx(Qp,{onClose:()=>Ue(!1)})]})}const mh=j.createContext(()=>{});function Dg(){return j.useContext(mh)}function Vp({children:u}){const s=at(),[m,r]=j.useState([]),E=j.useRef(1),R=j.useCallback(U=>{const v=E.current++;r(x=>[...x.slice(-3),{...U,id:v}]),window.setTimeout(()=>r(x=>x.filter(O=>O.id!==v)),6e3)},[]),C=U=>r(v=>v.filter(x=>x.id!==U));return _.jsxs(mh.Provider,{value:R,children:[u,_.jsx("div",{className:"toast-stack",role:"status","aria-live":"polite",children:m.map(U=>_.jsxs("div",{className:`toast ${U.kind==="info"?"":U.kind}`,children:[_.jsx("span",{style:{flex:1},children:U.text}),_.jsx("button",{type:"button",onClick:()=>C(U.id),"aria-label":s("common.close"),children:"✕"})]},U.id))})]})}function Uo({tone:u,size:s=10}){return u==="ok"?_.jsx("svg",{width:s,height:s,viewBox:"0 0 10 10","aria-hidden":"true",children:_.jsx("path",{d:"M1.5 5.5 L4 8 L8.5 2",fill:"none",stroke:"currentColor",strokeWidth:"1.6",strokeLinecap:"round",strokeLinejoin:"round"})}):u==="warn"?_.jsxs("svg",{width:s,height:s,viewBox:"0 0 10 10","aria-hidden":"true",children:[_.jsx("path",{d:"M5 1 L9.5 9 H0.5 Z",fill:"none",stroke:"currentColor",strokeWidth:"1.2",strokeLinejoin:"round"}),_.jsx("line",{x1:"5",y1:"4",x2:"5",y2:"6.4",stroke:"currentColor",strokeWidth:"1.2",strokeLinecap:"round"}),_.jsx("circle",{cx:"5",cy:"7.8",r:"0.7",fill:"currentColor"})]}):u==="error"?_.jsxs("svg",{width:s,height:s,viewBox:"0 0 10 10","aria-hidden":"true",children:[_.jsx("circle",{cx:"5",cy:"5",r:"4",fill:"none",stroke:"currentColor",strokeWidth:"1.2"}),_.jsx("path",{d:"M3.2 3.2 L6.8 6.8 M6.8 3.2 L3.2 6.8",stroke:"currentColor",strokeWidth:"1.2",strokeLinecap:"round"})]}):_.jsx("svg",{width:s,height:s,viewBox:"0 0 10 10","aria-hidden":"true",children:_.jsx("circle",{cx:"5",cy:"5",r:"4",fill:"none",stroke:"currentColor",strokeWidth:"1.2",strokeDasharray:"2 1.4"})})}function Kp({tone:u,children:s,title:m}){return _.jsxs("span",{className:`badge badge-${u}`,title:m,children:[u!=="accent"&&_.jsx(Uo,{tone:u}),s]})}const Jp={healthy:"ok",review:"warn",watch:"warn",critical:"error",fresh:"ok",blocked:"error",failed:"error",read_incomplete:"error",insufficient:"warn",previewed:"unknown",no_signal:"ok",ok:"ok",partial:"warn",stale:"warn",no_data:"unknown",not_connected:"unknown",unavailable:"unknown",read_failed:"error"};function $p(u){return Jp[u||""]||"unknown"}function Mg({status:u,reason:s}){const m=at(),r=u||"unknown",E=`state.${r}`,R=s?`reason.${s}`:null,C=R?m(R):void 0;return _.jsx("span",{"data-status":r,"data-reason":s??void 0,children:_.jsx(Kp,{tone:$p(r),title:C,children:m(E)})})}function Og({value:u,prefix:s="common.as_of"}){const m=at(),r=ka();if(!u)return _.jsx("span",{className:"asof",children:m(s,{value:m("common.na")})});const{text:E,zone:R}=fh(u,r);return _.jsx("span",{className:"asof",children:m(s,{value:R?`${E} (${R})`:E})})}function Ug({value:u}){const s=ka();return _.jsx("span",{className:"account-row-value",children:rh(u,s)})}function Cg({value:u,currency:s,signed:m=!1}){const r=ka(),{prefs:E}=Ro();if(u==null||!Number.isFinite(u))return _.jsx("span",{className:"money flat",children:"—"});if(E.hideAmounts)return _.jsx("span",{className:"money",children:Op(u)});const R=Dp(m?Math.abs(u):u,s,r),C=m?u>0?"+":u<0?"-":"":"",U=!m||u===0?"flat":u>0?"up":"down";return _.jsxs("span",{className:`money ${U}`,children:[C,R]})}function qg({value:u,digits:s=2}){if(u==null||!Number.isFinite(u))return _.jsx("span",{className:"percent flat",children:"—"});const m=ka(),r=u===0?"flat":u>0?"up":"down";return _.jsx("span",{className:`percent ${r}`,children:Np(u,m,s)})}function Zd({height:u=16,width:s="100%"}){return _.jsx("div",{className:"skeleton",style:{height:u,width:s},"aria-hidden":"true"})}function jg({title:u,body:s,action:m,state:r="no_data"}){return _.jsxs("div",{className:"empty-state","data-state":r,children:[_.jsx("span",{className:"state-icon","aria-hidden":"true",children:_.jsx(Uo,{tone:"unknown",size:14})}),_.jsxs("div",{className:"state-copy",children:[_.jsx("div",{className:"empty-title",children:u}),s&&_.jsx("p",{className:"state-short",children:s})]}),m&&_.jsx("div",{className:"state-action",children:m})]})}function kg({onRetry:u}){const s=at();return _.jsxs("div",{className:"error-state",role:"alert","data-state":"read_failed",children:[_.jsx("span",{className:"state-icon state-icon-error","aria-hidden":"true",children:_.jsx(Uo,{tone:"error",size:14})}),_.jsx("div",{className:"state-copy",children:_.jsx("div",{className:"error-title",children:s("state.load_failed")})}),u&&_.jsx("div",{className:"state-action",children:_.jsx("button",{type:"button",className:"button button-secondary button-sm",onClick:u,children:s("common.retry")})})]})}function Hg({titleKey:u,bodyKey:s}){const m=at();return _.jsxs("details",{className:"method-note",children:[_.jsx("summary",{children:m(u)}),_.jsx("p",{className:"card-note",children:m(s)})]})}class Wp extends j.Component{state={failed:!1};static getDerivedStateFromError(){return{failed:!0}}reload=()=>{location.reload()};render(){return this.state.failed?_.jsxs("div",{className:"page-load-error",role:"alert",children:[_.jsx("p",{children:this.props.title}),_.jsx("button",{className:"button button-primary",type:"button",onClick:this.reload,children:this.props.action})]}):this.props.children}}function Fp({children:u}){const s=at();return _.jsx(Wp,{title:s("common.page_load_failed"),action:s("shell.reload"),children:u})}const Pp=j.lazy(()=>An(()=>import("./OverviewPage-DLmRzWCy.js"),__vite__mapDeps([0,1,2,3,4,5,6,7,8]))),Ip=j.lazy(()=>An(()=>import("./PerformancePage-DuxiG9dq.js"),__vite__mapDeps([9,4,5,2,3,10,11,12]))),eg=j.lazy(()=>An(()=>import("./DecisionsPage-DjK85Y5B.js"),__vite__mapDeps([13,1,14,7,4,11,15]))),tg=j.lazy(()=>An(()=>import("./AccountsPage-CsdJjpqu.js"),__vite__mapDeps([16,17,4,14,7,11,18]))),ag=j.lazy(()=>An(()=>import("./StrategiesPage-DcL-BLIE.js"),__vite__mapDeps([19,17,4,11,20]))),ng=j.lazy(()=>An(()=>import("./HealthPage-C3MhtCXB.js"),__vite__mapDeps([21,4,5,10,6,7,22])));function Vd({kind:u,noAccess:s,onRetry:m}){const r=at(),E=u==="denied";return _.jsxs("main",{className:"access-screen",children:[_.jsx("img",{src:"/v2/assets/qsl-brand-icon.svg",alt:"",width:48,height:48}),_.jsx("h1",{children:r(E?s?"auth.denied_title":"auth.login_title":"auth.error_title")}),_.jsx("p",{children:r(E?s?"auth.denied_body":"auth.login_body":"auth.error_body")}),E?s?null:_.jsx("a",{className:"button button-primary",href:"/login",children:r("auth.login")}):_.jsx("button",{className:"button button-primary",type:"button",onClick:m,children:r("common.retry")})]})}function lg(){const[u,s]=j.useState(Wd),[m,r]=j.useState(()=>window.matchMedia?.("(prefers-color-scheme: dark)").matches??!1),[E,R]=j.useState("loading"),[C,U]=j.useState(null),[v,x]=j.useState(()=>Hd(window.location.search)),[O,L]=j.useState(null),[K,_e]=j.useState([]),[ie,ye]=j.useState("loading"),[De,Ae]=j.useState(0),[we,be]=j.useState("ready"),[Ue,V]=j.useState(!1),[J,me]=j.useState(null),[ze,Ye]=j.useState("loading"),[nt,$e]=j.useState(null),[$,je]=j.useState(0),Ge=j.useRef(v);Ge.current=v;const Se=j.useCallback(T=>{s(T),V(!pp(T))},[]),A=j.useCallback(()=>Ae(T=>T+1),[]),q=Fd(u.theme,m);j.useEffect(()=>{document.documentElement.dataset.theme=q},[q]),j.useEffect(()=>{document.documentElement.dataset.updown=u.upDown},[u.upDown]),j.useEffect(()=>{document.documentElement.lang=u.language==="zh"?"zh-CN":"en"},[u.language]),j.useEffect(()=>{const T=window.matchMedia?.("(prefers-color-scheme: dark)");if(!T)return;const D=M=>r(M.matches);return T.addEventListener?.("change",D),()=>T.removeEventListener?.("change",D)},[]),j.useEffect(()=>{let T=!1;return(async()=>{try{const D=await xp();if(T)return;if(!D.authenticated||!D.allowed){U(D),R("denied");return}U(D),R("ready")}catch(D){if(T)return;D instanceof No&&D.status===401?R("denied"):R(M=>M==="ready"?M:"error")}})(),()=>{T=!0}},[$]),j.useEffect(()=>{if(E!=="ready")return;let T=!1;const D=()=>{Ap().then(k=>{if(T)return;const F=k.status==="read_failed";Ye(F?"read_failed":"ok"),me(F?null:k.items.filter(Z=>Z.status==="pending").length)}).catch(()=>{T||(Ye("read_failed"),me(null))})};Ye("loading"),me(null),D();const M=Tp(D);return()=>{T=!0,M()}},[E]),j.useEffect(()=>{if(E!=="ready")return;let T=!1;return ye("loading"),(async()=>{try{const D=await wp();if(T)return;let M=null;try{M=await Ee("/api/config")}catch{}if(T)return;L(M),be(M?"ready":"error"),_e(D.accounts.map(k=>({alias:k.account_alias,platform:k.platform,paper:M?M.accountOptions?.[k.platform]?.find(F=>F.key===k.account_alias)?.broker_environment==="paper":null}))),$e(new Date().toISOString()),ye("ready")}catch{T||ye("error")}})(),()=>{T=!0}},[E,De]),j.useEffect(()=>{const T=()=>{U(null),R("denied")};return window.addEventListener("qsl-private-session-invalid",T),()=>window.removeEventListener("qsl-private-session-invalid",T)},[]);const Y=j.useCallback(T=>{const D={...Ge.current,...T},M=()=>{x(D),Bd(D)},k=Eo();if(k&&(D.page!==Ge.current.page||D.account!==Ge.current.account)){k().then(F=>{F&&M()});return}M()},[]);j.useEffect(()=>{const T=()=>{const D=Hd(window.location.search),M=Eo();if(M){M().then(k=>{k?x(D):Bd(Ge.current)});return}x(D)};return window.addEventListener("popstate",T),()=>window.removeEventListener("popstate",T)},[]);const ce=async()=>{Mo();try{await ch("/api/logout",{})}catch{}window.location.assign("/login")};if(j.useEffect(()=>{document.title=`${Jd(u.language,`nav.${v.page}`)} · QuantStrategyLab`},[u.language,v.page]),E==="loading")return _.jsx(Zi,{language:u.language,children:_.jsx("main",{className:"boot-screen",role:"status","aria-live":"polite",children:_.jsx(Zd,{height:24,width:200})})});if(E==="denied")return _.jsx(Zi,{language:u.language,children:_.jsx(Vd,{kind:"denied",noAccess:C?.authenticated===!0&&!C.allowed})});if(E==="error")return _.jsx(Zi,{language:u.language,children:_.jsx(Vd,{kind:"error",onRetry:()=>je(T=>T+1)})});const d={scope:v.scope,options:K,setScope:T=>Y({scope:T}),status:ie,metaStatus:we,retry:A};return _.jsx(Zi,{language:u.language,children:_.jsx(Id.Provider,{value:{prefs:u,setPrefs:Se,resolvedTheme:q,persistFailed:Ue},children:_.jsx(Pd.Provider,{value:O,children:_.jsx(eh.Provider,{value:d,children:_.jsx(ah.Provider,{value:Y,children:_.jsx(Vp,{children:_.jsx(Zp,{page:v.page,todoCount:J,todoStatus:ze,synthetic:C?.synthetic===!0,login:C?.login||null,updatedAt:nt,onLogout:()=>{ce()},children:_.jsx(Fp,{children:_.jsxs(j.Suspense,{fallback:_.jsx(Zd,{height:240}),children:[v.page==="overview"&&_.jsx(Pp,{}),v.page==="performance"&&_.jsx(Ip,{}),v.page==="decisions"&&_.jsx(eg,{}),v.page==="accounts"&&_.jsx(tg,{account:v.account,tab:v.tab}),v.page==="strategies"&&_.jsx(ag,{}),v.page==="health"&&_.jsx(ng,{})]})},v.page)})})})})})})})}const _h=Wd();document.documentElement.dataset.theme=Fd(_h.theme,window.matchMedia?.("(prefers-color-scheme: dark)").matches??!1);document.documentElement.lang=_h.language==="zh"?"zh-CN":"en";const Kd=document.getElementById("root");Kd&&K_.createRoot(Kd).render(_.jsx(lg,{}));export{Sp as $,Og as A,Kp as B,zl as C,Dg as D,kg as E,Ee as F,xp as G,Rg as H,ug as I,ch as J,No as K,ih as L,Cg as M,cg as N,Ug as O,qg as P,Ao as Q,Ng as R,Mg as S,jp as T,rg as U,hg as V,dg as W,pg as X,fg as Y,ig as Z,uh as _,th as a,wp as a0,og as a1,sg as a2,_g as a3,Eg as a4,Ag as a5,Tg as a6,gp as b,jg as c,yg as d,gg as e,Zd as f,Ap as g,mg as h,vg as i,_ as j,ka as k,xg as l,rh as m,wg as n,Bp as o,Hg as p,Ro as q,j as r,Np as s,Op as t,at as u,bg as v,Sg as w,zg as x,Dp as y,fh as z};
" },
+  "/v2/assets/cockpit-Cax-GxP0.js": { contentType: "text/javascript; charset=utf-8", base64: "import{F as z,L as S,u as h,k as y,j as t,g as N,m as f,B as j,r as g}from"./index-CwQsWZdm.js";function $(e){return e==="CAPITAL_PRESERVATION"||e==="BALANCED_COMPOUNDING"||e==="GROWTH_COMPOUNDING"}function T(e){return e==="research"||e==="paper"||e==="small_live"||e==="full_live"}function O(e){return T(e)?e:"unclassified"}function C(e){return e==="approve"||e==="reject"||e==="withdraw"?e:null}function P(e,c,a,i){if(!e)return{state:"none"};const l=Date.parse(e),s=c?Date.parse(c):Number.NaN,n=Date.parse(a);if(!Number.isFinite(l)||!Number.isFinite(s)||!Number.isFinite(n))return{state:"unknown",expiresAt:e};const o=s+Math.max(0,i-n);return o>=l?{state:"expired",expiresAt:e,serverNow:o}:{state:"open",expiresAt:e,remainingMs:l-o}}function D(e){return e instanceof S&&(e.status===404||e.status===501)}function _(e){return e!==null&&typeof e=="object"?e:null}function r(e){return typeof e=="string"&&e.length>0?e:null}function v(e){return typeof e=="number"&&Number.isFinite(e)?e:null}function q(e){return typeof e=="boolean"?e:null}function I(e){const c=_(e);if(!c)return null;const a=c.state==="current"||c.state==="stale"||c.state==="missing"||c.state==="expired"||c.state==="unavailable"?c.state:"unavailable",i=c.qualification==="qualified"||c.qualification==="unqualified"?c.qualification:"unknown",l=Array.isArray(c.limitations)?c.limitations.filter(s=>typeof s=="string"):[];return{evidence_id:r(c.evidence_id),label_key:r(c.label_key),observed_at:r(c.observed_at),valid_until:r(c.valid_until),state:a,qualification:i,limitations:l}}function L(e){return Array.isArray(e)?e.flatMap(c=>{const a=_(c);if(!a||typeof a.key!="string")return[];const i=a.status==="known"||a.status==="unknown"||a.status==="unavailable"?a.status:"unknown";return[{key:a.key,label_key:r(a.label_key),value:typeof a.value=="number"||typeof a.value=="string"?a.value:null,unit:r(a.unit),status:i,source:r(a.source)}]}):[]}function R(e){const c=_(e);if(!c)return null;const a=["pending","applying","applied","rejected","failed","unknown"],i=["running","paused","reduction_only","reconcile_only","unknown"],l=a.includes(c.state)?c.state:"unknown",s=i.includes(c.runtime_state)?c.runtime_state:"unknown";return{operation_id:r(c.operation_id)??"",request_id:r(c.request_id)??"",decision_id:r(c.decision_id),decision_revision:v(c.decision_revision),action:C(c.action),title_key:r(c.title_key),account_alias:r(c.account_alias),platform:r(c.platform),release_id:r(c.release_id),target_id:r(c.target_id),state:l,recorded_at:r(c.recorded_at),dispatched_at:r(c.dispatched_at),applied_at:r(c.applied_at),applied_by:c.applied_by==="platform"?"platform":null,runtime_confirmed_at:r(c.runtime_confirmed_at),runtime_state:s,failure_reason:r(c.failure_reason),unknown_reason:r(c.unknown_reason),readback_available:q(c.readback_available),server_time:r(c.server_time)}}async function ee(e,c=!1){if(c)return{status:"ready",synthetic:!0,data:F(e)};try{const a=await z(`/api/operations/${encodeURIComponent(e)}`),i=R(a);return i?{status:"ready",data:i,synthetic:!1}:{status:"not_ready"}}catch(a){if(D(a))return{status:"not_ready"};throw a}}function B(e,c){const a=_(e.temporary_restriction);return{scope:c,selected_tier:$(e.selected_tier)?e.selected_tier:null,selection_revision:v(e.selection_revision),approved_tier:$(e.approved_tier)?e.approved_tier:null,approved_policy_id:r(e.approved_policy_id),approved_policy_revision:r(e.approved_policy_revision),effective_tier:$(e.effective_tier)?e.effective_tier:null,effective_policy_id:r(e.effective_policy_id),effective_policy_revision:r(e.effective_policy_revision),effective_observed_at:r(e.effective_observed_at),temporary_restriction:a?{active:a.active===!0,reason:r(a.reason),until:r(a.until)}:null,values:L(e.values??e.limits)}}async function te(e,c=!1){if(c)return{status:"ready",synthetic:!0,data:M(e)};try{const a=new URLSearchParams({scope:e}),i=await z(`/api/risk-profiles?${a}`),l=_(i),s=_(l?.binding)??_(l?.policy_binding);return s?{status:"ready",data:B(s,e),synthetic:!1}:{status:"not_ready"}}catch(a){if(D(a))return{status:"not_ready"};throw a}}async function ce(e,c=!1){if(c)return{status:"ready",synthetic:!0,data:U()};const a=[];for(const i of e.strategies){const l=_(i.lifecycle);for(const s of i.configured_accounts){const n=_(s.lifecycle)??l;a.push({profile:i.profile,account_alias:s.account_alias,platform:s.platform,target_id:r(n?.target_id),release_id:r(n?.release_id),present:!!n,research_stage:O(n?.research_stage),authorized_stage:O(n?.authorized_stage),effective_stage:O(n?.effective_stage),operating_state:["running","paused","reduction_only","reconcile_only","unknown"].includes(n?.operating_state)?n?.operating_state:"unknown",application_state:["pending","applying","applied","rejected","failed","unknown"].includes(n?.application_state)?n?.application_state:"unknown",observed_at:r(n?.observed_at),evidence:I(n?.evidence),regime_effect:r(n?.regime_effect)})}}return{status:"ready",data:a,synthetic:!1}}async function ie(e,c=!1){if(c)return{status:"ready",synthetic:!0,data:G()};const a=_(e.digest);if(!a)return{status:"ready",synthetic:!1,data:{business_day:null,timezone:null,expected_targets:null,covered_targets:null,unavailable_targets:null,delivery_state:"unavailable",accepted_at:null,acknowledged_at:null,source_as_of:e.as_of,legacy_receipts:!0,targets:[]}};const i=a.delivery_state,l=i==="accepted"||i==="delivered"||i==="failed"||i==="unknown"?i:"unavailable";return{status:"ready",synthetic:!1,data:{business_day:r(a.business_day),timezone:r(a.timezone),expected_targets:v(a.expected_targets),covered_targets:v(a.covered_targets),unavailable_targets:v(a.unavailable_targets),delivery_state:l,accepted_at:r(a.accepted_at),acknowledged_at:r(a.acknowledged_at),source_as_of:r(a.source_as_of),legacy_receipts:!1,targets:[]}}}async function ae(e=null,c=!1){if(c)return{status:"ready",synthetic:!0,data:{events:Z(),next_cursor:null,coverage:"synthetic"}};try{const a=new URLSearchParams({limit:"25"});e!==null&&a.set("cursor",e);const i=_(await z(`/api/audit-events?${a}`));if(i?.schema_version!=="qsl.audit_events.v1"||i.data_status!=="ready"||!Array.isArray(i.events)||!Array.isArray(i.errors)||i.errors.length||!r(i.coverage)||!(i.next_cursor===null||typeof i.next_cursor=="string"&&/^[A-Za-z0-9_-]{1,2048}$/.test(i.next_cursor))||i.next_cursor!==null&&(i.events.length===0||i.next_cursor===e))throw Error("invalid_audit_page");const l=i.events.map(s=>{const n=_(s),o=_(n?.subject);if(!n||!r(n.id)||!r(n.occurred_at)||!Number.isFinite(Date.parse(n.occurred_at))||!r(n.action)||!(n.actor_alias===null||typeof n.actor_alias=="string")||!(n.revision===null||typeof n.revision=="string")||!(n.outcome===null||typeof n.outcome=="string")||!(n.subject===null||o&&r(o.kind)&&r(o.id)))throw Error("invalid_audit_event");return{event_id:n.id,occurred_at:n.occurred_at,actor:r(n.actor_alias),action:n.action,subject:o?`${o.kind}: ${o.id}`:null,revision:r(n.revision),decision_id:null,operation_id:null,outcome:r(n.outcome)}});if(new Set(l.map(s=>s.event_id)).size!==l.length)throw Error("duplicate_audit_event");return{status:"ready",data:{events:l,next_cursor:i.next_cursor,coverage:i.coverage},synthetic:!1}}catch(a){if(D(a))return{status:"not_ready"};throw a}}async function se(e){try{const c=_(await z(`/api/runtime/readback?${new URLSearchParams({scope:e})}`)),a=_(c?.policy),i=["enabled","paused","mixed","missing","unknown","not_applicable"];if(c?.schema_version!=="qsl.runtime_readback.v1"||c.scope!==e||!["ready","stale","unavailable"].includes(c.data_status)||a?.read_only!==!0||a.no_order!==!0||a.execution_authority_granted!==!1||typeof c.server_time!="string"||!Number.isFinite(Date.parse(c.server_time))||c.source!=="stored_runtime_target_lifecycle"||!(c.observed_at===null||typeof c.observed_at=="string"&&Number.isFinite(Date.parse(c.observed_at)))||!(c.runtime_enabled===null||typeof c.runtime_enabled=="boolean")||!i.includes(c.scheduler_state)||!(c.strategy_profile===null||typeof c.strategy_profile=="string")||c.data_status==="ready"&&(c.observed_at===null||c.runtime_enabled===null||Date.parse(c.observed_at)>Date.parse(c.server_time))||c.data_status!=="ready"&&(c.runtime_enabled!==null||c.scheduler_state!=="unknown"||c.strategy_profile!==null))throw Error("invalid_runtime_readback");return{status:"ready",synthetic:!1,data:{scope:e,data_status:c.data_status,observed_at:r(c.observed_at),runtime_enabled:c.runtime_enabled,scheduler_state:c.scheduler_state,strategy_profile:r(c.strategy_profile)}}}catch(c){if(D(c))return{status:"not_ready"};throw c}}function F(e){return{operation_id:e,request_id:"synthetic-request",decision_id:"synthetic-decision-001",decision_revision:3,action:"approve",title_key:"decision.promotion_title",account_alias:"demo_account",platform:"ibkr",release_id:"demo-release-2026.10",target_id:"demo-target",state:"applying",recorded_at:"2026-11-01T10:00:00Z",dispatched_at:"2026-11-01T10:00:05Z",applied_at:null,applied_by:null,runtime_confirmed_at:null,runtime_state:"unknown",failure_reason:null,unknown_reason:null,readback_available:null,server_time:new Date().toISOString()}}function M(e){return{scope:e,selected_tier:"BALANCED_COMPOUNDING",selection_revision:2,approved_tier:"BALANCED_COMPOUNDING",approved_policy_id:"synthetic-policy",approved_policy_revision:"r7",effective_tier:"BALANCED_COMPOUNDING",effective_policy_id:"synthetic-policy",effective_policy_revision:"r7",effective_observed_at:"2026-11-01T09:30:00Z",temporary_restriction:null,values:[{key:"max_gross_exposure",label_key:null,value:45,unit:"percent",status:"known",source:"server"},{key:"cash_floor",label_key:null,value:20,unit:"percent",status:"known",source:"server"}]}}function U(){return[{profile:"demo_trend",account_alias:"demo_account",platform:"ibkr",target_id:"demo-target",release_id:"demo-release-2026.10",present:!0,research_stage:"paper",authorized_stage:"paper",effective_stage:"paper",operating_state:"running",application_state:"applied",observed_at:"2026-11-01T09:30:00Z",evidence:{evidence_id:"synthetic-evidence",label_key:null,observed_at:"2026-10-31T13:00:00Z",valid_until:"2026-11-02T13:00:00Z",state:"current",qualification:"qualified",limitations:[]},regime_effect:"risk_reduction_only"}]}function G(){return{business_day:"2026-11-01",timezone:"America/New_York",expected_targets:4,covered_targets:3,unavailable_targets:1,delivery_state:"accepted",accepted_at:"2026-11-01T13:05:00Z",acknowledged_at:null,source_as_of:"2026-11-01T13:00:00Z",legacy_receipts:!1,targets:[]}}function Z(){return[{event_id:"synthetic-event-1",occurred_at:"2026-11-01T10:00:00Z",actor:"owner",action:"approval_recorded",subject:"synthetic-decision-001",revision:3,decision_id:"synthetic-decision-001",operation_id:"synthetic-operation-1",outcome:"recorded"},{event_id:"synthetic-event-2",occurred_at:"2026-11-01T10:00:05Z",actor:"platform",action:"application_dispatched",subject:"demo-target",revision:3,decision_id:"synthetic-decision-001",operation_id:"synthetic-operation-1",outcome:"applying"}]}const V=["CAPITAL_PRESERVATION","BALANCED_COMPOUNDING","GROWTH_COMPOUNDING"],w=["research","paper","small_live","full_live"];function A(e,c){return c(e==="CAPITAL_PRESERVATION"?"cockpit.tier.capital":e==="BALANCED_COMPOUNDING"?"cockpit.tier.balanced":e==="GROWTH_COMPOUNDING"?"cockpit.tier.growth":"cockpit.not_set")}function H(e){const[c,a]=g.useState(()=>Date.now());return g.useEffect(()=>{if(!e)return;const i=window.setInterval(()=>a(Date.now()),3e4);return()=>window.clearInterval(i)},[e]),c}function W(e,c){const a=Math.max(1,Math.ceil(e/6e4)),i=Math.floor(a/60),l=a%60;return i===0?c==="zh"?`${l} 分钟`:`${l}m`:c==="zh"?`${i} 小时 ${String(l).padStart(2,"0")} 分`:`${i}h ${String(l).padStart(2,"0")}m`}function J({state:e,observedAt:c}){const a=h(),i=y(),s=e==="fresh"||e==="ready"?"current":e==="current"||e==="stale"||e==="missing"||e==="unknown"||e==="partial"||e==="unavailable"||e==="read_failed"||e==="fresh"||e==="ready"?e:"unknown",n=s==="current"?"ok":s==="read_failed"?"error":s==="stale"||s==="partial"?"warn":"unknown",o=c?f(c,i):null;return t.jsxs("span",{className:"cockpit-freshness","data-state":s,children:[t.jsx(j,{tone:n,children:a(`cockpit.freshness.${s}`)}),o&&t.jsx("span",{className:"cockpit-meta",children:a("cockpit.as_of",{value:o.zone?`${o.text} (${o.zone})`:o.text})})]})}function ne({expiresAt:e,serverTime:c,receivedAt:a,onBoundary:i,showConsequence:l=!0}){const s=h(),n=y(),o=H(!!e),p=P(e,c,a,o),u=g.useRef(null);if(g.useEffect(()=>{p.state==="expired"&&u.current!==e&&(u.current=e,i?.())},[p.state,e,i]),p.state==="none")return t.jsx("p",{className:"cockpit-expiry","data-state":"none",children:s("cockpit.expiry.none")});if(p.state==="unknown")return t.jsx("p",{className:"cockpit-expiry","data-state":"unknown",children:s("cockpit.expiry.unknown")});const d=f(p.expiresAt,n),m=d.text==="—"?p.expiresAt:d.zone?`${d.text} (${d.zone})`:d.text,x=p.state==="expired",k=p.state==="expired"?0:p.remainingMs,b=x?"expired":k<5*6e4?"under_five":k<60*6e4?"under_hour":"open",E=x?s("cockpit.expiry.expired"):s(`cockpit.expiry.${b}`,{value:W(k,n)});return t.jsxs("div",{className:"cockpit-expiry","data-state":b,children:[t.jsxs("p",{className:"cockpit-expiry-line",children:[t.jsx("span",{children:s("cockpit.expiry.at",{value:m})}),t.jsx("span",{className:"cockpit-expiry-remaining",children:E})]}),t.jsx("span",{className:"cockpit-expiry-utc",children:t.jsx("time",{dateTime:p.expiresAt,children:p.expiresAt})}),l&&t.jsxs("p",{className:"cockpit-note",children:[s("cockpit.expiry.inaction")," ",!x&&s("cockpit.expiry.boundary")]})]})}function oe({evidence:e,status:c="ready"}){const a=h(),i=y();if(c==="loading")return t.jsx(N,{height:72});if(c==="unavailable"||!e)return t.jsxs("section",{className:"cockpit-section","aria-label":a("cockpit.support.title"),children:[t.jsx("h3",{className:"cockpit-section-title",children:a("cockpit.support.title")}),t.jsx("p",{className:"cockpit-note error",role:"status",children:a("cockpit.support.missing")})]});const l=e.limitations,s=e.qualification==="qualified"?l.length>0?a("cockpit.support.qualified_limited"):a("cockpit.support.qualified"):e.qualification==="unqualified"?a("cockpit.support.unqualified"):a("cockpit.support.unknown"),n=e.qualification==="qualified"?l.length>0?"warn":"ok":e.qualification==="unqualified"?"error":"unknown",o=e.state==="stale"?a("cockpit.support.stale"):e.state==="expired"?a("cockpit.support.expired"):e.state==="unavailable"?a("cockpit.support.unavailable"):e.state==="missing"?a("cockpit.support.missing"):null,p=e.observed_at?f(e.observed_at,i):null,u=e.valid_until?f(e.valid_until,i):null;return t.jsxs("section",{className:"cockpit-section","aria-label":a("cockpit.support.title"),children:[t.jsx("h3",{className:"cockpit-section-title",children:a("cockpit.support.title")}),t.jsxs("div",{className:"cockpit-badges",children:[t.jsx(j,{tone:n,children:s}),t.jsx(J,{state:e.state})]}),o&&t.jsx("p",{className:"cockpit-note error",role:"status",children:o}),t.jsxs("dl",{className:"cockpit-kv",children:[p&&t.jsxs(t.Fragment,{children:[t.jsx("dt",{children:a("cockpit.support.observed_label")}),t.jsx("dd",{children:p.zone?`${p.text} (${p.zone})`:p.text})]}),u&&t.jsxs(t.Fragment,{children:[t.jsx("dt",{children:a("cockpit.support.valid_until_label")}),t.jsx("dd",{children:u.zone?`${u.text} (${u.zone})`:u.text})]}),t.jsx("dt",{children:a("cockpit.support.limitations")}),t.jsx("dd",{children:l.length>0?l.join(" · "):a("cockpit.support.no_limitations")})]}),e.evidence_id&&t.jsxs("details",{className:"cockpit-details",children:[t.jsx("summary",{children:a("cockpit.support.provenance")}),t.jsx("code",{children:e.evidence_id})]})]})}function re({scope:e,value:c,savedValue:a,selectionRevision:i,mappingAvailable:l,disabled:s,saving:n,dirty:o,onChange:p,onSave:u}){const d=h(),m=g.useId(),x=c!==""&&!$(c);return t.jsxs("section",{className:"cockpit-section","aria-label":d("cockpit.tier.title"),children:[t.jsx("h3",{className:"cockpit-section-title",children:d("cockpit.tier.title")}),t.jsx("p",{className:"cockpit-meta",children:d("cockpit.tier.scope",{value:e})}),t.jsxs("fieldset",{className:"cockpit-tier-group",disabled:s||n,children:[t.jsx("legend",{className:"cockpit-sr-only",children:d("cockpit.tier.title")}),V.map(k=>{const b=k==="CAPITAL_PRESERVATION"?"cockpit.tier.capital_note":k==="BALANCED_COMPOUNDING"?"cockpit.tier.balanced_note":"cockpit.tier.growth_note";return t.jsxs("label",{className:"cockpit-tier-option",children:[t.jsx("input",{type:"radio",name:`${m}-tier`,value:k,checked:c===k,"aria-describedby":`${m}-${k}`,onChange:()=>p(k)}),t.jsxs("span",{children:[t.jsx("span",{className:"cockpit-tier-name",children:d(`cockpit.tier.${k==="CAPITAL_PRESERVATION"?"capital":k==="BALANCED_COMPOUNDING"?"balanced":"growth"}`)}),t.jsx("span",{className:"cockpit-tier-note",id:`${m}-${k}`,children:d(b)})]})]},k)}),t.jsxs("label",{className:"cockpit-tier-option",children:[t.jsx("input",{type:"radio",name:`${m}-tier`,value:"",checked:c==="","aria-describedby":`${m}-unset`,onChange:()=>p("")}),t.jsxs("span",{children:[t.jsx("span",{className:"cockpit-tier-name",children:d("cockpit.tier.unset")}),t.jsx("span",{className:"cockpit-tier-note",id:`${m}-unset`,children:d("cockpit.tier.unset_note")})]})]})]}),x&&t.jsxs("p",{className:"cockpit-note",role:"status",children:[d("cockpit.unknown"),": ",c]}),!l&&t.jsx("p",{className:"cockpit-note error",role:"status",children:d("cockpit.policy.mapping_unavailable")}),t.jsxs("div",{className:"cockpit-toolbar",children:[t.jsx("button",{type:"button",className:"button button-primary button-sm",disabled:s||n||!o||!l,onClick:u,children:d("cockpit.tier.save")}),t.jsx("span",{className:"cockpit-meta",children:d(o?"cockpit.tier.dirty":"cockpit.tier.unchanged")}),i!==null&&t.jsx("span",{className:"cockpit-meta",children:d("cockpit.tier.selection_revision",{value:i})})]}),t.jsxs("p",{className:"cockpit-meta",children:[d("cockpit.decision.selected"),": ",a===""?d("cockpit.tier.unset"):A(a,d)]}),!l&&t.jsx("p",{className:"cockpit-note",children:d("cockpit.policy.effective_note")})]})}function K({value:e}){const c=h();return e.status!=="known"||e.value===null?t.jsx("span",{className:"cockpit-unknown",children:c("cockpit.policy.unknown_value")}):t.jsxs("span",{children:[String(e.value),e.unit?` ${e.unit}`:""]})}function le({binding:e,status:c="ready",onRetry:a}){const i=h(),l=y();if(c==="loading")return t.jsx(N,{height:96});if(c==="error")return t.jsxs("section",{className:"cockpit-section","aria-label":i("cockpit.policy.title"),children:[t.jsx("h3",{className:"cockpit-section-title",children:i("cockpit.policy.title")}),t.jsx("p",{className:"cockpit-note error",role:"alert",children:i("cockpit.policy.read_failed")}),a&&t.jsx("button",{type:"button",className:"button button-secondary button-sm",onClick:a,children:i("common.retry")})]});if(c==="not_ready"||!e)return t.jsxs("section",{className:"cockpit-section","aria-label":i("cockpit.policy.title"),children:[t.jsx("h3",{className:"cockpit-section-title",children:i("cockpit.policy.title")}),t.jsx("p",{className:"cockpit-note error",role:"status",children:i("cockpit.policy.mapping_unavailable")})]});const s=e.temporary_restriction,n=e.effective_observed_at?f(e.effective_observed_at,l):null,o=s?.until?f(s.until,l):null;return t.jsxs("section",{className:"cockpit-section","aria-label":i("cockpit.policy.title"),children:[t.jsx("h3",{className:"cockpit-section-title",children:i("cockpit.policy.title")}),t.jsxs("dl",{className:"cockpit-kv",children:[t.jsx("dt",{children:i("cockpit.policy.selected")}),t.jsxs("dd",{children:[e.selected_tier?A(e.selected_tier,i):i("cockpit.unknown"),e.selection_revision!==null&&t.jsxs("span",{className:"cockpit-meta",children:[" · ",i("cockpit.policy.revision",{value:e.selection_revision})]})]}),t.jsx("dt",{children:i("cockpit.policy.approved")}),t.jsx("dd",{children:e.approved_policy_id||e.approved_tier?t.jsxs(t.Fragment,{children:[e.approved_tier&&t.jsxs(t.Fragment,{children:[A(e.approved_tier,i)," · "]}),e.approved_policy_id||i("cockpit.unknown"),e.approved_policy_revision&&t.jsxs("span",{className:"cockpit-meta",children:[" · ",i("cockpit.policy.revision",{value:e.approved_policy_revision})]})]}):i("cockpit.policy.mapping_unavailable")}),t.jsx("dt",{children:i("cockpit.policy.effective")}),t.jsx("dd",{children:e.effective_policy_id||e.effective_tier?t.jsxs(t.Fragment,{children:[e.effective_tier&&t.jsxs(t.Fragment,{children:[A(e.effective_tier,i)," · "]}),e.effective_policy_id||i("cockpit.unknown"),e.effective_policy_revision&&t.jsxs("span",{className:"cockpit-meta",children:[" · ",i("cockpit.policy.revision",{value:e.effective_policy_revision})]}),n&&t.jsxs("span",{className:"cockpit-meta",children:[" · ",i("cockpit.as_of",{value:n.text})]})]}):i("cockpit.policy.not_observed")}),t.jsx("dt",{children:i("cockpit.policy.restriction")}),t.jsx("dd",{children:s?.active?t.jsxs(t.Fragment,{children:[s.reason||i("cockpit.unknown"),o&&t.jsxs("span",{className:"cockpit-meta",children:[" · ",i("cockpit.policy.since",{value:o.text})]})]}):i("cockpit.policy.restriction_none")})]}),t.jsx("h4",{className:"cockpit-subtitle",children:i("cockpit.policy.values")}),e.values.length===0?t.jsx("p",{className:"cockpit-meta",children:i("cockpit.policy.no_values")}):t.jsxs("table",{className:"cockpit-table",children:[t.jsx("thead",{children:t.jsxs("tr",{children:[t.jsx("th",{scope:"col",children:i("cockpit.policy.values")}),t.jsx("th",{scope:"col",children:i("cockpit.policy.source_label")})]})}),t.jsx("tbody",{children:e.values.map(p=>t.jsxs("tr",{children:[t.jsx("th",{scope:"row",children:p.label_key?i(p.label_key):p.key}),t.jsxs("td",{children:[t.jsx(K,{value:p}),p.source&&t.jsxs("span",{className:"cockpit-meta",children:[" · ",i("cockpit.policy.source",{value:p.source})]})]})]},p.key))})]}),t.jsx("p",{className:"cockpit-note",children:i("cockpit.policy.effective_note")})]})}function pe({binding:e}){const c=h(),a=w.includes(e.authorized_stage)?e.authorized_stage:w.includes(e.effective_stage)?e.effective_stage:null,i=a?w.indexOf(a):-1,l=[{key:"cockpit.lifecycle.axis.research",value:c(`cockpit.lifecycle.stage.${e.research_stage}`)},{key:"cockpit.lifecycle.axis.authorized",value:c(`cockpit.lifecycle.stage.${e.authorized_stage}`)},{key:"cockpit.lifecycle.axis.effective",value:c(`cockpit.lifecycle.stage.${e.effective_stage}`)},{key:"cockpit.lifecycle.axis.operating",value:c(`cockpit.lifecycle.operating.${e.operating_state}`)},{key:"cockpit.lifecycle.axis.application",value:c(`cockpit.lifecycle.application.${e.application_state}`)}];return t.jsxs("section",{className:"cockpit-section","aria-label":c("cockpit.lifecycle.title"),children:[t.jsx("h3",{className:"cockpit-section-title",children:c("cockpit.lifecycle.title")}),t.jsx("p",{className:"cockpit-meta",children:c("cockpit.lifecycle.step")}),t.jsx("ol",{className:"cockpit-stepper",children:w.map((s,n)=>{const o=i>=0&&n===i,p=i>=0&&n<i;return t.jsxs("li",{className:`cockpit-step${o?" active":""}${p?" complete":""}`,"aria-current":o?"step":void 0,children:[t.jsx("span",{className:"cockpit-step-dot","aria-hidden":"true"}),t.jsx("span",{children:c(`cockpit.lifecycle.stage.${s}`)})]},s)})}),a===null&&t.jsx("p",{className:"cockpit-note",role:"status",children:c("cockpit.lifecycle.stage.unclassified")}),t.jsx("dl",{className:"cockpit-kv",children:l.map(s=>t.jsxs("div",{className:"cockpit-kv-pair",children:[t.jsx("dt",{children:c(s.key)}),t.jsx("dd",{children:s.value})]},s.key))}),t.jsx("p",{className:"cockpit-note",children:c("cockpit.lifecycle.note")})]})}function Y(e,c){return e.runtime_confirmed_at?c("cockpit.operation.confirmed"):e.state==="pending"?e.dispatched_at?c("cockpit.operation.applying"):c("cockpit.operation.accepted"):e.state==="applying"?c("cockpit.operation.applying"):e.state==="applied"?c("cockpit.operation.applied_unobserved"):e.state==="rejected"?c("cockpit.operation.rejected"):e.state==="failed"?c("cockpit.operation.failed"):c("cockpit.operation.unknown")}function Q(e){return e.runtime_confirmed_at?"ok":e.state==="rejected"||e.state==="failed"?"error":e.state==="applied"||e.state==="applying"||e.state==="pending"?"warn":"unknown"}function de({operation:e,status:c,onRefresh:a}){const i=h(),l=y();if(c==="loading")return t.jsx(N,{height:72});if(c==="not_ready")return t.jsxs("section",{className:"cockpit-section","aria-label":i("cockpit.operation.title"),children:[t.jsx("h3",{className:"cockpit-section-title",children:i("cockpit.operation.title")}),t.jsx("p",{className:"cockpit-note",role:"status",children:i("cockpit.operation.not_ready")})]});if(c==="error")return t.jsxs("section",{className:"cockpit-section","aria-label":i("cockpit.operation.title"),children:[t.jsx("h3",{className:"cockpit-section-title",children:i("cockpit.operation.title")}),t.jsx("p",{className:"cockpit-note error",role:"alert",children:i("cockpit.operation.read_failed")}),a&&t.jsx("button",{type:"button",className:"button button-secondary button-sm",onClick:a,children:i("cockpit.operation.refresh")})]});if(!e)return t.jsxs("section",{className:"cockpit-section","aria-label":i("cockpit.operation.title"),children:[t.jsx("h3",{className:"cockpit-section-title",children:i("cockpit.operation.title")}),t.jsx("p",{className:"cockpit-meta",children:i("cockpit.operation.none")})]});const s=e.state==="applied"||!!e.runtime_confirmed_at,n=!!e.runtime_confirmed_at,o=e.state==="rejected"||e.state==="failed",p=[{label:i("cockpit.operation.decision"),state:"complete"},{label:i("cockpit.operation.application"),state:o?"failed":n||s?"complete":"active"},{label:i("cockpit.operation.observation"),state:n?"complete":s?"active":"idle"}],u=e.applied_at??e.runtime_confirmed_at??e.dispatched_at??e.recorded_at,d=u?f(u,l):null;return t.jsxs("section",{className:"cockpit-section","aria-label":i("cockpit.operation.title"),children:[t.jsx("h3",{className:"cockpit-section-title",children:i("cockpit.operation.title")}),t.jsxs("div",{className:"cockpit-badges",children:[t.jsx(j,{tone:Q(e),children:Y(e,i)}),d&&t.jsx("span",{className:"cockpit-meta",children:i("cockpit.as_of",{value:d.zone?`${d.text} (${d.zone})`:d.text})})]}),t.jsx("ol",{className:"cockpit-stages",children:p.map(m=>t.jsx("li",{className:"cockpit-stage","data-state":m.state,children:m.label},m.label))}),(e.failure_reason||e.unknown_reason)&&t.jsx("p",{className:`cockpit-note ${o?"error":""}`,role:"status",children:e.failure_reason||e.unknown_reason}),e.state==="unknown"&&t.jsx("p",{className:"cockpit-note",role:"status",children:i("cockpit.operation.no_retry")}),t.jsxs("details",{className:"cockpit-details",children:[t.jsx("summary",{children:i("cockpit.operation.id",{value:e.operation_id||i("cockpit.unknown")})}),t.jsx("p",{className:"cockpit-meta",children:i("cockpit.operation.request",{value:e.request_id||i("cockpit.unknown")})}),e.decision_revision!==null&&t.jsx("p",{className:"cockpit-meta",children:i("cockpit.operation.revision",{value:e.decision_revision})})]}),a&&t.jsx("button",{type:"button",className:"button button-secondary button-sm",onClick:a,children:i("cockpit.operation.refresh")})]})}function ue({events:e,status:c,hasMore:a=!1,loadingMore:i=!1,onMore:l}){const s=h(),n=y();return c==="loading"?t.jsx(N,{height:96}):c==="not_ready"?t.jsx("p",{className:"cockpit-note",children:s("cockpit.change_log.unavailable")}):c==="error"?t.jsx("p",{className:"cockpit-note error",role:"alert",children:s("cockpit.change_log.load_failed")}):!e||e.length===0?t.jsx("p",{className:"cockpit-meta",children:s("cockpit.change_log.empty")}):t.jsxs("div",{className:"cockpit-change-log",children:[t.jsx("ol",{className:"cockpit-timeline",children:e.map(o=>{const p=f(o.occurred_at,n);return t.jsxs("li",{className:"cockpit-event",children:[t.jsx("time",{dateTime:o.occurred_at,children:p.zone?`${p.text} (${p.zone})`:p.text}),t.jsxs("div",{className:"cockpit-event-body",children:[t.jsx("span",{className:"cockpit-event-action",children:o.action.replace(/_/g," ")}),t.jsxs("span",{className:"cockpit-meta",children:[o.actor?s("cockpit.change_log.actor",{value:o.actor}):s("cockpit.unknown"),o.outcome&&` · ${s("cockpit.change_log.outcome",{value:o.outcome})}`]}),o.subject&&t.jsx("span",{className:"cockpit-meta",children:s("cockpit.change_log.subject",{value:o.subject})}),o.revision!==null&&t.jsx("span",{className:"cockpit-meta",children:s("cockpit.change_log.revision",{value:o.revision})})]})]},o.event_id)})}),a&&l&&t.jsx("button",{type:"button",className:"button button-secondary button-sm",disabled:i,onClick:l,children:s("cockpit.change_log.more")})]})}function _e({digest:e,status:c="ready",onRetry:a}){const i=h(),l=y();if(c==="loading")return t.jsx(N,{height:96});if(c==="error")return t.jsxs("section",{className:"cockpit-section","aria-label":i("cockpit.digest.title"),children:[t.jsx("h3",{className:"cockpit-section-title",children:i("cockpit.digest.title")}),t.jsx("p",{className:"cockpit-note error",role:"alert",children:i("cockpit.digest.read_failed")}),a&&t.jsx("button",{type:"button",className:"button button-secondary button-sm",onClick:a,children:i("common.retry")})]});if(c==="not_ready"||!e)return t.jsxs("section",{className:"cockpit-section","aria-label":i("cockpit.digest.title"),children:[t.jsx("h3",{className:"cockpit-section-title",children:i("cockpit.digest.title")}),t.jsx("p",{className:"cockpit-meta",children:i("cockpit.digest.no_data")})]});const s=e.delivery_state==="delivered"?"ok":e.delivery_state==="failed"?"error":e.delivery_state==="accepted"?"warn":"unknown",n=e.accepted_at?f(e.accepted_at,l):null,o=e.acknowledged_at?f(e.acknowledged_at,l):null,p=u=>u===null?i("cockpit.unknown"):String(u);return t.jsxs("section",{className:"cockpit-section","aria-label":i("cockpit.digest.title"),children:[t.jsx("h3",{className:"cockpit-section-title",children:i("cockpit.digest.title")}),t.jsxs("div",{className:"cockpit-badges",children:[t.jsx(j,{tone:s,children:i(`cockpit.digest.${e.delivery_state}`)}),e.legacy_receipts&&t.jsx(j,{tone:"unknown",children:i("cockpit.digest.legacy")})]}),(e.business_day||e.timezone)&&t.jsx("p",{className:"cockpit-meta",children:i("cockpit.digest.window",{day:e.business_day||i("cockpit.unknown"),zone:e.timezone||i("cockpit.unknown")})}),t.jsx("p",{className:"cockpit-meta",children:i("cockpit.digest.targets",{expected:p(e.expected_targets),covered:p(e.covered_targets),unavailable:p(e.unavailable_targets)})}),n&&t.jsx("p",{className:"cockpit-meta",children:i("cockpit.digest.accepted_at",{value:n.zone?`${n.text} (${n.zone})`:n.text})}),t.jsxs("p",{className:"cockpit-meta",children:[i("cockpit.digest.ack"),": ",o?i("cockpit.digest.ack_at",{value:o.zone?`${o.text} (${o.zone})`:o.text}):i("cockpit.digest.ack_unknown")]}),e.targets.length>0&&t.jsx("ul",{className:"cockpit-targets",children:e.targets.map(u=>t.jsxs("li",{children:[t.jsx("span",{children:u.label}),t.jsx("span",{className:"cockpit-meta",children:u.known?"✓":i("cockpit.unknown")})]},u.label))}),t.jsx("p",{className:"cockpit-note",children:i("cockpit.digest.note")})]})}export{de as A,_e as D,ne as E,J as F,pe as L,re as R,oe as a,se as b,te as c,le as d,P as e,ce as f,ie as g,ae as h,$ as i,ue as j,ee as l,A as t};
" },
+  "/v2/assets/cockpit-Lo-aJH0Q.css": { contentType: "text/css; charset=utf-8", base64: ".cockpit-section{display:grid;gap:12px;padding:20px;border:1px solid var(--border-divider);border-radius:var(--radius-m);background:var(--surface-default)}.cockpit-section-title{margin:0;font-size:16px;font-weight:600;color:var(--text-primary)}.cockpit-subtitle{margin:4px 0 0;font-size:13px;font-weight:600;color:var(--text-secondary)}.cockpit-meta{margin:0;font-size:12px;color:var(--text-muted)}.cockpit-note{margin:0;font-size:13px;line-height:1.5;color:var(--text-secondary)}.cockpit-note.error{color:var(--status-blocked)}.cockpit-unknown{color:var(--text-muted)}.cockpit-sr-only{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0 0 0 0);white-space:nowrap;border:0}.cockpit-badges,.cockpit-freshness,.cockpit-decision-support{display:flex;flex-wrap:wrap;align-items:center;gap:8px}.cockpit-kv{display:grid;gap:8px;margin:0}.cockpit-kv-pair{display:grid;grid-template-columns:minmax(120px,180px) minmax(0,1fr);gap:12px}.cockpit-kv dt{font-size:12px;color:var(--text-muted)}.cockpit-kv dd{margin:0;font-size:13px;color:var(--text-primary);overflow-wrap:anywhere}.cockpit-toolbar{display:flex;flex-wrap:wrap;align-items:center;gap:8px}.cockpit-details{font-size:12px;color:var(--text-secondary)}.cockpit-details summary{cursor:pointer;color:var(--text-muted)}.cockpit-details code{font-size:12px;color:var(--text-secondary);overflow-wrap:anywhere}.cockpit-expiry{display:grid;gap:4px;margin:0;padding:10px 12px;border-left:3px solid var(--border-control);border-radius:var(--radius-s);background:var(--surface-subtle)}.cockpit-expiry[data-state=under_five],.cockpit-expiry[data-state=under_hour]{border-left-color:var(--status-attention);background:var(--status-attention-bg)}.cockpit-expiry[data-state=expired]{border-left-color:var(--status-blocked);background:var(--status-blocked-bg)}.cockpit-expiry[data-state=unknown]{border-left-color:var(--status-unknown)}.cockpit-expiry-line{display:flex;flex-wrap:wrap;justify-content:space-between;gap:8px;margin:0;font-size:13px;color:var(--text-primary)}.cockpit-expiry-remaining{font-weight:600}.cockpit-expiry-utc{font-size:11px;color:var(--text-muted)}.cockpit-tier-group{display:grid;gap:8px;margin:0;padding:0;border:0}.cockpit-tier-option{display:flex;gap:10px;align-items:flex-start;padding:12px;border:1px solid var(--border-divider);border-radius:var(--radius-s);cursor:pointer}.cockpit-tier-option:has(input:checked){border-color:var(--accent-foreground);background:var(--accent-surface)}.cockpit-tier-option:has(input:disabled){cursor:not-allowed}.cockpit-tier-option input{margin-top:3px;accent-color:var(--accent-foreground)}.cockpit-tier-name{display:block;font-size:13px;font-weight:600;color:var(--text-primary)}.cockpit-tier-note{display:block;font-size:12px;color:var(--text-muted)}.cockpit-table{width:100%;border-collapse:collapse;font-size:13px}.cockpit-table th,.cockpit-table td{padding:8px 10px;text-align:left;border-bottom:1px solid var(--border-divider);vertical-align:top}.cockpit-table thead th{font-size:12px;font-weight:500;color:var(--text-muted)}.cockpit-table tbody th{font-weight:500;color:var(--text-secondary)}.cockpit-stepper{display:flex;gap:4px;margin:0;padding:0;list-style:none}.cockpit-step{display:flex;flex:1 1 0;align-items:center;gap:6px;min-width:0;padding:8px;border-radius:var(--radius-s);background:var(--surface-subtle);font-size:12px;color:var(--text-muted)}.cockpit-step-dot{width:8px;height:8px;flex:none;border-radius:50%;background:var(--border-control)}.cockpit-step.complete .cockpit-step-dot{background:var(--status-verified)}.cockpit-step.active{background:var(--accent-surface);color:var(--accent-foreground);font-weight:600}.cockpit-step.active .cockpit-step-dot{background:var(--accent-foreground)}.cockpit-stages{display:flex;gap:8px;margin:0;padding:0;list-style:none}.cockpit-stage{flex:1 1 0;padding:8px;border-top:3px solid var(--border-divider);font-size:12px;color:var(--text-muted)}.cockpit-stage[data-state=active]{border-top-color:var(--status-attention);color:var(--text-primary)}.cockpit-stage[data-state=complete]{border-top-color:var(--status-verified);color:var(--text-primary)}.cockpit-stage[data-state=failed]{border-top-color:var(--status-blocked);color:var(--status-blocked)}.cockpit-change-log{display:grid;gap:12px}.cockpit-timeline{display:grid;gap:0;margin:0;padding:0;list-style:none}.cockpit-event{display:grid;grid-template-columns:minmax(130px,180px) minmax(0,1fr);gap:12px;padding:10px 0;border-bottom:1px solid var(--border-divider)}.cockpit-event time{font-size:12px;color:var(--text-muted)}.cockpit-event-body{display:grid;gap:2px}.cockpit-event-action{font-size:13px;font-weight:500;color:var(--text-primary)}.cockpit-targets{display:grid;gap:4px;margin:0;padding:0;list-style:none}.cockpit-targets li{display:flex;justify-content:space-between;gap:12px;font-size:12px}.cockpit-decision{display:grid;gap:12px;padding:20px;border:1px solid var(--border-divider);border-radius:var(--radius-m);background:var(--surface-default)}.cockpit-decision.selected{border-color:var(--accent-foreground)}.cockpit-decision-title{margin:0;font-size:16px;font-weight:600;line-height:1.35;color:var(--text-primary)}.cockpit-blockers{margin:0;padding-left:18px;font-size:13px;color:var(--status-blocked)}.cockpit-strip{position:sticky;top:64px;z-index:20;display:flex;flex-wrap:wrap;align-items:center;gap:8px 12px;padding:10px 16px;border:1px solid var(--border-divider);border-radius:var(--radius-m);background:var(--surface-default);box-shadow:var(--shadow)}.cockpit-strip[data-state=unknown]{border-color:var(--status-blocked);background:var(--status-blocked-bg)}.cockpit-strip-title{font-size:12px;font-weight:600;color:var(--text-primary)}.cockpit-strip-subject{font-size:13px;color:var(--text-primary);overflow-wrap:anywhere}.cockpit-strip-actions{display:flex;gap:8px;margin-left:auto}@media(max-width:768px){.cockpit-section,.cockpit-decision{padding:16px}.cockpit-kv-pair{grid-template-columns:1fr;gap:2px}.cockpit-stepper{flex-wrap:wrap}.cockpit-step{flex:1 1 45%}.cockpit-event{grid-template-columns:1fr;gap:4px}.cockpit-strip{top:56px}.cockpit-strip-actions{margin-left:0;width:100%}}
" },
+  "/v2/assets/hooks-9usXmJc_.js": { contentType: "text/javascript; charset=utf-8", base64: "aW1wb3J0e3J9ZnJvbSIuL2luZGV4LUN3UXNXWmRtLmpzIjtmdW5jdGlvbiBwKCl7bGV0IGU9MDtyZXR1cm57YmVnaW4oKXtyZXR1cm4gZSs9MSxlfSxpc0N1cnJlbnQoYSl7cmV0dXJuIGE9PT1lfSxpbnZhbGlkYXRlKCl7ZSs9MX19fWZ1bmN0aW9uIGcoZSxhKXtjb25zdFtsLHVdPXIudXNlU3RhdGUoe3BoYXNlOiJsb2FkaW5nIixkYXRhOm51bGwsZXJyb3I6bnVsbH0pLHM9ci51c2VSZWYocCgpKSxbaSxmXT1yLnVzZVN0YXRlKDApLGM9ci51c2VSZWYoZSk7Yy5jdXJyZW50PWUsci51c2VFZmZlY3QoKCk9Pntjb25zdCB0PXMuY3VycmVudC5iZWdpbigpO3Uoe3BoYXNlOiJsb2FkaW5nIixkYXRhOm51bGwsZXJyb3I6bnVsbH0pO2xldCBvPSExO3JldHVybiBjLmN1cnJlbnQoKS50aGVuKG49PnshbyYmcy5jdXJyZW50LmlzQ3VycmVudCh0KSYmdSh7cGhhc2U6InJlYWR5IixkYXRhOm4sZXJyb3I6bnVsbH0pfSkuY2F0Y2gobj0+eyFvJiZzLmN1cnJlbnQuaXNDdXJyZW50KHQpJiZ1KHtwaGFzZToiZXJyb3IiLGRhdGE6bnVsbCxlcnJvcjpuIGluc3RhbmNlb2YgRXJyb3I/bjpuZXcgRXJyb3IoInJlcXVlc3RfZmFpbGVkIil9KX0pLCgpPT57bz0hMH19LFsuLi5hLGldKTtjb25zdCBkPXIudXNlQ2FsbGJhY2soKCk9PmYodD0+dCsxKSxbXSk7cmV0dXJuey4uLmwscmVsb2FkOmR9fWV4cG9ydHtwIGFzIGMsZyBhcyB1fTsK" },
+  "/v2/assets/inboxFailure-B9PDJ1HN.js": { contentType: "text/javascript; charset=utf-8", base64: "aW1wb3J0e0sgYXMgbyxMIGFzIGl9ZnJvbSIuL2luZGV4LUN3UXNXWmRtLmpzIjtjb25zdCByPW5ldyBTZXQoWyJxdW90YV9leGhhdXN0ZWQiLCJ1bmF1dGhvcml6ZWQiLCJpbmRleF9taXNzaW5nIiwiaW5kZXhfaW5jb21wbGV0ZSIsImluZGV4X3VuYXZhaWxhYmxlIiwidW5rbm93biJdKTtmdW5jdGlvbiBhKGUsdCl7aWYodCBpbnN0YW5jZW9mIG8pcmV0dXJuInVuYXV0aG9yaXplZCI7aWYodCBpbnN0YW5jZW9mIGkpe2NvbnN0IG49dC5wYXlsb2FkPy5lcnJvcl9zdGF0ZTtpZihuJiZyLmhhcyhuKSlyZXR1cm4gbn1yZXR1cm4gZT8uZXJyb3Jfc3RhdGUmJnIuaGFzKGUuZXJyb3Jfc3RhdGUpP2UuZXJyb3Jfc3RhdGU6InVua25vd24ifWV4cG9ydHthIGFzIGl9Owo=" },
+  "/v2/assets/index-CMzizWMv.css": { contentType: "text/css; charset=utf-8", base64: ":root{--background-canvas: #F7F8FA;--background-chrome: #FFFFFF;--surface-default: #FFFFFF;--surface-subtle: #F0F2F5;--surface-hover: #E8EBF0;--border-divider: #DFE2E8;--border-control: #858B98;--text-primary: #18181B;--text-secondary: #525763;--text-muted: #646B78;--accent-foreground: #5B4FD6;--accent-surface: #EEEBFC;--button-primary-bg: #18181B;--button-primary-fg: #FFFFFF;--button-primary-hover: #303034;--button-primary-pressed: #0F1012;--focus-ring: #5B4FD6;--overlay-scrim: #00000066;--status-attention: #805000;--status-attention-bg: #FFF4DD;--status-blocked: #A72E42;--status-blocked-bg: #FCECEF;--status-verified: #19624D;--status-verified-bg: #EAF6EF;--status-info: #136C9F;--status-info-bg: #EAF4FC;--chart-primary: #5B4FD6;--chart-secondary: #136C9F;--chart-benchmark: #646B78;--chart-grid: #DFE2E8;--canvas: #F7F8FA;--surface: #FFFFFF;--surface-2: #F0F2F5;--ink: #18181B;--muted: #646B78;--line: #DFE2E8;--accent: #5B4FD6;--on-accent: #FFFFFF;--up-green: #19624D;--down-green: #A72E42;--up: var(--up-green);--down: var(--down-green);--status-ok: #19624D;--status-warn: #805000;--on-warn: #FFFFFF;--status-error: #A72E42;--status-unknown: #646B78;--danger: #A72E42;--benchmark-1: #5B4FD6;--benchmark-2: #136C9F;--benchmark-3: #19624D;--benchmark-4: #646B78;--radius-s: 8px;--radius-m: 12px;--bottom-tabs-height: 64px;--shadow: 0 12px 32px #18181B1A;color-scheme:light}:root[data-theme=dark]{--background-canvas: #0F1012;--background-chrome: #0F1012;--surface-default: #17181C;--surface-subtle: #1D1F24;--surface-hover: #23262C;--border-divider: #303238;--border-control: #717684;--text-primary: #F4F4F5;--text-secondary: #B4B6BF;--text-muted: #8D919E;--accent-foreground: #B7ADFF;--accent-surface: #29243B;--button-primary-bg: #F4F4F5;--button-primary-fg: #17181C;--button-primary-hover: #FFFFFF;--button-primary-pressed: #DEDEE4;--focus-ring: #B7ADFF;--overlay-scrim: #00000099;--status-attention: #F3C677;--status-attention-bg: #302718;--status-blocked: #F1A5AD;--status-blocked-bg: #321F23;--status-verified: #8DCFB6;--status-verified-bg: #182C25;--status-info: #89C9EF;--status-info-bg: #192B38;--chart-primary: #B7ADFF;--chart-secondary: #89C9EF;--chart-benchmark: #9AA0AE;--chart-grid: #303238;--canvas: #0F1012;--surface: #17181C;--surface-2: #1D1F24;--ink: #F4F4F5;--muted: #8D919E;--line: #303238;--accent: #B7ADFF;--on-accent: #17181C;--up-green: #8DCFB6;--down-green: #F1A5AD;--status-ok: #8DCFB6;--status-warn: #F3C677;--on-warn: #17181C;--status-error: #F1A5AD;--status-unknown: #8D919E;--danger: #F1A5AD;--benchmark-1: #B7ADFF;--benchmark-2: #89C9EF;--benchmark-3: #8DCFB6;--benchmark-4: #9AA0AE;--shadow: 0 12px 32px #00000066;color-scheme:dark}:root[data-updown=red-up]{--up: var(--down-green);--down: var(--up-green)}*{box-sizing:border-box}html,body{margin:0;padding:0;background:var(--background-canvas);color:var(--text-primary);font-family:Geist,Inter,Noto Sans SC,system-ui,-apple-system,Segoe UI,Roboto,PingFang SC,Hiragino Sans GB,Microsoft YaHei,sans-serif;font-size:14px;line-height:1.5;-webkit-font-smoothing:antialiased}.num,.kpi-value,td.num,.money,.percent{font-variant-numeric:tabular-nums}a{color:var(--accent);text-decoration:none}a:hover{text-decoration:underline}button{font:inherit;color:inherit;cursor:pointer;border:none;background:none}button:disabled{cursor:not-allowed;opacity:.55}:focus-visible{outline:2px solid var(--accent);outline-offset:2px}.sr-only{position:absolute;width:1px;height:1px;margin:-1px;padding:0;overflow:hidden;clip:rect(0 0 0 0);white-space:nowrap;border:0}.skip-link{position:absolute;left:8px;top:-48px;padding:8px 12px;background:var(--accent);color:var(--on-accent);border-radius:var(--radius-s);z-index:100;transition:top .15s}.skip-link:focus{top:8px}.shell{display:flex;flex-direction:column;min-height:100vh;background:var(--background-canvas)}.shell-main{flex:1 1 auto;min-width:0;display:flex;flex-direction:column}.brand{display:flex;align-items:center;gap:10px;padding:0;text-align:left;color:var(--text-primary);flex:0 0 auto}.brand img{width:28px;height:28px;flex:0 0 auto}.brand-copy{display:flex;flex-direction:column;line-height:1.15;min-width:0}.brand-name{font-weight:700;font-size:14px;letter-spacing:-.01em;white-space:nowrap}.brand-subtitle{color:var(--text-muted);font-size:11px;white-space:nowrap}.topbar{display:flex;align-items:center;gap:16px;min-height:64px;padding:0 24px;border-bottom:1px solid var(--border-divider);background:var(--background-chrome);position:sticky;top:0;z-index:20;flex-wrap:nowrap}.topbar .spacer{flex:1 1 auto}.topbar-updated{color:var(--text-muted);font-size:12px;white-space:nowrap}.topnav{display:flex;align-items:stretch;gap:2px;height:64px;min-width:0}.topnav-item{display:inline-flex;align-items:center;gap:7px;padding:0 12px;min-height:44px;color:var(--text-secondary);font-size:14px;font-weight:500;white-space:nowrap;border-bottom:2px solid transparent;margin-bottom:-1px;transition:color .12s cubic-bezier(.2,0,0,1),background-color .12s cubic-bezier(.2,0,0,1)}.topnav-item:hover{color:var(--text-primary);background:var(--surface-subtle)}.topnav-item.active{color:var(--accent-foreground);border-bottom-color:var(--accent-foreground)}.topnav-item svg{flex:0 0 auto}.nav-item{display:flex;align-items:center;gap:10px;width:100%;padding:10px 12px;min-height:44px;border-radius:var(--radius-s);color:var(--text-secondary);text-align:left;position:relative;transition:background-color .12s cubic-bezier(.2,0,0,1),color .12s cubic-bezier(.2,0,0,1)}.nav-item:hover{background:var(--surface-hover);color:var(--text-primary)}.nav-item.active{background:var(--accent-surface);color:var(--accent-foreground);font-weight:600}.nav-item svg{flex:0 0 auto}.nav-badge{margin-left:auto;min-width:18px;padding:0 5px;border-radius:9px;background:var(--status-warn);color:var(--on-warn);font-size:12px;text-align:center;line-height:18px}.topnav-item .nav-badge{margin-left:2px}.nav-badge-unknown{background:var(--surface-2);color:var(--muted);box-shadow:inset 0 0 0 1px var(--line)}.content{flex:1 1 auto;padding:32px 24px 64px;max-width:1440px;width:100%;margin:0 auto}.icon-button{display:inline-flex;align-items:center;justify-content:center;width:40px;height:40px;border-radius:var(--radius-s);color:var(--text-secondary)}.icon-button:hover,.icon-button[aria-pressed=true]{background:var(--surface-hover);color:var(--text-primary)}.bottom-tabs{display:none;position:fixed;left:0;right:0;bottom:0;min-height:calc(var(--bottom-tabs-height) + env(safe-area-inset-bottom));background:var(--background-chrome);border-top:1px solid var(--border-divider);z-index:30;padding-bottom:env(safe-area-inset-bottom)}.bottom-tabs-inner{display:flex}.bottom-tab{flex:1 1 0;display:flex;flex-direction:column;align-items:center;justify-content:center;gap:3px;min-height:56px;padding:8px 0 6px;color:var(--text-secondary);font-size:12px;position:relative}.bottom-tab.active{color:var(--accent-foreground);font-weight:600}.bottom-tab .nav-badge{position:absolute;top:4px;right:calc(50% - 22px);margin:0}.more-sheet{position:fixed;left:0;right:0;bottom:calc(var(--bottom-tabs-height) + env(safe-area-inset-bottom));background:var(--surface-default);border-top:1px solid var(--border-divider);border-radius:16px 16px 0 0;padding:8px 16px 16px;max-height:70dvh;overflow-y:auto;z-index:40;box-shadow:var(--shadow)}.more-sheet .nav-item{font-size:15px;min-height:48px}.lang-label-short{display:none}.button{display:inline-flex;align-items:center;justify-content:center;gap:6px;min-height:40px;padding:9px 16px;border-radius:var(--radius-s);border:1px solid transparent;font-size:14px;font-weight:500;white-space:nowrap;transition:background-color .12s cubic-bezier(.2,0,0,1),border-color .12s cubic-bezier(.2,0,0,1),color .12s cubic-bezier(.2,0,0,1)}.button-primary{background:var(--button-primary-bg);color:var(--button-primary-fg)}.button-primary:hover:not(:disabled){background:var(--button-primary-hover)}.button-primary:active:not(:disabled){background:var(--button-primary-pressed)}.button-secondary{border-color:var(--border-control);background:var(--surface-default);color:var(--text-primary)}.button-secondary:hover:not(:disabled){background:var(--surface-hover)}.button-danger{background:var(--status-blocked);color:var(--status-blocked-bg)}.button-danger:hover:not(:disabled){background:color-mix(in srgb,var(--status-blocked) 88%,var(--surface-default))}.button-danger-outline{border-color:var(--status-blocked);color:var(--status-blocked);background:transparent}.button-danger-outline:hover:not(:disabled){background:var(--status-blocked-bg)}.button-sm{min-height:32px;padding:4px 11px;font-size:13px}.card{background:var(--surface-default);border:1px solid var(--border-divider);border-radius:var(--radius-m);padding:24px;min-width:0}.card-title{margin:0 0 12px;font-size:20px;font-weight:600;letter-spacing:-.015em;line-height:1.4}.card-note{color:var(--text-muted);font-size:12px;margin:8px 0 0;line-height:1.55}.kpi-grid{display:grid;grid-template-columns:repeat(5,minmax(0,1fr));gap:12px}.kpi-card{background:var(--surface-default);border:1px solid var(--border-divider);border-radius:var(--radius-m);padding:18px 20px;display:flex;flex-direction:column;gap:6px;min-width:0;text-align:left}button.kpi-card{transition:border-color .12s ease,background-color .12s ease}button.kpi-card:hover{border-color:color-mix(in srgb,var(--accent) 45%,var(--line));background:color-mix(in srgb,var(--accent) 3%,var(--surface))}.kpi-title{font-size:12px;font-weight:500;color:var(--muted)}.kpi-value{font-size:25px;font-weight:700;line-height:1.2;letter-spacing:-.015em;overflow-wrap:anywhere}.kpi-value .flat{font-size:20px;font-weight:500}.kpi-state{font-size:15px;font-weight:500;color:var(--muted)}.metric-note{margin:0;font-size:13px;color:var(--muted);line-height:1.6}.kpi-sub{font-size:12px;color:var(--muted);line-height:1.45;overflow-wrap:anywhere}.kpi-foot{display:flex;align-items:center;gap:6px 10px;margin-top:2px;flex-wrap:wrap}.kpi-foot .badge{max-width:100%;white-space:normal;overflow-wrap:anywhere}.badge{display:inline-flex;align-items:center;gap:5px;min-height:24px;padding:2px 8px;border-radius:999px;font-size:12px;font-weight:500;line-height:18px;white-space:nowrap}.badge svg{flex:0 0 auto}.badge-ok{color:var(--status-verified);background:var(--status-verified-bg)}.badge-warn{color:var(--status-attention);background:var(--status-attention-bg)}.badge-error{color:var(--status-blocked);background:var(--status-blocked-bg)}.badge-unknown{color:var(--text-secondary);background:var(--surface-subtle)}.badge-accent{color:var(--accent-foreground);background:var(--accent-surface)}.up{color:var(--up)}.down{color:var(--down)}.flat{color:var(--muted)}.asof{color:var(--muted);font-size:12px}.empty-state,.error-state{min-height:0;padding:12px 14px;display:flex;flex-wrap:wrap;align-items:center;gap:8px 10px;text-align:left;color:var(--muted);border-radius:10px}.empty-state{border:1px dashed color-mix(in srgb,var(--line) 90%,transparent);background:color-mix(in srgb,var(--surface-2) 30%,transparent)}.error-state{border:1px solid var(--line);background:color-mix(in srgb,var(--surface-2) 18%,var(--surface))}.state-icon{flex:none;width:26px;height:26px;display:grid;place-items:center;border-radius:50%;color:var(--muted);background:color-mix(in srgb,var(--muted) 9%,transparent)}.state-icon-error{color:var(--muted)}.state-copy{flex:1 1 180px;min-width:0;display:flex;flex-wrap:wrap;align-items:center;gap:2px 8px}.state-copy>.state-details{flex:0 1 auto;min-width:0;margin-top:0}.state-copy>.state-details[open]{flex:1 1 auto}.empty-state .empty-title,.error-state .error-title{margin:0;font-weight:600;line-height:1.4}.empty-state .empty-title,.error-state .error-title{color:var(--ink)}.state-action{flex:none;margin-left:auto;display:flex;flex-wrap:wrap;align-items:center;gap:6px}.state-details{margin-top:3px}.state-details>summary{display:inline-flex;align-items:center;gap:4px;color:var(--muted);font-size:12px;line-height:1.4;cursor:pointer;list-style:none}.state-details>summary::-webkit-details-marker{display:none}.state-details>summary:before{content:"›";display:inline-block;transition:transform .12s ease}.state-details[open]>summary:before{transform:rotate(90deg)}.state-details>p{margin:5px 0 0;max-width:62ch;font-size:12.5px;line-height:1.55;overflow-wrap:anywhere}.state-details ul{margin:6px 0 0;padding-left:18px;font-size:12.5px;line-height:1.55}.state-copy .state-short{margin:0;font-size:12.5px;line-height:1.45}.state-short{color:var(--muted);font-size:12px;line-height:1.45;overflow-wrap:anywhere}.state-inline{display:flex;flex-wrap:wrap;align-items:center;gap:4px 10px;margin-top:8px}.state-inline .state-details{margin-top:0}.skeleton{border-radius:var(--radius-s);background:linear-gradient(90deg,var(--surface-2) 25%,color-mix(in srgb,var(--surface-2) 60%,var(--surface)) 50%,var(--surface-2) 75%);background-size:200% 100%;animation:skeleton-sweep 1.4s infinite;min-height:16px}@keyframes skeleton-sweep{0%{background-position:200% 0}to{background-position:-200% 0}}.page{display:flex;flex-direction:column;gap:24px}.page-header{display:flex;align-items:center;gap:10px 16px;flex-wrap:wrap}.page-title{margin:0;font-size:32px;font-weight:600;letter-spacing:-.025em;line-height:1.25}.page-subtitle{margin:-12px 0 0;color:var(--text-secondary);font-size:16px;line-height:1.5;max-width:72ch}.page-header-actions{display:flex;align-items:center;gap:8px 12px;flex-wrap:wrap;margin-left:auto}.page-header-actions .segmented{max-width:100%}.grid-2{display:grid;grid-template-columns:1fr 1fr;gap:18px}.section-stack{display:flex;flex-direction:column;gap:16px}.table-wrap{overflow-x:auto;border:1px solid var(--line);border-radius:10px;background:var(--surface)}table.data-table{width:100%;border-collapse:collapse;font-size:13px}.data-table th,.data-table td{padding:10px 14px;text-align:left;border-bottom:1px solid var(--soft-line, var(--line));vertical-align:middle}.data-table thead th{position:sticky;top:0;background:color-mix(in srgb,var(--surface-2) 55%,var(--surface));color:var(--muted);font-weight:600;font-size:12px;letter-spacing:.01em;white-space:nowrap;z-index:1;border-bottom:1px solid var(--line)}.data-table tbody tr{transition:background-color .1s ease}.data-table tbody tr:hover{background:color-mix(in srgb,var(--accent) 4%,var(--surface))}.data-table tbody tr:last-child td{border-bottom:none}.table-sort{border:0;padding:0;background:none;color:inherit;font:inherit;cursor:pointer;text-align:inherit}.table-sort{min-height:24px}.data-table th.sortable{cursor:pointer;-webkit-user-select:none;user-select:none}.data-table th.sortable:hover{color:var(--ink)}.data-table td.num,.data-table th.num{text-align:right;font-variant-numeric:tabular-nums}.card-details{margin-top:6px;font-size:12px;color:var(--muted)}.card-details>summary{cursor:pointer}.card-details p{margin:4px 0 0}.account-facts-notes{margin-top:4px;font-size:12px;color:var(--muted)}.account-facts-notes summary{cursor:pointer}@media(max-width:768px){.data-table th,.data-table td{white-space:normal;overflow-wrap:anywhere}}.tabs{display:flex;gap:2px;border-bottom:1px solid var(--line);flex-wrap:wrap;overflow-x:auto;scrollbar-width:none}.tabs::-webkit-scrollbar{display:none}.tab{min-height:44px;padding:11px 14px;color:var(--text-secondary);border-bottom:2px solid transparent;margin-bottom:-1px;font-size:14px;font-weight:500;white-space:nowrap}.tab:hover{color:var(--text-primary)}.tab.active{color:var(--accent-foreground);border-bottom-color:var(--accent-foreground);font-weight:600}.segmented{display:inline-flex;background:var(--surface-2);border-radius:8px;padding:3px;gap:2px;flex-wrap:wrap}.segmented .segment{min-height:28px;padding:4px 11px;border-radius:6px;color:var(--muted);display:flex;flex-direction:column;align-items:center;justify-content:center;line-height:1.3;transition:background-color .1s ease,color .1s ease}.segmented .segment:hover:not(.active){color:var(--ink)}.segmented .segment .segment-sub{font-size:12px;font-variant-numeric:tabular-nums}.segmented .segment.active{background:var(--surface);color:var(--ink);font-weight:600;box-shadow:0 1px 3px #0f172a1a}.field{display:flex;flex-direction:column;gap:5px;margin-bottom:12px}.field>span{font-size:12px;color:var(--muted)}.input,select.input{min-height:40px;padding:9px 12px;border:1px solid var(--border-control);border-radius:var(--radius-s);background:var(--surface-default);color:var(--text-primary);font:inherit;width:100%}.input:hover,select.input:hover{border-color:var(--accent-foreground)}.input:focus{outline:2px solid var(--focus-ring);outline-offset:0;border-color:transparent}.checkbox-row{display:flex;align-items:flex-start;gap:8px;font-size:13px}.checkbox-row input{margin-top:3px}.dialog-backdrop{position:fixed;inset:0;background:var(--overlay-scrim);display:flex;align-items:center;justify-content:center;padding:16px;z-index:50}.dialog{background:var(--surface-default);border-radius:var(--radius-m);border:1px solid var(--border-divider);box-shadow:var(--shadow);max-width:480px;width:100%;max-height:85vh;overflow:auto;padding:32px}.dialog h2{margin:0 0 8px;font-size:20px;line-height:1.4}.dialog .dialog-target{font-weight:600;margin:0 0 8px}.dialog .dialog-summary{color:var(--muted);margin:0 0 8px}.dialog .dialog-consequence{margin:0 0 12px}.dialog .dialog-consequence.danger{color:var(--danger)}.dialog-actions{display:flex;justify-content:flex-end;gap:8px;margin-top:16px}.toast-stack{position:fixed;bottom:16px;right:16px;display:flex;flex-direction:column;gap:8px;z-index:120;max-width:min(420px,calc(100vw - 32px))}.toast{background:var(--surface);border:1px solid var(--line);border-left:4px solid var(--accent);border-radius:var(--radius-s);box-shadow:var(--shadow);padding:10px 12px;display:flex;gap:8px;align-items:flex-start;font-size:13px}.toast.error{border-left-color:var(--status-error)}.toast.success{border-left-color:var(--status-ok)}.toast button{color:var(--muted);flex:0 0 auto}.diff-affects-live{color:var(--danger);font-weight:600}.timeline{list-style:none;margin:0;padding:0}.timeline li{position:relative;padding:0 0 16px 20px;border-left:2px solid var(--line);margin-left:6px}.timeline li:last-child{padding-bottom:0}.timeline li:before{content:"";position:absolute;left:-6px;top:4px;width:10px;height:10px;border-radius:50%;background:var(--accent)}.timeline .timeline-time{color:var(--muted);font-size:12px}.danger-zone{border:1px solid var(--danger);border-radius:var(--radius-m);padding:16px;display:flex;flex-direction:column;gap:12px}.danger-zone-title{color:var(--danger);font-weight:700;margin:0;font-size:14px}.danger-row{display:flex;align-items:flex-start;justify-content:space-between;gap:16px;flex-wrap:wrap}.danger-row .danger-row-text{flex:1 1 320px}.danger-row .danger-row-text strong{display:block;margin-bottom:2px}.danger-row .danger-row-text p{margin:0;color:var(--muted);font-size:13px}.chart{width:100%}.chart-legend{display:flex;flex-wrap:wrap;gap:8px 16px;margin-top:8px}.chart-legend button{display:inline-flex;align-items:center;gap:6px;color:var(--muted);font-size:12px;padding:2px 4px;border-radius:4px;max-width:100%;min-width:0;white-space:normal;overflow-wrap:anywhere;text-align:left}.chart-legend button:hover{background:var(--surface-2)}.chart-legend button.off{opacity:.4;text-decoration:line-through}.chart-legend .legend-swatch{flex:0 0 14px;width:14px;height:3px;border-radius:2px;display:inline-block}.chart-tooltip{background:var(--surface);border:1px solid var(--line);border-radius:var(--radius-s);box-shadow:var(--shadow);padding:8px 10px;font-size:12px;pointer-events:none;position:absolute;z-index:10;max-width:min(240px,70vw);white-space:normal;overflow-wrap:anywhere}.chart-tooltip .tooltip-date{color:var(--muted);margin-bottom:4px}.chart-tooltip .tooltip-row{display:flex;align-items:center;gap:6px;font-variant-numeric:tabular-nums}.chart-frame{position:relative}.calendar-month-grid{display:grid;grid-template-columns:repeat(7,minmax(36px,1fr));gap:4px}.calendar-cell{min-height:40px;border-radius:var(--radius-s);border:1px solid var(--line);padding:4px 6px;font-size:12px;display:flex;flex-direction:column;gap:2px;background:var(--surface)}.calendar-cell .cell-date{color:var(--muted);font-size:11px}.calendar-cell .cell-value{font-variant-numeric:tabular-nums;font-weight:600}.calendar-cell.cell-empty{border-style:dashed;background:repeating-linear-gradient(135deg,transparent 0 6px,var(--surface-2) 6px 12px)}.calendar-year-grid{display:grid;grid-template-columns:repeat(4,minmax(0,1fr));gap:8px}.calendar-nav{display:flex;align-items:center;justify-content:center;gap:8px}.calendar-nav .current{font-weight:600;min-width:110px;text-align:center}.calendar-weekday{color:var(--muted);font-size:12px;text-align:center}.barlist{display:flex;flex-direction:column;gap:8px}.barlist-row{display:grid;grid-template-columns:90px 1fr 90px;align-items:center;gap:8px;font-size:13px}.barlist-label{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.barlist-track{position:relative;height:14px;background:var(--surface-2);border-radius:4px;overflow:hidden}.barlist-fill{position:absolute;top:0;bottom:0;border-radius:4px}.barlist-value{text-align:right;font-variant-numeric:tabular-nums}.inbox{display:grid;grid-template-columns:minmax(280px,380px) 1fr;gap:16px;align-items:start}.inbox.list-only{grid-template-columns:minmax(0,1fr)}.inbox.list-only .inbox-list{max-width:none}.inbox-list{display:flex;flex-direction:column;gap:8px}.inbox-item{display:flex;gap:10px;align-items:flex-start;padding:10px 12px;background:var(--surface);border:1px solid var(--line);border-radius:var(--radius-m);text-align:left;width:100%}.inbox-item:hover{border-color:var(--accent)}.inbox-item.active{border-color:var(--accent);box-shadow:inset 0 0 0 1px var(--accent)}.priority-dot{width:8px;height:8px;border-radius:50%;margin-top:6px;flex:0 0 auto}.priority-high{background:var(--status-error)}.priority-medium{background:var(--status-warn)}.priority-normal{background:var(--status-unknown)}.inbox-item .item-main{min-width:0;flex:1 1 auto}.inbox-item .item-title{font-weight:600;overflow-wrap:anywhere}.inbox-item .item-meta{color:var(--muted);font-size:12px;display:flex;gap:8px;flex-wrap:wrap}.inbox-detail{position:sticky;top:72px}.inbox-actions{position:sticky;bottom:0;display:flex;gap:8px;padding-top:12px;margin-top:12px;border-top:1px solid var(--line);background:var(--surface);flex-wrap:wrap}.account-grid{display:grid;grid-template-columns:repeat(auto-fit,minmax(260px,1fr));gap:12px}.account-card{background:var(--surface);border:1px solid var(--line);border-radius:var(--radius-m);padding:14px 16px;text-align:left;display:flex;flex-direction:column;gap:6px}.account-card:hover{border-color:var(--accent)}.account-card .account-title{font-weight:700;display:flex;align-items:center;gap:8px}.account-card .account-row{display:flex;justify-content:space-between;gap:8px;font-size:13px}.account-card .account-row span:first-child{color:var(--muted)}.accounts-layout{display:grid;grid-template-columns:minmax(300px,420px) 1fr;gap:16px;align-items:start}.strategy-grid{display:grid;grid-template-columns:repeat(3,minmax(0,1fr));gap:12px}@media(max-width:1000px){.strategy-grid{grid-template-columns:repeat(2,minmax(0,1fr))}}@media(max-width:700px){.account-grid,.strategy-grid{grid-template-columns:minmax(0,1fr)}}.health-grid{max-width:100%;overflow-x:auto;-webkit-overflow-scrolling:touch;overscroll-behavior-x:contain;scrollbar-width:thin;padding-bottom:2px}.health-grid table{width:max-content;min-width:100%;border-collapse:collapse;font-size:12px}.health-grid-hint{display:none;margin:0 0 8px;color:var(--muted);font-size:12px;line-height:1.45}.table-scroll-hint{display:none;margin:0 0 6px;color:var(--muted);font-size:12px;line-height:1.45}.health-grid th,.health-grid td{padding:4px;text-align:center}.health-grid th{color:var(--muted);font-weight:500;white-space:nowrap}.health-cell{width:26px;height:26px;border-radius:4px;display:inline-flex;align-items:center;justify-content:center;border:1px solid var(--line);font-size:11px}.health-cell.ok{background:color-mix(in srgb,var(--status-ok) 20%,transparent);color:var(--status-ok)}.health-cell.failed{background:color-mix(in srgb,var(--status-error) 20%,transparent);color:var(--status-error)}.health-cell.not-run{background:var(--surface-2);color:var(--muted)}.health-cell.no-record{background:repeating-linear-gradient(135deg,transparent 0 4px,var(--surface-2) 4px 8px);color:var(--muted)}.health-cell:hover,.health-cell:focus-visible{outline:2px solid var(--accent)}.health-legend{display:flex;gap:16px;flex-wrap:wrap;font-size:12px;color:var(--muted)}.health-legend span{display:inline-flex;align-items:center;gap:6px}.stat-strip{display:grid;grid-template-columns:repeat(5,minmax(0,1fr));gap:12px}.scope-switcher{position:relative;min-width:0}.scope-trigger{max-width:100%;min-width:0}.scope-trigger-label{min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.scope-panel{position:absolute;top:calc(100% + 4px);left:0;min-width:220px;background:var(--surface);border:1px solid var(--line);border-radius:var(--radius-m);box-shadow:var(--shadow);padding:6px;z-index:50;max-height:320px;overflow:auto}.scope-group{padding:4px 8px;color:var(--muted);font-size:12px}.scope-option{display:flex;align-items:center;gap:8px;width:100%;padding:8px;border-radius:var(--radius-s);text-align:left;min-width:0}.scope-option-label{flex:1 1 auto;min-width:0;white-space:normal;overflow-wrap:anywhere;line-height:1.4}.scope-option .badge{flex:none}.scope-panel-text{flex:1 1 auto;min-width:0;overflow-wrap:anywhere}.scope-option:hover{background:var(--surface-2)}.scope-option.active{color:var(--accent);font-weight:600}.user-menu{position:relative}.user-menu>summary{list-style:none;width:32px;height:32px;border-radius:50%;background:var(--accent);color:var(--on-accent);display:flex;align-items:center;justify-content:center;font-weight:700;cursor:pointer}.user-menu>summary::-webkit-details-marker{display:none}.user-menu-panel{position:absolute;right:0;top:calc(100% + 4px);background:var(--surface);border:1px solid var(--line);border-radius:var(--radius-m);box-shadow:var(--shadow);padding:8px;min-width:200px;z-index:50;display:flex;flex-direction:column;gap:2px}.user-menu-panel .menu-item{display:flex;align-items:center;gap:8px;width:100%;padding:8px;border-radius:var(--radius-s);text-align:left}.user-menu-panel .menu-item:hover{background:var(--surface-2)}.user-menu-name{padding:4px 8px 8px;border-bottom:1px solid var(--line);margin-bottom:4px}.prefs-grid{display:flex;flex-direction:column;gap:16px}.prefs-row{display:flex;align-items:center;justify-content:space-between;gap:16px}.prefs-row>span{font-weight:500}.boot-screen,.access-screen{min-height:100vh;display:flex;flex-direction:column;align-items:center;justify-content:center;gap:12px;text-align:center;padding:24px}.access-screen img{width:48px;height:48px}.access-screen h1{margin:0;font-size:24px}.access-screen p{color:var(--muted);max-width:420px;margin:0}.global-notice{display:flex;align-items:center;gap:12px;justify-content:space-between;padding:8px 16px;background:color-mix(in srgb,var(--status-warn) 12%,var(--surface));border-bottom:1px solid var(--line);font-size:13px}@media(max-width:1024px){.kpi-grid{grid-template-columns:repeat(3,minmax(0,1fr))}.grid-2,.accounts-layout,.inbox{grid-template-columns:1fr}.inbox-detail{position:static}}@media(max-width:1100px){.stat-strip{grid-template-columns:repeat(3,minmax(0,1fr))}}@media(max-width:1180px)and (min-width:769px){.topbar{gap:10px;padding:0 16px}.topnav-item{width:44px;padding:0;justify-content:center}.topnav-label{display:none}}@media(max-width:768px){.stat-strip{grid-template-columns:repeat(2,minmax(0,1fr))}.topnav{display:none}.bottom-tabs{display:block}.content{padding:20px 16px calc(var(--bottom-tabs-height) + 32px + env(safe-area-inset-bottom))}.health-grid-hint,.table-scroll-hint{display:block}.page{gap:16px}.page-header{gap:10px}.page-title{font-size:28px;letter-spacing:-.02em}.page-subtitle{margin-top:-8px;font-size:14px}.page-header-actions{margin-left:auto;justify-content:flex-end}.page-header-actions:has(>.segmented){width:100%;margin-left:0}.page-header-actions>.button{flex:0 0 auto}.page-header-actions>.segmented{width:100%;flex-wrap:nowrap;overflow-x:auto;scrollbar-width:none}.page-header-actions>.segmented::-webkit-scrollbar{display:none}.page-header-actions>.segmented .segment{flex:1 1 auto;justify-content:center;white-space:nowrap}.card{padding:16px}.card-title{font-size:18px;margin-bottom:10px}.kpi-grid{grid-template-columns:repeat(2,minmax(0,1fr))}.kpi-value{font-size:22px}.kpi-card{padding:14px}.topbar-updated{display:none}.topbar{min-height:56px;flex-wrap:nowrap;gap:8px;padding:6px 12px}.topbar .brand img{width:24px;height:24px}.brand-copy{display:none}.topbar .scope-switcher{flex:1 1 auto;min-width:44px}.topbar .spacer,.lang-label-full{display:none}.lang-label-short{display:inline}.topbar .theme-toggle-label{display:none}.topbar .appearance-toggle,.topbar .icon-button,.topbar .user-menu>summary{min-width:44px;min-height:44px}.topbar .scope-trigger{width:100%;min-width:44px;min-height:44px}.scope-panel{width:min(340px,calc(100vw - 24px));max-height:60dvh}.scope-option{min-height:44px}.calendar-year-grid{grid-template-columns:repeat(3,minmax(0,1fr))}.inbox-actions{position:static}.empty-state,.error-state{padding:11px 12px}.state-icon{width:24px;height:24px}.data-table th,.data-table td{padding:9px 11px}}@media(max-width:430px){.topbar:has(>.scope-switcher):has(>.topbar-synthetic){flex-wrap:wrap}.topbar:has(>.scope-switcher):has(>.topbar-synthetic)>.topbar-synthetic{order:10;flex:1 1 100%;display:flex;justify-content:center}}.update-notice{display:flex;flex-wrap:wrap;align-items:center;justify-content:space-between;gap:8px;padding:12px 20px;background:var(--surface-2)}@media(prefers-reduced-motion:reduce){*,*:before,*:after{animation-duration:.01ms!important;animation-iteration-count:1!important;transition-duration:.01ms!important}}.appearance-toggle{flex:0 0 auto;white-space:nowrap}.account-platform-group+.account-platform-group{margin-top:20px}.account-platform-title{margin:0 0 10px;font-size:16px}.account-strategy-link{display:flex;flex-direction:column;text-align:left;width:100%;gap:6px;padding:10px 8px;margin:0 -8px;border-radius:8px;transition:background-color .12s ease}.account-strategy-link+.account-strategy-link{border-top:1px solid var(--line)}.account-strategy-link:hover .account-strategy-name{color:var(--accent);text-decoration:underline}.account-strategy-link:hover,.account-strategy-link:focus-visible{background:color-mix(in srgb,var(--accent) 6%,transparent)}.account-strategy-head{display:flex;align-items:center;justify-content:space-between;gap:8px;min-width:0}.account-strategy-chevron{flex:0 0 auto;color:var(--muted);font-size:16px;line-height:1;transition:color .12s ease,transform .12s ease}.account-strategy-link:hover .account-strategy-chevron,.account-strategy-link:focus-visible .account-strategy-chevron{color:var(--accent);transform:translate(2px)}.account-strategy-name{font-weight:600;overflow-wrap:anywhere}.account-broker-title{margin:0 0 8px;font-size:15px;overflow-wrap:anywhere}.account-identity-note{color:var(--muted);font-size:12px}@media(max-width:768px){.topbar{gap:8px;padding-inline:12px}.topbar .scope-switcher{min-width:44px}.scope-switcher>button{max-width:100%;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.account-strategy-link{min-height:44px}}.account-group-card .account-row{display:flex;justify-content:space-between;gap:12px;font-size:13px}.account-group-card .account-row>span:first-child{color:var(--muted)}.account-strategy-link>.badge{align-self:flex-start}.calendar-cell.cell-future{border-style:solid;background:color-mix(in srgb,var(--surface-2) 55%,var(--surface))}.calendar-cell.cell-closed{border-style:solid;background:var(--surface-2)}.calendar-cell.cell-pending{position:relative;border-style:solid;border-color:color-mix(in srgb,var(--accent) 45%,var(--line));background:var(--surface)}.calendar-cell.cell-pending:after{content:"";position:absolute;top:5px;right:5px;width:5px;height:5px;border-radius:50%;background:var(--accent);opacity:.65}
" },
+  "/v2/assets/index-CwQsWZdm.js": { contentType: "text/javascript; charset=utf-8", base64: "const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["assets/OverviewPage-CGYvI0GD.js","assets/inboxFailure-B9PDJ1HN.js","assets/cashflowMethod-BoxXysdG.js","assets/cashflowMethod-Gm8aPj9t.css","assets/hooks-9usXmJc_.js","assets/status-DxL8ZWrC.js","assets/cockpit-Cax-GxP0.js","assets/cockpit-Lo-aJH0Q.css","assets/runtime_daily_contract-xW43mZQY.js","assets/KpiCard-DmeG7oeQ.js","assets/OverviewPage-CDp0o79F.css","assets/PerformancePage-B3t2Ex7X.js","assets/DataTable-CNz0DyJ6.js","assets/Tabs-BP4xZNhq.js","assets/PerformancePage-BMNSw_qo.css","assets/DecisionsPage-SP8nEoQr.js","assets/Dialog-Nx1EjiqV.js","assets/DecisionsPage-CyeuTPhn.css","assets/AccountsPage-BFP5IP6M.js","assets/ExecutionEvidence-CDki-xbb.js","assets/AccountsPage-CaB9EVDF.css","assets/StrategiesPage-DUHVXLhP.js","assets/StrategiesPage-CeZkxG_N.css","assets/HealthPage-BqIJ5fp5.js","assets/HealthPage-DWOwvlJZ.css"])))=>i.map(i=>d[i]);
(function(){const s=document.createElement("link").relList;if(s&&s.supports&&s.supports("modulepreload"))return;for(const w of document.querySelectorAll('link[rel="modulepreload"]'))r(w);new MutationObserver(w=>{for(const z of w)if(z.type==="childList")for(const U of z.addedNodes)U.tagName==="LINK"&&U.rel==="modulepreload"&&r(U)}).observe(document,{childList:!0,subtree:!0});function p(w){const z={};return w.integrity&&(z.integrity=w.integrity),w.referrerPolicy&&(z.referrerPolicy=w.referrerPolicy),w.crossOrigin==="use-credentials"?z.credentials="include":w.crossOrigin==="anonymous"?z.credentials="omit":z.credentials="same-origin",z}function r(w){if(w.ep)return;w.ep=!0;const z=p(w);fetch(w.href,z)}})();var mu={exports:{}},xl={};var Ad;function jm(){if(Ad)return xl;Ad=1;var o=Symbol.for("react.transitional.element"),s=Symbol.for("react.fragment");function p(r,w,z){var U=null;if(z!==void 0&&(U=""+z),w.key!==void 0&&(U=""+w.key),"key"in w){z={};for(var O in w)O!=="key"&&(z[O]=w[O])}else z=w;return w=z.ref,{$$typeof:o,type:r,key:U,ref:w!==void 0?w:null,props:z}}return xl.Fragment=s,xl.jsx=p,xl.jsxs=p,xl}var zd;function Hm(){return zd||(zd=1,mu.exports=jm()),mu.exports}var m=Hm(),_u={exports:{}},wl={},vu={exports:{}},gu={};var Rd;function Bm(){return Rd||(Rd=1,(function(o){function s(T,q){var Y=T.length;T.push(q);e:for(;0<Y;){var oe=Y-1>>>1,d=T[oe];if(0<w(d,q))T[oe]=q,T[Y]=d,Y=oe;else break e}}function p(T){return T.length===0?null:T[0]}function r(T){if(T.length===0)return null;var q=T[0],Y=T.pop();if(Y!==q){T[0]=Y;e:for(var oe=0,d=T.length,x=d>>>1;oe<x;){var D=2*(oe+1)-1,M=T[D],j=D+1,W=T[j];if(0>w(M,Y))j<d&&0>w(W,M)?(T[oe]=W,T[j]=Y,oe=j):(T[oe]=M,T[D]=Y,oe=D);else if(j<d&&0>w(W,Y))T[oe]=W,T[j]=Y,oe=j;else break e}}return q}function w(T,q){var Y=T.sortIndex-q.sortIndex;return Y!==0?Y:T.id-q.id}if(o.unstable_now=void 0,typeof performance=="object"&&typeof performance.now=="function"){var z=performance;o.unstable_now=function(){return z.now()}}else{var U=Date,O=U.now();o.unstable_now=function(){return U.now()-O}}var g=[],k=[],N=1,L=null,V=3,ve=!1,ie=!1,me=!1,Se=!1,Ze=typeof setTimeout=="function"?setTimeout:null,Ne=typeof clearTimeout=="function"?clearTimeout:null,ce=typeof setImmediate<"u"?setImmediate:null;function qe(T){for(var q=p(k);q!==null;){if(q.callback===null)r(k);else if(q.startTime<=T)r(k),q.sortIndex=q.expirationTime,s(g,q);else break;q=p(k)}}function $(T){if(me=!1,qe(T),!ie)if(p(g)!==null)ie=!0,K||(K=!0,we());else{var q=p(k);q!==null&&je($,q.startTime-T)}}var K=!1,_e=-1,ge=5,Ce=-1;function le(){return Se?!0:!(o.unstable_now()-Ce<ge)}function Ae(){if(Se=!1,K){var T=o.unstable_now();Ce=T;var q=!0;try{e:{ie=!1,me&&(me=!1,Ne(_e),_e=-1),ve=!0;var Y=V;try{t:{for(qe(T),L=p(g);L!==null&&!(L.expirationTime>T&&le());){var oe=L.callback;if(typeof oe=="function"){L.callback=null,V=L.priorityLevel;var d=oe(L.expirationTime<=T);if(T=o.unstable_now(),typeof d=="function"){L.callback=d,qe(T),q=!0;break t}L===p(g)&&r(g),qe(T)}else r(g);L=p(g)}if(L!==null)q=!0;else{var x=p(k);x!==null&&je($,x.startTime-T),q=!1}}break e}finally{L=null,V=Y,ve=!1}q=void 0}}finally{q?we():K=!1}}}var we;if(typeof ce=="function")we=function(){ce(Ae)};else if(typeof MessageChannel<"u"){var at=new MessageChannel,nt=at.port2;at.port1.onmessage=Ae,we=function(){nt.postMessage(null)}}else we=function(){Ze(Ae,0)};function je(T,q){_e=Ze(function(){T(o.unstable_now())},q)}o.unstable_IdlePriority=5,o.unstable_ImmediatePriority=1,o.unstable_LowPriority=4,o.unstable_NormalPriority=3,o.unstable_Profiling=null,o.unstable_UserBlockingPriority=2,o.unstable_cancelCallback=function(T){T.callback=null},o.unstable_forceFrameRate=function(T){0>T||125<T?console.error("forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported"):ge=0<T?Math.floor(1e3/T):5},o.unstable_getCurrentPriorityLevel=function(){return V},o.unstable_next=function(T){switch(V){case 1:case 2:case 3:var q=3;break;default:q=V}var Y=V;V=q;try{return T()}finally{V=Y}},o.unstable_requestPaint=function(){Se=!0},o.unstable_runWithPriority=function(T,q){switch(T){case 1:case 2:case 3:case 4:case 5:break;default:T=3}var Y=V;V=T;try{return q()}finally{V=Y}},o.unstable_scheduleCallback=function(T,q,Y){var oe=o.unstable_now();switch(typeof Y=="object"&&Y!==null?(Y=Y.delay,Y=typeof Y=="number"&&0<Y?oe+Y:oe):Y=oe,T){case 1:var d=-1;break;case 2:d=250;break;case 5:d=1073741823;break;case 4:d=1e4;break;default:d=5e3}return d=Y+d,T={id:N++,callback:q,priorityLevel:T,startTime:Y,expirationTime:d,sortIndex:-1},Y>oe?(T.sortIndex=Y,s(k,T),p(g)===null&&T===p(k)&&(me?(Ne(_e),_e=-1):me=!0,je($,Y-oe))):(T.sortIndex=d,s(g,T),ie||ve||(ie=!0,K||(K=!0,we()))),T},o.unstable_shouldYield=le,o.unstable_wrapCallback=function(T){var q=V;return function(){var Y=V;V=q;try{return T.apply(this,arguments)}finally{V=Y}}}})(gu)),gu}var Nd;function Lm(){return Nd||(Nd=1,vu.exports=Bm()),vu.exports}var yu={exports:{}},J={};var Dd;function Ym(){if(Dd)return J;Dd=1;var o=Symbol.for("react.transitional.element"),s=Symbol.for("react.portal"),p=Symbol.for("react.fragment"),r=Symbol.for("react.strict_mode"),w=Symbol.for("react.profiler"),z=Symbol.for("react.consumer"),U=Symbol.for("react.context"),O=Symbol.for("react.forward_ref"),g=Symbol.for("react.suspense"),k=Symbol.for("react.memo"),N=Symbol.for("react.lazy"),L=Symbol.iterator;function V(d){return d===null||typeof d!="object"?null:(d=L&&d[L]||d["@@iterator"],typeof d=="function"?d:null)}var ve={isMounted:function(){return!1},enqueueForceUpdate:function(){},enqueueReplaceState:function(){},enqueueSetState:function(){}},ie=Object.assign,me={};function Se(d,x,D){this.props=d,this.context=x,this.refs=me,this.updater=D||ve}Se.prototype.isReactComponent={},Se.prototype.setState=function(d,x){if(typeof d!="object"&&typeof d!="function"&&d!=null)throw Error("takes an object of state variables to update or a function which returns an object of state variables.");this.updater.enqueueSetState(this,d,x,"setState")},Se.prototype.forceUpdate=function(d){this.updater.enqueueForceUpdate(this,d,"forceUpdate")};function Ze(){}Ze.prototype=Se.prototype;function Ne(d,x,D){this.props=d,this.context=x,this.refs=me,this.updater=D||ve}var ce=Ne.prototype=new Ze;ce.constructor=Ne,ie(ce,Se.prototype),ce.isPureReactComponent=!0;var qe=Array.isArray,$={H:null,A:null,T:null,S:null,V:null},K=Object.prototype.hasOwnProperty;function _e(d,x,D,M,j,W){return D=W.ref,{$$typeof:o,type:d,key:x,ref:D!==void 0?D:null,props:W}}function ge(d,x){return _e(d.type,x,void 0,void 0,void 0,d.props)}function Ce(d){return typeof d=="object"&&d!==null&&d.$$typeof===o}function le(d){var x={"=":"=0",":":"=2"};return"$"+d.replace(/[=:]/g,function(D){return x[D]})}var Ae=/\/+/g;function we(d,x){return typeof d=="object"&&d!==null&&d.key!=null?le(""+d.key):x.toString(36)}function at(){}function nt(d){switch(d.status){case"fulfilled":return d.value;case"rejected":throw d.reason;default:switch(typeof d.status=="string"?d.then(at,at):(d.status="pending",d.then(function(x){d.status==="pending"&&(d.status="fulfilled",d.value=x)},function(x){d.status==="pending"&&(d.status="rejected",d.reason=x)})),d.status){case"fulfilled":return d.value;case"rejected":throw d.reason}}throw d}function je(d,x,D,M,j){var W=typeof d;(W==="undefined"||W==="boolean")&&(d=null);var Z=!1;if(d===null)Z=!0;else switch(W){case"bigint":case"string":case"number":Z=!0;break;case"object":switch(d.$$typeof){case o:case s:Z=!0;break;case N:return Z=d._init,je(Z(d._payload),x,D,M,j)}}if(Z)return j=j(d),Z=M===""?"."+we(d,0):M,qe(j)?(D="",Z!=null&&(D=Z.replace(Ae,"$&/")+"/"),je(j,x,D,"",function(Jt){return Jt})):j!=null&&(Ce(j)&&(j=ge(j,D+(j.key==null||d&&d.key===j.key?"":(""+j.key).replace(Ae,"$&/")+"/")+Z)),x.push(j)),1;Z=0;var lt=M===""?".":M+":";if(qe(d))for(var ye=0;ye<d.length;ye++)M=d[ye],W=lt+we(M,ye),Z+=je(M,x,D,W,j);else if(ye=V(d),typeof ye=="function")for(d=ye.call(d),ye=0;!(M=d.next()).done;)M=M.value,W=lt+we(M,ye++),Z+=je(M,x,D,W,j);else if(W==="object"){if(typeof d.then=="function")return je(nt(d),x,D,M,j);throw x=String(d),Error("Objects are not valid as a React child (found: "+(x==="[object Object]"?"object with keys {"+Object.keys(d).join(", ")+"}":x)+"). If you meant to render a collection of children, use an array instead.")}return Z}function T(d,x,D){if(d==null)return d;var M=[],j=0;return je(d,M,"","",function(W){return x.call(D,W,j++)}),M}function q(d){if(d._status===-1){var x=d._result;x=x(),x.then(function(D){(d._status===0||d._status===-1)&&(d._status=1,d._result=D)},function(D){(d._status===0||d._status===-1)&&(d._status=2,d._result=D)}),d._status===-1&&(d._status=0,d._result=x)}if(d._status===1)return d._result.default;throw d._result}var Y=typeof reportError=="function"?reportError:function(d){if(typeof window=="object"&&typeof window.ErrorEvent=="function"){var x=new window.ErrorEvent("error",{bubbles:!0,cancelable:!0,message:typeof d=="object"&&d!==null&&typeof d.message=="string"?String(d.message):String(d),error:d});if(!window.dispatchEvent(x))return}else if(typeof process=="object"&&typeof process.emit=="function"){process.emit("uncaughtException",d);return}console.error(d)};function oe(){}return J.Children={map:T,forEach:function(d,x,D){T(d,function(){x.apply(this,arguments)},D)},count:function(d){var x=0;return T(d,function(){x++}),x},toArray:function(d){return T(d,function(x){return x})||[]},only:function(d){if(!Ce(d))throw Error("React.Children.only expected to receive a single React element child.");return d}},J.Component=Se,J.Fragment=p,J.Profiler=w,J.PureComponent=Ne,J.StrictMode=r,J.Suspense=g,J.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE=$,J.__COMPILER_RUNTIME={__proto__:null,c:function(d){return $.H.useMemoCache(d)}},J.cache=function(d){return function(){return d.apply(null,arguments)}},J.cloneElement=function(d,x,D){if(d==null)throw Error("The argument must be a React element, but you passed "+d+".");var M=ie({},d.props),j=d.key,W=void 0;if(x!=null)for(Z in x.ref!==void 0&&(W=void 0),x.key!==void 0&&(j=""+x.key),x)!K.call(x,Z)||Z==="key"||Z==="__self"||Z==="__source"||Z==="ref"&&x.ref===void 0||(M[Z]=x[Z]);var Z=arguments.length-2;if(Z===1)M.children=D;else if(1<Z){for(var lt=Array(Z),ye=0;ye<Z;ye++)lt[ye]=arguments[ye+2];M.children=lt}return _e(d.type,j,void 0,void 0,W,M)},J.createContext=function(d){return d={$$typeof:U,_currentValue:d,_currentValue2:d,_threadCount:0,Provider:null,Consumer:null},d.Provider=d,d.Consumer={$$typeof:z,_context:d},d},J.createElement=function(d,x,D){var M,j={},W=null;if(x!=null)for(M in x.key!==void 0&&(W=""+x.key),x)K.call(x,M)&&M!=="key"&&M!=="__self"&&M!=="__source"&&(j[M]=x[M]);var Z=arguments.length-2;if(Z===1)j.children=D;else if(1<Z){for(var lt=Array(Z),ye=0;ye<Z;ye++)lt[ye]=arguments[ye+2];j.children=lt}if(d&&d.defaultProps)for(M in Z=d.defaultProps,Z)j[M]===void 0&&(j[M]=Z[M]);return _e(d,W,void 0,void 0,null,j)},J.createRef=function(){return{current:null}},J.forwardRef=function(d){return{$$typeof:O,render:d}},J.isValidElement=Ce,J.lazy=function(d){return{$$typeof:N,_payload:{_status:-1,_result:d},_init:q}},J.memo=function(d,x){return{$$typeof:k,type:d,compare:x===void 0?null:x}},J.startTransition=function(d){var x=$.T,D={};$.T=D;try{var M=d(),j=$.S;j!==null&&j(D,M),typeof M=="object"&&M!==null&&typeof M.then=="function"&&M.then(oe,Y)}catch(W){Y(W)}finally{$.T=x}},J.unstable_useCacheRefresh=function(){return $.H.useCacheRefresh()},J.use=function(d){return $.H.use(d)},J.useActionState=function(d,x,D){return $.H.useActionState(d,x,D)},J.useCallback=function(d,x){return $.H.useCallback(d,x)},J.useContext=function(d){return $.H.useContext(d)},J.useDebugValue=function(){},J.useDeferredValue=function(d,x){return $.H.useDeferredValue(d,x)},J.useEffect=function(d,x,D){var M=$.H;if(typeof D=="function")throw Error("useEffect CRUD overload is not enabled in this build of React.");return M.useEffect(d,x)},J.useId=function(){return $.H.useId()},J.useImperativeHandle=function(d,x,D){return $.H.useImperativeHandle(d,x,D)},J.useInsertionEffect=function(d,x){return $.H.useInsertionEffect(d,x)},J.useLayoutEffect=function(d,x){return $.H.useLayoutEffect(d,x)},J.useMemo=function(d,x){return $.H.useMemo(d,x)},J.useOptimistic=function(d,x){return $.H.useOptimistic(d,x)},J.useReducer=function(d,x,D){return $.H.useReducer(d,x,D)},J.useRef=function(d){return $.H.useRef(d)},J.useState=function(d){return $.H.useState(d)},J.useSyncExternalStore=function(d,x,D){return $.H.useSyncExternalStore(d,x,D)},J.useTransition=function(){return $.H.useTransition()},J.version="19.1.1",J}var Md;function Au(){return Md||(Md=1,yu.exports=Ym()),yu.exports}var bu={exports:{}},Je={};var Od;function Gm(){if(Od)return Je;Od=1;var o=Au();function s(g){var k="https://react.dev/errors/"+g;if(1<arguments.length){k+="?args[]="+encodeURIComponent(arguments[1]);for(var N=2;N<arguments.length;N++)k+="&args[]="+encodeURIComponent(arguments[N])}return"Minified React error #"+g+"; visit "+k+" for the full message or use the non-minified dev environment for full errors and additional helpful warnings."}function p(){}var r={d:{f:p,r:function(){throw Error(s(522))},D:p,C:p,L:p,m:p,X:p,S:p,M:p},p:0,findDOMNode:null},w=Symbol.for("react.portal");function z(g,k,N){var L=3<arguments.length&&arguments[3]!==void 0?arguments[3]:null;return{$$typeof:w,key:L==null?null:""+L,children:g,containerInfo:k,implementation:N}}var U=o.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE;function O(g,k){if(g==="font")return"";if(typeof k=="string")return k==="use-credentials"?k:""}return Je.__DOM_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE=r,Je.createPortal=function(g,k){var N=2<arguments.length&&arguments[2]!==void 0?arguments[2]:null;if(!k||k.nodeType!==1&&k.nodeType!==9&&k.nodeType!==11)throw Error(s(299));return z(g,k,null,N)},Je.flushSync=function(g){var k=U.T,N=r.p;try{if(U.T=null,r.p=2,g)return g()}finally{U.T=k,r.p=N,r.d.f()}},Je.preconnect=function(g,k){typeof g=="string"&&(k?(k=k.crossOrigin,k=typeof k=="string"?k==="use-credentials"?k:"":void 0):k=null,r.d.C(g,k))},Je.prefetchDNS=function(g){typeof g=="string"&&r.d.D(g)},Je.preinit=function(g,k){if(typeof g=="string"&&k&&typeof k.as=="string"){var N=k.as,L=O(N,k.crossOrigin),V=typeof k.integrity=="string"?k.integrity:void 0,ve=typeof k.fetchPriority=="string"?k.fetchPriority:void 0;N==="style"?r.d.S(g,typeof k.precedence=="string"?k.precedence:void 0,{crossOrigin:L,integrity:V,fetchPriority:ve}):N==="script"&&r.d.X(g,{crossOrigin:L,integrity:V,fetchPriority:ve,nonce:typeof k.nonce=="string"?k.nonce:void 0})}},Je.preinitModule=function(g,k){if(typeof g=="string")if(typeof k=="object"&&k!==null){if(k.as==null||k.as==="script"){var N=O(k.as,k.crossOrigin);r.d.M(g,{crossOrigin:N,integrity:typeof k.integrity=="string"?k.integrity:void 0,nonce:typeof k.nonce=="string"?k.nonce:void 0})}}else k==null&&r.d.M(g)},Je.preload=function(g,k){if(typeof g=="string"&&typeof k=="object"&&k!==null&&typeof k.as=="string"){var N=k.as,L=O(N,k.crossOrigin);r.d.L(g,N,{crossOrigin:L,integrity:typeof k.integrity=="string"?k.integrity:void 0,nonce:typeof k.nonce=="string"?k.nonce:void 0,type:typeof k.type=="string"?k.type:void 0,fetchPriority:typeof k.fetchPriority=="string"?k.fetchPriority:void 0,referrerPolicy:typeof k.referrerPolicy=="string"?k.referrerPolicy:void 0,imageSrcSet:typeof k.imageSrcSet=="string"?k.imageSrcSet:void 0,imageSizes:typeof k.imageSizes=="string"?k.imageSizes:void 0,media:typeof k.media=="string"?k.media:void 0})}},Je.preloadModule=function(g,k){if(typeof g=="string")if(k){var N=O(k.as,k.crossOrigin);r.d.m(g,{as:typeof k.as=="string"&&k.as!=="script"?k.as:void 0,crossOrigin:N,integrity:typeof k.integrity=="string"?k.integrity:void 0})}else r.d.m(g)},Je.requestFormReset=function(g){r.d.r(g)},Je.unstable_batchedUpdates=function(g,k){return g(k)},Je.useFormState=function(g,k,N){return U.H.useFormState(g,k,N)},Je.useFormStatus=function(){return U.H.useHostTransitionStatus()},Je.version="19.1.1",Je}var Ud;function Qm(){if(Ud)return bu.exports;Ud=1;function o(){if(!(typeof __REACT_DEVTOOLS_GLOBAL_HOOK__>"u"||typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE!="function"))try{__REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE(o)}catch(s){console.error(s)}}return o(),bu.exports=Gm(),bu.exports}var qd;function Xm(){if(qd)return wl;qd=1;var o=Lm(),s=Au(),p=Qm();function r(e){var t="https://react.dev/errors/"+e;if(1<arguments.length){t+="?args[]="+encodeURIComponent(arguments[1]);for(var a=2;a<arguments.length;a++)t+="&args[]="+encodeURIComponent(arguments[a])}return"Minified React error #"+e+"; visit "+t+" for the full message or use the non-minified dev environment for full errors and additional helpful warnings."}function w(e){return!(!e||e.nodeType!==1&&e.nodeType!==9&&e.nodeType!==11)}function z(e){var t=e,a=e;if(e.alternate)for(;t.return;)t=t.return;else{e=t;do t=e,(t.flags&4098)!==0&&(a=t.return),e=t.return;while(e)}return t.tag===3?a:null}function U(e){if(e.tag===13){var t=e.memoizedState;if(t===null&&(e=e.alternate,e!==null&&(t=e.memoizedState)),t!==null)return t.dehydrated}return null}function O(e){if(z(e)!==e)throw Error(r(188))}function g(e){var t=e.alternate;if(!t){if(t=z(e),t===null)throw Error(r(188));return t!==e?null:e}for(var a=e,n=t;;){var l=a.return;if(l===null)break;var i=l.alternate;if(i===null){if(n=l.return,n!==null){a=n;continue}break}if(l.child===i.child){for(i=l.child;i;){if(i===a)return O(l),e;if(i===n)return O(l),t;i=i.sibling}throw Error(r(188))}if(a.return!==n.return)a=l,n=i;else{for(var c=!1,u=l.child;u;){if(u===a){c=!0,a=l,n=i;break}if(u===n){c=!0,n=l,a=i;break}u=u.sibling}if(!c){for(u=i.child;u;){if(u===a){c=!0,a=i,n=l;break}if(u===n){c=!0,n=i,a=l;break}u=u.sibling}if(!c)throw Error(r(189))}}if(a.alternate!==n)throw Error(r(190))}if(a.tag!==3)throw Error(r(188));return a.stateNode.current===a?e:t}function k(e){var t=e.tag;if(t===5||t===26||t===27||t===6)return e;for(e=e.child;e!==null;){if(t=k(e),t!==null)return t;e=e.sibling}return null}var N=Object.assign,L=Symbol.for("react.element"),V=Symbol.for("react.transitional.element"),ve=Symbol.for("react.portal"),ie=Symbol.for("react.fragment"),me=Symbol.for("react.strict_mode"),Se=Symbol.for("react.profiler"),Ze=Symbol.for("react.provider"),Ne=Symbol.for("react.consumer"),ce=Symbol.for("react.context"),qe=Symbol.for("react.forward_ref"),$=Symbol.for("react.suspense"),K=Symbol.for("react.suspense_list"),_e=Symbol.for("react.memo"),ge=Symbol.for("react.lazy"),Ce=Symbol.for("react.activity"),le=Symbol.for("react.memo_cache_sentinel"),Ae=Symbol.iterator;function we(e){return e===null||typeof e!="object"?null:(e=Ae&&e[Ae]||e["@@iterator"],typeof e=="function"?e:null)}var at=Symbol.for("react.client.reference");function nt(e){if(e==null)return null;if(typeof e=="function")return e.$$typeof===at?null:e.displayName||e.name||null;if(typeof e=="string")return e;switch(e){case ie:return"Fragment";case Se:return"Profiler";case me:return"StrictMode";case $:return"Suspense";case K:return"SuspenseList";case Ce:return"Activity"}if(typeof e=="object")switch(e.$$typeof){case ve:return"Portal";case ce:return(e.displayName||"Context")+".Provider";case Ne:return(e._context.displayName||"Context")+".Consumer";case qe:var t=e.render;return e=e.displayName,e||(e=t.displayName||t.name||"",e=e!==""?"ForwardRef("+e+")":"ForwardRef"),e;case _e:return t=e.displayName||null,t!==null?t:nt(e.type)||"Memo";case ge:t=e._payload,e=e._init;try{return nt(e(t))}catch{}}return null}var je=Array.isArray,T=s.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE,q=p.__DOM_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE,Y={pending:!1,data:null,method:null,action:null},oe=[],d=-1;function x(e){return{current:e}}function D(e){0>d||(e.current=oe[d],oe[d]=null,d--)}function M(e,t){d++,oe[d]=e.current,e.current=t}var j=x(null),W=x(null),Z=x(null),lt=x(null);function ye(e,t){switch(M(Z,t),M(W,e),M(j,null),t.nodeType){case 9:case 11:e=(e=t.documentElement)&&(e=e.namespaceURI)?td(e):0;break;default:if(e=t.tagName,t=t.namespaceURI)t=td(t),e=ad(t,e);else switch(e){case"svg":e=1;break;case"math":e=2;break;default:e=0}}D(j),M(j,e)}function Jt(){D(j),D(W),D(Z)}function Ii(e){e.memoizedState!==null&&M(lt,e);var t=j.current,a=ad(t,e.type);t!==a&&(M(W,e),M(j,a))}function Nl(e){W.current===e&&(D(j),D(W)),lt.current===e&&(D(lt),gl._currentValue=Y)}var ec=Object.prototype.hasOwnProperty,tc=o.unstable_scheduleCallback,ac=o.unstable_cancelCallback,mp=o.unstable_shouldYield,_p=o.unstable_requestPaint,Et=o.unstable_now,vp=o.unstable_getCurrentPriorityLevel,Uu=o.unstable_ImmediatePriority,qu=o.unstable_UserBlockingPriority,Dl=o.unstable_NormalPriority,gp=o.unstable_LowPriority,Cu=o.unstable_IdlePriority,yp=o.log,bp=o.unstable_setDisableYieldValue,En=null,it=null;function $t(e){if(typeof yp=="function"&&bp(e),it&&typeof it.setStrictMode=="function")try{it.setStrictMode(En,e)}catch{}}var ct=Math.clz32?Math.clz32:xp,Sp=Math.log,kp=Math.LN2;function xp(e){return e>>>=0,e===0?32:31-(Sp(e)/kp|0)|0}var Ml=256,Ol=4194304;function ya(e){var t=e&42;if(t!==0)return t;switch(e&-e){case 1:return 1;case 2:return 2;case 4:return 4;case 8:return 8;case 16:return 16;case 32:return 32;case 64:return 64;case 128:return 128;case 256:case 512:case 1024:case 2048:case 4096:case 8192:case 16384:case 32768:case 65536:case 131072:case 262144:case 524288:case 1048576:case 2097152:return e&4194048;case 4194304:case 8388608:case 16777216:case 33554432:return e&62914560;case 67108864:return 67108864;case 134217728:return 134217728;case 268435456:return 268435456;case 536870912:return 536870912;case 1073741824:return 0;default:return e}}function Ul(e,t,a){var n=e.pendingLanes;if(n===0)return 0;var l=0,i=e.suspendedLanes,c=e.pingedLanes;e=e.warmLanes;var u=n&134217727;return u!==0?(n=u&~i,n!==0?l=ya(n):(c&=u,c!==0?l=ya(c):a||(a=u&~e,a!==0&&(l=ya(a))))):(u=n&~i,u!==0?l=ya(u):c!==0?l=ya(c):a||(a=n&~e,a!==0&&(l=ya(a)))),l===0?0:t!==0&&t!==l&&(t&i)===0&&(i=l&-l,a=t&-t,i>=a||i===32&&(a&4194048)!==0)?t:l}function An(e,t){return(e.pendingLanes&~(e.suspendedLanes&~e.pingedLanes)&t)===0}function wp(e,t){switch(e){case 1:case 2:case 4:case 8:case 64:return t+250;case 16:case 32:case 128:case 256:case 512:case 1024:case 2048:case 4096:case 8192:case 16384:case 32768:case 65536:case 131072:case 262144:case 524288:case 1048576:case 2097152:return t+5e3;case 4194304:case 8388608:case 16777216:case 33554432:return-1;case 67108864:case 134217728:case 268435456:case 536870912:case 1073741824:return-1;default:return-1}}function ju(){var e=Ml;return Ml<<=1,(Ml&4194048)===0&&(Ml=256),e}function Hu(){var e=Ol;return Ol<<=1,(Ol&62914560)===0&&(Ol=4194304),e}function nc(e){for(var t=[],a=0;31>a;a++)t.push(e);return t}function zn(e,t){e.pendingLanes|=t,t!==268435456&&(e.suspendedLanes=0,e.pingedLanes=0,e.warmLanes=0)}function Tp(e,t,a,n,l,i){var c=e.pendingLanes;e.pendingLanes=a,e.suspendedLanes=0,e.pingedLanes=0,e.warmLanes=0,e.expiredLanes&=a,e.entangledLanes&=a,e.errorRecoveryDisabledLanes&=a,e.shellSuspendCounter=0;var u=e.entanglements,f=e.expirationTimes,y=e.hiddenUpdates;for(a=c&~a;0<a;){var E=31-ct(a),R=1<<E;u[E]=0,f[E]=-1;var b=y[E];if(b!==null)for(y[E]=null,E=0;E<b.length;E++){var S=b[E];S!==null&&(S.lane&=-536870913)}a&=~R}n!==0&&Bu(e,n,0),i!==0&&l===0&&e.tag!==0&&(e.suspendedLanes|=i&~(c&~t))}function Bu(e,t,a){e.pendingLanes|=t,e.suspendedLanes&=~t;var n=31-ct(t);e.entangledLanes|=t,e.entanglements[n]=e.entanglements[n]|1073741824|a&4194090}function Lu(e,t){var a=e.entangledLanes|=t;for(e=e.entanglements;a;){var n=31-ct(a),l=1<<n;l&t|e[n]&t&&(e[n]|=t),a&=~l}}function lc(e){switch(e){case 2:e=1;break;case 8:e=4;break;case 32:e=16;break;case 256:case 512:case 1024:case 2048:case 4096:case 8192:case 16384:case 32768:case 65536:case 131072:case 262144:case 524288:case 1048576:case 2097152:case 4194304:case 8388608:case 16777216:case 33554432:e=128;break;case 268435456:e=134217728;break;default:e=0}return e}function ic(e){return e&=-e,2<e?8<e?(e&134217727)!==0?32:268435456:8:2}function Yu(){var e=q.p;return e!==0?e:(e=window.event,e===void 0?32:Sd(e.type))}function Ep(e,t){var a=q.p;try{return q.p=e,t()}finally{q.p=a}}var Wt=Math.random().toString(36).slice(2),Ve="__reactFiber$"+Wt,We="__reactProps$"+Wt,Ha="__reactContainer$"+Wt,cc="__reactEvents$"+Wt,Ap="__reactListeners$"+Wt,zp="__reactHandles$"+Wt,Gu="__reactResources$"+Wt,Rn="__reactMarker$"+Wt;function oc(e){delete e[Ve],delete e[We],delete e[cc],delete e[Ap],delete e[zp]}function Ba(e){var t=e[Ve];if(t)return t;for(var a=e.parentNode;a;){if(t=a[Ha]||a[Ve]){if(a=t.alternate,t.child!==null||a!==null&&a.child!==null)for(e=cd(e);e!==null;){if(a=e[Ve])return a;e=cd(e)}return t}e=a,a=e.parentNode}return null}function La(e){if(e=e[Ve]||e[Ha]){var t=e.tag;if(t===5||t===6||t===13||t===26||t===27||t===3)return e}return null}function Nn(e){var t=e.tag;if(t===5||t===26||t===27||t===6)return e.stateNode;throw Error(r(33))}function Ya(e){var t=e[Gu];return t||(t=e[Gu]={hoistableStyles:new Map,hoistableScripts:new Map}),t}function He(e){e[Rn]=!0}var Qu=new Set,Xu={};function ba(e,t){Ga(e,t),Ga(e+"Capture",t)}function Ga(e,t){for(Xu[e]=t,e=0;e<t.length;e++)Qu.add(t[e])}var Rp=RegExp("^[:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD][:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040]*$"),Zu={},Vu={};function Np(e){return ec.call(Vu,e)?!0:ec.call(Zu,e)?!1:Rp.test(e)?Vu[e]=!0:(Zu[e]=!0,!1)}function ql(e,t,a){if(Np(t))if(a===null)e.removeAttribute(t);else{switch(typeof a){case"undefined":case"function":case"symbol":e.removeAttribute(t);return;case"boolean":var n=t.toLowerCase().slice(0,5);if(n!=="data-"&&n!=="aria-"){e.removeAttribute(t);return}}e.setAttribute(t,""+a)}}function Cl(e,t,a){if(a===null)e.removeAttribute(t);else{switch(typeof a){case"undefined":case"function":case"symbol":case"boolean":e.removeAttribute(t);return}e.setAttribute(t,""+a)}}function Ot(e,t,a,n){if(n===null)e.removeAttribute(a);else{switch(typeof n){case"undefined":case"function":case"symbol":case"boolean":e.removeAttribute(a);return}e.setAttributeNS(t,a,""+n)}}var uc,Ku;function Qa(e){if(uc===void 0)try{throw Error()}catch(a){var t=a.stack.trim().match(/\n( *(at )?)/);uc=t&&t[1]||"",Ku=-1<a.stack.indexOf(`
    at`)?" (<anonymous>)":-1<a.stack.indexOf("@")?"@unknown:0:0":""}return`
`+uc+e+Ku}var sc=!1;function rc(e,t){if(!e||sc)return"";sc=!0;var a=Error.prepareStackTrace;Error.prepareStackTrace=void 0;try{var n={DetermineComponentFrameRoot:function(){try{if(t){var R=function(){throw Error()};if(Object.defineProperty(R.prototype,"props",{set:function(){throw Error()}}),typeof Reflect=="object"&&Reflect.construct){try{Reflect.construct(R,[])}catch(S){var b=S}Reflect.construct(e,[],R)}else{try{R.call()}catch(S){b=S}e.call(R.prototype)}}else{try{throw Error()}catch(S){b=S}(R=e())&&typeof R.catch=="function"&&R.catch(function(){})}}catch(S){if(S&&b&&typeof S.stack=="string")return[S.stack,b.stack]}return[null,null]}};n.DetermineComponentFrameRoot.displayName="DetermineComponentFrameRoot";var l=Object.getOwnPropertyDescriptor(n.DetermineComponentFrameRoot,"name");l&&l.configurable&&Object.defineProperty(n.DetermineComponentFrameRoot,"name",{value:"DetermineComponentFrameRoot"});var i=n.DetermineComponentFrameRoot(),c=i[0],u=i[1];if(c&&u){var f=c.split(`
`),y=u.split(`
`);for(l=n=0;n<f.length&&!f[n].includes("DetermineComponentFrameRoot");)n++;for(;l<y.length&&!y[l].includes("DetermineComponentFrameRoot");)l++;if(n===f.length||l===y.length)for(n=f.length-1,l=y.length-1;1<=n&&0<=l&&f[n]!==y[l];)l--;for(;1<=n&&0<=l;n--,l--)if(f[n]!==y[l]){if(n!==1||l!==1)do if(n--,l--,0>l||f[n]!==y[l]){var E=`
`+f[n].replace(" at new "," at ");return e.displayName&&E.includes("<anonymous>")&&(E=E.replace("<anonymous>",e.displayName)),E}while(1<=n&&0<=l);break}}}finally{sc=!1,Error.prepareStackTrace=a}return(a=e?e.displayName||e.name:"")?Qa(a):""}function Dp(e){switch(e.tag){case 26:case 27:case 5:return Qa(e.type);case 16:return Qa("Lazy");case 13:return Qa("Suspense");case 19:return Qa("SuspenseList");case 0:case 15:return rc(e.type,!1);case 11:return rc(e.type.render,!1);case 1:return rc(e.type,!0);case 31:return Qa("Activity");default:return""}}function Ju(e){try{var t="";do t+=Dp(e),e=e.return;while(e);return t}catch(a){return`
Error generating stack: `+a.message+`
`+a.stack}}function ht(e){switch(typeof e){case"bigint":case"boolean":case"number":case"string":case"undefined":return e;case"object":return e;default:return""}}function $u(e){var t=e.type;return(e=e.nodeName)&&e.toLowerCase()==="input"&&(t==="checkbox"||t==="radio")}function Mp(e){var t=$u(e)?"checked":"value",a=Object.getOwnPropertyDescriptor(e.constructor.prototype,t),n=""+e[t];if(!e.hasOwnProperty(t)&&typeof a<"u"&&typeof a.get=="function"&&typeof a.set=="function"){var l=a.get,i=a.set;return Object.defineProperty(e,t,{configurable:!0,get:function(){return l.call(this)},set:function(c){n=""+c,i.call(this,c)}}),Object.defineProperty(e,t,{enumerable:a.enumerable}),{getValue:function(){return n},setValue:function(c){n=""+c},stopTracking:function(){e._valueTracker=null,delete e[t]}}}}function jl(e){e._valueTracker||(e._valueTracker=Mp(e))}function Wu(e){if(!e)return!1;var t=e._valueTracker;if(!t)return!0;var a=t.getValue(),n="";return e&&(n=$u(e)?e.checked?"true":"false":e.value),e=n,e!==a?(t.setValue(e),!0):!1}function Hl(e){if(e=e||(typeof document<"u"?document:void 0),typeof e>"u")return null;try{return e.activeElement||e.body}catch{return e.body}}var Op=/[\n"\\]/g;function mt(e){return e.replace(Op,function(t){return"\\"+t.charCodeAt(0).toString(16)+" "})}function fc(e,t,a,n,l,i,c,u){e.name="",c!=null&&typeof c!="function"&&typeof c!="symbol"&&typeof c!="boolean"?e.type=c:e.removeAttribute("type"),t!=null?c==="number"?(t===0&&e.value===""||e.value!=t)&&(e.value=""+ht(t)):e.value!==""+ht(t)&&(e.value=""+ht(t)):c!=="submit"&&c!=="reset"||e.removeAttribute("value"),t!=null?dc(e,c,ht(t)):a!=null?dc(e,c,ht(a)):n!=null&&e.removeAttribute("value"),l==null&&i!=null&&(e.defaultChecked=!!i),l!=null&&(e.checked=l&&typeof l!="function"&&typeof l!="symbol"),u!=null&&typeof u!="function"&&typeof u!="symbol"&&typeof u!="boolean"?e.name=""+ht(u):e.removeAttribute("name")}function Fu(e,t,a,n,l,i,c,u){if(i!=null&&typeof i!="function"&&typeof i!="symbol"&&typeof i!="boolean"&&(e.type=i),t!=null||a!=null){if(!(i!=="submit"&&i!=="reset"||t!=null))return;a=a!=null?""+ht(a):"",t=t!=null?""+ht(t):a,u||t===e.value||(e.value=t),e.defaultValue=t}n=n??l,n=typeof n!="function"&&typeof n!="symbol"&&!!n,e.checked=u?e.checked:!!n,e.defaultChecked=!!n,c!=null&&typeof c!="function"&&typeof c!="symbol"&&typeof c!="boolean"&&(e.name=c)}function dc(e,t,a){t==="number"&&Hl(e.ownerDocument)===e||e.defaultValue===""+a||(e.defaultValue=""+a)}function Xa(e,t,a,n){if(e=e.options,t){t={};for(var l=0;l<a.length;l++)t["$"+a[l]]=!0;for(a=0;a<e.length;a++)l=t.hasOwnProperty("$"+e[a].value),e[a].selected!==l&&(e[a].selected=l),l&&n&&(e[a].defaultSelected=!0)}else{for(a=""+ht(a),t=null,l=0;l<e.length;l++){if(e[l].value===a){e[l].selected=!0,n&&(e[l].defaultSelected=!0);return}t!==null||e[l].disabled||(t=e[l])}t!==null&&(t.selected=!0)}}function Pu(e,t,a){if(t!=null&&(t=""+ht(t),t!==e.value&&(e.value=t),a==null)){e.defaultValue!==t&&(e.defaultValue=t);return}e.defaultValue=a!=null?""+ht(a):""}function Iu(e,t,a,n){if(t==null){if(n!=null){if(a!=null)throw Error(r(92));if(je(n)){if(1<n.length)throw Error(r(93));n=n[0]}a=n}a==null&&(a=""),t=a}a=ht(t),e.defaultValue=a,n=e.textContent,n===a&&n!==""&&n!==null&&(e.value=n)}function Za(e,t){if(t){var a=e.firstChild;if(a&&a===e.lastChild&&a.nodeType===3){a.nodeValue=t;return}}e.textContent=t}var Up=new Set("animationIterationCount aspectRatio borderImageOutset borderImageSlice borderImageWidth boxFlex boxFlexGroup boxOrdinalGroup columnCount columns flex flexGrow flexPositive flexShrink flexNegative flexOrder gridArea gridRow gridRowEnd gridRowSpan gridRowStart gridColumn gridColumnEnd gridColumnSpan gridColumnStart fontWeight lineClamp lineHeight opacity order orphans scale tabSize widows zIndex zoom fillOpacity floodOpacity stopOpacity strokeDasharray strokeDashoffset strokeMiterlimit strokeOpacity strokeWidth MozAnimationIterationCount MozBoxFlex MozBoxFlexGroup MozLineClamp msAnimationIterationCount msFlex msZoom msFlexGrow msFlexNegative msFlexOrder msFlexPositive msFlexShrink msGridColumn msGridColumnSpan msGridRow msGridRowSpan WebkitAnimationIterationCount WebkitBoxFlex WebKitBoxFlexGroup WebkitBoxOrdinalGroup WebkitColumnCount WebkitColumns WebkitFlex WebkitFlexGrow WebkitFlexPositive WebkitFlexShrink WebkitLineClamp".split(" "));function es(e,t,a){var n=t.indexOf("--")===0;a==null||typeof a=="boolean"||a===""?n?e.setProperty(t,""):t==="float"?e.cssFloat="":e[t]="":n?e.setProperty(t,a):typeof a!="number"||a===0||Up.has(t)?t==="float"?e.cssFloat=a:e[t]=(""+a).trim():e[t]=a+"px"}function ts(e,t,a){if(t!=null&&typeof t!="object")throw Error(r(62));if(e=e.style,a!=null){for(var n in a)!a.hasOwnProperty(n)||t!=null&&t.hasOwnProperty(n)||(n.indexOf("--")===0?e.setProperty(n,""):n==="float"?e.cssFloat="":e[n]="");for(var l in t)n=t[l],t.hasOwnProperty(l)&&a[l]!==n&&es(e,l,n)}else for(var i in t)t.hasOwnProperty(i)&&es(e,i,t[i])}function pc(e){if(e.indexOf("-")===-1)return!1;switch(e){case"annotation-xml":case"color-profile":case"font-face":case"font-face-src":case"font-face-uri":case"font-face-format":case"font-face-name":case"missing-glyph":return!1;default:return!0}}var qp=new Map([["acceptCharset","accept-charset"],["htmlFor","for"],["httpEquiv","http-equiv"],["crossOrigin","crossorigin"],["accentHeight","accent-height"],["alignmentBaseline","alignment-baseline"],["arabicForm","arabic-form"],["baselineShift","baseline-shift"],["capHeight","cap-height"],["clipPath","clip-path"],["clipRule","clip-rule"],["colorInterpolation","color-interpolation"],["colorInterpolationFilters","color-interpolation-filters"],["colorProfile","color-profile"],["colorRendering","color-rendering"],["dominantBaseline","dominant-baseline"],["enableBackground","enable-background"],["fillOpacity","fill-opacity"],["fillRule","fill-rule"],["floodColor","flood-color"],["floodOpacity","flood-opacity"],["fontFamily","font-family"],["fontSize","font-size"],["fontSizeAdjust","font-size-adjust"],["fontStretch","font-stretch"],["fontStyle","font-style"],["fontVariant","font-variant"],["fontWeight","font-weight"],["glyphName","glyph-name"],["glyphOrientationHorizontal","glyph-orientation-horizontal"],["glyphOrientationVertical","glyph-orientation-vertical"],["horizAdvX","horiz-adv-x"],["horizOriginX","horiz-origin-x"],["imageRendering","image-rendering"],["letterSpacing","letter-spacing"],["lightingColor","lighting-color"],["markerEnd","marker-end"],["markerMid","marker-mid"],["markerStart","marker-start"],["overlinePosition","overline-position"],["overlineThickness","overline-thickness"],["paintOrder","paint-order"],["panose-1","panose-1"],["pointerEvents","pointer-events"],["renderingIntent","rendering-intent"],["shapeRendering","shape-rendering"],["stopColor","stop-color"],["stopOpacity","stop-opacity"],["strikethroughPosition","strikethrough-position"],["strikethroughThickness","strikethrough-thickness"],["strokeDasharray","stroke-dasharray"],["strokeDashoffset","stroke-dashoffset"],["strokeLinecap","stroke-linecap"],["strokeLinejoin","stroke-linejoin"],["strokeMiterlimit","stroke-miterlimit"],["strokeOpacity","stroke-opacity"],["strokeWidth","stroke-width"],["textAnchor","text-anchor"],["textDecoration","text-decoration"],["textRendering","text-rendering"],["transformOrigin","transform-origin"],["underlinePosition","underline-position"],["underlineThickness","underline-thickness"],["unicodeBidi","unicode-bidi"],["unicodeRange","unicode-range"],["unitsPerEm","units-per-em"],["vAlphabetic","v-alphabetic"],["vHanging","v-hanging"],["vIdeographic","v-ideographic"],["vMathematical","v-mathematical"],["vectorEffect","vector-effect"],["vertAdvY","vert-adv-y"],["vertOriginX","vert-origin-x"],["vertOriginY","vert-origin-y"],["wordSpacing","word-spacing"],["writingMode","writing-mode"],["xmlnsXlink","xmlns:xlink"],["xHeight","x-height"]]),Cp=/^[\u0000-\u001F ]*j[\r\n\t]*a[\r\n\t]*v[\r\n\t]*a[\r\n\t]*s[\r\n\t]*c[\r\n\t]*r[\r\n\t]*i[\r\n\t]*p[\r\n\t]*t[\r\n\t]*:/i;function Bl(e){return Cp.test(""+e)?"javascript:throw new Error('React has blocked a javascript: URL as a security precaution.')":e}var hc=null;function mc(e){return e=e.target||e.srcElement||window,e.correspondingUseElement&&(e=e.correspondingUseElement),e.nodeType===3?e.parentNode:e}var Va=null,Ka=null;function as(e){var t=La(e);if(t&&(e=t.stateNode)){var a=e[We]||null;e:switch(e=t.stateNode,t.type){case"input":if(fc(e,a.value,a.defaultValue,a.defaultValue,a.checked,a.defaultChecked,a.type,a.name),t=a.name,a.type==="radio"&&t!=null){for(a=e;a.parentNode;)a=a.parentNode;for(a=a.querySelectorAll('input[name="'+mt(""+t)+'"][type="radio"]'),t=0;t<a.length;t++){var n=a[t];if(n!==e&&n.form===e.form){var l=n[We]||null;if(!l)throw Error(r(90));fc(n,l.value,l.defaultValue,l.defaultValue,l.checked,l.defaultChecked,l.type,l.name)}}for(t=0;t<a.length;t++)n=a[t],n.form===e.form&&Wu(n)}break e;case"textarea":Pu(e,a.value,a.defaultValue);break e;case"select":t=a.value,t!=null&&Xa(e,!!a.multiple,t,!1)}}}var _c=!1;function ns(e,t,a){if(_c)return e(t,a);_c=!0;try{var n=e(t);return n}finally{if(_c=!1,(Va!==null||Ka!==null)&&(wi(),Va&&(t=Va,e=Ka,Ka=Va=null,as(t),e)))for(t=0;t<e.length;t++)as(e[t])}}function Dn(e,t){var a=e.stateNode;if(a===null)return null;var n=a[We]||null;if(n===null)return null;a=n[t];e:switch(t){case"onClick":case"onClickCapture":case"onDoubleClick":case"onDoubleClickCapture":case"onMouseDown":case"onMouseDownCapture":case"onMouseMove":case"onMouseMoveCapture":case"onMouseUp":case"onMouseUpCapture":case"onMouseEnter":(n=!n.disabled)||(e=e.type,n=!(e==="button"||e==="input"||e==="select"||e==="textarea")),e=!n;break e;default:e=!1}if(e)return null;if(a&&typeof a!="function")throw Error(r(231,t,typeof a));return a}var Ut=!(typeof window>"u"||typeof window.document>"u"||typeof window.document.createElement>"u"),vc=!1;if(Ut)try{var Mn={};Object.defineProperty(Mn,"passive",{get:function(){vc=!0}}),window.addEventListener("test",Mn,Mn),window.removeEventListener("test",Mn,Mn)}catch{vc=!1}var Ft=null,gc=null,Ll=null;function ls(){if(Ll)return Ll;var e,t=gc,a=t.length,n,l="value"in Ft?Ft.value:Ft.textContent,i=l.length;for(e=0;e<a&&t[e]===l[e];e++);var c=a-e;for(n=1;n<=c&&t[a-n]===l[i-n];n++);return Ll=l.slice(e,1<n?1-n:void 0)}function Yl(e){var t=e.keyCode;return"charCode"in e?(e=e.charCode,e===0&&t===13&&(e=13)):e=t,e===10&&(e=13),32<=e||e===13?e:0}function Gl(){return!0}function is(){return!1}function Fe(e){function t(a,n,l,i,c){this._reactName=a,this._targetInst=l,this.type=n,this.nativeEvent=i,this.target=c,this.currentTarget=null;for(var u in e)e.hasOwnProperty(u)&&(a=e[u],this[u]=a?a(i):i[u]);return this.isDefaultPrevented=(i.defaultPrevented!=null?i.defaultPrevented:i.returnValue===!1)?Gl:is,this.isPropagationStopped=is,this}return N(t.prototype,{preventDefault:function(){this.defaultPrevented=!0;var a=this.nativeEvent;a&&(a.preventDefault?a.preventDefault():typeof a.returnValue!="unknown"&&(a.returnValue=!1),this.isDefaultPrevented=Gl)},stopPropagation:function(){var a=this.nativeEvent;a&&(a.stopPropagation?a.stopPropagation():typeof a.cancelBubble!="unknown"&&(a.cancelBubble=!0),this.isPropagationStopped=Gl)},persist:function(){},isPersistent:Gl}),t}var Sa={eventPhase:0,bubbles:0,cancelable:0,timeStamp:function(e){return e.timeStamp||Date.now()},defaultPrevented:0,isTrusted:0},Ql=Fe(Sa),On=N({},Sa,{view:0,detail:0}),jp=Fe(On),yc,bc,Un,Xl=N({},On,{screenX:0,screenY:0,clientX:0,clientY:0,pageX:0,pageY:0,ctrlKey:0,shiftKey:0,altKey:0,metaKey:0,getModifierState:kc,button:0,buttons:0,relatedTarget:function(e){return e.relatedTarget===void 0?e.fromElement===e.srcElement?e.toElement:e.fromElement:e.relatedTarget},movementX:function(e){return"movementX"in e?e.movementX:(e!==Un&&(Un&&e.type==="mousemove"?(yc=e.screenX-Un.screenX,bc=e.screenY-Un.screenY):bc=yc=0,Un=e),yc)},movementY:function(e){return"movementY"in e?e.movementY:bc}}),cs=Fe(Xl),Hp=N({},Xl,{dataTransfer:0}),Bp=Fe(Hp),Lp=N({},On,{relatedTarget:0}),Sc=Fe(Lp),Yp=N({},Sa,{animationName:0,elapsedTime:0,pseudoElement:0}),Gp=Fe(Yp),Qp=N({},Sa,{clipboardData:function(e){return"clipboardData"in e?e.clipboardData:window.clipboardData}}),Xp=Fe(Qp),Zp=N({},Sa,{data:0}),os=Fe(Zp),Vp={Esc:"Escape",Spacebar:" ",Left:"ArrowLeft",Up:"ArrowUp",Right:"ArrowRight",Down:"ArrowDown",Del:"Delete",Win:"OS",Menu:"ContextMenu",Apps:"ContextMenu",Scroll:"ScrollLock",MozPrintableKey:"Unidentified"},Kp={8:"Backspace",9:"Tab",12:"Clear",13:"Enter",16:"Shift",17:"Control",18:"Alt",19:"Pause",20:"CapsLock",27:"Escape",32:" ",33:"PageUp",34:"PageDown",35:"End",36:"Home",37:"ArrowLeft",38:"ArrowUp",39:"ArrowRight",40:"ArrowDown",45:"Insert",46:"Delete",112:"F1",113:"F2",114:"F3",115:"F4",116:"F5",117:"F6",118:"F7",119:"F8",120:"F9",121:"F10",122:"F11",123:"F12",144:"NumLock",145:"ScrollLock",224:"Meta"},Jp={Alt:"altKey",Control:"ctrlKey",Meta:"metaKey",Shift:"shiftKey"};function $p(e){var t=this.nativeEvent;return t.getModifierState?t.getModifierState(e):(e=Jp[e])?!!t[e]:!1}function kc(){return $p}var Wp=N({},On,{key:function(e){if(e.key){var t=Vp[e.key]||e.key;if(t!=="Unidentified")return t}return e.type==="keypress"?(e=Yl(e),e===13?"Enter":String.fromCharCode(e)):e.type==="keydown"||e.type==="keyup"?Kp[e.keyCode]||"Unidentified":""},code:0,location:0,ctrlKey:0,shiftKey:0,altKey:0,metaKey:0,repeat:0,locale:0,getModifierState:kc,charCode:function(e){return e.type==="keypress"?Yl(e):0},keyCode:function(e){return e.type==="keydown"||e.type==="keyup"?e.keyCode:0},which:function(e){return e.type==="keypress"?Yl(e):e.type==="keydown"||e.type==="keyup"?e.keyCode:0}}),Fp=Fe(Wp),Pp=N({},Xl,{pointerId:0,width:0,height:0,pressure:0,tangentialPressure:0,tiltX:0,tiltY:0,twist:0,pointerType:0,isPrimary:0}),us=Fe(Pp),Ip=N({},On,{touches:0,targetTouches:0,changedTouches:0,altKey:0,metaKey:0,ctrlKey:0,shiftKey:0,getModifierState:kc}),eh=Fe(Ip),th=N({},Sa,{propertyName:0,elapsedTime:0,pseudoElement:0}),ah=Fe(th),nh=N({},Xl,{deltaX:function(e){return"deltaX"in e?e.deltaX:"wheelDeltaX"in e?-e.wheelDeltaX:0},deltaY:function(e){return"deltaY"in e?e.deltaY:"wheelDeltaY"in e?-e.wheelDeltaY:"wheelDelta"in e?-e.wheelDelta:0},deltaZ:0,deltaMode:0}),lh=Fe(nh),ih=N({},Sa,{newState:0,oldState:0}),ch=Fe(ih),oh=[9,13,27,32],xc=Ut&&"CompositionEvent"in window,qn=null;Ut&&"documentMode"in document&&(qn=document.documentMode);var uh=Ut&&"TextEvent"in window&&!qn,ss=Ut&&(!xc||qn&&8<qn&&11>=qn),rs=" ",fs=!1;function ds(e,t){switch(e){case"keyup":return oh.indexOf(t.keyCode)!==-1;case"keydown":return t.keyCode!==229;case"keypress":case"mousedown":case"focusout":return!0;default:return!1}}function ps(e){return e=e.detail,typeof e=="object"&&"data"in e?e.data:null}var Ja=!1;function sh(e,t){switch(e){case"compositionend":return ps(t);case"keypress":return t.which!==32?null:(fs=!0,rs);case"textInput":return e=t.data,e===rs&&fs?null:e;default:return null}}function rh(e,t){if(Ja)return e==="compositionend"||!xc&&ds(e,t)?(e=ls(),Ll=gc=Ft=null,Ja=!1,e):null;switch(e){case"paste":return null;case"keypress":if(!(t.ctrlKey||t.altKey||t.metaKey)||t.ctrlKey&&t.altKey){if(t.char&&1<t.char.length)return t.char;if(t.which)return String.fromCharCode(t.which)}return null;case"compositionend":return ss&&t.locale!=="ko"?null:t.data;default:return null}}var fh={color:!0,date:!0,datetime:!0,"datetime-local":!0,email:!0,month:!0,number:!0,password:!0,range:!0,search:!0,tel:!0,text:!0,time:!0,url:!0,week:!0};function hs(e){var t=e&&e.nodeName&&e.nodeName.toLowerCase();return t==="input"?!!fh[e.type]:t==="textarea"}function ms(e,t,a,n){Va?Ka?Ka.push(n):Ka=[n]:Va=n,t=Ni(t,"onChange"),0<t.length&&(a=new Ql("onChange","change",null,a,n),e.push({event:a,listeners:t}))}var Cn=null,jn=null;function dh(e){Wf(e,0)}function Zl(e){var t=Nn(e);if(Wu(t))return e}function _s(e,t){if(e==="change")return t}var vs=!1;if(Ut){var wc;if(Ut){var Tc="oninput"in document;if(!Tc){var gs=document.createElement("div");gs.setAttribute("oninput","return;"),Tc=typeof gs.oninput=="function"}wc=Tc}else wc=!1;vs=wc&&(!document.documentMode||9<document.documentMode)}function ys(){Cn&&(Cn.detachEvent("onpropertychange",bs),jn=Cn=null)}function bs(e){if(e.propertyName==="value"&&Zl(jn)){var t=[];ms(t,jn,e,mc(e)),ns(dh,t)}}function ph(e,t,a){e==="focusin"?(ys(),Cn=t,jn=a,Cn.attachEvent("onpropertychange",bs)):e==="focusout"&&ys()}function hh(e){if(e==="selectionchange"||e==="keyup"||e==="keydown")return Zl(jn)}function mh(e,t){if(e==="click")return Zl(t)}function _h(e,t){if(e==="input"||e==="change")return Zl(t)}function vh(e,t){return e===t&&(e!==0||1/e===1/t)||e!==e&&t!==t}var ot=typeof Object.is=="function"?Object.is:vh;function Hn(e,t){if(ot(e,t))return!0;if(typeof e!="object"||e===null||typeof t!="object"||t===null)return!1;var a=Object.keys(e),n=Object.keys(t);if(a.length!==n.length)return!1;for(n=0;n<a.length;n++){var l=a[n];if(!ec.call(t,l)||!ot(e[l],t[l]))return!1}return!0}function Ss(e){for(;e&&e.firstChild;)e=e.firstChild;return e}function ks(e,t){var a=Ss(e);e=0;for(var n;a;){if(a.nodeType===3){if(n=e+a.textContent.length,e<=t&&n>=t)return{node:a,offset:t-e};e=n}e:{for(;a;){if(a.nextSibling){a=a.nextSibling;break e}a=a.parentNode}a=void 0}a=Ss(a)}}function xs(e,t){return e&&t?e===t?!0:e&&e.nodeType===3?!1:t&&t.nodeType===3?xs(e,t.parentNode):"contains"in e?e.contains(t):e.compareDocumentPosition?!!(e.compareDocumentPosition(t)&16):!1:!1}function ws(e){e=e!=null&&e.ownerDocument!=null&&e.ownerDocument.defaultView!=null?e.ownerDocument.defaultView:window;for(var t=Hl(e.document);t instanceof e.HTMLIFrameElement;){try{var a=typeof t.contentWindow.location.href=="string"}catch{a=!1}if(a)e=t.contentWindow;else break;t=Hl(e.document)}return t}function Ec(e){var t=e&&e.nodeName&&e.nodeName.toLowerCase();return t&&(t==="input"&&(e.type==="text"||e.type==="search"||e.type==="tel"||e.type==="url"||e.type==="password")||t==="textarea"||e.contentEditable==="true")}var gh=Ut&&"documentMode"in document&&11>=document.documentMode,$a=null,Ac=null,Bn=null,zc=!1;function Ts(e,t,a){var n=a.window===a?a.document:a.nodeType===9?a:a.ownerDocument;zc||$a==null||$a!==Hl(n)||(n=$a,"selectionStart"in n&&Ec(n)?n={start:n.selectionStart,end:n.selectionEnd}:(n=(n.ownerDocument&&n.ownerDocument.defaultView||window).getSelection(),n={anchorNode:n.anchorNode,anchorOffset:n.anchorOffset,focusNode:n.focusNode,focusOffset:n.focusOffset}),Bn&&Hn(Bn,n)||(Bn=n,n=Ni(Ac,"onSelect"),0<n.length&&(t=new Ql("onSelect","select",null,t,a),e.push({event:t,listeners:n}),t.target=$a)))}function ka(e,t){var a={};return a[e.toLowerCase()]=t.toLowerCase(),a["Webkit"+e]="webkit"+t,a["Moz"+e]="moz"+t,a}var Wa={animationend:ka("Animation","AnimationEnd"),animationiteration:ka("Animation","AnimationIteration"),animationstart:ka("Animation","AnimationStart"),transitionrun:ka("Transition","TransitionRun"),transitionstart:ka("Transition","TransitionStart"),transitioncancel:ka("Transition","TransitionCancel"),transitionend:ka("Transition","TransitionEnd")},Rc={},Es={};Ut&&(Es=document.createElement("div").style,"AnimationEvent"in window||(delete Wa.animationend.animation,delete Wa.animationiteration.animation,delete Wa.animationstart.animation),"TransitionEvent"in window||delete Wa.transitionend.transition);function xa(e){if(Rc[e])return Rc[e];if(!Wa[e])return e;var t=Wa[e],a;for(a in t)if(t.hasOwnProperty(a)&&a in Es)return Rc[e]=t[a];return e}var As=xa("animationend"),zs=xa("animationiteration"),Rs=xa("animationstart"),yh=xa("transitionrun"),bh=xa("transitionstart"),Sh=xa("transitioncancel"),Ns=xa("transitionend"),Ds=new Map,Nc="abort auxClick beforeToggle cancel canPlay canPlayThrough click close contextMenu copy cut drag dragEnd dragEnter dragExit dragLeave dragOver dragStart drop durationChange emptied encrypted ended error gotPointerCapture input invalid keyDown keyPress keyUp load loadedData loadedMetadata loadStart lostPointerCapture mouseDown mouseMove mouseOut mouseOver mouseUp paste pause play playing pointerCancel pointerDown pointerMove pointerOut pointerOver pointerUp progress rateChange reset resize seeked seeking stalled submit suspend timeUpdate touchCancel touchEnd touchStart volumeChange scroll toggle touchMove waiting wheel".split(" ");Nc.push("scrollEnd");function xt(e,t){Ds.set(e,t),ba(t,[e])}var Ms=new WeakMap;function _t(e,t){if(typeof e=="object"&&e!==null){var a=Ms.get(e);return a!==void 0?a:(t={value:e,source:t,stack:Ju(t)},Ms.set(e,t),t)}return{value:e,source:t,stack:Ju(t)}}var vt=[],Fa=0,Dc=0;function Vl(){for(var e=Fa,t=Dc=Fa=0;t<e;){var a=vt[t];vt[t++]=null;var n=vt[t];vt[t++]=null;var l=vt[t];vt[t++]=null;var i=vt[t];if(vt[t++]=null,n!==null&&l!==null){var c=n.pending;c===null?l.next=l:(l.next=c.next,c.next=l),n.pending=l}i!==0&&Os(a,l,i)}}function Kl(e,t,a,n){vt[Fa++]=e,vt[Fa++]=t,vt[Fa++]=a,vt[Fa++]=n,Dc|=n,e.lanes|=n,e=e.alternate,e!==null&&(e.lanes|=n)}function Mc(e,t,a,n){return Kl(e,t,a,n),Jl(e)}function Pa(e,t){return Kl(e,null,null,t),Jl(e)}function Os(e,t,a){e.lanes|=a;var n=e.alternate;n!==null&&(n.lanes|=a);for(var l=!1,i=e.return;i!==null;)i.childLanes|=a,n=i.alternate,n!==null&&(n.childLanes|=a),i.tag===22&&(e=i.stateNode,e===null||e._visibility&1||(l=!0)),e=i,i=i.return;return e.tag===3?(i=e.stateNode,l&&t!==null&&(l=31-ct(a),e=i.hiddenUpdates,n=e[l],n===null?e[l]=[t]:n.push(t),t.lane=a|536870912),i):null}function Jl(e){if(50<rl)throw rl=0,Bo=null,Error(r(185));for(var t=e.return;t!==null;)e=t,t=e.return;return e.tag===3?e.stateNode:null}var Ia={};function kh(e,t,a,n){this.tag=e,this.key=a,this.sibling=this.child=this.return=this.stateNode=this.type=this.elementType=null,this.index=0,this.refCleanup=this.ref=null,this.pendingProps=t,this.dependencies=this.memoizedState=this.updateQueue=this.memoizedProps=null,this.mode=n,this.subtreeFlags=this.flags=0,this.deletions=null,this.childLanes=this.lanes=0,this.alternate=null}function ut(e,t,a,n){return new kh(e,t,a,n)}function Oc(e){return e=e.prototype,!(!e||!e.isReactComponent)}function qt(e,t){var a=e.alternate;return a===null?(a=ut(e.tag,t,e.key,e.mode),a.elementType=e.elementType,a.type=e.type,a.stateNode=e.stateNode,a.alternate=e,e.alternate=a):(a.pendingProps=t,a.type=e.type,a.flags=0,a.subtreeFlags=0,a.deletions=null),a.flags=e.flags&65011712,a.childLanes=e.childLanes,a.lanes=e.lanes,a.child=e.child,a.memoizedProps=e.memoizedProps,a.memoizedState=e.memoizedState,a.updateQueue=e.updateQueue,t=e.dependencies,a.dependencies=t===null?null:{lanes:t.lanes,firstContext:t.firstContext},a.sibling=e.sibling,a.index=e.index,a.ref=e.ref,a.refCleanup=e.refCleanup,a}function Us(e,t){e.flags&=65011714;var a=e.alternate;return a===null?(e.childLanes=0,e.lanes=t,e.child=null,e.subtreeFlags=0,e.memoizedProps=null,e.memoizedState=null,e.updateQueue=null,e.dependencies=null,e.stateNode=null):(e.childLanes=a.childLanes,e.lanes=a.lanes,e.child=a.child,e.subtreeFlags=0,e.deletions=null,e.memoizedProps=a.memoizedProps,e.memoizedState=a.memoizedState,e.updateQueue=a.updateQueue,e.type=a.type,t=a.dependencies,e.dependencies=t===null?null:{lanes:t.lanes,firstContext:t.firstContext}),e}function $l(e,t,a,n,l,i){var c=0;if(n=e,typeof e=="function")Oc(e)&&(c=1);else if(typeof e=="string")c=wm(e,a,j.current)?26:e==="html"||e==="head"||e==="body"?27:5;else e:switch(e){case Ce:return e=ut(31,a,t,l),e.elementType=Ce,e.lanes=i,e;case ie:return wa(a.children,l,i,t);case me:c=8,l|=24;break;case Se:return e=ut(12,a,t,l|2),e.elementType=Se,e.lanes=i,e;case $:return e=ut(13,a,t,l),e.elementType=$,e.lanes=i,e;case K:return e=ut(19,a,t,l),e.elementType=K,e.lanes=i,e;default:if(typeof e=="object"&&e!==null)switch(e.$$typeof){case Ze:case ce:c=10;break e;case Ne:c=9;break e;case qe:c=11;break e;case _e:c=14;break e;case ge:c=16,n=null;break e}c=29,a=Error(r(130,e===null?"null":typeof e,"")),n=null}return t=ut(c,a,t,l),t.elementType=e,t.type=n,t.lanes=i,t}function wa(e,t,a,n){return e=ut(7,e,n,t),e.lanes=a,e}function Uc(e,t,a){return e=ut(6,e,null,t),e.lanes=a,e}function qc(e,t,a){return t=ut(4,e.children!==null?e.children:[],e.key,t),t.lanes=a,t.stateNode={containerInfo:e.containerInfo,pendingChildren:null,implementation:e.implementation},t}var en=[],tn=0,Wl=null,Fl=0,gt=[],yt=0,Ta=null,Ct=1,jt="";function Ea(e,t){en[tn++]=Fl,en[tn++]=Wl,Wl=e,Fl=t}function qs(e,t,a){gt[yt++]=Ct,gt[yt++]=jt,gt[yt++]=Ta,Ta=e;var n=Ct;e=jt;var l=32-ct(n)-1;n&=~(1<<l),a+=1;var i=32-ct(t)+l;if(30<i){var c=l-l%5;i=(n&(1<<c)-1).toString(32),n>>=c,l-=c,Ct=1<<32-ct(t)+l|a<<l|n,jt=i+e}else Ct=1<<i|a<<l|n,jt=e}function Cc(e){e.return!==null&&(Ea(e,1),qs(e,1,0))}function jc(e){for(;e===Wl;)Wl=en[--tn],en[tn]=null,Fl=en[--tn],en[tn]=null;for(;e===Ta;)Ta=gt[--yt],gt[yt]=null,jt=gt[--yt],gt[yt]=null,Ct=gt[--yt],gt[yt]=null}var $e=null,Te=null,ne=!1,Aa=null,At=!1,Hc=Error(r(519));function za(e){var t=Error(r(418,""));throw Gn(_t(t,e)),Hc}function Cs(e){var t=e.stateNode,a=e.type,n=e.memoizedProps;switch(t[Ve]=e,t[We]=n,a){case"dialog":ee("cancel",t),ee("close",t);break;case"iframe":case"object":case"embed":ee("load",t);break;case"video":case"audio":for(a=0;a<dl.length;a++)ee(dl[a],t);break;case"source":ee("error",t);break;case"img":case"image":case"link":ee("error",t),ee("load",t);break;case"details":ee("toggle",t);break;case"input":ee("invalid",t),Fu(t,n.value,n.defaultValue,n.checked,n.defaultChecked,n.type,n.name,!0),jl(t);break;case"select":ee("invalid",t);break;case"textarea":ee("invalid",t),Iu(t,n.value,n.defaultValue,n.children),jl(t)}a=n.children,typeof a!="string"&&typeof a!="number"&&typeof a!="bigint"||t.textContent===""+a||n.suppressHydrationWarning===!0||ed(t.textContent,a)?(n.popover!=null&&(ee("beforetoggle",t),ee("toggle",t)),n.onScroll!=null&&ee("scroll",t),n.onScrollEnd!=null&&ee("scrollend",t),n.onClick!=null&&(t.onclick=Di),t=!0):t=!1,t||za(e)}function js(e){for($e=e.return;$e;)switch($e.tag){case 5:case 13:At=!1;return;case 27:case 3:At=!0;return;default:$e=$e.return}}function Ln(e){if(e!==$e)return!1;if(!ne)return js(e),ne=!0,!1;var t=e.tag,a;if((a=t!==3&&t!==27)&&((a=t===5)&&(a=e.type,a=!(a!=="form"&&a!=="button")||tu(e.type,e.memoizedProps)),a=!a),a&&Te&&za(e),js(e),t===13){if(e=e.memoizedState,e=e!==null?e.dehydrated:null,!e)throw Error(r(317));e:{for(e=e.nextSibling,t=0;e;){if(e.nodeType===8)if(a=e.data,a==="/$"){if(t===0){Te=Tt(e.nextSibling);break e}t--}else a!=="$"&&a!=="$!"&&a!=="$?"||t++;e=e.nextSibling}Te=null}}else t===27?(t=Te,pa(e.type)?(e=iu,iu=null,Te=e):Te=t):Te=$e?Tt(e.stateNode.nextSibling):null;return!0}function Yn(){Te=$e=null,ne=!1}function Hs(){var e=Aa;return e!==null&&(et===null?et=e:et.push.apply(et,e),Aa=null),e}function Gn(e){Aa===null?Aa=[e]:Aa.push(e)}var Bc=x(null),Ra=null,Ht=null;function Pt(e,t,a){M(Bc,t._currentValue),t._currentValue=a}function Bt(e){e._currentValue=Bc.current,D(Bc)}function Lc(e,t,a){for(;e!==null;){var n=e.alternate;if((e.childLanes&t)!==t?(e.childLanes|=t,n!==null&&(n.childLanes|=t)):n!==null&&(n.childLanes&t)!==t&&(n.childLanes|=t),e===a)break;e=e.return}}function Yc(e,t,a,n){var l=e.child;for(l!==null&&(l.return=e);l!==null;){var i=l.dependencies;if(i!==null){var c=l.child;i=i.firstContext;e:for(;i!==null;){var u=i;i=l;for(var f=0;f<t.length;f++)if(u.context===t[f]){i.lanes|=a,u=i.alternate,u!==null&&(u.lanes|=a),Lc(i.return,a,e),n||(c=null);break e}i=u.next}}else if(l.tag===18){if(c=l.return,c===null)throw Error(r(341));c.lanes|=a,i=c.alternate,i!==null&&(i.lanes|=a),Lc(c,a,e),c=null}else c=l.child;if(c!==null)c.return=l;else for(c=l;c!==null;){if(c===e){c=null;break}if(l=c.sibling,l!==null){l.return=c.return,c=l;break}c=c.return}l=c}}function Qn(e,t,a,n){e=null;for(var l=t,i=!1;l!==null;){if(!i){if((l.flags&524288)!==0)i=!0;else if((l.flags&262144)!==0)break}if(l.tag===10){var c=l.alternate;if(c===null)throw Error(r(387));if(c=c.memoizedProps,c!==null){var u=l.type;ot(l.pendingProps.value,c.value)||(e!==null?e.push(u):e=[u])}}else if(l===lt.current){if(c=l.alternate,c===null)throw Error(r(387));c.memoizedState.memoizedState!==l.memoizedState.memoizedState&&(e!==null?e.push(gl):e=[gl])}l=l.return}e!==null&&Yc(t,e,a,n),t.flags|=262144}function Pl(e){for(e=e.firstContext;e!==null;){if(!ot(e.context._currentValue,e.memoizedValue))return!0;e=e.next}return!1}function Na(e){Ra=e,Ht=null,e=e.dependencies,e!==null&&(e.firstContext=null)}function Ke(e){return Bs(Ra,e)}function Il(e,t){return Ra===null&&Na(e),Bs(e,t)}function Bs(e,t){var a=t._currentValue;if(t={context:t,memoizedValue:a,next:null},Ht===null){if(e===null)throw Error(r(308));Ht=t,e.dependencies={lanes:0,firstContext:t},e.flags|=524288}else Ht=Ht.next=t;return a}var xh=typeof AbortController<"u"?AbortController:function(){var e=[],t=this.signal={aborted:!1,addEventListener:function(a,n){e.push(n)}};this.abort=function(){t.aborted=!0,e.forEach(function(a){return a()})}},wh=o.unstable_scheduleCallback,Th=o.unstable_NormalPriority,Oe={$$typeof:ce,Consumer:null,Provider:null,_currentValue:null,_currentValue2:null,_threadCount:0};function Gc(){return{controller:new xh,data:new Map,refCount:0}}function Xn(e){e.refCount--,e.refCount===0&&wh(Th,function(){e.controller.abort()})}var Zn=null,Qc=0,an=0,nn=null;function Eh(e,t){if(Zn===null){var a=Zn=[];Qc=0,an=Vo(),nn={status:"pending",value:void 0,then:function(n){a.push(n)}}}return Qc++,t.then(Ls,Ls),t}function Ls(){if(--Qc===0&&Zn!==null){nn!==null&&(nn.status="fulfilled");var e=Zn;Zn=null,an=0,nn=null;for(var t=0;t<e.length;t++)(0,e[t])()}}function Ah(e,t){var a=[],n={status:"pending",value:null,reason:null,then:function(l){a.push(l)}};return e.then(function(){n.status="fulfilled",n.value=t;for(var l=0;l<a.length;l++)(0,a[l])(t)},function(l){for(n.status="rejected",n.reason=l,l=0;l<a.length;l++)(0,a[l])(void 0)}),n}var Ys=T.S;T.S=function(e,t){typeof t=="object"&&t!==null&&typeof t.then=="function"&&Eh(e,t),Ys!==null&&Ys(e,t)};var Da=x(null);function Xc(){var e=Da.current;return e!==null?e:he.pooledCache}function ei(e,t){t===null?M(Da,Da.current):M(Da,t.pool)}function Gs(){var e=Xc();return e===null?null:{parent:Oe._currentValue,pool:e}}var Vn=Error(r(460)),Qs=Error(r(474)),ti=Error(r(542)),Zc={then:function(){}};function Xs(e){return e=e.status,e==="fulfilled"||e==="rejected"}function ai(){}function Zs(e,t,a){switch(a=e[a],a===void 0?e.push(t):a!==t&&(t.then(ai,ai),t=a),t.status){case"fulfilled":return t.value;case"rejected":throw e=t.reason,Ks(e),e;default:if(typeof t.status=="string")t.then(ai,ai);else{if(e=he,e!==null&&100<e.shellSuspendCounter)throw Error(r(482));e=t,e.status="pending",e.then(function(n){if(t.status==="pending"){var l=t;l.status="fulfilled",l.value=n}},function(n){if(t.status==="pending"){var l=t;l.status="rejected",l.reason=n}})}switch(t.status){case"fulfilled":return t.value;case"rejected":throw e=t.reason,Ks(e),e}throw Kn=t,Vn}}var Kn=null;function Vs(){if(Kn===null)throw Error(r(459));var e=Kn;return Kn=null,e}function Ks(e){if(e===Vn||e===ti)throw Error(r(483))}var It=!1;function Vc(e){e.updateQueue={baseState:e.memoizedState,firstBaseUpdate:null,lastBaseUpdate:null,shared:{pending:null,lanes:0,hiddenCallbacks:null},callbacks:null}}function Kc(e,t){e=e.updateQueue,t.updateQueue===e&&(t.updateQueue={baseState:e.baseState,firstBaseUpdate:e.firstBaseUpdate,lastBaseUpdate:e.lastBaseUpdate,shared:e.shared,callbacks:null})}function ea(e){return{lane:e,tag:0,payload:null,callback:null,next:null}}function ta(e,t,a){var n=e.updateQueue;if(n===null)return null;if(n=n.shared,(ue&2)!==0){var l=n.pending;return l===null?t.next=t:(t.next=l.next,l.next=t),n.pending=t,t=Jl(e),Os(e,null,a),t}return Kl(e,n,t,a),Jl(e)}function Jn(e,t,a){if(t=t.updateQueue,t!==null&&(t=t.shared,(a&4194048)!==0)){var n=t.lanes;n&=e.pendingLanes,a|=n,t.lanes=a,Lu(e,a)}}function Jc(e,t){var a=e.updateQueue,n=e.alternate;if(n!==null&&(n=n.updateQueue,a===n)){var l=null,i=null;if(a=a.firstBaseUpdate,a!==null){do{var c={lane:a.lane,tag:a.tag,payload:a.payload,callback:null,next:null};i===null?l=i=c:i=i.next=c,a=a.next}while(a!==null);i===null?l=i=t:i=i.next=t}else l=i=t;a={baseState:n.baseState,firstBaseUpdate:l,lastBaseUpdate:i,shared:n.shared,callbacks:n.callbacks},e.updateQueue=a;return}e=a.lastBaseUpdate,e===null?a.firstBaseUpdate=t:e.next=t,a.lastBaseUpdate=t}var $c=!1;function $n(){if($c){var e=nn;if(e!==null)throw e}}function Wn(e,t,a,n){$c=!1;var l=e.updateQueue;It=!1;var i=l.firstBaseUpdate,c=l.lastBaseUpdate,u=l.shared.pending;if(u!==null){l.shared.pending=null;var f=u,y=f.next;f.next=null,c===null?i=y:c.next=y,c=f;var E=e.alternate;E!==null&&(E=E.updateQueue,u=E.lastBaseUpdate,u!==c&&(u===null?E.firstBaseUpdate=y:u.next=y,E.lastBaseUpdate=f))}if(i!==null){var R=l.baseState;c=0,E=y=f=null,u=i;do{var b=u.lane&-536870913,S=b!==u.lane;if(S?(te&b)===b:(n&b)===b){b!==0&&b===an&&($c=!0),E!==null&&(E=E.next={lane:0,tag:u.tag,payload:u.payload,callback:null,next:null});e:{var X=e,G=u;b=t;var de=a;switch(G.tag){case 1:if(X=G.payload,typeof X=="function"){R=X.call(de,R,b);break e}R=X;break e;case 3:X.flags=X.flags&-65537|128;case 0:if(X=G.payload,b=typeof X=="function"?X.call(de,R,b):X,b==null)break e;R=N({},R,b);break e;case 2:It=!0}}b=u.callback,b!==null&&(e.flags|=64,S&&(e.flags|=8192),S=l.callbacks,S===null?l.callbacks=[b]:S.push(b))}else S={lane:b,tag:u.tag,payload:u.payload,callback:u.callback,next:null},E===null?(y=E=S,f=R):E=E.next=S,c|=b;if(u=u.next,u===null){if(u=l.shared.pending,u===null)break;S=u,u=S.next,S.next=null,l.lastBaseUpdate=S,l.shared.pending=null}}while(!0);E===null&&(f=R),l.baseState=f,l.firstBaseUpdate=y,l.lastBaseUpdate=E,i===null&&(l.shared.lanes=0),sa|=c,e.lanes=c,e.memoizedState=R}}function Js(e,t){if(typeof e!="function")throw Error(r(191,e));e.call(t)}function $s(e,t){var a=e.callbacks;if(a!==null)for(e.callbacks=null,e=0;e<a.length;e++)Js(a[e],t)}var ln=x(null),ni=x(0);function Ws(e,t){e=Vt,M(ni,e),M(ln,t),Vt=e|t.baseLanes}function Wc(){M(ni,Vt),M(ln,ln.current)}function Fc(){Vt=ni.current,D(ln),D(ni)}var aa=0,F=null,re=null,De=null,li=!1,cn=!1,Ma=!1,ii=0,Fn=0,on=null,zh=0;function ze(){throw Error(r(321))}function Pc(e,t){if(t===null)return!1;for(var a=0;a<t.length&&a<e.length;a++)if(!ot(e[a],t[a]))return!1;return!0}function Ic(e,t,a,n,l,i){return aa=i,F=t,t.memoizedState=null,t.updateQueue=null,t.lanes=0,T.H=e===null||e.memoizedState===null?Or:Ur,Ma=!1,i=a(n,l),Ma=!1,cn&&(i=Ps(t,a,n,l)),Fs(e),i}function Fs(e){T.H=fi;var t=re!==null&&re.next!==null;if(aa=0,De=re=F=null,li=!1,Fn=0,on=null,t)throw Error(r(300));e===null||Be||(e=e.dependencies,e!==null&&Pl(e)&&(Be=!0))}function Ps(e,t,a,n){F=e;var l=0;do{if(cn&&(on=null),Fn=0,cn=!1,25<=l)throw Error(r(301));if(l+=1,De=re=null,e.updateQueue!=null){var i=e.updateQueue;i.lastEffect=null,i.events=null,i.stores=null,i.memoCache!=null&&(i.memoCache.index=0)}T.H=qh,i=t(a,n)}while(cn);return i}function Rh(){var e=T.H,t=e.useState()[0];return t=typeof t.then=="function"?Pn(t):t,e=e.useState()[0],(re!==null?re.memoizedState:null)!==e&&(F.flags|=1024),t}function eo(){var e=ii!==0;return ii=0,e}function to(e,t,a){t.updateQueue=e.updateQueue,t.flags&=-2053,e.lanes&=~a}function ao(e){if(li){for(e=e.memoizedState;e!==null;){var t=e.queue;t!==null&&(t.pending=null),e=e.next}li=!1}aa=0,De=re=F=null,cn=!1,Fn=ii=0,on=null}function Pe(){var e={memoizedState:null,baseState:null,baseQueue:null,queue:null,next:null};return De===null?F.memoizedState=De=e:De=De.next=e,De}function Me(){if(re===null){var e=F.alternate;e=e!==null?e.memoizedState:null}else e=re.next;var t=De===null?F.memoizedState:De.next;if(t!==null)De=t,re=e;else{if(e===null)throw F.alternate===null?Error(r(467)):Error(r(310));re=e,e={memoizedState:re.memoizedState,baseState:re.baseState,baseQueue:re.baseQueue,queue:re.queue,next:null},De===null?F.memoizedState=De=e:De=De.next=e}return De}function no(){return{lastEffect:null,events:null,stores:null,memoCache:null}}function Pn(e){var t=Fn;return Fn+=1,on===null&&(on=[]),e=Zs(on,e,t),t=F,(De===null?t.memoizedState:De.next)===null&&(t=t.alternate,T.H=t===null||t.memoizedState===null?Or:Ur),e}function ci(e){if(e!==null&&typeof e=="object"){if(typeof e.then=="function")return Pn(e);if(e.$$typeof===ce)return Ke(e)}throw Error(r(438,String(e)))}function lo(e){var t=null,a=F.updateQueue;if(a!==null&&(t=a.memoCache),t==null){var n=F.alternate;n!==null&&(n=n.updateQueue,n!==null&&(n=n.memoCache,n!=null&&(t={data:n.data.map(function(l){return l.slice()}),index:0})))}if(t==null&&(t={data:[],index:0}),a===null&&(a=no(),F.updateQueue=a),a.memoCache=t,a=t.data[t.index],a===void 0)for(a=t.data[t.index]=Array(e),n=0;n<e;n++)a[n]=le;return t.index++,a}function Lt(e,t){return typeof t=="function"?t(e):t}function oi(e){var t=Me();return io(t,re,e)}function io(e,t,a){var n=e.queue;if(n===null)throw Error(r(311));n.lastRenderedReducer=a;var l=e.baseQueue,i=n.pending;if(i!==null){if(l!==null){var c=l.next;l.next=i.next,i.next=c}t.baseQueue=l=i,n.pending=null}if(i=e.baseState,l===null)e.memoizedState=i;else{t=l.next;var u=c=null,f=null,y=t,E=!1;do{var R=y.lane&-536870913;if(R!==y.lane?(te&R)===R:(aa&R)===R){var b=y.revertLane;if(b===0)f!==null&&(f=f.next={lane:0,revertLane:0,action:y.action,hasEagerState:y.hasEagerState,eagerState:y.eagerState,next:null}),R===an&&(E=!0);else if((aa&b)===b){y=y.next,b===an&&(E=!0);continue}else R={lane:0,revertLane:y.revertLane,action:y.action,hasEagerState:y.hasEagerState,eagerState:y.eagerState,next:null},f===null?(u=f=R,c=i):f=f.next=R,F.lanes|=b,sa|=b;R=y.action,Ma&&a(i,R),i=y.hasEagerState?y.eagerState:a(i,R)}else b={lane:R,revertLane:y.revertLane,action:y.action,hasEagerState:y.hasEagerState,eagerState:y.eagerState,next:null},f===null?(u=f=b,c=i):f=f.next=b,F.lanes|=R,sa|=R;y=y.next}while(y!==null&&y!==t);if(f===null?c=i:f.next=u,!ot(i,e.memoizedState)&&(Be=!0,E&&(a=nn,a!==null)))throw a;e.memoizedState=i,e.baseState=c,e.baseQueue=f,n.lastRenderedState=i}return l===null&&(n.lanes=0),[e.memoizedState,n.dispatch]}function co(e){var t=Me(),a=t.queue;if(a===null)throw Error(r(311));a.lastRenderedReducer=e;var n=a.dispatch,l=a.pending,i=t.memoizedState;if(l!==null){a.pending=null;var c=l=l.next;do i=e(i,c.action),c=c.next;while(c!==l);ot(i,t.memoizedState)||(Be=!0),t.memoizedState=i,t.baseQueue===null&&(t.baseState=i),a.lastRenderedState=i}return[i,n]}function Is(e,t,a){var n=F,l=Me(),i=ne;if(i){if(a===void 0)throw Error(r(407));a=a()}else a=t();var c=!ot((re||l).memoizedState,a);c&&(l.memoizedState=a,Be=!0),l=l.queue;var u=ar.bind(null,n,l,e);if(In(2048,8,u,[e]),l.getSnapshot!==t||c||De!==null&&De.memoizedState.tag&1){if(n.flags|=2048,un(9,ui(),tr.bind(null,n,l,a,t),null),he===null)throw Error(r(349));i||(aa&124)!==0||er(n,t,a)}return a}function er(e,t,a){e.flags|=16384,e={getSnapshot:t,value:a},t=F.updateQueue,t===null?(t=no(),F.updateQueue=t,t.stores=[e]):(a=t.stores,a===null?t.stores=[e]:a.push(e))}function tr(e,t,a,n){t.value=a,t.getSnapshot=n,nr(t)&&lr(e)}function ar(e,t,a){return a(function(){nr(t)&&lr(e)})}function nr(e){var t=e.getSnapshot;e=e.value;try{var a=t();return!ot(e,a)}catch{return!0}}function lr(e){var t=Pa(e,2);t!==null&&pt(t,e,2)}function oo(e){var t=Pe();if(typeof e=="function"){var a=e;if(e=a(),Ma){$t(!0);try{a()}finally{$t(!1)}}}return t.memoizedState=t.baseState=e,t.queue={pending:null,lanes:0,dispatch:null,lastRenderedReducer:Lt,lastRenderedState:e},t}function ir(e,t,a,n){return e.baseState=a,io(e,re,typeof n=="function"?n:Lt)}function Nh(e,t,a,n,l){if(ri(e))throw Error(r(485));if(e=t.action,e!==null){var i={payload:l,action:e,next:null,isTransition:!0,status:"pending",value:null,reason:null,listeners:[],then:function(c){i.listeners.push(c)}};T.T!==null?a(!0):i.isTransition=!1,n(i),a=t.pending,a===null?(i.next=t.pending=i,cr(t,i)):(i.next=a.next,t.pending=a.next=i)}}function cr(e,t){var a=t.action,n=t.payload,l=e.state;if(t.isTransition){var i=T.T,c={};T.T=c;try{var u=a(l,n),f=T.S;f!==null&&f(c,u),or(e,t,u)}catch(y){uo(e,t,y)}finally{T.T=i}}else try{i=a(l,n),or(e,t,i)}catch(y){uo(e,t,y)}}function or(e,t,a){a!==null&&typeof a=="object"&&typeof a.then=="function"?a.then(function(n){ur(e,t,n)},function(n){return uo(e,t,n)}):ur(e,t,a)}function ur(e,t,a){t.status="fulfilled",t.value=a,sr(t),e.state=a,t=e.pending,t!==null&&(a=t.next,a===t?e.pending=null:(a=a.next,t.next=a,cr(e,a)))}function uo(e,t,a){var n=e.pending;if(e.pending=null,n!==null){n=n.next;do t.status="rejected",t.reason=a,sr(t),t=t.next;while(t!==n)}e.action=null}function sr(e){e=e.listeners;for(var t=0;t<e.length;t++)(0,e[t])()}function rr(e,t){return t}function fr(e,t){if(ne){var a=he.formState;if(a!==null){e:{var n=F;if(ne){if(Te){t:{for(var l=Te,i=At;l.nodeType!==8;){if(!i){l=null;break t}if(l=Tt(l.nextSibling),l===null){l=null;break t}}i=l.data,l=i==="F!"||i==="F"?l:null}if(l){Te=Tt(l.nextSibling),n=l.data==="F!";break e}}za(n)}n=!1}n&&(t=a[0])}}return a=Pe(),a.memoizedState=a.baseState=t,n={pending:null,lanes:0,dispatch:null,lastRenderedReducer:rr,lastRenderedState:t},a.queue=n,a=Nr.bind(null,F,n),n.dispatch=a,n=oo(!1),i=ho.bind(null,F,!1,n.queue),n=Pe(),l={state:t,dispatch:null,action:e,pending:null},n.queue=l,a=Nh.bind(null,F,l,i,a),l.dispatch=a,n.memoizedState=e,[t,a,!1]}function dr(e){var t=Me();return pr(t,re,e)}function pr(e,t,a){if(t=io(e,t,rr)[0],e=oi(Lt)[0],typeof t=="object"&&t!==null&&typeof t.then=="function")try{var n=Pn(t)}catch(c){throw c===Vn?ti:c}else n=t;t=Me();var l=t.queue,i=l.dispatch;return a!==t.memoizedState&&(F.flags|=2048,un(9,ui(),Dh.bind(null,l,a),null)),[n,i,e]}function Dh(e,t){e.action=t}function hr(e){var t=Me(),a=re;if(a!==null)return pr(t,a,e);Me(),t=t.memoizedState,a=Me();var n=a.queue.dispatch;return a.memoizedState=e,[t,n,!1]}function un(e,t,a,n){return e={tag:e,create:a,deps:n,inst:t,next:null},t=F.updateQueue,t===null&&(t=no(),F.updateQueue=t),a=t.lastEffect,a===null?t.lastEffect=e.next=e:(n=a.next,a.next=e,e.next=n,t.lastEffect=e),e}function ui(){return{destroy:void 0,resource:void 0}}function mr(){return Me().memoizedState}function si(e,t,a,n){var l=Pe();n=n===void 0?null:n,F.flags|=e,l.memoizedState=un(1|t,ui(),a,n)}function In(e,t,a,n){var l=Me();n=n===void 0?null:n;var i=l.memoizedState.inst;re!==null&&n!==null&&Pc(n,re.memoizedState.deps)?l.memoizedState=un(t,i,a,n):(F.flags|=e,l.memoizedState=un(1|t,i,a,n))}function _r(e,t){si(8390656,8,e,t)}function vr(e,t){In(2048,8,e,t)}function gr(e,t){return In(4,2,e,t)}function yr(e,t){return In(4,4,e,t)}function br(e,t){if(typeof t=="function"){e=e();var a=t(e);return function(){typeof a=="function"?a():t(null)}}if(t!=null)return e=e(),t.current=e,function(){t.current=null}}function Sr(e,t,a){a=a!=null?a.concat([e]):null,In(4,4,br.bind(null,t,e),a)}function so(){}function kr(e,t){var a=Me();t=t===void 0?null:t;var n=a.memoizedState;return t!==null&&Pc(t,n[1])?n[0]:(a.memoizedState=[e,t],e)}function xr(e,t){var a=Me();t=t===void 0?null:t;var n=a.memoizedState;if(t!==null&&Pc(t,n[1]))return n[0];if(n=e(),Ma){$t(!0);try{e()}finally{$t(!1)}}return a.memoizedState=[n,t],n}function ro(e,t,a){return a===void 0||(aa&1073741824)!==0?e.memoizedState=t:(e.memoizedState=a,e=Af(),F.lanes|=e,sa|=e,a)}function wr(e,t,a,n){return ot(a,t)?a:ln.current!==null?(e=ro(e,a,n),ot(e,t)||(Be=!0),e):(aa&42)===0?(Be=!0,e.memoizedState=a):(e=Af(),F.lanes|=e,sa|=e,t)}function Tr(e,t,a,n,l){var i=q.p;q.p=i!==0&&8>i?i:8;var c=T.T,u={};T.T=u,ho(e,!1,t,a);try{var f=l(),y=T.S;if(y!==null&&y(u,f),f!==null&&typeof f=="object"&&typeof f.then=="function"){var E=Ah(f,n);el(e,t,E,dt(e))}else el(e,t,n,dt(e))}catch(R){el(e,t,{then:function(){},status:"rejected",reason:R},dt())}finally{q.p=i,T.T=c}}function Mh(){}function fo(e,t,a,n){if(e.tag!==5)throw Error(r(476));var l=Er(e).queue;Tr(e,l,t,Y,a===null?Mh:function(){return Ar(e),a(n)})}function Er(e){var t=e.memoizedState;if(t!==null)return t;t={memoizedState:Y,baseState:Y,baseQueue:null,queue:{pending:null,lanes:0,dispatch:null,lastRenderedReducer:Lt,lastRenderedState:Y},next:null};var a={};return t.next={memoizedState:a,baseState:a,baseQueue:null,queue:{pending:null,lanes:0,dispatch:null,lastRenderedReducer:Lt,lastRenderedState:a},next:null},e.memoizedState=t,e=e.alternate,e!==null&&(e.memoizedState=t),t}function Ar(e){var t=Er(e).next.queue;el(e,t,{},dt())}function po(){return Ke(gl)}function zr(){return Me().memoizedState}function Rr(){return Me().memoizedState}function Oh(e){for(var t=e.return;t!==null;){switch(t.tag){case 24:case 3:var a=dt();e=ea(a);var n=ta(t,e,a);n!==null&&(pt(n,t,a),Jn(n,t,a)),t={cache:Gc()},e.payload=t;return}t=t.return}}function Uh(e,t,a){var n=dt();a={lane:n,revertLane:0,action:a,hasEagerState:!1,eagerState:null,next:null},ri(e)?Dr(t,a):(a=Mc(e,t,a,n),a!==null&&(pt(a,e,n),Mr(a,t,n)))}function Nr(e,t,a){var n=dt();el(e,t,a,n)}function el(e,t,a,n){var l={lane:n,revertLane:0,action:a,hasEagerState:!1,eagerState:null,next:null};if(ri(e))Dr(t,l);else{var i=e.alternate;if(e.lanes===0&&(i===null||i.lanes===0)&&(i=t.lastRenderedReducer,i!==null))try{var c=t.lastRenderedState,u=i(c,a);if(l.hasEagerState=!0,l.eagerState=u,ot(u,c))return Kl(e,t,l,0),he===null&&Vl(),!1}catch{}if(a=Mc(e,t,l,n),a!==null)return pt(a,e,n),Mr(a,t,n),!0}return!1}function ho(e,t,a,n){if(n={lane:2,revertLane:Vo(),action:n,hasEagerState:!1,eagerState:null,next:null},ri(e)){if(t)throw Error(r(479))}else t=Mc(e,a,n,2),t!==null&&pt(t,e,2)}function ri(e){var t=e.alternate;return e===F||t!==null&&t===F}function Dr(e,t){cn=li=!0;var a=e.pending;a===null?t.next=t:(t.next=a.next,a.next=t),e.pending=t}function Mr(e,t,a){if((a&4194048)!==0){var n=t.lanes;n&=e.pendingLanes,a|=n,t.lanes=a,Lu(e,a)}}var fi={readContext:Ke,use:ci,useCallback:ze,useContext:ze,useEffect:ze,useImperativeHandle:ze,useLayoutEffect:ze,useInsertionEffect:ze,useMemo:ze,useReducer:ze,useRef:ze,useState:ze,useDebugValue:ze,useDeferredValue:ze,useTransition:ze,useSyncExternalStore:ze,useId:ze,useHostTransitionStatus:ze,useFormState:ze,useActionState:ze,useOptimistic:ze,useMemoCache:ze,useCacheRefresh:ze},Or={readContext:Ke,use:ci,useCallback:function(e,t){return Pe().memoizedState=[e,t===void 0?null:t],e},useContext:Ke,useEffect:_r,useImperativeHandle:function(e,t,a){a=a!=null?a.concat([e]):null,si(4194308,4,br.bind(null,t,e),a)},useLayoutEffect:function(e,t){return si(4194308,4,e,t)},useInsertionEffect:function(e,t){si(4,2,e,t)},useMemo:function(e,t){var a=Pe();t=t===void 0?null:t;var n=e();if(Ma){$t(!0);try{e()}finally{$t(!1)}}return a.memoizedState=[n,t],n},useReducer:function(e,t,a){var n=Pe();if(a!==void 0){var l=a(t);if(Ma){$t(!0);try{a(t)}finally{$t(!1)}}}else l=t;return n.memoizedState=n.baseState=l,e={pending:null,lanes:0,dispatch:null,lastRenderedReducer:e,lastRenderedState:l},n.queue=e,e=e.dispatch=Uh.bind(null,F,e),[n.memoizedState,e]},useRef:function(e){var t=Pe();return e={current:e},t.memoizedState=e},useState:function(e){e=oo(e);var t=e.queue,a=Nr.bind(null,F,t);return t.dispatch=a,[e.memoizedState,a]},useDebugValue:so,useDeferredValue:function(e,t){var a=Pe();return ro(a,e,t)},useTransition:function(){var e=oo(!1);return e=Tr.bind(null,F,e.queue,!0,!1),Pe().memoizedState=e,[!1,e]},useSyncExternalStore:function(e,t,a){var n=F,l=Pe();if(ne){if(a===void 0)throw Error(r(407));a=a()}else{if(a=t(),he===null)throw Error(r(349));(te&124)!==0||er(n,t,a)}l.memoizedState=a;var i={value:a,getSnapshot:t};return l.queue=i,_r(ar.bind(null,n,i,e),[e]),n.flags|=2048,un(9,ui(),tr.bind(null,n,i,a,t),null),a},useId:function(){var e=Pe(),t=he.identifierPrefix;if(ne){var a=jt,n=Ct;a=(n&~(1<<32-ct(n)-1)).toString(32)+a,t="«"+t+"R"+a,a=ii++,0<a&&(t+="H"+a.toString(32)),t+="»"}else a=zh++,t="«"+t+"r"+a.toString(32)+"»";return e.memoizedState=t},useHostTransitionStatus:po,useFormState:fr,useActionState:fr,useOptimistic:function(e){var t=Pe();t.memoizedState=t.baseState=e;var a={pending:null,lanes:0,dispatch:null,lastRenderedReducer:null,lastRenderedState:null};return t.queue=a,t=ho.bind(null,F,!0,a),a.dispatch=t,[e,t]},useMemoCache:lo,useCacheRefresh:function(){return Pe().memoizedState=Oh.bind(null,F)}},Ur={readContext:Ke,use:ci,useCallback:kr,useContext:Ke,useEffect:vr,useImperativeHandle:Sr,useInsertionEffect:gr,useLayoutEffect:yr,useMemo:xr,useReducer:oi,useRef:mr,useState:function(){return oi(Lt)},useDebugValue:so,useDeferredValue:function(e,t){var a=Me();return wr(a,re.memoizedState,e,t)},useTransition:function(){var e=oi(Lt)[0],t=Me().memoizedState;return[typeof e=="boolean"?e:Pn(e),t]},useSyncExternalStore:Is,useId:zr,useHostTransitionStatus:po,useFormState:dr,useActionState:dr,useOptimistic:function(e,t){var a=Me();return ir(a,re,e,t)},useMemoCache:lo,useCacheRefresh:Rr},qh={readContext:Ke,use:ci,useCallback:kr,useContext:Ke,useEffect:vr,useImperativeHandle:Sr,useInsertionEffect:gr,useLayoutEffect:yr,useMemo:xr,useReducer:co,useRef:mr,useState:function(){return co(Lt)},useDebugValue:so,useDeferredValue:function(e,t){var a=Me();return re===null?ro(a,e,t):wr(a,re.memoizedState,e,t)},useTransition:function(){var e=co(Lt)[0],t=Me().memoizedState;return[typeof e=="boolean"?e:Pn(e),t]},useSyncExternalStore:Is,useId:zr,useHostTransitionStatus:po,useFormState:hr,useActionState:hr,useOptimistic:function(e,t){var a=Me();return re!==null?ir(a,re,e,t):(a.baseState=e,[e,a.queue.dispatch])},useMemoCache:lo,useCacheRefresh:Rr},sn=null,tl=0;function di(e){var t=tl;return tl+=1,sn===null&&(sn=[]),Zs(sn,e,t)}function al(e,t){t=t.props.ref,e.ref=t!==void 0?t:null}function pi(e,t){throw t.$$typeof===L?Error(r(525)):(e=Object.prototype.toString.call(t),Error(r(31,e==="[object Object]"?"object with keys {"+Object.keys(t).join(", ")+"}":e)))}function qr(e){var t=e._init;return t(e._payload)}function Cr(e){function t(_,h){if(e){var v=_.deletions;v===null?(_.deletions=[h],_.flags|=16):v.push(h)}}function a(_,h){if(!e)return null;for(;h!==null;)t(_,h),h=h.sibling;return null}function n(_){for(var h=new Map;_!==null;)_.key!==null?h.set(_.key,_):h.set(_.index,_),_=_.sibling;return h}function l(_,h){return _=qt(_,h),_.index=0,_.sibling=null,_}function i(_,h,v){return _.index=v,e?(v=_.alternate,v!==null?(v=v.index,v<h?(_.flags|=67108866,h):v):(_.flags|=67108866,h)):(_.flags|=1048576,h)}function c(_){return e&&_.alternate===null&&(_.flags|=67108866),_}function u(_,h,v,A){return h===null||h.tag!==6?(h=Uc(v,_.mode,A),h.return=_,h):(h=l(h,v),h.return=_,h)}function f(_,h,v,A){var H=v.type;return H===ie?E(_,h,v.props.children,A,v.key):h!==null&&(h.elementType===H||typeof H=="object"&&H!==null&&H.$$typeof===ge&&qr(H)===h.type)?(h=l(h,v.props),al(h,v),h.return=_,h):(h=$l(v.type,v.key,v.props,null,_.mode,A),al(h,v),h.return=_,h)}function y(_,h,v,A){return h===null||h.tag!==4||h.stateNode.containerInfo!==v.containerInfo||h.stateNode.implementation!==v.implementation?(h=qc(v,_.mode,A),h.return=_,h):(h=l(h,v.children||[]),h.return=_,h)}function E(_,h,v,A,H){return h===null||h.tag!==7?(h=wa(v,_.mode,A,H),h.return=_,h):(h=l(h,v),h.return=_,h)}function R(_,h,v){if(typeof h=="string"&&h!==""||typeof h=="number"||typeof h=="bigint")return h=Uc(""+h,_.mode,v),h.return=_,h;if(typeof h=="object"&&h!==null){switch(h.$$typeof){case V:return v=$l(h.type,h.key,h.props,null,_.mode,v),al(v,h),v.return=_,v;case ve:return h=qc(h,_.mode,v),h.return=_,h;case ge:var A=h._init;return h=A(h._payload),R(_,h,v)}if(je(h)||we(h))return h=wa(h,_.mode,v,null),h.return=_,h;if(typeof h.then=="function")return R(_,di(h),v);if(h.$$typeof===ce)return R(_,Il(_,h),v);pi(_,h)}return null}function b(_,h,v,A){var H=h!==null?h.key:null;if(typeof v=="string"&&v!==""||typeof v=="number"||typeof v=="bigint")return H!==null?null:u(_,h,""+v,A);if(typeof v=="object"&&v!==null){switch(v.$$typeof){case V:return v.key===H?f(_,h,v,A):null;case ve:return v.key===H?y(_,h,v,A):null;case ge:return H=v._init,v=H(v._payload),b(_,h,v,A)}if(je(v)||we(v))return H!==null?null:E(_,h,v,A,null);if(typeof v.then=="function")return b(_,h,di(v),A);if(v.$$typeof===ce)return b(_,h,Il(_,v),A);pi(_,v)}return null}function S(_,h,v,A,H){if(typeof A=="string"&&A!==""||typeof A=="number"||typeof A=="bigint")return _=_.get(v)||null,u(h,_,""+A,H);if(typeof A=="object"&&A!==null){switch(A.$$typeof){case V:return _=_.get(A.key===null?v:A.key)||null,f(h,_,A,H);case ve:return _=_.get(A.key===null?v:A.key)||null,y(h,_,A,H);case ge:var P=A._init;return A=P(A._payload),S(_,h,v,A,H)}if(je(A)||we(A))return _=_.get(v)||null,E(h,_,A,H,null);if(typeof A.then=="function")return S(_,h,v,di(A),H);if(A.$$typeof===ce)return S(_,h,v,Il(h,A),H);pi(h,A)}return null}function X(_,h,v,A){for(var H=null,P=null,B=h,Q=h=0,Ye=null;B!==null&&Q<v.length;Q++){B.index>Q?(Ye=B,B=null):Ye=B.sibling;var ae=b(_,B,v[Q],A);if(ae===null){B===null&&(B=Ye);break}e&&B&&ae.alternate===null&&t(_,B),h=i(ae,h,Q),P===null?H=ae:P.sibling=ae,P=ae,B=Ye}if(Q===v.length)return a(_,B),ne&&Ea(_,Q),H;if(B===null){for(;Q<v.length;Q++)B=R(_,v[Q],A),B!==null&&(h=i(B,h,Q),P===null?H=B:P.sibling=B,P=B);return ne&&Ea(_,Q),H}for(B=n(B);Q<v.length;Q++)Ye=S(B,_,Q,v[Q],A),Ye!==null&&(e&&Ye.alternate!==null&&B.delete(Ye.key===null?Q:Ye.key),h=i(Ye,h,Q),P===null?H=Ye:P.sibling=Ye,P=Ye);return e&&B.forEach(function(ga){return t(_,ga)}),ne&&Ea(_,Q),H}function G(_,h,v,A){if(v==null)throw Error(r(151));for(var H=null,P=null,B=h,Q=h=0,Ye=null,ae=v.next();B!==null&&!ae.done;Q++,ae=v.next()){B.index>Q?(Ye=B,B=null):Ye=B.sibling;var ga=b(_,B,ae.value,A);if(ga===null){B===null&&(B=Ye);break}e&&B&&ga.alternate===null&&t(_,B),h=i(ga,h,Q),P===null?H=ga:P.sibling=ga,P=ga,B=Ye}if(ae.done)return a(_,B),ne&&Ea(_,Q),H;if(B===null){for(;!ae.done;Q++,ae=v.next())ae=R(_,ae.value,A),ae!==null&&(h=i(ae,h,Q),P===null?H=ae:P.sibling=ae,P=ae);return ne&&Ea(_,Q),H}for(B=n(B);!ae.done;Q++,ae=v.next())ae=S(B,_,Q,ae.value,A),ae!==null&&(e&&ae.alternate!==null&&B.delete(ae.key===null?Q:ae.key),h=i(ae,h,Q),P===null?H=ae:P.sibling=ae,P=ae);return e&&B.forEach(function(Cm){return t(_,Cm)}),ne&&Ea(_,Q),H}function de(_,h,v,A){if(typeof v=="object"&&v!==null&&v.type===ie&&v.key===null&&(v=v.props.children),typeof v=="object"&&v!==null){switch(v.$$typeof){case V:e:{for(var H=v.key;h!==null;){if(h.key===H){if(H=v.type,H===ie){if(h.tag===7){a(_,h.sibling),A=l(h,v.props.children),A.return=_,_=A;break e}}else if(h.elementType===H||typeof H=="object"&&H!==null&&H.$$typeof===ge&&qr(H)===h.type){a(_,h.sibling),A=l(h,v.props),al(A,v),A.return=_,_=A;break e}a(_,h);break}else t(_,h);h=h.sibling}v.type===ie?(A=wa(v.props.children,_.mode,A,v.key),A.return=_,_=A):(A=$l(v.type,v.key,v.props,null,_.mode,A),al(A,v),A.return=_,_=A)}return c(_);case ve:e:{for(H=v.key;h!==null;){if(h.key===H)if(h.tag===4&&h.stateNode.containerInfo===v.containerInfo&&h.stateNode.implementation===v.implementation){a(_,h.sibling),A=l(h,v.children||[]),A.return=_,_=A;break e}else{a(_,h);break}else t(_,h);h=h.sibling}A=qc(v,_.mode,A),A.return=_,_=A}return c(_);case ge:return H=v._init,v=H(v._payload),de(_,h,v,A)}if(je(v))return X(_,h,v,A);if(we(v)){if(H=we(v),typeof H!="function")throw Error(r(150));return v=H.call(v),G(_,h,v,A)}if(typeof v.then=="function")return de(_,h,di(v),A);if(v.$$typeof===ce)return de(_,h,Il(_,v),A);pi(_,v)}return typeof v=="string"&&v!==""||typeof v=="number"||typeof v=="bigint"?(v=""+v,h!==null&&h.tag===6?(a(_,h.sibling),A=l(h,v),A.return=_,_=A):(a(_,h),A=Uc(v,_.mode,A),A.return=_,_=A),c(_)):a(_,h)}return function(_,h,v,A){try{tl=0;var H=de(_,h,v,A);return sn=null,H}catch(B){if(B===Vn||B===ti)throw B;var P=ut(29,B,null,_.mode);return P.lanes=A,P.return=_,P}}}var rn=Cr(!0),jr=Cr(!1),bt=x(null),zt=null;function na(e){var t=e.alternate;M(Ue,Ue.current&1),M(bt,e),zt===null&&(t===null||ln.current!==null||t.memoizedState!==null)&&(zt=e)}function Hr(e){if(e.tag===22){if(M(Ue,Ue.current),M(bt,e),zt===null){var t=e.alternate;t!==null&&t.memoizedState!==null&&(zt=e)}}else la()}function la(){M(Ue,Ue.current),M(bt,bt.current)}function Yt(e){D(bt),zt===e&&(zt=null),D(Ue)}var Ue=x(0);function hi(e){for(var t=e;t!==null;){if(t.tag===13){var a=t.memoizedState;if(a!==null&&(a=a.dehydrated,a===null||a.data==="$?"||lu(a)))return t}else if(t.tag===19&&t.memoizedProps.revealOrder!==void 0){if((t.flags&128)!==0)return t}else if(t.child!==null){t.child.return=t,t=t.child;continue}if(t===e)break;for(;t.sibling===null;){if(t.return===null||t.return===e)return null;t=t.return}t.sibling.return=t.return,t=t.sibling}return null}function mo(e,t,a,n){t=e.memoizedState,a=a(n,t),a=a==null?t:N({},t,a),e.memoizedState=a,e.lanes===0&&(e.updateQueue.baseState=a)}var _o={enqueueSetState:function(e,t,a){e=e._reactInternals;var n=dt(),l=ea(n);l.payload=t,a!=null&&(l.callback=a),t=ta(e,l,n),t!==null&&(pt(t,e,n),Jn(t,e,n))},enqueueReplaceState:function(e,t,a){e=e._reactInternals;var n=dt(),l=ea(n);l.tag=1,l.payload=t,a!=null&&(l.callback=a),t=ta(e,l,n),t!==null&&(pt(t,e,n),Jn(t,e,n))},enqueueForceUpdate:function(e,t){e=e._reactInternals;var a=dt(),n=ea(a);n.tag=2,t!=null&&(n.callback=t),t=ta(e,n,a),t!==null&&(pt(t,e,a),Jn(t,e,a))}};function Br(e,t,a,n,l,i,c){return e=e.stateNode,typeof e.shouldComponentUpdate=="function"?e.shouldComponentUpdate(n,i,c):t.prototype&&t.prototype.isPureReactComponent?!Hn(a,n)||!Hn(l,i):!0}function Lr(e,t,a,n){e=t.state,typeof t.componentWillReceiveProps=="function"&&t.componentWillReceiveProps(a,n),typeof t.UNSAFE_componentWillReceiveProps=="function"&&t.UNSAFE_componentWillReceiveProps(a,n),t.state!==e&&_o.enqueueReplaceState(t,t.state,null)}function Oa(e,t){var a=t;if("ref"in t){a={};for(var n in t)n!=="ref"&&(a[n]=t[n])}if(e=e.defaultProps){a===t&&(a=N({},a));for(var l in e)a[l]===void 0&&(a[l]=e[l])}return a}var mi=typeof reportError=="function"?reportError:function(e){if(typeof window=="object"&&typeof window.ErrorEvent=="function"){var t=new window.ErrorEvent("error",{bubbles:!0,cancelable:!0,message:typeof e=="object"&&e!==null&&typeof e.message=="string"?String(e.message):String(e),error:e});if(!window.dispatchEvent(t))return}else if(typeof process=="object"&&typeof process.emit=="function"){process.emit("uncaughtException",e);return}console.error(e)};function Yr(e){mi(e)}function Gr(e){console.error(e)}function Qr(e){mi(e)}function _i(e,t){try{var a=e.onUncaughtError;a(t.value,{componentStack:t.stack})}catch(n){setTimeout(function(){throw n})}}function Xr(e,t,a){try{var n=e.onCaughtError;n(a.value,{componentStack:a.stack,errorBoundary:t.tag===1?t.stateNode:null})}catch(l){setTimeout(function(){throw l})}}function vo(e,t,a){return a=ea(a),a.tag=3,a.payload={element:null},a.callback=function(){_i(e,t)},a}function Zr(e){return e=ea(e),e.tag=3,e}function Vr(e,t,a,n){var l=a.type.getDerivedStateFromError;if(typeof l=="function"){var i=n.value;e.payload=function(){return l(i)},e.callback=function(){Xr(t,a,n)}}var c=a.stateNode;c!==null&&typeof c.componentDidCatch=="function"&&(e.callback=function(){Xr(t,a,n),typeof l!="function"&&(ra===null?ra=new Set([this]):ra.add(this));var u=n.stack;this.componentDidCatch(n.value,{componentStack:u!==null?u:""})})}function Ch(e,t,a,n,l){if(a.flags|=32768,n!==null&&typeof n=="object"&&typeof n.then=="function"){if(t=a.alternate,t!==null&&Qn(t,a,l,!0),a=bt.current,a!==null){switch(a.tag){case 13:return zt===null?Yo():a.alternate===null&&Ee===0&&(Ee=3),a.flags&=-257,a.flags|=65536,a.lanes=l,n===Zc?a.flags|=16384:(t=a.updateQueue,t===null?a.updateQueue=new Set([n]):t.add(n),Qo(e,n,l)),!1;case 22:return a.flags|=65536,n===Zc?a.flags|=16384:(t=a.updateQueue,t===null?(t={transitions:null,markerInstances:null,retryQueue:new Set([n])},a.updateQueue=t):(a=t.retryQueue,a===null?t.retryQueue=new Set([n]):a.add(n)),Qo(e,n,l)),!1}throw Error(r(435,a.tag))}return Qo(e,n,l),Yo(),!1}if(ne)return t=bt.current,t!==null?((t.flags&65536)===0&&(t.flags|=256),t.flags|=65536,t.lanes=l,n!==Hc&&(e=Error(r(422),{cause:n}),Gn(_t(e,a)))):(n!==Hc&&(t=Error(r(423),{cause:n}),Gn(_t(t,a))),e=e.current.alternate,e.flags|=65536,l&=-l,e.lanes|=l,n=_t(n,a),l=vo(e.stateNode,n,l),Jc(e,l),Ee!==4&&(Ee=2)),!1;var i=Error(r(520),{cause:n});if(i=_t(i,a),sl===null?sl=[i]:sl.push(i),Ee!==4&&(Ee=2),t===null)return!0;n=_t(n,a),a=t;do{switch(a.tag){case 3:return a.flags|=65536,e=l&-l,a.lanes|=e,e=vo(a.stateNode,n,e),Jc(a,e),!1;case 1:if(t=a.type,i=a.stateNode,(a.flags&128)===0&&(typeof t.getDerivedStateFromError=="function"||i!==null&&typeof i.componentDidCatch=="function"&&(ra===null||!ra.has(i))))return a.flags|=65536,l&=-l,a.lanes|=l,l=Zr(l),Vr(l,e,a,n),Jc(a,l),!1}a=a.return}while(a!==null);return!1}var Kr=Error(r(461)),Be=!1;function Ge(e,t,a,n){t.child=e===null?jr(t,null,a,n):rn(t,e.child,a,n)}function Jr(e,t,a,n,l){a=a.render;var i=t.ref;if("ref"in n){var c={};for(var u in n)u!=="ref"&&(c[u]=n[u])}else c=n;return Na(t),n=Ic(e,t,a,c,i,l),u=eo(),e!==null&&!Be?(to(e,t,l),Gt(e,t,l)):(ne&&u&&Cc(t),t.flags|=1,Ge(e,t,n,l),t.child)}function $r(e,t,a,n,l){if(e===null){var i=a.type;return typeof i=="function"&&!Oc(i)&&i.defaultProps===void 0&&a.compare===null?(t.tag=15,t.type=i,Wr(e,t,i,n,l)):(e=$l(a.type,null,n,t,t.mode,l),e.ref=t.ref,e.return=t,t.child=e)}if(i=e.child,!To(e,l)){var c=i.memoizedProps;if(a=a.compare,a=a!==null?a:Hn,a(c,n)&&e.ref===t.ref)return Gt(e,t,l)}return t.flags|=1,e=qt(i,n),e.ref=t.ref,e.return=t,t.child=e}function Wr(e,t,a,n,l){if(e!==null){var i=e.memoizedProps;if(Hn(i,n)&&e.ref===t.ref)if(Be=!1,t.pendingProps=n=i,To(e,l))(e.flags&131072)!==0&&(Be=!0);else return t.lanes=e.lanes,Gt(e,t,l)}return go(e,t,a,n,l)}function Fr(e,t,a){var n=t.pendingProps,l=n.children,i=e!==null?e.memoizedState:null;if(n.mode==="hidden"){if((t.flags&128)!==0){if(n=i!==null?i.baseLanes|a:a,e!==null){for(l=t.child=e.child,i=0;l!==null;)i=i|l.lanes|l.childLanes,l=l.sibling;t.childLanes=i&~n}else t.childLanes=0,t.child=null;return Pr(e,t,n,a)}if((a&536870912)!==0)t.memoizedState={baseLanes:0,cachePool:null},e!==null&&ei(t,i!==null?i.cachePool:null),i!==null?Ws(t,i):Wc(),Hr(t);else return t.lanes=t.childLanes=536870912,Pr(e,t,i!==null?i.baseLanes|a:a,a)}else i!==null?(ei(t,i.cachePool),Ws(t,i),la(),t.memoizedState=null):(e!==null&&ei(t,null),Wc(),la());return Ge(e,t,l,a),t.child}function Pr(e,t,a,n){var l=Xc();return l=l===null?null:{parent:Oe._currentValue,pool:l},t.memoizedState={baseLanes:a,cachePool:l},e!==null&&ei(t,null),Wc(),Hr(t),e!==null&&Qn(e,t,n,!0),null}function vi(e,t){var a=t.ref;if(a===null)e!==null&&e.ref!==null&&(t.flags|=4194816);else{if(typeof a!="function"&&typeof a!="object")throw Error(r(284));(e===null||e.ref!==a)&&(t.flags|=4194816)}}function go(e,t,a,n,l){return Na(t),a=Ic(e,t,a,n,void 0,l),n=eo(),e!==null&&!Be?(to(e,t,l),Gt(e,t,l)):(ne&&n&&Cc(t),t.flags|=1,Ge(e,t,a,l),t.child)}function Ir(e,t,a,n,l,i){return Na(t),t.updateQueue=null,a=Ps(t,n,a,l),Fs(e),n=eo(),e!==null&&!Be?(to(e,t,i),Gt(e,t,i)):(ne&&n&&Cc(t),t.flags|=1,Ge(e,t,a,i),t.child)}function ef(e,t,a,n,l){if(Na(t),t.stateNode===null){var i=Ia,c=a.contextType;typeof c=="object"&&c!==null&&(i=Ke(c)),i=new a(n,i),t.memoizedState=i.state!==null&&i.state!==void 0?i.state:null,i.updater=_o,t.stateNode=i,i._reactInternals=t,i=t.stateNode,i.props=n,i.state=t.memoizedState,i.refs={},Vc(t),c=a.contextType,i.context=typeof c=="object"&&c!==null?Ke(c):Ia,i.state=t.memoizedState,c=a.getDerivedStateFromProps,typeof c=="function"&&(mo(t,a,c,n),i.state=t.memoizedState),typeof a.getDerivedStateFromProps=="function"||typeof i.getSnapshotBeforeUpdate=="function"||typeof i.UNSAFE_componentWillMount!="function"&&typeof i.componentWillMount!="function"||(c=i.state,typeof i.componentWillMount=="function"&&i.componentWillMount(),typeof i.UNSAFE_componentWillMount=="function"&&i.UNSAFE_componentWillMount(),c!==i.state&&_o.enqueueReplaceState(i,i.state,null),Wn(t,n,i,l),$n(),i.state=t.memoizedState),typeof i.componentDidMount=="function"&&(t.flags|=4194308),n=!0}else if(e===null){i=t.stateNode;var u=t.memoizedProps,f=Oa(a,u);i.props=f;var y=i.context,E=a.contextType;c=Ia,typeof E=="object"&&E!==null&&(c=Ke(E));var R=a.getDerivedStateFromProps;E=typeof R=="function"||typeof i.getSnapshotBeforeUpdate=="function",u=t.pendingProps!==u,E||typeof i.UNSAFE_componentWillReceiveProps!="function"&&typeof i.componentWillReceiveProps!="function"||(u||y!==c)&&Lr(t,i,n,c),It=!1;var b=t.memoizedState;i.state=b,Wn(t,n,i,l),$n(),y=t.memoizedState,u||b!==y||It?(typeof R=="function"&&(mo(t,a,R,n),y=t.memoizedState),(f=It||Br(t,a,f,n,b,y,c))?(E||typeof i.UNSAFE_componentWillMount!="function"&&typeof i.componentWillMount!="function"||(typeof i.componentWillMount=="function"&&i.componentWillMount(),typeof i.UNSAFE_componentWillMount=="function"&&i.UNSAFE_componentWillMount()),typeof i.componentDidMount=="function"&&(t.flags|=4194308)):(typeof i.componentDidMount=="function"&&(t.flags|=4194308),t.memoizedProps=n,t.memoizedState=y),i.props=n,i.state=y,i.context=c,n=f):(typeof i.componentDidMount=="function"&&(t.flags|=4194308),n=!1)}else{i=t.stateNode,Kc(e,t),c=t.memoizedProps,E=Oa(a,c),i.props=E,R=t.pendingProps,b=i.context,y=a.contextType,f=Ia,typeof y=="object"&&y!==null&&(f=Ke(y)),u=a.getDerivedStateFromProps,(y=typeof u=="function"||typeof i.getSnapshotBeforeUpdate=="function")||typeof i.UNSAFE_componentWillReceiveProps!="function"&&typeof i.componentWillReceiveProps!="function"||(c!==R||b!==f)&&Lr(t,i,n,f),It=!1,b=t.memoizedState,i.state=b,Wn(t,n,i,l),$n();var S=t.memoizedState;c!==R||b!==S||It||e!==null&&e.dependencies!==null&&Pl(e.dependencies)?(typeof u=="function"&&(mo(t,a,u,n),S=t.memoizedState),(E=It||Br(t,a,E,n,b,S,f)||e!==null&&e.dependencies!==null&&Pl(e.dependencies))?(y||typeof i.UNSAFE_componentWillUpdate!="function"&&typeof i.componentWillUpdate!="function"||(typeof i.componentWillUpdate=="function"&&i.componentWillUpdate(n,S,f),typeof i.UNSAFE_componentWillUpdate=="function"&&i.UNSAFE_componentWillUpdate(n,S,f)),typeof i.componentDidUpdate=="function"&&(t.flags|=4),typeof i.getSnapshotBeforeUpdate=="function"&&(t.flags|=1024)):(typeof i.componentDidUpdate!="function"||c===e.memoizedProps&&b===e.memoizedState||(t.flags|=4),typeof i.getSnapshotBeforeUpdate!="function"||c===e.memoizedProps&&b===e.memoizedState||(t.flags|=1024),t.memoizedProps=n,t.memoizedState=S),i.props=n,i.state=S,i.context=f,n=E):(typeof i.componentDidUpdate!="function"||c===e.memoizedProps&&b===e.memoizedState||(t.flags|=4),typeof i.getSnapshotBeforeUpdate!="function"||c===e.memoizedProps&&b===e.memoizedState||(t.flags|=1024),n=!1)}return i=n,vi(e,t),n=(t.flags&128)!==0,i||n?(i=t.stateNode,a=n&&typeof a.getDerivedStateFromError!="function"?null:i.render(),t.flags|=1,e!==null&&n?(t.child=rn(t,e.child,null,l),t.child=rn(t,null,a,l)):Ge(e,t,a,l),t.memoizedState=i.state,e=t.child):e=Gt(e,t,l),e}function tf(e,t,a,n){return Yn(),t.flags|=256,Ge(e,t,a,n),t.child}var yo={dehydrated:null,treeContext:null,retryLane:0,hydrationErrors:null};function bo(e){return{baseLanes:e,cachePool:Gs()}}function So(e,t,a){return e=e!==null?e.childLanes&~a:0,t&&(e|=St),e}function af(e,t,a){var n=t.pendingProps,l=!1,i=(t.flags&128)!==0,c;if((c=i)||(c=e!==null&&e.memoizedState===null?!1:(Ue.current&2)!==0),c&&(l=!0,t.flags&=-129),c=(t.flags&32)!==0,t.flags&=-33,e===null){if(ne){if(l?na(t):la(),ne){var u=Te,f;if(f=u){e:{for(f=u,u=At;f.nodeType!==8;){if(!u){u=null;break e}if(f=Tt(f.nextSibling),f===null){u=null;break e}}u=f}u!==null?(t.memoizedState={dehydrated:u,treeContext:Ta!==null?{id:Ct,overflow:jt}:null,retryLane:536870912,hydrationErrors:null},f=ut(18,null,null,0),f.stateNode=u,f.return=t,t.child=f,$e=t,Te=null,f=!0):f=!1}f||za(t)}if(u=t.memoizedState,u!==null&&(u=u.dehydrated,u!==null))return lu(u)?t.lanes=32:t.lanes=536870912,null;Yt(t)}return u=n.children,n=n.fallback,l?(la(),l=t.mode,u=gi({mode:"hidden",children:u},l),n=wa(n,l,a,null),u.return=t,n.return=t,u.sibling=n,t.child=u,l=t.child,l.memoizedState=bo(a),l.childLanes=So(e,c,a),t.memoizedState=yo,n):(na(t),ko(t,u))}if(f=e.memoizedState,f!==null&&(u=f.dehydrated,u!==null)){if(i)t.flags&256?(na(t),t.flags&=-257,t=xo(e,t,a)):t.memoizedState!==null?(la(),t.child=e.child,t.flags|=128,t=null):(la(),l=n.fallback,u=t.mode,n=gi({mode:"visible",children:n.children},u),l=wa(l,u,a,null),l.flags|=2,n.return=t,l.return=t,n.sibling=l,t.child=n,rn(t,e.child,null,a),n=t.child,n.memoizedState=bo(a),n.childLanes=So(e,c,a),t.memoizedState=yo,t=l);else if(na(t),lu(u)){if(c=u.nextSibling&&u.nextSibling.dataset,c)var y=c.dgst;c=y,n=Error(r(419)),n.stack="",n.digest=c,Gn({value:n,source:null,stack:null}),t=xo(e,t,a)}else if(Be||Qn(e,t,a,!1),c=(a&e.childLanes)!==0,Be||c){if(c=he,c!==null&&(n=a&-a,n=(n&42)!==0?1:lc(n),n=(n&(c.suspendedLanes|a))!==0?0:n,n!==0&&n!==f.retryLane))throw f.retryLane=n,Pa(e,n),pt(c,e,n),Kr;u.data==="$?"||Yo(),t=xo(e,t,a)}else u.data==="$?"?(t.flags|=192,t.child=e.child,t=null):(e=f.treeContext,Te=Tt(u.nextSibling),$e=t,ne=!0,Aa=null,At=!1,e!==null&&(gt[yt++]=Ct,gt[yt++]=jt,gt[yt++]=Ta,Ct=e.id,jt=e.overflow,Ta=t),t=ko(t,n.children),t.flags|=4096);return t}return l?(la(),l=n.fallback,u=t.mode,f=e.child,y=f.sibling,n=qt(f,{mode:"hidden",children:n.children}),n.subtreeFlags=f.subtreeFlags&65011712,y!==null?l=qt(y,l):(l=wa(l,u,a,null),l.flags|=2),l.return=t,n.return=t,n.sibling=l,t.child=n,n=l,l=t.child,u=e.child.memoizedState,u===null?u=bo(a):(f=u.cachePool,f!==null?(y=Oe._currentValue,f=f.parent!==y?{parent:y,pool:y}:f):f=Gs(),u={baseLanes:u.baseLanes|a,cachePool:f}),l.memoizedState=u,l.childLanes=So(e,c,a),t.memoizedState=yo,n):(na(t),a=e.child,e=a.sibling,a=qt(a,{mode:"visible",children:n.children}),a.return=t,a.sibling=null,e!==null&&(c=t.deletions,c===null?(t.deletions=[e],t.flags|=16):c.push(e)),t.child=a,t.memoizedState=null,a)}function ko(e,t){return t=gi({mode:"visible",children:t},e.mode),t.return=e,e.child=t}function gi(e,t){return e=ut(22,e,null,t),e.lanes=0,e.stateNode={_visibility:1,_pendingMarkers:null,_retryCache:null,_transitions:null},e}function xo(e,t,a){return rn(t,e.child,null,a),e=ko(t,t.pendingProps.children),e.flags|=2,t.memoizedState=null,e}function nf(e,t,a){e.lanes|=t;var n=e.alternate;n!==null&&(n.lanes|=t),Lc(e.return,t,a)}function wo(e,t,a,n,l){var i=e.memoizedState;i===null?e.memoizedState={isBackwards:t,rendering:null,renderingStartTime:0,last:n,tail:a,tailMode:l}:(i.isBackwards=t,i.rendering=null,i.renderingStartTime=0,i.last=n,i.tail=a,i.tailMode=l)}function lf(e,t,a){var n=t.pendingProps,l=n.revealOrder,i=n.tail;if(Ge(e,t,n.children,a),n=Ue.current,(n&2)!==0)n=n&1|2,t.flags|=128;else{if(e!==null&&(e.flags&128)!==0)e:for(e=t.child;e!==null;){if(e.tag===13)e.memoizedState!==null&&nf(e,a,t);else if(e.tag===19)nf(e,a,t);else if(e.child!==null){e.child.return=e,e=e.child;continue}if(e===t)break e;for(;e.sibling===null;){if(e.return===null||e.return===t)break e;e=e.return}e.sibling.return=e.return,e=e.sibling}n&=1}switch(M(Ue,n),l){case"forwards":for(a=t.child,l=null;a!==null;)e=a.alternate,e!==null&&hi(e)===null&&(l=a),a=a.sibling;a=l,a===null?(l=t.child,t.child=null):(l=a.sibling,a.sibling=null),wo(t,!1,l,a,i);break;case"backwards":for(a=null,l=t.child,t.child=null;l!==null;){if(e=l.alternate,e!==null&&hi(e)===null){t.child=l;break}e=l.sibling,l.sibling=a,a=l,l=e}wo(t,!0,a,null,i);break;case"together":wo(t,!1,null,null,void 0);break;default:t.memoizedState=null}return t.child}function Gt(e,t,a){if(e!==null&&(t.dependencies=e.dependencies),sa|=t.lanes,(a&t.childLanes)===0)if(e!==null){if(Qn(e,t,a,!1),(a&t.childLanes)===0)return null}else return null;if(e!==null&&t.child!==e.child)throw Error(r(153));if(t.child!==null){for(e=t.child,a=qt(e,e.pendingProps),t.child=a,a.return=t;e.sibling!==null;)e=e.sibling,a=a.sibling=qt(e,e.pendingProps),a.return=t;a.sibling=null}return t.child}function To(e,t){return(e.lanes&t)!==0?!0:(e=e.dependencies,!!(e!==null&&Pl(e)))}function jh(e,t,a){switch(t.tag){case 3:ye(t,t.stateNode.containerInfo),Pt(t,Oe,e.memoizedState.cache),Yn();break;case 27:case 5:Ii(t);break;case 4:ye(t,t.stateNode.containerInfo);break;case 10:Pt(t,t.type,t.memoizedProps.value);break;case 13:var n=t.memoizedState;if(n!==null)return n.dehydrated!==null?(na(t),t.flags|=128,null):(a&t.child.childLanes)!==0?af(e,t,a):(na(t),e=Gt(e,t,a),e!==null?e.sibling:null);na(t);break;case 19:var l=(e.flags&128)!==0;if(n=(a&t.childLanes)!==0,n||(Qn(e,t,a,!1),n=(a&t.childLanes)!==0),l){if(n)return lf(e,t,a);t.flags|=128}if(l=t.memoizedState,l!==null&&(l.rendering=null,l.tail=null,l.lastEffect=null),M(Ue,Ue.current),n)break;return null;case 22:case 23:return t.lanes=0,Fr(e,t,a);case 24:Pt(t,Oe,e.memoizedState.cache)}return Gt(e,t,a)}function cf(e,t,a){if(e!==null)if(e.memoizedProps!==t.pendingProps)Be=!0;else{if(!To(e,a)&&(t.flags&128)===0)return Be=!1,jh(e,t,a);Be=(e.flags&131072)!==0}else Be=!1,ne&&(t.flags&1048576)!==0&&qs(t,Fl,t.index);switch(t.lanes=0,t.tag){case 16:e:{e=t.pendingProps;var n=t.elementType,l=n._init;if(n=l(n._payload),t.type=n,typeof n=="function")Oc(n)?(e=Oa(n,e),t.tag=1,t=ef(null,t,n,e,a)):(t.tag=0,t=go(null,t,n,e,a));else{if(n!=null){if(l=n.$$typeof,l===qe){t.tag=11,t=Jr(null,t,n,e,a);break e}else if(l===_e){t.tag=14,t=$r(null,t,n,e,a);break e}}throw t=nt(n)||n,Error(r(306,t,""))}}return t;case 0:return go(e,t,t.type,t.pendingProps,a);case 1:return n=t.type,l=Oa(n,t.pendingProps),ef(e,t,n,l,a);case 3:e:{if(ye(t,t.stateNode.containerInfo),e===null)throw Error(r(387));n=t.pendingProps;var i=t.memoizedState;l=i.element,Kc(e,t),Wn(t,n,null,a);var c=t.memoizedState;if(n=c.cache,Pt(t,Oe,n),n!==i.cache&&Yc(t,[Oe],a,!0),$n(),n=c.element,i.isDehydrated)if(i={element:n,isDehydrated:!1,cache:c.cache},t.updateQueue.baseState=i,t.memoizedState=i,t.flags&256){t=tf(e,t,n,a);break e}else if(n!==l){l=_t(Error(r(424)),t),Gn(l),t=tf(e,t,n,a);break e}else for(e=t.stateNode.containerInfo,e.nodeType===9?e=e.body:e=e.nodeName==="HTML"?e.ownerDocument.body:e,Te=Tt(e.firstChild),$e=t,ne=!0,Aa=null,At=!0,a=jr(t,null,n,a),t.child=a;a;)a.flags=a.flags&-3|4096,a=a.sibling;else{if(Yn(),n===l){t=Gt(e,t,a);break e}Ge(e,t,n,a)}t=t.child}return t;case 26:return vi(e,t),e===null?(a=rd(t.type,null,t.pendingProps,null))?t.memoizedState=a:ne||(a=t.type,e=t.pendingProps,n=Mi(Z.current).createElement(a),n[Ve]=t,n[We]=e,Xe(n,a,e),He(n),t.stateNode=n):t.memoizedState=rd(t.type,e.memoizedProps,t.pendingProps,e.memoizedState),null;case 27:return Ii(t),e===null&&ne&&(n=t.stateNode=od(t.type,t.pendingProps,Z.current),$e=t,At=!0,l=Te,pa(t.type)?(iu=l,Te=Tt(n.firstChild)):Te=l),Ge(e,t,t.pendingProps.children,a),vi(e,t),e===null&&(t.flags|=4194304),t.child;case 5:return e===null&&ne&&((l=n=Te)&&(n=fm(n,t.type,t.pendingProps,At),n!==null?(t.stateNode=n,$e=t,Te=Tt(n.firstChild),At=!1,l=!0):l=!1),l||za(t)),Ii(t),l=t.type,i=t.pendingProps,c=e!==null?e.memoizedProps:null,n=i.children,tu(l,i)?n=null:c!==null&&tu(l,c)&&(t.flags|=32),t.memoizedState!==null&&(l=Ic(e,t,Rh,null,null,a),gl._currentValue=l),vi(e,t),Ge(e,t,n,a),t.child;case 6:return e===null&&ne&&((e=a=Te)&&(a=dm(a,t.pendingProps,At),a!==null?(t.stateNode=a,$e=t,Te=null,e=!0):e=!1),e||za(t)),null;case 13:return af(e,t,a);case 4:return ye(t,t.stateNode.containerInfo),n=t.pendingProps,e===null?t.child=rn(t,null,n,a):Ge(e,t,n,a),t.child;case 11:return Jr(e,t,t.type,t.pendingProps,a);case 7:return Ge(e,t,t.pendingProps,a),t.child;case 8:return Ge(e,t,t.pendingProps.children,a),t.child;case 12:return Ge(e,t,t.pendingProps.children,a),t.child;case 10:return n=t.pendingProps,Pt(t,t.type,n.value),Ge(e,t,n.children,a),t.child;case 9:return l=t.type._context,n=t.pendingProps.children,Na(t),l=Ke(l),n=n(l),t.flags|=1,Ge(e,t,n,a),t.child;case 14:return $r(e,t,t.type,t.pendingProps,a);case 15:return Wr(e,t,t.type,t.pendingProps,a);case 19:return lf(e,t,a);case 31:return n=t.pendingProps,a=t.mode,n={mode:n.mode,children:n.children},e===null?(a=gi(n,a),a.ref=t.ref,t.child=a,a.return=t,t=a):(a=qt(e.child,n),a.ref=t.ref,t.child=a,a.return=t,t=a),t;case 22:return Fr(e,t,a);case 24:return Na(t),n=Ke(Oe),e===null?(l=Xc(),l===null&&(l=he,i=Gc(),l.pooledCache=i,i.refCount++,i!==null&&(l.pooledCacheLanes|=a),l=i),t.memoizedState={parent:n,cache:l},Vc(t),Pt(t,Oe,l)):((e.lanes&a)!==0&&(Kc(e,t),Wn(t,null,null,a),$n()),l=e.memoizedState,i=t.memoizedState,l.parent!==n?(l={parent:n,cache:n},t.memoizedState=l,t.lanes===0&&(t.memoizedState=t.updateQueue.baseState=l),Pt(t,Oe,n)):(n=i.cache,Pt(t,Oe,n),n!==l.cache&&Yc(t,[Oe],a,!0))),Ge(e,t,t.pendingProps.children,a),t.child;case 29:throw t.pendingProps}throw Error(r(156,t.tag))}function Qt(e){e.flags|=4}function of(e,t){if(t.type!=="stylesheet"||(t.state.loading&4)!==0)e.flags&=-16777217;else if(e.flags|=16777216,!md(t)){if(t=bt.current,t!==null&&((te&4194048)===te?zt!==null:(te&62914560)!==te&&(te&536870912)===0||t!==zt))throw Kn=Zc,Qs;e.flags|=8192}}function yi(e,t){t!==null&&(e.flags|=4),e.flags&16384&&(t=e.tag!==22?Hu():536870912,e.lanes|=t,hn|=t)}function nl(e,t){if(!ne)switch(e.tailMode){case"hidden":t=e.tail;for(var a=null;t!==null;)t.alternate!==null&&(a=t),t=t.sibling;a===null?e.tail=null:a.sibling=null;break;case"collapsed":a=e.tail;for(var n=null;a!==null;)a.alternate!==null&&(n=a),a=a.sibling;n===null?t||e.tail===null?e.tail=null:e.tail.sibling=null:n.sibling=null}}function ke(e){var t=e.alternate!==null&&e.alternate.child===e.child,a=0,n=0;if(t)for(var l=e.child;l!==null;)a|=l.lanes|l.childLanes,n|=l.subtreeFlags&65011712,n|=l.flags&65011712,l.return=e,l=l.sibling;else for(l=e.child;l!==null;)a|=l.lanes|l.childLanes,n|=l.subtreeFlags,n|=l.flags,l.return=e,l=l.sibling;return e.subtreeFlags|=n,e.childLanes=a,t}function Hh(e,t,a){var n=t.pendingProps;switch(jc(t),t.tag){case 31:case 16:case 15:case 0:case 11:case 7:case 8:case 12:case 9:case 14:return ke(t),null;case 1:return ke(t),null;case 3:return a=t.stateNode,n=null,e!==null&&(n=e.memoizedState.cache),t.memoizedState.cache!==n&&(t.flags|=2048),Bt(Oe),Jt(),a.pendingContext&&(a.context=a.pendingContext,a.pendingContext=null),(e===null||e.child===null)&&(Ln(t)?Qt(t):e===null||e.memoizedState.isDehydrated&&(t.flags&256)===0||(t.flags|=1024,Hs())),ke(t),null;case 26:return a=t.memoizedState,e===null?(Qt(t),a!==null?(ke(t),of(t,a)):(ke(t),t.flags&=-16777217)):a?a!==e.memoizedState?(Qt(t),ke(t),of(t,a)):(ke(t),t.flags&=-16777217):(e.memoizedProps!==n&&Qt(t),ke(t),t.flags&=-16777217),null;case 27:Nl(t),a=Z.current;var l=t.type;if(e!==null&&t.stateNode!=null)e.memoizedProps!==n&&Qt(t);else{if(!n){if(t.stateNode===null)throw Error(r(166));return ke(t),null}e=j.current,Ln(t)?Cs(t):(e=od(l,n,a),t.stateNode=e,Qt(t))}return ke(t),null;case 5:if(Nl(t),a=t.type,e!==null&&t.stateNode!=null)e.memoizedProps!==n&&Qt(t);else{if(!n){if(t.stateNode===null)throw Error(r(166));return ke(t),null}if(e=j.current,Ln(t))Cs(t);else{switch(l=Mi(Z.current),e){case 1:e=l.createElementNS("http://www.w3.org/2000/svg",a);break;case 2:e=l.createElementNS("http://www.w3.org/1998/Math/MathML",a);break;default:switch(a){case"svg":e=l.createElementNS("http://www.w3.org/2000/svg",a);break;case"math":e=l.createElementNS("http://www.w3.org/1998/Math/MathML",a);break;case"script":e=l.createElement("div"),e.innerHTML="<script><\/script>",e=e.removeChild(e.firstChild);break;case"select":e=typeof n.is=="string"?l.createElement("select",{is:n.is}):l.createElement("select"),n.multiple?e.multiple=!0:n.size&&(e.size=n.size);break;default:e=typeof n.is=="string"?l.createElement(a,{is:n.is}):l.createElement(a)}}e[Ve]=t,e[We]=n;e:for(l=t.child;l!==null;){if(l.tag===5||l.tag===6)e.appendChild(l.stateNode);else if(l.tag!==4&&l.tag!==27&&l.child!==null){l.child.return=l,l=l.child;continue}if(l===t)break e;for(;l.sibling===null;){if(l.return===null||l.return===t)break e;l=l.return}l.sibling.return=l.return,l=l.sibling}t.stateNode=e;e:switch(Xe(e,a,n),a){case"button":case"input":case"select":case"textarea":e=!!n.autoFocus;break e;case"img":e=!0;break e;default:e=!1}e&&Qt(t)}}return ke(t),t.flags&=-16777217,null;case 6:if(e&&t.stateNode!=null)e.memoizedProps!==n&&Qt(t);else{if(typeof n!="string"&&t.stateNode===null)throw Error(r(166));if(e=Z.current,Ln(t)){if(e=t.stateNode,a=t.memoizedProps,n=null,l=$e,l!==null)switch(l.tag){case 27:case 5:n=l.memoizedProps}e[Ve]=t,e=!!(e.nodeValue===a||n!==null&&n.suppressHydrationWarning===!0||ed(e.nodeValue,a)),e||za(t)}else e=Mi(e).createTextNode(n),e[Ve]=t,t.stateNode=e}return ke(t),null;case 13:if(n=t.memoizedState,e===null||e.memoizedState!==null&&e.memoizedState.dehydrated!==null){if(l=Ln(t),n!==null&&n.dehydrated!==null){if(e===null){if(!l)throw Error(r(318));if(l=t.memoizedState,l=l!==null?l.dehydrated:null,!l)throw Error(r(317));l[Ve]=t}else Yn(),(t.flags&128)===0&&(t.memoizedState=null),t.flags|=4;ke(t),l=!1}else l=Hs(),e!==null&&e.memoizedState!==null&&(e.memoizedState.hydrationErrors=l),l=!0;if(!l)return t.flags&256?(Yt(t),t):(Yt(t),null)}if(Yt(t),(t.flags&128)!==0)return t.lanes=a,t;if(a=n!==null,e=e!==null&&e.memoizedState!==null,a){n=t.child,l=null,n.alternate!==null&&n.alternate.memoizedState!==null&&n.alternate.memoizedState.cachePool!==null&&(l=n.alternate.memoizedState.cachePool.pool);var i=null;n.memoizedState!==null&&n.memoizedState.cachePool!==null&&(i=n.memoizedState.cachePool.pool),i!==l&&(n.flags|=2048)}return a!==e&&a&&(t.child.flags|=8192),yi(t,t.updateQueue),ke(t),null;case 4:return Jt(),e===null&&Wo(t.stateNode.containerInfo),ke(t),null;case 10:return Bt(t.type),ke(t),null;case 19:if(D(Ue),l=t.memoizedState,l===null)return ke(t),null;if(n=(t.flags&128)!==0,i=l.rendering,i===null)if(n)nl(l,!1);else{if(Ee!==0||e!==null&&(e.flags&128)!==0)for(e=t.child;e!==null;){if(i=hi(e),i!==null){for(t.flags|=128,nl(l,!1),e=i.updateQueue,t.updateQueue=e,yi(t,e),t.subtreeFlags=0,e=a,a=t.child;a!==null;)Us(a,e),a=a.sibling;return M(Ue,Ue.current&1|2),t.child}e=e.sibling}l.tail!==null&&Et()>ki&&(t.flags|=128,n=!0,nl(l,!1),t.lanes=4194304)}else{if(!n)if(e=hi(i),e!==null){if(t.flags|=128,n=!0,e=e.updateQueue,t.updateQueue=e,yi(t,e),nl(l,!0),l.tail===null&&l.tailMode==="hidden"&&!i.alternate&&!ne)return ke(t),null}else 2*Et()-l.renderingStartTime>ki&&a!==536870912&&(t.flags|=128,n=!0,nl(l,!1),t.lanes=4194304);l.isBackwards?(i.sibling=t.child,t.child=i):(e=l.last,e!==null?e.sibling=i:t.child=i,l.last=i)}return l.tail!==null?(t=l.tail,l.rendering=t,l.tail=t.sibling,l.renderingStartTime=Et(),t.sibling=null,e=Ue.current,M(Ue,n?e&1|2:e&1),t):(ke(t),null);case 22:case 23:return Yt(t),Fc(),n=t.memoizedState!==null,e!==null?e.memoizedState!==null!==n&&(t.flags|=8192):n&&(t.flags|=8192),n?(a&536870912)!==0&&(t.flags&128)===0&&(ke(t),t.subtreeFlags&6&&(t.flags|=8192)):ke(t),a=t.updateQueue,a!==null&&yi(t,a.retryQueue),a=null,e!==null&&e.memoizedState!==null&&e.memoizedState.cachePool!==null&&(a=e.memoizedState.cachePool.pool),n=null,t.memoizedState!==null&&t.memoizedState.cachePool!==null&&(n=t.memoizedState.cachePool.pool),n!==a&&(t.flags|=2048),e!==null&&D(Da),null;case 24:return a=null,e!==null&&(a=e.memoizedState.cache),t.memoizedState.cache!==a&&(t.flags|=2048),Bt(Oe),ke(t),null;case 25:return null;case 30:return null}throw Error(r(156,t.tag))}function Bh(e,t){switch(jc(t),t.tag){case 1:return e=t.flags,e&65536?(t.flags=e&-65537|128,t):null;case 3:return Bt(Oe),Jt(),e=t.flags,(e&65536)!==0&&(e&128)===0?(t.flags=e&-65537|128,t):null;case 26:case 27:case 5:return Nl(t),null;case 13:if(Yt(t),e=t.memoizedState,e!==null&&e.dehydrated!==null){if(t.alternate===null)throw Error(r(340));Yn()}return e=t.flags,e&65536?(t.flags=e&-65537|128,t):null;case 19:return D(Ue),null;case 4:return Jt(),null;case 10:return Bt(t.type),null;case 22:case 23:return Yt(t),Fc(),e!==null&&D(Da),e=t.flags,e&65536?(t.flags=e&-65537|128,t):null;case 24:return Bt(Oe),null;case 25:return null;default:return null}}function uf(e,t){switch(jc(t),t.tag){case 3:Bt(Oe),Jt();break;case 26:case 27:case 5:Nl(t);break;case 4:Jt();break;case 13:Yt(t);break;case 19:D(Ue);break;case 10:Bt(t.type);break;case 22:case 23:Yt(t),Fc(),e!==null&&D(Da);break;case 24:Bt(Oe)}}function ll(e,t){try{var a=t.updateQueue,n=a!==null?a.lastEffect:null;if(n!==null){var l=n.next;a=l;do{if((a.tag&e)===e){n=void 0;var i=a.create,c=a.inst;n=i(),c.destroy=n}a=a.next}while(a!==l)}}catch(u){pe(t,t.return,u)}}function ia(e,t,a){try{var n=t.updateQueue,l=n!==null?n.lastEffect:null;if(l!==null){var i=l.next;n=i;do{if((n.tag&e)===e){var c=n.inst,u=c.destroy;if(u!==void 0){c.destroy=void 0,l=t;var f=a,y=u;try{y()}catch(E){pe(l,f,E)}}}n=n.next}while(n!==i)}}catch(E){pe(t,t.return,E)}}function sf(e){var t=e.updateQueue;if(t!==null){var a=e.stateNode;try{$s(t,a)}catch(n){pe(e,e.return,n)}}}function rf(e,t,a){a.props=Oa(e.type,e.memoizedProps),a.state=e.memoizedState;try{a.componentWillUnmount()}catch(n){pe(e,t,n)}}function il(e,t){try{var a=e.ref;if(a!==null){switch(e.tag){case 26:case 27:case 5:var n=e.stateNode;break;case 30:n=e.stateNode;break;default:n=e.stateNode}typeof a=="function"?e.refCleanup=a(n):a.current=n}}catch(l){pe(e,t,l)}}function Rt(e,t){var a=e.ref,n=e.refCleanup;if(a!==null)if(typeof n=="function")try{n()}catch(l){pe(e,t,l)}finally{e.refCleanup=null,e=e.alternate,e!=null&&(e.refCleanup=null)}else if(typeof a=="function")try{a(null)}catch(l){pe(e,t,l)}else a.current=null}function ff(e){var t=e.type,a=e.memoizedProps,n=e.stateNode;try{e:switch(t){case"button":case"input":case"select":case"textarea":a.autoFocus&&n.focus();break e;case"img":a.src?n.src=a.src:a.srcSet&&(n.srcset=a.srcSet)}}catch(l){pe(e,e.return,l)}}function Eo(e,t,a){try{var n=e.stateNode;cm(n,e.type,a,t),n[We]=t}catch(l){pe(e,e.return,l)}}function df(e){return e.tag===5||e.tag===3||e.tag===26||e.tag===27&&pa(e.type)||e.tag===4}function Ao(e){e:for(;;){for(;e.sibling===null;){if(e.return===null||df(e.return))return null;e=e.return}for(e.sibling.return=e.return,e=e.sibling;e.tag!==5&&e.tag!==6&&e.tag!==18;){if(e.tag===27&&pa(e.type)||e.flags&2||e.child===null||e.tag===4)continue e;e.child.return=e,e=e.child}if(!(e.flags&2))return e.stateNode}}function zo(e,t,a){var n=e.tag;if(n===5||n===6)e=e.stateNode,t?(a.nodeType===9?a.body:a.nodeName==="HTML"?a.ownerDocument.body:a).insertBefore(e,t):(t=a.nodeType===9?a.body:a.nodeName==="HTML"?a.ownerDocument.body:a,t.appendChild(e),a=a._reactRootContainer,a!=null||t.onclick!==null||(t.onclick=Di));else if(n!==4&&(n===27&&pa(e.type)&&(a=e.stateNode,t=null),e=e.child,e!==null))for(zo(e,t,a),e=e.sibling;e!==null;)zo(e,t,a),e=e.sibling}function bi(e,t,a){var n=e.tag;if(n===5||n===6)e=e.stateNode,t?a.insertBefore(e,t):a.appendChild(e);else if(n!==4&&(n===27&&pa(e.type)&&(a=e.stateNode),e=e.child,e!==null))for(bi(e,t,a),e=e.sibling;e!==null;)bi(e,t,a),e=e.sibling}function pf(e){var t=e.stateNode,a=e.memoizedProps;try{for(var n=e.type,l=t.attributes;l.length;)t.removeAttributeNode(l[0]);Xe(t,n,a),t[Ve]=e,t[We]=a}catch(i){pe(e,e.return,i)}}var Xt=!1,Re=!1,Ro=!1,hf=typeof WeakSet=="function"?WeakSet:Set,Le=null;function Lh(e,t){if(e=e.containerInfo,Io=Hi,e=ws(e),Ec(e)){if("selectionStart"in e)var a={start:e.selectionStart,end:e.selectionEnd};else e:{a=(a=e.ownerDocument)&&a.defaultView||window;var n=a.getSelection&&a.getSelection();if(n&&n.rangeCount!==0){a=n.anchorNode;var l=n.anchorOffset,i=n.focusNode;n=n.focusOffset;try{a.nodeType,i.nodeType}catch{a=null;break e}var c=0,u=-1,f=-1,y=0,E=0,R=e,b=null;t:for(;;){for(var S;R!==a||l!==0&&R.nodeType!==3||(u=c+l),R!==i||n!==0&&R.nodeType!==3||(f=c+n),R.nodeType===3&&(c+=R.nodeValue.length),(S=R.firstChild)!==null;)b=R,R=S;for(;;){if(R===e)break t;if(b===a&&++y===l&&(u=c),b===i&&++E===n&&(f=c),(S=R.nextSibling)!==null)break;R=b,b=R.parentNode}R=S}a=u===-1||f===-1?null:{start:u,end:f}}else a=null}a=a||{start:0,end:0}}else a=null;for(eu={focusedElem:e,selectionRange:a},Hi=!1,Le=t;Le!==null;)if(t=Le,e=t.child,(t.subtreeFlags&1024)!==0&&e!==null)e.return=t,Le=e;else for(;Le!==null;){switch(t=Le,i=t.alternate,e=t.flags,t.tag){case 0:break;case 11:case 15:break;case 1:if((e&1024)!==0&&i!==null){e=void 0,a=t,l=i.memoizedProps,i=i.memoizedState,n=a.stateNode;try{var X=Oa(a.type,l,a.elementType===a.type);e=n.getSnapshotBeforeUpdate(X,i),n.__reactInternalSnapshotBeforeUpdate=e}catch(G){pe(a,a.return,G)}}break;case 3:if((e&1024)!==0){if(e=t.stateNode.containerInfo,a=e.nodeType,a===9)nu(e);else if(a===1)switch(e.nodeName){case"HEAD":case"HTML":case"BODY":nu(e);break;default:e.textContent=""}}break;case 5:case 26:case 27:case 6:case 4:case 17:break;default:if((e&1024)!==0)throw Error(r(163))}if(e=t.sibling,e!==null){e.return=t.return,Le=e;break}Le=t.return}}function mf(e,t,a){var n=a.flags;switch(a.tag){case 0:case 11:case 15:ca(e,a),n&4&&ll(5,a);break;case 1:if(ca(e,a),n&4)if(e=a.stateNode,t===null)try{e.componentDidMount()}catch(c){pe(a,a.return,c)}else{var l=Oa(a.type,t.memoizedProps);t=t.memoizedState;try{e.componentDidUpdate(l,t,e.__reactInternalSnapshotBeforeUpdate)}catch(c){pe(a,a.return,c)}}n&64&&sf(a),n&512&&il(a,a.return);break;case 3:if(ca(e,a),n&64&&(e=a.updateQueue,e!==null)){if(t=null,a.child!==null)switch(a.child.tag){case 27:case 5:t=a.child.stateNode;break;case 1:t=a.child.stateNode}try{$s(e,t)}catch(c){pe(a,a.return,c)}}break;case 27:t===null&&n&4&&pf(a);case 26:case 5:ca(e,a),t===null&&n&4&&ff(a),n&512&&il(a,a.return);break;case 12:ca(e,a);break;case 13:ca(e,a),n&4&&gf(e,a),n&64&&(e=a.memoizedState,e!==null&&(e=e.dehydrated,e!==null&&(a=$h.bind(null,a),pm(e,a))));break;case 22:if(n=a.memoizedState!==null||Xt,!n){t=t!==null&&t.memoizedState!==null||Re,l=Xt;var i=Re;Xt=n,(Re=t)&&!i?oa(e,a,(a.subtreeFlags&8772)!==0):ca(e,a),Xt=l,Re=i}break;case 30:break;default:ca(e,a)}}function _f(e){var t=e.alternate;t!==null&&(e.alternate=null,_f(t)),e.child=null,e.deletions=null,e.sibling=null,e.tag===5&&(t=e.stateNode,t!==null&&oc(t)),e.stateNode=null,e.return=null,e.dependencies=null,e.memoizedProps=null,e.memoizedState=null,e.pendingProps=null,e.stateNode=null,e.updateQueue=null}var be=null,Ie=!1;function Zt(e,t,a){for(a=a.child;a!==null;)vf(e,t,a),a=a.sibling}function vf(e,t,a){if(it&&typeof it.onCommitFiberUnmount=="function")try{it.onCommitFiberUnmount(En,a)}catch{}switch(a.tag){case 26:Re||Rt(a,t),Zt(e,t,a),a.memoizedState?a.memoizedState.count--:a.stateNode&&(a=a.stateNode,a.parentNode.removeChild(a));break;case 27:Re||Rt(a,t);var n=be,l=Ie;pa(a.type)&&(be=a.stateNode,Ie=!1),Zt(e,t,a),hl(a.stateNode),be=n,Ie=l;break;case 5:Re||Rt(a,t);case 6:if(n=be,l=Ie,be=null,Zt(e,t,a),be=n,Ie=l,be!==null)if(Ie)try{(be.nodeType===9?be.body:be.nodeName==="HTML"?be.ownerDocument.body:be).removeChild(a.stateNode)}catch(i){pe(a,t,i)}else try{be.removeChild(a.stateNode)}catch(i){pe(a,t,i)}break;case 18:be!==null&&(Ie?(e=be,id(e.nodeType===9?e.body:e.nodeName==="HTML"?e.ownerDocument.body:e,a.stateNode),kl(e)):id(be,a.stateNode));break;case 4:n=be,l=Ie,be=a.stateNode.containerInfo,Ie=!0,Zt(e,t,a),be=n,Ie=l;break;case 0:case 11:case 14:case 15:Re||ia(2,a,t),Re||ia(4,a,t),Zt(e,t,a);break;case 1:Re||(Rt(a,t),n=a.stateNode,typeof n.componentWillUnmount=="function"&&rf(a,t,n)),Zt(e,t,a);break;case 21:Zt(e,t,a);break;case 22:Re=(n=Re)||a.memoizedState!==null,Zt(e,t,a),Re=n;break;default:Zt(e,t,a)}}function gf(e,t){if(t.memoizedState===null&&(e=t.alternate,e!==null&&(e=e.memoizedState,e!==null&&(e=e.dehydrated,e!==null))))try{kl(e)}catch(a){pe(t,t.return,a)}}function Yh(e){switch(e.tag){case 13:case 19:var t=e.stateNode;return t===null&&(t=e.stateNode=new hf),t;case 22:return e=e.stateNode,t=e._retryCache,t===null&&(t=e._retryCache=new hf),t;default:throw Error(r(435,e.tag))}}function No(e,t){var a=Yh(e);t.forEach(function(n){var l=Wh.bind(null,e,n);a.has(n)||(a.add(n),n.then(l,l))})}function st(e,t){var a=t.deletions;if(a!==null)for(var n=0;n<a.length;n++){var l=a[n],i=e,c=t,u=c;e:for(;u!==null;){switch(u.tag){case 27:if(pa(u.type)){be=u.stateNode,Ie=!1;break e}break;case 5:be=u.stateNode,Ie=!1;break e;case 3:case 4:be=u.stateNode.containerInfo,Ie=!0;break e}u=u.return}if(be===null)throw Error(r(160));vf(i,c,l),be=null,Ie=!1,i=l.alternate,i!==null&&(i.return=null),l.return=null}if(t.subtreeFlags&13878)for(t=t.child;t!==null;)yf(t,e),t=t.sibling}var wt=null;function yf(e,t){var a=e.alternate,n=e.flags;switch(e.tag){case 0:case 11:case 14:case 15:st(t,e),rt(e),n&4&&(ia(3,e,e.return),ll(3,e),ia(5,e,e.return));break;case 1:st(t,e),rt(e),n&512&&(Re||a===null||Rt(a,a.return)),n&64&&Xt&&(e=e.updateQueue,e!==null&&(n=e.callbacks,n!==null&&(a=e.shared.hiddenCallbacks,e.shared.hiddenCallbacks=a===null?n:a.concat(n))));break;case 26:var l=wt;if(st(t,e),rt(e),n&512&&(Re||a===null||Rt(a,a.return)),n&4){var i=a!==null?a.memoizedState:null;if(n=e.memoizedState,a===null)if(n===null)if(e.stateNode===null){e:{n=e.type,a=e.memoizedProps,l=l.ownerDocument||l;t:switch(n){case"title":i=l.getElementsByTagName("title")[0],(!i||i[Rn]||i[Ve]||i.namespaceURI==="http://www.w3.org/2000/svg"||i.hasAttribute("itemprop"))&&(i=l.createElement(n),l.head.insertBefore(i,l.querySelector("head > title"))),Xe(i,n,a),i[Ve]=e,He(i),n=i;break e;case"link":var c=pd("link","href",l).get(n+(a.href||""));if(c){for(var u=0;u<c.length;u++)if(i=c[u],i.getAttribute("href")===(a.href==null||a.href===""?null:a.href)&&i.getAttribute("rel")===(a.rel==null?null:a.rel)&&i.getAttribute("title")===(a.title==null?null:a.title)&&i.getAttribute("crossorigin")===(a.crossOrigin==null?null:a.crossOrigin)){c.splice(u,1);break t}}i=l.createElement(n),Xe(i,n,a),l.head.appendChild(i);break;case"meta":if(c=pd("meta","content",l).get(n+(a.content||""))){for(u=0;u<c.length;u++)if(i=c[u],i.getAttribute("content")===(a.content==null?null:""+a.content)&&i.getAttribute("name")===(a.name==null?null:a.name)&&i.getAttribute("property")===(a.property==null?null:a.property)&&i.getAttribute("http-equiv")===(a.httpEquiv==null?null:a.httpEquiv)&&i.getAttribute("charset")===(a.charSet==null?null:a.charSet)){c.splice(u,1);break t}}i=l.createElement(n),Xe(i,n,a),l.head.appendChild(i);break;default:throw Error(r(468,n))}i[Ve]=e,He(i),n=i}e.stateNode=n}else hd(l,e.type,e.stateNode);else e.stateNode=dd(l,n,e.memoizedProps);else i!==n?(i===null?a.stateNode!==null&&(a=a.stateNode,a.parentNode.removeChild(a)):i.count--,n===null?hd(l,e.type,e.stateNode):dd(l,n,e.memoizedProps)):n===null&&e.stateNode!==null&&Eo(e,e.memoizedProps,a.memoizedProps)}break;case 27:st(t,e),rt(e),n&512&&(Re||a===null||Rt(a,a.return)),a!==null&&n&4&&Eo(e,e.memoizedProps,a.memoizedProps);break;case 5:if(st(t,e),rt(e),n&512&&(Re||a===null||Rt(a,a.return)),e.flags&32){l=e.stateNode;try{Za(l,"")}catch(S){pe(e,e.return,S)}}n&4&&e.stateNode!=null&&(l=e.memoizedProps,Eo(e,l,a!==null?a.memoizedProps:l)),n&1024&&(Ro=!0);break;case 6:if(st(t,e),rt(e),n&4){if(e.stateNode===null)throw Error(r(162));n=e.memoizedProps,a=e.stateNode;try{a.nodeValue=n}catch(S){pe(e,e.return,S)}}break;case 3:if(qi=null,l=wt,wt=Oi(t.containerInfo),st(t,e),wt=l,rt(e),n&4&&a!==null&&a.memoizedState.isDehydrated)try{kl(t.containerInfo)}catch(S){pe(e,e.return,S)}Ro&&(Ro=!1,bf(e));break;case 4:n=wt,wt=Oi(e.stateNode.containerInfo),st(t,e),rt(e),wt=n;break;case 12:st(t,e),rt(e);break;case 13:st(t,e),rt(e),e.child.flags&8192&&e.memoizedState!==null!=(a!==null&&a.memoizedState!==null)&&(Co=Et()),n&4&&(n=e.updateQueue,n!==null&&(e.updateQueue=null,No(e,n)));break;case 22:l=e.memoizedState!==null;var f=a!==null&&a.memoizedState!==null,y=Xt,E=Re;if(Xt=y||l,Re=E||f,st(t,e),Re=E,Xt=y,rt(e),n&8192)e:for(t=e.stateNode,t._visibility=l?t._visibility&-2:t._visibility|1,l&&(a===null||f||Xt||Re||Ua(e)),a=null,t=e;;){if(t.tag===5||t.tag===26){if(a===null){f=a=t;try{if(i=f.stateNode,l)c=i.style,typeof c.setProperty=="function"?c.setProperty("display","none","important"):c.display="none";else{u=f.stateNode;var R=f.memoizedProps.style,b=R!=null&&R.hasOwnProperty("display")?R.display:null;u.style.display=b==null||typeof b=="boolean"?"":(""+b).trim()}}catch(S){pe(f,f.return,S)}}}else if(t.tag===6){if(a===null){f=t;try{f.stateNode.nodeValue=l?"":f.memoizedProps}catch(S){pe(f,f.return,S)}}}else if((t.tag!==22&&t.tag!==23||t.memoizedState===null||t===e)&&t.child!==null){t.child.return=t,t=t.child;continue}if(t===e)break e;for(;t.sibling===null;){if(t.return===null||t.return===e)break e;a===t&&(a=null),t=t.return}a===t&&(a=null),t.sibling.return=t.return,t=t.sibling}n&4&&(n=e.updateQueue,n!==null&&(a=n.retryQueue,a!==null&&(n.retryQueue=null,No(e,a))));break;case 19:st(t,e),rt(e),n&4&&(n=e.updateQueue,n!==null&&(e.updateQueue=null,No(e,n)));break;case 30:break;case 21:break;default:st(t,e),rt(e)}}function rt(e){var t=e.flags;if(t&2){try{for(var a,n=e.return;n!==null;){if(df(n)){a=n;break}n=n.return}if(a==null)throw Error(r(160));switch(a.tag){case 27:var l=a.stateNode,i=Ao(e);bi(e,i,l);break;case 5:var c=a.stateNode;a.flags&32&&(Za(c,""),a.flags&=-33);var u=Ao(e);bi(e,u,c);break;case 3:case 4:var f=a.stateNode.containerInfo,y=Ao(e);zo(e,y,f);break;default:throw Error(r(161))}}catch(E){pe(e,e.return,E)}e.flags&=-3}t&4096&&(e.flags&=-4097)}function bf(e){if(e.subtreeFlags&1024)for(e=e.child;e!==null;){var t=e;bf(t),t.tag===5&&t.flags&1024&&t.stateNode.reset(),e=e.sibling}}function ca(e,t){if(t.subtreeFlags&8772)for(t=t.child;t!==null;)mf(e,t.alternate,t),t=t.sibling}function Ua(e){for(e=e.child;e!==null;){var t=e;switch(t.tag){case 0:case 11:case 14:case 15:ia(4,t,t.return),Ua(t);break;case 1:Rt(t,t.return);var a=t.stateNode;typeof a.componentWillUnmount=="function"&&rf(t,t.return,a),Ua(t);break;case 27:hl(t.stateNode);case 26:case 5:Rt(t,t.return),Ua(t);break;case 22:t.memoizedState===null&&Ua(t);break;case 30:Ua(t);break;default:Ua(t)}e=e.sibling}}function oa(e,t,a){for(a=a&&(t.subtreeFlags&8772)!==0,t=t.child;t!==null;){var n=t.alternate,l=e,i=t,c=i.flags;switch(i.tag){case 0:case 11:case 15:oa(l,i,a),ll(4,i);break;case 1:if(oa(l,i,a),n=i,l=n.stateNode,typeof l.componentDidMount=="function")try{l.componentDidMount()}catch(y){pe(n,n.return,y)}if(n=i,l=n.updateQueue,l!==null){var u=n.stateNode;try{var f=l.shared.hiddenCallbacks;if(f!==null)for(l.shared.hiddenCallbacks=null,l=0;l<f.length;l++)Js(f[l],u)}catch(y){pe(n,n.return,y)}}a&&c&64&&sf(i),il(i,i.return);break;case 27:pf(i);case 26:case 5:oa(l,i,a),a&&n===null&&c&4&&ff(i),il(i,i.return);break;case 12:oa(l,i,a);break;case 13:oa(l,i,a),a&&c&4&&gf(l,i);break;case 22:i.memoizedState===null&&oa(l,i,a),il(i,i.return);break;case 30:break;default:oa(l,i,a)}t=t.sibling}}function Do(e,t){var a=null;e!==null&&e.memoizedState!==null&&e.memoizedState.cachePool!==null&&(a=e.memoizedState.cachePool.pool),e=null,t.memoizedState!==null&&t.memoizedState.cachePool!==null&&(e=t.memoizedState.cachePool.pool),e!==a&&(e!=null&&e.refCount++,a!=null&&Xn(a))}function Mo(e,t){e=null,t.alternate!==null&&(e=t.alternate.memoizedState.cache),t=t.memoizedState.cache,t!==e&&(t.refCount++,e!=null&&Xn(e))}function Nt(e,t,a,n){if(t.subtreeFlags&10256)for(t=t.child;t!==null;)Sf(e,t,a,n),t=t.sibling}function Sf(e,t,a,n){var l=t.flags;switch(t.tag){case 0:case 11:case 15:Nt(e,t,a,n),l&2048&&ll(9,t);break;case 1:Nt(e,t,a,n);break;case 3:Nt(e,t,a,n),l&2048&&(e=null,t.alternate!==null&&(e=t.alternate.memoizedState.cache),t=t.memoizedState.cache,t!==e&&(t.refCount++,e!=null&&Xn(e)));break;case 12:if(l&2048){Nt(e,t,a,n),e=t.stateNode;try{var i=t.memoizedProps,c=i.id,u=i.onPostCommit;typeof u=="function"&&u(c,t.alternate===null?"mount":"update",e.passiveEffectDuration,-0)}catch(f){pe(t,t.return,f)}}else Nt(e,t,a,n);break;case 13:Nt(e,t,a,n);break;case 23:break;case 22:i=t.stateNode,c=t.alternate,t.memoizedState!==null?i._visibility&2?Nt(e,t,a,n):cl(e,t):i._visibility&2?Nt(e,t,a,n):(i._visibility|=2,fn(e,t,a,n,(t.subtreeFlags&10256)!==0)),l&2048&&Do(c,t);break;case 24:Nt(e,t,a,n),l&2048&&Mo(t.alternate,t);break;default:Nt(e,t,a,n)}}function fn(e,t,a,n,l){for(l=l&&(t.subtreeFlags&10256)!==0,t=t.child;t!==null;){var i=e,c=t,u=a,f=n,y=c.flags;switch(c.tag){case 0:case 11:case 15:fn(i,c,u,f,l),ll(8,c);break;case 23:break;case 22:var E=c.stateNode;c.memoizedState!==null?E._visibility&2?fn(i,c,u,f,l):cl(i,c):(E._visibility|=2,fn(i,c,u,f,l)),l&&y&2048&&Do(c.alternate,c);break;case 24:fn(i,c,u,f,l),l&&y&2048&&Mo(c.alternate,c);break;default:fn(i,c,u,f,l)}t=t.sibling}}function cl(e,t){if(t.subtreeFlags&10256)for(t=t.child;t!==null;){var a=e,n=t,l=n.flags;switch(n.tag){case 22:cl(a,n),l&2048&&Do(n.alternate,n);break;case 24:cl(a,n),l&2048&&Mo(n.alternate,n);break;default:cl(a,n)}t=t.sibling}}var ol=8192;function dn(e){if(e.subtreeFlags&ol)for(e=e.child;e!==null;)kf(e),e=e.sibling}function kf(e){switch(e.tag){case 26:dn(e),e.flags&ol&&e.memoizedState!==null&&Em(wt,e.memoizedState,e.memoizedProps);break;case 5:dn(e);break;case 3:case 4:var t=wt;wt=Oi(e.stateNode.containerInfo),dn(e),wt=t;break;case 22:e.memoizedState===null&&(t=e.alternate,t!==null&&t.memoizedState!==null?(t=ol,ol=16777216,dn(e),ol=t):dn(e));break;default:dn(e)}}function xf(e){var t=e.alternate;if(t!==null&&(e=t.child,e!==null)){t.child=null;do t=e.sibling,e.sibling=null,e=t;while(e!==null)}}function ul(e){var t=e.deletions;if((e.flags&16)!==0){if(t!==null)for(var a=0;a<t.length;a++){var n=t[a];Le=n,Tf(n,e)}xf(e)}if(e.subtreeFlags&10256)for(e=e.child;e!==null;)wf(e),e=e.sibling}function wf(e){switch(e.tag){case 0:case 11:case 15:ul(e),e.flags&2048&&ia(9,e,e.return);break;case 3:ul(e);break;case 12:ul(e);break;case 22:var t=e.stateNode;e.memoizedState!==null&&t._visibility&2&&(e.return===null||e.return.tag!==13)?(t._visibility&=-3,Si(e)):ul(e);break;default:ul(e)}}function Si(e){var t=e.deletions;if((e.flags&16)!==0){if(t!==null)for(var a=0;a<t.length;a++){var n=t[a];Le=n,Tf(n,e)}xf(e)}for(e=e.child;e!==null;){switch(t=e,t.tag){case 0:case 11:case 15:ia(8,t,t.return),Si(t);break;case 22:a=t.stateNode,a._visibility&2&&(a._visibility&=-3,Si(t));break;default:Si(t)}e=e.sibling}}function Tf(e,t){for(;Le!==null;){var a=Le;switch(a.tag){case 0:case 11:case 15:ia(8,a,t);break;case 23:case 22:if(a.memoizedState!==null&&a.memoizedState.cachePool!==null){var n=a.memoizedState.cachePool.pool;n!=null&&n.refCount++}break;case 24:Xn(a.memoizedState.cache)}if(n=a.child,n!==null)n.return=a,Le=n;else e:for(a=e;Le!==null;){n=Le;var l=n.sibling,i=n.return;if(_f(n),n===a){Le=null;break e}if(l!==null){l.return=i,Le=l;break e}Le=i}}}var Gh={getCacheForType:function(e){var t=Ke(Oe),a=t.data.get(e);return a===void 0&&(a=e(),t.data.set(e,a)),a}},Qh=typeof WeakMap=="function"?WeakMap:Map,ue=0,he=null,I=null,te=0,se=0,ft=null,ua=!1,pn=!1,Oo=!1,Vt=0,Ee=0,sa=0,qa=0,Uo=0,St=0,hn=0,sl=null,et=null,qo=!1,Co=0,ki=1/0,xi=null,ra=null,Qe=0,fa=null,mn=null,_n=0,jo=0,Ho=null,Ef=null,rl=0,Bo=null;function dt(){if((ue&2)!==0&&te!==0)return te&-te;if(T.T!==null){var e=an;return e!==0?e:Vo()}return Yu()}function Af(){St===0&&(St=(te&536870912)===0||ne?ju():536870912);var e=bt.current;return e!==null&&(e.flags|=32),St}function pt(e,t,a){(e===he&&(se===2||se===9)||e.cancelPendingCommit!==null)&&(vn(e,0),da(e,te,St,!1)),zn(e,a),((ue&2)===0||e!==he)&&(e===he&&((ue&2)===0&&(qa|=a),Ee===4&&da(e,te,St,!1)),Dt(e))}function zf(e,t,a){if((ue&6)!==0)throw Error(r(327));var n=!a&&(t&124)===0&&(t&e.expiredLanes)===0||An(e,t),l=n?Vh(e,t):Go(e,t,!0),i=n;do{if(l===0){pn&&!n&&da(e,t,0,!1);break}else{if(a=e.current.alternate,i&&!Xh(a)){l=Go(e,t,!1),i=!1;continue}if(l===2){if(i=t,e.errorRecoveryDisabledLanes&i)var c=0;else c=e.pendingLanes&-536870913,c=c!==0?c:c&536870912?536870912:0;if(c!==0){t=c;e:{var u=e;l=sl;var f=u.current.memoizedState.isDehydrated;if(f&&(vn(u,c).flags|=256),c=Go(u,c,!1),c!==2){if(Oo&&!f){u.errorRecoveryDisabledLanes|=i,qa|=i,l=4;break e}i=et,et=l,i!==null&&(et===null?et=i:et.push.apply(et,i))}l=c}if(i=!1,l!==2)continue}}if(l===1){vn(e,0),da(e,t,0,!0);break}e:{switch(n=e,i=l,i){case 0:case 1:throw Error(r(345));case 4:if((t&4194048)!==t)break;case 6:da(n,t,St,!ua);break e;case 2:et=null;break;case 3:case 5:break;default:throw Error(r(329))}if((t&62914560)===t&&(l=Co+300-Et(),10<l)){if(da(n,t,St,!ua),Ul(n,0,!0)!==0)break e;n.timeoutHandle=nd(Rf.bind(null,n,a,et,xi,qo,t,St,qa,hn,ua,i,2,-0,0),l);break e}Rf(n,a,et,xi,qo,t,St,qa,hn,ua,i,0,-0,0)}}break}while(!0);Dt(e)}function Rf(e,t,a,n,l,i,c,u,f,y,E,R,b,S){if(e.timeoutHandle=-1,R=t.subtreeFlags,(R&8192||(R&16785408)===16785408)&&(vl={stylesheets:null,count:0,unsuspend:Tm},kf(t),R=Am(),R!==null)){e.cancelPendingCommit=R(Cf.bind(null,e,t,i,a,n,l,c,u,f,E,1,b,S)),da(e,i,c,!y);return}Cf(e,t,i,a,n,l,c,u,f)}function Xh(e){for(var t=e;;){var a=t.tag;if((a===0||a===11||a===15)&&t.flags&16384&&(a=t.updateQueue,a!==null&&(a=a.stores,a!==null)))for(var n=0;n<a.length;n++){var l=a[n],i=l.getSnapshot;l=l.value;try{if(!ot(i(),l))return!1}catch{return!1}}if(a=t.child,t.subtreeFlags&16384&&a!==null)a.return=t,t=a;else{if(t===e)break;for(;t.sibling===null;){if(t.return===null||t.return===e)return!0;t=t.return}t.sibling.return=t.return,t=t.sibling}}return!0}function da(e,t,a,n){t&=~Uo,t&=~qa,e.suspendedLanes|=t,e.pingedLanes&=~t,n&&(e.warmLanes|=t),n=e.expirationTimes;for(var l=t;0<l;){var i=31-ct(l),c=1<<i;n[i]=-1,l&=~c}a!==0&&Bu(e,a,t)}function wi(){return(ue&6)===0?(fl(0),!1):!0}function Lo(){if(I!==null){if(se===0)var e=I.return;else e=I,Ht=Ra=null,ao(e),sn=null,tl=0,e=I;for(;e!==null;)uf(e.alternate,e),e=e.return;I=null}}function vn(e,t){var a=e.timeoutHandle;a!==-1&&(e.timeoutHandle=-1,um(a)),a=e.cancelPendingCommit,a!==null&&(e.cancelPendingCommit=null,a()),Lo(),he=e,I=a=qt(e.current,null),te=t,se=0,ft=null,ua=!1,pn=An(e,t),Oo=!1,hn=St=Uo=qa=sa=Ee=0,et=sl=null,qo=!1,(t&8)!==0&&(t|=t&32);var n=e.entangledLanes;if(n!==0)for(e=e.entanglements,n&=t;0<n;){var l=31-ct(n),i=1<<l;t|=e[l],n&=~i}return Vt=t,Vl(),a}function Nf(e,t){F=null,T.H=fi,t===Vn||t===ti?(t=Vs(),se=3):t===Qs?(t=Vs(),se=4):se=t===Kr?8:t!==null&&typeof t=="object"&&typeof t.then=="function"?6:1,ft=t,I===null&&(Ee=1,_i(e,_t(t,e.current)))}function Df(){var e=T.H;return T.H=fi,e===null?fi:e}function Mf(){var e=T.A;return T.A=Gh,e}function Yo(){Ee=4,ua||(te&4194048)!==te&&bt.current!==null||(pn=!0),(sa&134217727)===0&&(qa&134217727)===0||he===null||da(he,te,St,!1)}function Go(e,t,a){var n=ue;ue|=2;var l=Df(),i=Mf();(he!==e||te!==t)&&(xi=null,vn(e,t)),t=!1;var c=Ee;e:do try{if(se!==0&&I!==null){var u=I,f=ft;switch(se){case 8:Lo(),c=6;break e;case 3:case 2:case 9:case 6:bt.current===null&&(t=!0);var y=se;if(se=0,ft=null,gn(e,u,f,y),a&&pn){c=0;break e}break;default:y=se,se=0,ft=null,gn(e,u,f,y)}}Zh(),c=Ee;break}catch(E){Nf(e,E)}while(!0);return t&&e.shellSuspendCounter++,Ht=Ra=null,ue=n,T.H=l,T.A=i,I===null&&(he=null,te=0,Vl()),c}function Zh(){for(;I!==null;)Of(I)}function Vh(e,t){var a=ue;ue|=2;var n=Df(),l=Mf();he!==e||te!==t?(xi=null,ki=Et()+500,vn(e,t)):pn=An(e,t);e:do try{if(se!==0&&I!==null){t=I;var i=ft;t:switch(se){case 1:se=0,ft=null,gn(e,t,i,1);break;case 2:case 9:if(Xs(i)){se=0,ft=null,Uf(t);break}t=function(){se!==2&&se!==9||he!==e||(se=7),Dt(e)},i.then(t,t);break e;case 3:se=7;break e;case 4:se=5;break e;case 7:Xs(i)?(se=0,ft=null,Uf(t)):(se=0,ft=null,gn(e,t,i,7));break;case 5:var c=null;switch(I.tag){case 26:c=I.memoizedState;case 5:case 27:var u=I;if(!c||md(c)){se=0,ft=null;var f=u.sibling;if(f!==null)I=f;else{var y=u.return;y!==null?(I=y,Ti(y)):I=null}break t}}se=0,ft=null,gn(e,t,i,5);break;case 6:se=0,ft=null,gn(e,t,i,6);break;case 8:Lo(),Ee=6;break e;default:throw Error(r(462))}}Kh();break}catch(E){Nf(e,E)}while(!0);return Ht=Ra=null,T.H=n,T.A=l,ue=a,I!==null?0:(he=null,te=0,Vl(),Ee)}function Kh(){for(;I!==null&&!mp();)Of(I)}function Of(e){var t=cf(e.alternate,e,Vt);e.memoizedProps=e.pendingProps,t===null?Ti(e):I=t}function Uf(e){var t=e,a=t.alternate;switch(t.tag){case 15:case 0:t=Ir(a,t,t.pendingProps,t.type,void 0,te);break;case 11:t=Ir(a,t,t.pendingProps,t.type.render,t.ref,te);break;case 5:ao(t);default:uf(a,t),t=I=Us(t,Vt),t=cf(a,t,Vt)}e.memoizedProps=e.pendingProps,t===null?Ti(e):I=t}function gn(e,t,a,n){Ht=Ra=null,ao(t),sn=null,tl=0;var l=t.return;try{if(Ch(e,l,t,a,te)){Ee=1,_i(e,_t(a,e.current)),I=null;return}}catch(i){if(l!==null)throw I=l,i;Ee=1,_i(e,_t(a,e.current)),I=null;return}t.flags&32768?(ne||n===1?e=!0:pn||(te&536870912)!==0?e=!1:(ua=e=!0,(n===2||n===9||n===3||n===6)&&(n=bt.current,n!==null&&n.tag===13&&(n.flags|=16384))),qf(t,e)):Ti(t)}function Ti(e){var t=e;do{if((t.flags&32768)!==0){qf(t,ua);return}e=t.return;var a=Hh(t.alternate,t,Vt);if(a!==null){I=a;return}if(t=t.sibling,t!==null){I=t;return}I=t=e}while(t!==null);Ee===0&&(Ee=5)}function qf(e,t){do{var a=Bh(e.alternate,e);if(a!==null){a.flags&=32767,I=a;return}if(a=e.return,a!==null&&(a.flags|=32768,a.subtreeFlags=0,a.deletions=null),!t&&(e=e.sibling,e!==null)){I=e;return}I=e=a}while(e!==null);Ee=6,I=null}function Cf(e,t,a,n,l,i,c,u,f){e.cancelPendingCommit=null;do Ei();while(Qe!==0);if((ue&6)!==0)throw Error(r(327));if(t!==null){if(t===e.current)throw Error(r(177));if(i=t.lanes|t.childLanes,i|=Dc,Tp(e,a,i,c,u,f),e===he&&(I=he=null,te=0),mn=t,fa=e,_n=a,jo=i,Ho=l,Ef=n,(t.subtreeFlags&10256)!==0||(t.flags&10256)!==0?(e.callbackNode=null,e.callbackPriority=0,Fh(Dl,function(){return Yf(),null})):(e.callbackNode=null,e.callbackPriority=0),n=(t.flags&13878)!==0,(t.subtreeFlags&13878)!==0||n){n=T.T,T.T=null,l=q.p,q.p=2,c=ue,ue|=4;try{Lh(e,t,a)}finally{ue=c,q.p=l,T.T=n}}Qe=1,jf(),Hf(),Bf()}}function jf(){if(Qe===1){Qe=0;var e=fa,t=mn,a=(t.flags&13878)!==0;if((t.subtreeFlags&13878)!==0||a){a=T.T,T.T=null;var n=q.p;q.p=2;var l=ue;ue|=4;try{yf(t,e);var i=eu,c=ws(e.containerInfo),u=i.focusedElem,f=i.selectionRange;if(c!==u&&u&&u.ownerDocument&&xs(u.ownerDocument.documentElement,u)){if(f!==null&&Ec(u)){var y=f.start,E=f.end;if(E===void 0&&(E=y),"selectionStart"in u)u.selectionStart=y,u.selectionEnd=Math.min(E,u.value.length);else{var R=u.ownerDocument||document,b=R&&R.defaultView||window;if(b.getSelection){var S=b.getSelection(),X=u.textContent.length,G=Math.min(f.start,X),de=f.end===void 0?G:Math.min(f.end,X);!S.extend&&G>de&&(c=de,de=G,G=c);var _=ks(u,G),h=ks(u,de);if(_&&h&&(S.rangeCount!==1||S.anchorNode!==_.node||S.anchorOffset!==_.offset||S.focusNode!==h.node||S.focusOffset!==h.offset)){var v=R.createRange();v.setStart(_.node,_.offset),S.removeAllRanges(),G>de?(S.addRange(v),S.extend(h.node,h.offset)):(v.setEnd(h.node,h.offset),S.addRange(v))}}}}for(R=[],S=u;S=S.parentNode;)S.nodeType===1&&R.push({element:S,left:S.scrollLeft,top:S.scrollTop});for(typeof u.focus=="function"&&u.focus(),u=0;u<R.length;u++){var A=R[u];A.element.scrollLeft=A.left,A.element.scrollTop=A.top}}Hi=!!Io,eu=Io=null}finally{ue=l,q.p=n,T.T=a}}e.current=t,Qe=2}}function Hf(){if(Qe===2){Qe=0;var e=fa,t=mn,a=(t.flags&8772)!==0;if((t.subtreeFlags&8772)!==0||a){a=T.T,T.T=null;var n=q.p;q.p=2;var l=ue;ue|=4;try{mf(e,t.alternate,t)}finally{ue=l,q.p=n,T.T=a}}Qe=3}}function Bf(){if(Qe===4||Qe===3){Qe=0,_p();var e=fa,t=mn,a=_n,n=Ef;(t.subtreeFlags&10256)!==0||(t.flags&10256)!==0?Qe=5:(Qe=0,mn=fa=null,Lf(e,e.pendingLanes));var l=e.pendingLanes;if(l===0&&(ra=null),ic(a),t=t.stateNode,it&&typeof it.onCommitFiberRoot=="function")try{it.onCommitFiberRoot(En,t,void 0,(t.current.flags&128)===128)}catch{}if(n!==null){t=T.T,l=q.p,q.p=2,T.T=null;try{for(var i=e.onRecoverableError,c=0;c<n.length;c++){var u=n[c];i(u.value,{componentStack:u.stack})}}finally{T.T=t,q.p=l}}(_n&3)!==0&&Ei(),Dt(e),l=e.pendingLanes,(a&4194090)!==0&&(l&42)!==0?e===Bo?rl++:(rl=0,Bo=e):rl=0,fl(0)}}function Lf(e,t){(e.pooledCacheLanes&=t)===0&&(t=e.pooledCache,t!=null&&(e.pooledCache=null,Xn(t)))}function Ei(e){return jf(),Hf(),Bf(),Yf()}function Yf(){if(Qe!==5)return!1;var e=fa,t=jo;jo=0;var a=ic(_n),n=T.T,l=q.p;try{q.p=32>a?32:a,T.T=null,a=Ho,Ho=null;var i=fa,c=_n;if(Qe=0,mn=fa=null,_n=0,(ue&6)!==0)throw Error(r(331));var u=ue;if(ue|=4,wf(i.current),Sf(i,i.current,c,a),ue=u,fl(0,!1),it&&typeof it.onPostCommitFiberRoot=="function")try{it.onPostCommitFiberRoot(En,i)}catch{}return!0}finally{q.p=l,T.T=n,Lf(e,t)}}function Gf(e,t,a){t=_t(a,t),t=vo(e.stateNode,t,2),e=ta(e,t,2),e!==null&&(zn(e,2),Dt(e))}function pe(e,t,a){if(e.tag===3)Gf(e,e,a);else for(;t!==null;){if(t.tag===3){Gf(t,e,a);break}else if(t.tag===1){var n=t.stateNode;if(typeof t.type.getDerivedStateFromError=="function"||typeof n.componentDidCatch=="function"&&(ra===null||!ra.has(n))){e=_t(a,e),a=Zr(2),n=ta(t,a,2),n!==null&&(Vr(a,n,t,e),zn(n,2),Dt(n));break}}t=t.return}}function Qo(e,t,a){var n=e.pingCache;if(n===null){n=e.pingCache=new Qh;var l=new Set;n.set(t,l)}else l=n.get(t),l===void 0&&(l=new Set,n.set(t,l));l.has(a)||(Oo=!0,l.add(a),e=Jh.bind(null,e,t,a),t.then(e,e))}function Jh(e,t,a){var n=e.pingCache;n!==null&&n.delete(t),e.pingedLanes|=e.suspendedLanes&a,e.warmLanes&=~a,he===e&&(te&a)===a&&(Ee===4||Ee===3&&(te&62914560)===te&&300>Et()-Co?(ue&2)===0&&vn(e,0):Uo|=a,hn===te&&(hn=0)),Dt(e)}function Qf(e,t){t===0&&(t=Hu()),e=Pa(e,t),e!==null&&(zn(e,t),Dt(e))}function $h(e){var t=e.memoizedState,a=0;t!==null&&(a=t.retryLane),Qf(e,a)}function Wh(e,t){var a=0;switch(e.tag){case 13:var n=e.stateNode,l=e.memoizedState;l!==null&&(a=l.retryLane);break;case 19:n=e.stateNode;break;case 22:n=e.stateNode._retryCache;break;default:throw Error(r(314))}n!==null&&n.delete(t),Qf(e,a)}function Fh(e,t){return tc(e,t)}var Ai=null,yn=null,Xo=!1,zi=!1,Zo=!1,Ca=0;function Dt(e){e!==yn&&e.next===null&&(yn===null?Ai=yn=e:yn=yn.next=e),zi=!0,Xo||(Xo=!0,Ih())}function fl(e,t){if(!Zo&&zi){Zo=!0;do for(var a=!1,n=Ai;n!==null;){if(e!==0){var l=n.pendingLanes;if(l===0)var i=0;else{var c=n.suspendedLanes,u=n.pingedLanes;i=(1<<31-ct(42|e)+1)-1,i&=l&~(c&~u),i=i&201326741?i&201326741|1:i?i|2:0}i!==0&&(a=!0,Kf(n,i))}else i=te,i=Ul(n,n===he?i:0,n.cancelPendingCommit!==null||n.timeoutHandle!==-1),(i&3)===0||An(n,i)||(a=!0,Kf(n,i));n=n.next}while(a);Zo=!1}}function Ph(){Xf()}function Xf(){zi=Xo=!1;var e=0;Ca!==0&&(om()&&(e=Ca),Ca=0);for(var t=Et(),a=null,n=Ai;n!==null;){var l=n.next,i=Zf(n,t);i===0?(n.next=null,a===null?Ai=l:a.next=l,l===null&&(yn=a)):(a=n,(e!==0||(i&3)!==0)&&(zi=!0)),n=l}fl(e)}function Zf(e,t){for(var a=e.suspendedLanes,n=e.pingedLanes,l=e.expirationTimes,i=e.pendingLanes&-62914561;0<i;){var c=31-ct(i),u=1<<c,f=l[c];f===-1?((u&a)===0||(u&n)!==0)&&(l[c]=wp(u,t)):f<=t&&(e.expiredLanes|=u),i&=~u}if(t=he,a=te,a=Ul(e,e===t?a:0,e.cancelPendingCommit!==null||e.timeoutHandle!==-1),n=e.callbackNode,a===0||e===t&&(se===2||se===9)||e.cancelPendingCommit!==null)return n!==null&&n!==null&&ac(n),e.callbackNode=null,e.callbackPriority=0;if((a&3)===0||An(e,a)){if(t=a&-a,t===e.callbackPriority)return t;switch(n!==null&&ac(n),ic(a)){case 2:case 8:a=qu;break;case 32:a=Dl;break;case 268435456:a=Cu;break;default:a=Dl}return n=Vf.bind(null,e),a=tc(a,n),e.callbackPriority=t,e.callbackNode=a,t}return n!==null&&n!==null&&ac(n),e.callbackPriority=2,e.callbackNode=null,2}function Vf(e,t){if(Qe!==0&&Qe!==5)return e.callbackNode=null,e.callbackPriority=0,null;var a=e.callbackNode;if(Ei()&&e.callbackNode!==a)return null;var n=te;return n=Ul(e,e===he?n:0,e.cancelPendingCommit!==null||e.timeoutHandle!==-1),n===0?null:(zf(e,n,t),Zf(e,Et()),e.callbackNode!=null&&e.callbackNode===a?Vf.bind(null,e):null)}function Kf(e,t){if(Ei())return null;zf(e,t,!0)}function Ih(){sm(function(){(ue&6)!==0?tc(Uu,Ph):Xf()})}function Vo(){return Ca===0&&(Ca=ju()),Ca}function Jf(e){return e==null||typeof e=="symbol"||typeof e=="boolean"?null:typeof e=="function"?e:Bl(""+e)}function $f(e,t){var a=t.ownerDocument.createElement("input");return a.name=t.name,a.value=t.value,e.id&&a.setAttribute("form",e.id),t.parentNode.insertBefore(a,t),e=new FormData(e),a.parentNode.removeChild(a),e}function em(e,t,a,n,l){if(t==="submit"&&a&&a.stateNode===l){var i=Jf((l[We]||null).action),c=n.submitter;c&&(t=(t=c[We]||null)?Jf(t.formAction):c.getAttribute("formAction"),t!==null&&(i=t,c=null));var u=new Ql("action","action",null,n,l);e.push({event:u,listeners:[{instance:null,listener:function(){if(n.defaultPrevented){if(Ca!==0){var f=c?$f(l,c):new FormData(l);fo(a,{pending:!0,data:f,method:l.method,action:i},null,f)}}else typeof i=="function"&&(u.preventDefault(),f=c?$f(l,c):new FormData(l),fo(a,{pending:!0,data:f,method:l.method,action:i},i,f))},currentTarget:l}]})}}for(var Ko=0;Ko<Nc.length;Ko++){var Jo=Nc[Ko],tm=Jo.toLowerCase(),am=Jo[0].toUpperCase()+Jo.slice(1);xt(tm,"on"+am)}xt(As,"onAnimationEnd"),xt(zs,"onAnimationIteration"),xt(Rs,"onAnimationStart"),xt("dblclick","onDoubleClick"),xt("focusin","onFocus"),xt("focusout","onBlur"),xt(yh,"onTransitionRun"),xt(bh,"onTransitionStart"),xt(Sh,"onTransitionCancel"),xt(Ns,"onTransitionEnd"),Ga("onMouseEnter",["mouseout","mouseover"]),Ga("onMouseLeave",["mouseout","mouseover"]),Ga("onPointerEnter",["pointerout","pointerover"]),Ga("onPointerLeave",["pointerout","pointerover"]),ba("onChange","change click focusin focusout input keydown keyup selectionchange".split(" ")),ba("onSelect","focusout contextmenu dragend focusin keydown keyup mousedown mouseup selectionchange".split(" ")),ba("onBeforeInput",["compositionend","keypress","textInput","paste"]),ba("onCompositionEnd","compositionend focusout keydown keypress keyup mousedown".split(" ")),ba("onCompositionStart","compositionstart focusout keydown keypress keyup mousedown".split(" ")),ba("onCompositionUpdate","compositionupdate focusout keydown keypress keyup mousedown".split(" "));var dl="abort canplay canplaythrough durationchange emptied encrypted ended error loadeddata loadedmetadata loadstart pause play playing progress ratechange resize seeked seeking stalled suspend timeupdate volumechange waiting".split(" "),nm=new Set("beforetoggle cancel close invalid load scroll scrollend toggle".split(" ").concat(dl));function Wf(e,t){t=(t&4)!==0;for(var a=0;a<e.length;a++){var n=e[a],l=n.event;n=n.listeners;e:{var i=void 0;if(t)for(var c=n.length-1;0<=c;c--){var u=n[c],f=u.instance,y=u.currentTarget;if(u=u.listener,f!==i&&l.isPropagationStopped())break e;i=u,l.currentTarget=y;try{i(l)}catch(E){mi(E)}l.currentTarget=null,i=f}else for(c=0;c<n.length;c++){if(u=n[c],f=u.instance,y=u.currentTarget,u=u.listener,f!==i&&l.isPropagationStopped())break e;i=u,l.currentTarget=y;try{i(l)}catch(E){mi(E)}l.currentTarget=null,i=f}}}}function ee(e,t){var a=t[cc];a===void 0&&(a=t[cc]=new Set);var n=e+"__bubble";a.has(n)||(Ff(t,e,2,!1),a.add(n))}function $o(e,t,a){var n=0;t&&(n|=4),Ff(a,e,n,t)}var Ri="_reactListening"+Math.random().toString(36).slice(2);function Wo(e){if(!e[Ri]){e[Ri]=!0,Qu.forEach(function(a){a!=="selectionchange"&&(nm.has(a)||$o(a,!1,e),$o(a,!0,e))});var t=e.nodeType===9?e:e.ownerDocument;t===null||t[Ri]||(t[Ri]=!0,$o("selectionchange",!1,t))}}function Ff(e,t,a,n){switch(Sd(t)){case 2:var l=Nm;break;case 8:l=Dm;break;default:l=ru}a=l.bind(null,t,a,e),l=void 0,!vc||t!=="touchstart"&&t!=="touchmove"&&t!=="wheel"||(l=!0),n?l!==void 0?e.addEventListener(t,a,{capture:!0,passive:l}):e.addEventListener(t,a,!0):l!==void 0?e.addEventListener(t,a,{passive:l}):e.addEventListener(t,a,!1)}function Fo(e,t,a,n,l){var i=n;if((t&1)===0&&(t&2)===0&&n!==null)e:for(;;){if(n===null)return;var c=n.tag;if(c===3||c===4){var u=n.stateNode.containerInfo;if(u===l)break;if(c===4)for(c=n.return;c!==null;){var f=c.tag;if((f===3||f===4)&&c.stateNode.containerInfo===l)return;c=c.return}for(;u!==null;){if(c=Ba(u),c===null)return;if(f=c.tag,f===5||f===6||f===26||f===27){n=i=c;continue e}u=u.parentNode}}n=n.return}ns(function(){var y=i,E=mc(a),R=[];e:{var b=Ds.get(e);if(b!==void 0){var S=Ql,X=e;switch(e){case"keypress":if(Yl(a)===0)break e;case"keydown":case"keyup":S=Fp;break;case"focusin":X="focus",S=Sc;break;case"focusout":X="blur",S=Sc;break;case"beforeblur":case"afterblur":S=Sc;break;case"click":if(a.button===2)break e;case"auxclick":case"dblclick":case"mousedown":case"mousemove":case"mouseup":case"mouseout":case"mouseover":case"contextmenu":S=cs;break;case"drag":case"dragend":case"dragenter":case"dragexit":case"dragleave":case"dragover":case"dragstart":case"drop":S=Bp;break;case"touchcancel":case"touchend":case"touchmove":case"touchstart":S=eh;break;case As:case zs:case Rs:S=Gp;break;case Ns:S=ah;break;case"scroll":case"scrollend":S=jp;break;case"wheel":S=lh;break;case"copy":case"cut":case"paste":S=Xp;break;case"gotpointercapture":case"lostpointercapture":case"pointercancel":case"pointerdown":case"pointermove":case"pointerout":case"pointerover":case"pointerup":S=us;break;case"toggle":case"beforetoggle":S=ch}var G=(t&4)!==0,de=!G&&(e==="scroll"||e==="scrollend"),_=G?b!==null?b+"Capture":null:b;G=[];for(var h=y,v;h!==null;){var A=h;if(v=A.stateNode,A=A.tag,A!==5&&A!==26&&A!==27||v===null||_===null||(A=Dn(h,_),A!=null&&G.push(pl(h,A,v))),de)break;h=h.return}0<G.length&&(b=new S(b,X,null,a,E),R.push({event:b,listeners:G}))}}if((t&7)===0){e:{if(b=e==="mouseover"||e==="pointerover",S=e==="mouseout"||e==="pointerout",b&&a!==hc&&(X=a.relatedTarget||a.fromElement)&&(Ba(X)||X[Ha]))break e;if((S||b)&&(b=E.window===E?E:(b=E.ownerDocument)?b.defaultView||b.parentWindow:window,S?(X=a.relatedTarget||a.toElement,S=y,X=X?Ba(X):null,X!==null&&(de=z(X),G=X.tag,X!==de||G!==5&&G!==27&&G!==6)&&(X=null)):(S=null,X=y),S!==X)){if(G=cs,A="onMouseLeave",_="onMouseEnter",h="mouse",(e==="pointerout"||e==="pointerover")&&(G=us,A="onPointerLeave",_="onPointerEnter",h="pointer"),de=S==null?b:Nn(S),v=X==null?b:Nn(X),b=new G(A,h+"leave",S,a,E),b.target=de,b.relatedTarget=v,A=null,Ba(E)===y&&(G=new G(_,h+"enter",X,a,E),G.target=v,G.relatedTarget=de,A=G),de=A,S&&X)t:{for(G=S,_=X,h=0,v=G;v;v=bn(v))h++;for(v=0,A=_;A;A=bn(A))v++;for(;0<h-v;)G=bn(G),h--;for(;0<v-h;)_=bn(_),v--;for(;h--;){if(G===_||_!==null&&G===_.alternate)break t;G=bn(G),_=bn(_)}G=null}else G=null;S!==null&&Pf(R,b,S,G,!1),X!==null&&de!==null&&Pf(R,de,X,G,!0)}}e:{if(b=y?Nn(y):window,S=b.nodeName&&b.nodeName.toLowerCase(),S==="select"||S==="input"&&b.type==="file")var H=_s;else if(hs(b))if(vs)H=_h;else{H=hh;var P=ph}else S=b.nodeName,!S||S.toLowerCase()!=="input"||b.type!=="checkbox"&&b.type!=="radio"?y&&pc(y.elementType)&&(H=_s):H=mh;if(H&&(H=H(e,y))){ms(R,H,a,E);break e}P&&P(e,b,y),e==="focusout"&&y&&b.type==="number"&&y.memoizedProps.value!=null&&dc(b,"number",b.value)}switch(P=y?Nn(y):window,e){case"focusin":(hs(P)||P.contentEditable==="true")&&($a=P,Ac=y,Bn=null);break;case"focusout":Bn=Ac=$a=null;break;case"mousedown":zc=!0;break;case"contextmenu":case"mouseup":case"dragend":zc=!1,Ts(R,a,E);break;case"selectionchange":if(gh)break;case"keydown":case"keyup":Ts(R,a,E)}var B;if(xc)e:{switch(e){case"compositionstart":var Q="onCompositionStart";break e;case"compositionend":Q="onCompositionEnd";break e;case"compositionupdate":Q="onCompositionUpdate";break e}Q=void 0}else Ja?ds(e,a)&&(Q="onCompositionEnd"):e==="keydown"&&a.keyCode===229&&(Q="onCompositionStart");Q&&(ss&&a.locale!=="ko"&&(Ja||Q!=="onCompositionStart"?Q==="onCompositionEnd"&&Ja&&(B=ls()):(Ft=E,gc="value"in Ft?Ft.value:Ft.textContent,Ja=!0)),P=Ni(y,Q),0<P.length&&(Q=new os(Q,e,null,a,E),R.push({event:Q,listeners:P}),B?Q.data=B:(B=ps(a),B!==null&&(Q.data=B)))),(B=uh?sh(e,a):rh(e,a))&&(Q=Ni(y,"onBeforeInput"),0<Q.length&&(P=new os("onBeforeInput","beforeinput",null,a,E),R.push({event:P,listeners:Q}),P.data=B)),em(R,e,y,a,E)}Wf(R,t)})}function pl(e,t,a){return{instance:e,listener:t,currentTarget:a}}function Ni(e,t){for(var a=t+"Capture",n=[];e!==null;){var l=e,i=l.stateNode;if(l=l.tag,l!==5&&l!==26&&l!==27||i===null||(l=Dn(e,a),l!=null&&n.unshift(pl(e,l,i)),l=Dn(e,t),l!=null&&n.push(pl(e,l,i))),e.tag===3)return n;e=e.return}return[]}function bn(e){if(e===null)return null;do e=e.return;while(e&&e.tag!==5&&e.tag!==27);return e||null}function Pf(e,t,a,n,l){for(var i=t._reactName,c=[];a!==null&&a!==n;){var u=a,f=u.alternate,y=u.stateNode;if(u=u.tag,f!==null&&f===n)break;u!==5&&u!==26&&u!==27||y===null||(f=y,l?(y=Dn(a,i),y!=null&&c.unshift(pl(a,y,f))):l||(y=Dn(a,i),y!=null&&c.push(pl(a,y,f)))),a=a.return}c.length!==0&&e.push({event:t,listeners:c})}var lm=/\r\n?/g,im=/\u0000|\uFFFD/g;function If(e){return(typeof e=="string"?e:""+e).replace(lm,`
`).replace(im,"")}function ed(e,t){return t=If(t),If(e)===t}function Di(){}function fe(e,t,a,n,l,i){switch(a){case"children":typeof n=="string"?t==="body"||t==="textarea"&&n===""||Za(e,n):(typeof n=="number"||typeof n=="bigint")&&t!=="body"&&Za(e,""+n);break;case"className":Cl(e,"class",n);break;case"tabIndex":Cl(e,"tabindex",n);break;case"dir":case"role":case"viewBox":case"width":case"height":Cl(e,a,n);break;case"style":ts(e,n,i);break;case"data":if(t!=="object"){Cl(e,"data",n);break}case"src":case"href":if(n===""&&(t!=="a"||a!=="href")){e.removeAttribute(a);break}if(n==null||typeof n=="function"||typeof n=="symbol"||typeof n=="boolean"){e.removeAttribute(a);break}n=Bl(""+n),e.setAttribute(a,n);break;case"action":case"formAction":if(typeof n=="function"){e.setAttribute(a,"javascript:throw new Error('A React form was unexpectedly submitted. If you called form.submit() manually, consider using form.requestSubmit() instead. If you\\'re trying to use event.stopPropagation() in a submit event handler, consider also calling event.preventDefault().')");break}else typeof i=="function"&&(a==="formAction"?(t!=="input"&&fe(e,t,"name",l.name,l,null),fe(e,t,"formEncType",l.formEncType,l,null),fe(e,t,"formMethod",l.formMethod,l,null),fe(e,t,"formTarget",l.formTarget,l,null)):(fe(e,t,"encType",l.encType,l,null),fe(e,t,"method",l.method,l,null),fe(e,t,"target",l.target,l,null)));if(n==null||typeof n=="symbol"||typeof n=="boolean"){e.removeAttribute(a);break}n=Bl(""+n),e.setAttribute(a,n);break;case"onClick":n!=null&&(e.onclick=Di);break;case"onScroll":n!=null&&ee("scroll",e);break;case"onScrollEnd":n!=null&&ee("scrollend",e);break;case"dangerouslySetInnerHTML":if(n!=null){if(typeof n!="object"||!("__html"in n))throw Error(r(61));if(a=n.__html,a!=null){if(l.children!=null)throw Error(r(60));e.innerHTML=a}}break;case"multiple":e.multiple=n&&typeof n!="function"&&typeof n!="symbol";break;case"muted":e.muted=n&&typeof n!="function"&&typeof n!="symbol";break;case"suppressContentEditableWarning":case"suppressHydrationWarning":case"defaultValue":case"defaultChecked":case"innerHTML":case"ref":break;case"autoFocus":break;case"xlinkHref":if(n==null||typeof n=="function"||typeof n=="boolean"||typeof n=="symbol"){e.removeAttribute("xlink:href");break}a=Bl(""+n),e.setAttributeNS("http://www.w3.org/1999/xlink","xlink:href",a);break;case"contentEditable":case"spellCheck":case"draggable":case"value":case"autoReverse":case"externalResourcesRequired":case"focusable":case"preserveAlpha":n!=null&&typeof n!="function"&&typeof n!="symbol"?e.setAttribute(a,""+n):e.removeAttribute(a);break;case"inert":case"allowFullScreen":case"async":case"autoPlay":case"controls":case"default":case"defer":case"disabled":case"disablePictureInPicture":case"disableRemotePlayback":case"formNoValidate":case"hidden":case"loop":case"noModule":case"noValidate":case"open":case"playsInline":case"readOnly":case"required":case"reversed":case"scoped":case"seamless":case"itemScope":n&&typeof n!="function"&&typeof n!="symbol"?e.setAttribute(a,""):e.removeAttribute(a);break;case"capture":case"download":n===!0?e.setAttribute(a,""):n!==!1&&n!=null&&typeof n!="function"&&typeof n!="symbol"?e.setAttribute(a,n):e.removeAttribute(a);break;case"cols":case"rows":case"size":case"span":n!=null&&typeof n!="function"&&typeof n!="symbol"&&!isNaN(n)&&1<=n?e.setAttribute(a,n):e.removeAttribute(a);break;case"rowSpan":case"start":n==null||typeof n=="function"||typeof n=="symbol"||isNaN(n)?e.removeAttribute(a):e.setAttribute(a,n);break;case"popover":ee("beforetoggle",e),ee("toggle",e),ql(e,"popover",n);break;case"xlinkActuate":Ot(e,"http://www.w3.org/1999/xlink","xlink:actuate",n);break;case"xlinkArcrole":Ot(e,"http://www.w3.org/1999/xlink","xlink:arcrole",n);break;case"xlinkRole":Ot(e,"http://www.w3.org/1999/xlink","xlink:role",n);break;case"xlinkShow":Ot(e,"http://www.w3.org/1999/xlink","xlink:show",n);break;case"xlinkTitle":Ot(e,"http://www.w3.org/1999/xlink","xlink:title",n);break;case"xlinkType":Ot(e,"http://www.w3.org/1999/xlink","xlink:type",n);break;case"xmlBase":Ot(e,"http://www.w3.org/XML/1998/namespace","xml:base",n);break;case"xmlLang":Ot(e,"http://www.w3.org/XML/1998/namespace","xml:lang",n);break;case"xmlSpace":Ot(e,"http://www.w3.org/XML/1998/namespace","xml:space",n);break;case"is":ql(e,"is",n);break;case"innerText":case"textContent":break;default:(!(2<a.length)||a[0]!=="o"&&a[0]!=="O"||a[1]!=="n"&&a[1]!=="N")&&(a=qp.get(a)||a,ql(e,a,n))}}function Po(e,t,a,n,l,i){switch(a){case"style":ts(e,n,i);break;case"dangerouslySetInnerHTML":if(n!=null){if(typeof n!="object"||!("__html"in n))throw Error(r(61));if(a=n.__html,a!=null){if(l.children!=null)throw Error(r(60));e.innerHTML=a}}break;case"children":typeof n=="string"?Za(e,n):(typeof n=="number"||typeof n=="bigint")&&Za(e,""+n);break;case"onScroll":n!=null&&ee("scroll",e);break;case"onScrollEnd":n!=null&&ee("scrollend",e);break;case"onClick":n!=null&&(e.onclick=Di);break;case"suppressContentEditableWarning":case"suppressHydrationWarning":case"innerHTML":case"ref":break;case"innerText":case"textContent":break;default:if(!Xu.hasOwnProperty(a))e:{if(a[0]==="o"&&a[1]==="n"&&(l=a.endsWith("Capture"),t=a.slice(2,l?a.length-7:void 0),i=e[We]||null,i=i!=null?i[a]:null,typeof i=="function"&&e.removeEventListener(t,i,l),typeof n=="function")){typeof i!="function"&&i!==null&&(a in e?e[a]=null:e.hasAttribute(a)&&e.removeAttribute(a)),e.addEventListener(t,n,l);break e}a in e?e[a]=n:n===!0?e.setAttribute(a,""):ql(e,a,n)}}}function Xe(e,t,a){switch(t){case"div":case"span":case"svg":case"path":case"a":case"g":case"p":case"li":break;case"img":ee("error",e),ee("load",e);var n=!1,l=!1,i;for(i in a)if(a.hasOwnProperty(i)){var c=a[i];if(c!=null)switch(i){case"src":n=!0;break;case"srcSet":l=!0;break;case"children":case"dangerouslySetInnerHTML":throw Error(r(137,t));default:fe(e,t,i,c,a,null)}}l&&fe(e,t,"srcSet",a.srcSet,a,null),n&&fe(e,t,"src",a.src,a,null);return;case"input":ee("invalid",e);var u=i=c=l=null,f=null,y=null;for(n in a)if(a.hasOwnProperty(n)){var E=a[n];if(E!=null)switch(n){case"name":l=E;break;case"type":c=E;break;case"checked":f=E;break;case"defaultChecked":y=E;break;case"value":i=E;break;case"defaultValue":u=E;break;case"children":case"dangerouslySetInnerHTML":if(E!=null)throw Error(r(137,t));break;default:fe(e,t,n,E,a,null)}}Fu(e,i,u,f,y,c,l,!1),jl(e);return;case"select":ee("invalid",e),n=c=i=null;for(l in a)if(a.hasOwnProperty(l)&&(u=a[l],u!=null))switch(l){case"value":i=u;break;case"defaultValue":c=u;break;case"multiple":n=u;default:fe(e,t,l,u,a,null)}t=i,a=c,e.multiple=!!n,t!=null?Xa(e,!!n,t,!1):a!=null&&Xa(e,!!n,a,!0);return;case"textarea":ee("invalid",e),i=l=n=null;for(c in a)if(a.hasOwnProperty(c)&&(u=a[c],u!=null))switch(c){case"value":n=u;break;case"defaultValue":l=u;break;case"children":i=u;break;case"dangerouslySetInnerHTML":if(u!=null)throw Error(r(91));break;default:fe(e,t,c,u,a,null)}Iu(e,n,l,i),jl(e);return;case"option":for(f in a)a.hasOwnProperty(f)&&(n=a[f],n!=null)&&(f==="selected"?e.selected=n&&typeof n!="function"&&typeof n!="symbol":fe(e,t,f,n,a,null));return;case"dialog":ee("beforetoggle",e),ee("toggle",e),ee("cancel",e),ee("close",e);break;case"iframe":case"object":ee("load",e);break;case"video":case"audio":for(n=0;n<dl.length;n++)ee(dl[n],e);break;case"image":ee("error",e),ee("load",e);break;case"details":ee("toggle",e);break;case"embed":case"source":case"link":ee("error",e),ee("load",e);case"area":case"base":case"br":case"col":case"hr":case"keygen":case"meta":case"param":case"track":case"wbr":case"menuitem":for(y in a)if(a.hasOwnProperty(y)&&(n=a[y],n!=null))switch(y){case"children":case"dangerouslySetInnerHTML":throw Error(r(137,t));default:fe(e,t,y,n,a,null)}return;default:if(pc(t)){for(E in a)a.hasOwnProperty(E)&&(n=a[E],n!==void 0&&Po(e,t,E,n,a,void 0));return}}for(u in a)a.hasOwnProperty(u)&&(n=a[u],n!=null&&fe(e,t,u,n,a,null))}function cm(e,t,a,n){switch(t){case"div":case"span":case"svg":case"path":case"a":case"g":case"p":case"li":break;case"input":var l=null,i=null,c=null,u=null,f=null,y=null,E=null;for(S in a){var R=a[S];if(a.hasOwnProperty(S)&&R!=null)switch(S){case"checked":break;case"value":break;case"defaultValue":f=R;default:n.hasOwnProperty(S)||fe(e,t,S,null,n,R)}}for(var b in n){var S=n[b];if(R=a[b],n.hasOwnProperty(b)&&(S!=null||R!=null))switch(b){case"type":i=S;break;case"name":l=S;break;case"checked":y=S;break;case"defaultChecked":E=S;break;case"value":c=S;break;case"defaultValue":u=S;break;case"children":case"dangerouslySetInnerHTML":if(S!=null)throw Error(r(137,t));break;default:S!==R&&fe(e,t,b,S,n,R)}}fc(e,c,u,f,y,E,i,l);return;case"select":S=c=u=b=null;for(i in a)if(f=a[i],a.hasOwnProperty(i)&&f!=null)switch(i){case"value":break;case"multiple":S=f;default:n.hasOwnProperty(i)||fe(e,t,i,null,n,f)}for(l in n)if(i=n[l],f=a[l],n.hasOwnProperty(l)&&(i!=null||f!=null))switch(l){case"value":b=i;break;case"defaultValue":u=i;break;case"multiple":c=i;default:i!==f&&fe(e,t,l,i,n,f)}t=u,a=c,n=S,b!=null?Xa(e,!!a,b,!1):!!n!=!!a&&(t!=null?Xa(e,!!a,t,!0):Xa(e,!!a,a?[]:"",!1));return;case"textarea":S=b=null;for(u in a)if(l=a[u],a.hasOwnProperty(u)&&l!=null&&!n.hasOwnProperty(u))switch(u){case"value":break;case"children":break;default:fe(e,t,u,null,n,l)}for(c in n)if(l=n[c],i=a[c],n.hasOwnProperty(c)&&(l!=null||i!=null))switch(c){case"value":b=l;break;case"defaultValue":S=l;break;case"children":break;case"dangerouslySetInnerHTML":if(l!=null)throw Error(r(91));break;default:l!==i&&fe(e,t,c,l,n,i)}Pu(e,b,S);return;case"option":for(var X in a)b=a[X],a.hasOwnProperty(X)&&b!=null&&!n.hasOwnProperty(X)&&(X==="selected"?e.selected=!1:fe(e,t,X,null,n,b));for(f in n)b=n[f],S=a[f],n.hasOwnProperty(f)&&b!==S&&(b!=null||S!=null)&&(f==="selected"?e.selected=b&&typeof b!="function"&&typeof b!="symbol":fe(e,t,f,b,n,S));return;case"img":case"link":case"area":case"base":case"br":case"col":case"embed":case"hr":case"keygen":case"meta":case"param":case"source":case"track":case"wbr":case"menuitem":for(var G in a)b=a[G],a.hasOwnProperty(G)&&b!=null&&!n.hasOwnProperty(G)&&fe(e,t,G,null,n,b);for(y in n)if(b=n[y],S=a[y],n.hasOwnProperty(y)&&b!==S&&(b!=null||S!=null))switch(y){case"children":case"dangerouslySetInnerHTML":if(b!=null)throw Error(r(137,t));break;default:fe(e,t,y,b,n,S)}return;default:if(pc(t)){for(var de in a)b=a[de],a.hasOwnProperty(de)&&b!==void 0&&!n.hasOwnProperty(de)&&Po(e,t,de,void 0,n,b);for(E in n)b=n[E],S=a[E],!n.hasOwnProperty(E)||b===S||b===void 0&&S===void 0||Po(e,t,E,b,n,S);return}}for(var _ in a)b=a[_],a.hasOwnProperty(_)&&b!=null&&!n.hasOwnProperty(_)&&fe(e,t,_,null,n,b);for(R in n)b=n[R],S=a[R],!n.hasOwnProperty(R)||b===S||b==null&&S==null||fe(e,t,R,b,n,S)}var Io=null,eu=null;function Mi(e){return e.nodeType===9?e:e.ownerDocument}function td(e){switch(e){case"http://www.w3.org/2000/svg":return 1;case"http://www.w3.org/1998/Math/MathML":return 2;default:return 0}}function ad(e,t){if(e===0)switch(t){case"svg":return 1;case"math":return 2;default:return 0}return e===1&&t==="foreignObject"?0:e}function tu(e,t){return e==="textarea"||e==="noscript"||typeof t.children=="string"||typeof t.children=="number"||typeof t.children=="bigint"||typeof t.dangerouslySetInnerHTML=="object"&&t.dangerouslySetInnerHTML!==null&&t.dangerouslySetInnerHTML.__html!=null}var au=null;function om(){var e=window.event;return e&&e.type==="popstate"?e===au?!1:(au=e,!0):(au=null,!1)}var nd=typeof setTimeout=="function"?setTimeout:void 0,um=typeof clearTimeout=="function"?clearTimeout:void 0,ld=typeof Promise=="function"?Promise:void 0,sm=typeof queueMicrotask=="function"?queueMicrotask:typeof ld<"u"?function(e){return ld.resolve(null).then(e).catch(rm)}:nd;function rm(e){setTimeout(function(){throw e})}function pa(e){return e==="head"}function id(e,t){var a=t,n=0,l=0;do{var i=a.nextSibling;if(e.removeChild(a),i&&i.nodeType===8)if(a=i.data,a==="/$"){if(0<n&&8>n){a=n;var c=e.ownerDocument;if(a&1&&hl(c.documentElement),a&2&&hl(c.body),a&4)for(a=c.head,hl(a),c=a.firstChild;c;){var u=c.nextSibling,f=c.nodeName;c[Rn]||f==="SCRIPT"||f==="STYLE"||f==="LINK"&&c.rel.toLowerCase()==="stylesheet"||a.removeChild(c),c=u}}if(l===0){e.removeChild(i),kl(t);return}l--}else a==="$"||a==="$?"||a==="$!"?l++:n=a.charCodeAt(0)-48;else n=0;a=i}while(a);kl(t)}function nu(e){var t=e.firstChild;for(t&&t.nodeType===10&&(t=t.nextSibling);t;){var a=t;switch(t=t.nextSibling,a.nodeName){case"HTML":case"HEAD":case"BODY":nu(a),oc(a);continue;case"SCRIPT":case"STYLE":continue;case"LINK":if(a.rel.toLowerCase()==="stylesheet")continue}e.removeChild(a)}}function fm(e,t,a,n){for(;e.nodeType===1;){var l=a;if(e.nodeName.toLowerCase()!==t.toLowerCase()){if(!n&&(e.nodeName!=="INPUT"||e.type!=="hidden"))break}else if(n){if(!e[Rn])switch(t){case"meta":if(!e.hasAttribute("itemprop"))break;return e;case"link":if(i=e.getAttribute("rel"),i==="stylesheet"&&e.hasAttribute("data-precedence"))break;if(i!==l.rel||e.getAttribute("href")!==(l.href==null||l.href===""?null:l.href)||e.getAttribute("crossorigin")!==(l.crossOrigin==null?null:l.crossOrigin)||e.getAttribute("title")!==(l.title==null?null:l.title))break;return e;case"style":if(e.hasAttribute("data-precedence"))break;return e;case"script":if(i=e.getAttribute("src"),(i!==(l.src==null?null:l.src)||e.getAttribute("type")!==(l.type==null?null:l.type)||e.getAttribute("crossorigin")!==(l.crossOrigin==null?null:l.crossOrigin))&&i&&e.hasAttribute("async")&&!e.hasAttribute("itemprop"))break;return e;default:return e}}else if(t==="input"&&e.type==="hidden"){var i=l.name==null?null:""+l.name;if(l.type==="hidden"&&e.getAttribute("name")===i)return e}else return e;if(e=Tt(e.nextSibling),e===null)break}return null}function dm(e,t,a){if(t==="")return null;for(;e.nodeType!==3;)if((e.nodeType!==1||e.nodeName!=="INPUT"||e.type!=="hidden")&&!a||(e=Tt(e.nextSibling),e===null))return null;return e}function lu(e){return e.data==="$!"||e.data==="$?"&&e.ownerDocument.readyState==="complete"}function pm(e,t){var a=e.ownerDocument;if(e.data!=="$?"||a.readyState==="complete")t();else{var n=function(){t(),a.removeEventListener("DOMContentLoaded",n)};a.addEventListener("DOMContentLoaded",n),e._reactRetry=n}}function Tt(e){for(;e!=null;e=e.nextSibling){var t=e.nodeType;if(t===1||t===3)break;if(t===8){if(t=e.data,t==="$"||t==="$!"||t==="$?"||t==="F!"||t==="F")break;if(t==="/$")return null}}return e}var iu=null;function cd(e){e=e.previousSibling;for(var t=0;e;){if(e.nodeType===8){var a=e.data;if(a==="$"||a==="$!"||a==="$?"){if(t===0)return e;t--}else a==="/$"&&t++}e=e.previousSibling}return null}function od(e,t,a){switch(t=Mi(a),e){case"html":if(e=t.documentElement,!e)throw Error(r(452));return e;case"head":if(e=t.head,!e)throw Error(r(453));return e;case"body":if(e=t.body,!e)throw Error(r(454));return e;default:throw Error(r(451))}}function hl(e){for(var t=e.attributes;t.length;)e.removeAttributeNode(t[0]);oc(e)}var kt=new Map,ud=new Set;function Oi(e){return typeof e.getRootNode=="function"?e.getRootNode():e.nodeType===9?e:e.ownerDocument}var Kt=q.d;q.d={f:hm,r:mm,D:_m,C:vm,L:gm,m:ym,X:Sm,S:bm,M:km};function hm(){var e=Kt.f(),t=wi();return e||t}function mm(e){var t=La(e);t!==null&&t.tag===5&&t.type==="form"?Ar(t):Kt.r(e)}var Sn=typeof document>"u"?null:document;function sd(e,t,a){var n=Sn;if(n&&typeof t=="string"&&t){var l=mt(t);l='link[rel="'+e+'"][href="'+l+'"]',typeof a=="string"&&(l+='[crossorigin="'+a+'"]'),ud.has(l)||(ud.add(l),e={rel:e,crossOrigin:a,href:t},n.querySelector(l)===null&&(t=n.createElement("link"),Xe(t,"link",e),He(t),n.head.appendChild(t)))}}function _m(e){Kt.D(e),sd("dns-prefetch",e,null)}function vm(e,t){Kt.C(e,t),sd("preconnect",e,t)}function gm(e,t,a){Kt.L(e,t,a);var n=Sn;if(n&&e&&t){var l='link[rel="preload"][as="'+mt(t)+'"]';t==="image"&&a&&a.imageSrcSet?(l+='[imagesrcset="'+mt(a.imageSrcSet)+'"]',typeof a.imageSizes=="string"&&(l+='[imagesizes="'+mt(a.imageSizes)+'"]')):l+='[href="'+mt(e)+'"]';var i=l;switch(t){case"style":i=kn(e);break;case"script":i=xn(e)}kt.has(i)||(e=N({rel:"preload",href:t==="image"&&a&&a.imageSrcSet?void 0:e,as:t},a),kt.set(i,e),n.querySelector(l)!==null||t==="style"&&n.querySelector(ml(i))||t==="script"&&n.querySelector(_l(i))||(t=n.createElement("link"),Xe(t,"link",e),He(t),n.head.appendChild(t)))}}function ym(e,t){Kt.m(e,t);var a=Sn;if(a&&e){var n=t&&typeof t.as=="string"?t.as:"script",l='link[rel="modulepreload"][as="'+mt(n)+'"][href="'+mt(e)+'"]',i=l;switch(n){case"audioworklet":case"paintworklet":case"serviceworker":case"sharedworker":case"worker":case"script":i=xn(e)}if(!kt.has(i)&&(e=N({rel:"modulepreload",href:e},t),kt.set(i,e),a.querySelector(l)===null)){switch(n){case"audioworklet":case"paintworklet":case"serviceworker":case"sharedworker":case"worker":case"script":if(a.querySelector(_l(i)))return}n=a.createElement("link"),Xe(n,"link",e),He(n),a.head.appendChild(n)}}}function bm(e,t,a){Kt.S(e,t,a);var n=Sn;if(n&&e){var l=Ya(n).hoistableStyles,i=kn(e);t=t||"default";var c=l.get(i);if(!c){var u={loading:0,preload:null};if(c=n.querySelector(ml(i)))u.loading=5;else{e=N({rel:"stylesheet",href:e,"data-precedence":t},a),(a=kt.get(i))&&cu(e,a);var f=c=n.createElement("link");He(f),Xe(f,"link",e),f._p=new Promise(function(y,E){f.onload=y,f.onerror=E}),f.addEventListener("load",function(){u.loading|=1}),f.addEventListener("error",function(){u.loading|=2}),u.loading|=4,Ui(c,t,n)}c={type:"stylesheet",instance:c,count:1,state:u},l.set(i,c)}}}function Sm(e,t){Kt.X(e,t);var a=Sn;if(a&&e){var n=Ya(a).hoistableScripts,l=xn(e),i=n.get(l);i||(i=a.querySelector(_l(l)),i||(e=N({src:e,async:!0},t),(t=kt.get(l))&&ou(e,t),i=a.createElement("script"),He(i),Xe(i,"link",e),a.head.appendChild(i)),i={type:"script",instance:i,count:1,state:null},n.set(l,i))}}function km(e,t){Kt.M(e,t);var a=Sn;if(a&&e){var n=Ya(a).hoistableScripts,l=xn(e),i=n.get(l);i||(i=a.querySelector(_l(l)),i||(e=N({src:e,async:!0,type:"module"},t),(t=kt.get(l))&&ou(e,t),i=a.createElement("script"),He(i),Xe(i,"link",e),a.head.appendChild(i)),i={type:"script",instance:i,count:1,state:null},n.set(l,i))}}function rd(e,t,a,n){var l=(l=Z.current)?Oi(l):null;if(!l)throw Error(r(446));switch(e){case"meta":case"title":return null;case"style":return typeof a.precedence=="string"&&typeof a.href=="string"?(t=kn(a.href),a=Ya(l).hoistableStyles,n=a.get(t),n||(n={type:"style",instance:null,count:0,state:null},a.set(t,n)),n):{type:"void",instance:null,count:0,state:null};case"link":if(a.rel==="stylesheet"&&typeof a.href=="string"&&typeof a.precedence=="string"){e=kn(a.href);var i=Ya(l).hoistableStyles,c=i.get(e);if(c||(l=l.ownerDocument||l,c={type:"stylesheet",instance:null,count:0,state:{loading:0,preload:null}},i.set(e,c),(i=l.querySelector(ml(e)))&&!i._p&&(c.instance=i,c.state.loading=5),kt.has(e)||(a={rel:"preload",as:"style",href:a.href,crossOrigin:a.crossOrigin,integrity:a.integrity,media:a.media,hrefLang:a.hrefLang,referrerPolicy:a.referrerPolicy},kt.set(e,a),i||xm(l,e,a,c.state))),t&&n===null)throw Error(r(528,""));return c}if(t&&n!==null)throw Error(r(529,""));return null;case"script":return t=a.async,a=a.src,typeof a=="string"&&t&&typeof t!="function"&&typeof t!="symbol"?(t=xn(a),a=Ya(l).hoistableScripts,n=a.get(t),n||(n={type:"script",instance:null,count:0,state:null},a.set(t,n)),n):{type:"void",instance:null,count:0,state:null};default:throw Error(r(444,e))}}function kn(e){return'href="'+mt(e)+'"'}function ml(e){return'link[rel="stylesheet"]['+e+"]"}function fd(e){return N({},e,{"data-precedence":e.precedence,precedence:null})}function xm(e,t,a,n){e.querySelector('link[rel="preload"][as="style"]['+t+"]")?n.loading=1:(t=e.createElement("link"),n.preload=t,t.addEventListener("load",function(){return n.loading|=1}),t.addEventListener("error",function(){return n.loading|=2}),Xe(t,"link",a),He(t),e.head.appendChild(t))}function xn(e){return'[src="'+mt(e)+'"]'}function _l(e){return"script[async]"+e}function dd(e,t,a){if(t.count++,t.instance===null)switch(t.type){case"style":var n=e.querySelector('style[data-href~="'+mt(a.href)+'"]');if(n)return t.instance=n,He(n),n;var l=N({},a,{"data-href":a.href,"data-precedence":a.precedence,href:null,precedence:null});return n=(e.ownerDocument||e).createElement("style"),He(n),Xe(n,"style",l),Ui(n,a.precedence,e),t.instance=n;case"stylesheet":l=kn(a.href);var i=e.querySelector(ml(l));if(i)return t.state.loading|=4,t.instance=i,He(i),i;n=fd(a),(l=kt.get(l))&&cu(n,l),i=(e.ownerDocument||e).createElement("link"),He(i);var c=i;return c._p=new Promise(function(u,f){c.onload=u,c.onerror=f}),Xe(i,"link",n),t.state.loading|=4,Ui(i,a.precedence,e),t.instance=i;case"script":return i=xn(a.src),(l=e.querySelector(_l(i)))?(t.instance=l,He(l),l):(n=a,(l=kt.get(i))&&(n=N({},a),ou(n,l)),e=e.ownerDocument||e,l=e.createElement("script"),He(l),Xe(l,"link",n),e.head.appendChild(l),t.instance=l);case"void":return null;default:throw Error(r(443,t.type))}else t.type==="stylesheet"&&(t.state.loading&4)===0&&(n=t.instance,t.state.loading|=4,Ui(n,a.precedence,e));return t.instance}function Ui(e,t,a){for(var n=a.querySelectorAll('link[rel="stylesheet"][data-precedence],style[data-precedence]'),l=n.length?n[n.length-1]:null,i=l,c=0;c<n.length;c++){var u=n[c];if(u.dataset.precedence===t)i=u;else if(i!==l)break}i?i.parentNode.insertBefore(e,i.nextSibling):(t=a.nodeType===9?a.head:a,t.insertBefore(e,t.firstChild))}function cu(e,t){e.crossOrigin==null&&(e.crossOrigin=t.crossOrigin),e.referrerPolicy==null&&(e.referrerPolicy=t.referrerPolicy),e.title==null&&(e.title=t.title)}function ou(e,t){e.crossOrigin==null&&(e.crossOrigin=t.crossOrigin),e.referrerPolicy==null&&(e.referrerPolicy=t.referrerPolicy),e.integrity==null&&(e.integrity=t.integrity)}var qi=null;function pd(e,t,a){if(qi===null){var n=new Map,l=qi=new Map;l.set(a,n)}else l=qi,n=l.get(a),n||(n=new Map,l.set(a,n));if(n.has(e))return n;for(n.set(e,null),a=a.getElementsByTagName(e),l=0;l<a.length;l++){var i=a[l];if(!(i[Rn]||i[Ve]||e==="link"&&i.getAttribute("rel")==="stylesheet")&&i.namespaceURI!=="http://www.w3.org/2000/svg"){var c=i.getAttribute(t)||"";c=e+c;var u=n.get(c);u?u.push(i):n.set(c,[i])}}return n}function hd(e,t,a){e=e.ownerDocument||e,e.head.insertBefore(a,t==="title"?e.querySelector("head > title"):null)}function wm(e,t,a){if(a===1||t.itemProp!=null)return!1;switch(e){case"meta":case"title":return!0;case"style":if(typeof t.precedence!="string"||typeof t.href!="string"||t.href==="")break;return!0;case"link":if(typeof t.rel!="string"||typeof t.href!="string"||t.href===""||t.onLoad||t.onError)break;return t.rel==="stylesheet"?(e=t.disabled,typeof t.precedence=="string"&&e==null):!0;case"script":if(t.async&&typeof t.async!="function"&&typeof t.async!="symbol"&&!t.onLoad&&!t.onError&&t.src&&typeof t.src=="string")return!0}return!1}function md(e){return!(e.type==="stylesheet"&&(e.state.loading&3)===0)}var vl=null;function Tm(){}function Em(e,t,a){if(vl===null)throw Error(r(475));var n=vl;if(t.type==="stylesheet"&&(typeof a.media!="string"||matchMedia(a.media).matches!==!1)&&(t.state.loading&4)===0){if(t.instance===null){var l=kn(a.href),i=e.querySelector(ml(l));if(i){e=i._p,e!==null&&typeof e=="object"&&typeof e.then=="function"&&(n.count++,n=Ci.bind(n),e.then(n,n)),t.state.loading|=4,t.instance=i,He(i);return}i=e.ownerDocument||e,a=fd(a),(l=kt.get(l))&&cu(a,l),i=i.createElement("link"),He(i);var c=i;c._p=new Promise(function(u,f){c.onload=u,c.onerror=f}),Xe(i,"link",a),t.instance=i}n.stylesheets===null&&(n.stylesheets=new Map),n.stylesheets.set(t,e),(e=t.state.preload)&&(t.state.loading&3)===0&&(n.count++,t=Ci.bind(n),e.addEventListener("load",t),e.addEventListener("error",t))}}function Am(){if(vl===null)throw Error(r(475));var e=vl;return e.stylesheets&&e.count===0&&uu(e,e.stylesheets),0<e.count?function(t){var a=setTimeout(function(){if(e.stylesheets&&uu(e,e.stylesheets),e.unsuspend){var n=e.unsuspend;e.unsuspend=null,n()}},6e4);return e.unsuspend=t,function(){e.unsuspend=null,clearTimeout(a)}}:null}function Ci(){if(this.count--,this.count===0){if(this.stylesheets)uu(this,this.stylesheets);else if(this.unsuspend){var e=this.unsuspend;this.unsuspend=null,e()}}}var ji=null;function uu(e,t){e.stylesheets=null,e.unsuspend!==null&&(e.count++,ji=new Map,t.forEach(zm,e),ji=null,Ci.call(e))}function zm(e,t){if(!(t.state.loading&4)){var a=ji.get(e);if(a)var n=a.get(null);else{a=new Map,ji.set(e,a);for(var l=e.querySelectorAll("link[data-precedence],style[data-precedence]"),i=0;i<l.length;i++){var c=l[i];(c.nodeName==="LINK"||c.getAttribute("media")!=="not all")&&(a.set(c.dataset.precedence,c),n=c)}n&&a.set(null,n)}l=t.instance,c=l.getAttribute("data-precedence"),i=a.get(c)||n,i===n&&a.set(null,l),a.set(c,l),this.count++,n=Ci.bind(this),l.addEventListener("load",n),l.addEventListener("error",n),i?i.parentNode.insertBefore(l,i.nextSibling):(e=e.nodeType===9?e.head:e,e.insertBefore(l,e.firstChild)),t.state.loading|=4}}var gl={$$typeof:ce,Provider:null,Consumer:null,_currentValue:Y,_currentValue2:Y,_threadCount:0};function Rm(e,t,a,n,l,i,c,u){this.tag=1,this.containerInfo=e,this.pingCache=this.current=this.pendingChildren=null,this.timeoutHandle=-1,this.callbackNode=this.next=this.pendingContext=this.context=this.cancelPendingCommit=null,this.callbackPriority=0,this.expirationTimes=nc(-1),this.entangledLanes=this.shellSuspendCounter=this.errorRecoveryDisabledLanes=this.expiredLanes=this.warmLanes=this.pingedLanes=this.suspendedLanes=this.pendingLanes=0,this.entanglements=nc(0),this.hiddenUpdates=nc(null),this.identifierPrefix=n,this.onUncaughtError=l,this.onCaughtError=i,this.onRecoverableError=c,this.pooledCache=null,this.pooledCacheLanes=0,this.formState=u,this.incompleteTransitions=new Map}function _d(e,t,a,n,l,i,c,u,f,y,E,R){return e=new Rm(e,t,a,c,u,f,y,R),t=1,i===!0&&(t|=24),i=ut(3,null,null,t),e.current=i,i.stateNode=e,t=Gc(),t.refCount++,e.pooledCache=t,t.refCount++,i.memoizedState={element:n,isDehydrated:a,cache:t},Vc(i),e}function vd(e){return e?(e=Ia,e):Ia}function gd(e,t,a,n,l,i){l=vd(l),n.context===null?n.context=l:n.pendingContext=l,n=ea(t),n.payload={element:a},i=i===void 0?null:i,i!==null&&(n.callback=i),a=ta(e,n,t),a!==null&&(pt(a,e,t),Jn(a,e,t))}function yd(e,t){if(e=e.memoizedState,e!==null&&e.dehydrated!==null){var a=e.retryLane;e.retryLane=a!==0&&a<t?a:t}}function su(e,t){yd(e,t),(e=e.alternate)&&yd(e,t)}function bd(e){if(e.tag===13){var t=Pa(e,67108864);t!==null&&pt(t,e,67108864),su(e,67108864)}}var Hi=!0;function Nm(e,t,a,n){var l=T.T;T.T=null;var i=q.p;try{q.p=2,ru(e,t,a,n)}finally{q.p=i,T.T=l}}function Dm(e,t,a,n){var l=T.T;T.T=null;var i=q.p;try{q.p=8,ru(e,t,a,n)}finally{q.p=i,T.T=l}}function ru(e,t,a,n){if(Hi){var l=fu(n);if(l===null)Fo(e,t,n,Bi,a),kd(e,n);else if(Om(l,e,t,a,n))n.stopPropagation();else if(kd(e,n),t&4&&-1<Mm.indexOf(e)){for(;l!==null;){var i=La(l);if(i!==null)switch(i.tag){case 3:if(i=i.stateNode,i.current.memoizedState.isDehydrated){var c=ya(i.pendingLanes);if(c!==0){var u=i;for(u.pendingLanes|=2,u.entangledLanes|=2;c;){var f=1<<31-ct(c);u.entanglements[1]|=f,c&=~f}Dt(i),(ue&6)===0&&(ki=Et()+500,fl(0))}}break;case 13:u=Pa(i,2),u!==null&&pt(u,i,2),wi(),su(i,2)}if(i=fu(n),i===null&&Fo(e,t,n,Bi,a),i===l)break;l=i}l!==null&&n.stopPropagation()}else Fo(e,t,n,null,a)}}function fu(e){return e=mc(e),du(e)}var Bi=null;function du(e){if(Bi=null,e=Ba(e),e!==null){var t=z(e);if(t===null)e=null;else{var a=t.tag;if(a===13){if(e=U(t),e!==null)return e;e=null}else if(a===3){if(t.stateNode.current.memoizedState.isDehydrated)return t.tag===3?t.stateNode.containerInfo:null;e=null}else t!==e&&(e=null)}}return Bi=e,null}function Sd(e){switch(e){case"beforetoggle":case"cancel":case"click":case"close":case"contextmenu":case"copy":case"cut":case"auxclick":case"dblclick":case"dragend":case"dragstart":case"drop":case"focusin":case"focusout":case"input":case"invalid":case"keydown":case"keypress":case"keyup":case"mousedown":case"mouseup":case"paste":case"pause":case"play":case"pointercancel":case"pointerdown":case"pointerup":case"ratechange":case"reset":case"resize":case"seeked":case"submit":case"toggle":case"touchcancel":case"touchend":case"touchstart":case"volumechange":case"change":case"selectionchange":case"textInput":case"compositionstart":case"compositionend":case"compositionupdate":case"beforeblur":case"afterblur":case"beforeinput":case"blur":case"fullscreenchange":case"focus":case"hashchange":case"popstate":case"select":case"selectstart":return 2;case"drag":case"dragenter":case"dragexit":case"dragleave":case"dragover":case"mousemove":case"mouseout":case"mouseover":case"pointermove":case"pointerout":case"pointerover":case"scroll":case"touchmove":case"wheel":case"mouseenter":case"mouseleave":case"pointerenter":case"pointerleave":return 8;case"message":switch(vp()){case Uu:return 2;case qu:return 8;case Dl:case gp:return 32;case Cu:return 268435456;default:return 32}default:return 32}}var pu=!1,ha=null,ma=null,_a=null,yl=new Map,bl=new Map,va=[],Mm="mousedown mouseup touchcancel touchend touchstart auxclick dblclick pointercancel pointerdown pointerup dragend dragstart drop compositionend compositionstart keydown keypress keyup input textInput copy cut paste click change contextmenu reset".split(" ");function kd(e,t){switch(e){case"focusin":case"focusout":ha=null;break;case"dragenter":case"dragleave":ma=null;break;case"mouseover":case"mouseout":_a=null;break;case"pointerover":case"pointerout":yl.delete(t.pointerId);break;case"gotpointercapture":case"lostpointercapture":bl.delete(t.pointerId)}}function Sl(e,t,a,n,l,i){return e===null||e.nativeEvent!==i?(e={blockedOn:t,domEventName:a,eventSystemFlags:n,nativeEvent:i,targetContainers:[l]},t!==null&&(t=La(t),t!==null&&bd(t)),e):(e.eventSystemFlags|=n,t=e.targetContainers,l!==null&&t.indexOf(l)===-1&&t.push(l),e)}function Om(e,t,a,n,l){switch(t){case"focusin":return ha=Sl(ha,e,t,a,n,l),!0;case"dragenter":return ma=Sl(ma,e,t,a,n,l),!0;case"mouseover":return _a=Sl(_a,e,t,a,n,l),!0;case"pointerover":var i=l.pointerId;return yl.set(i,Sl(yl.get(i)||null,e,t,a,n,l)),!0;case"gotpointercapture":return i=l.pointerId,bl.set(i,Sl(bl.get(i)||null,e,t,a,n,l)),!0}return!1}function xd(e){var t=Ba(e.target);if(t!==null){var a=z(t);if(a!==null){if(t=a.tag,t===13){if(t=U(a),t!==null){e.blockedOn=t,Ep(e.priority,function(){if(a.tag===13){var n=dt();n=lc(n);var l=Pa(a,n);l!==null&&pt(l,a,n),su(a,n)}});return}}else if(t===3&&a.stateNode.current.memoizedState.isDehydrated){e.blockedOn=a.tag===3?a.stateNode.containerInfo:null;return}}}e.blockedOn=null}function Li(e){if(e.blockedOn!==null)return!1;for(var t=e.targetContainers;0<t.length;){var a=fu(e.nativeEvent);if(a===null){a=e.nativeEvent;var n=new a.constructor(a.type,a);hc=n,a.target.dispatchEvent(n),hc=null}else return t=La(a),t!==null&&bd(t),e.blockedOn=a,!1;t.shift()}return!0}function wd(e,t,a){Li(e)&&a.delete(t)}function Um(){pu=!1,ha!==null&&Li(ha)&&(ha=null),ma!==null&&Li(ma)&&(ma=null),_a!==null&&Li(_a)&&(_a=null),yl.forEach(wd),bl.forEach(wd)}function Yi(e,t){e.blockedOn===t&&(e.blockedOn=null,pu||(pu=!0,o.unstable_scheduleCallback(o.unstable_NormalPriority,Um)))}var Gi=null;function Td(e){Gi!==e&&(Gi=e,o.unstable_scheduleCallback(o.unstable_NormalPriority,function(){Gi===e&&(Gi=null);for(var t=0;t<e.length;t+=3){var a=e[t],n=e[t+1],l=e[t+2];if(typeof n!="function"){if(du(n||a)===null)continue;break}var i=La(a);i!==null&&(e.splice(t,3),t-=3,fo(i,{pending:!0,data:l,method:a.method,action:n},n,l))}}))}function kl(e){function t(f){return Yi(f,e)}ha!==null&&Yi(ha,e),ma!==null&&Yi(ma,e),_a!==null&&Yi(_a,e),yl.forEach(t),bl.forEach(t);for(var a=0;a<va.length;a++){var n=va[a];n.blockedOn===e&&(n.blockedOn=null)}for(;0<va.length&&(a=va[0],a.blockedOn===null);)xd(a),a.blockedOn===null&&va.shift();if(a=(e.ownerDocument||e).$$reactFormReplay,a!=null)for(n=0;n<a.length;n+=3){var l=a[n],i=a[n+1],c=l[We]||null;if(typeof i=="function")c||Td(a);else if(c){var u=null;if(i&&i.hasAttribute("formAction")){if(l=i,c=i[We]||null)u=c.formAction;else if(du(l)!==null)continue}else u=c.action;typeof u=="function"?a[n+1]=u:(a.splice(n,3),n-=3),Td(a)}}}function hu(e){this._internalRoot=e}Qi.prototype.render=hu.prototype.render=function(e){var t=this._internalRoot;if(t===null)throw Error(r(409));var a=t.current,n=dt();gd(a,n,e,t,null,null)},Qi.prototype.unmount=hu.prototype.unmount=function(){var e=this._internalRoot;if(e!==null){this._internalRoot=null;var t=e.containerInfo;gd(e.current,2,null,e,null,null),wi(),t[Ha]=null}};function Qi(e){this._internalRoot=e}Qi.prototype.unstable_scheduleHydration=function(e){if(e){var t=Yu();e={blockedOn:null,target:e,priority:t};for(var a=0;a<va.length&&t!==0&&t<va[a].priority;a++);va.splice(a,0,e),a===0&&xd(e)}};var Ed=s.version;if(Ed!=="19.1.1")throw Error(r(527,Ed,"19.1.1"));q.findDOMNode=function(e){var t=e._reactInternals;if(t===void 0)throw typeof e.render=="function"?Error(r(188)):(e=Object.keys(e).join(","),Error(r(268,e)));return e=g(t),e=e!==null?k(e):null,e=e===null?null:e.stateNode,e};var qm={bundleType:0,version:"19.1.1",rendererPackageName:"react-dom",currentDispatcherRef:T,reconcilerVersion:"19.1.1"};if(typeof __REACT_DEVTOOLS_GLOBAL_HOOK__<"u"){var Xi=__REACT_DEVTOOLS_GLOBAL_HOOK__;if(!Xi.isDisabled&&Xi.supportsFiber)try{En=Xi.inject(qm),it=Xi}catch{}}return wl.createRoot=function(e,t){if(!w(e))throw Error(r(299));var a=!1,n="",l=Yr,i=Gr,c=Qr,u=null;return t!=null&&(t.unstable_strictMode===!0&&(a=!0),t.identifierPrefix!==void 0&&(n=t.identifierPrefix),t.onUncaughtError!==void 0&&(l=t.onUncaughtError),t.onCaughtError!==void 0&&(i=t.onCaughtError),t.onRecoverableError!==void 0&&(c=t.onRecoverableError),t.unstable_transitionCallbacks!==void 0&&(u=t.unstable_transitionCallbacks)),t=_d(e,1,!1,null,null,a,n,l,i,c,u,null),e[Ha]=t.current,Wo(e),new hu(t)},wl.hydrateRoot=function(e,t,a){if(!w(e))throw Error(r(299));var n=!1,l="",i=Yr,c=Gr,u=Qr,f=null,y=null;return a!=null&&(a.unstable_strictMode===!0&&(n=!0),a.identifierPrefix!==void 0&&(l=a.identifierPrefix),a.onUncaughtError!==void 0&&(i=a.onUncaughtError),a.onCaughtError!==void 0&&(c=a.onCaughtError),a.onRecoverableError!==void 0&&(u=a.onRecoverableError),a.unstable_transitionCallbacks!==void 0&&(f=a.unstable_transitionCallbacks),a.formState!==void 0&&(y=a.formState)),t=_d(e,1,!0,t,a??null,n,l,i,c,u,f,y),t.context=vd(null),a=t.current,n=dt(),n=lc(n),l=ea(n),l.callback=null,ta(a,l,n),a=n,t.current.lanes=a,zn(t,a),Dt(t),e[Ha]=t.current,Wo(e),new Qi(t)},wl.version="19.1.1",wl}var Cd;function Zm(){if(Cd)return _u.exports;Cd=1;function o(){if(!(typeof __REACT_DEVTOOLS_GLOBAL_HOOK__>"u"||typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE!="function"))try{__REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE(o)}catch(s){console.error(s)}}return o(),_u.exports=Xm(),_u.exports}var Vm=Zm();const Km="modulepreload",Jm=function(o){return"/v2/"+o},jd={},Tn=function(s,p,r){let w=Promise.resolve();if(p&&p.length>0){let g=function(k){return Promise.all(k.map(N=>Promise.resolve(N).then(L=>({status:"fulfilled",value:L}),L=>({status:"rejected",reason:L}))))};document.getElementsByTagName("link");const U=document.querySelector("meta[property=csp-nonce]"),O=U?.nonce||U?.getAttribute("nonce");w=g(p.map(k=>{if(k=Jm(k),k in jd)return;jd[k]=!0;const N=k.endsWith(".css"),L=N?'[rel="stylesheet"]':"";if(document.querySelector(`link[href="${k}"]${L}`))return;const V=document.createElement("link");if(V.rel=N?"stylesheet":Km,N||(V.as="script"),V.crossOrigin="",V.href=k,O&&V.setAttribute("nonce",O),document.head.appendChild(V),N)return new Promise((ve,ie)=>{V.addEventListener("load",ve),V.addEventListener("error",()=>ie(new Error(`Unable to preload CSS for ${k}`)))})}))}function z(U){const O=new Event("vite:preloadError",{cancelable:!0});if(O.payload=U,window.dispatchEvent(O),!O.defaultPrevented)throw U}return w.then(U=>{for(const O of U||[])O.status==="rejected"&&z(O.reason);return s().catch(z)})};var C=Au();const $m={"shell.switch_light":"切换浅色模式","shell.switch_dark":"切换深色模式","shell.update_available":"新版已就绪，刷新后使用。","shell.reload":"刷新页面","app.name":"QuantStrategyLab","shell.cockpit":"决策驾驶舱","nav.main":"主导航","nav.overview":"总览","nav.performance":"收益分析","nav.decisions":"决策","nav.accounts":"账户","nav.strategies":"策略","nav.health":"健康","nav.more":"更多","nav.todo_unavailable":"待办数量不可读","common.loading":"正在读取…","common.retry":"重试","common.close":"关闭","common.cancel":"取消","common.confirm":"确认继续","common.save":"保存","common.edit":"编辑","common.back":"返回","common.all":"全部","common.none":"无","common.unknown":"未知","common.na":"—","common.as_of":"数据截至 {value}","common.updated_at":"页面刷新于 {value}","common.refresh":"刷新","common.refreshing":"正在刷新…","common.copy":"复制","common.copied":"已复制","common.view_all":"查看全部","common.load_more":"加载更多","common.table_scroll_hint":"左右滑动查看全部字段","common.expand":"展开","common.collapse":"收起","common.account":"账户","common.ibkr_account":"IBKR 账户","common.platform":"平台","common.strategy":"策略","common.time":"时间","common.status":"状态","common.details":"详情","common.synthetic_badge":"合成演示","common.paper_badge":"模拟","common.page_load_failed":"此页面无法加载","common.read_failed_banner":"部分数据读取失败，请稍后重试；读取失败不代表没有内容。","common.unsaved_guard_title":"放弃未保存的修改？","common.unsaved_guard_body":"当前有未保存的修改，离开后将丢失。","state.unknown_status":"未知状态","state.review":"待复核","state.watch":"需关注","state.critical":"严重","state.blocked":"运行受阻","state.failed":"运行失败","state.read_incomplete":"读取不完整","state.insufficient":"资料不足","state.previewed":"已预览","state.no_submission":"未提交订单","state.no_rebalance":"无需调仓","state.filled":"已成交","state.not_due":"尚未到运行时间","state.market_closed":"休市","state.outside_window":"不在运行时段","state.within_grace":"仍在等待期","state.missing_report":"缺少报告","state.error":"运行错误","state.healthy":"健康","state.no_signal":"无信号","state.ok":"正常","state.partial":"部分数据","state.partial_valuation":"估值不完整","state.partial_runtime":"运行未接入","state.stale":"数据偏旧","state.no_data":"暂无数据","state.not_connected":"未接入","state.unavailable":"暂不可计算","state.read_failed":"读取失败","state.load_failed":"暂时无法加载","reason.external_cashflow_required":"缺少完整出入金记录，暂不展示 TWR；金额按资产变动展示。","reason.fills_not_connected":"成交记录源未接入","reason.execution_coverage_unverified":"成交覆盖范围未核实","reason.avg_cost_missing":"缺少成本价，未实现盈亏暂不可计算","reason.mixed_currency":"多币种无法合并为单一金额；按币种分别展示","reason.snapshot_history_missing":"缺少历史资产快照","reason.snapshot_missing":"缺少资产快照","reason.snapshot_pending":"今日数据待更新","reason.previous_snapshot_missing":"缺少前一日的资产快照","reason.non_trading_weekend":"非交易日","reason.incomplete_month":"当月数据尚不完整","reason.insufficient_observations":"历史数据不足","reason.invalid_return_period":"区间端点无效","reason.positions_partial_coverage":"持仓仅覆盖部分资产","reason.positions_not_connected":"持仓数据源未接入","reason.positions_stale":"持仓数据偏旧","reason.benchmark_history_unreadable":"基准数据读取失败","reason.position_value_missing":"缺少持仓市值","reason.no_common_date":"与基准没有可对齐的共同日期","reason.benchmark_history_missing":"缺少基准历史数据","reason.stored_records_unreadable":"存储记录读取失败","reason.effect_verification_not_recorded":"暂无记录可用于确认变更结果。","reason.bounded_audit_log":"历史记录有保留上限，可能不完整","reason.no_closed_trades":"没有已平仓的交易","reason.notification_log_not_connected":"通知发送记录源未接入","reason.runtime_daily_not_connected":"运行记录源未接入","reason.runtime_daily_binding_conflict":"运行记录存在多个账户绑定，请检查配置","reason.today_record_missing":"今日暂无运行记录","reason.runtime_daily_stale":"运行记录已过期","reason.runtime_daily_incomplete":"运行记录不完整","reason.strategy_health_not_connected":"策略健康度来源未接入","reason.available":"可操作","reason.admin_required":"需要管理员权限","reason.dispatch_unavailable":"执行通道暂不可用","reason.stop_pending_or_identity_unavailable":"已有停用请求待确认或身份暂不可用","reason.strategy_application_not_connected":"策略应用通道未接入","reason.existing_recovery_not_available":"没有可用的既有恢复流程","reason.runtime_instances_not_bound":"运行实例未绑定","reason.account_settings_identity_conflict":"草案绑定的是旧身份，需先确认","reason.profile_draft_required":"请先保存当前账户的策略草案。","reason.profile_only_required":"仅支持策略档案类草案","reason.profile_not_selectable":"该策略档案不可选","reason.runtime_readback_unavailable":"运行状态读回不可用","reason.runtime_control_pending":"上次操作仍待确认","reason.runtime_control_result_unavailable":"结果暂未确认，请刷新查看。","reason.platform_result_unavailable":"平台结果暂未确认，请刷新查看。","reason.platform_dispatch_unverified":"平台请求结果暂未确认。","reason.platform_dispatch_rejected":"平台未接受请求，设置可能已保存。","reason.readback_dispatch_rejected":"暂时无法查询平台结果。","reason.runtime_control_workflow_permission_denied":"没有查询平台工作流的权限。","reason.runtime_control_workflow_unavailable":"平台工作流暂不可用。","reason.runtime_control_target_unsupported":"账户绑定与平台配置不一致。","reason.stop_source_permission_denied":"没有读取平台配置的权限。","reason.stop_source_not_accessible":"暂时无法读取平台配置。","reason.runtime_target_not_disabled":"运行目标尚未停用","reason.current_profile_conflict":"当前策略档案冲突","reason.profile_application_pending":"已有应用请求处理中","reason.synthetic_guard_blocked":"合成演示环境不提供该操作","reason.unknown":"原因未知","auth.login_title":"登录后继续使用","auth.login_body":"登录后可查看账户总览、收益分析、待办与运行状态。","auth.login":"登录","auth.denied_title":"没有访问权限","auth.denied_body":"当前账号未被允许访问此控制台。","auth.error_title":"暂时无法读取控制台","auth.error_body":"会话服务暂时不可用，请稍后重试。","shell.scope":"账户范围","shell.scope_error":"账户不可用","shell.scope_loading":"正在读取账户…","shell.scope_meta_error":"无法读取账户名称与模拟/实盘标记。","prefs.save_error":"无法保存偏好，刷新后可能失效。","shell.scope_all":"全部账户","shell.scope_paper_group":"模拟账户","shell.hide_amounts":"隐藏金额","shell.show_amounts":"显示金额","shell.user_menu":"用户菜单","shell.preferences":"偏好设置","shell.logout":"退出登录","shell.skip_to_content":"跳到主要内容","prefs.title":"偏好设置","prefs.theme":"主题","prefs.theme_light":"浅色","prefs.theme_dark":"深色","prefs.theme_system":"跟随系统","prefs.language":"语言","prefs.updown":"涨跌颜色","prefs.updown_green_up":"绿涨红跌","prefs.updown_red_up":"红涨绿跌","prefs.hide_amounts":"默认隐藏金额","prefs.default_range":"默认区间","prefs.note":"偏好仅保存在此浏览器中。","overview.total_assets":"总资产","overview.range_return":"区间收益 {range}","overview.last_day_change":"最近一日资产变动","overview.todos":"待办","overview.todos_urgent":"{count} 紧急","overview.runs_ok":"运行 {ok}/{total} 正常","overview.equity_trend":"收益走势","overview.todo_preview":"待办预览","overview.my_accounts":"我的账户","overview.account_strategy":"策略","overview.account_assets":"资产","overview.account_cash":"现金","overview.no_accounts":"暂无账户","overview.twr_tag":"时间加权收益","overview.open_performance":"打开收益分析","overview.open_health":"打开运行状态","overview.open_decisions":"打开待办","perf.value_kind_pnl":"盈亏","perf.value_kind_asset_change":"资产变动","perf.range.1M":"1月","perf.range.3M":"3月","perf.range.YTD":"年初至今","perf.range.1Y":"1年","perf.range.ALL":"全部","perf.range.label":"时间区间","perf.range.return_label":"{range} 收益","perf.card.twr":"累计收益（TWR）","perf.card.amount":"盈亏金额","perf.card.amount_asset_change":"资产变动","perf.card.max_drawdown":"最大回撤","perf.card.max_drawdown_dates":"{peak} → {trough}","perf.card.excess":"相对基准超额","perf.card.best_day":"最好的一天","perf.card.worst_day":"最差的一天","perf.returns_title":"收益率 vs 基准","perf.returns_cumulative":"累积","perf.returns_daily":"每日","perf.how_calculated":"如何计算？","perf.method_title":"收益如何计算","perf.method_body":"按时间加权（TWR）计算，已剔除出入金影响；区间起点归零。","perf.assets_title":"总资产","perf.assets_note":"仅展示当前账户范围的资产，不叠加基准。","perf.assets_flow_mark":"出入金","perf.calendar_title":"收益日历","perf.calendar_month":"月","perf.calendar_year":"年","perf.calendar_deposit_note":"出入金当日不计入盈亏","perf.holdings_title":"持仓","perf.holdings_note":"当前持仓 · 未实现盈亏","perf.ranking_title":"个股盈亏榜","perf.trades_title":"成交统计","perf.trades_not_connected":"成交统计未接入。","perf.mixed_currency_title":"多币种说明","perf.col.symbol":"标的","perf.col.quantity":"数量","perf.col.market_value":"市值","perf.col.currency":"币种","perf.col.avg_cost":"成本价","perf.col.unrealized_pnl":"未实现盈亏","perf.col.account":"账户","perf.col.date":"日期","perf.col.amount":"金额","perf.col.return":"收益率","decisions.title":"待办","decisions.filter.all":"全部","decisions.tab.pending":"待处理","decisions.tab.decided":"已处理","category.reconciliation_recovery":"对账恢复","category.strategy_promotion":"策略晋级","category.owner_decision":"负责人决定","category.credential_maintenance":"凭证维护","category.paper_account_application":"模拟账户应用","decisions.priority.high":"高","decisions.priority.medium":"中","decisions.priority.normal":"普通","decisions.status.pending":"待处理","decisions.status.decided":"已处理","decisions.status.expired":"已过期","decisions.question":"需要你决定","decisions.diff_title":"改前 → 改后","decisions.col.field":"字段","decisions.col.current":"当前","decisions.col.proposed":"建议","decisions.col.affects_live":"实盘影响","decisions.affects_live_yes":"是","decisions.affects_live_no":"否","decisions.materials":"材料","decisions.adopt_intent":"记录采用意向","decisions.decline_intent":"记录不采用意向","decisions.intent_note":"仅记录意向，不会下单。","decisions.confirm_adopt_title":"确认记录采用意向？","decisions.confirm_decline_title":"确认记录不采用意向？","decisions.confirm_body":"本次只记录意向，不会提交订单或改变交易权限。","decisions.history_title":"处理记录","decisions.history.empty":"暂无处理记录","decisions.action.adopt_intent":"记录采用意向","decisions.action.decline_intent":"记录不采用意向","decisions.empty_pending":"没有待处理的事项","decisions.account_global":"全部账户","decisions.ref":"编号 {id}","decisions.expires_at":"截止 {value}","decisions.created_at":"创建于 {value}","decisions.read_failed":"待办读取失败，请重试；这不代表没有待办。","decisions.application_status":"应用状态：{value}","accounts.title":"账户","accounts.col.alias":"别名","accounts.col.platform":"平台","accounts.col.strategy":"当前策略","accounts.col.run":"运行","accounts.col.drafts":"待生效草案","accounts.col.todos":"待办","accounts.col.last_change":"最近变更","accounts.tab.overview":"概览","accounts.tab.strategy":"策略与参数","risk.title":"风险偏好","risk.note":"用于记录投资偏好，不会改变交易设置。","risk.field":"偏好草案","risk.savedValue":"当前保存值","risk.unset":"未设置","risk.capital":"资本保全","risk.balanced":"稳健复利","risk.growth":"成长复利","risk.other":"未识别的值","risk.save":"保存风险偏好","risk.discard":"撤销","risk.saving":"正在保存风险偏好。","risk.gate":"当前账户不可编辑风险偏好。","risk.denied":"没有权限读取这项设置。","risk.readFailed":"风险偏好暂时读不到。","risk.readMismatch":"设置读回与所选账户不一致，请重新读取。","risk.reread":"重新读取","risk.stale":"显示上次成功读回值，当前状态未重新确认。","risk.saved":"偏好已保存，并已回读确认。","risk.mismatch":"回读与提交不一致，未确认已保存。","risk.unverified":"已提交，暂无法确认，请重新读取。","risk.conflict":"版本已变化，未覆盖已保存内容。","risk.review":"保存结果尚未确认，请重新读取。","risk.ack":"确认","accounts.tab.controls":"运行控制","accounts.tab.history":"变更记录","accounts.freshness":"数据新鲜度","accounts.run_state":"运行状态","accounts.edit":"编辑","accounts.check_changes":"检查变更","accounts.viewing":"查看态","accounts.editing":"编辑中","accounts.diff_dialog_title":"确认草案变更","accounts.col.draft":"草案","accounts.ack_live":"我已了解这些修改影响实盘","accounts.save_draft":"保存草案","accounts.draft_saved":"草案已保存。","accounts.draft_note":"保存草案不会下单、启用账户或改变交易权限；当前生效配置保持不变。","accounts.conflict":"版本冲突：草案已被其他人修改。请刷新确认最新差异后重试。","accounts.identity_conflict":"草案绑定的账户身份已变化，请先刷新确认。","accounts.no_changes":"没有修改","accounts.history.empty":"暂无变更记录","accounts.event.draft_saved":"草案保存","accounts.event.approved":"批准","accounts.event.unrecorded":"未记录","accounts.history.note":"变更记录有保留上限；批准或保存不代表已生效。","accounts.draft_revision":"草案版本 {value}","controls.title":"运行控制","controls.danger_note":"以下操作影响实盘运行，请确认后执行。","controls.enable":"启用","controls.stop":"停止","controls.resume":"恢复","controls.approve_application":"批准应用","controls.stop_summary":"停止只阻止新的触发，不会撤单、平仓或清除在途请求。","controls.resume_summary":"恢复既有运行目标，不修改策略或资金参数。","controls.approve_summary":"批准应用当前策略档案草案；提交后需确认实际生效状态，不会直接下单。","controls.enable_summary":"启用运行目标，使既有调度恢复触发。","controls.stop_confirm_title":"确认停止运行目标","controls.stop_type_alias":"输入账户别名 {alias} 以确认停止","controls.alias_mismatch":"输入的别名不一致","controls.submitted":"请求已提交；结果需读回确认，请勿重复提交。","controls.submit_failed":"提交未完成；请确认当前状态后再决定，避免重复提交。","controls.unknown_result":"上次提交结果未知，已锁定；请先刷新确认。","controls.unavailable":"不可用：{reason}","strategies.title":"策略","strategies.domain":"市场","strategies.modes":"新增启用／切换方式","strategies.accounts_using":"已配置账户","strategies.account_execution":"账户执行模式","strategies.execution.legacy_live":"实盘","strategies.execution.live":"实盘","strategies.execution.live_unknown":"实盘","strategies.execution.paper":"模拟","strategies.execution.dry_run":"演练","strategies.execution.unknown":"执行模式未知","strategies.live_exposure":"实盘策略使用真实资金；目录方式仅约束新增启用或切换。","strategies.execution_source":"模式来自账户配置；最近运行及成交状态未验证。","strategies.health":"健康度","strategies.health_score":"评分 {value}","strategies.last_promotion":"最近晋级","strategies.params_summary":"参数摘要","strategies.promotion_timeline":"晋级时间线","strategies.empty":"暂无策略","strategies.tab.catalog":"策略目录","strategies.tab.research":"研究线索","strategies.research_only":"仅研究，不下单","strategies.research_not_connected":"研究线索未接入。","health.title":"运行状态","health.stat.today_runs":"今日运行 {ok}/{total}","health.stat.observed":"已观测 {observed}/{configured}","health.stat.credentials":"凭证 {count} 项需关注","health.stat.recent_failure":"最近失败 {count}","health.grid_title":"近 14 个纽约业务日","health.grid.ok":"成功","health.grid.failed":"失败","health.grid.not_run":"未运行","health.grid.no_record":"无记录","health.day_detail":"当日记录","health.freshness_title":"数据新鲜度","health.credentials_title":"凭证到期","health.credential_ibkr_report":"IBKR 报表凭证","health.credential_other":"账户凭证","health.table_scroll_hint":"左右滑动查看完整表格","health.grid_scroll_hint":"左右滑动查看全部日期，账户列保持可见","health.credential_expires":"到期 {value}","health.credential_phase.expired":"已过期","health.credential_phase.30":"30 天内到期","health.credential_phase.7":"7 天内到期","health.credential_phase.1":"1 天内到期","health.credential_phase.not_due":"正常","health.credential_phase.unknown":"未知","health.activity":"活动","health.run_count":"运行次数","health.col.account":"账户","health.col.source":"来源","health.col.status":"状态","health.col.as_of":"数据时间","error.generic":"请求未完成；请刷新并确认当前状态。","error.session_expired":"会话已失效，请重新登录。","error.access_denied":"访问被拒绝。","error.conflict":"版本冲突；当前编辑已保留，请刷新确认。"},Wm={"shell.switch_light":"Switch to light mode","shell.switch_dark":"Switch to dark mode","shell.update_available":"A new version is ready. Refresh to use it.","shell.reload":"Refresh page","app.name":"QuantStrategyLab","shell.cockpit":"Decision Cockpit","nav.main":"Main navigation","nav.overview":"Overview","nav.performance":"Performance","nav.decisions":"Decisions","nav.accounts":"Accounts","nav.strategies":"Strategies","nav.health":"Health","nav.more":"More","nav.todo_unavailable":"To-do count unavailable","common.loading":"Loading…","common.retry":"Retry","common.close":"Close","common.cancel":"Cancel","common.confirm":"Confirm","common.save":"Save","common.edit":"Edit","common.back":"Back","common.all":"All","common.none":"None","common.unknown":"Unknown","common.na":"—","common.as_of":"Data as of {value}","common.updated_at":"Page refreshed {value}","common.refresh":"Refresh","common.refreshing":"Refreshing…","common.copy":"Copy","common.copied":"Copied","common.view_all":"View all","common.load_more":"Load more","common.table_scroll_hint":"Scroll sideways for all fields","common.expand":"Expand","common.collapse":"Collapse","common.account":"Account","common.ibkr_account":"IBKR account","common.platform":"Platform","common.strategy":"Strategy","common.time":"Time","common.status":"Status","common.details":"Details","common.synthetic_badge":"Synthetic demo","common.paper_badge":"Paper","common.page_load_failed":"This page could not be loaded","common.read_failed_banner":"Some data failed to load. A failed read does not mean there is nothing to show; please retry.","common.unsaved_guard_title":"Discard unsaved changes?","common.unsaved_guard_body":"You have unsaved changes that will be lost if you leave.","state.unknown_status":"Unknown status","state.review":"Needs review","state.watch":"Watch","state.critical":"Critical","state.blocked":"Blocked","state.failed":"Failed","state.read_incomplete":"Read incomplete","state.insufficient":"Insufficient data","state.previewed":"Previewed","state.no_submission":"No order submitted","state.no_rebalance":"No rebalance","state.filled":"Filled","state.not_due":"Not due yet","state.market_closed":"Market closed","state.outside_window":"Outside run window","state.within_grace":"Within grace period","state.missing_report":"Report missing","state.error":"Run error","state.healthy":"Healthy","state.no_signal":"No signal","state.ok":"OK","state.partial":"Partial","state.partial_valuation":"Valuation incomplete","state.partial_runtime":"Runtime not connected","state.stale":"Stale","state.no_data":"No data","state.not_connected":"Not connected","state.unavailable":"Unavailable","state.read_failed":"Read failed","state.load_failed":"Unable to load","reason.external_cashflow_required":"Complete cash-flow records are missing; TWR is unavailable and amounts are shown as asset change.","reason.fills_not_connected":"The fill source is not connected","reason.execution_coverage_unverified":"Execution coverage is unverified","reason.avg_cost_missing":"Average cost is missing, so unrealized P/L cannot be calculated","reason.mixed_currency":"Mixed currencies cannot be combined into one amount; each currency is shown separately","reason.snapshot_history_missing":"Historical asset snapshots are missing","reason.snapshot_missing":"Asset snapshot is missing","reason.snapshot_pending":"Today's data is pending update","reason.previous_snapshot_missing":"The previous day's asset snapshot is missing","reason.non_trading_weekend":"Non-trading day","reason.incomplete_month":"The month is still incomplete","reason.insufficient_observations":"Not enough history","reason.invalid_return_period":"Invalid range endpoints","reason.positions_partial_coverage":"Positions cover only part of the assets","reason.positions_not_connected":"The position source is not connected","reason.positions_stale":"Position data is stale","reason.benchmark_history_unreadable":"Benchmark data failed to load","reason.position_value_missing":"Position market value is missing","reason.no_common_date":"No common date to align with the benchmark","reason.benchmark_history_missing":"Benchmark history is missing","reason.stored_records_unreadable":"Stored records could not be read","reason.effect_verification_not_recorded":"No record is available to confirm whether the change took effect.","reason.bounded_audit_log":"History retention is bounded and may be incomplete","reason.no_closed_trades":"No closed trades","reason.notification_log_not_connected":"The notification log source is not connected","reason.runtime_daily_not_connected":"The run-record source is not connected","reason.runtime_daily_binding_conflict":"Multiple run-record bindings match this account; check configuration","reason.today_record_missing":"No run record for today","reason.runtime_daily_stale":"The run record is stale","reason.runtime_daily_incomplete":"The run record is incomplete","reason.strategy_health_not_connected":"The strategy health source is not connected","reason.available":"Available","reason.admin_required":"Admin permission required","reason.dispatch_unavailable":"Dispatch is unavailable","reason.stop_pending_or_identity_unavailable":"A stop request is pending or identity is unavailable","reason.strategy_application_not_connected":"The strategy application channel is not connected","reason.existing_recovery_not_available":"No existing recovery flow is available","reason.runtime_instances_not_bound":"Runtime instances are not bound","reason.account_settings_identity_conflict":"The draft is bound to an older identity; reconcile first","reason.profile_draft_required":"Save a strategy draft for this account first.","reason.profile_only_required":"Only strategy-profile drafts are supported","reason.profile_not_selectable":"This strategy profile cannot be selected","reason.runtime_readback_unavailable":"Runtime readback is unavailable","reason.runtime_control_pending":"The previous action is awaiting confirmation","reason.runtime_control_result_unavailable":"The result is unconfirmed. Refresh to check.","reason.platform_result_unavailable":"The platform result is unconfirmed. Refresh to check.","reason.platform_dispatch_unverified":"The platform request is unconfirmed.","reason.platform_dispatch_rejected":"The platform rejected the request; the setting may have been saved.","reason.readback_dispatch_rejected":"The platform result cannot be checked right now.","reason.runtime_control_workflow_permission_denied":"Permission to read the platform workflow is unavailable.","reason.runtime_control_workflow_unavailable":"The platform workflow is unavailable.","reason.runtime_control_target_unsupported":"The account binding does not match the platform configuration.","reason.stop_source_permission_denied":"Permission to read platform settings is unavailable.","reason.stop_source_not_accessible":"Platform settings cannot be read right now.","reason.runtime_target_not_disabled":"The runtime target is not disabled yet","reason.current_profile_conflict":"The current strategy profile conflicts","reason.profile_application_pending":"An application request is already pending","reason.synthetic_guard_blocked":"This action is not offered in the synthetic demo","reason.unknown":"Unknown reason","auth.login_title":"Sign in to continue","auth.login_body":"Sign in to view overview, performance, to-dos and run status.","auth.login":"Sign in","auth.denied_title":"No access","auth.denied_body":"This account is not allowed to use the console.","auth.error_title":"Console unavailable","auth.error_body":"The session service is temporarily unavailable. Please retry later.","shell.scope":"Account scope","shell.scope_error":"Accounts unavailable","shell.scope_loading":"Loading accounts…","shell.scope_meta_error":"Account names and paper/live labels are unavailable.","prefs.save_error":"Preferences could not be saved and may be lost after refresh.","shell.scope_all":"All accounts","shell.scope_paper_group":"Paper accounts","shell.hide_amounts":"Hide amounts","shell.show_amounts":"Show amounts","shell.user_menu":"User menu","shell.preferences":"Preferences","shell.logout":"Sign out","shell.skip_to_content":"Skip to content","prefs.title":"Preferences","prefs.theme":"Theme","prefs.theme_light":"Light","prefs.theme_dark":"Dark","prefs.theme_system":"System","prefs.language":"Language","prefs.updown":"Up/down colors","prefs.updown_green_up":"Green up / red down","prefs.updown_red_up":"Red up / green down","prefs.hide_amounts":"Hide amounts by default","prefs.default_range":"Default range","prefs.note":"Preferences are stored only in this browser.","overview.total_assets":"Total assets","overview.range_return":"Range return {range}","overview.last_day_change":"Latest daily asset change","overview.todos":"To-dos","overview.todos_urgent":"{count} urgent","overview.runs_ok":"Runs {ok}/{total} OK","overview.equity_trend":"Return trend","overview.todo_preview":"To-do preview","overview.my_accounts":"My accounts","overview.account_strategy":"Strategy","overview.account_assets":"Assets","overview.account_cash":"Cash","overview.no_accounts":"No accounts yet","overview.twr_tag":"Time-weighted return","overview.open_performance":"Open performance","overview.open_health":"Open run status","overview.open_decisions":"Open to-dos","perf.value_kind_pnl":"P/L","perf.value_kind_asset_change":"Asset change","perf.range.1M":"1M","perf.range.3M":"3M","perf.range.YTD":"YTD","perf.range.1Y":"1Y","perf.range.ALL":"All","perf.range.label":"Time range","perf.range.return_label":"{range} return","perf.card.twr":"Cumulative return (TWR)","perf.card.amount":"P/L amount","perf.card.amount_asset_change":"Asset change","perf.card.max_drawdown":"Max drawdown","perf.card.max_drawdown_dates":"{peak} → {trough}","perf.card.excess":"Excess vs benchmark","perf.card.best_day":"Best day","perf.card.worst_day":"Worst day","perf.returns_title":"Returns vs benchmarks","perf.returns_cumulative":"Cumulative","perf.returns_daily":"Daily","perf.how_calculated":"How is this calculated?","perf.method_title":"How returns are calculated","perf.method_body":"Time-weighted (TWR); cash flows are excluded and each range starts at zero.","perf.assets_title":"Total assets","perf.assets_note":"Shows assets of the selected scope only; no benchmarks.","perf.assets_flow_mark":"Cash flow","perf.calendar_title":"Return calendar","perf.calendar_month":"Month","perf.calendar_year":"Year","perf.calendar_deposit_note":"Cash-flow days do not count as P/L","perf.holdings_title":"Holdings","perf.holdings_note":"Current holdings · unrealized","perf.ranking_title":"Symbol P/L ranking","perf.trades_title":"Trade statistics","perf.trades_not_connected":"Trade statistics are not connected.","perf.mixed_currency_title":"Mixed currencies","perf.col.symbol":"Symbol","perf.col.quantity":"Quantity","perf.col.market_value":"Market value","perf.col.currency":"Currency","perf.col.avg_cost":"Avg cost","perf.col.unrealized_pnl":"Unrealized P/L","perf.col.account":"Account","perf.col.date":"Date","perf.col.amount":"Amount","perf.col.return":"Return","decisions.title":"To-dos","decisions.filter.all":"All","decisions.tab.pending":"Pending","decisions.tab.decided":"Decided","category.reconciliation_recovery":"Reconciliation recovery","category.strategy_promotion":"Strategy promotion","category.owner_decision":"Owner decision","category.credential_maintenance":"Credential maintenance","category.paper_account_application":"Paper account application","decisions.priority.high":"High","decisions.priority.medium":"Medium","decisions.priority.normal":"Normal","decisions.status.pending":"Pending","decisions.status.decided":"Decided","decisions.status.expired":"Expired","decisions.question":"Your decision","decisions.diff_title":"Before → after","decisions.col.field":"Field","decisions.col.current":"Current","decisions.col.proposed":"Proposed","decisions.col.affects_live":"Live impact","decisions.affects_live_yes":"Yes","decisions.affects_live_no":"No","decisions.materials":"Materials","decisions.adopt_intent":"Record adopt intent","decisions.decline_intent":"Record decline intent","decisions.intent_note":"Records intent only; no orders are placed.","decisions.confirm_adopt_title":"Record adopt intent?","decisions.confirm_decline_title":"Record decline intent?","decisions.confirm_body":"Only your intent is recorded. No order is submitted and no trading permission changes.","decisions.history_title":"History","decisions.history.empty":"No history yet","decisions.action.adopt_intent":"Adopt intent","decisions.action.decline_intent":"Decline intent","decisions.empty_pending":"Nothing pending","decisions.account_global":"All accounts","decisions.ref":"Ref {id}","decisions.expires_at":"Due {value}","decisions.created_at":"Created {value}","decisions.read_failed":"To-dos failed to load. This does not mean there is nothing pending; please retry.","decisions.application_status":"Application status: {value}","accounts.title":"Accounts","accounts.col.alias":"Alias","accounts.col.platform":"Platform","accounts.col.strategy":"Strategy","accounts.col.run":"Run","accounts.col.drafts":"Pending drafts","accounts.col.todos":"To-dos","accounts.col.last_change":"Last change","accounts.tab.overview":"Overview","accounts.tab.strategy":"Strategy & parameters","risk.title":"Risk preference","risk.note":"Records your investment preference without changing trading settings.","risk.field":"Preference draft","risk.savedValue":"Saved value","risk.unset":"Not set","risk.capital":"Capital preservation","risk.balanced":"Balanced compounding","risk.growth":"Growth compounding","risk.other":"Unrecognized value","risk.save":"Save risk preference","risk.discard":"Discard","risk.saving":"Saving risk preference.","risk.gate":"Risk preference is not editable for this account.","risk.denied":"You do not have permission to read this setting.","risk.readFailed":"Risk preference is unavailable right now.","risk.readMismatch":"The read did not match the selected account. Re-read.","risk.reread":"Re-read","risk.stale":"Showing the last successful read; current state is unconfirmed.","risk.saved":"Preference saved and confirmed by re-read.","risk.mismatch":"The re-read does not match the submission; not confirmed as saved.","risk.unverified":"Submitted, but the re-read could not confirm it. Re-read to check.","risk.conflict":"The revision changed; nothing was overwritten.","risk.review":"The save result or account source is unconfirmed. Re-read to check.","risk.ack":"I have checked","accounts.tab.controls":"Run controls","accounts.tab.history":"Change history","accounts.freshness":"Data freshness","accounts.run_state":"Run state","accounts.edit":"Edit","accounts.check_changes":"Review changes","accounts.viewing":"Viewing","accounts.editing":"Editing","accounts.diff_dialog_title":"Confirm draft changes","accounts.col.draft":"Draft","accounts.ack_live":"I understand these changes affect live trading","accounts.save_draft":"Save draft","accounts.draft_saved":"Draft saved.","accounts.draft_note":"Saving a draft places no orders, enables no account, and changes no trading permissions. The effective settings stay unchanged.","accounts.conflict":"Revision conflict: the draft was changed elsewhere. Refresh and review the latest diff before retrying.","accounts.identity_conflict":"The account identity behind the draft has changed. Refresh and reconcile first.","accounts.no_changes":"No changes","accounts.history.empty":"No changes recorded","accounts.event.draft_saved":"Draft saved","accounts.event.approved":"Approved","accounts.event.unrecorded":"Not recorded","accounts.history.note":"History retention is bounded; a save or approval does not prove the change took effect.","accounts.draft_revision":"Draft revision {value}","controls.title":"Run controls","controls.danger_note":"These actions affect live runs. Review before executing.","controls.enable":"Enable","controls.stop":"Stop","controls.resume":"Resume","controls.approve_application":"Approve application","controls.stop_summary":"Stopping only blocks new triggers. It does not cancel orders, close positions, or clear in-flight requests.","controls.resume_summary":"Resume the existing runtime target. No strategy or funding parameters change.","controls.approve_summary":"Approve applying the current strategy-profile draft. Verify the effective state after submission; this does not directly place orders.","controls.enable_summary":"Enable the runtime target so the existing schedule resumes triggering.","controls.stop_confirm_title":"Confirm stopping the runtime target","controls.stop_type_alias":"Type the account alias {alias} to confirm the stop","controls.alias_mismatch":"The alias does not match","controls.submitted":"Request submitted; the result needs read-back. Do not resubmit.","controls.submit_failed":"Submission did not complete. Verify the current state before deciding; avoid resubmitting blindly.","controls.unknown_result":"The previous submission's result is unknown and locked. Refresh and verify first.","controls.unavailable":"Unavailable: {reason}","strategies.title":"Strategies","strategies.domain":"Market","strategies.modes":"New activation / switch modes","strategies.accounts_using":"Configured accounts","strategies.account_execution":"Account execution mode","strategies.execution.legacy_live":"Live","strategies.execution.live":"Live","strategies.execution.live_unknown":"Live","strategies.execution.paper":"Paper","strategies.execution.dry_run":"Dry run","strategies.execution.unknown":"Execution mode unknown","strategies.live_exposure":"Live strategies use real money; catalog modes only constrain new activations or switches.","strategies.execution_source":"Modes come from account configuration; recent runs and fills are unverified.","strategies.health":"Health","strategies.health_score":"Score {value}","strategies.last_promotion":"Last promotion","strategies.params_summary":"Parameter summary","strategies.promotion_timeline":"Promotion timeline","strategies.empty":"No strategies yet","strategies.tab.catalog":"Catalog","strategies.tab.research":"Research leads","strategies.research_only":"Research only; no orders","strategies.research_not_connected":"Research leads are not connected.","health.title":"Run status","health.stat.today_runs":"Today {ok}/{total}","health.stat.observed":"Observed {observed}/{configured}","health.stat.credentials":"{count} credential(s) need attention","health.stat.recent_failure":"Recent failures {count}","health.grid_title":"Last 14 New York business days","health.grid.ok":"Succeeded","health.grid.failed":"Failed","health.grid.not_run":"Not run","health.grid.no_record":"No record","health.day_detail":"Day detail","health.freshness_title":"Data freshness","health.credentials_title":"Credential expiry","health.credential_ibkr_report":"IBKR report credential","health.credential_other":"Account credential","health.table_scroll_hint":"Scroll horizontally to see the full table","health.grid_scroll_hint":"Scroll for all dates; accounts stay visible","health.credential_expires":"Expires {value}","health.credential_phase.expired":"Expired","health.credential_phase.30":"Expires within 30 days","health.credential_phase.7":"Expires within 7 days","health.credential_phase.1":"Expires within 1 day","health.credential_phase.not_due":"Normal","health.credential_phase.unknown":"Unknown","health.activity":"Activity","health.run_count":"Run count","health.col.account":"Account","health.col.source":"Source","health.col.status":"Status","health.col.as_of":"As of","error.generic":"The request did not complete. Refresh and verify the current state.","error.session_expired":"Session expired. Please sign in again.","error.access_denied":"Access denied.","error.conflict":"Revision conflict. Your edits are kept; refresh and verify."},Fm={"overview.asset_summary":"资产摘要","overview.runtime_target":"运行目标","overview.runtime_enabled":"已启用","overview.runtime_disabled":"已停用","overview.runtime_config_note":"自动运行显示的是配置状态，不代表今日运行结果。","overview.mixed_currency_short":"多币种","overview.runs_card_title":"今日有记录账户","overview.business_date":"纽约业务日 {value}","overview.calendar_date":"纽约日期 {value}","overview.no_records_for_day":"当前未观测到该业务日记录","overview.non_trading_day_short":"非交易日","overview.decision_queue":"决定队列","overview.needs_review":"待你查看的决定：{count} 个","overview.queue_complete_empty":"没有需要处理的待办决定。","overview.queue_incomplete":"决定来源未完整读取，因此不显示计数。","overview.queue_read_failed":"决定队列读取失败。","overview.queue_blocked":"受阻：{count} 个","overview.queue_high_priority":"高优先级：{count} 个","overview.queue_more":"查看全部决定","overview.expires_plain":"有效期至 {value}","overview.latest_activity":"最近确认的活动"},Pm={"overview.asset_summary":"Asset summary","overview.runtime_target":"Runtime target","overview.runtime_enabled":"Enabled","overview.runtime_disabled":"Stopped","overview.runtime_config_note":"Automatic runs show configuration, not today's run result.","overview.mixed_currency_short":"Multiple currencies","overview.runs_card_title":"Accounts with records today","overview.business_date":"New York business day {value}","overview.calendar_date":"New York date {value}","overview.no_records_for_day":"No records observed for this business day","overview.non_trading_day_short":"Non-trading day","overview.decision_queue":"Decision queue","overview.needs_review":"Decisions awaiting your review: {count}","overview.queue_complete_empty":"No decisions need action.","overview.queue_incomplete":"Decision coverage is incomplete, so counts are hidden.","overview.queue_read_failed":"The decision queue could not be read.","overview.queue_blocked":"Blocked: {count}","overview.queue_high_priority":"High priority: {count}","overview.queue_more":"View all decisions","overview.expires_plain":"Expires {value}","overview.latest_activity":"Latest verified activity"},Im={"perf.latest_balance_scope_note":"可能包含环境待确认账户，合计可能不完整。","perf.latest_balance_total":"{currency} 最近已知余额合计","perf.latest_balance_subtotal":"{currency} 最近已知余额小计","perf.balance_oldest_time":"最早数据 {value}","perf.balance_latest_time":"最晚数据 {value}","perf.balance_source_time":"余额数据 {value}","perf.average_cost_field":"平均成本","perf.col.cost_basis":"成本价","perf.broker_cost_label":"券商成本（按券商设置）","reason.currency_mismatch":"账户币种与当前币种不符，未计入合计。","perf.coverage_details":"查看计入与排除的账户","perf.account_included":"已计入","perf.account_excluded":"未计入","perf.valuation_date":"估值日期 {date}","perf.holdings_missing_fields":"“—”表示来源未提供该字段；数量已知不代表市值、成本价或盈亏齐全。","perf.holdings_scroll_hint":"左右滑动查看持仓全部字段。","perf.ranking_no_movement":"可排名持仓暂无盈亏变化","perf.ranking_unavailable":"暂无可排名的持仓","perf.ranking_missing_fields":"缺少可用于排行的持仓收益数据，可在持仓页查看。","perf.ranking_missing_currency":"未提供币种的持仓不参与排行，无法确认可比币种。","perf.fields_not_provided":"未提供：{fields}","perf.native_return_accounts":"以下账户已有原生收益：{accounts}。可从顶部切换单个账户查看；这些结果不代表全部账户的组合收益。","perf.per_account_daily_title":"各账户日收益率","perf.per_account_daily_note":"各账户分别展示，缺失日期留空。","perf.combined_metrics_unavailable":"组合指标暂不可计算，以下展示各账户日收益。","perf.mixed_currency_unavailable":"当前范围含多种币种，未进行汇率转换，组合指标不可计算；下方按账户和币种展示原生收益。","perf.mixed_currency_native":"当前范围含多种币种，组合指标不可计算；下方按账户和币种展示原生收益。","perf.mixed_currency_asset_change":"当前范围含多种币种，组合收益不可计算；下方按币种展示资产变化（含出入金影响），不代表时间加权收益。","reason.invalid_valuation_date":"估值日期无效，未计入合计。","reason.invalid_balance":"资产金额未确认，未计入合计。","reason.duplicate_currency":"同币种有重复余额，未计入合计。","reason.identity_mismatch":"账户身份不匹配，未计入合计。","reason.identity_not_bound":"账户身份尚未绑定，未计入合计。","reason.aggregation_duplicate":"与另一账户重复，未重复计入。","reason.aggregation_conflict":"账户归属存在冲突，未计入合计。","reason.account_facts_disabled":"该账户的数据读取未启用。","perf.history_incomplete":"部分历史数据未返回","perf.history_stale":"历史数据可能不是最新","perf.history_coverage_note":"部分账户缺少历史数据，曲线仅包含有数据的账户。","perf.history_affected_accounts":"{count} 个账户的历史数据不完整","perf.history_carried_balances":"部分日期包含沿用的此前余额，这些余额并非当日观测。","perf.currency_excluded_accounts":"另有 {count} 个账户的币种或金额未确认。","perf.drawdown_twr_title":"TWR 最大回撤","perf.native_totals_note":"按币种分别展示，不换汇。","perf.currency_subtotal":"{currency} 资产小计","perf.currency_total":"{currency} 资产合计","perf.partial_accounts":"未含全部账户","perf.currency_accounts":"合计含 {count} 个账户","perf.freshness_counts":"{stale} 个账户的数据可能不是最新","perf.freshness_threshold":"按各账户时间分别判断，超过 {hours} 小时视为可能不是最新。","perf.data_may_be_stale":"部分账户数据待更新","perf.as_of_not_refresh":"“截至”显示账户数据时间，不是页面刷新时间。","perf.data_notes":"数据说明","perf.history_details":"查看账户","perf.calendar_asset_balance":"资产余额","reason.no_cashflow_data":"缺少完整出入金记录，无法计算 TWR 及其回撤。","reason.insufficient_history":"至少需要两条有效估值记录。","reason.no_snapshot":"暂无可用估值。","reason.snapshot_stale":"该账户快照已超过时效阈值。","reason.valuation_date_mismatch":"部分账户估值日期不同，未计入合计。","reason.incomplete_account_coverage":"部分账户未纳入合计。","perf.benchmark_sp500":"标普500","perf.benchmark_nasdaq100":"纳斯达克100","perf.benchmark_dow":"道琼斯工业平均指数","perf.benchmark_russell2000":"罗素2000","perf.benchmark_unknown":"基准","performance.current_holdings_unrealized":"当前持仓 · 未实现盈亏","perf.return_kind_twr":"时间加权收益率（TWR）","perf.native_daily_title":"日收益率","perf.native_daily_tag":"每日","perf.native_daily_note":"部分日期缺失，暂无法计算区间累计收益。","perf.method_body_native_daily":"每日收益来自券商，缺失日期留空。","perf.method_dietz_approx":"Modified Dietz（近似）","perf.method_unknown":"收益计算方式未知","perf.card.return_value":"累计收益","perf.drawdown_plain_title":"最大回撤","perf.method_body_unknown":"收益计算方式尚未确认。数值按原结果展示，未确认为时间加权收益率（TWR）；未知收益不按 0 处理。","perf.method_body_dietz":"有出入金记录但无法逐日精确加权时，采用 Modified Dietz 近似法并标注「近似」。区间起点归零，出入金不计入收益；记录不完整时仅展示资产余额，不展示 TWR。","perf.method_body_asset_change":"缺少完整出入金记录，暂无法计算 TWR。图中仅展示资产变化（%），包含出入金影响，不代表时间加权收益，也不与基准比较。","perf.returns_title_plain":"收益率","perf.asset_balance_title":"资产余额","perf.missing_cashflow_records":"缺少入出金记录，暂无法计算收益","perf.asset_change_title":"资产变化","perf.asset_change_tag":"资产变化 · 含出入金影响","perf.asset_change_calendar_tag":"含出入金影响","perf.asset_change_note":"暂时无法计算收益，以下展示资产变化（%）。该变化包含出入金影响，不代表时间加权收益，也不与基准比较。","perf.calendar_fallback_note":"部分账户缺少当日快照，本月历按可用账户的资产变化展示（含出入金影响），不代表收益。","perf.portfolio_series":"组合","perf.currency_switch":"币种","perf.crypto_benchmark_note":"加密账户按 7×24 交易，暂不与美股指数比较；BTC 基准数据尚未接入。","perf.mixed_benchmark_note":"当前范围同时包含加密与美股账户，暂不与单一市场指数比较；可切换到单个账户查看。","perf.currency_benchmark_note":"该币种账户暂不与美股指数比较。","perf.no_common_date_note":"账户与基准没有共同日期，暂不叠加基准。","perf.benchmark_not_applicable":"该范围暂不设置基准","perf.holdings_coverage_accounts":"覆盖账户：{value}","perf.ranking_note":"按未实现盈亏金额排序；盈亏比例以平均成本为基准，缺少平均成本的持仓不参与排行。","perf.ranking_winners":"盈利靠前","perf.ranking_losers":"亏损靠前","perf.benchmarks_unavailable":"基准暂不可用（{count}）","perf.col.side":"方向","perf.col.price":"价格","perf.col.commission":"佣金","perf.col.taxes":"税费","perf.side.buy":"买入","perf.side.sell":"卖出","perf.executions_count":"已观测 {count} 条成交","perf.executions_partial_short":"部分记录","perf.executions_partial":"仅列出已观测成交；覆盖范围未核实，不代表完整历史。","perf.executions_empty_partial":"部分记录，当前范围内暂无可展示成交。"},e_={"perf.latest_balance_scope_note":"May include accounts with unconfirmed environments; the total may be incomplete.","perf.latest_balance_total":"{currency} latest known balance total","perf.latest_balance_subtotal":"{currency} latest known balance subtotal","perf.balance_oldest_time":"Earliest data {value}","perf.balance_latest_time":"Latest data {value}","perf.balance_source_time":"Balance data {value}","perf.average_cost_field":"Avg cost","perf.col.cost_basis":"Cost basis","perf.broker_cost_label":"Broker cost (broker settings)","reason.currency_mismatch":"The account currency differs from this total; excluded.","perf.coverage_details":"View included and excluded accounts","perf.account_included":"Included","perf.account_excluded":"Excluded","perf.valuation_date":"Valuation date {date}","perf.holdings_missing_fields":"“—” means the source did not provide that field. A known quantity does not establish market value, cost basis or P/L.","perf.holdings_scroll_hint":"Scroll horizontally to view all holding fields.","perf.ranking_no_movement":"Eligible holdings have no P/L movement","perf.ranking_unavailable":"No holdings are eligible for ranking","perf.ranking_missing_fields":"Eligible holding return data is unavailable; check the Holdings tab.","perf.ranking_missing_currency":"Holdings without a currency are not ranked because no comparable currency can be confirmed.","perf.fields_not_provided":"Not provided: {fields}","perf.native_return_accounts":"Native returns are available for: {accounts}. Select one account at the top to view them; these are not returns for the full portfolio.","perf.per_account_daily_title":"Daily returns by account","perf.per_account_daily_note":"Accounts are shown separately; missing dates are left blank.","perf.combined_metrics_unavailable":"Combined metrics are unavailable; daily returns are shown by account below.","perf.mixed_currency_unavailable":"This scope contains multiple currencies. No FX conversion was applied, so combined metrics are unavailable. Native returns are shown by account and currency below.","perf.mixed_currency_native":"This scope contains multiple currencies, so combined metrics are unavailable. Native returns are shown by account and currency below.","perf.mixed_currency_asset_change":"This scope contains multiple currencies, so a combined return is unavailable. Asset change (including cash-flow effects) is shown by currency; it is not a time-weighted return.","reason.invalid_valuation_date":"The valuation date is invalid; excluded from the total.","reason.invalid_balance":"The balance is unconfirmed; excluded from the total.","reason.duplicate_currency":"Duplicate balances for this currency; excluded from the total.","reason.identity_mismatch":"The account identity does not match; excluded from the total.","reason.identity_not_bound":"The account identity is not bound; excluded from the total.","reason.aggregation_duplicate":"Duplicates another account; not counted twice.","reason.aggregation_conflict":"Account ownership is conflicting; excluded from the total.","reason.account_facts_disabled":"Data reads are disabled for this account.","perf.history_incomplete":"Some history is unavailable","perf.history_stale":"History may not be up to date","perf.history_coverage_note":"Some accounts lack history; the curve includes only accounts with data.","perf.history_affected_accounts":"History is incomplete for {count} accounts","perf.history_carried_balances":"Some dates include earlier balances; those balances were not observed on those dates.","perf.currency_excluded_accounts":"Currency or balance is unconfirmed for {count} additional accounts.","perf.drawdown_twr_title":"Maximum TWR drawdown","perf.native_totals_note":"Shown by currency without FX conversion.","perf.currency_subtotal":"{currency} asset subtotal","perf.currency_total":"{currency} asset total","perf.partial_accounts":"Not all accounts","perf.currency_accounts":"Total includes {count} accounts","perf.freshness_counts":"Data may be out of date for {stale} accounts","perf.freshness_threshold":"Each account is checked separately; data older than {hours} hours is marked as possibly out of date.","perf.data_may_be_stale":"Some account data may be out of date","perf.as_of_not_refresh":"“As of” shows the account data time, not the page refresh time.","perf.data_notes":"Data notes","perf.history_details":"View accounts","perf.calendar_asset_balance":"Asset balance","reason.no_cashflow_data":"Complete cash-flow records are missing; TWR and its drawdown cannot be calculated.","reason.insufficient_history":"At least two valid valuation records are required.","reason.no_snapshot":"No valuation is available.","reason.snapshot_stale":"This account snapshot exceeds the freshness threshold.","reason.valuation_date_mismatch":"Some accounts have different valuation dates and are excluded from the total.","reason.incomplete_account_coverage":"Some accounts are not included in the total.","perf.benchmark_sp500":"S&P 500","perf.benchmark_nasdaq100":"Nasdaq-100","perf.benchmark_dow":"Dow Jones Industrial Average","perf.benchmark_russell2000":"Russell 2000","perf.benchmark_unknown":"Benchmark","performance.current_holdings_unrealized":"Current holdings · unrealized P/L","perf.return_kind_twr":"Time-weighted return (TWR)","perf.native_daily_title":"Daily returns","perf.native_daily_tag":"Daily","perf.native_daily_note":"Some dates are missing, so the period return is unavailable.","perf.method_body_native_daily":"Daily returns are reported by the broker; missing dates are left blank.","perf.method_dietz_approx":"Modified Dietz (approximate)","perf.method_unknown":"Return method unknown","perf.card.return_value":"Cumulative return","perf.drawdown_plain_title":"Maximum drawdown","perf.method_body_unknown":"The return method is unconfirmed. Values are shown as provided, but are not confirmed as time-weighted returns (TWR); unknown returns are not treated as zero.","perf.method_body_dietz":"When cash flows exist but exact daily weighting is unavailable, Modified Dietz is used and labeled as approximate. Each range starts at zero, and cash flows are excluded from returns. If records are incomplete, only asset balance is shown instead of TWR.","perf.method_body_asset_change":"Complete cash-flow records are missing, so TWR is unavailable. The chart shows asset change (%), including the effect of cash flows; it is not a time-weighted return and is not compared with benchmarks.","perf.returns_title_plain":"Returns","perf.asset_balance_title":"Asset balance","perf.missing_cashflow_records":"Cash-flow records are missing; returns cannot be calculated yet.","perf.asset_change_title":"Asset change","perf.asset_change_tag":"Asset change · includes cash flows","perf.asset_change_calendar_tag":"Includes cash flows","perf.asset_change_note":"Returns are unavailable; the chart shows asset change (%), including the effect of cash flows. It is not a time-weighted return and is not compared with benchmarks.","perf.calendar_fallback_note":"Some accounts are missing snapshots on these dates. This calendar shows asset change from the available accounts, including cash-flow effects; it is not a return.","perf.portfolio_series":"Portfolio","perf.currency_switch":"Currency","perf.crypto_benchmark_note":"Crypto accounts trade 24/7 and are not compared with US equity indices; BTC benchmark data is not available yet.","perf.mixed_benchmark_note":"This scope mixes crypto and US equity accounts, so no single market index applies. Open one account to compare benchmarks.","perf.currency_benchmark_note":"Accounts in this currency are not compared with US equity indices.","perf.no_common_date_note":"The account and benchmarks share no common date, so benchmarks are not overlaid.","perf.benchmark_not_applicable":"No benchmark for this scope","perf.holdings_coverage_accounts":"Covered accounts: {value}","perf.ranking_note":"Ranked by unrealized P/L amount; percentages use average cost. Holdings without an average cost are not ranked.","perf.ranking_winners":"Top gainers","perf.ranking_losers":"Top losers","perf.benchmarks_unavailable":"{count} benchmark(s) unavailable","perf.col.side":"Side","perf.col.price":"Price","perf.col.commission":"Commission","perf.col.taxes":"Taxes","perf.side.buy":"Buy","perf.side.sell":"Sell","perf.executions_count":"{count} observed executions","perf.executions_partial_short":"Partial records","perf.executions_partial":"Only observed executions are listed; coverage is unverified and this is not a complete history.","perf.executions_empty_partial":"Partial records; no executions to show in this range."},t_={"reconciliation.title":"历史对账信息","reconciliation.current":"当前对账状态","reconciliation.not_connected":"未接入 / 未知","reconciliation.history_notice":"历史恢复方案不代表当前对账状态。","reconciliation.materials":"恢复方案详情","reconciliation.stale":"数据可能不是最新","reconciliation.read_unknown":"恢复方案或处理状态暂未确认","reconciliation.empty":"暂无恢复记录。","reconciliation.unnamed_strategy":"未命名策略","reconciliation.decision_status":"处理状态","reconciliation.decision_unknown":"处理状态未知","reconciliation.freshness":"数据时效","reconciliation.observed_at":"数据时间","reconciliation.generated_at":"方案生成时间","reconciliation.computed_at":"计算时间","inbox.count_unknown":"待办与审批数量暂时无法确认。","inbox.error.quota_exhausted.title":"待办暂时无法读取","inbox.error.quota_exhausted.detail":"今日读取次数已达上限，完整待办暂时不可用。","inbox.error.unauthorized.title":"待办访问受限","inbox.error.unauthorized.detail":"登录已失效或当前账户没有读取权限。","inbox.error.index_missing.title":"待办列表尚未建立","inbox.error.index_missing.detail":"完整列表尚未准备好，无法确认待办与审批数量。","inbox.error.index_incomplete.title":"待办列表尚未更新完成","inbox.error.index_incomplete.detail":"部分旧记录尚未纳入列表，暂时无法确认全部待办与审批。","inbox.error.index_unavailable.title":"待办暂时无法读取","inbox.error.index_unavailable.detail":"现有列表无法完整读取，请稍后重试；若持续失败，请联系管理员。","inbox.error.unknown.title":"待办暂时无法读取","inbox.error.unknown.detail":"原因尚未确认，请稍后重试；若持续失败，请联系管理员。","inbox.retry_at":"最早重试时间：{value}，不保证届时恢复。","inbox.auth_hint":"请使用已有读取权限的账户重新登录。","inbox.retry_hint":"稍后可重新读取；一分钟内可能仍显示上次失败结果。","inbox.retry":"重新读取待办","state.fresh":"最新","state.unknown":"未知","decisions.partial_notice":"部分来源不可用或不是最新，对应类别的待办可能不完整。","decisions.partial_affected":"受影响来源","decisions.partial_consequence.stale":"数据偏旧，该类别的待办可能不完整。","decisions.partial_consequence.unavailable":"暂不可用，该类别的待办无法确认。","decisions.partial_consequence.read_failed":"读取失败，该类别的待办无法确认。","decisions.unknown_source":"其他来源","decisions.material_freshness":"数据时效：{value}","decisions.stale_hint":"数据可能不是最新","decisions.stale_visible_hint":"创建较早，请确认是否仍有效","decisions.affects_live_required":"需实盘确认","decisions.affects_live_none":"不影响实盘","decisions.more_info":"更多信息","decisions.not_set":"未设置","decisions.intent_recorded":"选择已记录。","decisions.material_changed":"内容已更新，请重新查看后再确认。","decisions.intent_not_pending":"该事项已不在待处理状态。","decisions.intent_unavailable":"暂时无法确认最新内容，无法提交；请刷新后重试。","decisions.reconciliation_recovery":"对账恢复确认","decisions.strategy_promotion":"策略晋级方案","decisions.owner_decision":"负责人决定","decisions.paper_account_application":"模拟账户应用","decisions.credential_maintenance":"凭证维护","decisions.strategy":"策略","decisions.version":"版本","decisions.parameters":"参数","decisions.shadow_passed":"模拟运行已通过","decisions.shadow":"模拟运行指标","decisions.prompt.reconciliation_recovery":"是否采用这份恢复方案？提交后不会直接启用账户。","decisions.prompt.strategy_promotion":"是否采用这项策略晋级方案？","decisions.prompt.owner_decision":"是否采用这个策略候选？","decisions.prompt.paper_account_application":"是否将这个方案应用到模拟账户？","decisions.prompt.credential_maintenance":"凭证需要维护，请在运行状态页处理。","decisions.initial_enrollment_title":"首次接入确认","decisions.prompt.initial_enrollment":"是否确认这份首次接入事实？确认只记录人工意图，不会自动启用账户。","decisions.select_prompt":"从左侧选择一条事项查看详情。","decisions.select_account":"目标账户","decisions.no_account_options":"暂无可用的模拟账户选项，无法提交应用。","decisions.apply_note":"只提交模拟账户应用请求，不会自动启用策略或下单。","decisions.application_submitted":"请求已提交，结果待确认，请勿重复提交。","decisions.application_uncertain":"此前的请求结果待确认，请勿重复提交。","decisions.open_health":"前往运行状态","decisions.submitting":"正在提交…","decisions.confirm_adopt_label":"确认采用","decisions.confirm_decline_label":"确认不采用","decisions.freshness.ready":"就绪","decisions.source.owner":"负责人决定","decisions.source.promotion":"策略晋级","decisions.source.recovery":"对账恢复","decisions.source.credential":"凭证","decisions.technical_details":"参数详情","decisions.account_unbound":"未绑定账户","decisions.policy_unbound":"该晋级方案尚未绑定风险档位与策略版本，暂时不能提交。","decisions.outcome_unknown":"请求结果无法确认；为避免重复提交，请先刷新并确认当前状态。","initial_enrollment.title":"首次接入事实","initial_enrollment.source_time":"来源时间","initial_enrollment.status.complete":"完整","initial_enrollment.status.partial":"部分","initial_enrollment.status.unknown":"未知","initial_enrollment.surface.positions":"持仓","initial_enrollment.surface.cash":"现金","initial_enrollment.surface.open_orders":"未成交委托","initial_enrollment.surface.recent_executions":"近期成交","initial_enrollment.surface.local_execution_ledger":"本地执行账本","initial_enrollment.known_empty":"已确认无记录","initial_enrollment.partial_unavailable":"部分或暂不可用","initial_enrollment.partial_notice":"仅显示已返回的部分记录，不代表完整范围。","initial_enrollment.scope":"范围限定","initial_enrollment.scope_unavailable":"范围信息暂不可用；以下边界保持未知。","initial_enrollment.scope_field.kind":"范围类型","initial_enrollment.scope_field.currency":"币种","initial_enrollment.scope_field.window_start":"窗口开始","initial_enrollment.scope_field.window_end":"窗口结束","initial_enrollment.current_broker_day":"仅当前券商交易日","initial_enrollment.scope_field.limit_per_namespace":"每类记录上限","initial_enrollment.scope_field.gateway_availability":"网关可用性","initial_enrollment.scope_field.truncated":"结果是否截断","initial_enrollment.scope_kind.account_strategy_positions":"账户与策略持仓","initial_enrollment.scope_kind.returned_account_cash":"账户返回的现金","initial_enrollment.scope_kind.all_client_open_orders":"全部客户端未成交委托","initial_enrollment.scope_kind.broker_requested_window":"券商请求的时间窗口","initial_enrollment.scope_kind.bounded_live_claims_and_outcomes":"有界实盘声明与结果","initial_enrollment.value.true":"是","initial_enrollment.value.false":"否","initial_enrollment.blocked":"首次接入资料尚不完整，暂不能确认。","initial_enrollment.notice":"首次接入不构成历史对账，也不会自动启用账户、策略或交易。","initial_enrollment.fact.symbol":"代码","initial_enrollment.fact.underlier":"标的","initial_enrollment.fact.local_symbol":"本地代码","initial_enrollment.fact.expiration":"到期日","initial_enrollment.fact.right":"期权方向","initial_enrollment.fact.strike":"行权价","initial_enrollment.fact.quantity":"数量","initial_enrollment.fact.average_cost":"平均成本","initial_enrollment.fact.currency":"币种","initial_enrollment.fact.tags":"金额标签","initial_enrollment.fact.contract":"合约","initial_enrollment.fact.con_id":"合约标识","initial_enrollment.fact.sec_type":"证券类型","initial_enrollment.fact.perm_id":"永久委托标识","initial_enrollment.fact.action":"买卖方向","initial_enrollment.fact.order_type":"委托类型","initial_enrollment.fact.total_quantity":"委托总量","initial_enrollment.fact.limit_price":"限价","initial_enrollment.fact.aux_price":"附加价格","initial_enrollment.fact.status":"状态","initial_enrollment.fact.filled":"已成交数量","initial_enrollment.fact.remaining":"剩余数量","initial_enrollment.fact.execution_id":"成交标识","initial_enrollment.fact.order_id":"委托标识","initial_enrollment.fact.time":"成交时间","initial_enrollment.fact.side":"方向","initial_enrollment.fact.shares":"股数","initial_enrollment.fact.price":"价格","initial_enrollment.fact.record_count":"记录数","initial_enrollment.fact.CashBalance":"现金余额","initial_enrollment.fact.TotalCashBalance":"现金总额","initial_enrollment.fact.SettledCash":"已结算现金","initial_enrollment.fact.$LEDGER-CashBalance":"账本现金余额","initial_enrollment.fact.$LEDGER-TotalCashBalance":"账本现金总额"},a_={"reconciliation.title":"Reconciliation history","reconciliation.current":"Current reconciliation status","reconciliation.not_connected":"Not connected / unknown","reconciliation.history_notice":"Historical recovery plans do not confirm the current reconciliation status.","reconciliation.materials":"Recovery plan details","reconciliation.stale":"Data may not be up to date","reconciliation.read_unknown":"Recovery plan or processing status is unconfirmed","reconciliation.empty":"No recovery records.","reconciliation.unnamed_strategy":"Unnamed strategy","reconciliation.decision_status":"Processing status","reconciliation.decision_unknown":"Processing status unknown","reconciliation.freshness":"Data freshness","reconciliation.observed_at":"Data time","reconciliation.generated_at":"Plan generated at","reconciliation.computed_at":"Calculated at","inbox.count_unknown":"Todo and approval counts cannot be confirmed right now.","inbox.error.quota_exhausted.title":"Todos could not be read","inbox.error.quota_exhausted.detail":"The daily read limit has been reached, so the complete inbox is temporarily unavailable.","inbox.error.unauthorized.title":"Todo access restricted","inbox.error.unauthorized.detail":"Your session has expired or this account lacks read access.","inbox.error.index_missing.title":"Todo list not ready","inbox.error.index_missing.detail":"A complete list is not ready, so todo and approval counts are unknown.","inbox.error.index_incomplete.title":"Todo list update incomplete","inbox.error.index_incomplete.detail":"Some older records are not included yet, so complete todo and approval coverage is unknown.","inbox.error.index_unavailable.title":"Todos could not be read","inbox.error.index_unavailable.detail":"The existing list could not be read completely. Try again later; contact an administrator if the problem persists.","inbox.error.unknown.title":"Todos could not be read","inbox.error.unknown.detail":"The cause is unconfirmed. Try again later; contact an administrator if the problem persists.","inbox.retry_at":"Earliest retry: {value}. Recovery by then is not guaranteed.","inbox.auth_hint":"Sign in again with an account that already has read access.","inbox.retry_hint":"Try again later. The previous failure may still appear for up to one minute.","inbox.retry":"Read todos again","state.fresh":"Fresh","state.unknown":"Unknown","decisions.partial_notice":"Some sources are unavailable or out of date; the affected categories may be incomplete.","decisions.partial_affected":"Affected sources","decisions.partial_consequence.stale":"out of date; this category may be incomplete.","decisions.partial_consequence.unavailable":"unavailable; this category's pending items cannot be confirmed.","decisions.partial_consequence.read_failed":"failed to load; this category's pending items cannot be confirmed.","decisions.unknown_source":"Other source","decisions.material_freshness":"Data freshness: {value}","decisions.stale_hint":"Data may not be up to date","decisions.stale_visible_hint":"Created earlier; verify whether it is still relevant","decisions.affects_live_required":"Live confirmation required","decisions.affects_live_none":"No live impact","decisions.more_info":"More info","decisions.not_set":"Not set","decisions.intent_recorded":"Choice recorded.","decisions.material_changed":"The content has changed. Review it again before confirming.","decisions.intent_not_pending":"This item is no longer pending.","decisions.intent_unavailable":"The latest content cannot be confirmed, so this cannot be submitted. Refresh and try again.","decisions.reconciliation_recovery":"Reconciliation recovery","decisions.strategy_promotion":"Strategy promotion","decisions.owner_decision":"Owner decision","decisions.paper_account_application":"Paper account application","decisions.credential_maintenance":"Credential maintenance","decisions.strategy":"Strategy","decisions.version":"Version","decisions.parameters":"Parameter","decisions.shadow_passed":"Simulation check passed","decisions.shadow":"Simulation metrics","decisions.prompt.reconciliation_recovery":"Adopt this recovery plan? Submitting will not enable the account directly.","decisions.prompt.strategy_promotion":"Adopt this strategy promotion?","decisions.prompt.owner_decision":"Adopt this strategy candidate?","decisions.prompt.paper_account_application":"Apply this proposal to a paper account?","decisions.prompt.credential_maintenance":"This credential needs maintenance; handle it on the Health page.","decisions.initial_enrollment_title":"Initial enrollment","decisions.prompt.initial_enrollment":"Confirm these first-enrollment facts? Confirming records human intent only and does not automatically enable the account.","decisions.select_prompt":"Select an item on the left to see details.","decisions.select_account":"Target account","decisions.no_account_options":"No paper account option is available, so no application can be submitted.","decisions.apply_note":"This only submits a paper account application request; it does not enable the strategy or place orders.","decisions.application_submitted":"Request submitted. The result still needs confirmation; do not resubmit.","decisions.application_uncertain":"An earlier request still needs confirmation. Do not resubmit.","decisions.open_health":"Open Health","decisions.submitting":"Submitting…","decisions.confirm_adopt_label":"Confirm adopt","decisions.confirm_decline_label":"Confirm decline","decisions.freshness.ready":"Ready","decisions.source.owner":"Owner decisions","decisions.source.promotion":"Strategy promotions","decisions.source.recovery":"Reconciliation recovery","decisions.source.credential":"Credentials","decisions.technical_details":"Parameter details","decisions.account_unbound":"No linked account","decisions.policy_unbound":"This promotion has no bound risk tier and policy revision, so it cannot be submitted yet.","decisions.outcome_unknown":"The request outcome cannot be confirmed. Refresh and confirm the current state before trying again.","initial_enrollment.title":"First enrollment facts","initial_enrollment.source_time":"Source time","initial_enrollment.status.complete":"Complete","initial_enrollment.status.partial":"Partial","initial_enrollment.status.unknown":"Unknown","initial_enrollment.surface.positions":"Positions","initial_enrollment.surface.cash":"Cash","initial_enrollment.surface.open_orders":"Open orders","initial_enrollment.surface.recent_executions":"Recent executions","initial_enrollment.surface.local_execution_ledger":"Local execution ledger","initial_enrollment.known_empty":"No records (confirmed)","initial_enrollment.partial_unavailable":"Partial or unavailable","initial_enrollment.partial_notice":"Only the returned partial records are shown; they do not represent the complete scope.","initial_enrollment.scope":"Bounded scope","initial_enrollment.scope_unavailable":"Scope information is unavailable; the bounds below remain unknown.","initial_enrollment.scope_field.kind":"Scope type","initial_enrollment.scope_field.currency":"Currency","initial_enrollment.scope_field.window_start":"Window start","initial_enrollment.scope_field.window_end":"Window end","initial_enrollment.current_broker_day":"Current broker day only","initial_enrollment.scope_field.limit_per_namespace":"Limit per record type","initial_enrollment.scope_field.gateway_availability":"Gateway availability","initial_enrollment.scope_field.truncated":"Truncated","initial_enrollment.scope_kind.account_strategy_positions":"Account and strategy positions","initial_enrollment.scope_kind.returned_account_cash":"Returned account cash","initial_enrollment.scope_kind.all_client_open_orders":"All client open orders","initial_enrollment.scope_kind.broker_requested_window":"Broker-requested window","initial_enrollment.scope_kind.bounded_live_claims_and_outcomes":"Bounded live claims and outcomes","initial_enrollment.value.true":"Yes","initial_enrollment.value.false":"No","initial_enrollment.blocked":"First enrollment facts are incomplete, so they cannot be confirmed yet.","initial_enrollment.notice":"First enrollment is not a historical reconciliation and does not automatically enable the account, strategy or trading.","initial_enrollment.fact.symbol":"Symbol","initial_enrollment.fact.underlier":"Underlier","initial_enrollment.fact.local_symbol":"Local symbol","initial_enrollment.fact.expiration":"Expiration","initial_enrollment.fact.right":"Option right","initial_enrollment.fact.strike":"Strike","initial_enrollment.fact.quantity":"Quantity","initial_enrollment.fact.average_cost":"Average cost","initial_enrollment.fact.currency":"Currency","initial_enrollment.fact.tags":"Amount tags","initial_enrollment.fact.contract":"Contract","initial_enrollment.fact.con_id":"Contract ID","initial_enrollment.fact.sec_type":"Security type","initial_enrollment.fact.perm_id":"Permanent order ID","initial_enrollment.fact.action":"Action","initial_enrollment.fact.order_type":"Order type","initial_enrollment.fact.total_quantity":"Total quantity","initial_enrollment.fact.limit_price":"Limit price","initial_enrollment.fact.aux_price":"Auxiliary price","initial_enrollment.fact.status":"Status","initial_enrollment.fact.filled":"Filled","initial_enrollment.fact.remaining":"Remaining","initial_enrollment.fact.execution_id":"Execution ID","initial_enrollment.fact.order_id":"Order ID","initial_enrollment.fact.time":"Execution time","initial_enrollment.fact.side":"Side","initial_enrollment.fact.shares":"Shares","initial_enrollment.fact.price":"Price","initial_enrollment.fact.record_count":"Record count","initial_enrollment.fact.CashBalance":"Cash balance","initial_enrollment.fact.TotalCashBalance":"Total cash balance","initial_enrollment.fact.SettledCash":"Settled cash","initial_enrollment.fact.$LEDGER-CashBalance":"Ledger cash balance","initial_enrollment.fact.$LEDGER-TotalCashBalance":"Ledger total cash balance"},n_={"accounts.open_strategy":"查看 {account} 的 {strategy} 设置","accounts.retired_option_draft":"保存时会清除旧期权草稿，不会更改实盘配置。","accounts.execution.mode":"执行模式","accounts.execution.reason.evidence_missing":"执行方式尚未确认。","accounts.execution.broker_environment":"券商环境：{value}","accounts.execution.source":"配置来源：{value}","accounts.execution.observed":"配置检查时间：","accounts.execution.config_only":"仅说明已读取的配置，当前运行及成交状态未验证。","accounts.execution.runtime_target_note":"运行目标已启用只表示配置状态，不代表已实盘运行或今日已有成交。","accounts.activation_setting":"启用设置","accounts.execution.source.runtime_target":"运行目标配置","accounts.execution.source.service_target":"服务目标配置","accounts.execution.source.missing":"未提供执行配置来源","accounts.execution.reason.not_connected":"配置读取未接入","accounts.execution.reason.read_failed":"配置读取失败","accounts.execution.reason.permission_denied":"无权读取配置","accounts.execution.reason.broker_environment_missing":"账户目录缺少明确的券商环境","accounts.execution.reason.execution_config_missing":"缺少匹配账户的明确执行模式配置","accounts.execution.reason.dry_run_flag_missing":"缺少明确的演练限制配置","accounts.execution.reason.environment_conflict":"券商环境与执行配置冲突","accounts.environment.live":"实盘账户","accounts.environment.paper":"模拟账户","accounts.environment.unknown":"环境待确认","accounts.environment_count":"{count} 个账户","accounts.environment.paper_note":"模拟账户金额单列，不计入实盘合计。","accounts.environment.unknown_note":"环境未确认的账户不计入实盘合计；金额按各来源展示。","accounts.unassigned_note":"{count} 条待办未关联账户","accounts.go_todos":"去待办","accounts.select_account":"选择一个账户查看详情","accounts.select_account_hint":"从账户列表中选择要查看的账户。","accounts.back_to_list":"返回账户列表","accounts.identity":"账户标识","accounts.data_notes":"数据说明","accounts.draft_value":"草案：{value}","accounts.section.strategy":"策略","accounts.section.dca":"定投","accounts.section.cash_reserve":"资金预留","accounts.section.income_layer":"收入层","accounts.section.options_layer":"期权层","accounts.field.strategy_profile":"策略档案","accounts.field.dca_mode":"定投模式","accounts.field.dca_base_investment_usd":"定投基准金额（USD）","accounts.field.reserved_cash_floor":"预留现金下限（USD）","accounts.field.reserved_cash_ratio":"预留现金比例","accounts.field.income_layer_enabled":"收入层","accounts.field.option_overlay_enabled":"期权层","accounts.bool.on":"开启","accounts.bool.off":"关闭","accounts.dca_mode.fixed":"定额定投","accounts.dca_mode.smart":"智能定投","accounts.form.inherit":"跟随当前值","accounts.form.clear_override":"清除覆盖","accounts.form.undo":"撤销修改","accounts.form.select_profile":"请选择策略档案","accounts.form.dca_pair_required":"定投模式与金额需要一起填写","accounts.form.invalid_decimal":"需要是不小于 0 的数字","accounts.form.invalid_ratio":"比例需要在 0 到 1 之间，例如 0.15","accounts.form.invalid_dca_amount":"定投金额需为大于 0 的数字","accounts.checking":"正在检查最新配置…","accounts.saving":"正在保存…","accounts.save_unknown":"保存结果未知；请刷新确认当前草案，确认前不要重复提交。","controls.submitting":"正在提交…","controls.confirm.enable_title":"确认启用运行目标","controls.confirm.resume_title":"确认恢复运行目标","controls.confirm.approve_title":"确认批准策略应用","controls.enable_note":"当前页面暂不支持提交启用请求；运行目标状态保持不变。","controls.enable_control_note":"启用不会解除已有保护状态。","controls.protected":"已有保护状态仍然生效。","controls.approve_not_ready":"当前没有仅修改策略档案且可批准的草案；请刷新确认。","controls.stop_consequence":"停止只阻止新的触发；不会撤单、平仓或清除在途请求。","controls.result.enable":"已启用","controls.result.disable":"已停用","accounts.effect_unconfirmed":"暂时无法确认是否生效。","accounts.declaration.title":"账户声明","accounts.declaration.note":"用于账户展示，不会改变交易设置。","accounts.declaration.environment":"环境声明","accounts.declaration.account_type":"账户类型","accounts.declaration.env.live":"实盘","accounts.declaration.env.paper":"模拟","accounts.declaration.type.cash":"现金账户","accounts.declaration.type.margin":"保证金账户","accounts.declaration.unset":"未声明","accounts.declaration.savedValue":"已声明","accounts.declaration.save":"保存声明","accounts.declaration.discard":"撤销修改","accounts.declaration.saving":"正在保存声明…","accounts.declaration.saved":"声明已保存。","accounts.declaration.conflict":"保存冲突；请重新读取后再试。","accounts.declaration.mismatch":"读回结果与提交内容不一致。","accounts.declaration.unverified":"保存结果未知；请重新读取确认，确认前不要重复提交。","accounts.declaration.review":"保存结果未知；请重新读取确认。","accounts.declaration.gate":"当前不支持保存账户声明。","accounts.declaration.reread":"重新读取","accounts.declaration.denied":"没有权限读取账户声明。","accounts.declaration.readMismatch":"读回的账户与所选账户不一致。","accounts.declaration.readFailed":"账户声明暂时读不到。","accounts.declaration.stale":"显示的是上次读取的声明。","accounts.declaration.conflict_notice":"与已有信息不一致，请确认。","accounts.declaration.ack":"已了解"},l_={"accounts.open_strategy":"Open {strategy} settings for {account}","accounts.retired_option_draft":"Saving removes the old options draft without changing live configuration.","accounts.execution.mode":"Execution mode","accounts.execution.reason.evidence_missing":"Execution mode is not yet confirmed.","accounts.execution.broker_environment":"Broker environment: {value}","accounts.execution.source":"Configuration source: {value}","accounts.execution.observed":"Configuration checked at:","accounts.execution.config_only":"Describes the configuration read; current runs and fills are unverified.","accounts.execution.runtime_target_note":"An enabled runtime target is configuration state only; it does not mean live trading ran or produced fills today.","accounts.activation_setting":"Activation setting","accounts.execution.source.runtime_target":"Runtime target configuration","accounts.execution.source.service_target":"Service target configuration","accounts.execution.source.missing":"Execution configuration source unavailable","accounts.execution.reason.not_connected":"Configuration reader is not connected","accounts.execution.reason.read_failed":"Configuration read failed","accounts.execution.reason.permission_denied":"Configuration read permission denied","accounts.execution.reason.broker_environment_missing":"Account directory has no explicit broker environment","accounts.execution.reason.execution_config_missing":"No explicit execution mode in a matching account configuration","accounts.execution.reason.dry_run_flag_missing":"Explicit dry-run constraint is missing","accounts.execution.reason.environment_conflict":"Broker environment conflicts with execution configuration","accounts.environment.live":"Live accounts","accounts.environment.paper":"Paper accounts","accounts.environment.unknown":"Environment unconfirmed","accounts.environment_count":"{count} accounts","accounts.environment.paper_note":"Paper account amounts are listed separately and excluded from live totals.","accounts.environment.unknown_note":"Accounts with an unconfirmed environment are excluded from live totals; amounts are shown per source.","accounts.unassigned_note":"{count} to-dos are not linked to an account","accounts.go_todos":"Open to-dos","accounts.select_account":"Select an account to see details","accounts.select_account_hint":"Pick an account from the list.","accounts.back_to_list":"Back to accounts","accounts.identity":"Account ID","accounts.data_notes":"Data notes","accounts.draft_value":"Draft: {value}","accounts.section.strategy":"Strategy","accounts.section.dca":"DCA","accounts.section.cash_reserve":"Cash reserve","accounts.section.income_layer":"Income layer","accounts.section.options_layer":"Options layer","accounts.field.strategy_profile":"Strategy profile","accounts.field.dca_mode":"DCA mode","accounts.field.dca_base_investment_usd":"DCA base amount (USD)","accounts.field.reserved_cash_floor":"Reserved cash floor (USD)","accounts.field.reserved_cash_ratio":"Reserved cash ratio","accounts.field.income_layer_enabled":"Income layer","accounts.field.option_overlay_enabled":"Option overlay","accounts.bool.on":"On","accounts.bool.off":"Off","accounts.dca_mode.fixed":"Fixed amount","accounts.dca_mode.smart":"Smart","accounts.form.inherit":"Inherit current value","accounts.form.clear_override":"Clear override","accounts.form.undo":"Undo","accounts.form.select_profile":"Select a strategy profile","accounts.form.dca_pair_required":"DCA mode and amount must be provided together","accounts.form.invalid_decimal":"Must be a number greater than or equal to 0","accounts.form.invalid_ratio":"Ratio must be between 0 and 1, e.g. 0.15","accounts.form.invalid_dca_amount":"DCA amount must be a number greater than 0","accounts.checking":"Checking the latest settings…","accounts.saving":"Saving…","accounts.save_unknown":"The save result is unknown. Refresh and verify the current draft; do not resubmit until then.","controls.submitting":"Submitting…","controls.confirm.enable_title":"Confirm enabling the runtime target","controls.confirm.resume_title":"Confirm resuming the runtime target","controls.confirm.approve_title":"Confirm approving the strategy application","controls.enable_note":"This page cannot submit an enable request yet. The runtime target state stays unchanged.","controls.enable_control_note":"Enabling does not remove an existing protection state.","controls.protected":"The existing protection state remains active.","controls.approve_not_ready":"There is no approvable draft that changes only the strategy profile. Refresh and check again.","controls.stop_consequence":"Stopping only blocks new triggers; it does not cancel orders, close positions, or clear in-flight requests.","controls.result.enable":"Enabled","controls.result.disable":"Disabled","accounts.effect_unconfirmed":"Unable to confirm whether the change took effect.","accounts.declaration.title":"Account declaration","accounts.declaration.note":"Used for account display; trading settings are unchanged.","accounts.declaration.environment":"Environment declaration","accounts.declaration.account_type":"Account type","accounts.declaration.env.live":"Live","accounts.declaration.env.paper":"Paper","accounts.declaration.type.cash":"Cash account","accounts.declaration.type.margin":"Margin account","accounts.declaration.unset":"Not declared","accounts.declaration.savedValue":"Declared","accounts.declaration.save":"Save declaration","accounts.declaration.discard":"Discard changes","accounts.declaration.saving":"Saving declaration…","accounts.declaration.saved":"Declaration saved.","accounts.declaration.conflict":"Save conflict; re-read and try again.","accounts.declaration.mismatch":"The readback does not match what was submitted.","accounts.declaration.unverified":"The save result is unknown; re-read to confirm and do not resubmit until then.","accounts.declaration.review":"The save result is unknown; re-read to confirm.","accounts.declaration.gate":"Saving account declarations is not available.","accounts.declaration.reread":"Re-read","accounts.declaration.denied":"No permission to read the account declaration.","accounts.declaration.readMismatch":"The readback account does not match the selected account.","accounts.declaration.readFailed":"The account declaration is temporarily unavailable.","accounts.declaration.stale":"Showing the declaration from the last successful read.","accounts.declaration.conflict_notice":"This differs from available information. Please check.","accounts.declaration.ack":"Acknowledge"},i_={"strategies.assignment_unknown":"账户绑定待确认","strategies.assignment_unavailable":"账户配置未完整读取，暂无法确认策略绑定；已有健康数据仍按其来源日期展示。","strategies.health_as_of":"健康数据截至 {value}","strategies.health_label":"策略健康","strategies.health_not_provided":"未提供","strategies.execution_section":"账户执行模式","strategies.execution_unknown_note":"未知表示账户目录或运行目标还缺少明确的执行配置；补齐后会自动确认。","strategies.domain_note":"策略健康来自策略评估；执行模式来自账户配置。两者都不代表平台今日运行结果。","reason.strategy_health_stale":"策略健康数据已过期。","strategies.details":"详细信息","strategies.research_unavailable":"研究资料暂时不可用。","strategies.research_sources":"来源：{value}","strategies.research_as_of":"资料日期：{value}","strategies.research_expires":"有效期至 {value}","strategies.research_more":"查看说明","research.source.generic":"研究来源","research.source.quant-advisor-research":"量化研究信号","research.source.quant_advisor_research":"量化研究信号","research.state.context_only":"仅作背景","research.state.candidate":"研究候选","research.state.source_verification_required":"来源待核实","research.state.deferred":"暂缓研究","state.unknown":"未知","strategies.research_empty":"暂无研究资料。","strategies.configured_section":"已配置策略","strategies.catalog_section":"目录策略","strategies.section_count":"{count} 项","strategies.no_configured":"当前没有账户配置策略；可从下方目录继续查看。","strategies.binding":"账户绑定","strategies.unbound":"未绑定账户","strategies.unbound_note":"目录项尚未绑定账户；这不表示策略已停用或正在运行。","strategies.unmatched_title":"目录外策略绑定","strategies.unmatched_note":"以下账户绑定的策略不在当前策略目录中（可能已停用或改名）。此处只读展示绑定事实，不推断该策略仍可运行。","strategies.unmatched_profile":"目录中不存在的策略标识"},c_={"strategies.assignment_unknown":"Account binding unconfirmed","strategies.assignment_unavailable":"Account configuration could not be read completely, so strategy bindings are unconfirmed. Available health data keeps its source date.","strategies.health_as_of":"Health data as of {value}","strategies.health_label":"Strategy health","strategies.health_not_provided":"Not provided","strategies.execution_section":"Account execution mode","strategies.execution_unknown_note":"Unknown means the account directory or runtime target still lacks explicit execution configuration; it confirms automatically once supplied.","strategies.domain_note":"Strategy health comes from strategy evaluation; execution mode comes from account configuration. Neither establishes today's platform run result.","reason.strategy_health_stale":"Strategy health data is stale.","strategies.details":"Details","strategies.research_unavailable":"Research data is temporarily unavailable.","strategies.research_sources":"Sources: {value}","strategies.research_as_of":"Data as of: {value}","strategies.research_expires":"Expires {value}","strategies.research_more":"View notes","research.source.generic":"Research source","research.source.quant-advisor-research":"Quant research signal","research.source.quant_advisor_research":"Quant research signal","research.state.context_only":"Context only","research.state.candidate":"Research candidate","research.state.source_verification_required":"Source verification required","research.state.deferred":"Research deferred","state.unknown":"Unknown","strategies.research_empty":"No research data yet.","strategies.configured_section":"Configured strategies","strategies.catalog_section":"Catalog strategies","strategies.section_count":"{count}","strategies.no_configured":"No account is configured with a strategy yet. Browse the catalog below.","strategies.binding":"Account binding","strategies.unbound":"No account linked","strategies.unbound_note":"This catalog entry has no linked account; it does not mean the strategy is stopped or running.","strategies.unmatched_title":"Bindings outside the catalog","strategies.unmatched_note":"These accounts are bound to a strategy the current catalog no longer declares (retired or renamed). The row reports the binding as configured; it does not claim the strategy can still run.","strategies.unmatched_profile":"Strategy identifier missing from the catalog"},o_={"health.failure_at_least":"至少 {count}","health.failure_window":"{date} · 纽约时间","health.failure_window_detail":"仅统计今日，不含下方 14 日历史；纽约时间含夏令时。","health.failure_incomplete":"部分数据未返回","health.kpi.today_runs":"完整数据账户","health.kpi.today_runs_note":"未接入 {not_connected} · 暂无数据 {no_data}","health.kpi.today_runs_note_title":"未接入和暂无数据不计为失败。","health.kpi.observed":"今日有记录账户","health.kpi.credentials":"凭证","health.kpi.credentials_unit":"项需关注","health.kpi.recent_failure":"今日失败账户","health.business_date":"纽约业务日 {value}","health.non_trading_day":"非交易日：周末无计划运行；加密货币账户可能仍有记录。","health.non_trading_day_short":"非交易日","health.grid_read_failed_note":"部分日期读取失败，无法确认当天是否运行。","health.grid.binding_changed":"绑定已轮换","health.grid.binding_changed_detail":"该日期记录写于绑定轮换之前，无法与当前账户绑定匹配，因此不展示；这不代表当天未运行。","health.grid_binding_changed_note":"部分日期属于绑定轮换前的历史记录；记录已保留，但不会与当前账户绑定混用。","health.global_scope_note":"本页展示全部平台与账户的运行状态。","health.grid.incomplete":"未完成","health.col.credential":"凭证","health.col.phase":"阶段","health.col.expires":"到期时间","health.col.channel":"渠道","health.col.summary":"内容","health.detail.started":"开始","health.detail.finished":"结束","health.account_fraction":"{count}/{total}","health.state_counts":"今日账户状态（有数据）","health.state_details":"状态明细","health.day_detail_summary":"{count} 次运行","health.day_detail_runs":"查看每次运行","health.run_state.succeeded":"成功","health.run_state.failed":"失败","health.run_state.blocked":"被拦截","health.run_state.no_data":"暂无数据","health.run_state.not_connected":"未接入","health.run_state.not_run":"尚未到期或非运行时段","health.run_state.unknown":"未知","health.run_state.read_failed":"读取失败","health.run_state.incomplete":"读取不完整"},u_={"health.failure_at_least":"At least {count}","health.failure_window":"{date} · New York time","health.failure_window_detail":"Today only; excludes the 14-day history below. New York time observes DST.","health.failure_incomplete":"Some data was not returned","health.kpi.today_runs":"Accounts with complete data","health.kpi.today_runs_note":"Not connected: {not_connected} · no data: {no_data}","health.kpi.today_runs_note_title":"Not connected and no data do not count as failures.","health.kpi.observed":"Accounts with today's records","health.kpi.credentials":"Credentials","health.kpi.credentials_unit":"need attention","health.kpi.recent_failure":"Today's failed accounts","health.business_date":"New York business day {value}","health.non_trading_day":"Non-trading day: no scheduled weekend runs; crypto accounts may still report.","health.non_trading_day_short":"Non-trading day","health.grid_read_failed_note":"Some dates could not be read, so whether a run occurred is unknown.","health.grid.binding_changed":"Binding rotated","health.grid.binding_changed_detail":"This day was recorded under an earlier binding and no longer matches the current account binding, so it is not shown. It does not mean no run occurred.","health.grid_binding_changed_note":"Some dates predate a binding rotation; their records are retained but never mixed with the current account binding.","health.global_scope_note":"This page shows runtime status for all platforms and accounts.","health.grid.incomplete":"Incomplete","health.col.credential":"Credential","health.col.phase":"Phase","health.col.expires":"Expires","health.col.channel":"Channel","health.col.summary":"Summary","health.detail.started":"Started","health.detail.finished":"Finished","health.account_fraction":"{count}/{total}","health.state_counts":"Today's account states (with data)","health.state_details":"Status details","health.day_detail_summary":"{count} runs","health.day_detail_runs":"View individual runs","health.run_state.succeeded":"Succeeded","health.run_state.failed":"Failed","health.run_state.blocked":"Blocked","health.run_state.no_data":"No data","health.run_state.not_connected":"Not connected","health.run_state.not_run":"Not due or outside run window","health.run_state.unknown":"Unknown","health.run_state.read_failed":"Read failed","health.run_state.incomplete":"Read incomplete"},s_={"facts.assets":"资产","facts.cash":"现金","facts.available_cash":"可用现金","facts.cash_semantics":"券商提供的现金余额，不代表购买力、可用资金或保证金。","facts.identity_unverified":"账户身份未核验，金额暂不展示","facts.platform_identity_unverified":"平台合计不可用：有账户身份未核验","facts.observation_conflict":"同一账户身份的数据不一致，金额暂不展示","facts.amount_unavailable":"金额不可用","facts.platform_total":"平台合计","facts.platform_subtotal":"部分合计","facts.platform_total_live":"实盘合计","facts.platform_subtotal_live":"实盘小计","facts.platform_scope_note":"仅含实盘账户，不含模拟账户；仅合计已核验且估值日期一致的账户。","facts.platform_subtotal_note":"仅合计已核验且估值日期一致的账户。","facts.coverage":"已计入 {covered}/{expected} 个账户","facts.partial_badge":"估值不完整","facts.stale_pending":"待更新","facts.as_of_stale":"截至 {value} · 待更新","facts.identity_action":"去核验账户","facts.wallet_valuation":"钱包估值","facts.wallet_holdings":"持仓 · {count} 种资产","facts.wallet_scope_note":"Binance 返回的钱包估值，不代表完整账户净值或现金；不计入实盘账户合计。","facts.wallet_holdings_scope_note":"持仓数量仅覆盖现货与活期理财，不含资金账户、杠杆、合约及锁定理财。","facts.wallet_unavailable":"暂不可用","facts.wallet_no_data":"暂无数据","facts.wallet_pending":"待更新","facts.wallet_read_failed":"读取失败"},r_={"facts.assets":"Assets","facts.cash":"Cash","facts.available_cash":"Available cash","facts.cash_semantics":"Broker-reported cash balance; this is not buying power, available funds, or margin.","facts.identity_unverified":"Account identity unverified; amounts are hidden","facts.platform_identity_unverified":"Platform total unavailable: some account identities are unverified","facts.observation_conflict":"Data conflicts for the same account identity; amounts are hidden","facts.amount_unavailable":"Amount unavailable","facts.platform_total":"Platform total","facts.platform_subtotal":"Subtotal","facts.platform_total_live":"Live total","facts.platform_subtotal_live":"Live subtotal","facts.platform_scope_note":"Live accounts only; paper accounts are excluded. Only verified accounts with the same valuation date are summed.","facts.platform_subtotal_note":"Only verified accounts with the same valuation date are included.","facts.coverage":"Includes {covered} of {expected} accounts","facts.partial_badge":"Valuation incomplete","facts.stale_pending":"Update pending","facts.as_of_stale":"As of {value} · update pending","facts.identity_action":"Verify accounts","facts.wallet_valuation":"Wallet valuation","facts.wallet_holdings":"Holdings · {count} assets","facts.wallet_scope_note":"Provider-returned wallet valuation, not complete account NAV or cash; excluded from live-account totals.","facts.wallet_holdings_scope_note":"Quantities cover Spot and Flexible Earn only; funding, margin, futures, and locked Earn are excluded.","facts.wallet_unavailable":"Temporarily unavailable","facts.wallet_no_data":"No data","facts.wallet_pending":"Update pending","facts.wallet_read_failed":"Read failed"},f_={"cockpit.change_log.coverage":"包含持久化决定与应用记录，以及保留范围内的操作日志。","cockpit.runtime.title":"运行状态读回","cockpit.runtime.switch":"运行开关","cockpit.runtime.enabled":"已启用","cockpit.runtime.disabled":"已停用","cockpit.runtime.scheduler":"调度器","cockpit.runtime.scheduler.enabled":"已启用","cockpit.runtime.scheduler.paused":"已暂停","cockpit.runtime.scheduler.mixed":"状态不一致","cockpit.runtime.scheduler.missing":"未找到","cockpit.runtime.scheduler.unknown":"未知","cockpit.runtime.scheduler.not_applicable":"不适用","cockpit.runtime.boundary":"来自最近保存的部署观测；不代表交易授权、订单或成交。","cockpit.synthetic":"示例数据","cockpit.unknown":"未知","cockpit.not_set":"未设置","cockpit.as_of":"截至 {value}","cockpit.freshness.current":"最新","cockpit.freshness.stale":"已过期","cockpit.freshness.missing":"未提供","cockpit.freshness.unknown":"未知","cockpit.freshness.partial":"部分覆盖","cockpit.freshness.unavailable":"暂不可用","cockpit.freshness.read_failed":"读取失败","cockpit.expiry.none":"无有效期限制","cockpit.expiry.unknown":"有效期无法确认","cockpit.expiry.at":"有效期至 {value}","cockpit.expiry.open":"{value} 后失效","cockpit.expiry.under_hour":"{value} 后失效（不足一小时）","cockpit.expiry.under_five":"{value} 后失效（不足五分钟）","cockpit.expiry.expired":"已失效","cockpit.expiry.inaction":"不处理则该决定到期后自动失效，不会执行任何变更。","cockpit.expiry.boundary":"到期后需重新读取决定，不会延长有效期。","cockpit.decision.review":"查看决定","cockpit.decision.qualification":"资格摘要","cockpit.decision.target":"目标","cockpit.decision.release":"版本","cockpit.decision.tier":"风险档位","cockpit.decision.policy":"策略版本","cockpit.decision.operation":"申请状态","cockpit.decision.expires":"有效期","cockpit.decision.no_action":"不处理：到期后自动失效，不产生变更。","cockpit.decision.blocked":"暂不可审批","cockpit.decision.selected":"当前已选","cockpit.decision.state.pending":"待处理","cockpit.decision.state.approved":"已批准","cockpit.decision.state.rejected":"已拒绝","cockpit.decision.state.expired":"已过期","cockpit.decision.state.superseded":"已被取代","cockpit.decision.state.withdrawn":"已撤回","cockpit.blocker.expired":"决定已到期。","cockpit.blocker.expiry":"有效期无法确认。","cockpit.blocker.not_allowed":"服务端当前不允许审批。","cockpit.blocker.support_missing":"支持资料缺失。","cockpit.blocker.support":"支持资料不是最新或不完整。","cockpit.blocker.unqualified":"支持资料未达到资格要求。","cockpit.blocker.policy":"风险策略不可用。","cockpit.blocker.binding":"风险档位或策略版本未绑定。","cockpit.blocker.revision":"决定修订无法确认。","cockpit.blocker.state":"该决定已不在待处理状态。","cockpit.blocker.other":"当前不可审批。","cockpit.support.title":"支持资料","cockpit.support.qualified":"合格","cockpit.support.qualified_limited":"合格但有限制","cockpit.support.unqualified":"不合格","cockpit.support.unknown":"资格未知","cockpit.support.observed":"观察时间 {value}","cockpit.support.observed_label":"观察时间","cockpit.support.valid_until":"有效至 {value}","cockpit.support.valid_until_label":"有效至","cockpit.support.limitations":"限制","cockpit.support.no_limitations":"未报告限制。","cockpit.support.missing":"支持资料未提供，审批保持关闭。","cockpit.support.unavailable":"支持资料暂不可用。","cockpit.support.stale":"支持资料已过期，需重新读取。","cockpit.support.expired":"支持资料已失效，不能用于审批。","cockpit.support.provenance":"来源标识","cockpit.policy.title":"风险策略","cockpit.policy.selected":"已选偏好","cockpit.policy.approved":"已批准策略","cockpit.policy.effective":"生效策略","cockpit.policy.restriction":"临时限制","cockpit.policy.not_observed":"尚未观察到","cockpit.policy.mapping_unavailable":"策略映射不可用","cockpit.policy.read_failed":"风险策略读取失败。","cockpit.policy.revision":"修订 {value}","cockpit.policy.values":"计算出的限制","cockpit.policy.no_values":"暂无计算值。","cockpit.policy.source":"来源：{value}","cockpit.policy.source_label":"来源","cockpit.policy.unknown_value":"未知","cockpit.policy.current":"映射已是最新","cockpit.policy.restriction_none":"无","cockpit.policy.since":"自 {value}","cockpit.policy.effective_note":"已选偏好与生效策略分开显示；观察确认前不会视为已生效。","cockpit.tier.title":"风险档位","cockpit.tier.capital":"资本保全","cockpit.tier.balanced":"平衡复利","cockpit.tier.growth":"成长复利","cockpit.tier.capital_note":"偏好较低风险；适用限制由已批准策略计算。","cockpit.tier.balanced_note":"兼顾成长与约束；适用限制由已批准策略计算。","cockpit.tier.growth_note":"接受较高风险；适用限制由已批准策略计算。","cockpit.tier.unset":"尚未选择","cockpit.tier.unset_note":"保存后表示暂不选择风险档位。","cockpit.tier.save":"保存档位选择","cockpit.tier.dirty":"已修改但未保存","cockpit.tier.unchanged":"未修改","cockpit.tier.gate":"当前不允许保存档位选择。","cockpit.tier.scope":"范围 {value}","cockpit.tier.selection_revision":"选择修订 {value}","cockpit.lifecycle.title":"生命周期","cockpit.lifecycle.step":"产品阶段","cockpit.lifecycle.axis.research":"研究阶段","cockpit.lifecycle.axis.authorized":"授权上限","cockpit.lifecycle.axis.effective":"实际观察","cockpit.lifecycle.axis.operating":"运行状态","cockpit.lifecycle.axis.application":"应用状态","cockpit.lifecycle.stage.research":"研究","cockpit.lifecycle.stage.paper":"模拟","cockpit.lifecycle.stage.small_live":"小规模实盘","cockpit.lifecycle.stage.full_live":"完整实盘","cockpit.lifecycle.stage.unclassified":"阶段未分类","cockpit.lifecycle.operating.running":"运行中","cockpit.lifecycle.operating.paused":"已暂停","cockpit.lifecycle.operating.reduction_only":"仅减仓","cockpit.lifecycle.operating.reconcile_only":"仅对账","cockpit.lifecycle.operating.unknown":"未知","cockpit.lifecycle.application.pending":"待应用","cockpit.lifecycle.application.applying":"应用中","cockpit.lifecycle.application.applied":"平台已应用","cockpit.lifecycle.application.rejected":"应用被拒绝","cockpit.lifecycle.application.failed":"应用失败","cockpit.lifecycle.application.unknown":"未知","cockpit.lifecycle.note":"阶段、授权、实际观察和运行状态分别显示；界面不会自行提升阶段。","cockpit.lifecycle.not_provided":"未提供该目标的生命周期阶段信息。","cockpit.lifecycle.identity":"版本 {release} · 目标 {target}","cockpit.operation.title":"申请状态","cockpit.operation.decision":"决定","cockpit.operation.application":"应用","cockpit.operation.observation":"运行观察","cockpit.operation.recorded":"决定已记录","cockpit.operation.accepted":"已接受，等待平台处理","cockpit.operation.applying":"应用进行中","cockpit.operation.rejected":"应用被拒绝","cockpit.operation.unknown":"结果未知","cockpit.operation.failed":"应用失败","cockpit.operation.applied_unobserved":"平台已报告应用，等待运行确认","cockpit.operation.confirmed":"运行已确认","cockpit.operation.refresh":"刷新状态","cockpit.operation.id":"操作标识 {value}","cockpit.operation.request":"请求标识 {value}","cockpit.operation.revision":"绑定修订 {value}","cockpit.operation.not_ready":"操作状态接口暂不可用，无法追查这次申请。","cockpit.operation.read_failed":"操作状态读取失败。","cockpit.operation.no_retry":"结果未知时不会自动重试；请先刷新状态确认。","cockpit.operation.none":"暂无操作记录。","cockpit.pause.title":"运行控制","cockpit.pause.pause":"暂停","cockpit.pause.resume":"恢复","cockpit.pause.pending":"控制请求处理中","cockpit.pause.unavailable":"当前不支持该操作。","cockpit.pause.note":"暂停与恢复使用平台已有语义；应用成功不等于运行已确认。","cockpit.pause.running":"运行中","cockpit.pause.paused":"已暂停","cockpit.pause.unknown":"运行状态未知","cockpit.change_log.title":"活动记录","cockpit.change_log.empty":"暂无活动记录。","cockpit.change_log.unavailable":"活动记录暂不可用。","cockpit.change_log.load_failed":"活动记录读取失败。","cockpit.change_log.more":"加载更多","cockpit.change_log.actor":"操作者 {value}","cockpit.change_log.subject":"对象 {value}","cockpit.change_log.revision":"修订 {value}","cockpit.change_log.outcome":"结果 {value}","cockpit.digest.title":"每日摘要发送","cockpit.digest.accepted":"已接受投递","cockpit.digest.delivered":"供应商已接受投递","cockpit.digest.failed":"发送失败","cockpit.digest.unknown":"投递结果未知","cockpit.digest.unavailable":"暂无法确认投递","cockpit.digest.window":"业务日 {day} · {zone}","cockpit.digest.targets":"目标 {expected} · 已覆盖 {covered} · 不可用 {unavailable}","cockpit.digest.accepted_at":"接受时间 {value}","cockpit.digest.ack":"接收方确认","cockpit.digest.ack_unknown":"未知","cockpit.digest.ack_at":"确认时间 {value}","cockpit.digest.legacy":"仅显示历史回执，不代表当前生产投递。","cockpit.digest.no_data":"暂无摘要投递记录。","cockpit.digest.read_failed":"摘要投递状态读取失败。","cockpit.digest.note":"已接受不等于已送达；送达也不等于人工确认。","cockpit.strip.title":"待确认操作","cockpit.strip.unknown":"结果未知，需确认","cockpit.strip.view":"查看操作","cockpit.strip.ack":"已知悉，继续显示原因","cockpit.strip.last_read":"状态读取于 {value}","cockpit.strip.note":"页面切换不会隐藏该操作。"},d_={"cockpit.change_log.coverage":"Includes durable decisions and application records, plus retained activity logs.","cockpit.runtime.title":"Runtime readback","cockpit.runtime.switch":"Runtime switch","cockpit.runtime.enabled":"Enabled","cockpit.runtime.disabled":"Disabled","cockpit.runtime.scheduler":"Scheduler","cockpit.runtime.scheduler.enabled":"Enabled","cockpit.runtime.scheduler.paused":"Paused","cockpit.runtime.scheduler.mixed":"Mixed","cockpit.runtime.scheduler.missing":"Missing","cockpit.runtime.scheduler.unknown":"Unknown","cockpit.runtime.scheduler.not_applicable":"Not applicable","cockpit.runtime.boundary":"Last stored deployment observation; it does not establish trading authority, orders or fills.","cockpit.synthetic":"Synthetic data","cockpit.unknown":"Unknown","cockpit.not_set":"Not set","cockpit.as_of":"As of {value}","cockpit.freshness.current":"Current","cockpit.freshness.stale":"Stale","cockpit.freshness.missing":"Not provided","cockpit.freshness.unknown":"Unknown","cockpit.freshness.partial":"Partial coverage","cockpit.freshness.unavailable":"Unavailable","cockpit.freshness.read_failed":"Read failed","cockpit.expiry.none":"No expiry","cockpit.expiry.unknown":"Expiry unconfirmed","cockpit.expiry.at":"Expires {value}","cockpit.expiry.open":"Expires in {value}","cockpit.expiry.under_hour":"Expires in {value} (under one hour)","cockpit.expiry.under_five":"Expires in {value} (under five minutes)","cockpit.expiry.expired":"Expired","cockpit.expiry.inaction":"If left open, this decision expires without changing anything.","cockpit.expiry.boundary":"At expiry the decision must be re-read; validity is never extended.","cockpit.decision.review":"Review decision","cockpit.decision.qualification":"Qualification","cockpit.decision.target":"Target","cockpit.decision.release":"Release","cockpit.decision.tier":"Risk tier","cockpit.decision.policy":"Policy","cockpit.decision.operation":"Application","cockpit.decision.expires":"Expiry","cockpit.decision.no_action":"If no action is taken: it expires with no change.","cockpit.decision.blocked":"Approval unavailable","cockpit.decision.selected":"Selected","cockpit.decision.state.pending":"Pending","cockpit.decision.state.approved":"Approved","cockpit.decision.state.rejected":"Rejected","cockpit.decision.state.expired":"Expired","cockpit.decision.state.superseded":"Superseded","cockpit.decision.state.withdrawn":"Withdrawn","cockpit.blocker.expired":"This decision has expired.","cockpit.blocker.expiry":"The validity window cannot be confirmed.","cockpit.blocker.not_allowed":"The server does not allow approval right now.","cockpit.blocker.support_missing":"Supporting data is missing.","cockpit.blocker.support":"Supporting data is not current or complete.","cockpit.blocker.unqualified":"Supporting data does not meet the qualification requirement.","cockpit.blocker.policy":"The risk policy is unavailable.","cockpit.blocker.binding":"The risk tier or policy revision is not bound.","cockpit.blocker.revision":"The decision revision cannot be confirmed.","cockpit.blocker.state":"This decision is no longer pending.","cockpit.blocker.other":"Approval is unavailable.","cockpit.support.title":"Supporting data","cockpit.support.qualified":"Qualified","cockpit.support.qualified_limited":"Qualified with limitations","cockpit.support.unqualified":"Unqualified","cockpit.support.unknown":"Qualification unknown","cockpit.support.observed":"Observed {value}","cockpit.support.observed_label":"Observed","cockpit.support.valid_until":"Valid until {value}","cockpit.support.valid_until_label":"Valid until","cockpit.support.limitations":"Limitations","cockpit.support.no_limitations":"No limitations reported.","cockpit.support.missing":"Supporting data is not provided, so approval stays closed.","cockpit.support.unavailable":"Supporting data is unavailable.","cockpit.support.stale":"Supporting data is stale; re-read it.","cockpit.support.expired":"Supporting data has expired and cannot support approval.","cockpit.support.provenance":"Source identifier","cockpit.policy.title":"Risk policy","cockpit.policy.selected":"Selected preference","cockpit.policy.approved":"Approved policy","cockpit.policy.effective":"Effective policy","cockpit.policy.restriction":"Temporary restriction","cockpit.policy.not_observed":"Not yet observed","cockpit.policy.mapping_unavailable":"Policy mapping unavailable","cockpit.policy.read_failed":"The risk policy could not be read.","cockpit.policy.revision":"Revision {value}","cockpit.policy.values":"Computed limits","cockpit.policy.no_values":"No computed values.","cockpit.policy.source":"Source: {value}","cockpit.policy.source_label":"Source","cockpit.policy.unknown_value":"Unknown","cockpit.policy.current":"Mapping current","cockpit.policy.restriction_none":"None","cockpit.policy.since":"Since {value}","cockpit.policy.effective_note":"Selected preference and effective policy stay separate; a selection is not effective before observation.","cockpit.tier.title":"Risk tier","cockpit.tier.capital":"Capital preservation","cockpit.tier.balanced":"Balanced compounding","cockpit.tier.growth":"Growth compounding","cockpit.tier.capital_note":"Prefer lower risk; the approved policy computes the applicable limits.","cockpit.tier.balanced_note":"Balance growth and restraint; the approved policy computes the applicable limits.","cockpit.tier.growth_note":"Accept higher risk; the approved policy computes the applicable limits.","cockpit.tier.unset":"No tier selected","cockpit.tier.unset_note":"Saving leaves no risk tier selected.","cockpit.tier.save":"Save tier selection","cockpit.tier.dirty":"Changed, not saved","cockpit.tier.unchanged":"Unchanged","cockpit.tier.gate":"Tier selection cannot be saved right now.","cockpit.tier.scope":"Scope {value}","cockpit.tier.selection_revision":"Selection revision {value}","cockpit.lifecycle.title":"Lifecycle","cockpit.lifecycle.step":"Product stage","cockpit.lifecycle.axis.research":"Research stage","cockpit.lifecycle.axis.authorized":"Authorized ceiling","cockpit.lifecycle.axis.effective":"Observed stage","cockpit.lifecycle.axis.operating":"Operating state","cockpit.lifecycle.axis.application":"Application state","cockpit.lifecycle.stage.research":"Research","cockpit.lifecycle.stage.paper":"Paper","cockpit.lifecycle.stage.small_live":"Small live","cockpit.lifecycle.stage.full_live":"Full live","cockpit.lifecycle.stage.unclassified":"Stage unclassified","cockpit.lifecycle.operating.running":"Running","cockpit.lifecycle.operating.paused":"Paused","cockpit.lifecycle.operating.reduction_only":"Reduction only","cockpit.lifecycle.operating.reconcile_only":"Reconcile only","cockpit.lifecycle.operating.unknown":"Unknown","cockpit.lifecycle.application.pending":"Pending","cockpit.lifecycle.application.applying":"Applying","cockpit.lifecycle.application.applied":"Applied by platform","cockpit.lifecycle.application.rejected":"Rejected","cockpit.lifecycle.application.failed":"Failed","cockpit.lifecycle.application.unknown":"Unknown","cockpit.lifecycle.note":"Stage, authority, observation and operating state stay separate; the UI never promotes a stage.","cockpit.lifecycle.not_provided":"Lifecycle stages were not provided for this target.","cockpit.lifecycle.identity":"Release {release} · target {target}","cockpit.operation.title":"Application status","cockpit.operation.decision":"Decision","cockpit.operation.application":"Application","cockpit.operation.observation":"Runtime observation","cockpit.operation.recorded":"Decision recorded","cockpit.operation.accepted":"Accepted; waiting for platform dispatch","cockpit.operation.applying":"Application in progress","cockpit.operation.rejected":"Application rejected","cockpit.operation.unknown":"Outcome unknown","cockpit.operation.failed":"Application failed","cockpit.operation.applied_unobserved":"Platform reported applied; runtime confirmation pending","cockpit.operation.confirmed":"Runtime confirmed","cockpit.operation.refresh":"Refresh status","cockpit.operation.id":"Operation {value}","cockpit.operation.request":"Request {value}","cockpit.operation.revision":"Bound revision {value}","cockpit.operation.not_ready":"The operation-status endpoint is not available, so this application cannot be traced.","cockpit.operation.read_failed":"Operation status could not be read.","cockpit.operation.no_retry":"An unknown outcome is never retried automatically; refresh status first.","cockpit.operation.none":"No operation recorded.","cockpit.pause.title":"Runtime control","cockpit.pause.pause":"Pause","cockpit.pause.resume":"Resume","cockpit.pause.pending":"Control request pending","cockpit.pause.unavailable":"This action is not supported right now.","cockpit.pause.note":"Pause and resume use existing platform semantics; application success is not runtime confirmation.","cockpit.pause.running":"Running","cockpit.pause.paused":"Paused","cockpit.pause.unknown":"Runtime state unknown","cockpit.change_log.title":"Activity history","cockpit.change_log.empty":"No activity recorded.","cockpit.change_log.unavailable":"Activity history is unavailable.","cockpit.change_log.load_failed":"Activity history could not be read.","cockpit.change_log.more":"Load more","cockpit.change_log.actor":"Actor {value}","cockpit.change_log.subject":"Subject {value}","cockpit.change_log.revision":"Revision {value}","cockpit.change_log.outcome":"Outcome {value}","cockpit.digest.title":"Daily digest delivery","cockpit.digest.accepted":"Accepted for delivery","cockpit.digest.delivered":"Provider accepted delivery","cockpit.digest.failed":"Delivery failed","cockpit.digest.unknown":"Delivery outcome unknown","cockpit.digest.unavailable":"Delivery status unavailable","cockpit.digest.window":"Business day {day} · {zone}","cockpit.digest.targets":"Targets {expected} · covered {covered} · unavailable {unavailable}","cockpit.digest.accepted_at":"Accepted {value}","cockpit.digest.ack":"Recipient acknowledgment","cockpit.digest.ack_unknown":"Unknown","cockpit.digest.ack_at":"Acknowledged {value}","cockpit.digest.legacy":"Only legacy receipts are shown; they do not represent current production delivery.","cockpit.digest.no_data":"No digest delivery record.","cockpit.digest.read_failed":"Digest delivery status could not be read.","cockpit.digest.note":"Accepted is not delivered; delivery is not human acknowledgment.","cockpit.strip.title":"Pending operation","cockpit.strip.unknown":"Outcome unknown; confirmation required","cockpit.strip.view":"View operation","cockpit.strip.ack":"Acknowledge (stays visible)","cockpit.strip.last_read":"Status read {value}","cockpit.strip.note":"Navigation does not hide this operation."},Ki={...$m,...Fm,...Im,...t_,...n_,...i_,...o_,...s_,...f_},Ji={...Wm,...Pm,...e_,...a_,...l_,...c_,...u_,...r_,...d_};for(const o of Object.keys(Ki))if(!(o in Ji))throw new Error(`i18n: missing en translation for ${o}`);for(const o of Object.keys(Ji))if(!(o in Ki))throw new Error(`i18n: missing zh translation for ${o}`);function Jd(o,s,p={}){const r=o==="zh"?Ki:Ji,w=s.startsWith("state.")?"state.unknown_status":s.startsWith("reason.")?"reason.unknown":s.startsWith("research.state.")?"state.unknown_status":null;return(r[s]??(o==="zh"?Ji[s]:Ki[s])??(w?r[w]:s)).replace(/\{(\w+)\}/g,(U,O)=>O in p?String(p[O]):U)}const $d=C.createContext("zh");function Zi({language:o,children:s}){return m.jsx($d.Provider,{value:o,children:s})}function ja(){return C.useContext($d)}function tt(){const o=ja();return(s,p)=>Jd(o,s,p)}const zl={theme:"system",language:"en",upDown:"green-up",hideAmounts:!1,defaultRange:"YTD"},Mt={theme:"qsl-theme-preference",language:"qsl-switch-lang",upDown:"qsl-updown-preference",hideAmounts:"qsl-hide-amounts",defaultRange:"qsl-default-range"};function Tl(o){try{return window.localStorage.getItem(o)}catch{return null}}function El(o,s){try{return window.localStorage.setItem(o,s),window.localStorage.getItem(o)===s}catch{return!1}}function p_(o){return o==="light"||o==="dark"||o==="system"?o:zl.theme}function h_(o){if(o==="zh"||o==="zh-CN")return"zh";if(o==="en")return"en";const s=typeof navigator>"u"?[]:navigator.languages?.length?navigator.languages:[navigator.language];for(const p of s){if(/^zh(?:-|$)/i.test(p))return"zh";if(/^en(?:-|$)/i.test(p))return"en"}return zl.language}function m_(o){return o==="red-up"||o==="green-up"?o:zl.upDown}function __(o){return o==="1M"||o==="3M"||o==="YTD"||o==="1Y"||o==="ALL"?o:zl.defaultRange}function Wd(){return{theme:p_(Tl(Mt.theme)),language:h_(Tl(Mt.language)),upDown:m_(Tl(Mt.upDown)),hideAmounts:Tl(Mt.hideAmounts)==="1",defaultRange:__(Tl(Mt.defaultRange))}}function v_(o){return[El(Mt.theme,o.theme),El(Mt.language,o.language),El(Mt.upDown,o.upDown),El(Mt.hideAmounts,o.hideAmounts?"1":"0"),El(Mt.defaultRange,o.defaultRange)].every(Boolean)}function Fd(o,s){return o==="system"?s?"dark":"light":o}const Pd=C.createContext(null),Id=C.createContext({prefs:zl,persistFailed:!1,resolvedTheme:"light",setPrefs:()=>{}});function zu(){return C.useContext(Id)}const ep=C.createContext({scope:"all",options:[],setScope:()=>{},status:"ready",metaStatus:"ready",retry:()=>{}});function g_(){return C.useContext(ep)}const tp=C.createContext(()=>{});function y_(){return C.useContext(tp)}const b_=["overview","performance","decisions","accounts","strategies","health"],ap="all";function Hd(o){const s=new URLSearchParams(o);let p=s.get("page");const r=s.get("workspace");return!p&&r==="research"&&(p="decisions"),!p&&r==="accounts"&&(p="accounts"),(!p||!b_.includes(p))&&(p="overview"),{page:p,scope:s.get("scope")||ap,account:s.get("account"),tab:s.get("tab")}}function S_(o){const s=new URLSearchParams;o.page!=="overview"&&s.set("page",o.page),o.scope!==ap&&s.set("scope",o.scope),o.account&&s.set("account",o.account),o.tab&&s.set("tab",o.tab);const p=s.toString();return p?`?${p}`:""}function Bd(o){const s=S_(o);window.history.pushState({qsl:o},"",`${window.location.pathname}${s}`)}let np=null;function ov(o){np=o}function wu(){return np}class Ru extends Error{status;constructor(s){super(s===401?"session_expired":"access_denied"),this.status=s}}class lp extends Error{status;payload;constructor(s,p){const r=p?.error;super(r||`http_${s}`),this.status=s,this.payload=p}}let Fi=0,Nu=0;function k_(){return Nu}function Du(){Fi+=1,Nu+=1,window.dispatchEvent(new Event("qsl-private-session-invalid"))}function $i(o){if(o!==Fi)throw new Error("session_invalidated")}async function xe(o){const s=Fi,p=await fetch(o,{method:"GET",credentials:"same-origin",cache:"no-store",headers:{Accept:"application/json"}});if(p.status===401||p.status===403)throw Du(),new Ru(p.status);if($i(s),!p.ok){const w=await p.json().catch(()=>({}));throw new lp(p.status,w)}const r=await p.json();return $i(s),r}async function ip(o,s){const p=Fi,r=await fetch(o,{method:"POST",credentials:"same-origin",cache:"no-store",headers:{Accept:"application/json","Content-Type":"application/json"},body:JSON.stringify(s)});if(r.status===401||r.status===403)throw Du(),new Ru(r.status);$i(p);const w=await r.json().catch(()=>({}));if($i(p),!r.ok||w?.ok===!1)throw new lp(r.status,w);return Nu+=1,w}function Tu(o){return`${o.platform}:${o.account_alias}`}function x_(o,s){if(!s)return;const p=o.find(w=>Tu(w)===s);if(p)return p;const r=o.filter(w=>w.account_alias===s);return r.length===1?r[0]:void 0}function cp(o,s,p){return o?.accountOptions?.[s]?.find(r=>r.key===p)}function Ld(o,s){return cp(o,s.platform,s.account_alias)?.account_selector?.trim()||s.account_alias}function uv(o,s){const p=new Map;for(const r of o){let w=p.get(r.platform);w||p.set(r.platform,w=new Map);const U=Ld(s,r).toUpperCase(),O=w.get(U);O?O.push(r):w.set(U,[r])}return[...p].map(([r,w])=>({platform:r,accounts:[...w.values()].map(z=>({identity:Ld(s,z[0]),rows:z}))}))}function op(o,s){const p=o.indexOf(":");return p>0?{scope:o.slice(p+1),platform:o.slice(0,p)}:{scope:o,platform:s}}const Yd={};function w_(){return xe("/api/session")}let Vi=null,wn=null;const Eu=new Set;function T_(o){return Eu.add(o),()=>{Eu.delete(o)}}function E_(o){const s=Number(o?Yd?.VITE_INBOX_FAILURE_BACKOFF_MS:Yd?.VITE_INBOX_CACHE_MS);return Number.isFinite(s)&&s>=1e3&&s<=3e5?s:o?6e4:15e3}function A_(o=!1){const s=k_();return wn&&wn.revision===s&&Date.now()<wn.until&&(!o||wn.value.status==="read_failed")?Promise.resolve(wn.value):(Vi||(Vi=xe("/api/decisions-inbox").then(p=>{wn={value:p,until:Date.now()+E_(p.status==="read_failed"),revision:s};for(const r of[...Eu])r();return p}).finally(()=>{Vi=null})),Vi)}function sv(o=25,s){const p=new URLSearchParams({limit:String(o)});return s&&p.set("cursor",s),xe(`/api/owner-decisions/history?${p}`)}function z_(){return xe("/api/accounts")}function rv(){return xe("/api/account-facts")}function fv(){return xe("/api/binance-account-facts")}function dv(o,s){const p=new URLSearchParams({account:o});return s&&p.set("platform",s),xe(`/api/account-settings/diff?${p}`)}function pv(o,s,p=25,r){const w=new URLSearchParams({account:o,limit:String(p)});return s&&w.set("platform",s),r&&w.set("cursor",r),xe(`/api/account-settings/history?${w}`)}function hv(o){return ip("/api/account-settings/draft",o)}function mv(o,s){const p=new URLSearchParams({platform:o,key:s});return xe(`/api/account-settings?${p}`)}function _v(){return xe("/api/runtime/today")}function vv(){return xe("/api/strategies/summary")}function gv(o=25,s){const p=new URLSearchParams({limit:String(o)});return xe(`/api/notifications/send-log?${p}`)}function yv(o,s){const p=new URLSearchParams({account:o});return s&&p.set("platform",s),xe(`/api/accounts/run-controls?${p}`)}function Rl(o,s,p){const r=op(o,p),w=new URLSearchParams({scope:r.scope,range:s});return r.platform&&w.set("platform",r.platform),String(w)}function bv(o,s,p){return xe(`/api/performance/summary?${Rl(o,s,p)}`)}function Sv(o,s,p){return xe(`/api/performance/returns?${Rl(o,s,p)}`)}function kv(o,s,p){return xe(`/api/performance/assets?${Rl(o,s,p)}`)}function xv(o,s,p){return xe(`/api/performance/holdings?${Rl(o,s,p)}`)}function wv(o,s,p){return xe(`/api/performance/trades?${Rl(o,s,p)}`)}function Tv(o,s,p,r,w,z){const U=op(o,w),O=new URLSearchParams({scope:U.scope,range:s,year:String(p)});return r!=null&&O.set("month",String(r)),U.platform&&O.set("platform",U.platform),z&&O.set("currency",z),xe(`/api/performance/calendar?${O}`)}async function Ev(){return(await xe("/api/config")).runtimeDailyBindings??[]}function Av(o,s,p,r=!0){const w=new URLSearchParams({date:o});return s&&w.set("platform",s),p&&w.set("account_key",p),r||w.set("include_history","false"),xe(`/api/runtime-daily?${w}`)}function zv(){return xe("/api/credential-maintenance")}async function R_(o,s=fetch){if(!/^[a-f0-9]{64}$/.test(o))return!1;const p=await s("/",{method:"HEAD",cache:"no-store",credentials:"omit"}),r=p.headers.get("X-Console-Build");return p.ok&&/^[a-f0-9]{64}$/.test(r||"")&&r!==o}function N_(){const o=tt(),[s,p]=C.useState(!1);if(C.useEffect(()=>{const w=document.querySelector('meta[name="qsl-console-build"]')?.content||"";let z=!1,U=!1,O=0;const g=async()=>{if(!(document.visibilityState!=="visible"||U||Date.now()-O<6e4)){U=!0,O=Date.now();try{await R_(w)&&!z&&p(!0)}catch{}finally{U=!1}}};return window.addEventListener("focus",g),document.addEventListener("visibilitychange",g),()=>{z=!0,window.removeEventListener("focus",g),document.removeEventListener("visibilitychange",g)}},[]),!s)return null;const r=async()=>{const w=wu();(!w||await w())&&window.location.reload()};return m.jsxs("div",{className:"update-notice",role:"status",children:[m.jsx("span",{children:o("shell.update_available")}),m.jsx("button",{type:"button",className:"button button-secondary",onClick:()=>{r()},children:o("shell.reload")})]})}const Gd=new Map,Wi=new Map;function Mu(o){return o==="zh"?"zh-CN":"en-US"}function Pi(o,s){const p=`${o}:${JSON.stringify(s)}`;let r=Gd.get(p);return r||(r=new Intl.NumberFormat(Mu(o),s),Gd.set(p,r)),r}function D_(o,s,p=2){return o==null||!Number.isFinite(o)?"—":`${o>0?"+":o<0?"-":""}${Pi(s,{minimumFractionDigits:p,maximumFractionDigits:p}).format(Math.abs(o))}%`}function Rv(o,s){return o==null||!Number.isFinite(o)?"—":`${o>0?"+":o<0?"-":""}${Pi(s,{minimumFractionDigits:2,maximumFractionDigits:2}).format(Math.abs(o))} pp`}function M_(o,s,p){if(o==null||!Number.isFinite(o))return"—";const r=Pi(p,{minimumFractionDigits:2,maximumFractionDigits:2}).format(o);return s?`${s} ${r}`:r}const O_=/^-?(?:0|[1-9]\d*)(?:\.\d+)?$/;function U_(o){return typeof o=="number"?Number.isFinite(o)?o<0?"−•••":"•••":"—":typeof o!="string"||!O_.test(o)?"—":o.startsWith("-")&&/[1-9]/.test(o)?"−•••":"•••"}function Nv(o,s){return o==null||!Number.isFinite(o)?"—":Pi(s,{maximumFractionDigits:6}).format(o)}const up=/^\d{4}-\d{2}-\d{2}$/;function sp(o,s){if(!o)return"—";if(up.test(o))return o;const p=Date.parse(o);if(!Number.isFinite(p))return"—";const r=`${s}:date`;let w=Wi.get(r);return w||(w=new Intl.DateTimeFormat(Mu(s),{year:"numeric",month:"2-digit",day:"2-digit"}),Wi.set(r,w)),w.format(new Date(p))}function rp(o,s,p=!1){if(!o)return{text:"—",zone:""};const r=Date.parse(o);if(!Number.isFinite(r))return{text:"—",zone:""};if(up.test(o))return{text:sp(o,s),zone:""};const w=new Date(r),z=`${s}:datetime:${p}`;let U=Wi.get(z);U||(U=new Intl.DateTimeFormat(Mu(s),{year:p?"numeric":void 0,month:"2-digit",day:"2-digit",hour:"2-digit",minute:"2-digit",hour12:!1,timeZoneName:"shortOffset"}),Wi.set(z,U));const O=U.formatToParts(w),g=O.find(N=>N.type==="timeZoneName")?.value||"";return{text:O.filter(N=>N.type!=="timeZoneName").map(N=>N.value).join("").trim(),zone:g}}function Dv(o,s){if(!o)return null;const p=Date.parse(o);if(!Number.isFinite(p))return null;const r=Math.max(0,Math.round((Date.now()-p)/1e3));if(r<60)return s==="zh"?"刚刚":"just now";const w=Math.floor(r/60);if(w<60)return s==="zh"?`${w} 分钟前`:`${w}m ago`;const z=Math.floor(w/60);if(z<48)return s==="zh"?`${z} 小时前`:`${z}h ago`;const U=Math.floor(z/24);return s==="zh"?`${U} 天前`:`${U}d ago`}const Su={account_aliases:{hk:{en:"HK",zh:"香港"},live:{en:"live",zh:"实盘"},paper:{en:"paper",zh:"模拟"},sg:{en:"SG",zh:"新加坡"},soxl:{en:"SOXL",zh:"SOXL"},tqqq:{en:"TQQQ",zh:"TQQQ"}},accounts:{binance:{Binance:{en:"live",zh:"实盘"},binance:{en:"live",zh:"实盘"},crypto_combo:{en:"live",zh:"实盘"},default:{en:"live",zh:"实盘"}}},domains:{cn_equity:{en:"CN A-share",zh:"A股"},crypto:{en:"Crypto",zh:"加密"},hk_equity:{en:"HK Equity",zh:"港股"},us_equity:{en:"US Equity",zh:"美股"}},lanes:{dry_run:{en:"dry run",zh:"演练"},live:{en:"live",zh:"实盘"},paper:{en:"paper",zh:"模拟"},research:{en:"research",zh:"研究"},shadow:{en:"shadow",zh:"影子"}},platforms:{binance:"Binance",firstrade:"Firstrade",ibkr:"IBKR",longbridge:"LongBridge",qmt:"QMT",schwab:"Schwab"},senders:{quant_sentinel:{en:"QuantSentinel",zh:"量化哨兵"}},strategies:{cn_chinext_growth_momentum_quality:{en:"CN ChiNext Growth Momentum Quality",zh:"创业板成长动量质量"},cn_chinext_growth_momentum_quality_snapshot:{en:"CN ChiNext Growth Quality Snapshot",zh:"创业板成长质量快照"},cn_chinext_tactical_rotation:{en:"CN ChiNext Tactical Rotation",zh:"创业板战术轮动"},cn_csi500_multi_factor_snapshot:{en:"CN CSI 500 Multi-Factor Snapshot",zh:"A股中证500多因子"},cn_dividend_quality_snapshot:{en:"CN Dividend Quality",zh:"A股红利质量"},cn_equity_combo:{en:"CN Alpha Combo",zh:"A股进取组合"},cn_index_etf_tactical_rotation:{en:"CN Index ETF Tactical Rotation",zh:"A股宽基ETF战术轮动"},cn_industry_etf_rotation:{en:"CN Industry ETF Rotation",zh:"A股行业ETF轮动"},cn_industry_etf_rotation_aggressive:{en:"CN ETF Rotation",zh:"A股ETF轮动"},cn_star_growth_momentum_quality:{en:"CN STAR Growth Momentum Quality",zh:"科创板成长动量质量"},cn_stock_momentum_rotation:{en:"CN Stock Momentum Rotation",zh:"A股股票动量轮动"},crypto_btc_dca:{en:"BTC DCA",zh:"BTC定投"},crypto_equity_combo:{en:"Crypto Core Combo",zh:"加密动量组合"},crypto_leader_rotation:{en:"Crypto Leader Rotation",zh:"加密领涨轮动"},crypto_live_pool_rotation:{en:"Crypto Pool Rotation",zh:"加密池轮动"},crypto_trend_rotation:{en:"Altcoin Trend",zh:"山寨趋势轮动"},global_etf_confidence_vol_gate:{en:"Global ETF Confidence Vol Gate",zh:"全球 ETF 置信波动门控"},global_etf_rotation:{en:"Global ETF Rotation",zh:"全球ETF轮动"},hk_equity_combo:{en:"HK Core Combo",zh:"港股恒生组合"},hk_global_etf_tactical_rotation:{en:"HK ETF Tactical Rotation",zh:"港股ETF战术轮动"},hk_low_vol_dividend_quality_snapshot:{en:"HK Dividend Quality",zh:"港股红利质量"},ibit_smart_dca:{en:"IBIT Bitcoin DCA",zh:"IBIT比特币定投"},nasdaq_sp500_smart_dca:{en:"NASDAQ/S&P 500 DCA",zh:"纳指标普定投"},qqq_tech_enhancement:{en:"Tech/Communication Pullback Enhancement",zh:"科技通信回调增强"},russell_top50_leader_rotation:{en:"Russell Top50 Leaders",zh:"罗素Top50领涨"},soxl_soxx_core_only_p2_v7_longterm_compounding_cash_reserve:{en:"SOXL/SOXX Core Compounding (Cash Reserve)",zh:"SOXL/SOXX 核心复利（现金保留）"},soxl_soxx_trend_income:{en:"Semiconductor Trend Income",zh:"半导体趋势收益"},tech_communication_pullback_enhancement:{en:"Tech/Communication Pullback Enhancement",zh:"科技通信回调增强"},tecl_xlk_trend_income:{en:"TECL/XLK Trend Income",zh:"TECL/XLK趋势收益"},tqqq_growth_income:{en:"NASDAQ Growth Income",zh:"纳斯达克增长收益"},us_equity_combo:{en:"US Core Income Combo",zh:"美股核心收益组合"},us_equity_combo_core:{en:"US Core Combo",zh:"美股核心组合"},us_equity_combo_leveraged:{en:"US Alpha Combo",zh:"美股加速组合"}},strategy_aliases:{bitcoin_etf_smart_dca:"ibit_smart_dca",global_etf_confidence_vol_gate:"global_etf_rotation",global_macro_etf_rotation:"global_etf_rotation"}},q_={BASE_URL:"/v2/",DEV:!1,MODE:"production",PROD:!0,SSR:!1};let fp={};try{const o=JSON.parse(q_?.VITE_QSL_DISPLAY_NAMES_JSON||"{}");o&&typeof o=="object"&&!Array.isArray(o)&&(fp=o)}catch{}function Al(o,s,p="en",r="",w="",z=fp){const U=z.strategy_aliases?.[s]||Su.strategy_aliases?.[s]||s;for(const O of[z,Su]){const g=o==="accounts"?O[o]?.[String(w).toLowerCase()]:O[o],N=g?.[O===Su&&o==="strategies"?U:s]??(o==="strategies"?g?.[U]:null),L=typeof N=="object"&&N?N[String(p).startsWith("zh")?"zh":"en"]||N.en:N;if(typeof L=="string"&&L.trim())return L.trim()}return r||s||""}const C_={"Global ETF":{en:"Global ETF",zh:"全球ETF"},"Russell Top 50":{en:"Russell Top 50",zh:"罗素Top50"}};function Qd(o,s="en",p){if(!o||p&&p.toLowerCase()!=="ibkr")return null;const r=C_[o.trim()];return r?r[s.startsWith("zh")?"zh":"en"]:null}function j_(o,s,p="en",r=""){return Al("accounts",o||"",p,Al("account_aliases",o||"",p,r||o||""),s||"")}function H_(o,s,p=""){return Al("strategies",o,s,p||(s.startsWith("zh")?"未命名策略":"Unnamed strategy"))}function B_(o,s){return Al("lanes",o,s,s.startsWith("zh")?"未知":"Unknown")}function L_(o,s){return Al("domains",o,s,s.startsWith("zh")?"未知市场":"Unknown market")}function Y_(o){const s=C.useContext(Pd),p=ja(),r=tt(),w=o===void 0?s:o;return{config:w,account:(z,U)=>{if(!z)return r("common.account");const O=U?cp(w,U,z):void 0,g=U?.toLowerCase()==="ibkr"?O?.account_selector?.trim():void 0;if(g&&/^(?:DU|U)\d{5,}$/i.test(g))return g;const k=Qd(O?.label,p,U)||Qd(z,p,U),N=O?.label&&O.label!==z?O.label:z;return k||j_(z,U,p,N)},strategy:z=>{const U=w?.strategyProfiles?.find(O=>O.profile===z);return H_(z,p,p==="zh"?U?.label_zh:U?.label_en)},currentStrategy:z=>w?.currentStrategies?.[z.platform]?.[z.account_alias]?.strategy_profile,platform:z=>G_(w?.platformMeta?.[z]?.label,z),lane:z=>B_(z,p),domain:z=>L_(z,p)}}function G_(o,s){return o||s}function Q_({onRetry:o}){const s=tt();return m.jsxs("div",{className:"scope-error",role:"status","aria-live":"polite",style:{display:"flex",alignItems:"center",gap:8,padding:"6px 10px"},children:[m.jsx("span",{className:"scope-panel-text",children:s("shell.scope_meta_error")}),m.jsx("button",{type:"button",className:"button button-secondary button-sm",onClick:o,children:s("common.retry")})]})}function X_(){const o=tt(),s=Y_(),{scope:p,options:r,setScope:w,status:z,metaStatus:U,retry:O}=g_(),[g,k]=C.useState(!1),N=C.useRef(null),L=C.useRef(null),V=C.useRef(null),ve=C.useRef(!1),ie=C.useRef(null),me=o("shell.scope_error"),Se=o("shell.scope_loading"),Ze=K=>{ie.current=K,k(!1)};C.useEffect(()=>{g?V.current?.querySelector(".scope-option, .scope-panel button")?.focus():ve.current&&ie.current!=="outside"&&L.current?.focus(),g||(ie.current=null),ve.current=g},[g]),C.useEffect(()=>{if(!g)return;const K=ge=>{N.current?.contains(ge.target)||Ze("outside")},_e=ge=>{ge.key==="Escape"&&Ze("escape")};return document.addEventListener("pointerdown",K),document.addEventListener("keydown",_e),()=>{document.removeEventListener("pointerdown",K),document.removeEventListener("keydown",_e)}},[g]);const Ne=x_(r.map(K=>({...K,account_alias:K.alias})),p),ce=p==="all"?o("shell.scope_all"):Ne?`${s.platform(Ne.platform)} · ${s.account(Ne.alias,Ne.platform)}`:o("common.unknown"),qe=[...new Set(r.map(K=>K.platform))],$=K=>m.jsxs("button",{type:"button",className:`scope-option${p===Tu({platform:K.platform,account_alias:K.alias})?" active":""}`,onClick:()=>{w(Tu({platform:K.platform,account_alias:K.alias})),Ze("select")},children:[m.jsx("span",{className:"scope-option-label",children:s.account(K.alias,K.platform)}),K.paper===!0&&m.jsx("span",{className:"badge badge-accent",children:o("common.paper_badge")})]},`${K.platform}:${K.alias}`);return m.jsxs("div",{className:"scope-switcher",ref:N,children:[m.jsx("button",{ref:L,type:"button",className:"button button-secondary button-sm scope-trigger","aria-haspopup":"listbox","aria-expanded":g,"aria-label":o("shell.scope"),onClick:()=>k(K=>!K),children:m.jsxs("span",{className:"scope-trigger-label",children:[z==="error"?me:ce," ▾"]})}),g&&m.jsxs("div",{className:"scope-panel",ref:V,role:"listbox","aria-label":o("shell.scope"),children:[z!=="ready"&&m.jsxs("div",{className:"scope-error",role:"status","aria-live":"polite",style:{display:"flex",alignItems:"center",gap:8,padding:"6px 10px"},children:[m.jsx("span",{className:"scope-panel-text",children:z==="error"?me:Se}),z==="error"&&m.jsx("button",{type:"button",className:"button button-secondary button-sm",onClick:O,children:o("common.retry")})]}),z==="ready"&&U==="error"&&m.jsx(Q_,{onRetry:O}),m.jsx("button",{type:"button",className:`scope-option${p==="all"?" active":""}`,onClick:()=>{w("all"),Ze("select")},children:o("shell.scope_all")}),qe.map(K=>m.jsxs("div",{children:[m.jsx("div",{className:"scope-group",children:s.platform(K)}),r.filter(_e=>_e.platform===K).map($)]},K))]})]})}const dp=["1M","3M","YTD","1Y","ALL"];function Mv({value:o,onChange:s,returns:p}){const r=tt(),w=p?.[o]??null;return m.jsx("div",{className:"segmented",role:"group","aria-label":r("perf.range.label"),children:dp.map(z=>m.jsxs("button",{type:"button",className:`segment${z===o?" active":""}`,"aria-pressed":z===o,onClick:()=>s(z),children:[m.jsx("span",{children:r(`perf.range.${z}`)}),z===o&&w&&m.jsx("span",{className:"segment-sub",children:w})]},z))})}function Z_({onClose:o}){const s=tt(),{prefs:p,setPrefs:r,persistFailed:w}=zu(),z=C.useRef(null);C.useEffect(()=>{const g=document.activeElement instanceof HTMLElement?document.activeElement:null,k=g?.closest("details"),N=k&&!k.open?k.querySelector("summary"):g;return z.current?.querySelector("button")?.focus(),()=>{N instanceof HTMLElement&&N.isConnected&&N.focus()}},[]);const U=g=>{if(g.key==="Escape"){g.preventDefault(),o();return}if(g.key!=="Tab")return;const k=z.current?.querySelectorAll('button:not(:disabled), input:not(:disabled), [tabindex]:not([tabindex="-1"])');if(!k?.length)return;const N=k[0],L=k[k.length-1];g.shiftKey&&document.activeElement===N?(g.preventDefault(),L.focus()):!g.shiftKey&&document.activeElement===L&&(g.preventDefault(),N.focus())},O=(g,k)=>r({...p,[g]:k});return m.jsx("div",{className:"dialog-backdrop",onMouseDown:g=>g.target===g.currentTarget&&o(),children:m.jsxs("div",{className:"dialog",role:"dialog","aria-modal":"true","aria-labelledby":"prefs-title",ref:z,onKeyDown:U,children:[m.jsx("h2",{id:"prefs-title",children:s("prefs.title")}),m.jsxs("div",{className:"prefs-grid",children:[m.jsxs("div",{className:"prefs-row",children:[m.jsx("span",{children:s("prefs.theme")}),m.jsx("div",{className:"segmented",role:"group","aria-label":s("prefs.theme"),children:["light","dark","system"].map(g=>m.jsx("button",{type:"button",className:`segment${p.theme===g?" active":""}`,onClick:()=>O("theme",g),children:s(`prefs.theme_${g}`)},g))})]}),m.jsxs("div",{className:"prefs-row",children:[m.jsx("span",{children:s("prefs.language")}),m.jsx("div",{className:"segmented",role:"group","aria-label":s("prefs.language"),children:["zh","en"].map(g=>m.jsx("button",{type:"button",className:`segment${p.language===g?" active":""}`,onClick:()=>O("language",g),children:g==="zh"?"中文":"English"},g))})]}),m.jsxs("div",{className:"prefs-row",children:[m.jsx("span",{children:s("prefs.updown")}),m.jsx("div",{className:"segmented",role:"group","aria-label":s("prefs.updown"),children:["green-up","red-up"].map(g=>m.jsx("button",{type:"button",className:`segment${p.upDown===g?" active":""}`,onClick:()=>O("upDown",g),children:s(g==="green-up"?"prefs.updown_green_up":"prefs.updown_red_up")},g))})]}),m.jsxs("div",{className:"prefs-row",children:[m.jsx("span",{children:s("prefs.hide_amounts")}),m.jsx("input",{type:"checkbox",checked:p.hideAmounts,onChange:g=>O("hideAmounts",g.target.checked),"aria-label":s("prefs.hide_amounts")})]}),m.jsxs("div",{className:"prefs-row",children:[m.jsx("span",{children:s("prefs.default_range")}),m.jsx("div",{className:"segmented",role:"group","aria-label":s("prefs.default_range"),children:dp.map(g=>m.jsx("button",{type:"button",className:`segment${p.defaultRange===g?" active":""}`,onClick:()=>O("defaultRange",g),children:s(`perf.range.${g}`)},g))})]})]}),m.jsx("p",{className:"card-note",children:s("prefs.note")}),w&&m.jsx("p",{className:"card-note",role:"status",children:s("prefs.save_error")}),m.jsx("div",{className:"dialog-actions",children:m.jsx("button",{type:"button",className:"button button-primary",onClick:o,children:s("common.close")})})]})})}const ku=[{id:"overview",labelKey:"nav.overview",icon:"M3 12 L12 4 L21 12 M6 10 V20 H18 V10"},{id:"decisions",labelKey:"nav.decisions",icon:"M4 6 H20 M4 12 H20 M4 18 H14"},{id:"strategies",labelKey:"nav.strategies",icon:"M5 5 H19 V19 H5 Z M5 10 H19 M10 10 V19"},{id:"accounts",labelKey:"nav.accounts",icon:"M12 12 m-4 0 a4 4 0 1 0 8 0 a4 4 0 1 0 -8 0 M4 20 c0-4 4-6 8-6 s8 2 8 6"},{id:"performance",labelKey:"nav.performance",icon:"M4 18 L10 10 L14 13 L20 5"},{id:"health",labelKey:"nav.health",icon:"M3 12 H7 L10 5 L14 19 L17 12 H21"}],V_=["overview","decisions"],Xd=["strategies","accounts","performance","health"];function xu({path:o}){return m.jsx("svg",{width:"18",height:"18",viewBox:"0 0 24 24",fill:"none",stroke:"currentColor",strokeWidth:"1.8",strokeLinecap:"round",strokeLinejoin:"round","aria-hidden":"true",children:m.jsx("path",{d:o})})}function K_({page:o,todoCount:s,todoStatus:p="ok",synthetic:r,login:w,updatedAt:z,onLogout:U,children:O}){const g=tt(),k=ja(),N=y_(),{prefs:L,setPrefs:V,resolvedTheme:ve}=zu(),ie=ve==="dark",[me,Se]=C.useState(!1),[Ze,Ne]=C.useState(!1),ce=C.useRef(null),qe=C.useRef(null),$=C.useRef(!1);C.useEffect(()=>{ce.current&&(ce.current.open=!1),Se(!1)},[o]),C.useEffect(()=>{$.current&&!me&&qe.current?.focus(),$.current=me},[me]),C.useEffect(()=>{const le=we=>{const at=ce.current;at?.open&&!at.contains(we.target)&&(at.open=!1)},Ae=we=>{we.key==="Escape"&&(ce.current&&(ce.current.open=!1),Se(!1))};return document.addEventListener("pointerdown",le),document.addEventListener("keydown",Ae),()=>{document.removeEventListener("pointerdown",le),document.removeEventListener("keydown",Ae)}},[]);const K=s!==null&&s>0?m.jsx("span",{className:"nav-badge",children:s}):null,_e=p==="read_failed",ge=z?rp(z,k):null,Ce=(le,Ae="")=>m.jsxs("button",{type:"button",className:`${Ae}${o===le.id?" active":""}`,"aria-label":le.id==="decisions"&&_e?`${g(le.labelKey)} · ${g("nav.todo_unavailable")}`:g(le.labelKey),"aria-current":o===le.id?"page":void 0,onClick:()=>N({page:le.id,account:null,tab:null}),children:[m.jsx(xu,{path:le.icon}),m.jsx("span",{className:Ae==="topnav-item"?"topnav-label":"nav-text",children:g(le.labelKey)}),le.id==="decisions"&&(K||_e&&m.jsx("span",{className:"nav-badge nav-badge-unknown","aria-hidden":"true",children:"?"}))]},le.id);return m.jsxs("div",{className:"shell",children:[m.jsx("a",{className:"skip-link",href:"#main-content",children:g("shell.skip_to_content")}),m.jsxs("div",{className:"shell-main",children:[m.jsxs("header",{className:"topbar",children:[m.jsxs("button",{type:"button",className:"brand","aria-label":g("app.name"),onClick:()=>N({page:"overview",account:null,tab:null}),children:[m.jsx("img",{src:"/v2/assets/qsl-brand-icon.svg",alt:"",width:28,height:28}),m.jsxs("span",{className:"brand-copy",children:[m.jsx("span",{className:"brand-name",children:g("app.name")}),m.jsx("span",{className:"brand-subtitle",children:g("shell.cockpit")})]})]}),m.jsx("nav",{className:"topnav","aria-label":g("nav.main"),children:ku.map(le=>Ce(le,"topnav-item"))}),m.jsx("span",{className:"spacer"}),o!=="health"&&m.jsx(X_,{}),ge&&m.jsx("span",{className:"topbar-updated",children:g("common.updated_at",{value:`${ge.text}${ge.zone?` (${ge.zone})`:""}`})}),m.jsxs("button",{type:"button",className:"button button-secondary button-sm appearance-toggle lang-toggle","aria-label":g("prefs.language"),title:g("prefs.language"),onClick:()=>V({...L,language:k==="zh"?"en":"zh"}),children:[m.jsx("span",{className:"lang-label lang-label-full",children:k==="zh"?"English":"中文"}),m.jsx("span",{className:"lang-label lang-label-short","aria-hidden":"true",children:k==="zh"?"EN":"中"})]}),m.jsxs("button",{type:"button",className:"button button-secondary button-sm appearance-toggle","aria-label":g(ie?"shell.switch_light":"shell.switch_dark"),title:g(ie?"shell.switch_light":"shell.switch_dark"),onClick:()=>V({...L,theme:ie?"light":"dark"}),children:[m.jsx("span",{"aria-hidden":"true",children:ie?"☀":"☾"}),m.jsx("span",{className:"theme-toggle-label",children:g(ie?"prefs.theme_light":"prefs.theme_dark")})]}),r&&m.jsx("span",{className:"topbar-synthetic",children:m.jsx("span",{className:"badge badge-accent",children:g("common.synthetic_badge")})}),m.jsx("button",{type:"button",className:"icon-button","aria-pressed":L.hideAmounts,"aria-label":g(L.hideAmounts?"shell.show_amounts":"shell.hide_amounts"),title:g(L.hideAmounts?"shell.show_amounts":"shell.hide_amounts"),onClick:()=>V({...L,hideAmounts:!L.hideAmounts}),children:m.jsx("svg",{width:"18",height:"18",viewBox:"0 0 24 24",fill:"none",stroke:"currentColor",strokeWidth:"1.8",strokeLinecap:"round",strokeLinejoin:"round","aria-hidden":"true",children:L.hideAmounts?m.jsx("path",{d:"M3 3 L21 21 M10 5.5 C11.5 5 13 5 14 5.5 C18 7 21 12 21 12 C20 14 18.5 15.8 16.5 17 M6.5 6.8 C4 8.7 3 12 3 12 C3 12 6 18 12 18 C13 18 14 17.8 14.8 17.5"}):m.jsxs(m.Fragment,{children:[m.jsx("path",{d:"M2 12 C2 12 5.5 5 12 5 C18.5 5 22 12 22 12 C22 12 18.5 19 12 19 C5.5 19 2 12 2 12 Z"}),m.jsx("circle",{cx:"12",cy:"12",r:"3"})]})})}),m.jsxs("details",{className:"user-menu",ref:ce,children:[m.jsx("summary",{"aria-label":g("shell.user_menu"),children:(w||"U").slice(0,1).toUpperCase()}),m.jsxs("div",{className:"user-menu-panel",children:[m.jsx("strong",{className:"user-menu-name",children:w||"—"}),m.jsx("button",{type:"button",className:"menu-item",onClick:()=>{Ne(!0),ce.current&&(ce.current.open=!1)},children:g("shell.preferences")}),m.jsx("button",{type:"button",className:"menu-item",onClick:U,children:g("shell.logout")})]})]})]}),m.jsx(N_,{}),m.jsx("main",{className:"content",id:"main-content",children:O},o)]}),m.jsx("nav",{className:"bottom-tabs","aria-label":g("nav.main"),children:m.jsxs("div",{className:"bottom-tabs-inner",children:[V_.map(le=>Ce(ku.find(Ae=>Ae.id===le),"bottom-tab")),m.jsxs("button",{type:"button",ref:qe,className:`bottom-tab${me||Xd.includes(o)?" active":""}`,"aria-expanded":me,"aria-controls":"more-sheet","aria-label":g("nav.more"),onClick:()=>Se(le=>!le),children:[m.jsx(xu,{path:"M5 12 m-1.5 0 a1.5 1.5 0 1 0 3 0 a1.5 1.5 0 1 0 -3 0 M12 12 m-1.5 0 a1.5 1.5 0 1 0 3 0 a1.5 1.5 0 1 0 -3 0 M19 12 m-1.5 0 a1.5 1.5 0 1 0 3 0 a1.5 1.5 0 1 0 -3 0"}),m.jsx("span",{className:"nav-text",children:g("nav.more")})]})]})}),me&&m.jsxs("div",{className:"more-sheet",id:"more-sheet",role:"menu",children:[Xd.map(le=>Ce(ku.find(Ae=>Ae.id===le),"nav-item")),m.jsxs("button",{type:"button",className:"nav-item",onClick:()=>{Ne(!0),Se(!1)},children:[m.jsx(xu,{path:"M12 15 m-3 0 a3 3 0 1 0 6 0 a3 3 0 1 0 -6 0 M19 12 a7 7 0 0 0-.1-1.2 l2-1.5 -2-3.4 -2.3 1 a7 7 0 0 0-2-1.2 L14.2 3 H9.8 L9.4 5.7 a7 7 0 0 0-2 1.2 l-2.3-1 -2 3.4 2 1.5 A7 7 0 0 0 5 12"}),m.jsx("span",{className:"nav-text",children:g("shell.preferences")})]})]}),Ze&&m.jsx(Z_,{onClose:()=>Ne(!1)})]})}const pp=C.createContext(()=>{});function Ov(){return C.useContext(pp)}function J_({children:o}){const s=tt(),[p,r]=C.useState([]),w=C.useRef(1),z=C.useCallback(O=>{const g=w.current++;r(k=>[...k.slice(-3),{...O,id:g}]),window.setTimeout(()=>r(k=>k.filter(N=>N.id!==g)),6e3)},[]),U=O=>r(g=>g.filter(k=>k.id!==O));return m.jsxs(pp.Provider,{value:z,children:[o,m.jsx("div",{className:"toast-stack",role:"status","aria-live":"polite",children:p.map(O=>m.jsxs("div",{className:`toast ${O.kind==="info"?"":O.kind}`,children:[m.jsx("span",{style:{flex:1},children:O.text}),m.jsx("button",{type:"button",onClick:()=>U(O.id),"aria-label":s("common.close"),children:"✕"})]},O.id))})]})}function Ou({tone:o,size:s=10}){return o==="ok"?m.jsx("svg",{width:s,height:s,viewBox:"0 0 10 10","aria-hidden":"true",children:m.jsx("path",{d:"M1.5 5.5 L4 8 L8.5 2",fill:"none",stroke:"currentColor",strokeWidth:"1.6",strokeLinecap:"round",strokeLinejoin:"round"})}):o==="warn"?m.jsxs("svg",{width:s,height:s,viewBox:"0 0 10 10","aria-hidden":"true",children:[m.jsx("path",{d:"M5 1 L9.5 9 H0.5 Z",fill:"none",stroke:"currentColor",strokeWidth:"1.2",strokeLinejoin:"round"}),m.jsx("line",{x1:"5",y1:"4",x2:"5",y2:"6.4",stroke:"currentColor",strokeWidth:"1.2",strokeLinecap:"round"}),m.jsx("circle",{cx:"5",cy:"7.8",r:"0.7",fill:"currentColor"})]}):o==="error"?m.jsxs("svg",{width:s,height:s,viewBox:"0 0 10 10","aria-hidden":"true",children:[m.jsx("circle",{cx:"5",cy:"5",r:"4",fill:"none",stroke:"currentColor",strokeWidth:"1.2"}),m.jsx("path",{d:"M3.2 3.2 L6.8 6.8 M6.8 3.2 L3.2 6.8",stroke:"currentColor",strokeWidth:"1.2",strokeLinecap:"round"})]}):m.jsx("svg",{width:s,height:s,viewBox:"0 0 10 10","aria-hidden":"true",children:m.jsx("circle",{cx:"5",cy:"5",r:"4",fill:"none",stroke:"currentColor",strokeWidth:"1.2",strokeDasharray:"2 1.4"})})}function $_({tone:o,children:s,title:p}){return m.jsxs("span",{className:`badge badge-${o}`,title:p,children:[o!=="accent"&&m.jsx(Ou,{tone:o}),s]})}const W_={healthy:"ok",review:"warn",watch:"warn",critical:"error",fresh:"ok",blocked:"error",failed:"error",read_incomplete:"error",insufficient:"warn",previewed:"unknown",no_signal:"ok",ok:"ok",partial:"warn",stale:"warn",no_data:"unknown",not_connected:"unknown",unavailable:"unknown",read_failed:"error"};function F_(o){return W_[o||""]||"unknown"}function Uv({status:o,reason:s}){const p=tt(),r=o||"unknown",w=`state.${r}`,z=s?`reason.${s}`:null,U=z?p(z):void 0;return m.jsx("span",{"data-status":r,"data-reason":s??void 0,children:m.jsx($_,{tone:F_(r),title:U,children:p(w)})})}function qv({value:o,prefix:s="common.as_of"}){const p=tt(),r=ja();if(!o)return m.jsx("span",{className:"asof",children:p(s,{value:p("common.na")})});const{text:w,zone:z}=rp(o,r);return m.jsx("span",{className:"asof",children:p(s,{value:z?`${w} (${z})`:w})})}function Cv({value:o}){const s=ja();return m.jsx("span",{className:"account-row-value",children:sp(o,s)})}function jv({value:o,currency:s,signed:p=!1}){const r=ja(),{prefs:w}=zu();if(o==null||!Number.isFinite(o))return m.jsx("span",{className:"money flat",children:"—"});if(w.hideAmounts)return m.jsx("span",{className:"money",children:U_(o)});const z=M_(p?Math.abs(o):o,s,r),U=p?o>0?"+":o<0?"-":"":"",O=!p||o===0?"flat":o>0?"up":"down";return m.jsxs("span",{className:`money ${O}`,children:[U,z]})}function Hv({value:o,digits:s=2}){if(o==null||!Number.isFinite(o))return m.jsx("span",{className:"percent flat",children:"—"});const p=ja(),r=o===0?"flat":o>0?"up":"down";return m.jsx("span",{className:`percent ${r}`,children:D_(o,p,s)})}function Zd({height:o=16,width:s="100%"}){return m.jsx("div",{className:"skeleton",style:{height:o,width:s},"aria-hidden":"true"})}function Bv({title:o,body:s,action:p,state:r="no_data"}){return m.jsxs("div",{className:"empty-state","data-state":r,children:[m.jsx("span",{className:"state-icon","aria-hidden":"true",children:m.jsx(Ou,{tone:"unknown",size:14})}),m.jsxs("div",{className:"state-copy",children:[m.jsx("div",{className:"empty-title",children:o}),s&&m.jsx("p",{className:"state-short",children:s})]}),p&&m.jsx("div",{className:"state-action",children:p})]})}function Lv({onRetry:o}){const s=tt();return m.jsxs("div",{className:"error-state",role:"alert","data-state":"read_failed",children:[m.jsx("span",{className:"state-icon state-icon-error","aria-hidden":"true",children:m.jsx(Ou,{tone:"error",size:14})}),m.jsx("div",{className:"state-copy",children:m.jsx("div",{className:"error-title",children:s("state.load_failed")})}),o&&m.jsx("div",{className:"state-action",children:m.jsx("button",{type:"button",className:"button button-secondary button-sm",onClick:o,children:s("common.retry")})})]})}function Yv({titleKey:o,bodyKey:s}){const p=tt();return m.jsxs("details",{className:"method-note",children:[m.jsx("summary",{children:p(o)}),m.jsx("p",{className:"card-note",children:p(s)})]})}class P_ extends C.Component{state={failed:!1};static getDerivedStateFromError(){return{failed:!0}}reload=()=>{location.reload()};render(){return this.state.failed?m.jsxs("div",{className:"page-load-error",role:"alert",children:[m.jsx("p",{children:this.props.title}),m.jsx("button",{className:"button button-primary",type:"button",onClick:this.reload,children:this.props.action})]}):this.props.children}}function I_({children:o}){const s=tt();return m.jsx(P_,{title:s("common.page_load_failed"),action:s("shell.reload"),children:o})}const ev=C.lazy(()=>Tn(()=>import("./OverviewPage-CGYvI0GD.js"),__vite__mapDeps([0,1,2,3,4,5,6,7,8,9,10]))),tv=C.lazy(()=>Tn(()=>import("./PerformancePage-B3t2Ex7X.js"),__vite__mapDeps([11,4,9,2,3,12,13,14]))),av=C.lazy(()=>Tn(()=>import("./DecisionsPage-SP8nEoQr.js"),__vite__mapDeps([15,1,16,8,6,7,4,13,17]))),nv=C.lazy(()=>Tn(()=>import("./AccountsPage-BFP5IP6M.js"),__vite__mapDeps([18,19,4,6,7,16,8,13,20]))),lv=C.lazy(()=>Tn(()=>import("./StrategiesPage-DUHVXLhP.js"),__vite__mapDeps([21,19,6,7,4,13,22]))),iv=C.lazy(()=>Tn(()=>import("./HealthPage-BqIJ5fp5.js"),__vite__mapDeps([23,6,7,5,4,8,9,12,24])));function Vd({kind:o,noAccess:s,onRetry:p}){const r=tt(),w=o==="denied";return m.jsxs("main",{className:"access-screen",children:[m.jsx("img",{src:"/v2/assets/qsl-brand-icon.svg",alt:"",width:48,height:48}),m.jsx("h1",{children:r(w?s?"auth.denied_title":"auth.login_title":"auth.error_title")}),m.jsx("p",{children:r(w?s?"auth.denied_body":"auth.login_body":"auth.error_body")}),w?s?null:m.jsx("a",{className:"button button-primary",href:"/login",children:r("auth.login")}):m.jsx("button",{className:"button button-primary",type:"button",onClick:p,children:r("common.retry")})]})}function cv(){const[o,s]=C.useState(Wd),[p,r]=C.useState(()=>window.matchMedia?.("(prefers-color-scheme: dark)").matches??!1),[w,z]=C.useState("loading"),[U,O]=C.useState(null),[g,k]=C.useState(()=>Hd(window.location.search)),[N,L]=C.useState(null),[V,ve]=C.useState([]),[ie,me]=C.useState("loading"),[Se,Ze]=C.useState(0),[Ne,ce]=C.useState("ready"),[qe,$]=C.useState(!1),[K,_e]=C.useState(null),[ge,Ce]=C.useState("loading"),[le,Ae]=C.useState(null),[we,at]=C.useState(0),nt=C.useRef(g);nt.current=g;const je=C.useCallback(x=>{s(x),$(!v_(x))},[]),T=C.useCallback(()=>Ze(x=>x+1),[]),q=Fd(o.theme,p);C.useEffect(()=>{document.documentElement.dataset.theme=q},[q]),C.useEffect(()=>{document.documentElement.dataset.updown=o.upDown},[o.upDown]),C.useEffect(()=>{document.documentElement.lang=o.language==="zh"?"zh-CN":"en"},[o.language]),C.useEffect(()=>{const x=window.matchMedia?.("(prefers-color-scheme: dark)");if(!x)return;const D=M=>r(M.matches);return x.addEventListener?.("change",D),()=>x.removeEventListener?.("change",D)},[]),C.useEffect(()=>{let x=!1;return(async()=>{try{const D=await w_();if(x)return;if(!D.authenticated||!D.allowed){O(D),z("denied");return}O(D),z("ready")}catch(D){if(x)return;D instanceof Ru&&D.status===401?z("denied"):z(M=>M==="ready"?M:"error")}})(),()=>{x=!0}},[we]),C.useEffect(()=>{if(w!=="ready")return;let x=!1;const D=()=>{A_().then(j=>{if(x)return;const W=j.status==="read_failed";Ce(W?"read_failed":"ok"),_e(W?null:j.items.filter(Z=>Z.status==="pending").length)}).catch(()=>{x||(Ce("read_failed"),_e(null))})};Ce("loading"),_e(null),D();const M=T_(D);return()=>{x=!0,M()}},[w]),C.useEffect(()=>{if(w!=="ready")return;let x=!1;return me("loading"),(async()=>{try{const D=await z_();if(x)return;let M=null;try{M=await xe("/api/config")}catch{}if(x)return;L(M),ce(M?"ready":"error"),ve(D.accounts.map(j=>({alias:j.account_alias,platform:j.platform,paper:M?M.accountOptions?.[j.platform]?.find(W=>W.key===j.account_alias)?.broker_environment==="paper":null}))),Ae(new Date().toISOString()),me("ready")}catch{x||me("error")}})(),()=>{x=!0}},[w,Se]),C.useEffect(()=>{const x=()=>{O(null),z("denied")};return window.addEventListener("qsl-private-session-invalid",x),()=>window.removeEventListener("qsl-private-session-invalid",x)},[]);const Y=C.useCallback(x=>{const D={...nt.current,...x},M=()=>{k(D),Bd(D)},j=wu();if(j&&(D.page!==nt.current.page||D.account!==nt.current.account)){j().then(W=>{W&&M()});return}M()},[]);C.useEffect(()=>{const x=()=>{const D=Hd(window.location.search),M=wu();if(M){M().then(j=>{j?k(D):Bd(nt.current)});return}k(D)};return window.addEventListener("popstate",x),()=>window.removeEventListener("popstate",x)},[]);const oe=async()=>{Du();try{await ip("/api/logout",{})}catch{}window.location.assign("/login")};if(C.useEffect(()=>{document.title=`${Jd(o.language,`nav.${g.page}`)} · QuantStrategyLab`},[o.language,g.page]),w==="loading")return m.jsx(Zi,{language:o.language,children:m.jsx("main",{className:"boot-screen",role:"status","aria-live":"polite",children:m.jsx(Zd,{height:24,width:200})})});if(w==="denied")return m.jsx(Zi,{language:o.language,children:m.jsx(Vd,{kind:"denied",noAccess:U?.authenticated===!0&&!U.allowed})});if(w==="error")return m.jsx(Zi,{language:o.language,children:m.jsx(Vd,{kind:"error",onRetry:()=>at(x=>x+1)})});const d={scope:g.scope,options:V,setScope:x=>Y({scope:x}),status:ie,metaStatus:Ne,retry:T};return m.jsx(Zi,{language:o.language,children:m.jsx(Id.Provider,{value:{prefs:o,setPrefs:je,resolvedTheme:q,persistFailed:qe},children:m.jsx(Pd.Provider,{value:N,children:m.jsx(ep.Provider,{value:d,children:m.jsx(tp.Provider,{value:Y,children:m.jsx(J_,{children:m.jsx(K_,{page:g.page,todoCount:K,todoStatus:ge,synthetic:U?.synthetic===!0,login:U?.login||null,updatedAt:le,onLogout:()=>{oe()},children:m.jsx(I_,{children:m.jsxs(C.Suspense,{fallback:m.jsx(Zd,{height:240}),children:[g.page==="overview"&&m.jsx(ev,{}),g.page==="performance"&&m.jsx(tv,{}),g.page==="decisions"&&m.jsx(av,{}),g.page==="accounts"&&m.jsx(nv,{account:g.account,tab:g.tab}),g.page==="strategies"&&m.jsx(lv,{}),g.page==="health"&&m.jsx(iv,{})]})},g.page)})})})})})})})}const hp=Wd();document.documentElement.dataset.theme=Fd(hp.theme,window.matchMedia?.("(prefers-color-scheme: dark)").matches??!1);document.documentElement.lang=hp.language==="zh"?"zh-CN":"en";const Kd=document.getElementById("root");Kd&&Vm.createRoot(Kd).render(m.jsx(cv,{}));export{x_ as $,qv as A,$_ as B,Al as C,Ov as D,Lv as E,xe as F,w_ as G,Dv as H,sv as I,ip as J,Ru as K,lp as L,jv as M,uv as N,Cv as O,Hv as P,Tu as Q,Mv as R,Uv as S,H_ as T,dv as U,mv as V,hv as W,yv as X,pv as Y,ov as Z,cp as _,g_ as a,z_ as a0,rv as a1,fv as a2,vv as a3,Av as a4,zv as a5,gv as a6,Ev as a7,y_ as b,Bv as c,A_ as d,kv as e,bv as f,Zd as g,_v as h,Sv as i,m as j,ja as k,Tv as l,rp as m,sp as n,Rv as o,Y_ as p,Yv as q,C as r,zu as s,D_ as t,tt as u,U_ as v,xv as w,wv as x,Nv as y,M_ as z};
" },
   "/v2/assets/runtime_daily_contract-xW43mZQY.js": { contentType: "text/javascript; charset=utf-8", base64: "Y29uc3Qgcz0iQW1lcmljYS9OZXdfWW9yayI7ZnVuY3Rpb24gdShlPURhdGUubm93KCkpe3JldHVybiBuZXcgSW50bC5EYXRlVGltZUZvcm1hdCgiZW4tQ0EiLHt0aW1lWm9uZTpzLHllYXI6Im51bWVyaWMiLG1vbnRoOiIyLWRpZ2l0IixkYXk6IjItZGlnaXQifSkuZm9ybWF0KGUpfWNvbnN0IGQ9T2JqZWN0LmZyZWV6ZSh7cGxhdGZvcm06ImxvbmdicmlkZ2UiLHNlcnZpY2U6ImxvbmdicmlkZ2UtcXVhbnQtcGFwZXItc2VydmljZSIsc3RyYXRlZ3lfcHJvZmlsZToicnVzc2VsbF90b3A1MF9sZWFkZXJfcm90YXRpb24iLGFjY291bnRfc2NvcGU6InBhcGVyIix0YXJnZXRfa2V5OiJsb25nYnJpZGdlLXF1YW50LXBhcGVyLXNlcnZpY2V8cnVzc2VsbF90b3A1MF9sZWFkZXJfcm90YXRpb258cGFwZXIifSksYz1bIm5vX3N1Ym1pc3Npb24iLCJub19zaWduYWwiLCJub19yZWJhbGFuY2UiLCJmaWxsZWQiXSxhPVsiZmFpbGVkIiwiYmxvY2tlZCIsImVycm9yIl0sbD1bInVua25vd24iLCJyZWNvbmNpbGlhdGlvbl9yZXF1aXJlZCIsInN1Ym1pdHRlZCIsImJyb2tlcl9hY2tub3dsZWRnZWQiLCJwYXJ0aWFsbHlfZmlsbGVkIiwiY29uZmxpY3QiLCJpbnN1ZmZpY2llbnQiXTtmdW5jdGlvbiBfKGUpe2NvbnN0IHI9ZT8uZXZpZGVuY2UsaT1yP3IuZXJyb3JzX3ByZXNlbnQ6ZT8uZXJyb3JzX3ByZXNlbnQsbj1bZT8uYWN0aXZpdHksZT8ucmVwb3J0X3N0YXR1cyxyPy5leGVjdXRpb25fc3RhdHVzLHI/LnJlY2VpcHRfb3V0Y29tZV07aWYoZT8uaXNzdWU9PT0iZmFpbHVyZSIpcmV0dXJuImZhaWx1cmUiO2lmKHImJk9iamVjdC5wcm90b3R5cGUuaGFzT3duUHJvcGVydHkuY2FsbChyLCJyZWNlaXB0X3N0YXRlIikpe2NvbnN0IHQ9Wy4uLm4sci5yZWNlaXB0X2Jyb2tlcl9jb25maXJtYXRpb25dO2lmKGk9PT0hMHx8dC5zb21lKG89PlsiZmFpbGVkIiwiZmFpbHVyZSIsImVycm9yIiwiYmxvY2tlZCIsInJpc2tfYmxvY2tlZCIsImNhbmNlbGxlZCIsImNhbmNlbGVkIiwidGltZWRfb3V0Il0uaW5jbHVkZXMobykpKXJldHVybiJmYWlsdXJlIjtpZihyLnJlY2VpcHRfc3RhdGUhPT0idmFsaWQifHx0LnNvbWUobz0+WyJwZW5kaW5nX3JlY29uY2lsaWF0aW9uIiwicmVjb25jaWxpYXRpb25fcmVxdWlyZWQiLCJ1bmtub3duIiwidW5rbm93bl9vcmRlciJdLmluY2x1ZGVzKG8pKSlyZXR1cm4idW5jb25maXJtZWQifXJldHVybiBpPT09ITB8fG4uc29tZSh0PT5hLmluY2x1ZGVzKHQpKT8iZmFpbHVyZSI6ZT8uaXNzdWU9PT0idW5jb25maXJtZWQifHxpIT09ITF8fCFjLmluY2x1ZGVzKGU/LmFjdGl2aXR5KXx8bi5zbGljZSgxKS5zb21lKHQ9PmwuaW5jbHVkZXModCkpfHwocj8ub3JkZXJzX3BlbmRpbmdfY291bnR8fDApPjA/InVuY29uZmlybWVkIjpudWxsfWV4cG9ydHtkIGFzIFIsXyBhcyBhLHUgYXMgcn07Cg==" },
-  "/v2/assets/status-B_UXUo8G.js": { contentType: "text/javascript; charset=utf-8", base64: "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" },
+  "/v2/assets/status-DxL8ZWrC.js": { contentType: "text/javascript; charset=utf-8", base64: "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" },
   "/v2/assets/qsl-brand-icon.svg": { contentType: "image/svg+xml", base64: "PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCA2NCA2NCI+CiAgPHJlY3Qgd2lkdGg9IjY0IiBoZWlnaHQ9IjY0IiByeD0iMTQiIGZpbGw9IiMyNTYzRUIiLz4KICA8cGF0aCBkPSJNMTQgNDIgTDI2IDMwIEwzNCAzNiBMNTAgMjAiIGZpbGw9Im5vbmUiIHN0cm9rZT0iI0ZGRkZGRiIgc3Ryb2tlLXdpZHRoPSI1IiBzdHJva2UtbGluZWNhcD0icm91bmQiIHN0cm9rZS1saW5lam9pbj0icm91bmQiLz4KICA8Y2lyY2xlIGN4PSI1MCIgY3k9IjIwIiByPSI0IiBmaWxsPSIjRkZGRkZGIi8+CiAgPHBhdGggZD0iTTE0IDUwIEg1MCIgc3Ryb2tlPSIjOTNDNUZEIiBzdHJva2Utd2lkdGg9IjQiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIvPgo8L3N2Zz4K" },
 });