@spooky-sync/core 0.0.1-canary.290 → 0.0.1-canary.292

package/src/modules/devtools/index.ts

@@ -1,19 +1,20 @@
 import type { LocalStore, RemoteDatabaseService } from '../../services/database/index';
-import type { Logger } from '../../services/logger/index';
+import type { Level } from 'pino';
+import type { LogRead, LogTap, Logger } from '../../services/logger/index';
 import type { SchemaStructure } from '@spooky-sync/query-builder';
 import { RecordId } from 'surrealdb';
 import type { StreamUpdate, StreamUpdateReceiver } from '../../services/stream-processor/index';
 import { encodeRecordId } from '../../utils/index';
 
-// DevTools interfaces (matching extension expectations)
-export interface DevToolsEvent {
-  id: number;
-  timestamp: number;
-  eventType: string;
-  payload: any;
-}
-
-import type { QueryState, QueryTimings } from '../../types';
+import type { MutationEventType, QueryState, QueryTimings } from '../../types';
+import type { ClientState } from '../../state/client-state';
+import {
+  parsePendingRow,
+  parseStoredRecordId,
+  storedIdString,
+  type FailedMutationRow,
+  type PendingMutationRow,
+} from '../../mutation/rows';
 import type {
   AuthService,
   ActiveImpersonation,
@@ -29,6 +30,13 @@ import {
 } from './versions';
 import { walkOpfs, type BlobCacheInfo, type SharedTabsInfo, type StorageInfo } from './storage-info';
 import { FlagsAdminService, type LocalOverrideStore } from './flags';
+import {
+  buildMutationsState,
+  queuedAtOf,
+  trimHistory,
+  type DevToolsMutationsState,
+  type MutationHistoryEntry,
+} from './mutations';
 
 // Real bundled frontend versions, injected at build time by tsdown's
 // version-define plugin (see tsdown.config.ts). The `typeof` guard keeps these
@@ -51,6 +59,28 @@ export interface DevToolsQuerySource {
 
 export type ImpersonationOp = 'status' | 'listUsers' | 'start' | 'stop';
 
+/** What the Mutations tab reads and does; the client wires it to the runtime. */
+export interface DevToolsMutationSource {
+  state(): ClientState;
+  listFailed(): Promise<FailedMutationRow[]>;
+  retryFailed(mutationId: string): Promise<boolean>;
+  discardFailed(mutationId: string): Promise<boolean>;
+}
+
+export type MutationOp = 'listFailed' | 'get' | 'retry' | 'discard' | 'clearHistory';
+
+export interface MutationOpResult {
+  success: boolean;
+  error?: string;
+  failed?: FailedMutationRow[];
+  /** `get`: the stored outbox row, or null once it left the outbox. */
+  row?: PendingMutationRow | null;
+}
+
+export type LogOp = 'read' | 'setCaptureLevel' | 'clear';
+
+export type LogOpResult = { success: boolean; error?: string } & Partial<LogRead>;
+
 export interface ImpersonationOpResult {
   success: boolean;
   error?: string;
@@ -63,26 +93,25 @@ export interface ImpersonationOpResult {
 }
 
 export class DevToolsService implements StreamUpdateReceiver {
-  private eventsHistory: DevToolsEvent[] = [];
-  private eventIdCounter = 0;
   // Real bundled frontend version (injected at build time via tsdown `define`).
   private version = CORE_VERSION;
   // Backend stack info (versions + per-entity status), read via the
   // `fn::spooky::info()` SurrealQL function; empty/'unavailable' until resolved.
   private backendInfo: BackendInfo = emptyBackendInfo();
   // Dormant until a devtools consumer (extension panel or MCP) handshakes via
-  // `SP00KY_DEVTOOLS_CONNECT`. While false, `notifyDevTools()`/`addEvent()` do no
-  // work, so prod pays zero serialization/postMessage cost for an unwatched panel.
+  // `SP00KY_DEVTOOLS_CONNECT`. While false, `notifyDevTools()` and the mutation
+  // history do no work, so prod pays zero serialization/postMessage cost for an
+  // unwatched panel.
   // `window.__00__.getState()` stays live regardless, so the panel's first paint
   // (the on-demand GET_STATE pull) still works before the push channel turns on.
   private enabled = false;
 
   // A state push serializes EVERY active query's full record set (see
   // `getActiveQueries`) and postMessage clones it again, so its cost scales with
-  // the whole client dataset — and it is triggered per event, including one per
-  // local DB query (`DATABASE_LOCAL_QUERY` → `logEvent`). Unthrottled, a single
-  // page load's few hundred local queries turn a handful of MB of rows into GBs
-  // of short-lived large-object garbage and OOM the renderer (V8
+  // the whole client dataset — and it is requested on every sync event (it used
+  // to be one per local DB query, when those were recorded as events).
+  // Unthrottled, a page load's burst of requests turned a handful of MB of rows
+  // into GBs of short-lived large-object garbage and OOMed the renderer (V8
   // "young object promotion failed"). Coalesce instead: push immediately when
   // idle, then at most once per window, always serializing the LATEST state.
   private static readonly NOTIFY_MIN_INTERVAL_MS = 250;
@@ -104,6 +133,38 @@ export class DevToolsService implements StreamUpdateReceiver {
   /** Blob cache counters for the panel, wired by Sp00kyClient. */
   private blobInfoProvider: (() => BlobCacheInfo) | null = null;
 
+  /** Outbox, debounced writes and the failed tray, wired by Sp00kyClient. */
+  private mutationSource: DevToolsMutationSource | null = null;
+  /**
+   * Mutations seen since a consumer attached, by id, oldest first. The outbox
+   * only knows what is still queued; this is what lets the panel show a write
+   * as synced or rolled back after it left.
+   */
+  private mutationHistory = new Map<string, MutationHistoryEntry>();
+  private static readonly MUTATIONS_CAP = 200;
+
+  setMutationSource(source: DevToolsMutationSource): void {
+    this.mutationSource = source;
+  }
+
+  /**
+   * The page's log buffer. It records whether or not anybody is watching (so
+   * a panel opened late still sees the boot); while a consumer is attached,
+   * new lines go out as small `SP00KY_LOGS` deltas, never inside the state
+   * push, which would re-serialize the whole buffer every time.
+   */
+  private logTap: LogTap | null = null;
+  /** `seq` of the newest line already pushed. */
+  private logCursor = 0;
+  private logTimer: ReturnType<typeof setTimeout> | null = null;
+  private lastLogPushAt = 0;
+
+  setLogTap(tap: LogTap): void {
+    this.logTap = tap;
+    this.logCursor = tap.head;
+    tap.subscribe(() => this.scheduleLogPush());
+  }
+
   setBlobInfoProvider(provider: () => BlobCacheInfo): void {
     this.blobInfoProvider = provider;
   }
@@ -152,6 +213,9 @@ export class DevToolsService implements StreamUpdateReceiver {
         const type = (e.data as { type?: string } | undefined)?.type;
         if (type === 'SP00KY_DEVTOOLS_CONNECT') {
           this.enabled = true;
+          // The consumer pulls the backlog itself (`logOp('read')`); pushes
+          // carry only what arrives after this point.
+          this.logCursor = this.logTap?.head ?? 0;
           this.refreshLocalTables();
           this.notifyDevTools();
         } else if (type === 'SP00KY_DEVTOOLS_DISCONNECT') {
@@ -266,73 +330,184 @@ export class DevToolsService implements StreamUpdateReceiver {
     return result;
   }
 
-  public onQueryInitialized(payload: any) {
+  public onStreamUpdate(update: StreamUpdate) {
+    // A synthetic re-materialize is not an ingest (DataModule.scheduleRematerialize).
+    if (update.synthetic) return;
+    // Counts and timings, not the `localArray` itself: that is one [id, version]
+    // pair per row of the view. The Logs tab shows this line at debug.
     this.logger.debug(
-      { payload, Category: 'sp00ky-client::DevToolsService::onQueryInitialized' },
-      'QueryInitialized'
+      {
+        queryHash: update.queryHash,
+        op: update.op,
+        localCount: update.localArray?.length ?? 0,
+        materializationTimeMs: update.materializationTimeMs,
+        storeApplyMs: update.storeApplyMs,
+        circuitStepMs: update.circuitStepMs,
+        transformMs: update.transformMs,
+        Category: 'sp00ky-client::DevToolsService::onStreamUpdate',
+      },
+      'StreamUpdate'
     );
-    const queryHash = this.hashString(payload.queryId.toString());
+    this.notifyDevTools();
+  }
 
-    this.addEvent('QUERY_REQUEST_INIT', {
-      queryHash,
-      query: payload.sql,
-      variables: {},
-    });
+  public onMutation(payload: any[]) {
+    for (const p of payload) this.recordQueued(p);
     this.notifyDevTools();
   }
 
-  public onQueryUpdated(payload: any) {
-    this.logger.debug(
-      {
-        id: payload.queryId?.toString(),
-        Category: 'sp00ky-client::DevToolsService::onQueryUpdated',
-      },
-      'QueryUpdated'
-    );
-    const queryHash = this.hashString(payload.queryId.toString());
+  /** A write entered the outbox. */
+  private recordQueued(p: any): void {
+    if (!this.enabled || !p?.mutation_id) return;
+    const id = storedIdString(p.mutation_id);
+    const recordId = p.record_id ? encodeRecordId(p.record_id) : '';
+    this.mutationHistory.set(id, {
+      id,
+      op: (p.type ?? 'create') as MutationEventType,
+      recordId,
+      table: typeof p.tableName === 'string' ? p.tableName : recordId.split(':')[0],
+      fields: p.data && typeof p.data === 'object' ? Object.keys(p.data) : [],
+      queuedAt: queuedAtOf(id) || Date.now(),
+    });
+    trimHistory(this.mutationHistory, DevToolsService.MUTATIONS_CAP);
+  }
 
-    this.addEvent('QUERY_UPDATED', {
-      queryHash,
-      recordCount: Array.isArray(payload.records) ? payload.records.length : 0,
+  /** The server answered a write: accepted (`synced`) or rejected (`rolled-back`). */
+  public onMutationOutcome(e: {
+    mutationId: string;
+    recordId: string;
+    eventType: string;
+    status: 'synced' | 'rolled-back';
+    error?: string;
+  }): void {
+    if (!this.enabled) return;
+    const prev = this.mutationHistory.get(e.mutationId);
+    this.mutationHistory.set(e.mutationId, {
+      ...(prev ?? {
+        id: e.mutationId,
+        op: e.eventType as MutationEventType,
+        recordId: e.recordId,
+        table: e.recordId.split(':')[0],
+        queuedAt: queuedAtOf(e.mutationId),
+      }),
+      outcome: { status: e.status, at: Date.now(), error: e.error },
     });
+    trimHistory(this.mutationHistory, DevToolsService.MUTATIONS_CAP);
     this.notifyDevTools();
   }
 
-  public onStreamUpdate(update: StreamUpdate) {
-    // A synthetic re-materialize is not an ingest (DataModule.scheduleRematerialize).
-    if (update.synthetic) return;
-    this.logger.debug(
-      { queryHash: update.queryHash, Category: 'sp00ky-client::DevToolsService::onStreamUpdate' },
-      'StreamUpdate'
-    );
-    // Counts and timings, not the `localArray` itself: that is one [id, version]
-    // pair per row of the view, serialized on every single update.
-    this.addEvent('STREAM_UPDATE', {
-      queryHash: update.queryHash,
-      op: update.op,
-      localCount: update.localArray?.length ?? 0,
-      materializationTimeMs: update.materializationTimeMs,
-      storeApplyMs: update.storeApplyMs,
-      circuitStepMs: update.circuitStepMs,
-      transformMs: update.transformMs,
-    });
+  /** Something the panel shows moved (a query's status, the outbox, sync health): re-push. */
+  public onStateChanged(): void {
     this.notifyDevTools();
   }
 
-  public onMutation(payload: any[]) {
-    const payloads = payload;
-    payloads.forEach((p) => {
-      this.addEvent('MUTATION_REQUEST_EXECUTION', {
-        mutation: {
-          type: p.type ?? 'create',
-          // Field names only; a payload body (a PGN, a document) is not
-          // something to clone on every write.
-          fields: 'data' in p && p.data && typeof p.data === 'object' ? Object.keys(p.data) : [],
-          selector: encodeRecordId(p.record_id),
-        },
-      });
+  private mutationsState(): DevToolsMutationsState | null {
+    const source = this.mutationSource;
+    if (!source) return null;
+    const s = source.state();
+    return buildMutationsState({
+      outbox: s.outbox,
+      pendingWrites: s.pendingWrites.values(),
+      failedCount: s.failedCount,
+      tabRole: s.tabRole,
+      health: s.sync.health,
+      history: this.mutationHistory.values(),
+      cap: DevToolsService.MUTATIONS_CAP,
     });
-    this.notifyDevTools();
+  }
+
+  /**
+   * The Mutations tab's on-demand half: the failed tray (a local read), one
+   * queued row's payload, and the tray's retry / discard.
+   */
+  public async mutationOp(op: MutationOp, args: Record<string, unknown>): Promise<MutationOpResult> {
+    const source = this.mutationSource;
+    if (!source) return { success: false, error: 'this client does not expose its mutations' };
+    const id = String(args.id ?? '');
+    try {
+      switch (op) {
+        case 'listFailed':
+          return this.serializeForDevTools({ success: true, failed: await source.listFailed() });
+        case 'get': {
+          const res = await this.databaseService.query<any>('SELECT * FROM $ids', {
+            ids: [parseStoredRecordId(id)],
+          });
+          const raw = Array.isArray(res?.[0]) ? res[0][0] : undefined;
+          return this.serializeForDevTools({ success: true, row: raw ? parsePendingRow(raw) : null });
+        }
+        case 'retry':
+          return (await source.retryFailed(id))
+            ? { success: true }
+            : { success: false, error: `${id} is not in the failed tray` };
+        case 'discard':
+          return (await source.discardFailed(id))
+            ? { success: true }
+            : { success: false, error: `${id} is not in the failed tray` };
+        case 'clearHistory':
+          this.mutationHistory.clear();
+          this.notifyDevTools();
+          return { success: true };
+        default:
+          return { success: false, error: `Unknown mutation op: ${String(op)}` };
+      }
+    } catch (e) {
+      return { success: false, error: e instanceof Error ? e.message : String(e) };
+    }
+  }
+
+  /** The Logs tab: read the buffer, change what it records, empty it. */
+  public logOp(op: LogOp, args: Record<string, unknown>): LogOpResult {
+    const tap = this.logTap;
+    if (!tap) return { success: false, error: 'this client does not capture its logs' };
+    try {
+      switch (op) {
+        case 'read': {
+          const limit = typeof args.limit === 'number' ? args.limit : undefined;
+          return { success: true, ...tap.read(Number(args.after ?? 0), limit) };
+        }
+        case 'setCaptureLevel':
+          tap.setCaptureLevel(String(args.level) as Level);
+          this.notifyDevTools();
+          return { success: true, captureLevel: tap.captureLevel, consoleLevel: tap.consoleLevel };
+        case 'clear':
+          tap.clear();
+          return { success: true, head: tap.head };
+        default:
+          return { success: false, error: `Unknown log op: ${String(op)}` };
+      }
+    } catch (e) {
+      return { success: false, error: e instanceof Error ? e.message : String(e) };
+    }
+  }
+
+  /** Same coalescing as {@link notifyDevTools}, for the log delta channel. */
+  private scheduleLogPush(): void {
+    if (!this.enabled || typeof window === 'undefined' || this.logTimer !== null) return;
+    const waited = Date.now() - this.lastLogPushAt;
+    const delay = Math.max(0, DevToolsService.NOTIFY_MIN_INTERVAL_MS - waited);
+    this.logTimer = setTimeout(() => {
+      this.logTimer = null;
+      if (this.enabled) this.flushLogs();
+    }, delay);
+  }
+
+  private flushLogs(): void {
+    const tap = this.logTap;
+    if (!tap) return;
+    this.lastLogPushAt = Date.now();
+    const delta = tap.read(this.logCursor);
+    this.logCursor = delta.head;
+    if (delta.entries.length === 0) return;
+    window.postMessage(
+      {
+        type: 'SP00KY_LOGS',
+        source: 'sp00ky-devtools-page',
+        entries: delta.entries,
+        head: delta.head,
+        dropped: delta.dropped,
+      },
+      '*'
+    );
   }
 
   private hashString(str: string): number {
@@ -346,23 +521,6 @@ export class DevToolsService implements StreamUpdateReceiver {
     return hash;
   }
 
-  public logEvent(eventType: string, payload: any) {
-    this.addEvent(eventType, payload);
-    this.notifyDevTools();
-  }
-
-  private addEvent(eventType: string, payload: any) {
-    // No consumer attached → skip recording (and the recursive serialize it does).
-    if (!this.enabled) return;
-    this.eventsHistory.push({
-      id: this.eventIdCounter++,
-      timestamp: Date.now(),
-      eventType,
-      payload: this.serializeForDevTools(payload),
-    });
-    if (this.eventsHistory.length > 100) this.eventsHistory.shift();
-  }
-
   /** Unwrap a SurrealDB `INFO FOR DB` result to its `{ tables, ... }` object. */
   private unwrapInfo(res: any): any {
     if (!Array.isArray(res) || !res[0]) return null;
@@ -413,7 +571,10 @@ export class DevToolsService implements StreamUpdateReceiver {
     // the single local op queue.
     if (opts.refreshTables) this.refreshLocalTables();
     return this.serializeForDevTools({
-      eventsHistory: [...this.eventsHistory],
+      // The event log is gone (the Logs and Mutations tabs carry what it did);
+      // still sent empty because panels before canary.291 read it to tell this
+      // state shape apart from their own.
+      eventsHistory: [],
       activeQueries: Object.fromEntries(this.getActiveQueries()),
       auth: {
         authenticated: this.authService.isAuthenticated,
@@ -447,6 +608,18 @@ export class DevToolsService implements StreamUpdateReceiver {
         // Shared-tabs role state (null when the feature is off / fell back).
         tabs: this.tabsInfoProvider?.() ?? null,
       },
+      // Outbox, debounced writes, tray count and recent outcomes. Small by
+      // construction (capped entries, field names only, never payloads).
+      mutations: this.mutationsState(),
+      // Log buffer metadata only; the lines travel as `SP00KY_LOGS` deltas and
+      // through `logOp('read')`.
+      logs: this.logTap
+        ? {
+            head: this.logTap.head,
+            consoleLevel: this.logTap.consoleLevel,
+            captureLevel: this.logTap.captureLevel,
+          }
+        : null,
     });
   }
 
@@ -701,6 +874,9 @@ export class DevToolsService implements StreamUpdateReceiver {
         // nothing here grants anything.
         impersonationOp: (op: ImpersonationOp, args?: Record<string, unknown>) =>
           this.impersonationOp(op, args ?? {}),
+        // ---- Mutations + Logs tabs ---------------------------------------
+        mutationOp: (op: MutationOp, args?: Record<string, unknown>) => this.mutationOp(op, args ?? {}),
+        logOp: (op: LogOp, args?: Record<string, unknown>) => this.logOp(op, args ?? {}),
         setFlagEnabled: (key: string, enabled: boolean) =>
           this.flagsAdmin.setFlagEnabled(key, enabled),
         setFlagUserVariant: (key: string, variant: string, remove: boolean, userId?: string) =>
@@ -708,10 +884,6 @@ export class DevToolsService implements StreamUpdateReceiver {
         setLocalFlagOverride: (key: string, variant: string | null, payload?: unknown) =>
           this.flagsAdmin.setLocalFlagOverride(key, variant, payload),
         clearLocalFlagOverrides: () => this.flagsAdmin.clearLocalFlagOverrides(),
-        clearHistory: () => {
-          this.eventsHistory = [];
-          this.notifyDevTools();
-        },
         refreshVersions: () => this.refreshBackendVersions(),
         getStorageInfo: (opts?: { tableCounts?: boolean }) => this.getStorageInfo(opts),
         requestPersistentStorage: () => this.requestPersistentStorage(),

package/src/modules/devtools/mutations.test.ts

@@ -0,0 +1,92 @@
+import { describe, it, expect } from 'vitest';
+import type { OutboxItem, PendingWrite } from '../../state/client-state';
+import { initialHealth } from '../../state/client-state';
+import { buildMutationsState, trimHistory, type MutationHistoryEntry } from './mutations';
+
+const id = (ts: number, n = 1) => `_00_pending_mutations:${String(ts).padStart(13, '0')}_${String(n).padStart(4, '0')}_tab`;
+
+const item = (over: Partial<OutboxItem> & { id: string }): OutboxItem => ({
+  type: 'update',
+  recordId: 'thread:a',
+  table: 'thread',
+  status: 'pending',
+  ackedAt: null,
+  attempts: 0,
+  ...over,
+});
+
+const build = (over: Partial<Parameters<typeof buildMutationsState>[0]> = {}) =>
+  buildMutationsState({
+    outbox: [],
+    pendingWrites: [],
+    failedCount: 0,
+    tabRole: 'solo',
+    health: initialHealth('connected'),
+    history: [],
+    cap: 200,
+    ...over,
+  });
+
+describe('buildMutationsState', () => {
+  it('reads status off the outbox, queued time off the id', () => {
+    const s = build({
+      outbox: [
+        item({ id: id(1000) }),
+        item({ id: id(2000), attempts: 3 }),
+        item({ id: id(3000), status: 'acked', ackedAt: 3500 }),
+      ],
+    });
+    expect(s.entries.map((e) => [e.queuedAt, e.status])).toEqual([
+      [3000, 'synced'],
+      [2000, 'retrying'],
+      [1000, 'pending'],
+    ]);
+    expect(s.entries[0].settledAt).toBe(3500);
+    expect(s.counts).toMatchObject({ pending: 1, retrying: 1, synced: 1, rolledBack: 0 });
+  });
+
+  it('keeps what left the outbox, and the live outbox wins over history', () => {
+    const history: MutationHistoryEntry[] = [
+      { id: id(1000), op: 'create', recordId: 'thread:a', table: 'thread', fields: ['title'], queuedAt: 1000, outcome: { status: 'synced', at: 1100 } },
+      { id: id(2000), op: 'update', recordId: 'thread:b', table: 'thread', fields: ['body'], queuedAt: 2000, outcome: { status: 'rolled-back', at: 2100, error: 'denied' } },
+      { id: id(3000), op: 'update', recordId: 'thread:c', table: 'thread', fields: ['x'], queuedAt: 3000 },
+      { id: id(4000), op: 'delete', recordId: 'thread:d', table: 'thread', queuedAt: 4000 },
+    ];
+    const s = build({ history, outbox: [item({ id: id(3000), recordId: 'thread:c', attempts: 1 })] });
+    const byId = new Map(s.entries.map((e) => [e.id, e]));
+    expect(byId.get(id(1000))).toMatchObject({ status: 'synced', settledAt: 1100, fields: ['title'] });
+    expect(byId.get(id(2000))).toMatchObject({ status: 'rolled-back', error: 'denied' });
+    expect(byId.get(id(3000))).toMatchObject({ status: 'retrying', attempts: 1, fields: ['x'] });
+    expect(byId.get(id(4000))).toMatchObject({ status: 'dropped' });
+  });
+
+  it('caps entries but counts and totals everything', () => {
+    const outbox = Array.from({ length: 5 }, (_, i) => item({ id: id(1000 + i) }));
+    const s = build({ outbox, cap: 2 });
+    expect(s.entries.map((e) => e.queuedAt)).toEqual([1004, 1003]);
+    expect(s.total).toBe(5);
+    expect(s.counts.pending).toBe(5);
+  });
+
+  it('lists debounced writes and carries role, health and tray count', () => {
+    const w: PendingWrite = { key: 'k', table: 'doc', recordId: 'doc:1', data: { title: 't', body: 'b' }, before: null, firstAt: 42, mirrorId: null };
+    const s = build({
+      pendingWrites: [w],
+      failedCount: 3,
+      tabRole: 'follower',
+      health: { ...initialHealth('reconnecting'), status: 'degraded', consecutiveFailures: 4, error: 'socket closed' },
+    });
+    expect(s.debounced).toEqual([{ key: 'k', recordId: 'doc:1', table: 'doc', fields: ['title', 'body'], since: 42, durable: false }]);
+    expect(s).toMatchObject({ role: 'follower', connection: 'reconnecting', health: 'degraded', consecutiveFailures: 4, lastError: 'socket closed' });
+    expect(s.counts).toMatchObject({ failed: 3, debounced: 1 });
+  });
+});
+
+describe('trimHistory', () => {
+  it('drops the oldest entries first', () => {
+    const h = new Map<string, MutationHistoryEntry>();
+    for (const n of [1, 2, 3]) h.set(`m${n}`, { id: `m${n}`, op: 'create', recordId: 'a:1', table: 'a', queuedAt: n });
+    trimHistory(h, 2);
+    expect([...h.keys()]).toEqual(['m2', 'm3']);
+  });
+});