meadow-integration 1.0.41 → 1.0.43

package/test/Meadow-Integration-BisectionSync_test.js

@@ -428,18 +428,28 @@ function setupSQLiteProvider(pFable, fCallback)
 
 function seedLocalBooks(pFable, pBooks)
 {
-	const tmpInsert = pFable.MeadowSQLiteProvider.db.prepare(`
+	// node:sqlite's DatabaseSync has no `.transaction(fn)` helper (that was
+	// a better-sqlite3 idiom).  Bracket the bulk insert manually so seeding
+	// many thousands of rows doesn't pay per-row commit overhead.
+	const tmpDB = pFable.MeadowSQLiteProvider.db;
+	const tmpInsert = tmpDB.prepare(`
 		INSERT OR REPLACE INTO Book (IDBook, GUIDBook, CreateDate, CreatingIDUser, UpdateDate, UpdatingIDUser, Deleted, DeleteDate, DeletingIDUser, Title, Type, Genre, PublicationYear)
 		VALUES (@IDBook, @GUIDBook, @CreateDate, @CreatingIDUser, @UpdateDate, @UpdatingIDUser, @Deleted, @DeleteDate, @DeletingIDUser, @Title, @Type, @Genre, @PublicationYear)
 	`);
-	const tmpInsertMany = pFable.MeadowSQLiteProvider.db.transaction((pRecords) =>
+	tmpDB.exec('BEGIN');
+	try
 	{
-		for (const tmpRecord of pRecords)
+		for (const tmpRecord of pBooks)
 		{
 			tmpInsert.run(tmpRecord);
 		}
-	});
-	tmpInsertMany(pBooks);
+		tmpDB.exec('COMMIT');
+	}
+	catch (pError)
+	{
+		tmpDB.exec('ROLLBACK');
+		throw pError;
+	}
 }
 
 function getLocalBookCount(pFable)

package/test/Meadow-Integration-NewStrategies_test.js

@@ -552,18 +552,28 @@ function setupSQLiteProvider(pFable, fCallback)
 
 function seedLocalBooks(pFable, pBooks)
 {
-	const tmpInsert = pFable.MeadowSQLiteProvider.db.prepare(`
+	// node:sqlite's DatabaseSync has no `.transaction(fn)` helper (that was
+	// a better-sqlite3 idiom).  Bracket the bulk insert manually so seeding
+	// many thousands of rows doesn't pay per-row commit overhead.
+	const tmpDB = pFable.MeadowSQLiteProvider.db;
+	const tmpInsert = tmpDB.prepare(`
 		INSERT OR REPLACE INTO Book (IDBook, GUIDBook, CreateDate, CreatingIDUser, UpdateDate, UpdatingIDUser, Deleted, DeleteDate, DeletingIDUser, Title, Type, Genre, PublicationYear)
 		VALUES (@IDBook, @GUIDBook, @CreateDate, @CreatingIDUser, @UpdateDate, @UpdatingIDUser, @Deleted, @DeleteDate, @DeletingIDUser, @Title, @Type, @Genre, @PublicationYear)
 	`);
-	const tmpInsertMany = pFable.MeadowSQLiteProvider.db.transaction((pRecords) =>
+	tmpDB.exec('BEGIN');
+	try
 	{
-		for (const tmpRecord of pRecords)
+		for (const tmpRecord of pBooks)
 		{
 			tmpInsert.run(tmpRecord);
 		}
-	});
-	tmpInsertMany(pBooks);
+		tmpDB.exec('COMMIT');
+	}
+	catch (pError)
+	{
+		tmpDB.exec('ROLLBACK');
+		throw pError;
+	}
 }
 
 function getLocalBookCount(pFable)

package/test/Meadow-Integration-OngoingEventualConsistencyDeleteCursor_test.js

@@ -0,0 +1,228 @@
+/*
+	Unit tests for the resumable (head/tail) delete cursor.
+
+	Drives OngoingEventualConsistency.syncDeletedRecords with DeleteCursorStatePath
+	set, simulating successive "runs" (each call re-reads the JSON state file, as a
+	fresh container would). Verifies the tail drains across runs, the head pass
+	picks up new high-id deletions, the caught-up steady state, and that state
+	persists in the JSON file.
+
+	Mock server serves the keyset deleted-page queries
+	(FBV~Deleted~EQ~1[~FBV~IDBook~GT~N][~FBV~IDBook~LT~M]~FSF~IDBook~DESC~DESC).
+*/
+
+const Chai = require('chai');
+const Expect = Chai.expect;
+
+const libHTTP = require('http');
+const libFS = require('fs');
+const libOS = require('os');
+const libPath = require('path');
+const libFable = require('fable');
+const libMeadowConnectionSQLite = require('meadow-connection-sqlite');
+
+const libMeadowCloneRestClient = require('../source/services/clone/Meadow-Service-RestClient.js');
+const libMeadowSync = require('../source/services/clone/Meadow-Service-Sync.js');
+
+const MOCK_PORT = 18095;
+const MOCK_BASE_URL = `http://localhost:${MOCK_PORT}/1.0/`;
+const STATE_PATH = libPath.join(libOS.tmpdir(), `oec-delete-cursor-${process.pid}.json`);
+
+const _BookSchema =
+{
+	TableName: 'Book',
+	Columns:
+	[
+		{ Column: 'IDBook', DataType: 'int' },
+		{ Column: 'GUIDBook', DataType: 'GUID' },
+		{ Column: 'CreateDate', DataType: 'DateTime' },
+		{ Column: 'CreatingIDUser', DataType: 'int' },
+		{ Column: 'UpdateDate', DataType: 'DateTime' },
+		{ Column: 'UpdatingIDUser', DataType: 'int' },
+		{ Column: 'Deleted', DataType: 'int' },
+		{ Column: 'DeleteDate', DataType: 'DateTime' },
+		{ Column: 'DeletingIDUser', DataType: 'int' },
+		{ Column: 'Title', DataType: 'String' }
+	],
+	MeadowSchema:
+	{
+		Scope: 'Book', DefaultIdentifier: 'IDBook', Domain: 'Default',
+		Schema:
+		[
+			{ Column: 'IDBook', Type: 'AutoIdentity', Size: 'Default' },
+			{ Column: 'GUIDBook', Type: 'AutoGUID', Size: '128' },
+			{ Column: 'CreateDate', Type: 'CreateDate', Size: 'Default' },
+			{ Column: 'CreatingIDUser', Type: 'CreateIDUser', Size: 'int' },
+			{ Column: 'UpdateDate', Type: 'UpdateDate', Size: 'Default' },
+			{ Column: 'UpdatingIDUser', Type: 'UpdateIDUser', Size: 'int' },
+			{ Column: 'Deleted', Type: 'Deleted', Size: 'Default' },
+			{ Column: 'DeleteDate', Type: 'DeleteDate', Size: 'Default' },
+			{ Column: 'DeletingIDUser', Type: 'DeleteIDUser', Size: 'int' },
+			{ Column: 'Title', Type: 'String', Size: '200' }
+		],
+		DefaultObject: { IDBook: 0, GUIDBook: '', CreateDate: null, CreatingIDUser: 0, UpdateDate: null, UpdatingIDUser: 0, Deleted: 0, DeleteDate: null, DeletingIDUser: 0, Title: '' },
+		JsonSchema: { title: 'Book', type: 'object', properties: { IDBook: { type: 'integer' } }, required: ['IDBook'] }
+	}
+};
+
+// Server-deleted ids: 10,20,...,100 (mutable so a test can add a new one).
+let _ServerDeletedIDs = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100];
+function serverDeletedRecord(pID)
+{
+	return { IDBook: pID, GUIDBook: `GUID-${pID}`, Deleted: 1, DeleteDate: '2025-07-01T00:00:00.000Z', DeletingIDUser: 1, Title: `Deleted-${pID}` };
+}
+
+function createMockServer()
+{
+	return libHTTP.createServer((pRequest, pResponse) =>
+	{
+		const tmpURL = pRequest.url;
+		pResponse.setHeader('Content-Type', 'application/json');
+
+		const tmpMatch = tmpURL.match(/\/1\.0\/Books\/FilteredTo\/(.+?)\/(\d+)\/(\d+)(\?|$)/);
+		if (tmpMatch && tmpMatch[1].indexOf('FBV~Deleted~EQ~1') > -1)
+		{
+			const tmpFilter = tmpMatch[1];
+			const tmpOffset = parseInt(tmpMatch[2], 10) || 0;
+			const tmpPageSize = parseInt(tmpMatch[3], 10) || 100;
+			const tmpGT = tmpFilter.match(/FBV~IDBook~GT~(\d+)/);
+			const tmpLT = tmpFilter.match(/FBV~IDBook~LT~(\d+)/);
+
+			let tmpIDs = _ServerDeletedIDs.slice();
+			if (tmpGT) { const n = parseInt(tmpGT[1], 10); tmpIDs = tmpIDs.filter((id) => id > n); }
+			if (tmpLT) { const n = parseInt(tmpLT[1], 10); tmpIDs = tmpIDs.filter((id) => id < n); }
+			tmpIDs.sort((a, b) => b - a); // DESC
+			const tmpPage = tmpIDs.slice(tmpOffset, tmpOffset + tmpPageSize).map(serverDeletedRecord);
+			pResponse.end(JSON.stringify(tmpPage));
+			return;
+		}
+
+		pResponse.statusCode = 404;
+		pResponse.end(JSON.stringify({ Error: `Unknown endpoint: ${tmpURL}` }));
+	});
+}
+
+function createTestFable()
+{
+	const tmpFable = new libFable({ Product: 'OECDeleteCursorTest', MeadowProvider: 'SQLite', SQLite: { SQLiteFilePath: ':memory:' }, LogStreams: [{ streamtype: 'console', level: 'error' }] });
+	tmpFable.ProgramConfiguration = {};
+	return tmpFable;
+}
+
+function readState() { try { return JSON.parse(libFS.readFileSync(STATE_PATH, 'utf8')); } catch (e) { return {}; } }
+function deletedCount(pFable) { return pFable.MeadowSQLiteProvider.db.prepare('SELECT COUNT(*) c FROM Book WHERE Deleted=1').get().c; }
+
+suite
+(
+	'OngoingEventualConsistency resumable delete cursor',
+	() =>
+	{
+		let _MockServer = null;
+		let _Fable = null;
+		let _Entity = null;
+
+		suiteSetup((fDone) => { _MockServer = createMockServer(); _MockServer.listen(MOCK_PORT, fDone); });
+		suiteTeardown((fDone) => { try { libFS.unlinkSync(STATE_PATH); } catch (e) {} if (_MockServer) { _MockServer.close(fDone); } else { return fDone(); } });
+
+		setup((fDone) =>
+		{
+			_ServerDeletedIDs = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100];
+			try { libFS.unlinkSync(STATE_PATH); } catch (e) {}
+
+			_Fable = createTestFable();
+			_Fable.serviceManager.addServiceType('MeadowSQLiteProvider', libMeadowConnectionSQLite);
+			_Fable.serviceManager.instantiateServiceProvider('MeadowSQLiteProvider');
+			_Fable.MeadowSQLiteProvider.connectAsync((pErr) =>
+			{
+				if (pErr) return fDone(pErr);
+				_Fable.MeadowSQLiteProvider.db.exec(`CREATE TABLE IF NOT EXISTS Book (
+					IDBook INTEGER PRIMARY KEY AUTOINCREMENT, GUIDBook TEXT DEFAULT '', CreateDate TEXT DEFAULT '',
+					CreatingIDUser INTEGER DEFAULT 0, UpdateDate TEXT DEFAULT '', UpdatingIDUser INTEGER DEFAULT 0,
+					Deleted INTEGER DEFAULT 0, DeleteDate TEXT DEFAULT '', DeletingIDUser INTEGER DEFAULT 0, Title TEXT DEFAULT '');`);
+
+				_Fable.serviceManager.addServiceType('MeadowCloneRestClient', libMeadowCloneRestClient);
+				_Fable.serviceManager.instantiateServiceProvider('MeadowCloneRestClient', { ServerURL: MOCK_BASE_URL });
+				_Fable.serviceManager.addServiceType('MeadowSync', libMeadowSync);
+				// PageSize 3 + MaxRecordsPerEntity 3 => one page per "run" so we can watch it resume.
+				_Fable.serviceManager.instantiateServiceProvider('MeadowSync',
+					{ PageSize: 3, SyncDeletedRecords: true, BackSyncTimeLimit: 999999, MaxRecordsPerEntity: 3, DeleteCursorStatePath: STATE_PATH });
+				_Fable.MeadowSync.SyncMode = 'OngoingEventualConsistency';
+				_Fable.MeadowSync.SyncDeletedRecords = true;
+				_Fable.MeadowSync.BackSyncTimeLimit = 999999;
+				_Fable.MeadowSync.loadMeadowSchema({ Tables: { Book: _BookSchema } }, (pSchemaErr) =>
+				{
+					if (pSchemaErr) return fDone(pSchemaErr);
+					_Entity = _Fable.MeadowSync.MeadowSyncEntities['Book'];
+					_Entity.syncResults = { Created: 0, Updated: 0, Deleted: 0 };
+					// Seed all 10 as ACTIVE so each can be flagged when the cursor reaches it.
+					const tmpIns = _Fable.MeadowSQLiteProvider.db.prepare('INSERT INTO Book (IDBook, GUIDBook, Deleted, Title) VALUES (?, ?, 0, ?)');
+					for (const id of [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]) { tmpIns.run(id, `GUID-${id}`, `Active-${id}`); }
+					return fDone();
+				});
+			});
+		});
+
+		// Helper: run syncDeletedRecords once (a "run").
+		function run(fNext) { _Entity.syncResults = { Created: 0, Updated: 0, Deleted: 0 }; _Entity.syncDeletedRecords(fNext); }
+
+		test('drains the backlog across runs, resuming each time (no re-walk)', function (fDone)
+		{
+			this.timeout(20000);
+			// 10 deleted, 3 per run → ~4 runs to drain.
+			run(() =>
+			{
+				// Run 1: newest 3 (100,90,80) flagged; cursor advanced, not caught up.
+				Expect(deletedCount(_Fable)).to.equal(3, 'run 1 flags newest 3');
+				const s1 = readState().Book;
+				Expect(s1).to.be.an('object');
+				Expect(s1.HeadID).to.equal(100, 'head established at the top');
+				Expect(s1.TailID).to.equal(80, 'tail advanced to lowest examined');
+				Expect(s1.CaughtUp).to.equal(false);
+
+				run(() =>
+				{
+					Expect(deletedCount(_Fable)).to.equal(6, 'run 2 resumes: +3 (70,60,50)');
+					Expect(readState().Book.TailID).to.equal(50);
+					run(() =>
+					{
+						Expect(deletedCount(_Fable)).to.equal(9, 'run 3 resumes: +3 (40,30,20)');
+						run(() =>
+						{
+							// Run 4: only 10 left → flagged, then exhausted → caught up.
+							Expect(deletedCount(_Fable)).to.equal(10, 'run 4 flags the last one');
+							const s4 = readState().Book;
+							Expect(s4.CaughtUp).to.equal(true, 'tail reached the bottom → caught up');
+							return fDone();
+						});
+					});
+				});
+			});
+		});
+
+		test('once caught up, the head pass picks up a new high-id deletion cheaply', function (fDone)
+		{
+			this.timeout(20000);
+			// Drain fully first (4 runs).
+			run(() => run(() => run(() => run(() =>
+			{
+				Expect(deletedCount(_Fable)).to.equal(10);
+				Expect(readState().Book.CaughtUp).to.equal(true);
+				const tmpHeadBefore = readState().Book.HeadID;
+				Expect(tmpHeadBefore).to.equal(100);
+
+				// A new record (id 110) is created and deleted on the server; seed it locally as active.
+				_ServerDeletedIDs.push(110);
+				_Fable.MeadowSQLiteProvider.db.prepare('INSERT INTO Book (IDBook, GUIDBook, Deleted, Title) VALUES (110, ?, 0, ?)').run('GUID-110', 'Active-110');
+
+				run(() =>
+				{
+					// Head pass (id > 100) catches 110; tail stays caught up.
+					Expect(_Fable.MeadowSQLiteProvider.db.prepare('SELECT Deleted FROM Book WHERE IDBook=110').get().Deleted).to.equal(1, 'new high-id deletion flagged by head pass');
+					Expect(readState().Book.HeadID).to.equal(110, 'head advanced to the new max');
+					Expect(readState().Book.CaughtUp).to.equal(true, 'still caught up');
+					return fDone();
+				});
+			}))));
+		});
+	}
+);

package/test/Meadow-Integration-OngoingEventualConsistencyDeleteSync_test.js

@@ -0,0 +1,311 @@
+/*
+	Unit tests for OngoingEventualConsistency delete reconciliation.
+
+	Focused on the correctness fix: deleted server rows are matched to local
+	rows by GUID (not identity), so a cloned database that holds a record under
+	a DIFFERENT auto-increment id (the real-world failure mode) still gets the
+	row flagged deleted instead of attempting a CREATE that collides on the GUID
+	unique index.
+
+	Also covers: already-deleted rows are skipped, rows never synced live are
+	skipped (not created), and the structured report receives the real count.
+
+	Uses a mock HTTP server for the deleted-record API and an in-memory SQLite
+	database as the local clone destination.  Calls syncDeletedRecords() directly
+	so the forward-sync phases don't need mocking.
+*/
+
+const Chai = require('chai');
+const Expect = Chai.expect;
+
+const libHTTP = require('http');
+const libFable = require('fable');
+const libMeadowConnectionSQLite = require('meadow-connection-sqlite');
+
+const libMeadowCloneRestClient = require('../source/services/clone/Meadow-Service-RestClient.js');
+const libMeadowSync = require('../source/services/clone/Meadow-Service-Sync.js');
+
+const MOCK_PORT = 18097;
+const MOCK_BASE_URL = `http://localhost:${MOCK_PORT}/1.0/`;
+
+const _BookSchema =
+{
+	TableName: 'Book',
+	Columns:
+	[
+		{ Column: 'IDBook',          DataType: 'int' },
+		{ Column: 'GUIDBook',        DataType: 'GUID' },
+		{ Column: 'CreateDate',      DataType: 'DateTime' },
+		{ Column: 'CreatingIDUser',  DataType: 'int' },
+		{ Column: 'UpdateDate',      DataType: 'DateTime' },
+		{ Column: 'UpdatingIDUser',  DataType: 'int' },
+		{ Column: 'Deleted',         DataType: 'int' },
+		{ Column: 'DeleteDate',      DataType: 'DateTime' },
+		{ Column: 'DeletingIDUser',  DataType: 'int' },
+		{ Column: 'Title',           DataType: 'String' }
+	],
+	MeadowSchema:
+	{
+		Scope: 'Book',
+		DefaultIdentifier: 'IDBook',
+		Domain: 'Default',
+		Schema:
+		[
+			{ Column: 'IDBook',          Type: 'AutoIdentity', Size: 'Default' },
+			{ Column: 'GUIDBook',        Type: 'AutoGUID',     Size: '128'     },
+			{ Column: 'CreateDate',      Type: 'CreateDate',   Size: 'Default' },
+			{ Column: 'CreatingIDUser',  Type: 'CreateIDUser', Size: 'int'     },
+			{ Column: 'UpdateDate',      Type: 'UpdateDate',   Size: 'Default' },
+			{ Column: 'UpdatingIDUser',  Type: 'UpdateIDUser', Size: 'int'     },
+			{ Column: 'Deleted',         Type: 'Deleted',      Size: 'Default' },
+			{ Column: 'DeleteDate',      Type: 'DeleteDate',   Size: 'Default' },
+			{ Column: 'DeletingIDUser',  Type: 'DeleteIDUser', Size: 'int'     },
+			{ Column: 'Title',           Type: 'String',       Size: '200'     }
+		],
+		DefaultObject:
+		{
+			IDBook: 0, GUIDBook: '', CreateDate: null, CreatingIDUser: 0,
+			UpdateDate: null, UpdatingIDUser: 0, Deleted: 0,
+			DeleteDate: null, DeletingIDUser: 0, Title: ''
+		},
+		JsonSchema:
+		{
+			title: 'Book', type: 'object',
+			properties:
+			{
+				IDBook: { type: 'integer' }, GUIDBook: { type: 'string' },
+				CreateDate: { type: 'string' }, CreatingIDUser: { type: 'integer' },
+				UpdateDate: { type: 'string' }, UpdatingIDUser: { type: 'integer' },
+				Deleted: { type: 'boolean' }, DeleteDate: { type: 'string' },
+				DeletingIDUser: { type: 'integer' }, Title: { type: 'string' }
+			},
+			required: ['IDBook']
+		}
+	}
+};
+
+// Server-side deleted set (ids 100-103).  Returned newest-id-first.
+function makeServerDeleted(pID)
+{
+	return {
+		IDBook: pID,
+		GUIDBook: `GUID-BOOK-${pID}`,
+		CreateDate: '2025-01-01T00:00:00.000Z',
+		CreatingIDUser: 1,
+		UpdateDate: '2025-06-15T12:00:00.000Z',
+		UpdatingIDUser: 1,
+		Deleted: 1,
+		DeleteDate: '2025-07-01T00:00:00.000Z',
+		DeletingIDUser: 7,
+		Title: `Server-Deleted-${pID}`
+	};
+}
+const SERVER_DELETED = [ makeServerDeleted(100), makeServerDeleted(101), makeServerDeleted(102), makeServerDeleted(103) ];
+
+function createMockServer()
+{
+	return libHTTP.createServer(
+		(pRequest, pResponse) =>
+		{
+			const tmpURL = pRequest.url;
+			pResponse.setHeader('Content-Type', 'application/json');
+
+			// Count of deleted records
+			if (tmpURL.match(/\/1\.0\/Books\/Count\/FilteredTo\/FBV~Deleted~EQ~1/))
+			{
+				pResponse.end(JSON.stringify({ Count: SERVER_DELETED.length }));
+				return;
+			}
+
+			// Deleted page, newest-id first (DESC) — this is the new ordering.
+			if (tmpURL.match(/\/1\.0\/Books\/FilteredTo\/FBV~Deleted~EQ~1~FSF~IDBook~DESC~DESC/))
+			{
+				const tmpParts = tmpURL.split('?')[0].split('/');
+				const tmpOffset = parseInt(tmpParts[tmpParts.length - 2], 10) || 0;
+				const tmpPageSize = parseInt(tmpParts[tmpParts.length - 1], 10) || 100;
+				const tmpSortedDesc = SERVER_DELETED.slice().sort((a, b) => b.IDBook - a.IDBook);
+				pResponse.end(JSON.stringify(tmpSortedDesc.slice(tmpOffset, tmpOffset + tmpPageSize)));
+				return;
+			}
+
+			pResponse.statusCode = 404;
+			pResponse.end(JSON.stringify({ Error: `Unknown endpoint: ${tmpURL}` }));
+		});
+}
+
+function createTestFable()
+{
+	const tmpFable = new libFable(
+		{
+			Product: 'OECDeleteSyncTest',
+			ProductVersion: '1.0.0',
+			MeadowProvider: 'SQLite',
+			SQLite: { SQLiteFilePath: ':memory:' },
+			LogStreams: [{ streamtype: 'console', level: 'error' }]
+		});
+	tmpFable.ProgramConfiguration = {};
+	return tmpFable;
+}
+
+function setupSQLite(pFable, fCallback)
+{
+	pFable.serviceManager.addServiceType('MeadowSQLiteProvider', libMeadowConnectionSQLite);
+	pFable.serviceManager.instantiateServiceProvider('MeadowSQLiteProvider');
+	pFable.MeadowSQLiteProvider.connectAsync(
+		(pError) =>
+		{
+			if (pError) return fCallback(pError);
+			pFable.MeadowSQLiteProvider.db.exec(`
+				CREATE TABLE IF NOT EXISTS Book (
+					IDBook INTEGER PRIMARY KEY AUTOINCREMENT,
+					GUIDBook TEXT DEFAULT '',
+					CreateDate TEXT DEFAULT '',
+					CreatingIDUser INTEGER DEFAULT 0,
+					UpdateDate TEXT DEFAULT '',
+					UpdatingIDUser INTEGER DEFAULT 0,
+					Deleted INTEGER DEFAULT 0,
+					DeleteDate TEXT DEFAULT '',
+					DeletingIDUser INTEGER DEFAULT 0,
+					Title TEXT DEFAULT ''
+				);
+			`);
+			return fCallback();
+		});
+}
+
+function seedBook(pFable, pID, pGUID, pDeleted, pTitle)
+{
+	pFable.MeadowSQLiteProvider.db.prepare(
+		'INSERT INTO Book (IDBook, GUIDBook, Deleted, DeleteDate, Title) VALUES (?, ?, ?, ?, ?)')
+		.run(pID, pGUID, pDeleted, pDeleted ? '2025-07-01T00:00:00.000Z' : '', pTitle);
+}
+
+function allBooks(pFable)
+{
+	return pFable.MeadowSQLiteProvider.db.prepare('SELECT * FROM Book ORDER BY IDBook').all();
+}
+function bookByGUID(pFable, pGUID)
+{
+	return pFable.MeadowSQLiteProvider.db.prepare('SELECT * FROM Book WHERE GUIDBook = ?').all(pGUID);
+}
+function bookByID(pFable, pID)
+{
+	return pFable.MeadowSQLiteProvider.db.prepare('SELECT * FROM Book WHERE IDBook = ?').get(pID);
+}
+
+suite
+(
+	'OngoingEventualConsistency delete reconciliation',
+	() =>
+	{
+		let _MockServer = null;
+
+		suiteSetup((fDone) => { _MockServer = createMockServer(); _MockServer.listen(MOCK_PORT, fDone); });
+		suiteTeardown((fDone) => { if (_MockServer) { _MockServer.close(fDone); } else { return fDone(); } });
+
+		let _Fable = null;
+		let _Entity = null;
+
+		setup
+		(
+			(fDone) =>
+			{
+				_Fable = createTestFable();
+				setupSQLite(_Fable,
+					(pError) =>
+					{
+						if (pError) return fDone(pError);
+
+						_Fable.serviceManager.addServiceType('MeadowCloneRestClient', libMeadowCloneRestClient);
+						_Fable.serviceManager.instantiateServiceProvider('MeadowCloneRestClient', { ServerURL: MOCK_BASE_URL });
+
+						// Wire through MeadowSync so fable.Meadow is established and the
+						// entity is built/initialized exactly as in production.
+						_Fable.serviceManager.addServiceType('MeadowSync', libMeadowSync);
+						_Fable.serviceManager.instantiateServiceProvider('MeadowSync',
+							{ PageSize: 100, SyncDeletedRecords: true, BackSyncTimeLimit: 999999 });
+						_Fable.MeadowSync.SyncMode = 'OngoingEventualConsistency';
+						_Fable.MeadowSync.SyncDeletedRecords = true;
+						_Fable.MeadowSync.BackSyncTimeLimit = 999999;
+
+						_Fable.MeadowSync.loadMeadowSchema({ Tables: { Book: _BookSchema } },
+							(pSchemaError) =>
+							{
+								if (pSchemaError) return fDone(pSchemaError);
+								_Entity = _Fable.MeadowSync.MeadowSyncEntities['Book'];
+								_Entity.syncResults = { Created: 0, Updated: 0, Deleted: 0 };
+
+								// Seed local clone state AFTER the table exists. Server has
+								// deleted ids 100, 101, 102, 103.
+								//   id 101 active            -> matches a deleted id -> mark deleted
+								//   id 102 already deleted   -> skip
+								//   id 100 absent            -> not in clone -> skip (no create)
+								//   id 777 active, GUID twin -> shares GUID-BOOK-103 with the deleted
+								//                               id 103 but under a DIFFERENT id. MUST
+								//                               NOT be touched (the duplicate-GUID trap).
+								//   id 50  unrelated active  -> untouched
+								seedBook(_Fable, 101, 'GUID-BOOK-101', 0, 'Normal-101');
+								seedBook(_Fable, 102, 'GUID-BOOK-102', 1, 'Already-102');
+								seedBook(_Fable, 777, 'GUID-BOOK-103', 0, 'GuidTwin-of-deleted-103');
+								seedBook(_Fable, 50,  'GUID-BOOK-50',  0, 'Untouched-50');
+
+								return fDone();
+							});
+					});
+			}
+		);
+
+		test
+		(
+			'flags the row whose id matches the server-deleted id, and NEVER a GUID twin under a different id',
+			(fDone) =>
+			{
+				_Entity.syncDeletedRecords(
+					() =>
+					{
+						// id 101 matched a server-deleted id -> flagged deleted, DeleteDate stamped
+						const tmp101 = bookByID(_Fable, 101);
+						Expect(tmp101.Deleted).to.equal(1, 'id 101 flagged deleted');
+						Expect(tmp101.DeleteDate).to.be.a('string').and.not.equal('', 'DeleteDate stamped on delete');
+
+						// THE SAFETY CASE: id 777 shares GUID-BOOK-103 with the server-deleted id
+						// 103, but is a DIFFERENT, active record. It must be left untouched —
+						// deleting it would be data corruption from a duplicate GUID.
+						const tmp777 = bookByID(_Fable, 777);
+						Expect(tmp777.Deleted).to.equal(0, 'GUID twin under a different id MUST NOT be deleted');
+
+						// No local row at the server-deleted ids 100 or 103 was created.
+						Expect(bookByID(_Fable, 100)).to.be.undefined;
+						Expect(bookByID(_Fable, 103)).to.be.undefined;
+						return fDone();
+					});
+			}
+		);
+
+		test
+		(
+			'skips already-deleted and not-in-clone rows; creates nothing; reports the real count',
+			(fDone) =>
+			{
+				_Entity.syncDeletedRecords(
+					() =>
+					{
+						// id 102 already deleted — still exactly one row, still deleted
+						const tmp102 = bookByGUID(_Fable, 'GUID-BOOK-102');
+						Expect(tmp102.length).to.equal(1);
+						Expect(tmp102[0].Deleted).to.equal(1);
+
+						// Unrelated active row untouched
+						Expect(bookByID(_Fable, 50).Deleted).to.equal(0);
+
+						// No rows created at all — total stays at the 4 seeded (101, 102, 777, 50)
+						Expect(allBooks(_Fable).length).to.equal(4, 'no ghost rows created');
+
+						// Only id 101 was newly flagged (102 already; 100/103 not in clone)
+						Expect(_Entity.syncResults.Deleted).to.equal(1, 'reports exactly the newly-flagged count');
+						return fDone();
+					});
+			}
+		);
+	}
+);