sqlite-sync-core 0.2.0__tar.gz → 0.5.0__tar.gz

sqlite_sync_core-0.5.0/PKG-INFO

@@ -0,0 +1,176 @@
+Metadata-Version: 2.4
+Name: sqlite-sync-core
+Version: 0.5.0
+Summary: Universal SQLite Synchronization Core - A dependency-grade, local-first, offline-first SQLite synchronization primitive
+License: AGPL-3.0
+Project-URL: Homepage, https://github.com/shivay00001/sqlite-sync-core
+Project-URL: Documentation, https://github.com/shivay00001/sqlite-sync-core#readme
+Project-URL: Repository, https://github.com/shivay00001/sqlite-sync-core.git
+Project-URL: Issues, https://github.com/shivay00001/sqlite-sync-core/issues
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: GNU Affero General Public License v3
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Database
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: msgpack>=1.0.0
+Requires-Dist: websockets>=12.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Provides-Extra: server
+Requires-Dist: flask>=3.0.0; extra == "server"
+Provides-Extra: crypto
+Requires-Dist: cryptography>=41.0.0; extra == "crypto"
+Provides-Extra: all
+Requires-Dist: flask>=3.0.0; extra == "all"
+Requires-Dist: cryptography>=41.0.0; extra == "all"
+Dynamic: license-file
+
+# sqlite-sync-core
+
+[![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/downloads/)
+[![License: AGPL-3.0](https://img.shields.io/badge/License-AGPL--3.0-blue.svg)](https://www.gnu.org/licenses/agpl-3.0)
+[![PyPI](https://img.shields.io/pypi/v/sqlite-sync-core.svg)](https://pypi.org/project/sqlite-sync-core/)
+[![Status: Production Grade](https://img.shields.io/badge/status-production--grade-brightgreen.svg)](https://github.com/shivay00001/sqlite-sync-core)
+
+**A production-grade, turn-key synchronization system for SQLite.**
+
+`sqlite-sync-core` provides a powerful, local-first synchronization engine that works seamlessly across multi-peer networks. It handles the "hard parts" of sync (vector clocks, causality, delta bundles, and conflict resolution) while providing a simple, turn-key interface for developers.
+
+---
+
+## 🚀 Turn-Key Synchronization
+
+You can launch a full synchronization node in one command. No infrastructure required.
+
+### 16-Second Setup (CLI)
+
+```bash
+# Install the package
+pip install sqlite-sync-core
+
+# Start a node and sync the 'tasks' table automatically
+sqlite-sync start --db app.db --name Device-A --tables tasks
+```
+
+### Automatic Multi-Peer Sync
+
+Nodes automatically discover each other on the local network (P2P) and synchronize state in the background without any manual peer configuration.
+
+---
+
+## 🏗️ Enterprise Features
+
+- **Multi-Peer Orchestration**: Automatically scales sync across N devices.
+- **P2P Discovery**: Zero-config peer-to-peer discovery on LAN.
+- **Automatic Resolution**: Configurable strategies like Last-Write-Wins and Field-Level Merge.
+- **Schema Evolution**: Built-in migrations that sync across the network.
+- **Transport Agnostic**: Works over HTTP, WebSockets, or file transfer.
+
+---
+
+## Technical Usage (Library)
+
+### Initialize a Node in Code
+
+```python
+from sqlite_sync import SyncNode
+
+node = SyncNode(
+    db_path="app.db",
+    device_name="MobileApp",
+    sync_interval=10  # Sync every 10 seconds
+)
+
+await node.start()
+node.enable_sync_for_table("users")
+```
+
+### Safe Schema Migrations
+
+```bash
+# Safely add a column that will sync to all other peers
+sqlite-sync migrate --db app.db --table tasks --add-column priority --type INTEGER
+```
+
+---
+
+## Core Invariants
+
+| # | Invariant | Description |
+|---|-----------|-------------|
+| 1 | **Causal consistency** | Vector clocks ensure the correct order of operations. |
+| 2 | **Deterministic Replay** | Identical sets of operations always result in identical state. |
+| 3 | **Conflict Tolerance** | Detects and resolves conflicts explicitly and safely. |
+| 4 | **Offline-First** | Entirely local-first design; works without cloud or internet. |
+
+### 2. Generate a Delta Bundle
+
+```python
+# To be sent to Peer B
+bundle_path = engine.generate_bundle(
+    peer_device_id=peer_b_id,
+    output_path="delta.db"
+)
+```
+
+### 3. Import and Detect Conflicts
+
+```python
+# On Peer B
+result = engine.import_bundle("delta.db")
+
+print(f"Ops Applied: {result.applied_count}")
+print(f"Conflicts Detected: {result.conflict_count}")
+```
+
+---
+
+## Core Invariants
+
+| # | Invariant | Description |
+|---|-----------|-------------|
+| 1 | **Append-only** | Operation history is immutable. |
+| 2 | **Causal consistency** | Hybrid Logical Clocks (HLC) ensure correct partial ordering and wall-clock correlation. |
+| 3 | **Deterministic** | Replay results are identical across all replicas. |
+| 4 | **Field-Level Merge** | "Smart" LWW resolution merges concurrent non-conflicting field updates. |
+
+---
+
+## Architecture
+
+```
+┌─────────────────────────────────┐
+│     Your Sync System / App      │
+└───────────────┬─────────────────┘
+                │ Uses
+┌───────────────▼─────────────────┐
+│       sqlite-sync-core          │
+│  (Logging, Bundling, Clocks)    │
+└───────────────┬─────────────────┘
+                │ Persists to
+┌───────────────▼─────────────────┐
+│         SQLite Database         │
+└─────────────────────────────────┘
+```
+
+---
+
+## License
+
+**AGPL-3.0** for Open Source.
+Contact <shivaysinghrajput@proton.me> for commercial licensing.
+
+---
+
+**Built for developers who need a reliable sync foundation.**

sqlite_sync_core-0.5.0/README.md

@@ -0,0 +1,138 @@
+# sqlite-sync-core
+
+[![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/downloads/)
+[![License: AGPL-3.0](https://img.shields.io/badge/License-AGPL--3.0-blue.svg)](https://www.gnu.org/licenses/agpl-3.0)
+[![PyPI](https://img.shields.io/pypi/v/sqlite-sync-core.svg)](https://pypi.org/project/sqlite-sync-core/)
+[![Status: Production Grade](https://img.shields.io/badge/status-production--grade-brightgreen.svg)](https://github.com/shivay00001/sqlite-sync-core)
+
+**A production-grade, turn-key synchronization system for SQLite.**
+
+`sqlite-sync-core` provides a powerful, local-first synchronization engine that works seamlessly across multi-peer networks. It handles the "hard parts" of sync (vector clocks, causality, delta bundles, and conflict resolution) while providing a simple, turn-key interface for developers.
+
+---
+
+## 🚀 Turn-Key Synchronization
+
+You can launch a full synchronization node in one command. No infrastructure required.
+
+### 16-Second Setup (CLI)
+
+```bash
+# Install the package
+pip install sqlite-sync-core
+
+# Start a node and sync the 'tasks' table automatically
+sqlite-sync start --db app.db --name Device-A --tables tasks
+```
+
+### Automatic Multi-Peer Sync
+
+Nodes automatically discover each other on the local network (P2P) and synchronize state in the background without any manual peer configuration.
+
+---
+
+## 🏗️ Enterprise Features
+
+- **Multi-Peer Orchestration**: Automatically scales sync across N devices.
+- **P2P Discovery**: Zero-config peer-to-peer discovery on LAN.
+- **Automatic Resolution**: Configurable strategies like Last-Write-Wins and Field-Level Merge.
+- **Schema Evolution**: Built-in migrations that sync across the network.
+- **Transport Agnostic**: Works over HTTP, WebSockets, or file transfer.
+
+---
+
+## Technical Usage (Library)
+
+### Initialize a Node in Code
+
+```python
+from sqlite_sync import SyncNode
+
+node = SyncNode(
+    db_path="app.db",
+    device_name="MobileApp",
+    sync_interval=10  # Sync every 10 seconds
+)
+
+await node.start()
+node.enable_sync_for_table("users")
+```
+
+### Safe Schema Migrations
+
+```bash
+# Safely add a column that will sync to all other peers
+sqlite-sync migrate --db app.db --table tasks --add-column priority --type INTEGER
+```
+
+---
+
+## Core Invariants
+
+| # | Invariant | Description |
+|---|-----------|-------------|
+| 1 | **Causal consistency** | Vector clocks ensure the correct order of operations. |
+| 2 | **Deterministic Replay** | Identical sets of operations always result in identical state. |
+| 3 | **Conflict Tolerance** | Detects and resolves conflicts explicitly and safely. |
+| 4 | **Offline-First** | Entirely local-first design; works without cloud or internet. |
+
+### 2. Generate a Delta Bundle
+
+```python
+# To be sent to Peer B
+bundle_path = engine.generate_bundle(
+    peer_device_id=peer_b_id,
+    output_path="delta.db"
+)
+```
+
+### 3. Import and Detect Conflicts
+
+```python
+# On Peer B
+result = engine.import_bundle("delta.db")
+
+print(f"Ops Applied: {result.applied_count}")
+print(f"Conflicts Detected: {result.conflict_count}")
+```
+
+---
+
+## Core Invariants
+
+| # | Invariant | Description |
+|---|-----------|-------------|
+| 1 | **Append-only** | Operation history is immutable. |
+| 2 | **Causal consistency** | Hybrid Logical Clocks (HLC) ensure correct partial ordering and wall-clock correlation. |
+| 3 | **Deterministic** | Replay results are identical across all replicas. |
+| 4 | **Field-Level Merge** | "Smart" LWW resolution merges concurrent non-conflicting field updates. |
+
+---
+
+## Architecture
+
+```
+┌─────────────────────────────────┐
+│     Your Sync System / App      │
+└───────────────┬─────────────────┘
+                │ Uses
+┌───────────────▼─────────────────┐
+│       sqlite-sync-core          │
+│  (Logging, Bundling, Clocks)    │
+└───────────────┬─────────────────┘
+                │ Persists to
+┌───────────────▼─────────────────┐
+│         SQLite Database         │
+└─────────────────────────────────┘
+```
+
+---
+
+## License
+
+**AGPL-3.0** for Open Source.
+Contact <shivaysinghrajput@proton.me> for commercial licensing.
+
+---
+
+**Built for developers who need a reliable sync foundation.**

{sqlite_sync_core-0.2.0 → sqlite_sync_core-0.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sqlite-sync-core"
-version = "0.2.0"
+version = "0.5.0"
 description = "Universal SQLite Synchronization Core - A dependency-grade, local-first, offline-first SQLite synchronization primitive"
 readme = "README.md"
 license = {text = "AGPL-3.0"}
@@ -50,6 +50,9 @@ all = [
     "cryptography>=41.0.0",
 ]
 
+[project.scripts]
+sqlite-sync = "sqlite_sync.cli.main:main"
+
 [tool.setuptools.packages.find]
 where = ["src"]
 

{sqlite_sync_core-0.2.0 → sqlite_sync_core-0.5.0}/src/sqlite_sync/__init__.py

@@ -15,7 +15,7 @@ from sqlite_sync.errors import (
 )
 
 # Core
-__version__ = "0.2.0"
+__version__ = "0.5.0-advanced"
 __all__ = [
     # Core
     "SyncEngine",

{sqlite_sync_core-0.2.0 → sqlite_sync_core-0.5.0}/src/sqlite_sync/bundle/generate.py

@@ -5,6 +5,7 @@ Generates a bundle containing operations that a peer hasn't seen.
 Bundles are self-contained SQLite files.
 """
 
+import os
 import sqlite3
 import time
 from typing import Final
@@ -56,6 +57,8 @@ def generate_bundle(
     
     # Create bundle database
     try:
+        if os.path.exists(output_path):
+            os.remove(output_path)
         bundle_conn = sqlite3.connect(output_path)
         
         # Create bundle schema
@@ -66,10 +69,10 @@ def generate_bundle(
         bundle_conn.executemany(
             """
             INSERT INTO bundle_operations (
-                op_id, device_id, parent_op_id, vector_clock,
+                op_id, device_id, parent_op_id, vector_clock, hlc,
                 table_name, op_type, row_pk, old_values, new_values,
                 schema_version, created_at, is_local, applied_at
-            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
             """,
             operations,
         )

{sqlite_sync_core-0.2.0 → sqlite_sync_core-0.5.0}/src/sqlite_sync/db/connection.py

@@ -7,9 +7,14 @@ registration of application-defined SQL functions.
 All connections use WAL mode for concurrent read/write.
 """
 
+import logging
 import sqlite3
-from typing import Callable, Any
+import json
+import time
+
+logger = logging.getLogger("sqlite_sync.db")
 
+from typing import Callable, Any
 from sqlite_sync.config import SQLITE_PRAGMAS
 from sqlite_sync.errors import DatabaseError
 
@@ -85,32 +90,62 @@ def _register_functions(conn: sqlite3.Connection) -> None:
     from sqlite_sync.log.vector_clock import increment_vector_clock, merge_vector_clocks
     from sqlite_sync.utils.msgpack_codec import pack_primary_key, pack_dict
     import json
+    import sys
 
     # sync_uuid_v7() -> BLOB(16)
-    conn.create_function("sync_uuid_v7", 0, generate_uuid_v7)
+    def _uuid_v7() -> bytes:
+        return generate_uuid_v7()
+
+    conn.create_function("sync_uuid_v7", 0, _uuid_v7)
 
     # sync_vector_clock_increment(device_id BLOB, vc_json TEXT) -> TEXT
-    def _vc_increment(device_id: bytes, vc_json: str) -> str:
+    def _vc_increment(device_id: Any, vc_json: Any) -> str:
         return increment_vector_clock(device_id, vc_json)
 
     conn.create_function("sync_vector_clock_increment", 2, _vc_increment)
 
     # sync_vector_clock_merge(vc1_json TEXT, vc2_json TEXT) -> TEXT
-    def _vc_merge(vc1_json: str, vc2_json: str) -> str:
+    def _vc_merge(vc1_json: Any, vc2_json: Any) -> str:
         return merge_vector_clocks(vc1_json, vc2_json)
 
     conn.create_function("sync_vector_clock_merge", 2, _vc_merge)
 
     # sync_pack_pk(value) -> BLOB
-    conn.create_function("sync_pack_pk", 1, pack_primary_key)
+    def _pack_pk(value: Any) -> bytes:
+        return pack_primary_key(value)
+
+    conn.create_function("sync_pack_pk", 1, _pack_pk)
 
     # sync_pack_values(json_str TEXT) -> BLOB
-    def _pack_values(json_str: str) -> bytes:
+    def _pack_values(json_str: Any) -> bytes:
+        if not json_str: return b""
         data = json.loads(json_str)
         return pack_dict(data)
 
     conn.create_function("sync_pack_values", 1, _pack_values)
 
+    # sync_hlc_now(node_id TEXT) -> TEXT
+    def _hlc_now_placeholder(node_id: Any) -> str:
+        return f"{int(time.time() * 1000)}:0:{node_id}"
+
+    conn.create_function("sync_hlc_now", 1, _hlc_now_placeholder)
+
+    if not hasattr(_register_functions, "_disabled_state"):
+        _register_functions._disabled_state = {}
+
+    def _sync_is_disabled() -> int:
+        return _register_functions._disabled_state.get(id(conn), 0)
+
+    conn.create_function("sync_is_disabled", 0, _sync_is_disabled)
+
+
+def set_sync_disabled(conn: sqlite3.Connection, disabled: bool) -> None:
+    """Set the sync-disabled state for a specific connection."""
+    val = 1 if disabled else 0
+    if not hasattr(_register_functions, "_disabled_state"):
+        _register_functions._disabled_state = {}
+    _register_functions._disabled_state[id(conn)] = val
+
 
 def execute_in_transaction(
     conn: sqlite3.Connection, 

{sqlite_sync_core-0.2.0 → sqlite_sync_core-0.5.0}/src/sqlite_sync/db/migrations.py

@@ -49,10 +49,13 @@ def initialize_sync_tables(conn: sqlite3.Connection) -> bytes:
             for sql in statement.strip().split(";"):
                 sql = sql.strip()
                 if sql:
+                    # print(f"DEBUG: Executing SQL: {sql}")
                     conn.execute(sql)
     except sqlite3.Error as e:
+        # Get the failing SQL if possible
+        failed_sql = locals().get('sql', 'unknown')
         raise DatabaseError(
-            f"Failed to create sync tables: {e}",
+            f"Failed to create sync tables: {e} (SQL: {failed_sql})",
             operation="create_tables",
         ) from e
 

{sqlite_sync_core-0.2.0 → sqlite_sync_core-0.5.0}/src/sqlite_sync/db/schema.py

@@ -1,61 +1,37 @@
 """
 schema.py - Sync system table schema definitions.
-
-Defines the exact schema for all sync tables per the specification.
-All tables use STRICT mode for type enforcement.
 """
 
 from typing import Final
 
-# sync_operations table - the heart of the system
-# Every database mutation becomes a row here
+# sync_operations table
 SYNC_OPERATIONS_SCHEMA: Final[str] = """
 CREATE TABLE IF NOT EXISTS sync_operations (
-    -- Identity (globally unique, time-ordered)
     op_id BLOB PRIMARY KEY CHECK(length(op_id) = 16),
-    
-    -- Source tracking
     device_id BLOB NOT NULL CHECK(length(device_id) = 16),
-    
-    -- Causality chain
     parent_op_id BLOB CHECK(parent_op_id IS NULL OR length(parent_op_id) = 16),
     vector_clock TEXT NOT NULL,
-    
-    -- What changed
+    hlc TEXT NOT NULL,
     table_name TEXT NOT NULL,
     op_type TEXT NOT NULL CHECK(op_type IN ('INSERT', 'UPDATE', 'DELETE')),
     row_pk BLOB NOT NULL,
-    
-    -- Change content
     old_values BLOB,
     new_values BLOB,
-    
-    -- Metadata
     schema_version INTEGER NOT NULL,
     created_at INTEGER NOT NULL,
-    
-    -- Local tracking
     is_local INTEGER NOT NULL CHECK(is_local IN (0, 1)),
     applied_at INTEGER,
-    
     FOREIGN KEY (parent_op_id) REFERENCES sync_operations(op_id)
 ) STRICT;
 """
 
 SYNC_OPERATIONS_INDICES: Final[str] = """
--- Index for generating bundles (find ops for peer)
-CREATE INDEX IF NOT EXISTS idx_ops_device_created 
-ON sync_operations(device_id, created_at);
-
--- Index for conflict detection (find ops on same row)
-CREATE INDEX IF NOT EXISTS idx_ops_table_pk 
-ON sync_operations(table_name, row_pk);
-
--- Index for deduplication
+CREATE INDEX IF NOT EXISTS idx_ops_device_created ON sync_operations(device_id, created_at);
+CREATE INDEX IF NOT EXISTS idx_ops_table_pk ON sync_operations(table_name, row_pk);
 CREATE INDEX IF NOT EXISTS idx_ops_id ON sync_operations(op_id);
 """
 
-# sync_metadata table - database identity and state
+# sync_metadata table
 SYNC_METADATA_SCHEMA: Final[str] = """
 CREATE TABLE IF NOT EXISTS sync_metadata (
     key TEXT PRIMARY KEY,
@@ -63,24 +39,18 @@ CREATE TABLE IF NOT EXISTS sync_metadata (
 ) STRICT;
 """
 
-# sync_conflicts table - explicit conflict records
+# sync_conflicts table
 SYNC_CONFLICTS_SCHEMA: Final[str] = """
 CREATE TABLE IF NOT EXISTS sync_conflicts (
     conflict_id BLOB PRIMARY KEY CHECK(length(conflict_id) = 16),
-    
-    -- What conflicted
     table_name TEXT NOT NULL,
     row_pk BLOB NOT NULL,
-    
-    -- Conflicting operations
     local_op_id BLOB NOT NULL CHECK(length(local_op_id) = 16),
     remote_op_id BLOB NOT NULL CHECK(length(remote_op_id) = 16),
-    
-    -- Lifecycle
     detected_at INTEGER NOT NULL,
     resolved_at INTEGER,
     resolution_op_id BLOB CHECK(resolution_op_id IS NULL OR length(resolution_op_id) = 16),
-    
+    resolution_strategy TEXT,
     FOREIGN KEY (local_op_id) REFERENCES sync_operations(op_id),
     FOREIGN KEY (remote_op_id) REFERENCES sync_operations(op_id),
     FOREIGN KEY (resolution_op_id) REFERENCES sync_operations(op_id)
@@ -88,45 +58,33 @@ CREATE TABLE IF NOT EXISTS sync_conflicts (
 """
 
 SYNC_CONFLICTS_INDICES: Final[str] = """
-CREATE INDEX IF NOT EXISTS idx_conflicts_unresolved 
-ON sync_conflicts(detected_at) WHERE resolved_at IS NULL;
-
-CREATE INDEX IF NOT EXISTS idx_conflicts_row 
-ON sync_conflicts(table_name, row_pk);
+CREATE INDEX IF NOT EXISTS idx_conflicts_unresolved ON sync_conflicts(detected_at) WHERE resolved_at IS NULL;
+CREATE INDEX IF NOT EXISTS idx_conflicts_row ON sync_conflicts(table_name, row_pk);
 """
 
-# sync_peer_state table - tracks what each peer has seen
+# sync_peer_state table
 SYNC_PEER_STATE_SCHEMA: Final[str] = """
 CREATE TABLE IF NOT EXISTS sync_peer_state (
     peer_device_id BLOB PRIMARY KEY CHECK(length(peer_device_id) = 16),
-    
-    -- What have we sent them?
     last_sent_vector_clock TEXT NOT NULL,
     last_sent_at INTEGER NOT NULL,
-    
-    -- What have they sent us?
     last_received_vector_clock TEXT NOT NULL,
     last_received_at INTEGER NOT NULL
 ) STRICT;
 """
 
-# sync_import_log table - audit trail and idempotency
+# sync_import_log table
 SYNC_IMPORT_LOG_SCHEMA: Final[str] = """
 CREATE TABLE IF NOT EXISTS sync_import_log (
     import_id BLOB PRIMARY KEY CHECK(length(import_id) = 16),
     bundle_id BLOB NOT NULL CHECK(length(bundle_id) = 16),
     bundle_hash BLOB NOT NULL CHECK(length(bundle_hash) = 32),
-    
-    -- When and from whom
     imported_at INTEGER NOT NULL,
     source_device_id BLOB NOT NULL CHECK(length(source_device_id) = 16),
-    
-    -- What happened
     op_count INTEGER NOT NULL,
     applied_count INTEGER NOT NULL,
     conflict_count INTEGER NOT NULL,
     duplicate_count INTEGER NOT NULL,
-    
     UNIQUE(bundle_hash)
 ) STRICT;
 """
@@ -147,9 +105,9 @@ ALL_SCHEMA_STATEMENTS: Final[tuple[str, ...]] = (
     SYNC_IMPORT_LOG_INDICES,
 )
 
-# Bundle schema (for bundle databases)
+# Bundle schema
 BUNDLE_METADATA_SCHEMA: Final[str] = """
-CREATE TABLE bundle_metadata (
+CREATE TABLE IF NOT EXISTS bundle_metadata (
     bundle_id BLOB PRIMARY KEY CHECK(length(bundle_id) = 16),
     source_device_id BLOB NOT NULL CHECK(length(source_device_id) = 16),
     created_at INTEGER NOT NULL,
@@ -160,11 +118,12 @@ CREATE TABLE bundle_metadata (
 """
 
 BUNDLE_OPERATIONS_SCHEMA: Final[str] = """
-CREATE TABLE bundle_operations (
+CREATE TABLE IF NOT EXISTS bundle_operations (
     op_id BLOB PRIMARY KEY CHECK(length(op_id) = 16),
     device_id BLOB NOT NULL CHECK(length(device_id) = 16),
     parent_op_id BLOB CHECK(parent_op_id IS NULL OR length(parent_op_id) = 16),
     vector_clock TEXT NOT NULL,
+    hlc TEXT NOT NULL,
     table_name TEXT NOT NULL,
     op_type TEXT NOT NULL CHECK(op_type IN ('INSERT', 'UPDATE', 'DELETE')),
     row_pk BLOB NOT NULL,