@powersync/nuxt 0.0.0-dev-20260503073249 → 0.0.0-dev-20260630141119

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "powersync-nuxt",
   "configKey": "powersync",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "unknown"

package/dist/runtime/components/SyncStatusTab.vue

@@ -54,7 +54,7 @@
           <div flex="~ col gap-2">
             <span text="sm gray-500">Upload Progress</span>
             <div flex="~ items-center gap-2">
-              <span v-if="syncStatus?.dataFlowStatus.uploading">upload in progress...</span>
+              <span v-if="syncStatus?.uploading">upload in progress...</span>
               <span v-else text="sm gray-400">No active upload</span>
             </div>
           </div>

package/dist/runtime/composables/useDiagnosticsLogger.d.ts

@@ -1,11 +1,11 @@
-import { type ILogHandler } from '@powersync/web';
+import { type PowerSyncLogger } from '@powersync/common';
 /**
  * Provides a logger configured for PowerSync diagnostics.
  *
  * This composable creates a logger instance that is automatically configured for diagnostics
  * recording. The logger stores logs in session storage and emits events for real-time log monitoring.
  *
- * @param customHandler - Optional custom log handler to process log messages
+ * @param additional - Optional logger that messages will also be forwarded to.
  *
  * @returns An object containing:
  * - `logger` - The configured ILogHandler instance
@@ -20,8 +20,8 @@ import { type ILogHandler } from '@powersync/web';
  * // Use it in your PowerSync setup if needed
  * ```
  */
-export declare const useDiagnosticsLogger: (customHandler?: ILogHandler) => {
-    logger: import("@powersync/common").GlobalLogger;
+export declare const useDiagnosticsLogger: (additional?: PowerSyncLogger) => {
+    logger: PowerSyncLogger;
     logsStorage: import("unstorage").Storage<import("unstorage").StorageValue>;
     emitter: import("mitt").Emitter<Record<import("mitt").EventType, unknown>>;
 };

package/dist/runtime/composables/useDiagnosticsLogger.js

@@ -1,4 +1,4 @@
-import { createBaseLogger, LogLevel } from "@powersync/web";
+import { createConsoleLogger, LogLevels } from "@powersync/common";
 import { createStorage } from "unstorage";
 import localStorageDriver from "unstorage/drivers/session-storage";
 import mitt from "mitt";
@@ -6,28 +6,35 @@ const emitter = mitt();
 const logsStorage = createStorage({
   driver: localStorageDriver({ base: "powersync:" })
 });
-export const useDiagnosticsLogger = (customHandler) => {
-  const logger = createBaseLogger();
-  const consoleHandler = logger.createDefaultHandler({
-    formatter: (messages, context) => {
-      messages.unshift(`[PowerSync]${context.name ? ` [${context.name}]` : ""}`);
+export const useDiagnosticsLogger = (additional) => {
+  const consoleLogger = createConsoleLogger({ minLevel: LogLevels.debug });
+  const logger = {
+    async log(record) {
+      consoleLogger.log(record);
+      const logObject = {
+        date: /* @__PURE__ */ new Date(),
+        message: record.message,
+        error: record.error,
+        level: nameOfLogLevel(record.level)
+      };
+      const key = `log:${logObject.date.toISOString()}`;
+      await logsStorage.set(key, logObject);
+      emitter.emit("log", { key, value: logObject });
+      additional?.log(record);
     }
-  });
-  logger.setLevel(LogLevel.DEBUG);
-  logger.setHandler(async (messages, context) => {
-    consoleHandler(messages, context);
-    const messageArray = Array.from(messages);
-    const mainMessage = String(messageArray[0] ?? "Empty log message");
-    const extra = messageArray.length > 1 ? messageArray.length === 2 ? messageArray[1] : messageArray.slice(1) : void 0;
-    const logObject = {
-      date: /* @__PURE__ */ new Date(),
-      type: context.level.name.toLowerCase(),
-      args: [mainMessage, extra, context]
-    };
-    const key = `log:${logObject.date.toISOString()}`;
-    await logsStorage.set(key, logObject);
-    emitter.emit("log", { key, value: logObject });
-    await customHandler?.(messages, context);
-  });
+  };
   return { logger, logsStorage, emitter };
 };
+const levelNames = [
+  ["ERROR", LogLevels.error],
+  ["WARNING", LogLevels.warn],
+  ["INFO", LogLevels.info],
+  ["DEBUG", LogLevels.debug],
+  ["TRACE", LogLevels.trace]
+];
+function nameOfLogLevel(level) {
+  for (const [name, minLevel] of levelNames) {
+    if (level >= minLevel) return name;
+  }
+  return void 0;
+}

package/dist/runtime/composables/usePowerSyncInspector.d.ts

@@ -1,4 +1,3 @@
-import { RecordingStorageAdapter } from '../utils/RecordingStorageAdapter.js';
 import { DynamicSchemaManager } from '../utils/DynamicSchemaManager.js';
 declare function getCurrentSchemaManager(): DynamicSchemaManager;
 /**
@@ -9,7 +8,6 @@ declare function getCurrentSchemaManager(): DynamicSchemaManager;
  *
  * @returns An object containing:
  * - `diagnosticsSchema` - The schema for diagnostics data collection. Use this to extend your app schema with diagnostic tables.
- * - `RecordingStorageAdapter` - Used internally. Storage adapter class that records operations for diagnostic purposes.
  * - `getCurrentSchemaManager()` - Used internally. Gets the current schema manager instance for dynamic schema operations.
  *
  * @example
@@ -36,7 +34,6 @@ export declare function usePowerSyncInspector(): {
             data: import("@powersync/common").BaseColumnType<string | null>;
         }>;
     }>;
-    RecordingStorageAdapter: typeof RecordingStorageAdapter;
     getCurrentSchemaManager: typeof getCurrentSchemaManager;
 };
 export {};

package/dist/runtime/composables/usePowerSyncInspector.js

@@ -1,5 +1,4 @@
 import { DiagnosticsAppSchema } from "../utils/AppSchema.js";
-import { RecordingStorageAdapter } from "../utils/RecordingStorageAdapter.js";
 import { DynamicSchemaManager } from "../utils/DynamicSchemaManager.js";
 let currentSchemaManager = null;
 function getCurrentSchemaManager() {
@@ -13,7 +12,6 @@ export function usePowerSyncInspector() {
   const diagnosticsSchema = DiagnosticsAppSchema;
   return {
     diagnosticsSchema,
-    RecordingStorageAdapter,
     getCurrentSchemaManager
   };
 }

package/dist/runtime/composables/usePowerSyncInspectorDiagnostics.d.ts

@@ -1,4 +1,4 @@
-import type { AbstractPowerSyncDatabase, PowerSyncBackendConnector, PowerSyncConnectionOptions, SyncStatus, UploadQueueStats } from '@powersync/web';
+import type { CommonPowerSyncDatabase, PowerSyncBackendConnector, SyncOptions, SyncStatus, UploadQueueStats } from '@powersync/common';
 import type { ComputedRef, Ref } from 'vue';
 export type BucketRow = {
     name: string;
@@ -33,9 +33,9 @@ type ReadonlyRef<T> = Readonly<Ref<T>>;
  * Uses named types so the signature stays readable in docs and IDE.
  */
 export interface UsePowerSyncInspectorDiagnosticsReturn {
-    db: Ref<AbstractPowerSyncDatabase> | undefined;
+    db: Ref<CommonPowerSyncDatabase> | undefined;
     connector: ComputedRef<PowerSyncBackendConnector | null>;
-    connectionOptions: ComputedRef<PowerSyncConnectionOptions | null>;
+    connectionOptions: ComputedRef<SyncOptions | null>;
     isDiagnosticSchemaSetup: ReadonlyRef<boolean>;
     /** Current sync status. Typed as SyncStatus for a concise doc signature; at runtime it may be a readonly proxy. */
     syncStatus: ReadonlyRef<SyncStatus>;

package/dist/runtime/composables/usePowerSyncInspectorDiagnostics.js

@@ -73,12 +73,12 @@ export function usePowerSyncInspectorDiagnostics() {
   const hasSynced = ref(syncStatus.value?.hasSynced || false);
   const isConnected = ref(syncStatus.value?.connected || false);
   const isSyncing = ref(false);
-  const isDownloading = ref(syncStatus.value?.dataFlowStatus.downloading || false);
-  const isUploading = ref(syncStatus.value?.dataFlowStatus.uploading || false);
+  const isDownloading = ref(syncStatus.value?.downloading || false);
+  const isUploading = ref(syncStatus.value?.uploading || false);
   const lastSyncedAt = ref(syncStatus.value?.lastSyncedAt || null);
-  const uploadError = ref(syncStatus.value?.dataFlowStatus.uploadError || null);
-  const downloadError = ref(syncStatus.value?.dataFlowStatus.downloadError || null);
-  const downloadProgressDetails = ref(syncStatus.value?.dataFlowStatus.downloadProgress || null);
+  const uploadError = ref(syncStatus.value?.uploadError || null);
+  const downloadError = ref(syncStatus.value?.downloadError || null);
+  const downloadProgressDetails = ref(syncStatus.value?.downloadProgress || null);
   const bucketRows = ref(null);
   const tableRows = ref(null);
   const uploadQueueStats = ref(null);
@@ -111,7 +111,7 @@ export function usePowerSyncInspectorDiagnostics() {
   const uploadQueueSize = computed(() => formatBytes(uploadQueueStats.value?.size ?? 0));
   const uploadQueueCount = computed(() => uploadQueueStats.value?.count ?? 0);
   const clearData = async () => {
-    await db.value?.syncStreamImplementation?.disconnect();
+    await db.value?.disconnect();
     const connector2 = db.value.connector;
     const connectionOptions2 = db.value.connectionOptions;
     await db.value?.disconnectAndClear();
@@ -126,7 +126,7 @@ export function usePowerSyncInspectorDiagnostics() {
         "SELECT powersync_last_synced_at() as synced_at"
       );
       uploadQueueStats.value = await db.value?.getUploadQueueStats(true);
-      if (synced_at != null && !syncStatus.value?.dataFlowStatus.downloading) {
+      if (synced_at != null && !syncStatus.value?.downloading) {
         bucketRows.value = await db.value.getAll(BUCKETS_QUERY);
         tableRows.value = await db.value.getAll(TABLES_QUERY);
       } else if (synced_at != null) {
@@ -146,16 +146,16 @@ export function usePowerSyncInspectorDiagnostics() {
       statusChanged: (newStatus) => {
         hasSynced.value = !!newStatus.hasSynced;
         isConnected.value = !!newStatus.connected;
-        isDownloading.value = !!newStatus.dataFlowStatus.downloading;
-        isUploading.value = !!newStatus.dataFlowStatus.uploading;
+        isDownloading.value = !!newStatus.downloading;
+        isUploading.value = !!newStatus.uploading;
         lastSyncedAt.value = newStatus.lastSyncedAt || null;
-        uploadError.value = newStatus.dataFlowStatus.uploadError || null;
-        downloadError.value = newStatus.dataFlowStatus.downloadError || null;
-        downloadProgressDetails.value = newStatus.dataFlowStatus.downloadProgress || null;
+        uploadError.value = newStatus.uploadError || null;
+        downloadError.value = newStatus.downloadError || null;
+        downloadProgressDetails.value = newStatus.downloadProgress || null;
         if (newStatus?.hasSynced === void 0 || newStatus?.priorityStatusEntries?.length && newStatus.priorityStatusEntries.length > 0) {
           hasSynced.value = newStatus?.priorityStatusEntries.every((entry) => entry.hasSynced) ?? false;
         }
-        if (newStatus?.dataFlowStatus.downloading || newStatus?.dataFlowStatus.uploading) {
+        if (newStatus?.downloading || newStatus?.uploading) {
           isSyncing.value = true;
         } else {
           isSyncing.value = false;
@@ -169,7 +169,6 @@ export function usePowerSyncInspectorDiagnostics() {
         }
       },
       {
-        rawTableNames: true,
         tables: ["ps_oplog", "ps_buckets", "ps_data_local__local_bucket_data", "ps_crud"],
         throttleMs: 500
       }

package/dist/runtime/utils/DynamicSchemaManager.d.ts

@@ -1,5 +1,6 @@
-import type { DBAdapter, SyncDataBatch } from '@powersync/web';
+import type { DBAdapter } from '@powersync/web';
 import { Schema } from '@powersync/web';
+import type { SyncDataBucketJSON } from '@powersync/shared-internals/internal/sync_protocol';
 /**
  * Record fields from downloaded data, then build a schema from it.
  */
@@ -8,7 +9,7 @@ export declare class DynamicSchemaManager {
     private dirty;
     constructor();
     clear(): Promise<void>;
-    updateFromOperations(batch: SyncDataBatch): Promise<void>;
+    updateFromOperations(batch: SyncDataBucketJSON): Promise<void>;
     refreshSchema(db: DBAdapter): Promise<void>;
     buildSchema(): Schema;
     schemaToString(): string;

package/dist/runtime/utils/DynamicSchemaManager.js

@@ -1,4 +1,4 @@
-import { Column, ColumnType, OpTypeEnum, Schema, Table } from "@powersync/web";
+import { Column, ColumnType, ResolvedTable, Schema } from "@powersync/web";
 import { DiagnosticsAppSchema as AppSchema } from "./AppSchema.js";
 import { JsSchemaGenerator } from "./JsSchemaGenerator.js";
 export class DynamicSchemaManager {
@@ -15,34 +15,32 @@ export class DynamicSchemaManager {
   }
   async updateFromOperations(batch) {
     let schemaDirty = false;
-    for (const bucket of batch.buckets) {
-      for (const op of bucket.data) {
-        if (op.op.value == OpTypeEnum.PUT && op.data != null) {
-          this.tables[op.object_type] ??= {};
-          const table = this.tables[op.object_type];
-          const data = JSON.parse(op.data);
-          for (const [key, value] of Object.entries(data)) {
-            if (key == "id") {
-              continue;
-            }
-            if (table) {
-              const existing = table[key];
-              if (typeof value == "number" && Number.isInteger(value) && existing != ColumnType.REAL && existing != ColumnType.TEXT) {
-                if (table[key] != ColumnType.INTEGER) {
-                  schemaDirty = true;
-                }
-                table[key] = ColumnType.INTEGER;
-              } else if (typeof value == "number" && existing != ColumnType.TEXT) {
-                if (table[key] != ColumnType.REAL) {
-                  schemaDirty = true;
-                }
-                table[key] = ColumnType.REAL;
-              } else if (typeof value == "string") {
-                if (table[key] != ColumnType.TEXT) {
-                  schemaDirty = true;
-                }
-                table[key] = ColumnType.TEXT;
+    for (const op of batch.data) {
+      if (op.op == "PUT" && op.data != null) {
+        this.tables[op.object_type] ??= {};
+        const table = this.tables[op.object_type];
+        const data = JSON.parse(op.data);
+        for (const [key, value] of Object.entries(data)) {
+          if (key == "id") {
+            continue;
+          }
+          if (table) {
+            const existing = table[key];
+            if (typeof value == "number" && Number.isInteger(value) && existing != ColumnType.REAL && existing != ColumnType.TEXT) {
+              if (table[key] != ColumnType.INTEGER) {
+                schemaDirty = true;
+              }
+              table[key] = ColumnType.INTEGER;
+            } else if (typeof value == "number" && existing != ColumnType.TEXT) {
+              if (table[key] != ColumnType.REAL) {
+                schemaDirty = true;
+              }
+              table[key] = ColumnType.REAL;
+            } else if (typeof value == "string") {
+              if (table[key] != ColumnType.TEXT) {
+                schemaDirty = true;
               }
+              table[key] = ColumnType.TEXT;
             }
           }
         }
@@ -64,7 +62,7 @@ export class DynamicSchemaManager {
     const base = AppSchema;
     const tables = [...base.tables];
     for (const [key, value] of Object.entries(this.tables)) {
-      const table = new Table({
+      const table = new ResolvedTable({
         name: key,
         columns: Object.entries(value).map(
           ([cname, ctype]) => new Column({

package/dist/runtime/utils/NuxtPowerSyncDatabase.d.ts

@@ -1,4 +1,17 @@
-import { PowerSyncDatabase, type DisconnectAndClearOptions, type PowerSyncBackendConnector, type PowerSyncConnectionOptions, type RequiredAdditionalConnectionOptions, type StreamingSyncImplementation, type WebPowerSyncDatabaseOptions } from '@powersync/web';
+import { WebPowerSyncDatabase, type DisconnectAndClearOptions, type PowerSyncBackendConnector, type WebPowerSyncDatabaseOptions, type SyncOptions, type CommonPowerSyncDatabase, type PowerSyncDatabaseConstructor } from '@powersync/web';
+import { type StreamingSyncImplementation, type CreateSyncImplementationOptions } from '@powersync/shared-internals';
+export declare class NuxtDatabaseImplementation extends WebPowerSyncDatabase {
+    private schemaManager;
+    private _connector;
+    private useDiagnostics;
+    get dbOptions(): WebPowerSyncDatabaseOptions;
+    get connector(): PowerSyncBackendConnector | null;
+    constructor(options: WebPowerSyncDatabaseOptions);
+    protected generateSyncStreamImplementation(connector: PowerSyncBackendConnector, options: CreateSyncImplementationOptions): StreamingSyncImplementation;
+    connect(connector: PowerSyncBackendConnector, options?: SyncOptions): Promise<void>;
+    disconnect(): Promise<void>;
+    disconnectAndClear(options?: DisconnectAndClearOptions): Promise<void>;
+}
 /**
  * An extended PowerSync database class that includes diagnostic capabilities for use with the PowerSync Inspector.
  *
@@ -24,17 +37,6 @@ import { PowerSyncDatabase, type DisconnectAndClearOptions, type PowerSyncBacken
  * - Automatically configures logging when diagnostics are enabled
  * - When diagnostics are disabled, behaves like a standard `PowerSyncDatabase`
  */
-export declare class NuxtPowerSyncDatabase extends PowerSyncDatabase {
-    private schemaManager;
-    private _connector;
-    private _connectionOptions;
-    private useDiagnostics;
-    get dbOptions(): WebPowerSyncDatabaseOptions;
-    get connector(): PowerSyncBackendConnector | null;
-    get connectionOptions(): PowerSyncConnectionOptions | null;
-    constructor(options: WebPowerSyncDatabaseOptions);
-    protected generateSyncStreamImplementation(connector: PowerSyncBackendConnector, options: RequiredAdditionalConnectionOptions): StreamingSyncImplementation;
-    connect(connector: PowerSyncBackendConnector, options?: PowerSyncConnectionOptions): Promise<void>;
-    disconnect(): Promise<void>;
-    disconnectAndClear(options?: DisconnectAndClearOptions): Promise<void>;
+export declare const NuxtPowerSyncDatabase: PowerSyncDatabaseConstructor<WebPowerSyncDatabaseOptions>;
+export interface NuxtPowerSyncDatabase extends CommonPowerSyncDatabase {
 }

package/dist/runtime/utils/NuxtPowerSyncDatabase.js

@@ -1,22 +1,19 @@
 import {
-  DEFAULT_SYNC_CLIENT_IMPLEMENTATION,
-  PowerSyncDatabase,
+  WebPowerSyncDatabase,
   Schema,
   SharedWebStreamingSyncImplementation,
-  SyncClientImplementation,
   WebRemote,
-  WebStreamingSyncImplementation
+  WebStreamingSyncImplementation,
+  LogLevels
 } from "@powersync/web";
-import { RecordingStorageAdapter } from "./RecordingStorageAdapter.js";
 import { usePowerSyncInspector } from "../composables/usePowerSyncInspector.js";
 import { useDiagnosticsLogger } from "../composables/useDiagnosticsLogger.js";
 import { shallowRef } from "vue";
 import { useRuntimeConfig } from "#app";
 import { RustClientInterceptor } from "./RustClientInterceptor.js";
-export class NuxtPowerSyncDatabase extends PowerSyncDatabase {
+export class NuxtDatabaseImplementation extends WebPowerSyncDatabase {
   schemaManager;
   _connector = null;
-  _connectionOptions = null;
   useDiagnostics = false;
   get dbOptions() {
     return this.options;
@@ -24,20 +21,16 @@ export class NuxtPowerSyncDatabase extends PowerSyncDatabase {
   get connector() {
     return this._connector ?? super.connector;
   }
-  get connectionOptions() {
-    return this._connectionOptions ?? super.connectionOptions;
-  }
   constructor(options) {
     const useDiagnostics = useRuntimeConfig().public.powerSyncModuleOptions.useDiagnostics ?? false;
     if (useDiagnostics) {
       const { logger } = useDiagnosticsLogger();
       const { getCurrentSchemaManager, diagnosticsSchema } = usePowerSyncInspector();
       const currentSchemaManager = getCurrentSchemaManager();
-      options.flags = {
-        ...options.flags,
-        enableMultiTabs: true,
-        broadcastLogs: true
-      };
+      if ("database" in options) {
+        options.database.enableMultiTabs = true;
+        options.broadcastLogs = true;
+      }
       options.logger = logger;
       options.schema = new Schema([...options.schema.tables, ...diagnosticsSchema.tables]);
       super(options);
@@ -54,22 +47,17 @@ export class NuxtPowerSyncDatabase extends PowerSyncDatabase {
       const { getCurrentSchemaManager } = usePowerSyncInspector();
       const currentSchemaManager = getCurrentSchemaManager();
       const schemaManager = currentSchemaManager || this.schemaManager;
-      const clientImplementation = this.connectionOptions?.clientImplementation ?? DEFAULT_SYNC_CLIENT_IMPLEMENTATION;
-      const adapter = clientImplementation === SyncClientImplementation.RUST ? new RustClientInterceptor(
-        shallowRef(this),
-        new WebRemote(connector, logger),
-        shallowRef(schemaManager)
-      ) : new RecordingStorageAdapter(
+      const adapter = new RustClientInterceptor(
         shallowRef(this),
         shallowRef(schemaManager)
       );
-      if (this.options.flags?.enableMultiTabs) {
-        if (!this.resolvedFlags.broadcastLogs) {
+      if (this.resolvedOpenOptions.enableMultiTabs) {
+        if (!this.enableBroadcastLogs) {
           const warning = `
             Multiple tabs are enabled, but broadcasting of logs is disabled.
             Logs for shared sync worker will only be available in the shared worker context
           `;
-          logger ? logger.warn(warning) : console.warn(warning);
+          logger ? logger.log({ level: LogLevels.warn, message: warning }) : console.warn(warning);
         }
         return new SharedWebStreamingSyncImplementation({
           ...options,
@@ -80,7 +68,9 @@ export class NuxtPowerSyncDatabase extends PowerSyncDatabase {
             await connector.uploadData(this);
           },
           logger,
-          db: this.database
+          db: this.database,
+          logLevel: this.resolvedOpenOptions.databaseWorkerLogLevel ?? LogLevels.info,
+          enableBroadcastLogs: this.enableBroadcastLogs
         });
       } else {
         return new WebStreamingSyncImplementation({
@@ -91,7 +81,7 @@ export class NuxtPowerSyncDatabase extends PowerSyncDatabase {
             await this.waitForReady();
             await connector.uploadData(this);
           },
-          identifier: "dbFilename" in this.options.database ? this.options.database.dbFilename : "diagnostics-sync",
+          identifier: "database" in this.options ? this.options.database.dbFilename : "diagnostics-sync",
           logger
         });
       }
@@ -101,17 +91,15 @@ export class NuxtPowerSyncDatabase extends PowerSyncDatabase {
   }
   async connect(connector, options) {
     this._connector = connector;
-    this._connectionOptions = options ?? null;
     await super.connect(connector, options);
   }
   async disconnect() {
     this._connector = null;
-    this._connectionOptions = null;
     await super.disconnect();
   }
   async disconnectAndClear(options) {
     this._connector = null;
-    this._connectionOptions = null;
     await super.disconnectAndClear(options);
   }
 }
+export const NuxtPowerSyncDatabase = NuxtDatabaseImplementation;

package/dist/runtime/utils/RustClientInterceptor.d.ts

@@ -1,5 +1,5 @@
-import type { AbstractRemote, ColumnType, PowerSyncDatabase } from '@powersync/web';
-import { PowerSyncControlCommand, SqliteBucketStorage } from '@powersync/web';
+import type { ColumnType, PowerSyncDatabase } from '@powersync/web';
+import { PowerSyncControlCommand, SqliteBucketStorage } from '@powersync/shared-internals';
 import type { DynamicSchemaManager } from './DynamicSchemaManager.js';
 import type { ShallowRef } from 'vue';
 /**
@@ -10,12 +10,12 @@ import type { ShallowRef } from 'vue';
  * `powersync_control` calls to decode sync lines and derive progress information.
  */
 export declare class RustClientInterceptor extends SqliteBucketStorage {
-    private remote;
     private schemaManager;
+    private bson?;
     private rdb;
     private lastStartedCheckpoint;
     tables: Record<string, Record<string, ColumnType>>;
-    constructor(db: ShallowRef<PowerSyncDatabase>, remote: AbstractRemote, schemaManager: ShallowRef<DynamicSchemaManager>);
+    constructor(db: ShallowRef<PowerSyncDatabase>, schemaManager: ShallowRef<DynamicSchemaManager>);
     control(op: PowerSyncControlCommand, payload: string | Uint8Array | ArrayBuffer | null): Promise<string>;
     private processTextLine;
     private processBinaryLine;

package/dist/runtime/utils/RustClientInterceptor.js

@@ -1,21 +1,11 @@
-import {
-  AbstractPowerSyncDatabase,
-  isStreamingSyncCheckpoint,
-  isStreamingSyncCheckpointComplete,
-  isStreamingSyncCheckpointDiff,
-  isStreamingSyncCheckpointPartiallyComplete,
-  isStreamingSyncData,
-  PowerSyncControlCommand,
-  SqliteBucketStorage,
-  SyncDataBucket
-} from "@powersync/web";
+import { BasePowerSyncDatabase, PowerSyncControlCommand, SqliteBucketStorage } from "@powersync/shared-internals";
 export class RustClientInterceptor extends SqliteBucketStorage {
-  constructor(db, remote, schemaManager) {
-    super(db.value.database, AbstractPowerSyncDatabase.transactionMutex);
-    this.remote = remote;
+  constructor(db, schemaManager) {
+    super(db.value.database, BasePowerSyncDatabase.transactionMutex);
     this.schemaManager = schemaManager;
     this.rdb = db.value.database;
   }
+  bson;
   rdb;
   lastStartedCheckpoint = null;
   tables = {};
@@ -32,14 +22,14 @@ export class RustClientInterceptor extends SqliteBucketStorage {
     return this.processParsedLine(JSON.parse(line));
   }
   async processBinaryLine(line) {
-    const bson = await this.remote.getBSON();
+    const bson = this.bson ??= await import("bson");
     await this.processParsedLine(bson.deserialize(line));
   }
   async processParsedLine(line) {
-    if (isStreamingSyncCheckpoint(line)) {
+    if ("checkpoint" in line) {
       this.lastStartedCheckpoint = line.checkpoint;
       await this.trackCheckpoint(line.checkpoint);
-    } else if (isStreamingSyncCheckpointDiff(line) && this.lastStartedCheckpoint) {
+    } else if ("checkpoint_diff" in line && this.lastStartedCheckpoint) {
       const diff = line.checkpoint_diff;
       const newBuckets = /* @__PURE__ */ new Map();
       for (const checksum of this.lastStartedCheckpoint.buckets) {
@@ -58,24 +48,22 @@ export class RustClientInterceptor extends SqliteBucketStorage {
       };
       this.lastStartedCheckpoint = newCheckpoint;
       await this.trackCheckpoint(newCheckpoint);
-    } else if (isStreamingSyncData(line)) {
-      const batch = { buckets: [SyncDataBucket.fromRow(line.data)] };
+    } else if ("data" in line) {
+      const bucket = line.data;
       await this.rdb.writeTransaction(async (tx) => {
-        for (const bucket of batch.buckets) {
-          const size = JSON.stringify(bucket.data).length;
-          await tx.execute(
-            `UPDATE local_bucket_data SET
+        const size = JSON.stringify(bucket.data).length;
+        await tx.execute(
+          `UPDATE local_bucket_data SET
                 download_size = IFNULL(download_size, 0) + ?,
                 last_op = ?,
                 downloading = ?,
                 downloaded_operations = IFNULL(downloaded_operations, 0) + ?
               WHERE id = ?`,
-            [size, bucket.next_after, bucket.has_more, bucket.data.length, bucket.bucket]
-          );
-        }
+          [size, bucket.next_after, bucket.has_more, bucket.data.length, bucket.bucket]
+        );
       });
-      await this.schemaManager.value.updateFromOperations(batch);
-    } else if (isStreamingSyncCheckpointPartiallyComplete(line) || isStreamingSyncCheckpointComplete(line)) {
+      await this.schemaManager.value.updateFromOperations(bucket);
+    } else if ("partial_checkpoint_complete" in line || "checkpoint_complete" in line) {
       setTimeout(() => {
         this.schemaManager.value.refreshSchema(this.rdb);
       }, 60);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@powersync/nuxt",
-  "version": "0.0.0-dev-20260503073249",
+  "version": "0.0.0-dev-20260630141119",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
     "access": "public"
@@ -48,13 +48,15 @@
     "reka-ui": "^2.9.1",
     "shiki": "^3.23.0",
     "unocss": "^66.6.6",
-    "unstorage": "^1.17.4"
+    "unstorage": "^1.17.4",
+    "bson": "^6.10.4"
   },
   "peerDependencies": {
     "@journeyapps/wa-sqlite": "^1.7.0",
-    "@powersync/kysely-driver": "1.3.3",
-    "@powersync/vue": "0.5.1",
-    "@powersync/web": "0.0.0-dev-20260503073249"
+    "@powersync/kysely-driver": "0.0.0-dev-20260630141119",
+    "@powersync/vue": "0.0.0-dev-20260630141119",
+    "@powersync/web": "0.0.0-dev-20260630141119",
+    "@powersync/shared-internals": "1.0.0"
   },
   "peerDependenciesMeta": {
     "@powersync/kysely-driver": {
@@ -65,16 +67,16 @@
     "@journeyapps/wa-sqlite": "^1.7.0",
     "@nuxt/module-builder": "^1.0.2",
     "@nuxt/schema": "^4.3.1",
-    "@nuxt/test-utils": "^4.0.0",
-    "bson": "^6.10.4",
+    "@nuxt/test-utils": "^4.0.3",
     "comlink": "^4.4.2",
     "nuxt": "^4.3.1",
-    "vitest": "^3.2.4",
+    "vitest": "^4.1.8",
     "vue": "^3.5.30",
     "vue-tsc": "^3.2.5",
-    "@powersync/vue": "0.5.1",
-    "@powersync/kysely-driver": "1.3.3",
-    "@powersync/web": "0.0.0-dev-20260503073249"
+    "@powersync/kysely-driver": "0.0.0-dev-20260630141119",
+    "@powersync/vue": "0.0.0-dev-20260630141119",
+    "@powersync/web": "0.0.0-dev-20260630141119",
+    "@powersync/common": "0.0.0-dev-20260630141119"
   },
   "scripts": {
     "prebuild": "nuxt-module-build prepare",

package/dist/runtime/utils/RecordingStorageAdapter.d.ts

@@ -1,13 +0,0 @@
-import type { Checkpoint, ColumnType, PowerSyncDatabase, SyncDataBatch } from '@powersync/web';
-import { SqliteBucketStorage } from '@powersync/web';
-import type { DynamicSchemaManager } from './DynamicSchemaManager.js';
-import type { ShallowRef } from 'vue';
-export declare class RecordingStorageAdapter extends SqliteBucketStorage {
-    private rdb;
-    private schemaManager;
-    tables: Record<string, Record<string, ColumnType>>;
-    constructor(db: ShallowRef<PowerSyncDatabase>, schemaManager: ShallowRef<DynamicSchemaManager>);
-    setTargetCheckpoint(checkpoint: Checkpoint): Promise<void>;
-    syncLocalDatabase(checkpoint: Checkpoint, priority?: number): Promise<import("@powersync/common").SyncLocalDatabaseResult>;
-    saveSyncData(batch: SyncDataBatch): Promise<void>;
-}

package/dist/runtime/utils/RecordingStorageAdapter.js

@@ -1,58 +0,0 @@
-import { AbstractPowerSyncDatabase, SqliteBucketStorage } from "@powersync/web";
-export class RecordingStorageAdapter extends SqliteBucketStorage {
-  rdb;
-  schemaManager;
-  tables = {};
-  constructor(db, schemaManager) {
-    super(db.value.database, AbstractPowerSyncDatabase.transactionMutex);
-    this.rdb = db.value.database;
-    this.schemaManager = schemaManager.value;
-  }
-  async setTargetCheckpoint(checkpoint) {
-    await super.setTargetCheckpoint(checkpoint);
-    await this.rdb.writeTransaction(async (tx) => {
-      for (const bucket of checkpoint.buckets) {
-        await tx.execute(
-          `INSERT OR REPLACE INTO local_bucket_data(id, total_operations, last_op, download_size, downloading, downloaded_operations)
-             VALUES (
-              ?,
-              ?,
-              IFNULL((SELECT last_op FROM local_bucket_data WHERE id = ?), '0'),
-              IFNULL((SELECT download_size FROM local_bucket_data WHERE id = ?), 0),
-              IFNULL((SELECT downloading FROM local_bucket_data WHERE id = ?), TRUE),
-              IFNULL((SELECT downloaded_operations FROM local_bucket_data WHERE id = ?), TRUE)
-              )`,
-          [bucket.bucket, bucket.count, bucket.bucket, bucket.bucket, bucket.bucket, bucket.bucket]
-        );
-      }
-    });
-  }
-  async syncLocalDatabase(checkpoint, priority) {
-    const r = await super.syncLocalDatabase(checkpoint, priority);
-    setTimeout(() => {
-      this.schemaManager.refreshSchema(this.rdb);
-    }, 60);
-    if (r.checkpointValid) {
-      await this.rdb.execute("UPDATE local_bucket_data SET downloading = FALSE");
-    }
-    return r;
-  }
-  async saveSyncData(batch) {
-    await super.saveSyncData(batch);
-    await this.rdb.writeTransaction(async (tx) => {
-      for (const bucket of batch.buckets) {
-        const size = JSON.stringify(bucket.data).length;
-        await tx.execute(
-          `UPDATE local_bucket_data SET
-                download_size = IFNULL(download_size, 0) + ?,
-                last_op = ?,
-                downloading = ?,
-                downloaded_operations = IFNULL(downloaded_operations, 0) + ?
-              WHERE id = ?`,
-          [size, bucket.next_after, bucket.has_more, bucket.data.length, bucket.bucket]
-        );
-      }
-    });
-    await this.schemaManager.updateFromOperations(batch);
-  }
-}