@spooky-sync/core 0.0.1-canary.4 → 0.0.1-canary.41

package/src/modules/cache/index.ts

@@ -1,13 +1,13 @@
-import { LocalDatabaseService } from '../../services/database/index';
-import {
+import type { LocalDatabaseService } from '../../services/database/index';
+import type {
   StreamProcessorService,
   StreamUpdate,
   StreamUpdateReceiver,
 } from '../../services/stream-processor/index';
-import { Logger } from '../../services/logger/index';
+import type { Logger } from '../../services/logger/index';
 import { parseRecordIdString, encodeRecordId, surql } from '../../utils/index';
-import { CacheRecord, QueryConfig } from './types';
-import { RecordVersionArray } from '../../types';
+import type { CacheRecord, QueryConfig } from './types';
+import type { RecordVersionArray } from '../../types';
 
 export * from './types';
 
@@ -43,7 +43,7 @@ export class CacheModule implements StreamUpdateReceiver {
       {
         queryHash: update.queryHash,
         arrayLength: update.localArray?.length,
-        Category: 'spooky-client::CacheModule::onStreamUpdate',
+        Category: 'sp00ky-client::CacheModule::onStreamUpdate',
       },
       'Stream update received'
     );
@@ -73,7 +73,7 @@ export class CacheModule implements StreamUpdateReceiver {
     this.logger.debug(
       {
         count: records.length,
-        Category: 'spooky-client::CacheModule::saveBatch',
+        Category: 'sp00ky-client::CacheModule::saveBatch',
       },
       'Saving record batch'
     );
@@ -85,7 +85,7 @@ export class CacheModule implements StreamUpdateReceiver {
           ...record,
           record: {
             ...record.record,
-            spooky_rv: record.version,
+            _00_rv: record.version,
           },
         };
       });
@@ -114,7 +114,7 @@ export class CacheModule implements StreamUpdateReceiver {
         await this.local.execute(query, params);
       }
 
-      // 2. Batch ingest into DBSP (use populatedRecords which has spooky_rv set)
+      // 2. Batch ingest into DBSP (use populatedRecords which has _00_rv set)
       for (const record of populatedRecords) {
         const recordId = encodeRecordId(record.record.id);
         this.versionLookups[recordId] = record.version;
@@ -122,12 +122,12 @@ export class CacheModule implements StreamUpdateReceiver {
       }
 
       this.logger.debug(
-        { count: records.length, Category: 'spooky-client::CacheModule::saveBatch' },
+        { count: records.length, Category: 'sp00ky-client::CacheModule::saveBatch' },
         'Batch saved successfully'
       );
     } catch (err) {
       this.logger.error(
-        { err, count: records.length, Category: 'spooky-client::CacheModule::saveBatch' },
+        { err, count: records.length, Category: 'sp00ky-client::CacheModule::saveBatch' },
         'Failed to save batch'
       );
       throw err;
@@ -137,9 +137,9 @@ export class CacheModule implements StreamUpdateReceiver {
   /**
    * Delete a record from local DB and ingest deletion into DBSP
    */
-  async delete(table: string, id: string, skipDbDelete: boolean = false): Promise<void> {
+  async delete(table: string, id: string, skipDbDelete: boolean = false, recordData: Record<string, any> = {}): Promise<void> {
     this.logger.debug(
-      { table, id, Category: 'spooky-client::CacheModule::delete' },
+      { table, id, Category: 'sp00ky-client::CacheModule::delete' },
       'Deleting record'
     );
 
@@ -149,17 +149,17 @@ export class CacheModule implements StreamUpdateReceiver {
         await this.local.query('DELETE $id', { id: parseRecordIdString(id) });
       }
 
-      // 2. Ingest deletion into DBSP
+      // 2. Ingest deletion into DBSP (pass record data so predicates can be matched)
       delete this.versionLookups[id];
-      await this.streamProcessor.ingest(table, 'DELETE', id, {});
+      this.streamProcessor.ingest(table, 'DELETE', id, recordData);
 
       this.logger.debug(
-        { table, id, Category: 'spooky-client::CacheModule::delete' },
+        { table, id, Category: 'sp00ky-client::CacheModule::delete' },
         'Record deleted successfully'
       );
     } catch (err) {
       this.logger.error(
-        { err, table, id, Category: 'spooky-client::CacheModule::delete' },
+        { err, table, id, Category: 'sp00ky-client::CacheModule::delete' },
         'Failed to delete record'
       );
       throw err;
@@ -175,7 +175,7 @@ export class CacheModule implements StreamUpdateReceiver {
       {
         queryHash: config.queryHash,
         surql: config.surql,
-        Category: 'spooky-client::CacheModule::registerQuery',
+        Category: 'sp00ky-client::CacheModule::registerQuery',
       },
       'Registering query'
     );
@@ -202,7 +202,7 @@ export class CacheModule implements StreamUpdateReceiver {
         {
           queryHash: config.queryHash,
           arrayLength: update.localArray?.length,
-          Category: 'spooky-client::CacheModule::registerQuery',
+          Category: 'sp00ky-client::CacheModule::registerQuery',
         },
         'Query registered successfully'
       );
@@ -210,7 +210,7 @@ export class CacheModule implements StreamUpdateReceiver {
       return { localArray: update.localArray };
     } catch (err) {
       this.logger.error(
-        { err, queryHash: config.queryHash, Category: 'spooky-client::CacheModule::registerQuery' },
+        { err, queryHash: config.queryHash, Category: 'sp00ky-client::CacheModule::registerQuery' },
         'Failed to register query'
       );
       throw err;
@@ -222,18 +222,18 @@ export class CacheModule implements StreamUpdateReceiver {
    */
   unregisterQuery(queryHash: string): void {
     this.logger.debug(
-      { queryHash, Category: 'spooky-client::CacheModule::unregisterQuery' },
+      { queryHash, Category: 'sp00ky-client::CacheModule::unregisterQuery' },
       'Unregistering query'
     );
     try {
       this.streamProcessor.unregisterQueryPlan(queryHash);
       this.logger.debug(
-        { queryHash, Category: 'spooky-client::CacheModule::unregisterQuery' },
+        { queryHash, Category: 'sp00ky-client::CacheModule::unregisterQuery' },
         'Query unregistered successfully'
       );
     } catch (err) {
       this.logger.error(
-        { err, queryHash, Category: 'spooky-client::CacheModule::unregisterQuery' },
+        { err, queryHash, Category: 'sp00ky-client::CacheModule::unregisterQuery' },
         'Failed to unregister query'
       );
     }

package/src/modules/cache/types.ts

@@ -1,5 +1,5 @@
-import { RecordId, Duration } from 'surrealdb';
-import { QueryTimeToLive, RecordVersionArray } from '../../types';
+import type { RecordId, Duration } from 'surrealdb';
+import type { QueryTimeToLive } from '../../types';
 
 export type RecordWithId = Record<string, any> & { id: RecordId<string> };
 

package/src/modules/data/index.ts

@@ -1,17 +1,16 @@
 import { RecordId, Duration } from 'surrealdb';
-import {
+import type {
   SchemaStructure,
   TableNames,
   BackendNames,
   BackendRoutes,
   RoutePayload,
 } from '@spooky-sync/query-builder';
-import { LocalDatabaseService } from '../../services/database/index';
-import { CacheModule, RecordWithId } from '../cache/index';
-import { Logger } from '../../services/logger/index';
-import { StreamUpdate } from '../../services/stream-processor/index';
-import {
-  MutationEvent,
+import type { LocalDatabaseService } from '../../services/database/index';
+import type { CacheModule, RecordWithId } from '../cache/index';
+import type { Logger } from '../../services/logger/index';
+import type { StreamUpdate } from '../../services/stream-processor/index';
+import type {
   QueryConfig,
   QueryHash,
   QueryState,
@@ -21,8 +20,7 @@ import {
   RecordVersionArray,
   QueryConfigRecord,
   UpdateOptions,
-  RunOptions,
-} from '../../types';
+  RunOptions} from '../../types';
 import {
   parseRecordIdString,
   extractIdPart,
@@ -34,8 +32,8 @@ import {
   extractTablePart,
   generateId,
 } from '../../utils/index';
-import { CreateEvent, DeleteEvent, UpdateEvent } from '../sync/index';
-import { PushEventOptions } from '../../events/index';
+import type { CreateEvent, DeleteEvent, UpdateEvent } from '../sync/index';
+import type { PushEventOptions } from '../../events/index';
 
 /**
  * DataModule - Unified query and mutation management
@@ -62,7 +60,7 @@ export class DataModule<S extends SchemaStructure> {
   }
 
   async init(): Promise<void> {
-    this.logger.info({ Category: 'spooky-client::DataModule::init' }, 'DataModule initialized');
+    this.logger.info({ Category: 'sp00ky-client::DataModule::init' }, 'DataModule initialized');
   }
 
   // ==================== QUERY MANAGEMENT ====================
@@ -78,15 +76,15 @@ export class DataModule<S extends SchemaStructure> {
   ): Promise<QueryHash> {
     const hash = await this.calculateHash({ surql: surqlString, params });
     this.logger.debug(
-      { hash, Category: 'spooky-client::DataModule::query' },
+      { hash, Category: 'sp00ky-client::DataModule::query' },
       'Query Initialization: started'
     );
 
-    const recordId = new RecordId('_spooky_query', hash);
+    const recordId = new RecordId('_00_query', hash);
 
     if (this.activeQueries.has(hash)) {
       this.logger.debug(
-        { hash, Category: 'spooky-client::DataModule::query' },
+        { hash, Category: 'sp00ky-client::DataModule::query' },
         'Query Initialization: exists, returning'
       );
       return hash;
@@ -95,7 +93,7 @@ export class DataModule<S extends SchemaStructure> {
     // Another call is already creating this query — wait for it
     if (this.pendingQueries.has(hash)) {
       this.logger.debug(
-        { hash, Category: 'spooky-client::DataModule::query' },
+        { hash, Category: 'sp00ky-client::DataModule::query' },
         'Query Initialization: pending, waiting for existing creation'
       );
       await this.pendingQueries.get(hash);
@@ -103,7 +101,7 @@ export class DataModule<S extends SchemaStructure> {
     }
 
     this.logger.debug(
-      { hash, Category: 'spooky-client::DataModule::query' },
+      { hash, Category: 'sp00ky-client::DataModule::query' },
       'Query Initialization: not found, creating new query'
     );
 
@@ -173,6 +171,7 @@ export class DataModule<S extends SchemaStructure> {
     if (op === 'UPDATE') {
       // Clear existing timer if any
       if (this.debounceTimers.has(queryHash)) {
+        // oxlint-disable-next-line no-non-null-assertion -- guarded by .has() check above
         clearTimeout(this.debounceTimers.get(queryHash)!);
       }
 
@@ -194,7 +193,7 @@ export class DataModule<S extends SchemaStructure> {
     const queryState = this.activeQueries.get(queryHash);
     if (!queryState) {
       this.logger.warn(
-        { queryHash, Category: 'spooky-client::DataModule::onStreamUpdate' },
+        { queryHash, Category: 'sp00ky-client::DataModule::onStreamUpdate' },
         'Received update for unknown query. Skipping...'
       );
       return;
@@ -221,7 +220,7 @@ export class DataModule<S extends SchemaStructure> {
       queryState.records = newRecords;
       if (prevJson === newJson) {
         this.logger.debug(
-          { queryHash, Category: 'spooky-client::DataModule::onStreamUpdate' },
+          { queryHash, Category: 'sp00ky-client::DataModule::onStreamUpdate' },
           'Query records unchanged, skipping notification'
         );
         return;
@@ -241,13 +240,13 @@ export class DataModule<S extends SchemaStructure> {
         {
           queryHash,
           recordCount: records?.length,
-          Category: 'spooky-client::DataModule::onStreamUpdate',
+          Category: 'sp00ky-client::DataModule::onStreamUpdate',
         },
         'Query updated from stream'
       );
     } catch (err) {
       this.logger.error(
-        { err, queryHash, Category: 'spooky-client::DataModule::onStreamUpdate' },
+        { err, queryHash, Category: 'sp00ky-client::DataModule::onStreamUpdate' },
         'Failed to fetch records for stream update'
       );
     }
@@ -278,7 +277,7 @@ export class DataModule<S extends SchemaStructure> {
     const queryState = this.activeQueries.get(id);
     if (!queryState) {
       this.logger.warn(
-        { id, Category: 'spooky-client::DataModule::updateQueryLocalArray' },
+        { id, Category: 'sp00ky-client::DataModule::updateQueryLocalArray' },
         'Query to update local array not found'
       );
       return;
@@ -294,7 +293,7 @@ export class DataModule<S extends SchemaStructure> {
     const queryState = this.getQueryByHash(hash);
     if (!queryState) {
       this.logger.warn(
-        { hash, Category: 'spooky-client::DataModule::updateQueryRemoteArray' },
+        { hash, Category: 'sp00ky-client::DataModule::updateQueryRemoteArray' },
         'Query to update remote array not found'
       );
       return;
@@ -370,6 +369,10 @@ export class DataModule<S extends SchemaStructure> {
       retry_strategy: options?.retry_strategy ?? 'linear',
     };
 
+    if (options?.timeout != null) {
+      record.timeout = options.timeout;
+    }
+
     if (options?.assignedTo) {
       record.assigned_to = options.assignedTo;
     }
@@ -392,7 +395,7 @@ export class DataModule<S extends SchemaStructure> {
 
     const rid = parseRecordIdString(id);
     const params = parseParams(tableSchema.columns, data);
-    const mutationId = parseRecordIdString(`_spooky_pending_mutations:${Date.now()}`);
+    const mutationId = parseRecordIdString(`_00_pending_mutations:${Date.now()}`);
 
     const dataKeys = Object.keys(params).map((key) => ({ key, variable: `data_${key}` }));
     const prefixedParams = Object.fromEntries(
@@ -441,7 +444,7 @@ export class DataModule<S extends SchemaStructure> {
       callback([mutationEvent]);
     }
 
-    this.logger.debug({ id, Category: 'spooky-client::DataModule::create' }, 'Record created');
+    this.logger.debug({ id, Category: 'sp00ky-client::DataModule::create' }, 'Record created');
 
     return target;
   }
@@ -463,7 +466,7 @@ export class DataModule<S extends SchemaStructure> {
 
     const rid = parseRecordIdString(id);
     const params = parseParams(tableSchema.columns, data);
-    const mutationId = parseRecordIdString(`_spooky_pending_mutations:${Date.now()}`);
+    const mutationId = parseRecordIdString(`_00_pending_mutations:${Date.now()}`);
 
     // Capture current record state before mutation for rollback support
     const [beforeRecord] = await withRetry(this.logger, () =>
@@ -472,7 +475,7 @@ export class DataModule<S extends SchemaStructure> {
 
     const query = surql.seal<{ target: T }>(
       surql.tx([
-        surql.updateSet('id', [{ statement: 'spooky_rv += 1' }]),
+        surql.updateSet('id', [{ statement: '_00_rv += 1' }]),
         surql.let('updated', surql.updateMerge('id', 'data')),
         surql.createMutation('update', 'mid', 'id', 'data'),
         surql.returnObject([{ key: 'target', variable: 'updated' }]),
@@ -496,8 +499,8 @@ export class DataModule<S extends SchemaStructure> {
         updatedFields[key] = (target as Record<string, any>)[key];
       }
     }
-    if ('spooky_rv' in (target as Record<string, any>)) {
-      updatedFields.spooky_rv = (target as Record<string, any>).spooky_rv;
+    if ('_00_rv' in (target as Record<string, any>)) {
+      updatedFields._00_rv = (target as Record<string, any>)._00_rv;
     }
     this.replaceRecordInQueries(updatedFields);
 
@@ -509,7 +512,7 @@ export class DataModule<S extends SchemaStructure> {
         table: table,
         op: 'UPDATE',
         record: parsedRecord,
-        version: target.spooky_rv as number,
+        version: target._00_rv as number,
       },
       true
     );
@@ -531,7 +534,7 @@ export class DataModule<S extends SchemaStructure> {
       callback([mutationEvent]);
     }
 
-    this.logger.debug({ id, Category: 'spooky-client::DataModule::update' }, 'Record updated');
+    this.logger.debug({ id, Category: 'sp00ky-client::DataModule::update' }, 'Record updated');
 
     return target;
   }
@@ -547,14 +550,29 @@ export class DataModule<S extends SchemaStructure> {
     }
 
     const rid = parseRecordIdString(id);
-    const mutationId = parseRecordIdString(`_spooky_pending_mutations:${Date.now()}`);
+    const mutationId = parseRecordIdString(`_00_pending_mutations:${Date.now()}`);
+
+    // Fetch the record before deleting so DBSP can match it against query predicates
+    const [beforeRecords] = await this.local.query<[Record<string, any>[]]>(
+      'SELECT * FROM ONLY $id',
+      { id: rid }
+    );
+    const beforeRecord = beforeRecords ?? {};
 
     const query = surql.seal<void>(
       surql.tx([surql.delete('id'), surql.createMutation('delete', 'mid', 'id')])
     );
 
     await withRetry(this.logger, () => this.local.execute(query, { id: rid, mid: mutationId }));
-    await this.cache.delete(table, id, true);
+    await this.cache.delete(table, id, true, beforeRecord);
+
+    // DBSP may not emit view updates for DELETE ops —
+    // manually notify all queries that reference this table
+    for (const [queryHash, queryState] of this.activeQueries) {
+      if (queryState.config.tableName === tableName) {
+        await this.notifyQuerySynced(queryHash);
+      }
+    }
 
     // Emit mutation event
     const mutationEvent: DeleteEvent = {
@@ -567,7 +585,7 @@ export class DataModule<S extends SchemaStructure> {
       callback([mutationEvent]);
     }
 
-    this.logger.debug({ id, Category: 'spooky-client::DataModule::delete' }, 'Record deleted');
+    this.logger.debug({ id, Category: 'sp00ky-client::DataModule::delete' }, 'Record deleted');
   }
 
   // ==================== ROLLBACK METHODS ====================
@@ -586,12 +604,12 @@ export class DataModule<S extends SchemaStructure> {
       this.removeRecordFromQueries(recordId);
 
       this.logger.info(
-        { id, tableName, Category: 'spooky-client::DataModule::rollbackCreate' },
+        { id, tableName, Category: 'sp00ky-client::DataModule::rollbackCreate' },
         'Rolled back optimistic create'
       );
     } catch (err) {
       this.logger.error(
-        { err, id, tableName, Category: 'spooky-client::DataModule::rollbackCreate' },
+        { err, id, tableName, Category: 'sp00ky-client::DataModule::rollbackCreate' },
         'Failed to rollback create'
       );
     }
@@ -626,7 +644,7 @@ export class DataModule<S extends SchemaStructure> {
           table: tableName,
           op: 'UPDATE',
           record: parsedRecord,
-          version: (beforeRecord.spooky_rv as number) || 1,
+          version: (beforeRecord._00_rv as number) || 1,
         },
         true
       );
@@ -635,12 +653,12 @@ export class DataModule<S extends SchemaStructure> {
       await this.replaceRecordInQueries(beforeRecord);
 
       this.logger.info(
-        { id, tableName, Category: 'spooky-client::DataModule::rollbackUpdate' },
+        { id, tableName, Category: 'sp00ky-client::DataModule::rollbackUpdate' },
         'Rolled back optimistic update'
       );
     } catch (err) {
       this.logger.error(
-        { err, id, tableName, Category: 'spooky-client::DataModule::rollbackUpdate' },
+        { err, id, tableName, Category: 'sp00ky-client::DataModule::rollbackUpdate' },
         'Failed to rollback update'
       );
     }
@@ -710,7 +728,7 @@ export class DataModule<S extends SchemaStructure> {
         hash,
         tableName,
         recordCount: queryState.records.length,
-        Category: 'spooky-client::DataModule::query',
+        Category: 'sp00ky-client::DataModule::query',
       },
       'Query registered'
     );
@@ -772,7 +790,7 @@ export class DataModule<S extends SchemaStructure> {
       records = result || [];
     } catch (err) {
       this.logger.warn(
-        { err, Category: 'spooky-client::DataModule::createNewQuery' },
+        { err, Category: 'sp00ky-client::DataModule::createNewQuery' },
         'Failed to load initial cached records'
       );
     }
@@ -804,7 +822,7 @@ export class DataModule<S extends SchemaStructure> {
       this.logger.debug(
         {
           id: encodeRecordId(queryState.config.id),
-          Category: 'spooky-client::DataModule::startTTLHeartbeat',
+          Category: 'sp00ky-client::DataModule::startTTLHeartbeat',
         },
         'TTL heartbeat'
       );
@@ -851,7 +869,7 @@ export function parseUpdateOptions(
     const delay = options.debounced !== true ? (options.debounced?.delay ?? 200) : 200;
     const keyType = options.debounced !== true ? (options.debounced?.key ?? id) : id;
     const key =
-      keyType === 'recordId_x_fields' ? `${id}::${Object.keys(data).sort().join('#')}` : id;
+      keyType === 'recordId_x_fields' ? `${id}::${Object.keys(data).toSorted().join('#')}` : id;
 
     pushEventOptions = {
       debounced: {

package/src/modules/devtools/index.ts

@@ -1,8 +1,8 @@
-import { LocalDatabaseService, RemoteDatabaseService } from '../../services/database/index';
-import { Logger } from '../../services/logger/index';
-import { SchemaStructure } from '@spooky-sync/query-builder';
+import type { LocalDatabaseService, RemoteDatabaseService } from '../../services/database/index';
+import type { Logger } from '../../services/logger/index';
+import type { SchemaStructure } from '@spooky-sync/query-builder';
 import { RecordId } from 'surrealdb';
-import { StreamUpdate, StreamUpdateReceiver } from '../../services/stream-processor/index';
+import type { StreamUpdate, StreamUpdateReceiver } from '../../services/stream-processor/index';
 import { encodeRecordId } from '../../utils/index';
 
 // DevTools interfaces (matching extension expectations)
@@ -13,8 +13,8 @@ export interface DevToolsEvent {
   payload: any;
 }
 
-import { DataModule } from '../data/index';
-import { AuthService } from '../auth/index';
+import type { DataModule } from '../data/index';
+import type { AuthService } from '../auth/index';
 import { AuthEventTypes } from '../auth/events/index';
 
 export class DevToolsService implements StreamUpdateReceiver {
@@ -37,7 +37,7 @@ export class DevToolsService implements StreamUpdateReceiver {
       this.notifyDevTools();
     });
 
-    this.logger.debug({ Category: 'spooky-client::DevToolsService::init' }, 'Service initialized');
+    this.logger.debug({ Category: 'sp00ky-client::DevToolsService::init' }, 'Service initialized');
   }
 
   // Get active queries directly from DataManager (single source of truth)
@@ -70,7 +70,7 @@ export class DevToolsService implements StreamUpdateReceiver {
 
   public onQueryInitialized(payload: any) {
     this.logger.debug(
-      { payload, Category: 'spooky-client::DevToolsService::onQueryInitialized' },
+      { payload, Category: 'sp00ky-client::DevToolsService::onQueryInitialized' },
       'QueryInitialized'
     );
     const queryHash = this.hashString(payload.queryId.toString());
@@ -87,7 +87,7 @@ export class DevToolsService implements StreamUpdateReceiver {
     this.logger.debug(
       {
         id: payload.queryId?.toString(),
-        Category: 'spooky-client::DevToolsService::onQueryUpdated',
+        Category: 'sp00ky-client::DevToolsService::onQueryUpdated',
       },
       'QueryUpdated'
     );
@@ -102,7 +102,7 @@ export class DevToolsService implements StreamUpdateReceiver {
 
   public onStreamUpdate(update: StreamUpdate) {
     this.logger.debug(
-      { update, Category: 'spooky-client::DevToolsService::onStreamUpdate' },
+      { update, Category: 'sp00ky-client::DevToolsService::onStreamUpdate' },
       'StreamUpdate'
     );
     this.addEvent('STREAM_UPDATE', {
@@ -171,8 +171,8 @@ export class DevToolsService implements StreamUpdateReceiver {
     if (typeof window !== 'undefined') {
       window.postMessage(
         {
-          type: 'SPOOKY_STATE_CHANGED',
-          source: 'spooky-devtools-page',
+          type: 'SP00KY_STATE_CHANGED',
+          source: 'sp00ky-devtools-page',
           state: this.getState(),
         },
         '*'
@@ -229,7 +229,7 @@ export class DevToolsService implements StreamUpdateReceiver {
 
   private exposeToWindow() {
     if (typeof window !== 'undefined') {
-      (window as any).__SPOOKY__ = {
+      (window as any).__00__ = {
         version: this.version,
         getState: () => this.getState(),
         clearHistory: () => {
@@ -270,7 +270,7 @@ export class DevToolsService implements StreamUpdateReceiver {
             return this.serializeForDevTools(records) || [];
           } catch (e) {
             this.logger.error(
-              { err: e, Category: 'spooky-client::DevToolsService::exposeToWindow' },
+              { err: e, Category: 'sp00ky-client::DevToolsService::exposeToWindow' },
               'Failed to get table data'
             );
             return [];
@@ -299,7 +299,7 @@ export class DevToolsService implements StreamUpdateReceiver {
         runQuery: async (query: string, target: 'local' | 'remote' = 'local') => {
           try {
             this.logger.debug(
-              { query, target, Category: 'spooky-client::DevToolsService::runQuery' },
+              { query, target, Category: 'sp00ky-client::DevToolsService::runQuery' },
               'Running query (START)'
             );
             const service = target === 'remote' ? this.remoteDatabaseService : this.databaseService;
@@ -314,7 +314,7 @@ export class DevToolsService implements StreamUpdateReceiver {
                 time: queryTime,
                 resultType: typeof result,
                 isArray: Array.isArray(result),
-                Category: 'spooky-client::DevToolsService::runQuery',
+                Category: 'sp00ky-client::DevToolsService::runQuery',
               },
               'Database returned result'
             );
@@ -328,7 +328,7 @@ export class DevToolsService implements StreamUpdateReceiver {
               {
                 serializeTime,
                 serializedLength: JSON.stringify(serialized).length,
-                Category: 'spooky-client::DevToolsService::runQuery',
+                Category: 'sp00ky-client::DevToolsService::runQuery',
               },
               'Serialization complete'
             );
@@ -340,7 +340,7 @@ export class DevToolsService implements StreamUpdateReceiver {
             };
           } catch (e: any) {
             this.logger.error(
-              { err: e, query, target, Category: 'spooky-client::DevToolsService::runQuery' },
+              { err: e, query, target, Category: 'sp00ky-client::DevToolsService::runQuery' },
               'Query execution failed'
             );
             // Ensure we always return a string for error
@@ -353,12 +353,15 @@ export class DevToolsService implements StreamUpdateReceiver {
 
       window.postMessage(
         {
-          type: 'SPOOKY_DETECTED',
-          source: 'spooky-devtools-page',
+          type: 'SP00KY_DETECTED',
+          source: 'sp00ky-devtools-page',
           data: { version: this.version, detected: true },
         },
         '*'
       );
+
+      // Dispatch custom event so the devtools page-script can detect late initialization
+      window.dispatchEvent(new CustomEvent('sp00ky:init'));
     }
   }
 }