framer-code-link 0.4.4 → 0.4.6

package/dist/index.mjs

@@ -3,11 +3,11 @@ import { createRequire } from "node:module";
 import { Command } from "commander";
 import fs from "fs/promises";
 import { WebSocketServer } from "ws";
-import chokidar from "chokidar";
 import path from "path";
 import { createHash } from "crypto";
 import { setupTypeAcquisition } from "@typescript/ata";
 import ts from "typescript";
+import chokidar from "chokidar";
 
 //#region rolldown:runtime
 var __create = Object.create;
@@ -36,6 +36,173 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	enumerable: true
 }) : target, mod));
 
+//#endregion
+//#region ../code-link-shared/src/hash.ts
+/**
+* Base58 alphabet (no 0/O/I/l to avoid confusion)
+*/
+const BASE58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+/**
+* Derive a short, deterministic hash from the full Framer project hash.
+* Uses a simple numeric hash encoded in base58 for compactness.
+* Idempotent: if input is already the target length, returns it unchanged.
+*/
+function shortProjectHash(fullHash, length = 8) {
+	if (fullHash.length === length) return fullHash;
+	let h1 = 0;
+	let h2 = 0;
+	for (let i = 0; i < fullHash.length; i++) {
+		const char = fullHash.charCodeAt(i);
+		h1 = Math.imul(h1 ^ char, 2246822507);
+		h2 = Math.imul(h2 ^ char, 3266489909);
+	}
+	h1 ^= h2 >>> 16;
+	h2 ^= h1 >>> 13;
+	let result = "";
+	const combined = [Math.abs(h1), Math.abs(h2)];
+	for (const num of combined) {
+		let n = num >>> 0;
+		while (n > 0 && result.length < length) {
+			result += BASE58[n % 58];
+			n = Math.floor(n / 58);
+		}
+	}
+	while (result.length < length) result += BASE58[0];
+	return result.slice(0, length);
+}
+
+//#endregion
+//#region ../code-link-shared/src/paths.ts
+/**
+* File path normalization utilities
+* Framer code files include extensions in their paths (.tsx, .ts, etc.)
+*/
+const firstCharacterRegex = /^[a-zA-Z$_]/;
+const remainingCharactersRegex = /[^a-zA-Z0-9$_]/g;
+const onlyDotsRegex = /^\.+$/;
+const tsxExtension = ".tsx";
+var NameType = /* @__PURE__ */ function(NameType) {
+	NameType["Variable"] = "Variable";
+	NameType["Selector"] = "Selector";
+	NameType["Directory"] = "Directory";
+	return NameType;
+}(NameType || {});
+function sanitizedName(type, name) {
+	if (!name) return null;
+	let validName = name.trim();
+	if (validName.length === 0) return null;
+	const validFirstChar = type === NameType.Selector ? "_" : "$";
+	if (type === NameType.Directory) {
+		if (onlyDotsRegex.test(validName)) return null;
+	} else if (!firstCharacterRegex.test(validName)) validName = validFirstChar + validName;
+	validName = validName.replace(remainingCharactersRegex, "_");
+	validName = validName.replace(/_+/g, "_");
+	validName = validName.replace(/^\$_/u, validFirstChar);
+	return validName;
+}
+function sanitizedVariableName(name) {
+	return sanitizedName(NameType.Variable, name);
+}
+function sanitizedDirectoryName(name) {
+	return sanitizedName(NameType.Directory, name);
+}
+function capitalizeFirstLetter(str) {
+	if (str.length === 0) return str;
+	return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function hasValidExtension(fileName) {
+	if (fileName.endsWith(".json")) return true;
+	return /\.[tj]sx?$/u.test(fileName);
+}
+function splitExtension(fileName) {
+	const lastDot = fileName.lastIndexOf(".");
+	if (lastDot <= 0) return [fileName, ""];
+	return [fileName.slice(0, lastDot), fileName.slice(lastDot + 1)];
+}
+function dirname(filePath) {
+	const at = filePath.lastIndexOf("/");
+	if (at < 0) return "";
+	return filePath.slice(0, at);
+}
+function filename(filePath) {
+	const at = filePath.lastIndexOf("/") + 1;
+	return filePath.slice(at);
+}
+function pathJoin(...parts) {
+	let res = "";
+	parts.forEach((part) => {
+		while (part.startsWith("/")) part = part.slice(1);
+		while (part.endsWith("/")) part = part.slice(0, -1);
+		if (part === "") return;
+		if (res !== "") res += "/";
+		res += part;
+	});
+	return res;
+}
+function normalizePath$1(filePath) {
+	if (!filePath) return "";
+	const isAbsolute = filePath.startsWith("/");
+	const segments = filePath.replace(/\\/g, "/").split("/");
+	const stack = [];
+	for (const segment of segments) {
+		if (!segment || segment === ".") continue;
+		if (segment === "..") {
+			if (stack.length > 0) stack.pop();
+			continue;
+		}
+		stack.push(segment);
+	}
+	const normalized = stack.join("/");
+	if (isAbsolute) return `/${normalized}`;
+	return normalized;
+}
+function sanitizeFilePath(input, capitalizeReactComponent = true) {
+	const trimmed = input.trim();
+	const [inputName, extension] = splitExtension(filename(trimmed));
+	const extensionWithDot = extension ? `.${extension}` : "";
+	const dirName = dirname(trimmed).split("/").map((part) => sanitizedDirectoryName(part)).filter((part) => Boolean(part)).join("/");
+	let name = sanitizedVariableName(inputName) ?? "MyComponent";
+	if ((!hasValidExtension(extension) || extension === tsxExtension) && capitalizeReactComponent) name = capitalizeFirstLetter(name);
+	return {
+		path: pathJoin(dirName, name + extensionWithDot),
+		dirName,
+		name,
+		extension
+	};
+}
+function isSupportedExtension$1(filePath) {
+	return /\.(tsx?|jsx?|json)$/i.test(filePath);
+}
+/**
+* Pluralize a word based on count
+* @example pluralize(1, "file") => "1 file"
+* @example pluralize(3, "file") => "3 files"
+* @example pluralize(0, "conflict") => "0 conflicts"
+*/
+function pluralize(count, singular, plural) {
+	return `${count} ${count === 1 ? singular : plural ?? `${singular}s`}`;
+}
+
+//#endregion
+//#region ../code-link-shared/src/ports.ts
+/**
+* Generate a deterministic port number from a project hash (full or short).
+* Port range: 3847-4096 (250 possible ports)
+* Must match between CLI and plugin.
+*
+* Internally normalizes to the short id so both full and short inputs yield the same port.
+*/
+function getPortFromHash(projectHash) {
+	const shortId = shortProjectHash(projectHash);
+	let hash = 0;
+	for (let i = 0; i < shortId.length; i++) {
+		const char = shortId.charCodeAt(i);
+		hash = (hash << 5) - hash + char;
+		hash = hash & hash;
+	}
+	return 3847 + Math.abs(hash) % 250;
+}
+
 //#endregion
 //#region ../../node_modules/picocolors/picocolors.js
 var require_picocolors = /* @__PURE__ */ __commonJSMin(((exports, module) => {
@@ -108,12 +275,12 @@ var require_picocolors = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 //#endregion
 //#region src/utils/logging.ts
 var import_picocolors = /* @__PURE__ */ __toESM(require_picocolors(), 1);
-let LogLevel = /* @__PURE__ */ function(LogLevel$1) {
-	LogLevel$1[LogLevel$1["DEBUG"] = 0] = "DEBUG";
-	LogLevel$1[LogLevel$1["INFO"] = 1] = "INFO";
-	LogLevel$1[LogLevel$1["WARN"] = 2] = "WARN";
-	LogLevel$1[LogLevel$1["ERROR"] = 3] = "ERROR";
-	return LogLevel$1;
+let LogLevel = /* @__PURE__ */ function(LogLevel) {
+	LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
+	LogLevel[LogLevel["INFO"] = 1] = "INFO";
+	LogLevel[LogLevel["WARN"] = 2] = "WARN";
+	LogLevel[LogLevel["ERROR"] = 3] = "ERROR";
+	return LogLevel;
 }({});
 let currentLevel = LogLevel.INFO;
 let lastMessage = "";
@@ -158,9 +325,9 @@ function logWithDedupe(message, writer) {
 /**
 * Print the startup banner - one colored line
 */
-function banner(version$1, port) {
+function banner(version, port) {
 	console.log();
-	let message = `  ${import_picocolors.default.cyan(import_picocolors.default.bold("⚡ Code Link"))} ${import_picocolors.default.dim(`v${version$1}`)}`;
+	let message = `  ${import_picocolors.default.cyan(import_picocolors.default.bold("⚡ Code Link"))} ${import_picocolors.default.dim(`v${version}`)}`;
 	if (currentLevel <= LogLevel.DEBUG) message += `  ${import_picocolors.default.dim("Port")} ${import_picocolors.default.yellow(port)}`;
 	console.log(message);
 	console.log();
@@ -294,11 +461,6 @@ function resetDisconnectState() {
 //#endregion
 //#region src/helpers/connection.ts
 /**
-* WebSocket connection helper
-*
-* Wrapper around ws.Server that normalizes handshake and surfaces callbacks.
-*/
-/**
 * Initializes a WebSocket server and returns a connection interface
 * Returns a Promise that resolves when the server is ready, or rejects on startup errors
 */
@@ -419,298 +581,63 @@ function sendMessage(socket, message) {
 }
 
 //#endregion
-//#region ../code-link-shared/src/hash.ts
+//#region src/utils/node-paths.ts
 /**
-* Base58 alphabet (no 0/O/I/l to avoid confusion)
+* Path manipulation utilities
 */
-const BASE58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
 /**
-* Derive a short, deterministic hash from the full Framer project hash.
-* Uses a simple numeric hash encoded in base58 for compactness.
-* Idempotent: if input is already the target length, returns it unchanged.
+* Gets a relative path from the project directory
 */
-function shortProjectHash(fullHash, length = 8) {
-	if (fullHash.length === length) return fullHash;
-	let h1 = 0;
-	let h2 = 0;
-	for (let i = 0; i < fullHash.length; i++) {
-		const char = fullHash.charCodeAt(i);
-		h1 = Math.imul(h1 ^ char, 2246822507);
-		h2 = Math.imul(h2 ^ char, 3266489909);
-	}
-	h1 ^= h2 >>> 16;
-	h2 ^= h1 >>> 13;
-	let result = "";
-	const combined = [Math.abs(h1), Math.abs(h2)];
-	for (const num of combined) {
-		let n = num >>> 0;
-		while (n > 0 && result.length < length) {
-			result += BASE58[n % 58];
-			n = Math.floor(n / 58);
+function getRelativePath(projectDir, absolutePath) {
+	return path.relative(projectDir, absolutePath);
+}
+/**
+* Normalizes a file path by:
+* - Converting backslashes to forward slashes
+* - Resolving . and .. segments
+* - Removing duplicate slashes
+*/
+function normalizePath(filePath) {
+	if (!filePath) return "";
+	const isAbsolute = filePath.startsWith("/");
+	const segments = filePath.replace(/\\/g, "/").split("/");
+	const stack = [];
+	for (const segment of segments) {
+		if (!segment || segment === ".") continue;
+		if (segment === "..") {
+			if (stack.length > 0) stack.pop();
+			continue;
 		}
+		stack.push(segment);
 	}
-	while (result.length < length) result += BASE58[0];
-	return result.slice(0, length);
+	const normalized = stack.join("/");
+	if (isAbsolute) return `/${normalized}`;
+	return normalized;
 }
 
 //#endregion
-//#region ../code-link-shared/src/ports.ts
+//#region src/utils/state-persistence.ts
 /**
-* Generate a deterministic port number from a project hash (full or short).
-* Port range: 3847-4096 (250 possible ports)
-* Must match between CLI and plugin.
+* State persistence helper
 *
-* Internally normalizes to the short id so both full and short inputs yield the same port.
+* Persists last sync timestamps along with content hashes.
+* We only trust persisted timestamps if the file content hasn't changed
+* (hash matches), because that means the file wasn't edited while CLI was offline.
 */
-function getPortFromHash(projectHash) {
-	const shortId = shortProjectHash(projectHash);
-	let hash = 0;
-	for (let i = 0; i < shortId.length; i++) {
-		const char = shortId.charCodeAt(i);
-		hash = (hash << 5) - hash + char;
-		hash = hash & hash;
-	}
-	return 3847 + Math.abs(hash) % 250;
-}
-
-//#endregion
-//#region ../code-link-shared/src/paths.ts
-/**
-* File path normalization utilities
-* Framer code files include extensions in their paths (.tsx, .ts, etc.)
-*/
-const firstCharacterRegex = /^[a-zA-Z$_]/;
-const remainingCharactersRegex = /[^a-zA-Z0-9$_]/g;
-const onlyDotsRegex = /^\.+$/;
-const tsxExtension = ".tsx";
-var NameType = /* @__PURE__ */ function(NameType$1) {
-	NameType$1["Variable"] = "Variable";
-	NameType$1["Selector"] = "Selector";
-	NameType$1["Directory"] = "Directory";
-	return NameType$1;
-}(NameType || {});
-function sanitizedName(type, name) {
-	if (!name) return null;
-	let validName = name.trim();
-	if (validName.length === 0) return null;
-	const validFirstChar = type === NameType.Selector ? "_" : "$";
-	if (type === NameType.Directory) {
-		if (onlyDotsRegex.test(validName)) return null;
-	} else if (!firstCharacterRegex.test(validName)) validName = validFirstChar + validName;
-	validName = validName.replace(remainingCharactersRegex, "_");
-	validName = validName.replace(/_+/g, "_");
-	validName = validName.replace(/^\$_/u, validFirstChar);
-	return validName;
-}
-function sanitizedVariableName(name) {
-	return sanitizedName(NameType.Variable, name);
-}
-function sanitizedDirectoryName(name) {
-	return sanitizedName(NameType.Directory, name);
-}
-function capitalizeFirstLetter(str) {
-	if (str.length === 0) return str;
-	return str.charAt(0).toUpperCase() + str.slice(1);
-}
-function hasValidExtension(fileName) {
-	if (fileName.endsWith(".json")) return true;
-	return /\.[tj]sx?$/u.test(fileName);
-}
-function splitExtension(fileName) {
-	const lastDot = fileName.lastIndexOf(".");
-	if (lastDot <= 0) return [fileName, ""];
-	return [fileName.slice(0, lastDot), fileName.slice(lastDot + 1)];
-}
-function dirname(filePath) {
-	const at = filePath.lastIndexOf("/");
-	if (at < 0) return "";
-	return filePath.slice(0, at);
-}
-function filename(filePath) {
-	const at = filePath.lastIndexOf("/") + 1;
-	return filePath.slice(at);
-}
-function pathJoin(...parts) {
-	let res = "";
-	parts.forEach((part) => {
-		while (part.startsWith("/")) part = part.slice(1);
-		while (part.endsWith("/")) part = part.slice(0, -1);
-		if (part === "") return;
-		if (res !== "") res += "/";
-		res += part;
-	});
-	return res;
-}
-function normalizePath(filePath) {
-	if (!filePath) return "";
-	const isAbsolute = filePath.startsWith("/");
-	const segments = filePath.replace(/\\/g, "/").split("/");
-	const stack = [];
-	for (const segment of segments) {
-		if (!segment || segment === ".") continue;
-		if (segment === "..") {
-			if (stack.length > 0) stack.pop();
-			continue;
-		}
-		stack.push(segment);
-	}
-	const normalized = stack.join("/");
-	if (isAbsolute) return `/${normalized}`;
-	return normalized;
-}
-function sanitizeFilePath(input, capitalizeReactComponent = true) {
-	const trimmed = input.trim();
-	const [inputName, extension] = splitExtension(filename(trimmed));
-	const extensionWithDot = extension ? `.${extension}` : "";
-	const dirName = dirname(trimmed).split("/").map((part) => sanitizedDirectoryName(part)).filter((part) => Boolean(part)).join("/");
-	let name = sanitizedVariableName(inputName) ?? "MyComponent";
-	if ((!hasValidExtension(extension) || extension === tsxExtension) && capitalizeReactComponent) name = capitalizeFirstLetter(name);
-	return {
-		path: pathJoin(dirName, name + extensionWithDot),
-		dirName,
-		name,
-		extension
-	};
-}
-function isSupportedExtension$1(filePath) {
-	return /\.(tsx?|jsx?|json)$/i.test(filePath);
-}
-/**
-* Pluralize a word based on count
-* @example pluralize(1, "file") => "1 file"
-* @example pluralize(3, "file") => "3 files"
-* @example pluralize(0, "conflict") => "0 conflicts"
-*/
-function pluralize(count, singular, plural) {
-	return `${count} ${count === 1 ? singular : plural ?? `${singular}s`}`;
-}
-
-//#endregion
-//#region src/utils/node-paths.ts
-/**
-* Path manipulation utilities
-*/
-/**
-* Gets a relative path from the project directory
-*/
-function getRelativePath(projectDir, absolutePath) {
-	return path.relative(projectDir, absolutePath);
-}
-/**
-* Normalizes a file path by:
-* - Converting backslashes to forward slashes
-* - Resolving . and .. segments
-* - Removing duplicate slashes
-*/
-function normalizePath$1(filePath) {
-	if (!filePath) return "";
-	const isAbsolute = filePath.startsWith("/");
-	const segments = filePath.replace(/\\/g, "/").split("/");
-	const stack = [];
-	for (const segment of segments) {
-		if (!segment || segment === ".") continue;
-		if (segment === "..") {
-			if (stack.length > 0) stack.pop();
-			continue;
-		}
-		stack.push(segment);
-	}
-	const normalized = stack.join("/");
-	if (isAbsolute) return `/${normalized}`;
-	return normalized;
-}
-
-//#endregion
-//#region src/helpers/watcher.ts
-/**
-* File watcher helper
-*
-* Wrapper around chokidar that normalizes file paths and filters to ts, tsx, js, json.
-*/
-/**
-* Initializes a file watcher for the given directory
-*/
-function initWatcher(filesDir) {
-	const handlers = [];
-	const watcher = chokidar.watch(filesDir, {
-		ignored: /(^|[/\\])\.\./,
-		persistent: true,
-		ignoreInitial: false
-	});
-	debug(`Watching directory: ${filesDir}`);
-	const emitEvent = async (kind, absolutePath) => {
-		if (!isSupportedExtension$1(absolutePath)) return;
-		const rawRelativePath = normalizePath(getRelativePath(filesDir, absolutePath));
-		const relativePath = sanitizeFilePath(rawRelativePath, false).path;
-		let effectiveAbsolutePath = absolutePath;
-		if (relativePath !== rawRelativePath && kind === "add") {
-			const newAbsolutePath = path.join(filesDir, relativePath);
-			try {
-				await fs.mkdir(path.dirname(newAbsolutePath), { recursive: true });
-				await fs.rename(absolutePath, newAbsolutePath);
-				debug(`Renamed ${rawRelativePath} -> ${relativePath}`);
-				effectiveAbsolutePath = newAbsolutePath;
-			} catch (err) {
-				warn(`Failed to rename ${rawRelativePath}`, err);
-			}
-		}
-		let content;
-		if (kind !== "delete") try {
-			content = await fs.readFile(effectiveAbsolutePath, "utf-8");
-		} catch (err) {
-			debug(`Failed to read file ${relativePath}:`, err);
-			return;
-		}
-		const event = {
-			kind,
-			relativePath,
-			content
-		};
-		debug(`Watcher event: ${kind} ${relativePath}`);
-		for (const handler of handlers) handler(event);
-	};
-	watcher.on("add", (filePath) => {
-		emitEvent("add", filePath);
-	});
-	watcher.on("change", (filePath) => {
-		emitEvent("change", filePath);
-	});
-	watcher.on("unlink", (filePath) => {
-		emitEvent("delete", filePath);
-	});
-	return {
-		on(_event, handler) {
-			handlers.push(handler);
-		},
-		async close() {
-			await watcher.close();
-		}
-	};
-}
-
-//#endregion
-//#region src/utils/state-persistence.ts
-/**
-* State persistence helper
-*
-* Persists last sync timestamps along with content hashes.
-* We only trust persisted timestamps if the file content hasn't changed
-* (hash matches), because that means the file wasn't edited while CLI was offline.
-*/
-const STATE_FILE_NAME = ".framer-sync-state.json";
-const CURRENT_VERSION = 1;
-const SUPPORTED_EXTENSIONS$1 = [
-	".ts",
-	".tsx",
-	".js",
-	".jsx",
-	".json"
-];
-const DEFAULT_EXTENSION$1 = ".tsx";
-function normalizePersistedFileName(fileName) {
-	let normalized = normalizePath$1(fileName.trim());
-	if (!SUPPORTED_EXTENSIONS$1.some((ext) => normalized.toLowerCase().endsWith(ext))) normalized = `${normalized}${DEFAULT_EXTENSION$1}`;
-	return normalized;
+const STATE_FILE_NAME = ".framer-sync-state.json";
+const CURRENT_VERSION = 1;
+const SUPPORTED_EXTENSIONS$1 = [
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".json"
+];
+const DEFAULT_EXTENSION$1 = ".tsx";
+function normalizePersistedFileName(fileName) {
+	let normalized = normalizePath(fileName.trim());
+	if (!SUPPORTED_EXTENSIONS$1.some((ext) => normalized.toLowerCase().endsWith(ext))) normalized = `${normalized}${DEFAULT_EXTENSION$1}`;
+	return normalized;
 }
 /**
 * Hash file content to detect changes
@@ -785,7 +712,7 @@ const SUPPORTED_EXTENSIONS = [
 	".json"
 ];
 const DEFAULT_EXTENSION = ".tsx";
-const DEFAULT_REMOTE_DRIFT_MS = 2e3;
+const DEFAULT_REMOTE_DRIFT_MS = 2500;
 /** Normalize file name for case-insensitive comparison (macOS/Windows compat) */
 function normalizeForComparison(fileName) {
 	return fileName.toLowerCase();
@@ -804,7 +731,7 @@ async function listFiles(filesDir) {
 				continue;
 			}
 			if (!isSupportedExtension(entry.name)) continue;
-			const sanitizedPath = sanitizeFilePath(normalizePath(path.relative(filesDir, entryPath)), false).path;
+			const sanitizedPath = sanitizeFilePath(normalizePath$1(path.relative(filesDir, entryPath)), false).path;
 			try {
 				const [content, stats] = await Promise.all([fs.readFile(entryPath, "utf-8"), fs.stat(entryPath)]);
 				files.push({
@@ -832,7 +759,7 @@ async function detectConflicts(remoteFiles, filesDir, options = {}) {
 	const detect = options.detectConflicts ?? true;
 	const preferRemote = options.preferRemote ?? false;
 	const persistedState = options.persistedState;
-	const getPersistedState = (fileName) => persistedState?.get(normalizeForComparison(fileName)) ?? persistedState?.get(fileName);
+	const getPersistedState = (fileName) => persistedState?.get(normalizeForComparison(fileName));
 	debug(`Detecting conflicts for ${String(remoteFiles.length)} remote files`);
 	const localFiles = await listFiles(filesDir);
 	const localFileMap = new Map(localFiles.map((f) => [normalizeForComparison(f.name), f]));
@@ -928,7 +855,7 @@ async function detectConflicts(remoteFiles, filesDir, options = {}) {
 	};
 }
 function autoResolveConflicts(conflicts, versions, options = {}) {
-	const versionMap = new Map(versions.map((version$1) => [version$1.fileName, version$1.latestRemoteVersionMs]));
+	const versionMap = new Map(versions.map((version) => [version.fileName, version.latestRemoteVersionMs]));
 	const remoteDriftMs = options.remoteDriftMs ?? DEFAULT_REMOTE_DRIFT_MS;
 	const autoResolvedLocal = [];
 	const autoResolvedRemote = [];
@@ -948,28 +875,31 @@ function autoResolveConflicts(conflicts, versions, options = {}) {
 			}
 			continue;
 		}
+		if (localClean) {
+			debug(`  Local clean -> REMOTE (safe to overwrite)`);
+			autoResolvedRemote.push(conflict);
+			continue;
+		}
 		if (!latestRemoteVersionMs) {
-			debug(`  No remote version data, keeping conflict`);
+			debug(`  Local modified, no remote version data -> conflict`);
 			remainingConflicts.push(conflict);
 			continue;
 		}
 		if (!lastSyncedAt) {
-			debug(`  No last sync timestamp, keeping conflict`);
+			debug(`  Local modified, no sync timestamp -> conflict`);
 			remainingConflicts.push(conflict);
 			continue;
 		}
 		debug(`  Remote: ${new Date(latestRemoteVersionMs).toISOString()}`);
 		debug(`  Synced: ${new Date(lastSyncedAt).toISOString()}`);
 		const remoteUnchanged = latestRemoteVersionMs <= lastSyncedAt + remoteDriftMs;
-		if (remoteUnchanged && !localClean) {
+		const driftMargin = latestRemoteVersionMs - lastSyncedAt;
+		if (remoteUnchanged) {
 			debug(`  Remote unchanged, local changed -> LOCAL`);
+			if (driftMargin > 0) debug(`    (within drift tolerance: ${driftMargin}ms < ${remoteDriftMs}ms threshold)`);
 			autoResolvedLocal.push(conflict);
-		} else if (localClean && !remoteUnchanged) {
-			debug(`  Local unchanged, remote changed -> REMOTE`);
-			autoResolvedRemote.push(conflict);
-		} else if (remoteUnchanged && localClean) debug(`  Both unchanged, skipping`);
-		else {
-			debug(`  Both changed, real conflict`);
+		} else {
+			debug(`  Both changed -> conflict (remote ahead by ${driftMargin}ms, threshold: ${remoteDriftMs}ms)`);
 			remainingConflicts.push(conflict);
 		}
 	}
@@ -1046,9 +976,9 @@ function resolveRemoteReference(filesDir, rawName) {
 	};
 }
 function sanitizeRelativePath(relativePath) {
-	const trimmed = normalizePath(relativePath.trim());
+	const trimmed = normalizePath$1(relativePath.trim());
 	const sanitized = sanitizeFilePath(SUPPORTED_EXTENSIONS.some((ext) => trimmed.toLowerCase().endsWith(ext)) ? trimmed : `${trimmed}${DEFAULT_EXTENSION}`, false);
-	const normalized = normalizePath(sanitized.path);
+	const normalized = normalizePath$1(sanitized.path);
 	return {
 		relativePath: normalized,
 		extension: sanitized.extension || path.extname(normalized) || DEFAULT_EXTENSION
@@ -1109,6 +1039,7 @@ function extractPackageFromUrl(url) {
 */
 const FETCH_TIMEOUT_MS = 6e4;
 const MAX_FETCH_RETRIES = 3;
+const MAX_CONSECUTIVE_FAILURES = 10;
 const REACT_TYPES_VERSION = "18.3.12";
 const REACT_DOM_TYPES_VERSION = "18.3.1";
 const CORE_LIBRARIES = ["framer-motion", "framer"];
@@ -1154,8 +1085,8 @@ var Installer = class {
 				finished: (files) => {
 					if (files.size > 0) debug("ATA: type acquisition complete");
 				},
-				errorMessage: (message, error$1) => {
-					warn(`ATA warning: ${message}`, error$1);
+				errorMessage: (message, error) => {
+					warn(`ATA warning: ${message}`, error);
 				},
 				receivedFile: (code, receivedPath) => {
 					(async () => {
@@ -1265,7 +1196,6 @@ var Installer = class {
 			return;
 		}
 		if (/node_modules\/@types\/[^/]+\/index\.d\.ts$/.exec(normalized)) await this.ensureTypesPackageJson(normalized);
-		if (normalized.includes("node_modules/@types/react/index.d.ts")) await this.patchReactTypes(destination);
 	}
 	async ensureTypesPackageJson(normalizedPath) {
 		const pkgMatch = /node_modules\/(@types\/[^/]+)\//.exec(normalizedPath);
@@ -1277,25 +1207,14 @@ var Installer = class {
 			const response = await fetch(`https://registry.npmjs.org/${pkgName}`);
 			if (!response.ok) return;
 			const npmData = await response.json();
-			const version$1 = npmData["dist-tags"]?.latest;
-			if (!version$1 || !npmData.versions?.[version$1]) return;
-			const pkg = npmData.versions[version$1];
+			const version = npmData["dist-tags"]?.latest;
+			if (!version || !npmData.versions?.[version]) return;
+			const pkg = npmData.versions[version];
 			if (pkg.exports) for (const key of Object.keys(pkg.exports)) pkg.exports[key] = fixExportTypes(pkg.exports[key]);
 			await fs.mkdir(pkgDir, { recursive: true });
 			await fs.writeFile(pkgJsonPath, JSON.stringify(pkg, null, 2));
 		} catch {}
 	}
-	async patchReactTypes(destination) {
-		try {
-			let content = await fs.readFile(destination, "utf-8");
-			if (content.includes("function useRef<T = undefined>()")) return;
-			const overloadPattern = /function useRef<T>\(initialValue: T \| undefined\): RefObject<T \| undefined>;/;
-			if (!content.includes("function useRef<T>(initialValue: T | undefined)")) return;
-			content = content.replace(overloadPattern, `function useRef<T>(initialValue: T | undefined): RefObject<T | undefined>;
-    function useRef<T = undefined>(): MutableRefObject<T | undefined>;`);
-			await fs.writeFile(destination, content, "utf-8");
-		} catch {}
-	}
 	async ensureTsConfig() {
 		const tsconfigPath = path.join(this.projectDir, "tsconfig.json");
 		try {
@@ -1398,11 +1317,11 @@ declare module "*.json"
 		if (await this.hasTypePackage(reactDomDir, REACT_DOM_TYPES_VERSION, reactDomFiles)) debug("📦 React DOM types (from cache)");
 		else await this.downloadTypePackage("@types/react-dom", REACT_DOM_TYPES_VERSION, reactDomDir, reactDomFiles);
 	}
-	async hasTypePackage(destinationDir, version$1, files) {
+	async hasTypePackage(destinationDir, version, files) {
 		try {
 			const pkgJsonPath = path.join(destinationDir, "package.json");
 			const pkgJson = await fs.readFile(pkgJsonPath, "utf-8");
-			if (JSON.parse(pkgJson).version !== version$1) return false;
+			if (JSON.parse(pkgJson).version !== version) return false;
 			for (const file of files) {
 				if (file === "package.json") continue;
 				await fs.access(path.join(destinationDir, file));
@@ -1412,8 +1331,8 @@ declare module "*.json"
 			return false;
 		}
 	}
-	async downloadTypePackage(pkgName, version$1, destinationDir, files) {
-		const baseUrl = `https://unpkg.com/${pkgName}@${version$1}`;
+	async downloadTypePackage(pkgName, version, destinationDir, files) {
+		const baseUrl = `https://unpkg.com/${pkgName}@${version}`;
 		await fs.mkdir(destinationDir, { recursive: true });
 		await Promise.all(files.map(async (file) => {
 			const destination = path.join(destinationDir, file);
@@ -1438,6 +1357,20 @@ function fixExportTypes(value) {
 	if ((value.import ?? value.require) && !value.types) value.types = (value.import ?? value.require)?.replace(/\.js$/, ".d.ts").replace(/\.cjs$/, ".d.cts");
 	return value;
 }
+/** Tracks consecutive network failures across all fetches */
+let consecutiveFailures = 0;
+/** Reset failure counter on successful fetch */
+function resetFailureCounter() {
+	consecutiveFailures = 0;
+}
+/** Check if we should give up due to persistent network issues */
+function checkFatalFailure(url) {
+	consecutiveFailures++;
+	if (consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
+		error(`Network unavailable - ${MAX_CONSECUTIVE_FAILURES} fetch failures.\n  Check your internet connection and try again.\n  Last failed URL: ${url}`);
+		process.exit(1);
+	}
+}
 async function fetchWithRetry(url, init, retries = MAX_FETCH_RETRIES) {
 	let urlString;
 	if (typeof url === "string") urlString = url;
@@ -1454,158 +1387,26 @@ async function fetchWithRetry(url, init, retries = MAX_FETCH_RETRIES) {
 				signal: controller.signal
 			});
 			clearTimeout(timeout);
+			resetFailureCounter();
 			return response;
 		} catch (err) {
 			clearTimeout(timeout);
-			const error$1 = err;
-			const isRetryable = error$1.cause?.code === "ECONNRESET" || error$1.cause?.code === "ETIMEDOUT" || error$1.cause?.code === "UND_ERR_CONNECT_TIMEOUT" || error$1.message.includes("timeout");
+			const error = err;
+			const isRetryable = error.cause?.code === "ECONNRESET" || error.cause?.code === "ETIMEDOUT" || error.cause?.code === "UND_ERR_CONNECT_TIMEOUT" || error.message.includes("timeout");
+			if (isRetryable) checkFatalFailure(urlString);
 			if (attempt < retries && isRetryable) {
 				const delay = attempt * 1e3;
-				warn(`Fetch failed (${error$1.cause?.code ?? error$1.message}) for ${urlString}, retrying in ${delay}ms...`);
+				warn(`Fetch failed (${error.cause?.code ?? error.message}) for ${urlString}, retrying in ${delay}ms...`);
 				await new Promise((resolve) => setTimeout(resolve, delay));
 				continue;
 			}
-			warn(`Fetch failed for ${urlString}`, error$1);
-			throw error$1;
+			warn(`Fetch failed for ${urlString}`, error);
+			throw error;
 		}
 	}
 	throw new Error(`Max retries exceeded for ${urlString}`);
 }
 
-//#endregion
-//#region src/utils/hash-tracker.ts
-/**
-* Hash tracking utilities for echo prevention
-*
-* The hash tracker prevents echo loops by remembering content hashes
-* and skipping watcher events for files we just wrote.
-*/
-/**
-* Creates a hash tracker instance for echo prevention
-*/
-function createHashTracker() {
-	const hashes = /* @__PURE__ */ new Map();
-	const pendingDeletes = /* @__PURE__ */ new Map();
-	return {
-		remember(filePath, content) {
-			const hash = hashContent(content);
-			hashes.set(filePath, hash);
-		},
-		shouldSkip(filePath, content) {
-			const currentHash = hashContent(content);
-			return hashes.get(filePath) === currentHash;
-		},
-		forget(filePath) {
-			hashes.delete(filePath);
-		},
-		clear() {
-			hashes.clear();
-		},
-		markDelete(filePath) {
-			const existingTimer = pendingDeletes.get(filePath);
-			if (existingTimer) clearTimeout(existingTimer);
-			const timeout = setTimeout(() => {
-				pendingDeletes.delete(filePath);
-			}, 5e3);
-			pendingDeletes.set(filePath, timeout);
-		},
-		shouldSkipDelete(filePath) {
-			return pendingDeletes.has(filePath);
-		},
-		clearDelete(filePath) {
-			const timeout = pendingDeletes.get(filePath);
-			if (timeout) clearTimeout(timeout);
-			pendingDeletes.delete(filePath);
-		}
-	};
-}
-/**
-* Computes a SHA256 hash of file content for comparison
-*/
-function hashContent(content) {
-	return createHash("sha256").update(content).digest("hex");
-}
-
-//#endregion
-//#region src/utils/file-metadata-cache.ts
-var FileMetadataCache = class {
-	metadata = /* @__PURE__ */ new Map();
-	persisted = /* @__PURE__ */ new Map();
-	projectDir = null;
-	initialized = false;
-	pendingPersist = null;
-	async initialize(projectDir) {
-		if (this.initialized && this.projectDir === projectDir) return;
-		this.projectDir = projectDir;
-		const loaded = await loadPersistedState(projectDir);
-		this.persisted = loaded;
-		this.metadata = /* @__PURE__ */ new Map();
-		for (const [fileName, state] of loaded.entries()) this.metadata.set(fileName, {
-			localHash: state.contentHash,
-			lastSyncedHash: state.contentHash,
-			lastRemoteTimestamp: state.timestamp
-		});
-		this.initialized = true;
-	}
-	get(fileName) {
-		return this.metadata.get(fileName);
-	}
-	has(fileName) {
-		return this.metadata.has(fileName);
-	}
-	size() {
-		return this.metadata.size;
-	}
-	getPersistedState() {
-		return this.persisted;
-	}
-	recordRemoteWrite(fileName, content, remoteModifiedAt) {
-		const contentHash = hashFileContent(content);
-		this.metadata.set(fileName, {
-			localHash: contentHash,
-			lastSyncedHash: contentHash,
-			lastRemoteTimestamp: remoteModifiedAt
-		});
-		this.persisted.set(fileName, {
-			contentHash,
-			timestamp: remoteModifiedAt
-		});
-		this.schedulePersist();
-	}
-	recordSyncedSnapshot(fileName, contentHash, remoteModifiedAt) {
-		this.metadata.set(fileName, {
-			localHash: contentHash,
-			lastSyncedHash: contentHash,
-			lastRemoteTimestamp: remoteModifiedAt
-		});
-		this.persisted.set(fileName, {
-			contentHash,
-			timestamp: remoteModifiedAt
-		});
-		this.schedulePersist();
-	}
-	recordDelete(fileName) {
-		this.metadata.delete(fileName);
-		this.persisted.delete(fileName);
-		this.schedulePersist();
-	}
-	async flush() {
-		if (this.pendingPersist) await this.pendingPersist;
-	}
-	schedulePersist() {
-		const projectDir = this.projectDir;
-		if (!projectDir) return;
-		this.pendingPersist ??= (async () => {
-			try {
-				await Promise.resolve();
-				await savePersistedState(projectDir, this.persisted);
-			} finally {
-				this.pendingPersist = null;
-			}
-		})();
-	}
-};
-
 //#endregion
 //#region src/helpers/plugin-prompts.ts
 var PluginDisconnectedError = class extends Error {
@@ -1744,6 +1545,218 @@ function validateIncomingChange(fileMeta, currentMode) {
 	};
 }
 
+//#endregion
+//#region src/helpers/watcher.ts
+/**
+* File watcher helper
+*
+* Wrapper around chokidar that normalizes file paths and filters to ts, tsx, js, json.
+*/
+/**
+* Initializes a file watcher for the given directory
+*/
+function initWatcher(filesDir) {
+	const handlers = [];
+	const watcher = chokidar.watch(filesDir, {
+		ignored: /(^|[/\\])\.\./,
+		persistent: true,
+		ignoreInitial: false
+	});
+	debug(`Watching directory: ${filesDir}`);
+	const emitEvent = async (kind, absolutePath) => {
+		if (!isSupportedExtension$1(absolutePath)) return;
+		const rawRelativePath = normalizePath$1(getRelativePath(filesDir, absolutePath));
+		const relativePath = sanitizeFilePath(rawRelativePath, false).path;
+		let effectiveAbsolutePath = absolutePath;
+		if (relativePath !== rawRelativePath && kind === "add") {
+			const newAbsolutePath = path.join(filesDir, relativePath);
+			try {
+				await fs.mkdir(path.dirname(newAbsolutePath), { recursive: true });
+				await fs.rename(absolutePath, newAbsolutePath);
+				debug(`Renamed ${rawRelativePath} -> ${relativePath}`);
+				effectiveAbsolutePath = newAbsolutePath;
+			} catch (err) {
+				warn(`Failed to rename ${rawRelativePath}`, err);
+			}
+		}
+		let content;
+		if (kind !== "delete") try {
+			content = await fs.readFile(effectiveAbsolutePath, "utf-8");
+		} catch (err) {
+			debug(`Failed to read file ${relativePath}:`, err);
+			return;
+		}
+		const event = {
+			kind,
+			relativePath,
+			content
+		};
+		debug(`Watcher event: ${kind} ${relativePath}`);
+		for (const handler of handlers) handler(event);
+	};
+	watcher.on("add", (filePath) => {
+		emitEvent("add", filePath);
+	});
+	watcher.on("change", (filePath) => {
+		emitEvent("change", filePath);
+	});
+	watcher.on("unlink", (filePath) => {
+		emitEvent("delete", filePath);
+	});
+	return {
+		on(_event, handler) {
+			handlers.push(handler);
+		},
+		async close() {
+			await watcher.close();
+		}
+	};
+}
+
+//#endregion
+//#region src/utils/file-metadata-cache.ts
+/**
+* In-memory cache on top of state-persistence.
+*/
+/** Normalize file name for case-insensitive lookup (macOS/Windows compat) */
+function normalizeKey(fileName) {
+	return fileName.toLowerCase();
+}
+var FileMetadataCache = class {
+	metadata = /* @__PURE__ */ new Map();
+	persisted = /* @__PURE__ */ new Map();
+	projectDir = null;
+	initialized = false;
+	pendingPersist = null;
+	async initialize(projectDir) {
+		if (this.initialized && this.projectDir === projectDir) return;
+		this.projectDir = projectDir;
+		const loaded = await loadPersistedState(projectDir);
+		this.persisted = loaded;
+		this.metadata = /* @__PURE__ */ new Map();
+		for (const [fileName, state] of loaded.entries()) this.metadata.set(normalizeKey(fileName), {
+			localHash: state.contentHash,
+			lastSyncedHash: state.contentHash,
+			lastRemoteTimestamp: state.timestamp
+		});
+		this.initialized = true;
+	}
+	get(fileName) {
+		return this.metadata.get(normalizeKey(fileName));
+	}
+	has(fileName) {
+		return this.metadata.has(normalizeKey(fileName));
+	}
+	size() {
+		return this.metadata.size;
+	}
+	getPersistedState() {
+		return this.persisted;
+	}
+	recordRemoteWrite(fileName, content, remoteModifiedAt) {
+		const key = normalizeKey(fileName);
+		const contentHash = hashFileContent(content);
+		this.metadata.set(key, {
+			localHash: contentHash,
+			lastSyncedHash: contentHash,
+			lastRemoteTimestamp: remoteModifiedAt
+		});
+		this.persisted.set(key, {
+			contentHash,
+			timestamp: remoteModifiedAt
+		});
+		this.schedulePersist();
+	}
+	recordSyncedSnapshot(fileName, contentHash, remoteModifiedAt) {
+		const key = normalizeKey(fileName);
+		this.metadata.set(key, {
+			localHash: contentHash,
+			lastSyncedHash: contentHash,
+			lastRemoteTimestamp: remoteModifiedAt
+		});
+		this.persisted.set(key, {
+			contentHash,
+			timestamp: remoteModifiedAt
+		});
+		this.schedulePersist();
+	}
+	recordDelete(fileName) {
+		const key = normalizeKey(fileName);
+		this.metadata.delete(key);
+		this.persisted.delete(key);
+		this.schedulePersist();
+	}
+	async flush() {
+		if (this.pendingPersist) await this.pendingPersist;
+	}
+	schedulePersist() {
+		const projectDir = this.projectDir;
+		if (!projectDir) return;
+		this.pendingPersist ??= (async () => {
+			try {
+				await Promise.resolve();
+				await savePersistedState(projectDir, this.persisted);
+			} finally {
+				this.pendingPersist = null;
+			}
+		})();
+	}
+};
+
+//#endregion
+//#region src/utils/hash-tracker.ts
+/**
+* Hash tracking utilities for echo prevention
+*
+* The hash tracker prevents echo loops by remembering content hashes
+* and skipping watcher events for files we just wrote.
+*/
+/**
+* Creates a hash tracker instance for echo prevention
+*/
+function createHashTracker() {
+	const hashes = /* @__PURE__ */ new Map();
+	const pendingDeletes = /* @__PURE__ */ new Map();
+	return {
+		remember(filePath, content) {
+			const hash = hashContent(content);
+			hashes.set(filePath, hash);
+		},
+		shouldSkip(filePath, content) {
+			const currentHash = hashContent(content);
+			return hashes.get(filePath) === currentHash;
+		},
+		forget(filePath) {
+			hashes.delete(filePath);
+		},
+		clear() {
+			hashes.clear();
+		},
+		markDelete(filePath) {
+			const existingTimer = pendingDeletes.get(filePath);
+			if (existingTimer) clearTimeout(existingTimer);
+			const timeout = setTimeout(() => {
+				pendingDeletes.delete(filePath);
+			}, 5e3);
+			pendingDeletes.set(filePath, timeout);
+		},
+		shouldSkipDelete(filePath) {
+			return pendingDeletes.has(filePath);
+		},
+		clearDelete(filePath) {
+			const timeout = pendingDeletes.get(filePath);
+			if (timeout) clearTimeout(timeout);
+			pendingDeletes.delete(filePath);
+		}
+	};
+}
+/**
+* Computes a SHA256 hash of file content for comparison
+*/
+function hashContent(content) {
+	return createHash("sha256").update(content).digest("hex");
+}
+
 //#endregion
 //#region src/utils/project.ts
 function toPackageName(name) {
@@ -1810,12 +1823,6 @@ async function matchesProject(packageJsonPath, projectHash) {
 
 //#endregion
 //#region src/controller.ts
-/**
-* CLI Controller
-*
-* All runtime state and orchestrates the sync lifecycle.
-* Helpers should provide data, nevering hold control or callbacks.
-*/
 /** Log helper */
 function log(level, message) {
 	return {
@@ -1898,9 +1905,9 @@ function transition(state, event) {
 				state,
 				effects
 			};
-		case "FILE_LIST":
+		case "REMOTE_FILE_LIST":
 			if (state.mode !== "handshaking") {
-				effects.push(log("warn", `Received FILE_LIST in mode ${state.mode}, ignoring`));
+				effects.push(log("warn", `Received REMOTE_FILE_LIST in mode ${state.mode}, ignoring`));
 				return {
 					state,
 					effects
@@ -1977,7 +1984,7 @@ function transition(state, event) {
 				effects
 			};
 		}
-		case "FILE_CHANGE": {
+		case "REMOTE_FILE_CHANGE": {
 			const validation = validateIncomingChange(event.fileMeta, state.mode);
 			if (validation.action === "queue") {
 				effects.push(log("debug", `Queueing file change: ${event.file.name} (${validation.reason})`));
@@ -2478,13 +2485,13 @@ async function start(config) {
 			case "file-list":
 				debug(`Received file list: ${message.files.length} files`);
 				event = {
-					type: "FILE_LIST",
+					type: "REMOTE_FILE_LIST",
 					files: message.files
 				};
 				break;
 			case "file-change":
 				event = {
-					type: "FILE_CHANGE",
+					type: "REMOTE_FILE_CHANGE",
 					file: {
 						name: message.fileName,
 						content: message.content,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "framer-code-link",
-  "version": "0.4.4",
+  "version": "0.4.6",
   "description": "CLI tool for syncing Framer code components - controller-centric architecture",
   "main": "dist/index.mjs",
   "type": "module",
@@ -24,7 +24,7 @@
   "dependencies": {
     "@typescript/ata": "^0.9.8",
     "chokidar": "^5.0.0",
-    "commander": "^14.0.2",
+    "commander": "^14.0.3",
     "prettier": "^3.7.4",
     "typescript": "^5.9.3",
     "ws": "^8.18.3"
@@ -33,7 +33,7 @@
     "@code-link/shared": "1.0.0",
     "@types/node": "^22.19.2",
     "@types/ws": "^8.18.1",
-    "tsdown": "^0.17.4",
+    "tsdown": "^0.20.1",
     "tsx": "^4.21.0",
     "vitest": "^4.0.15"
   }