@peers-app/peers-sdk 0.7.25 → 0.7.27

package/dist/context/user-context.js

@@ -158,13 +158,13 @@ class UserContext {
         // sync my user to personal db
         if (!(0, lodash_1.isEqual)(me, meSigned)) {
             (0, keys_1.verifyObjectSignature)(meSigned);
-            await (0, data_1.Users)(userContext.userDataContext).save(meSigned);
+            await (0, data_1.Users)(userContext.userDataContext).save(meSigned, { weakInsert: true });
         }
         // sync my user to all my groups
         for (const [, dataContext] of userContext.groupDataContexts) {
             let groupMe = await (0, data_1.Users)(dataContext).get(me.userId);
             if (!(0, lodash_1.isEqual)(groupMe, meSigned)) {
-                await (0, data_1.Users)(dataContext).save(meSigned);
+                await (0, data_1.Users)(dataContext).save(meSigned, { weakInsert: true });
             }
         }
         // sync group objects to my personal db

package/dist/data/change-tracking.d.ts

@@ -1,219 +1,133 @@
-import { z } from "zod";
-import { ISqlDb, SQLDataSource } from "./orm";
-import { Emitter, Event } from "../events";
-declare const insertChange: z.ZodObject<{
+/**
+ * Change tracking table V2
+ *
+ * This table stores granular change records for data synchronization.
+ * Unlike V1, each JSON patch operation gets its own record, enabling
+ * path-based superseding and more efficient cleanup.
+ */
+import { Emitter, Event } from '../events';
+import { DataFilter, IDataQueryParams, ISqlDb, ITableMetaData, SQLDataSource } from './orm';
+import { z } from 'zod';
+export declare const changeRecordSchema: z.ZodObject<{
     changeId: z.ZodEffects<z.ZodString, string, string>;
-    changeType: z.ZodUnion<[z.ZodUnion<[z.ZodLiteral<"insert">, z.ZodLiteral<"snapshot">]>, z.ZodLiteral<"restore">]>;
-    timestamp: z.ZodNumber;
-    timestampApplied: z.ZodNumber;
+    transactionId: z.ZodOptional<z.ZodString>;
     tableName: z.ZodString;
     recordId: z.ZodString;
-    newRecord: z.ZodObject<{}, "strip", z.ZodAny, z.objectOutputType<{}, z.ZodAny, "strip">, z.objectInputType<{}, z.ZodAny, "strip">>;
+    op: z.ZodEnum<["set", "delete", "patch-text"]>;
+    path: z.ZodString;
+    value: z.ZodOptional<z.ZodNullable<z.ZodAny>>;
+    createdAt: z.ZodNumber;
+    appliedAt: z.ZodNumber;
+    supersededAt: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
+    path: string;
+    createdAt: number;
     changeId: string;
-    changeType: "insert" | "snapshot" | "restore";
-    timestamp: number;
-    timestampApplied: number;
     tableName: string;
     recordId: string;
-    newRecord: {} & {
-        [k: string]: any;
-    };
+    op: "set" | "delete" | "patch-text";
+    appliedAt: number;
+    value?: any;
+    transactionId?: string | undefined;
+    supersededAt?: number | undefined;
 }, {
+    path: string;
+    createdAt: number;
     changeId: string;
-    changeType: "insert" | "snapshot" | "restore";
-    timestamp: number;
-    timestampApplied: number;
     tableName: string;
     recordId: string;
-    newRecord: {} & {
-        [k: string]: any;
-    };
+    op: "set" | "delete" | "patch-text";
+    appliedAt: number;
+    value?: any;
+    transactionId?: string | undefined;
+    supersededAt?: number | undefined;
 }>;
-export type IChangeInsert = z.infer<typeof insertChange>;
-declare const deleteChange: z.ZodObject<{
-    changeId: z.ZodEffects<z.ZodString, string, string>;
-    changeType: z.ZodLiteral<"delete">;
-    timestamp: z.ZodNumber;
-    timestampApplied: z.ZodNumber;
-    tableName: z.ZodString;
-    recordId: z.ZodString;
-    oldRecord: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodAny, z.objectOutputType<{}, z.ZodAny, "strip">, z.objectInputType<{}, z.ZodAny, "strip">>>;
-}, "strip", z.ZodTypeAny, {
-    changeId: string;
-    changeType: "delete";
-    timestamp: number;
-    timestampApplied: number;
-    tableName: string;
-    recordId: string;
-    oldRecord?: z.objectOutputType<{}, z.ZodAny, "strip"> | undefined;
-}, {
-    changeId: string;
-    changeType: "delete";
-    timestamp: number;
-    timestampApplied: number;
-    tableName: string;
-    recordId: string;
-    oldRecord?: z.objectInputType<{}, z.ZodAny, "strip"> | undefined;
-}>;
-export type IChangeDelete = z.infer<typeof deleteChange>;
-declare const updateChange: z.ZodObject<{
-    changeId: z.ZodEffects<z.ZodString, string, string>;
-    changeType: z.ZodLiteral<"update">;
-    timestamp: z.ZodNumber;
-    timestampApplied: z.ZodNumber;
-    tableName: z.ZodString;
-    recordId: z.ZodString;
-    newRecord: z.ZodObject<{}, "strip", z.ZodAny, z.objectOutputType<{}, z.ZodAny, "strip">, z.objectInputType<{}, z.ZodAny, "strip">>;
-    jsonDiff: z.ZodArray<z.ZodAny, "many">;
-}, "strip", z.ZodTypeAny, {
-    changeId: string;
-    changeType: "update";
-    timestamp: number;
-    timestampApplied: number;
-    tableName: string;
-    recordId: string;
-    newRecord: {} & {
-        [k: string]: any;
-    };
-    jsonDiff: any[];
-}, {
-    changeId: string;
-    changeType: "update";
-    timestamp: number;
-    timestampApplied: number;
-    tableName: string;
-    recordId: string;
-    newRecord: {} & {
-        [k: string]: any;
-    };
-    jsonDiff: any[];
-}>;
-export type IChangeUpdate = z.infer<typeof updateChange>;
-declare const changeSchema: z.ZodUnion<[z.ZodObject<{
-    changeId: z.ZodEffects<z.ZodString, string, string>;
-    changeType: z.ZodUnion<[z.ZodUnion<[z.ZodLiteral<"insert">, z.ZodLiteral<"snapshot">]>, z.ZodLiteral<"restore">]>;
-    timestamp: z.ZodNumber;
-    timestampApplied: z.ZodNumber;
-    tableName: z.ZodString;
-    recordId: z.ZodString;
-    newRecord: z.ZodObject<{}, "strip", z.ZodAny, z.objectOutputType<{}, z.ZodAny, "strip">, z.objectInputType<{}, z.ZodAny, "strip">>;
-}, "strip", z.ZodTypeAny, {
-    changeId: string;
-    changeType: "insert" | "snapshot" | "restore";
-    timestamp: number;
-    timestampApplied: number;
-    tableName: string;
-    recordId: string;
-    newRecord: {} & {
-        [k: string]: any;
-    };
-}, {
-    changeId: string;
-    changeType: "insert" | "snapshot" | "restore";
-    timestamp: number;
-    timestampApplied: number;
-    tableName: string;
-    recordId: string;
-    newRecord: {} & {
-        [k: string]: any;
-    };
-}>, z.ZodObject<{
-    changeId: z.ZodEffects<z.ZodString, string, string>;
-    changeType: z.ZodLiteral<"delete">;
-    timestamp: z.ZodNumber;
-    timestampApplied: z.ZodNumber;
-    tableName: z.ZodString;
-    recordId: z.ZodString;
-    oldRecord: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodAny, z.objectOutputType<{}, z.ZodAny, "strip">, z.objectInputType<{}, z.ZodAny, "strip">>>;
-}, "strip", z.ZodTypeAny, {
-    changeId: string;
-    changeType: "delete";
-    timestamp: number;
-    timestampApplied: number;
-    tableName: string;
-    recordId: string;
-    oldRecord?: z.objectOutputType<{}, z.ZodAny, "strip"> | undefined;
-}, {
-    changeId: string;
-    changeType: "delete";
-    timestamp: number;
-    timestampApplied: number;
-    tableName: string;
-    recordId: string;
-    oldRecord?: z.objectInputType<{}, z.ZodAny, "strip"> | undefined;
-}>, z.ZodObject<{
-    changeId: z.ZodEffects<z.ZodString, string, string>;
-    changeType: z.ZodLiteral<"update">;
-    timestamp: z.ZodNumber;
-    timestampApplied: z.ZodNumber;
-    tableName: z.ZodString;
-    recordId: z.ZodString;
-    newRecord: z.ZodObject<{}, "strip", z.ZodAny, z.objectOutputType<{}, z.ZodAny, "strip">, z.objectInputType<{}, z.ZodAny, "strip">>;
-    jsonDiff: z.ZodArray<z.ZodAny, "many">;
-}, "strip", z.ZodTypeAny, {
-    changeId: string;
-    changeType: "update";
-    timestamp: number;
-    timestampApplied: number;
-    tableName: string;
-    recordId: string;
-    newRecord: {} & {
-        [k: string]: any;
-    };
-    jsonDiff: any[];
-}, {
-    changeId: string;
-    changeType: "update";
-    timestamp: number;
-    timestampApplied: number;
-    tableName: string;
-    recordId: string;
-    newRecord: {} & {
-        [k: string]: any;
-    };
-    jsonDiff: any[];
-}>]>;
-export type IChange = z.infer<typeof changeSchema>;
-export declare const changeTrackingSchema: z.ZodObject<{
-    changeId: z.ZodEffects<z.ZodString, string, string>;
-    changeType: z.ZodEnum<["insert", "snapshot", "update", "delete", "restore"]>;
-    timestamp: z.ZodNumber;
-    timestampApplied: z.ZodNumber;
-    tableName: z.ZodString;
-    recordId: z.ZodString;
-    oldRecord: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodAny, z.objectOutputType<{}, z.ZodAny, "strip">, z.objectInputType<{}, z.ZodAny, "strip">>>;
-    newRecord: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodAny, z.objectOutputType<{}, z.ZodAny, "strip">, z.objectInputType<{}, z.ZodAny, "strip">>>;
-    jsonDiff: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
-}, "strip", z.ZodTypeAny, {
-    changeId: string;
-    changeType: "update" | "insert" | "delete" | "snapshot" | "restore";
-    timestamp: number;
-    timestampApplied: number;
-    tableName: string;
-    recordId: string;
-    newRecord?: z.objectOutputType<{}, z.ZodAny, "strip"> | undefined;
-    oldRecord?: z.objectOutputType<{}, z.ZodAny, "strip"> | undefined;
-    jsonDiff?: any[] | undefined;
-}, {
-    changeId: string;
-    changeType: "update" | "insert" | "delete" | "snapshot" | "restore";
-    timestamp: number;
-    timestampApplied: number;
-    tableName: string;
-    recordId: string;
-    newRecord?: z.objectInputType<{}, z.ZodAny, "strip"> | undefined;
-    oldRecord?: z.objectInputType<{}, z.ZodAny, "strip"> | undefined;
-    jsonDiff?: any[] | undefined;
-}>;
-export type IChangeAny = z.infer<typeof changeTrackingSchema>;
-export declare class ChangeTrackingTable extends SQLDataSource<IChange> {
-    constructor({ db, }: {
+export type IChangeRecord = z.infer<typeof changeRecordSchema>;
+export declare class ChangeTrackingTable extends SQLDataSource<IChangeRecord> {
+    readonly dataChangedEmitter: Emitter<IChangeRecord>;
+    readonly dataChanged: Event<IChangeRecord>;
+    constructor({ db }: {
         db: ISqlDb;
     });
-    readonly dataChangedEmitter: Emitter<IChange>;
-    readonly dataChanged: Event<IChange>;
+    /**
+     * Efficiently find which recordIds have been deleted.
+     *
+     * A record is deleted if the most recent write to path "/" is a 'delete' operation.
+     * This handles distributed scenarios where peers may write to specific paths after
+     * deletion - those writes are valid but superseded.
+     *
+     * Uses optimized SQL with CTE for performance.
+     *
+     * @param recordIds - Array of recordIds to check
+     * @returns Array of recordIds that are deleted
+     */
     filterToDeletedIds(recordIds: string[]): Promise<string[]>;
+    /**
+     * Find recordIds that have no change records at all.
+     *
+     * This is useful for identifying records that were never synced
+     * or have been completely cleaned up.
+     *
+     * @param recordIds - Array of recordIds to check
+     * @returns Array of recordIds with no change records
+     */
     filterToMissingIds(recordIds: string[]): Promise<string[]>;
+    /**
+    * Find changeIds that we do not have
+    *
+    * @param changeIds - Array of changeIds to check
+    * @returns Array of changeIds with no change records
+    */
+    filterToMissingChangeIds(changeIds: string[]): Promise<string[]>;
+    markAllPriorChangesSuperseded(tableName: string, recordId: string, supersededAt: number): Promise<void>;
+    /**
+     * Batch update supersededAt timestamps for multiple changes.
+     * More efficient than updating one at a time.
+     *
+     * @param updates - Array of {changeId, supersededAt} pairs
+     */
+    batchMarkSuperseded(updates: Array<{
+        changeId: string;
+        supersededAt: number;
+    }>): Promise<void>;
+    /**
+     * Override list to deserialize value field from JSON string
+     */
+    list(filter?: DataFilter<IChangeRecord>, opts?: IDataQueryParams<IChangeRecord>): Promise<IChangeRecord[]>;
+    /**
+     * Override get to deserialize value field from JSON string
+     */
+    get(id: string): Promise<IChangeRecord | undefined>;
+    /**
+     * Override to serialize value field to JSON string
+     */
+    insert(record: IChangeRecord): Promise<IChangeRecord>;
+    /**
+     * Override to serialize value field to JSON string
+     */
+    update(record: IChangeRecord): Promise<IChangeRecord>;
+    /**
+     * Deserialize the value field if it's a JSON string
+     * For path "/" (full object changes), use fromJSONString to handle special types
+     */
+    private deserializeValue;
+    /**
+     * Delete all superseded changes for a specific table that were superseded before the given timestamp.
+     * This is used for compaction to prevent the change tracking table from growing indefinitely.
+     *
+     * @param tableName - Name of the table to compact
+     * @param beforeTimestamp - Delete changes superseded before this timestamp
+     */
+    deleteSupersededChangesOlderThan(tableName: string, beforeTimestamp: number): Promise<void>;
+    /**
+     * Bulk delete changes
+     *
+     * @param tableName - Name of the table to compact
+     * @param beforeTimestamp - Delete changes superseded before this timestamp
+     */
+    deleteChanges(changeIds: string[]): Promise<void>;
+    /**
+     * Get table metadata
+     */
+    static getTableMetaData(): ITableMetaData;
 }
-export {};

package/dist/data/change-tracking.js

@@ -1,122 +1,269 @@
 "use strict";
+/**
+ * Change tracking table V2
+ *
+ * This table stores granular change records for data synchronization.
+ * Unlike V1, each JSON patch operation gets its own record, enabling
+ * path-based superseding and more efficient cleanup.
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ChangeTrackingTable = exports.changeTrackingSchema = void 0;
-const zod_1 = require("zod");
-const zod_types_1 = require("../types/zod-types");
-const orm_1 = require("./orm");
+exports.ChangeTrackingTable = exports.changeRecordSchema = void 0;
 const events_1 = require("../events");
+const serial_json_1 = require("../serial-json");
 const utils_1 = require("../utils");
-const changeType = zod_1.z.enum(['insert', 'snapshot', 'update', 'delete', 'restore']);
-const insertChange = zod_1.z.object({
-    changeId: zod_types_1.zodPeerId,
-    changeType: zod_1.z.literal('insert').or(zod_1.z.literal('snapshot')).or(zod_1.z.literal('restore')),
-    timestamp: zod_1.z.number(),
-    timestampApplied: zod_1.z.number(),
-    tableName: zod_1.z.string(),
-    recordId: zod_1.z.string(),
-    newRecord: zod_types_1.zodAnyObject,
-});
-const deleteChange = zod_1.z.object({
-    changeId: zod_types_1.zodPeerId,
-    changeType: zod_1.z.literal('delete'),
-    timestamp: zod_1.z.number(),
-    timestampApplied: zod_1.z.number(),
-    tableName: zod_1.z.string(),
-    recordId: zod_1.z.string(),
-    oldRecord: zod_types_1.zodAnyObject.optional(),
-});
-const updateChange = zod_1.z.object({
-    changeId: zod_types_1.zodPeerId,
-    changeType: zod_1.z.literal('update'),
-    timestamp: zod_1.z.number(),
-    timestampApplied: zod_1.z.number(),
-    tableName: zod_1.z.string(),
-    recordId: zod_1.z.string(),
-    newRecord: zod_types_1.zodAnyObject,
-    jsonDiff: zod_1.z.array(zod_1.z.any()),
-});
-const changeSchema = zod_1.z.union([insertChange, deleteChange, updateChange]);
-exports.changeTrackingSchema = zod_1.z.object({
+const orm_1 = require("./orm");
+const zod_1 = require("zod");
+const zod_types_1 = require("../types/zod-types");
+exports.changeRecordSchema = zod_1.z.object({
     changeId: zod_types_1.zodPeerId,
-    changeType: changeType,
-    timestamp: zod_1.z.number(),
-    timestampApplied: zod_1.z.number(),
+    transactionId: zod_1.z.string().optional(), // not used for now
     tableName: zod_1.z.string(),
     recordId: zod_1.z.string(),
-    oldRecord: zod_types_1.zodAnyObject.optional(),
-    newRecord: zod_types_1.zodAnyObject.optional(),
-    jsonDiff: zod_1.z.array(zod_1.z.any()).optional(),
+    op: zod_1.z.enum(['set', 'delete', 'patch-text']),
+    path: zod_1.z.string().describe('JSON Patch path (e.g., "/title", "/age")'),
+    value: zod_1.z.any().nullish().describe('JSON value - can be any type (object, string, number, boolean, array, null, or undefined)'),
+    createdAt: zod_1.z.number(),
+    appliedAt: zod_1.z.number(),
+    supersededAt: zod_1.z.number().optional(),
 });
-const changeTrackingTableMetaData = {
-    name: 'ChangeTracking',
+const changeTrackingV2TableMetaData = {
+    name: 'ChangeTrackingV2',
     primaryKeyName: 'changeId',
-    description: 'Change tracking table',
-    fields: (0, orm_1.schemaToFields)(exports.changeTrackingSchema),
+    description: 'Change tracking table V2 with superseding support',
+    fields: (0, orm_1.schemaToFields)(exports.changeRecordSchema),
     indexes: [
-        { fields: ['tableName'] },
-        { fields: ['recordId'] },
-        { fields: ['changeType'] },
-        { fields: ['timestamp'] },
-        { fields: ['timestampApplied'] },
-        // compound indexes for common queries
-        { fields: ['tableName', 'recordId', 'timestamp'] },
-        { fields: ['recordId', 'changeType'] },
+        // Single-column indexes for common sorting/filtering
+        { fields: ['createdAt'] },
+        { fields: ['appliedAt'] },
+        // Compound indexes optimized for actual query patterns
+        { fields: ['tableName', 'recordId', 'createdAt'] }, // active changes by table + record
+        { fields: ['tableName', 'recordId', 'supersededAt'] }, // active changes lookup without full sort
+        { fields: ['recordId', 'path'] }, // path-based superseding and deleted record checks
+        { fields: ['supersededAt', 'appliedAt', 'createdAt'] }, // main sync query (supersededAt filter + appliedAt range + createdAt sort)
+        { fields: ['tableName', 'supersededAt'] }, // cleanup superseded changes by table
     ],
     localOnly: true,
 };
 class ChangeTrackingTable extends orm_1.SQLDataSource {
-    constructor({ db, }) {
-        super(db, changeTrackingTableMetaData, changeSchema);
-        const tableName = changeTrackingTableMetaData.name;
-        this.dataChangedEmitter = new events_1.Emitter(tableName + "_DataChanged_" + (0, utils_1.newid)());
+    dataChangedEmitter;
+    dataChanged;
+    constructor({ db }) {
+        super(db, changeTrackingV2TableMetaData, exports.changeRecordSchema);
+        const tableName = changeTrackingV2TableMetaData.name;
+        this.dataChangedEmitter = new events_1.Emitter(tableName + '_DataChanged_' + (0, utils_1.newid)());
         // @ts-ignore
         this.dataChanged = this.dataChangedEmitter.event;
-        // TODO turn this back on to observe changes and make it performant
-        // this.dataChanged.subscribe((change) => {
-        //   console.log("Data changed:", change);
-        // });
     }
-    dataChangedEmitter;
-    dataChanged;
+    /**
+     * Efficiently find which recordIds have been deleted.
+     *
+     * A record is deleted if the most recent write to path "/" is a 'delete' operation.
+     * This handles distributed scenarios where peers may write to specific paths after
+     * deletion - those writes are valid but superseded.
+     *
+     * Uses optimized SQL with CTE for performance.
+     *
+     * @param recordIds - Array of recordIds to check
+     * @returns Array of recordIds that are deleted
+     */
     async filterToDeletedIds(recordIds) {
+        if (recordIds.length === 0)
+            return [];
         await this.initTable();
-        // find all changes who have been deleted
+        // Find the most recent change to path "/" for each record
+        // If it's a 'delete' operation, the record is deleted
         const deletedRecordsResult = await this.db.all(`
-      WITH InsertsAndDeletes AS (
-        SELECT 
+      WITH RootPathChanges AS (
+        SELECT
           recordId,
-          MAX(timestamp) as last_timestamp
+          op,
+          MAX(createdAt) as last_timestamp
         FROM "${this.tableName}"
         WHERE
-          recordId IN (${recordIds.map(() => '?').join(',')}) AND
-          changeType IN ('restore', 'delete')
+          recordId IN (${recordIds.map(() => '?').join(',')})
+          AND path = '/'
         GROUP BY recordId
       )
-      SELECT 
-        ct.recordId 
-      FROM "${this.tableName}" ct
-      JOIN InsertsAndDeletes iad ON ct.recordId = iad.recordId AND ct.timestamp = iad.last_timestamp
-      WHERE
-        ct.changeType = 'delete'
-      `, recordIds);
+      SELECT
+        recordId
+      FROM RootPathChanges
+      WHERE op = 'delete'
+    `, recordIds);
         return deletedRecordsResult.map(d => d.recordId);
     }
+    /**
+     * Find recordIds that have no change records at all.
+     *
+     * This is useful for identifying records that were never synced
+     * or have been completely cleaned up.
+     *
+     * @param recordIds - Array of recordIds to check
+     * @returns Array of recordIds with no change records
+     */
     async filterToMissingIds(recordIds) {
+        if (recordIds.length === 0)
+            return [];
         await this.initTable();
         const missingRecordsResult = await this.db.all(`
       WITH InputRecordIds(recordId) AS (
         VALUES
-          ${recordIds.map(() => '(?)').join(',\n      ')}
+          ${recordIds.map(() => '(?)').join(',\n          ')}
       )
-      SELECT 
+      SELECT
         i.recordId
       FROM InputRecordIds AS i
       LEFT JOIN "${this.tableName}" AS existing
         ON i.recordId = existing.recordId
-      WHERE existing.recordId IS NULL;
-      `, recordIds);
-        let missingIds = missingRecordsResult.map(d => d.recordId);
-        return missingIds;
+      WHERE existing.recordId IS NULL
+    `, recordIds);
+        return missingRecordsResult.map(d => d.recordId);
+    }
+    /**
+    * Find changeIds that we do not have
+    *
+    * @param changeIds - Array of changeIds to check
+    * @returns Array of changeIds with no change records
+    */
+    async filterToMissingChangeIds(changeIds) {
+        if (changeIds.length === 0)
+            return [];
+        await this.initTable();
+        const missingChangeIds = await this.db.all(`
+      WITH InputChangeIds(changeId) AS (
+        VALUES
+          ${changeIds.map(() => '(?)').join(',\n          ')}
+      )
+      SELECT
+        i.changeId
+      FROM InputChangeIds AS i
+      LEFT JOIN "${this.tableName}" AS existing
+        ON i.changeId = existing.changeId
+      WHERE existing.changeId IS NULL
+    `, changeIds);
+        return missingChangeIds.map(d => d.changeId);
+    }
+    async markAllPriorChangesSuperseded(tableName, recordId, supersededAt) {
+        await this.db.exec(`
+      UPDATE "${this.tableName}" 
+      SET supersededAt = $supersededAt
+      WHERE 
+        tableName = $tableName AND
+        recordId = $recordId AND 
+        createdAt < $supersededAt AND
+        supersededAt IS NULL 
+    `, { tableName, recordId, supersededAt });
+    }
+    /**
+     * Batch update supersededAt timestamps for multiple changes.
+     * More efficient than updating one at a time.
+     *
+     * @param updates - Array of {changeId, supersededAt} pairs
+     */
+    async batchMarkSuperseded(updates) {
+        if (updates.length === 0)
+            return;
+        await this.initTable();
+        // Build a CASE statement for bulk update
+        const changeIds = updates.map(u => u.changeId);
+        const caseStatement = updates.map(u => `WHEN '${u.changeId}' THEN ${u.supersededAt}`).join('\n        ');
+        await this.db.exec(`
+      UPDATE "${this.tableName}"
+      SET supersededAt = CASE changeId
+        ${caseStatement}
+      END
+      WHERE changeId IN (${changeIds.map(() => '?').join(',')})
+    `, changeIds);
+    }
+    /**
+     * Override list to deserialize value field from JSON string
+     */
+    async list(filter, opts) {
+        const records = await super.list(filter, opts);
+        return records.map(this.deserializeValue);
+    }
+    /**
+     * Override get to deserialize value field from JSON string
+     */
+    async get(id) {
+        const record = await super.get(id);
+        return record ? this.deserializeValue(record) : undefined;
+    }
+    /**
+     * Override to serialize value field to JSON string
+     */
+    async insert(record) {
+        if (record.value !== undefined) {
+            record.value = (0, serial_json_1.toJSONString)(record.value);
+        }
+        return super.insert(record);
+    }
+    /**
+     * Override to serialize value field to JSON string
+     */
+    async update(record) {
+        if (record.value !== undefined) {
+            record.value = (0, serial_json_1.toJSONString)(record.value);
+        }
+        return super.update(record);
+    }
+    /**
+     * Deserialize the value field if it's a JSON string
+     * For path "/" (full object changes), use fromJSONString to handle special types
+     */
+    deserializeValue(record) {
+        if (record.value !== undefined) {
+            record.value = (0, serial_json_1.fromJSONString)(record.value);
+        }
+        // if (typeof record.value === 'string') {
+        //   try {
+        //     if (record.path === '/') {
+        //       // use metadata to convert record
+        //       record.value = fromJSONString(record.value);
+        //     } else {
+        //       // Use plain JSON.parse for field values
+        //       // record.value = JSON.parse(record.value);
+        //       record.value = fromJSONString(record.value);
+        //     }
+        //   } catch (e) {
+        //     // If it's not valid JSON, leave it as a string
+        //   }
+        // }
+        return record;
+    }
+    /**
+     * Delete all superseded changes for a specific table that were superseded before the given timestamp.
+     * This is used for compaction to prevent the change tracking table from growing indefinitely.
+     *
+     * @param tableName - Name of the table to compact
+     * @param beforeTimestamp - Delete changes superseded before this timestamp
+     */
+    async deleteSupersededChangesOlderThan(tableName, beforeTimestamp) {
+        await this.initTable();
+        await this.db.exec(`
+      DELETE FROM "${this.tableName}"
+      WHERE tableName = ?
+        AND supersededAt IS NOT NULL
+        AND supersededAt < ?
+    `, [tableName, beforeTimestamp]);
+    }
+    /**
+     * Bulk delete changes
+     *
+     * @param tableName - Name of the table to compact
+     * @param beforeTimestamp - Delete changes superseded before this timestamp
+     */
+    async deleteChanges(changeIds) {
+        await this.initTable();
+        await this.db.exec(`
+      DELETE FROM "${this.tableName}"
+      WHERE changeId IN (${changeIds.map(c => "?").join()})
+    `, changeIds);
+    }
+    /**
+     * Get table metadata
+     */
+    static getTableMetaData() {
+        return changeTrackingV2TableMetaData;
     }
 }
 exports.ChangeTrackingTable = ChangeTrackingTable;

package/dist/data/data-locks.js

@@ -115,12 +115,23 @@ class DataLocksTable extends orm_1.Table {
     async countLockAcknowledgements(lock) {
         if (!this.peerDevice)
             throw new Error(`Peer device not set for DataLocksTable`);
-        const updates = await this.peerDevice.listChanges({
+        const changes = await this.peerDevice.listChanges({
             tableName: dataLocksTableMetaData.name,
             recordId: lock.dataLockId,
-            changeType: 'update',
+            op: 'set', // V2 uses 'set' for updates
         });
-        const acknowledgedUpdates = updates.map(u => u.newRecord.acknowledged).filter(a => a !== undefined);
+        // In V2, look for changes at path "/acknowledged" or full record changes at path "/"
+        const acknowledgedUpdates = changes
+            .map(change => {
+            if (change.path === '/acknowledged') {
+                return change.value;
+            }
+            else if (change.path === '/' && change.value && typeof change.value === 'object') {
+                return change.value.acknowledged;
+            }
+            return undefined;
+        })
+            .filter(a => a !== undefined);
         // NOTE this could potentially miscount if two peers acknowledge the lock with the same timestamp (very unlikely)
         return (0, lodash_1.uniq)(acknowledgedUpdates).length;
     }

package/dist/data/data-locks.test.js

@@ -60,7 +60,7 @@ class MockPeerDevice {
             return this.changes;
         return this.changes.filter(change => change.tableName === query.tableName &&
             change.recordId === query.recordId &&
-            change.changeType === query.changeType);
+            change.op === query.op);
     }
     async notifyOfChanges(deviceId, timestampLastApplied) {
         // Mock implementation
@@ -78,11 +78,11 @@ class MockPeerDevice {
             changeId: (0, utils_1.newid)(),
             tableName: 'DataLocks',
             recordId,
-            changeType: 'update',
-            newRecord: { acknowledged },
-            timestamp: Date.now(),
-            timestampApplied: Date.now(),
-            jsonDiff: []
+            op: 'set',
+            path: '/acknowledged',
+            value: acknowledged,
+            createdAt: Date.now(),
+            appliedAt: Date.now(),
         });
     }
     setConnectionCount(count) {

package/dist/data/orm/data-query.d.ts

@@ -1,6 +1,7 @@
 export interface ISaveOptions {
     restoreIfDeleted?: boolean;
     saveAsSnapshot?: boolean;
+    weakInsert?: boolean;
 }
 export interface IDataSource<T extends {
     [key: string]: any;

package/dist/device/connection.js

@@ -225,7 +225,7 @@ class Connection {
             this.emit('reset');
             throw new Error('Untrusted connection');
         }
-        console.log(`Connection ${this.connectionId} verified on server side with trust level ${this.trustLevel}`);
+        // console.log(`Connection ${this.connectionId} verified on server side with trust level ${this.trustLevel}`);
         this._verified = true;
         if (this.onHandshakeComplete) {
             setTimeout(() => {
@@ -264,7 +264,7 @@ class Connection {
             this.emit('reset');
             throw new Error('Untrusted connection');
         }
-        console.log(`Connection ${this.connectionId} (${remoteAddress}) verified on client side with trust level ${this.trustLevel}`);
+        // console.log(`Connection ${this.connectionId} (${remoteAddress}) verified on client side with trust level ${this.trustLevel}`);
         return handshakeResponse;
     }
     closeLocal() {

package/dist/device/get-trust-level-fn.js

@@ -13,19 +13,24 @@ function getTrustLevelFn(me, serverUrl) {
             // if (deviceInfo.deviceId === thisDeviceId()) {
             //   return TrustLevel.Untrusted;
             // }
-            const device = await (0, data_1.Devices)(userDataContext).get(deviceInfo.deviceId) || {
+            const existingDevice = await (0, data_1.Devices)(userDataContext).get(deviceInfo.deviceId);
+            const device = existingDevice || {
                 deviceId: deviceInfo.deviceId,
                 userId: deviceInfo.userId,
                 firstSeen: new Date(),
                 lastSeen: new Date(),
-                trustLevel: socket_type_1.TrustLevel.Trusted,
+                trustLevel: socket_type_1.TrustLevel.NewDevice,
                 serverUrl,
             };
             device.lastSeen = new Date();
-            device.trustLevel = socket_type_1.TrustLevel.Trusted;
+            const seenMoreThan2DaysAgo = Date.now() - device.firstSeen.getTime() > 1000 * 60 * 60 * 24 * 2;
+            device.trustLevel = seenMoreThan2DaysAgo ? socket_type_1.TrustLevel.Trusted : socket_type_1.TrustLevel.NewDevice;
             console.log(`Updating my own device: ${deviceInfo.deviceId}`);
-            await (0, data_1.Devices)(userDataContext).save(device, { restoreIfDeleted: true });
-            return socket_type_1.TrustLevel.Trusted;
+            await (0, data_1.Devices)(userDataContext).save(device, {
+                restoreIfDeleted: true,
+                weakInsert: true,
+            });
+            return device.trustLevel;
         }
         let [user, device, userTrustLevel] = await Promise.all([
             (0, data_1.Users)(userDataContext).get(deviceInfo.userId),
@@ -113,10 +118,16 @@ function getTrustLevelFn(me, serverUrl) {
         // } 
         if (newUser) {
             // TODO: I'm not sure we immediately want to save this user to the my personal db...
-            await (0, data_1.Users)(userDataContext).save(user, { restoreIfDeleted: true });
+            await (0, data_1.Users)(userDataContext).save(user, {
+                restoreIfDeleted: true,
+                weakInsert: true,
+            });
         }
         // device.trustLevel = remoteTrustLevel || trustLevel;
-        await (0, data_1.Devices)(userDataContext).save(device, { restoreIfDeleted: true });
+        await (0, data_1.Devices)(userDataContext).save(device, {
+            restoreIfDeleted: true,
+            weakInsert: true,
+        });
         return device.trustLevel;
     };
 }

package/dist/logging/console-logs.table.d.ts

@@ -14,8 +14,8 @@ export declare const consoleLogSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     message: string;
     level: "error" | "debug" | "info" | "log" | "warn";
-    timestamp: number;
     logId: string;
+    timestamp: number;
     process: string;
     processInstanceId: string;
     source?: string | undefined;

package/dist/types/peer-device.d.ts

@@ -1,10 +1,10 @@
-import type { IChange, GroupMemberRole } from "../data";
+import type { IChangeRecord, GroupMemberRole } from "../data";
 import type { DataFilter, IDataQueryParams } from "../data/orm";
 export interface IPeerDevice {
     deviceId: string;
     userId: string;
     role: GroupMemberRole;
-    listChanges(filter?: DataFilter<IChange>, opts?: IDataQueryParams<IChange>): Promise<IChange[]>;
+    listChanges(filter?: DataFilter<IChangeRecord>, opts?: IDataQueryParams<IChangeRecord>): Promise<IChangeRecord[]>;
     getNetworkInfo(): Promise<INetworkInfo>;
     notifyOfChanges(deviceId: string, timestampLastApplied: number): Promise<void>;
     sendDeviceMessage(message: IDeviceMessage): Promise<any>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peers-app/peers-sdk",
-  "version": "0.7.25",
+  "version": "0.7.27",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/peers-app/peers-sdk.git"