electron-pinia-sync 1.0.0

package/dist/main/index.js

@@ -0,0 +1,221 @@
+import { ipcMain, BrowserWindow } from 'electron';
+import { createPinia } from 'pinia';
+import Store from 'electron-store';
+
+// src/main/index.ts
+
+// src/types.ts
+var IPC_CHANNELS = {
+  /** Renderer requests initial state from Main */
+  STATE_PULL: "pinia-sync:state-pull",
+  /** Renderer sends patch to Main */
+  STATE_PATCH: "pinia-sync:state-patch",
+  /** Main broadcasts state update to all Renderers */
+  STATE_UPDATED: "pinia-sync:state-updated"};
+
+// src/debug.ts
+function createDebugLogger(namespace, debugLevel = false, customLogger) {
+  const isEnabled = debugLevel !== false;
+  const isVerbose = debugLevel === "verbose" || debugLevel === true;
+  const prefix = `[${namespace}]`;
+  const noop = () => {
+  };
+  const logger = customLogger || console;
+  return {
+    log: logger.log?.bind(logger, prefix) || console.log.bind(console, prefix),
+    warn: logger.warn?.bind(logger, prefix) || console.warn.bind(console, prefix),
+    error: logger.error?.bind(logger, prefix) || console.error.bind(console, prefix),
+    debug: isEnabled ? logger.log?.bind(logger, prefix) || console.log.bind(console, prefix) : noop,
+    verbose: isVerbose ? logger.log?.bind(logger, `${prefix}[VERBOSE]`) || console.log.bind(console, `${prefix}[VERBOSE]`) : noop
+  };
+}
+function formatStateForDebug(state, maxLength = 200) {
+  try {
+    const json = JSON.stringify(state);
+    if (json.length > maxLength) {
+      return json.substring(0, maxLength) + `... (${json.length} chars total)`;
+    }
+    return json;
+  } catch {
+    return "[Circular or non-serializable]";
+  }
+}
+function formatPatchForDebug(patch) {
+  try {
+    const keys = Object.keys(patch);
+    if (keys.length === 0) {
+      return "{}";
+    }
+    if (keys.length > 5) {
+      return `{ ${keys.slice(0, 5).join(", ")}, ... (${keys.length} keys) }`;
+    }
+    return JSON.stringify(patch, null, 2);
+  } catch {
+    return "[Invalid patch]";
+  }
+}
+
+// src/utils/toRawState.ts
+function toRawState(state) {
+  return JSON.parse(JSON.stringify(state));
+}
+
+// src/main/index.ts
+var MainSync = class {
+  pinia;
+  electronStore;
+  storeMetadata = /* @__PURE__ */ new Map();
+  processingTransactions = /* @__PURE__ */ new Set();
+  MAX_TRANSACTION_HISTORY = 100;
+  debug;
+  constructor(options = {}) {
+    this.debug = createDebugLogger("electron-pinia-sync:main", options.debug ?? false, options.logger);
+    this.debug.debug("Initializing MainSync");
+    this.pinia = options.pinia ?? createPinia();
+    this.electronStore = new Store({
+      name: "pinia-sync-store",
+      ...options.storeOptions
+    });
+    this.debug.verbose("electron-store initialized with options:", options.storeOptions);
+    this.setupIpcHandlers();
+    this.debug.debug("MainSync initialized successfully");
+  }
+  /**
+   * Get the Pinia instance managed by this sync manager
+   */
+  getPinia() {
+    return this.pinia;
+  }
+  /**
+   * Register a store with the sync manager
+   */
+  registerStore(storeId, store, options = {}) {
+    this.debug.debug(`Registering store: ${storeId}`);
+    const persistConfig = this.normalizePersistOptions(options.persist);
+    this.storeMetadata.set(storeId, {
+      persist: persistConfig
+    });
+    if (persistConfig) {
+      const key = persistConfig.key ?? storeId;
+      const persistedState = this.electronStore.get(key);
+      if (persistedState) {
+        this.debug.verbose(`Loading persisted state for ${storeId}:`, formatStateForDebug(persistedState));
+        store.$patch(persistedState);
+      } else {
+        this.debug.verbose(`No persisted state found for ${storeId}`);
+      }
+    }
+    store.$subscribe((_mutation, state) => {
+      this.debug.verbose(`Store ${storeId} changed:`, formatStateForDebug(state));
+      const serializedState = toRawState(state);
+      if (persistConfig) {
+        const key = persistConfig.key ?? storeId;
+        this.electronStore.set(key, serializedState);
+        this.debug.verbose(`Persisted state for ${storeId} to key: ${key}`);
+      }
+      this.broadcastStateUpdate(storeId, serializedState);
+    }, { detached: true });
+    this.debug.debug(`Store ${storeId} registered successfully (persist: ${!!persistConfig})`);
+  }
+  /**
+   * Normalize persist options to standard format
+   */
+  normalizePersistOptions(persist) {
+    if (persist === true) {
+      return { enabled: true };
+    } else if (persist === false || persist === void 0) {
+      return false;
+    } else {
+      return persist;
+    }
+  }
+  /**
+   * Setup IPC handlers for communication with renderers
+   */
+  setupIpcHandlers() {
+    this.debug.debug("Setting up IPC handlers");
+    ipcMain.handle(
+      IPC_CHANNELS.STATE_PULL,
+      async (_event, request) => {
+        this.debug.debug(`IPC handler called: STATE_PULL for store: ${request.storeId}`);
+        const store = this.pinia._s.get(request.storeId);
+        if (store) {
+          this.debug.verbose(`Sending state for ${request.storeId}:`, formatStateForDebug(store.$state));
+        } else {
+          this.debug.warn(`Store "${request.storeId}" not found in Main process`);
+        }
+        return {
+          storeId: request.storeId,
+          state: store ? toRawState(store.$state) : null
+        };
+      }
+    );
+    this.debug.debug(`IPC handler registered: ${IPC_CHANNELS.STATE_PULL}`);
+    ipcMain.handle(
+      IPC_CHANNELS.STATE_PATCH,
+      async (_event, message) => {
+        this.debug.debug(`IPC handler called: STATE_PATCH for store: ${message.storeId}, transaction: ${message.transactionId}`);
+        this.debug.verbose(`Patch data:`, formatPatchForDebug(message.patch));
+        const store = this.pinia._s.get(message.storeId);
+        if (!store) {
+          this.debug.warn(`Store "${message.storeId}" not found in Main process`);
+          return;
+        }
+        this.addTransaction(message.transactionId);
+        try {
+          store.$patch(message.patch);
+          this.debug.debug(`Successfully applied patch to store: ${message.storeId}`);
+        } catch (error) {
+          this.debug.error(`Failed to patch store "${message.storeId}":`, error);
+        }
+      }
+    );
+    this.debug.debug(`IPC handler registered: ${IPC_CHANNELS.STATE_PATCH}`);
+    this.debug.debug("IPC handlers setup complete");
+  }
+  addTransaction(id) {
+    this.processingTransactions.add(id);
+    if (this.processingTransactions.size > this.MAX_TRANSACTION_HISTORY) {
+      const first = this.processingTransactions.values().next().value;
+      if (first) this.processingTransactions.delete(first);
+    }
+    setTimeout(() => this.processingTransactions.delete(id), 5e3);
+  }
+  /**
+   * Broadcast state update to all renderer processes
+   */
+  broadcastStateUpdate(storeId, state, transactionId) {
+    this.debug.verbose(`Broadcasting state update for store: ${storeId}`, transactionId ? `(transaction: ${transactionId})` : "");
+    const message = {
+      storeId,
+      state,
+      transactionId
+    };
+    const windows = BrowserWindow.getAllWindows();
+    this.debug.verbose(`Broadcasting to ${windows.length} window(s)`);
+    windows.forEach((window, index) => {
+      if (!window.isDestroyed()) {
+        this.debug.verbose(`Sending ${IPC_CHANNELS.STATE_UPDATED} to window ${index + 1}`);
+        window.webContents.send(IPC_CHANNELS.STATE_UPDATED, message);
+      } else {
+        this.debug.verbose(`Skipping destroyed window ${index + 1}`);
+      }
+    });
+    this.debug.debug(`Broadcast complete for store: ${storeId}`);
+  }
+  /**
+   * Cleanup IPC handlers
+   */
+  destroy() {
+    this.debug.debug("Destroying MainSync, cleaning up IPC handlers");
+    ipcMain.removeHandler(IPC_CHANNELS.STATE_PULL);
+    ipcMain.removeHandler(IPC_CHANNELS.STATE_PATCH);
+    this.debug.debug("MainSync destroyed");
+  }
+};
+function createMainSync(options) {
+  return new MainSync(options);
+}
+console.log("main sync plugin loaded");
+
+export { MainSync, createDebugLogger, createMainSync, formatPatchForDebug, formatStateForDebug };

package/dist/preload/index.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/preload/index.js

@@ -0,0 +1,60 @@
+import { contextBridge, ipcRenderer } from 'electron';
+
+// src/preload/index.ts
+
+// src/types.ts
+var IPC_CHANNELS = {
+  /** Renderer requests initial state from Main */
+  STATE_PULL: "pinia-sync:state-pull",
+  /** Renderer sends patch to Main */
+  STATE_PATCH: "pinia-sync:state-patch",
+  /** Main broadcasts state update to all Renderers */
+  STATE_UPDATED: "pinia-sync:state-updated"};
+
+// src/preload/index.ts
+var piniaSyncAPI = {
+  /**
+   * Pull initial state from Main process
+   */
+  async pullState(storeId) {
+    console.log(`[preload] IPC invoke: ${IPC_CHANNELS.STATE_PULL} for store "${storeId}"`);
+    const request = { storeId };
+    const response = await ipcRenderer.invoke(
+      IPC_CHANNELS.STATE_PULL,
+      request
+    );
+    console.log(`[preload] IPC response: STATE_PULL for "${storeId}" - state:`, response.state ? "received" : "null");
+    return response.state;
+  },
+  /**
+   * Send state patch to Main process
+   */
+  async patchState(storeId, patch, transactionId) {
+    console.log(`[preload] IPC invoke: ${IPC_CHANNELS.STATE_PATCH} for store "${storeId}", transaction: ${transactionId}`);
+    const message = {
+      storeId,
+      patch,
+      transactionId
+    };
+    await ipcRenderer.invoke(IPC_CHANNELS.STATE_PATCH, message);
+    console.log(`[preload] IPC response: STATE_PATCH for "${storeId}" completed`);
+  },
+  /**
+   * Subscribe to state updates from Main process
+   */
+  onStateUpdate(callback) {
+    console.log(`[preload] IPC listener registered: ${IPC_CHANNELS.STATE_UPDATED}`);
+    const listener = (_event, message) => {
+      console.log(`[preload] IPC event received: ${IPC_CHANNELS.STATE_UPDATED} for store "${message.storeId}", transaction: ${message.transactionId || "none"}`);
+      callback(message);
+    };
+    ipcRenderer.on(IPC_CHANNELS.STATE_UPDATED, listener);
+    return () => {
+      console.log(`[preload] IPC listener removed: ${IPC_CHANNELS.STATE_UPDATED}`);
+      ipcRenderer.removeListener(IPC_CHANNELS.STATE_UPDATED, listener);
+    };
+  }
+};
+contextBridge.exposeInMainWorld("piniaSync", piniaSyncAPI);
+console.log("[preload] piniaSync API exposed to window");
+console.log("[preload] electron-pinia-sync preload script initialized");

package/dist/renderer/index.d.ts

@@ -0,0 +1,123 @@
+import { StateTree, PiniaPluginContext } from 'pinia';
+
+/**
+ * Common types shared across Main, Renderer, and Preload processes
+ */
+
+/**
+ * Debug level configuration
+ */
+type DebugLevel$1 = boolean | 'verbose' | 'minimal';
+/**
+ * Message sent from Main to Renderer when state is updated
+ */
+interface StateUpdateMessage {
+    /** Store ID */
+    storeId: string;
+    /** New state */
+    state: StateTree;
+    /** Transaction ID that caused this update (if any) */
+    transactionId?: string;
+}
+/**
+ * Options for configuring store persistence
+ */
+interface PersistOptions {
+    /** Whether to persist this store to disk */
+    enabled: boolean;
+    /** Optional custom key for electron-store (defaults to storeId) */
+    key?: string;
+}
+/**
+ * Extended Pinia store options with persistence support
+ */
+interface SyncStoreOptions {
+    /** Persistence configuration */
+    persist?: boolean | PersistOptions;
+}
+/**
+ * API exposed to Renderer via contextBridge
+ */
+interface PiniaSyncAPI {
+    /**
+     * Pull initial state from Main process
+     */
+    pullState: (storeId: string) => Promise<StateTree | null>;
+    /**
+     * Send state patch to Main process
+     */
+    patchState: (storeId: string, patch: Partial<StateTree>, transactionId: string) => Promise<void>;
+    /**
+     * Subscribe to state updates from Main process
+     */
+    onStateUpdate: (callback: (message: StateUpdateMessage) => void) => () => void;
+}
+declare global {
+    interface Window {
+        piniaSync?: PiniaSyncAPI;
+    }
+}
+
+/**
+ * Debug utilities for electron-pinia-sync
+ *
+ * Enable debug logging programmatically:
+ * - { debug: true } - enable debug logging
+ * - { debug: 'verbose' } - enable verbose logging with state diffs
+ * - { debug: 'minimal' } - only log errors and warnings
+ */
+type DebugLevel = boolean | 'verbose' | 'minimal';
+interface DebugLogger {
+    log: (message: string, ...args: unknown[]) => void;
+    warn: (message: string, ...args: unknown[]) => void;
+    error: (message: string, ...args: unknown[]) => void;
+    debug: (message: string, ...args: unknown[]) => void;
+    verbose: (message: string, ...args: unknown[]) => void;
+}
+/**
+ * Create a debug logger for a specific namespace
+ */
+declare function createDebugLogger(namespace: string, debugLevel?: DebugLevel, customLogger?: Partial<DebugLogger>): DebugLogger;
+/**
+ * Format state for debug output (truncate large objects)
+ */
+declare function formatStateForDebug(state: unknown, maxLength?: number): string;
+/**
+ * Format patch for debug output
+ */
+declare function formatPatchForDebug(patch: unknown): string;
+
+/**
+ * Options for the renderer sync plugin
+ */
+interface RendererSyncOptions {
+    /**
+     * Enable debug logging
+     * - true: enable debug logging
+     * - 'verbose': enable verbose logging with state diffs
+     * - 'minimal': only log errors and warnings
+     * - false: disable debug logging (default)
+     */
+    debug?: DebugLevel$1;
+    /**
+     * Custom logger (default: console)
+     */
+    logger?: Partial<DebugLogger>;
+    /**
+     * Custom API implementation (for testing)
+     * @internal
+     */
+    customApi?: PiniaSyncAPI;
+}
+
+/**
+ * Renderer process Pinia plugin
+ * Synchronizes local store changes with Main process and receives updates
+ */
+
+/**
+ * Create the Pinia plugin for renderer process synchronization
+ */
+declare function createRendererSync(options?: RendererSyncOptions): (context: PiniaPluginContext) => void;
+
+export { type DebugLevel, type DebugLogger, type SyncStoreOptions, createDebugLogger, createRendererSync, formatPatchForDebug, formatStateForDebug };

package/dist/renderer/index.js

@@ -0,0 +1,199 @@
+import diff from 'microdiff';
+
+// src/renderer/index.ts
+
+// src/debug.ts
+function createDebugLogger(namespace, debugLevel = false, customLogger) {
+  const isEnabled = debugLevel !== false;
+  const isVerbose = debugLevel === "verbose" || debugLevel === true;
+  const prefix = `[${namespace}]`;
+  const noop = () => {
+  };
+  const logger = customLogger || console;
+  return {
+    log: logger.log?.bind(logger, prefix) || console.log.bind(console, prefix),
+    warn: logger.warn?.bind(logger, prefix) || console.warn.bind(console, prefix),
+    error: logger.error?.bind(logger, prefix) || console.error.bind(console, prefix),
+    debug: isEnabled ? logger.log?.bind(logger, prefix) || console.log.bind(console, prefix) : noop,
+    verbose: isVerbose ? logger.log?.bind(logger, `${prefix}[VERBOSE]`) || console.log.bind(console, `${prefix}[VERBOSE]`) : noop
+  };
+}
+function formatStateForDebug(state, maxLength = 200) {
+  try {
+    const json = JSON.stringify(state);
+    if (json.length > maxLength) {
+      return json.substring(0, maxLength) + `... (${json.length} chars total)`;
+    }
+    return json;
+  } catch {
+    return "[Circular or non-serializable]";
+  }
+}
+function formatPatchForDebug(patch) {
+  try {
+    const keys = Object.keys(patch);
+    if (keys.length === 0) {
+      return "{}";
+    }
+    if (keys.length > 5) {
+      return `{ ${keys.slice(0, 5).join(", ")}, ... (${keys.length} keys) }`;
+    }
+    return JSON.stringify(patch, null, 2);
+  } catch {
+    return "[Invalid patch]";
+  }
+}
+
+// src/utils/toRawState.ts
+function toRawState(state) {
+  return JSON.parse(JSON.stringify(state));
+}
+
+// src/renderer/index.ts
+function generateTransactionId() {
+  return `${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+}
+function calculatePatch(oldState, newState, mutation) {
+  const differences = diff(oldState, newState);
+  if (differences.length === 0) {
+    return extractPatchFromMutation(mutation, newState);
+  }
+  const patch = {};
+  for (const change of differences) {
+    if (change.path.length === 0) {
+      return newState;
+    }
+    const topLevelKey = change.path[0];
+    if (typeof topLevelKey === "string" || typeof topLevelKey === "number") {
+      patch[topLevelKey] = newState[topLevelKey];
+    }
+  }
+  return Object.keys(patch).length > 0 ? patch : extractPatchFromMutation(mutation, newState);
+}
+function extractPatchFromMutation(mutation, state) {
+  if (mutation.type === "patch object") {
+    return mutation.payload;
+  } else if (mutation.type === "patch function") {
+    return state;
+  } else if (mutation.type === "direct") {
+    const patch = {};
+    const events = mutation.events;
+    if (events && Array.isArray(events) && events.length > 0) {
+      const firstEvent = events[0];
+      const key = firstEvent?.key;
+      if (typeof key === "string" && key in state) {
+        patch[key] = state[key];
+        return patch;
+      }
+    }
+    return state;
+  } else {
+    return state;
+  }
+}
+function createRendererSync(options = {}) {
+  const debug = createDebugLogger("electron-pinia-sync:renderer", options.debug ?? false, options.logger);
+  debug.debug("Initializing RendererSync");
+  let api = options.customApi;
+  if (!api) {
+    if (typeof window !== "undefined" && window.piniaSync) {
+      api = window.piniaSync;
+    } else if (typeof globalThis !== "undefined" && globalThis.window?.piniaSync) {
+      api = globalThis.window.piniaSync;
+    }
+  }
+  if (!api) {
+    debug.error("window.piniaSync is not available. Make sure the preload script is loaded correctly.");
+    throw new Error("Pinia sync API not available");
+  }
+  debug.debug("Pinia sync API found");
+  const processingTransactions = /* @__PURE__ */ new Set();
+  return function rendererSyncPlugin(context) {
+    const { store } = context;
+    debug.debug(`Initializing sync for store: ${store.$id}`);
+    let isApplyingRemoteUpdate = false;
+    let previousState = toRawState(store.$state);
+    const initializeState = async () => {
+      debug.debug(`Pulling initial state for store: ${store.$id}`);
+      try {
+        const state = await api.pullState(store.$id);
+        if (state !== null) {
+          debug.verbose(`Received initial state for ${store.$id}:`, formatStateForDebug(state));
+          isApplyingRemoteUpdate = true;
+          store.$patch(state);
+          previousState = toRawState(store.$state);
+          isApplyingRemoteUpdate = false;
+          debug.debug(`Successfully initialized state for store: ${store.$id}`);
+        } else {
+          debug.debug(`No initial state available for store: ${store.$id}`);
+        }
+      } catch (error) {
+        debug.error(`Failed to pull initial state for store "${store.$id}":`, error);
+      }
+    };
+    const subscribeToLocalChanges = () => {
+      debug.debug(`Subscribing to local changes for store: ${store.$id}`);
+      store.$subscribe((mutation, state) => {
+        if (isApplyingRemoteUpdate) {
+          debug.verbose(`Skipping sync for ${store.$id} (applying remote update)`);
+          return;
+        }
+        debug.verbose(`Local state changed for ${store.$id}, mutation type: ${mutation.type}`);
+        const patch = calculatePatch(previousState, state, mutation);
+        previousState = toRawState(state);
+        if (Object.keys(patch).length === 0) {
+          debug.verbose(`No changes detected for ${store.$id}, skipping sync`);
+          return;
+        }
+        debug.verbose(`Calculated patch for ${store.$id}:`, formatPatchForDebug(patch));
+        const transactionId = generateTransactionId();
+        debug.debug(`Syncing patch to Main (transaction: ${transactionId})`);
+        processingTransactions.add(transactionId);
+        const rawPatch = toRawState(patch);
+        api.patchState(store.$id, rawPatch, transactionId).catch((error) => {
+          debug.error(`Failed to sync state for store "${store.$id}":`, error);
+        }).finally(() => {
+          setTimeout(() => {
+            processingTransactions.delete(transactionId);
+          }, 100);
+        });
+      }, { detached: true });
+    };
+    const subscribeToRemoteUpdates = () => {
+      debug.debug(`Subscribing to remote updates for store: ${store.$id}`);
+      const unsubscribe = api.onStateUpdate((message) => {
+        if (message.storeId !== store.$id) {
+          return;
+        }
+        debug.verbose(`Received remote update for ${store.$id}`, message.transactionId ? `(transaction: ${message.transactionId})` : "");
+        if (message.transactionId && processingTransactions.has(message.transactionId)) {
+          debug.verbose(`Skipping echo update for ${store.$id} (transaction: ${message.transactionId})`);
+          return;
+        }
+        debug.verbose(`Applying remote state to ${store.$id}:`, formatStateForDebug(message.state));
+        isApplyingRemoteUpdate = true;
+        store.$patch(message.state);
+        previousState = toRawState(store.$state);
+        isApplyingRemoteUpdate = false;
+        debug.debug(`Successfully applied remote update to store: ${store.$id}`);
+      });
+      store._piniaSync_unsubscribe = unsubscribe;
+    };
+    debug.debug(`Initializing store synchronization for: ${store.$id}`);
+    initializeState();
+    subscribeToLocalChanges();
+    subscribeToRemoteUpdates();
+    debug.debug(`Store ${store.$id} sync setup complete`);
+    const originalDispose = store.$dispose.bind(store);
+    store.$dispose = () => {
+      debug.debug(`Disposing store: ${store.$id}`);
+      const unsubscribe = store._piniaSync_unsubscribe;
+      if (unsubscribe) {
+        unsubscribe();
+      }
+      originalDispose();
+    };
+  };
+}
+
+export { createDebugLogger, createRendererSync, formatPatchForDebug, formatStateForDebug };

package/package.json

@@ -0,0 +1,86 @@
+{
+  "name": "electron-pinia-sync",
+  "version": "1.0.0",
+  "description": "A comprehensive Pinia plugin for Electron that synchronizes store states across multiple windows via IPC and provides seamless persistence through electron-store.",
+  "license": "MIT",
+  "author": "simpli.fyi",
+  "website": "https://simpli.fyi",
+  "keywords": [
+    "electron",
+    "pinia",
+    "vue",
+    "state-management",
+    "synchronization",
+    "ipc",
+    "persistence"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/simpli-fyi/electron-pinia-sync.git"
+  },
+  "type": "module",
+  "packageManager": "npm@10.9.0",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "exports": {
+    "./main": {
+      "types": "./dist/main/index.d.ts",
+      "import": "./dist/main/index.js"
+    },
+    "./preload": {
+      "types": "./dist/preload/index.d.ts",
+      "import": "./dist/preload/index.js"
+    },
+    "./renderer": {
+      "types": "./dist/renderer/index.d.ts",
+      "import": "./dist/renderer/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "CONTRIBUTING.md"
+  ],
+  "scripts": {
+    "build": "npm run clean && npm run build:main && npm run build:renderer && npm run build:preload",
+    "build:main": "tsup src/main/index.ts --format esm --dts --outDir dist/main",
+    "build:preload": "tsup src/preload/index.ts --format esm --dts --outDir dist/preload",
+    "build:renderer": "tsup src/renderer/index.ts --format esm --dts --outDir dist/renderer",
+    "clean": "rm -rf dist",
+    "dev": "npm run build --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "test:e2e": "playwright test",
+    "lint": "eslint src",
+    "lint:fix": "eslint src --fix",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build && npm run test && npm run typecheck"
+  },
+  "peerDependencies": {
+    "electron": ">=40.0.0",
+    "pinia": ">=3.0.0",
+    "vue": ">=3.5.0"
+  },
+  "dependencies": {
+    "electron-store": "^11.0.0",
+    "microdiff": "^1.5.0"
+  },
+  "devDependencies": {
+    "@playwright/test": "^1.58.0",
+    "@types/node": "^25.1.0",
+    "@vitest/coverage-v8": "^4.0.0",
+    "electron": "^40.1.0",
+    "eslint": "^9.39.0",
+    "pinia": "^3.0.0",
+    "playwright": "^1.58.0",
+    "tsup": "^8.5.0",
+    "tsx": "^4.21.0",
+    "typescript": "^5.7.0",
+    "typescript-eslint": "^8.32.0",
+    "vitest": "^4.0.0",
+    "vue": "^3.5.0"
+  }
+}