gloomberb 0.10.4 → 0.11.0

package/src/renderers/opentui/host.tsx

@@ -5,9 +5,13 @@ import { resetTerminalInputState } from "../../utils/terminal-input-reset";
 import type { KeyEventLike } from "../../react/input";
 import type { NativeRendererHost, PixelResolution, RendererHost } from "../../ui/host";
 import { colors } from "../../theme/colors";
+import { safeExternalUrl } from "../../utils/external-url";
+import { createTerminalMediaReaper, terminalMediaStateFile } from "./terminal-media";
 
 export { useKeyboard, useTerminalDimensions };
 
+const terminalMedia = createTerminalMediaReaper({ stateFile: terminalMediaStateFile() });
+
 export interface OpenTuiHost {
   renderer: CliRenderer;
   rendererHost: RendererHost;
@@ -95,7 +99,9 @@ export async function createOpenTuiHost(): Promise<OpenTuiHost> {
 
   const rendererHost: RendererHost = {
     requestExit: () => renderer.destroy(),
-    async openExternal(url) {
+    async openExternal(rawUrl) {
+      const url = safeExternalUrl(rawUrl);
+      if (!url) return;
       const command = process.platform === "darwin"
         ? ["open", url]
         : process.platform === "win32"
@@ -137,6 +143,9 @@ export async function createOpenTuiHost(): Promise<OpenTuiHost> {
         throw new Error("mpv is required for terminal TV playback. Install mpv and try again.");
       }
 
+      // A player stranded by a previous run keeps decoding video, so clear it
+      // before adding another one.
+      terminalMedia.reapStale();
       renderer.suspend();
       try {
         const proc = Bun.spawn([
@@ -158,6 +167,7 @@ export async function createOpenTuiHost(): Promise<OpenTuiHost> {
           stdout: "inherit",
           stderr: "pipe",
         });
+        terminalMedia.track(proc);
         const stderrPromise = new Response(proc.stderr).text();
         const exitCode = await proc.exited;
         const stderr = await stderrPromise;
@@ -166,10 +176,14 @@ export async function createOpenTuiHost(): Promise<OpenTuiHost> {
           throw new Error(detail || `mpv exited with status ${exitCode}`);
         }
       } finally {
+        terminalMedia.stopActive();
         renderer.resume();
         renderer.requestRender();
       }
     },
+    stopTerminalMedia() {
+      terminalMedia.stopActive();
+    },
   };
 
   const nativeRenderer: NativeRendererHost = {

package/src/renderers/opentui/terminal-media.test.ts

@@ -0,0 +1,102 @@
+import { afterEach, expect, test } from "bun:test";
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+import { createTerminalMediaReaper, type TerminalMediaChild } from "./terminal-media";
+
+const dirs: string[] = [];
+
+function stateFile(): string {
+  const dir = mkdtempSync(join(tmpdir(), "gloom-media-"));
+  dirs.push(dir);
+  return join(dir, "terminal-media.pid");
+}
+
+function fakeChild(pid: number): TerminalMediaChild & { killed: boolean; exit(): void } {
+  let resolveExit: (code: number) => void = () => {};
+  const exited = new Promise<number>((resolve) => { resolveExit = resolve; });
+  return {
+    pid,
+    killed: false,
+    kill() { this.killed = true; },
+    exited,
+    exit() { resolveExit(0); },
+  };
+}
+
+afterEach(() => {
+  for (const dir of dirs.splice(0)) rmSync(dir, { recursive: true, force: true });
+});
+
+test("kills the player left behind by a run that was killed without warning", () => {
+  const file = stateFile();
+  writeFileSync(file, "4242", "utf8");
+  const killed: number[] = [];
+  const reaper = createTerminalMediaReaper({
+    stateFile: file,
+    isPlayerProcess: (pid) => pid === 4242,
+    killProcess: (pid) => killed.push(pid),
+    installExitHooks: false,
+  });
+
+  reaper.reapStale();
+
+  expect(killed).toEqual([4242]);
+  // The pid must not linger, or a later run kills whatever inherits it.
+  expect(existsSync(file)).toBe(false);
+});
+
+test("leaves a recycled pid alone when it is not our player", () => {
+  const file = stateFile();
+  writeFileSync(file, "4242", "utf8");
+  const killed: number[] = [];
+  const reaper = createTerminalMediaReaper({
+    stateFile: file,
+    isPlayerProcess: () => false,
+    killProcess: (pid) => killed.push(pid),
+    installExitHooks: false,
+  });
+
+  reaper.reapStale();
+
+  expect(killed).toEqual([]);
+});
+
+test("replacing a player kills the previous one and records the new pid", () => {
+  const file = stateFile();
+  const reaper = createTerminalMediaReaper({
+    stateFile: file,
+    isPlayerProcess: () => false,
+    killProcess: () => {},
+    installExitHooks: false,
+  });
+
+  const first = fakeChild(11);
+  const second = fakeChild(22);
+  reaper.track(first);
+  expect(readFileSync(file, "utf8")).toBe("11");
+
+  reaper.track(second);
+
+  expect(first.killed).toBe(true);
+  expect(second.killed).toBe(false);
+  expect(readFileSync(file, "utf8")).toBe("22");
+});
+
+test("a player that exits on its own clears the recorded pid", async () => {
+  const file = stateFile();
+  const reaper = createTerminalMediaReaper({
+    stateFile: file,
+    isPlayerProcess: () => false,
+    killProcess: () => {},
+    installExitHooks: false,
+  });
+
+  const child = fakeChild(33);
+  reaper.track(child);
+  child.exit();
+  await child.exited;
+  await Promise.resolve();
+
+  expect(existsSync(file)).toBe(false);
+});

package/src/renderers/opentui/terminal-media.ts

@@ -0,0 +1,142 @@
+import { homedir } from "os";
+import { join } from "path";
+import { existsSync, readFileSync, rmSync, writeFileSync } from "fs";
+
+/** The subset of `Bun.Subprocess` this module needs, so tests can supply a fake. */
+export interface TerminalMediaChild {
+  readonly pid: number;
+  kill(): void;
+  readonly exited: Promise<number>;
+}
+
+export interface TerminalMediaReaperOptions {
+  /** File holding the pid of the player started by the most recent run. */
+  stateFile: string;
+  /** True when the pid is still running and is actually our media player. */
+  isPlayerProcess?(pid: number): boolean;
+  killProcess?(pid: number): void;
+  /** Install process exit hooks. Off in tests so the suite keeps its handlers. */
+  installExitHooks?: boolean;
+}
+
+export interface TerminalMediaReaper {
+  /** Kill a player left behind by a previous run of the app. */
+  reapStale(): void;
+  /** Adopt a freshly spawned player, replacing and killing any current one. */
+  track(child: TerminalMediaChild): void;
+  /** Kill the player this run started, if it is still going. */
+  stopActive(): void;
+}
+
+export function terminalMediaStateFile(): string {
+  return join(process.env.HOME || homedir(), ".gloomberb", "terminal-media.pid");
+}
+
+function defaultIsPlayerProcess(pid: number): boolean {
+  if (!Number.isInteger(pid) || pid <= 1) return false;
+  try {
+    // A recycled pid could belong to anything, so confirm the command first.
+    const probe = Bun.spawnSync(["ps", "-p", String(pid), "-o", "comm="]);
+    if (probe.exitCode !== 0) return false;
+    return probe.stdout.toString().toLowerCase().includes("mpv");
+  } catch {
+    return false;
+  }
+}
+
+function defaultKillProcess(pid: number): void {
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {
+    // Already gone, or not ours to kill.
+  }
+}
+
+/**
+ * `mpv` outlives the app: it is a plain child process, and `bun run --watch`
+ * restarts by SIGKILLing the parent, so no exit handler ever runs. Every reload
+ * with the TV pane open used to strand another player decoding video forever.
+ *
+ * Recording the pid on disk lets the next run kill the previous player even
+ * though that run was killed without warning.
+ */
+export function createTerminalMediaReaper(options: TerminalMediaReaperOptions): TerminalMediaReaper {
+  const {
+    stateFile,
+    isPlayerProcess = defaultIsPlayerProcess,
+    killProcess = defaultKillProcess,
+    installExitHooks = true,
+  } = options;
+
+  let active: TerminalMediaChild | null = null;
+  let hooksInstalled = false;
+
+  function forgetState(): void {
+    try {
+      rmSync(stateFile, { force: true });
+    } catch {
+      // A stale pid file is harmless; the next reap validates it anyway.
+    }
+  }
+
+  function rememberState(pid: number): void {
+    try {
+      writeFileSync(stateFile, String(pid), "utf8");
+    } catch {
+      // Losing the pid only costs us cross-restart reaping, never correctness.
+    }
+  }
+
+  function stopActive(): void {
+    const child = active;
+    active = null;
+    if (child) {
+      try {
+        child.kill();
+      } catch {
+        // Already exited.
+      }
+    }
+    forgetState();
+  }
+
+  function installExitCleanup(): void {
+    if (hooksInstalled || !installExitHooks) return;
+    hooksInstalled = true;
+    // Covers orderly shutdown. A SIGKILLed parent is handled by reapStale.
+    process.on("exit", stopActive);
+    for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"] as const) {
+      process.on(signal, () => {
+        stopActive();
+        process.exit(0);
+      });
+    }
+  }
+
+  return {
+    reapStale() {
+      if (!existsSync(stateFile)) return;
+      let pid = 0;
+      try {
+        pid = Number.parseInt(readFileSync(stateFile, "utf8").trim(), 10);
+      } catch {
+        pid = 0;
+      }
+      forgetState();
+      if (Number.isFinite(pid) && pid > 0 && isPlayerProcess(pid)) killProcess(pid);
+    },
+    track(child) {
+      stopActive();
+      active = child;
+      rememberState(child.pid);
+      installExitCleanup();
+      void child.exited.then(() => {
+        if (active === child) {
+          active = null;
+          forgetState();
+        }
+      }).catch(() => {});
+    },
+    stopActive,
+  };
+}

package/src/renderers/opentui/test-utils.tsx

@@ -1,5 +1,4 @@
 import { useMemo, type ReactNode } from "react";
-import { DialogProvider } from "@opentui-ui/dialog/react";
 import { testRender as openTuiTestRender } from "@opentui/react/test-utils";
 import { createRoot as openTuiCreateRoot, useRenderer } from "@opentui/react";
 import { UiHostProvider, type NativeRendererHost, type RendererHost } from "../../ui";
@@ -12,7 +11,7 @@ import { openTuiToastHost } from "./toast-host";
 
 export function TestDialogProvider({ children }: { children: ReactNode }) {
   return (
-    <DialogProvider
+    <OpenTuiDialogHostProvider
       dialogOptions={{
         style: {
           backgroundColor: colors.bg,
@@ -22,7 +21,7 @@ export function TestDialogProvider({ children }: { children: ReactNode }) {
       }}
     >
       {children}
-    </DialogProvider>
+    </OpenTuiDialogHostProvider>
   );
 }
 
@@ -55,9 +54,13 @@ function OpenTuiTestProviders({ children }: { children: ReactNode }) {
       <OpenTuiInputHostProvider>
         <ToastHostProvider host={openTuiToastHost}>
           <OpenTuiDialogHostProvider
-            backgroundColor={colors.bg}
-            containerBorderColor={colors.border}
-            focusedBorderColor={colors.borderFocused}
+            dialogOptions={{
+              style: {
+                backgroundColor: colors.bg,
+                borderColor: colors.borderFocused,
+                borderStyle: "single",
+              },
+            }}
           >
             {children}
           </OpenTuiDialogHostProvider>

package/src/renderers/opentui/toast-host.tsx

@@ -1,10 +1,139 @@
-import { Toaster, toast } from "@opentui-ui/toast/react";
-import type { ToastHost } from "../../ui/toast";
+/** @jsxImportSource @opentui/react */
+import { useTerminalDimensions } from "@opentui/react";
+import { useSyncExternalStore } from "react";
+import { colors } from "../../theme/colors";
+import type { ToastHost, ToastOptions } from "../../ui/toast";
+
+type ToastTone = "success" | "error" | "info";
+
+interface ToastRecord {
+  id: number;
+  body: string;
+  tone: ToastTone;
+  options?: ToastOptions;
+}
+
+let nextToastId = 1;
+let toasts: ToastRecord[] = [];
+const listeners = new Set<() => void>();
+const timers = new Map<number, ReturnType<typeof setTimeout>>();
+
+function publish(): void {
+  for (const listener of listeners) listener();
+}
+
+function dismissToast(id: string | number): void {
+  const numericId = typeof id === "number" ? id : Number(id);
+  if (!Number.isFinite(numericId)) return;
+  const timer = timers.get(numericId);
+  if (timer) clearTimeout(timer);
+  timers.delete(numericId);
+  const next = toasts.filter((toast) => toast.id !== numericId);
+  if (next.length === toasts.length) return;
+  toasts = next;
+  publish();
+}
+
+function addToast(tone: ToastTone, body: string, options?: ToastOptions): number {
+  const id = nextToastId++;
+  toasts = [...toasts, { id, body, tone, options }];
+  publish();
+  const duration = options?.duration ?? 4_000;
+  if (Number.isFinite(duration) && duration > 0) {
+    timers.set(id, setTimeout(() => dismissToast(id), duration));
+  }
+  return id;
+}
+
+function subscribe(listener: () => void): () => void {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}
+
+function getSnapshot(): ToastRecord[] {
+  return toasts;
+}
+
+function toneColor(tone: ToastTone): string {
+  if (tone === "success") return colors.positive;
+  if (tone === "error") return colors.negative;
+  return colors.neutral;
+}
+
+function toneIcon(tone: ToastTone): string {
+  if (tone === "success") return "✓";
+  if (tone === "error") return "!";
+  return "i";
+}
+
+function ToastViewport({ position = "bottom-right" }: { position?: string }) {
+  const dimensions = useTerminalDimensions();
+  const visibleToasts = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+  const maxWidth = Math.max(1, Math.min(60, dimensions.width - 4));
+  const placement = position.startsWith("top") ? { top: 1 } : { bottom: 1 };
+  const horizontal = position.endsWith("left")
+    ? { left: 2 }
+    : position.endsWith("center")
+      ? { left: Math.max(0, Math.floor((dimensions.width - maxWidth) / 2)) }
+      : { right: 2 };
+
+  if (visibleToasts.length === 0) return null;
+
+  return (
+    <box
+      position="absolute"
+      {...placement}
+      {...horizontal}
+      width={maxWidth}
+      zIndex={9_900}
+      flexDirection="column"
+      gap={1}
+    >
+      {visibleToasts.slice(-4).map((toast) => (
+        <box
+          key={toast.id}
+          width="100%"
+          border
+          borderStyle="single"
+          borderColor={toneColor(toast.tone)}
+          backgroundColor={colors.panel}
+          paddingX={1}
+          flexDirection="row"
+          gap={1}
+        >
+          <text fg={toneColor(toast.tone)}>{toneIcon(toast.tone)}</text>
+          <text fg={colors.text} flexGrow={1} wrapMode="word">{toast.body}</text>
+          {toast.options?.action && (
+            <text
+              fg={colors.textBright}
+              attributes={1}
+              onMouseDown={(event) => {
+                event.stopPropagation();
+                toast.options?.action?.onClick();
+              }}
+            >
+              {`[${toast.options.action.label}]`}
+            </text>
+          )}
+          <text
+            fg={colors.textMuted}
+            onMouseDown={(event) => {
+              event.stopPropagation();
+              dismissToast(toast.id);
+            }}
+          >
+            ×
+          </text>
+        </box>
+      ))}
+    </box>
+  );
+}
 
 export const openTuiToastHost: ToastHost = {
-  Viewport: Toaster as ToastHost["Viewport"],
-  success: toast.success,
-  error: toast.error,
-  info: toast.info,
-  dismiss: toast.dismiss,
+  Viewport: ToastViewport,
+  success: (body, options) => addToast("success", body, options),
+  error: (body, options) => addToast("error", body, options),
+  info: (body, options) => addToast("info", body, options),
+  dismiss: dismissToast,
 };

package/src/renderers/opentui/ui-host.tsx

@@ -1,6 +1,5 @@
 import { RGBA, StyledText as OpenTuiStyledText, SyntaxStyle, TextAttributes as OpenTuiTextAttributes } from "@opentui/core";
-import { createElement, forwardRef, type ReactNode } from "react";
-import "opentui-spinner/react";
+import { createElement, forwardRef, useEffect, useState, type ReactNode } from "react";
 import { TextAttributes, type UiHost, type TextProps } from "../../ui/host";
 import { renderAsciiText } from "../../ui/ascii-font";
 import { OpenTuiImageSurface } from "./image/surface";
@@ -60,9 +59,26 @@ const OpenTuiBox = createOpenTuiPrimitive("box");
 const OpenTuiScrollBox = createOpenTuiPrimitive("scrollbox");
 const OpenTuiInput = createOpenTuiPrimitive("input");
 const OpenTuiTextarea = createOpenTuiPrimitive("textarea");
-const OpenTuiSpinnerMark = createOpenTuiPrimitive("spinner");
 const OpenTuiMediaSurface = createOpenTuiPrimitive("box");
 
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+
+const OpenTuiSpinnerMark = forwardRef<unknown, OpenTuiPrimitiveProps & { name?: string; color?: string }>(
+  function OpenTuiSpinnerMark({ name: _name, color, ...props }, ref) {
+    const [frame, setFrame] = useState(0);
+    useEffect(() => {
+      const timer = setInterval(() => setFrame((current) => (current + 1) % SPINNER_FRAMES.length), 80);
+      return () => clearInterval(timer);
+    }, []);
+    return createElement("text" as any, {
+      ...props,
+      ref,
+      fg: color,
+      content: SPINNER_FRAMES[frame],
+    });
+  },
+);
+
 const OpenTuiText = forwardRef<unknown, TextProps>(function OpenTuiText({ children, ...props }, ref) {
   const textProps = stripTextProps(props);
   return createElement("text" as any, {

package/src/sources/provider-router/connection-health.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, test } from "bun:test";
+import { ConnectionHealthRegistry } from "../../core/connection-health";
+import type { DataProvider } from "../../types/data-provider";
+import { withProviderConnectionHealth } from "./connection-health";
+
+describe("withProviderConnectionHealth", () => {
+  test("attributes network calls without reporting cached or static checks", async () => {
+    const health = new ConnectionHealthRegistry();
+    health.registerSource({ id: "asset-data.yahoo", name: "Yahoo", kind: "asset-data" });
+    const provider = withProviderConnectionHealth({
+      id: "yahoo",
+      name: "Yahoo",
+      canProvide: () => true,
+      getCachedFinancialsForTargets: () => new Map(),
+      getChartResolutionSupport: () => [],
+      getQuote: async () => ({ price: 1 }),
+    } as unknown as DataProvider, health);
+
+    await provider.canProvide?.("AAPL");
+    provider.getCachedFinancialsForTargets?.([]);
+    await provider.getChartResolutionSupport?.("AAPL");
+    await provider.getQuote("AAPL");
+
+    const state = health.getSnapshot().sources[0]!;
+    expect(state.lastOperation).toBe("getQuote");
+    expect(state.recentRequests).toHaveLength(1);
+  });
+});

package/src/sources/provider-router/connection-health.ts

@@ -0,0 +1,47 @@
+import type { ConnectionHealthRegistry } from "../../core/connection-health";
+import type { DataProvider } from "../../types/data-provider";
+
+const REQUEST_METHODS = new Set([
+  "getQuotesBatch",
+  "getTickerFinancialsBatch",
+  "getTickerFinancials",
+  "getQuote",
+  "getExchangeRate",
+  "search",
+  "getNews",
+  "getHolders",
+  "getAnalystResearch",
+  "getCorporateActions",
+  "getEarningsCalendar",
+  "getSecFilings",
+  "getSecFilingDocuments",
+  "getSecFilingContent",
+  "getArticleSummary",
+  "getPriceHistory",
+  "getPriceHistoryForResolution",
+  "getDetailedPriceHistory",
+  "getOptionsChain",
+]);
+
+/** Wraps provider calls without changing the provider object or treating router cache reads as requests. */
+export function withProviderConnectionHealth(
+  provider: DataProvider,
+  health: ConnectionHealthRegistry,
+): DataProvider {
+  const methods = new Map<PropertyKey, unknown>();
+  return new Proxy(provider, {
+    get(target, property, receiver) {
+      const value = Reflect.get(target, property, receiver);
+      if (typeof property !== "string" || typeof value !== "function") return value;
+      if (!REQUEST_METHODS.has(property)) return value.bind(target);
+      if (!methods.has(property)) {
+        methods.set(property, (...args: unknown[]) => health.track(
+          `asset-data.${provider.id}`,
+          property,
+          () => Promise.resolve(value.apply(target, args)),
+        ));
+      }
+      return methods.get(property);
+    },
+  });
+}

package/src/sources/provider-router/history.test.ts

@@ -283,8 +283,8 @@ describe("AssetDataRouter chart history", () => {
     persistence.close();
   });
 
-  test("refreshes stale cached chart history before falling back to cache", async () => {
-    const dbPath = createTempDbPath("stale-chart-refresh");
+  test("returns stale unexpired chart history immediately and refreshes in the background", async () => {
+    const dbPath = createTempDbPath("stale-chart-hit");
     const persistence = new AppPersistence(dbPath);
 
     const seedRouter = new AssetDataRouter({
@@ -299,19 +299,68 @@ describe("AssetDataRouter chart history", () => {
       .query("UPDATE resource_cache SET stale_at = ? WHERE namespace = ? AND kind = ? AND entity_key = ?")
       .run(Date.now() - 1, "market", "price-history", "AAPL");
 
+    let resolveFresh!: (points: Array<{ date: Date; close: number }>) => void;
+    const freshHistory = new Promise<Array<{ date: Date; close: number }>>((resolve) => {
+      resolveFresh = resolve;
+    });
     let providerCalls = 0;
     const refreshRouter = new AssetDataRouter({
       ...fallbackProvider,
       async getPriceHistory() {
         providerCalls += 1;
-        return [{ date: new Date("2026-03-28T00:00:00Z"), close: 202 }];
+        return freshHistory;
       },
     }, [], persistence.resources);
 
     const history = await refreshRouter.getPriceHistory("AAPL", "NASDAQ", "1Y");
 
+    expect(history[0]?.close).toBe(101);
+    await Promise.resolve();
     expect(providerCalls).toBe(1);
-    expect(history[0]?.close).toBe(202);
+
+    resolveFresh([{ date: new Date("2026-03-28T00:00:00Z"), close: 202 }]);
+    await freshHistory;
+    await new Promise((resolve) => setTimeout(resolve, 20));
+
+    const refreshed = await refreshRouter.getPriceHistory("AAPL", "NASDAQ", "1Y");
+    expect(refreshed[0]?.close).toBe(202);
+
+    persistence.close();
+  });
+
+  test("clips a shorter resolution range from a wider cached series", async () => {
+    const dbPath = createTempDbPath("clip-wider-chart-cache");
+    const persistence = new AppPersistence(dbPath);
+    const now = Date.parse("2026-03-28T00:00:00Z");
+    const sixYearsAgo = new Date(now - 6 * 365 * 24 * 60 * 60_000);
+    const twoYearsAgo = new Date(now - 2 * 365 * 24 * 60 * 60_000);
+    const latest = new Date(now);
+
+    const seedRouter = new AssetDataRouter({
+      ...fallbackProvider,
+      async getPriceHistoryForResolution() {
+        return [
+          { date: sixYearsAgo, close: 50 },
+          { date: twoYearsAgo, close: 101 },
+          { date: latest, close: 110 },
+        ];
+      },
+    }, [], persistence.resources);
+    await seedRouter.getPriceHistoryForResolution("AAPL", "NASDAQ", "ALL", "1wk");
+
+    let providerCalls = 0;
+    const clipRouter = new AssetDataRouter({
+      ...fallbackProvider,
+      async getPriceHistoryForResolution() {
+        providerCalls += 1;
+        return [{ date: latest, close: 999 }];
+      },
+    }, [], persistence.resources);
+
+    const history = await clipRouter.getPriceHistoryForResolution("AAPL", "NASDAQ", "5Y", "1wk");
+
+    expect(providerCalls).toBe(0);
+    expect(history.map((point) => point.close)).toEqual([101, 110]);
 
     persistence.close();
   });