@alfe.ai/openclaw-sync 0.2.2 → 0.2.3

package/dist/sync-engine.js

@@ -1,4 +1,4 @@
-import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import { appendFile, copyFile, mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
 import { createReadStream, existsSync, readFileSync } from "node:fs";
 import { createHash } from "node:crypto";
 import { basename, dirname, extname, join } from "node:path";
@@ -67,6 +67,20 @@ async function updateManifestEntry(workspacePath, relativePath, entry) {
 	await writeManifest(workspacePath, manifest);
 }
 /**
+* Update many file entries in one read-modify-write pass.
+*
+* `updateManifestEntry` re-reads and rewrites the whole manifest JSON per
+* call — fine for single-file watcher events, quadratic for bulk heals, and
+* lossy when calls overlap. Use this for any batch (e.g. the recovery
+* "identical → heal" pass). Optionally stamps the owning agentId.
+*/
+async function updateManifestEntries(workspacePath, entries, options = {}) {
+	const manifest = await readManifest(workspacePath);
+	Object.assign(manifest.files, entries);
+	if (options.agentId) manifest.agentId = options.agentId;
+	await writeManifest(workspacePath, manifest);
+}
+/**
 * Remove a file entry from the local manifest.
 */
 async function removeManifestEntry(workspacePath, relativePath) {
@@ -241,6 +255,12 @@ async function withRetry(fn, options = {}) {
 * Each step retries with exponential backoff via `withRetry`.
 */
 const log$2 = createLogger("SyncUploader");
+/**
+* Prefixes stored as GLACIER_IR on the sync bucket. Shared with the recovery
+* classifier in sync-engine.ts, which must never cut conflict sidecars for
+* archive objects (their presigned GETs fail until restored, so hashing/
+* preserving them is wasted work on a pull that can't succeed anyway).
+*/
 const ARCHIVE_PREFIXES = ["sessions/archive/", "context/archive/"];
 function getStorageClass(relativePath) {
 	return ARCHIVE_PREFIXES.some((p) => relativePath.startsWith(p)) ? "GLACIER_IR" : "STANDARD";
@@ -280,17 +300,17 @@ async function uploadOne(workspacePath, relativePath, client) {
 				size,
 				storageClass
 			});
-			await updateManifestEntry(workspacePath, relativePath, {
-				hash,
-				size,
-				lastSynced: (/* @__PURE__ */ new Date()).toISOString(),
-				storageClass
-			});
 			return {
 				path: relativePath,
 				success: true,
 				hash,
-				size
+				size,
+				entry: {
+					hash,
+					size,
+					lastSynced: (/* @__PURE__ */ new Date()).toISOString(),
+					storageClass
+				}
 			};
 		});
 	} catch (err) {
@@ -310,11 +330,20 @@ async function uploadFiles(workspacePath, relativePaths, client, options = {}) {
 	for (let i = 0; i < relativePaths.length; i += concurrency) {
 		const batch = relativePaths.slice(i, i + concurrency);
 		const batchResults = await Promise.all(batch.map((path) => uploadOne(workspacePath, path, client)));
+		const entries = {};
 		for (const result of batchResults) {
-			results.push(result);
+			if (result.entry !== void 0) entries[result.path] = result.entry;
+			results.push({
+				path: result.path,
+				success: result.success,
+				hash: result.hash,
+				size: result.size,
+				error: result.error
+			});
 			if (!quiet) if (result.success) log$2.info(`Uploaded ${result.path} (${formatBytes$1(result.size ?? 0)})`);
 			else log$2.error(`Failed to upload ${result.path}: ${result.error ?? "Unknown error"}`);
 		}
+		if (Object.keys(entries).length > 0) await updateManifestEntries(workspacePath, entries);
 	}
 	return results;
 }
@@ -349,16 +378,17 @@ async function downloadOne(workspacePath, relativePath, client, remoteEntry) {
 			const absolutePath = join(workspacePath, relativePath);
 			await mkdir(dirname(absolutePath), { recursive: true });
 			await writeFile(absolutePath, buffer);
-			await updateManifestEntry(workspacePath, relativePath, {
+			const entry = {
 				hash: remoteEntry?.hash ?? "",
 				size: buffer.length,
 				lastSynced: (/* @__PURE__ */ new Date()).toISOString(),
 				storageClass: remoteEntry?.storageClass ?? "STANDARD"
-			});
+			};
 			return {
 				path: relativePath,
 				success: true,
-				size: buffer.length
+				size: buffer.length,
+				entry
 			};
 		});
 	} catch (err) {
@@ -375,11 +405,19 @@ async function downloadFiles(workspacePath, relativePaths, client, remoteManifes
 	for (let i = 0; i < relativePaths.length; i += concurrency) {
 		const batch = relativePaths.slice(i, i + concurrency);
 		const batchResults = await Promise.all(batch.map((path) => downloadOne(workspacePath, path, client, remoteManifest?.files[path])));
+		const entries = {};
 		for (const result of batchResults) {
-			results.push(result);
+			if (result.entry !== void 0) entries[result.path] = result.entry;
+			results.push({
+				path: result.path,
+				success: result.success,
+				size: result.size,
+				error: result.error
+			});
 			if (!quiet) if (result.success) log$1.info(`Downloaded ${result.path} (${formatBytes(result.size ?? 0)})`);
 			else log$1.error(`Failed to download ${result.path}: ${result.error ?? "Unknown error"}`);
 		}
+		if (Object.keys(entries).length > 0) await updateManifestEntries(workspacePath, entries);
 	}
 	return results;
 }
@@ -403,12 +441,45 @@ function formatBytes(bytes) {
 */
 const log = createLogger("SyncEngine");
 /**
+* Above this size a diverged local file is NOT copied to a `.conflict-*`
+* sidecar during recovery (the cloud copy still replaces it). Sidecars
+* double disk usage per file; a multi-GB session archive could fill the VM.
+* The un-preserved overwrite is never silent — it is logged and listed in
+* the RECOVERY report.
+*/
+const MAX_PRESERVE_BYTES = 100 * 1024 * 1024;
+/** Marker that keeps the heartbeat recovery nudge idempotent across runs. */
+const RECOVERY_NUDGE_MARKER = "<!-- alfe-sync:recovery-nudge -->";
+/**
+* Recovery artifacts: `.conflict-<ts>` sidecars and `RECOVERY-<ts>.md`
+* reports. Anchored to the timestamp shape so legitimate user files like
+* `my.conflict-notes.txt` or `RECOVERY-plan.md` are never misclassified.
+*
+* They seed UP to the cloud so a preserved local version survives even if
+* the VM dies before the agent merges it (retrievable via the dashboard
+* file manager), but they are never AUTO-restored back down and never
+* preserved again — restoring would resurrect copies the agent already
+* cleaned up, and re-preserving would cascade `.conflict`-of-`.conflict`
+* files. Cloud copies are reclaimed when the agent's local cleanup
+* propagates through the watcher; artifacts orphaned by a rebuild before
+* cleanup linger until then (accepted: small, user-visible, deletable).
+* The watcher's delete brake also exempts them so the agent's post-merge
+* cleanup of many sidecars can't trip it.
+*
+* Deliberately NOT in the ignore set: ignored paths don't seed up and would
+* be eligible for pruneIgnored deletion.
+*/
+function isRecoveryArtifact(relativePath) {
+	const name = basename(relativePath);
+	return /\.conflict-\d{4}-\d{2}-\d{2}T/.test(name) || /^RECOVERY-\d{4}-\d{2}-\d{2}T.*\.md$/.test(name);
+}
+/**
 * Construct a sync engine bound to a workspace + agent API client.
 *
 * The client is constructed once in plugin.ts (or the CLI) and passed in,
 * so credentials never leak into multiple places.
 */
-function createSyncEngine({ workspacePath, client, runtime = "openclaw" }) {
+function createSyncEngine({ workspacePath, client, runtime = "openclaw", maxPreserveBytes = MAX_PRESERVE_BYTES }) {
 	return {
 		workspacePath,
 		client,
@@ -501,15 +572,11 @@ function createSyncEngine({ workspacePath, client, runtime = "openclaw" }) {
 			const trueConflicts = diff.conflicts.filter((p) => localChanges.includes(p));
 			const remoteOnlyChanges = diff.conflicts.filter((p) => !localChanges.includes(p));
 			let conflictCount = 0;
+			const conflictTimestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
 			for (const conflictPath of trueConflicts) {
-				const absolutePath = join(workspacePath, conflictPath);
-				if (!existsSync(absolutePath)) continue;
-				const ext = extname(conflictPath);
-				const base = basename(conflictPath, ext);
-				const dir = dirname(conflictPath);
-				const conflictName = `${base}.conflict-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}${ext}`;
-				await writeFile(join(workspacePath, dir, conflictName), await readFile(absolutePath));
-				if (!quiet) log.warn(`Conflict: ${conflictPath} — saved as ${conflictName}`);
+				const outcome = await preserveConflictCopy(workspacePath, conflictPath, conflictTimestamp);
+				if (outcome.status === "vanished") continue;
+				if (outcome.status !== "too-large" && !quiet) log.warn(`Conflict: ${conflictPath} — saved as ${outcome.conflictPath}`);
 				conflictCount++;
 			}
 			const filesToPush = filterIgnored([...diff.toPush, ...localChanges.filter((p) => !diff.conflicts.includes(p))], ignorePatterns);
@@ -553,25 +620,104 @@ function createSyncEngine({ workspacePath, client, runtime = "openclaw" }) {
 			const remotePaths = Object.keys(remoteManifest.files);
 			if (remotePaths.length === 0) {
 				if (!quiet) log.info("First-run sync: no cloud state — seeding workspace to cloud");
-				return this.push(void 0, options);
+				const seedResult = await this.push(void 0, options);
+				await updateManifestEntries(workspacePath, {}, { agentId: remoteManifest.agentId });
+				return seedResult;
 			}
 			if (!quiet) log.info(`First-run sync: ${String(remotePaths.length)} file(s) in cloud — restoring cloud state before seeding`);
 			const ignorePatterns = await loadIgnorePatterns(workspacePath, runtime);
-			const restorePaths = filterIgnored(remotePaths, ignorePatterns);
-			const restore = await this.pullFiles(restorePaths, options);
+			const restorePaths = filterIgnored(remotePaths, ignorePatterns).filter((p) => !isRecoveryArtifact(p));
+			const localManifest = await readManifest(workspacePath);
+			const manifestTrusted = localManifest.agentId === void 0 || localManifest.agentId === remoteManifest.agentId;
+			if (!manifestTrusted) {
+				log.warn(`Local sync manifest belongs to agent ${localManifest.agentId ?? "?"} but cloud state is agent ${remoteManifest.agentId} — treating the manifest as lost`);
+				await writeManifest(workspacePath, {
+					files: {},
+					agentId: remoteManifest.agentId
+				});
+			}
+			const classes = await classifyRestorePaths(workspacePath, restorePaths, remoteManifest.files, localManifest, manifestTrusted);
+			for (const p of classes.offlineDeletes) if (!quiet) log.info(`Recovery: ${p} was deleted locally while sync was down — not restoring it`);
+			if (classes.offlineDeletes.length > 0) log.info(`Recovery: ${String(classes.offlineDeletes.length)} locally-deleted file(s) not restored from cloud`);
+			const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+			const preserved = [];
+			let newlyPreserved = 0;
+			for (const { path, diskHash, size } of classes.preserve) {
+				const outcome = await preserveConflictCopy(workspacePath, path, timestamp, {
+					maxBytes: maxPreserveBytes,
+					sourceHash: diskHash
+				});
+				if (outcome.status === "vanished") continue;
+				const record = {
+					path,
+					localHash: diskHash,
+					remoteHash: remoteManifest.files[path].hash,
+					size
+				};
+				if (outcome.status === "too-large") {
+					record.tooLarge = true;
+					newlyPreserved++;
+					log.warn(`Recovery: ${path} diverged locally but exceeds the sidecar size cap — cloud version will replace it WITHOUT a preserved copy`);
+				} else {
+					record.conflictPath = outcome.conflictPath;
+					if (outcome.status === "preserved") newlyPreserved++;
+					log.warn(`Recovery: preserved local ${path} as ${outcome.conflictPath} — cloud version restored in place`);
+				}
+				preserved.push(record);
+			}
+			let recoveryReportPath = null;
+			if (preserved.length > 0 && (newlyPreserved > 0 || !await recoveryReportExists(workspacePath))) {
+				recoveryReportPath = `${agentDirPrefix(workspacePath)}RECOVERY-${timestamp}.md`;
+				const reportAbsolute = join(workspacePath, recoveryReportPath);
+				await mkdir(dirname(reportAbsolute), { recursive: true });
+				await writeFile(reportAbsolute, buildRecoveryReport(preserved, workspacePath), "utf-8");
+				log.warn(`Recovery: ${String(preserved.length)} diverged local file(s) — see ${recoveryReportPath}`);
+			}
+			const pullList = [
+				...classes.missing,
+				...classes.pullClean,
+				...classes.preserve.map((p) => p.path)
+			];
+			const restore = {
+				pulled: 0,
+				errors: 0
+			};
+			if (pullList.length > 0) {
+				if (!quiet) log.info(`Pulling ${String(pullList.length)} file(s)`);
+				const results = await downloadFiles(workspacePath, pullList, client, remoteManifest, options);
+				restore.pulled = results.filter((r) => r.success).length;
+				restore.errors = results.filter((r) => !r.success).length;
+			}
+			if (Object.keys(classes.heal).length > 0 || localManifest.agentId !== remoteManifest.agentId) await updateManifestEntries(workspacePath, classes.heal, { agentId: remoteManifest.agentId });
 			const remoteSet = new Set(remotePaths);
-			const toSeed = (await detectLocalChanges(workspacePath, ignorePatterns)).filter((p) => !remoteSet.has(p));
-			const seed = toSeed.length > 0 ? await this.push(toSeed, options) : {
+			const pushList = [...(await detectLocalChanges(workspacePath, ignorePatterns)).filter((p) => !remoteSet.has(p)), ...classes.localAhead];
+			const seed = pushList.length > 0 ? await this.push(pushList, options) : {
 				pushed: 0,
 				pulled: 0,
 				conflicts: 0,
 				errors: 0
 			};
+			let nudge = {
+				pushed: 0,
+				errors: 0
+			};
+			if (preserved.length > 0 && recoveryReportPath !== null && runtime === "openclaw") try {
+				const nudgePath = await appendRecoveryNudge(workspacePath, recoveryReportPath, preserved.length);
+				if (nudgePath !== null) {
+					const pushResult = await this.push([nudgePath], options);
+					nudge = {
+						pushed: pushResult.pushed,
+						errors: pushResult.errors
+					};
+				}
+			} catch (err) {
+				log.warn(`Recovery: failed to write heartbeat nudge: ${err instanceof Error ? err.message : String(err)}`);
+			}
 			return {
-				pushed: seed.pushed,
+				pushed: seed.pushed + nudge.pushed,
 				pulled: restore.pulled,
-				conflicts: restore.conflicts + seed.conflicts,
-				errors: restore.errors + seed.errors
+				conflicts: preserved.length + seed.conflicts,
+				errors: restore.errors + seed.errors + nudge.errors
 			};
 		},
 		async pullFiles(paths, options = {}) {
@@ -674,7 +820,191 @@ async function detectLocalChanges(workspacePath, ignorePatterns) {
 	await walk(workspacePath);
 	return changed;
 }
+/**
+* Relative prefix of the agent's actual working directory. The sync root is
+* the runtime HOME (`~/.openclaw`), but the agent lives and works in
+* `~/.openclaw/workspace/` — recovery artifacts meant for the agent's eyes
+* (RECOVERY report, heartbeat nudge) must land there or it never sees them.
+* Falls back to the sync root when no `workspace/` dir exists (tests, CLI
+* usage against a bare directory).
+*/
+function agentDirPrefix(workspacePath) {
+	return existsSync(join(workspacePath, "workspace")) ? "workspace/" : "";
+}
+/** Whether an unresolved RECOVERY-*.md report already sits in the agent dir. */
+async function recoveryReportExists(workspacePath) {
+	return (await readdir(join(workspacePath, agentDirPrefix(workspacePath))).catch(() => [])).some((name) => name.startsWith("RECOVERY-") && name.endsWith(".md"));
+}
+/**
+* Copy a file aside as `<base>.conflict-<ts><ext>` in the same directory
+* before a remote copy overwrites it. Uses `copyFile` (no buffering — safe
+* for large/binary files).
+*
+* Idempotent: if a sibling sidecar with identical content already exists
+* (crash-loop retry, repeated recovery), no new copy is stacked. Pass
+* `sourceHash` when the caller already hashed the file.
+*/
+async function preserveConflictCopy(workspacePath, relativePath, timestamp, options = {}) {
+	const absolutePath = join(workspacePath, relativePath);
+	const ext = extname(relativePath);
+	const base = basename(relativePath, ext);
+	const dir = dirname(relativePath);
+	try {
+		const fileStat = await stat(absolutePath);
+		if (options.maxBytes !== void 0 && fileStat.size > options.maxBytes) return {
+			status: "too-large",
+			size: fileStat.size
+		};
+		const sourceHash = options.sourceHash ?? await computeFileHash(absolutePath);
+		const siblings = await readdir(join(workspacePath, dir)).catch(() => []);
+		for (const name of siblings) {
+			if (!name.startsWith(`${base}.conflict-`)) continue;
+			if (ext !== "" && !name.endsWith(ext)) continue;
+			if (await computeFileHash(join(workspacePath, dir, name)).catch(() => null) === sourceHash) return {
+				status: "already-preserved",
+				conflictPath: join(dir, name).replace(/\\/g, "/")
+			};
+		}
+		const conflictName = `${base}.conflict-${timestamp}${ext}`;
+		await copyFile(absolutePath, join(workspacePath, dir, conflictName));
+		return {
+			status: "preserved",
+			conflictPath: join(dir, conflictName).replace(/\\/g, "/")
+		};
+	} catch {
+		return { status: "vanished" };
+	}
+}
+const CLASSIFY_CONCURRENCY = 8;
+/**
+* Classify every cloud-held path for recovery. The destructive decision
+* (overwrite local content) is only ever taken when the DISK hash diverges
+* from the cloud AND the local manifest can't vouch for the disk content —
+* and even then the local bytes are preserved first. The manifest and mtime
+* are used solely to avoid work and to detect local-ahead edits, never to
+* authorize an unpreserved overwrite.
+*/
+async function classifyRestorePaths(workspacePath, restorePaths, remoteFiles, localManifest, manifestTrusted) {
+	const out = {
+		missing: [],
+		offlineDeletes: [],
+		heal: {},
+		pullClean: [],
+		localAhead: [],
+		preserve: []
+	};
+	async function classifyOne(path) {
+		const remote = remoteFiles[path];
+		const entry = manifestTrusted ? localManifest.files[path] : void 0;
+		const absolutePath = join(workspacePath, path);
+		let fileStat = null;
+		try {
+			fileStat = await stat(absolutePath);
+		} catch {}
+		if (!fileStat?.isFile()) {
+			if (entry?.hash === remote.hash) out.offlineDeletes.push(path);
+			else out.missing.push(path);
+			return;
+		}
+		const unchangedSinceSync = fileStat.size === entry?.size && fileStat.mtimeMs <= Date.parse(entry.lastSynced);
+		const isArchive = ARCHIVE_PREFIXES.some((p) => path.startsWith(p));
+		if (unchangedSinceSync || isArchive) {
+			if (entry?.hash === remote.hash) return;
+			out.pullClean.push(path);
+			return;
+		}
+		let diskHash;
+		try {
+			diskHash = await computeFileHash(absolutePath);
+		} catch {
+			out.missing.push(path);
+			return;
+		}
+		if (diskHash === remote.hash) {
+			if (entry?.hash !== remote.hash) out.heal[path] = {
+				hash: remote.hash,
+				size: fileStat.size,
+				lastSynced: (/* @__PURE__ */ new Date()).toISOString(),
+				storageClass: remote.storageClass ?? "STANDARD"
+			};
+			return;
+		}
+		if (entry?.hash === diskHash) {
+			out.pullClean.push(path);
+			return;
+		}
+		if (entry?.hash === remote.hash) {
+			out.localAhead.push(path);
+			return;
+		}
+		out.preserve.push({
+			path,
+			diskHash,
+			size: fileStat.size
+		});
+	}
+	for (let i = 0; i < restorePaths.length; i += CLASSIFY_CONCURRENCY) await Promise.all(restorePaths.slice(i, i + CLASSIFY_CONCURRENCY).map(classifyOne));
+	return out;
+}
+function buildRecoveryReport(records, workspacePath) {
+	const lines = [
+		`# Workspace recovery report`,
+		"",
+		`A sync recovery restored this agent's cloud-saved workspace. The files`,
+		`below had local content that differed from the cloud copy. The cloud`,
+		`version now lives at the original path; the pre-recovery local version`,
+		`was preserved next to it as a \`.conflict-*\` sidecar.`,
+		"",
+		`**What to do:** open each sidecar, merge anything worth keeping into the`,
+		`live file, then delete the sidecar. Delete this report when done.`,
+		"",
+		`Paths are relative to the sync root: \`${workspacePath}\``,
+		""
+	];
+	const capped = records.filter((r) => r.tooLarge === true);
+	const kept = records.filter((r) => r.tooLarge !== true);
+	if (kept.length > 0) {
+		lines.push(`| File | Preserved copy | Local hash | Cloud hash | Size (bytes) |`);
+		lines.push(`| --- | --- | --- | --- | --- |`);
+		for (const r of kept) lines.push(`| \`${r.path}\` | \`${r.conflictPath ?? ""}\` | \`${r.localHash}\` | \`${r.remoteHash}\` | ${String(r.size)} |`);
+		lines.push("");
+	}
+	if (capped.length > 0) {
+		lines.push(`The following diverged files exceeded the sidecar size cap and were`, `replaced by the cloud version WITHOUT a preserved copy:`, "");
+		for (const r of capped) lines.push(`- \`${r.path}\` (${String(r.size)} bytes, local hash \`${r.localHash}\`)`);
+		lines.push("");
+	}
+	return lines.join("\n");
+}
+/**
+* Append the recovery nudge to the agent's HEARTBEAT.md (OpenClaw reads it
+* from the agent workspace dir on its periodic heartbeat). Returns the
+* sync-relative path when a nudge was appended, or null when a prior nudge
+* is still pending (idempotency marker present).
+*/
+async function appendRecoveryNudge(workspacePath, recoveryReportPath, preservedCount) {
+	const prefix = agentDirPrefix(workspacePath);
+	const heartbeatPath = `${prefix}HEARTBEAT.md`;
+	const absolutePath = join(workspacePath, heartbeatPath);
+	if ((existsSync(absolutePath) ? await readFile(absolutePath, "utf-8") : "").includes(RECOVERY_NUDGE_MARKER)) return null;
+	const reportForAgent = recoveryReportPath.startsWith(prefix) ? recoveryReportPath.slice(prefix.length) : recoveryReportPath;
+	const block = [
+		"",
+		RECOVERY_NUDGE_MARKER,
+		"## Workspace recovery needs your attention",
+		"",
+		`A sync recovery preserved ${String(preservedCount)} pre-recovery local file version(s)`,
+		`as \`.conflict-*\` sidecars. Read every \`RECOVERY-*.md\` report in this directory`,
+		`(latest: \`${reportForAgent}\`), merge anything worth keeping into the live files,`,
+		`then delete the sidecars, the reports, and this section (including its marker`,
+		`comment).`,
+		""
+	].join("\n");
+	await mkdir(dirname(absolutePath), { recursive: true });
+	await appendFile(absolutePath, block, "utf-8");
+	return heartbeatPath;
+}
 //#endregion
-export { DEFAULT_IGNORES as a, shouldIgnore as c, diffManifests as d, readManifest as f, writeManifest as h, withRetry as i, shouldIgnoreDir as l, updateManifestEntry as m, downloadFiles as n, filterIgnored as o, removeManifestEntry as p, uploadFiles as r, loadIgnorePatterns as s, createSyncEngine as t, computeFileHash as u };
+export { withRetry as a, loadIgnorePatterns as c, computeFileHash as d, diffManifests as f, writeManifest as g, updateManifestEntry as h, uploadFiles as i, shouldIgnore as l, removeManifestEntry as m, isRecoveryArtifact as n, DEFAULT_IGNORES as o, readManifest as p, downloadFiles as r, filterIgnored as s, createSyncEngine as t, shouldIgnoreDir as u };
 
 //# sourceMappingURL=sync-engine.js.map