ompchamber 3.4.0 → 3.6.0

package/src/client/hooks/ui/updates/index.ts

@@ -0,0 +1,178 @@
+/**
+ * Live update state: the check that reports what is available, and the apply
+ * that runs it.
+ *
+ * The apply is a POST whose response is an SSE stream, not a JSON body. An
+ * `omp update` or an OMPChamber install runs for minutes; a buffered response
+ * left the console with a spinner and nothing else until it finished, and
+ * discarded the command output the server had already collected. Every frame
+ * the stream carries is folded into `progress`, which survives the modal being
+ * closed — the hook lives on the sidebar, so leaving the dialog no longer hides
+ * the run.
+ */
+
+import { useCallback, useEffect, useRef, useState } from 'preact/hooks';
+import { readSseStream } from '@/shared/lib/chat/read-sse';
+import { appendUpdateLog, type UpdateLogState } from '@/shared/lib/updates/progress';
+import type { UpdateApplyResult, UpdateCheckResult, UpdateTarget } from '@/shared/types/updates';
+
+export interface UseUpdatesResult {
+  info: UpdateCheckResult | null;
+  checking: boolean;
+  applying: UpdateTarget | null;
+  /** Log of the run in flight (or the last one), null before any apply. */
+  progress: UpdateLogState | null;
+  error: string | null;
+  hasUpdate: boolean;
+  check: () => Promise<void>;
+  apply: (target: UpdateTarget) => Promise<UpdateApplyResult | null>;
+}
+
+function responseMessage(payload: unknown, fallback: string): string {
+  if (typeof payload !== 'object' || payload === null) return fallback;
+
+  if ('error' in payload && typeof payload.error === 'string') return payload.error;
+  if ('message' in payload && typeof payload.message === 'string') return payload.message;
+  return fallback;
+}
+
+export function isUpdateApplyResult(payload: unknown): payload is UpdateApplyResult {
+  if (typeof payload !== 'object' || payload === null) return false;
+
+  return (
+    'success' in payload && typeof payload.success === 'boolean' &&
+    'target' in payload && (payload.target === 'ompchamber' || payload.target === 'omp') &&
+    'manual' in payload && typeof payload.manual === 'boolean' &&
+    'message' in payload && typeof payload.message === 'string'
+  );
+}
+
+export function useUpdates(): UseUpdatesResult {
+  const [info, setInfo] = useState<UpdateCheckResult | null>(null);
+  const [checking, setChecking] = useState(false);
+  const [applying, setApplying] = useState<UpdateTarget | null>(null);
+  const [progress, setProgress] = useState<UpdateLogState | null>(null);
+  const [error, setError] = useState<string | null>(null);
+  const inFlightCheckRef = useRef<Promise<void> | null>(null);
+  const didAutoCheckRef = useRef(false);
+  const applyAbortRef = useRef<AbortController | null>(null);
+
+  const check = useCallback(() => {
+    if (inFlightCheckRef.current) return inFlightCheckRef.current;
+
+    const request = (async () => {
+      setChecking(true);
+      setError(null);
+
+      try {
+        const response = await fetch('/api/updates/check');
+        const payload: unknown = await response.json();
+        if (!response.ok) {
+          throw new Error(responseMessage(payload, `Update check failed (HTTP ${response.status})`));
+        }
+        setInfo(payload as UpdateCheckResult);
+      } catch (cause) {
+        setError(cause instanceof Error ? cause.message : 'Unable to check for updates.');
+      } finally {
+        setChecking(false);
+        inFlightCheckRef.current = null;
+      }
+    })();
+
+    inFlightCheckRef.current = request;
+    return request;
+  }, []);
+
+  const apply = useCallback(async (target: UpdateTarget): Promise<UpdateApplyResult | null> => {
+    setApplying(target);
+    setProgress({ lines: [], pending: '', truncated: false });
+    setError(null);
+
+    const controller = new AbortController();
+    applyAbortRef.current = controller;
+    // The fold is mirrored in a local so each frame is one setState, rather
+    // than a read-modify-write against the previous render's state.
+    let log: UpdateLogState = { lines: [], pending: '', truncated: false };
+    let result: UpdateApplyResult | null = null;
+
+    try {
+      const response = await fetch('/api/updates/apply', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', Accept: 'text/event-stream' },
+        body: JSON.stringify({ target }),
+        signal: controller.signal,
+      });
+
+      if (!response.ok && !(response.headers.get('content-type') ?? '').includes('text/event-stream')) {
+        const payload: unknown = await response.json().catch(() => null);
+        const message = responseMessage(payload, `Update failed (HTTP ${response.status})`);
+        // 409 is the server saying another run holds the slot. That is a state,
+        // not a failure of this request, so it is reported by toast alone: an
+        // error state would replace the update rows with a block the user
+        // cannot act on, and its Retry only re-checks.
+        if (response.status === 409) return { success: false, target, manual: false, message };
+        throw new Error(message);
+      }
+
+      await readSseStream(
+        response,
+        (event, data) => {
+          if (event === 'line') {
+            log = appendUpdateLog(log, JSON.parse(data) as string);
+            setProgress(log);
+            return;
+          }
+          if (event === 'stage') {
+            // A stage is its own line: the updater's heading and the output
+            // under it must not be glued into one line.
+            log = appendUpdateLog(log, `${JSON.parse(data) as string}\n`);
+            setProgress(log);
+            return;
+          }
+          if (event === 'result') {
+            const payload: unknown = JSON.parse(data);
+            if (isUpdateApplyResult(payload)) result = payload;
+          }
+        },
+        controller.signal,
+      );
+
+      if (!controller.signal.aborted) await check();
+      return result;
+    } catch (cause) {
+      if (controller.signal.aborted) return null;
+      const message = cause instanceof Error ? cause.message : 'Unable to apply the update.';
+      setError(message);
+      // Returned rather than swallowed: the caller's toast is the only surface
+      // the user sees, and a generic "could not be completed" would hide a
+      // refusal the server explained — an update already running, in the case
+      // that matters most, because a reload has just erased this panel's own
+      // record that one was.
+      return { success: false, target, manual: false, message };
+    } finally {
+      if (applyAbortRef.current === controller) {
+        applyAbortRef.current = null;
+        setApplying(null);
+      }
+    }
+  }, [check]);
+
+  useEffect(() => {
+    if (didAutoCheckRef.current) return;
+    didAutoCheckRef.current = true;
+    void check();
+  }, [check]);
+
+  useEffect(() => () => applyAbortRef.current?.abort(), []);
+
+  return {
+    info,
+    checking,
+    applying,
+    progress,
+    error,
+    hasUpdate: Boolean(info?.ompchamber.updateAvailable || info?.omp.updateAvailable),
+    check,
+    apply,
+  };
+}

package/src/client/hooks/workspace/session-delete.ts

@@ -0,0 +1,94 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Session deletion, shared by the desktop session row and the mobile one.
+ *
+ * Both sidebars render the same confirmation dialog and issue the same request,
+ * so the state machine (which row is pending, in-flight, why it was refused)
+ * lives here rather than in two components that would drift on the URL, the
+ * verb, or the event they dispatch afterwards.
+ *
+ * Two follow-ups are load-bearing and both happen only on success:
+ *
+ *   - `omp:workspace-updated` refreshes the sidebar list. The deleted row is
+ *     gone from disk, but the client still holds the previous snapshot.
+ *   - when the deleted session is the one on screen, `?sessionId=` is dropped.
+ *     Leaving the URL pointing at a removed session renders the chat's "not
+ *     found" state over a row the user just deleted, and every panel keyed to
+ *     that id keeps fetching for it.
+ */
+
+import { useCallback, useState } from 'preact/hooks';
+import { useSearchParams } from '@/client/lib/router/search-params';
+import { forgetSession } from '@/shared/lib/workspace/session-state/store';
+import type { SessionItemData } from '@/shared/types';
+
+export interface SessionDeleteActions {
+  /** The session awaiting confirmation, or null when the dialog is closed. */
+  pending: SessionItemData | null;
+  /** True while the DELETE request is in flight. */
+  isDeleting: boolean;
+  /** The server's refusal reason, shown inside the dialog. */
+  error: string | null;
+  /** Open the confirmation for this session. */
+  requestDelete: (session: SessionItemData) => void;
+  /** Close it without deleting. */
+  cancelDelete: () => void;
+  /** Issue the delete. Resolves once the request settled. */
+  confirmDelete: () => Promise<void>;
+}
+
+export function useSessionDelete(): SessionDeleteActions {
+  const [pending, setPending] = useState<SessionItemData | null>(null);
+  const [isDeleting, setIsDeleting] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const [searchParams, setSearchParams] = useSearchParams();
+
+  const requestDelete = useCallback((session: SessionItemData) => {
+    setError(null);
+    setPending(session);
+  }, []);
+
+  const cancelDelete = useCallback(() => {
+    setError(null);
+    setPending(null);
+  }, []);
+
+  const confirmDelete = useCallback(async () => {
+    if (!pending || isDeleting) return;
+    const sessionId = String(pending.id);
+    setIsDeleting(true);
+    setError(null);
+    try {
+      const res = await fetch(`/api/sessions/${encodeURIComponent(sessionId)}`, { method: 'DELETE' });
+      const body = (await res.json().catch(() => null)) as { error?: string } | null;
+      if (!res.ok) {
+        // The refusal reasons the server gives (mid-run, pending chat) are
+        // actionable, so they stay on screen instead of closing the dialog.
+        setError(body?.error || `Could not delete the session (HTTP ${res.status}).`);
+        return;
+      }
+      forgetSession(sessionId);
+      if (searchParams.get('sessionId') === sessionId) {
+        setSearchParams((prev) => {
+          const next = new URLSearchParams(prev);
+          next.delete('sessionId');
+          // A subagent transcript belongs to the session being removed.
+          next.delete('subagent');
+          return next;
+        }, { replace: true });
+      }
+      setPending(null);
+      window.dispatchEvent(new CustomEvent('omp:workspace-updated'));
+    } catch (err) {
+      setError(err instanceof Error ? err.message : 'Could not reach the server.');
+    } finally {
+      setIsDeleting(false);
+    }
+  }, [pending, isDeleting, searchParams, setSearchParams]);
+
+  return { pending, isDeleting, error, requestDelete, cancelDelete, confirmDelete };
+}

package/src/server/db.server.ts

@@ -7,7 +7,9 @@
  * Database lifecycle for OMPChamber: resolve the SQLite path, open the
  * `bun:sqlite` client once, bootstrap the schema, and seed demo data in mock
  * mode. The DDL lives in `./db/schema`, the mock presets in `./db/seed` and
- * the workspace discovery sync in `./db/workspace-sync`.
+ * the workspace discovery sync in `./db/workspace-sync`. The one-time overlay
+ * rewrite is NOT here: it is a server-lifecycle concern (`compact-chat-overlay`)
+ * and runs from the server bootstrap, so opening a handle can never trigger it.
  */
 
 import path from 'path';
@@ -21,10 +23,33 @@ import { isMockMode } from '@/server/mock.server';
 import { pathExists } from '@/server/lib/omp/core/paths';
 import { migrateLegacyProjectSettings } from '@/shared/lib/workspace/project-settings-migration';
 
-let dbPromise: Promise<DbClient> | null = null;
-/** Resolved handle cached by getDb(); promise callbacks never run sync, so
- *  hot paths unwrap through `getDbSync` instead of awaiting. */
-let dbResolved: DbClient | null = null;
+/**
+ * The handle and its promise live on `globalThis`, not in module bindings.
+ *
+ * `bun run --hot` re-evaluates this module on every server-file edit while the
+ * process lives on, so a module-level cache is reset each time and the previous
+ * `Database` is dropped without ever being closed: measured on Bun 1.4.2 /
+ * macOS, each reload of this file left two more descriptors behind (`db.sqlite`
+ * and `db.sqlite-wal`), which is 2 per edit toward the 10,240-descriptor point
+ * where every `Bun.spawn` in the process starts failing with `EBADF`. The slot
+ * keeps ONE handle per process — the same reason the terminal registry, the
+ * flock host and the provider cache are anchored here.
+ */
+interface DbSlot {
+  /** In-flight open, so concurrent `getDb()` callers share one handle. */
+  promise: Promise<DbClient> | null;
+  /** Resolved handle for `getDbSync`; hot paths must not await. */
+  resolved: DbClient | null;
+}
+
+declare global {
+  // eslint-disable-next-line no-var
+  var __ompChamberDb: DbSlot | undefined;
+}
+
+function slot(): DbSlot {
+  return (globalThis.__ompChamberDb ??= { promise: null, resolved: null });
+}
 
 export async function getDatabasePath(): Promise<string> {
   if (isMockMode()) {
@@ -51,9 +76,13 @@ export async function getDatabasePath(): Promise<string> {
 }
 
 export async function getDb(): Promise<DbClient> {
-  if (dbPromise) return dbPromise;
+  const state = slot();
+  if (state.promise) return state.promise;
+  // A reload keeps the previous generation's handle: the schema was already
+  // initialized in this process, and re-opening would leak the old one.
+  if (state.resolved) return state.resolved;
 
-  dbPromise = (async () => {
+  state.promise = (async () => {
     const dbPath = await getDatabasePath();
     const db = createDb(dbPath);
 
@@ -72,11 +101,11 @@ export async function getDb(): Promise<DbClient> {
 
     await migrateLegacyProjectSettings(db);
 
-    dbResolved = db;
+    state.resolved = db;
     return db;
   })();
 
-  return dbPromise;
+  return state.promise;
 }
 
 /**
@@ -86,6 +115,7 @@ export async function getDb(): Promise<DbClient> {
  * use `getDb()`.
  */
 export function getDbSync(): DbClient {
-  if (!dbResolved) throw new Error('Database not initialized — call getDb() first');
-  return dbResolved;
+  const resolved = slot().resolved;
+  if (!resolved) throw new Error('Database not initialized — call getDb() first');
+  return resolved;
 }

package/src/server/index.ts

@@ -4,7 +4,8 @@ import shell from '@/../index.html';
 import { apiRoutes } from '@/server/routes';
 import { ssrRoutes } from '@/server/plugins/ssr';
 import { setListener } from '@/server/lib/lifecycle/listener';
-import { getDatabasePath } from '@/server/db.server';
+import { getDatabasePath, getDb } from '@/server/db.server';
+import { compactChatOverlayRows } from '@/server/lib/db/compact-chat-overlay';
 import { fetchOmpRegistrySnapshot } from '@/server/lib/models/provider-registry.server';
 import { ompStartupError, ompStartupLogLines } from '@/server/lib/omp/core/startup';
 import { readInstanceRecord, removeInstanceRecord, writeInstanceRecord } from '@/server/lib/lifecycle/instance';
@@ -106,6 +107,21 @@ await logDetectedRegistry();
 
 console.log(`[ompchamber] listening on http://${host}:${port}`);
 
+/**
+ * One-time rewrite of the overlay rows written before `overlayRowsForOmpSession`
+ * existed — see the module. Deliberately HERE, after the banner, and NOT inside
+ * `getDb()`: the test suite and the CLI reach `getDb()` in real mode too, and
+ * merely opening the database must not be able to launch a rewrite of every
+ * mirrored conversation. (It could: a `bun test` run compacted a live database.)
+ * The pass is marker-keyed, so from the second start it is one indexed SELECT,
+ * and it reports its own per-row failures rather than throwing.
+ */
+try {
+  await compactChatOverlayRows(await getDb());
+} catch (error) {
+  console.error('[chat-overlay] compaction skipped:', error);
+}
+
 /**
  * What omp reports it can actually run. A live RPC round-trip: a cold utility
  * process takes seconds, which is why it runs after the listener is up. Side

package/src/server/lib/btw/purge.server.ts

@@ -0,0 +1,56 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Deleting a session's side questions.
+ *
+ * A side question is keyed to the parent session but stored outside it — rows
+ * in `btw_topics`/`btw_turns`, a live omp child per topic, and a private
+ * transcript directory under `<db dir>/btw/<sessionId>/<topicId>/`. Deleting
+ * the chat session therefore leaves all three behind unless they are purged
+ * with it: orphan turns still readable in the database, and on disk a full
+ * copy of the very transcript the user just deleted.
+ *
+ * Kept out of `service.server.ts` (which owns the interactive topic
+ * operations) so that file's growth stays attributable.
+ */
+
+import path from 'path';
+import { listBtwTopics, deleteBtwTopic } from '@/server/lib/btw/store.server';
+import { forgetBtwRuntime, getBtwRuntime } from '@/server/lib/btw/registry.server';
+import { getBtwRoot, removeBtwWorkspace, resolveBtwWorkspacePaths } from '@/server/lib/btw/session-copy.server';
+import { isSinglePathSegment } from '@/server/lib/fs/path-segment';
+
+/**
+ * Drop every topic of `sessionId`, its child, its rows, and its workspace.
+ *
+ * `sessionId` MUST name one child of the btw root. The last step below removes
+ * `join(getBtwRoot(), sessionId)` unconditionally, and `join(root, '.')` is
+ * `root` itself — so an id of `.` (or any id with a separator) turns this
+ * per-session purge into "delete every session's side questions on disk". The
+ * route validates its id; this check is the independent second gate, because
+ * this function is reachable on its own and its failure mode is other
+ * sessions' data.
+ */
+export async function purgeBtwForSession(sessionId: string): Promise<number> {
+  if (!isSinglePathSegment(sessionId)) return 0;
+
+  const topics = await listBtwTopics(sessionId);
+  for (const topic of topics) {
+    const runtime = getBtwRuntime(topic.id);
+    if (runtime) {
+      // Disposes the child; a running turn is settled as cancelled rather than
+      // left to write into a transcript this purge is about to remove.
+      await runtime.dispose();
+      forgetBtwRuntime(topic.id);
+    }
+    await deleteBtwTopic(topic.id);
+    await removeBtwWorkspace((await resolveBtwWorkspacePaths(sessionId, topic.id)).dir);
+  }
+  // The per-session directory as a whole: a topic whose row is already gone can
+  // still have a workspace (a crash between the two, a manual row delete).
+  await removeBtwWorkspace(path.join(await getBtwRoot(), sessionId));
+  return topics.length;
+}

package/src/server/lib/db/client.ts

@@ -21,10 +21,27 @@ export interface DbClient {
  * reusable, and the app issues thousands of small queries per request cycle
  * (sidebar scans, telemetry probes, file listings).
  */
+/**
+ * How long a blocked write waits for another connection to release the lock.
+ *
+ * The chamber database is shared: a second chamber on another port writes the
+ * same file, the CLI writes it, and a maintenance `VACUUM` takes the exclusive
+ * lock outright. Without this, a write that meets any of them fails on the spot
+ * with `SQLITE_BUSY: database is locked` — which is exactly what a server log
+ * from 2026-09-25 is full of, with no writer at fault.
+ *
+ * Deliberately modest: `bun:sqlite` is synchronous, so this wait blocks the
+ * whole event loop — every request, stream and terminal frame with it. Two
+ * seconds clears every realistic holder (a full `VACUUM` of this database
+ * measured 134 ms) without freezing the app for long when a lock is stuck.
+ */
+const BUSY_TIMEOUT_MS = 2000;
+
 export function createDb(path: string): DbClient {
   const raw = new Database(path, { create: true });
   raw.exec('PRAGMA journal_mode = WAL');
   raw.exec('PRAGMA foreign_keys = ON');
+  raw.exec(`PRAGMA busy_timeout = ${BUSY_TIMEOUT_MS}`);
 
   const stmts = new Map<string, ReturnType<Database['query']>>();
   const prep = (sql: string) => {

package/src/server/lib/db/compact-chat-overlay.test.ts

@@ -0,0 +1,121 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The overlay repair. Its whole risk is asymmetric: narrowing a row it should
+ * not touch DESTROYS a conversation (for a chamber-created session the DB is the
+ * only copy there is), while leaving a row it should narrow merely wastes disk.
+ * So the file-existence gate is the behaviour under test, and it is exercised
+ * against a real temp tree rather than a stub — `findSessionFileById` is the
+ * thing being trusted.
+ *
+ * The pass has no marker on purpose (see the module): the per-row "did the
+ * filter shrink it?" guard is what makes it self-limiting, so a second run must
+ * find nothing left to do.
+ */
+
+import { afterAll, describe, expect, test } from 'bun:test';
+import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { createDb, type DbClient } from '@/server/lib/db/client';
+import { initSchema } from '@/server/lib/db/schema';
+import { compactChatOverlayRows } from '@/server/lib/db/compact-chat-overlay';
+
+const WITH_FILE = '01a0dddd-1111-7222-8333-444455556666';
+const CHAMBER_ONLY = 'new-1700000000000';
+const NOTICE = 'Context window: 1000000 tokens (1% used)';
+
+/** Mirrored shape: the user turn plus assistant rows no reader ever touches. */
+const MIRRORED = [
+  { id: 'msg-1-user', role: 'user', content: 'hello' },
+  { id: 'omp-a1', role: 'ai', content: 'hi there' },
+  { id: 'cmdout-1', role: 'ai', content: '', notice: NOTICE },
+  { id: 'omp-a2', role: 'ai', content: 'more' },
+];
+/** A chamber-created conversation: no session file exists for it. */
+const CHAMBER = [
+  { id: 'msg-9-user', role: 'user', content: 'ask' },
+  { id: 'local-ai', role: 'ai', content: 'answer' },
+];
+
+const cleanup: string[] = [];
+afterAll(() => {
+  for (const target of cleanup) rmSync(target, { recursive: true, force: true });
+});
+
+function tempDir(label: string): string {
+  const dir = join(tmpdir(), `overlay-${label}-${crypto.randomUUID()}`);
+  cleanup.push(dir);
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+/** A sessions root holding exactly one session file, named the way omp names it. */
+function sessionsRoot(): string {
+  const root = tempDir('root');
+  const project = join(root, '--proj--');
+  mkdirSync(project, { recursive: true });
+  writeFileSync(
+    join(project, `2026-01-01T00-00-00-000Z_${WITH_FILE}.jsonl`),
+    `${JSON.stringify({ type: 'session', id: WITH_FILE, timestamp: '2026-01-01T00:00:00.000Z', cwd: '/' })}\n`,
+  );
+  return root;
+}
+
+async function seededDb() {
+  const db = createDb(join(tempDir('db'), 'db.sqlite'));
+  await initSchema(db);
+  const put = (sessionId: string, messages: unknown[]) =>
+    db.run('INSERT OR REPLACE INTO chat_sessions (session_id, title, messages) VALUES (?, ?, ?)', [
+      sessionId,
+      't',
+      JSON.stringify(messages),
+    ]);
+  await put(WITH_FILE, MIRRORED);
+  await put(CHAMBER_ONLY, CHAMBER);
+  return db;
+}
+
+async function storedMessages(db: DbClient, sessionId: string) {
+  const row = (await db.get('SELECT messages FROM chat_sessions WHERE session_id = ?', [sessionId])) as {
+    messages: string;
+  };
+  return JSON.parse(row.messages) as { id: string; role: string }[];
+}
+
+describe('compactChatOverlayRows', () => {
+  test('narrows a mirrored row whose session file exists', async () => {
+    const db = await seededDb();
+    await compactChatOverlayRows(db, sessionsRoot());
+
+    const kept = await storedMessages(db, WITH_FILE);
+    expect(kept.map((m) => m.id)).toEqual(['msg-1-user', 'cmdout-1']);
+  });
+
+  test('leaves a chamber-created row untouched — the DB is its only copy', async () => {
+    const db = await seededDb();
+    await compactChatOverlayRows(db, sessionsRoot());
+
+    expect(await storedMessages(db, CHAMBER_ONLY)).toEqual(CHAMBER);
+  });
+
+  test('finds nothing left to do on a second run', async () => {
+    const db = await seededDb();
+    const root = sessionsRoot();
+    await compactChatOverlayRows(db, root);
+    const once = JSON.stringify({
+      mirrored: await storedMessages(db, WITH_FILE),
+      chamber: await storedMessages(db, CHAMBER_ONLY),
+    });
+
+    await compactChatOverlayRows(db, root);
+
+    expect(
+      JSON.stringify({
+        mirrored: await storedMessages(db, WITH_FILE),
+        chamber: await storedMessages(db, CHAMBER_ONLY),
+      }),
+    ).toBe(once);
+  });
+});