@spooky-sync/core 0.0.1-canary.6 → 0.0.1-canary.61

package/src/services/stream-processor/index.ts

@@ -1,10 +1,11 @@
-import init, { SpookyProcessor } from '@spooky-sync/ssp-wasm';
-import { EventDefinition, EventSystem } from '../../events/index';
-import { Logger } from 'pino';
-import { LocalDatabaseService } from '../database/index';
-import { WasmProcessor, WasmStreamUpdate } from './wasm-types';
-import { Duration } from 'surrealdb';
-import { PersistenceClient, QueryTimeToLive, RecordVersionArray } from '../../types';
+// oxlint-disable-next-line no-named-as-default -- WASM module default export convention
+import init, { Sp00kyProcessor } from '@spooky-sync/ssp-wasm';
+import type { EventDefinition, EventSystem } from '../../events/index';
+import type { Logger } from 'pino';
+import type { LocalDatabaseService } from '../database/index';
+import type { WasmProcessor, WasmStreamUpdate } from './wasm-types';
+import type { Duration } from 'surrealdb';
+import type { PersistenceClient, QueryTimeToLive, RecordVersionArray } from '../../types';
 
 // Simple interface for query plan registration (replaces Incantation class)
 interface QueryPlanConfig {
@@ -80,25 +81,25 @@ export class StreamProcessorService {
     if (this.isInitialized) return;
 
     this.logger.info(
-      { Category: 'spooky-client::StreamProcessorService::init' },
+      { Category: 'sp00ky-client::StreamProcessorService::init' },
       'Initializing WASM...'
     );
     try {
       await init(); // Initialize the WASM module (web target)
-      // We cast the generated SpookyProcessor to our interface which is safer
-      this.processor = new SpookyProcessor() as unknown as WasmProcessor;
+      // We cast the generated Sp00kyProcessor to our interface which is safer
+      this.processor = new Sp00kyProcessor() as unknown as WasmProcessor;
 
       // Try to load state
       await this.loadState();
 
       this.isInitialized = true;
       this.logger.info(
-        { Category: 'spooky-client::StreamProcessorService::init' },
+        { Category: 'sp00ky-client::StreamProcessorService::init' },
         'Initialized successfully'
       );
     } catch (e) {
       this.logger.error(
-        { error: e, Category: 'spooky-client::StreamProcessorService::init' },
+        { error: e, Category: 'sp00ky-client::StreamProcessorService::init' },
         'Failed to initialize'
       );
       throw e;
@@ -108,7 +109,7 @@ export class StreamProcessorService {
   async loadState() {
     if (!this.processor) return;
     try {
-      const result = await this.persistenceClient.get('_spooky_stream_processor_state');
+      const result = await this.persistenceClient.get('_00_stream_processor_state');
 
       // Check if we have a valid result from the query
       if (
@@ -122,7 +123,7 @@ export class StreamProcessorService {
         this.logger.info(
           {
             stateLength: state.length,
-            Category: 'spooky-client::StreamProcessorService::loadState',
+            Category: 'sp00ky-client::StreamProcessorService::loadState',
           },
           'Loading state from DB'
         );
@@ -132,19 +133,19 @@ export class StreamProcessorService {
           (this.processor as any).load_state(state);
         } else {
           this.logger.warn(
-            { Category: 'spooky-client::StreamProcessorService::loadState' },
+            { Category: 'sp00ky-client::StreamProcessorService::loadState' },
             'load_state method not found on processor'
           );
         }
       } else {
         this.logger.info(
-          { Category: 'spooky-client::StreamProcessorService::loadState' },
+          { Category: 'sp00ky-client::StreamProcessorService::loadState' },
           'No saved state found'
         );
       }
     } catch (e) {
       this.logger.error(
-        { error: e, Category: 'spooky-client::StreamProcessorService::loadState' },
+        { error: e, Category: 'sp00ky-client::StreamProcessorService::loadState' },
         'Failed to load state'
       );
     }
@@ -157,16 +158,16 @@ export class StreamProcessorService {
       if (typeof (this.processor as any).save_state === 'function') {
         const state = (this.processor as any).save_state();
         if (state) {
-          await this.persistenceClient.set('_spooky_stream_processor_state', state);
+          await this.persistenceClient.set('_00_stream_processor_state', state);
           this.logger.trace(
-            { Category: 'spooky-client::StreamProcessorService::saveState' },
+            { Category: 'sp00ky-client::StreamProcessorService::saveState' },
             'State saved'
           );
         }
       }
     } catch (e) {
       this.logger.error(
-        { error: e, Category: 'spooky-client::StreamProcessorService::saveState' },
+        { error: e, Category: 'sp00ky-client::StreamProcessorService::saveState' },
         'Failed to save state'
       );
     }
@@ -188,14 +189,14 @@ export class StreamProcessorService {
         table,
         op,
         id,
-        Category: 'spooky-client::StreamProcessorService::ingest',
+        Category: 'sp00ky-client::StreamProcessorService::ingest',
       },
       'Ingesting into ssp'
     );
 
     if (!this.processor) {
       this.logger.warn(
-        { Category: 'spooky-client::StreamProcessorService::ingest' },
+        { Category: 'sp00ky-client::StreamProcessorService::ingest' },
         'Not initialized, skipping ingest'
       );
       return [];
@@ -211,7 +212,7 @@ export class StreamProcessorService {
           op,
           id,
           rawUpdates: rawUpdates.length,
-          Category: 'spooky-client::StreamProcessorService::ingest',
+          Category: 'sp00ky-client::StreamProcessorService::ingest',
         },
         'Ingesting into ssp done'
       );
@@ -229,7 +230,7 @@ export class StreamProcessorService {
       return rawUpdates;
     } catch (e) {
       this.logger.error(
-        { error: e, Category: 'spooky-client::StreamProcessorService::ingest' },
+        { error: e, Category: 'sp00ky-client::StreamProcessorService::ingest' },
         'Ingesting into ssp failed'
       );
     }
@@ -243,7 +244,7 @@ export class StreamProcessorService {
   registerQueryPlan(queryPlan: QueryPlanConfig) {
     if (!this.processor) {
       this.logger.warn(
-        { Category: 'spooky-client::StreamProcessorService::registerQueryPlan' },
+        { Category: 'sp00ky-client::StreamProcessorService::registerQueryPlan' },
         'Not initialized, skipping registration'
       );
       return;
@@ -254,7 +255,7 @@ export class StreamProcessorService {
         queryHash: queryPlan.queryHash,
         surql: queryPlan.surql,
         params: queryPlan.params,
-        Category: 'spooky-client::StreamProcessorService::registerQueryPlan',
+        Category: 'sp00ky-client::StreamProcessorService::registerQueryPlan',
       },
       'Registering query plan'
     );
@@ -272,7 +273,7 @@ export class StreamProcessorService {
       });
 
       this.logger.debug(
-        { initialUpdate, Category: 'spooky-client::StreamProcessorService::registerQueryPlan' },
+        { initialUpdate, Category: 'sp00ky-client::StreamProcessorService::registerQueryPlan' },
         'register_view result'
       );
 
@@ -289,14 +290,14 @@ export class StreamProcessorService {
           queryHash: queryPlan.queryHash,
           surql: queryPlan.surql,
           params: queryPlan.params,
-          Category: 'spooky-client::StreamProcessorService::registerQueryPlan',
+          Category: 'sp00ky-client::StreamProcessorService::registerQueryPlan',
         },
         'Registered query plan'
       );
       return update;
     } catch (e) {
       this.logger.error(
-        { error: e, Category: 'spooky-client::StreamProcessorService::registerQueryPlan' },
+        { error: e, Category: 'sp00ky-client::StreamProcessorService::registerQueryPlan' },
         'Error registering query plan'
       );
       throw e;
@@ -313,7 +314,7 @@ export class StreamProcessorService {
       this.saveState();
     } catch (e) {
       this.logger.error(
-        { error: e, Category: 'spooky-client::StreamProcessorService::unregisterQueryPlan' },
+        { error: e, Category: 'sp00ky-client::StreamProcessorService::unregisterQueryPlan' },
         'Error unregistering query plan'
       );
     }
@@ -334,7 +335,7 @@ export class StreamProcessorService {
       if (hasTable && hasId && hasToString && isNotPlainObject) {
         const result = value.toString();
         this.logger.trace(
-          { result, Category: 'spooky-client::StreamProcessorService::normalizeValue' },
+          { result, Category: 'sp00ky-client::StreamProcessorService::normalizeValue' },
           'RecordId detected'
         );
         return result;

package/src/services/stream-processor/stream-processor.test.ts

@@ -127,7 +127,7 @@ describe('StreamProcessor Ingest Behavior', () => {
     const params = { id: new MockRecordId('user', '2dng4ngbicbl0scod87i') };
     const normalizedParams = normalizeValue(params);
 
-    const ingestedRecord = {
+    const _ingestedRecord = {
       id: 'user:2dng4ngbicbl0scod87i',
       username: 'sara',
     };

package/src/services/stream-processor/wasm-types.ts

@@ -1,4 +1,4 @@
-import { RecordVersionArray } from '../../types';
+import type { RecordVersionArray } from '../../types';
 
 export interface WasmStreamUpdate {
   query_id: string;
@@ -23,7 +23,7 @@ export interface WasmIngestItem {
   version?: number;
 }
 
-// Interface matching the SpookyProcessor class from WASM
+// Interface matching the Sp00kyProcessor class from WASM
 export interface WasmProcessor {
   ingest(table: string, op: string, id: string, record: any): WasmStreamUpdate[];
   register_view(config: WasmQueryConfig): WasmStreamUpdate | undefined;

package/src/{spooky.ts → sp00ky.ts}

@@ -1,24 +1,21 @@
 import { DataModule } from './modules/data/index';
-import {
-  SpookyConfig,
+import type {
+  Sp00kyConfig,
   QueryTimeToLive,
-  SpookyQueryResultPromise,
+  Sp00kyQueryResultPromise,
   PersistenceClient,
-  MutationEvent,
   UpdateOptions,
-  RunOptions,
-} from './types';
+  RunOptions} from './types';
 import {
   LocalDatabaseService,
   LocalMigrator,
   RemoteDatabaseService,
 } from './services/database/index';
-import { Surreal } from 'surrealdb';
-import { SpookySync, UpEvent } from './modules/sync/index';
-import {
+import type { UpEvent } from './modules/sync/index';
+import { Sp00kySync } from './modules/sync/index';
+import type {
   GetTable,
   InnerQuery,
-  QueryBuilder,
   QueryOptions,
   SchemaStructure,
   TableModel,
@@ -26,7 +23,9 @@ import {
   BucketNames,
   BackendNames,
   BackendRoutes,
-  RoutePayload,
+  RoutePayload} from '@spooky-sync/query-builder';
+import {
+  QueryBuilder
 } from '@spooky-sync/query-builder';
 
 import { DevToolsService } from './modules/devtools/index';
@@ -35,9 +34,11 @@ import { AuthService } from './modules/auth/index';
 import { StreamProcessorService } from './services/stream-processor/index';
 import { EventSystem } from './events/index';
 import { CacheModule } from './modules/cache/index';
+import { CrdtManager, CrdtField } from './modules/crdt/index';
 import { LocalStoragePersistenceClient } from './services/persistence/localstorage';
 import { generateId, parseParams } from './utils/index';
 import { SurrealDBPersistenceClient } from './services/persistence/surrealdb';
+import { ResilientPersistenceClient } from './services/persistence/resilient';
 
 export class BucketHandle {
   constructor(private bucketName: string, private remote: RemoteDatabaseService) {}
@@ -80,7 +81,7 @@ export class BucketHandle {
   }
 }
 
-export class SpookyClient<S extends SchemaStructure> {
+export class Sp00kyClient<S extends SchemaStructure> {
   private local: LocalDatabaseService;
   private remote: RemoteDatabaseService;
   private persistenceClient: PersistenceClient;
@@ -88,8 +89,9 @@ export class SpookyClient<S extends SchemaStructure> {
   private migrator: LocalMigrator;
   private cache: CacheModule;
   private dataModule: DataModule<S>;
-  private sync: SpookySync<S>;
+  private sync: Sp00kySync<S>;
   private devTools: DevToolsService;
+  private crdtManager: CrdtManager;
 
   private logger: ReturnType<typeof createLogger>;
   public auth: AuthService<S>;
@@ -111,16 +113,16 @@ export class SpookyClient<S extends SchemaStructure> {
     return this.sync.subscribeToPendingMutations(cb);
   }
 
-  constructor(private config: SpookyConfig<S>) {
-    const logger = createLogger(config.logLevel ?? 'info', config.otelEndpoint);
-    this.logger = logger.child({ service: 'SpookyClient' });
+  constructor(private config: Sp00kyConfig<S>) {
+    const logger = createLogger(config.logLevel ?? 'info', config.otelTransmit);
+    this.logger = logger.child({ service: 'Sp00kyClient' });
 
     this.logger.info(
       {
         config: { ...config, schema: '[SchemaStructure]' },
-        Category: 'spooky-client::SpookyClient::constructor',
+        Category: 'sp00ky-client::Sp00kyClient::constructor',
       },
-      'SpookyClient initialized'
+      'Sp00kyClient initialized'
     );
 
     this.local = new LocalDatabaseService(this.config.database, logger);
@@ -134,6 +136,8 @@ export class SpookyClient<S extends SchemaStructure> {
       this.persistenceClient = config.persistenceClient;
     }
 
+    this.persistenceClient = new ResilientPersistenceClient(this.persistenceClient, logger);
+
     this.streamProcessor = new StreamProcessorService(
       new EventSystem(['stream_update']),
       this.local,
@@ -152,6 +156,9 @@ export class SpookyClient<S extends SchemaStructure> {
       logger
     );
 
+    // Initialize CRDT Manager (needs remote for _00_crdt LIVE SELECT)
+    this.crdtManager = new CrdtManager(this.config.schema, this.remote, logger);
+
     this.dataModule = new DataModule(
       this.cache,
       this.local,
@@ -164,7 +171,7 @@ export class SpookyClient<S extends SchemaStructure> {
     this.auth = new AuthService(this.config.schema, this.remote, this.persistenceClient, logger);
 
     // Initialize Sync
-    this.sync = new SpookySync(this.local, this.remote, this.cache, this.dataModule, this.config.schema, this.logger);
+    this.sync = new Sp00kySync(this.local, this.remote, this.cache, this.dataModule, this.config.schema, this.logger);
 
     // Initialize DevTools
     this.devTools = new DevToolsService(
@@ -215,64 +222,65 @@ export class SpookyClient<S extends SchemaStructure> {
 
   async init() {
     this.logger.info(
-      { Category: 'spooky-client::SpookyClient::init' },
-      'SpookyClient initialization started'
+      { Category: 'sp00ky-client::Sp00kyClient::init' },
+      'Sp00kyClient initialization started'
     );
     try {
       const clientId = this.config.clientId ?? (await this.loadOrGenerateClientId());
       this.persistClientId(clientId);
       this.logger.debug(
-        { clientId, Category: 'spooky-client::SpookyClient::init' },
+        { clientId, Category: 'sp00ky-client::Sp00kyClient::init' },
         'Client ID loaded'
       );
 
       await this.local.connect();
       this.logger.debug(
-        { Category: 'spooky-client::SpookyClient::init' },
+        { Category: 'sp00ky-client::Sp00kyClient::init' },
         'Local database connected'
       );
 
       await this.migrator.provision(this.config.schemaSurql);
-      this.logger.debug({ Category: 'spooky-client::SpookyClient::init' }, 'Schema provisioned');
+      this.logger.debug({ Category: 'sp00ky-client::Sp00kyClient::init' }, 'Schema provisioned');
 
       await this.remote.connect();
       this.logger.debug(
-        { Category: 'spooky-client::SpookyClient::init' },
+        { Category: 'sp00ky-client::Sp00kyClient::init' },
         'Remote database connected'
       );
 
       await this.streamProcessor.init();
       this.logger.debug(
-        { Category: 'spooky-client::SpookyClient::init' },
+        { Category: 'sp00ky-client::Sp00kyClient::init' },
         'StreamProcessor initialized'
       );
 
       await this.auth.init();
-      this.logger.debug({ Category: 'spooky-client::SpookyClient::init' }, 'Auth initialized');
+      this.logger.debug({ Category: 'sp00ky-client::Sp00kyClient::init' }, 'Auth initialized');
 
       await this.dataModule.init();
       this.logger.debug(
-        { Category: 'spooky-client::SpookyClient::init' },
+        { Category: 'sp00ky-client::Sp00kyClient::init' },
         'DataModule initialized'
       );
 
       await this.sync.init(clientId);
-      this.logger.debug({ Category: 'spooky-client::SpookyClient::init' }, 'Sync initialized');
+      this.logger.debug({ Category: 'sp00ky-client::Sp00kyClient::init' }, 'Sync initialized');
 
       this.logger.info(
-        { Category: 'spooky-client::SpookyClient::init' },
-        'SpookyClient initialization completed successfully'
+        { Category: 'sp00ky-client::Sp00kyClient::init' },
+        'Sp00kyClient initialization completed successfully'
       );
     } catch (e) {
       this.logger.error(
-        { error: e, Category: 'spooky-client::SpookyClient::init' },
-        'SpookyClient initialization failed'
+        { error: e, Category: 'sp00ky-client::Sp00kyClient::init' },
+        'Sp00kyClient initialization failed'
       );
       throw e;
     }
   }
 
   async close() {
+    this.crdtManager.closeAll();
     await this.local.close();
     await this.remote.close();
   }
@@ -281,6 +289,27 @@ export class SpookyClient<S extends SchemaStructure> {
     return this.remote.getClient().authenticate(token);
   }
 
+  /**
+   * Open a CRDT field for collaborative editing.
+   * Returns a CrdtField with a LoroDoc that can be bound to any editor.
+   * Also starts a LIVE SELECT on _00_crdt for real-time sync.
+   */
+  async openCrdtField(
+    table: string,
+    recordId: string,
+    field: string,
+    fallbackText?: string,
+  ): Promise<CrdtField> {
+    return this.crdtManager.open(table, recordId, field, fallbackText);
+  }
+
+  /**
+   * Close a CRDT field when editing is done.
+   */
+  closeCrdtField(table: string, recordId: string, field: string): void {
+    this.crdtManager.close(table, recordId, field);
+  }
+
   deauthenticate() {
     return this.remote.getClient().invalidate();
   }
@@ -289,8 +318,8 @@ export class SpookyClient<S extends SchemaStructure> {
     table: Table,
     options: QueryOptions<TableModel<GetTable<S, Table>>, false>,
     ttl: QueryTimeToLive = '10m'
-  ): QueryBuilder<S, Table, SpookyQueryResultPromise> {
-    return new QueryBuilder<S, Table, SpookyQueryResultPromise>(
+  ): QueryBuilder<S, Table, Sp00kyQueryResultPromise> {
+    return new QueryBuilder<S, Table, Sp00kyQueryResultPromise>(
       this.config.schema,
       table,
       async (q) => ({
@@ -369,17 +398,17 @@ export class SpookyClient<S extends SchemaStructure> {
 
   private persistClientId(id: string) {
     try {
-      this.persistenceClient.set('spooky_client_id', id);
+      this.persistenceClient.set('sp00ky_client_id', id);
     } catch (e) {
       this.logger.warn(
-        { error: e, Category: 'spooky-client::SpookyClient::persistClientId' },
+        { error: e, Category: 'sp00ky-client::Sp00kyClient::persistClientId' },
         'Failed to persist client ID'
       );
     }
   }
 
   private async loadOrGenerateClientId(): Promise<string> {
-    const clientId = await this.persistenceClient.get<string>('spooky_client_id');
+    const clientId = await this.persistenceClient.get<string>('sp00ky_client_id');
 
     if (clientId) {
       return clientId;

package/src/types.ts

@@ -1,9 +1,14 @@
-import { RecordId, SchemaStructure } from '@spooky-sync/query-builder';
-import { Level } from 'pino';
-import { PushEventOptions } from './events/index';
-import { UpEvent } from './modules/sync/index';
+import type { RecordId, SchemaStructure } from '@spooky-sync/query-builder';
+import type { Level, LoggerOptions } from 'pino';
+import type { PushEventOptions } from './events/index';
+import type { UpEvent } from './modules/sync/index';
 
-export type { Level } from 'pino';
+export type { Level };
+
+/**
+ * A pino browser transmit object for forwarding logs to an external sink (e.g. OpenTelemetry).
+ */
+export type PinoTransmit = NonNullable<NonNullable<LoggerOptions['browser']>['transmit']>;
 
 /**
  * The type of storage backend to use for the local database.
@@ -65,22 +70,22 @@ export type QueryTimeToLive =
 /**
  * Result object returned when a query is registered or executed.
  */
-export interface SpookyQueryResult {
+export interface Sp00kyQueryResult {
   /** The unique hash identifier for the query. */
   hash: string;
 }
 
-export type SpookyQueryResultPromise = Promise<SpookyQueryResult>;
+export type Sp00kyQueryResultPromise = Promise<Sp00kyQueryResult>;
 
 export interface EventSubscriptionOptions {
   priority?: number;
 }
 
 /**
- * Configuration options for the Spooky client.
+ * Configuration options for the Sp00ky client.
  * @template S The schema structure type.
  */
-export interface SpookyConfig<S extends SchemaStructure> {
+export interface Sp00kyConfig<S extends SchemaStructure> {
   /** Database connection configuration. */
   database: {
     /** The SurrealDB endpoint URL. */
@@ -107,8 +112,8 @@ export interface SpookyConfig<S extends SchemaStructure> {
    * Can be a custom implementation, 'surrealdb' (default), or 'localstorage'.
    */
   persistenceClient?: PersistenceClient | 'surrealdb' | 'localstorage';
-  /** OpenTelemetry collector endpoint for telemetry data. */
-  otelEndpoint?: string;
+  /** A pino browser transmit object for forwarding logs (e.g. via @spooky-sync/core/otel). */
+  otelTransmit?: PinoTransmit;
   /**
    * Debounce time in milliseconds for stream updates.
    * Defaults to 100ms.
@@ -209,6 +214,8 @@ export interface RunOptions {
   assignedTo?: string;
   max_retries?: number;
   retry_strategy?: 'linear' | 'exponential';
+  /** Timeout in seconds for the backend HTTP call. Only used if the backend allows timeout override. */
+  timeout?: number;
 }
 
 /**

package/src/utils/index.ts

@@ -1,7 +1,7 @@
-import { GetTable, SchemaStructure, TableModel, TableNames } from '@spooky-sync/query-builder';
+import type { GetTable, SchemaStructure, TableModel, TableNames } from '@spooky-sync/query-builder';
 import { Uuid, RecordId, Duration } from 'surrealdb';
-import { Logger } from '../services/logger/index';
-import { QueryTimeToLive } from '../types';
+import type { Logger } from '../services/logger/index';
+import type { QueryTimeToLive } from '../types';
 
 export * from './surql';
 export * from './parser';
@@ -59,7 +59,7 @@ export function generateNewTableId<S extends SchemaStructure, T extends TableNam
 
 // ==================== SCHEMA ENCODING/DECODING ====================
 
-export function decodeFromSpooky<S extends SchemaStructure, T extends TableNames<S>>(
+export function decodeFromSp00ky<S extends SchemaStructure, T extends TableNames<S>>(
   schema: S,
   tableName: T,
   record: TableModel<GetTable<S, T>>
@@ -74,19 +74,19 @@ export function decodeFromSpooky<S extends SchemaStructure, T extends TableNames
   for (const field of Object.keys(table.columns)) {
     const column = table.columns[field] as any;
     const relation = schema.relationships.find((r) => r.from === tableName && r.field === field);
-    if ((column.recordId || relation) && encoded[field] != null) {
+    if ((column.recordId || relation) && encoded[field] !== null && encoded[field] !== undefined) {
       if (encoded[field] instanceof RecordId) {
         encoded[field] = `${encoded[field].table.toString()}:${encoded[field].id}`;
       } else if (
         relation &&
-        (encoded[field] instanceof Object || encoded[field] instanceof Array)
+        (encoded[field] instanceof Object || Array.isArray(encoded[field]))
       ) {
         if (Array.isArray(encoded[field])) {
           encoded[field] = encoded[field].map((item) =>
-            decodeFromSpooky(schema, relation.to, item)
+            decodeFromSp00ky(schema, relation.to, item)
           );
         } else {
-          encoded[field] = decodeFromSpooky(schema, relation.to, encoded[field]);
+          encoded[field] = decodeFromSp00ky(schema, relation.to, encoded[field]);
         }
       }
     }
@@ -117,7 +117,7 @@ export function parseDuration(duration: QueryTimeToLive | Duration): number {
 
   const match = duration.match(/^(\d+)([smh])$/);
   if (!match) return 600000;
-  const val = parseInt(match[1], 10);
+  const val = Number.parseInt(match[1], 10);
   const unit = match[2];
   switch (unit) {
     case 's':
@@ -137,6 +137,18 @@ export async function fileToUint8Array(file: File | Blob): Promise<Uint8Array> {
   return new Uint8Array(buffer);
 }
 
+// ==================== TEXT UTILITIES ====================
+
+/**
+ * Convert plain text to simple HTML paragraphs.
+ * Useful for seeding a rich-text editor (e.g. TipTap/ProseMirror) with fallback content.
+ */
+export function textToHtml(text: string): string {
+  return text
+    .replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
+    .split('\n').map((l) => `<p>${l || '<br>'}</p>`).join('');
+}
+
 // ==================== DATABASE UTILITIES ====================
 
 /**
@@ -165,7 +177,7 @@ export async function withRetry<T>(
             attempt: i + 1,
             retries,
             error: msg,
-            Category: 'spooky-client::utils::withRetry',
+            Category: 'sp00ky-client::utils::withRetry',
           },
           'Retrying DB operation'
         );

package/src/utils/parser.ts

@@ -1,4 +1,5 @@
-import { ColumnSchema, RecordId } from '@spooky-sync/query-builder';
+import type { ColumnSchema} from '@spooky-sync/query-builder';
+import { RecordId } from '@spooky-sync/query-builder';
 import { parseRecordIdString } from './index';
 import { DateTime } from 'surrealdb';
 
@@ -8,7 +9,7 @@ export function cleanRecord(
 ): Record<string, any> {
   const cleaned: Record<string, any> = {};
   for (const [key, value] of Object.entries(record)) {
-    if (key === 'id' || key in tableSchema) {
+    if (key === 'id' || key.startsWith('_00_') || key in tableSchema) {
       cleaned[key] = value;
     }
   }