@spooky-sync/core 0.0.1-canary.9 → 0.0.1-canary.90

package/src/modules/auth/index.ts

@@ -1,17 +1,14 @@
-import { RemoteDatabaseService } from '../../services/database/remote';
-import { LocalDatabaseService } from '../../services/database/local';
-import { DataModule } from '../data/index';
-import {
+import type { RemoteDatabaseService } from '../../services/database/remote';
+import type {
   SchemaStructure,
   AccessDefinition,
   ColumnSchema,
   TypeNameToTypeMap,
 } from '@spooky-sync/query-builder';
-import { Logger } from '../../services/logger/index';
-import { encodeRecordId } from '../../utils/index';
+import type { Logger } from '../../services/logger/index';
 export * from './events/index';
 import { AuthEventTypes, createAuthEventSystem } from './events/index';
-import { PersistenceClient } from '../../types';
+import type { PersistenceClient } from '../../types';
 
 // Helper to pretty print types
 type Prettify<T> = {
@@ -38,11 +35,41 @@ type ExtractAccessParams<
       }>
     : never;
 
+/**
+ * Read the `AC` (access-method name) claim from a SurrealDB record-access
+ * JWT without verifying it — we only need the claim, the server enforces the
+ * token. Returns null on any malformed input. The in-browser SSP needs this
+ * to resolve `$access` in table permission predicates (mirrors the session's
+ * `$access` that the server's `fn::query::register` reads).
+ */
+function decodeAccessFromToken(token: string): string | null {
+  try {
+    const payload = token.split('.')[1];
+    if (!payload) return null;
+    let b64 = payload.replace(/-/g, '+').replace(/_/g, '/');
+    b64 += '='.repeat((4 - (b64.length % 4)) % 4);
+    const json =
+      typeof atob === 'function' ? atob(b64) : Buffer.from(b64, 'base64').toString('binary');
+    const claims = JSON.parse(json) as Record<string, unknown>;
+    const ac = claims.AC ?? claims.ac;
+    return typeof ac === 'string' ? ac : null;
+  } catch {
+    return null;
+  }
+}
+
 export class AuthService<S extends SchemaStructure> {
   // State
   public token: string | null = null;
   public currentUser: any | null = null;
   public isAuthenticated: boolean = false;
+  /**
+   * The record-access method name for the current session (e.g. `"account"`),
+   * derived from the token's `AC` claim. Consumed by the in-browser SSP's
+   * permission injection so `$access`-gated table predicates resolve locally,
+   * mirroring the server's `$access`. Null when logged out.
+   */
+  public access: string | null = null;
   public isLoading: boolean = true;
 
   private events = createAuthEventSystem();
@@ -95,11 +122,11 @@ export class AuthService<S extends SchemaStructure> {
     this.isLoading = true;
 
     try {
-      const token = accessToken || (await this.persistenceClient.get<string>('spooky_auth_token'));
+      const token = accessToken || (await this.persistenceClient.get<string>('sp00ky_auth_token'));
 
       if (!token) {
         this.logger.debug(
-          { Category: 'spooky-client::AuthService::check' },
+          { Category: 'sp00ky-client::AuthService::check' },
           'No token found in storage or arguments'
         );
         this.isLoading = false;
@@ -119,13 +146,13 @@ export class AuthService<S extends SchemaStructure> {
 
       if (user && user.id) {
         this.logger.info(
-          { user, Category: 'spooky-client::AuthService::check' },
+          { user, Category: 'sp00ky-client::AuthService::check' },
           'Auth check complete (via $auth.id)'
         );
         await this.setSession(token, user);
       } else {
         this.logger.warn(
-          { Category: 'spooky-client::AuthService::check' },
+          { Category: 'sp00ky-client::AuthService::check' },
           '$auth.id empty, attempting manual user fetch'
         );
 
@@ -140,13 +167,13 @@ export class AuthService<S extends SchemaStructure> {
 
         if (manualUser && manualUser.id) {
           this.logger.info(
-            { user: manualUser, Category: 'spooky-client::AuthService::check' },
+            { user: manualUser, Category: 'sp00ky-client::AuthService::check' },
             'Auth check complete (via manual fetch)'
           );
           await this.setSession(token, manualUser);
         } else {
           this.logger.warn(
-            { Category: 'spooky-client::AuthService::check' },
+            { Category: 'sp00ky-client::AuthService::check' },
             'Token valid but user not found via fallback'
           );
           await this.signOut();
@@ -154,7 +181,7 @@ export class AuthService<S extends SchemaStructure> {
       }
     } catch (error) {
       this.logger.error(
-        { error, stack: (error as Error).stack, Category: 'spooky-client::AuthService::check' },
+        { error, stack: (error as Error).stack, Category: 'sp00ky-client::AuthService::check' },
         'Auth check failed'
       );
       await this.signOut();
@@ -170,12 +197,13 @@ export class AuthService<S extends SchemaStructure> {
     this.token = null;
     this.currentUser = null;
     this.isAuthenticated = false;
+    this.access = null;
 
-    await this.persistenceClient.remove('spooky_auth_token');
+    await this.persistenceClient.remove('sp00ky_auth_token');
 
     try {
       await this.remote.getClient().invalidate();
-    } catch (e) {
+    } catch (_e) {
       // Ignore invalidation errors
     }
 
@@ -186,10 +214,21 @@ export class AuthService<S extends SchemaStructure> {
     this.token = token;
     this.currentUser = user;
     this.isAuthenticated = true;
-    await this.persistenceClient.set('spooky_auth_token', token);
+    // Resolve the access-method name (e.g. "account") for in-browser SSP
+    // permission injection. Prefer the token's `AC` claim; fall back to the
+    // schema's sole record-access method if the claim is absent.
+    this.access = decodeAccessFromToken(token) ?? this.defaultAccessName();
+    await this.persistenceClient.set('sp00ky_auth_token', token);
     this.notifyListeners();
   }
 
+  /** Fallback when the token carries no `AC` claim: if the schema defines
+   *  exactly one record-access method, assume the session used it. */
+  private defaultAccessName(): string | null {
+    const names = Object.keys(this.schema.access ?? {});
+    return names.length === 1 ? names[0] : null;
+  }
+
   async signUp<Name extends keyof S['access'] & string>(
     accessName: Name,
     params: ExtractAccessParams<S, Name, 'signup'>
@@ -212,7 +251,7 @@ export class AuthService<S extends SchemaStructure> {
     }
 
     this.logger.info(
-      { accessName, runtimeParams, Category: 'spooky-client::AuthService::signUp' },
+      { accessName, runtimeParams, Category: 'sp00ky-client::AuthService::signUp' },
       'Attempting signup'
     );
 
@@ -222,7 +261,7 @@ export class AuthService<S extends SchemaStructure> {
     });
 
     this.logger.info(
-      { Category: 'spooky-client::AuthService::signUp' },
+      { Category: 'sp00ky-client::AuthService::signUp' },
       'Signup successful, token received'
     );
 
@@ -253,7 +292,7 @@ export class AuthService<S extends SchemaStructure> {
     }
 
     this.logger.info(
-      { accessName, Category: 'spooky-client::AuthService::signIn' },
+      { accessName, Category: 'sp00ky-client::AuthService::signIn' },
       'Attempting signin'
     );
 

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,
           },
         };
       });
@@ -94,7 +94,12 @@ export class CacheModule implements StreamUpdateReceiver {
         const query = surql.seal<void>(
           surql.tx(
             populatedRecords.map((_, i) => {
-              return surql.upsert(`id${i}`, `content${i}`);
+              // MERGE, not REPLACE: the remote payload omits local-only
+              // fields (`_00_crdt`, `_00_cursor`) injected by the CLI's
+              // local schema, so REPLACE would wipe the persisted CRDT
+              // snapshot on every sync-down round-trip and break offline
+              // reload of formatted text.
+              return surql.upsertMerge(`id${i}`, `content${i}`);
             })
           )
         );
@@ -114,20 +119,24 @@ export class CacheModule implements StreamUpdateReceiver {
         await this.local.execute(query, params);
       }
 
-      // 2. Batch ingest into DBSP (use populatedRecords which has spooky_rv set)
-      for (const record of populatedRecords) {
+      // 2. Bulk ingest into DBSP (use populatedRecords which has _00_rv set).
+      // ingestMany coalesces the per-record stream updates into a single
+      // notification per affected query — the UI then updates once, after the
+      // whole batch is ingested, instead of row-by-row.
+      const bulk = populatedRecords.map((record) => {
         const recordId = encodeRecordId(record.record.id);
         this.versionLookups[recordId] = record.version;
-        this.streamProcessor.ingest(record.table, record.op, recordId, record.record);
-      }
+        return { table: record.table, op: record.op, id: recordId, record: record.record };
+      });
+      this.streamProcessor.ingestMany(bulk);
 
       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 +146,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 +158,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;
@@ -170,12 +179,15 @@ export class CacheModule implements StreamUpdateReceiver {
    * Register a query with DBSP to create a materialized view
    * Returns the initial result array
    */
-  registerQuery(config: QueryConfig): { localArray: RecordVersionArray } {
+  registerQuery(config: QueryConfig): {
+    localArray: RecordVersionArray;
+    registrationTimings?: { parseMs: number; planMs: number; snapshotMs: number };
+  } {
     this.logger.debug(
       {
         queryHash: config.queryHash,
         surql: config.surql,
-        Category: 'spooky-client::CacheModule::registerQuery',
+        Category: 'sp00ky-client::CacheModule::registerQuery',
       },
       'Registering query'
     );
@@ -202,15 +214,15 @@ 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'
       );
 
-      return { localArray: update.localArray };
+      return { localArray: update.localArray, registrationTimings: update.registration };
     } 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 +234,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/crdt/crdt-field.ts

@@ -0,0 +1,281 @@
+import { LoroDoc } from 'loro-crdt';
+import type { LocalDatabaseService, RemoteDatabaseService } from '../../services/database/index';
+import type { Logger } from '../../services/logger/index';
+import { parseRecordIdString } from '../../utils/index';
+
+// ==================== CURSOR UTILITIES ====================
+
+export const CURSOR_COLORS = [
+  '#3b82f6', '#ef4444', '#22c55e', '#f59e0b',
+  '#8b5cf6', '#ec4899', '#14b8a6', '#f97316',
+];
+
+export function cursorColorFromName(name: string): string {
+  let hash = 0;
+  for (let i = 0; i < name.length; i++) {
+    hash = ((hash << 5) - hash + name.charCodeAt(i)) | 0;
+  }
+  return CURSOR_COLORS[Math.abs(hash) % CURSOR_COLORS.length];
+}
+
+// ==================== CRDT FIELD ====================
+
+export class CrdtField {
+  private doc: LoroDoc;
+  private pushTimer: ReturnType<typeof setTimeout> | null = null;
+  private local: LocalDatabaseService | null = null;
+  private remote: RemoteDatabaseService | null = null;
+  private recordId: string | null = null;
+  private sessionId: string = '';
+  private unsubscribe: (() => void) | null = null;
+  private lastPushTime = 0;
+  private lastCursorPushTime = 0;
+  private loadedFromCrdt = false;
+  private pushRetryCount = 0;
+  private logger: Logger | null;
+  private cursorsEnabled: boolean;
+  /** Remote-push debounce. Local writes happen immediately on every Loro
+   *  update; the remote UPSERT is coalesced over this window. Configured
+   *  via `Sp00kyConfig.crdtDebounceMs`, default 500. */
+  private remoteDebounceMs: number = 500;
+
+  private _onCursorUpdate: ((data: Uint8Array) => void) | null = null;
+  private pendingCursorUpdate: Uint8Array | null = null;
+
+  /** Callback set by the editor to receive remote cursor updates.
+   *  Any cursor data that arrived before this callback was set will be replayed. */
+  set onCursorUpdate(cb: ((data: Uint8Array) => void) | null) {
+    this._onCursorUpdate = cb;
+    if (cb && this.pendingCursorUpdate) {
+      try { cb(this.pendingCursorUpdate); } catch (e) {
+        this.logger?.warn(
+          { error: e, Category: 'sp00ky-client::CrdtField::onCursorUpdate' },
+          'Failed to replay pending cursor update'
+        );
+      }
+      this.pendingCursorUpdate = null;
+    }
+  }
+
+  get onCursorUpdate() { return this._onCursorUpdate; }
+
+  constructor(
+    private fieldName: string,
+    cursorsEnabled: boolean,
+    initialState?: Uint8Array,
+    logger?: Logger | null,
+  ) {
+    if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(fieldName)) {
+      throw new Error(
+        `CrdtField: refusing unsafe field identifier '${fieldName}' — must match [a-zA-Z_][a-zA-Z0-9_]*`
+      );
+    }
+    this.logger = logger ?? null;
+    this.cursorsEnabled = cursorsEnabled;
+    this.doc = new LoroDoc();
+    if (initialState && initialState.length > 0) {
+      // Tolerance: catch bad-snapshot data (corrupt blob, stale legacy
+      // value left over from a pre-`bytes` migration) so the editor still
+      // mounts. Without this guard the rejection bubbles through
+      // `useCrdtField` → permanent fallback `<p>`, with no cursor.
+      try {
+        this.doc.import(initialState);
+        this.loadedFromCrdt = true;
+      } catch (e) {
+        this.logger?.warn(
+          {
+            error: e,
+            fieldName,
+            Category: 'sp00ky-client::CrdtField::constructor',
+          },
+          'Initial CRDT state is not a valid LoroDoc snapshot — starting empty and will seed from fallback text'
+        );
+      }
+    }
+  }
+
+  getDoc(): LoroDoc { return this.doc; }
+
+  /** Whether the LoroDoc was loaded from saved CRDT state */
+  hasContent(): boolean {
+    return this.loadedFromCrdt;
+  }
+
+  startSync(
+    local: LocalDatabaseService,
+    remote: RemoteDatabaseService,
+    recordId: string,
+    sessionId: string,
+    debounceMs: number,
+  ): void {
+    this.local = local;
+    this.remote = remote;
+    this.recordId = recordId;
+    this.sessionId = sessionId;
+    this.remoteDebounceMs = debounceMs;
+    // Every local Loro update writes the snapshot to the local cache
+    // *immediately* (so reload/offline see the latest text), then
+    // schedules a debounced push to remote. The local UPSERT is cheap —
+    // it's an in-memory SurrealKV write — but errors are swallowed so a
+    // bad write never blocks user input.
+    this.unsubscribe = this.doc.subscribeLocalUpdates(() => {
+      void this.persistLocal();
+      this.scheduleRemotePush();
+    });
+  }
+
+  stopSync(): void {
+    if (this.unsubscribe) { this.unsubscribe(); this.unsubscribe = null; }
+    if (this.pushTimer) { clearTimeout(this.pushTimer); this.pushTimer = null; }
+    if (this.remote && this.recordId) { void this.pushToRemote(); }
+  }
+
+  importRemote(state: Uint8Array): void {
+    // Echo suppression: skip imports within `remoteDebounceMs + 200` of
+    // our own push. The +200 guards against round-trip jitter where our
+    // own write echoes back from the LIVE feed before the debounce
+    // window closes.
+    if (Date.now() - this.lastPushTime < this.remoteDebounceMs + 200) return;
+    try {
+      this.doc.import(state);
+      // Persist the merged snapshot locally so the next reload/offline
+      // open sees the freshest converged state without waiting for the
+      // LIVE feed.
+      void this.persistLocal();
+    } catch (e) {
+      this.logger?.warn(
+        { error: e, Category: 'sp00ky-client::CrdtField::importRemote' },
+        'Failed to import remote CRDT state'
+      );
+    }
+  }
+
+  exportSnapshot(): Uint8Array {
+    return this.doc.export({ mode: 'snapshot' });
+  }
+
+  /** Push this session's cursor blob into the parent row at
+   *  `<field>.cursors[$sid]`. No-op when cursors aren't enabled on this
+   *  field — the editor still calls this method optimistically, but
+   *  without `@cursor` on the schema there's nowhere to store the blob.
+   *  The UPDATE itself fires the parent table's LIVE feed, so other
+   *  browsers receive the cursor change without a separate `_00_rv` bump. */
+  async pushCursorState(encoded: Uint8Array): Promise<void> {
+    if (!this.remote || !this.recordId) return;
+    if (!this.cursorsEnabled) return;
+    this.lastCursorPushTime = Date.now();
+    try {
+      const state = encodeBase64(encoded);
+      await this.remote.query(
+        `UPDATE $id SET ${this.fieldName}.cursors[$sid] = $state RETURN NONE;`,
+        {
+          id: parseRecordIdString(this.recordId),
+          sid: this.sessionId,
+          state,
+        }
+      );
+    } catch (e) {
+      this.logger?.warn(
+        { error: e, Category: 'sp00ky-client::CrdtField::pushCursorState' },
+        'Failed to push cursor state'
+      );
+    }
+  }
+
+  /** Import remote cursor state (called by CrdtManager from LIVE SELECT) */
+  importRemoteCursor(base64State: string): void {
+    if (Date.now() - this.lastCursorPushTime < 300) return; // echo suppression
+    try {
+      const data = decodeBase64(base64State);
+      if (this._onCursorUpdate) {
+        this._onCursorUpdate(data);
+      } else {
+        // Only keep the latest cursor state — older positions are useless
+        this.pendingCursorUpdate = data;
+      }
+    } catch (e) {
+      this.logger?.warn(
+        { error: e, Category: 'sp00ky-client::CrdtField::importRemoteCursor' },
+        'Failed to apply remote cursor data'
+      );
+    }
+  }
+
+  private scheduleRemotePush(): void {
+    if (this.pushTimer) clearTimeout(this.pushTimer);
+    this.pushTimer = setTimeout(() => void this.pushToRemote(), this.remoteDebounceMs);
+  }
+
+  /** SET path inside a parent row for the current snapshot. `@crdt`-only
+   *  fields hold the snapshot directly (`<field>`); `@crdt @cursor`
+   *  fields hold a `{ state, cursors }` object so the snapshot lives at
+   *  `<field>.state` next to per-session cursor blobs. */
+  private statePath(): string {
+    return this.cursorsEnabled ? `${this.fieldName}.state` : this.fieldName;
+  }
+
+  /** Mirror the LoroDoc snapshot into the parent row locally. Runs on
+   *  every local update and every remote import so reloads (online or
+   *  offline) see the freshest content immediately. Failures are
+   *  swallowed — a stale local write must never block user input. */
+  private async persistLocal(): Promise<void> {
+    if (!this.local || !this.recordId) return;
+    try {
+      await this.local.query(
+        `UPDATE $id SET ${this.statePath()} = $state RETURN NONE;`,
+        { id: parseRecordIdString(this.recordId), state: this.exportSnapshot() }
+      );
+    } catch (e) {
+      this.logger?.debug(
+        { error: e, Category: 'sp00ky-client::CrdtField::persistLocal' },
+        'Local CRDT persist failed (best-effort)'
+      );
+    }
+  }
+
+  private async pushToRemote(): Promise<void> {
+    if (!this.remote || !this.recordId) return;
+    this.lastPushTime = Date.now();
+    try {
+      // The UPDATE on the parent fires the parent table's LIVE feed,
+      // so cross-browser receivers see this change directly in the LIVE
+      // payload — no separate `_00_rv` bump or sidecar UPSERT.
+      await this.remote.query(
+        `UPDATE $id SET ${this.statePath()} = $state RETURN NONE;`,
+        { id: parseRecordIdString(this.recordId), state: this.exportSnapshot() }
+      );
+      this.pushRetryCount = 0;
+    } catch (e) {
+      this.logger?.warn(
+        { error: e, Category: 'sp00ky-client::CrdtField::pushToRemote' },
+        'Failed to push CRDT state to remote'
+      );
+      // Bounded retry. Offline first-loads will exhaust this and stop
+      // hammering; the next user keystroke (or the next time a remote
+      // event lands once we're back online) will kick off another push.
+      if (this.pushRetryCount < 2) {
+        this.pushRetryCount++;
+        this.scheduleRemotePush();
+      }
+    }
+  }
+}
+
+export function decodeBase64(b64: string): Uint8Array {
+  if (typeof atob === 'function') {
+    const binary = atob(b64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+    return bytes;
+  }
+  return new Uint8Array(Buffer.from(b64, 'base64'));
+}
+
+export function encodeBase64(bytes: Uint8Array): string {
+  if (typeof btoa === 'function') {
+    let binary = '';
+    for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]);
+    return btoa(binary);
+  }
+  return Buffer.from(bytes).toString('base64');
+}