@narumitw/pi-statusline 0.50.4 → 0.51.0

package/src/extension-status-metadata.ts

@@ -0,0 +1,208 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+const UPDATE_CHANNEL = "extension-status:v1:update";
+const REQUEST_CHANNEL = "extension-status:v1:request";
+const ACTIVITIES = new Set([
+  "idle",
+  "checking",
+  "working",
+  "pushing",
+  "pulling",
+  "resolving",
+  "retry",
+  "blocked",
+  "local-change",
+  "remote-change",
+  "review",
+] as const);
+
+export type ExtensionStatusActivity =
+  | "idle"
+  | "checking"
+  | "working"
+  | "pushing"
+  | "pulling"
+  | "resolving"
+  | "retry"
+  | "blocked"
+  | "local-change"
+  | "remote-change"
+  | "review";
+
+export interface ExtensionStatusPresentation {
+  readonly value: string;
+  readonly activity: ExtensionStatusActivity;
+  readonly reason?: string;
+}
+
+export interface ExtensionStatusMetadata {
+  get(key: string, value: string): ExtensionStatusPresentation | undefined;
+  reconcile(statuses: ReadonlyMap<string, string>): void;
+  dispose(): void;
+}
+
+function parseMetadata(data: Record<string, unknown>): {
+  presentation?: ExtensionStatusPresentation;
+  withdrawal: boolean;
+} {
+  if (Array.isArray(data)) return { withdrawal: false };
+  // Capture fields once: accessors and proxy traps can synchronously replace the current state.
+  const { version, value, activity, reason } = data;
+  const hasValue = Object.hasOwn(data, "value");
+  const hasActivity = "activity" in data;
+  const hasReason = "reason" in data;
+  const withdrawal = version === 1 && hasValue && value === undefined && !hasActivity && !hasReason;
+  if (
+    version !== 1 ||
+    !hasValue ||
+    typeof value !== "string" ||
+    value.length === 0 ||
+    !ACTIVITIES.has(activity as ExtensionStatusActivity)
+  )
+    return { withdrawal };
+  if (activity === "retry" || activity === "blocked") {
+    // JavaScript's $ also matches before a final newline; require the complete safe label.
+    if (typeof reason !== "string" || /^[a-z][a-z0-9-]{0,31}$/.exec(reason)?.[0] !== reason) return { withdrawal };
+    return { presentation: Object.freeze({ value, activity, reason }), withdrawal };
+  }
+  if (hasReason) return { withdrawal };
+  return { presentation: Object.freeze({ value, activity: activity as ExtensionStatusActivity }), withdrawal };
+}
+
+/** Optional display metadata; the raw Pi status map remains authoritative. */
+export function subscribeExtensionStatusMetadata(
+  events: ExtensionAPI["events"],
+  sessionManager: object,
+  getStatuses: () => ReadonlyMap<string, string>,
+  requestRender: () => void,
+): ExtensionStatusMetadata {
+  const records = new Map<string, ExtensionStatusPresentation>();
+  const liveKeys = new Set<string>();
+  const requestId = {};
+  let observedStatuses = new Map<string, string>();
+  try {
+    observedStatuses = new Map(getStatuses());
+  } catch {
+    // A raw-map read failure must leave the ordinary footer available.
+  }
+  let disposed = false;
+  let revision = 0;
+  const keyRevisions = new Map<string, number>();
+  const isCurrent = (key: string, owner: number) => !disposed && keyRevisions.get(key) === owner;
+  let unsubscribe: (() => void) | undefined;
+
+  const reconcile = (statuses: ReadonlyMap<string, string>, ownerKey?: string) => {
+    if (disposed) return;
+    const before = revision;
+    const snapshot = new Map(statuses);
+    if (disposed || revision !== before) return;
+    for (const [key, value] of observedStatuses) {
+      if (snapshot.get(key) === value) continue;
+      records.delete(key);
+      // An observed raw replacement must also fence off a delayed same-value snapshot.
+      liveKeys.add(key);
+      if (key !== ownerKey) keyRevisions.set(key, ++revision);
+    }
+    for (const key of snapshot.keys()) {
+      if (observedStatuses.has(key)) continue;
+      liveKeys.add(key);
+      if (key !== ownerKey) keyRevisions.set(key, ++revision);
+    }
+    observedStatuses = snapshot;
+  };
+
+  const metadata: ExtensionStatusMetadata = {
+    get(key, value) {
+      const presentation = records.get(key);
+      return presentation?.value === value ? presentation : undefined;
+    },
+    reconcile(statuses) {
+      reconcile(statuses);
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      revision++;
+      keyRevisions.clear();
+      records.clear();
+      liveKeys.clear();
+      observedStatuses.clear();
+      try {
+        unsubscribe?.();
+      } catch {
+        // Optional metadata cleanup must not prevent footer disposal.
+      }
+      unsubscribe = undefined;
+    },
+  };
+
+  const receive = (payload: unknown) => {
+    if (disposed || !payload || typeof payload !== "object") return;
+    const entered = revision;
+    let key: string;
+    let snapshot: boolean;
+    const data = payload as Record<string, unknown>;
+    try {
+      const rawKey = data.key;
+      const manager = data.sessionManager;
+      snapshot = "requestId" in data;
+      const replyId = snapshot ? data.requestId : undefined;
+      if (disposed || manager !== sessionManager || typeof rawKey !== "string" || !rawKey) return;
+      key = rawKey;
+      if ((keyRevisions.get(key) ?? 0) > entered) return;
+      if (snapshot && (replyId !== requestId || liveKeys.has(key))) return;
+    } catch {
+      return;
+    }
+
+    // Only an accepted envelope for this key can supersede its in-flight update.
+    const owner = ++revision;
+    keyRevisions.set(key, owner);
+    if (!snapshot) liveKeys.add(key);
+    const previous = records.get(key);
+    try {
+      const { presentation, withdrawal } = parseMetadata(data);
+      if (!isCurrent(key, owner)) return;
+      // Read after payload accessors, and copy before touching the cache: either operation can reenter.
+      const reading = revision;
+      const statuses = new Map(getStatuses());
+      if (!isCurrent(key, owner)) return;
+      if (revision !== reading) {
+        // An unstable read must not retain old hidden state or erase a newer sibling record.
+        records.delete(key);
+      } else {
+        reconcile(statuses, key);
+        if (!isCurrent(key, owner) || (snapshot && liveKeys.has(key))) return;
+        if (presentation && statuses.get(key) === presentation.value) {
+          records.set(key, presentation);
+        } else if (!snapshot || withdrawal) {
+          // Invalid live data and explicit withdrawals restore the existing raw-text path.
+          records.delete(key);
+        }
+      }
+    } catch {
+      if (!isCurrent(key, owner)) return;
+      if (!snapshot) records.delete(key);
+    }
+    if (isCurrent(key, owner) && previous !== records.get(key)) {
+      try {
+        requestRender();
+      } catch {
+        // A closed UI must not turn optional metadata delivery into an event-bus error.
+      }
+    }
+  };
+
+  try {
+    unsubscribe = events.on(UPDATE_CHANNEL, receive);
+  } catch {
+    // Metadata support must not prevent the footer from loading.
+    return metadata;
+  }
+  try {
+    events.emit(REQUEST_CHANNEL, { version: 1, sessionManager, requestId });
+  } catch {
+    // Keep the live subscription usable when a snapshot request fails.
+  }
+  return metadata;
+}

package/src/extension-status.ts

@@ -1,7 +1,9 @@
 import { existsSync, readFileSync } from "node:fs";
 import { dirname, isAbsolute, join, resolve } from "node:path";
 import { getAgentDir, type Theme, type ThemeColor } from "@earendil-works/pi-coding-agent";
-import { wrapTextWithAnsi } from "@earendil-works/pi-tui";
+import { truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
+import { sanitizeTerminalText } from "@narumitw/pi-tui-kit/terminal-text";
+import type { ExtensionStatusMetadata, ExtensionStatusPresentation } from "./extension-status-metadata.js";
 import { powerlineExtensionSeparator } from "./powerline.js";
 import { DEFAULT_EXTENSION_STATUS_ICONS } from "./settings.js";
 import type { StatuslineConfig } from "./types.js";
@@ -10,6 +12,7 @@ export type ExtensionStatusIconAliasMap = ReadonlyMap<string, readonly string[]>
 export interface ExtensionStatusRuntime {
   duplicateExtensions: string[];
   extensionStatusIconAliases: ExtensionStatusIconAliasMap;
+  extensionStatusMetadata?: ExtensionStatusMetadata;
 }
 
 const STATUSLINE_KEY = "statusline";
@@ -32,12 +35,19 @@ export function formatExtensionStatuses(
   hiddenKeys: ReadonlySet<string> = new Set(),
   trueColor = true,
 ): string {
+  runtime.extensionStatusMetadata?.reconcile(statuses);
   const separator = extensionStatusSeparator(config, theme, trueColor);
   const visibleStatuses = [
     ...formatDuplicateExtensionStatus(runtime, theme),
     ...[...statuses.entries()]
       .filter(([key, value]) => key !== STATUSLINE_KEY && !hiddenKeys.has(key) && value.trim().length > 0)
-      .map(([key, value]) => formatExtensionStatus(key, value, theme, config, runtime.extensionStatusIconAliases)),
+      .map(([key, value]) => {
+        const presentation = runtime.extensionStatusMetadata?.get(key, value);
+        return presentation
+          ? formatCompactExtensionStatus(key, value, presentation, theme, config, runtime.extensionStatusIconAliases)
+          : formatExtensionStatus(key, value, theme, config, runtime.extensionStatusIconAliases);
+      })
+      .filter((status) => status.length > 0),
   ].slice(0, 5);
 
   return visibleStatuses.join(separator);
@@ -59,6 +69,38 @@ export function formatExtensionStatus(
   return icon ? `${theme.fg(color, icon)} ${renderedText}` : renderedText;
 }
 
+function formatCompactExtensionStatus(
+  key: string,
+  value: string,
+  presentation: ExtensionStatusPresentation,
+  theme: Theme,
+  config: Pick<StatuslineConfig, "extensionStatusIcons">,
+  aliases: ExtensionStatusIconAliasMap,
+): string {
+  if (presentation.activity === "idle") return "";
+  // Only the compact path strips terminal controls; raw statuses retain their existing PR links.
+  const status = splitExtensionStatusIcon(
+    stripExtensionStatusPrefix(sanitizeTerminalText(key), sanitizeTerminalText(value)),
+  );
+  const icon = sanitizeTerminalText(extensionStatusIcon(key, status.icon, config.extensionStatusIcons, aliases));
+  const bodies = {
+    checking: "…",
+    working: "↻",
+    pushing: "↑",
+    pulling: "↓",
+    resolving: "AI",
+    retry: `retry: ${presentation.reason}`,
+    blocked: `! ${presentation.reason}`,
+    "local-change": "⇡",
+    "remote-change": "⇣",
+    review: "⇕",
+  };
+  const warning = presentation.activity === "blocked" || presentation.activity === "retry";
+  const color = warning ? "warning" : extensionColor(key, value);
+  const body = theme.fg(warning ? "warning" : "muted", bodies[presentation.activity]);
+  return icon ? `${theme.fg(color, icon)} ${body}` : body;
+}
+
 function extensionStatusIcon(
   key: string,
   leadingIcon: string | undefined,
@@ -68,14 +110,16 @@ function extensionStatusIcon(
   if (Object.hasOwn(configuredIcons, key)) return configuredIcons[key];
   const namespaceIcon = configuredNamespaceIcon(key, configuredIcons);
   if (namespaceIcon !== undefined) return namespaceIcon;
-  const compatibleKey = COMPATIBLE_STATUS_ICON_KEYS[key];
+  const compatibleKey = Object.hasOwn(COMPATIBLE_STATUS_ICON_KEYS, key) ? COMPATIBLE_STATUS_ICON_KEYS[key] : undefined;
   if (compatibleKey && Object.hasOwn(configuredIcons, compatibleKey)) {
     return configuredIcons[compatibleKey];
   }
   for (const alias of extensionStatusAliasesForKey(key, extensionStatusIconAliases)) {
     if (Object.hasOwn(configuredIcons, alias)) return configuredIcons[alias];
   }
-  return leadingIcon ?? DEFAULT_EXTENSION_STATUS_ICONS[key] ?? "🔌";
+  return (
+    leadingIcon ?? (Object.hasOwn(DEFAULT_EXTENSION_STATUS_ICONS, key) ? DEFAULT_EXTENSION_STATUS_ICONS[key] : "🔌")
+  );
 }
 
 function configuredNamespaceIcon(key: string, configuredIcons: Readonly<Record<string, string>>): string | undefined {
@@ -105,7 +149,9 @@ function statusKeyMatchesStatusBase(key: string, statusBase: string): boolean {
 
 export function wrapExtensionStatusline(status: string, width: number): string[] {
   if (!status || width <= 0) return [];
-  return wrapTextWithAnsi(status, width);
+  return wrapTextWithAnsi(status, width).map((line) =>
+    visibleWidth(line) > width ? truncateToWidth(line, width, "") : line,
+  );
 }
 
 function formatDuplicateExtensionStatus(runtime: ExtensionStatusRuntime, theme: Theme): string[] {

package/src/render.ts

@@ -47,6 +47,7 @@ export function renderStatusline(
 ): string {
   if (width <= 0) return "";
 
+  const inlineStatuses = legacyInlineStatuses(footerData.getExtensionStatuses(), runtime);
   const usageSummary = summarizeFooterUsage(ctx.sessionManager.getEntries());
   const rows: Array<{ configuredSegments: number; segments: RenderSegment[] }> = [
     { configuredSegments: 0, segments: [] },
@@ -60,7 +61,7 @@ export function renderStatusline(
     const row = rows.at(-1);
     if (!row) continue;
     row.configuredSegments += 1;
-    const rendered = buildSegment(name, ctx, footerData, config, runtime, usageSummary);
+    const rendered = buildSegment(name, ctx, footerData, config, runtime, usageSummary, inlineStatuses);
     if (rendered && rendered.text.length > 0) row.segments.push(rendered);
   }
 
@@ -84,7 +85,7 @@ export function renderExtensionStatusline(
   trueColor = true,
 ): string[] {
   const statuses = footerData.getExtensionStatuses();
-  const prContext = prContextFromStatuses(statuses);
+  const prContext = prContextFromStatuses(legacyInlineStatuses(statuses, runtime));
   const rendersPrInline = prContext !== undefined && mainLine.includes(prContext);
   const status = formatExtensionStatuses(
     statuses,
@@ -97,6 +98,16 @@ export function renderExtensionStatusline(
   return wrapExtensionStatusline(status, width);
 }
 
+function legacyInlineStatuses(
+  statuses: ReadonlyMap<string, string>,
+  runtime: ExtensionStatusRuntime,
+): ReadonlyMap<string, string> {
+  const metadata = runtime.extensionStatusMetadata;
+  if (!metadata) return statuses;
+  metadata.reconcile(statuses);
+  return new Map([...statuses].filter(([key, value]) => !metadata.get(key, value)));
+}
+
 function buildSegment(
   name: SegmentName,
   ctx: ExtensionContext,
@@ -104,6 +115,7 @@ function buildSegment(
   config: StatuslineConfig,
   runtime: RuntimeState,
   usageSummary: FooterUsageSummary,
+  inlineStatuses: ReadonlyMap<string, string>,
 ): RenderSegment | undefined {
   switch (name) {
     case "brand":
@@ -124,7 +136,7 @@ function buildSegment(
       return segment(name, runtime.thinkingLevel, config, thinkingColor(runtime.thinkingLevel), "header");
     case "branch": {
       const branch = footerData.getGitBranch();
-      const pr = branch ? prContextFromStatuses(footerData.getExtensionStatuses()) : undefined;
+      const pr = branch ? prContextFromStatuses(inlineStatuses) : undefined;
       return segment(name, formatGitBranchValue(branch, runtime.gitStatus, pr), config, "accent", "git");
     }
     case "cwd":

package/src/statusline.ts

@@ -9,6 +9,7 @@ import {
   findDuplicateExtensions,
   readInstalledExtensionPackages,
 } from "./extension-status.js";
+import { subscribeExtensionStatusMetadata } from "./extension-status-metadata.js";
 import { type GitStatusSummary, gitStatusSummaryEqual, readGitStatus } from "./git-status.js";
 import { type RuntimeState, renderExtensionStatusline, renderStatusline } from "./render.js";
 import {
@@ -42,6 +43,7 @@ export default function statusline(pi: ExtensionAPI) {
   let loaded: LoadedStatuslineSettings | undefined;
   let previewPalettePreset: PalettePreset | undefined;
   let activeSessionManager: ExtensionContext["sessionManager"] | undefined;
+  let disposeFooter: (() => void) | undefined;
   const runtime: RuntimeState = {
     turnCount: 0,
     activeTools: new Map(),
@@ -135,6 +137,7 @@ export default function statusline(pi: ExtensionAPI) {
   };
 
   const installFooter = (ctx: ExtensionContext) => {
+    disposeFooter?.();
     const generation = ++sessionGeneration;
     menuController.abort(new DOMException("Statusline session context replaced", "AbortError"));
     menuController = new AbortController();
@@ -148,47 +151,93 @@ export default function statusline(pi: ExtensionAPI) {
     runtime.gitStatus = undefined;
     runtime.duplicateExtensions = [];
     runtime.extensionStatusIconAliases = EMPTY_EXTENSION_STATUS_ICON_ALIASES;
+    runtime.extensionStatusMetadata = undefined;
+    runtime.requestRender = undefined;
     ctx.ui.setStatus(STATUSLINE_KEY, undefined);
     if (!activeGitStatusTarget || !loaded) return;
     const installedPackages = readInstalledExtensionPackages(cwd);
     runtime.duplicateExtensions = findDuplicateExtensions(installedPackages);
     runtime.extensionStatusIconAliases = buildExtensionStatusIconAliases(installedPackages);
-    ctx.ui.setFooter((tui, theme, footerData) => {
-      runtime.requestRender = () => tui.requestRender();
-
-      const refreshFooterGitStatus = () => refreshGitStatus(cwd, generation);
-      const branchUnsubscribe = footerData.onBranchChange(() => {
-        runtime.gitStatus = undefined;
-        abortGitStatusRefresh("Statusline Git branch changed");
-        clearGitStatusDebounce();
-        refreshFooterGitStatus();
-        tui.requestRender();
-      });
-      const clock = setInterval(() => {
-        clearGitStatusDebounce();
-        refreshFooterGitStatus();
-        tui.requestRender();
-      }, GIT_STATUS_REFRESH_INTERVAL_MS);
-      clock.unref();
+    const sessionManager = ctx.sessionManager;
+    const createFooter: NonNullable<Parameters<ExtensionContext["ui"]["setFooter"]>[0]> = (tui, theme, footerData) => {
+      if (generation !== sessionGeneration || sessionManager !== activeSessionManager) {
+        return { render: () => [], invalidate() {} };
+      }
+      disposeFooter?.();
+      activeGitStatusTarget = { cwd, generation };
+      let disposed = false;
+      let branchUnsubscribe: (() => void) | undefined;
+      let clock: ReturnType<typeof setInterval> | undefined;
+      let metadata: ReturnType<typeof subscribeExtensionStatusMetadata> | undefined;
+      const isCurrentFooter = () =>
+        !disposed && generation === sessionGeneration && sessionManager === activeSessionManager;
+      const dispose = () => {
+        if (disposed) return;
+        disposed = true;
+        try {
+          metadata?.dispose();
+        } finally {
+          try {
+            branchUnsubscribe?.();
+          } finally {
+            if (clock) clearInterval(clock);
+            if (disposeFooter === dispose) {
+              disposeFooter = undefined;
+              runtime.extensionStatusMetadata = undefined;
+              runtime.requestRender = undefined;
+            }
+            if (isActiveGitStatusTarget(cwd, generation)) {
+              activeGitStatusTarget = undefined;
+              abortGitStatusRefresh("Statusline footer disposed");
+              clearGitStatusDebounce();
+              pendingGitStatusRefresh = undefined;
+              runtime.gitStatus = undefined;
+            }
+          }
+        }
+      };
+      disposeFooter = dispose;
+      runtime.requestRender = () => {
+        if (isCurrentFooter()) tui.requestRender();
+      };
+
+      try {
+        const refreshFooterGitStatus = () => refreshGitStatus(cwd, generation);
+        branchUnsubscribe = footerData.onBranchChange(() => {
+          if (!isCurrentFooter()) return;
+          runtime.gitStatus = undefined;
+          abortGitStatusRefresh("Statusline Git branch changed");
+          clearGitStatusDebounce();
+          refreshFooterGitStatus();
+          refresh();
+        });
+        clock = setInterval(() => {
+          if (!isCurrentFooter()) return;
+          clearGitStatusDebounce();
+          refreshFooterGitStatus();
+          refresh();
+        }, GIT_STATUS_REFRESH_INTERVAL_MS);
+        clock.unref();
+        metadata = subscribeExtensionStatusMetadata(
+          pi.events,
+          sessionManager,
+          () => footerData.getExtensionStatuses(),
+          () => {
+            if (isCurrentFooter()) refresh();
+          },
+        );
+        if (isCurrentFooter()) runtime.extensionStatusMetadata = metadata;
+        else metadata.dispose();
+      } catch (error) {
+        dispose();
+        throw error;
+      }
 
       return {
-        dispose() {
-          branchUnsubscribe();
-          clearInterval(clock);
-          if (isActiveGitStatusTarget(cwd, generation)) {
-            activeGitStatusTarget = undefined;
-            abortGitStatusRefresh("Statusline footer disposed");
-            clearGitStatusDebounce();
-            pendingGitStatusRefresh = undefined;
-            runtime.gitStatus = undefined;
-            runtime.duplicateExtensions = [];
-            runtime.extensionStatusIconAliases = EMPTY_EXTENSION_STATUS_ICON_ALIASES;
-            runtime.requestRender = undefined;
-          }
-        },
+        dispose,
         invalidate() {},
         render(width: number): string[] {
-          if (!loaded) return [];
+          if (!isCurrentFooter() || !loaded) return [];
           const config = previewPalettePreset
             ? { ...loaded.config, palettePreset: previewPalettePreset }
             : loaded.config;
@@ -199,7 +248,13 @@ export default function statusline(pi: ExtensionAPI) {
           return lines;
         },
       };
-    });
+    };
+    try {
+      ctx.ui.setFooter(createFooter);
+    } catch (error) {
+      disposeFooter?.();
+      throw error;
+    }
     refreshGitStatus(cwd, generation);
   };
 
@@ -242,14 +297,19 @@ export default function statusline(pi: ExtensionAPI) {
     runtime.activeTools.clear();
     runtime.isStreaming = false;
     runtime.uiPrompt = undefined;
-    loaded = loadStatuslineSettingsForAgent(agentDir);
-    const settingsNotice = consumeStatuslineSettingsNotice();
-    if (settingsNotice) ctx.ui.notify(settingsNotice, "warning");
-    if (loaded.diagnostics.length > 0) {
-      ctx.ui.notify(formatSettingsDiagnostics(loaded), "warning");
+    try {
+      loaded = loadStatuslineSettingsForAgent(agentDir);
+      const settingsNotice = consumeStatuslineSettingsNotice();
+      if (settingsNotice) ctx.ui.notify(settingsNotice, "warning");
+      if (loaded.diagnostics.length > 0) {
+        ctx.ui.notify(formatSettingsDiagnostics(loaded), "warning");
+      }
+      runtime.thinkingLevel = pi.getThinkingLevel();
+      installFooter(ctx);
+    } catch (error) {
+      disposeFooter?.();
+      throw error;
     }
-    runtime.thinkingLevel = pi.getThinkingLevel();
-    installFooter(ctx);
   });
 
   pi.on("session_tree", (_event, ctx) => {
@@ -259,6 +319,7 @@ export default function statusline(pi: ExtensionAPI) {
 
   pi.on("session_shutdown", (_event, ctx) => {
     if (!ownsRuntime(ctx)) return;
+    disposeFooter?.();
     sessionGeneration += 1;
     menuController.abort(new DOMException("Statusline session shut down", "AbortError"));
     activeSessionManager = undefined;
@@ -273,7 +334,7 @@ export default function statusline(pi: ExtensionAPI) {
     runtime.uiPrompt = undefined;
     runtime.duplicateExtensions = [];
     runtime.extensionStatusIconAliases = EMPTY_EXTENSION_STATUS_ICON_ALIASES;
-    ctx.ui.setFooter(undefined);
+    if (ctx.mode === "tui") ctx.ui.setFooter(undefined);
     ctx.ui.setStatus(STATUSLINE_KEY, undefined);
     runtime.requestRender = undefined;
   });