@spooky-sync/core 0.0.1-canary.33 → 0.0.1-canary.331

package/src/services/database/sqlite-column-reset.integration.test.ts

@@ -0,0 +1,100 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import sqlite3InitModule from '@sqlite.org/sqlite-wasm';
+import { COLUMNS_ROW_ID, columnFingerprints, planColumnReset } from './sqlite-column-reset';
+
+/**
+ * A body landed under an older schema lacks the columns that schema did not
+ * know, at the server's version. Without a reset the next build never fetches
+ * it again (WhitePawn's puzzles stuck on "Preparing" for want of `layout`).
+ * These run the planned statements against a REAL in-memory SQLite, the same
+ * build the worker loads.
+ */
+
+let db: any;
+
+const rows = (sql: string, bind?: unknown[]) =>
+  db.exec({ sql, bind, rowMode: 'object', returnValue: 'resultRows' }) as Record<string, unknown>[];
+
+const versions = (table: string) =>
+  Object.fromEntries(
+    rows(`SELECT id, json_extract(data, '$._00_rv') AS rv FROM "${table}"`).map((r) => [r.id, r.rv])
+  );
+
+const storedSets = () => {
+  const r = rows(`SELECT data FROM "_00_schema" WHERE id = ?`, [COLUMNS_ROW_ID]);
+  return r[0] ? (JSON.parse(r[0].data as string) as Record<string, string>) : null;
+};
+
+const existing = () => new Set(rows(`SELECT name FROM sqlite_master WHERE type = 'table'`).map((r) => r.name as string));
+
+function run(current: Record<string, string>, keep: string[] = []) {
+  const plan = planColumnReset(storedSets(), current, existing(), keep);
+  db.exec({ sql: 'BEGIN' });
+  for (const s of plan.statements) db.exec({ sql: s.sql, bind: s.bind });
+  db.exec({ sql: 'COMMIT' });
+  return plan;
+}
+
+beforeEach(async () => {
+  const sqlite3: any = await sqlite3InitModule();
+  db = new sqlite3.oo1.DB(':memory:', 'c');
+  for (const t of ['_00_schema', 'puzzle', 'game']) {
+    db.exec({ sql: `CREATE TABLE "${t}" (id TEXT PRIMARY KEY, data TEXT NOT NULL)` });
+  }
+  const put = (t: string, id: string, body: object) =>
+    db.exec({ sql: `INSERT INTO "${t}"(id, data) VALUES(?, ?)`, bind: [id, JSON.stringify(body)] });
+  // Landed by the old build: no `layout`, at the server's version 6.
+  put('puzzle', 'puzzle:a', { title: 'A', _00_rv: 6 });
+  put('puzzle', 'puzzle:b', { title: 'B', _00_rv: 6 });
+  put('game', 'game:1', { white: 'x', _00_rv: 3 });
+});
+
+afterEach(() => db?.close());
+
+const OLD = { puzzle: 'title', game: 'white' };
+const NEW = { puzzle: 'layout,title', game: 'white' };
+
+describe('column reset on the SQLite cache', () => {
+  it('fingerprints are the sorted declared columns', () => {
+    expect(columnFingerprints([{ name: 'puzzle', columns: { title: {}, layout: {} } }])).toEqual({
+      puzzle: 'layout,title',
+    });
+  });
+
+  it('first boot with no recorded sets resets every cached table once', () => {
+    const plan = run(NEW);
+    expect(plan.changed.sort()).toEqual(['game', 'puzzle']);
+    expect(versions('puzzle')).toEqual({ 'puzzle:a': 0, 'puzzle:b': 0 });
+    expect(versions('game')).toEqual({ 'game:1': 0 });
+    expect(storedSets()).toEqual(NEW);
+    // Bodies stay: they keep rendering until the refetch lands.
+    expect(rows(`SELECT data FROM puzzle WHERE id = 'puzzle:a'`)[0].data).toContain('"title":"A"');
+
+    // The next boot of the same build changes nothing.
+    const again = run(NEW);
+    expect(again.statements).toEqual([]);
+  });
+
+  it('a new column resets only that table', () => {
+    run(OLD);
+    db.exec({ sql: `UPDATE puzzle SET data = json_set(data, '$._00_rv', 6)` });
+    db.exec({ sql: `UPDATE game SET data = json_set(data, '$._00_rv', 3)` });
+
+    const plan = run(NEW);
+    expect(plan.changed).toEqual(['puzzle']);
+    expect(versions('puzzle')).toEqual({ 'puzzle:a': 0, 'puzzle:b': 0 });
+    expect(versions('game')).toEqual({ 'game:1': 3 });
+  });
+
+  it('keeps the version of a row with an unsettled local write', () => {
+    const plan = run(NEW, ['puzzle:b', 'game:9']);
+    expect(plan.changed).toContain('puzzle');
+    expect(versions('puzzle')).toEqual({ 'puzzle:a': 0, 'puzzle:b': 6 });
+  });
+
+  it('records a table the store has no rows for without touching it', () => {
+    const plan = run({ ...NEW, puzzle_chapter: 'puzzle,sort,title' });
+    expect(plan.changed).not.toContain('puzzle_chapter');
+    expect(storedSets()).toEqual({ ...NEW, puzzle_chapter: 'puzzle,sort,title' });
+  });
+});

package/src/services/database/sqlite-column-reset.ts

@@ -0,0 +1,91 @@
+/**
+ * Cached bodies outlive a schema change on the SQLite engine, and that loses
+ * columns for good.
+ *
+ * A body is landed through `cleanRecord`, which keeps only the columns the
+ * running app's schema declares, and is stored at the server's `_00_rv`. The
+ * engine is schemaless (no migrator, nothing is recreated when the schema
+ * changes), so a tab on an older build that fetched a row after the server
+ * added and backfilled a column stored it WITHOUT that column at the new
+ * version. The next build knows the column, but its local version equals the
+ * server's, so the fetch plan never asks for the row again and the column
+ * stays missing until something else bumps the row. (WhitePawn, 2026-10-11:
+ * every puzzle read as unconverted because `layout` never arrived.)
+ *
+ * So the store remembers each table's column set (`_00_schema`, row
+ * `columns`). On boot, before the prime reads the versions, a table whose set
+ * changed, or every table when no set was recorded yet, gets its cached
+ * `_00_rv` reset to 0. The bodies stay and keep rendering; any view that names
+ * one of those rows sees it as stale and fetches it again, whole. Rows with an
+ * unsettled local write keep their version: their echo is a newer body anyway.
+ */
+
+/** `_00_schema` row holding the recorded column sets. */
+export const COLUMNS_ROW_ID = 'columns';
+
+export interface ColumnResetPlan {
+  /** Tables with cached rows whose versions are reset. */
+  changed: string[];
+  /** One transaction: the resets, then the new column sets. Empty when nothing changed. */
+  statements: { sql: string; bind?: unknown[] }[];
+}
+
+/**
+ * The column set of every table, as `cleanRecord` sees it: the sorted declared
+ * column names. Plain names rather than a hash, so a stored set says what it is.
+ */
+export function columnFingerprints(
+  tables: readonly { name: string; columns: Record<string, unknown> }[]
+): Record<string, string> {
+  const out: Record<string, string> = {};
+  for (const t of tables) out[t.name] = Object.keys(t.columns).sort().join(',');
+  return out;
+}
+
+const sameSets = (a: Record<string, string> | null, b: Record<string, string>): boolean => {
+  if (!a) return false;
+  const ka = Object.keys(a);
+  return ka.length === Object.keys(b).length && ka.every((k) => a[k] === b[k]);
+};
+
+/**
+ * What to run for the column sets `current`, given the `stored` ones (null when
+ * none were recorded), the tables that exist in the store, and the encoded ids
+ * (`table:id`) with an unsettled local write.
+ */
+export function planColumnReset(
+  stored: Record<string, string> | null,
+  current: Record<string, string>,
+  existingTables: ReadonlySet<string>,
+  keep: Iterable<string>
+): ColumnResetPlan {
+  if (sameSets(stored, current)) return { changed: [], statements: [] };
+
+  const keepByTable = new Map<string, string[]>();
+  for (const id of keep) {
+    const table = id.slice(0, id.indexOf(':'));
+    if (!keepByTable.has(table)) keepByTable.set(table, []);
+    keepByTable.get(table)!.push(id);
+  }
+
+  const changed: string[] = [];
+  const statements: ColumnResetPlan['statements'] = [];
+  for (const [table, set] of Object.entries(current)) {
+    if (stored && stored[table] === set) continue;
+    if (!existingTables.has(table)) continue;
+    changed.push(table);
+    const quoted = `"${table.replace(/"/g, '""')}"`;
+    const reset = `UPDATE ${quoted} SET data = json_set(data, '$._00_rv', 0) WHERE json_extract(data, '$._00_rv') != 0`;
+    const kept = keepByTable.get(table);
+    statements.push(
+      kept
+        ? { sql: `${reset} AND id NOT IN (SELECT value FROM json_each(?))`, bind: [JSON.stringify(kept)] }
+        : { sql: reset }
+    );
+  }
+  statements.push({
+    sql: `INSERT OR REPLACE INTO "_00_schema"(id, data) VALUES (?, ?)`,
+    bind: [COLUMNS_ROW_ID, JSON.stringify(current)],
+  });
+  return { changed, statements };
+}

package/src/services/database/sqlite-devtools-queries.integration.test.ts

@@ -0,0 +1,143 @@
+import { describe, it, expect, beforeAll } from 'vitest';
+import sqlite3InitModule from '@sqlite.org/sqlite-wasm';
+import { SqliteCacheEngine } from './sqlite-cache-engine';
+import { stubTransport } from './sqlite-transport.fixture';
+import { serializeRow } from './sqlite-plan-sql';
+import type { Row } from './cache-engine';
+
+/**
+ * Integration: the DevTools Database explorer's statements run end-to-end
+ * (translate → engine SQL → REAL in-memory SQLite, the same
+ * @sqlite.org/sqlite-wasm build the worker loads). The unit test asserts the
+ * translation; this asserts the SQL actually executes and returns the right
+ * rows — the paging window in particular is easy to render into invalid SQLite
+ * (there is no bare OFFSET).
+ */
+
+let db: any;
+
+function makeLogger(): any {
+  const noop = () => {};
+  const l: any = { debug: noop, info: noop, warn: noop, error: noop, trace: noop };
+  l.child = () => l;
+  return l;
+}
+
+/** An engine whose transport is a real SQLite database. */
+function realEngine(): SqliteCacheEngine {
+  const engine = new SqliteCacheEngine({ namespace: 'n', database: 'd' } as any, makeLogger());
+  stubTransport(engine, (type, payload: any) => {
+    switch (type) {
+      case 'open':
+        for (const t of payload.systemTables ?? []) {
+          db.exec({
+            sql: `CREATE TABLE IF NOT EXISTS "${t}" (id TEXT PRIMARY KEY, data TEXT NOT NULL)`,
+          });
+        }
+        return { persisted: true };
+      case 'exec':
+        return {
+          rows: db.exec({
+            sql: payload.sql,
+            bind: payload.bind,
+            rowMode: 'object',
+            returnValue: 'resultRows',
+          }),
+        };
+      case 'run':
+        db.exec({ sql: payload.sql, bind: payload.bind });
+        return {};
+      case 'batch':
+        for (const stmt of payload as { sql: string; bind?: unknown[] }[]) {
+          db.exec({ sql: stmt.sql, bind: stmt.bind });
+        }
+        return {};
+      default:
+        return {};
+    }
+  });
+  return engine;
+}
+
+function seed(table: string, rows: Row[]): void {
+  db.exec({
+    sql: `CREATE TABLE IF NOT EXISTS "${table}" (id TEXT PRIMARY KEY, data TEXT NOT NULL)`,
+  });
+  for (const row of rows) {
+    db.exec({
+      sql: `INSERT INTO "${table}"(id, data) VALUES(?, ?)`,
+      bind: [row.id, serializeRow(row)],
+    });
+  }
+}
+
+beforeAll(async () => {
+  const sqlite3: any = await sqlite3InitModule();
+  db = new sqlite3.oo1.DB(':memory:', 'c');
+  seed(
+    'game_insight',
+    Array.from({ length: 5 }, (_, i) => ({
+      id: `game_insight:${i}`,
+      n: i,
+      tag: i % 2 ? 'odd' : 'even',
+    }))
+  );
+});
+
+describe('DevTools explorer against real SQLite', () => {
+  it('pages a table with LIMIT/START', async () => {
+    const engine = realEngine();
+    await engine.connect('anon');
+
+    const [page1] = await engine.query<[Row[]]>('SELECT * FROM game_insight LIMIT 2 START 0');
+    const [page2] = await engine.query<[Row[]]>('SELECT * FROM game_insight LIMIT 2 START 2');
+    const [tail] = await engine.query<[Row[]]>('SELECT * FROM game_insight LIMIT 20 START 4');
+
+    expect(page1.map((r) => r.id)).toEqual(['game_insight:0', 'game_insight:1']);
+    expect(page2.map((r) => r.id)).toEqual(['game_insight:2', 'game_insight:3']);
+    expect(tail.map((r) => r.id)).toEqual(['game_insight:4']);
+  });
+
+  it('counts rows, with and without a filter', async () => {
+    const engine = realEngine();
+    await engine.connect('anon');
+
+    const [all] = await engine.query<[{ count: number }[]]>(
+      'SELECT count() FROM game_insight GROUP ALL'
+    );
+    const [odd] = await engine.query<[{ count: number }[]]>(
+      "SELECT count() FROM game_insight WHERE tag = 'odd' GROUP ALL"
+    );
+
+    expect(all).toEqual([{ count: 5 }]);
+    expect(odd).toEqual([{ count: 2 }]);
+  });
+
+  it('lists tables via INFO FOR DB', async () => {
+    const engine = realEngine();
+    await engine.connect('anon');
+
+    const [info] = await engine.query<[{ tables: Record<string, string> }]>('INFO FOR DB');
+
+    expect(Object.keys(info.tables)).toContain('game_insight');
+    // Seeded system tables show up too — the panel's "internal" toggle filters
+    // them, the engine must not pre-filter.
+    expect(Object.keys(info.tables)).toContain('_00_view');
+    expect(Object.keys(info.tables).some((t) => t.startsWith('sqlite_'))).toBe(false);
+  });
+
+  it('edits and deletes a row by literal record id', async () => {
+    const engine = realEngine();
+    await engine.connect('anon');
+
+    await engine.query('UPDATE game_insight:1 MERGE $updates', { updates: { tag: 'edited' } });
+    const [edited] = await engine.query<[Row[]]>('SELECT * FROM game_insight LIMIT 20 START 1');
+    expect(edited[0]).toMatchObject({ id: 'game_insight:1', n: 1, tag: 'edited' });
+
+    await engine.query('DELETE game_insight:1');
+    const [after] = await engine.query<[{ count: number }[]]>(
+      'SELECT count() FROM game_insight GROUP ALL'
+    );
+    expect(after).toEqual([{ count: 4 }]);
+  });
+});

package/src/services/database/sqlite-devtools-queries.test.ts

@@ -0,0 +1,154 @@
+import { describe, it, expect } from 'vitest';
+import { SqliteCacheEngine } from './sqlite-cache-engine';
+import { stubTransport } from './sqlite-transport.fixture';
+import { translateSurql } from './surql-translate';
+
+/**
+ * The statements the DevTools Database explorer emits against the LOCAL store.
+ * None of them come from `surql`, so they only ever exercised the SurrealDB
+ * engine: on SQLite the paging read threw "unsupported SurrealQL for
+ * translation: SELECT * FROM game_insight LIMIT 20 START 0", the table list came
+ * back empty (`INFO FOR DB` lowered to a noop) and row edit/delete never
+ * matched (they inline a literal record id).
+ */
+
+function makeLogger(): any {
+  const noop = () => {};
+  const l: any = { debug: noop, info: noop, warn: noop, error: noop, trace: noop };
+  l.child = () => l;
+  return l;
+}
+
+/** Records every exec/run SQL so the paging window can be asserted. */
+function recordingEngine(rows: Record<string, unknown[]> = {}) {
+  const sql: string[] = [];
+  const engine = new SqliteCacheEngine({ namespace: 'n', database: 'd' } as any, makeLogger());
+  stubTransport(engine, (type, payload: any) => {
+    if (type === 'open') return { persisted: true };
+    if (type === 'exec' || type === 'run') {
+      sql.push(payload.sql);
+      for (const [needle, out] of Object.entries(rows)) {
+        if (payload.sql.includes(needle)) return { rows: out };
+      }
+      return { rows: [] };
+    }
+    return {};
+  });
+  return { engine, sql };
+}
+
+describe('DevTools table paging (LIMIT/START)', () => {
+  it('translates the window instead of throwing', () => {
+    const { ops } = translateSurql('SELECT * FROM game_insight LIMIT 20 START 0', {});
+    expect(ops).toEqual([
+      {
+        kind: 'selectTable',
+        table: 'game_insight',
+        where: undefined,
+        orderBy: undefined,
+        select: undefined,
+        value: undefined,
+        limit: 20,
+        start: 0,
+      },
+    ]);
+  });
+
+  it('renders LIMIT/OFFSET in SQL, page 3 of 20', async () => {
+    const { engine, sql } = recordingEngine();
+    await engine.connect('anon');
+    await engine.query('SELECT * FROM game_insight LIMIT 20 START 40');
+    expect(sql.some((s) => /SELECT data FROM "game_insight" LIMIT 20 OFFSET 40$/.test(s))).toBe(
+      true
+    );
+  });
+
+  it('keeps WHERE and ORDER BY alongside the window', () => {
+    const { ops } = translateSurql(
+      'SELECT * FROM game WHERE done = true ORDER BY date desc LIMIT 10 START 30',
+      {}
+    );
+    expect(ops[0]).toMatchObject({
+      kind: 'selectTable',
+      table: 'game',
+      where: [{ field: 'done', op: '=', value: true }],
+      orderBy: [['date', 'desc']],
+      limit: 10,
+      start: 30,
+    });
+  });
+
+  it('leaves a LIMIT that is part of a string literal alone', () => {
+    const { ops } = translateSurql("SELECT * FROM game WHERE note = 'LIMIT 5'", {});
+    expect(ops[0]).toMatchObject({
+      kind: 'selectTable',
+      where: [{ field: 'note', op: '=', value: 'LIMIT 5' }],
+      limit: undefined,
+      start: undefined,
+    });
+  });
+
+  it('a START with no LIMIT still renders valid SQLite', async () => {
+    const { engine, sql } = recordingEngine();
+    await engine.connect('anon');
+    await engine.query('SELECT * FROM game START 5');
+    // SQLite has no bare OFFSET — `LIMIT -1` is its "everything" sentinel.
+    expect(sql.some((s) => s.endsWith('LIMIT -1 OFFSET 5'))).toBe(true);
+  });
+});
+
+describe('DevTools row count', () => {
+  it("answers `SELECT count() FROM t GROUP ALL` in SurrealDB's shape", async () => {
+    const { engine } = recordingEngine({ 'COUNT(*)': [{ n: 137 }] });
+    await engine.connect('anon');
+    const res = await engine.query<[{ count: number }[]]>(
+      'SELECT count() FROM game_insight GROUP ALL'
+    );
+    expect(res[0]).toEqual([{ count: 137 }]);
+  });
+
+  it('counts zero rows as 0, not undefined', async () => {
+    const { engine } = recordingEngine();
+    await engine.connect('anon');
+    const res = await engine.query<[{ count: number }[]]>('SELECT count() FROM empty GROUP ALL');
+    expect(res[0]).toEqual([{ count: 0 }]);
+  });
+});
+
+describe('DevTools table list', () => {
+  it('answers INFO FOR DB from sqlite_master, minus SQLite internals', async () => {
+    const { engine } = recordingEngine({
+      sqlite_master: [{ name: 'game' }, { name: '_00_query' }],
+    });
+    await engine.connect('anon');
+    const [info] = await engine.query<[{ tables: Record<string, string> }]>('INFO FOR DB');
+    expect(Object.keys(info.tables)).toEqual(['game', '_00_query']);
+  });
+});
+
+describe('DevTools row edit / delete (literal record ids)', () => {
+  it('UPDATE <table>:<id> MERGE $updates writes that row', async () => {
+    const { engine, sql } = recordingEngine();
+    await engine.connect('anon');
+    await engine.query('UPDATE game:abc MERGE $updates', { updates: { white: 'hikaru' } });
+    const write = sql.find((s) => s.startsWith('INSERT INTO "game"'));
+    expect(write).toBeDefined();
+    expect(write).toContain('json_patch');
+  });
+
+  it('DELETE <table>:<id> deletes one row, DELETE <table> still clears the table', () => {
+    expect(translateSurql('DELETE game:abc', {}).ops[0]).toEqual({
+      kind: 'delete',
+      id: 'game:abc',
+    });
+    expect(translateSurql('DELETE game', {}).ops[0]).toEqual({ kind: 'deleteAll', table: 'game' });
+  });
+
+  it('refuses a table-wide MERGE rather than writing a row named after the table', () => {
+    // `UPDATE game MERGE $x` means every row of `game` in SurrealQL. Unsupported
+    // here — and it must SAY so, not silently create `game:undefined`.
+    expect(() => translateSurql('UPDATE game MERGE $x', { x: {} })).toThrow(
+      /unsupported SurrealQL/
+    );
+  });
+});

package/src/services/database/sqlite-lock-verify.test.ts

@@ -0,0 +1,33 @@
+import { describe, it, expect, vi } from 'vitest';
+import { verifyLockStillHeld } from './sqlite-lock-verify';
+
+describe('verifyLockStillHeld', () => {
+  it('fences when the lock is no longer held', async () => {
+    const fence = vi.fn(async () => {});
+    await verifyLockStillHeld({ query: async () => ({ held: [] }) }, 'lock-a', fence, 50);
+    expect(fence).toHaveBeenCalledWith('lock missing after suspected freeze');
+  });
+
+  it('does nothing when the lock is still held', async () => {
+    const fence = vi.fn(async () => {});
+    await verifyLockStillHeld({ query: async () => ({ held: [{ name: 'lock-a' }] }) }, 'lock-a', fence, 50);
+    expect(fence).not.toHaveBeenCalled();
+  });
+
+  it('resolves within the bound when the lock query never answers, without fencing', async () => {
+    const fence = vi.fn(async () => {});
+    const warn = vi.fn();
+    const started = Date.now();
+    await verifyLockStillHeld({ query: () => new Promise(() => {}) }, 'lock-a', fence, 30, warn);
+    expect(Date.now() - started).toBeLessThan(1_000);
+    expect(fence).not.toHaveBeenCalled();
+    expect(warn).toHaveBeenCalledTimes(1);
+  });
+
+  it('is a no-op without a lock or a query API', async () => {
+    const fence = vi.fn(async () => {});
+    await verifyLockStillHeld(null, 'x', fence);
+    await verifyLockStillHeld({ query: async () => ({}) }, undefined, fence);
+    expect(fence).not.toHaveBeenCalled();
+  });
+});

package/src/services/database/sqlite-lock-verify.ts

@@ -0,0 +1,45 @@
+/**
+ * "Do we still hold the OPFS lock?" - asked by the SQLite worker after a gap
+ * in its ticks long enough that the tab may have been frozen and the broker
+ * may have handed the lock to another tab.
+ *
+ * Bounded. `navigator.locks.query()` has no deadline of its own, and every op
+ * on the worker's chain awaits this verification: one query that never
+ * resolves stopped every reply to every client for good. On timeout we resolve
+ * WITHOUT fencing - the steal callback registered on the lock request remains
+ * the backstop that fences a genuinely stolen lock - and say so.
+ */
+export interface LockQueryLike {
+  query(): Promise<{ held?: { name?: string }[] }>;
+}
+
+export const LOCK_VERIFY_TIMEOUT_MS = 2_000;
+
+export async function verifyLockStillHeld(
+  locks: LockQueryLike | null | undefined,
+  name: string | undefined,
+  fence: (reason: string) => Promise<void> | void,
+  timeoutMs = LOCK_VERIFY_TIMEOUT_MS,
+  warn: (msg: string) => void = () => {}
+): Promise<void> {
+  if (!locks || !name || typeof locks.query !== 'function') return;
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  try {
+    const state = await Promise.race([
+      locks.query(),
+      new Promise<null>((resolve) => {
+        timer = setTimeout(() => resolve(null), timeoutMs);
+      }),
+    ]);
+    if (state === null) {
+      warn(`lock verification did not answer within ${timeoutMs}ms; trusting the steal callback`);
+      return;
+    }
+    const stillHeld = (state.held ?? []).some((l) => l.name === name);
+    if (!stillHeld) await fence('lock missing after suspected freeze');
+  } catch {
+    /* query unavailable: fall back to the steal callback */
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}