@vellumai/assistant 0.10.4 → 0.10.5-dev.202607022329.d89bf2f

package/src/persistence/conversation-search-lexical.ts

@@ -0,0 +1,49 @@
+/**
+ * Shared lexical candidate helper for message-content search.
+ *
+ * Encodes a free-text query with the local TF-IDF sparse encoder and queries
+ * the BM25-style sparse Qdrant lexical index (`messages_lexical`) for matching
+ * message ids. This is the single entry point the message-search read sites use
+ * when they select the `qdrant` backend, mirroring the
+ * candidate set SQLite FTS5 would return.
+ */
+
+import { generateSparseEmbedding } from "./embeddings/embedding-backend.js";
+import {
+  getMessagesLexicalIndex,
+  type MessageLexicalSearchResult,
+} from "./embeddings/messages-lexical-index.js";
+
+/**
+ * Resolve message-id candidates for `query` from the Qdrant lexical index,
+ * ranked by sparse similarity score (highest first).
+ *
+ * This is a **pure lexical candidate generator**: it returns the top-`limit`
+ * message ids by sparse score with NO visibility, source, or
+ * active-conversation filtering (the only scoping it applies is the optional
+ * `conversationId` restriction). Those exclusions (active conversation,
+ * private conversations, non-message sources) live in SQL at the read sites.
+ *
+ * Callers that apply such post-retrieval SQL filters MUST over-fetch: pass an
+ * inflated `limit` (the `QDRANT_RECALL_CANDIDATE_MULTIPLIER` /
+ * `QDRANT_SEARCH_CANDIDATE_LIMIT` pattern the read sites use) and re-limit
+ * after filtering in SQL. Applying the caller's real limit here first would
+ * let excluded rows consume the candidate slots and drop valid visible
+ * matches below the fold.
+ *
+ * @param query          free-text search query
+ * @param limit          maximum number of candidates to return
+ * @param opts.conversationId  restrict results to a single conversation
+ */
+export async function searchMessageIdsLexical(
+  query: string,
+  limit: number,
+  opts?: { conversationId?: string },
+): Promise<MessageLexicalSearchResult[]> {
+  const sparse = generateSparseEmbedding(query);
+  // A query that tokenizes to nothing (whitespace/punctuation-only) yields an
+  // empty sparse vector; matching the FTS paths and other sparse callers,
+  // return no candidates without querying Qdrant on an empty vector.
+  if (sparse.indices.length === 0) return [];
+  return getMessagesLexicalIndex().searchLexical(sparse, limit, opts);
+}

package/src/persistence/db-async-query.ts

@@ -26,6 +26,7 @@
  * ms) should keep using the in-process drizzle / `bun:sqlite` handle
  * directly — the subprocess overhead would dominate.
  */
+import { spawn } from "node:child_process";
 import { Database } from "bun:sqlite";
 
 import { getLogger } from "../util/logger.js";
@@ -327,3 +328,44 @@ async function runInProcessBlocking(
     transient?.close();
   }
 }
+
+/**
+ * Fire-and-forget `PRAGMA wal_checkpoint(TRUNCATE)` against the main
+ * assistant DB in a detached `sqlite3` subprocess.
+ *
+ * For exit paths that cannot wait for a fold to finish (the force-exit
+ * timeout in `shutdown-handlers.ts`): the child runs in its own process
+ * group with no inherited stdio, so it survives the daemon's `process.exit`
+ * — and any group-directed follow-up signal from a supervisor — and
+ * finishes the fold in the background. A concurrent checkpointer just makes
+ * this one give up after its busy timeout; the fold is best-effort either
+ * way, with the pre-open checkpoint in `db-init.ts` as the backstop.
+ *
+ * Returns false when no `sqlite3` binary is on the host or the spawn fails —
+ * there is no in-process fallback because the caller is exiting.
+ */
+export function spawnDetachedWalCheckpoint(): boolean {
+  const sqlite3Path = findSqlite3();
+  if (!sqlite3Path) {
+    return false;
+  }
+  try {
+    const child = spawn(
+      sqlite3Path,
+      [
+        getDbPath(),
+        `PRAGMA busy_timeout=${SQLITE_BUSY_TIMEOUT_MS}; PRAGMA wal_checkpoint(TRUNCATE);`,
+      ],
+      { detached: true, stdio: "ignore" },
+    );
+    // A post-spawn failure can't be acted on — the daemon is exiting — but an
+    // unlistened ChildProcess "error" event would throw as an uncaught
+    // exception.
+    child.on("error", () => {});
+    child.unref();
+    log.info({ pid: child.pid }, "Spawned detached WAL checkpoint subprocess");
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/persistence/db-connection.ts

@@ -11,6 +11,7 @@ import { ensureDataDir, getDbPath } from "../util/platform.js";
 import { getTelemetryDbPath } from "../util/telemetry-db-path.js";
 import { clearStoredDb, getStoredDb, setStoredDb } from "./db-singleton.js";
 import * as schema from "./schema/index.js";
+import { wrapSqliteForSlowQueryLogging } from "./slow-query-log.js";
 
 export type DrizzleDb = ReturnType<typeof drizzle<typeof schema>>;
 
@@ -113,11 +114,22 @@ export function getDb(): DrizzleDb {
   ensureDataDir();
   const sqlite = new Database(getDbPath());
   applyConnectionPragmas(sqlite);
+  wrapSqliteForSlowQueryLogging(sqlite);
   const db = drizzle(sqlite, { schema });
   setStoredDb("main", db, () => sqlite.close());
   return db;
 }
 
+/**
+ * Whether the main assistant DB connection is currently open. Lets exit paths
+ * decide between DB teardown work and skipping it entirely — `getDb()` /
+ * `getSqlite()` lazily open the connection, so probing with those would
+ * create the very state being checked for.
+ */
+export function isDbOpen(): boolean {
+  return getStoredDb<DrizzleDb>("main") !== null;
+}
+
 /**
  * Get the underlying bun:sqlite Database from the global Drizzle instance.
  *
@@ -159,6 +171,7 @@ function openDedicatedDb(
   try {
     const sqlite = new Database(dbPath);
     applyConnectionPragmas(sqlite);
+    wrapSqliteForSlowQueryLogging(sqlite);
     const db = drizzle(sqlite, { schema });
     setStoredDb(key, db, () => sqlite.close());
     return db;

package/src/persistence/delivery-channels.ts

@@ -10,36 +10,6 @@ import { eq } from "drizzle-orm";
 import { getDb } from "./db-connection.js";
 import { channelInboundEvents } from "./schema.js";
 
-const SLACK_DM_LIVE_DELIVERED_TEXT_RESPONSE_INDEXES =
-  "slackDmLiveDeliveredTextResponseIndexes";
-
-function parseRawPayload(
-  rawPayload: string | null,
-): Record<string, unknown> | undefined {
-  if (!rawPayload) return undefined;
-  try {
-    const parsed = JSON.parse(rawPayload) as unknown;
-    if (
-      parsed === null ||
-      typeof parsed !== "object" ||
-      Array.isArray(parsed)
-    ) {
-      return undefined;
-    }
-    return parsed as Record<string, unknown>;
-  } catch {
-    return undefined;
-  }
-}
-
-function normalizePositiveIntegerIndexes(value: unknown): number[] {
-  if (!Array.isArray(value)) return [];
-  const indexes = value.filter(
-    (item): item is number => Number.isSafeInteger(item) && item > 0,
-  );
-  return [...new Set(indexes)].sort((a, b) => a - b);
-}
-
 // ── Per-segment delivery progress ──────────────────────────────────
 //
 // When a split reply (multiple text segments from tool boundaries) fails
@@ -61,58 +31,6 @@ export function updateDeliveredSegmentCount(
     .run();
 }
 
-export function getSlackDmLiveDeliveredTextResponseIndexes(
-  eventId: string,
-): number[] {
-  const db = getDb();
-  const row = db
-    .select({ rawPayload: channelInboundEvents.rawPayload })
-    .from(channelInboundEvents)
-    .where(eq(channelInboundEvents.id, eventId))
-    .get();
-  const payload = parseRawPayload(row?.rawPayload ?? null);
-  if (!payload) return [];
-  return normalizePositiveIntegerIndexes(
-    payload[SLACK_DM_LIVE_DELIVERED_TEXT_RESPONSE_INDEXES],
-  );
-}
-
-export function addSlackDmLiveDeliveredTextResponseIndex(
-  eventId: string,
-  responseIndex: number,
-): void {
-  if (!Number.isSafeInteger(responseIndex) || responseIndex <= 0) return;
-
-  const db = getDb();
-  db.transaction((tx) => {
-    const row = tx
-      .select({ rawPayload: channelInboundEvents.rawPayload })
-      .from(channelInboundEvents)
-      .where(eq(channelInboundEvents.id, eventId))
-      .get();
-    if (!row?.rawPayload) return;
-
-    const payload = parseRawPayload(row.rawPayload);
-    if (!payload) return;
-    const indexes = normalizePositiveIntegerIndexes(
-      payload[SLACK_DM_LIVE_DELIVERED_TEXT_RESPONSE_INDEXES],
-    );
-    if (!indexes.includes(responseIndex)) indexes.push(responseIndex);
-    indexes.sort((a, b) => a - b);
-
-    tx.update(channelInboundEvents)
-      .set({
-        rawPayload: JSON.stringify({
-          ...payload,
-          [SLACK_DM_LIVE_DELIVERED_TEXT_RESPONSE_INDEXES]: indexes,
-        }),
-        updatedAt: Date.now(),
-      })
-      .where(eq(channelInboundEvents.id, eventId))
-      .run();
-  });
-}
-
 // ── Deliver-once guard for terminal reply idempotency ────────────────
 //
 // When both the main poll (processChannelMessageWithApprovals) and the

package/src/persistence/delivery-crud.ts

@@ -314,13 +314,13 @@ export function storePayload(
 }
 
 /**
- * Persist the assistant reply row generated for an inbound event so callback
- * delivery retries target that exact response instead of the latest message in
- * the conversation.
+ * Merge a patch into an inbound event's stored payload, preserving existing
+ * keys. No-ops when the event has no payload or the stored value is not a JSON
+ * object.
  */
-export function storeReplyMessageId(
+function mergeRawPayload(
   eventId: string,
-  replyMessageId: string,
+  patch: Record<string, unknown>,
 ): void {
   const db = getDb();
   const row = db
@@ -347,13 +347,34 @@ export function storeReplyMessageId(
 
   db.update(channelInboundEvents)
     .set({
-      rawPayload: JSON.stringify({ ...payload, replyMessageId }),
+      rawPayload: JSON.stringify({ ...payload, ...patch }),
       updatedAt: Date.now(),
     })
     .where(eq(channelInboundEvents.id, eventId))
     .run();
 }
 
+/**
+ * Persist the assistant reply row generated for an inbound event so callback
+ * delivery retries target that exact response instead of the latest message in
+ * the conversation.
+ */
+export function storeReplyMessageId(
+  eventId: string,
+  replyMessageId: string,
+): void {
+  mergeRawPayload(eventId, { replyMessageId });
+}
+
+/**
+ * Persist the `ts` of a Slack message already streamed for an inbound event.
+ * A processing retry reconciles its durable delivery into this message instead
+ * of opening a second stream, preventing a duplicate reply.
+ */
+export function storeStreamedReplyTs(eventId: string, streamTs: string): void {
+  mergeRawPayload(eventId, { slackStreamMessageTs: streamTs });
+}
+
 /**
  * Clear a previously stored payload. Used when the ingress check
  * detects secret-bearing content — the payload must not remain on disk.

package/src/persistence/embeddings/__tests__/embedding-identity.test.ts

@@ -13,11 +13,15 @@ let backendToReturn: {
   embed: (inputs: string[]) => Promise<number[][]>;
 } | null = null;
 let breakerOpen = false;
-
-const selectEmbeddingBackendMock = mock(async () => ({
-  backend: backendToReturn,
-  reason: backendToReturn ? null : "no backend",
-}));
+let selectBackendThrows = false;
+
+const selectEmbeddingBackendMock = mock(async () => {
+  if (selectBackendThrows) throw new Error("credential store unavailable");
+  return {
+    backend: backendToReturn,
+    reason: backendToReturn ? null : "no backend",
+  };
+});
 // probeBackendDimension delegates the measurement to resolveBackendDimension;
 // the mock mirrors the real resolver's "embed → vector length, null on throw"
 // contract so these tests drive behavior through the stub backend's embed().
@@ -69,6 +73,7 @@ const { probeBackendDimension, readConceptPageCollectionDim } =
 describe("probeBackendDimension", () => {
   beforeEach(() => {
     breakerOpen = false;
+    selectBackendThrows = false;
     backendToReturn = {
       provider: "openai",
       model: "text-embedding-3-small",
@@ -110,6 +115,14 @@ describe("probeBackendDimension", () => {
     };
     expect(await probeBackendDimension(CONFIG)).toBeNull();
   });
+
+  test("returns null (does not reject) when backend selection rejects", async () => {
+    // `selectEmbeddingBackend` resolves provider credentials, which reject on a
+    // non-timeout credential-store error. The probe must uphold its never-throws
+    // contract so the reconcile defers instead of crashing.
+    selectBackendThrows = true;
+    expect(await probeBackendDimension(CONFIG)).toBeNull();
+  });
 });
 
 describe("readConceptPageCollectionDim", () => {

package/src/persistence/embeddings/__tests__/messages-lexical-index.test.ts

@@ -0,0 +1,334 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+// ── Mock Qdrant REST client ───────────────────────────────────────────
+
+interface CreateCollectionCall {
+  name: string;
+  config: Record<string, unknown>;
+}
+
+interface UpsertCall {
+  name: string;
+  opts: { points: Array<Record<string, unknown>> };
+}
+
+interface QueryCall {
+  name: string;
+  opts: Record<string, unknown>;
+}
+
+interface DeleteCall {
+  name: string;
+  opts: { filter?: Record<string, unknown>; points?: Array<string | number> };
+}
+
+let mockCollectionExists: boolean;
+let createCollectionCalls: CreateCollectionCall[];
+let upsertCalls: UpsertCall[];
+let queryCalls: QueryCall[];
+let deleteCalls: DeleteCall[];
+let deleteCollectionCalls: string[];
+let payloadIndexCalls: Array<Record<string, unknown>>;
+let mockQueryPoints: Array<{
+  id: string | number;
+  score: number;
+  payload: Record<string, unknown>;
+}>;
+
+function resetMockState() {
+  mockCollectionExists = false;
+  createCollectionCalls = [];
+  upsertCalls = [];
+  queryCalls = [];
+  deleteCalls = [];
+  deleteCollectionCalls = [];
+  payloadIndexCalls = [];
+  mockQueryPoints = [];
+}
+
+mock.module("@qdrant/js-client-rest", () => ({
+  QdrantClient: class MockQdrantClient {
+    async collectionExists(_name: string) {
+      return { exists: mockCollectionExists };
+    }
+
+    async createCollection(name: string, config: Record<string, unknown>) {
+      createCollectionCalls.push({ name, config });
+      mockCollectionExists = true;
+    }
+
+    async createPayloadIndex(_name: string, config: Record<string, unknown>) {
+      payloadIndexCalls.push(config);
+    }
+
+    async upsert(
+      name: string,
+      opts: { points: Array<Record<string, unknown>> },
+    ) {
+      upsertCalls.push({ name, opts });
+    }
+
+    async query(name: string, opts: Record<string, unknown>) {
+      queryCalls.push({ name, opts });
+      return { points: mockQueryPoints };
+    }
+
+    async delete(name: string, opts: DeleteCall["opts"]) {
+      deleteCalls.push({ name, opts });
+    }
+
+    async deleteCollection(name: string) {
+      deleteCollectionCalls.push(name);
+      mockCollectionExists = false;
+    }
+
+    async count(_name: string, _opts: unknown) {
+      return { count: 7 };
+    }
+  },
+}));
+
+import type { SparseEmbedding } from "../embedding-types.js";
+import {
+  messagePointId,
+  MessagesLexicalIndex,
+} from "../messages-lexical-index.js";
+
+const SPARSE: SparseEmbedding = { indices: [1, 5, 9], values: [0.5, 0.2, 0.8] };
+
+function makeIndex() {
+  return new MessagesLexicalIndex({ url: "http://localhost:6333" });
+}
+
+beforeEach(() => {
+  resetMockState();
+});
+
+describe("MessagesLexicalIndex", () => {
+  test("creates a sparse-only collection (no dense vectors config)", async () => {
+    const index = makeIndex();
+    await index.ensureCollection();
+
+    expect(createCollectionCalls.length).toBe(1);
+    const config = createCollectionCalls[0].config;
+
+    // Sparse vector named "sparse" must be present.
+    expect(config.sparse_vectors).toBeDefined();
+    expect(
+      (config.sparse_vectors as Record<string, unknown>).sparse,
+    ).toBeDefined();
+
+    // No dense `vectors` config at all.
+    expect(config.vectors).toBeUndefined();
+    expect("vectors" in config).toBe(false);
+
+    // Payload indexes on conversation_id (keyword) + created_at (integer).
+    const fields = payloadIndexCalls.map((c) => c.field_name);
+    expect(fields).toContain("conversation_id");
+    expect(fields).toContain("created_at");
+    const convIdx = payloadIndexCalls.find(
+      (c) => c.field_name === "conversation_id",
+    );
+    const createdIdx = payloadIndexCalls.find(
+      (c) => c.field_name === "created_at",
+    );
+    expect(convIdx?.field_schema).toBe("keyword");
+    expect(createdIdx?.field_schema).toBe("integer");
+  });
+
+  test("upsertMessage writes a deterministic point id and a sparse-only vector with the right payload", async () => {
+    const index = makeIndex();
+    await index.upsertMessage("msg-123", SPARSE, {
+      conversationId: "conv-abc",
+      createdAt: 1700000000,
+    });
+
+    expect(upsertCalls.length).toBe(1);
+    const points = upsertCalls[0].opts.points;
+    expect(points.length).toBe(1);
+    const point = points[0] as {
+      id: string;
+      vector: Record<string, unknown>;
+      payload: Record<string, unknown>;
+    };
+
+    // Deterministic point id derived from message id.
+    expect(point.id).toBe(messagePointId("msg-123"));
+
+    // Sparse-only vector under the "sparse" named vector, no dense vector.
+    expect(point.vector.sparse).toEqual({
+      indices: SPARSE.indices,
+      values: SPARSE.values,
+    });
+    expect(point.vector.dense).toBeUndefined();
+    expect("dense" in point.vector).toBe(false);
+    // The vector field carries only the sparse named vector.
+    expect(Object.keys(point.vector)).toEqual(["sparse"]);
+
+    // Payload carries message_id, conversation_id, created_at.
+    expect(point.payload.message_id).toBe("msg-123");
+    expect(point.payload.conversation_id).toBe("conv-abc");
+    expect(point.payload.created_at).toBe(1700000000);
+  });
+
+  test("re-upserting the same messageId yields the same point id (idempotent)", async () => {
+    const index = makeIndex();
+    await index.upsertMessage("msg-same", SPARSE, {
+      conversationId: "conv-1",
+      createdAt: 1,
+    });
+    await index.upsertMessage("msg-same", SPARSE, {
+      conversationId: "conv-1",
+      createdAt: 2,
+    });
+
+    expect(upsertCalls.length).toBe(2);
+    const id1 = (upsertCalls[0].opts.points[0] as { id: string }).id;
+    const id2 = (upsertCalls[1].opts.points[0] as { id: string }).id;
+    expect(id1).toBe(id2);
+    expect(id1).toBe(messagePointId("msg-same"));
+    // Distinct message ids map to distinct point ids.
+    expect(messagePointId("msg-same")).not.toBe(messagePointId("msg-other"));
+  });
+
+  test("upsertMessagesBatch writes many points in a single upsert call", async () => {
+    const index = makeIndex();
+    await index.upsertMessagesBatch([
+      { messageId: "m1", sparse: SPARSE, conversationId: "c1", createdAt: 10 },
+      { messageId: "m2", sparse: SPARSE, conversationId: "c2", createdAt: 20 },
+    ]);
+
+    expect(upsertCalls.length).toBe(1);
+    expect(upsertCalls[0].opts.points.length).toBe(2);
+    const ids = upsertCalls[0].opts.points.map((p) => (p as { id: string }).id);
+    expect(ids).toEqual([messagePointId("m1"), messagePointId("m2")]);
+  });
+
+  test("searchLexical queries the sparse named vector and returns {messageId, score}", async () => {
+    mockQueryPoints = [
+      { id: "pt-1", score: 0.91, payload: { message_id: "msg-A" } },
+      { id: "pt-2", score: 0.42, payload: { message_id: "msg-B" } },
+    ];
+
+    const index = makeIndex();
+    const results = await index.searchLexical(SPARSE, 5);
+
+    expect(queryCalls.length).toBe(1);
+    const opts = queryCalls[0].opts;
+    // Query targets the sparse named vector.
+    expect(opts.using).toBe("sparse");
+    expect(opts.query).toEqual({
+      indices: SPARSE.indices,
+      values: SPARSE.values,
+    });
+    expect(opts.limit).toBe(5);
+    // No filter when no conversation scope is given.
+    expect(opts.filter).toBeUndefined();
+
+    expect(results).toEqual([
+      { messageId: "msg-A", score: 0.91 },
+      { messageId: "msg-B", score: 0.42 },
+    ]);
+  });
+
+  test("searchLexical passes a conversation_id payload filter when given", async () => {
+    mockQueryPoints = [
+      { id: "pt-1", score: 0.5, payload: { message_id: "msg-A" } },
+    ];
+
+    const index = makeIndex();
+    await index.searchLexical(SPARSE, 3, { conversationId: "conv-xyz" });
+
+    expect(queryCalls.length).toBe(1);
+    const filter = queryCalls[0].opts.filter as {
+      must: Array<{ key: string; match: { value: string } }>;
+    };
+    expect(filter).toBeDefined();
+    expect(filter.must).toEqual([
+      { key: "conversation_id", match: { value: "conv-xyz" } },
+    ]);
+  });
+
+  test("deleteByConversation issues a conversation_id payload-filter delete", async () => {
+    const index = makeIndex();
+    await index.deleteByConversation("conv-del");
+
+    expect(deleteCalls.length).toBe(1);
+    const filter = deleteCalls[0].opts.filter as {
+      must: Array<{ key: string; match: { value: string } }>;
+    };
+    expect(filter.must).toEqual([
+      { key: "conversation_id", match: { value: "conv-del" } },
+    ]);
+  });
+
+  test("deleteByMessageId deletes by the deterministic point id (not a payload filter)", async () => {
+    const index = makeIndex();
+    await index.deleteByMessageId("msg-del");
+
+    expect(deleteCalls.length).toBe(1);
+    // `message_id` is unindexed, so deletes target the deterministic point id.
+    expect(deleteCalls[0].opts.points).toEqual([messagePointId("msg-del")]);
+    expect(deleteCalls[0].opts.filter).toBeUndefined();
+  });
+
+  test("count returns the collection count", async () => {
+    const index = makeIndex();
+    expect(await index.count()).toBe(7);
+  });
+
+  test("clear drops the whole collection when it exists", async () => {
+    mockCollectionExists = true;
+    const index = makeIndex();
+
+    const dropped = await index.clear();
+
+    expect(dropped).toBe(true);
+    expect(deleteCollectionCalls).toEqual(["messages_lexical"]);
+  });
+
+  test("clear returns false (no throw) when the collection is absent", async () => {
+    mockCollectionExists = false;
+    const index = makeIndex();
+
+    const dropped = await index.clear();
+
+    expect(dropped).toBe(false);
+    expect(deleteCollectionCalls).toEqual([]);
+  });
+
+  test("no dense vector is ever written or queried across operations", async () => {
+    mockQueryPoints = [
+      { id: "pt-1", score: 0.5, payload: { message_id: "msg-A" } },
+    ];
+    const index = makeIndex();
+    await index.upsertMessage("m1", SPARSE, {
+      conversationId: "c1",
+      createdAt: 1,
+    });
+    await index.searchLexical(SPARSE, 5);
+
+    // Collection config never declares a dense vector.
+    for (const call of createCollectionCalls) {
+      expect("vectors" in call.config).toBe(false);
+    }
+    // No upsert point carries a dense vector.
+    for (const call of upsertCalls) {
+      for (const point of call.opts.points) {
+        const vector = (point as { vector: Record<string, unknown> }).vector;
+        expect("dense" in vector).toBe(false);
+      }
+    }
+    // No query targets a dense vector.
+    for (const call of queryCalls) {
+      expect(call.opts.using).toBe("sparse");
+    }
+  });
+});