@spooky-sync/core 0.0.1-canary.108 → 0.0.1-canary.109

package/dist/index.d.ts

@@ -1,35 +1,10 @@
-import { A as SyncHealthStatus, C as RunOptions, D as StoreType, E as Sp00kyQueryResultPromise, F as SyncEventSystem, I as EventDefinition, L as EventSystem, M as UpdateOptions, N as UpEvent, O as SyncHealth, P as Logger$1, S as RegistrationTimings, T as Sp00kyQueryResult, _ as QueryTimeToLive, a as MutationCallback, b as RecordVersionArray, c as PersistenceClient, d as QueryConfig, f as QueryConfigRecord, g as QueryStatusCallback, h as QueryStatus, i as MATERIALIZATION_SAMPLE_WINDOW, j as TimingPhase, k as SyncHealthConfig, l as PhaseStat, m as QueryState, n as EventSubscriptionOptions, o as MutationEvent, p as QueryHash, r as Level, s as MutationEventType, t as DebounceOptions, u as PinoTransmit, v as QueryTimings, w as Sp00kyConfig, x as RecordVersionDiff, y as QueryUpdateCallback } from "./types.js";
+import { A as SyncHealthStatus, B as EventDefinition, C as RunOptions, D as StoreType, E as Sp00kyQueryResultPromise, F as SealedQuery, I as DatabaseEventSystem, L as DatabaseEventTypes, M as UpdateOptions, N as UpEvent, O as SyncHealth, P as LocalStore, R as Logger$1, S as RegistrationTimings, T as Sp00kyQueryResult, V as EventSystem, _ as QueryTimeToLive, a as MutationCallback, b as RecordVersionArray, c as PersistenceClient, d as QueryConfig, f as QueryConfigRecord, g as QueryStatusCallback, h as QueryStatus, i as MATERIALIZATION_SAMPLE_WINDOW, j as TimingPhase, k as SyncHealthConfig, l as PhaseStat, m as QueryState, n as EventSubscriptionOptions, o as MutationEvent, p as QueryHash, r as Level, s as MutationEventType, t as DebounceOptions, u as PinoTransmit, v as QueryTimings, w as Sp00kyConfig, x as RecordVersionDiff, y as QueryUpdateCallback, z as SyncEventSystem } from "./types.js";
 import * as surrealdb0 from "surrealdb";
 import { Duration, RecordId, Surreal as Surreal$1, SurrealTransaction } from "surrealdb";
-import { AccessDefinition, BackendNames, BackendRoutes, BucketNames, ColumnSchema, GetTable, QueryBuilder, QueryOptions, RoutePayload, SchemaStructure, TableModel, TableNames, TypeNameToTypeMap } from "@spooky-sync/query-builder";
+import { AccessDefinition, BackendNames, BackendRoutes, BucketNames, ColumnSchema, GetTable, QueryBuilder, QueryOptions, QueryPlan, RoutePayload, SchemaStructure, TableModel, TableNames, TypeNameToTypeMap } from "@spooky-sync/query-builder";
 import { Logger } from "pino";
 import { LoroDoc } from "loro-crdt";
 
-//#region src/services/database/events/index.d.ts
-declare const DatabaseEventTypes: {
-  readonly LocalQuery: "DATABASE_LOCAL_QUERY";
-  readonly RemoteQuery: "DATABASE_REMOTE_QUERY";
-};
-interface DatabaseQueryEventPayload {
-  query: string;
-  vars?: Record<string, unknown>;
-  duration: number;
-  success: boolean;
-  error?: string;
-  timestamp: number;
-}
-type DatabaseEventTypeMap = {
-  [DatabaseEventTypes.LocalQuery]: EventDefinition<typeof DatabaseEventTypes.LocalQuery, DatabaseQueryEventPayload>;
-  [DatabaseEventTypes.RemoteQuery]: EventDefinition<typeof DatabaseEventTypes.RemoteQuery, DatabaseQueryEventPayload>;
-};
-type DatabaseEventSystem = EventSystem<DatabaseEventTypeMap>;
-//#endregion
-//#region src/utils/surql.d.ts
-interface SealedQuery<T = void> {
-  readonly sql: string;
-  readonly extract: (results: unknown[]) => T;
-}
-//#endregion
 //#region src/services/database/database.d.ts
 declare abstract class AbstractDatabaseService {
   protected client: Surreal$1;
@@ -50,85 +25,6 @@ declare abstract class AbstractDatabaseService {
   close(): Promise<void>;
 }
 //#endregion
-//#region src/services/database/local.d.ts
-declare class LocalDatabaseService extends AbstractDatabaseService {
-  private config;
-  protected eventType: "DATABASE_LOCAL_QUERY";
-  /** Bucket currently open. Set by `connect`/`switchStore`. */
-  private bucketId;
-  /**
-   * Monotonic store generation. Bumped on every `switchStore`. Async chains
-   * that read from the store, await something remote, and then write back
-   * (sync poll, SSP stream updates) capture this at chain start and drop
-   * their write when it no longer matches — a stale-epoch write would land
-   * another user's data in the new bucket.
-   */
-  private storeEpoch;
-  /** Gate that `query()`/`execute()` await; closed for the switch window. */
-  private gate;
-  /** The incoming client while a switch is in flight (for unload cleanup). */
-  private pendingSwitchClient;
-  constructor(config: Sp00kyConfig<any>['database'], logger: Logger$1);
-  getConfig(): Sp00kyConfig<any>['database'];
-  get currentBucketId(): string;
-  get epoch(): number;
-  /**
-   * Close the query gate for a bucket switch. Every `query()`/`execute()`
-   * issued after this waits until the returned release fn runs — so work
-   * triggered mid-switch (sibling auth subscribers registering queries)
-   * lands on the NEW bucket instead of racing the swap. The migrator uses
-   * `queryUngated()` to provision the new bucket while the gate is closed.
-   */
-  beginSwitch(): () => void;
-  query<T extends unknown[]>(query: string, vars?: Record<string, unknown>, opts?: {
-    epoch?: number;
-  }): Promise<T>;
-  execute<T>(query: SealedQuery<T>, vars?: Record<string, unknown>, opts?: {
-    epoch?: number;
-  }): Promise<T>;
-  /** Gate-bypassing query — ONLY for the switch path itself (schema
-   *  provisioning must run while the gate is closed, or it deadlocks). */
-  queryUngated<T extends unknown[]>(query: string, vars?: Record<string, unknown>): Promise<T>;
-  connect(bucketId?: string): Promise<void>;
-  /**
-   * Switch the local store to another user's bucket. Opens the NEW bucket on a
-   * second client first (with the same 3-tier recovery), then atomically swaps
-   * `this.client` and closes the old one — a failed open never leaves the
-   * service on a dead client. Bumps the store epoch so in-flight old-bucket
-   * async chains can detect they're stale.
-   *
-   * Callers own the drain/rebind choreography (close the gate, quiesce sync +
-   * timers BEFORE calling this; re-provision + rebind AFTER).
-   */
-  switchStore(bucketId: string): Promise<void>;
-  /**
-   * Open `storeUrl` on `client` with tiered recovery:
-   * tier 1 retries the same store (transient idb-handle races — preserves the
-   * cache), tier 2 drops THIS bucket's IndexedDB store and reconnects fresh,
-   * tier 3 falls back to `mem://` for the session. Only ever drops the bucket
-   * being opened — other users' buckets hold their own caches AND un-pushed
-   * mutation outboxes, which must survive another bucket's corruption.
-   */
-  private openWithRecovery;
-  private unloadCloseRegistered;
-  /**
-   * Close the local DB on page unload so the SurrealDB-WASM worker releases its
-   * IndexedDB connection cleanly. Without this, the previous page's connection
-   * lingers; the next load's `client.connect` opens the store but the first
-   * write transaction in `client.use` hits an "IndexedDB error" — which then
-   * (mis)triggered the corrupt-store recovery and WIPED the cache on every
-   * reload, making warm loads as slow as cold ones. `pagehide` is the reliable
-   * unload signal (fires on bfcache + normal navigation); `close()` is async but
-   * the WASM worker initiates the IndexedDB connection teardown synchronously.
-   * Also closes a mid-switch incoming client so its fresh handle doesn't linger.
-   */
-  private registerUnloadClose;
-  private openStore;
-}
-/** True for the SurrealDB-WASM error raised when its IndexedDB-backed key-value
- *  store can't be opened (corrupt / version-incompatible / blocked). Exported
- *  for unit testing the error-message match. */
-//#endregion
 //#region src/services/database/remote.d.ts
 declare class RemoteDatabaseService extends AbstractDatabaseService {
   private config;
@@ -243,7 +139,7 @@ declare class StreamProcessorService {
   private sessionAuth;
   private stateKeySuffix;
   private stateGeneration;
-  constructor(events: EventSystem<StreamProcessorEvents>, db: LocalDatabaseService, persistenceClient: PersistenceClient, logger: Logger);
+  constructor(events: EventSystem<StreamProcessorEvents>, db: LocalStore, persistenceClient: PersistenceClient, logger: Logger);
   /**
    * Add a receiver for stream updates.
    * Multiple receivers can be registered (DataManager, DevTools, etc.)
@@ -371,7 +267,7 @@ declare class CacheModule implements StreamUpdateReceiver {
   private logger;
   private streamUpdateCallback;
   private versionLookups;
-  constructor(local: LocalDatabaseService, streamProcessor: StreamProcessorService, streamUpdateCallback: (update: StreamUpdate) => void, logger: Logger$1);
+  constructor(local: LocalStore, streamProcessor: StreamProcessorService, streamUpdateCallback: (update: StreamUpdate) => void, logger: Logger$1);
   /**
    * Implements StreamUpdateReceiver interface
    * Called directly by StreamProcessor when views change
@@ -463,7 +359,7 @@ declare class DataModule<S extends SchemaStructure> {
   onDeregister?: (hash: QueryHash) => void;
   private sessionId;
   private currentUserId;
-  constructor(cache: CacheModule, local: LocalDatabaseService, schema: S, logger: Logger$1, streamDebounceTime?: number);
+  constructor(cache: CacheModule, local: LocalStore, schema: S, logger: Logger$1, streamDebounceTime?: number);
   init(sessionId: string): Promise<void>;
   /**
    * Update the session salt used in query-id hashing. Call this when the
@@ -485,7 +381,7 @@ declare class DataModule<S extends SchemaStructure> {
   /**
    * Register a query and return its hash for subscriptions
    */
-  query<T extends TableNames<S>>(tableName: T, surqlString: string, params: Record<string, any>, ttl: QueryTimeToLive): Promise<QueryHash>;
+  query<T extends TableNames<S>>(tableName: T, surqlString: string, params: Record<string, any>, ttl: QueryTimeToLive, plan?: QueryPlan): Promise<QueryHash>;
   /**
    * Subscribe to query updates
    */
@@ -781,7 +677,7 @@ declare class Sp00kySync<S extends SchemaStructure> {
   private startSelfHeal;
   private scheduleSelfHeal;
   private stopSelfHeal;
-  constructor(local: LocalDatabaseService, remote: RemoteDatabaseService, cache: CacheModule, dataModule: DataModule<S>, schema: S, logger: Logger$1, options?: Sp00kySyncOptions);
+  constructor(local: LocalStore, remote: RemoteDatabaseService, cache: CacheModule, dataModule: DataModule<S>, schema: S, logger: Logger$1, options?: Sp00kySyncOptions);
   /**
    * Initializes the synchronization system.
    * Starts the scheduler and initiates the initial sync cycles.
@@ -1026,7 +922,7 @@ declare class CrdtField {
   getDoc(): LoroDoc;
   /** Whether the LoroDoc was loaded from saved CRDT state */
   hasContent(): boolean;
-  startSync(local: LocalDatabaseService, remote: RemoteDatabaseService, recordId: string, sessionId: string, debounceMs: number): void;
+  startSync(local: LocalStore, remote: RemoteDatabaseService, recordId: string, sessionId: string, debounceMs: number): void;
   /**
    * Stop syncing this field. Flushes one final remote push by default so the
    * last keystrokes aren't lost. Pass `{ flush: false }` on a bucket switch —
@@ -1093,7 +989,7 @@ declare class CrdtManager {
   private pendingLive;
   private logger;
   private sessionId;
-  constructor(schema: SchemaStructure, local: LocalDatabaseService, remote: RemoteDatabaseService, logger: Logger$1, debounceMs?: number);
+  constructor(schema: SchemaStructure, local: LocalStore, remote: RemoteDatabaseService, logger: Logger$1, debounceMs?: number);
   /** Set the session id that scopes this client's cursor entries. Must be
    *  called before `open()` for cursors to be pushed under a stable key.
    *  Passed in from `sp00ky.ts` at boot (it already fetches `session::id()`
@@ -1241,7 +1137,7 @@ declare class Sp00kyClient<S extends SchemaStructure> {
   auth: AuthService<S>;
   streamProcessor: StreamProcessorService;
   get remoteClient(): surrealdb0.Surreal;
-  get localClient(): surrealdb0.Surreal;
+  get localClient(): unknown;
   get pendingMutationCount(): number;
   /** Number of times the initial list_ref LIVE subscription retried on
    *  the most recent `setCurrentUserId` call. 0 when the SSP's