electron-state-sync 1.1.0

package/dist/solid.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"solid.js","names":[],"sources":["../src/renderer/solid.ts"],"sourcesContent":["import { createSignal, onCleanup, onMount, type Accessor } from \"solid-js\";\n\nimport type { SyncStateChannelOptions } from \"../channels\";\nimport type { SyncStateBridge } from \"../types\";\nimport { resolveSyncStateBridge } from \"./bridge\";\nimport { getGlobalConfig } from \"./index\";\n\nexport interface UseSyncStateSolidOptions extends SyncStateChannelOptions {\n  bridge?: SyncStateBridge;\n}\n\n// Solid Setter type\nexport type SyncStateSolidSetter<StateValue> = (\n  value: StateValue | ((prev: StateValue) => StateValue),\n) => StateValue;\n\n// Solid Hook return type\nexport type UseSyncStateSolidResult<StateValue> = readonly [\n  Accessor<StateValue>,\n  SyncStateSolidSetter<StateValue>,\n  Accessor<boolean>,\n];\n\n// Remote update tracker\ninterface RemoteUpdateTracker<StateValue> {\n  // Apply main process update\n  applyRemoteValue: (value: StateValue) => void;\n  // Check if should skip local sync\n  shouldSkipLocalSync: () => boolean;\n}\n\nconst createChannelOptions = (options: UseSyncStateSolidOptions): SyncStateChannelOptions => {\n  const globalConfig = getGlobalConfig();\n  return {\n    baseChannel: options.baseChannel ?? globalConfig.baseChannel,\n    name: options.name,\n  };\n};\n\nconst createRemoteUpdateTracker = <StateValue>(\n  setState: (value: StateValue) => StateValue,\n  setIsSynced: (value: boolean) => void,\n): RemoteUpdateTracker<StateValue> => {\n  // Whether update is from main process\n  let isRemoteUpdate = false;\n\n  const applyRemoteValue = (value: StateValue): void => {\n    isRemoteUpdate = true;\n    setState(value);\n    // Mark first sync as completed\n    setIsSynced(true);\n    // Reset immediately since Solid doesn't have a watch that consumes this synchronously\n    isRemoteUpdate = false;\n  };\n\n  const shouldSkipLocalSync = (): boolean => {\n    if (!isRemoteUpdate) {\n      return false;\n    }\n    isRemoteUpdate = false;\n    return true;\n  };\n\n  return {\n    applyRemoteValue,\n    shouldSkipLocalSync,\n  };\n};\n\n// Sync Setter options\ninterface SyncSetterOptions<StateValue> {\n  accessor: Accessor<StateValue>;\n  setState: (value: StateValue) => StateValue;\n  bridge: SyncStateBridge;\n  channelOptions: SyncStateChannelOptions;\n  tracker: RemoteUpdateTracker<StateValue>;\n}\n\nconst createSyncSetter =\n  <StateValue>(options: SyncSetterOptions<StateValue>): SyncStateSolidSetter<StateValue> =>\n  (value: StateValue | ((prev: StateValue) => StateValue)) => {\n    const { accessor, bridge, channelOptions, setState, tracker } = options;\n    let nextValue = value as StateValue;\n\n    if (typeof value === \"function\") {\n      nextValue = (value as (prev: StateValue) => StateValue)(accessor());\n    }\n\n    if (tracker.shouldSkipLocalSync()) {\n      return setState(nextValue);\n    }\n\n    const resultValue = setState(nextValue);\n    void bridge.set(channelOptions, nextValue);\n    return resultValue;\n  };\n\nexport const useSyncState = <StateValue>(\n  initialValue: StateValue,\n  options: UseSyncStateSolidOptions,\n): UseSyncStateSolidResult<StateValue> => {\n  const [rawStateValue, rawSetStateValue] = createSignal<StateValue>(initialValue as StateValue);\n  const stateValue = rawStateValue as Accessor<StateValue>;\n  // First sync completion flag\n  const [isSynced, setIsSynced] = createSignal(false);\n  const setStateValue = (value: StateValue): StateValue => {\n    (rawSetStateValue as (nextValue: StateValue) => void)(value);\n    return value;\n  };\n  const globalConfig = getGlobalConfig();\n  const bridge = resolveSyncStateBridge(options.bridge ?? globalConfig.bridge);\n  const channelOptions = createChannelOptions(options);\n  const tracker = createRemoteUpdateTracker(setStateValue, setIsSynced);\n  const setAndSync = createSyncSetter<StateValue>({\n    accessor: stateValue,\n    bridge,\n    channelOptions,\n    setState: setStateValue,\n    tracker,\n  });\n\n  onMount(() => {\n    const unsubscribe = bridge.subscribe(channelOptions, tracker.applyRemoteValue);\n    void bridge.get<StateValue>(channelOptions).then(tracker.applyRemoteValue);\n\n    onCleanup(() => {\n      unsubscribe();\n    });\n  });\n\n  return [stateValue, setAndSync, isSynced] as const;\n};\n\n// Backward compatibility alias\nexport { useSyncState as useSyncStateSolid };\n"],"mappings":";;;;AA+BA,MAAM,wBAAwB,YAA+D;CAC3F,MAAM,eAAe,iBAAiB;AACtC,QAAO;EACL,aAAa,QAAQ,eAAe,aAAa;EACjD,MAAM,QAAQ;EACf;;AAGH,MAAM,6BACJ,UACA,gBACoC;CAEpC,IAAI,iBAAiB;CAErB,MAAM,oBAAoB,UAA4B;AACpD,mBAAiB;AACjB,WAAS,MAAM;AAEf,cAAY,KAAK;AAEjB,mBAAiB;;CAGnB,MAAM,4BAAqC;AACzC,MAAI,CAAC,eACH,QAAO;AAET,mBAAiB;AACjB,SAAO;;AAGT,QAAO;EACL;EACA;EACD;;AAYH,MAAM,oBACS,aACZ,UAA2D;CAC1D,MAAM,EAAE,UAAU,QAAQ,gBAAgB,UAAU,YAAY;CAChE,IAAI,YAAY;AAEhB,KAAI,OAAO,UAAU,WACnB,aAAa,MAA2C,UAAU,CAAC;AAGrE,KAAI,QAAQ,qBAAqB,CAC/B,QAAO,SAAS,UAAU;CAG5B,MAAM,cAAc,SAAS,UAAU;AACvC,CAAK,OAAO,IAAI,gBAAgB,UAAU;AAC1C,QAAO;;AAGX,MAAa,gBACX,cACA,YACwC;CACxC,MAAM,CAAC,eAAe,oBAAoB,aAAyB,aAA2B;CAC9F,MAAM,aAAa;CAEnB,MAAM,CAAC,UAAU,eAAe,aAAa,MAAM;CACnD,MAAM,iBAAiB,UAAkC;AACvD,EAAC,iBAAqD,MAAM;AAC5D,SAAO;;CAET,MAAM,eAAe,iBAAiB;CACtC,MAAM,SAAS,uBAAuB,QAAQ,UAAU,aAAa,OAAO;CAC5E,MAAM,iBAAiB,qBAAqB,QAAQ;CACpD,MAAM,UAAU,0BAA0B,eAAe,YAAY;CACrE,MAAM,aAAa,iBAA6B;EAC9C,UAAU;EACV;EACA;EACA,UAAU;EACV;EACD,CAAC;AAEF,eAAc;EACZ,MAAM,cAAc,OAAO,UAAU,gBAAgB,QAAQ,iBAAiB;AAC9E,EAAK,OAAO,IAAgB,eAAe,CAAC,KAAK,QAAQ,iBAAiB;AAE1E,kBAAgB;AACd,gBAAa;IACb;GACF;AAEF,QAAO;EAAC;EAAY;EAAY;EAAS"}

package/dist/svelte.cjs

@@ -0,0 +1,63 @@
+const require_renderer = require('./renderer-D3YziJ_U.cjs');
+let svelte_store = require("svelte/store");
+
+//#region src/renderer/svelte.ts
+const createChannelOptions = (options) => {
+	const globalConfig = require_renderer.getGlobalConfig();
+	return {
+		baseChannel: options.baseChannel ?? globalConfig.baseChannel,
+		name: options.name
+	};
+};
+const createRemoteUpdateTracker = (setStoreValue, isSynced) => {
+	let isRemoteUpdate = false;
+	const applyRemoteValue = (value) => {
+		isRemoteUpdate = true;
+		setStoreValue(value);
+		isSynced.set(true);
+		isRemoteUpdate = false;
+	};
+	const shouldSkipLocalSync = () => {
+		if (!isRemoteUpdate) return false;
+		isRemoteUpdate = false;
+		return true;
+	};
+	return {
+		applyRemoteValue,
+		shouldSkipLocalSync
+	};
+};
+const useSyncState = (initialValue, options) => {
+	const globalConfig = require_renderer.getGlobalConfig();
+	const bridge = require_renderer.resolveSyncStateBridge(options.bridge ?? globalConfig.bridge);
+	const channelOptions = createChannelOptions(options);
+	const isSynced = (0, svelte_store.writable)(false);
+	let tracker = void 0;
+	const store = (0, svelte_store.writable)(initialValue, (setStoreValue) => {
+		tracker = createRemoteUpdateTracker(setStoreValue, isSynced);
+		const unsubscribe = bridge.subscribe(channelOptions, tracker.applyRemoteValue);
+		bridge.get(channelOptions).then(tracker.applyRemoteValue);
+		return () => {
+			unsubscribe();
+			tracker = void 0;
+		};
+	});
+	const set = (value) => {
+		if (tracker?.shouldSkipLocalSync()) return;
+		store.set(value);
+		bridge.set(channelOptions, value);
+	};
+	const update = (updater) => {
+		set(updater((0, svelte_store.get)(store)));
+	};
+	return {
+		isSynced,
+		set,
+		subscribe: store.subscribe,
+		update
+	};
+};
+
+//#endregion
+exports.createSyncStateStore = useSyncState;
+exports.useSyncState = useSyncState;

package/dist/svelte.d.cts

@@ -0,0 +1,14 @@
+import { a as SyncStateChannelOptions, t as SyncStateBridge } from "./types-C18dHgLI.cjs";
+import { Readable, Writable } from "svelte/store";
+
+//#region src/renderer/svelte.d.ts
+interface SyncStateSvelteOptions extends SyncStateChannelOptions {
+  bridge?: SyncStateBridge;
+}
+interface SyncStateStore<StateValue> extends Writable<StateValue> {
+  isSynced: Readable<boolean>;
+}
+declare const useSyncState: <StateValue>(initialValue: StateValue, options: SyncStateSvelteOptions) => SyncStateStore<StateValue>;
+//#endregion
+export { SyncStateStore, SyncStateSvelteOptions, useSyncState as createSyncStateStore, useSyncState };
+//# sourceMappingURL=svelte.d.cts.map

package/dist/svelte.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"svelte.d.cts","names":[],"sources":["../src/renderer/svelte.ts"],"sourcesContent":[],"mappings":";;;;UAOiB,sBAAA,SAA+B;EAA/B,MAAA,CAAA,EACN,eADM;AASjB;AAA6D,UAA5C,cAA4C,CAAA,UAAA,CAAA,SAAT,QAAS,CAAA,UAAA,CAAA,CAAA;EACjD,QAAA,EAAA,QAAA,CAAA,OAAA,CAAA;;AADgD,cAwC/C,YAxC+C,EAAA,CAAA,UAAA,CAAA,CAAA,YAAA,EAyC5C,UAzC4C,EAAA,OAAA,EA0CjD,sBA1CiD,EAAA,GA2CzD,cA3CyD,CA2C1C,UA3C0C,CAAA"}

package/dist/svelte.d.ts

@@ -0,0 +1,14 @@
+import { a as SyncStateChannelOptions, t as SyncStateBridge } from "./types-7wPPX0ty.js";
+import { Readable, Writable } from "svelte/store";
+
+//#region src/renderer/svelte.d.ts
+interface SyncStateSvelteOptions extends SyncStateChannelOptions {
+  bridge?: SyncStateBridge;
+}
+interface SyncStateStore<StateValue> extends Writable<StateValue> {
+  isSynced: Readable<boolean>;
+}
+declare const useSyncState: <StateValue>(initialValue: StateValue, options: SyncStateSvelteOptions) => SyncStateStore<StateValue>;
+//#endregion
+export { SyncStateStore, SyncStateSvelteOptions, useSyncState as createSyncStateStore, useSyncState };
+//# sourceMappingURL=svelte.d.ts.map

package/dist/svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"svelte.d.ts","names":[],"sources":["../src/renderer/svelte.ts"],"sourcesContent":[],"mappings":";;;;UAOiB,sBAAA,SAA+B;EAA/B,MAAA,CAAA,EACN,eADM;AASjB;AAA6D,UAA5C,cAA4C,CAAA,UAAA,CAAA,SAAT,QAAS,CAAA,UAAA,CAAA,CAAA;EACjD,QAAA,EAAA,QAAA,CAAA,OAAA,CAAA;;AADgD,cAwC/C,YAxC+C,EAAA,CAAA,UAAA,CAAA,CAAA,YAAA,EAyC5C,UAzC4C,EAAA,OAAA,EA0CjD,sBA1CiD,EAAA,GA2CzD,cA3CyD,CA2C1C,UA3C0C,CAAA"}

package/dist/svelte.js

@@ -0,0 +1,63 @@
+import { a as resolveSyncStateBridge, t as getGlobalConfig } from "./renderer-C7zF3UQm.js";
+import { get, writable } from "svelte/store";
+
+//#region src/renderer/svelte.ts
+const createChannelOptions = (options) => {
+	const globalConfig = getGlobalConfig();
+	return {
+		baseChannel: options.baseChannel ?? globalConfig.baseChannel,
+		name: options.name
+	};
+};
+const createRemoteUpdateTracker = (setStoreValue, isSynced) => {
+	let isRemoteUpdate = false;
+	const applyRemoteValue = (value) => {
+		isRemoteUpdate = true;
+		setStoreValue(value);
+		isSynced.set(true);
+		isRemoteUpdate = false;
+	};
+	const shouldSkipLocalSync = () => {
+		if (!isRemoteUpdate) return false;
+		isRemoteUpdate = false;
+		return true;
+	};
+	return {
+		applyRemoteValue,
+		shouldSkipLocalSync
+	};
+};
+const useSyncState = (initialValue, options) => {
+	const globalConfig = getGlobalConfig();
+	const bridge = resolveSyncStateBridge(options.bridge ?? globalConfig.bridge);
+	const channelOptions = createChannelOptions(options);
+	const isSynced = writable(false);
+	let tracker = void 0;
+	const store = writable(initialValue, (setStoreValue) => {
+		tracker = createRemoteUpdateTracker(setStoreValue, isSynced);
+		const unsubscribe = bridge.subscribe(channelOptions, tracker.applyRemoteValue);
+		bridge.get(channelOptions).then(tracker.applyRemoteValue);
+		return () => {
+			unsubscribe();
+			tracker = void 0;
+		};
+	});
+	const set = (value) => {
+		if (tracker?.shouldSkipLocalSync()) return;
+		store.set(value);
+		bridge.set(channelOptions, value);
+	};
+	const update = (updater) => {
+		set(updater(get(store)));
+	};
+	return {
+		isSynced,
+		set,
+		subscribe: store.subscribe,
+		update
+	};
+};
+
+//#endregion
+export { useSyncState as createSyncStateStore, useSyncState };
+//# sourceMappingURL=svelte.js.map

package/dist/svelte.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"svelte.js","names":[],"sources":["../src/renderer/svelte.ts"],"sourcesContent":["import { get, writable, type Readable, type Updater, type Writable } from \"svelte/store\";\n\nimport type { SyncStateChannelOptions } from \"../channels\";\nimport type { SyncStateBridge } from \"../types\";\nimport { resolveSyncStateBridge } from \"./bridge\";\nimport { getGlobalConfig } from \"./index\";\n\nexport interface SyncStateSvelteOptions extends SyncStateChannelOptions {\n  bridge?: SyncStateBridge;\n}\n\ninterface RemoteUpdateTracker<StateValue> {\n  applyRemoteValue: (value: StateValue) => void;\n  shouldSkipLocalSync: () => boolean;\n}\n\nexport interface SyncStateStore<StateValue> extends Writable<StateValue> {\n  isSynced: Readable<boolean>;\n}\n\nconst createChannelOptions = (options: SyncStateSvelteOptions): SyncStateChannelOptions => {\n  const globalConfig = getGlobalConfig();\n  return {\n    baseChannel: options.baseChannel ?? globalConfig.baseChannel,\n    name: options.name,\n  };\n};\n\nconst createRemoteUpdateTracker = <StateValue>(\n  setStoreValue: (value: StateValue) => void,\n  isSynced: Writable<boolean>,\n): RemoteUpdateTracker<StateValue> => {\n  let isRemoteUpdate = false;\n\n  const applyRemoteValue = (value: StateValue): void => {\n    isRemoteUpdate = true;\n    setStoreValue(value);\n    isSynced.set(true);\n    // Reset immediately since Svelte doesn't have a watch that consumes this synchronously\n    isRemoteUpdate = false;\n  };\n\n  const shouldSkipLocalSync = (): boolean => {\n    if (!isRemoteUpdate) {\n      return false;\n    }\n    isRemoteUpdate = false;\n    return true;\n  };\n\n  return {\n    applyRemoteValue,\n    shouldSkipLocalSync,\n  };\n};\n\nexport const useSyncState = <StateValue>(\n  initialValue: StateValue,\n  options: SyncStateSvelteOptions,\n): SyncStateStore<StateValue> => {\n  const globalConfig = getGlobalConfig();\n  const bridge = resolveSyncStateBridge(options.bridge ?? globalConfig.bridge);\n  const channelOptions = createChannelOptions(options);\n  const isSynced = writable(false);\n  let tracker: RemoteUpdateTracker<StateValue> | undefined = undefined;\n\n  const store = writable(initialValue, (setStoreValue) => {\n    tracker = createRemoteUpdateTracker(setStoreValue, isSynced);\n    const unsubscribe = bridge.subscribe(channelOptions, tracker.applyRemoteValue);\n    void bridge.get<StateValue>(channelOptions).then(tracker.applyRemoteValue);\n\n    return () => {\n      unsubscribe();\n      tracker = undefined;\n    };\n  });\n\n  const set = (value: StateValue): void => {\n    if (tracker?.shouldSkipLocalSync()) {\n      return;\n    }\n\n    store.set(value);\n    void bridge.set(channelOptions, value);\n  };\n\n  const update = (updater: Updater<StateValue>): void => {\n    const nextValue = updater(get(store));\n    set(nextValue);\n  };\n\n  return {\n    isSynced,\n    set,\n    subscribe: store.subscribe,\n    update,\n  };\n};\n\n// Backward compatibility alias\nexport { useSyncState as createSyncStateStore };\n"],"mappings":";;;;AAoBA,MAAM,wBAAwB,YAA6D;CACzF,MAAM,eAAe,iBAAiB;AACtC,QAAO;EACL,aAAa,QAAQ,eAAe,aAAa;EACjD,MAAM,QAAQ;EACf;;AAGH,MAAM,6BACJ,eACA,aACoC;CACpC,IAAI,iBAAiB;CAErB,MAAM,oBAAoB,UAA4B;AACpD,mBAAiB;AACjB,gBAAc,MAAM;AACpB,WAAS,IAAI,KAAK;AAElB,mBAAiB;;CAGnB,MAAM,4BAAqC;AACzC,MAAI,CAAC,eACH,QAAO;AAET,mBAAiB;AACjB,SAAO;;AAGT,QAAO;EACL;EACA;EACD;;AAGH,MAAa,gBACX,cACA,YAC+B;CAC/B,MAAM,eAAe,iBAAiB;CACtC,MAAM,SAAS,uBAAuB,QAAQ,UAAU,aAAa,OAAO;CAC5E,MAAM,iBAAiB,qBAAqB,QAAQ;CACpD,MAAM,WAAW,SAAS,MAAM;CAChC,IAAI,UAAuD;CAE3D,MAAM,QAAQ,SAAS,eAAe,kBAAkB;AACtD,YAAU,0BAA0B,eAAe,SAAS;EAC5D,MAAM,cAAc,OAAO,UAAU,gBAAgB,QAAQ,iBAAiB;AAC9E,EAAK,OAAO,IAAgB,eAAe,CAAC,KAAK,QAAQ,iBAAiB;AAE1E,eAAa;AACX,gBAAa;AACb,aAAU;;GAEZ;CAEF,MAAM,OAAO,UAA4B;AACvC,MAAI,SAAS,qBAAqB,CAChC;AAGF,QAAM,IAAI,MAAM;AAChB,EAAK,OAAO,IAAI,gBAAgB,MAAM;;CAGxC,MAAM,UAAU,YAAuC;AAErD,MADkB,QAAQ,IAAI,MAAM,CAAC,CACvB;;AAGhB,QAAO;EACL;EACA;EACA,WAAW,MAAM;EACjB;EACD"}

package/dist/types-7wPPX0ty.d.ts

@@ -0,0 +1,37 @@
+//#region src/channels.d.ts
+interface SyncStateChannelOptions {
+  name: string;
+  baseChannel?: string;
+}
+interface SyncStateChannels {
+  getChannel: string;
+  setChannel: string;
+  subscribeChannel: string;
+  unsubscribeChannel: string;
+  updateChannel: string;
+}
+declare const createSyncStateChannels: (options: SyncStateChannelOptions) => SyncStateChannels;
+//#endregion
+//#region src/types.d.ts
+type SyncStateListener<StateValue> = (value: StateValue) => void;
+type SyncStateErrorCode = "RENDERER_READONLY" | "RENDERER_INVALID_VALUE";
+declare class SyncStateError extends Error {
+  readonly code: SyncStateErrorCode;
+  readonly stateName?: string;
+  readonly baseChannel?: string;
+  readonly cause?: Error;
+  constructor(code: SyncStateErrorCode, message: string, context?: {
+    stateName?: string;
+    baseChannel?: string;
+    cause?: Error;
+  });
+  getFullMessage(): string;
+}
+interface SyncStateBridge {
+  get: <StateValue>(options: SyncStateChannelOptions) => Promise<StateValue>;
+  set: <StateValue>(options: SyncStateChannelOptions, value: StateValue) => Promise<void>;
+  subscribe: <StateValue>(options: SyncStateChannelOptions, listener: SyncStateListener<StateValue>) => () => void;
+}
+//#endregion
+export { SyncStateChannelOptions as a, SyncStateListener as i, SyncStateError as n, SyncStateChannels as o, SyncStateErrorCode as r, createSyncStateChannels as s, SyncStateBridge as t };
+//# sourceMappingURL=types-7wPPX0ty.d.ts.map

package/dist/types-7wPPX0ty.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-7wPPX0ty.d.ts","names":[],"sources":["../src/channels.ts","../src/types.ts"],"sourcesContent":[],"mappings":";UAAiB,uBAAA;EAAA,IAAA,EAAA,MAAA;EAKA,WAAA,CAAA,EAAA,MAAiB;AAQlC;UARiB,iBAAA;;;ECHL,gBAAA,EAAA,MAAiB;EAEjB,kBAAA,EAAA,MAAkB;EAEjB,aAAA,EAAA,MAAe;;AAIF,cDGb,uBCHa,EAAA,CAAA,OAAA,EDGuB,uBCHvB,EAAA,GDGiD,iBCHjD;;;ADVT,KCEL,iBDFK,CAAuB,UAAA,CAAA,GAAA,CAAA,KAAA,ECEY,UDFZ,EAAA,GAAA,IAAA;AAKvB,KCDL,kBAAA,GDCsB,mBAAA,GAAA,wBAAA;AAQrB,cCPA,cAAA,SAAuB,KAAA,CDOa;iBCNzB;;;EALZ,SAAA,KAAA,CAAA,EAQc,KARG;EAEjB,WAAA,CAAA,IAAA,EASF,kBAToB,EAAA,OAAA,EAAA,MAAA,EAAA,OASpB,CAToB,EAAA;IAEjB,SAAA,CAAA,EAAA,MAAe;IACJ,WAAA,CAAA,EAAA,MAAA;IAGE,KAAA,CAAA,EAKwC,KALxC;EAGhB,CAAA;EAEwD,cAAA,CAAA,CAAA,EAAA,MAAA;;AATzB,UAsCxB,eAAA,CAtCwB;EAsCxB,GAAA,EAAA,CAAA,UAAA,CAAA,CAAe,OAAA,EACH,uBADG,EAAA,GACyB,OADzB,CACiC,UADjC,CAAA;EACH,GAAA,EAAA,CAAA,UAAA,CAAA,CAAA,OAAA,EACA,uBADA,EAAA,KAAA,EACgC,UADhC,EAAA,GAC+C,OAD/C,CAAA,IAAA,CAAA;EAAoC,SAAA,EAAA,CAAA,UAAA,CAAA,CAAA,OAAA,EAGpD,uBAHoD,EAAA,QAAA,EAInD,iBAJmD,CAIjC,UAJiC,CAAA,EAAA,GAAA,GAAA,GAAA,IAAA"}

package/dist/types-C18dHgLI.d.cts

@@ -0,0 +1,37 @@
+//#region src/channels.d.ts
+interface SyncStateChannelOptions {
+  name: string;
+  baseChannel?: string;
+}
+interface SyncStateChannels {
+  getChannel: string;
+  setChannel: string;
+  subscribeChannel: string;
+  unsubscribeChannel: string;
+  updateChannel: string;
+}
+declare const createSyncStateChannels: (options: SyncStateChannelOptions) => SyncStateChannels;
+//#endregion
+//#region src/types.d.ts
+type SyncStateListener<StateValue> = (value: StateValue) => void;
+type SyncStateErrorCode = "RENDERER_READONLY" | "RENDERER_INVALID_VALUE";
+declare class SyncStateError extends Error {
+  readonly code: SyncStateErrorCode;
+  readonly stateName?: string;
+  readonly baseChannel?: string;
+  readonly cause?: Error;
+  constructor(code: SyncStateErrorCode, message: string, context?: {
+    stateName?: string;
+    baseChannel?: string;
+    cause?: Error;
+  });
+  getFullMessage(): string;
+}
+interface SyncStateBridge {
+  get: <StateValue>(options: SyncStateChannelOptions) => Promise<StateValue>;
+  set: <StateValue>(options: SyncStateChannelOptions, value: StateValue) => Promise<void>;
+  subscribe: <StateValue>(options: SyncStateChannelOptions, listener: SyncStateListener<StateValue>) => () => void;
+}
+//#endregion
+export { SyncStateChannelOptions as a, SyncStateListener as i, SyncStateError as n, SyncStateChannels as o, SyncStateErrorCode as r, createSyncStateChannels as s, SyncStateBridge as t };
+//# sourceMappingURL=types-C18dHgLI.d.cts.map

package/dist/types-C18dHgLI.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-C18dHgLI.d.cts","names":[],"sources":["../src/channels.ts","../src/types.ts"],"sourcesContent":[],"mappings":";UAAiB,uBAAA;EAAA,IAAA,EAAA,MAAA;EAKA,WAAA,CAAA,EAAA,MAAiB;AAQlC;UARiB,iBAAA;;;ECHL,gBAAA,EAAA,MAAiB;EAEjB,kBAAA,EAAA,MAAkB;EAEjB,aAAA,EAAA,MAAe;;AAIF,cDGb,uBCHa,EAAA,CAAA,OAAA,EDGuB,uBCHvB,EAAA,GDGiD,iBCHjD;;;ADVT,KCEL,iBDFK,CAAuB,UAAA,CAAA,GAAA,CAAA,KAAA,ECEY,UDFZ,EAAA,GAAA,IAAA;AAKvB,KCDL,kBAAA,GDCsB,mBAAA,GAAA,wBAAA;AAQrB,cCPA,cAAA,SAAuB,KAAA,CDOa;iBCNzB;;;EALZ,SAAA,KAAA,CAAA,EAQc,KARG;EAEjB,WAAA,CAAA,IAAA,EASF,kBAToB,EAAA,OAAA,EAAA,MAAA,EAAA,OASpB,CAToB,EAAA;IAEjB,SAAA,CAAA,EAAA,MAAe;IACJ,WAAA,CAAA,EAAA,MAAA;IAGE,KAAA,CAAA,EAKwC,KALxC;EAGhB,CAAA;EAEwD,cAAA,CAAA,CAAA,EAAA,MAAA;;AATzB,UAsCxB,eAAA,CAtCwB;EAsCxB,GAAA,EAAA,CAAA,UAAA,CAAA,CAAe,OAAA,EACH,uBADG,EAAA,GACyB,OADzB,CACiC,UADjC,CAAA;EACH,GAAA,EAAA,CAAA,UAAA,CAAA,CAAA,OAAA,EACA,uBADA,EAAA,KAAA,EACgC,UADhC,EAAA,GAC+C,OAD/C,CAAA,IAAA,CAAA;EAAoC,SAAA,EAAA,CAAA,UAAA,CAAA,CAAA,OAAA,EAGpD,uBAHoD,EAAA,QAAA,EAInD,iBAJmD,CAIjC,UAJiC,CAAA,EAAA,GAAA,GAAA,GAAA,IAAA"}

package/dist/vue.cjs

@@ -0,0 +1,69 @@
+const require_renderer = require('./renderer-D3YziJ_U.cjs');
+let vue = require("vue");
+
+//#region src/renderer/vue.ts
+const createChannelOptions = (options) => {
+	const globalConfig = require_renderer.getGlobalConfig();
+	return {
+		baseChannel: options.baseChannel ?? globalConfig.baseChannel,
+		name: options.name
+	};
+};
+const resolveSyncValue = (value) => {
+	if (value !== null && typeof value === "object" && (0, vue.isProxy)(value)) return (0, vue.toRaw)(value);
+	return value;
+};
+const createRemoteUpdateTracker = (stateRef, isSynced) => {
+	let isApplyingRemoteValue = false;
+	let lastRemoteValue = void 0;
+	const applyRemoteValue = (value) => {
+		const resolvedValue = resolveSyncValue(value);
+		isApplyingRemoteValue = true;
+		lastRemoteValue = resolvedValue;
+		stateRef.value = resolvedValue;
+		isSynced.value = true;
+		isApplyingRemoteValue = false;
+	};
+	const shouldSkipLocalSync = (currentValue) => isApplyingRemoteValue && resolveSyncValue(currentValue) === lastRemoteValue;
+	return {
+		applyRemoteValue,
+		shouldSkipLocalSync
+	};
+};
+const createStateWatcher = ({ bridge, channelOptions, deep, stateRef, tracker }) => (0, vue.watch)(stateRef, (nextValue) => {
+	if (tracker.shouldSkipLocalSync(nextValue)) return;
+	bridge.set(channelOptions, resolveSyncValue(nextValue));
+}, {
+	deep: Boolean(deep),
+	flush: "sync"
+});
+const useSyncState = (initialValue, options) => {
+	const stateRef = (0, vue.ref)(initialValue);
+	const isSynced = (0, vue.ref)(false);
+	const globalConfig = require_renderer.getGlobalConfig();
+	const bridge = require_renderer.resolveSyncStateBridge(options.bridge ?? globalConfig.bridge);
+	const channelOptions = createChannelOptions(options);
+	const tracker = createRemoteUpdateTracker(stateRef, isSynced);
+	const stopWatcher = createStateWatcher({
+		bridge,
+		channelOptions,
+		deep: options.deep,
+		stateRef,
+		tracker
+	});
+	let unsubscribe = void 0;
+	(0, vue.onMounted)(() => {
+		unsubscribe = bridge.subscribe(channelOptions, tracker.applyRemoteValue);
+		bridge.get(channelOptions).then(tracker.applyRemoteValue);
+	});
+	(0, vue.onBeforeUnmount)(() => {
+		stopWatcher();
+		unsubscribe?.();
+		unsubscribe = void 0;
+	});
+	stateRef.isSynced = isSynced;
+	return stateRef;
+};
+
+//#endregion
+exports.useSyncState = useSyncState;

package/dist/vue.d.cts

@@ -0,0 +1,15 @@
+import { a as SyncStateChannelOptions, t as SyncStateBridge } from "./types-C18dHgLI.cjs";
+import { Ref } from "vue";
+
+//#region src/renderer/vue.d.ts
+interface UseSyncStateOptions extends SyncStateChannelOptions {
+  bridge?: SyncStateBridge;
+  deep?: boolean;
+}
+interface SyncStateRef<StateValue> extends Ref<StateValue> {
+  isSynced: Ref<boolean>;
+}
+declare const useSyncState: <StateValue>(initialValue: StateValue, options: UseSyncStateOptions) => SyncStateRef<StateValue>;
+//#endregion
+export { SyncStateRef, UseSyncStateOptions, useSyncState };
+//# sourceMappingURL=vue.d.cts.map

package/dist/vue.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vue.d.cts","names":[],"sources":["../src/renderer/vue.ts"],"sourcesContent":[],"mappings":";;;;UAOiB,mBAAA,SAA4B;EAA5B,MAAA,CAAA,EACN,eAD0B;EAqFpB,IAAA,CAAA,EAAA,OAAA;;AACL,UADK,YACL,CAAA,UAAA,CAAA,SADsC,GACtC,CAD0C,UAC1C,CAAA,CAAA;EADsC,QAAA,EACtC,GADsC,CAAA,OAAA,CAAA;;AAIrC,cAAA,YAkCZ,EAAA,CAAA,UAAA,CAAA,CAAA,YAAA,EAjCe,UAiCf,EAAA,OAAA,EAhCU,mBAgCV,EAAA,GA/BE,YA+BF,CA/Be,UA+Bf,CAAA"}

package/dist/vue.d.ts

@@ -0,0 +1,15 @@
+import { a as SyncStateChannelOptions, t as SyncStateBridge } from "./types-7wPPX0ty.js";
+import { Ref } from "vue";
+
+//#region src/renderer/vue.d.ts
+interface UseSyncStateOptions extends SyncStateChannelOptions {
+  bridge?: SyncStateBridge;
+  deep?: boolean;
+}
+interface SyncStateRef<StateValue> extends Ref<StateValue> {
+  isSynced: Ref<boolean>;
+}
+declare const useSyncState: <StateValue>(initialValue: StateValue, options: UseSyncStateOptions) => SyncStateRef<StateValue>;
+//#endregion
+export { SyncStateRef, UseSyncStateOptions, useSyncState };
+//# sourceMappingURL=vue.d.ts.map

package/dist/vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vue.d.ts","names":[],"sources":["../src/renderer/vue.ts"],"sourcesContent":[],"mappings":";;;;UAOiB,mBAAA,SAA4B;EAA5B,MAAA,CAAA,EACN,eAD0B;EAqFpB,IAAA,CAAA,EAAA,OAAA;;AACL,UADK,YACL,CAAA,UAAA,CAAA,SADsC,GACtC,CAD0C,UAC1C,CAAA,CAAA;EADsC,QAAA,EACtC,GADsC,CAAA,OAAA,CAAA;;AAIrC,cAAA,YAkCZ,EAAA,CAAA,UAAA,CAAA,CAAA,YAAA,EAjCe,UAiCf,EAAA,OAAA,EAhCU,mBAgCV,EAAA,GA/BE,YA+BF,CA/Be,UA+Bf,CAAA"}

package/dist/vue.js

@@ -0,0 +1,70 @@
+import { a as resolveSyncStateBridge, t as getGlobalConfig } from "./renderer-C7zF3UQm.js";
+import { isProxy, onBeforeUnmount, onMounted, ref, toRaw, watch } from "vue";
+
+//#region src/renderer/vue.ts
+const createChannelOptions = (options) => {
+	const globalConfig = getGlobalConfig();
+	return {
+		baseChannel: options.baseChannel ?? globalConfig.baseChannel,
+		name: options.name
+	};
+};
+const resolveSyncValue = (value) => {
+	if (value !== null && typeof value === "object" && isProxy(value)) return toRaw(value);
+	return value;
+};
+const createRemoteUpdateTracker = (stateRef, isSynced) => {
+	let isApplyingRemoteValue = false;
+	let lastRemoteValue = void 0;
+	const applyRemoteValue = (value) => {
+		const resolvedValue = resolveSyncValue(value);
+		isApplyingRemoteValue = true;
+		lastRemoteValue = resolvedValue;
+		stateRef.value = resolvedValue;
+		isSynced.value = true;
+		isApplyingRemoteValue = false;
+	};
+	const shouldSkipLocalSync = (currentValue) => isApplyingRemoteValue && resolveSyncValue(currentValue) === lastRemoteValue;
+	return {
+		applyRemoteValue,
+		shouldSkipLocalSync
+	};
+};
+const createStateWatcher = ({ bridge, channelOptions, deep, stateRef, tracker }) => watch(stateRef, (nextValue) => {
+	if (tracker.shouldSkipLocalSync(nextValue)) return;
+	bridge.set(channelOptions, resolveSyncValue(nextValue));
+}, {
+	deep: Boolean(deep),
+	flush: "sync"
+});
+const useSyncState = (initialValue, options) => {
+	const stateRef = ref(initialValue);
+	const isSynced = ref(false);
+	const globalConfig = getGlobalConfig();
+	const bridge = resolveSyncStateBridge(options.bridge ?? globalConfig.bridge);
+	const channelOptions = createChannelOptions(options);
+	const tracker = createRemoteUpdateTracker(stateRef, isSynced);
+	const stopWatcher = createStateWatcher({
+		bridge,
+		channelOptions,
+		deep: options.deep,
+		stateRef,
+		tracker
+	});
+	let unsubscribe = void 0;
+	onMounted(() => {
+		unsubscribe = bridge.subscribe(channelOptions, tracker.applyRemoteValue);
+		bridge.get(channelOptions).then(tracker.applyRemoteValue);
+	});
+	onBeforeUnmount(() => {
+		stopWatcher();
+		unsubscribe?.();
+		unsubscribe = void 0;
+	});
+	stateRef.isSynced = isSynced;
+	return stateRef;
+};
+
+//#endregion
+export { useSyncState };
+//# sourceMappingURL=vue.js.map

package/dist/vue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vue.js","names":[],"sources":["../src/renderer/vue.ts"],"sourcesContent":["import { isProxy, onBeforeUnmount, onMounted, ref, toRaw, watch, type Ref } from \"vue\";\n\nimport type { SyncStateChannelOptions } from \"../channels\";\nimport type { SyncStateBridge } from \"../types\";\nimport { resolveSyncStateBridge } from \"./bridge\";\nimport { getGlobalConfig } from \"./index\";\n\nexport interface UseSyncStateOptions extends SyncStateChannelOptions {\n  bridge?: SyncStateBridge;\n  deep?: boolean;\n}\n\ninterface RemoteUpdateTracker<StateValue> {\n  applyRemoteValue: (value: StateValue) => void;\n  shouldSkipLocalSync: (currentValue: StateValue) => boolean;\n}\n\nconst createChannelOptions = (options: UseSyncStateOptions): SyncStateChannelOptions => {\n  const globalConfig = getGlobalConfig();\n  return {\n    baseChannel: options.baseChannel ?? globalConfig.baseChannel,\n    name: options.name,\n  };\n};\n\n// Convert Vue Proxy to serializable raw value\nconst resolveSyncValue = <StateValue>(value: StateValue): StateValue => {\n  if (value !== null && typeof value === \"object\" && isProxy(value)) {\n    return toRaw(value) as StateValue;\n  }\n\n  return value;\n};\n\nconst createRemoteUpdateTracker = <StateValue>(\n  stateRef: Ref<StateValue>,\n  isSynced: Ref<boolean>,\n): RemoteUpdateTracker<StateValue> => {\n  let isApplyingRemoteValue = false;\n  // Record the last raw value synced from main process\n  let lastRemoteValue: StateValue | undefined = undefined;\n\n  const applyRemoteValue = (value: StateValue): void => {\n    // Convert remote synced value to raw object\n    const resolvedValue = resolveSyncValue(value);\n    isApplyingRemoteValue = true;\n    lastRemoteValue = resolvedValue;\n    stateRef.value = resolvedValue;\n    isSynced.value = true;\n    isApplyingRemoteValue = false;\n  };\n\n  const shouldSkipLocalSync = (currentValue: StateValue): boolean =>\n    // Skip sync if we're currently applying a remote value AND it matches\n    // This prevents infinite loops while allowing all local updates to sync\n    isApplyingRemoteValue && resolveSyncValue(currentValue) === lastRemoteValue;\n\n  return {\n    applyRemoteValue,\n    shouldSkipLocalSync,\n  };\n};\n\ninterface StateWatcherOptions<StateValue> {\n  bridge: SyncStateBridge;\n  channelOptions: SyncStateChannelOptions;\n  stateRef: Ref<StateValue>;\n  tracker: RemoteUpdateTracker<StateValue>;\n  deep?: boolean;\n}\n\nconst createStateWatcher = <StateValue>({\n  bridge,\n  channelOptions,\n  deep,\n  stateRef,\n  tracker,\n}: StateWatcherOptions<StateValue>): (() => void) =>\n  watch(\n    stateRef,\n    (nextValue: StateValue) => {\n      if (tracker.shouldSkipLocalSync(nextValue)) {\n        return;\n      }\n      void bridge.set(channelOptions, resolveSyncValue(nextValue));\n    },\n    {\n      deep: Boolean(deep),\n      flush: \"sync\",\n    },\n  );\n\nexport interface SyncStateRef<StateValue> extends Ref<StateValue> {\n  isSynced: Ref<boolean>;\n}\n\nexport const useSyncState = <StateValue>(\n  initialValue: StateValue,\n  options: UseSyncStateOptions,\n): SyncStateRef<StateValue> => {\n  const stateRef = ref(initialValue) as unknown as SyncStateRef<StateValue>;\n  const isSynced = ref(false);\n  const globalConfig = getGlobalConfig();\n  const bridge = resolveSyncStateBridge(options.bridge ?? globalConfig.bridge);\n  const channelOptions = createChannelOptions(options);\n  const tracker = createRemoteUpdateTracker(stateRef, isSynced);\n  const stopWatcher = createStateWatcher({\n    bridge,\n    channelOptions,\n    deep: options.deep,\n    stateRef,\n    tracker,\n  });\n\n  let unsubscribe: (() => void) | undefined = undefined;\n\n  onMounted(() => {\n    unsubscribe = bridge.subscribe(channelOptions, tracker.applyRemoteValue);\n    void bridge.get<StateValue>(channelOptions).then(tracker.applyRemoteValue);\n  });\n\n  onBeforeUnmount(() => {\n    stopWatcher();\n    unsubscribe?.();\n    unsubscribe = undefined;\n  });\n\n  stateRef.isSynced = isSynced;\n\n  return stateRef;\n};\n"],"mappings":";;;;AAiBA,MAAM,wBAAwB,YAA0D;CACtF,MAAM,eAAe,iBAAiB;AACtC,QAAO;EACL,aAAa,QAAQ,eAAe,aAAa;EACjD,MAAM,QAAQ;EACf;;AAIH,MAAM,oBAAgC,UAAkC;AACtE,KAAI,UAAU,QAAQ,OAAO,UAAU,YAAY,QAAQ,MAAM,CAC/D,QAAO,MAAM,MAAM;AAGrB,QAAO;;AAGT,MAAM,6BACJ,UACA,aACoC;CACpC,IAAI,wBAAwB;CAE5B,IAAI,kBAA0C;CAE9C,MAAM,oBAAoB,UAA4B;EAEpD,MAAM,gBAAgB,iBAAiB,MAAM;AAC7C,0BAAwB;AACxB,oBAAkB;AAClB,WAAS,QAAQ;AACjB,WAAS,QAAQ;AACjB,0BAAwB;;CAG1B,MAAM,uBAAuB,iBAG3B,yBAAyB,iBAAiB,aAAa,KAAK;AAE9D,QAAO;EACL;EACA;EACD;;AAWH,MAAM,sBAAkC,EACtC,QACA,gBACA,MACA,UACA,cAEA,MACE,WACC,cAA0B;AACzB,KAAI,QAAQ,oBAAoB,UAAU,CACxC;AAEF,CAAK,OAAO,IAAI,gBAAgB,iBAAiB,UAAU,CAAC;GAE9D;CACE,MAAM,QAAQ,KAAK;CACnB,OAAO;CACR,CACF;AAMH,MAAa,gBACX,cACA,YAC6B;CAC7B,MAAM,WAAW,IAAI,aAAa;CAClC,MAAM,WAAW,IAAI,MAAM;CAC3B,MAAM,eAAe,iBAAiB;CACtC,MAAM,SAAS,uBAAuB,QAAQ,UAAU,aAAa,OAAO;CAC5E,MAAM,iBAAiB,qBAAqB,QAAQ;CACpD,MAAM,UAAU,0BAA0B,UAAU,SAAS;CAC7D,MAAM,cAAc,mBAAmB;EACrC;EACA;EACA,MAAM,QAAQ;EACd;EACA;EACD,CAAC;CAEF,IAAI,cAAwC;AAE5C,iBAAgB;AACd,gBAAc,OAAO,UAAU,gBAAgB,QAAQ,iBAAiB;AACxE,EAAK,OAAO,IAAgB,eAAe,CAAC,KAAK,QAAQ,iBAAiB;GAC1E;AAEF,uBAAsB;AACpB,eAAa;AACb,iBAAe;AACf,gBAAc;GACd;AAEF,UAAS,WAAW;AAEpB,QAAO"}

package/dist/zustand.cjs

@@ -0,0 +1,193 @@
+const require_renderer = require('./renderer-D3YziJ_U.cjs');
+let react = require("react");
+let zustand_vanilla = require("zustand/vanilla");
+
+//#region src/renderer/zustand.ts
+const createChannelOptions = (options) => {
+	const globalConfig = require_renderer.getGlobalConfig();
+	return {
+		baseChannel: options.baseChannel ?? globalConfig.baseChannel,
+		name: options.name
+	};
+};
+/**
+* Zustand middleware that syncs store state with Electron main process
+*
+* @example
+* ```typescript
+* import { create } from 'zustand';
+* import { syncStateMiddleware } from 'electron-state-sync/zustand';
+*
+* const useStore = create(
+*   syncStateMiddleware({ name: 'counter' })((set) => ({
+*     count: 0,
+*     increment: () => set((state) => ({ count: state.count + 1 }))
+*   }))
+* );
+* ```
+*/
+const syncStateMiddleware = (options) => (config) => (set, get, api) => {
+	const globalConfig = require_renderer.getGlobalConfig();
+	const bridge = require_renderer.resolveSyncStateBridge(options.bridge ?? globalConfig.bridge);
+	const channelOptions = createChannelOptions(options);
+	let isApplyingRemoteValue = false;
+	const originalSetState = api.setState;
+	api.setState = (partial, replace) => {
+		const currentState = get();
+		if (isApplyingRemoteValue) {
+			isApplyingRemoteValue = false;
+			return originalSetState(partial, replace);
+		}
+		let nextState;
+		if (typeof partial === "function") nextState = partial(currentState);
+		else if (replace) nextState = partial;
+		else nextState = {
+			...currentState,
+			...partial
+		};
+		const dataOnlyState = Object.fromEntries(Object.entries(nextState).filter(([_, v]) => typeof v !== "function"));
+		bridge.set(channelOptions, dataOnlyState);
+		return originalSetState(partial, replace);
+	};
+	const applyRemoteValue = (value) => {
+		isApplyingRemoteValue = true;
+		const currentState = get();
+		if (typeof value === "object" && value !== null && !Array.isArray(value)) api.setState({
+			...currentState,
+			...value
+		}, true);
+		else {
+			const keys = Object.keys(currentState).filter((k) => typeof currentState[k] !== "function");
+			if (keys.length === 1) api.setState({
+				...currentState,
+				[keys[0]]: value
+			}, true);
+			else api.setState(value, true);
+		}
+	};
+	const unsubscribe = bridge.subscribe(channelOptions, applyRemoteValue);
+	bridge.get(channelOptions).then(applyRemoteValue);
+	const store = config(set, get, api);
+	const storeApi = api;
+	if (storeApi.destroy) {
+		const originalDestroy = storeApi.destroy;
+		storeApi.destroy = () => {
+			unsubscribe();
+			originalDestroy();
+		};
+	}
+	return store;
+};
+/**
+* Hook to access sync state for a Zustand store
+*
+* @example
+* ```typescript
+* import { useSyncState } from 'electron-state-sync/zustand';
+*
+* function App() {
+*   const { state, isSynced } = useSyncState({ name: 'counter' });
+*   return <div>{state?.count}</div>;
+* }
+* ```
+*/
+const useSyncState = (options) => {
+	const [isSynced, setIsSynced] = (0, react.useState)(false);
+	const [state, setState] = (0, react.useState)();
+	const globalConfig = require_renderer.getGlobalConfig();
+	const bridge = require_renderer.resolveSyncStateBridge(options.bridge ?? globalConfig.bridge);
+	const channelOptions = (0, react.useMemo)(() => createChannelOptions(options), [options.baseChannel, options.name]);
+	(0, react.useEffect)(() => {
+		const unsubscribe = bridge.subscribe(channelOptions, (value) => {
+			setState(value);
+			setIsSynced(true);
+		});
+		bridge.get(channelOptions).then((value) => {
+			setState(value);
+			setIsSynced(true);
+		});
+		return () => {
+			unsubscribe();
+		};
+	}, [bridge, channelOptions]);
+	return {
+		isSynced,
+		state
+	};
+};
+/**
+* Create a synced Zustand store (hook-less version for vanilla JS)
+*
+* @example
+* ```typescript
+* import { createSyncedStore } from 'electron-state-sync/zustand';
+*
+* const store = createSyncedStore(
+*   { count: 0 },
+*   { name: 'counter' },
+*   (set) => ({
+*     increment: () => set((state) => ({ count: state.count + 1 }))
+*   })
+* );
+* ```
+*/
+const createSyncedStore = (initialState, options) => {
+	const globalConfig = require_renderer.getGlobalConfig();
+	const bridge = require_renderer.resolveSyncStateBridge(options.bridge ?? globalConfig.bridge);
+	const channelOptions = createChannelOptions(options);
+	let isApplyingRemoteValue = false;
+	const store = (0, zustand_vanilla.createStore)()(() => initialState);
+	const originalSetState = store.setState.bind(store);
+	store.setState = (partial, replace) => {
+		const currentState = store.getState();
+		if (isApplyingRemoteValue) {
+			isApplyingRemoteValue = false;
+			return originalSetState(partial, replace);
+		}
+		let nextState;
+		if (typeof partial === "function") nextState = partial(currentState);
+		else if (replace) nextState = partial;
+		else nextState = {
+			...currentState,
+			...partial
+		};
+		const dataOnlyState = Object.fromEntries(Object.entries(nextState).filter(([_, v]) => typeof v !== "function"));
+		bridge.set(channelOptions, dataOnlyState);
+		return originalSetState(partial, replace);
+	};
+	const applyRemoteValue = (value) => {
+		isApplyingRemoteValue = true;
+		const currentState = store.getState();
+		if (typeof value === "object" && value !== null && !Array.isArray(value)) store.setState({
+			...currentState,
+			...value
+		});
+		else {
+			const keys = Object.keys(currentState).filter((k) => typeof currentState[k] !== "function");
+			if (keys.length === 1) store.setState({
+				...currentState,
+				[keys[0]]: value
+			});
+			else store.setState(value);
+		}
+	};
+	const unsubscribe = bridge.subscribe(channelOptions, applyRemoteValue);
+	bridge.get(channelOptions).then(applyRemoteValue);
+	const storeWithCleanup = store;
+	if (storeWithCleanup.destroy) {
+		const originalDestroy = storeWithCleanup.destroy;
+		storeWithCleanup.destroy = () => {
+			unsubscribe();
+			originalDestroy();
+		};
+	} else storeWithCleanup.destroy = () => {
+		unsubscribe();
+	};
+	return store;
+};
+
+//#endregion
+exports.createSyncedStore = createSyncedStore;
+exports.syncStateMiddleware = syncStateMiddleware;
+exports.useSyncState = useSyncState;
+exports.useZustandSyncState = useSyncState;